@womp/spark-agent 8.0.0 → 9.1.0

package/dist/materials/types.d.ts

@@ -101,9 +101,24 @@ export type MaterialWriteResult = {
         color: MaterialVector;
         exposed?: boolean;
     }[];
+    /** Parameter overrides reset by a FlowIR replacement. */
+    diagnostics?: string[];
     status: "applied";
     rendering: "unverified";
 };
+export type MaterialProgramWrite = {
+    materialId?: number;
+    cloneFrom?: number;
+    layerIndex: number;
+    source: string;
+    objectIds?: number[];
+};
+export type MaterialProgramRead = {
+    materialId: number;
+    layerIndex: number;
+    source: string | null;
+    diagnostics: string[];
+};
 export type MaterialNodeOptions = {
     op: string;
     name?: string;

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.js

@@ -246,8 +246,7 @@ export function createSdkGeometryHost(options) {
             }
             catch (error) {
                 if (operationId !== undefined && repairKey !== undefined) {
-                    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 repairs.refund(repairKey, operationId);
                 }
                 throw error;

package/dist/sdk-materials-host.js

@@ -1,5 +1,8 @@
 import { sparkErrorDiagnostics } from "./error-diagnostics.js";
-import { graphSchema, materialId, parseMaterialCatalog, validateMaterialGraph, writeSchema, value3, } from "./materials/graph.js";
+import { graphSchema, materialId, parseMaterialCatalog, validateMaterialGraph, writeSchema, programWriteSchema, value3, } from "./materials/graph.js";
+import { comparableMaterialGraph, compileMaterialFlowir } from "./materials/flowir.js";
+import { liftMaterialFlowir } from "./materials/lift.js";
+import { boundedDiagnostics } from "./geometry/diagnostics.js";
 function record(value, label) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         throw new Error(`Invalid ${label}`);
@@ -115,7 +118,7 @@ export function createSdkMaterialsHost(options) {
             ],
         };
     };
