@womp/spark-agent 7.0.0 → 9.0.0

package/dist/sdk-geometry-host.js

@@ -1,293 +1,294 @@
+import { KakapoError, } from "@womp/kakapo-sdk";
 import { SceneOperationError } from "./sdk-scene-host.js";
-import { compileGeometry, migrateGraphExt, readEditableGeometry, } from "./geometry/compiler.js";
-import { graphExtSchema } from "./geometry/graph.js";
+import { compileGeometry, migrateGraphExt, readEditableGeometry } from "./geometry/compiler.js";
 import { boundedDiagnostics } from "./geometry/diagnostics.js";
-import { migrateParameterOverrides, readParameterOverrides, } from "./geometry/parameters.js";
+import { graphExtSchema } from "./geometry/graph.js";
+import { migrateParameterOverrides, readParameterOverrides } from "./geometry/parameters.js";
+import { convertAABB, sceneNodePosition, sceneNodeRotation, sceneNodeSize } from "./womp-scene-api.js";
+import { sceneUnitMultiplier } from "./coordinates.js";
 import { unverifiedSceneHealth } from "./scene-health.js";
-import { createGeometryRepairTracker, } from "./repair-state.js";
+import { createGeometryRepairTracker } from "./repair-state.js";
+const MEMORY_LIMIT = "Scene memory limits prevent applying this graph.";
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function unusedId(entries) {
     let id = 0;
     while (id in entries)
         id++;
     return id;
 }
