@pascal-app/editor 1.0.3 → 1.0.4

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 }