@pascal-app/editor 1.0.0-beta.5 → 1.0.1

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

@@ -0,0 +1,379 @@
+import type { Manifold as ManifoldSolid, ManifoldToplevel } from 'manifold-3d'
+import type { PrintShellCompileDiagnostic } from './print-shell-compiler-baseline'
+import type {
+  ManifoldCompileOutput,
+  ManifoldMeshData,
+  ManifoldRuntimeOptions,
+} from './print-shell-compiler-protocol'
+
+let modulePromise: Promise<ManifoldToplevel> | null = null
+const MANIFOLD_OUTPUT_WELD_EPSILON_METERS = 2e-5
+const COLLINEAR_SEAM_CROSS_LENGTH_SQ = 1e-20
+
+type Triangle = [number, number, number]
+
+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
+    })
+  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(
+  module: ManifoldToplevel,
+  mesh: ManifoldMeshData,
+): InstanceType<ManifoldToplevel['Mesh']> {
+  return new module.Mesh({
+    numProp: 3,
+    vertProperties: mesh.positions,
+    triVerts: mesh.indices,
+  })
+}
+
+function distanceSquared(positions: Float32Array, left: number, right: number): number {
+  const dx = positions[left * 3]! - positions[right * 3]!
+  const dy = positions[left * 3 + 1]! - positions[right * 3 + 1]!
+  const dz = positions[left * 3 + 2]! - positions[right * 3 + 2]!
+  return dx * dx + dy * dy + dz * dz
+}
+
+function triangleCrossLengthSquared(positions: Float32Array, [a, b, c]: Triangle): number {
+  const abX = positions[b * 3]! - positions[a * 3]!
+  const abY = positions[b * 3 + 1]! - positions[a * 3 + 1]!
+  const abZ = positions[b * 3 + 2]! - positions[a * 3 + 2]!
+  const acX = positions[c * 3]! - positions[a * 3]!
+  const acY = positions[c * 3 + 1]! - positions[a * 3 + 1]!
+  const acZ = positions[c * 3 + 2]! - positions[a * 3 + 2]!
+  const crossX = abY * acZ - abZ * acY
+  const crossY = abZ * acX - abX * acZ
+  const crossZ = abX * acY - abY * acX
+  return crossX * crossX + crossY * crossY + crossZ * crossZ
+}
+
+function collinearSeam(
+  positions: Float32Array,
+  triangle: Triangle,
+): { start: number; middle: number; end: number } | null {
+  if (triangleCrossLengthSquared(positions, triangle) > COLLINEAR_SEAM_CROSS_LENGTH_SQ) {
+    return null
+  }
+
+  const [a, b, c] = triangle
+  const edges = [
+    { start: a, middle: c, end: b, lengthSquared: distanceSquared(positions, a, b) },
+    { start: b, middle: a, end: c, lengthSquared: distanceSquared(positions, b, c) },
+    { start: c, middle: b, end: a, lengthSquared: distanceSquared(positions, c, a) },
+  ].sort((left, right) => right.lengthSquared - left.lengthSquared)
+  const longest = edges[0]!
+  if (longest.lengthSquared === 0) return null
+
+  const startOffset = longest.start * 3
+  const middleOffset = longest.middle * 3
+  const endOffset = longest.end * 3
+  const edgeX = positions[endOffset]! - positions[startOffset]!
+  const edgeY = positions[endOffset + 1]! - positions[startOffset + 1]!
+  const edgeZ = positions[endOffset + 2]! - positions[startOffset + 2]!
+  const middleX = positions[middleOffset]! - positions[startOffset]!
+  const middleY = positions[middleOffset + 1]! - positions[startOffset + 1]!
+  const middleZ = positions[middleOffset + 2]! - positions[startOffset + 2]!
+  const projection = middleX * edgeX + middleY * edgeY + middleZ * edgeZ
+  if (projection <= 0 || projection >= longest.lengthSquared) return null
+
+  return longest
+}
+
+function stitchCollinearSeams(positions: Float32Array, input: Triangle[]): Triangle[] {
+  const triangles: Array<Triangle | null> = [...input]
+
+  // Manifold can encode a T-junction as one zero-area triangle: one surface owns the long
+  // edge while the other owns its two segments. Split the neighboring face at the middle
+  // vertex before removing the collapsed face so indexed edge incidence remains closed.
+  for (let triangleIndex = 0; triangleIndex < triangles.length; triangleIndex += 1) {
+    const triangle = triangles[triangleIndex]
+    if (!triangle) continue
+    const seam = collinearSeam(positions, triangle)
+    if (!seam) continue
+
+    const matches: Array<{ index: number; edgeOffset: number }> = []
+    for (let candidateIndex = 0; candidateIndex < triangles.length; candidateIndex += 1) {
+      if (candidateIndex === triangleIndex) continue
+      const candidate = triangles[candidateIndex]
+      if (
+        !candidate ||
+        triangleCrossLengthSquared(positions, candidate) <= COLLINEAR_SEAM_CROSS_LENGTH_SQ
+      ) {
+        continue
+      }
+      for (let edgeOffset = 0; edgeOffset < 3; edgeOffset += 1) {
+        const from = candidate[edgeOffset]!
+        const to = candidate[(edgeOffset + 1) % 3]!
+        if ((from === seam.start && to === seam.end) || (from === seam.end && to === seam.start)) {
+          matches.push({ index: candidateIndex, edgeOffset })
+        }
+      }
+    }
+    if (matches.length !== 1) continue
+
+    const match = matches[0]!
+    const neighbor = triangles[match.index]!
+    const from = neighbor[match.edgeOffset]!
+    const to = neighbor[(match.edgeOffset + 1) % 3]!
+    const opposite = neighbor[(match.edgeOffset + 2) % 3]!
+    triangles[match.index] = [from, seam.middle, opposite]
+    triangles.push([seam.middle, to, opposite])
+    triangles[triangleIndex] = null
+  }
+
+  return triangles.filter((triangle): triangle is Triangle => triangle !== null)
+}
+
+function manifoldOutput(solid: ManifoldSolid): { positions: Float32Array; indices: Uint32Array } {
+  const mesh = solid.getMesh()
+  const positions = new Float32Array(mesh.numVert * 3)
+  for (let index = 0; index < mesh.numVert; index += 1) {
+    const sourceOffset = index * mesh.numProp
+    positions[index * 3] = mesh.vertProperties[sourceOffset]!
+    positions[index * 3 + 1] = mesh.vertProperties[sourceOffset + 1]!
+    positions[index * 3 + 2] = mesh.vertProperties[sourceOffset + 2]!
+  }
+
+  const parents = new Uint32Array(mesh.numVert)
+  for (let index = 0; index < parents.length; index += 1) parents[index] = index
+  const find = (index: number): number => {
+    let root = index
+    while (parents[root] !== root) root = parents[root]!
+    while (parents[index] !== index) {
+      const next = parents[index]!
+      parents[index] = root
+      index = next
+    }
+    return root
+  }
+  for (let index = 0; index < mesh.mergeFromVert.length; index += 1) {
+    parents[find(mesh.mergeFromVert[index]!)] = find(mesh.mergeToVert[index]!)
+  }
+
+  // Float32 boolean output can leave seam vertices just over 10 microns apart. Dropping the
+  // resulting sliver triangle by area opens the shell; weld the vertices first so adjacent
+  // faces inherit one indexed edge, then remove only triangles collapsed by that topology.
+  const cellSize = MANIFOLD_OUTPUT_WELD_EPSILON_METERS
+  const cellRoots = new Map<string, number[]>()
+  const cellCoordinate = (value: number) => Math.floor(value / cellSize)
+  const cellKey = (x: number, y: number, z: number) => `${x},${y},${z}`
+  const weldDistanceSquared = cellSize * cellSize
+  for (let index = 0; index < mesh.numVert; index += 1) {
+    const root = find(index)
+    if (root !== index) continue
+    const cellX = cellCoordinate(positions[root * 3]!)
+    const cellY = cellCoordinate(positions[root * 3 + 1]!)
+    const cellZ = cellCoordinate(positions[root * 3 + 2]!)
+    let weldedTo: number | null = null
+    for (let xOffset = -1; xOffset <= 1 && weldedTo === null; xOffset += 1) {
+      for (let yOffset = -1; yOffset <= 1 && weldedTo === null; yOffset += 1) {
+        for (let zOffset = -1; zOffset <= 1 && weldedTo === null; zOffset += 1) {
+          const candidates = cellRoots.get(
+            cellKey(cellX + xOffset, cellY + yOffset, cellZ + zOffset),
+          )
+          for (const candidate of candidates ?? []) {
+            if (distanceSquared(positions, root, candidate) <= weldDistanceSquared) {
+              weldedTo = candidate
+              break
+            }
+          }
+        }
+      }
+    }
+    if (weldedTo === null) {
+      const key = cellKey(cellX, cellY, cellZ)
+      const roots = cellRoots.get(key) ?? []
+      roots.push(root)
+      cellRoots.set(key, roots)
+    } else {
+      parents[root] = find(weldedTo)
+    }
+  }
+
+  const triangles: Triangle[] = []
+  for (let index = 0; index + 2 < mesh.triVerts.length; index += 3) {
+    const a = find(mesh.triVerts[index]!)
+    const b = find(mesh.triVerts[index + 1]!)
+    const c = find(mesh.triVerts[index + 2]!)
+    if (a === b || b === c || c === a) continue
+    triangles.push([a, b, c])
+  }
+  const indices = stitchCollinearSeams(positions, triangles).flat()
+
+  return { positions, indices: new Uint32Array(indices) }
+}
+
+function elapsed(startedAt: number): number {
+  return Math.max(0, performance.now() - startedAt)
+}
+
+export async function compileManifoldMeshData(
+  meshes: ManifoldMeshData[],
+  runtime?: ManifoldRuntimeOptions,
+): Promise<ManifoldCompileOutput> {
+  const startedAt = performance.now()
+  const sourceNodeIds = Array.from(new Set(meshes.map((mesh) => mesh.nodeId))).sort()
+  const diagnostics: PrintShellCompileDiagnostic[] = []
+  const solids: ManifoldSolid[] = []
+  let union: ManifoldSolid | null = null
+  let result: ManifoldSolid | null = null
+
+  if (meshes.length === 0) {
+    return {
+      status: 'blocked',
+      positions: null,
+      indices: null,
+      diagnostics: [
+        {
+          severity: 'error',
+          code: 'no_shell_meshes',
+          message: 'No structural meshes are available for Manifold compilation.',
+          nodeIds: [],
+        },
+      ],
+      durationMs: elapsed(startedAt),
+    }
+  }
+
+  try {
+    const module = await getManifoldModule(runtime)
+    for (const mesh of meshes) {
+      try {
+        solids.push(new module.Manifold(manifoldMesh(module, mesh)))
+      } catch (error) {
+        diagnostics.push({
+          severity: 'error',
+          code: 'manifold_input_failed',
+          message: `Node ${mesh.nodeId}: ${
+            error instanceof Error ? error.message : 'Manifold rejected the shell input.'
+          }`,
+          nodeIds: [mesh.nodeId],
+        })
+      }
+    }
+    if (diagnostics.length > 0) {
+      return {
+        status: 'blocked',
+        positions: null,
+        indices: null,
+        diagnostics,
+        durationMs: elapsed(startedAt),
+      }
+    }
+
+    union = module.Manifold.union(solids)
+    result = union.asOriginal()
+    const status = result.status()
+    if (status !== 'NoError') {
+      return {
+        status: 'blocked',
+        positions: null,
+        indices: null,
+        diagnostics: [
+          {
+            severity: 'error',
+            code: 'manifold_union_failed',
+            message: `Manifold union failed with ${status}.`,
+            nodeIds: sourceNodeIds,
+          },
+        ],
+        durationMs: elapsed(startedAt),
+      }
+    }
+
+    const output = manifoldOutput(result)
+    if (output.indices.length === 0) {
+      return {
+        status: 'blocked',
+        positions: null,
+        indices: null,
+        diagnostics: [
+          {
+            severity: 'error',
+            code: 'manifold_union_failed',
+            message: 'Manifold produced no printable triangles.',
+            nodeIds: sourceNodeIds,
+          },
+        ],
+        durationMs: elapsed(startedAt),
+      }
+    }
+    return {
+      status: 'compiled',
+      positions: output.positions,
+      indices: output.indices,
+      diagnostics: [],
+      durationMs: elapsed(startedAt),
+    }
+  } catch (error) {
+    return {
+      status: 'blocked',
+      positions: null,
+      indices: null,
+      diagnostics: [
+        {
+          severity: 'error',
+          code: 'manifold_worker_failed',
+          message: error instanceof Error ? error.message : 'Manifold compilation failed.',
+          nodeIds: sourceNodeIds,
+        },
+      ],
+      durationMs: elapsed(startedAt),
+    }
+  } finally {
+    for (const solid of solids) solid.delete()
+    union?.delete()
+    result?.delete()
+  }
+}

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

