@womp/spark-agent 7.0.0 → 9.0.0

package/dist/index.js

@@ -5,6 +5,5 @@ export { applyCompaction, latestCompaction } from "./compaction.js";
 export * from "./context-window.js";
 export * from "./capabilities.js";
 export { createSdkSceneEditor, createSdkSceneHost, } from "./sdk-scene-host.js";
-export { recoverSceneOperation } from "./scene-operations.js";
 export { DEFAULT_MODEL_ID, getSparkModel, REASONING_EFFORT_LABELS, resolveReasoningEffort, SPARK_MODELS, } from "./models.js";
 export { SPARK_AGENT_PROMPT, sparkSystemPrompt } from "./prompt.js";

package/dist/intent-bench.js

@@ -342,7 +342,7 @@ async function intentFixtures(testCase, controller) {
                     if (objectId !== 0)
                         return refuse("geometry.read", `Object ${objectId} has no Geometry Nodes graph.`);
                     note("geometry.read");
-                    return { kind: "container", objectId: 0, title: "Scene", source: null, instances: [], diagnostics: [] };
+                    return { kind: "container", objectId: 0, title: "Scene", source: null, transform: null, bounds: null, instances: [], diagnostics: [] };
                 },
                 write: async (options) => decide("geometry-nodes", "geometry.write", options),
             }, geometryReference()),

package/dist/kakapo.d.ts

@@ -1,6 +1,6 @@
 export { KakapoRuntime } from "./runtime.js";
 export { createSdkSceneDraft, createSdkSceneEditor, createSdkSceneHost, type SdkSceneEditor, type SdkSceneEditorOptions, type SdkSceneEditIdentity, type SdkSceneServices, } from "./sdk-scene-host.js";
-export type { SceneOperation, SceneOperationStore, } from "./scene-operations.js";
+export type { SceneOperation } from "./scene-operations.js";
 export { createWompSceneApi, NodeType, OperationType, PrimitiveTypeValue, } from "./womp-scene-api.js";
 export type { WompSceneApi, WompSceneApiContext } from "./womp-scene-api.js";
 export { createSdkGeometryHost, type SdkGeometryHostOptions, } from "./sdk-geometry-host.js";

package/dist/scene-operations.d.ts

@@ -4,10 +4,10 @@ export type SceneEditResult = {
 } | {
     empty: true;
 };
+/** One scene edit's outcome, held for the invocation that made it. */
 export type SceneOperation = {
     id: string;
     targetKey: string;
-    revision: number;
     status: "started" | "prepared" | "committed" | "rolled_back" | "unknown";
     result?: SceneEditResult;
     changed?: boolean;
@@ -17,23 +17,9 @@ export type SceneOperation = {
     };
     completedAt?: string;
 };
-export interface SceneOperationStore {
-    getSceneOperation(targetKey: string, id: string): Promise<SceneOperation | undefined>;
-    createSceneOperation(operation: SceneOperation): Promise<boolean>;
-    saveSceneOperation(operation: SceneOperation): Promise<SceneOperation>;
-}
-/** Recover acknowledged/no-op results without replaying or refetching an uncertain edit. */
-export declare function recoverSceneOperation(options: {
-    api: KakapoAPI;
-    store: SceneOperationStore;
-    targetKey: string;
-    id: string;
-    assertActive(): void | Promise<void>;
-}): Promise<SceneOperation | undefined>;
-/** Hosts may omit persistence; journal-backed hosts retain duplicate-operation protection. */
+/** Applies one edit directly to the scene and reports its outcome; nothing is journaled or replayed. */
 export declare function executeSceneOperation<T>(options: {
     api: KakapoAPI;
-    store?: SceneOperationStore;
     onOutcome?(operation: SceneOperation): void;
     operation: Pick<SceneOperation, "id" | "targetKey">;
     assertEditable(): void | Promise<void>;
@@ -44,5 +30,4 @@ export declare function executeSceneOperation<T>(options: {
 }): Promise<{
     value: T;
     operation: SceneOperation;
-    reused?: boolean;
 }>;

package/dist/scene-operations.js

@@ -42,44 +42,15 @@ function resultValue(operation) {
 function complete(operation, status) {
     return { ...operation, status, completedAt: operation.completedAt ?? new Date().toISOString() };
 }
-/** 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.assertActive();
-    if (previous.changed === false && previous.result) {
-        return options.store.saveSceneOperation(complete(previous, "committed"));
-    }
-    return previous;
-}
-/** Hosts may omit persistence; journal-backed hosts retain duplicate-operation protection. */
+/** Applies one edit directly to the scene and reports its outcome; nothing is journaled or replayed. */
 export async function executeSceneOperation(options) {
-    const { api, store, operation: identity } = options;
+    const { api, operation: identity } = options;
     const savesScene = options.saveToRenderer === true;
     await options.assertEditable();
-    const previous = await store?.getSceneOperation(identity.targetKey, identity.id);
-    if (previous && store) {
-        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, 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, 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 = {
-        ...identity, revision: 0, status: "started",
+        ...identity, status: "started",
         ...(savesScene ? { save: { status: "unknown" } } : {}),
     };
-    if (store && !await store.createSceneOperation(operation))
-        throw new Error("Scene operation is already in progress");
     try {
         const edit = async (draft) => {
             await options.assertEditable();
@@ -94,8 +65,6 @@ export async function executeSceneOperation(options) {
                     ...operation, status: "prepared", changed,
                     ...(savesScene && !changed ? { save: { status: "not_needed" } } : {}),
                 };
-                if (store)
-                    operation = await store.saveSceneOperation(operation);
                 await options.assertEditable();
                 if (changed)
                     await options.prepareCommit?.(operation);
@@ -118,16 +87,11 @@ export async function executeSceneOperation(options) {
                 ...(operation.save && status === "rolled_back" ? { save: { status: "not_needed" } } : {}),
             };
             options.onOutcome?.(operation);
-            if (store)
-                operation = await store.saveSceneOperation(operation);
         }
         catch {
-            // Keep the original error; recovery can inspect the prepared record.
+            // Keep the original error.
         }
         throw error;
     }
-    // A prepared record alone never proves an uncertain commit succeeded.
-    if (store)
-        operation = await store.saveSceneOperation(complete(operation, "committed"));
     return { value: resultValue(operation), operation };
 }

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

@@ -1,5 +1,5 @@
-import { type SdkSceneEditor } from "./sdk-scene-host.js";
 import type { GeometryHost } from "./capabilities.js";
+import { type SdkSceneEditor } from "./sdk-scene-host.js";
 import { readSdkSceneHealth } from "./scene-health.js";
 import { type RepairStateStore } from "./repair-state.js";
 export type SdkGeometryHostOptions = {