@womp/spark-agent 4.4.1 → 5.0.1

package/dist/sdk-scene-health-host.js

@@ -1,4 +1,5 @@
-import { getSdkSceneAreaId, getSdkSceneAreaIds, readStableSdkSceneHealth, } from "./scene-health.js";
+import { getSdkSceneAreaId, getSdkSceneAreaIds, readSdkSceneHealth, parseSceneHealth, } from "./scene-health.js";
+import { createGeometryRepairTracker } from "./repair-state.js";
 /**
  * The Area that owns `objectId`, or undefined when the node is in no Area --
  * the scene root 0, a root-level Group, a Light. The engine's thermometer has a
@@ -9,25 +10,74 @@ function owningAreaId(api, objectId) {
     const areaId = getSdkSceneAreaId(api, objectId);
     return api.getNode(Number(areaId)).kind === "union" ? areaId : undefined;
 }
-export function createSdkSceneHealthHost(editor, onHealth) {
+// Health is requested explicitly. Feed its checked Areas back to the same
+// target budgets used by writes, without spending an attempt or settling an
+// operation. A partial reading must not clear a linked target's other Areas.
+async function observeRepairs(api, health, store) {
+    if (health.thermometer === undefined)
+        return;
+    const targets = new Map();
+    const add = (namespace, target, objectId) => {
+        const area = owningAreaId(api, objectId);
+        if (area === undefined)
+            return;
+        const key = `${namespace}:${target}`;
+        const entry = targets.get(key) ?? { namespace, target, areas: new Set() };
+        entry.areas.add(area);
+        targets.set(key, entry);
+    };
+    const unions = api.listNodes({ kind: "union" });
+    const scripts = api.getSceneStorage().scripts;
+    const instances = scripts && typeof scripts === "object" && !Array.isArray(scripts)
+        ? scripts.instances : undefined;
+    for (const node of unions) {
+        if (node.kind !== "union" || node.scriptInstanceId === undefined)
+            continue;
+        const instance = instances && typeof instances === "object" && !Array.isArray(instances)
+            ? instances[node.scriptInstanceId] : undefined;
+        if (instance && typeof instance === "object" && !Array.isArray(instance)
+            && typeof instance.graph_id === "number") {
+            add("geometry", String(instance.graph_id), node.id);
+        }
+    }
+    for (const node of api.listNodes({ kind: "openScad" })) {
+        if (node.kind === "openScad")
+            add("openscad.geometry", `script:${node.scriptId}`, node.id);
+    }
+    const checked = new Set(health.affectedAreaIds);
+    for (const { namespace, target, areas } of targets.values()) {
+        if ([...areas].some((id) => !checked.has(id)))
+            continue;
+        const scoped = parseSceneHealth(health.thermometer, [...areas]);
+        // A zero-count Area does not prove that its output is healthy, even if
+        // another Area in the full thermometer has an overflow flag.
+        if (scoped.emptyAreaIds?.some((id) => areas.has(id)))
+            continue;
+        await createGeometryRepairTracker(store, namespace).observe(target, scoped);
+    }
+}
+export function createSdkSceneHealthHost(editor, onHealth, repairs) {
     return {
         read: (objectIds, context) => editor.read(context, async (api) => {
             const owned = objectIds
                 .map((id) => ({ id, areaId: owningAreaId(api, id) }))
                 .filter((entry) => entry.areaId !== undefined);
-            // `scene.read()` publishes node 0, and ids outside any Area are legal
+            // `scene.access()` publishes node 0, and ids outside any Area are legal
             // arguments. They narrow nothing, so they are reported rather than
             // allowed to make the whole reading unverified; with nothing left to
             // narrow by, this is the whole-scene read `health()` already means.
             const outside = objectIds.filter((id) => owned.some((entry) => entry.id === id) === false);
             const areaIds = owned.length > 0 ? owned.map((entry) => entry.areaId) : getSdkSceneAreaIds(api);
-            const health = await readStableSdkSceneHealth(api, [...new Set(areaIds)], context.signal);
+            const health = await readSdkSceneHealth(api, [...new Set(areaIds)], context.signal);
             const note = outside.length === 0
                 ? undefined
                 : `${outside.join(", ")} ${outside.length === 1 ? "is" : "are"} in no Area, and the engine reports health per Area, so ${owned.length > 0 ? "health is reported for the remaining ids" : "this is the whole scene's health"}.`;
             const reported = note === undefined
                 ? health
                 : { ...health, reason: health.reason === undefined ? note : `${health.reason} ${note}` };
+            context.signal.throwIfAborted();
+            if (repairs)
+                await observeRepairs(api, reported, repairs);
             onHealth?.(reported);
             return reported;
         }),

package/dist/sdk-scene-host.d.ts

@@ -1,4 +1,4 @@
-import type { FontFamily, KakapoAPI, SceneEdit, MaterialResource } from "@womp/kakapo-sdk";
+import type { FontFamily, KakapoAPI, SceneEdit, MaterialResource, NativeSceneSnapshot } from "@womp/kakapo-sdk";
 import type { ArtifactRef, SparkInvocationContext } from "./capabilities.js";
 import type { SceneHost, SceneHealthHost, SceneScreenshotOptions } from "./capabilities/scene.js";
 import { type SceneOperation, type SceneOperationStore } from "./scene-operations.js";
@@ -24,10 +24,10 @@ export type SdkSceneEditorOptions = {
     /** Supply this when the host adds a stricter connection lifetime. */
     context?: SparkInvocationContext) => Promise<T>): Promise<T>;
     assertEditable(context: SparkInvocationContext): void | Promise<void>;