-function scriptStorage(source) {
-    const scripts = source.getSceneStorage().scripts;
-    if (!scripts || typeof scripts !== "object" || Array.isArray(scripts))
-        return { graphs: {}, instances: {} };
-    const value = scripts;
+function readScripts(scene) {
+    const stored = scene.getSceneStorage().scripts;
+    const scripts = isRecord(stored) ? stored : {};
     return {
-        graphs: value.graphs && typeof value.graphs === "object"
-            ? value.graphs
-            : {},
-        instances: value.instances && typeof value.instances === "object"
-            ? value.instances
-            : {},
+        ...scripts,
+        graphs: isRecord(scripts.graphs) ? scripts.graphs : {},
+        instances: isRecord(scripts.instances) ? scripts.instances : {},
     };
 }
-function objectIdsFor(source, instanceId) {
-    return source
-        .listNodes({ kind: "union" })
-        .filter((node) => node.kind === "union" && node.scriptInstanceId === instanceId)
-        .map((node) => node.id);
+function readGraphExts(scene) {
+    const graphExts = scene.getSceneExt(["graphsExt"]).graphsExt;
+    return isRecord(graphExts) ? graphExts : {};
+}
+function graphExtOf(graphExts, graphId) {
+    return graphExtSchema.parse(graphExts[graphId] ?? {});
 }
-function resolveTarget(source, objectId) {
-    const node = source.getNode(objectId);
+function graphInstances(scripts, graphId) {
+    return Object.entries(scripts.instances).filter(([, instance]) => instance.graph_id === graphId);
+}
+function objectIdsByInstance(scene) {
+    const objectIds = new Map();
+    for (const node of scene.listNodes({ kind: "union" })) {
+        if (node.kind !== "union" || node.scriptInstanceId === undefined)
+            continue;
+        const ids = objectIds.get(node.scriptInstanceId);
+        if (ids)
+            ids.push(node.id);
+        else
+            objectIds.set(node.scriptInstanceId, [node.id]);
+    }
+    return objectIds;
+}
+function resolveTarget(scene, objectId) {
+    const node = scene.getNode(objectId);
     if (objectId !== 0 && node.kind !== "union" && node.kind !== "group")
         throw new Error("Geometry Nodes requires an Area, Group, or scene root target.");
+    const scripts = readScripts(scene);
     const instanceId = node.kind === "union" ? node.scriptInstanceId : undefined;
-    const scripts = scriptStorage(source);
-    const instance = instanceId === undefined ? undefined : scripts.instances[instanceId];
-    if (instanceId !== undefined && !instance)
+    if (instanceId === undefined)
+        return { node, scripts };
+    const instance = scripts.instances[instanceId];
+    if (!instance)
         throw new Error("The target's Geometry Nodes instance is missing. Inspect it before editing.");
-    const graphId = instance?.graph_id;
-    const graph = graphId === undefined ? undefined : scripts.graphs[graphId];
-    if (instance && (graph === undefined || !Number.isInteger(graphId)))
+    const graphId = instance.graph_id;
+    const graph = scripts.graphs[graphId];
+    if (graph === undefined || !Number.isInteger(graphId))
         throw new Error("The target's Geometry Nodes graph is missing. Inspect it before editing.");
-    return { node, graph, graphId, instanceId, scripts };
+    return { node, scripts, graphId, instanceId, graph };
 }
-async function readTarget(api, objectId, target = resolveTarget(api, objectId)) {
-    const result = {
-        kind: target.graphId === undefined ? "container" : "graph",
-        objectId,
-        title: target.node.name,
-        graphId: target.graphId,
-        instanceId: target.instanceId,
-        source: null,
-        instances: [],
-        diagnostics: [],
-    };
-    if (target.graphId === undefined || target.graph === undefined)
-        return result;
+function describeGraph(api, target) {
+    if (target.graph === undefined)
+        return { source: null, instances: [], diagnostics: [] };
     try {
-        const ext = graphExtSchema.parse(api.getSceneExt().graphsExt?.[target.graphId] ?? {});
+        const ext = graphExtOf(readGraphExts(api), target.graphId);
         const editable = readEditableGeometry(target.graph, ext);
-        result.source = editable.source;
-        for (const [id, instance] of Object.entries(target.scripts.instances)) {
-            if (instance.graph_id !== target.graphId)
-                continue;
-            const { params } = readParameterOverrides(editable.graph, ext, instance.data ?? {});
-            result.instances.push({
+        const objectIds = objectIdsByInstance(api);
+        return {
+            source: editable.source,
+            instances: graphInstances(target.scripts, target.graphId).map(([id, instance]) => ({
                 instanceId: Number(id),
-                objectIds: objectIdsFor(api, Number(id)),
-                params,
-            });
-        }
+                objectIds: objectIds.get(Number(id)) ?? [],
+                params: readParameterOverrides(editable.graph, ext, instance.data ?? {}).params,
+            })),
+            diagnostics: [],
+        };
     }
     catch (error) {
-        result.source = null;
-        // Bounded: a compiler diagnostic is unbounded text (./geometry/diagnostics.ts).
-        result.diagnostics.push(...boundedDiagnostics([errorMessage(error)]));
+        return { source: null, instances: [], diagnostics: boundedDiagnostics([errorMessage(error)]) };
     }
-    return structuredClone(result);
 }
-function writeGraphStorage(draft, graphId, graph, instances) {
-    const scripts = draft.getSceneStorage().scripts;
-    if (!scripts || typeof scripts !== "object" || Array.isArray(scripts)) {
-        draft.patchSceneStorage([
-            {
-                op: "add",
-                path: "/scripts",
-                value: { graphs: {}, instances: {} },
-            },
-        ], { returnScene: false });
+async function readPlacement(api, objectId, target) {
+    if (objectId === 0)
+        return { transform: null, bounds: null, diagnostics: [] };
+    const reader = { requireNode: (id) => api.getNode(id), getNode: (id) => api.getNode(id) };
+    const unitMultiplier = sceneUnitMultiplier(api.getSceneProperties().unit_multiplier);
+    const transform = {
+        position: sceneNodePosition(reader, 0, unitMultiplier, objectId),
+        rotation: sceneNodeRotation(reader, objectId),
+        size: sceneNodeSize(reader, 0, unitMultiplier, objectId),
+    };
+    if (target.graph === undefined || target.node.parentId !== 0)
+        return { transform, bounds: null, diagnostics: [] };
+    try {
+        return { transform, bounds: convertAABB(await api.getNodeBoundingBox(objectId), unitMultiplier), diagnostics: [] };
     }
-    else {
-        const record = scripts;
-        const additions = [];
-        if (!record.graphs)
-            additions.push({
-                op: "add",
-                path: "/scripts/graphs",
-                value: {},
-            });
-        if (!record.instances)
-            additions.push({
-                op: "add",
-                path: "/scripts/instances",
-                value: {},
-            });
-        if (additions.length)
-            draft.patchSceneStorage(additions, { returnScene: false });
+    catch (error) {
+        if (error instanceof KakapoError && error.code === "EMPTY_BOUNDING_BOX")
+            return { transform, bounds: null, diagnostics: [] };
+        return { transform, bounds: null, diagnostics: [`Bounds are unavailable: ${errorMessage(error)}`] };
     }
-    draft.patchSceneStorage([
-        {
-            op: "add",
-            path: `/scripts/graphs/${graphId}`,
-            value: graph,
-        },
-        ...[...instances].map(([id, instance]) => ({
-            op: "add",
-            path: `/scripts/instances/${id}`,
-            value: instance,
-        })),
-    ], { returnScene: false });
+}
+async function readTarget(api, objectId) {
+    const target = resolveTarget(api, objectId);
+    const graph = describeGraph(api, target);
+    const placement = await readPlacement(api, objectId, target);
+    return {
+        kind: target.graph === undefined ? "container" : "graph",
+        objectId,
+        title: target.node.name,
+        graphId: target.graphId,
+        instanceId: target.instanceId,
+        source: graph.source,
+        transform: placement.transform,
+        bounds: placement.bounds,
+        instances: graph.instances,
+        diagnostics: boundedDiagnostics([...graph.diagnostics, ...placement.diagnostics]),
+    };
+}
+function planUpdate(target, graphExts, compiled) {
+    const ext = graphExtOf(graphExts, target.graphId);
+    const previous = readEditableGeometry(target.graph, ext);
+    const nextExt = migrateGraphExt(ext, previous.nodeIds, compiled);
+    const instances = {};
+    const diagnostics = [];
+    for (const [id, instance] of graphInstances(target.scripts, target.graphId)) {
+        const migrated = migrateParameterOverrides(previous.graph, ext, compiled.graph, nextExt, instance.data ?? {});
+        instances[id] = { graph_id: target.graphId, data: migrated.data };
+        if (migrated.removed.length)
+            diagnostics.push(`Instance ${id}: removed or type-changed overrides ${migrated.removed.join(", ")} now use graph defaults where present.`);
+    }
+    return { graphId: target.graphId, instanceId: target.instanceId, graph: compiled.graph, ext: nextExt, instances, diagnostics };
+}
+function planCreation(target, compiled) {
+    const graphId = unusedId(target.scripts.graphs);
+    const instanceId = unusedId(target.scripts.instances);
+    return {
+        graphId,
+        instanceId,
+        graph: compiled.graph,
+        ext: migrateGraphExt({ nodes: {} }, {}, compiled),
+        instances: { [instanceId]: { graph_id: graphId, data: {} } },
+        diagnostics: [],
+    };
+}
+function attachArea(draft, objectId, node, instanceId) {
+    const areaId = objectId !== 0 && node.kind === "union"
+        ? objectId
+        : draft.createNode({ kind: "union", parentId: objectId, name: "Area" }).id;
+    draft.updateNode(areaId, { scriptInstanceId: instanceId });
+    return areaId;
+}
+function writeGraph(draft, scripts, graphExts, change) {
+    const nextScripts = {
+        ...scripts,
+        graphs: { ...scripts.graphs, [change.graphId]: change.graph },
+        instances: { ...scripts.instances, ...change.instances },
+    };
+    draft.patchSceneStorage([{ op: "add", path: "/scripts", value: nextScripts }], { returnScene: false });
+    draft.patchSceneExt([{ op: "add", path: "/graphsExt", value: { ...graphExts, [change.graphId]: change.ext } }], { returnScene: false });
 }
 export function createSdkGeometryHost(options) {
-    const editor = options.editor;
+    const { editor } = options;
     const repairs = createGeometryRepairTracker(options.repairs, "geometry");
     const pendingTargets = new Set();
-    return {
-        read: (objectId, invocation) => editor.read(invocation, (api) => readTarget(api, objectId)),
-        write: async (input, invocation) => {
-            invocation.signal.throwIfAborted();
-            const target = await editor.read(invocation, api => readTarget(api, input.objectId));
-            const pendingKey = target.graphId === undefined
-                ? `object:${input.objectId}`
-                : `graph:${target.graphId}`;
-            if (pendingTargets.has(pendingKey))
-                throw new Error("This Geometry Nodes target is still being updated. Await its current update first.");
-            pendingTargets.add(pendingKey);
+    const write = async (input, invocation) => {
+        const target = await editor.read(invocation, (api) => resolveTarget(api, input.objectId));
+        const rejected = (diagnostics) => ({
+            status: "rejected",
+            objectId: input.objectId,
+            graphId: target.graphId,
+            instanceId: target.instanceId,
+            affectedObjectIds: [],
+            diagnostics: boundedDiagnostics(diagnostics),
+        });
+        const pendingKey = target.graphId === undefined ? `object:${input.objectId}` : `graph:${target.graphId}`;
+        if (pendingTargets.has(pendingKey))
+            throw new Error("This Geometry Nodes target is still being updated. Await its current update first.");
+        pendingTargets.add(pendingKey);
+        try {
+            const repairKey = target.graphId === undefined ? undefined : String(target.graphId);
+            const repairing = repairKey !== undefined && (await repairs.isPending(repairKey));
+            if (repairKey !== undefined)
+                await repairs.assertCanWrite(repairKey);
+            let compiled;
             try {
-                const repairingGeometry = target.graphId !== undefined &&
-                    (await repairs.isPending(String(target.graphId)));
-                if (target.graphId !== undefined)
-                    await repairs.assertCanWrite(String(target.graphId));
-                const rejected = (diagnostics) => ({
-                    status: "rejected",
-                    objectId: input.objectId,
-                    graphId: target.graphId,
-                    instanceId: target.instanceId,
-                    affectedObjectIds: [],
-                    diagnostics: boundedDiagnostics(diagnostics),
-                });
-                let compiled;
-                const diagnostics = [];
-                try {
-                    compiled = compileGeometry(input.source);
-                    readEditableGeometry(compiled.graph, compiled.graphExt);
-                }
-                catch (error) {
-                    return rejected([errorMessage(error)]);
-                }
-                if (repairingGeometry === false && options.canGrow?.() === false)
-                    return rejected(["Scene memory limits prevent applying this graph."]);
-                const receiptTarget = {
-                    objectId: input.objectId,
-                };
-                let operationId;
-                let applied;
-                try {
-                    applied = await editor.access({
-                        capability: "geometry",
-                        operation: "write",
-                        target: () => receiptTarget,
-                    }, async (_api, draft, id) => {
-                        operationId = id;
-                        const current = resolveTarget(draft, input.objectId);
-                        if (repairingGeometry === false && options.canGrow?.() === false)
-                            throw new Error("Scene memory limits prevent applying this graph.");
-                        if (current.graphId !== target.graphId)
-                            throw new Error("The Geometry Nodes target changed. Read it again.");
-                        let nextExt;
-                        const updates = new Map();
-                        try {
-                            if (target.graphId === undefined) {
-                                nextExt = migrateGraphExt({ nodes: {} }, {}, compiled);
-                            }
-                            else {
-                                if (current.graph === undefined)
-                                    throw new Error("The Geometry Nodes graph is missing.");
-                                const graphExt = draft.getSceneExt(["graphsExt"]).graphsExt;
-                                const ext = graphExtSchema.parse(graphExt?.[target.graphId] ?? {});
-                                const previous = readEditableGeometry(current.graph, ext);
-                                nextExt = migrateGraphExt(ext, previous.nodeIds, compiled);
-                                for (const [id, instance] of Object.entries(current.scripts.instances)) {
-                                    if (instance.graph_id !== target.graphId)
-                                        continue;
-                                    const old = readParameterOverrides(previous.graph, ext, instance.data ?? {});
-                                    const migrated = migrateParameterOverrides(previous.graph, ext, compiled.graph, nextExt, old.data);
-                                    updates.set(id, {
-                                        graph_id: target.graphId,
-                                        data: migrated.data,
-                                    });
-                                    if (migrated.removed.length)
-                                        diagnostics.push(`Instance ${id}: removed or type-changed overrides ${migrated.removed.join(", ")} now use graph defaults where present.`);
-                                }
-                            }
-                        }
-                        catch (error) {
-                            return { rejected: [errorMessage(error)] };
-                        }
-                        if (current.graphId !== undefined)
-                            await repairs.reserve(String(current.graphId), id);
-                        let objectId = input.objectId;
-                        let graphId = current.graphId;
-                        let instanceId = current.instanceId;
-                        const nextInstances = new Map(updates);
-                        if (graphId === undefined) {
-                            graphId = unusedId(current.scripts.graphs);
-                            instanceId = unusedId(current.scripts.instances);
-                            if (objectId === 0 || current.node.kind !== "union") {
-                                objectId = draft.createNode({
-                                    kind: "union",
-                                    parentId: objectId,
-                                    name: "Area",
-                                }).id;
-                            }
-                            draft.updateNode(objectId, { scriptInstanceId: instanceId });
-                            nextInstances.set(String(instanceId), {
-                                graph_id: graphId,
-                                data: {},
-                            });
-                        }
-                        writeGraphStorage(draft, graphId, compiled.graph, nextInstances);
-                        const ext = draft.getSceneExt();
-                        if (!ext.graphsExt)
-                            draft.patchSceneExt([
-                                { op: "add", path: "/graphsExt", value: {} },
-                            ], { returnScene: false });
-                        draft.patchSceneExt([
-                            {
-                                op: "add",
-                                path: `/graphsExt/${graphId}`,
-                                value: nextExt,
-                            },
-                        ], { returnScene: false });
-                        const affectedObjectIds = Object.entries(scriptStorage(draft).instances)
-                            .filter(([, instance]) => instance.graph_id === graphId)
-                            .flatMap(([id]) => objectIdsFor(draft, Number(id)));
-                        Object.assign(receiptTarget, { objectId, graphId, instanceId });
-                        return { objectId, graphId, instanceId, affectedObjectIds };
-                    }, invocation, async (operation) => {
-                        const graphId = receiptTarget.graphId;
-                        if (graphId === undefined)
-                            return;
-                        const recorded = await repairs.record(String(graphId), operation.id, unverifiedSceneHealth([], "Health was not requested."));
-                        return {
-                            geometryRepairAttempts: recorded.repairAttempts,
-                            geometryRepairLimit: recorded.repairLimit,
-                        };
-                    });
-                }
-                catch (error) {
-                    if (operationId !== undefined && target.graphId !== undefined) {
-                        const operation = error instanceof SceneOperationError
-                            ? error.operation : await editor.getOperation(operationId);
-                        if (operation?.status === "rolled_back")
-                            await repairs.refund(String(target.graphId), operationId);
+                compiled = compileGeometry(input.source);
+                readEditableGeometry(compiled.graph, compiled.graphExt);
+            }
+            catch (error) {
+                return rejected([errorMessage(error)]);
+            }
+            const memoryBlocked = () => repairing === false && options.canGrow?.() === false;
+            if (memoryBlocked())
+                return rejected([MEMORY_LIMIT]);
+            const receipt = { objectId: input.objectId };
+            let operationId;
+            let applied;
+            try {
+                applied = await editor.access({ capability: "geometry", operation: "write", target: () => receipt }, async (_api, draft, id) => {
+                    operationId = id;
+                    const current = resolveTarget(draft, input.objectId);
+                    if (memoryBlocked())
+                        throw new Error(MEMORY_LIMIT);
+                    if (current.graphId !== target.graphId)
+                        throw new Error("The Geometry Nodes target changed. Read it again.");
+                    const graphExts = readGraphExts(draft);
+                    let change;
+                    try {
+                        change = current.graph === undefined ? planCreation(current, compiled) : planUpdate(current, graphExts, compiled);
                     }
-                    throw error;
-                }
-                if (applied.value.rejected)
-                    return rejected(applied.value.rejected);
-                invocation.signal.throwIfAborted();
-                try {
-                    await options.onSelect?.(applied.value.objectId);
+                    catch (error) {
+                        return { rejected: [errorMessage(error)] };
+                    }
+                    if (current.graph !== undefined)
+                        await repairs.reserve(String(current.graphId), id);
+                    const objectId = current.graph === undefined ? attachArea(draft, input.objectId, current.node, change.instanceId) : input.objectId;
+                    writeGraph(draft, current.scripts, graphExts, change);
+                    const objectIds = objectIdsByInstance(draft);
+                    Object.assign(receipt, { objectId, graphId: change.graphId, instanceId: change.instanceId });
+                    return {
+                        objectId,
+                        graphId: change.graphId,
+                        instanceId: change.instanceId,
+                        affectedObjectIds: Object.keys(change.instances).flatMap((instanceId) => objectIds.get(Number(instanceId)) ?? []),
+                        diagnostics: change.diagnostics,
+                    };
+                }, invocation, async (operation) => {
+                    if (receipt.graphId === undefined)
+                        return;
+                    const recorded = await repairs.record(String(receipt.graphId), operation.id, unverifiedSceneHealth([], "Health was not requested."));
+                    return { geometryRepairAttempts: recorded.repairAttempts, geometryRepairLimit: recorded.repairLimit };
+                });
+            }
+            catch (error) {
+                if (operationId !== undefined && repairKey !== undefined) {
+                    if (error instanceof SceneOperationError && error.operation.status === "rolled_back")
+                        await repairs.refund(repairKey, operationId);
                 }
-                catch { }
-                return {
-                    status: "applied",
-                    ...applied.value,
-                    diagnostics: boundedDiagnostics(diagnostics),
-                };
+                throw error;
             }
-            finally {
-                pendingTargets.delete(pendingKey);
+            const result = applied.value;
+            if (result.rejected)
+                return rejected(result.rejected);
+            invocation.signal.throwIfAborted();
+            try {
+                await options.onSelect?.(result.objectId);
+            }
+            catch { }
+            let committed;
+            try {
+                committed = await editor.read(invocation, (api) => readTarget(api, result.objectId));
             }
-        },
+            catch (error) {
+                committed = {
+                    source: null,
+                    transform: null,
+                    bounds: null,
+                    diagnostics: [`The write was applied, but reading it back failed: ${errorMessage(error)} Read the target before editing it again.`],
+                };
+            }
+            return {
+                status: "applied",
+                objectId: result.objectId,
+                graphId: result.graphId,
+                instanceId: result.instanceId,
+                affectedObjectIds: result.affectedObjectIds,
+                source: committed.source ?? undefined,
+                transform: committed.transform,
+                bounds: committed.bounds,
+                diagnostics: boundedDiagnostics([...result.diagnostics, ...committed.diagnostics]),
+            };
+        }
+        finally {
+            pendingTargets.delete(pendingKey);
+        }
+    };
+    return {
+        read: (objectId, invocation) => editor.read(invocation, (api) => readTarget(api, objectId)),
+        write,
     };
 }

package/dist/sdk-openscad-host.js

@@ -238,9 +238,7 @@ export function createSdkOpenScadHost(options) {
         }
         catch (error) {
             if (creating === false && operationId !== "") {
-                const operation = error instanceof SceneOperationError
-                    ? error.operation : await editor.getOperation(operationId);
-                if (operation?.status === "rolled_back") {
+                if (error instanceof SceneOperationError && error.operation.status === "rolled_back") {
                     await geometryRepairs.refund(resolved.repairKey, operationId);
                     await printabilityRepairs.refund(resolved.repairKey, operationId);
                 }

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

@@ -1,7 +1,7 @@
 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";
+import { type SceneOperation } from "./scene-operations.js";
 import type { SceneHdr } from "./scene-environment.js";
 export type SdkSceneServices = {
     fonts: FontFamily[];
@@ -19,7 +19,6 @@ export type SdkSceneServices = {
 export type SdkSceneEditorOptions = {
     targetKey: string;
     projectId?: number;
-    operations?: SceneOperationStore;
     saveToRenderer?: boolean;
     withConnection<T>(context: SparkInvocationContext, action: (api: KakapoAPI, beginSettlement: () => void, 
     /** Supply this when the host adds a stricter connection lifetime. */
@@ -27,7 +26,7 @@ export type SdkSceneEditorOptions = {
     assertEditable(context: SparkInvocationContext): 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. */
+    /** Must adopt each operation ID at most once. */
     onCommitted?(operation: SceneOperation, api: KakapoAPI, context: SparkInvocationContext, identity: SdkSceneEditIdentity, scene: NativeSceneSnapshot): Promise<Record<string, unknown> | void>;
 };
 export type SdkSceneEditIdentity = {
@@ -35,13 +34,12 @@ export type SdkSceneEditIdentity = {
     operation: string;
     target?: Record<string, unknown> | (() => Record<string, unknown>);
 };
-/** Carries this invocation's outcome without requiring a persistent journal. */
+/** A failed edit's outcome, for callers that settle per-edit state such as repair budgets. */
 export declare class SceneOperationError extends Error {
     readonly operation: SceneOperation;
     constructor(operation: SceneOperation, cause: unknown);
 }
 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>;
     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<{