pcb-scene3d-viewer 1.3.3 → 1.3.4

package/src/PcbScene3dGeometryWorkerClient.mjs

@@ -0,0 +1,182 @@
+import { PcbScene3dGeneratedGeometryBuilder } from './PcbScene3dGeneratedGeometryBuilder.mjs'
+import { PcbScene3dGeometryTransfer } from './PcbScene3dGeometryTransfer.mjs'
+import { PcbScene3dRuntimeHelpers } from './PcbScene3dRuntimeHelpers.mjs'
+
+/** Owns cancellable worker geometry stages with an exact compatibility fallback. */
+export class PcbScene3dGeometryWorkerClient {
+    #worker = null
+    #options
+    #requests = new Map()
+    #sequence = 0
+    #unavailable = false
+    #disposed = false
+
+    /**
+     * @param {{ workerFactory?: (() => Worker) | null, threeModuleUrl?: string, requestTimeoutMs?: number }} [options] Worker deployment options; a null factory disables workers.
+     */
+    constructor(options = {}) {
+        this.#options = options
+    }
+
+    /**
+     * Builds a stage away from the UI thread and restores received buffers.
+     * @param {any} THREE Runtime Three.js namespace.
+     * @param {'board' | 'copper'} kind Generated stage.
+     * @param {object} sceneDescription Normalized scene description.
+     * @returns {Promise<any>}
+     */
+    async build(THREE, kind, sceneDescription) {
+        this.#assertActive()
+        const worker = this.#ensureWorker()
+        if (worker) {
+            try {
+                const data = await this.#request(worker, kind, sceneDescription)
+                this.#assertActive()
+                return PcbScene3dGeometryTransfer.deserialize(THREE, data)
+            } catch (error) {
+                this.#assertActive()
+                this.#fail(error)
+            }
+        }
+        // A worker may be forbidden by the host CSP; retain exact geometry there.
+        await PcbScene3dRuntimeHelpers.yieldToNextFrame(globalThis)
+        this.#assertActive()
+        return PcbScene3dGeneratedGeometryBuilder.build(
+            THREE,
+            kind,
+            sceneDescription
+        )
+    }
+
+    /** Terminates active work instead of leaving detached scene builds running. @returns {void} */
+    dispose() {
+        this.#disposed = true
+        this.#fail(this.#abortError())
+        this.#options = {}
+    }
+
+    /** Creates one reusable worker, isolating startup failures. @returns {Worker | null} */
+    #ensureWorker() {
+        if (this.#unavailable || this.#worker) return this.#worker
+        try {
+            if (this.#options.workerFactory === null) {
+                this.#unavailable = true
+                return null
+            }
+            if (this.#options.workerFactory)
+                this.#worker = this.#options.workerFactory()
+            else if (typeof globalThis.Worker === 'function') {
+                const url = new URL(
+                    './PcbScene3dGeometryWorker.mjs',
+                    import.meta.url
+                )
+                url.search = new URL(import.meta.url).search
+                this.#worker = new globalThis.Worker(url, {
+                    type: 'module',
+                    name: 'pcb-generated-geometry'
+                })
+            }
+            if (!this.#worker) {
+                this.#unavailable = true
+                return null
+            }
+            this.#worker.addEventListener('message', (event) =>
+                this.#receive(event.data)
+            )
+            this.#worker.addEventListener('error', (event) =>
+                this.#fail(
+                    new Error(event?.message || 'Geometry worker failed.')
+                )
+            )
+            this.#worker.addEventListener('messageerror', () =>
+                this.#fail(
+                    new Error('Geometry worker response could not be read.')
+                )
+            )
+        } catch (error) {
+            this.#fail(error)
+        }
+        return this.#worker
+    }
+
+    /**
+     * Sends a cloneable scene subset without transferring caller-owned arrays.
+     * @param {Worker} worker Active worker.
+     * @param {string} kind Geometry stage.
+     * @param {object} sceneDescription Normalized scene.
+     * @returns {Promise<object>}
+     */
+    #request(worker, kind, sceneDescription) {
+        return new Promise((resolve, reject) => {
+            const requestId = 'geometry-' + ++this.#sequence
+            const timeout = setTimeout(
+                () => this.#fail(new Error('Geometry worker timed out.')),
+                this.#options.requestTimeoutMs ?? 120000
+            )
+            this.#requests.set(requestId, { resolve, reject, timeout })
+            try {
+                const version = new URL(import.meta.url).search
+                worker.postMessage({
+                    type: 'scene3d:geometry-build',
+                    requestId,
+                    kind,
+                    threeModuleUrl:
+                        this.#options.threeModuleUrl ||
+                        '/node_modules/three/build/three.module.js' + version,
+                    sceneDescription:
+                        PcbScene3dGeneratedGeometryBuilder.workerInput(
+                            sceneDescription
+                        )
+                })
+            } catch (error) {
+                this.#fail(error)
+            }
+        })
+    }
+
+    /**
+     * Settles a pending request and ignores late replies after cancellation.
+     * @param {object} payload Worker reply.
+     * @returns {void}
+     */
+    #receive(payload) {
+        const pending = this.#requests.get(payload?.requestId)
+        if (!pending) return
+        this.#requests.delete(payload.requestId)
+        clearTimeout(pending.timeout)
+        if (payload.type === 'scene3d:geometry-success')
+            pending.resolve(payload.geometry)
+        else
+            pending.reject(
+                new Error(payload.message || 'Geometry worker failed.')
+            )
+    }
+
+    /**
+     * Rejects every outstanding stage and permanently stops the failed worker.
+     * @param {Error} error Failure or cancellation.
+     * @returns {void}
+     */
+    #fail(error) {
+        this.#unavailable = true
+        for (const { reject, timeout } of this.#requests.values()) {
+            clearTimeout(timeout)
+            reject(error)
+        }
+        this.#requests.clear()
+        this.#worker?.terminate()
+        this.#worker = null
+    }
+
+    /** Rejects calls on a disposed client. @returns {void} */
+    #assertActive() {
+        if (this.#disposed) throw this.#abortError()
+    }
+
+    /** Creates a portable abort error, including non-DOM hosts. @returns {Error} */
+    #abortError() {
+        const error = new Error('Generated geometry build was cancelled.')
+        error.name = 'AbortError'
+        return error
+    }
+}

