@womp/spark-agent 6.5.0 → 8.0.0

package/dist/index.js

@@ -1,7 +1,8 @@
 export { runSparkAgent, } from "./agent.js";
 export { createSparkTools } from "./agent-tools.js";
 export { convertSparkMessages } from "./model-history.js";
-export * from "./context-budget.js";
+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";

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

package/dist/sdk-geometry-host.js

@@ -1,293 +1,295 @@
+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) {
+                    const operation = error instanceof SceneOperationError ? error.operation : await editor.getOperation(operationId);
+                    if (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/ui.d.ts

@@ -106,6 +106,12 @@ export type SparkSelectionData = {
 export type SparkCompaction = {
     /** The user message the model reads verbatim from; everything before it is summarized. */
     firstKeptMessageId: string;
+    /**
+     * Set when the summary was written during its turn: the first step of the
+     * recording message the model still reads, counted from 0. Its earlier steps
+     * are summarized too.
+     */
+    firstKeptStep?: number;
     summary: string;
     /** Skills read in the summarized messages; their current text is sent after the summary. */
     skills: string[];
@@ -363,6 +369,7 @@ export declare const sparkDataPartSchemas: {
     }, z.core.$strip>;
     readonly compaction: z.ZodObject<{
         firstKeptMessageId: z.ZodString;
+        firstKeptStep: z.ZodOptional<z.ZodNumber>;
         summary: z.ZodString;
         skills: z.ZodArray<z.ZodString>;
         modelId: z.ZodString;

package/dist/ui.js

@@ -88,6 +88,7 @@ export const sparkDataPartSchemas = {
     selection: z.object({ nodeIds: z.array(z.string().min(1).max(64)).min(1).max(8192) }),
     compaction: z.object({
         firstKeptMessageId: z.string().min(1),
+        firstKeptStep: z.number().int().positive().optional(),
         summary: z.string().min(1),
         skills: z.array(z.string().min(1)),
         modelId: z.string(),

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

@@ -1,4 +1,4 @@
-import type { FontFamily, KakapoAPI, KakapoNode, NodeKind, SceneEdit, Vec2, Vec3 } from "@womp/kakapo-sdk";
+import type { BoundingBox, FontFamily, KakapoAPI, KakapoNode, NodeKind, SceneEdit, Vec2, Vec3 } from "@womp/kakapo-sdk";
 import { type SceneHdr } from "./scene-environment.js";
 import { type MirrorAxis } from "./coordinates.js";
 export declare const NodeType: {
@@ -81,6 +81,14 @@ export type WompSceneApiContext = {
 };
 export type WompSceneApi = ReturnType<typeof createWompSceneApi>;
 export declare function sceneNodeType(kind: NodeKind): number;
+export declare function convertAABB(box: BoundingBox, unitMultiplier: number): AABB;
+export type SceneNodeReader = {
+    requireNode(id: number): KakapoNode;
+    getNode(id: number): KakapoNode;
+};
+export declare function sceneNodePosition(reader: SceneNodeReader, rootId: number, unitMultiplier: number, id: number): Vec3;
+export declare function sceneNodeRotation(reader: SceneNodeReader, id: number): Vec3;
+export declare function sceneNodeSize(reader: SceneNodeReader, rootId: number, unitMultiplier: number, id: number): Vec3;
 /** Align local +Z toward target. Both points are in the same parent-local coordinates. */
 declare function lookAt(origin: Vec3, target: Vec3): Vec3;
 /** XYZ degrees aligning the selected positive local axis to a parent-local direction. */