diff --git a/src/components/ControlPanel.css b/src/components/ControlPanel.css
index 3a6f5ce..f420ccb 100644
--- a/src/components/ControlPanel.css
+++ b/src/components/ControlPanel.css
@@ -148,3 +148,34 @@
   min-width: 100px;
   text-align: right;
 }
+
+.resolution-input,
+.allowance-input {
+  margin-bottom: 12px;
+}
+
+.resolution-input label,
+.allowance-input label {
+  color: #fff;
+  font-size: 13px;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.resolution-input input,
+.allowance-input input {
+  width: 60px;
+  padding: 4px 8px;
+  border: 1px solid #444;
+  border-radius: 4px;
+  background: #1a1a2e;
+  color: #fff;
+  font-size: 13px;
+}
+
+.resolution-input input:focus,
+.allowance-input input:focus {
+  outline: none;
+  border-color: #e94560;
+}
diff --git a/src/components/ControlPanel.jsx b/src/components/ControlPanel.jsx
index 782f93c..21c8719 100644
--- a/src/components/ControlPanel.jsx
+++ b/src/components/ControlPanel.jsx
@@ -12,6 +12,7 @@ function ControlPanel({ model, upperEnvelope, onModelImport, onGenerateUpper, on
   const fileInputRef = useRef(null)
   const workerRef = useRef(null)
   const selectedToolRef = useRef('ball')
+  const upperEnvelopeRef = useRef(null)
   const [isGenerating, setIsGenerating] = useState(false)
   const [isRepairing, setIsRepairing] = useState(false)
   const [repairProgress, setRepairProgress] = useState(0)
@@ -19,6 +20,8 @@ function ControlPanel({ model, upperEnvelope, onModelImport, onGenerateUpper, on
   const [selectedTool, setSelectedTool] = useState('ball')
   const [computeMode, setComputeMode] = useState('worker')
   const [webgpuAvailable, setWebgpuAvailable] = useState(false)
+  const [resolutionPercent, setResolutionPercent] = useState(12)
+  const [allowance, setAllowance] = useState(0.5)
 
   useEffect(() => {
     if (navigator.gpu) {
@@ -34,6 +37,10 @@ function ControlPanel({ model, upperEnvelope, onModelImport, onGenerateUpper, on
     selectedToolRef.current = selectedTool
   }, [selectedTool])
 
+  useEffect(() => {
+    upperEnvelopeRef.current = upperEnvelope
+  }, [upperEnvelope])
+
   useEffect(() => {
     workerRef.current = new Worker(
       new URL('../workers/repairWorker.js', import.meta.url),
@@ -51,8 +58,8 @@ function ControlPanel({ model, upperEnvelope, onModelImport, onGenerateUpper, on
         const toolpathPoints = []
         const repairedPoints = []
         const halfSize = MATERIAL_SIZE / 2
-        const resolution = 0.1
-        const gridSize = Math.ceil(MATERIAL_SIZE / resolution)
+        const resolution = upperEnvelopeRef.current.resolution
+        const gridSize = upperEnvelopeRef.current.gridSize
         const gridOffset = halfSize
 
         for (let gy = 0; gy < gridSize; gy++) {
@@ -199,35 +206,60 @@ function ControlPanel({ model, upperEnvelope, onModelImport, onGenerateUpper, on
       await new Promise(resolve => setTimeout(resolve, 50))
 
       const geometry = model.geometry
-      const resolution = 0.1
-      const gridSize = Math.ceil(MATERIAL_SIZE / resolution)
       
-      const depthMap = new Float32Array(gridSize * gridSize).fill(-Infinity)
-
-      const vertices = geometry.attributes.position.array
-      const bbox = geometry.boundingBox
+      let resolution
+      const tool = selectedToolRef.current
+      const toolDiameter = (tool === 'flat14') ? 6.35 : 3.175
+      if (tool === 'ball' || tool === 'flat18' || tool === 'flat14') {
+        resolution = toolDiameter * (resolutionPercent / 100)
+      } else {
+        resolution = 0.1
+      }
+      
+      const gridSize = Math.ceil(MATERIAL_SIZE / resolution)
       
       const halfSize = MATERIAL_SIZE / 2
       const gridOffset = halfSize
+      const toGrid = (v) => Math.floor((v + gridOffset) / resolution)
 
-      for (let i = 0; i < vertices.length; i += 3) {
-        const x = vertices[i]
-        const y = vertices[i + 1]
-        const z = vertices[i + 2]
+      const vertices = geometry.attributes.position.array
+      const bbox = geometry.boundingBox
 
-        const gridX = Math.floor((x + gridOffset) / resolution)
-        const gridY = Math.floor((y + gridOffset) / resolution)
+      const depthMap = new Float32Array(gridSize * gridSize).fill(-Infinity)
 
-        if (gridX >= 0 && gridX < gridSize && gridY >= 0 && gridY < gridSize) {
-          const idx = gridY * gridSize + gridX
-          if (z > depthMap[idx]) {
-            depthMap[idx] = z
+      for (let i = 0; i < vertices.length; i += 9) {
+        const x0 = vertices[i],     y0 = vertices[i + 1], z0 = vertices[i + 2]
+        const x1 = vertices[i + 3], y1 = vertices[i + 4], z1 = vertices[i + 5]
+        const x2 = vertices[i + 6], y2 = vertices[i + 7], z2 = vertices[i + 8]
+
+        const gMinX = Math.max(0, Math.min(toGrid(x0), toGrid(x1), toGrid(x2)))
+        const gMaxX = Math.min(gridSize - 1, Math.max(toGrid(x0), toGrid(x1), toGrid(x2)))
+        const gMinY = Math.max(0, Math.min(toGrid(y0), toGrid(y1), toGrid(y2)))
+        const gMaxY = Math.min(gridSize - 1, Math.max(toGrid(y0), toGrid(y1), toGrid(y2)))
+
+        const det = (y1 - y2) * (x0 - x2) + (x2 - x1) * (y0 - y2)
+        if (Math.abs(det) < 1e-10) continue
+
+        for (let gy = gMinY; gy <= gMaxY; gy++) {
+          for (let gx = gMinX; gx <= gMaxX; gx++) {
+            const px = gx * resolution - gridOffset + resolution / 2
+            const py = gy * resolution - gridOffset + resolution / 2
+
+            const lambda1 = ((y1 - y2) * (px - x2) + (x2 - x1) * (py - y2)) / det
+            const lambda2 = ((y2 - y0) * (px - x2) + (x0 - x2) * (py - y2)) / det
+            const lambda3 = 1 - lambda1 - lambda2
+
+            if (lambda1 >= 0 && lambda2 >= 0 && lambda3 >= 0) {
+              const z = lambda1 * z0 + lambda2 * z1 + lambda3 * z2
+              const idx = gy * gridSize + gx
+              if (z > depthMap[idx]) {
+                depthMap[idx] = z
+              }
+            }
           }
         }
       }
 
-      console.log('depthMap 采样完成, gridSize:', gridSize, '有效像素:', depthMap.filter(z => z !== -Infinity).length)
-
       const surfacePoints = []
       for (let gy = 0; gy < gridSize; gy++) {
         for (let gx = 0; gx < gridSize; gx++) {
@@ -270,6 +302,14 @@ function ControlPanel({ model, upperEnvelope, onModelImport, onGenerateUpper, on
       toolRadius = 3.175 / 2
       toolAngle = 0
       tipRadius = 0
+    } else if (selectedTool === 'flat18') {
+      toolRadius = 3.175 / 2
+      toolAngle = 0
+      tipRadius = 0
+    } else if (selectedTool === 'flat14') {
+      toolRadius = 6.35 / 2
+      toolAngle = 0
+      tipRadius = 0
     } else if (selectedTool === 'taper15') {
       toolRadius = 3.175 / 2
       toolAngle = 15
@@ -290,6 +330,7 @@ function ControlPanel({ model, upperEnvelope, onModelImport, onGenerateUpper, on
           toolRadius,
           toolAngle,
           tipRadius,
+          allowance,
           (msg) => {
             if (msg.type === 'progress') {
               setRepairProgress(msg.progress)
@@ -336,7 +377,8 @@ function ControlPanel({ model, upperEnvelope, onModelImport, onGenerateUpper, on
         toolType: selectedTool,
         toolRadius,
         toolAngle,
-        tipRadius
+        tipRadius,
+        allowance
       })
     }
   }
@@ -367,6 +409,22 @@ function ControlPanel({ model, upperEnvelope, onModelImport, onGenerateUpper, on
 
       <div className="control-section">
         <h3>2. 生成上包络面</h3>
+        <div className="resolution-input">
+          <label>
+            采样精度（刀具直径百分比）:
+            <input
+              type="number"
+              min="1"
+              step="1"
+              value={resolutionPercent}
+              onChange={(e) => {
+                const val = parseInt(e.target.value)
+                if (val > 0) setResolutionPercent(val)
+              }}
+            />
+            %
+          </label>
+        </div>
         <button
           className="btn btn-success"
           onClick={generateUpperEnvelope}
@@ -405,6 +463,26 @@ function ControlPanel({ model, upperEnvelope, onModelImport, onGenerateUpper, on
             />
             1/8" 球刀
           </label>
+          <label>
+            <input
+              type="radio"
+              name="tool"
+              value="flat18"
+              checked={selectedTool === 'flat18'}
+              onChange={() => setSelectedTool('flat18')}
+            />
+            1/8" 平底铣刀
+          </label>
+          <label>
+            <input
+              type="radio"
+              name="tool"
+              value="flat14"
+              checked={selectedTool === 'flat14'}
+              onChange={() => setSelectedTool('flat14')}
+            />
+            1/4" 平底铣刀
+          </label>
           <label>
             <input
               type="radio"
@@ -426,6 +504,23 @@ function ControlPanel({ model, upperEnvelope, onModelImport, onGenerateUpper, on
             1/8" 30° 尖刀 (0.1mm)
           </label>
         </div>
+        {(selectedTool === 'flat18' || selectedTool === 'flat14') && (
+          <div className="allowance-input">
+            <label>
+              余量 (mm):
+              <input
+                type="number"
+                min="0"
+                step="0.1"
+                value={allowance}
+                onChange={(e) => {
+                  const val = parseFloat(e.target.value)
+                  if (val >= 0) setAllowance(val)
+                }}
+              />
+            </label>
+          </div>
+        )}
         <button
           className="btn btn-warning"
           onClick={repairAndGenerate}
diff --git a/src/components/EnvelopeViewer.jsx b/src/components/EnvelopeViewer.jsx
index 1320b1f..83102f4 100644
--- a/src/components/EnvelopeViewer.jsx
+++ b/src/components/EnvelopeViewer.jsx
@@ -214,7 +214,7 @@ function EnvelopeViewer({
     geometry.setAttribute('color', new THREE.Float32BufferAttribute(colors, 3))
 
     const material = new THREE.PointsMaterial({
-      size: resolution * 0.8,
+      size: Math.max(resolution * 0.8, 0.15),
       vertexColors: true,
       transparent: true,
       opacity: 0.8,
diff --git a/src/utils/webgpuConvolution.js b/src/utils/webgpuConvolution.js
index 1908ee9..f042525 100644
--- a/src/utils/webgpuConvolution.js
+++ b/src/utils/webgpuConvolution.js
@@ -135,7 +135,7 @@ fn repairedMain(@builtin(global_invocation_id) global_id: vec3<u32>) {
 }
 `
 
-export async function runWebGPUConvolution(depthMap, gridSize, resolution, toolType, toolRadius, toolAngle, tipRadius, onProgress) {
+export async function runWebGPUConvolution(depthMap, gridSize, resolution, toolType, toolRadius, toolAngle, tipRadius, allowance, onProgress) {
   if (!navigator.gpu) {
     throw new Error('WebGPU not supported')
   }
@@ -152,6 +152,10 @@ export async function runWebGPUConvolution(depthMap, gridSize, resolution, toolT
     gpuInputMap[i] = depthMap[i] === -Infinity ? EMPTY_VALUE : depthMap[i]
   }
 
+  const isFlatTool = toolType === 'flat18' || toolType === 'flat14'
+  const allowanceRadius = isFlatTool ? (toolRadius / 2 + allowance) : 0
+  const allowanceKernelRadius = isFlatTool ? Math.ceil(allowanceRadius / resolution) : 0
+
   const kernelRadius = Math.ceil(toolRadius / resolution)
 
   const computeToolProfile = (dist) => {
@@ -160,6 +164,8 @@ export async function runWebGPUConvolution(depthMap, gridSize, resolution, toolT
         return Math.sqrt(toolRadius * toolRadius - dist * dist)
       }
       return 0
+    } else if (toolType === 'flat18' || toolType === 'flat14') {
+      return 0
     } else {
       const halfAngle = toolAngle * Math.PI / 180 / 2
       const tanHalf = Math.tan(halfAngle)
@@ -186,6 +192,20 @@ export async function runWebGPUConvolution(depthMap, gridSize, resolution, toolT
 
   const centerProfileZ = kernel.find(k => k.kx === 0 && k.ky === 0)?.profileZ || 0
 
+  const allowanceKernel = isFlatTool ? [] : null
+  if (isFlatTool) {
+    for (let ky = -allowanceKernelRadius; ky <= allowanceKernelRadius; ky++) {
+      for (let kx = -allowanceKernelRadius; kx <= allowanceKernelRadius; kx++) {
+        const dx = kx * resolution
+        const dy = ky * resolution
+        const dist = Math.sqrt(dx * dx + dy * dy)
+        if (dist <= allowanceRadius) {
+          allowanceKernel.push({ kx, ky })
+        }
+      }
+    }
+  }
+
   const kernelData = new ArrayBuffer(kernel.length * 16)
   const kernelView = new DataView(kernelData)
   kernel.forEach((k, i) => {
@@ -278,12 +298,68 @@ export async function runWebGPUConvolution(depthMap, gridSize, resolution, toolT
   const convolutionMap = await runPass('convolutionMain', inputBuffer, outputBuffer)
   if (onProgress) onProgress({ type: 'progress', progress: 35, iteration: 1 })
 
-  device.queue.writeBuffer(inputBuffer, 0, convolutionMap)
-  const toolpathMap = await runPass('toolpathMain', inputBuffer, outputBuffer)
+  let toolpathMap
+  if (isFlatTool) {
+    toolpathMap = new Float32Array(convolutionMap.length)
+    for (let gy = 0; gy < gridSize; gy++) {
+      for (let gx = 0; gx < gridSize; gx++) {
+        const centerIdx = gy * gridSize + gx
+        const currentZ = convolutionMap[centerIdx]
+        if (currentZ < -49.9) {
+          toolpathMap[centerIdx] = EMPTY_VALUE
+          continue
+        }
+        let maxZ = currentZ
+        for (const { kx, ky } of allowanceKernel) {
+          const nx = gx + kx
+          const ny = gy + ky
+          if (nx < 0 || nx >= gridSize || ny < 0 || ny >= gridSize) continue
+          const neighborIdx = ny * gridSize + nx
+          const neighborZ = convolutionMap[neighborIdx]
+          if (neighborZ > maxZ) {
+            maxZ = neighborZ
+          }
+        }
+        toolpathMap[centerIdx] = maxZ
+      }
+    }
+  } else {
+    device.queue.writeBuffer(inputBuffer, 0, convolutionMap)
+    toolpathMap = await runPass('toolpathMain', inputBuffer, outputBuffer)
+  }
   if (onProgress) onProgress({ type: 'progress', progress: 50, iteration: 1 })
 
-  device.queue.writeBuffer(inputBuffer, 0, convolutionMap)
-  const repairedMap = await runPass('repairedMain', inputBuffer, outputBuffer)
+  let repairedMap
+  if (isFlatTool) {
+    repairedMap = new Float32Array(toolpathMap.length)
+    for (let gy = 0; gy < gridSize; gy++) {
+      for (let gx = 0; gx < gridSize; gx++) {
+        const centerIdx = gy * gridSize + gx
+        const toolpathZ = toolpathMap[centerIdx]
+        if (toolpathZ < -49.9) {
+          repairedMap[centerIdx] = EMPTY_VALUE
+          continue
+        }
+        let minZ = toolpathZ
+        for (const { kx, ky, profileZ } of kernel) {
+          const nx = gx + kx
+          const ny = gy + ky
+          if (nx < 0 || nx >= gridSize || ny < 0 || ny >= gridSize) continue
+          const neighborIdx = ny * gridSize + nx
+          const neighborToolpathZ = toolpathMap[neighborIdx]
+          if (neighborToolpathZ < -49.9) continue
+          const surfaceZ = neighborToolpathZ - profileZ
+          if (surfaceZ < minZ) {
+            minZ = surfaceZ
+          }
+        }
+        repairedMap[centerIdx] = minZ
+      }
+    }
+  } else {
+    device.queue.writeBuffer(inputBuffer, 0, convolutionMap)
+    repairedMap = await runPass('repairedMain', inputBuffer, outputBuffer)
+  }
   if (onProgress) onProgress({ type: 'progress', progress: 95, iteration: 1 })
 
   inputBuffer.destroy()
diff --git a/src/workers/repairWorker.js b/src/workers/repairWorker.js
index 02a1811..ef7fb27 100644
--- a/src/workers/repairWorker.js
+++ b/src/workers/repairWorker.js
@@ -1,15 +1,13 @@
+const MAX_CHUNK_SIZE = 2000
+
 self.onmessage = function(e) {
-  const { depthMap, gridSize, resolution, toolType, toolRadius, toolAngle, tipRadius } = e.data
+  const { depthMap, gridSize, resolution, toolType, toolRadius, toolAngle, tipRadius, allowance } = e.data
 
-  const inputMap = new Float32Array(depthMap)
-  const convolutionMap = new Float32Array(depthMap.length)
-  convolutionMap.fill(-Infinity)
-  const repairedMap = new Float32Array(depthMap.length)
-  repairedMap.fill(-Infinity)
+  const isFlatTool = toolType === 'flat18' || toolType === 'flat14'
+  const allowanceRadius = isFlatTool ? (toolRadius / 2 + allowance) : 0
+  const allowanceKernelRadius = isFlatTool ? Math.ceil(allowanceRadius / resolution) : 0
 
-  const kernelRadius = toolType === 'ball'
-    ? Math.ceil(toolRadius / resolution)
-    : Math.ceil(toolRadius / resolution)
+  const kernelRadius = Math.ceil(toolRadius / resolution)
 
   const computeToolProfile = (dist) => {
     if (toolType === 'ball') {
@@ -17,6 +15,8 @@ self.onmessage = function(e) {
         return Math.sqrt(toolRadius * toolRadius - dist * dist)
       }
       return 0
+    } else if (toolType === 'flat18' || toolType === 'flat14') {
+      return 0
     } else {
       const halfAngle = toolAngle * Math.PI / 180 / 2
       const tanHalf = Math.tan(halfAngle)
@@ -45,42 +45,252 @@ self.onmessage = function(e) {
   }
 
   const kernel = precomputeKernel()
+  const centerProfileZ = kernel.find(k => k.kx === 0 && k.ky === 0)?.profileZ || 0
 
-  let processedCount = 0
-  const totalPixels = gridSize * gridSize
-
-  for (let gy = 0; gy < gridSize; gy++) {
-    for (let gx = 0; gx < gridSize; gx++) {
-      const centerIdx = gy * gridSize + gx
-      const currentZ = inputMap[centerIdx]
-
-      if (currentZ === -Infinity) {
-        processedCount++
-        continue
-      }
-
-      let convolutionZ = currentZ
-
-      for (const { kx, ky, profileZ } of kernel) {
-        const nx = gx + kx
-        const ny = gy + ky
-
-        if (nx < 0 || nx >= gridSize || ny < 0 || ny >= gridSize) continue
-
-        const neighborIdx = ny * gridSize + nx
-        const neighborZ = inputMap[neighborIdx]
-        if (neighborZ === -Infinity) continue
-
-        const candidateZ = neighborZ + profileZ
-        if (candidateZ > convolutionZ) {
-          convolutionZ = candidateZ
+  const precomputeAllowanceKernel = () => {
+    if (!isFlatTool) return null
+    const allowanceKernel = []
+    for (let ky = -allowanceKernelRadius; ky <= allowanceKernelRadius; ky++) {
+      for (let kx = -allowanceKernelRadius; kx <= allowanceKernelRadius; kx++) {
+        const dx = kx * resolution
+        const dy = ky * resolution
+        const dist = Math.sqrt(dx * dx + dy * dy)
+        if (dist <= allowanceRadius) {
+          allowanceKernel.push({ kx, ky })
         }
       }
+    }
+    return allowanceKernel
+  }
 
-      convolutionMap[centerIdx] = convolutionZ
-      processedCount++
+  const allowanceKernel = precomputeAllowanceKernel()
 
-      if (gy % 10 === 0) {
+  const runAllowanceConvolution = (inputMap, gs) => {
+    if (!isFlatTool) return inputMap
+    const outputMap = new Float32Array(gs * gs)
+    outputMap.fill(-Infinity)
+
+    for (let gy = 0; gy < gs; gy++) {
+      for (let gx = 0; gx < gs; gx++) {
+        const centerIdx = gy * gs + gx
+        const currentZ = inputMap[centerIdx]
+        if (currentZ === -Infinity) continue
+
+        let maxZ = currentZ
+        for (const { kx, ky } of allowanceKernel) {
+          const nx = gx + kx
+          const ny = gy + ky
+          if (nx < 0 || nx >= gs || ny < 0 || ny >= gs) continue
+          const neighborIdx = ny * gs + nx
+          const neighborZ = inputMap[neighborIdx]
+          if (neighborZ > maxZ) {
+            maxZ = neighborZ
+          }
+        }
+        outputMap[centerIdx] = maxZ
+      }
+    }
+    return outputMap
+  }
+
+  const runFlatToolpathRepaired = (toolpathMap, gs) => {
+    if (!isFlatTool) return toolpathMap
+    const outputMap = new Float32Array(gs * gs)
+    outputMap.fill(-Infinity)
+
+    for (let gy = 0; gy < gs; gy++) {
+      for (let gx = 0; gx < gs; gx++) {
+        const centerIdx = gy * gs + gx
+        const toolpathZ = toolpathMap[centerIdx]
+        if (toolpathZ === -Infinity) continue
+
+        let minZ = toolpathZ
+        for (const { kx, ky, profileZ } of kernel) {
+          const nx = gx + kx
+          const ny = gy + ky
+          if (nx < 0 || nx >= gs || ny < 0 || ny >= gs) continue
+          const neighborIdx = ny * gs + nx
+          const neighborToolpathZ = toolpathMap[neighborIdx]
+          if (neighborToolpathZ === -Infinity) continue
+          const surfaceZ = neighborToolpathZ - profileZ
+          if (surfaceZ < minZ) {
+            minZ = surfaceZ
+          }
+        }
+        outputMap[centerIdx] = minZ
+      }
+    }
+    return outputMap
+  }
+
+  const runConvolution = (inputMap, gs) => {
+    const outputMap = new Float32Array(gs * gs)
+    outputMap.fill(-Infinity)
+
+    for (let gy = 0; gy < gs; gy++) {
+      for (let gx = 0; gx < gs; gx++) {
+        const centerIdx = gy * gs + gx
+        const currentZ = inputMap[centerIdx]
+
+        if (currentZ === -Infinity) continue
+
+        let convolutionZ = currentZ
+
+        for (const { kx, ky, profileZ } of kernel) {
+          const nx = gx + kx
+          const ny = gy + ky
+
+          if (nx < 0 || nx >= gs || ny < 0 || ny >= gs) continue
+
+          const neighborIdx = ny * gs + nx
+          const neighborZ = inputMap[neighborIdx]
+          if (neighborZ === -Infinity) continue
+
+          const candidateZ = neighborZ + profileZ
+          if (candidateZ > convolutionZ) {
+            convolutionZ = candidateZ
+          }
+        }
+
+        outputMap[centerIdx] = convolutionZ
+      }
+    }
+
+    return outputMap
+  }
+
+  const runRepaired = (convolutionMap, gs) => {
+    const outputMap = new Float32Array(gs * gs)
+    outputMap.fill(-Infinity)
+
+    for (let gy = 0; gy < gs; gy++) {
+      for (let gx = 0; gx < gs; gx++) {
+        const centerIdx = gy * gs + gx
+        const convolutionZ = convolutionMap[centerIdx]
+
+        if (convolutionZ === -Infinity) continue
+
+        let repairedZ = convolutionZ
+
+        for (const { kx, ky, profileZ } of kernel) {
+          const nx = gx + kx
+          const ny = gy + ky
+
+          if (nx < 0 || nx >= gs || ny < 0 || ny >= gs) continue
+
+          const neighborIdx = ny * gs + nx
+          const neighborConvolutionZ = convolutionMap[neighborIdx]
+          if (neighborConvolutionZ === -Infinity) continue
+
+          const surfaceZ = neighborConvolutionZ - profileZ
+          if (surfaceZ < repairedZ) {
+            repairedZ = surfaceZ
+          }
+        }
+
+        outputMap[centerIdx] = repairedZ
+      }
+    }
+
+    return outputMap
+  }
+
+  const runToolpath = (convolutionMap, gs) => {
+    const outputMap = new Float32Array(gs * gs)
+    for (let i = 0; i < gs * gs; i++) {
+      if (convolutionMap[i] === -Infinity) {
+        outputMap[i] = -Infinity
+      } else {
+        outputMap[i] = convolutionMap[i] - centerProfileZ
+      }
+    }
+    return outputMap
+  }
+
+  const inputMap = new Float32Array(depthMap)
+  const totalPixels = gridSize * gridSize
+  let processedCount = 0
+
+  if (gridSize <= MAX_CHUNK_SIZE) {
+    const convolutionMap = runConvolution(inputMap, gridSize)
+    processedCount = totalPixels
+    self.postMessage({
+      type: 'progress',
+      progress: 33,
+      iteration: 1
+    })
+
+    const toolpathMap = isFlatTool
+      ? runAllowanceConvolution(convolutionMap, gridSize)
+      : runToolpath(convolutionMap, gridSize)
+    self.postMessage({
+      type: 'progress',
+      progress: 50,
+      iteration: 1
+    })
+
+    const repairedMap = isFlatTool
+      ? runFlatToolpathRepaired(toolpathMap, gridSize)
+      : runRepaired(convolutionMap, gridSize)
+    self.postMessage({
+      type: 'progress',
+      progress: 99.9,
+      iteration: 1
+    })
+
+    self.postMessage({
+      type: 'complete',
+      convolutionMap,
+      toolpathMap,
+      repairedMap,
+      iterations: 1
+    }, [convolutionMap.buffer, toolpathMap.buffer, repairedMap.buffer])
+  } else {
+    const numChunks = 2
+    const chunkSize = Math.ceil(gridSize / numChunks)
+    const overlap = kernelRadius
+
+    const convolutionMap = new Float32Array(totalPixels)
+    convolutionMap.fill(-Infinity)
+
+    for (let cy = 0; cy < numChunks; cy++) {
+      for (let cx = 0; cx < numChunks; cx++) {
+        const startY = cy * chunkSize
+        const startX = cx * chunkSize
+        const endY = Math.min(startY + chunkSize, gridSize)
+        const endX = Math.min(startX + chunkSize, gridSize)
+
+        const chunkH = endY - startY
+        const chunkW = endX - startX
+        const chunkSizeWithOverlap = (chunkH + overlap * 2) * (chunkW + overlap * 2)
+        const chunkInput = new Float32Array(chunkSizeWithOverlap)
+        chunkInput.fill(-Infinity)
+
+        for (let oy = -overlap; oy < chunkH + overlap; oy++) {
+          for (let ox = -overlap; ox < chunkW + overlap; ox++) {
+            const gy = startY + oy
+            const gx = startX + ox
+            if (gy < 0 || gy >= gridSize || gx < 0 || gx >= gridSize) continue
+
+            const chunkIdx = (oy + overlap) * (chunkW + overlap * 2) + (ox + overlap)
+            const globalIdx = gy * gridSize + gx
+            chunkInput[chunkIdx] = inputMap[globalIdx]
+          }
+        }
+
+        const chunkConvolution = runConvolution(chunkInput, chunkW + overlap * 2)
+
+        for (let oy = 0; oy < chunkH; oy++) {
+          for (let ox = 0; ox < chunkW; ox++) {
+            const chunkIdx = (oy + overlap) * (chunkW + overlap * 2) + (ox + overlap)
+            const globalIdx = (startY + oy) * gridSize + (startX + ox)
+            if (chunkConvolution[chunkIdx] > convolutionMap[globalIdx]) {
+              convolutionMap[globalIdx] = chunkConvolution[chunkIdx]
+            }
+          }
+        }
+
+        processedCount += chunkH * chunkW
         const progress = (processedCount / totalPixels) * 33
         self.postMessage({
           type: 'progress',
@@ -89,67 +299,33 @@ self.onmessage = function(e) {
         })
       }
     }
+
+    self.postMessage({
+      type: 'progress',
+      progress: 33,
+      iteration: 1
+    })
+
+    const toolpathMap = isFlatTool
+      ? runAllowanceConvolution(convolutionMap, gridSize)
+      : new Float32Array(totalPixels).map((_, i) => convolutionMap[i] === -Infinity ? -Infinity : convolutionMap[i] - centerProfileZ)
+
+    self.postMessage({
+      type: 'progress',
+      progress: 50,
+      iteration: 1
+    })
+
+    const repairedMap = isFlatTool
+      ? runFlatToolpathRepaired(toolpathMap, gridSize)
+      : runRepaired(convolutionMap, gridSize)
+
+    self.postMessage({
+      type: 'complete',
+      convolutionMap,
+      toolpathMap,
+      repairedMap,
+      iterations: 1
+    }, [convolutionMap.buffer, toolpathMap.buffer, repairedMap.buffer])
   }
-
-  const centerProfileZ = kernel.find(k => k.kx === 0 && k.ky === 0)?.profileZ || 0
-  const toolpathMap = new Float32Array(depthMap.length)
-  for (let i = 0; i < depthMap.length; i++) {
-    if (convolutionMap[i] === -Infinity) {
-      toolpathMap[i] = -Infinity
-    } else {
-      toolpathMap[i] = convolutionMap[i] - centerProfileZ
-    }
-  }
-
-  processedCount = 0
-
-  for (let gy = 0; gy < gridSize; gy++) {
-    for (let gx = 0; gx < gridSize; gx++) {
-      const centerIdx = gy * gridSize + gx
-      const convolutionZ = convolutionMap[centerIdx]
-
-      if (convolutionZ === -Infinity) {
-        processedCount++
-        continue
-      }
-
-      let repairedZ = convolutionZ
-
-      for (const { kx, ky, profileZ } of kernel) {
-        const nx = gx + kx
-        const ny = gy + ky
-
-        if (nx < 0 || nx >= gridSize || ny < 0 || ny >= gridSize) continue
-
-        const neighborIdx = ny * gridSize + nx
-        const neighborConvolutionZ = convolutionMap[neighborIdx]
-        if (neighborConvolutionZ === -Infinity) continue
-
-        const surfaceZ = neighborConvolutionZ - profileZ
-        if (surfaceZ < repairedZ) {
-          repairedZ = surfaceZ
-        }
-      }
-
-      repairedMap[centerIdx] = repairedZ
-      processedCount++
-
-      if (gy % 10 === 0) {
-        const progress = 50 + (processedCount / totalPixels) * 50
-        self.postMessage({
-          type: 'progress',
-          progress: Math.min(progress, 99.9),
-          iteration: 1
-        })
-      }
-    }
-  }
-
-  self.postMessage({
-    type: 'complete',
-    convolutionMap,
-    toolpathMap,
-    repairedMap,
-    iterations: 1
-  })
 }