@pascal-app/editor 1.0.1 → 1.0.4

package/src/lib/fresh-planar-placement.ts

@@ -1,16 +1,29 @@
 import {
   type AnyNode,
   type AnyNodeId,
+  beginSceneHistoryPauseSession,
+  type CloneNodesIntoResult,
   cloneNodesInto,
+  collectionIdsOf,
   collectSubtree,
+  createSceneApi,
   type DuplicableConfig,
+  getSceneHistoryPauseDepth,
+  getSurfaceProvider,
   nodeRegistry,
+  resolveSurfacePlacement,
+  runSceneHistoryDraftWrite,
+  type SurfaceRejectReason,
   useScene,
 } from '@pascal-app/core'
+import { evaluateRecipe, isProceduralItem } from '@pascal-app/core/procedural-items'
+import useInteractionScope from '../store/use-interaction-scope'
+import usePlacementPreview from '../store/use-placement-preview'
 import { getPlacementMetadataRecord, stripPlacementMetadataFlags } from './placement-metadata'
 import {
   surfaceAttachmentId,
   surfaceAttachmentUpdates,
+  surfaceFramePose,
   updateSurfaceNode,
 } from './surface-attachment'
 
@@ -26,13 +39,33 @@ function parentIdOf(node: AnyNode): AnyNodeId | undefined {
   return parentId ?? undefined
 }
 
