@graphrefly/ts 0.0.0

package/dist/chunk-DJC4CHLQ.js

@@ -0,0 +1,818 @@
+import {
+  assertReactiveCollectionChangeFrame,
+  assertReactiveCollectionSnapshotFrame,
+  collectionSnapshotKey,
+  loadReactiveIndexState,
+  loadReactiveListState,
+  loadReactiveLogState,
+  loadReactiveMapState,
+  reactiveCollectionChangeFrame,
+  reactiveCollectionSnapshotFrame
+} from "./chunk-GTPCOEOZ.js";
+import {
+  agenticMemoryRecordCodec,
+  agenticMemoryRecordFrame,
+  agenticMemoryRecordFrameCodec,
+  assertAgenticMemoryRecordFrame
+} from "./chunk-COHO25CZ.js";
+import {
+  assertGraphLocalNode
+} from "./chunk-2ILL7HQI.js";
+import {
+  restoreReactiveIndex,
+  restoreReactiveList,
+  restoreReactiveLog,
+  restoreReactiveMap
+} from "./chunk-RIIOUTGM.js";
+
+// src/adapters/agentic-memory-storage.ts
+var AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT = "graphrefly.agenticMemory.records.snapshot";
+var AGENTIC_MEMORY_RECORD_CHANGE_FORMAT = "graphrefly.agenticMemory.records.change";
+var AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION = 1;
+function agenticMemoryRecordsSnapshotKey(storagePrefix = "agentic-memory") {
+  if (storagePrefix.length === 0) throw new TypeError("storagePrefix must be non-empty");
+  return `${storagePrefix}/records.snapshot`;
+}
+function agenticMemoryRecordSnapshotFrame(records, opts = {}) {
+  const changeCursor = validateChangeCursor(opts.changeCursor ?? -1);
+  return assertAgenticMemoryRecordSnapshotFrame({
+    format: AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT,
+    version: AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION,
+    changeCursor,
+    records: records.map((record) => agenticMemoryRecordFrame(record))
+  });
+}
+function agenticMemoryRecordChangeFrame(records) {
+  return assertAgenticMemoryRecordChangeFrame({
+    format: AGENTIC_MEMORY_RECORD_CHANGE_FORMAT,
+    version: AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION,
+    change: {
+      kind: "replaceAll",
+      records: records.map((record) => agenticMemoryRecordFrame(record))
+    }
+  });
+}
+function assertAgenticMemoryRecordSnapshotFrame(value) {
+  if (!isPlainRecord(value)) throw new TypeError("agentic memory snapshot frame must be an object");
+  assertKeys(
+    value,
+    ["changeCursor", "format", "records", "version"],
+    "agentic memory snapshot frame"
+  );
+  if (value.format !== AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT) {
+    throw new TypeError("agentic memory snapshot frame: invalid format");
+  }
+  if (value.version !== AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION) {
+    throw new TypeError("agentic memory snapshot frame: invalid version");
+  }
+  const changeCursor = validateChangeCursor(value.changeCursor);
+  if (!Array.isArray(value.records)) {
+    throw new TypeError("agentic memory snapshot frame: records must be an array");
+  }
+  const records = assertDenseRecordFrames(
+    value.records,
+    "agentic memory snapshot frame records"
+  );
+  return Object.freeze({
+    format: AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT,
+    version: AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION,
+    changeCursor,
+    records: Object.freeze(records)
+  });
+}
+function assertAgenticMemoryRecordChangeFrame(value) {
+  if (!isPlainRecord(value)) throw new TypeError("agentic memory change frame must be an object");
+  assertKeys(value, ["change", "format", "version"], "agentic memory change frame");
+  if (value.format !== AGENTIC_MEMORY_RECORD_CHANGE_FORMAT) {
+    throw new TypeError("agentic memory change frame: invalid format");
+  }
+  if (value.version !== AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION) {
+    throw new TypeError("agentic memory change frame: invalid version");
+  }
+  if (!isPlainRecord(value.change)) {
+    throw new TypeError("agentic memory change frame: change must be an object");
+  }
+  assertKeys(value.change, ["kind", "records"], "agentic memory change frame change");
+  if (value.change.kind !== "replaceAll") {
+    throw new TypeError("agentic memory change frame: change.kind must be replaceAll");
+  }
+  if (!Array.isArray(value.change.records)) {
+    throw new TypeError("agentic memory change frame: change.records must be an array");
+  }
+  const records = assertDenseRecordFrames(
+    value.change.records,
+    "agentic memory change frame records"
+  );
+  return Object.freeze({
+    format: AGENTIC_MEMORY_RECORD_CHANGE_FORMAT,
+    version: AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION,
+    change: Object.freeze({
+      kind: "replaceAll",
+      records: Object.freeze(records)
+    })
+  });
+}
+function loadAgenticMemoryRecordsState(opts) {
+  const storagePrefix = opts.storagePrefix ?? "agentic-memory";
+  const snapshotKey = opts.snapshotKey ?? agenticMemoryRecordsSnapshotKey(storagePrefix);
+  return opts.snapshotStore.get(snapshotKey).then((rawSnapshot) => {
+    let records = [];
+    let source = "empty";
+    let changeCursor = -1;
+    if (rawSnapshot !== void 0) {
+      const snapshot = assertAgenticMemoryRecordSnapshotFrame(rawSnapshot);
+      records = snapshot.records.map(recordFromFrame);
+      changeCursor = snapshot.changeCursor;
+      source = "snapshot";
+    }
+    if (opts.changeLog === void 0) {
+      return {
+        records,
+        source,
+        snapshot: { found: rawSnapshot !== void 0, changeCursor },
+        changes: { applied: 0, cursor: changeCursor }
+      };
+    }
+    return opts.changeLog.read({ after: changeCursor }).then((entries) => {
+      let applied = 0;
+      let cursor = changeCursor;
+      for (const entry of entries) {
+        if (entry.seq !== cursor + 1) {
+          throw new Error("agentic memory records change log is non-contiguous");
+        }
+        const change = assertAgenticMemoryRecordChangeFrame(entry.value);
+        records = change.change.records.map(recordFromFrame);
+        cursor = entry.seq;
+        applied += 1;
+      }
+      return {
+        records,
+        source: rawSnapshot !== void 0 && applied > 0 ? "snapshot+changes" : rawSnapshot !== void 0 ? "snapshot" : applied > 0 ? "changes" : "empty",
+        snapshot: { found: rawSnapshot !== void 0, changeCursor },
+        changes: { applied, cursor }
+      };
+    });
+  });
+}
+function persistAgenticMemoryRecords(graph, records, opts) {
+  const name = opts.name ?? "agenticMemoryRecords.persistence";
+  const snapshotKey = opts.snapshotKey ?? agenticMemoryRecordsSnapshotKey(opts.storagePrefix ?? name);
+  const snapshotEveryChanges = validateSnapshotEveryChanges(opts.snapshotEveryChanges);
+  assertGraphLocalNode(graph, records, `${name}.records`);
+  let cursorValue = {
+    kind: "persistence.cursor",
+    changeSeq: validateChangeCursor(opts.initialChangeCursor ?? -1),
+    snapshotWrites: 0,
+    changeWrites: 0
+  };
+  let statusValue = statusOf("starting", 0, 0, 0, cursorValue);
+  let errorCount = 0;
+  let writes = 0;
+  let running = false;
+  let disposed = false;
+  let disposeRequested = false;
+  let subscribing = true;
+  let observedChangesSinceSnapshot = 0;
+  let latestRecords = records.cache ?? [];
+  let stop;
+  const queue = [];
+  const ready = graph.state(false, { name: `${name}/ready` });
+  const status = graph.state(statusValue, {
+    name: `${name}/status`
+  });
+  const error = graph.state(null, {
+    name: `${name}/error`
+  });
+  const cursor = graph.state(cursorValue, {
+    name: `${name}/cursor`
+  });
+  function publish(state) {
+    const nextState = statusValue.state === "errored" && state !== "disposed" ? "errored" : state;
+    statusValue = statusOf(
+      nextState,
+      queue.length + (running ? 1 : 0),
+      writes,
+      errorCount,
+      cursorValue
+    );
+    cursor.set(cursorValue);
+    status.set(statusValue);
+    if (nextState === "ready") ready.set(true);
+    if (nextState === "errored" || nextState === "disposed") ready.set(false);
+  }
+  function report(phase, caught) {
+    errorCount += 1;
+    error.set({ phase, message: errorMessage(caught), cursor: cursorValue });
+  }
+  function callDone(done) {
+    try {
+      done?.(statusValue);
+    } catch {
+    }
+  }
+  function finish(item) {
+    if (item.phase === "dispose") {
+      disposed = true;
+      running = false;
+      publish("disposed");
+    } else if (statusValue.state !== "errored") {
+      running = false;
+      publish("ready");
+    } else {
+      running = false;
+      publish("errored");
+    }
+    callDone(item.done);
+    drain();
+  }
+  function fail(item, caught) {
+    if (item.phase === "snapshot" || item.phase === "change") report(item.phase, caught);
+    running = false;
+    if (item.phase === "snapshot" || item.phase === "change") publish("errored");
+    callDone(item.done);
+    drain();
+  }
+  function chainThenable(item, value) {
+    if (typeof value !== "object" && typeof value !== "function" || value === null) return false;
+    const then = value.then;
+    if (typeof then !== "function") return false;
+    let settled = false;
+    const settle = (next) => {
+      if (settled) return;
+      settled = true;
+      next();
+    };
+    try {
+      then.call(
+        value,
+        () => settle(() => finish(item)),
+        (caught) => settle(() => fail(item, caught))
+      );
+    } catch (caught) {
+      settle(() => fail(item, caught));
+    }
+    return true;
+  }
+  function enqueue(item) {
+    if (disposed || disposeRequested && item.phase !== "dispose" && item.phase !== "flush") {
+      callDone(item.done);
+      return;
+    }
+    queue.push(item);
+    drain();
+  }
+  function drain() {
+    if (running) return;
+    const item = queue.shift();
+    if (item === void 0) return;
+    running = true;
+    publish(
+      item.phase === "flush" ? "flushing" : statusValue.state === "starting" ? "starting" : "ready"
+    );
+    let result;
+    try {
+      result = item.run();
+    } catch (caught) {
+      fail(item, caught);
+      return;
+    }
+    if (chainThenable(item, result)) return;
+    finish(item);
+  }
+  function enqueueSnapshot(done) {
+    const snapshotRecords = latestRecords;
+    observedChangesSinceSnapshot = 0;
+    enqueue({
+      phase: "snapshot",
+      done,
+      run() {
+        const records2 = Object.freeze(
+          snapshotRecords.map((record) => agenticMemoryRecordFrame(record))
+        );
+        const frame = assertAgenticMemoryRecordSnapshotFrame({
+          format: AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT,
+          version: AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION,
+          changeCursor: cursorValue.changeSeq,
+          records: records2
+        });
+        return opts.snapshotStore.set(snapshotKey, frame).then(() => {
+          cursorValue = { ...cursorValue, snapshotWrites: cursorValue.snapshotWrites + 1 };
+          writes += 1;
+          publish("ready");
+        });
+      }
+    });
+  }
+  function enqueueChange(nextRecords) {
+    const changeLog = opts.changeLog;
+    if (changeLog === void 0) return;
+    enqueue({
+      phase: "change",
+      run() {
+        const frame = agenticMemoryRecordChangeFrame(nextRecords);
+        return changeLog.append(frame).then((written) => {
+          const entry = written;
+          cursorValue = {
+            ...cursorValue,
+            changeSeq: entry.seq,
+            changeWrites: cursorValue.changeWrites + 1
+          };
+          writes += 1;
+          publish("ready");
+        });
+      }
+    });
+  }
+  function cancelQueuedForDispose() {
+    const pending = queue.splice(0);
+    for (const item of pending) callDone(item.done);
+  }
+  stop = records.subscribe((msg, delivery) => {
+    if (disposeRequested) return;
+    const nextRecords = dataOf(msg);
+    if (nextRecords === void 0) return;
+    latestRecords = nextRecords;
+    if (subscribing && delivery === void 0) return;
+    observedChangesSinceSnapshot += 1;
+    enqueueChange(nextRecords);
+    if (snapshotEveryChanges !== void 0 && observedChangesSinceSnapshot >= snapshotEveryChanges) {
+      enqueueSnapshot();
+    }
+  });
+  subscribing = false;
+  if (opts.snapshotOnAttach !== false) enqueueSnapshot();
+  else publish("ready");
+  return {
+    ready,
+    status,
+    error,
+    cursor,
+    flush(done) {
+      if (disposed) {
+        callDone(done);
+        return;
+      }
+      enqueue({ phase: "flush", done, run: () => void 0 });
+    },
+    snapshot(done) {
+      if (disposed || disposeRequested) {
+        callDone(done);
+        return;
+      }
+      enqueueSnapshot(done);
+    },
+    dispose(done) {
+      if (disposed) {
+        callDone(done);
+        return;
+      }
+      disposeRequested = true;
+      stop?.();
+      cancelQueuedForDispose();
+      enqueue({ phase: "dispose", done, run: () => void 0 });
+    }
+  };
+}
+function openPersistentAgenticMemoryRecords(opts) {
+  const storagePrefix = opts.storagePrefix ?? opts.name ?? "agentic-memory";
+  const snapshotKey = opts.snapshotKey ?? agenticMemoryRecordsSnapshotKey(storagePrefix);
+  return loadAgenticMemoryRecordsState({ ...opts, snapshotKey, storagePrefix }).then(
+    (loaded) => {
+      const records = loaded.source === "empty" && opts.initial !== void 0 ? opts.initial : loaded.records;
+      const node = opts.graph.state(records, {
+        name: opts.name
+      });
+      const persistence = persistAgenticMemoryRecords(opts.graph, node, {
+        ...opts,
+        name: opts.name ? `${opts.name}/persistence` : void 0,
+        snapshotKey,
+        storagePrefix,
+        initialChangeCursor: loaded.changes.cursor
+      });
+      return { records: node, persistence, loaded };
+    }
+  );
+}
+function recordFromFrame(frame) {
+  return agenticMemoryRecordCodec().decode(
+    agenticMemoryRecordFrameCodec().encode(frame)
+  );
+}
+function statusOf(state, pending, writes, errors, cursor) {
+  return { state, pending, writes, errors, cursor };
+}
+function dataOf(msg) {
+  return msg[0] === "DATA" ? msg[1] : void 0;
+}
+function validateChangeCursor(value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < -1) {
+    throw new RangeError("changeCursor must be a safe integer >= -1");
+  }
+  return value;
+}
+function validateSnapshotEveryChanges(value) {
+  if (value === void 0) return void 0;
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new RangeError("snapshotEveryChanges must be a positive safe integer");
+  }
+  return value;
+}
+function isPlainRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function assertKeys(value, expected, label) {
+  const actual = Object.keys(value).sort();
+  const want = [...expected].sort();
+  if (actual.length !== want.length || actual.some((key, i) => key !== want[i])) {
+    throw new TypeError(`${label}: unexpected frame fields ${actual.join(",")}`);
+  }
+}
+function assertDenseRecordFrames(value, label) {
+  const records = [];
+  for (let i = 0; i < value.length; i += 1) {
+    if (!Object.hasOwn(value, i)) {
+      throw new TypeError(`${label}: sparse array hole at ${i}`);
+    }
+    records.push(assertAgenticMemoryRecordFrame(value[i]));
+  }
+  return Object.freeze(records);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/adapters/reactive-collection-storage.ts
+function emptyCursor(collection) {
+  return {
+    kind: "persistence.cursor",
+    collection,
+    changeSeq: -1,
+    snapshotWrites: 0,
+    changeWrites: 0
+  };
+}
+function errorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function validateSnapshotEveryChanges2(value) {
+  if (value === void 0) return void 0;
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new RangeError("snapshotEveryChanges must be a positive safe integer");
+  }
+  return value;
+}
+function validateInitialChangeCursor(value) {
+  if (value === void 0) return -1;
+  if (!Number.isSafeInteger(value) || value < -1) {
+    throw new RangeError("initialChangeCursor must be a safe integer >= -1");
+  }
+  return value;
+}
+function statusOf2(state, pending, writes, errors, cursor) {
+  return { state, pending, writes, errors, cursor };
+}
+function dataOf2(msg) {
+  return msg[0] === "DATA" ? msg[1] : void 0;
+}
+function persistReactiveCollection(graph, collection, opts) {
+  const kind = opts.kind;
+  const name = opts.name ?? `${kind}.persistence`;
+  const snapshotKey = opts.snapshotKey ?? collectionSnapshotKey(opts.storagePrefix ?? name);
+  const snapshotEveryChanges = validateSnapshotEveryChanges2(opts.snapshotEveryChanges);
+  assertGraphLocalNode(graph, collection.delta, `${name}.collection.delta`);
+  assertGraphLocalNode(graph, collection.snapshot, `${name}.collection.snapshot`);
+  let cursorValue = {
+    ...emptyCursor(kind),
+    changeSeq: validateInitialChangeCursor(opts.initialChangeCursor)
+  };
+  let statusValue = statusOf2("starting", 0, 0, 0, cursorValue);
+  let errorCount = 0;
+  let writes = 0;
+  let observedChangesSinceSnapshot = 0;
+  let running = false;
+  let disposed = false;
+  let disposeRequested = false;
+  let subscribing = true;
+  let stop;
+  const queue = [];
+  const ready = graph.state(false, { name: `${name}/ready` });
+  const status = graph.state(statusValue, {
+    name: `${name}/status`
+  });
+  const error = graph.state(null, {
+    name: `${name}/error`
+  });
+  const cursor = graph.state(cursorValue, {
+    name: `${name}/cursor`
+  });
+  function publish(state) {
+    const nextState = statusValue.state === "errored" && state !== "disposed" ? "errored" : state;
+    statusValue = statusOf2(
+      nextState,
+      queue.length + (running ? 1 : 0),
+      writes,
+      errorCount,
+      cursorValue
+    );
+    cursor.set(cursorValue);
+    status.set(statusValue);
+    if (nextState === "ready") ready.set(true);
+    if (nextState === "errored" || nextState === "disposed") ready.set(false);
+  }
+  function report(phase, caught) {
+    errorCount += 1;
+    const fact = { phase, message: errorMessage2(caught), cursor: cursorValue };
+    error.set(fact);
+  }
+  function callDone(done) {
+    try {
+      done?.(statusValue);
+    } catch {
+    }
+  }
+  function finish(item) {
+    if (item.phase === "dispose") {
+      disposed = true;
+      running = false;
+      publish("disposed");
+    } else if (statusValue.state !== "errored") {
+      running = false;
+      publish("ready");
+    } else {
+      running = false;
+      publish("errored");
+    }
+    callDone(item.done);
+    drain();
+  }
+  function fail(item, caught) {
+    if (item.phase === "snapshot" || item.phase === "change") report(item.phase, caught);
+    running = false;
+    if (item.phase === "snapshot" || item.phase === "change") publish("errored");
+    callDone(item.done);
+    drain();
+  }
+  function chainThenable(item, value) {
+    if (typeof value !== "object" && typeof value !== "function" || value === null) return false;
+    let then;
+    try {
+      then = value.then;
+    } catch (caught) {
+      fail(item, caught);
+      return true;
+    }
+    if (typeof then !== "function") return false;
+    let settled = false;
+    const settle = (next) => {
+      if (settled) return;
+      settled = true;
+      next();
+    };
+    try {
+      then.call(
+        value,
+        () => settle(() => finish(item)),
+        (caught) => settle(() => fail(item, caught))
+      );
+    } catch (caught) {
+      settle(() => fail(item, caught));
+    }
+    return true;
+  }
+  function enqueue(item) {
+    if (disposed || disposeRequested && item.phase !== "dispose" && item.phase !== "flush") {
+      callDone(item.done);
+      return;
+    }
+    queue.push(item);
+    drain();
+  }
+  function drain() {
+    if (running) return;
+    const item = queue.shift();
+    if (item === void 0) return;
+    running = true;
+    publish(
+      item.phase === "flush" ? "flushing" : statusValue.state === "starting" ? "starting" : "ready"
+    );
+    let result;
+    try {
+      result = item.run();
+    } catch (caught) {
+      fail(item, caught);
+      return;
+    }
+    if (chainThenable(item, result)) return;
+    finish(item);
+  }
+  function enqueueSnapshot(done) {
+    const snapshot = collectionSnapshot(collection, kind);
+    observedChangesSinceSnapshot = 0;
+    enqueue({
+      phase: "snapshot",
+      done,
+      run() {
+        const frame = reactiveCollectionSnapshotFrame(kind, snapshot, {
+          changeCursor: cursorValue.changeSeq
+        });
+        assertReactiveCollectionSnapshotFrame(frame, kind);
+        return opts.snapshotStore.set(snapshotKey, frame).then(() => {
+          cursorValue = {
+            ...cursorValue,
+            snapshotWrites: cursorValue.snapshotWrites + 1
+          };
+          writes += 1;
+          publish("ready");
+        });
+      }
+    });
+  }
+  function enqueueChange(change) {
+    const changeLog = opts.changeLog;
+    if (changeLog === void 0) return;
+    enqueue({
+      phase: "change",
+      run() {
+        const frame = reactiveCollectionChangeFrame(kind, change);
+        assertReactiveCollectionChangeFrame(frame, kind);
+        return changeLog.append(frame).then((written) => {
+          const entry = written;
+          cursorValue = {
+            ...cursorValue,
+            changeSeq: entry.seq,
+            changeWrites: cursorValue.changeWrites + 1
+          };
+          writes += 1;
+          publish("ready");
+        });
+      }
+    });
+  }
+  function cancelQueuedForDispose() {
+    const pending = queue.splice(0);
+    for (const item of pending) callDone(item.done);
+  }
+  stop = collection.delta.subscribe(
+    (msg, delivery) => {
+      if (disposeRequested) return;
+      const change = dataOf2(msg);
+      if (change === void 0) return;
+      if (subscribing && delivery === void 0) return;
+      observedChangesSinceSnapshot += 1;
+      enqueueChange(change);
+      if (snapshotEveryChanges !== void 0 && observedChangesSinceSnapshot >= snapshotEveryChanges) {
+        enqueueSnapshot();
+      }
+    }
+  );
+  subscribing = false;
+  if (opts.snapshotOnAttach !== false) enqueueSnapshot();
+  else publish("ready");
+  return {
+    ready,
+    status,
+    error,
+    cursor,
+    flush(done) {
+      if (disposed) {
+        callDone(done);
+        return;
+      }
+      enqueue({ phase: "flush", done, run: () => void 0 });
+    },
+    snapshot(done) {
+      if (disposed || disposeRequested) {
+        callDone(done);
+        return;
+      }
+      enqueueSnapshot(done);
+    },
+    dispose(done) {
+      if (disposed) {
+        callDone(done);
+        return;
+      }
+      disposeRequested = true;
+      stop?.();
+      cancelQueuedForDispose();
+      enqueue({ phase: "dispose", done, run: () => void 0 });
+    }
+  };
+}
+function collectionSnapshot(collection, kind) {
+  if (kind === "reactiveMap") {
+    return [...collection.toMap()];
+  }
+  if (kind === "reactiveIndex") {
+    return collection.toArray();
+  }
+  return collection.toArray();
+}
+function openPersistentReactiveList(opts) {
+  const storagePrefix = opts.storagePrefix ?? opts.name ?? "reactive-collection";
+  const snapshotKey = opts.snapshotKey ?? collectionSnapshotKey(storagePrefix);
+  const loadOpts = { ...opts, snapshotKey, storagePrefix };
+  return loadReactiveListState(loadOpts).then((loaded) => {
+    const state = loaded.source === "empty" && opts.initial !== void 0 ? { ...loaded, state: opts.initial } : loaded;
+    const collection = restoreReactiveList(state, {
+      ...opts.collection ?? {},
+      graph: opts.graph,
+      name: opts.name
+    });
+    const persistence = persistReactiveCollection(opts.graph, collection, {
+      ...opts,
+      kind: "reactiveList",
+      name: opts.name ? `${opts.name}/persistence` : void 0,
+      snapshotKey,
+      storagePrefix,
+      initialChangeCursor: loaded.changes.cursor
+    });
+    return { collection, persistence, loaded };
+  });
+}
+function openPersistentReactiveLog(opts) {
+  const storagePrefix = opts.storagePrefix ?? opts.name ?? "reactive-collection";
+  const snapshotKey = opts.snapshotKey ?? collectionSnapshotKey(storagePrefix);
+  const loadOpts = { ...opts, snapshotKey, storagePrefix };
+  return loadReactiveLogState(loadOpts).then((loaded) => {
+    const state = loaded.source === "empty" && opts.initial !== void 0 ? { ...loaded, state: opts.initial } : loaded;
+    const collection = restoreReactiveLog(state, {
+      ...opts.collection ?? {},
+      graph: opts.graph,
+      name: opts.name
+    });
+    const persistence = persistReactiveCollection(opts.graph, collection, {
+      ...opts,
+      kind: "reactiveLog",
+      name: opts.name ? `${opts.name}/persistence` : void 0,
+      snapshotKey,
+      storagePrefix,
+      initialChangeCursor: loaded.changes.cursor
+    });
+    return { collection, persistence, loaded };
+  });
+}
+function openPersistentReactiveMap(opts) {
+  const storagePrefix = opts.storagePrefix ?? opts.name ?? "reactive-collection";
+  const snapshotKey = opts.snapshotKey ?? collectionSnapshotKey(storagePrefix);
+  const loadOpts = { ...opts, snapshotKey, storagePrefix };
+  return loadReactiveMapState(loadOpts).then((loaded) => {
+    const state = loaded.source === "empty" && opts.initial !== void 0 ? { ...loaded, state: opts.initial } : loaded;
+    const collection = restoreReactiveMap(state, {
+      ...opts.collection ?? {},
+      graph: opts.graph,
+      name: opts.name
+    });
+    const persistence = persistReactiveCollection(opts.graph, collection, {
+      ...opts,
+      kind: "reactiveMap",
+      name: opts.name ? `${opts.name}/persistence` : void 0,
+      snapshotKey,
+      storagePrefix,
+      initialChangeCursor: loaded.changes.cursor
+    });
+    return { collection, persistence, loaded };
+  });
+}
+function openPersistentReactiveIndex(opts) {
+  const storagePrefix = opts.storagePrefix ?? opts.name ?? "reactive-collection";
+  const snapshotKey = opts.snapshotKey ?? collectionSnapshotKey(storagePrefix);
+  const loadOpts = { ...opts, snapshotKey, storagePrefix };
+  return loadReactiveIndexState(loadOpts).then((loaded) => {
+    const state = loaded.source === "empty" && opts.initial !== void 0 ? { ...loaded, state: opts.initial } : loaded;
+    const collection = restoreReactiveIndex(state, {
+      ...opts.collection ?? {},
+      graph: opts.graph,
+      name: opts.name
+    });
+    const persistence = persistReactiveCollection(opts.graph, collection, {
+      ...opts,
+      kind: "reactiveIndex",
+      name: opts.name ? `${opts.name}/persistence` : void 0,
+      snapshotKey,
+      storagePrefix,
+      initialChangeCursor: loaded.changes.cursor
+    });
+    return { collection, persistence, loaded };
+  });
+}
+
+export {
+  AGENTIC_MEMORY_RECORD_SNAPSHOT_FORMAT,
+  AGENTIC_MEMORY_RECORD_CHANGE_FORMAT,
+  AGENTIC_MEMORY_RECORD_STORAGE_FRAME_VERSION,
+  agenticMemoryRecordsSnapshotKey,
+  agenticMemoryRecordSnapshotFrame,
+  agenticMemoryRecordChangeFrame,
+  assertAgenticMemoryRecordSnapshotFrame,
+  assertAgenticMemoryRecordChangeFrame,
+  loadAgenticMemoryRecordsState,
+  persistAgenticMemoryRecords,
+  openPersistentAgenticMemoryRecords,
+  persistReactiveCollection,
+  openPersistentReactiveList,
+  openPersistentReactiveLog,
+  openPersistentReactiveMap,
+  openPersistentReactiveIndex
+};
+//# sourceMappingURL=chunk-DJC4CHLQ.js.map