@graphrefly/ts 0.0.0

package/dist/storage/index.cjs

@@ -0,0 +1,1989 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/storage/index.ts
+var storage_exports = {};
+__export(storage_exports, {
+  APPEND_LOG_SEQ_PAD: () => APPEND_LOG_SEQ_PAD,
+  ContentAddressedMissError: () => ContentAddressedMissError,
+  REACTIVE_COLLECTION_CHANGE_FORMAT: () => REACTIVE_COLLECTION_CHANGE_FORMAT,
+  REACTIVE_COLLECTION_FRAME_VERSION: () => REACTIVE_COLLECTION_FRAME_VERSION,
+  REACTIVE_COLLECTION_SNAPSHOT_FORMAT: () => REACTIVE_COLLECTION_SNAPSHOT_FORMAT,
+  WAL_FORMAT_VERSION: () => WAL_FORMAT_VERSION,
+  WAL_FRAME_SEQ_PAD: () => WAL_FRAME_SEQ_PAD,
+  WAL_KEY_SEGMENT: () => WAL_KEY_SEGMENT,
+  appendLogKey: () => appendLogKey,
+  appendLogStorage: () => appendLogStorage,
+  assertChangeEnvelope: () => assertChangeEnvelope,
+  assertDecimalIntegerString: () => assertDecimalIntegerString,
+  assertNonNegativeDecimalIntegerString: () => assertNonNegativeDecimalIntegerString,
+  assertObserveEventFrame: () => assertObserveEventFrame,
+  assertReactiveCollectionChangeFrame: () => assertReactiveCollectionChangeFrame,
+  assertReactiveCollectionSnapshotFrame: () => assertReactiveCollectionSnapshotFrame,
+  assertStrictJsonObject: () => assertStrictJsonObject,
+  assertStrictJsonValue: () => assertStrictJsonValue,
+  assertWalFrame: () => assertWalFrame,
+  bigIntToDecimalString: () => bigIntToDecimalString,
+  bigIntToNonNegativeDecimalString: () => bigIntToNonNegativeDecimalString,
+  changeEnvelopeCodec: () => changeEnvelopeCodec,
+  collectionSnapshotKey: () => collectionSnapshotKey,
+  contentAddressedKv: () => contentAddressedKv,
+  contentAddressedStorage: () => contentAddressedStorage,
+  decimalStringToBigInt: () => decimalStringToBigInt,
+  dictKv: () => dictKv,
+  envelopeChange: () => envelopeChange,
+  hasKvPutIfAbsent: () => hasKvPutIfAbsent,
+  hasKvVersioned: () => hasKvVersioned,
+  hasStoragePutIfAbsent: () => hasStoragePutIfAbsent,
+  hasStorageVersioned: () => hasStorageVersioned,
+  isDecimalIntegerString: () => isDecimalIntegerString,
+  isNonNegativeDecimalIntegerString: () => isNonNegativeDecimalIntegerString,
+  jsonCodec: () => jsonCodec,
+  jsonCodecFor: () => jsonCodecFor,
+  kvStorage: () => kvStorage,
+  listByPrefix: () => listByPrefix2,
+  loadReactiveIndexState: () => loadReactiveIndexState,
+  loadReactiveListState: () => loadReactiveListState,
+  loadReactiveLogState: () => loadReactiveLogState,
+  loadReactiveMapState: () => loadReactiveMapState,
+  memoryAppendLog: () => memoryAppendLog,
+  memoryBackend: () => memoryBackend,
+  memoryKv: () => memoryKv,
+  memoryMultiWriterAppendLog: () => memoryMultiWriterAppendLog,
+  multiWriterAppendLogStorage: () => multiWriterAppendLogStorage,
+  nonNegativeDecimalStringToBigInt: () => nonNegativeDecimalStringToBigInt,
+  nowNs: () => nowNs,
+  observeEventFrame: () => observeEventFrame,
+  observeEventFrameCodec: () => observeEventFrameCodec,
+  reactiveCollectionChangeFrame: () => reactiveCollectionChangeFrame,
+  reactiveCollectionChangeFrameCodec: () => reactiveCollectionChangeFrameCodec,
+  reactiveCollectionSnapshotFrame: () => reactiveCollectionSnapshotFrame,
+  reactiveCollectionSnapshotFrameCodec: () => reactiveCollectionSnapshotFrameCodec,
+  readAppendLogPage: () => readAppendLogPage,
+  readObserveEventLogPage: () => readObserveEventLogPage,
+  readThroughKv: () => readThroughKv,
+  requireKvPutIfAbsent: () => requireKvPutIfAbsent,
+  requireKvVersioned: () => requireKvVersioned,
+  requireStoragePutIfAbsent: () => requireStoragePutIfAbsent,
+  requireStorageVersioned: () => requireStorageVersioned,
+  stableJsonString: () => stableJsonString,
+  strictJsonCodec: () => strictJsonCodec,
+  strictJsonCodecFor: () => strictJsonCodecFor,
+  tieredReadThrough: () => tieredReadThrough,
+  verifyWalFrameChecksum: () => verifyWalFrameChecksum,
+  walFrame: () => walFrame,
+  walFrameChecksum: () => walFrameChecksum,
+  walFrameCodec: () => walFrameCodec,
+  walFrameKey: () => walFrameKey,
+  walFramePrefix: () => walFramePrefix,
+  webStorageBackend: () => webStorageBackend
+});
+module.exports = __toCommonJS(storage_exports);
+
+// src/storage/backend.ts
+var HEX_TABLE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+var NAMESPACE_SEPARATOR = "\0";
+function cloneBytes(bytes) {
+  return Uint8Array.from(bytes);
+}
+function encodeNamespacePrefix(namespace) {
+  return namespace.length > 0 ? `${namespace}${NAMESPACE_SEPARATOR}` : "";
+}
+function encodeBytesToHex(bytes) {
+  let out = "";
+  for (const byte of bytes) out += HEX_TABLE[byte];
+  return out;
+}
+function decodeHexToBytes(raw) {
+  if (raw.length % 2 !== 0 || !/^[0-9a-f]*$/i.test(raw)) {
+    throw new TypeError("webStorageBackend: malformed stored bytes");
+  }
+  const out = new Uint8Array(raw.length / 2);
+  for (let i = 0; i < raw.length; i += 2) {
+    const value = Number.parseInt(raw.slice(i, i + 2), 16);
+    if (Number.isNaN(value)) throw new TypeError("webStorageBackend: malformed stored bytes");
+    out[i / 2] = value;
+  }
+  return out;
+}
+function validateLogicalKey(label, key) {
+  if (typeof key !== "string") {
+    throw new TypeError(`${label}: key must be a string`);
+  }
+  if (key.includes(NAMESPACE_SEPARATOR)) {
+    throw new TypeError(`${label}: key must not contain U+0000`);
+  }
+  return key;
+}
+function validateListPrefix(label, prefix) {
+  if (typeof prefix !== "string") {
+    throw new TypeError(`${label}: list prefix must be a string`);
+  }
+  if (prefix.includes(NAMESPACE_SEPARATOR)) {
+    throw new TypeError(`${label}: list prefix must not contain U+0000`);
+  }
+  return prefix;
+}
+function validateNamespace(label, namespace) {
+  if (typeof namespace !== "string") {
+    throw new TypeError(`${label}: namespace must be a string`);
+  }
+  if (namespace.includes(NAMESPACE_SEPARATOR)) {
+    throw new TypeError(`${label}: namespace must not contain U+0000`);
+  }
+  return namespace;
+}
+function hasStoragePutIfAbsent(backend) {
+  return typeof backend.putIfAbsent === "function";
+}
+function requireStoragePutIfAbsent(backend, label = "storage backend") {
+  if (!hasStoragePutIfAbsent(backend)) {
+    throw new Error(`${label}: backend does not support putIfAbsent`);
+  }
+  return backend;
+}
+function hasStorageVersioned(backend) {
+  return typeof backend.getVersioned === "function" && typeof backend.setIfMatch === "function";
+}
+function requireStorageVersioned(backend, label = "storage backend") {
+  if (!hasStorageVersioned(backend)) {
+    throw new Error(`${label}: backend does not support versioned get/set-if-match`);
+  }
+  return backend;
+}
+function toStorageKey(namespace, key) {
+  return `${encodeNamespacePrefix(namespace)}${key}`;
+}
+function enumerateStorageKeys(storage) {
+  if (storage.keys) return [...storage.keys()];
+  if (typeof storage.key === "function" && typeof storage.length === "number") {
+    const keys = [];
+    for (let i = 0; i < storage.length; i += 1) {
+      const key = storage.key(i);
+      if (key !== null && key !== void 0) keys.push(key);
+    }
+    return keys;
+  }
+  const fallback = storage;
+  return Object.keys(fallback).filter((key) => typeof fallback[key] === "string");
+}
+function decodeStorageListKey(namespace, rawKey) {
+  if (typeof rawKey !== "string") {
+    throw new TypeError("webStorageBackend: stored key must be a string");
+  }
+  const prefix = encodeNamespacePrefix(namespace);
+  if (!rawKey.startsWith(prefix)) return void 0;
+  const logical = rawKey.slice(prefix.length);
+  if (logical.includes(NAMESPACE_SEPARATOR)) {
+    throw new TypeError("webStorageBackend: malformed stored key");
+  }
+  return logical;
+}
+function listByPrefix(namespace, prefix, raw) {
+  const out = [];
+  for (const key of raw) {
+    const logical = decodeStorageListKey(namespace, key);
+    if (logical === void 0) continue;
+    if (!logical.startsWith(prefix)) continue;
+    out.push(logical);
+  }
+  out.sort();
+  return out;
+}
+function webStorageBackend(storage, opts = {}) {
+  const namespace = opts.namespace === void 0 ? "" : validateNamespace("webStorageBackend", opts.namespace);
+  return {
+    get(key) {
+      const raw = storage.getItem(
+        toStorageKey(namespace, validateLogicalKey("webStorageBackend", key))
+      );
+      if (raw === null || raw === void 0) return void 0;
+      return decodeHexToBytes(raw);
+    },
+    put(key, value) {
+      storage.setItem(
+        toStorageKey(namespace, validateLogicalKey("webStorageBackend", key)),
+        encodeBytesToHex(cloneBytes(value))
+      );
+    },
+    delete(key) {
+      storage.removeItem(toStorageKey(namespace, validateLogicalKey("webStorageBackend", key)));
+    },
+    list(prefix = "") {
+      return listByPrefix(
+        namespace,
+        validateListPrefix("webStorageBackend", prefix),
+        enumerateStorageKeys(storage)
+      );
+    }
+  };
+}
+var MEMORY_GENERATION = /* @__PURE__ */ Symbol("graphrefly.memoryBackend.generation");
+function memoryGeneration(epoch, key, version) {
+  return Object.freeze({ [MEMORY_GENERATION]: Object.freeze([epoch, key, version]) });
+}
+function readMemoryGeneration(generation) {
+  if (typeof generation !== "object" || generation === null) return void 0;
+  const maybe = generation;
+  const token = maybe[MEMORY_GENERATION];
+  if (Array.isArray(token) && token.length === 3 && typeof token[0] === "number" && typeof token[1] === "string" && typeof token[2] === "number") {
+    return token;
+  }
+  return void 0;
+}
+function memoryBackend(initial = []) {
+  const entries = /* @__PURE__ */ new Map();
+  const versions = /* @__PURE__ */ new Map();
+  let epoch = 0;
+  for (const [key, value] of initial) {
+    entries.set(validateLogicalKey("memoryBackend", key), cloneBytes(value));
+  }
+  const versionOf = (key) => versions.get(key) ?? 0;
+  const bump = (key) => {
+    versions.set(key, versionOf(key) + 1);
+  };
+  return {
+    entries,
+    get(key) {
+      const value = entries.get(validateLogicalKey("memoryBackend", key));
+      return value === void 0 ? void 0 : cloneBytes(value);
+    },
+    put(key, value) {
+      validateLogicalKey("memoryBackend", key);
+      entries.set(key, cloneBytes(value));
+      bump(key);
+    },
+    putIfAbsent(key, value) {
+      validateLogicalKey("memoryBackend", key);
+      if (entries.has(key)) return false;
+      entries.set(key, cloneBytes(value));
+      bump(key);
+      return true;
+    },
+    getVersioned(key) {
+      validateLogicalKey("memoryBackend", key);
+      const value = entries.get(key);
+      const generation = memoryGeneration(epoch, key, versionOf(key));
+      if (value === void 0) return { kind: "miss", generation };
+      return { kind: "hit", value: cloneBytes(value), generation };
+    },
+    setIfMatch(key, value, generation) {
+      validateLogicalKey("memoryBackend", key);
+      const observed = readMemoryGeneration(generation);
+      if (observed === void 0 || observed[0] !== epoch || observed[1] !== key || observed[2] !== versionOf(key)) {
+        return false;
+      }
+      entries.set(key, cloneBytes(value));
+      bump(key);
+      return true;
+    },
+    delete(key) {
+      validateLogicalKey("memoryBackend", key);
+      if (entries.delete(key)) bump(key);
+    },
+    list(prefix = "") {
+      const validatedPrefix = validateListPrefix("memoryBackend", prefix);
+      return [...entries.keys()].filter((key) => key.startsWith(validatedPrefix)).sort();
+    },
+    clear() {
+      entries.clear();
+      versions.clear();
+      epoch += 1;
+    }
+  };
+}
+
+// src/json/codec.ts
+var JS_MIN_NORMAL_NUMBER = 2 ** -1022;
+function assertStableJsonNumber(value, path) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`stableJsonString: non-finite number at ${path}`);
+  }
+}
+function assertStrictJsonNumber(value, path) {
+  assertStableJsonNumber(value, path);
+  if (Object.is(value, -0)) {
+    throw new TypeError(`stableJsonString: non-canonical number at ${path}`);
+  }
+  const abs = Math.abs(value);
+  if (abs > 0 && abs < JS_MIN_NORMAL_NUMBER) {
+    throw new TypeError(`stableJsonString: subnormal number at ${path}`);
+  }
+  if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+    throw new TypeError(`stableJsonString: integer outside safe range at ${path}`);
+  }
+}
+function sortedJsonValue(value, seen = /* @__PURE__ */ new Set(), path = "$", strictNumbers = false) {
+  if (value === null) return null;
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (strictNumbers) assertStrictJsonNumber(value, path);
+    else assertStableJsonNumber(value, path);
+    return value;
+  }
+  if (typeof value !== "object") {
+    throw new TypeError(`stableJsonString: value at ${path} is not JSON-encodable`);
+  }
+  if (seen.has(value)) throw new TypeError(`stableJsonString: circular reference at ${path}`);
+  const proto = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && proto !== Object.prototype && proto !== null) {
+    throw new TypeError(`stableJsonString: non-plain object at ${path}`);
+  }
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      if (Object.getOwnPropertySymbols(value).length > 0) {
+        throw new TypeError(`stableJsonString: symbol-keyed properties at ${path}`);
+      }
+      for (const key of Object.getOwnPropertyNames(value)) {
+        const isIndex = /^(0|[1-9]\d*)$/.test(key) && Number.isSafeInteger(Number(key)) && Number(key) < value.length;
+        if (key !== "length" && !isIndex) {
+          throw new TypeError(`stableJsonString: non-index array property at ${path}.${key}`);
+        }
+      }
+      const out2 = [];
+      for (let i = 0; i < value.length; i += 1) {
+        if (!(i in value)) {
+          throw new TypeError(`stableJsonString: sparse array hole at ${path}[${i}]`);
+        }
+        out2.push(sortedJsonValue(value[i], seen, `${path}[${i}]`, strictNumbers));
+      }
+      return out2;
+    }
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      throw new TypeError(`stableJsonString: symbol-keyed properties at ${path}`);
+    }
+    const out = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(value).sort()) {
+      out[key] = sortedJsonValue(
+        value[key],
+        seen,
+        `${path}.${key}`,
+        strictNumbers
+      );
+    }
+    return out;
+  } finally {
+    seen.delete(value);
+  }
+}
+function stableJsonString(value) {
+  return JSON.stringify(sortedJsonValue(value));
+}
+function strictStableJsonString(value) {
+  return JSON.stringify(sortedJsonValue(value, /* @__PURE__ */ new Set(), "$", true));
+}
+function jsonCodecFor() {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  return {
+    encode(value) {
+      return encoder.encode(stableJsonString(value));
+    },
+    decode(bytes) {
+      return JSON.parse(decoder.decode(bytes));
+    }
+  };
+}
+var jsonCodec = jsonCodecFor();
+function bytesEqual(a, b) {
+  if (a.byteLength !== b.byteLength) return false;
+  for (let i = 0; i < a.byteLength; i += 1) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function hasUnpairedSurrogate(value) {
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        i += 1;
+        continue;
+      }
+      return true;
+    }
+    if (code >= 56320 && code <= 57343) return true;
+  }
+  return false;
+}
+function assertNoUnpairedSurrogates(value, seen = /* @__PURE__ */ new Set(), path = "$") {
+  if (typeof value === "string") {
+    if (hasUnpairedSurrogate(value)) {
+      throw new TypeError(`strictJsonCodec: unpaired surrogate at ${path}`);
+    }
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  if (seen.has(value)) return;
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i += 1) {
+        assertNoUnpairedSurrogates(value[i], seen, `${path}[${i}]`);
+      }
+      return;
+    }
+    for (const key of Object.keys(value)) {
+      if (hasUnpairedSurrogate(key)) {
+        throw new TypeError(`strictJsonCodec: unpaired surrogate at ${path}.${key}`);
+      }
+      assertNoUnpairedSurrogates(value[key], seen, `${path}.${key}`);
+    }
+  } finally {
+    seen.delete(value);
+  }
+}
+function assertNoDuplicateJsonObjectKeys(text) {
+  let index = 0;
+  function fail(message) {
+    throw new TypeError(`strictJsonCodec: ${message}`);
+  }
+  function skipWhitespace() {
+    while (/\s/.test(text[index] ?? "")) index += 1;
+  }
+  function readJsonString() {
+    const start = index;
+    index += 1;
+    while (index < text.length) {
+      const ch = text[index];
+      if (ch === '"') {
+        index += 1;
+        try {
+          return JSON.parse(text.slice(start, index));
+        } catch {
+          fail("malformed JSON string");
+        }
+      }
+      if (ch === "\\") {
+        index += 2;
+        continue;
+      }
+      index += 1;
+    }
+    fail("unterminated JSON string");
+  }
+  function consumeLiteral(literal) {
+    if (text.slice(index, index + literal.length) !== literal) {
+      fail(`malformed JSON near byte ${index}`);
+    }
+    index += literal.length;
+  }
+  function consumeNumber() {
+    const match = /^-?(0|[1-9]\d*)(\.\d+)?([eE][+-]?\d+)?/.exec(text.slice(index));
+    if (!match) fail(`malformed JSON number near byte ${index}`);
+    index += match[0].length;
+  }
+  function parseValue(path) {
+    skipWhitespace();
+    const ch = text[index];
+    if (ch === "{") {
+      parseObject(path);
+      return;
+    }
+    if (ch === "[") {
+      parseArray(path);
+      return;
+    }
+    if (ch === '"') {
+      readJsonString();
+      return;
+    }
+    if (ch === "t") {
+      consumeLiteral("true");
+      return;
+    }
+    if (ch === "f") {
+      consumeLiteral("false");
+      return;
+    }
+    if (ch === "n") {
+      consumeLiteral("null");
+      return;
+    }
+    if (ch === "-" || ch !== void 0 && ch >= "0" && ch <= "9") {
+      consumeNumber();
+      return;
+    }
+    fail(`malformed JSON near byte ${index}`);
+  }
+  function parseObject(path) {
+    const keys = /* @__PURE__ */ new Set();
+    index += 1;
+    skipWhitespace();
+    if (text[index] === "}") {
+      index += 1;
+      return;
+    }
+    while (index < text.length) {
+      skipWhitespace();
+      if (text[index] !== '"') fail(`expected object key near byte ${index}`);
+      const key = readJsonString();
+      if (keys.has(key)) {
+        throw new TypeError(
+          `strictJsonCodec: duplicate object key ${JSON.stringify(key)} at ${path}`
+        );
+      }
+      keys.add(key);
+      skipWhitespace();
+      if (text[index] !== ":") fail(`expected ':' after object key near byte ${index}`);
+      index += 1;
+      parseValue(`${path}.${key}`);
+      skipWhitespace();
+      if (text[index] === ",") {
+        index += 1;
+        continue;
+      }
+      if (text[index] === "}") {
+        index += 1;
+        return;
+      }
+      fail(`expected ',' or '}' near byte ${index}`);
+    }
+    fail("unterminated JSON object");
+  }
+  function parseArray(path) {
+    index += 1;
+    skipWhitespace();
+    if (text[index] === "]") {
+      index += 1;
+      return;
+    }
+    let item = 0;
+    while (index < text.length) {
+      parseValue(`${path}[${item}]`);
+      item += 1;
+      skipWhitespace();
+      if (text[index] === ",") {
+        index += 1;
+        continue;
+      }
+      if (text[index] === "]") {
+        index += 1;
+        return;
+      }
+      fail(`expected ',' or ']' near byte ${index}`);
+    }
+    fail("unterminated JSON array");
+  }
+  parseValue("$");
+  skipWhitespace();
+  if (index !== text.length) fail(`trailing JSON token near byte ${index}`);
+}
+function strictJsonCodecFor() {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  return {
+    encode(value) {
+      assertNoUnpairedSurrogates(value);
+      return encoder.encode(strictStableJsonString(value));
+    },
+    decode(bytes) {
+      const text = decoder.decode(bytes);
+      assertNoDuplicateJsonObjectKeys(text);
+      const decoded = JSON.parse(text);
+      assertNoUnpairedSurrogates(decoded);
+      const canonical = encoder.encode(strictStableJsonString(decoded));
+      if (!bytesEqual(bytes, canonical)) {
+        throw new TypeError("strictJsonCodec: bytes are not canonical stable JSON");
+      }
+      return decoded;
+    }
+  };
+}
+var strictJsonCodec = strictJsonCodecFor();
+function strictCanonicalJsonBytes(value) {
+  return strictJsonCodec.encode(value);
+}
+function assertStrictJsonValue(value, label = "strictJsonValue") {
+  try {
+    return strictJsonCodec.decode(strictJsonCodec.encode(value));
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    throw new TypeError(`${label}: value is not strict JSON compatible: ${message}`, { cause });
+  }
+}
+function assertStrictJsonObject(value, label = "strictJsonObject") {
+  const normalized = assertStrictJsonValue(value, label);
+  if (normalized === null || typeof normalized !== "object" || Array.isArray(normalized)) {
+    throw new TypeError(`${label}: value must be a strict JSON object`);
+  }
+  return normalized;
+}
+
+// src/storage/kv.ts
+function hasKvPutIfAbsent(tier) {
+  return typeof tier.putIfAbsent === "function";
+}
+function requireKvPutIfAbsent(tier, label = "kvStorage") {
+  if (!hasKvPutIfAbsent(tier)) {
+    throw new Error(`${label}: KV tier does not support putIfAbsent`);
+  }
+  return tier;
+}
+function hasKvVersioned(tier) {
+  return typeof tier.getVersioned === "function" && typeof tier.setIfMatch === "function";
+}
+function requireKvVersioned(tier, label = "kvStorage") {
+  if (!hasKvVersioned(tier)) {
+    throw new Error(`${label}: KV tier does not support versioned get/set-if-match`);
+  }
+  return tier;
+}
+function defer(fn) {
+  return Promise.resolve().then(fn);
+}
+function kvStorage(opts) {
+  const codec = opts.codec ?? jsonCodecFor();
+  const { backend } = opts;
+  const tier = {
+    get(key) {
+      return defer(() => backend.get(key)).then(
+        (bytes) => bytes === void 0 ? void 0 : codec.decode(bytes)
+      );
+    },
+    set(key, value) {
+      return defer(() => backend.put(key, codec.encode(value))).then(() => void 0);
+    },
+    delete(key) {
+      return defer(() => backend.delete?.(key)).then(() => void 0);
+    },
+    list(prefix = "") {
+      return defer(() => {
+        if (!backend.list) throw new Error("kvStorage.list: backend does not support listing");
+        return backend.list(prefix);
+      }).then((keys) => [...keys].sort());
+    }
+  };
+  let out = tier;
+  if (hasStoragePutIfAbsent(backend)) {
+    out = {
+      ...out,
+      putIfAbsent(key, value) {
+        return defer(() => backend.putIfAbsent(key, codec.encode(value)));
+      }
+    };
+  }
+  if (hasStorageVersioned(backend)) {
+    out = {
+      ...out,
+      getVersioned(key) {
+        return defer(() => backend.getVersioned(key)).then((result) => {
+          if (result.kind === "miss") return { kind: "miss", generation: result.generation };
+          return {
+            kind: "hit",
+            value: codec.decode(result.value),
+            generation: result.generation
+          };
+        });
+      },
+      setIfMatch(key, value, generation) {
+        return defer(() => backend.setIfMatch(key, codec.encode(value), generation));
+      }
+    };
+  }
+  return out;
+}
+function memoryKv(codec = jsonCodecFor()) {
+  return kvStorage({ backend: memoryBackend(), codec });
+}
+function dictKv(entries = {}, codec = jsonCodecFor()) {
+  const backend = memoryBackend();
+  const kv = kvStorage({ backend, codec });
+  for (const [key, value] of Object.entries(entries)) {
+    backend.put(key, codec.encode(value));
+  }
+  return kv;
+}
+function listByPrefix2(tier, prefix = "") {
+  return tier.list(prefix);
+}
+
+// src/storage/append-log.ts
+var APPEND_LOG_SEQ_PAD = 20;
+function appendLogKey(prefix, seq) {
+  if (!Number.isSafeInteger(seq) || seq < 0) {
+    throw new RangeError(`appendLogKey: seq must be a non-negative safe integer, got ${seq}`);
+  }
+  return `${prefix}/${seq.toString().padStart(APPEND_LOG_SEQ_PAD, "0")}`;
+}
+function seqFromKey(prefix, key) {
+  const head = `${prefix}/`;
+  if (!key.startsWith(head)) throw new Error(`append log key outside prefix: ${key}`);
+  const raw = key.slice(head.length);
+  if (!/^\d+$/.test(raw)) {
+    throw new Error(`append log key has a non-numeric sequence: ${key}`);
+  }
+  if (raw.length !== APPEND_LOG_SEQ_PAD) {
+    throw new Error(`append log key sequence must be ${APPEND_LOG_SEQ_PAD} padded digits: ${key}`);
+  }
+  const seq = Number(raw);
+  if (!Number.isSafeInteger(seq)) {
+    throw new Error(`append log key sequence is outside the safe integer range: ${key}`);
+  }
+  return seq;
+}
+function nextSeqFromKeys(prefix, keys) {
+  if (keys.length === 0) return 0;
+  const next = Math.max(...keys.map((key) => seqFromKey(prefix, key))) + 1;
+  if (!Number.isSafeInteger(next)) {
+    throw new RangeError(`append log next sequence is outside the safe integer range: ${prefix}`);
+  }
+  return next;
+}
+function sizeFromKeys(prefix, keys) {
+  for (const key of keys) seqFromKey(prefix, key);
+  return keys.length;
+}
+function validateReadOptions(opts) {
+  const after = opts.after ?? -1;
+  const limit = opts.limit ?? Number.POSITIVE_INFINITY;
+  if (!Number.isSafeInteger(after) || after < -1) {
+    throw new RangeError(
+      `appendLogStorage.read: after must be an integer cursor >= -1, got ${after}`
+    );
+  }
+  if (limit !== Number.POSITIVE_INFINITY && (!Number.isSafeInteger(limit) || limit < 0)) {
+    throw new RangeError(
+      `appendLogStorage.read: limit must be a non-negative safe integer or Infinity, got ${limit}`
+    );
+  }
+  return { after, limit };
+}
+function validatePageLimit(limit) {
+  if (!Number.isSafeInteger(limit) || limit < 1) {
+    throw new RangeError(`readAppendLogPage: limit must be a positive safe integer, got ${limit}`);
+  }
+  if (limit >= Number.MAX_SAFE_INTEGER) {
+    throw new RangeError("readAppendLogPage: limit must leave room for one lookahead entry");
+  }
+  return limit;
+}
+function readAppendLogEntries(kv, prefix, opts) {
+  const { after, limit } = validateReadOptions(opts);
+  return kv.list(`${prefix}/`).then((listed) => {
+    const keys = listed.map((key) => ({ key, seq: seqFromKey(prefix, key) })).filter(({ seq }) => seq > after).sort((a, b) => a.seq - b.seq).slice(0, limit);
+    return Promise.all(
+      keys.map(
+        ({ key, seq }) => kv.get(key).then((value) => {
+          if (value === void 0) {
+            throw new Error(`append log listed key is missing: ${key}`);
+          }
+          return { key, seq, value };
+        })
+      )
+    ).then((entries) => {
+      const out = [];
+      for (const entry of entries) if (entry !== void 0) out.push(entry);
+      return out;
+    });
+  });
+}
+function readAppendLogPage(log, opts = {}) {
+  const { after, limit } = validateReadOptions({ after: opts.after, limit: opts.limit ?? 100 });
+  const pageLimit = validatePageLimit(limit);
+  return log.read({ after, limit: pageLimit + 1 }).then((entries) => {
+    const visible = entries.slice(0, pageLimit);
+    const last = visible[visible.length - 1];
+    return {
+      entries: visible,
+      nextAfter: last?.seq ?? after,
+      done: entries.length <= pageLimit
+    };
+  });
+}
+function deleteAppendLogEntriesAfter(kv, prefix, seq) {
+  return kv.list(`${prefix}/`).then(
+    (keys) => Promise.all(keys.filter((key) => seqFromKey(prefix, key) > seq).map((key) => kv.delete(key)))
+  ).then(() => kv.list(`${prefix}/`)).then(() => void 0);
+}
+function appendLogStorage(opts) {
+  const { kv, prefix = "event-log" } = opts;
+  let tail = Promise.resolve();
+  function initNextSeq() {
+    return kv.list(`${prefix}/`).then((keys) => {
+      return nextSeqFromKeys(prefix, keys);
+    });
+  }
+  function enqueue(task) {
+    const run = tail.then(task, task);
+    tail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  return {
+    append(value) {
+      return enqueue(
+        () => initNextSeq().then((seq) => {
+          const key = appendLogKey(prefix, seq);
+          return kv.set(key, value).then(() => {
+            return { key, seq, value };
+          });
+        })
+      );
+    },
+    read(opts2 = {}) {
+      return enqueue(() => readAppendLogEntries(kv, prefix, opts2));
+    },
+    truncateAfter(seq) {
+      return enqueue(() => deleteAppendLogEntriesAfter(kv, prefix, seq));
+    },
+    size() {
+      return enqueue(() => kv.list(`${prefix}/`).then((keys) => sizeFromKeys(prefix, keys)));
+    }
+  };
+}
+function multiWriterAppendLogStorage(opts) {
+  const { kv, prefix = "event-log", maxAttempts = 1024 } = opts;
+  const capableKv = requireKvPutIfAbsent(kv, "multiWriterAppendLogStorage");
+  let tail = Promise.resolve();
+  if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1) {
+    throw new RangeError(
+      `multiWriterAppendLogStorage: maxAttempts must be a positive safe integer, got ${maxAttempts}`
+    );
+  }
+  function initNextSeq() {
+    return kv.list(`${prefix}/`).then((keys) => nextSeqFromKeys(prefix, keys));
+  }
+  function enqueue(task) {
+    const run = tail.then(task, task);
+    tail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  return {
+    append(value) {
+      return enqueue(
+        () => initNextSeq().then((startSeq) => {
+          let seq = startSeq;
+          let attempt = 0;
+          const tryNext = () => {
+            if (attempt >= maxAttempts) {
+              return initNextSeq().then((refreshedSeq) => {
+                seq = Math.max(seq, refreshedSeq);
+                attempt = 0;
+                return tryNext();
+              });
+            }
+            attempt += 1;
+            const key = appendLogKey(prefix, seq);
+            return capableKv.putIfAbsent(key, value).then((created) => {
+              if (created) return { key, seq, value };
+              seq += 1;
+              if (!Number.isSafeInteger(seq)) {
+                throw new RangeError(
+                  `append log next sequence is outside the safe integer range: ${prefix}`
+                );
+              }
+              return tryNext();
+            });
+          };
+          return tryNext();
+        })
+      );
+    },
+    read(opts2 = {}) {
+      return enqueue(() => readAppendLogEntries(kv, prefix, opts2));
+    },
+    truncateAfter(seq) {
+      return enqueue(() => {
+        if (!Number.isSafeInteger(seq) || seq < -1) {
+          throw new RangeError(
+            `multiWriterAppendLogStorage.truncateAfter: seq must be an integer cursor >= -1, got ${seq}`
+          );
+        }
+        throw new Error(
+          "multiWriterAppendLogStorage.truncateAfter: unsupported without a stronger compaction capability"
+        );
+      });
+    },
+    size() {
+      return enqueue(() => kv.list(`${prefix}/`).then((keys) => sizeFromKeys(prefix, keys)));
+    }
+  };
+}
+function memoryAppendLog(prefix) {
+  return appendLogStorage({ kv: memoryKv(), prefix });
+}
+function memoryMultiWriterAppendLog(prefix) {
+  return multiWriterAppendLogStorage({ kv: memoryKv(), prefix });
+}
+
+// src/storage/scalar.ts
+var DECIMAL_INTEGER_RE = /^(0|-?[1-9]\d*)$/;
+var NON_NEGATIVE_DECIMAL_INTEGER_RE = /^(0|[1-9]\d*)$/;
+function isDecimalIntegerString(value) {
+  return typeof value === "string" && DECIMAL_INTEGER_RE.test(value);
+}
+function isNonNegativeDecimalIntegerString(value) {
+  return typeof value === "string" && NON_NEGATIVE_DECIMAL_INTEGER_RE.test(value);
+}
+function assertDecimalIntegerString(value, label = "decimal integer") {
+  if (!isDecimalIntegerString(value)) {
+    throw new TypeError(`${label} must be a canonical decimal integer string`);
+  }
+  return value;
+}
+function assertNonNegativeDecimalIntegerString(value, label = "decimal integer") {
+  if (!isNonNegativeDecimalIntegerString(value)) {
+    throw new TypeError(`${label} must be a canonical non-negative decimal integer string`);
+  }
+  return value;
+}
+function bigIntToDecimalString(value) {
+  return value.toString();
+}
+function bigIntToNonNegativeDecimalString(value) {
+  if (value < 0n) {
+    throw new TypeError("decimal integer must be non-negative");
+  }
+  return value.toString();
+}
+function decimalStringToBigInt(value) {
+  return BigInt(assertDecimalIntegerString(value));
+}
+function nonNegativeDecimalStringToBigInt(value) {
+  return BigInt(assertNonNegativeDecimalIntegerString(value));
+}
+
+// src/storage/change.ts
+function nowNs() {
+  return bigIntToNonNegativeDecimalString(BigInt(Date.now()) * 1000000n);
+}
+function envelopeChange(change, opts) {
+  const envelope = {
+    lifecycle: opts.lifecycle ?? "data",
+    structure: opts.structure,
+    version: opts.version ?? 1,
+    t_ns: opts.t_ns ?? nowNs(),
+    ...opts.seq === void 0 ? {} : { seq: opts.seq },
+    change
+  };
+  return assertChangeEnvelope(envelope);
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isLifecycle(value) {
+  return value === "spec" || value === "data" || value === "ownership";
+}
+function assertChangeEnvelope(value) {
+  if (!isRecord(value)) throw new TypeError("changeEnvelopeCodec: frame must be an object");
+  if (!isLifecycle(value.lifecycle)) {
+    throw new TypeError("changeEnvelopeCodec: lifecycle must be spec, data, or ownership");
+  }
+  if (typeof value.structure !== "string" || value.structure.length === 0) {
+    throw new TypeError("changeEnvelopeCodec: structure must be a non-empty string");
+  }
+  if ((typeof value.version !== "number" || !Number.isFinite(value.version)) && typeof value.version !== "string") {
+    throw new TypeError("changeEnvelopeCodec: version must be a finite number or string");
+  }
+  assertNonNegativeDecimalIntegerString(value.t_ns, "changeEnvelopeCodec: t_ns");
+  if (value.seq !== void 0 && (!Number.isSafeInteger(value.seq) || value.seq < 0)) {
+    throw new TypeError(
+      "changeEnvelopeCodec: seq must be a non-negative safe integer when present"
+    );
+  }
+  if (!Object.hasOwn(value, "change")) {
+    throw new TypeError("changeEnvelopeCodec: change payload is required");
+  }
+  return value;
+}
+function changeEnvelopeCodec() {
+  const codec = strictJsonCodecFor();
+  return {
+    encode(value) {
+      return codec.encode(assertChangeEnvelope(value));
+    },
+    decode(bytes) {
+      return assertChangeEnvelope(codec.decode(bytes));
+    }
+  };
+}
+
+// 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_TABLE2 = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  let out = "";
+  for (const byte of bytes) out += HEX_TABLE2[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/observe-event-log.ts
+function observeEventFrame(event, value, opts = {}) {
+  return {
+    ...envelopeChange(value, {
+      lifecycle: "data",
+      structure: "observe-event",
+      version: 1,
+      seq: event.seq
+    }),
+    structure: "observe-event",
+    observeSeq: event.seq,
+    path: event.path,
+    ...opts.stream === void 0 ? {} : { stream: opts.stream }
+  };
+}
+function assertObserveEventFrame(value) {
+  const frame = assertChangeEnvelope(value);
+  const record = frame;
+  if (frame.structure !== "observe-event") {
+    throw new TypeError("observeEventFrameCodec: structure must be observe-event");
+  }
+  if (!Number.isSafeInteger(record.observeSeq) || record.observeSeq < 0) {
+    throw new TypeError("observeEventFrameCodec: observeSeq must be a non-negative safe integer");
+  }
+  if (typeof record.path !== "string") {
+    throw new TypeError("observeEventFrameCodec: path must be a string");
+  }
+  if (record.stream !== void 0 && typeof record.stream !== "string") {
+    throw new TypeError("observeEventFrameCodec: stream must be a string when present");
+  }
+  return frame;
+}
+function observeEventFrameCodec() {
+  const codec = strictJsonCodecFor();
+  return {
+    encode(value) {
+      return codec.encode(assertObserveEventFrame(value));
+    },
+    decode(bytes) {
+      return assertObserveEventFrame(codec.decode(bytes));
+    }
+  };
+}
+function readObserveEventLogPage(log, opts = {}) {
+  return readAppendLogPage(log, 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 isRecord2(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 (!isRecord2(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 (!isRecord2(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 (!isRecord2(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 (!isRecord2(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 (!isRecord2(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 (!isRecord2(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 (!isRecord2(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/read-through.ts
+function defer2(fn) {
+  return Promise.resolve().then(fn);
+}
+function readThroughKv(opts) {
+  return tieredReadThrough(opts);
+}
+function tieredReadThrough(opts) {
+  const { key, tiers, tierNames = [], load, promoteTo, onMiss, onError } = opts;
+  const lookupFacts = [];
+  const promotions = [];
+  let hitTier;
+  let value;
+  const safeOnMiss = (tier) => {
+    if (!onMiss) return;
+    try {
+      onMiss({ key, tier });
+    } catch {
+    }
+  };
+  const safeOnError = (context) => {
+    if (!onError) return;
+    try {
+      onError(context);
+    } catch {
+    }
+  };
+  const addFact = (fact) => {
+    lookupFacts.push(fact);
+  };
+  const lookupTier = (index) => ({
+    index,
+    name: tierNames[index]
+  });
+  const lookupNext = (index) => {
+    if (hitTier !== void 0 || index >= tiers.length) return defer2(() => void 0);
+    const tier = tiers[index];
+    const info = lookupTier(index);
+    const read = hasKvVersioned(tier) ? defer2(() => tier.getVersioned(key)).then((result2) => {
+      if (result2.kind === "miss") {
+        return { found: void 0, generation: result2.generation };
+      }
+      return { found: result2.value, generation: result2.generation };
+    }) : defer2(() => tier.get(key)).then((found) => ({ found, generation: void 0 }));
+    return read.then(({ found, generation }) => {
+      if (found === void 0) {
+        addFact({ kind: "miss", key, tier: info, generation });
+        safeOnMiss(info);
+        return lookupNext(index + 1);
+      }
+      addFact({ kind: "hit", key, tier: info, value: found, generation });
+      hitTier = info;
+      value = found;
+    }).catch((error) => {
+      addFact({ kind: "error", key, tier: info, error });
+      safeOnError({ key, tier: info, stage: "lookup", error });
+      return lookupNext(index + 1);
+    });
+  };
+  const runLoader = () => {
+    if (hitTier !== void 0 || typeof load !== "function") return defer2(() => void 0);
+    const loaderTier = { index: -1, name: "load" };
+    return defer2(() => load(key)).then((loaded) => {
+      if (loaded === void 0) {
+        addFact({ kind: "miss", key, tier: loaderTier });
+        safeOnMiss(loaderTier);
+        return;
+      }
+      addFact({ kind: "hit", key, tier: loaderTier, value: loaded });
+      hitTier = loaderTier;
+      value = loaded;
+    }).catch((error) => {
+      addFact({ kind: "error", key, tier: loaderTier, error });
+      safeOnError({ key, tier: loaderTier, stage: "lookup", error });
+    });
+  };
+  const promoteNext = (targets, offset) => {
+    if (offset >= targets.length || value === void 0) return defer2(() => void 0);
+    const index = targets[offset];
+    const info = { index, name: tierNames[index] };
+    const tier = tiers[index];
+    const generation = generationForTier(lookupFacts, index);
+    const write = hasKvVersioned(tier) ? generation === void 0 ? defer2(() => {
+      throw new Error(
+        "tieredReadThrough: versioned promotion target was not observed with a generation"
+      );
+    }) : defer2(() => tier.setIfMatch(key, value, generation)) : defer2(() => tier.set(key, value)).then(() => true);
+    return write.then((ok) => {
+      promotions.push({ tier: info, ok });
+    }).catch((error) => {
+      promotions.push({ tier: info, ok: false, error });
+      safeOnError({ key, tier: info, stage: "promotion", error });
+    }).then(() => promoteNext(targets, offset + 1));
+  };
+  const promote = () => {
+    if (hitTier === void 0 || value === void 0) return defer2(() => void 0);
+    const sourceIndex = hitTier.index === -1 ? tiers.length : hitTier.index;
+    const targets = buildPromotionTargets(tiers.length, sourceIndex, promoteTo);
+    return promoteNext(targets, 0);
+  };
+  const result = () => {
+    const status = (() => {
+      if (hitTier !== void 0 && hitTier.index >= -1 && value !== void 0) return "hit";
+      if (lookupFacts.some((fact) => fact.kind === "error")) return "error";
+      return "miss";
+    })();
+    return {
+      status,
+      key,
+      value,
+      hitTier,
+      facts: lookupFacts,
+      promotions
+    };
+  };
+  return lookupNext(0).then(runLoader).then(promote).then(result);
+}
+function generationForTier(facts, index) {
+  return facts.find((fact) => fact.tier.index === index)?.generation;
+}
+function buildPromotionTargets(tierCount, hitIndex, promoteTo) {
+  if (promoteTo === false || tierCount <= 0) return [];
+  const maxPromote = Math.max(0, Math.min(hitIndex, tierCount));
+  if (promoteTo === void 0) {
+    return [...Array(maxPromote).keys()];
+  }
+  const normalized = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const index of promoteTo) {
+    if (!Number.isSafeInteger(index) || index < 0 || index >= tierCount || index >= maxPromote) {
+      continue;
+    }
+    if (!seen.has(index)) {
+      seen.add(index);
+      normalized.push(index);
+    }
+  }
+  return normalized;
+}
+
+// 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_TABLE3 = 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_TABLE3[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 isRecord3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isLifecycle2(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 (!isRecord3(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 (!isLifecycle2(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 (!isRecord3(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));
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APPEND_LOG_SEQ_PAD,
+  ContentAddressedMissError,
+  REACTIVE_COLLECTION_CHANGE_FORMAT,
+  REACTIVE_COLLECTION_FRAME_VERSION,
+  REACTIVE_COLLECTION_SNAPSHOT_FORMAT,
+  WAL_FORMAT_VERSION,
+  WAL_FRAME_SEQ_PAD,
+  WAL_KEY_SEGMENT,
+  appendLogKey,
+  appendLogStorage,
+  assertChangeEnvelope,
+  assertDecimalIntegerString,
+  assertNonNegativeDecimalIntegerString,
+  assertObserveEventFrame,
+  assertReactiveCollectionChangeFrame,
+  assertReactiveCollectionSnapshotFrame,
+  assertStrictJsonObject,
+  assertStrictJsonValue,
+  assertWalFrame,
+  bigIntToDecimalString,
+  bigIntToNonNegativeDecimalString,
+  changeEnvelopeCodec,
+  collectionSnapshotKey,
+  contentAddressedKv,
+  contentAddressedStorage,
+  decimalStringToBigInt,
+  dictKv,
+  envelopeChange,
+  hasKvPutIfAbsent,
+  hasKvVersioned,
+  hasStoragePutIfAbsent,
+  hasStorageVersioned,
+  isDecimalIntegerString,
+  isNonNegativeDecimalIntegerString,
+  jsonCodec,
+  jsonCodecFor,
+  kvStorage,
+  listByPrefix,
+  loadReactiveIndexState,
+  loadReactiveListState,
+  loadReactiveLogState,
+  loadReactiveMapState,
+  memoryAppendLog,
+  memoryBackend,
+  memoryKv,
+  memoryMultiWriterAppendLog,
+  multiWriterAppendLogStorage,
+  nonNegativeDecimalStringToBigInt,
+  nowNs,
+  observeEventFrame,
+  observeEventFrameCodec,
+  reactiveCollectionChangeFrame,
+  reactiveCollectionChangeFrameCodec,
+  reactiveCollectionSnapshotFrame,
+  reactiveCollectionSnapshotFrameCodec,
+  readAppendLogPage,
+  readObserveEventLogPage,
+  readThroughKv,
+  requireKvPutIfAbsent,
+  requireKvVersioned,
+  requireStoragePutIfAbsent,
+  requireStorageVersioned,
+  stableJsonString,
+  strictJsonCodec,
+  strictJsonCodecFor,
+  tieredReadThrough,
+  verifyWalFrameChecksum,
+  walFrame,
+  walFrameChecksum,
+  walFrameCodec,
+  walFrameKey,
+  walFramePrefix,
+  webStorageBackend
+});
+//# sourceMappingURL=index.cjs.map