@@ -0,0 +1,200 @@
+import type { AnyNode } from '@pascal-app/core'
+import * as THREE from 'three'
+import {
+  prepareSemanticPrintShellSource,
+  type SemanticPrintCompileOptions,
+} from './print-shell-compiler'
+import {
+  collectPrintShellInput,
+  type PrintShellCompileDiagnostic,
+  type PrintShellCompileResult,
+} from './print-shell-compiler-baseline'
+import {
+  geometryFromManifoldMeshData,
+  geometryToManifoldMeshData,
+} from './print-shell-compiler-mesh-data'
+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 & {
+  runner?: ManifoldCompileRunner
+}
+
+type PendingRequest = {
+  resolve: (output: ManifoldCompileOutput) => void
+  reject: (error: Error) => void
+  timeout: ReturnType<typeof setTimeout>
+}
+
+let worker: Worker | null = null
+let nextRequestId = 1
+const pendingRequests = new Map<number, PendingRequest>()
+
+function resetWorker(error: Error) {
+  worker?.terminate()
+  worker = null
+  for (const pending of pendingRequests.values()) {
+    clearTimeout(pending.timeout)
+    pending.reject(error)
+  }
+  pendingRequests.clear()
+}
+
+function getWorker(): Worker {
+  if (worker) return worker
+  if (typeof Worker === 'undefined') {
+    throw new Error('Web Workers are unavailable in this environment.')
+  }
+  worker = new Worker(new URL('./print-shell-compiler-manifold.worker.ts', import.meta.url), {
+    type: 'module',
+  })
+  worker.addEventListener('message', (event: MessageEvent<ManifoldWorkerResponse>) => {
+    const pending = pendingRequests.get(event.data.id)
+    if (!pending) return
+    pendingRequests.delete(event.data.id)
+    clearTimeout(pending.timeout)
+    pending.resolve(event.data)
+  })
+  worker.addEventListener('error', (event) => {
+    resetWorker(new Error(event.message || 'The Manifold worker failed.'))
+  })
+  worker.addEventListener('messageerror', () => {
+    resetWorker(new Error('The Manifold worker returned an unreadable response.'))
+  })
+  return worker
+}
+
+export const runManifoldWorker: ManifoldCompileRunner = (meshes) => {
+  const activeWorker = getWorker()
+  const id = nextRequestId
+  nextRequestId += 1
+  const request: ManifoldWorkerRequest = { id, meshes, runtime: manifoldRuntime }
+  const transfer = meshes.flatMap((mesh) => [
+    mesh.positions.buffer as ArrayBuffer,
+    mesh.indices.buffer as ArrayBuffer,
+  ])
+
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      resetWorker(new Error(`The Manifold worker exceeded ${WORKER_TIMEOUT_MS / 1000} seconds.`))
+    }, WORKER_TIMEOUT_MS)
+    pendingRequests.set(id, { resolve, reject, timeout })
+    try {
+      activeWorker.postMessage(request, transfer)
+    } catch (error) {
+      resetWorker(
+        error instanceof Error ? error : new Error('Failed to start the Manifold worker.'),
+      )
+    }
+  })
+}
+
+function blockedResult(
+  inputMeshCount: number,
+  sourceNodeIds: Iterable<string>,
+  diagnostics: PrintShellCompileDiagnostic[],
+): PrintShellCompileResult {
+  return {
+    backend: 'manifold-3d',
+    status: 'blocked',
+    scene: null,
+    inputMeshCount,
+    sourceNodeIds: Array.from(sourceNodeIds).sort(),
+    diagnostics,
+  }
+}
+
+export async function compileSemanticPrintShellWithManifold(
+  source: THREE.Object3D,
+  nodes: Record<string, AnyNode>,
+  options: SemanticManifoldCompileOptions = {},
+): Promise<PrintShellCompileResult> {
+  const { runner = runManifoldWorker, ...semanticOptions } = options
+  const prepared = prepareSemanticPrintShellSource(source, nodes, {
+    ...semanticOptions,
+    wallSolids: semanticOptions.wallSolids ?? true,
+  })
+  if (prepared.status === 'blocked') {
+    return blockedResult(prepared.inputMeshCount, prepared.sourceNodeIds, prepared.diagnostics)
+  }
+
+  const input = collectPrintShellInput(prepared.scene)
+  prepared.dispose()
+  if (input.diagnostics.some((diagnostic) => diagnostic.severity === 'error')) {
+    for (const geometry of input.geometries) geometry.dispose()
+    return blockedResult(input.inputMeshCount, input.sourceNodeIds, input.diagnostics)
+  }
+
+  const meshes = input.geometries.map((geometry, index) =>
+    geometryToManifoldMeshData(geometry, input.geometryNodeIds[index]!),
+  )
+  for (const geometry of input.geometries) geometry.dispose()
+
+  let output: ManifoldCompileOutput
+  try {
+    output = await runner(meshes)
+  } catch (error) {
+    return blockedResult(input.inputMeshCount, input.sourceNodeIds, [
+      ...input.diagnostics,
+      {
+        severity: 'error',
+        code: 'manifold_worker_failed',
+        message: error instanceof Error ? error.message : 'The Manifold worker failed.',
+        nodeIds: Array.from(input.sourceNodeIds).sort(),
+      },
+    ])
+  }
+
+  const diagnostics = [...input.diagnostics, ...output.diagnostics]
+  if (output.status === 'blocked') {
+    return blockedResult(input.inputMeshCount, input.sourceNodeIds, diagnostics)
+  }
+
+  const geometry = geometryFromManifoldMeshData(output.positions, output.indices)
+  const mesh = new THREE.Mesh(geometry, new THREE.MeshStandardMaterial())
+  mesh.name = 'print-shell-manifold'
+  mesh.userData = {
+    printCompiler: 'manifold-3d',
+    sourceNodeIds: Array.from(input.sourceNodeIds).sort(),
+  }
+  const scene = new THREE.Group()
+  scene.name = 'compiled-print-shell'
+  scene.add(mesh)
+  diagnostics.push({
+    severity: 'info',
+    code: runner === runManifoldWorker ? 'manifold_worker_compiler' : 'manifold_compiler_candidate',
+    message: `Compiled with Manifold in ${output.durationMs.toFixed(1)} ms${
+      runner === runManifoldWorker ? ' off the main thread' : ' through the in-process test runner'
+    }.`,
+    nodeIds: Array.from(input.sourceNodeIds).sort(),
+  })
+  return {
+    backend: 'manifold-3d',
+    status: 'compiled',
+    scene,
+    inputMeshCount: input.inputMeshCount,
+    sourceNodeIds: Array.from(input.sourceNodeIds).sort(),
+    diagnostics,
+  }
+}

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