package/src/PcbScene3dMaskCoveredCopperSurfaceFilter.mjs

@@ -52,7 +52,9 @@ export class PcbScene3dMaskCoveredCopperSurfaceFilter {
                     options
                 )
             ) {
-                filtered.push(...source.slice(index, index + 9))
+                for (let offset = 0; offset < 9; offset += 1) {
+                    filtered.push(source[index + offset])
+                }
             }
         }
 
@@ -83,32 +85,20 @@ export class PcbScene3dMaskCoveredCopperSurfaceFilter {
      * @returns {boolean}
      */
     static #keepsTriangle(source, index, zBounds, options) {
-        const zValues = [2, 5, 8].map((offset) => source[index + offset])
-        const hasTop = zValues.some((z) =>
-            PcbScene3dMaskCoveredCopperSurfaceFilter.#matchesZ(z, zBounds.maxZ)
-        )
-        const hasBottom = zValues.some((z) =>
-            PcbScene3dMaskCoveredCopperSurfaceFilter.#matchesZ(z, zBounds.minZ)
-        )
-
-        if (hasTop && !hasBottom) {
-            return true
-        }
-
-        return options?.keepSideWalls === true && hasTop && hasBottom
-    }
-
-    /**
-     * Checks whether a Z value matches one target plane.
-     * @param {number} value Candidate Z.
-     * @param {number} target Target Z.
-     * @returns {boolean}
-     */
-    static #matchesZ(value, target) {
-        return (
-            Math.abs(Number(value) - Number(target)) <=
-            PcbScene3dMaskCoveredCopperSurfaceFilter.#Z_EPSILON
-        )
+        const a = Number(source[index + 2])
+        const b = Number(source[index + 5])
+        const c = Number(source[index + 8])
+        const epsilon = PcbScene3dMaskCoveredCopperSurfaceFilter.#Z_EPSILON
+        const hasTop =
+            Math.abs(a - zBounds.maxZ) <= epsilon ||
+            Math.abs(b - zBounds.maxZ) <= epsilon ||
+            Math.abs(c - zBounds.maxZ) <= epsilon
+        if (!hasTop || options?.keepSideWalls === true) return hasTop
+        const hasBottom =
+            Math.abs(a - zBounds.minZ) <= epsilon ||
+            Math.abs(b - zBounds.minZ) <= epsilon ||
+            Math.abs(c - zBounds.minZ) <= epsilon
+        return !hasBottom
     }
 
     /**

package/src/PcbScene3dRuntime.mjs

@@ -1,15 +1,14 @@
-import { PcbScene3dBoardSolderMaskFactory } from './PcbScene3dBoardSolderMaskFactory.mjs'
 import { PcbScene3dCameraRig } from './PcbScene3dCameraRig.mjs'
 import { PcbScene3dCircuitJsonAdapter } from './PcbScene3dCircuitJsonAdapter.mjs'
 import { PcbScene3dComponentVisibility } from './PcbScene3dComponentVisibility.mjs'
 import { PcbScene3dComponentAdjustment } from './PcbScene3dComponentAdjustment.mjs'
 import { PcbScene3dComponentAdjustmentRegistry } from './PcbScene3dComponentAdjustmentRegistry.mjs'
 import { PcbScene3dCompanionBasePlacementAdjuster } from './PcbScene3dCompanionBasePlacementAdjuster.mjs'
-import { PcbScene3dCopperDetailGroupBuilder } from './PcbScene3dCopperDetailGroupBuilder.mjs'
 import { PcbScene3dCopperFactory } from './PcbScene3dCopperFactory.mjs'
 import { PcbScene3dDetailCoordinateNormalizer } from './PcbScene3dDetailCoordinateNormalizer.mjs'
 import { PcbScene3dDeferredModelFinalizer } from './PcbScene3dDeferredModelFinalizer.mjs'
-import { PcbScene3dDrillVoidFactory } from './PcbScene3dDrillVoidFactory.mjs'
+import { PcbScene3dGeometryTransfer } from './PcbScene3dGeometryTransfer.mjs'
+import { PcbScene3dGeometryWorkerClient } from './PcbScene3dGeometryWorkerClient.mjs'
 import { PcbScene3dExternalCompanionFallback } from './PcbScene3dExternalCompanionFallback.mjs'
 import { PcbScene3dExternalModels } from './PcbScene3dExternalModels.mjs'
 import { PcbScene3dExternalPlacementDefaults } from './PcbScene3dExternalPlacementDefaults.mjs'
@@ -75,10 +74,11 @@ export class PcbScene3dRuntime {
     #hasSettledReady
     #renderScheduler
     #visibilityGraph
+    #geometryWorker
     /**
      * @param {HTMLElement} viewportNode
      * @param {any} sceneDescription Scene description or CircuitJSON model.
-     * @param {{ setDiagnostics?: (messages: string[]) => void, setSelection?: (selection: any | null) => void, loadRuntimeModules?: () => Promise<{ THREE: any, OrbitControls: any }>, translate?: ((key: string) => string) | null, modelLoaderOptions?: object }} [hooks]
+     * @param {{ setDiagnostics?: (messages: string[]) => void, setSelection?: (selection: any | null) => void, loadRuntimeModules?: () => Promise<{ THREE: any, OrbitControls: any }>, translate?: ((key: string) => string) | null, modelLoaderOptions?: object, geometryWorkerOptions?: object }} [hooks]
      */
     constructor(viewportNode, sceneDescription, hooks = {}) {
         const renderModel =
@@ -129,6 +129,9 @@ export class PcbScene3dRuntime {
             }
         })
         this.#visibilityGraph = new PcbScene3dVisibilityGraph()
