@graphrefly/ts 0.0.0

package/dist/chunk-GTPCOEOZ.js

@@ -0,0 +1,741 @@
+import {
+  assertNonNegativeDecimalIntegerString,
+  nowNs
+} from "./chunk-K3FXTC3I.js";
+import {
+  strictCanonicalJsonBytes,
+  strictJsonCodecFor
+} from "./chunk-4VLAQHZI.js";
+
+// src/storage/content-addressed.ts
+var ContentAddressedMissError = class extends Error {
+  key;
+  context;
+  constructor(key, context) {
+    super(`content-addressed lookup miss in read-strict mode: ${key}`);
+    this.name = "ContentAddressedMissError";
+    this.key = key;
+    this.context = context;
+  }
+};
+var SHA_256 = "SHA-256";
+var HEX_TABLE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  let out = "";
+  for (const byte of bytes) out += HEX_TABLE[byte];
+  return out;
+}
+function sha256Hex(data) {
+  const digestInput = Uint8Array.from(data);
+  return globalThis.crypto.subtle.digest(SHA_256, digestInput).then((buf) => bytesToHex(new Uint8Array(buf)));
+}
+function contentAddressedKv(opts) {
+  const { kv, keyContext, keyPrefix, mode = "read-write" } = opts;
+  const contextForKey = keyContext ?? ((ctx) => ctx);
+  function keyFor(ctx) {
+    let bytes;
+    try {
+      bytes = strictCanonicalJsonBytes(contextForKey(ctx));
+    } catch (err) {
+      return Promise.resolve().then(() => {
+        throw err;
+      });
+    }
+    return Promise.resolve().then(() => sha256Hex(bytes)).then((hex) => keyPrefix ? `${keyPrefix}:${hex}` : hex);
+  }
+  return {
+    keyFor,
+    lookup(ctx) {
+      if (mode === "write") return Promise.resolve(void 0);
+      return keyFor(ctx).then(
+        (key) => kv.get(key).then((value) => {
+          if (value === void 0 && mode === "read-strict") {
+            throw new ContentAddressedMissError(key, ctx);
+          }
+          return value;
+        })
+      );
+    },
+    store(ctx, value) {
+      if (mode === "read") return Promise.resolve();
+      return keyFor(ctx).then((key) => kv.set(key, value));
+    },
+    forget(ctx) {
+      if (mode === "read" || mode === "write") return Promise.resolve();
+      return keyFor(ctx).then((key) => kv.delete(key));
+    }
+  };
+}
+function contentAddressedStorage(opts) {
+  return contentAddressedKv(opts);
+}
+
+// src/storage/reactive-collection.ts
+var REACTIVE_COLLECTION_SNAPSHOT_FORMAT = "graphrefly.reactive-collection.snapshot.v1";
+var REACTIVE_COLLECTION_CHANGE_FORMAT = "graphrefly.reactive-collection.change.v1";
+var REACTIVE_COLLECTION_FRAME_VERSION = 1;
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function ownKeys(value) {
+  return Object.keys(value).sort();
+}
+function assertKeys(value, expected, label) {
+  const actual = ownKeys(value);
+  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 assertSafeInteger(value, label, min = 0) {
+  if (!Number.isSafeInteger(value) || value < min) {
+    throw new TypeError(`${label} must be a safe integer >= ${min}`);
+  }
+  return value;
+}
+function assertKind(value, expected, label) {
+  if (value !== expected) throw new TypeError(`${label}: kind must be ${expected}`);
+  return expected;
+}
+function assertArray(value, label) {
+  if (!Array.isArray(value)) throw new TypeError(`${label}: snapshot must be an array`);
+  return value;
+}
+function strictJsonIdentity(value) {
+  return Array.from(strictCanonicalJsonBytes(value)).join(",");
+}
+function assertEntryArray(value, label) {
+  const entries = assertArray(value, label);
+  const seen = /* @__PURE__ */ new Set();
+  for (const [i, entry] of entries.entries()) {
+    if (!Array.isArray(entry) || entry.length !== 2) {
+      throw new TypeError(`${label}: entry ${i} must be [key,value]`);
+    }
+    const key = strictJsonIdentity(entry[0]);
+    if (seen.has(key)) throw new TypeError(`${label}: entry ${i} duplicates an earlier key`);
+    seen.add(key);
+  }
+  return entries;
+}
+function assertIndexRows(value, label) {
+  const rows = assertArray(value, label);
+  const seen = /* @__PURE__ */ new Set();
+  for (const [i, row] of rows.entries()) {
+    if (!isRecord(row)) throw new TypeError(`${label}: row ${i} must be an object`);
+    assertKeys(row, ["primary", "secondary", "value"], `${label} row`);
+    const primary = strictJsonIdentity(row.primary);
+    if (seen.has(primary)) {
+      throw new TypeError(`${label}: row ${i} duplicates an earlier primary`);
+    }
+    seen.add(primary);
+  }
+  return rows;
+}
+function collectionSnapshotKey(storagePrefix = "reactive-collection") {
+  if (storagePrefix.length === 0) throw new TypeError("storagePrefix must be non-empty");
+  return `${storagePrefix}/snapshot`;
+}
+function reactiveCollectionSnapshotFrame(kind, snapshot, opts = {}) {
+  const changeCursor = opts.changeCursor ?? -1;
+  if (!Number.isSafeInteger(changeCursor) || changeCursor < -1) {
+    throw new RangeError("reactive collection snapshot changeCursor must be a safe integer >= -1");
+  }
+  return {
+    format: REACTIVE_COLLECTION_SNAPSHOT_FORMAT,
+    version: REACTIVE_COLLECTION_FRAME_VERSION,
+    kind,
+    changeCursor,
+    snapshot
+  };
+}
+function reactiveCollectionChangeFrame(kind, change) {
+  return {
+    format: REACTIVE_COLLECTION_CHANGE_FORMAT,
+    version: REACTIVE_COLLECTION_FRAME_VERSION,
+    kind,
+    change
+  };
+}
+function assertReactiveCollectionSnapshotFrame(value, expectedKind) {
+  if (!isRecord(value)) throw new TypeError("reactive collection snapshot frame must be an object");
+  assertKeys(value, ["changeCursor", "format", "kind", "snapshot", "version"], "snapshot frame");
+  if (value.format !== REACTIVE_COLLECTION_SNAPSHOT_FORMAT) {
+    throw new TypeError("snapshot frame: invalid format");
+  }
+  if (value.version !== REACTIVE_COLLECTION_FRAME_VERSION) {
+    throw new TypeError("snapshot frame: invalid version");
+  }
+  assertKind(value.kind, expectedKind, "snapshot frame");
+  assertSafeInteger(value.changeCursor, "snapshot frame changeCursor", -1);
+  strictJsonCodecFor().encode(value);
+  return value;
+}
+function assertReactiveCollectionChangeFrame(value, expectedKind) {
+  if (!isRecord(value)) throw new TypeError("reactive collection change frame must be an object");
+  assertKeys(value, ["change", "format", "kind", "version"], "change frame");
+  if (value.format !== REACTIVE_COLLECTION_CHANGE_FORMAT) {
+    throw new TypeError("change frame: invalid format");
+  }
+  if (value.version !== REACTIVE_COLLECTION_FRAME_VERSION) {
+    throw new TypeError("change frame: invalid version");
+  }
+  assertKind(value.kind, expectedKind, "change frame");
+  if (!Object.hasOwn(value, "change")) throw new TypeError("change frame: change is required");
+  strictJsonCodecFor().encode(value);
+  return value;
+}
+function reactiveCollectionSnapshotFrameCodec(kind) {
+  const codec = strictJsonCodecFor();
+  return {
+    encode(value) {
+      return codec.encode(assertReactiveCollectionSnapshotFrame(value, kind));
+    },
+    decode(bytes) {
+      return assertReactiveCollectionSnapshotFrame(codec.decode(bytes), kind);
+    }
+  };
+}
+function reactiveCollectionChangeFrameCodec(kind) {
+  const codec = strictJsonCodecFor();
+  return {
+    encode(value) {
+      return codec.encode(assertReactiveCollectionChangeFrame(value, kind));
+    },
+    decode(bytes) {
+      return assertReactiveCollectionChangeFrame(codec.decode(bytes), kind);
+    }
+  };
+}
+function assertListChange(value) {
+  if (!isRecord(value) || typeof value.kind !== "string") {
+    throw new TypeError("reactiveList change must be an object with kind");
+  }
+  switch (value.kind) {
+    case "append":
+      if (!Object.hasOwn(value, "value")) throw new TypeError("reactiveList append.value required");
+      assertKeys(value, ["kind", "value"], "reactiveList append");
+      return value;
+    case "appendMany":
+      assertKeys(value, ["kind", "values"], "reactiveList appendMany");
+      assertArray(value.values, "reactiveList appendMany.values");
+      return value;
+    case "insert":
+      assertKeys(value, ["index", "kind", "value"], "reactiveList insert");
+      assertSafeInteger(value.index, "reactiveList insert.index", 0);
+      return value;
+    case "insertMany":
+      assertKeys(value, ["index", "kind", "values"], "reactiveList insertMany");
+      assertSafeInteger(value.index, "reactiveList insertMany.index", 0);
+      assertArray(value.values, "reactiveList insertMany.values");
+      return value;
+    case "pop":
+      assertKeys(value, ["index", "kind", "value"], "reactiveList pop");
+      assertSafeInteger(value.index, "reactiveList pop.index", 0);
+      return value;
+    case "trimHead":
+      assertKeys(value, ["kind", "n"], "reactiveList trimHead");
+      assertSafeInteger(value.n, "reactiveList trimHead.n", 0);
+      return value;
+    case "clear":
+      assertKeys(value, ["count", "kind"], "reactiveList clear");
+      assertSafeInteger(value.count, "reactiveList clear.count", 0);
+      return value;
+    default:
+      throw new TypeError(`unsupported reactiveList change kind ${value.kind}`);
+  }
+}
+function assertLogChange(value) {
+  if (!isRecord(value) || typeof value.kind !== "string") {
+    throw new TypeError("reactiveLog change must be an object with kind");
+  }
+  switch (value.kind) {
+    case "append":
+      if (!Object.hasOwn(value, "value")) throw new TypeError("reactiveLog append.value required");
+      assertKeys(value, ["kind", "value"], "reactiveLog append");
+      return value;
+    case "appendMany":
+      assertKeys(value, ["kind", "values"], "reactiveLog appendMany");
+      assertArray(value.values, "reactiveLog appendMany.values");
+      return value;
+    case "trimHead":
+      assertKeys(value, ["kind", "n"], "reactiveLog trimHead");
+      assertSafeInteger(value.n, "reactiveLog trimHead.n", 0);
+      return value;
+    case "clear":
+      assertKeys(value, ["count", "kind"], "reactiveLog clear");
+      assertSafeInteger(value.count, "reactiveLog clear.count", 0);
+      return value;
+    default:
+      throw new TypeError(`unsupported reactiveLog change kind ${value.kind}`);
+  }
+}
+function assertMapChange(value) {
+  if (!isRecord(value) || typeof value.kind !== "string") {
+    throw new TypeError("reactiveMap change must be an object with kind");
+  }
+  switch (value.kind) {
+    case "set":
+      if (!Object.hasOwn(value, "key")) throw new TypeError("reactiveMap set.key required");
+      if (!Object.hasOwn(value, "value")) throw new TypeError("reactiveMap set.value required");
+      assertKeys(value, ["key", "kind", "value"], "reactiveMap set");
+      return value;
+    case "delete":
+      if (!Object.hasOwn(value, "key")) throw new TypeError("reactiveMap delete.key required");
+      if (!Object.hasOwn(value, "previous")) {
+        throw new TypeError("reactiveMap delete.previous required");
+      }
+      assertKeys(value, ["key", "kind", "previous", "reason"], "reactiveMap delete");
+      if (value.reason !== "expired" && value.reason !== "lru-evict" && value.reason !== "archived" && value.reason !== "explicit") {
+        throw new TypeError("reactiveMap delete.reason is invalid");
+      }
+      return value;
+    case "clear":
+      assertKeys(value, ["count", "kind"], "reactiveMap clear");
+      assertSafeInteger(value.count, "reactiveMap clear.count", 0);
+      return value;
+    default:
+      throw new TypeError(`unsupported reactiveMap change kind ${value.kind}`);
+  }
+}
+function assertIndexChange(value) {
+  if (!isRecord(value) || typeof value.kind !== "string") {
+    throw new TypeError("reactiveIndex change must be an object with kind");
+  }
+  switch (value.kind) {
+    case "upsert":
+      if (!Object.hasOwn(value, "primary")) {
+        throw new TypeError("reactiveIndex upsert.primary required");
+      }
+      if (!Object.hasOwn(value, "secondary")) {
+        throw new TypeError("reactiveIndex upsert.secondary required");
+      }
+      if (!Object.hasOwn(value, "value"))
+        throw new TypeError("reactiveIndex upsert.value required");
+      assertKeys(value, ["kind", "primary", "secondary", "value"], "reactiveIndex upsert");
+      return value;
+    case "delete":
+      if (!Object.hasOwn(value, "primary")) {
+        throw new TypeError("reactiveIndex delete.primary required");
+      }
+      assertKeys(value, ["kind", "primary"], "reactiveIndex delete");
+      return value;
+    case "deleteMany":
+      assertKeys(value, ["kind", "primaries"], "reactiveIndex deleteMany");
+      assertArray(value.primaries, "reactiveIndex deleteMany.primaries");
+      return value;
+    case "clear":
+      assertKeys(value, ["count", "kind"], "reactiveIndex clear");
+      assertSafeInteger(value.count, "reactiveIndex clear.count", 0);
+      return value;
+    default:
+      throw new TypeError(`unsupported reactiveIndex change kind ${value.kind}`);
+  }
+}
+function applyListChange(state, change) {
+  switch (change.kind) {
+    case "append":
+      state.push(change.value);
+      return;
+    case "appendMany":
+      state.push(...change.values);
+      return;
+    case "insert":
+      if (change.index > state.length)
+        throw new Error("reactiveList insert change is out of range");
+      state.splice(change.index, 0, change.value);
+      return;
+    case "insertMany":
+      if (change.index > state.length) {
+        throw new Error("reactiveList insertMany change is out of range");
+      }
+      state.splice(change.index, 0, ...change.values);
+      return;
+    case "pop":
+      if (change.index >= state.length) throw new Error("reactiveList pop change is out of range");
+      if (!strictJsonEquals(state[change.index], change.value)) {
+        throw new Error("reactiveList pop change value does not match current state");
+      }
+      state.splice(change.index, 1);
+      return;
+    case "trimHead":
+      if (change.n > state.length) throw new Error("reactiveList trimHead change is out of range");
+      state.splice(0, change.n);
+      return;
+    case "clear":
+      if (change.count !== state.length) {
+        throw new Error("reactiveList clear change count does not match current state");
+      }
+      state.length = 0;
+      return;
+  }
+}
+function strictJsonEquals(a, b) {
+  const left = strictCanonicalJsonBytes(a);
+  const right = strictCanonicalJsonBytes(b);
+  if (left.byteLength !== right.byteLength) return false;
+  for (let i = 0; i < left.byteLength; i += 1) if (left[i] !== right[i]) return false;
+  return true;
+}
+function findJsonIndex(values, match, key, label) {
+  let found = -1;
+  for (let i = 0; i < values.length; i += 1) {
+    if (strictJsonEquals(match(values[i]), key)) {
+      if (found !== -1) throw new Error(`${label} duplicate JSON key in restore state`);
+      found = i;
+    }
+  }
+  return found;
+}
+function cmpOrd(a, b) {
+  if (a === b) return 0;
+  const ta = typeof a;
+  if (ta === typeof b && (ta === "number" || ta === "string" || ta === "boolean" || ta === "bigint")) {
+    const ax = a;
+    const bx = b;
+    return ax < bx ? -1 : ax > bx ? 1 : 0;
+  }
+  return String(a).localeCompare(String(b));
+}
+function applyLogChange(state, change) {
+  switch (change.kind) {
+    case "append":
+      state.push(change.value);
+      return;
+    case "appendMany":
+      state.push(...change.values);
+      return;
+    case "trimHead":
+      if (change.n > state.length) throw new Error("reactiveLog trimHead change is out of range");
+      state.splice(0, change.n);
+      return;
+    case "clear":
+      if (change.count !== state.length) {
+        throw new Error("reactiveLog clear change count does not match current state");
+      }
+      state.length = 0;
+      return;
+  }
+}
+function applyMapChange(state, change) {
+  switch (change.kind) {
+    case "set": {
+      const index = findJsonIndex(state, ([key]) => key, change.key, "reactiveMap");
+      if (index === -1) state.push([change.key, change.value]);
+      else state[index] = [change.key, change.value];
+      return;
+    }
+    case "delete": {
+      const index = findJsonIndex(state, ([key]) => key, change.key, "reactiveMap");
+      if (index === -1) throw new Error("reactiveMap delete change key is missing");
+      if (!strictJsonEquals(state[index]?.[1], change.previous)) {
+        throw new Error("reactiveMap delete change previous value does not match current state");
+      }
+      state.splice(index, 1);
+      return;
+    }
+    case "clear":
+      if (change.count !== state.length) {
+        throw new Error("reactiveMap clear change count does not match current state");
+      }
+      state.length = 0;
+      return;
+  }
+}
+function sortIndexRows(state) {
+  state.sort((a, b) => {
+    const bySecondary = cmpOrd(a.secondary, b.secondary);
+    return bySecondary === 0 ? cmpOrd(a.primary, b.primary) : bySecondary;
+  });
+}
+function applyIndexChange(state, change) {
+  switch (change.kind) {
+    case "upsert": {
+      const index = findJsonIndex(state, (row2) => row2.primary, change.primary, "reactiveIndex");
+      const row = {
+        primary: change.primary,
+        secondary: change.secondary,
+        value: change.value
+      };
+      if (index === -1) state.push(row);
+      else state[index] = row;
+      sortIndexRows(state);
+      return;
+    }
+    case "delete": {
+      const index = findJsonIndex(state, (row) => row.primary, change.primary, "reactiveIndex");
+      if (index === -1) throw new Error("reactiveIndex delete change primary is missing");
+      state.splice(index, 1);
+      return;
+    }
+    case "deleteMany": {
+      for (const primary of change.primaries) {
+        const index = findJsonIndex(state, (row) => row.primary, primary, "reactiveIndex");
+        if (index === -1) {
+          throw new Error("reactiveIndex deleteMany change primary is missing");
+        }
+        state.splice(index, 1);
+      }
+      return;
+    }
+    case "clear":
+      if (change.count !== state.length) {
+        throw new Error("reactiveIndex clear change count does not match current state");
+      }
+      state.length = 0;
+      return;
+  }
+}
+function finishState(kind, state, snapshotFound, snapshotCursor, applied, cursor) {
+  return {
+    kind,
+    state,
+    source: snapshotFound ? applied > 0 ? "snapshot+changes" : "snapshot" : applied > 0 ? "changes" : "empty",
+    snapshot: { found: snapshotFound, changeCursor: snapshotCursor },
+    changes: { applied, cursor }
+  };
+}
+function loadState(kind, opts, assertSnapshot, assertChange, applyChange) {
+  const key = opts.snapshotKey ?? collectionSnapshotKey(opts.storagePrefix);
+  return opts.snapshotStore.get(key).then((snapshotValue) => {
+    let snapshotFound = false;
+    let snapshotCursor = -1;
+    let state = [];
+    if (snapshotValue !== void 0) {
+      const frame = assertReactiveCollectionSnapshotFrame(snapshotValue, kind);
+      state = [...assertSnapshot(frame.snapshot)];
+      snapshotFound = true;
+      snapshotCursor = frame.changeCursor;
+    }
+    if (opts.changeLog === void 0) {
+      return finishState(kind, state, snapshotFound, snapshotCursor, 0, snapshotCursor);
+    }
+    return opts.changeLog.read({ after: snapshotCursor }).then((entries) => {
+      let applied = 0;
+      let cursor = snapshotCursor;
+      for (const entry of entries) {
+        const expectedSeq = cursor + 1;
+        if (!Number.isSafeInteger(entry.seq) || entry.seq !== expectedSeq) {
+          throw new Error(
+            `reactive collection change log is non-contiguous: expected seq ${expectedSeq}, got ${entry.seq}`
+          );
+        }
+        const frame = assertReactiveCollectionChangeFrame(entry.value, kind);
+        const change = assertChange(frame.change);
+        applyChange(state, change);
+        applied += 1;
+        cursor = entry.seq;
+      }
+      return finishState(kind, state, snapshotFound, snapshotCursor, applied, cursor);
+    });
+  });
+}
+function loadReactiveListState(opts) {
+  return loadState(
+    "reactiveList",
+    opts,
+    (value) => assertArray(value, "reactiveList snapshot"),
+    assertListChange,
+    applyListChange
+  );
+}
+function loadReactiveLogState(opts) {
+  return loadState(
+    "reactiveLog",
+    opts,
+    (value) => assertArray(value, "reactiveLog snapshot"),
+    assertLogChange,
+    applyLogChange
+  );
+}
+function loadReactiveMapState(opts) {
+  return loadState(
+    "reactiveMap",
+    opts,
+    (value) => assertEntryArray(value, "reactiveMap snapshot"),
+    assertMapChange,
+    applyMapChange
+  );
+}
+function loadReactiveIndexState(opts) {
+  return loadState(
+    "reactiveIndex",
+    opts,
+    (value) => assertIndexRows(value, "reactiveIndex snapshot"),
+    assertIndexChange,
+    applyIndexChange
+  );
+}
+
+// src/storage/wal.ts
+var WAL_KEY_SEGMENT = "wal";
+var WAL_FRAME_SEQ_PAD = 20;
+var WAL_FORMAT_VERSION = 1;
+var SHA_2562 = "SHA-256";
+var HEX_TABLE2 = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+var CHECKSUM_RE = /^[0-9a-f]{64}$/;
+var WAL_BODY_KEYS = /* @__PURE__ */ new Set([
+  "t",
+  "lifecycle",
+  "path",
+  "change",
+  "frame_seq",
+  "frame_t_ns",
+  "format_version"
+]);
+var WAL_FRAME_KEYS = /* @__PURE__ */ new Set([...WAL_BODY_KEYS, "checksum"]);
+function bytesToHex2(bytes) {
+  let out = "";
+  for (const byte of bytes) out += HEX_TABLE2[byte];
+  return out;
+}
+function sha256Hex2(data) {
+  const digestInput = Uint8Array.from(data);
+  return globalThis.crypto.subtle.digest(SHA_2562, digestInput).then((buf) => bytesToHex2(new Uint8Array(buf)));
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isLifecycle(value) {
+  return value === "spec" || value === "data" || value === "ownership";
+}
+function assertOnlyKeys(value, allowed) {
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key)) throw new TypeError(`walFrameCodec: unknown field ${key}`);
+  }
+}
+function assertFrameSeq(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError(`${label} must be a non-negative safe integer`);
+  }
+  return value;
+}
+function assertWalFrameBody(value, allowedKeys = WAL_BODY_KEYS) {
+  if (!isRecord2(value)) throw new TypeError("walFrameCodec: frame must be an object");
+  assertOnlyKeys(value, allowedKeys);
+  if (value.t !== "c") throw new TypeError("walFrameCodec: t must be c");
+  if (!isLifecycle(value.lifecycle)) {
+    throw new TypeError("walFrameCodec: lifecycle must be spec, data, or ownership");
+  }
+  if (typeof value.path !== "string" || value.path.length === 0) {
+    throw new TypeError("walFrameCodec: path must be a non-empty string");
+  }
+  if (!Object.hasOwn(value, "change")) {
+    throw new TypeError("walFrameCodec: change payload is required");
+  }
+  const frameSeq = assertFrameSeq(value.frame_seq, "walFrameCodec: frame_seq");
+  const frameTimestamp = assertNonNegativeDecimalIntegerString(
+    value.frame_t_ns,
+    "walFrameCodec: frame_t_ns"
+  );
+  if (value.format_version !== WAL_FORMAT_VERSION) {
+    throw new TypeError(`walFrameCodec: format_version must be ${WAL_FORMAT_VERSION}`);
+  }
+  return {
+    t: "c",
+    lifecycle: value.lifecycle,
+    path: value.path,
+    change: value.change,
+    frame_seq: frameSeq,
+    frame_t_ns: frameTimestamp,
+    format_version: WAL_FORMAT_VERSION
+  };
+}
+function walFramePrefix(namespace) {
+  if (namespace.length === 0) return WAL_KEY_SEGMENT;
+  return `${namespace}/${WAL_KEY_SEGMENT}`;
+}
+function walFrameKey(prefix, frameSeq) {
+  if (!Number.isSafeInteger(frameSeq) || frameSeq < 0) {
+    throw new RangeError(
+      `walFrameKey: frameSeq must be a non-negative safe integer, got ${frameSeq}`
+    );
+  }
+  return `${prefix}/${frameSeq.toString().padStart(WAL_FRAME_SEQ_PAD, "0")}`;
+}
+function walFrameChecksum(body) {
+  let bytes;
+  try {
+    bytes = strictCanonicalJsonBytes(assertWalFrameBody(body));
+  } catch (err) {
+    return Promise.resolve().then(() => {
+      throw err;
+    });
+  }
+  return sha256Hex2(bytes);
+}
+function walFrame(opts) {
+  const body = {
+    t: "c",
+    lifecycle: opts.lifecycle ?? "data",
+    path: opts.path,
+    change: opts.change,
+    frame_seq: opts.frame_seq,
+    frame_t_ns: opts.frame_t_ns ?? nowNs(),
+    format_version: WAL_FORMAT_VERSION
+  };
+  return walFrameChecksum(body).then((checksum) => ({ ...body, checksum }));
+}
+function assertWalFrame(value) {
+  if (!isRecord2(value)) throw new TypeError("walFrameCodec: frame must be an object");
+  assertOnlyKeys(value, WAL_FRAME_KEYS);
+  const body = assertWalFrameBody(value, WAL_FRAME_KEYS);
+  const checksum = value.checksum;
+  if (typeof checksum !== "string" || !CHECKSUM_RE.test(checksum)) {
+    throw new TypeError("walFrameCodec: checksum must be a lowercase sha256 hex string");
+  }
+  return { ...body, checksum };
+}
+function verifyWalFrameChecksum(frame) {
+  let checked;
+  try {
+    checked = assertWalFrame(frame);
+  } catch (err) {
+    return Promise.resolve().then(() => {
+      throw err;
+    });
+  }
+  const { checksum, ...body } = checked;
+  return walFrameChecksum(body).then((expected) => expected === checksum);
+}
+function walFrameCodec() {
+  const codec = strictJsonCodecFor();
+  return {
+    encode(value) {
+      return codec.encode(assertWalFrame(value));
+    },
+    decode(bytes) {
+      return assertWalFrame(codec.decode(bytes));
+    }
+  };
+}
+
+export {
+  ContentAddressedMissError,
+  contentAddressedKv,
+  contentAddressedStorage,
+  REACTIVE_COLLECTION_SNAPSHOT_FORMAT,
+  REACTIVE_COLLECTION_CHANGE_FORMAT,
+  REACTIVE_COLLECTION_FRAME_VERSION,
+  collectionSnapshotKey,
+  reactiveCollectionSnapshotFrame,
+  reactiveCollectionChangeFrame,
+  assertReactiveCollectionSnapshotFrame,
+  assertReactiveCollectionChangeFrame,
+  reactiveCollectionSnapshotFrameCodec,
+  reactiveCollectionChangeFrameCodec,
+  loadReactiveListState,
+  loadReactiveLogState,
+  loadReactiveMapState,
+  loadReactiveIndexState,
+  WAL_KEY_SEGMENT,
+  WAL_FRAME_SEQ_PAD,
+  WAL_FORMAT_VERSION,
+  walFramePrefix,
+  walFrameKey,
+  walFrameChecksum,
+  walFrame,
+  assertWalFrame,
+  verifyWalFrameChecksum,
+  walFrameCodec
+};
+//# sourceMappingURL=chunk-GTPCOEOZ.js.map