@zenera/neo 1.1.11 → 1.1.12

package/dist/inspect/client.js

@@ -60,6 +60,15 @@ const ROOT = flatten(STATE.trajectory, 0, null);
 
 function names(list) { return list.join(', '); }
 
+// The edges are what makes a recollection a subgraph rather than a hit list,
+// so they are shown even though the injected block already renders them.
+function edgeLines(edges) {
+  if (!edges || !edges.length) return '';
+  return '\\n\\n' + edges.map(function (e) {
+    return e.source + ' --' + e.relation + '--> ' + e.target;
+  }).join('\\n');
+}
+
 function base(path) { return path.split('/').pop() || path; }
 
 function label(n) {
@@ -68,8 +77,8 @@ function label(n) {
     case 'system_prompt': return 'system prompt'
       + (n.sources && n.sources.length ? ': ' + names(n.sources.map(function (s) { return base(s.path); })) : '');
     case 'load_skills': return 'skills: ' + names(n.skills.map(function (s) { return s.name; }));
-    case 'memory_recall': return 'memory recall: ' + n.scope;
-    case 'memory_op': return 'memory ' + n.op;
+    case 'memory_recall': return 'memory recall: ' + n.nodes.length + ' nodes';
+    case 'memory_op': return 'memory ' + n.op + ': ' + n.nodes.length + ' nodes';
     case 'llm_call': return 'llm: ' + n.model + (n.toolCalls.length
       ? ' -> ' + names(n.toolCalls.map(function (c) { return c.name; })) : '');
     case 'tool_call': return 'call: ' + n.name;
@@ -512,18 +521,20 @@ function detailFor(e) {
       break;
 
     case 'memory_recall':
-      out.appendChild(textBlock('Query', JSON.stringify(n.query, null, 2), n.store + ' · ' + n.scope));
-      out.appendChild(textBlock('Hits', n.hits.map(function (hit) {
-        return hit.id + '  score=' + hit.score + '  rev=' + hit.revision;
-      }).join('\\n')));
+      out.appendChild(textBlock('Query', JSON.stringify(n.query, null, 2),
+        n.seeds.length + ' seed(s)'));
+      out.appendChild(textBlock('Subgraph', n.nodes.map(function (m) {
+        return m.id + '  ' + m.kind
+          + (n.seeds.indexOf(m.id) >= 0 ? '  score=' + m.score.toFixed(3) : '  (stitched)');
+      }).join('\\n') + edgeLines(n.edges)));
       out.appendChild(textBlock('Injected block', blob(n.content)));
       break;
 
     case 'memory_op':
-      out.appendChild(textBlock('Operation',
-        n.op + ' ' + n.recordId + ' (rev ' + n.revision + ')', n.store + ' · ' + n.scope));
-      if (n.before) out.appendChild(textBlock('Before', blob(n.before)));
-      if (n.after) out.appendChild(textBlock('After', blob(n.after)));
+      out.appendChild(textBlock('Operation', n.nodes.map(function (m) {
+        return n.op + ' ' + m.id + '  ' + m.kind + '  rev ' + m.revision;
+      }).join('\\n') + edgeLines(n.edges),
+        n.files ? n.files + ' file(s)' : undefined));
       break;
 
     case 'llm_call': {
@@ -998,6 +1009,14 @@ function diagram() {
   return lines.join('\\n');
 }
 
+// Mermaid refuses a diagram past either of these (defaults 500 edges and
+// 50000 characters, which a long run passes easily) and the pane then shows
+// only its error. Both are "secure" options, so initialize() is the one place
+// they can be raised from. The report is a file on disk, not a live page —
+// a slow render beats a refused one.
+const MAX_EDGES = 20000;
+const MAX_TEXT_SIZE = 5000000;
+
 // One Mermaid, two diagrams. Loading it is the only network the page does, so
 // it happens once and both panes wait on the same promise.
 let mermaidLib = null;
@@ -1006,6 +1025,7 @@ function mermaid() {
     mermaidLib = import(MERMAID_URL).then(function (m) {
       m.default.initialize({
         startOnLoad: false, theme: 'dark', securityLevel: 'strict',
+        maxEdges: MAX_EDGES, maxTextSize: MAX_TEXT_SIZE,
         flowchart: { htmlLabels: false }
       });
       return m.default;
@@ -1098,7 +1118,7 @@ ENTRIES.forEach(function (e) {
   } else if (n.type === 'handoff') {
     bump(USED.handoffs, n.from + SEP + n.to, e.key);
   } else if (n.type === 'memory_recall' || n.type === 'memory_op') {
-    bump(USED.memory, n.agent + SEP + n.store + '/' + n.scope, e.key);
+    bump(USED.memory, n.agent, e.key);
   } else if (n.type === 'fork') {
     n.branches.forEach(function (b) { bump(USED.forks, n.agent + SEP + b.agent, e.key); });
   }
@@ -1113,7 +1133,7 @@ function observedArchitecture() {
   const byName = new Map();
   function agentOf(name) {
     if (!byName.has(name)) {
-      byName.set(name, { name: name, tools: [], handoffs: [], memory: [] });
+      byName.set(name, { name: name, tools: [], handoffs: [] });
     }
     return byName.get(name);
   }
@@ -1142,15 +1162,10 @@ function observedArchitecture() {
       agentOf(n.to);
       if (from.handoffs.indexOf(n.to) < 0) from.handoffs.push(n.to);
     } else if (n.type === 'memory_recall' || n.type === 'memory_op') {
-      const known = a.memory.some(function (m) {
-        return m.store === n.store && m.scope === n.scope;
-      });
-      if (!known) {
-        a.memory.push({
-          store: n.store, scope: n.scope,
-          access: n.type === 'memory_op' ? 'read-write' : 'read'
-        });
-      }
+      // A run shows that an agent reached the memory, never how wide its mask
+      // was: nothing it did not read leaves a trace to read the mask off.
+      if (!a.memory) a.memory = { access: 'read', sees: [], writes: [] };
+      if (n.type === 'memory_op') a.memory.access = 'read-write';
     } else if (n.type === 'fork') {
       if (!a.fork) a.fork = { agents: [] };
       n.branches.forEach(function (b) {
@@ -1255,15 +1270,16 @@ function archDiagram() {
       lines.push('  ' + self + ' --- ' + k);
     }
 
-    a.memory.forEach(function (m) {
-      const used = USED.memory.get(a.name + SEP + m.store + '/' + m.scope);
+    if (a.memory) {
+      const used = USED.memory.get(a.name);
       const k = archKey(used);
-      lines.push('  ' + k + '[("' + safe(m.store) + ' / ' + safe(m.scope)
-        + (m.access === 'read-write' ? ' (rw)' : ' (ro)') + '")]');
+      const sees = Array.isArray(a.memory.sees) ? a.memory.sees : [a.memory.sees];
+      lines.push('  ' + k + '[("memory ' + (a.memory.access === 'read' ? '(ro)' : '(rw)')
+        + ' sees ' + safe(sees.join(' ') || '*') + '")]');
       lines.push('  class ' + k + ' mem;');
       if (!used) lines.push('  class ' + k + ' idle;');
       lines.push('  ' + self + ' --- ' + k);
-    });
+    }
     lines.push('  end');
     // Mermaid's default subgraph is a light box, which on a dark page reads as
     // the foreground rather than as the container. An agent nobody entered is

package/dist/kernel.d.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { Agent, AgentRegistry } from './agent.ts';
 import type { PendingToolCall } from './events.ts';
 import { type IdClock } from './ids.ts';
-import { type MemoryOpSpec, type MemoryRecallSpec } from './memory.ts';
+import type { MemoryOpSpec, MemoryRecallSpec } from './memory/types.ts';
 import type { ModelRequest, ModelResponse } from './model.ts';
 import type { Services } from './services.ts';
 import { type Skill } from './skills.ts';

package/dist/kernel.js

@@ -1,7 +1,8 @@
 import { z } from 'zod';
 import { Agent, AgentRegistry, handoffTarget, handoffTool } from "./agent.js";
 import { systemClock } from "./ids.js";
-import { memoryTools } from "./memory.js";
+import { memoryInstructions, renderPreferences } from "./memory/instructions.js";
+import { memoryTools } from "./memory/tools.js";
 import { hash } from "./payload.js";
 import { composePrompt } from "./prompt.js";
 import { allows, lockedSkillTools, renderSkillIndex, renderSkills, skillContentHash, skillTools, } from "./skills.js";
@@ -285,7 +286,10 @@ export async function resolveTools(state, reg, env) {
     for (const name of agent.handoffs) {
         tools.push(handoffTool(name, reg.find(name)?.description));
     }
-    tools.push(...memoryTools(agent.memoryBindings(ctx)));
+    const binding = agent.memoryBinding(ctx);
+    if (binding && env.services.memory) {
+        tools.push(...memoryTools({ index: env.services.memory, binding }));
+    }
     if (agent.skills) {
         const binding = agent.skills;
         tools.push(...skillTools(binding));
@@ -318,14 +322,24 @@ function toSchema(t) {
     return { name: t.name, description: t.description, parameters: t.parameters };
 }
 /**
- * Prompt text the runtime owns rather than the author: the skill index and the
- * `final_output` instruction. Both used to be appended inside `buildRequest`,
- * which meant part of the system prompt existed in no node and showed up in no
- * audit. Composed in now, always last, so the volatile tail never invalidates
- * the cacheable prefix.
+ * Prompt text the runtime owns rather than the author: how to use memory, the
+ * user's standing preferences, the skill index and the `final_output`
+ * instruction. Most used to be appended inside `buildRequest`, which meant part
+ * of the system prompt existed in no node and showed up in no audit. Composed
+ * in now, always last, so the volatile tail never invalidates the cacheable
+ * prefix.
  */
 async function derivedPrompt(agent, state, env) {
     const out = [];
+    const memory = agent.memoryBinding(state.context);
+    if (memory && env.services.memory) {
+        // The one part of the prompt that reads mutable state. It is allowed
+        // because preferences change at most once in a run and
+        // `applySystemPrompt` is keyed on the rendered bytes, so a commit
+        // re-renders the prefix once rather than every turn.
+        out.push(memoryInstructions(memory));
+        out.push(renderPreferences(env.services.memory.preferences(memory.sees)));
+    }
     if (agent.skills?.discovery === 'index') {
         const binding = agent.skills;
         const provider = env.services.skillProvider(binding.provider);
@@ -654,11 +668,14 @@ export async function applyToolResult(state, callId, outcome, env) {
         durationMs: outcome.durationMs,
     });
     for (const effect of outcome.effects ?? []) {
-        if (effect.kind === 'memory_op') {
+        if (effect.kind === 'skill_load') {
+            await addSkillLoad(b, env, effect.spec);
+        }
+        else if (effect.spec.kind === 'op') {
             await addMemoryOp(b, env, effect.spec);
         }
         else {
-            await addSkillLoad(b, env, effect.spec);
+            await addMemoryRecall(b, env, effect.spec);
         }
     }
     const target = outcome.isError ? undefined : handoffTarget(call.name);
@@ -694,13 +711,20 @@ async function addMemoryOp(b, env, spec) {
     b.add({
         type: 'memory_op',
         op: spec.op,
-        store: spec.store,
-        scope: spec.scope,
         opId: spec.opId,
-        recordId: spec.recordId,
-        revision: spec.revision,
-        before: spec.before === undefined ? undefined : await put(env, spec.before),
-        after: spec.after === undefined ? undefined : await put(env, spec.after),
+        nodes: spec.nodes,
+        edges: spec.edges,
+        files: spec.files,
+    });
+}
+async function addMemoryRecall(b, env, spec) {
+    b.add({
+        type: 'memory_recall',
+        query: spec.query,
+        seeds: spec.seeds,
+        nodes: spec.nodes,
+        edges: spec.edges,
+        content: await put(env, spec.content),
     });
 }
 async function addSkillLoad(b, env, spec) {
@@ -724,14 +748,7 @@ export async function applyMemoryEffect(state, effect, env) {
         await addMemoryOp(b, env, effect);
     }
     else {
-        b.add({
-            type: 'memory_recall',
-            store: effect.store,
-            scope: effect.scope,
-            query: effect.query,
-            hits: effect.hits,
-            content: await put(env, effect.content),
-        });
+        await addMemoryRecall(b, env, effect);
     }
     return b.commit({});
 }

package/dist/memory/files.d.ts

@@ -0,0 +1,24 @@
+import { type MemoryFile } from './types.ts';
+/** Where remembered files appear in the agent's namespace. */
+export declare const MEMORY_MOUNT = "/memory";
+/**
+ * Big enough for any script or config worth re-running, small enough that the
+ * memory directory cannot become a place where build outputs go to hide.
+ */
+export declare const MAX_FILE_BYTES: number;
+export interface RememberOptions {
+    maxBytes?: number;
+}
+/**
+ * Copy `source` into the memory directory under `id` and describe it.
+ *
+ * The bytes are read once and both hashed and written from that one buffer, so
+ * the digest provably belongs to the copy that was kept — re-reading the source
+ * to hash it would leave a window for it to change in between.
+ */
+export declare function rememberFile(dir: string, source: string, id: string, opts?: RememberOptions): Promise<MemoryFile>;
+/** The host path of a remembered file, for reading it back or deleting it. */
+export declare function hostPath(dir: string, file: MemoryFile): string;
+/** Drop the bytes of a forgotten node. Missing is success — the goal is absence. */
+export declare function forgetFile(dir: string, file: MemoryFile): Promise<void>;
+//# sourceMappingURL=files.d.ts.map

package/dist/memory/files.js

@@ -0,0 +1,85 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { basename, extname, join } from 'node:path';
+import { FILES_DIR } from "./store.js";
+import { MemoryError } from "./types.js";
+// ---------------------------------------------------------------------------
+// Remembered files
+//
+// An agent that writes a working script should be able to run it again next
+// week, and a summary of a script is not a script. So the bytes are copied out
+// of the workspace — which is disposable, and may be a container that is about
+// to be discarded — into the memory directory, under the id of the node that
+// describes them. The copy is the point: a reference to a workspace path would
+// dangle the moment the run ends.
+//
+// The tree is mounted read-only at /memory. Nothing writes there through the
+// file tools, so every file under it has a node that explains what it is, and
+// the graph cannot acquire orphans that no recollection can ever surface.
+// ---------------------------------------------------------------------------
+/** Where remembered files appear in the agent's namespace. */
+export const MEMORY_MOUNT = '/memory';
+/**
+ * Big enough for any script or config worth re-running, small enough that the
+ * memory directory cannot become a place where build outputs go to hide.
+ */
+export const MAX_FILE_BYTES = 2 * 1024 * 1024;
+/** Extensions are for `run_command` and syntax hints, not a type system. */
+const MAX_FORMAT_LEN = 16;
+/**
+ * Copy `source` into the memory directory under `id` and describe it.
+ *
+ * The bytes are read once and both hashed and written from that one buffer, so
+ * the digest provably belongs to the copy that was kept — re-reading the source
+ * to hash it would leave a window for it to change in between.
+ */
+export async function rememberFile(dir, source, id, opts = {}) {
+    const maxBytes = opts.maxBytes ?? MAX_FILE_BYTES;
+    const info = await describe(source);
+    if (!info.isFile()) {
+        throw new MemoryError(`${source} is not a regular file`, 'only files can be remembered; write a `fact` node describing a directory instead');
+    }
+    if (info.size > maxBytes) {
+        throw new MemoryError(`${source} is ${info.size} bytes, over the ${maxBytes} byte limit for a remembered file`, 'keep the artifact in the workspace and remember a `snippet` of the part that matters');
+    }
+    const bytes = await readFile(source);
+    if (bytes.byteLength > maxBytes) {
+        throw new MemoryError(`${source} grew past the ${maxBytes} byte limit while being read`);
+    }
+    const format = formatOf(source);
+    const name = id + (format ? `.${format}` : '');
+    await mkdir(join(dir, FILES_DIR), { recursive: true });
+    await writeFile(join(dir, FILES_DIR, name), bytes);
+    return {
+        path: `${MEMORY_MOUNT}/${name}`,
+        bytes: bytes.byteLength,
+        sha256: createHash('sha256').update(bytes).digest('hex'),
+        format,
+    };
+}
+/** The host path of a remembered file, for reading it back or deleting it. */
+export function hostPath(dir, file) {
+    // Through `basename` so a stored path can never climb out of the tree.
+    return join(dir, FILES_DIR, basename(file.path));
+}
+/** Drop the bytes of a forgotten node. Missing is success — the goal is absence. */
+export async function forgetFile(dir, file) {
+    await rm(hostPath(dir, file), { force: true });
+}
+async function describe(source) {
+    try {
+        return await stat(source);
+    }
+    catch {
+        throw new MemoryError(`${source} does not exist`, 'remember a file the run actually wrote, by the path the file tools use');
+    }
+}
+/**
+ * The extension drives how the file is run and rendered, so it is kept, but it
+ * becomes part of a filename this module chooses — hence the character class.
+ */
+function formatOf(source) {
+    const ext = extname(source).slice(1).toLowerCase();
+    return /^[a-z0-9]+$/.test(ext) && ext.length <= MAX_FORMAT_LEN ? ext : '';
+}
+//# sourceMappingURL=files.js.map

package/dist/memory/graph.d.ts

@@ -0,0 +1,56 @@
+import { MultiDirectedGraph } from 'graphology';
+import { type MemoryEdge, type MemoryEdgeAttrs, type MemoryNode, type Relation } from './types.ts';
+export type Graphology = MultiDirectedGraph<MemoryNode, MemoryEdgeAttrs>;
+export interface NodeDraft {
+    id: string;
+    kind: string;
+    text: string;
+    audience: string[];
+    metadata?: Record<string, unknown>;
+    file?: MemoryNode['file'];
+}
+export interface NodePatch {
+    kind?: string;
+    text?: string;
+    audience?: string[];
+    metadata?: Record<string, unknown>;
+    file?: MemoryNode['file'];
+    /** when given, the update fails unless the stored revision matches */
+    expectedRevision?: number;
+}
+/** Deterministic, so the same link committed twice stays one edge. */
+export declare const edgeKey: (source: string, target: string, relation: Relation) => string;
+export declare class MemoryGraph {
+    #private;
+    static from(serialized: unknown): MemoryGraph;
+    export(): ReturnType<Graphology['export']>;
+    get order(): number;
+    get size(): number;
+    has(id: string): boolean;
+    get(id: string): MemoryNode | undefined;
+    add(draft: NodeDraft, at: string): MemoryNode;
+    update(id: string, patch: NodePatch, at: string): MemoryNode;
+    /** Reading is what counts as use — see `memory_load`, not `memory_search`. */
+    touch(id: string, at: string): MemoryNode | undefined;
+    link(source: string, target: string, relation: Relation, at: string): void;
+    /** Drops the node and every edge touching it; the file it names is the store's to unlink. */
+    forget(id: string): MemoryNode | undefined;
+    nodes(sees?: readonly string[]): MemoryNode[];
+    edges(sees?: readonly string[]): MemoryEdge[];
+    /** Both directions: a memory is as often reached from its artifact as from its request. */
+    neighbors(id: string, sees?: readonly string[]): MemoryEdge[];
+    /** Edges between nodes already chosen — what makes a materialized subgraph closed. */
+    between(ids: Iterable<string>, sees?: readonly string[]): MemoryEdge[];
+    /**
+     * The nodes some visible node replaces. Recall drops these, which is what
+     * makes a correction take effect without erasing what was corrected.
+     */
+    superseded(sees?: readonly string[]): Set<string>;
+}
+export declare class RevisionMismatch extends Error {
+    readonly id: string;
+    readonly expected: number;
+    readonly actual: number;
+    constructor(id: string, expected: number, actual: number);
+}
+//# sourceMappingURL=graph.d.ts.map

package/dist/memory/graph.js

@@ -0,0 +1,159 @@
+import { MultiDirectedGraph } from 'graphology';
+import { edgeVisible, visible, } from "./types.js";
+/** Deterministic, so the same link committed twice stays one edge. */
+export const edgeKey = (source, target, relation) => `${source}|${relation}|${target}`;
+export class MemoryGraph {
+    #graph = new MultiDirectedGraph();
+    static from(serialized) {
+        const g = new MemoryGraph();
+        g.#graph.import(serialized);
+        return g;
+    }
+    export() {
+        return this.#graph.export();
+    }
+    get order() {
+        return this.#graph.order;
+    }
+    get size() {
+        return this.#graph.size;
+    }
+    has(id) {
+        return this.#graph.hasNode(id);
+    }
+    get(id) {
+        return this.#graph.hasNode(id) ? this.#graph.getNodeAttributes(id) : undefined;
+    }
+    add(draft, at) {
+        const node = {
+            id: draft.id,
+            kind: draft.kind,
+            text: draft.text,
+            audience: draft.audience.length ? [...draft.audience] : ['*'],
+            createdAt: at,
+            updatedAt: at,
+            lastUsedAt: at,
+            useCount: 0,
+            revision: 1,
+            ...(draft.metadata ? { metadata: draft.metadata } : {}),
+            ...(draft.file ? { file: draft.file } : {}),
+        };
+        this.#graph.addNode(node.id, node);
+        return node;
+    }
+    update(id, patch, at) {
+        const current = this.#graph.getNodeAttributes(id);
+        if (patch.expectedRevision !== undefined && patch.expectedRevision !== current.revision) {
+            throw new RevisionMismatch(id, patch.expectedRevision, current.revision);
+        }
+        const next = {
+            ...current,
+            ...(patch.kind !== undefined ? { kind: patch.kind } : {}),
+            ...(patch.text !== undefined ? { text: patch.text } : {}),
+            ...(patch.audience !== undefined ? { audience: [...patch.audience] } : {}),
+            ...(patch.metadata !== undefined ? { metadata: patch.metadata } : {}),
+            ...(patch.file !== undefined ? { file: patch.file } : {}),
+            updatedAt: at,
+            revision: current.revision + 1,
+        };
+        this.#graph.replaceNodeAttributes(id, next);
+        return next;
+    }
+    /** Reading is what counts as use — see `memory_load`, not `memory_search`. */
+    touch(id, at) {
+        if (!this.#graph.hasNode(id)) {
+            return undefined;
+        }
+        const node = this.#graph.getNodeAttributes(id);
+        const next = { ...node, lastUsedAt: at, useCount: node.useCount + 1 };
+        this.#graph.replaceNodeAttributes(id, next);
+        return next;
+    }
+    link(source, target, relation, at) {
+        this.#graph.mergeEdgeWithKey(edgeKey(source, target, relation), source, target, {
+            relation,
+            createdAt: at,
+        });
+    }
+    /** Drops the node and every edge touching it; the file it names is the store's to unlink. */
+    forget(id) {
+        const node = this.get(id);
+        if (node) {
+            this.#graph.dropNode(id);
+        }
+        return node;
+    }
+    nodes(sees) {
+        const out = [];
+        this.#graph.forEachNode((_id, attrs) => {
+            if (!sees || visible(attrs, sees)) {
+                out.push(attrs);
+            }
+        });
+        return out;
+    }
+    edges(sees) {
+        const out = [];
+        this.#graph.forEachEdge((_key, attrs, source, target) => {
+            if (sees && !this.#passable(source, target, attrs, sees)) {
+                return;
+            }
+            out.push({ source, target, relation: attrs.relation });
+        });
+        return out;
+    }
+    /** Both directions: a memory is as often reached from its artifact as from its request. */
+    neighbors(id, sees) {
+        if (!this.#graph.hasNode(id)) {
+            return [];
+        }
+        const out = [];
+        this.#graph.forEachEdge(id, (_key, attrs, source, target) => {
+            if (sees && !this.#passable(source, target, attrs, sees)) {
+                return;
+            }
+            out.push({ source, target, relation: attrs.relation });
+        });
+        return out;
+    }
+    /** Edges between nodes already chosen — what makes a materialized subgraph closed. */
+    between(ids, sees) {
+        const set = new Set(ids);
+        return this.edges(sees).filter((e) => set.has(e.source) && set.has(e.target));
+    }
+    /**
+     * The nodes some visible node replaces. Recall drops these, which is what
+     * makes a correction take effect without erasing what was corrected.
+     */
+    superseded(sees) {
+        const out = new Set();
+        this.#graph.forEachEdge((_key, attrs, source, target) => {
+            if (attrs.relation !== 'SUPERSEDES') {
+                return;
+            }
+            if (sees && !this.#passable(source, target, attrs, sees)) {
+                return;
+            }
+            out.add(target);
+        });
+        return out;
+    }
+    #passable(source, target, attrs, sees) {
+        return (edgeVisible(attrs, sees) &&
+            visible(this.#graph.getNodeAttributes(source), sees) &&
+            visible(this.#graph.getNodeAttributes(target), sees));
+    }
+}
+export class RevisionMismatch extends Error {
+    id;
+    expected;
+    actual;
+    constructor(id, expected, actual) {
+        super(`memory ${id} has revision ${actual}, not ${expected}`);
+        this.name = 'RevisionMismatch';
+        this.id = id;
+        this.expected = expected;
+        this.actual = actual;
+    }
+}
+//# sourceMappingURL=graph.js.map