+        this.#geometryWorker = new PcbScene3dGeometryWorkerClient(
+            hooks.geometryWorkerOptions
+        )
         this.#resolveReadyPromise = null
         this.#readyPromise = new Promise((resolve) => {
             this.#resolveReadyPromise = resolve
@@ -218,6 +221,10 @@ export class PcbScene3dRuntime {
     /** @returns {void} */
     dispose() {
         this.#isDisposed = true
+        this.#geometryWorker.dispose()
+        ;['board', 'copper'].forEach((kind) =>
+            PcbScene3dGeometryTransfer.dispose(this.#groups.get(kind))
+        )
         this.#renderScheduler.cancel()
         this.#listeners.forEach(({ node, type, listener }) => {
             node.removeEventListener?.(type, listener)
@@ -283,9 +290,13 @@ export class PcbScene3dRuntime {
             this.#bindSelectionInteraction()
             this.#applyToggleVisibility()
             this.#render()
+            await this.#loadGeneratedGeometry('board')
+            if (this.#isDisposed) return
+            this.#render()
             await this.#loadDeferredDetail()
             this.#settleReady()
         } catch (error) {
+            if (this.#isDisposed) return
             this.#hooks.setDiagnostics?.([
                 '3D preview could not start: ' +
                     String(error?.message || error || 'Unknown error.')
@@ -342,44 +353,6 @@ export class PcbScene3dRuntime {
             .multiplyScalar(this.#initialRadius * 0.8)
         this.#scene.add(ambientLight, keyLight, fillLight)
         const boardGroup = new THREE.Group()
-        boardGroup.add(
-            PcbScene3dRuntimeBoardMeshes.buildBoardMesh(
-                THREE,
-                this.#sceneDescription,
-                (x, y) => this.#normalizeDetailPoint(x, y)
-            )
-        )
-        boardGroup.add(
-            PcbScene3dBoardSolderMaskFactory.buildGroup(
-                THREE,
-                this.#sceneDescription,
-                (x, y) => this.#normalizeDetailPoint(x, y)
-            )
-        )
-        boardGroup.add(
-            PcbScene3dDrillVoidFactory.buildGroup(
-                THREE,
-                this.#sceneDescription.detail,
-                board.thicknessMil / 2,
-                -board.thicknessMil / 2,
-                (x, y) => this.#normalizeDetailPoint(x, y),
-                {
-                    enabled: true,
-                    board,
-                    hasBoardAssemblyModel: Boolean(
-                        this.#sceneDescription.boardAssemblyModel
-                    ),
-                    sourceFormat: this.#sceneDescription.sourceFormat
-                }
-            )
-        )
-        boardGroup.add(
-            PcbScene3dRuntimeBoardMeshes.buildBoardOutline(
-                THREE,
-                this.#sceneDescription,
-                (x, y) => this.#normalizeDetailPoint(x, y)
-            )
-        )
         this.#groups.set('board', boardGroup)
         PcbScene3dRuntimeBoardMeshes.applyBoardFaceSide(
             this.#three,
@@ -536,7 +509,8 @@ export class PcbScene3dRuntime {
             if (this.#isDisposed) {
                 return
             }
-            this.#loadDeferredCopper()
+            await this.#loadGeneratedGeometry('copper')
+            if (this.#isDisposed) return
             this.#applyToggleVisibility()
             this.#render()
             this.#settleReady()
@@ -596,24 +570,29 @@ export class PcbScene3dRuntime {
     }
 
     /**
-     * Builds and attaches copper and via detail once after the first frame.
-     * @returns {void}
+     * Attaches exact worker-built geometry only while its runtime is alive.
+     * @param {'board' | 'copper'} kind Generated detail stage.
+     * @returns {Promise<void>}
      */
-    #loadDeferredCopper() {
-        const copperGroup = this.#groups.get('copper')
-        if (!copperGroup || copperGroup.children.length) {
+    async #loadGeneratedGeometry(kind) {
+        const group = this.#groups.get(kind)
+        if (!group || group.children.length || this.#isDisposed) {
             return
         }
-        const topZ = this.#sceneDescription.board.thicknessMil / 2 + 0.05
-        const detailGroup = PcbScene3dCopperDetailGroupBuilder.build(
+        const detailGroup = await this.#geometryWorker.build(
             this.#three,
-            this.#sceneDescription,
-            topZ,
-            (x, y) => this.#normalizeDetailPoint(x, y)
+            kind,
+            this.#sceneDescription
         )
+        if (this.#isDisposed) {
+            PcbScene3dGeometryTransfer.dispose(detailGroup)
+            return
+        }
         if (detailGroup.children.length) {
-            copperGroup.add(detailGroup)
+            if (kind === 'board') group.add(...[...detailGroup.children])
+            else group.add(detailGroup)
             this.#applyViewScale(this.#presetState.get())
+            this.#applyToggleVisibility()
         }
     }
     /**

package/src/PcbScene3dSilkscreenChunkedFactory.mjs

@@ -41,6 +41,7 @@ export class PcbScene3dSilkscreenChunkedFactory {
         }
 
         const group = new THREE.Group()
+        const cutoutContexts = {}
         for (const side of ['top', 'bottom']) {
             for (const recordKey of PcbScene3dSilkscreenChunkedFactory
                 .#RECORD_KEYS) {
@@ -53,7 +54,8 @@ export class PcbScene3dSilkscreenChunkedFactory {
                     topZ,
                     bottomZ,
                     normalizeBoardPoint,
-                    options
+                    options,
+                    cutoutContexts
                 )
             }
         }
@@ -72,6 +74,7 @@ export class PcbScene3dSilkscreenChunkedFactory {
      * @param {number} bottomZ
      * @param {(x: number, y: number) => { x: number, y: number }} normalizeBoardPoint
      * @param {{ yieldToMain?: () => Promise<void> | void, shouldContinue?: () => boolean }} options
+     * @param {object} cutoutContexts Build-scoped side preparations.
      * @returns {Promise<void>}
      */
     static async #appendRecordChunks(
@@ -83,7 +86,8 @@ export class PcbScene3dSilkscreenChunkedFactory {
         topZ,
         bottomZ,
         normalizeBoardPoint,
-        options
+        options,
+        cutoutContexts
     ) {
         const sideSilkscreen = silkscreen?.[side] || {}
         const records = Array.isArray(sideSilkscreen[recordKey])
@@ -98,6 +102,13 @@ export class PcbScene3dSilkscreenChunkedFactory {
             PcbScene3dSilkscreenChunkedFactory.#shouldContinue(options);
             index += batchSize
         ) {
+            // Prepare lazily so cancelled or empty sides incur no cutout work.
+            cutoutContexts[side] ||=
+                PcbScene3dSilkscreenFactory.prepareCutoutContext(
+                    sideSilkscreen,
+                    normalizeBoardPoint,
+                    side === 'bottom'
+                )
             const chunkGroup = PcbScene3dSilkscreenFactory.buildGroup(
                 THREE,
                 PcbScene3dSilkscreenChunkedFactory.#buildChunkSilkscreen(
@@ -108,7 +119,8 @@ export class PcbScene3dSilkscreenChunkedFactory {
                 ),
                 topZ,
                 bottomZ,
-                normalizeBoardPoint
+                normalizeBoardPoint,
+                cutoutContexts
             )
             if (chunkGroup.children.length) {
                 group.add(chunkGroup)

package/src/PcbScene3dSilkscreenCutoutContext.mjs

@@ -66,6 +66,41 @@ export class PcbScene3dSilkscreenCutoutContext {
         this.#prepareNormalizedCutout(cutout)
     )
 
+    /** @type {{ x: number, y: number }[][]} */
+    #surfaceCutouts
+
+    /** @type {WeakMap<any[], object>} */
+    #preparedCutoutCache = new WeakMap()
+
+    /**
+     * Owns detached normalized cutouts for one side of a build. Callers must
+     * keep these coordinates unchanged for the lifetime of this context.
+     * @param {{ x: number, y: number }[][]} [surfaceCutouts] Normalized cutouts.
+     */
+    constructor(surfaceCutouts = []) {
+        this.#surfaceCutouts = surfaceCutouts
+    }
+
+    /**
+     * Returns the normalized surface cutouts shared by every side batch.
+     * @returns {{ x: number, y: number }[][]}
+     */
+    get surfaceCutouts() {
+        return this.#surfaceCutouts
+    }
+
+    /**
+     * Returns build-scoped caches for exact clipping consumers. Weak keys
+     * allow temporary fill-specific cutout lists to be released after use.
+     * @returns {{ preparedPolygonCache: Map, preparedCutoutCache: WeakMap }}
+     */
+    get geometryFilterOptions() {
+        return {
+            preparedPolygonCache: this.#preparedPolygonCache,
+            preparedCutoutCache: this.#preparedCutoutCache
+        }
+    }
+
     /**
      * Returns the lazy cache shared by exact geometry consumers.
      * @returns {Map<any, PcbScene3dPreparedPolygon>}

package/src/PcbScene3dSilkscreenFactory.mjs

@@ -31,23 +31,33 @@ export class PcbScene3dSilkscreenFactory {
      * @param {number} topZ
      * @param {number} bottomZ
      * @param {(x: number, y: number) => { x: number, y: number }} normalizeBoardPoint
+     * @param {{ top?: PcbScene3dSilkscreenCutoutContext, bottom?: PcbScene3dSilkscreenCutoutContext }} [cutoutContexts] Internal build-scoped side preparations.
      * @returns {any}
      */
-    static buildGroup(THREE, silkscreen, topZ, bottomZ, normalizeBoardPoint) {
+    static buildGroup(
+        THREE,
+        silkscreen,
+        topZ,
+        bottomZ,
+        normalizeBoardPoint,
+        cutoutContexts = {}
+    ) {
         const group = new THREE.Group()
         const topGroup = PcbScene3dSilkscreenFactory.#buildSideGroup(
             THREE,
             silkscreen?.top,
             Math.abs(Number(topZ || 0)),
             normalizeBoardPoint,
-            false
+            false,
+            cutoutContexts.top
         )
         const bottomGroup = PcbScene3dSilkscreenFactory.#buildSideGroup(
             THREE,
             silkscreen?.bottom,
             Math.abs(Number(bottomZ || 0)),
             normalizeBoardPoint,
-            true
+            true,
+            cutoutContexts.bottom
         )
 
         if (topGroup.children.length) {
@@ -60,6 +70,30 @@ export class PcbScene3dSilkscreenFactory {
         return group
     }
 
+    /**
+     * Normalizes detached cutouts once for all batches on one board side.
+     * The returned context must not be reused across separate scene builds.
+     * @param {{ drillCutouts?: object[][], copperCutouts?: object[][] } | undefined} silkscreen Side artwork.
+     * @param {(x: number, y: number) => { x: number, y: number }} normalizeBoardPoint Board normalizer.
+     * @param {boolean} mirrorY Whether the side is mirrored.
+     * @returns {PcbScene3dSilkscreenCutoutContext}
+     */
+    static prepareCutoutContext(silkscreen, normalizeBoardPoint, mirrorY) {
+        const drillCutouts = PcbScene3dSilkscreenFactory.#normalizeCutouts(
+            silkscreen?.drillCutouts,
+            normalizeBoardPoint,
+            mirrorY
+        )
+        const copperCutouts = PcbScene3dSilkscreenFactory.#normalizeCutouts(
+            silkscreen?.copperCutouts,
+            normalizeBoardPoint,
+            mirrorY
+        )
+        return new PcbScene3dSilkscreenCutoutContext(
+            drillCutouts.concat(copperCutouts)
+        )
+    }
+
     /**
      * Builds one side-specific silkscreen group.
      * @param {any} THREE
@@ -67,9 +101,17 @@ export class PcbScene3dSilkscreenFactory {
      * @param {number} z
      * @param {(x: number, y: number) => { x: number, y: number }} normalizeBoardPoint
      * @param {boolean} mirrorY
+     * @param {PcbScene3dSilkscreenCutoutContext} [preparedCutoutContext] Shared side preparation.
      * @returns {any}
      */
-    static #buildSideGroup(THREE, silkscreen, z, normalizeBoardPoint, mirrorY) {
+    static #buildSideGroup(
+        THREE,
+        silkscreen,
+        z,
+        normalizeBoardPoint,
+        mirrorY,
+        preparedCutoutContext
+    ) {
         const group = new THREE.Group()
         const strokeColor = PcbScene3dSilkscreenFactory.#resolveMaterialColor(
             silkscreen?.strokeColor
@@ -89,18 +131,14 @@ export class PcbScene3dSilkscreenFactory {
               ? fillColor
               : textMaterialColor
         const strokeZ = z + PcbScene3dSilkscreenFactory.#STROKE_Z_OFFSET
-        const drillCutouts = PcbScene3dSilkscreenFactory.#normalizeCutouts(
-            silkscreen?.drillCutouts,
-            normalizeBoardPoint,
-            mirrorY
-        )
-        const copperCutouts = PcbScene3dSilkscreenFactory.#normalizeCutouts(
-            silkscreen?.copperCutouts,
-            normalizeBoardPoint,
-            mirrorY
-        )
-        const surfaceCutouts = drillCutouts.concat(copperCutouts)
-        const cutoutContext = new PcbScene3dSilkscreenCutoutContext()
+        const cutoutContext =
+            preparedCutoutContext ||
+            PcbScene3dSilkscreenFactory.prepareCutoutContext(
+                silkscreen,
+                normalizeBoardPoint,
+                mirrorY
+            )
+        const surfaceCutouts = cutoutContext.surfaceCutouts
         const strokeMaterial = PcbScene3dSilkscreenFactory.#buildMaterial(
             THREE,
             strokeColor
@@ -147,9 +185,7 @@ export class PcbScene3dSilkscreenFactory {
             mirrorY,
             fillMaterial,
             surfaceCutouts,
-            {
-                preparedPolygonCache: cutoutContext.preparedPolygonCache
-            }
+            cutoutContext.geometryFilterOptions
         )
         const texts = Array.isArray(silkscreen?.texts) ? silkscreen.texts : []
         const renderableTexts = texts.filter(
@@ -179,7 +215,7 @@ export class PcbScene3dSilkscreenFactory {
                     fog: false
                 },
                 mirrorY,
-                preparedPolygonCache: cutoutContext.preparedPolygonCache,
+                ...cutoutContext.geometryFilterOptions,
                 side: mirrorY ? 'bottom' : 'top'
             }
         )
@@ -534,7 +570,7 @@ export class PcbScene3dSilkscreenFactory {
                 maxDepth: 12,
                 maxEdgeLength:
                     PcbScene3dSilkscreenFactory.#CUTOUT_MAX_EDGE_LENGTH,
-                preparedPolygonCache: cutoutContext.preparedPolygonCache
+                ...cutoutContext.geometryFilterOptions
             }
         )
         const mesh = new THREE.Mesh(geometry, material)
@@ -823,7 +859,7 @@ export class PcbScene3dSilkscreenFactory {
                     maxDepth: 12,
                     maxEdgeLength:
                         PcbScene3dSilkscreenFactory.#CUTOUT_MAX_EDGE_LENGTH,
-                    preparedPolygonCache: cutoutContext?.preparedPolygonCache
+                    ...cutoutContext?.geometryFilterOptions
                 }
             ),
             material

package/src/PcbScene3dSilkscreenFillSeamBuilder.mjs

@@ -22,7 +22,7 @@ export class PcbScene3dSilkscreenFillSeamBuilder {
      * @param {boolean} mirrorY Whether the side is mirrored.
      * @param {any} material Shared fill material.
      * @param {{ x: number, y: number }[][]} [cutouts] Cutouts that should remain uncovered.
-     * @param {{ preparedPolygonCache?: Map }} [options] Request-scoped options.
+     * @param {{ preparedPolygonCache?: Map, preparedCutoutCache?: WeakMap }} [options] Request-scoped options.
      * @returns {any[]}
      */
     static buildMeshes(
@@ -117,7 +117,7 @@ export class PcbScene3dSilkscreenFillSeamBuilder {
      * @param {number[]} positions Position buffer.
      * @param {any} material Shared material.
      * @param {{ x: number, y: number }[][]} cutouts Cutout polygons.
-     * @param {{ preparedPolygonCache?: Map }} options Request-scoped options.
+     * @param {{ preparedPolygonCache?: Map, preparedCutoutCache?: WeakMap }} options Request-scoped options.
      * @returns {void}
      */
     static #appendMesh(meshes, THREE, positions, material, cutouts, options) {
@@ -139,7 +139,8 @@ export class PcbScene3dSilkscreenFillSeamBuilder {
             PcbScene3dCutoutGeometryFilter.filter(THREE, geometry, cutouts, {
                 maxDepth: 12,
                 maxEdgeLength: 2,
-                preparedPolygonCache: options?.preparedPolygonCache
+                preparedPolygonCache: options?.preparedPolygonCache,
+                preparedCutoutCache: options?.preparedCutoutCache
             }),
             material
         )