+/**
+ * Create ops for a clone of scene nodes: each copy joins the collections its
+ * source is in, whatever its kind.
+ */
+export function copyCreateOps(cloned: CloneNodesIntoResult, parentId: AnyNodeId | undefined) {
+  const collections = useScene.getState().collections
+  const sourceIds = new Map([...cloned.idMap].map(([source, copy]) => [copy, source]))
+  return cloned.nodes.map((node, index) => ({
+    node,
+    ...(index === 0 && parentId ? { parentId } : {}),
+    collectionIds: collectionIdsOf(collections, sourceIds.get(node.id as AnyNodeId)!),
+  }))
+}
+
 function duplicableConfigFor(node: AnyNode): DuplicableConfig | null {
   const duplicable = nodeRegistry.get(node.type)?.capabilities?.duplicable
   return duplicable && typeof duplicable === 'object' ? duplicable : null
 }
 
 export function duplicatesAsFreshSubtree(node: AnyNode): boolean {
-  return duplicableConfigFor(node)?.subtree === true
+  // A surface-local root needs the same attachment lifecycle even without descendants.
+  if (surfaceAttachmentId(node) !== null) return true
+  const policy = duplicableConfigFor(node)?.subtree
+  return (
+    policy === true ||
+    (policy === 'with-children' && 'children' in node && node.children.length > 0)
+  )
 }
 
 /**
@@ -99,57 +132,179 @@ export function createFreshPlacementSubtree(
     parentId,
   })
 
-  useScene
-    .getState()
-    .createNodes(
-      cloned.nodes.map((node, index) => (index === 0 && parentId ? { node, parentId } : { node })),
-    )
+  scene.applyNodeChanges({
+    create: copyCreateOps(cloned, parentId),
+    update: surfaceAttachmentUpdates(cloned.rootId, parentId, surfaceAttachmentId(subtree.root)),
+  })
 
+  const created = useScene.getState().nodes[cloned.rootId]
+  if (!created) return null
+  useInteractionScope.getState().noteSubtreeCreation(created)
   return cloned.rootId
 }
 
+export function discardFreshPlacementSubtree(rootId: AnyNodeId): void {
+  const scene = useScene.getState()
+  if (!scene.nodes[rootId]) return
+  scene.applyNodeChanges({
+    delete: [rootId],
+    update: surfaceAttachmentUpdates(rootId, null, null),
+  })
+}
+
+function namedSurfaceRejection(
+  root: AnyNode,
+  surfaceId: string | null,
+): SurfaceRejectReason | null {
+  if (surfaceId === null) return null
+  const scene = createSceneApi(useScene)
+  const host = root.parentId ? scene.get(root.parentId as AnyNodeId) : undefined
+  if (!host || !('position' in root) || !Array.isArray(root.rotation)) return 'no-surface'
+  const surface = getSurfaceProvider(host)
+    .surfaces?.(host, { scene })
+    .find((s) => s.id === surfaceId)
+  if (!surface) return 'no-surface'
+  const pose = surfaceFramePose(
+    root.parentId,
+    surfaceId,
+    root as {
+      position: [number, number, number]
+      rotation: [number, number, number]
+    },
+    false,
+  )
+  const capabilities = nodeRegistry.get(root.type)?.capabilities
+  const evaluated = isProceduralItem(root) ? evaluateRecipe(root.recipe, root.parameters) : null
+  const bounds =
+    capabilities?.dragBounds?.(root, scene.nodes()) ??
+    (evaluated
+      ? {
+          size: evaluated.dimensions,
+          center: evaluated.min.map((v, i) => (v + evaluated.max[i]!) / 2) as [
+            number,
+            number,
+            number,
+          ],
+        }
+      : undefined)
+  const size = bounds?.size ??
+    capabilities?.floorPlaced?.footprint?.(root, { nodes: scene.nodes() }).dimensions ?? [0, 0, 0]
+  const center = bounds?.center
+  const localBounds = center
+    ? {
+        min: center.map((value, axis) => value - size[axis]! / 2) as [number, number, number],
+        max: center.map((value, axis) => value + size[axis]! / 2) as [number, number, number],
+      }
+    : undefined
+  let reason: SurfaceRejectReason | null = null
+  const placement = resolveSurfacePlacement({
+    host,
+    surface,
+    childKind: root.type,
+    childId: root.id,
+    childFootprint: {
+      size,
+      rotationY: pose.rotation[1],
+      rotation: pose.rotation,
+      localBounds,
+    },
+    hit: { point: pose.position, normalWorldY: 1 },
+    origin: pose.position,
+    scene,
+    onReject: (value) => {
+      reason = value
+    },
+  })
+  if (!placement) return reason ?? 'no-surface'
+  return null
+}
+
+/**
+ * Runs a placement's one committing write as a history step. The moving node's gesture
+ * sessions (the 2D move overlay's) are lifted for it; any other owner's pause still holds, so
+ * the write then records nothing. A legacy caller's raw `temporal.pause()` is kept afterwards.
+ */
+function recordPlacementStep(rootId: AnyNodeId, wasTracking: boolean, write: () => void): void {
+  const step = beginSceneHistoryPauseSession(useScene, { gesture: rootId })
+  try {
+    step.commitStep(write)
+  } finally {
+    step.end()
+    if (!wasTracking && getSceneHistoryPauseDepth() === 0) useScene.temporal.getState().pause()
+  }
+}
+
 /**
- * Finalises a fresh catalog/duplicate draft as a single undoable creation.
- *
- * Fresh drafts already exist in the scene so renderers and move tools can
- * preview real geometry. On commit we delete that draft while history is
- * paused, then create a clean clone at the final cursor position with history
- * resumed. Undo therefore removes the placed node instead of resurrecting the
- * hidden draft at its origin.
+ * Replace the draft in one validated write. History already excludes fresh
+ * subtrees, so this records one creation without first deleting the preview.
  */
 export function commitFreshPlacementSubtree(
   rootId: AnyNodeId,
   rootPatch: Partial<AnyNode>,
+  onReject?: (reason: SurfaceRejectReason) => void,
 ): AnyNodeId | null {
   const scene = useScene.getState()
   const subtree = collectSubtree(scene.nodes, rootId)
-  if (!subtree) return null
+  if (!subtree || scene.readOnly) return null
 
-  const root = cleanPlacementMetadata({
-    ...subtree.root,
-    ...rootPatch,
-  } as AnyNode)
+  const root = cleanPlacementMetadata({ ...subtree.root, ...rootPatch } as AnyNode)
+  const surfaceId =
+    root.parentId === subtree.root.parentId ? surfaceAttachmentId(subtree.root) : null
+  const rejection = namedSurfaceRejection(root, surfaceId)
+  if (rejection) {
+    onReject?.(rejection)
+    return null
+  }
   const descendants = subtree.descendants.map((node) => cleanPlacementMetadata(node))
   const parentId = parentIdOf(root)
-  const cloned = cloneNodesInto([root, ...descendants], {
-    rootId,
-    parentId,
-  })
+  const cloned = cloneNodesInto([root, ...descendants], { rootId, parentId })
+  // The drafts' memberships, read before they are deleted.
+  const create = copyCreateOps(cloned, parentId)
+  const updates = surfaceAttachmentUpdates(rootId, null, null)
+  for (const update of surfaceAttachmentUpdates(cloned.rootId, parentId, surfaceId)) {
+    const attachments = { ...(update.data as { attachments: Record<string, string> }).attachments }
+    delete attachments[rootId]
+    const previous = updates.findIndex((entry) => entry.id === update.id)
+    const merged = { id: update.id, data: { attachments } }
+    if (previous === -1) updates.push(merged)
+    else updates[previous] = merged
+  }
 
-  const surfaceId = surfaceAttachmentId(subtree.root)
+  const scope = useInteractionScope.getState()
+  const factoryCreated =
+    scope.ownedSubtree?.creation.rootId === rootId || scope.pendingSubtree?.rootId === rootId
   const temporal = useScene.temporal.getState()
-  const wasTracking = (temporal as { isTracking?: boolean }).isTracking !== false
-  if (wasTracking) temporal.pause()
-  updateSurfaceNode(rootId, {}, null)
-  useScene.getState().deleteNode(rootId)
-  temporal.resume()
-  useScene.getState().applyNodeChanges({
-    create: cloned.nodes.map((node, index) =>
-      index === 0 && parentId ? { node, parentId } : { node },
-    ),
-    update: surfaceAttachmentUpdates(cloned.rootId, parentId, surfaceId),
-  })
-  if (!wasTracking) temporal.pause()
-
+  const wasTracking = temporal.isTracking
+  if (!factoryCreated && descendants.length === 0 && surfaceId === null) {
+    // Preserve the established root-only lifecycle for placements outside the subtree factory.
+    runSceneHistoryDraftWrite(() => {
+      updateSurfaceNode(rootId, {}, null)
+      useScene.getState().deleteNode(rootId)
+    })
+    recordPlacementStep(rootId, wasTracking, () =>
+      useScene.getState().applyNodeChanges({ create, update: updates }),
+    )
+  } else {
+    recordPlacementStep(rootId, wasTracking, () => {
+      try {
+        // applyNodeChanges validates the complete proposed graph before publishing any part of it.
+        scene.applyNodeChanges({ delete: [rootId], create, update: updates })
+        for (const node of [subtree.root, ...subtree.descendants]) scene.clearDirty(node.id)
+      } catch (error) {
+        // Zustand publishes before notifying subscribers. A subscriber error must restore
+        // the draft and its ownership/history, never masquerade as a placement refusal.
+        useScene.temporal.getState().pause()
+        try {
+          if (useScene.getState() !== scene) useScene.setState(scene, true)
+        } finally {
+          useInteractionScope.setState(scope)
+          useScene.temporal.setState(temporal)
+        }
+        throw error
+      }
+    })
+  }
+  useInteractionScope.getState().finishSubtree(rootId)
+  if (usePlacementPreview.getState().node?.id === rootId) usePlacementPreview.getState().clear()
   return cloned.rootId
 }

