@pascal-app/editor 1.0.0 → 1.0.1

package/src/lib/linear-display.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from 'bun:test'
+import { getLinearDisplay } from './linear-display'
+
+describe('linear property control units', () => {
+  test('keeps meter storage while displaying and accepting millimeters', () => {
+    const display = getLinearDisplay('m', 'metric', 'millimeters', 2, 0.05)
+    expect(display.displayUnit).toBe('mm')
+    expect(display.parseUnit).toBe('mm')
+    expect(display.toDisplay(2.5)).toBe(2500)
+    expect(display.toStored(1800)).toBe(1.8)
+    expect(display.toStored(-250)).toBe(-0.25)
+    expect(display.precision).toBe(0)
+    expect(display.step).toBe(50)
+    expect(display.toStored(display.step)).toBe(0.05)
+  })
+
+  test('retains sub-millimeter precision when the field supports it', () => {
+    const display = getLinearDisplay('m', 'metric', 'millimeters', 4, 0.0001)
+    expect(display.precision).toBe(1)
+    expect(display.step).toBe(0.1)
+    expect(display.toDisplay(0.0125)).toBe(12.5)
+    expect(display.roundStored(0.01254)).toBe(0.0125)
+  })
+
+  test('imperial preference takes precedence over the saved metric notation', () => {
+    const display = getLinearDisplay('m', 'imperial', 'millimeters', 2, 0.05)
+    expect(display.displayUnit).toBe('ft')
+    expect(display.parseUnit).toBe('ft')
+    expect(display.toDisplay(0.9144)).toBeCloseTo(3, 10)
+    expect(display.toStored(7)).toBeCloseTo(2.1336, 10)
+    expect(display.precision).toBe(2)
+    expect(display.step).toBe(0.05)
+  })
+
+  test('switching notation round-trips the same stored dimensions', () => {
+    for (const stored of [0, 0.01, 0.125, 0.9, 2.1, -0.25]) {
+      for (const [unit, notation] of [
+        ['metric', 'meters'],
+        ['metric', 'millimeters'],
+        ['imperial', 'meters'],
+      ] as const) {
+        const display = getLinearDisplay('m', unit, notation, 2, 0.01)
+        expect(display.toStored(display.toDisplay(stored))).toBeCloseTo(stored, 12)
+      }
+    }
+  })
+
+  test('leaves non-meter fields and their gesture steps unchanged', () => {
+    for (const unit of ['°', 'rad', '%', '', 'in', 'cm']) {
+      const display = getLinearDisplay(unit, 'metric', 'millimeters', 2, 0.05)
+      expect(display.displayUnit).toBe(unit)
+      expect(display.parseUnit).toBeUndefined()
+      expect(display.toDisplay(12.5)).toBe(12.5)
+      expect(display.toStored(12.5)).toBe(12.5)
+      expect(display.precision).toBe(2)
+      expect(display.step).toBe(0.05)
+    }
+  })
+})

package/src/lib/linear-display.ts

@@ -0,0 +1,39 @@
+import {
+  getLinearUnitLabel,
+  type LinearUnit,
+  linearUnitToMeters,
+  type MetricNotation,
+  metersToLinearUnit,
+} from './measurements'
+
+export function getLinearDisplay(
+  unit: string,
+  viewerUnit: LinearUnit,
+  metricNotation: MetricNotation,
+  precision: number,
+  step: number,
+) {
+  const isImperial = unit === 'm' && viewerUnit === 'imperial'
+  const isMillimeters = unit === 'm' && viewerUnit === 'metric' && metricNotation === 'millimeters'
+  const displayUnit = isImperial ? getLinearUnitLabel('imperial') : isMillimeters ? 'mm' : unit
+  const displayPrecision = isMillimeters ? Math.max(0, precision - 3) : precision
+  const displayStep = isMillimeters ? step * 1000 : step
+  const parseUnit = isImperial ? 'ft' : isMillimeters ? 'mm' : undefined
+  const toDisplay = (stored: number) =>
+    isImperial ? metersToLinearUnit(stored, 'imperial') : isMillimeters ? stored * 1000 : stored
+  const toStored = (display: number) =>
+    isImperial ? linearUnitToMeters(display, 'imperial') : isMillimeters ? display / 1000 : display
+  const roundStored = (stored: number) =>
+    toStored(Number.parseFloat(toDisplay(stored).toFixed(displayPrecision)))
+
+  return {
+    isImperial,
+    displayUnit,
+    parseUnit,
+    precision: displayPrecision,
+    step: displayStep,
+    toDisplay,
+    toStored,
+    roundStored,
+  }
+}