-    /** Acquire after preparation. Cleanup receives false until rollback or host synchronization is confirmed. */
-    prepareCommit?(operation: SceneOperation, context: SparkInvocationContext): Promise<(synchronized: boolean) => void | Promise<void>>;
+    /** Suspend for the complete access, including reads and failed preparation. */
+    acquireAccess?(context: SparkInvocationContext): Promise<(synchronized: boolean) => void | Promise<void>>;
     /** Must adopt each operation ID at most once, including during recovery. */
-    onCommitted?(operation: SceneOperation, api: KakapoAPI, context: SparkInvocationContext, identity: SdkSceneEditIdentity): Promise<Record<string, unknown> | void>;
+    onCommitted?(operation: SceneOperation, api: KakapoAPI, context: SparkInvocationContext, identity: SdkSceneEditIdentity, scene: NativeSceneSnapshot): Promise<Record<string, unknown> | void>;
 };
 export type SdkSceneEditIdentity = {
     capability: string;
@@ -36,8 +36,9 @@ export type SdkSceneEditIdentity = {
 };
 export type SdkSceneEditor = {
     getOperation(operationId: string): Promise<SceneOperation | undefined>;
+    withConnection<T>(context: SparkInvocationContext, action: (api: KakapoAPI, beginSettlement: () => void) => T | Promise<T>): Promise<T>;
     read<T>(context: SparkInvocationContext, action: (api: KakapoAPI, beginSettlement: () => void) => T | Promise<T>): Promise<T>;
-    edit<T>(identity: SdkSceneEditIdentity, callback: (api: KakapoAPI, draft: SceneEdit, operationId: string) => T | Promise<T>, expectedRevision: string, context: SparkInvocationContext, afterCommitted?: (operation: SceneOperation, api: KakapoAPI) => Promise<Record<string, unknown> | void>): Promise<{
+    access<T>(identity: SdkSceneEditIdentity, callback: (api: KakapoAPI, draft: SceneEdit, operationId: string) => T | Promise<T>, context: SparkInvocationContext, afterCommitted?: (operation: SceneOperation, api: KakapoAPI) => Promise<Record<string, unknown> | void>): Promise<{
         value: T;
         operation: SceneOperation;
     }>;
@@ -308,6 +309,20 @@ export declare function createSdkSceneDraft(api: KakapoAPI, scene: SceneEdit, se
         g: number;
         b: number;
     }) => void;
+    unitMultiplier: number;
+    nodes(options?: {
+        ids?: number[];
+        type?: number;
+        parentId?: number;
+        name?: string;
+        offset?: number;
+        limit?: number;
+    }): {
+        id: number;
+        name: string;
+        type: number;
+        parentId: number;
+    }[];
 };
 export declare function createSdkSceneEditor(options: SdkSceneEditorOptions): SdkSceneEditor;
 export declare function createSdkSceneHost(options: SdkSceneEditorOptions & {

package/dist/sdk-scene-host.js

@@ -1,8 +1,15 @@
-import { createWompSceneApi, sceneNodeType } from "./womp-scene-api.js";
-import { sceneUnitMultiplier } from "./coordinates.js";
+import { createWompSceneApi } from "./womp-scene-api.js";
 import { executeSceneOperation, } from "./scene-operations.js";
 import { readMaterialMetadata, writeMaterialMetadata, } from "./scene-metadata.js";
 import { boundedReceiptDetails } from "./scene-health.js";
+function assertSceneSaved(operation) {
+    if (!operation.changed)
+        return;
+    if (operation.save?.status === "failed")
+        throw new Error(`The scene edit was applied, but the save failed: ${operation.save.error} Do not repeat the edit.`);
+    if (operation.save?.status === "unknown" || operation.save?.status === "requested")
+        throw new Error("The scene edit was applied, but its save outcome is unknown. Inspect persistence before continuing; do not repeat the edit.");
+}
 export function createSdkSceneDraft(api, scene, services) {
     let defaultMaterialId = scene
         .listMaterials()
@@ -59,13 +66,17 @@ export function createSdkSceneEditor(options) {
     const ordinals = new WeakMap();
     return {
         getOperation: (operationId) => options.operations.getSceneOperation(options.targetKey, operationId),
+        withConnection: (context, action) => options.withConnection(context, async (api, settle, active = context) => {
+            active.signal.throwIfAborted();
+            return action(api, settle);
+        }),
         read: (context, action) => options.withConnection(context, async (api, beginSettlement, activeContext = context) => {
             activeContext.signal.throwIfAborted();
-            await api.refreshScene();
+            await api.refreshScene({ returnScene: false });
             activeContext.signal.throwIfAborted();
             return action(api, beginSettlement);
         }),
-        edit: (identity, callback, expectedRevision, context, afterCommitted) => {
+        access: (identity, callback, context, afterCommitted) => {
             const operationKey = `${identity.capability}.${identity.operation}`;
             const contextOrdinals = ordinals.get(context) ?? new Map();
             ordinals.set(context, contextOrdinals);
@@ -89,6 +100,8 @@ export function createSdkSceneEditor(options) {
                 });
                 let releaseCommit;
                 let synchronized = false;
+                let saveSettled = true;
+                let committedScene;
                 let hostDetails = {};
                 const record = async (operation, details) => {
                     hostDetails = { ...hostDetails, ...details };
@@ -113,6 +126,8 @@ export function createSdkSceneEditor(options) {
                     });
                 };
                 try {
+                    releaseCommit = await options.acquireAccess?.(activeContext);
+                    synchronized = true;
                     let result;
                     try {
                         result = await executeSceneOperation({
@@ -122,20 +137,20 @@ export function createSdkSceneEditor(options) {
                             operation: {
                                 id,
                                 targetKey: options.targetKey,
-                                expectedRevision,
                             },
                             assertEditable: async () => {
                                 activeContext.signal.throwIfAborted();
                                 await options.assertEditable(activeContext);
                             },
                             edit: (draft) => callback(api, draft, id),
+                            onCommittedScene: scene => { committedScene = scene; },
                             prepareCommit: async (operation) => {
                                 await activeContext.recordReceipt({
                                     ...receipt(),
                                     status: "unknown",
                                 });
-                                releaseCommit = await options.prepareCommit?.(operation, activeContext);
                                 beginSettlement();
+                                synchronized = false;
                             },
                         });
                     }
@@ -153,12 +168,19 @@ export function createSdkSceneEditor(options) {
                         }
                         throw error;
                     }
+                    saveSettled = !result.operation.changed || !["unknown", "requested"].includes(result.operation.save?.status ?? "");
+                    // A duplicate returns its journaled result; retain its original receipt
+                    // and let explicit recovery handle any earlier synchronization failure.
+                    if (result.reused) {
+                        assertSceneSaved(result.operation);
+                        return result;
+                    }
                     synchronized = !result.operation.changed || !options.onCommitted;
                     await record(result.operation);
                     if (!synchronized) {
                         let details;
                         try {
-                            details = await options.onCommitted(result.operation, api, activeContext, identity);
+                            details = await options.onCommitted(result.operation, api, activeContext, identity, committedScene);
                             synchronized = true;
                         }
                         catch (error) {
@@ -175,11 +197,7 @@ export function createSdkSceneEditor(options) {
                         await record(result.operation, details || undefined);
                     }
                     if (result.operation.changed) {
-                        if (result.operation.save?.status === "failed")
-                            throw new Error(`The scene edit was applied, but the save failed: ${result.operation.save.error} Do not repeat the edit.`);
-                        if (result.operation.save?.status === "unknown" ||
-                            result.operation.save?.status === "requested")
-                            throw new Error("The scene edit was applied, but its save outcome is unknown. Inspect persistence before continuing; do not repeat the edit.");
+                        assertSceneSaved(result.operation);
                         const details = await afterCommitted?.(result.operation, api);
                         if (details)
                             await record(result.operation, details);
@@ -187,7 +205,7 @@ export function createSdkSceneEditor(options) {
                     return result;
                 }
                 finally {
-                    await releaseCommit?.(synchronized);
+                    await releaseCommit?.(synchronized && saveSettled);
                 }
             });
         },
@@ -197,23 +215,8 @@ export function createSdkSceneHost(options) {
     const editor = options.editor ?? createSdkSceneEditor(options);
     return {
         health: options.health?.read.bind(options.health),
-        read: (context) => editor.read(context, async (api) => {
-            const scene = api.getScene();
-            const revision = await api.getSceneRevision();
-            return {
-                revision,
-                projectId: options.projectId,
-                unitMultiplier: sceneUnitMultiplier(scene.properties.unit_multiplier),
-                nodes: Object.values(scene.nodes).map(({ id, name, kind, parentId }) => ({
-                    id,
-                    name,
-                    type: sceneNodeType(kind),
-                    parentId: parentId ?? 0,
-                })),
-            };
-        }),
-        edit: (callback, expectedRevision, context) => editor
-            .edit({ capability: "scene", operation: "edit" }, async (api, draft) => {
+        access: (callback, context) => editor
+            .access({ capability: "scene", operation: "access" }, async (api, draft) => {
             const services = await options.services(api, context);
             let active = true;
             const scopedDraft = new Proxy(draft, {
@@ -234,7 +237,7 @@ export function createSdkSceneHost(options) {
             finally {
                 active = false;
             }
-        }, expectedRevision, context, options.onSceneCommitted)
+        }, context, options.onSceneCommitted)
             .then(({ value }) => value),
         screenshot: options.screenshot,
     };

package/dist/sdk-scene-screenshot.d.ts

@@ -1,5 +1,5 @@
 import type { KakapoAPI } from "@womp/kakapo-sdk";
 import type { SceneScreenshotOptions } from "./capabilities/scene.js";
 import type { ExecutionScreenshot } from "./types.js";
-/** Convert Womp scene coordinates at the host boundary; never fit a camera implicitly. */
+/** Convert explicit cameras at the native boundary; never fit or move the default view. */
 export declare function captureSdkSceneScreenshot(api: KakapoAPI, input: SceneScreenshotOptions): Promise<ExecutionScreenshot>;

package/dist/sdk-scene-screenshot.js

@@ -1,10 +1,11 @@
 import { INTERNAL_UNITS_PER_MM, sceneUnitMultiplier, toEnginePosition } from "./coordinates.js";
-/** Convert Womp scene coordinates at the host boundary; never fit a camera implicitly. */
+/** Convert explicit cameras at the native boundary; never fit or move the default view. */
 export async function captureSdkSceneScreenshot(api, input) {
     if (!input.camera)
         return api.captureScreenshot({ timeoutMs: 30_000 });
-    const scene = await api.refreshScene();
-    const units = sceneUnitMultiplier(scene.properties.unit_multiplier);
+    // Read authoritative project units without returning another full-scene copy.
+    await api.refreshScene({ returnScene: false });
+    const units = sceneUnitMultiplier(api.getSceneProperties().unit_multiplier);
     const camera = {
         ...input.camera,
         position: toEnginePosition(input.camera.position, units),

package/dist/server/scene-access.d.ts

@@ -0,0 +1,4 @@
+export declare function standaloneSceneAccess(url: string): {
+    release(synchronized: boolean): void;
+    run<T>(signal: AbortSignal, action: (signal: AbortSignal, beginSettlement: () => void) => Promise<T>): Promise<T>;
+};

package/dist/server/scene-access.js

@@ -0,0 +1,40 @@
+/** One queue per native renderer, shared by every standalone run in this process. */
+const renderers = new Map();
+export function standaloneSceneAccess(url) {
+    const key = new URL(url).href;
+    let access = renderers.get(key);
+    if (!access) {
+        access = createSceneAccess();
+        renderers.set(key, access);
+    }
+    return access;
+}
+function createSceneAccess() {
+    let tail = Promise.resolve();
+    let uncertain = false;
+    return {
+        release(synchronized) {
+            if (!synchronized)
+                uncertain = true;
+        },
+        run(signal, action) {
+            const result = tail.then(async () => {
+                signal.throwIfAborted();
+                if (uncertain)
+                    throw new Error("The renderer has an uncertain scene commit. Inspect it before restarting standalone scene access; do not repeat the edit.");
+                const active = new AbortController();
+                const abort = () => active.abort(signal.reason);
+                signal.addEventListener("abort", abort, { once: true });
+                const beginSettlement = () => signal.removeEventListener("abort", abort);
+                try {
+                    return await action(active.signal, beginSettlement);
+                }
+                finally {
+                    beginSettlement();
+                }
+            });
+            tail = result.then(() => { }, () => { });
+            return result;
+        },
+    };
+}

package/dist/server/standalone.js

@@ -3,7 +3,7 @@ import { createOpenAI } from "@ai-sdk/openai";
 import { createGoogleGenerativeAI } from "@ai-sdk/google";
 import express from "express";
 import { getSparkModel, SPARK_MODELS } from "../models.js";
-import { KakapoAPI, KakapoRpcError } from "@womp/kakapo-sdk";
+import { KakapoAPI, KakapoRpcError, KakapoSceneCommitError } from "@womp/kakapo-sdk";
 import { captureSdkSceneScreenshot } from "../sdk-scene-screenshot.js";
 import { composeCapabilities, createAccountCapability, createGeometryCapability, createOpenScadCapability, createSceneCapability, } from "../capabilities.js";
 import { loadDemoSceneMaterials } from "./demo-scene-materials.js";
@@ -13,7 +13,7 @@ import { createSdkGeometryHost } from "../sdk-geometry-host.js";
 import { createSdkOpenScadHost } from "../sdk-openscad-host.js";
 import { createSdkSceneHealthHost } from "../sdk-scene-health-host.js";
 import { geometryReference } from "../geometry.js";
-import { getSdkSceneAreaIds, hasSceneResourcePressure, readStableSdkSceneHealth, } from "../scene-health.js";
+import { hasSceneResourcePressure, } from "../scene-health.js";
 import { QuickJSJavaScriptExecutor } from "../quickjs-executor.js";
 import { sparkModelOptions } from "../model-options.js";
 import { createSparkRunExecutor } from "./executor.js";
@@ -21,7 +21,7 @@ import { createSparkAgentRouter } from "./express.js";
 import { SparkAgentService } from "./service.js";
 import { SqliteSparkStore } from "./sqlite-store.js";
 import { clearSceneContents } from "./scene-actions.js";
-import { initializeStandaloneScene } from "./scene-initialization.js";
+import { standaloneSceneAccess } from "./scene-access.js";
 export async function checkStandaloneServices(api) {
     const [fonts, openScad] = await Promise.allSettled([
         api.listFonts(),
@@ -57,6 +57,7 @@ export async function createStandaloneSparkAgentApp(options) {
         throw error;
     }
     const artifactStore = store;
+    const sceneAccess = standaloneSceneAccess(options.kakapoUrl);
     const executeRun = createSparkRunExecutor({
         createHost: async (context) => {
             const api = new KakapoAPI({
@@ -65,9 +66,7 @@ export async function createStandaloneSparkAgentApp(options) {
             });
             try {
                 context.signal.throwIfAborted();
-                await api.connect();
-                context.signal.throwIfAborted();
-                await initializeStandaloneScene(api, context.signal);
+                await api.connect({ refreshScene: false });
                 context.signal.throwIfAborted();
                 const support = await checkStandaloneServices(api);
                 const services = {
@@ -81,12 +80,12 @@ export async function createStandaloneSparkAgentApp(options) {
                     targetKey,
                     operations: store,
                     saveToRenderer: true,
-                    withConnection: async (invocation, action) => {
-                        invocation.signal.throwIfAborted();
+                    withConnection: (invocation, action) => sceneAccess.run(invocation.signal, async (signal, beginSettlement) => {
                         if (!api.isConnected)
                             throw new Error("The Kakapo connection was interrupted; reconnect before continuing");
-                        return action(api, () => { }, invocation);
-                    },
+                        return action(api, beginSettlement, { ...invocation, signal });
+                    }),
+                    acquireAccess: async () => sceneAccess.release,
                     assertEditable: () => {
                         if (!api.isConnected)
                             throw new Error("The Kakapo connection is unavailable");
@@ -103,16 +102,11 @@ export async function createStandaloneSparkAgentApp(options) {
                 const sceneHost = createSdkSceneHost({
                     ...editorOptions,
                     editor,
-                    health: createSdkSceneHealthHost(editor, onHealth),
-                    onSceneCommitted: async (_operation, api) => {
-                        const sceneHealth = await readStableSdkSceneHealth(api, getSdkSceneAreaIds(api), context.signal);
-                        onHealth(sceneHealth);
-                        return { sceneHealth };
-                    },
+                    health: createSdkSceneHealthHost(editor, onHealth, repairs),
                     services: async () => services,
                     screenshot: async (settings, invocation) => {
                         invocation.signal.throwIfAborted();
-                        const image = await captureSdkSceneScreenshot(api, settings);
+                        const image = await editor.withConnection(invocation, activeApi => captureSdkSceneScreenshot(activeApi, settings));
                         options.onScreenshot?.(context.runId);
                         invocation.signal.throwIfAborted();
                         return artifactStore.write(context.ownerId, image);
@@ -254,8 +248,19 @@ export async function createStandaloneSparkAgentApp(options) {
         clearingScene = true;
         const api = new KakapoAPI({ url: options.kakapoUrl, requestTimeoutMs: 30_000 });
         try {
-            await api.connect();
-            const { save } = await api.editSceneAndSave(clearSceneContents);
+            await api.connect({ refreshScene: false });
+            const { save } = await sceneAccess.run(new AbortController().signal, async () => {
+                try {
+                    const result = await api.accessScene(clearSceneContents, { save: true });
+                    sceneAccess.release(result.save.status !== "unknown");
+                    return result;
+                }
+                catch (error) {
+                    if (error instanceof KakapoSceneCommitError && error.outcome === "unknown")
+                        sceneAccess.release(false);
+                    throw error;
+                }
+            });
             const warning = save.status === "failed" || save.status === "unknown"
                 ? `Scene cleared, but saving ${save.status === "failed" ? "failed" : "could not be confirmed"}: ${save.error} Do not repeat the clear operation.`
                 : undefined;

package/dist/womp-scene-api.d.ts

@@ -306,5 +306,20 @@ export declare function createWompSceneApi(context: WompSceneApiContext): {
         g: number;
         b: number;
     }) => void;
+    unitMultiplier: number;
+    /** Current draft summaries. Filters precede pagination; defaults to 100 results, maximum 1000. */
+    nodes(options?: {
+        ids?: number[];
+        type?: number;
+        parentId?: number;
+        name?: string;
+        offset?: number;
+        limit?: number;
+    }): {
+        id: number;
+        name: string;
+        type: number;
+        parentId: number;
+    }[];
 };
 export {};

package/dist/womp-scene-api.js

@@ -436,6 +436,23 @@ export function createWompSceneApi(context) {
         return converted;
     };
     const api = {
+        get unitMultiplier() {
+            return sceneUnitMultiplier(scene.getSceneProperties().unit_multiplier);
+        },
+        /** Current draft summaries. Filters precede pagination; defaults to 100 results, maximum 1000. */
+        nodes(options = {}) {
+            const { offset = 0, limit = 100 } = options;
+            if (!Number.isInteger(offset) || offset < 0 || !Number.isInteger(limit) || limit < 1 || limit > 1000)
+                throw new Error("nodes() requires a nonnegative integer offset and a limit from 1 to 1000");
+            const ids = options.ids === undefined ? undefined : new Set(options.ids);
+            const query = options.name?.toLowerCase();
+            return scene.listNodeSummaries().filter(({ id, name, kind, parentId }) => (ids === undefined || ids.has(id)) &&
+                (options.type === undefined || sceneNodeType(kind) === options.type) &&
+                (options.parentId === undefined || (parentId ?? 0) === options.parentId) &&
+                (query === undefined || name.toLowerCase().includes(query))).slice(offset, offset + limit).map(({ id, name, kind, parentId }) => ({
+                id, name, type: sceneNodeType(kind), parentId: parentId ?? 0,
+            }));
+        },
         ...createSceneEnvironment(scene, context.hdrs, context.print),
         listSuperMaterials: () => {
             if (!context.superMaterialNames)
@@ -611,7 +628,7 @@ export function createWompSceneApi(context) {
         nodeSetLock: (id, locked) => {
             requireNode(id);
             const current = metadataObject(scene.getSceneExt([String(id)])[String(id)]);
-            scene.patchSceneExt([{ op: "add", path: `/${id}`, value: { ...current, locked: Boolean(locked) } }]);
+            scene.patchSceneExt([{ op: "add", path: `/${id}`, value: { ...current, locked: Boolean(locked) } }], { returnScene: false });
         },
         nodeSetPos: (id, position) => {
             requireEditableTransform(id);