@womp/spark-agent 4.4.1 → 5.0.1

package/dist/scene-operations.js

@@ -1,5 +1,4 @@
 import { KakapoSceneCommitError } from "@womp/kakapo-sdk";
-import { metadataObject } from "./scene-metadata.js";
 function savedResult(value) {
     if (value === undefined)
         return { empty: true };
@@ -11,9 +10,9 @@ function savedResult(value) {
             return;
         if (typeof item !== "object" || item === null ||
             (!Array.isArray(item) && Object.getPrototypeOf(item) !== Object.prototype && Object.getPrototypeOf(item) !== null))
-            throw new Error("scene.edit must return JSON data or undefined");
+            throw new Error("scene.access must return JSON data or undefined");
         if (active.has(item))
-            throw new Error("scene.edit cannot return cyclic data");
+            throw new Error("scene.access cannot return cyclic data");
         active.add(item);
         for (const nested of Object.values(item))
             validate(nested);
@@ -27,26 +26,17 @@ function resultValue(operation) {
         throw new Error("The saved scene operation result is missing");
     return ("value" in operation.result ? structuredClone(operation.result.value) : undefined);
 }
-function committedIds(ext) {
-    const ids = metadataObject(ext.spark).committedSceneEdits;
-    return Array.isArray(ids) ? ids.filter((id) => typeof id === "string") : [];
-}
 function complete(operation, status) {
     return { ...operation, status, completedAt: operation.completedAt ?? new Date().toISOString() };
 }
-/** Resolve a journaled edit from a fresh renderer snapshot without executing its JavaScript. */
+/** Recover acknowledged/no-op results without replaying or refetching an uncertain edit. */
 export async function recoverSceneOperation(options) {
     await options.assertActive();
     const previous = await options.store.getSceneOperation(options.targetKey, options.id);
     if (!previous || previous.status === "committed" || previous.status === "rolled_back")
         return previous;
-    await options.api.refreshScene();
-    const ext = options.api.getSceneExt();
-    const revision = await options.api.getSceneRevision();
     await options.assertActive();
-    const matches = previous.resultRevision !== undefined &&
-        previous.resultRevision === revision && committedIds(ext).includes(previous.id);
-    if ((previous.changed === false || matches) && previous.result) {
+    if (previous.changed === false && previous.result) {
         return options.store.saveSceneOperation(complete(previous, "committed"));
     }
     return previous;
@@ -58,19 +48,17 @@ export async function executeSceneOperation(options) {
     await options.assertEditable();
     const previous = await store.getSceneOperation(identity.targetKey, identity.id);
     if (previous) {
-        if (previous.expectedRevision !== identity.expectedRevision)
-            throw new Error("Scene operation identity was reused with a different revision");
         if ((previous.save !== undefined) !== savesScene)
             throw new Error("Scene operation identity was reused with a different save policy");
         if (previous.status === "committed")
-            return { value: resultValue(previous), operation: previous };
+            return { value: resultValue(previous), operation: previous, reused: true };
         if (previous.status === "rolled_back")
             throw new Error(previous.error ?? "Scene operation was rolled back");
         const recovered = await recoverSceneOperation({
             api, store, targetKey: identity.targetKey, id: identity.id, assertActive: options.assertEditable,
         });
         if (recovered?.status === "committed")
-            return { value: resultValue(recovered), operation: recovered };
+            return { value: resultValue(recovered), operation: recovered, reused: true };
         throw new Error("Scene edit outcome is uncertain. Inspect the scene before making a new edit; this operation was not replayed.");
     }
     let operation = {
@@ -82,33 +70,26 @@ export async function executeSceneOperation(options) {
     try {
         const edit = async (draft) => {
             await options.assertEditable();
-            if (await api.getSceneRevision() !== identity.expectedRevision)
-                throw new Error("Scene changed since inspection. Read the scene again before editing.");
-            const result = savedResult(await options.edit(draft));
-            await options.assertEditable();
-            const changed = await api.getSceneRevision() !== identity.expectedRevision;
-            if (changed) {
-                const spark = metadataObject(draft.getSceneExt().spark);
-                const ids = [...committedIds(api.getSceneExt()), identity.id].slice(-64);
-                draft.patchSceneExt([{ op: "add", path: "/spark", value: { ...spark, committedSceneEdits: ids } }]);
-            }
-            operation = await store.saveSceneOperation({
-                ...operation, status: "prepared", result, changed,
-                ...(changed ? { resultRevision: await api.getSceneRevision() } : {}),
-                ...(savesScene && !changed ? { save: { status: "not_needed" } } : {}),
-            });
-            await options.assertEditable();
-            if (changed)
-                await options.prepareCommit?.(operation);
+            operation = { ...operation, result: savedResult(await options.edit(draft)) };
             await options.assertEditable();
         };
-        if (options.saveToRenderer) {
-            const committed = await api.editSceneAndSave(edit);
+        const committed = await api.accessScene(edit, {
+            save: savesScene,
+            beforeCommit: async (changed) => {
+                await options.assertEditable();
+                operation = await store.saveSceneOperation({
+                    ...operation, status: "prepared", changed,
+                    ...(savesScene && !changed ? { save: { status: "not_needed" } } : {}),
+                });
+                await options.assertEditable();
+                if (changed)
+                    await options.prepareCommit?.(operation);
+            },
+        });
+        if (savesScene)
             operation = { ...operation, save: committed.save };
-        }
-        else {
-            await api.editScene(edit);
-        }
+        if (committed.changed)
+            options.onCommittedScene?.(committed.scene);
     }
     catch (error) {
         const status = error instanceof KakapoSceneCommitError ? error.outcome
@@ -125,7 +106,7 @@ export async function executeSceneOperation(options) {
         }
         throw error;
     }
-    // Recovery requires both the operation marker and the exact prepared scene revision.
+    // A prepared record alone never proves an uncertain commit succeeded.
     operation = await store.saveSceneOperation(complete(operation, "committed"));
     return { value: resultValue(operation), operation };
 }

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

@@ -1,12 +1,12 @@
 import { type SdkSceneEditor } from "./sdk-scene-host.js";
 import type { GeometryHost } from "./capabilities.js";
-import { readStableSdkSceneHealth } from "./scene-health.js";
+import { readSdkSceneHealth } from "./scene-health.js";
 import { type RepairStateStore } from "./repair-state.js";
 export type SdkGeometryHostOptions = {
     editor: SdkSceneEditor;
     repairs: RepairStateStore;
     canGrow?: () => boolean;
-    onHealth?: (health: Awaited<ReturnType<typeof readStableSdkSceneHealth>>) => void;
+    onHealth?: (health: Awaited<ReturnType<typeof readSdkSceneHealth>>) => void;
     onSelect?: (objectId: number) => void | Promise<void>;
 };
 export declare function createSdkGeometryHost(options: SdkGeometryHostOptions): GeometryHost;

package/dist/sdk-geometry-host.js

@@ -2,7 +2,7 @@ import { compileGeometry, migrateGraphExt, readEditableGeometry, } from "./geome
 import { graphExtSchema } from "./geometry/graph.js";
 import { boundedDiagnostics } from "./geometry/diagnostics.js";
 import { migrateParameterOverrides, readParameterOverrides, } from "./geometry/parameters.js";
-import { getSdkSceneAreaId, readStableSdkSceneHealth } from "./scene-health.js";
+import { unverifiedSceneHealth } from "./scene-health.js";
 import { createGeometryRepairTracker, } from "./repair-state.js";
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
@@ -57,7 +57,6 @@ async function readTarget(api, objectId, target = resolveTarget(api, objectId))
         instanceId: target.instanceId,
         source: null,
         instances: [],
-        revision: await api.getSceneRevision(),
         diagnostics: [],
     };
     if (target.graphId === undefined || target.graph === undefined)
@@ -93,7 +92,7 @@ function writeGraphStorage(draft, graphId, graph, instances) {
                 path: "/scripts",
                 value: { graphs: {}, instances: {} },
             },
-        ]);
+        ], { returnScene: false });
     }
     else {
         const record = scripts;
@@ -111,7 +110,7 @@ function writeGraphStorage(draft, graphId, graph, instances) {
                 value: {},
             });
         if (additions.length)