package/src/lib/local-guide-image.test.ts

@@ -0,0 +1,24 @@
+import { expect, mock, test } from 'bun:test'
+import * as core from '@pascal-app/core'
+
+const saveAsset = mock(async () => 'asset://stored-scan')
+
+mock.module('@pascal-app/core', () => ({ ...core, saveAsset }))
+
+const { createLocalScan } = await import('./local-guide-image')
+
+test('createLocalScan stores and attaches a scan asset to its level', async () => {
+  const createNode = mock()
+  const file = new File(['scan data'], 'living-room.glb', { type: 'model/gltf-binary' })
+
+  const { scan, url } = await createLocalScan({ createNode, file, levelId: 'level_ground' })
+
+  expect(saveAsset).toHaveBeenCalledWith(file)
+  expect(scan).toMatchObject({
+    name: 'living-room',
+    type: 'scan',
+    url: 'asset://stored-scan',
+  })
+  expect(url).toBe('asset://stored-scan')
+  expect(createNode).toHaveBeenCalledWith(scan, 'level_ground')
+})

package/src/lib/local-guide-image.ts

@@ -2,13 +2,23 @@ import {
   type AnyNodeId,
   GuideNode,
   type GuideNode as GuideNodeType,
+  ScanNode,
+  type ScanNode as ScanNodeType,
   saveAsset,
 } from '@pascal-app/core'
 
 export function getGuideImageName(filename: string) {
+  return getAssetName(filename, 'Guide image')
+}
+
+export function getScanName(filename: string) {
+  return getAssetName(filename, 'Scan')
+}
+
+function getAssetName(filename: string, fallback: string) {
   const trimmed = filename.trim()
   if (!trimmed) {
-    return 'Guide image'
+    return fallback
   }
 
   const dotIndex = trimmed.lastIndexOf('.')
@@ -40,3 +50,26 @@ export async function createLocalGuideImage({
   createNode(guide, levelId as AnyNodeId)
   return guide
 }
+
+export async function createLocalScan({
+  createNode,
+  file,
+  levelId,
+}: {
+  createNode: (node: ScanNodeType, parentId: AnyNodeId) => void
+  file: File
+  levelId: string
+}) {
+  const assetUrl = await saveAsset(file)
+  const scan = ScanNode.parse({
+    name: getScanName(file.name),
+    url: assetUrl,
+    position: [0, 0, 0],
+    rotation: [0, 0, 0],
+    scale: 1,
+    opacity: 100,
+  })
+
+  createNode(scan, levelId as AnyNodeId)
+  return { scan, url: assetUrl }
+}

package/src/lib/node-action-movement.ts

@@ -0,0 +1,21 @@
+import { type AnyNode, createSceneApi, isMovable, nodeRegistry, useScene } from '@pascal-app/core'
+
+export function registryMoveDisabled(node: AnyNode): boolean {
+  const def = nodeRegistry.get(node.type)
+  return Boolean(
+    def?.capabilities.movable &&
+      !isMovable(node) &&
+      !def.floorplanMoveTarget &&
+      !def.affordanceTools?.move,
+  )
+}
+
+export function duplicateWithoutMove(node: AnyNode) {
+  const api = createSceneApi(useScene)
+  const subtree = api.getSubtree(node.id)
+  if (!subtree || !node.parentId) return null
+  return api.cloneNodesInto([subtree.root, ...subtree.descendants], {
+    rootId: node.id,
+    parentId: node.parentId as AnyNode['id'],
+  })
+}

package/src/lib/portable-export.test.ts

@@ -5,6 +5,8 @@ import {
   BoxGeometry,
   BufferGeometry,
   Color,
+  CompressedTexture,
+  DataTexture,
   DoubleSide,
   Float32BufferAttribute,
   FrontSide,
@@ -15,11 +17,13 @@ import {
   Mesh,
   MeshStandardMaterial,
   Quaternion,
+  Texture,
   Vector3,
 } from 'three'
 import { USDZExporter } from 'three/examples/jsm/exporters/USDZExporter.js'
 import {
   createUsdzScene,
+  decompressCanonicalNormalMaps,
   expandInstancedMeshes,
   freezeDeformedMeshes,
   normalizePortableScene,
@@ -345,6 +349,17 @@ function withCanvasCapture(run: (capture: () => ImageData) => void): void {
       putImageData: (image: ImageData) => {
         captured = image
       },
+      drawImage: () => {
+        if (!captured) throw new Error('Source canvas has no captured pixels')
+      },
+      getImageData: (_x: number, _y: number, width: number, height: number) =>
+        captured ??
+        ({
+          colorSpace: 'srgb',
+          data: new Uint8ClampedArray(width * height * 4),
+          height,
+          width,
+        } as ImageData),
     }),
   } as unknown as HTMLCanvasElement
   globals.document = {
@@ -364,3 +379,77 @@ function withCanvasCapture(run: (capture: () => ImageData) => void): void {
     else delete globals.document
   }
 }
+
+describe('portable normal maps', () => {
+  function flatNormalPixels(size: number): Uint8Array {
+    const pixels = new Uint8Array(size * size * 4)
+    for (let index = 0; index < pixels.length; index += 4) pixels.set([128, 128, 255, 255], index)
+    return pixels
+  }
+
+  test('decompresses a shared compressed normal map once before canonicalising it', async () => {
+    const compressed = new CompressedTexture([], 2, 2)
+    compressed.name = 'NormalGL_test'
+    compressed.repeat.set(2, 2)
+    const first = new MeshStandardMaterial({ normalMap: compressed })
+    first.normalScale.set(0.5, 0.5)
+    const second = new MeshStandardMaterial({ normalMap: compressed })
+    second.normalScale.set(0.5, -0.5)
+    const root = new Group()
+    root.add(new Mesh(new BoxGeometry(), first), new Mesh(new BoxGeometry(), second))
+
+    let calls = 0
+    await decompressCanonicalNormalMaps(root, async () => {
+      calls += 1
+      return new DataTexture(flatNormalPixels(2), 2, 2)
+    })
+
+    expect(calls).toBe(1)
+    expect(first.normalMap).toBe(second.normalMap)
+    expect(first.normalMap?.repeat.toArray()).toEqual([2, 2])
+    expect(first.normalMap?.name).toBe('NormalGL_test')
+
+    withCanvasCapture(() => {
+      normalizePortableScene(root)
+    })
+
+    expect((first.normalMap as { isCanvasTexture?: boolean }).isCanvasTexture).toBe(true)
+    expect(first.normalMap).not.toBe(second.normalMap)
+    expect(first.normalScale.toArray()).toEqual([1, 1])
+    expect(second.normalScale.toArray()).toEqual([1, 1])
+  })
+
+  test('a compressed normal map that was not decompressed still fails loudly', () => {
+    const material = new MeshStandardMaterial({ normalMap: new CompressedTexture([], 2, 2) })
+    material.normalScale.set(0.5, 0.5)
+    const root = new Group()
+    root.add(new Mesh(new BoxGeometry(), material))
+    withCanvasCapture(() => {
+      expect(() => normalizePortableScene(root)).toThrow('must be baked before portable export')
+    })
+  })
+
+  test('preserved normal maps keep their texture and normal scale', async () => {
+    const placeholder = new Texture()
+    placeholder.image = { width: 1, height: 1 }
+    const material = new MeshStandardMaterial({ normalMap: placeholder })
+    material.normalScale.set(1, -1)
+    const root = new Group()
+    root.add(new Mesh(new BoxGeometry(), material))
+    const options = { preserveNormalMap: (texture: Texture) => texture === placeholder }
+
+    await decompressCanonicalNormalMaps(
+      root,
+      async () => {
+        throw new Error('preserved maps must not be decompressed')
+      },
+      options,
+    )
+    withCanvasCapture(() => {
+      normalizePortableScene(root, options)
+    })
+
+    expect(material.normalMap).toBe(placeholder)
+    expect(material.normalScale.toArray()).toEqual([1, -1])
+  })
+})

package/src/lib/portable-export.ts

@@ -1,5 +1,6 @@
 import * as THREE from 'three'
 import { StaticGeometryGenerator } from 'three-mesh-bvh'
+import { cloneExportUserData } from './export-user-data'
 
 const VERTEX_COLOR_UV_CHANNEL = 0
 const VERTEX_COLOR_TILE_SIZE = 8
@@ -64,7 +65,7 @@ function copyObjectState(source: THREE.Object3D, target: THREE.Object3D): void {
   target.layers.mask = source.layers.mask
   target.renderOrder = source.renderOrder
   target.frustumCulled = source.frustumCulled
-  target.userData = structuredClone(source.userData)
+  target.userData = cloneExportUserData(source.userData)
 }
 
 function replaceObject(source: THREE.Object3D, replacement: THREE.Object3D): void {
@@ -554,7 +555,7 @@ function cloneTextureSettings(source: THREE.Texture, target: THREE.Texture): voi
   target.flipY = source.flipY
   target.unpackAlignment = source.unpackAlignment
   target.colorSpace = THREE.NoColorSpace
-  target.userData = structuredClone(source.userData)
+  target.userData = cloneExportUserData(source.userData)
   target.needsUpdate = true
 }
 function materializeDataTextures(root: THREE.Object3D): void {
@@ -671,19 +672,68 @@ function canonicalNormalTexture(source: THREE.Texture, scale: THREE.Vector2): TH
   return texture
 }
 
-function canonicalizeNormalMaps(root: THREE.Object3D): void {
+export type PortableNormalizeOptions = {
+  /**
+   * Leave this normal map and its material's `normalScale` untouched. By-reference
+   * placeholders get their real bytes re-attached later, so baking the scale into
+   * placeholder pixels would drop both the reference and the strength.
+   */
+  preserveNormalMap?: (texture: THREE.Texture) => boolean
+}
+
+export type CompressedTextureDecompressor = (
+  texture: THREE.CompressedTexture,
+) => Promise<THREE.Texture>
+
+function canonicalNormalMaterials(
+  root: THREE.Object3D,
+  options: PortableNormalizeOptions,
+): THREE.MeshStandardMaterial[] {
   const materials = new Set<THREE.Material>()
   root.traverse((object) => {
     if (!(object as THREE.Mesh).isMesh) return
     for (const material of materialsOf(object as THREE.Mesh)) materials.add(material)
   })
-
-  const cache = new Map<THREE.Texture, Map<string, THREE.CanvasTexture>>()
+  const result: THREE.MeshStandardMaterial[] = []
   for (const material of materials) {
     const standard = material as THREE.MeshStandardMaterial
     if (!standard.normalMap || !standard.normalScale) continue
     if (standard.normalScale.x === 1 && standard.normalScale.y === 1) continue
-    const source = standard.normalMap
+    if (options.preserveNormalMap?.(standard.normalMap)) continue
+    result.push(standard)
+  }
+  return result
+}
+
+/**
+ * Canonicalizing a normal map reads its pixels on the CPU, which compressed
+ * (KTX2) textures cannot provide — decompress the ones that will be baked
+ * first. Runs before `normalizePortableScene` / `normalizeViewerArtifactMaterials`.
+ */
+export async function decompressCanonicalNormalMaps(
+  root: THREE.Object3D,
+  decompress: CompressedTextureDecompressor,
+  options: PortableNormalizeOptions = {},
+): Promise<void> {
+  const readable = new Map<THREE.Texture, THREE.Texture>()
+  for (const standard of canonicalNormalMaterials(root, options)) {
+    const source = standard.normalMap as THREE.CompressedTexture
+    if (!source.isCompressedTexture) continue
+    let texture = readable.get(source)
+    if (!texture) {
+      texture = await decompress(source)
+      cloneTextureSettings(source, texture)
+      readable.set(source, texture)
+      rememberDiscarded(root, source)
+    }
+    standard.normalMap = texture
+  }
+}
+
+function canonicalizeNormalMaps(root: THREE.Object3D, options: PortableNormalizeOptions): void {
+  const cache = new Map<THREE.Texture, Map<string, THREE.CanvasTexture>>()
+  for (const standard of canonicalNormalMaterials(root, options)) {
+    const source = standard.normalMap!
     const key = `${standard.normalScale.x}:${standard.normalScale.y}`
     let variants = cache.get(source)
     if (!variants) {
@@ -817,7 +867,10 @@ function clampPortableMaterialColors(root: THREE.Object3D): boolean {
   return clipped
 }
 
-export function normalizePortableScene(root: THREE.Object3D): string[] {
+export function normalizePortableScene(
+  root: THREE.Object3D,
+  options: PortableNormalizeOptions = {},
+): string[] {
   expandInstancedMeshes(root)
   root.updateMatrixWorld(true)
   freezeDeformedMeshes(root)
@@ -826,7 +879,7 @@ export function normalizePortableScene(root: THREE.Object3D): string[] {
   const clampedVertexColors = bakeVertexColors(root)
   const clampedHdr = clampedMaterialColors || clampedVertexColors
   canonicalizeAlphaMaps(root)
-  canonicalizeNormalMaps(root)
+  canonicalizeNormalMaps(root, options)
   bakeDoubleSidedMeshes(root)
   root.updateMatrixWorld(true)
   return clampedHdr
@@ -839,12 +892,15 @@ export function normalizePortableScene(root: THREE.Object3D): string[] {
  * Canonicalize baked static material details without freezing authored item
  * deformation that existing saved-viewer animation clips still target.
  */
-export function normalizeViewerArtifactMaterials(root: THREE.Object3D): string[] {
+export function normalizeViewerArtifactMaterials(
+  root: THREE.Object3D,
+  options: PortableNormalizeOptions = {},
+): string[] {
   const clampedMaterialColors = clampPortableMaterialColors(root)
   materializeDataTextures(root)
   const clampedVertexColors = bakeVertexColors(root, true)
   canonicalizeAlphaMaps(root)
-  canonicalizeNormalMaps(root)
+  canonicalizeNormalMaps(root, options)
   return clampedMaterialColors || clampedVertexColors
     ? [
         'Some rendered colors were outside the portable range (including colors brighter than the portable range) and were clipped to 0–1; the brightest areas may lose contrast.',
@@ -852,9 +908,26 @@ export function normalizeViewerArtifactMaterials(root: THREE.Object3D): string[]
     : []
 }
 
+/** Where the portable GLB conversion parks the authored opacity of glass it
+ * rewrote as transmission, so formats without transmission can fall back. */
+export const GLASS_OPACITY_USERDATA = 'pascalGlassOpacity'
+
 function cloneMaterialForUsdz(material: THREE.Material): THREE.Material {
   const clone = material.clone()
   clone.side = THREE.FrontSide
+  // USDPreviewSurface has no transmission and USDZExporter only writes
+  // `inputs:opacity`; hand glass back its authored opacity for Quick Look.
+  const physical = clone as THREE.MeshPhysicalMaterial
+  const authoredOpacity = clone.userData[GLASS_OPACITY_USERDATA]
+  if (
+    physical.isMeshPhysicalMaterial &&
+    physical.transmission > 0 &&
+    typeof authoredOpacity === 'number'
+  ) {
+    physical.transmission = 0
+    physical.transparent = true
+    physical.opacity = authoredOpacity
+  }
   return clone
 }
 
@@ -925,7 +998,7 @@ export function createUsdzScene(source: THREE.Object3D): THREE.Object3D {
     clone.visible = object.visible
     clone.layers.mask = object.layers.mask
     clone.renderOrder = object.renderOrder
-    clone.userData = structuredClone(object.userData)
+    clone.userData = cloneExportUserData(object.userData)
     for (const child of object.children) clone.add(cloneObject(child))
     return clone
   }

package/src/lib/print-shell-compiler-manifold-core.ts

@@ -1,6 +1,10 @@
-import ManifoldModule, { type Manifold as ManifoldSolid, type ManifoldToplevel } from 'manifold-3d'
+import type { Manifold as ManifoldSolid, ManifoldToplevel } from 'manifold-3d'
 import type { PrintShellCompileDiagnostic } from './print-shell-compiler-baseline'
-import type { ManifoldCompileOutput, ManifoldMeshData } from './print-shell-compiler-protocol'
+import type {
+  ManifoldCompileOutput,
+  ManifoldMeshData,
+  ManifoldRuntimeOptions,
+} from './print-shell-compiler-protocol'
 
 let modulePromise: Promise<ManifoldToplevel> | null = null
 const MANIFOLD_OUTPUT_WELD_EPSILON_METERS = 2e-5
@@ -8,14 +12,59 @@ const COLLINEAR_SEAM_CROSS_LENGTH_SQ = 1e-20
 
 type Triangle = [number, number, number]
 
-async function getManifoldModule(wasmUrl?: string): Promise<ManifoldToplevel> {
-  modulePromise ??= ManifoldModule(wasmUrl ? { locateFile: () => wasmUrl } : undefined).then(
-    (module) => {
+type ManifoldFactory = (config?: {
+  locateFile?: (path: string) => string
+}) => Promise<ManifoldToplevel>
+
+// manifold-3d's emscripten glue awaits import('node:module') behind a Node
+// check. The branch never executes in a browser, but webpack refuses to
+// *build* a graph that can reach it, so a static specifier here poisons every
+// external bundler that compiles this package's source (#715). The factory is
+// therefore loaded through an import() no bundler can trace: the bare
+// specifier resolves wherever node-style resolution exists at runtime (bun
+// tests, dev servers, bundlers that inline it anyway), and the version-pinned
+// CDN copy covers bundled browser builds that left the specifier unresolved —
+// emscripten then locates manifold.wasm relative to the glue's own URL. Hosts
+// that can't reach the CDN (offline, CSP) pass their own URLs through
+// configureManifoldRuntime.
+const MANIFOLD_VERSION = '3.5.1'
+const FALLBACK_MODULE_URL = `https://cdn.jsdelivr.net/npm/manifold-3d@${MANIFOLD_VERSION}/manifold.js`
+
+function importUntraced(specifier: string): Promise<{ default: ManifoldFactory }> {
+  return import(/* webpackIgnore: true */ /* @vite-ignore */ specifier)
+}
+
+async function loadManifoldFactory(moduleUrl?: string): Promise<ManifoldFactory> {
+  const specifiers = moduleUrl ? [moduleUrl] : ['manifold-3d', FALLBACK_MODULE_URL]
+  let lastError: unknown
+  for (const specifier of specifiers) {
+    try {
+      return (await importUntraced(specifier)).default
+    } catch (error) {
+      lastError = error
+    }
+  }
+  throw lastError instanceof Error ? lastError : new Error('Failed to load manifold-3d.')
+}
+
+async function getManifoldModule(runtime?: ManifoldRuntimeOptions): Promise<ManifoldToplevel> {
+  modulePromise ??= loadManifoldFactory(runtime?.moduleUrl)
+    .then((factory) => {
+      const wasmUrl = runtime?.wasmUrl
+      return factory(wasmUrl ? { locateFile: () => wasmUrl } : undefined)
+    })
+    .then((module) => {
       module.setup()
       return module
-    },
-  )
-  return modulePromise
+    })
+  try {
+    return await modulePromise
+  } catch (error) {
+    // A transient load failure (offline, blocked CDN) must not poison every
+    // later compile attempt with the cached rejection.
+    modulePromise = null
+    throw error
+  }
 }
 
 function manifoldMesh(
@@ -211,7 +260,7 @@ function elapsed(startedAt: number): number {
 
 export async function compileManifoldMeshData(
   meshes: ManifoldMeshData[],
-  wasmUrl?: string,
+  runtime?: ManifoldRuntimeOptions,
 ): Promise<ManifoldCompileOutput> {
   const startedAt = performance.now()
   const sourceNodeIds = Array.from(new Set(meshes.map((mesh) => mesh.nodeId))).sort()
@@ -238,7 +287,7 @@ export async function compileManifoldMeshData(
   }
 
   try {
-    const module = await getManifoldModule(wasmUrl)
+    const module = await getManifoldModule(runtime)
     for (const mesh of meshes) {
       try {
         solids.push(new module.Manifold(manifoldMesh(module, mesh)))

package/src/lib/print-shell-compiler-manifold-worker.ts

@@ -16,12 +16,25 @@ import {
 import type {
   ManifoldCompileOutput,
   ManifoldMeshData,
+  ManifoldRuntimeOptions,
   ManifoldWorkerRequest,
   ManifoldWorkerResponse,
 } from './print-shell-compiler-protocol'
 
 const WORKER_TIMEOUT_MS = 60_000
 
+let manifoldRuntime: ManifoldRuntimeOptions | undefined
+
+/**
+ * Overrides where the print-export worker loads the manifold-3d module and
+ * wasm from. See the loader in print-shell-compiler-manifold-core.ts for the
+ * default resolution order; hosts with restrictive networks should call this
+ * with self-hosted asset URLs before the first print export.
+ */
+export function configureManifoldRuntime(options: ManifoldRuntimeOptions | undefined): void {
+  manifoldRuntime = options
+}
+
 export type ManifoldCompileRunner = (meshes: ManifoldMeshData[]) => Promise<ManifoldCompileOutput>
 
 export type SemanticManifoldCompileOptions = SemanticPrintCompileOptions & {
@@ -76,7 +89,7 @@ export const runManifoldWorker: ManifoldCompileRunner = (meshes) => {
   const activeWorker = getWorker()
   const id = nextRequestId
   nextRequestId += 1
-  const request: ManifoldWorkerRequest = { id, meshes }
+  const request: ManifoldWorkerRequest = { id, meshes, runtime: manifoldRuntime }
   const transfer = meshes.flatMap((mesh) => [
     mesh.positions.buffer as ArrayBuffer,
     mesh.indices.buffer as ArrayBuffer,

package/src/lib/print-shell-compiler-manifold.worker.ts

@@ -10,7 +10,7 @@ const workerScope = self as unknown as {
 }
 
 workerScope.addEventListener('message', async (event) => {
-  const output = await compileManifoldMeshData(event.data.meshes)
+  const output = await compileManifoldMeshData(event.data.meshes, event.data.runtime)
   const response: ManifoldWorkerResponse = { id: event.data.id, ...output }
   const transfer: Transferable[] = []
   if (response.status === 'compiled') {

package/src/lib/print-shell-compiler-protocol.ts

@@ -22,9 +22,17 @@ export type ManifoldCompileOutput =
       durationMs: number
     }
 
+export type ManifoldRuntimeOptions = {
+  /** URL of the manifold-3d emscripten glue module. Defaults to the pinned CDN copy. */
+  moduleUrl?: string
+  /** URL of manifold.wasm. Defaults to resolving relative to the glue module. */
+  wasmUrl?: string
+}
+
 export type ManifoldWorkerRequest = {
   id: number
   meshes: ManifoldMeshData[]
+  runtime?: ManifoldRuntimeOptions
 }
 
 export type ManifoldWorkerResponse = ManifoldCompileOutput & { id: number }

package/src/lib/scene-clipboard.ts

@@ -382,7 +382,7 @@ function parseClipboardPayload(text: string): ClipboardPayload | null {
     if (materials.some((result) => !result.success)) return null
 
     const parsedNodes = nodes.filter((result) => result.success).map((result) => result.data)
-    const nodeIds = new Set(parsedNodes.map((node) => node.id))
+    const nodeIds = new Set<AnyNodeId>(parsedNodes.map((node) => node.id))
     const rootIds = candidate.rootIds as AnyNodeId[]
     if (rootIds.length === 0 || rootIds.some((id) => !nodeIds.has(id))) return null