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

package/src/lib/level-print-export.ts

@@ -0,0 +1,526 @@
+import {
+  type AnyNode,
+  getLevelDisplayName,
+  getLevelElevations,
+  type LevelNode,
+} from '@pascal-app/core'
+import { disposeObject3DResources } from '@pascal-app/viewer'
+import { type Zippable, zipSync } from 'fflate'
+import * as THREE from 'three'
+import { createPrint3mf, type Print3mfPart } from './print-3mf'
+import {
+  encodePreparedPrintSceneToStl,
+  extractPreparedPrintMesh,
+  mergePrintExportDiagnostics,
+  type PrintArtifactFormat,
+  type PrintExportBounds,
+  type PrintExportDiagnostic,
+  type PrintExportReport,
+  type PrintMeshData,
+  prepareSceneForPrint,
+} from './print-export'
+import {
+  applyPrintFeatureThickness,
+  applySemanticPrintFeatureThickness,
+  isPrintFeatureThicknessDiagnostic,
+} from './print-feature-thickness'
+import { compileSemanticPrintShell } from './print-shell-compiler'
+import type { PrintShellCompileResult } from './print-shell-compiler-baseline'
+
+const ZIP_MTIME = new Date(2000, 0, 1, 0, 0, 0)
+const MILLIMETERS_PER_METER = 1000
+const LEVEL_BASE_TOLERANCE_MM = 0.01
+
+export type PrintBaseMode = 'none' | 'plinth'
+
+export type PrintPlinthOptions = {
+  marginMm: number
+  thicknessMm: number
+}
+
+export type PrintLevelPartReport = {
+  kind: 'level' | 'plinth'
+  levelId: string
+  label: string
+  objectName: string
+  filename: string | null
+  sourceBaseMeters: number | null
+  report: PrintExportReport
+}
+
+export type PrintLevelBundleReport = {
+  kind: 'print-level-export-report'
+  version: 2
+  format: PrintArtifactFormat
+  scale: number
+  units: 'millimeter'
+  orientation: 'z-up'
+  status: 'pass' | 'warning' | 'blocked'
+  partCount: number
+  parts: PrintLevelPartReport[]
+  excludedNodeIds: string[]
+  diagnostics: PrintExportDiagnostic[]
+}
+
+export type PrintLevelPackage = {
+  data: Uint8Array<ArrayBuffer>
+  report: PrintLevelBundleReport
+}
+
+export type PrintLevelExportOptions = {
+  scale: number
+  format?: PrintArtifactFormat
+  plinth?: PrintPlinthOptions
+  minimumFeatureMm?: number
+  compileShells?: boolean
+  compileShell?: (
+    source: THREE.Object3D,
+    nodes: Record<string, AnyNode>,
+  ) => Promise<PrintShellCompileResult>
+}
+
+function exportedIdentityIds(root: THREE.Object3D): Set<string> {
+  const ids = new Set<string>()
+  root.traverse((object) => {
+    const id = object.userData.pascalId
+    if (typeof id === 'string') ids.add(id)
+  })
+  return ids
+}
+
+function owningLevelId(
+  id: string,
+  nodes: Record<string, AnyNode>,
+  memo: Map<string, string | null>,
+  path = new Set<string>(),
+): string | null {
+  if (memo.has(id)) return memo.get(id) ?? null
+  const node = nodes[id]
+  if (!node || path.has(id)) return null
+  if (node.type === 'level') {
+    memo.set(id, id)
+    return id
+  }
+  if (!node.parentId) {
+    memo.set(id, null)
+    return null
+  }
+
+  path.add(id)
+  const levelId = owningLevelId(node.parentId, nodes, memo, path)
+  path.delete(id)
+  memo.set(id, levelId)
+  return levelId
+}
+
+function levelAncestors(levelId: string, nodes: Record<string, AnyNode>): Set<string> {
+  const ancestors = new Set<string>()
+  const visited = new Set<string>()
+  let parentId = nodes[levelId]?.parentId ?? null
+  while (parentId && !visited.has(parentId)) {
+    visited.add(parentId)
+    ancestors.add(parentId)
+    parentId = nodes[parentId]?.parentId ?? null
+  }
+  return ancestors
+}
+
+function isSpanningNode(node: AnyNode, ownerLevelId: string | null): boolean {
+  if (node.type === 'elevator') return true
+  if (node.type !== 'stair') return false
+
+  const fromLevelId = node.fromLevelId ?? ownerLevelId
+  const toLevelId = node.toLevelId
+  return Boolean(fromLevelId && toLevelId && fromLevelId !== toLevelId)
+}
+
+function hasExcludedAncestor(
+  id: string,
+  excludedIds: ReadonlySet<string>,
+  nodes: Record<string, AnyNode>,
+): boolean {
+  const visited = new Set<string>()
+  let parentId = nodes[id]?.parentId ?? null
+  while (parentId && !visited.has(parentId)) {
+    if (excludedIds.has(parentId)) return true
+    visited.add(parentId)
+    parentId = nodes[parentId]?.parentId ?? null
+  }
+  return false
+}
+
+function pruneSceneToLevel(
+  source: THREE.Object3D,
+  levelId: string,
+  nodes: Record<string, AnyNode>,
+  excludedIds: ReadonlySet<string>,
+  ownerByNodeId: Map<string, string | null>,
+): THREE.Object3D {
+  const scene = source.clone(true)
+  const ancestors = levelAncestors(levelId, nodes)
+  const removals: THREE.Object3D[] = []
+
+  scene.traverse((object) => {
+    const id = object.userData.pascalId
+    if (typeof id !== 'string') return
+    const belongsToLevel =
+      ownerByNodeId.get(id) === levelId &&
+      !excludedIds.has(id) &&
+      !hasExcludedAncestor(id, excludedIds, nodes)
+    if (!belongsToLevel && !ancestors.has(id)) removals.push(object)
+  })
+
+  for (const object of removals) object.removeFromParent()
+  scene.name = `print-level-${levelId}`
+  return scene
+}
+
+function safeFilenamePart(value: string): string {
+  return (
+    value
+      .normalize('NFKD')
+      .replace(/[\u0300-\u036f]/g, '')
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-+|-+$/g, '') || 'level'
+  )
+}
+
+function bundleStatus(
+  diagnostics: PrintExportDiagnostic[],
+  parts: PrintLevelPartReport[],
+): PrintLevelBundleReport['status'] {
+  if (
+    diagnostics.some((diagnostic) => diagnostic.severity === 'error') ||
+    parts.some((part) => part.report.status === 'blocked')
+  ) {
+    return 'blocked'
+  }
+  if (
+    diagnostics.some((diagnostic) => diagnostic.severity === 'warning') ||
+    parts.some((part) => part.report.status === 'warning')
+  ) {
+    return 'warning'
+  }
+  return 'pass'
+}
+
+type PreparedLevelArtifact = {
+  filename: string | null
+  objectName: string
+  bytes: Uint8Array<ArrayBuffer> | null
+  mesh: PrintMeshData | null
+  bounds: PrintExportBounds | null
+}
+
+function levelBaseDiagnostics(
+  level: LevelNode,
+  label: string,
+  sourceBaseMeters: number | null,
+  report: PrintExportReport,
+): PrintExportDiagnostic[] {
+  if (sourceBaseMeters === null) {
+    return [
+      {
+        severity: 'error',
+        code: 'missing_level_base',
+        message: `${label} has no finite stored level base and cannot be normalized reliably.`,
+        nodeIds: [level.id],
+      },
+    ]
+  }
+
+  const minZ = report.bounds?.min.z
+  if (minZ === undefined || Math.abs(minZ) <= LEVEL_BASE_TOLERANCE_MM) return []
+  if (minZ < 0) {
+    return [
+      {
+        severity: 'error',
+        code: 'level_geometry_below_base',
+        message: `${label} extends ${Math.abs(minZ).toFixed(3)} mm below its stored level base. Correct the level ownership or supporting slab before printing.`,
+        nodeIds: [level.id],
+      },
+    ]
+  }
+
+  return [
+    {
+      severity: 'error',
+      code: 'level_geometry_detached_from_base',
+      message: `${label} begins ${minZ.toFixed(3)} mm above its stored level base, leaving the printable part detached from the bed. Add or assign a floor solid before printing.`,
+      nodeIds: [level.id],
+    },
+  ]
+}
+
+export async function exportSceneLevelsForPrint(
+  source: THREE.Object3D,
+  nodes: Record<string, AnyNode>,
+  options: PrintLevelExportOptions,
+): Promise<PrintLevelPackage> {
+  const format = options.format ?? 'stl'
+  const exportedIds = exportedIdentityIds(source)
+  const levelElevations = getLevelElevations(nodes)
+  const ownerByNodeId = new Map<string, string | null>()
+  for (const id of Object.keys(nodes)) owningLevelId(id, nodes, ownerByNodeId)
+
+  const levels = Object.values(nodes)
+    .filter((node): node is LevelNode => node.type === 'level' && exportedIds.has(node.id))
+    .sort(
+      (a, b) =>
+        (a.parentId ?? '').localeCompare(b.parentId ?? '') ||
+        a.level - b.level ||
+        a.id.localeCompare(b.id),
+    )
+
+  const excludedIds = new Set<string>()
+  const diagnostics: PrintExportDiagnostic[] = []
+  for (const id of exportedIds) {
+    const node = nodes[id]
+    if (!node || !isSpanningNode(node, ownerByNodeId.get(id) ?? null)) continue
+    excludedIds.add(id)
+    diagnostics.push({
+      severity: 'error',
+      code: 'unsplit_spanning_node',
+      message: `${node.type} ${id} spans levels and was omitted. Hide it or define a deterministic split before downloading level parts.`,
+    })
+  }
+
+  if (levels.length === 0) {
+    diagnostics.push({
+      severity: 'error',
+      code: 'no_visible_levels',
+      message: 'No visible level nodes remain in the print scope.',
+    })
+  }
+
+  const levelArtifacts: PreparedLevelArtifact[] = []
+  const levelParts: PrintLevelPartReport[] = []
+  for (const [index, level] of levels.entries()) {
+    const label = getLevelDisplayName(level)
+    const prefix = String(index + 1).padStart(2, '0')
+    const objectName = `${prefix} ${label}`
+    const filename = format === 'stl' ? `${prefix}_${safeFilenamePart(label)}.stl` : null
+    const levelScene = pruneSceneToLevel(source, level.id, nodes, excludedIds, ownerByNodeId)
+    const sourceBase = levelElevations.get(level.id)?.baseY
+    const sourceBaseMeters =
+      typeof sourceBase === 'number' && Number.isFinite(sourceBase) ? sourceBase : null
+    const compiled = options.compileShells
+      ? options.compileShell
+        ? await options.compileShell(levelScene, nodes)
+        : compileSemanticPrintShell(levelScene, nodes)
+      : null
+    try {
+      const printSource = compiled ? (compiled.scene ?? new THREE.Group()) : levelScene
+      const prepared = prepareSceneForPrint(printSource, {
+        scale: options.scale,
+        compiled: compiled?.status === 'compiled',
+        indexedTopology: compiled?.backend === 'manifold-3d',
+        format,
+        ...(sourceBaseMeters === null ? {} : { sourceBedElevationMeters: sourceBaseMeters }),
+      })
+      let report = compiled
+        ? mergePrintExportDiagnostics(
+            prepared.report,
+            compiled.diagnostics,
+            new Set(['compiler_pending']),
+          )
+        : prepared.report
+      if (compiled) {
+        report = applySemanticPrintFeatureThickness(
+          report,
+          nodes,
+          compiled.sourceNodeIds,
+          options.minimumFeatureMm,
+        )
+      }
+      const baseDiagnostics = levelBaseDiagnostics(level, label, sourceBaseMeters, report)
+      report = mergePrintExportDiagnostics(report, baseDiagnostics)
+      if (compiled) {
+        diagnostics.push(
+          ...compiled.diagnostics.filter((diagnostic) => diagnostic.severity !== 'info'),
+        )
+      }
+      diagnostics.push(...report.diagnostics.filter(isPrintFeatureThicknessDiagnostic))
+      diagnostics.push(...baseDiagnostics)
+      levelArtifacts.push({
+        filename,
+        objectName,
+        bytes:
+          format === 'stl' ? new Uint8Array(encodePreparedPrintSceneToStl(prepared.scene)) : null,
+        mesh:
+          format === '3mf' && report.bounds && report.invalidTriangleCount === 0
+            ? extractPreparedPrintMesh(prepared.scene)
+            : null,
+        bounds: report.bounds,
+      })
+      levelParts.push({
+        kind: 'level',
+        levelId: level.id,
+        label,
+        objectName,
+        filename,
+        sourceBaseMeters,
+        report,
+      })
+    } finally {
+      if (compiled?.scene) disposeObject3DResources(compiled.scene)
+    }
+  }
+
+  let plinthArtifact: PreparedLevelArtifact | null = null
+  let plinthPart: PrintLevelPartReport | null = null
+  if (options.plinth) {
+    const { marginMm, thicknessMm } = options.plinth
+    if (
+      !Number.isFinite(marginMm) ||
+      marginMm < 0 ||
+      !Number.isFinite(thicknessMm) ||
+      thicknessMm <= 0
+    ) {
+      diagnostics.push({
+        severity: 'error',
+        code: 'invalid_plinth_dimensions',
+        message: 'Plinth margin must be non-negative and thickness must be positive.',
+      })
+    } else {
+      const buildingIds = new Set(levels.map((level) => level.parentId ?? 'unparented-building'))
+      const lowestLevel = levels[0]
+      const lowestPart = levelParts[0]
+      const bounds = lowestPart?.report.bounds
+      if (buildingIds.size > 1) {
+        diagnostics.push({
+          severity: 'error',
+          code: 'multiple_building_plinth',
+          message: 'A plinth currently requires the print scope to contain exactly one building.',
+        })
+      } else if (!lowestLevel || !lowestPart || !bounds) {
+        diagnostics.push({
+          severity: 'error',
+          code: 'plinth_missing_footprint',
+          message: 'The lowest visible level has no structural bounds for plinth generation.',
+        })
+      } else {
+        const widthMeters = ((bounds.width + marginMm * 2) * options.scale) / MILLIMETERS_PER_METER
+        const depthMeters = ((bounds.depth + marginMm * 2) * options.scale) / MILLIMETERS_PER_METER
+        const thicknessMeters = (thicknessMm * options.scale) / MILLIMETERS_PER_METER
+        const mesh = new THREE.Mesh(
+          new THREE.BoxGeometry(widthMeters, thicknessMeters, depthMeters),
+        )
+        try {
+          const prepared = prepareSceneForPrint(mesh, { ...options, format })
+          const report = applyPrintFeatureThickness(
+            prepared.report,
+            {
+              features: [{ nodeId: lowestLevel.id, thicknessMm }],
+              unmeasuredNodeIds: [],
+            },
+            options.minimumFeatureMm,
+          )
+          const filename = format === 'stl' ? '00_plinth.stl' : null
+          const objectName = '00 Plinth'
+          plinthArtifact = {
+            filename,
+            objectName,
+            bytes:
+              format === 'stl'
+                ? new Uint8Array(encodePreparedPrintSceneToStl(prepared.scene))
+                : null,
+            mesh:
+              format === '3mf' &&
+              prepared.report.bounds &&
+              prepared.report.invalidTriangleCount === 0
+                ? extractPreparedPrintMesh(prepared.scene)
+                : null,
+            bounds: report.bounds,
+          }
+          plinthPart = {
+            kind: 'plinth',
+            levelId: lowestLevel.id,
+            label: 'Plinth',
+            objectName,
+            filename,
+            sourceBaseMeters: null,
+            report,
+          }
+          diagnostics.push(...report.diagnostics.filter(isPrintFeatureThicknessDiagnostic))
+          diagnostics.push({
+            severity: 'info',
+            code: 'rectangular_plinth_experimental',
+            message:
+              'The plinth is a separate rectangular part derived from the lowest level bounds; footprint shaping and connectors are not implemented yet.',
+          })
+        } finally {
+          disposeObject3DResources(mesh)
+        }
+      }
+    }
+  }
+
+  diagnostics.push({
+    severity: 'info',
+    code: 'level_parts_experimental',
+    message: options.compileShells
+      ? options.compileShell
+        ? 'Level parts use stored level bases and worker-backed Manifold semantic shell compilation; known wall, slab, roof, and plinth dimensions are measured, while mesh-observed thin features and self-intersections remain pending.'
+        : 'Level parts use stored level bases and the experimental synchronous semantic shell compiler; known wall, slab, roof, and plinth dimensions are measured, while worker execution, mesh-observed thin features, and self-intersections remain pending.'
+      : 'Level parts use stored level bases and semantic separation but are not boolean-unioned printable shells yet.',
+  })
+
+  const files: Zippable = {}
+  const parts: PrintLevelPartReport[] = []
+  const packageParts: Print3mfPart[] = []
+  if (plinthArtifact && plinthPart) {
+    if (plinthArtifact.filename && plinthArtifact.bytes) {
+      files[plinthArtifact.filename] = [plinthArtifact.bytes, { level: 0, mtime: ZIP_MTIME }]
+    }
+    if (plinthArtifact.mesh && plinthArtifact.bounds) {
+      packageParts.push({
+        name: plinthArtifact.objectName,
+        mesh: plinthArtifact.mesh,
+        bounds: plinthArtifact.bounds,
+      })
+    }
+    parts.push(plinthPart)
+  }
+  for (const [index, artifact] of levelArtifacts.entries()) {
+    if (artifact.filename && artifact.bytes) {
+      files[artifact.filename] = [artifact.bytes, { level: 0, mtime: ZIP_MTIME }]
+    }
+    if (artifact.mesh && artifact.bounds) {
+      packageParts.push({
+        name: artifact.objectName,
+        mesh: artifact.mesh,
+        bounds: artifact.bounds,
+      })
+    }
+    const part = levelParts[index]
+    if (part) parts.push(part)
+  }
+
+  return {
+    data:
+      format === '3mf'
+        ? createPrint3mf(packageParts, 'Pascal level parts')
+        : zipSync(files, { level: 0 }),
+    report: {
+      kind: 'print-level-export-report',
+      version: 2,
+      format,
+      scale: options.scale,
+      units: 'millimeter',
+      orientation: 'z-up',
+      status: bundleStatus(diagnostics, parts),
+      partCount: parts.length,
+      parts,
+      excludedNodeIds: Array.from(excludedIds).sort(),
+      diagnostics,
+    },
+  }
+}
+
+export function isPrintLevelBundleReport(value: unknown): value is PrintLevelBundleReport {
+  if (!value || typeof value !== 'object') return false
+  const report = value as Partial<PrintLevelBundleReport>
+  return report.kind === 'print-level-export-report' && report.version === 2
+}

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 }
+}