@@ -0,0 +1,20 @@
+import { compileManifoldMeshData } from './print-shell-compiler-manifold-core'
+import type { ManifoldWorkerRequest, ManifoldWorkerResponse } from './print-shell-compiler-protocol'
+
+const workerScope = self as unknown as {
+  addEventListener: (
+    type: 'message',
+    listener: (event: MessageEvent<ManifoldWorkerRequest>) => void,
+  ) => void
+  postMessage: (response: ManifoldWorkerResponse, transfer: Transferable[]) => void
+}
+
+workerScope.addEventListener('message', async (event) => {
+  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') {
+    transfer.push(response.positions.buffer as ArrayBuffer, response.indices.buffer as ArrayBuffer)
+  }
+  workerScope.postMessage(response, transfer)
+})

package/src/lib/print-shell-compiler-mesh-data.ts

@@ -0,0 +1,32 @@
+import * as THREE from 'three'
+import type { ManifoldMeshData } from './print-shell-compiler-protocol'
+
+export function geometryToManifoldMeshData(
+  geometry: THREE.BufferGeometry,
+  nodeId: string,
+): ManifoldMeshData {
+  const position = geometry.getAttribute('position')
+  const positions = new Float32Array(position.count * 3)
+  for (let index = 0; index < position.count; index += 1) {
+    positions[index * 3] = position.getX(index)
+    positions[index * 3 + 1] = position.getY(index)
+    positions[index * 3 + 2] = position.getZ(index)
+  }
+  const geometryIndex = geometry.getIndex()
+  const indices = new Uint32Array(geometryIndex?.count ?? position.count)
+  for (let index = 0; index < indices.length; index += 1) {
+    indices[index] = geometryIndex?.getX(index) ?? index
+  }
+  return { nodeId, positions, indices }
+}
+
+export function geometryFromManifoldMeshData(
+  positions: Float32Array,
+  indices: Uint32Array,
+): THREE.BufferGeometry {
+  const geometry = new THREE.BufferGeometry()
+  geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3))
+  geometry.setIndex(new THREE.BufferAttribute(indices, 1))
+  geometry.computeVertexNormals()
+  return geometry
+}

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

@@ -0,0 +1,38 @@
+import type { PrintShellCompileDiagnostic } from './print-shell-compiler-baseline'
+
+export type ManifoldMeshData = {
+  nodeId: string
+  positions: Float32Array
+  indices: Uint32Array
+}
+
+export type ManifoldCompileOutput =
+  | {
+      status: 'compiled'
+      positions: Float32Array
+      indices: Uint32Array
+      diagnostics: PrintShellCompileDiagnostic[]
+      durationMs: number
+    }
+  | {
+      status: 'blocked'
+      positions: null
+      indices: null
+      diagnostics: PrintShellCompileDiagnostic[]
+      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 }