package/src/lib/geometry-script/author.ts

@@ -0,0 +1,152 @@
+import {
+  type AnyNodeId,
+  type CompiledGeometryScript,
+  GEOMETRY_SCRIPT_MIME_TYPES,
+  GeometryArtifactMetadata,
+  GeometryReuseFields,
+  type GeometryScriptLanguage,
+  type GeometryScriptParamValue,
+  generateId,
+  getArtifactStore,
+  isScriptedNode,
+  runAsSingleSceneHistoryStep,
+  scriptedObjectMeta,
+  useScene,
+} from '@pascal-app/core'
+import {
+  addColumn,
+  addObject,
+  authoredObject,
+  editedScriptLanguage,
+  editedScriptParams,
+  rescriptOpening,
+} from '@pascal-app/core/agent-operations'
+import { compileGeometryScriptInWorker } from './client'
+
+/**
+ * Builds a bpy module and stores its GLB and text, returning their hashes.
+ * Blender runs outside the browser, so the host provides this (the hosted app
+ * calls its Blender service); without one, bpy scripts are refused.
+ */
+export type BlenderScriptBuilder = (input: {
+  code: string
+  params?: Record<string, GeometryScriptParamValue>
+  nodeId: string
+  metadata: GeometryArtifactMetadata
+}) => Promise<CompiledGeometryScript>
+
+let blenderBuilder: BlenderScriptBuilder | null = null
+
+export function configureBlenderScriptBuilder(next: BlenderScriptBuilder | null): void {
+  blenderBuilder = next
+}
+
+/**
+ * The editor's compile step for `add_object`: runs the module (a three.js one
+ * in the worker, a bpy one through the host's Blender builder) and stores the
+ * GLB and the module text, so the core operation can reference both by hash.
+ * Without `code`, the node's stored script is rebuilt; either way an edit keeps
+ * the node's param values it does not override.
+ */
+export async function compileAndStoreGeometryScript(input: {
+  code?: string
+  language?: GeometryScriptLanguage
+  nodeId?: string
+  params?: Record<string, GeometryScriptParamValue>
+  kind?: 'item' | 'door' | 'window' | 'column'
+  name?: string
+  description?: string
+  category?: string
+  tags?: string[]
+  provenance?: GeometryArtifactMetadata
+}): Promise<CompiledGeometryScript> {
+  const code = input.code ?? (await storedScript(input.nodeId))
+  const node = input.nodeId ? useScene.getState().nodes[input.nodeId as AnyNodeId] : undefined
+  const language = editedScriptLanguage(node, input)
+  const params = editedScriptParams(node, input.params)
+  const kind =
+    input.kind ??
+    (node?.type === 'door' || node?.type === 'window' || node?.type === 'column'
+      ? node.type
+      : 'item')
+  const nodeId = input.nodeId ?? generateId(kind)
+  const metadata = GeometryArtifactMetadata.parse({
+    ...(isScriptedNode(node) ? scriptedObjectMeta(node) : {}),
+    ...input.provenance,
+    ...GeometryReuseFields.parse(input),
+    kind,
+  })
+  if (language === 'bpy') {
+    if (!blenderBuilder) throw new Error('This editor cannot run Blender (bpy) scripts')
+    return { ...(await blenderBuilder({ code, params, nodeId, metadata })), nodeId }
+  }
+  const { glb, ...compiled } = await compileGeometryScriptInWorker({ code, params })
+  const context = { nodeId, metadata: { ...metadata, mount: compiled.mount } }
+  const store = getArtifactStore()
+  const [sha256] = await Promise.all([
+    store.put(compiled.sha256, glb, 'model/gltf-binary', context),
+    store.put(
+      compiled.script,
+      new TextEncoder().encode(code),
+      GEOMETRY_SCRIPT_MIME_TYPES.three,
+      context,
+    ),
+  ])
+  return { ...compiled, sha256, nodeId }
+}
+
+/** The module text of an authored object, read back from the artifact store. */
+export async function storedScript(nodeId: string | undefined): Promise<string> {
+  if (!nodeId) throw new Error('Pass the code to build a new object')
+  const node = authoredObject(useScene.getState().nodes, nodeId)
+  const code = await getArtifactStore().text(node.source.script)
+  if (code === null) throw new Error(`The script of ${nodeId} could not be read`)
+  return code
+}
+
+const rebuildGeneration = new Map<string, number>()
+
+/**
+ * Re-runs a scripted node's script with new param values, the inspector's
+ * and resize handles' path: same code, new artifact, one undo step. A slower earlier rebuild of
+ * the same node never overwrites a newer one.
+ */
+export async function rebuildAuthoredObject(
+  nodeId: string,
+  params: Record<string, GeometryScriptParamValue>,
+  /** Where it ends up, when a resize also moves it (a side arrow keeps the opposite edge). */
+  position?: [number, number, number],
+): Promise<void> {
+  const generation = (rebuildGeneration.get(nodeId) ?? 0) + 1
+  rebuildGeneration.set(nodeId, generation)
+  const compiled = await compileAndStoreGeometryScript({ nodeId, params })
+  if (rebuildGeneration.get(nodeId) !== generation) return
+  const changes = rebuildChanges(nodeId, compiled, params, position)
+  runAsSingleSceneHistoryStep(useScene, () => {
+    for (const { id, data } of changes?.update ?? []) {
+      useScene.getState().updateNode(id as AnyNodeId, data)
+    }
+  })
+}
+
+/** What a rebuild changes, through the operation of the node's kind. */
+function rebuildChanges(
+  nodeId: string,
+  compiled: CompiledGeometryScript,
+  params: Record<string, GeometryScriptParamValue>,
+  position: [number, number, number] | undefined,
+) {
+  const nodes = useScene.getState().nodes
+  const context = { activeLevelId: null }
+  switch (nodes[nodeId as AnyNodeId]?.type) {
+    case 'column': {
+      const at = position && { x: position[0], y: position[1], z: position[2] }
+      return addColumn(nodes, { nodeId, compiled, ...at }, context).changes
+    }
+    case 'window':
+    case 'door':
+      return rescriptOpening(nodes, { nodeId, compiled, position }, context).changes
+    default:
+      return addObject(nodes, { params, nodeId, compiled, position }, context).changes
+  }
+}

