@pascal-app/editor 1.0.6 → 1.1.0

package/src/lib/floorplan/site-plan/site-parts.ts

@@ -10,7 +10,9 @@ import {
   type AnyNode,
   type AnyNodeId,
   type BuildingNode,
+  floorPlateRoom,
   getRoofSegmentDeckReach,
+  isOutdoorRoomType,
   type LevelNode,
   migrateSiteMetadata,
   type RoofSegmentNode,
@@ -201,7 +203,7 @@ function coveredShare(ring: readonly Pt[], covers: readonly Pt[][]): number {
 
 /**
  * The level's outdoor slabs in site metres: porches, decks, patios and
- * landings (a generator `metadata.porch`, or a deck / porch-slab floor, or a
+ * landings (a generator `metadata.porch`, an outdoor room’s plate, or a
  * slab lying outside the house's walls) and the flatwork. The house's own
  * floors (the storey slab, a raised platform, the garage pad) and a porch
  * cover's beam are not outdoor parts. `roofs` decides which are covered.
@@ -247,7 +249,8 @@ export function outdoorParts(
     // a porch cover's beam box is not a floor
     if (/beam/i.test(floor) || /beam/i.test(slab.name ?? '')) continue
     const porch = meta.porch as { policy?: string; entrance?: string } | undefined
-    const outdoorFloor = floor === 'deck' || floor === 'porch-slab'
+    const roomType = floorPlateRoom(child, (id) => scene.nodes[id])?.roomType
+    const outdoorFloor = isOutdoorRoomType(roomType)
     if (!porch && !outdoorFloor) {
       // a hand-drawn slab: the house's floor when it lies under the walls
       if (HOUSE_FLOORS.has(floor)) continue
@@ -257,7 +260,7 @@ export function outdoorParts(
       )
       if (walls.length === 0 || walls.some((w) => pointInPolygon(w, c[0], c[1]))) continue
     }
-    const wood = floor === 'deck'
+    const wood = roomType === 'deck'
     const policy = porch?.policy ?? ''
     const kind: OutdoorKind =
       policy === 'deck' || (wood && policy !== 'full' && policy !== 'entry')

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

@@ -0,0 +1,114 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type ArtifactStore,
+  artifactUrl,
+  BuildingNode,
+  GeometryArtifactManifest,
+  generateId,
+  ItemNode,
+  LevelNode,
+  scriptSource,
+} from '@pascal-app/core'
+import {
+  captureRegistryVersions,
+  effectIds,
+  openDetachedScene,
+  SceneEnvironmentDisposedError,
+  type SceneSnapshot,
+} from '@pascal-app/core/runtime'
+import { compileAndStoreGeometryScript } from './author'
+
+// A compile of an object for a detached scene reads the scene and mints the object's id before
+// its first await: the scene records those reads and allocates that id in its synchronous scope,
+// and a compile that resolves after the scene is disposed reaches nothing of it.
+
+const sha = 'a'.repeat(64)
+const compiled = {
+  sha256: sha,
+  script: 'b'.repeat(64),
+  language: 'three' as const,
+  mount: 'floor' as const,
+  params: {},
+  manifest: GeometryArtifactManifest.parse({
+    bounds: { min: [-0.5, 0, -0.5], max: [0.5, 1, 0.5] },
+    triangles: 12,
+  }),
+}
+
+function scene() {
+  const screen = ItemNode.parse({
+    id: 'item_screen',
+    parentId: 'level_0',
+    name: 'Screen',
+    source: scriptSource(compiled),
+    asset: {
+      id: 'script_screen',
+      category: 'screen',
+      name: 'Screen',
+      thumbnail: '',
+      source: 'mine',
+      src: artifactUrl(sha),
+      dimensions: [1, 1, 1],
+    },
+  })
+  const level = LevelNode.parse({ id: 'level_0', parentId: 'building_0', children: [screen.id] })
+  const building = BuildingNode.parse({ id: 'building_0', children: [level.id] })
+  const snapshot = {
+    nodes: Object.fromEntries([building, level, screen].map((node) => [node.id, node])),
+    rootNodeIds: [building.id],
+    collections: {},
+    materials: {},
+    installedPlugins: [],
+  } as unknown as SceneSnapshot
+  return openDetachedScene(snapshot, {
+    base: { kind: 'authority', seq: 1 },
+    context: {
+      activeLevelId: 'level_0',
+      selection: [],
+      units: 'metric',
+      catalogVersion: 'test',
+      registryVersions: captureRegistryVersions(),
+    },
+    ids: effectIds('effect_compile'),
+  })
+}
+
+const artifacts = {
+  url: () => null,
+  put: async (hash: string) => hash,
+  text: async () => 'export default function build() {}',
+} as unknown as ArtifactStore
+
+describe('compileAndStoreGeometryScript on a detached scene', () => {
+  test('reads the node it rebuilds before the first await', async () => {
+    const detached = scene()
+    const compiling = detached.run(() =>
+      compileAndStoreGeometryScript(
+        { nodeId: 'item_screen', params: {} },
+        { nodes: detached.reader().nodes as Record<string, AnyNode>, artifacts },
+      ),
+    )
+    expect(detached.dependencies()).toContainEqual(
+      expect.objectContaining({ kind: 'node', id: 'item_screen' }),
+    )
+    detached.dispose()
+    const error = await compiling.catch((thrown: unknown) => thrown)
+    expect(error).not.toBeInstanceOf(SceneEnvironmentDisposedError)
+  })
+
+  test("mints a new object's id in the scene's scope, before the first await", async () => {
+    const detached = scene()
+    const next = detached.run(() => {
+      void compileAndStoreGeometryScript(
+        { code: 'export default function build() {}', kind: 'item' },
+        { nodes: detached.reader().nodes as Record<string, AnyNode>, artifacts },
+      ).catch(() => {})
+      return generateId('item')
+    })
+    const ids = effectIds('effect_compile')
+    ids('item')
+    expect(next as string).toBe(ids('item'))
+    detached.dispose()
+  })
+})

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

@@ -1,5 +1,7 @@
 import {
+  type AnyNode,
   type AnyNodeId,
+  type ArtifactStore,
   type CompiledGeometryScript,
   GEOMETRY_SCRIPT_MIME_TYPES,
   GeometryArtifactMetadata,
@@ -41,28 +43,46 @@ export function configureBlenderScriptBuilder(next: BlenderScriptBuilder | null)
   blenderBuilder = next
 }
 
+/**
+ * What a compile reads from the scene and the artifact service it stores to. By default the
+ * editor's own; a detached scene passes its tracked nodes, so the reads are recorded there.
+ */
+export type GeometryScriptScene = {
+  nodes?: Readonly<Record<string, AnyNode>>
+  artifacts?: ArtifactStore
+}
+
 /**
  * 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.
+ *
+ * Everything it reads from the scene, and the id of a new object, are taken
+ * synchronously, before the first await: a detached scene records reads and
+ * mints ids only inside its synchronous scope, and is disposed by the time a
+ * late compile resolves.
  */
-export async function compileAndStoreGeometryScript(input: {
-  code?: string
-  language?: GeometryScriptLanguage
-  nodeId?: string
-  params?: Record<string, GeometryScriptParamValue>
-  kind?: 'item' | 'door' | 'window' | 'column'
-  inputs?: Record<string, unknown>
-  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
+export async function compileAndStoreGeometryScript(
+  input: {
+    code?: string
+    language?: GeometryScriptLanguage
+    nodeId?: string
+    params?: Record<string, GeometryScriptParamValue>
+    kind?: 'item' | 'door' | 'window' | 'column'
+    inputs?: Record<string, unknown>
+    name?: string
+    description?: string
+    category?: string
+    tags?: string[]
+    provenance?: GeometryArtifactMetadata
+  },
+  scene: GeometryScriptScene = {},
+): Promise<CompiledGeometryScript> {
+  const nodes = scene.nodes ?? useScene.getState().nodes
+  const artifacts = scene.artifacts ?? getArtifactStore()
+  const node = input.nodeId ? nodes[input.nodeId as AnyNodeId] : undefined
   const language = editedScriptLanguage(node, input)
   const params = editedScriptParams(node, input.params)
   const kind =
@@ -71,12 +91,16 @@ export async function compileAndStoreGeometryScript(input: {
       ? node.type
       : 'item')
   const nodeId = input.nodeId ?? generateId(kind)
+  const authored = isScriptedNode(node) ? scriptedObjectMeta(node) : {}
+  const script = input.code === undefined ? authoredScript(nodes, input.nodeId) : null
   const metadata = GeometryArtifactMetadata.parse({
-    ...(isScriptedNode(node) ? scriptedObjectMeta(node) : {}),
+    ...authored,
     ...input.provenance,
     ...GeometryReuseFields.parse(input),
     kind,
   })
+
+  const code = input.code ?? (await readScript(artifacts, script!, input.nodeId!))
   if (language === 'bpy') {
     if (!blenderBuilder) throw new Error('This editor cannot run Blender (bpy) scripts')
     return { ...(await blenderBuilder({ code, params, nodeId, metadata })), nodeId }
@@ -87,10 +111,9 @@ export async function compileAndStoreGeometryScript(input: {
     inputs: input.inputs,
   })
   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(
+    artifacts.put(compiled.sha256, glb, 'model/gltf-binary', context),
+    artifacts.put(
       compiled.script,
       new TextEncoder().encode(code),
       GEOMETRY_SCRIPT_MIME_TYPES.three,
@@ -100,15 +123,24 @@ export async function compileAndStoreGeometryScript(input: {
   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> {
+/** The hash of an authored object's script, read from the scene. */
+function authoredScript(nodes: Readonly<Record<string, AnyNode>>, nodeId: string | undefined) {
   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)
+  return authoredObject(nodes as Record<string, AnyNode>, nodeId).source.script
+}
+
+async function readScript(artifacts: ArtifactStore, script: string, nodeId: string) {
+  const code = await artifacts.text(script)
   if (code === null) throw new Error(`The script of ${nodeId} could not be read`)
   return code
 }
 
+/** The module text of an authored object, read back from the artifact store. */
+export async function storedScript(nodeId: string | undefined): Promise<string> {
+  const script = authoredScript(useScene.getState().nodes, nodeId)
+  return readScript(getArtifactStore(), script, nodeId!)
+}
+
 const rebuildGeneration = new Map<string, number>()
 
 /**

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

@@ -1,4 +1,5 @@
 import type { GeometryScriptParamValue } from '@pascal-app/core'
+import { sdfChecksOn } from '@pascal-app/core/usage-field'
 import type { GeometryScriptCompileOutput } from '@pascal-app/geometry-script'
 import type { GeometryScriptWorkerRequest, GeometryScriptWorkerResponse } from './protocol'
 
@@ -148,6 +149,8 @@ export async function compileGeometryScriptInWorker(input: {
     code: input.code,
     params: input.params,
     inputs: input.inputs,
+    // the sandbox is its own context: the flag travels with the request, only when it is on
+    ...(sdfChecksOn() ? { usageShape: true } : {}),
   }
   return new Promise((resolve, reject) => {
     const timeout = setTimeout(() => {

package/src/lib/geometry-script/finish-scripts.ts

@@ -17,9 +17,9 @@ import {
 import { compileGeometryScriptInWorker } from './client'
 
 /**
- * Runs a finish script (a room's floor, a wall's face) in the sandbox for what it finishes and
- * stores the GLB and the module text, answering the compile with the stored hashes
- * (`setRoomFloorScript` and `setWallFaceScript` take it with its `inputs`).
+ * Runs a finish script (a room's floor, a slab's surface, a wall's face) in the sandbox for what it
+ * finishes and stores the GLB and the module text, answering the compile with the stored hashes
+ * (`setRoomFloorScript`, `setSlabSurfaceScript` and `setWallFaceScript` take it with its `inputs`).
  */
 export async function compileAndStoreFinishScript(
   input: FinishScriptTarget & {
@@ -65,10 +65,10 @@ const SETTLE_MS = 150
 
 /**
  * Keeps every finish script built for what it finishes: after a scene change settles, each script
- * whose room's floor the structure re-derived, or whose wall face changed, runs again in the
- * sandbox. The new build is written outside history, as the reconcile's derived writes are, and
- * only while its floor or face is still the one it was built for; undo brings back the room or
- * wall and the script built for it together.
+ * whose room's floor the structure re-derived, whose slab was reshaped, or whose wall face changed,
+ * runs again in the sandbox. The new build is written outside history, as the reconcile's derived
+ * writes are, and only while its floor or face is still the one it was built for; undo brings back
+ * the room, slab or wall and the script built for it together.
  */
 export function initFinishScriptRefresh(): () => void {
   let timer: ReturnType<typeof setTimeout> | null = null

package/src/lib/gesture-lifecycle.ts

@@ -33,7 +33,9 @@ export type GestureSpec = {
   kind: string
   /**
    * Drops the gesture's own in-flight state (draft, preview, listeners,
-   * pending frames). Never writes the scene. Runs once, on cancel only.
+   * pending frames). Runs once, on cancel only. Undo and redo cancel before
+   * they jump, so this must record no history: a gesture that previews
+   * through scene writes under paused history reverts them here, then resumes.
    */
   onCancel: (reason: GestureCancelReason) => void
   /** A scope the owner begins for the gesture and releases only while it is still this one. */