-            draft.patchSceneStorage(additions);
+            draft.patchSceneStorage(additions, { returnScene: false });
     }
     draft.patchSceneStorage([
         {
@@ -124,7 +123,7 @@ function writeGraphStorage(draft, graphId, graph, instances) {
             path: `/scripts/instances/${id}`,
             value: instance,
         })),
-    ]);
+    ], { returnScene: false });
 }
 export function createSdkGeometryHost(options) {
     const editor = options.editor;
@@ -134,17 +133,7 @@ export function createSdkGeometryHost(options) {
         read: (objectId, invocation) => editor.read(invocation, (api) => readTarget(api, objectId)),
         write: async (input, invocation) => {
             invocation.signal.throwIfAborted();
-            const inspected = await editor.read(invocation, async (api) => {
-                const current = resolveTarget(api, input.objectId);
-                return {
-                    target: await readTarget(api, input.objectId, current),
-                    current,
-                    graphExt: current.graphId === undefined
-                        ? undefined
-                        : api.getSceneExt().graphsExt?.[current.graphId],
-                };
-            });
-            const { target } = inspected;
+            const target = await editor.read(invocation, api => readTarget(api, input.objectId));
             const pendingKey = target.graphId === undefined
                 ? `object:${input.objectId}`
                 : `graph:${target.graphId}`;
@@ -152,8 +141,6 @@ export function createSdkGeometryHost(options) {
                 throw new Error("This Geometry Nodes target is still being updated. Await its current update first.");
             pendingTargets.add(pendingKey);
             try {
-                if (target.revision !== input.expectedRevision)
-                    throw new Error("The scene changed. Read it again before editing.");
                 const repairingGeometry = target.graphId !== undefined &&
                     (await repairs.isPending(String(target.graphId)));
                 if (target.graphId !== undefined)
@@ -164,39 +151,13 @@ export function createSdkGeometryHost(options) {
                     graphId: target.graphId,
                     instanceId: target.instanceId,
                     affectedObjectIds: [],
-                    revision: target.revision,
                     diagnostics: boundedDiagnostics(diagnostics),
                 });
                 let compiled;
-                let nextExt;
-                const updates = new Map();
                 const diagnostics = [];
                 try {
                     compiled = compileGeometry(input.source);
                     readEditableGeometry(compiled.graph, compiled.graphExt);
-                    if (target.graphId === undefined) {
-                        nextExt = migrateGraphExt({ nodes: {} }, {}, compiled);
-                    }
-                    else {
-                        const { current } = inspected;
-                        if (current.graph === undefined)
-                            throw new Error("The Geometry Nodes graph is missing.");
-                        const ext = graphExtSchema.parse(inspected.graphExt ?? {});
-                        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)]);
@@ -209,7 +170,7 @@ export function createSdkGeometryHost(options) {
                 let operationId;
                 let applied;
                 try {
-                    applied = await editor.edit({
+                    applied = await editor.access({
                         capability: "geometry",
                         operation: "write",
                         target: () => receiptTarget,
@@ -220,6 +181,36 @@ export function createSdkGeometryHost(options) {
                             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;
@@ -247,34 +238,25 @@ export function createSdkGeometryHost(options) {
                         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 };
-                    }, input.expectedRevision, invocation, async (_operation, api) => {
-                        const committed = resolveTarget(api, receiptTarget.objectId);
-                        if (committed.graphId === undefined)
+                    }, invocation, async (operation) => {
+                        const graphId = receiptTarget.graphId;
+                        if (graphId === undefined)
                             return;
-                        const affectedObjectIds = Object.entries(committed.scripts.instances)
-                            .filter(([, instance]) => instance.graph_id === committed.graphId)
-                            .flatMap(([id]) => objectIdsFor(api, Number(id)));
-                        const areaIds = [
-                            ...new Set(affectedObjectIds.map((id) => getSdkSceneAreaId(api, id))),
-                        ];
-                        const sceneHealth = await readStableSdkSceneHealth(api, areaIds, invocation.signal);
-                        options.onHealth?.(sceneHealth);
-                        const recorded = await repairs.record(String(committed.graphId), _operation.id, sceneHealth);
+                        const recorded = await repairs.record(String(graphId), operation.id, unverifiedSceneHealth([], "Health was not requested."));
                         return {
-                            sceneHealth,
                             geometryRepairAttempts: recorded.repairAttempts,
                             geometryRepairLimit: recorded.repairLimit,
                         };
@@ -288,6 +270,8 @@ export function createSdkGeometryHost(options) {
                     }
                     throw error;
                 }
+                if (applied.value.rejected)
+                    return rejected(applied.value.rejected);
                 invocation.signal.throwIfAborted();
                 try {
                     await options.onSelect?.(applied.value.objectId);
@@ -296,7 +280,6 @@ export function createSdkGeometryHost(options) {
                 return {
                     status: "applied",
                     ...applied.value,
-                    revision: applied.operation.resultRevision ?? input.expectedRevision,
                     diagnostics: boundedDiagnostics(diagnostics),
                 };
             }

package/dist/sdk-openscad-host.js

@@ -1,8 +1,7 @@
 import { z } from "zod";
-import { getOpenScadGroundedPosition, MAX_PRINTABILITY_REPAIR_ATTEMPTS, requestStableOpenScadPrintability, toOpenScadCompileResponse, } from "./openscad.js";
-import { waitForOpenScadRenderer } from "./sdk-openscad-renderer.js";
+import { getOpenScadGroundedPosition, MAX_PRINTABILITY_REPAIR_ATTEMPTS, requestTurnOpenScadPrintability, toOpenScadCompileResponse, } from "./openscad.js";
 import { createGeometryRepairTracker, createRepairTracker, } from "./repair-state.js";
-import { getSdkSceneAreaId, hasGeometryOverflow, readStableSdkSceneHealth, unverifiedSceneHealth, } from "./scene-health.js";
+import { getSdkSceneAreaId, unverifiedSceneHealth, } from "./scene-health.js";
 const compileMetadata = z.object({
     error: z.string(),
     params: z.array(z.object({ name: z.string() })),
@@ -19,7 +18,6 @@ export function createSdkOpenScadHost(options) {
     const printabilityRepairs = createRepairTracker(options.repairs, "openscad.printability", MAX_PRINTABILITY_REPAIR_ATTEMPTS, (status) => status === "unavailable" ? undefined : status === "failed");
     const pendingTargets = new Set();
     const resolveTarget = async (api, objectId) => {
-        const revision = await api.getSceneRevision();
         const node = objectId === 0 ? undefined : api.getNode(objectId);
         if (objectId === 0 || node?.kind === "union" || node?.kind === "group") {
             return {
@@ -30,18 +28,12 @@ export function createSdkOpenScadHost(options) {
                     title: node?.name ?? "",
                     source: null,
                     params: {},
-                    revision,
                 },
             };
         }
         if (node?.kind !== "openScad")
             throw new Error("The target must be an OpenSCAD part or an Area/Group.");
         const script = api.getOpenScadScript(node.scriptId);
-        let rendererBounds;
-        try {
-            rendererBounds = await api.getNodeBoundingBox(objectId);
-        }
-        catch { }
         return {
             target: {
                 kind: "part",
@@ -50,10 +42,8 @@ export function createSdkOpenScadHost(options) {
                 source: script.source,
                 title: script.name || node.name || "OpenSCAD part",
                 params: structuredClone(node.params ?? {}),
-                revision,
             },
             repairKey: `script:${node.scriptId}`,
-            rendererBounds,
         };
     };
     const write = async (source, targetId, creating, invocation) => {
@@ -68,8 +58,6 @@ export function createSdkOpenScadHost(options) {
         let operationId = "";
         let operationRepairKey = resolved.repairKey;
         try {
-            if (target.revision !== source.expectedRevision)
-                throw new Error("The scene changed. Read it again before editing.");
             if (target.kind !== (creating ? "container" : "part"))
                 throw new Error(creating
                     ? "Creation requires a parent container ID."
@@ -85,63 +73,60 @@ export function createSdkOpenScadHost(options) {
             }
             if (creating && options.canGrow?.() === false)
                 throw new Error("OpenSCAD creation is disabled because scene memory is low.");
-            const params = z
-                .record(z.string(), z.json())
-                .parse({ ...target.params, ...source.params });
-            invocation.reportStatus("running", "Compiling the parametric part...");
-            let rawValidation;
-            try {
-                rawValidation = await editor.read(invocation, (api) => api.validateOpenScad(source.source, params));
-            }
-            catch {
-                invocation.signal.throwIfAborted();
-            }
-            const response = toOpenScadCompileResponse(rawValidation);
-            const metadataAvailable = compileMetadata.safeParse(rawValidation).success;
-            const validation = response && (response.error || metadataAvailable)
-                ? {
-                    status: response.error ? "invalid" : "valid",
-                    error: response.error || undefined,
-                    warnings: response.warnings,
-                }
-                : {
-                    status: "unavailable",
-                    warnings: [
-                        "OpenSCAD validation is unavailable; compilation and parameter validity could not be confirmed.",
-                    ],
-                };
-            if (validation.status === "invalid" ||
-                (creating &&
-                    (validation.status !== "valid" ||
-                        response?.boundingBox === undefined))) {
-                if (creating && response?.boundingBox === undefined)
-                    validation.warnings.push("The part was not added because validated placement bounds are unavailable.");
-                return {
-                    status: "rejected",
-                    objectId,
-                    revision: target.revision,
-                    validation,
-                    repairAttempts: 0,
-                    repairLimit: MAX_PRINTABILITY_REPAIR_ATTEMPTS,
-                };
-            }
-            const validNames = new Set(response && metadataAvailable
-                ? response.params.map((param) => param.name)
-                : Object.keys(params));
-            const nextParams = Object.fromEntries(Object.entries(params).filter(([name]) => validNames.has(name)));
             const receiptTarget = {
                 parentId: target.parentId,
             };
             if (objectId !== undefined)
                 receiptTarget.objectId = objectId;
             let affectedObjectIds = [];
-            let sceneHealth;
-            const applied = await editor.edit({
+            let affectedAreaIds = [];
+            const applied = await editor.access({
                 capability: "openscad",
                 operation: creating ? "create" : "update",
                 target: () => receiptTarget,
-            }, async (_api, draft, id) => {
+            }, async (api, draft, id) => {
                 operationId = id;
+                const current = draft.getNode(targetId);
+                if (creating === false && (current.kind !== "openScad" || `script:${current.scriptId}` !== resolved.repairKey))
+                    throw new Error("The OpenSCAD target changed. Read it again.");
+                const currentParams = current.kind === "openScad" ? current.params : {};
+                const params = z
+                    .record(z.string(), z.json())
+                    .parse({ ...currentParams, ...source.params });
+                invocation.reportStatus("running", "Compiling the parametric part...");
+                let rawValidation;
+                try {
+                    rawValidation = await api.validateOpenScad(source.source, params);
+                }
+                catch {
+                    invocation.signal.throwIfAborted();
+                }
+                const response = toOpenScadCompileResponse(rawValidation);
+                const metadataAvailable = compileMetadata.safeParse(rawValidation).success;
+                const validation = response && (response.error || metadataAvailable)
+                    ? {
+                        status: response.error ? "invalid" : "valid",
+                        ...(response.error ? { error: response.error } : {}),
+                        warnings: response.warnings,
+                    }
+                    : {
+                        status: "unavailable",
+                        warnings: [
+                            "OpenSCAD validation is unavailable; compilation and parameter validity could not be confirmed.",
+                        ],
+                    };
+                if (validation.status === "invalid" ||
+                    (creating &&
+                        (validation.status !== "valid" ||
+                            response?.boundingBox === undefined))) {
+                    if (creating && response?.boundingBox === undefined)
+                        validation.warnings.push("The part was not added because validated placement bounds are unavailable.");
+                    return { rejected: validation };
+                }
+                const validNames = new Set(response && metadataAvailable
+                    ? response.params.map((param) => param.name)
+                    : Object.keys(params));
+                const nextParams = Object.fromEntries(Object.entries(params).filter(([name]) => validNames.has(name)));
                 if (creating === false) {
                     if (resolved.repairKey === undefined)
                         throw new Error("The OpenSCAD repair target is unavailable.");
@@ -158,7 +143,8 @@ export function createSdkOpenScadHost(options) {
                     });
                     draft.setNodeName(targetId, source.title);
                     draft.setOpenScadScript(targetId, node.scriptId, nextParams);
-                    return { objectId: targetId, repairKey: resolved.repairKey };
+                    affectedAreaIds = [...new Set(affectedObjectIds.map(id => Number(getSdkSceneAreaId(draft, id))))];
+                    return { objectId: targetId, repairKey: resolved.repairKey, validation };
                 }
                 if (options.canGrow?.() === false)
                     throw new Error("OpenSCAD creation is disabled because scene memory is low.");
@@ -186,69 +172,46 @@ export function createSdkOpenScadHost(options) {
                 objectId = node.id;
                 affectedObjectIds = [node.id];
                 Object.assign(receiptTarget, { objectId: node.id, parentId });
-                return { objectId: node.id, repairKey: operationRepairKey };
-            }, source.expectedRevision, invocation, async (operation, api) => {
-                if (objectId === undefined)
-                    return;
-                const areaIds = [
-                    ...new Set(affectedObjectIds.map((id) => getSdkSceneAreaId(api, id))),
-                ];
-                try {
-                    const rendererReady = response?.boundingBox === undefined ||
-                        (creating === false && resolved.rendererBounds === undefined)
-                        ? false
-                        : await waitForOpenScadRenderer({
-                            api,
-                            objectId,
-                            expectedBounds: response.boundingBox,
-                            baselineBounds: resolved.rendererBounds,
-                            signal: invocation.signal,
-                        });
-                    sceneHealth = rendererReady
-                        ? await readStableSdkSceneHealth(api, areaIds, invocation.signal)
-                        : unverifiedSceneHealth(areaIds, "The renderer did not confirm the committed OpenSCAD geometry before health checks.");
-                }
-                catch (error) {
-                    sceneHealth = unverifiedSceneHealth(areaIds, `OpenSCAD renderer checks stopped after the edit committed: ${String(error)}`);
-                }
-                options.onHealth?.(sceneHealth);
+                affectedAreaIds = [Number(getSdkSceneAreaId(draft, node.id))];
+                return { objectId: node.id, repairKey: operationRepairKey, validation };
+            }, invocation, async (operation) => {
                 if (operationRepairKey === undefined)
                     return;
-                const recorded = await geometryRepairs.record(operationRepairKey, operation.id, sceneHealth);
+                const recorded = await geometryRepairs.record(operationRepairKey, operation.id, unverifiedSceneHealth([], "Health was not requested."));
                 return {
-                    sceneHealth,
                     affectedObjectIds,
                     geometryRepairAttempts: recorded.repairAttempts,
                     geometryRepairLimit: recorded.repairLimit,
                 };
             });
+            if (applied.value.rejected)
+                return {
+                    status: "rejected", objectId, validation: applied.value.rejected,
+                    repairAttempts: 0, repairLimit: MAX_PRINTABILITY_REPAIR_ATTEMPTS,
+                };
+            const { validation } = applied.value;
             objectId = applied.value.objectId;
             try {
                 await options.onSelect?.(objectId);
             }
             catch { }
-            const revision = applied.operation.resultRevision ?? source.expectedRevision;
-            if (sceneHealth?.status === "unverified" ||
-                (sceneHealth !== undefined && hasGeometryOverflow(sceneHealth))) {
-                await printabilityRepairs.refund(applied.value.repairKey, operationId);
+            // Geometry repairs do not consume the independent printability budget.
+            // Explicit health must resolve the known geometry failure first.
+            if (repairingGeometry) {
                 return {
                     status: "applied",
                     objectId,
-                    revision,
                     validation,
                     repairAttempts: 0,
                     repairLimit: MAX_PRINTABILITY_REPAIR_ATTEMPTS,
                 };
             }
             invocation.reportStatus("running", "Checking wall thickness...");
-            const printability = await editor.read(invocation, (api, beginSettlement) => (options.requestPrintability ?? requestStableOpenScadPrintability)({
+            const printability = await editor.withConnection(invocation, (api, beginSettlement) => (options.requestPrintability ?? requestTurnOpenScadPrintability)({
                 api,
-                expectedRevision: revision,
                 signal: invocation.signal,
                 onSubmissionStarted: beginSettlement,
-                objectIds: [
-                    ...new Set(affectedObjectIds.map((id) => Number(getSdkSceneAreaId(api, id)))),
-                ],
+                objectIds: affectedAreaIds,
             }));
             invocation.signal.throwIfAborted();
             if (printability.reason === "context_busy") {
@@ -256,7 +219,6 @@ export function createSdkOpenScadHost(options) {
                 return {
                     status: "applied",
                     objectId,
-                    revision,
                     validation,
                     printability,
                     repairAttempts: refunded.repairAttempts,
@@ -267,7 +229,6 @@ export function createSdkOpenScadHost(options) {
             return {
                 status: "applied",
                 objectId,
-                revision,
                 validation,
                 printability,
                 repairAttempts: recorded.repairAttempts,

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

@@ -1,4 +1,5 @@
 import type { SceneHealthHost } from "./capabilities.js";
 import { type SdkSceneEditor } from "./sdk-scene-host.js";
+import { type RepairStateStore } from "./repair-state.js";
 import type { SceneHealth } from "./scene-health.js";
-export declare function createSdkSceneHealthHost(editor: SdkSceneEditor, onHealth?: (health: SceneHealth) => void): SceneHealthHost;
+export declare function createSdkSceneHealthHost(editor: SdkSceneEditor, onHealth?: (health: SceneHealth) => void, repairs?: RepairStateStore): SceneHealthHost;