-    return {
+    const host = {
         catalog: (settings, context) => options.editor.read(context, async (api) => {
             const nodes = await catalogue(api, context, settings.refreshTextures === true);
             const selected = {};
@@ -200,7 +203,7 @@ export function createSdkMaterialsHost(options) {
                 explanation: "A zero queue does not prove compilation, texture loading or the new rendered appearance succeeded. Inspect a scene screenshot.",
             };
         }),
-        write: async (input, context) => {
+        write: async (input, context, program) => {
             const request = writeSchema.parse(input);
             await options.assertAvailable(context);
             let resultId = request.materialId;
@@ -211,7 +214,8 @@ export function createSdkMaterialsHost(options) {
             }, async (api, draft) => {
                 await options.assertAvailable(context);
                 context.signal.throwIfAborted();
-                if (request.materialId !== undefined &&
+                if (program === undefined &&
+                    request.materialId !== undefined &&
                     request.layers === undefined &&
                     request.constants === undefined) {
                     draft.getMaterial(request.materialId);
@@ -226,12 +230,58 @@ export function createSdkMaterialsHost(options) {
                 const catalog = await catalogue(api, context, false);
                 const sourceId = request.materialId ?? request.cloneFrom;
                 const original = sourceId === undefined ? undefined : rawMaterial(draft, sourceId);
-                const graphs = (request.layers ??
-                    (sourceId === undefined ? [] : layers(draft, sourceId))).map((graph) => graph === null ? null : validateMaterialGraph(graph, catalog));
-                let rewriteGraphs = request.layers !== undefined || request.materialId === undefined;
+                const sourceLayers = sourceId === undefined ? [] : layers(draft, sourceId);
+                const proposedLayers = program ? [...sourceLayers] : request.layers ?? sourceLayers;
+                let programSymbols;
+                const programDiagnostics = [];
+                if (program) {
+                    while (proposedLayers.length <= program.layerIndex)
+                        proposedLayers.push(null);
+                    const compiled = compileMaterialFlowir(program.source, catalog);
+                    const replacement = compiled.graph;
+                    programSymbols = compiled.symbols;
+                    const previous = sourceLayers[program.layerIndex];
+                    for (const node of replacement.nodes) {
+                        const matches = previous?.nodes.filter(candidate => candidate.op === node.op && candidate.name === node.name) ?? [];
+                        const old = matches.length === 1 ? matches[0] : undefined;
+                        if (!old || node.name === undefined)
+                            continue;
+                        if (old.location !== undefined)
+                            node.location = old.location;
+                        if (old.editor_flags !== undefined)
+                            node.editor_flags = old.editor_flags;
+                        if (node.op !== "Constant")
+                            continue;
+                        const exposure = node.in3.x;
+                        const oldExposure = old.in3?.x ?? 0;
+                        const nodeSlot = replacement.connections.find(edge => edge.input_node === replacement.nodes.indexOf(node))?.input_slot;
+                        const oldSlot = previous?.connections.find(edge => edge.input_node === previous.nodes.indexOf(old))?.input_slot;
+                        const vectorWidget = exposure === 1 && oldExposure === 2 && oldSlot === 1;
+                        const compatible = (nodeSlot === oldSlot && exposure === oldExposure) || vectorWidget;
+                        if (compatible) {
+                            if (vectorWidget) {
+                                node.in1 = node.in2;
+                                delete node.in2;
+                                for (const edge of replacement.connections)
+                                    if (edge.input_node === replacement.nodes.indexOf(node) && edge.input_slot === 2)
+                                        edge.input_slot = 1;
+                            }
+                            if (old.reference_id !== undefined)
+                                node.reference_id = old.reference_id;
+                            if (old.in3 !== undefined)
+                                node.in3 = old.in3;
+                        }
+                    }
+                    for (const option of previous?.nodes.filter(node => node.op === "Options") ?? [])
+                        replacement.nodes.push(option);
+                    proposedLayers[program.layerIndex] = replacement;
+                }
+                const graphs = proposedLayers.map((graph, slot) => graph === null ? null : program && slot !== program.layerIndex ? graph : validateMaterialGraph(graph, catalog));
+                let rewriteGraphs = program !== undefined || request.layers !== undefined || request.materialId === undefined;
                 const used = allReferences(draft);
                 const refs = new Map();
-                for (const graph of graphs)
+                const changedGraphs = program && request.materialId !== undefined ? [graphs[program.layerIndex]] : graphs;
+                for (const graph of changedGraphs)
                     for (const node of graph?.nodes ?? [])
                         if (node.op === "Constant") {
                             const id = typeof node.reference_id === "number" && node.reference_id > 0
@@ -249,6 +299,18 @@ export function createSdkMaterialsHost(options) {
                     ? record(original.data, "material data")
                     : undefined;
                 const constants = record(sourceData?.constants ?? {}, "material constants");
+                if (program) {
+                    const retained = new Set(graphs.flatMap(graph => graph?.nodes.filter(node => node.op === "Constant").map(node => String(node.reference_id)) ?? []));
+                    for (const node of sourceLayers[program.layerIndex]?.nodes ?? []) {
+                        if (node.op !== "Constant" || retained.has(String(node.reference_id)))
+                            continue;
+                        const key = String(node.reference_id);
+                        if (constants[key] !== undefined) {
+                            delete constants[key];
+                            programDiagnostics.push(`Reset override for ${String(node.name ?? key)}: parameter removed or type changed.`);
+                        }
+                    }
+                }
                 const referenceIdChanges = {};
                 for (const [key, override] of Object.entries(request.constants ?? {})) {
                     const node = refs.get(Number(key));
@@ -264,7 +326,7 @@ export function createSdkMaterialsHost(options) {
                     // Replaced graphs can reuse IDs whose deleted overrides remain in the native cache.
                     if (request.constants?.[key] === null ||
                         (request.materialId !== undefined &&
-                            request.layers !== undefined &&
+                            (request.layers !== undefined || program !== undefined) &&
                             constants[key] === undefined)) {
                         const id = freshReference(used);
                         rewriteGraphs = true;
@@ -286,6 +348,8 @@ export function createSdkMaterialsHost(options) {
                 const slots = graphs.map((graph, slot) => {
                     if (graph === null)
                         return 0;
+                    if (program && request.materialId !== undefined && slot !== program.layerIndex)
+                        return materialId.parse(oldSlots[slot]);
                     if (!rewriteGraphs)
                         return materialId.parse(oldSlots[slot]);
                     const oldId = oldSlots[slot];
@@ -310,6 +374,30 @@ export function createSdkMaterialsHost(options) {
                 });
                 while (slots.length < 8)
                     slots.push(0);
+                if (program) {
+                    const ext = draft.getSceneExt();
+                    if (!ext.shadersExt)
+                        draft.patchSceneExt([{ op: "add", path: "/shadersExt", value: {} }], { returnScene: false });
+                    const previousMetadata = ext.shadersExt;
+                    if (request.cloneFrom !== undefined)
+                        for (let slot = 0; slot < slots.length; slot++) {
+                            if (slot === program.layerIndex || !slots[slot])
+                                continue;
+                            const originalShader = oldSlots[slot];
+                            const metadata = previousMetadata?.[String(originalShader)];
+                            if (metadata !== undefined)
+                                draft.patchSceneExt([{ op: "add", path: `/shadersExt/${slots[slot]}`, value: metadata }], { returnScene: false });
+                        }
+                    draft.patchSceneExt([{
+                            op: "add",
+                            path: `/shadersExt/${slots[program.layerIndex]}`,
+                            value: {
+                                ...record(previousMetadata?.[String(oldSlots[program.layerIndex])] ?? {}, "shader metadata"),
+                                flowirSource: program.source,
+                                flowirSymbols: programSymbols,
+                            },
+                        }], { returnScene: false });
+                }
                 patchEntry(draft, "materials", resultId, {
                     ...target,
                     ...(original ?? {}),
@@ -339,7 +427,8 @@ export function createSdkMaterialsHost(options) {
                     materialId: resultId,
                     objectIds: directUsers(draft, resultId),
                     referenceIdChanges,
-                    parameters: graphs.flatMap(graph => graph?.nodes.filter(node => node.op === "Constant").map(node => {
+                    ...(program ? { diagnostics: boundedDiagnostics(programDiagnostics) } : {}),
+                    parameters: (program ? changedGraphs : graphs).flatMap(graph => graph?.nodes.filter(node => node.op === "Constant").map(node => {
                         const referenceId = node.reference_id;
                         const override = constants[String(referenceId)];
                         return { name: node.name ?? "", referenceId,
@@ -356,5 +445,42 @@ export function createSdkMaterialsHost(options) {
                 rendering: "unverified",
             };
         },
+        writeProgram: async (input, context) => {
+            const request = programWriteSchema.parse(input);
+            return host.write({
+                ...(request.materialId === undefined ? {} : { materialId: request.materialId }),
+                ...(request.cloneFrom === undefined ? {} : { cloneFrom: request.cloneFrom }),
+                ...(request.objectIds === undefined ? {} : { objectIds: request.objectIds }),
+            }, context, request);
+        },
+        readProgram: async (material, layerIndex, context) => options.editor.read(context, async (api) => {
+            await options.assertAvailable(context);
+            context.signal.throwIfAborted();
+            const id = materialId.parse(material);
+            if (!Number.isInteger(layerIndex) || layerIndex < 0 || layerIndex > 7)
+                throw new Error("layerIndex must be within 0..7");
+            const materialData = rawMaterial(api, id);
+            const shaderId = Array.isArray(materialData.shaders) ? materialData.shaders[layerIndex] : undefined;
+            if (typeof shaderId !== "number" || shaderId <= 0)
+                return { materialId: id, layerIndex, source: null, diagnostics: ["This layer is empty."] };
+            const metadata = api.getSceneExt().shadersExt?.[String(shaderId)];
+            const source = metadata?.flowirSource;
+            const catalog = await catalogue(api, context, false);
+            const actual = layers(api, id)[layerIndex];
+            if (!actual)
+                return { materialId: id, layerIndex, source: null, diagnostics: ["This layer is empty."] };
+            try {
+                if (typeof source === "string") {
+                    const rebuilt = compileMaterialFlowir(source, catalog).graph;
+                    if (comparableMaterialGraph(rebuilt) === comparableMaterialGraph(actual))
+                        return { materialId: id, layerIndex, source, diagnostics: [] };
+                }
+                return { materialId: id, layerIndex, source: liftMaterialFlowir(actual, catalog), diagnostics: [] };
+            }
+            catch (error) {
+                return { materialId: id, layerIndex, source: null, diagnostics: boundedDiagnostics([sparkErrorDiagnostics(error).message]) };
+            }
+        }),
     };
+    return host;
 }

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<{

package/dist/sdk-scene-host.js

@@ -10,7 +10,7 @@ function assertSceneSaved(operation) {
     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.");
 }
-/** 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 class SceneOperationError extends Error {
     operation;
     constructor(operation, cause) {
@@ -74,7 +74,6 @@ export function createSdkSceneDraft(api, scene, services) {
 export function createSdkSceneEditor(options) {
     const ordinals = new WeakMap();
     return {
-        getOperation: (operationId) => options.operations?.getSceneOperation(options.targetKey, operationId) ?? Promise.resolve(undefined),
         withConnection: (context, action) => options.withConnection(context, async (api, settle, active = context) => {
             active.signal.throwIfAborted();
             return action(api, settle);
@@ -131,7 +130,6 @@ export function createSdkSceneEditor(options) {
                             result: operation.result,
                             save: operation.save,
                             error: operation.error,
-                            ...(options.operations ? { synchronized } : {}),
                         }),
                     });
                 };
@@ -142,7 +140,6 @@ export function createSdkSceneEditor(options) {
                     try {
                         result = await executeSceneOperation({
                             api,
-                            store: options.operations,
                             onOutcome: operation => { outcome = operation; },
                             saveToRenderer: options.saveToRenderer,
                             operation: {
@@ -168,10 +165,9 @@ export function createSdkSceneEditor(options) {
                     catch (error) {
                         // Receipt persistence must not replace the original SDK/tool error.
                         try {
-                            const operation = outcome ?? await options.operations?.getSceneOperation(options.targetKey, id);
-                            if (operation) {
-                                synchronized = operation.status === "rolled_back";
-                                await record(operation);
+                            if (outcome) {
+                                synchronized = outcome.status === "rolled_back";
+                                await record(outcome);
                             }
                         }
                         catch {
@@ -180,12 +176,6 @@ 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) {
@@ -216,7 +206,7 @@ export function createSdkSceneEditor(options) {
                     return result;
                 }
                 catch (error) {
-                    if (!options.operations && outcome)
+                    if (outcome)
                         throw new SceneOperationError(outcome, error);
                     throw error;
                 }

package/dist/server/sqlite-store.d.ts

@@ -2,11 +2,10 @@ import type { SparkGoal } from "../goals.js";
 import type { ExecutionScreenshot } from "../types.js";
 import type { SparkArtifact, StoredSparkChunk } from "../ui.js";
 import type { SparkArtifactStore, StoredSparkArtifact } from "./artifacts.js";
-import type { SceneOperation, SceneOperationStore } from "../scene-operations.js";
 import { type RepairStateStore } from "../repair-state.js";
 import type { SparkAgentStore, SparkConversation, SparkConversationSummary, SparkRun, SparkRunSettings } from "./types.js";
 /** Local development storage. Execution ownership belongs to the host service. */
-export declare class SqliteSparkStore implements SparkAgentStore, SparkArtifactStore, SceneOperationStore {
+export declare class SqliteSparkStore implements SparkAgentStore, SparkArtifactStore {
     private readonly artifactBaseUrl;
     private readonly database;
     private ownershipToken;
@@ -15,9 +14,6 @@ export declare class SqliteSparkStore implements SparkAgentStore, SparkArtifactS
     close(): void;
     claimExecutionOwnership(): void;
     listInterruptedRuns(): Promise<SparkRun[]>;
-    getSceneOperation(targetKey: string, id: string): Promise<SceneOperation | undefined>;
-    createSceneOperation(operation: SceneOperation): Promise<boolean>;
-    saveSceneOperation(operation: SceneOperation): Promise<SceneOperation>;
     createConversation(value: SparkConversation): Promise<void>;
     getConversation(id: string): Promise<SparkConversation | undefined>;
     listConversations(ownerId: string): Promise<SparkConversationSummary[]>;

package/dist/server/sqlite-store.js

@@ -2,7 +2,6 @@ import { mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { emptyRepairState, } from "../repair-state.js";
-const completedSceneOperationLimit = 128;
 /** Local development storage. Execution ownership belongs to the host service. */
 export class SqliteSparkStore {
     artifactBaseUrl;
@@ -13,7 +12,7 @@ export class SqliteSparkStore {
         mkdirSync(dirname(path), { recursive: true });
         this.database = new DatabaseSync(path);
         const version = this.database.prepare("PRAGMA user_version").get()?.user_version;
-        if (version !== 0 && version !== 1 && version !== 2 && version !== 3 && version !== 4) {
+        if (version !== 0 && version !== 1 && version !== 2 && version !== 3 && version !== 4 && version !== 5) {
             this.database.close();
             throw new Error(`Unsupported Spark database version: ${version}`);
         }
@@ -39,14 +38,11 @@ export class SqliteSparkStore {
       CREATE TABLE IF NOT EXISTS execution_owner (
         singleton INTEGER PRIMARY KEY CHECK (singleton = 1), pid INTEGER NOT NULL, token TEXT NOT NULL
       );
-      CREATE TABLE IF NOT EXISTS scene_operations (
-        target_key TEXT NOT NULL, id TEXT NOT NULL, revision INTEGER NOT NULL, data TEXT NOT NULL,
-        PRIMARY KEY (target_key, id)
-      );
+      DROP TABLE IF EXISTS scene_operations;
       CREATE TABLE IF NOT EXISTS repair_states (
         target_key TEXT PRIMARY KEY, revision INTEGER NOT NULL, data TEXT NOT NULL
       );
-      PRAGMA user_version = 4;
+      PRAGMA user_version = 5;
     `);
     }
     repairStateStore(targetKey) {
@@ -111,39 +107,6 @@ export class SqliteSparkStore {
             throw new Error("Claim execution ownership before recovering runs");
         return this.database.prepare("SELECT data FROM runs WHERE json_extract(data, '$.status') IN ('queued', 'running')").all().map((row) => JSON.parse(String(row.data)));
     }
-    async getSceneOperation(targetKey, id) {
-        const row = this.database.prepare("SELECT data FROM scene_operations WHERE target_key = ? AND id = ?").get(targetKey, id);
-        return row ? JSON.parse(String(row.data)) : undefined;
-    }
-    async createSceneOperation(operation) {
-        const result = this.database.prepare("INSERT OR IGNORE INTO scene_operations VALUES (?, ?, ?, ?)").run(operation.targetKey, operation.id, operation.revision, JSON.stringify(operation));
-        return result.changes === 1;
-    }
-    async saveSceneOperation(operation) {
-        const next = { ...operation, revision: operation.revision + 1 };
-        this.database.exec("BEGIN IMMEDIATE");
-        try {
-            const result = this.database.prepare("UPDATE scene_operations SET revision = ?, data = ? WHERE target_key = ? AND id = ? AND revision = ?").run(next.revision, JSON.stringify(next), operation.targetKey, operation.id, operation.revision);
-            if (result.changes !== 1)
-                throw new Error("Scene operation changed concurrently or is missing");
-            if (next.status === "committed" || next.status === "rolled_back") {
-                this.database.prepare(`
-          DELETE FROM scene_operations WHERE rowid IN (
-            SELECT rowid FROM scene_operations
-            WHERE target_key = ? AND json_extract(data, '$.status') IN ('committed', 'rolled_back')
-            ORDER BY COALESCE(json_extract(data, '$.completedAt'), '') DESC
-            LIMIT -1 OFFSET ?
-          )
-        `).run(next.targetKey, completedSceneOperationLimit);
-            }
-            this.database.exec("COMMIT");
-            return next;
-        }
-        catch (error) {
-            this.database.exec("ROLLBACK");
-            throw error;
-        }
-    }
     async createConversation(value) {
         this.database.prepare("INSERT INTO conversations VALUES (?, ?, ?, ?)")
             .run(value.id, value.ownerId, value.updatedAt, JSON.stringify(value));

package/dist/server/standalone.js

@@ -102,7 +102,6 @@ export async function createStandaloneSparkAgentApp(options) {
                 const targetKey = `${context.ownerId}:${sceneIdentity}`;
                 const editorOptions = {
                     targetKey,
-                    operations: store,
                     saveToRenderer: true,
                     withConnection: (invocation, action) => sceneAccess.run(invocation.signal, async (signal, beginSettlement) => {
                         if (!api.isConnected)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@womp/spark-agent",
-  "version": "8.0.0",
+  "version": "9.1.0",
   "description": "Portable skills-based AI agent with local and durable chat transports for Womp",
   "type": "module",
   "main": "./dist/index.js",
@@ -74,6 +74,7 @@
     "dist/**/*.d.ts",
     "dist/server/fixtures/**/*.json",
     "dist/geometry/schemas/**/*.json",
+    "dist/materials/schemas/**/*.json",
     "README.md",
     "CHANGELOG.md"
   ],
@@ -105,6 +106,7 @@
     "web:build": "yarn build && tsc --noEmit -p web/tsconfig.json && vite build --config web/vite.config.ts",
     "test": "yarn build && tsx --tsconfig tsconfig.json --test test/**/*.test.ts && node --input-type=module -e \"await Promise.all([import('@womp/spark-agent'), import('@womp/spark-agent/ui'), import('@womp/spark-agent/client'), import('@womp/spark-agent/server'), import('@womp/spark-agent/express'), import('@womp/spark-agent/kakapo'), import('@womp/spark-agent/geometry'), import('@womp/spark-agent/openscad')])\"",
     "test:live": "tsx --tsconfig tsconfig.json test/womp-scene-api.live.ts",
+    "test:live:materials": "tsx --tsconfig tsconfig.json test/materials-flowir.live.ts",
     "prepack": "yarn build",
     "release:pack": "node scripts/npm-release.mjs pack"
   },