package/src/lib/geometry-script/client.ts

@@ -0,0 +1,152 @@
+import type { GeometryScriptParamValue } from '@pascal-app/core'
+import type { GeometryScriptCompileOutput } from '@pascal-app/geometry-script'
+import type { GeometryScriptWorkerRequest, GeometryScriptWorkerResponse } from './protocol'
+
+const COMPILE_TIMEOUT_MS = 20_000
+const START_TIMEOUT_MS = 15_000
+
+// Model-written code runs in a worker inside a sandboxed frame: an opaque
+// origin (no cookies, storage or access to the editor) whose CSP allows only
+// its own scripts and blob workers, so the code cannot reach the network,
+// load fonts or images, or open frames. The worker inherits that policy.
+const FRAME_CSP =
+  "default-src 'none'; script-src 'unsafe-inline' 'unsafe-eval' blob:; worker-src blob:"
+const FRAME_HTML = `<!doctype html><meta http-equiv="Content-Security-Policy" content="${FRAME_CSP}"><script>
+let worker
+addEventListener('message', (event) => {
+  if (event.source !== parent) return
+  const data = event.data
+  if (data && data.type === 'start') {
+    worker = new Worker(URL.createObjectURL(new Blob([data.source], { type: 'text/javascript' })))
+    worker.onmessage = (e) => parent.postMessage(e.data, '*', e.data && e.data.output ? [e.data.output.glb] : [])
+    worker.onerror = (e) => parent.postMessage({ crashed: e.message || 'The compile worker crashed' }, '*')
+    return
+  }
+  if (worker) worker.postMessage(data)
+})
+parent.postMessage({ frame: true }, '*')
+</script>`
+
+type Pending = {
+  code: string
+  resolve: (output: GeometryScriptCompileOutput) => void
+  reject: (error: Error) => void
+  timeout: ReturnType<typeof setTimeout>
+}
+
+type FrameMessage =
+  | { frame: true }
+  | { ready: true }
+  | { crashed: string }
+  | GeometryScriptWorkerResponse
+
+let frame: HTMLIFrameElement | null = null
+let started: Promise<Window> | null = null
+let nextId = 1
+const pending = new Map<number, Pending>()
+let onFrameMessage: ((message: FrameMessage) => void) | null = null
+
+function reset(error: Error) {
+  frame?.remove()
+  frame = null
+  started = null
+  for (const entry of pending.values()) {
+    clearTimeout(entry.timeout)
+    entry.reject(error)
+  }
+  pending.clear()
+}
+
+if (typeof window !== 'undefined') {
+  window.addEventListener('message', (event: MessageEvent<FrameMessage>) => {
+    if (!frame || event.source !== frame.contentWindow) return
+    const message = event.data
+    if ('crashed' in message) return reset(new Error(message.crashed))
+    if ('id' in message) {
+      const entry = pending.get(message.id)
+      if (!entry) return
+      pending.delete(message.id)
+      clearTimeout(entry.timeout)
+      if (message.ok) withOwnHashes(message.output, entry.code).then(entry.resolve, entry.reject)
+      else entry.reject(new Error(message.error))
+      return
+    }
+    onFrameMessage?.(message)
+  })
+}
+
+async function sha256(bytes: ArrayBuffer | Uint8Array): Promise<string> {
+  const hash = await crypto.subtle.digest('SHA-256', bytes as BufferSource)
+  return Array.from(new Uint8Array(hash), (b) => b.toString(16).padStart(2, '0')).join('')
+}
+
+/** The artifact and script hashes and the language, set here: nothing the sandboxed code reports about itself is trusted. */
+async function withOwnHashes(
+  output: GeometryScriptCompileOutput,
+  code: string,
+): Promise<GeometryScriptCompileOutput> {
+  const [artifact, script] = await Promise.all([
+    sha256(output.glb),
+    sha256(new TextEncoder().encode(code)),
+  ])
+  return { ...output, sha256: artifact, script, language: 'three' }
+}
+
+/** Starts the sandbox frame and its compile worker once; a crash or timeout starts a fresh one. */
+function startSandbox(): Promise<Window> {
+  if (started) return started
+  started = (async () => {
+    if (typeof document === 'undefined') throw new Error('Geometry scripts compile in a browser')
+    const { sandboxWorkerSource } = await import('@pascal-app/geometry-script/sandbox')
+    const iframe = document.createElement('iframe')
+    iframe.sandbox.add('allow-scripts')
+    iframe.setAttribute('aria-hidden', 'true')
+    iframe.tabIndex = -1
+    iframe.style.display = 'none'
+    iframe.srcdoc = FRAME_HTML
+    frame = iframe
+    const ready = new Promise<Window>((resolve, reject) => {
+      const timer = setTimeout(
+        () => reject(new Error('The script sandbox did not start')),
+        START_TIMEOUT_MS,
+      )
+      onFrameMessage = (message) => {
+        const target = iframe.contentWindow
+        if (!target) return
+        if ('frame' in message)
+          target.postMessage({ type: 'start', source: sandboxWorkerSource }, '*')
+        if ('ready' in message) {
+          clearTimeout(timer)
+          onFrameMessage = null
+          resolve(target)
+        }
+      }
+    })
+    document.body.appendChild(iframe)
+    return ready
+  })()
+  started.catch((error: unknown) =>
+    reset(error instanceof Error ? error : new Error(String(error))),
+  )
+  return started
+}
+
+/**
+ * Runs a geometry script in the sandbox and returns its GLB + manifest. A
+ * script that hangs is stopped with its sandbox; the next compile starts fresh.
+ */
+export async function compileGeometryScriptInWorker(input: {
+  code: string
+  params?: Record<string, GeometryScriptParamValue>
+}): Promise<GeometryScriptCompileOutput> {
+  const target = await startSandbox()
+  const id = nextId++
+  const request: GeometryScriptWorkerRequest = { id, code: input.code, params: input.params }
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reset(new Error(`The script ran longer than ${COMPILE_TIMEOUT_MS / 1000} s and was stopped`))
+    }, COMPILE_TIMEOUT_MS)
+    pending.set(id, { code: input.code, resolve, reject, timeout })
+    target.postMessage(request, '*')
+  })
+}

package/src/lib/geometry-script/protocol.ts

@@ -0,0 +1,12 @@
+import type { GeometryScriptParamValue } from '@pascal-app/core'
+import type { GeometryScriptCompileOutput } from '@pascal-app/geometry-script'
+
+export type GeometryScriptWorkerRequest = {
+  id: number
+  code: string
+  params?: Record<string, GeometryScriptParamValue>
+}
+
+export type GeometryScriptWorkerResponse =
+  | { id: number; ok: true; output: GeometryScriptCompileOutput }
+  | { id: number; ok: false; error: string }