@korajs/core 0.0.0-canary-20261008174129

package/dist/chunk-QUD3DMSD.js

@@ -0,0 +1,1297 @@
+// src/errors/error-fixes.ts
+var KORA_ERROR_FIX_SUGGESTIONS = {
+  SCHEMA_VALIDATION: "Review your defineSchema() definition: every collection needs at least one field and a positive version.",
+  OPERATION_ERROR: "Check the operation payload matches your schema field types and required fields.",
+  MERGE_CONFLICT: "Add a custom resolver for the conflicting field in defineSchema(), or adjust constraint onConflict rules.",
+  SYNC_ERROR: "Verify the sync server URL, auth token, and that the server accepts your schema version.",
+  STORAGE_ERROR: "Confirm the storage adapter is supported in this environment and the database path is writable.",
+  CLOCK_DRIFT: "Sync device wall-clock time (NTP). Kora refuses new timestamps when drift exceeds five minutes.",
+  INVALID_TIMESTAMP_FIELDS: "HLC timestamps need non-negative integer wallTime (< 10^15) and logical (<= 99999). Generate timestamps through HybridLogicalClock instead of building them by hand.",
+  PERSISTENCE_ERROR: "IndexedDB persistence failed; check browser storage settings and available disk quota.",
+  MISSING_WORKER_URL: "Pass store.workerUrl pointing to sqlite-wasm-worker.js (see create-kora-app templates).",
+  INVALID_SYNC_URL: "Use ws:// or wss:// for WebSocket transport, or http(s):// for HTTP long-polling.",
+  APP_NOT_READY: "Await app.ready before querying or mutating collections, or wrap the tree in <KoraProvider app={app}>."
+};
+function getKoraErrorFix(code) {
+  return KORA_ERROR_FIX_SUGGESTIONS[code];
+}
+
+// src/errors/errors.ts
+var KoraError = class extends Error {
+  constructor(message, code, context) {
+    super(message);
+    this.code = code;
+    this.context = context;
+    this.name = "KoraError";
+  }
+  code;
+  context;
+  /**
+   * Actionable hint for resolving this error (from registry or error context).
+   */
+  get fix() {
+    const fromContext = this.context?.fix;
+    if (typeof fromContext === "string" && fromContext.length > 0) {
+      return fromContext;
+    }
+    return getKoraErrorFix(this.code);
+  }
+};
+var SchemaValidationError = class extends KoraError {
+  constructor(message, context) {
+    super(message, "SCHEMA_VALIDATION", context);
+    this.name = "SchemaValidationError";
+  }
+};
+var OperationError = class extends KoraError {
+  constructor(message, context) {
+    super(message, "OPERATION_ERROR", context);
+    this.name = "OperationError";
+  }
+};
+var OperationTooLargeError = class extends KoraError {
+  constructor(collection, recordId, bytes, maxBytes) {
+    super(
+      `A write to ${collection}/${recordId} would produce an operation of ${bytes} bytes, more than the ${maxBytes}-byte limit (maxOperationBytes). Nothing was written. Store large content as a blob (t.blob()) or split it across records.`,
+      "OPERATION_TOO_LARGE",
+      { collection, recordId, bytes, maxBytes }
+    );
+    this.collection = collection;
+    this.recordId = recordId;
+    this.bytes = bytes;
+    this.maxBytes = maxBytes;
+    this.name = "OperationTooLargeError";
+  }
+  collection;
+  recordId;
+  bytes;
+  maxBytes;
+};
+var MergeConflictError = class extends KoraError {
+  constructor(operationA, operationB, field) {
+    super(
+      `Merge conflict on field "${field}" in collection "${operationA.collection}"`,
+      "MERGE_CONFLICT",
+      { operationA: operationA.id, operationB: operationB.id, field }
+    );
+    this.operationA = operationA;
+    this.operationB = operationB;
+    this.field = field;
+    this.name = "MergeConflictError";
+  }
+  operationA;
+  operationB;
+  field;
+};
+var SyncError = class extends KoraError {
+  constructor(message, context) {
+    super(message, "SYNC_ERROR", context);
+    this.name = "SyncError";
+  }
+};
+var StorageError = class extends KoraError {
+  constructor(message, context) {
+    super(message, "STORAGE_ERROR", context);
+    this.name = "StorageError";
+  }
+};
+var AppNotReadyError = class extends KoraError {
+  constructor(detail) {
+    super(detail, "APP_NOT_READY", {
+      fix: "Await app.ready, or wrap your UI in <KoraProvider app={app}> before calling useQuery()."
+    });
+    this.name = "AppNotReadyError";
+  }
+};
+var RemoteClockDriftError = class extends KoraError {
+  constructor(remoteWallTime, localReferenceTime) {
+    const aheadSeconds = Math.round((remoteWallTime - localReferenceTime) / 1e3);
+    super(
+      `Rejected remote timestamp ${aheadSeconds}s ahead of local reference time. The sending device's clock is set too far in the future.`,
+      "REMOTE_CLOCK_DRIFT",
+      { remoteWallTime, localReferenceTime, aheadSeconds }
+    );
+    this.remoteWallTime = remoteWallTime;
+    this.localReferenceTime = localReferenceTime;
+    this.name = "RemoteClockDriftError";
+  }
+  remoteWallTime;
+  localReferenceTime;
+};
+var InvalidTimestampError = class extends KoraError {
+  constructor(message, wallTime, logical) {
+    super(message, "INVALID_TIMESTAMP_FIELDS", { wallTime, logical });
+    this.wallTime = wallTime;
+    this.logical = logical;
+    this.name = "InvalidTimestampError";
+  }
+  wallTime;
+  logical;
+};
+var ClockDriftError = class extends KoraError {
+  constructor(currentHlcTime, physicalTime) {
+    const driftSeconds = Math.round((currentHlcTime - physicalTime) / 1e3);
+    super(
+      `Clock drift of ${driftSeconds}s detected. Physical time is behind HLC by more than 5 minutes. This indicates a severe clock issue.`,
+      "CLOCK_DRIFT",
+      { currentHlcTime, physicalTime, driftSeconds }
+    );
+    this.currentHlcTime = currentHlcTime;
+    this.physicalTime = physicalTime;
+    this.name = "ClockDriftError";
+  }
+  currentHlcTime;
+  physicalTime;
+};
+
+// src/clock/hlc.ts
+var systemTimeSource = { now: () => Date.now() };
+var MAX_LOGICAL = 99999;
+var LOGICAL_MODULUS = MAX_LOGICAL + 1;
+var WALL_TIME_LIMIT = 10 ** 15;
+var DRIFT_WARN_MS = 6e4;
+var DRIFT_ERROR_MS = 5 * 6e4;
+var MAX_REMOTE_FUTURE_MS = 5 * 6e4;
+var HybridLogicalClock = class _HybridLogicalClock {
+  constructor(nodeId, timeSource = systemTimeSource, onDriftWarning, onDriftError) {
+    this.nodeId = nodeId;
+    this.timeSource = timeSource;
+    this.onDriftWarning = onDriftWarning;
+    this.onDriftError = onDriftError;
+  }
+  nodeId;
+  timeSource;
+  onDriftWarning;
+  onDriftError;
+  wallTime = 0;
+  logical = 0;
+  referenceOffsetMs = null;
+  /**
+   * Records the known offset between an external time reference (usually the
+   * sync server, learned at handshake) and this device's physical clock:
+   * `referenceTime - localPhysicalTime`. Once set, drift evaluation and remote
+   * timestamp validation are performed against reference-corrected time, so a
+   * device with a wrong local clock still validates remote timestamps correctly.
+   */
+  setReferenceOffset(offsetMs) {
+    this.referenceOffsetMs = offsetMs;
+  }
+  getReferenceOffset() {
+    return this.referenceOffsetMs;
+  }
+  /** Physical time corrected by the known reference offset, when available. */
+  effectiveTime(physicalTime) {
+    return physicalTime + (this.referenceOffsetMs ?? 0);
+  }
+  /**
+   * Generate a new timestamp for a local event.
+   * Guarantees monotonicity: each call returns a timestamp strictly greater than the previous.
+   *
+   * Never throws and never blocks a local write: if the physical clock has
+   * fallen behind the HLC (e.g. the user corrected a fast clock), the HLC
+   * freezes wallTime and advances the logical counter, and drift is reported
+   * through the onDriftWarning / onDriftError callbacks instead.
+   */
+  now() {
+    const physicalTime = this.timeSource.now();
+    this.checkDrift(physicalTime);
+    if (physicalTime > this.wallTime) {
+      this.wallTime = physicalTime;
+      this.logical = 0;
+    } else {
+      this.logical++;
+    }
+    this.carryLogicalOverflow();
+    return { wallTime: this.wallTime, logical: this.logical, nodeId: this.nodeId };
+  }
+  /**
+   * Update clock on receiving a remote timestamp.
+   * Merges the remote clock state with the local state to maintain causal ordering.
+   *
+   * @throws {InvalidTimestampError} If the remote timestamp has non-integer or
+   * negative wallTime/logical, or logical beyond {@link MAX_LOGICAL}. Checked
+   * BEFORE any state change, so malformed input cannot corrupt this clock.
+   * @throws {RemoteClockDriftError} If the remote timestamp is more than 5 minutes
+   * ahead of reference-corrected local time. Validation happens BEFORE any state
+   * is adopted, so a rejected timestamp cannot poison this clock. When no
+   * reference offset is known and this clock is uninitialized (cold start with
+   * a possibly-wrong local clock), validation is skipped, matching the previous
+   * cold-start behavior but now without a corrupting failure mode afterward.
+   */
+  receive(remote) {
+    const physicalTime = this.timeSource.now();
+    const wasColdStart = this.wallTime === 0;
+    if (!Number.isInteger(remote.wallTime) || remote.wallTime < 0 || !Number.isInteger(remote.logical) || remote.logical < 0 || remote.logical > MAX_LOGICAL) {
+      throw new InvalidTimestampError(
+        `Rejected remote HLC timestamp with invalid fields (wallTime=${remote.wallTime}, logical=${remote.logical}). wallTime and logical must be non-negative integers and logical must not exceed ${MAX_LOGICAL}.`,
+        remote.wallTime,
+        remote.logical
+      );
+    }
+    const canValidate = this.referenceOffsetMs !== null || !wasColdStart;
+    if (canValidate) {
+      const reference = this.effectiveTime(physicalTime);
+      if (remote.wallTime > reference + MAX_REMOTE_FUTURE_MS) {
+        throw new RemoteClockDriftError(remote.wallTime, reference);
+      }
+    }
+    if (physicalTime > this.wallTime && physicalTime > remote.wallTime) {
+      this.wallTime = physicalTime;
+      this.logical = 0;
+    } else if (remote.wallTime > this.wallTime) {
+      this.wallTime = remote.wallTime;
+      this.logical = remote.logical + 1;
+    } else if (this.wallTime === remote.wallTime) {
+      this.logical = Math.max(this.logical, remote.logical) + 1;
+    } else {
+      this.logical++;
+    }
+    this.carryLogicalOverflow();
+    if (!wasColdStart) {
+      this.checkDrift(physicalTime);
+    }
+    return { wallTime: this.wallTime, logical: this.logical, nodeId: this.nodeId };
+  }
+  /**
+   * Advance this clock to at least the given timestamp.
+   *
+   * Used after a timestamp rebase rewrites unsynced operations: future `now()`
+   * timestamps must sort after every rebased operation, otherwise a write issued
+   * immediately after the rebase could interleave with (or precede) rebased ops
+   * and break the log's total order. Never moves the clock backward — a
+   * timestamp at or before the current state is a no-op, preserving the
+   * monotonicity guarantee of `now()`.
+   *
+   * Inputs with logical > MAX_LOGICAL are normalized deterministically by
+   * carrying the excess into wallTime, so the adopted state always leaves room
+   * for the next increment inside the serializable range.
+   */
+  advanceTo(ts) {
+    const normalized = {
+      wallTime: ts.wallTime + Math.floor(ts.logical / LOGICAL_MODULUS),
+      logical: ts.logical % LOGICAL_MODULUS,
+      nodeId: ts.nodeId
+    };
+    const current = {
+      wallTime: this.wallTime,
+      logical: this.logical,
+      nodeId: this.nodeId
+    };
+    if (_HybridLogicalClock.compare(normalized, current) > 0) {
+      this.wallTime = normalized.wallTime;
+      this.logical = normalized.logical;
+    }
+  }
+  /**
+   * Carry the logical counter into wallTime when an increment pushed it past
+   * MAX_LOGICAL. Bumping wallTime by 1ms keeps the timestamp strictly greater
+   * than everything issued before (monotonicity) while keeping the logical
+   * counter inside the 5-digit slot the serialized form depends on.
+   */
+  carryLogicalOverflow() {
+    if (this.logical > MAX_LOGICAL) {
+      this.wallTime += 1;
+      this.logical = 0;
+    }
+  }
+  /**
+   * Compare two timestamps. Returns negative if a < b, positive if a > b, zero if equal.
+   * Total order: wallTime first, then logical, then nodeId (lexicographic).
+   */
+  static compare(a, b) {
+    if (a.wallTime !== b.wallTime) return a.wallTime - b.wallTime;
+    if (a.logical !== b.logical) return a.logical - b.logical;
+    if (a.nodeId < b.nodeId) return -1;
+    if (a.nodeId > b.nodeId) return 1;
+    return 0;
+  }
+  /**
+   * Serialize an HLC timestamp to a string that sorts lexicographically.
+   * Format: zero-padded wallTime:logical:nodeId
+   *
+   * @throws {InvalidTimestampError} If wallTime does not fit 15 digits or
+   * logical does not fit 5 digits (or either is negative/non-integer). Such a
+   * value would overflow its zero-padded slot and the serialized string would
+   * no longer sort in the same order as {@link HybridLogicalClock.compare} —
+   * silently corrupting every LWW comparison on stored `_version` columns.
+   * Internal clocks can no longer produce such values (the logical counter
+   * carries into wallTime); this guards against hand-built timestamps.
+   */
+  static serialize(ts) {
+    if (!Number.isInteger(ts.wallTime) || ts.wallTime < 0 || ts.wallTime >= WALL_TIME_LIMIT || !Number.isInteger(ts.logical) || ts.logical < 0 || ts.logical > MAX_LOGICAL) {
+      throw new InvalidTimestampError(
+        `Cannot serialize HLC timestamp (wallTime=${ts.wallTime}, logical=${ts.logical}): wallTime must be an integer in [0, 10^15) and logical an integer in [0, ${MAX_LOGICAL}]. Values outside these ranges overflow the zero-padded serialized form, which must sort lexicographically identically to HybridLogicalClock.compare.`,
+        ts.wallTime,
+        ts.logical
+      );
+    }
+    const wall = ts.wallTime.toString().padStart(15, "0");
+    const log = ts.logical.toString().padStart(5, "0");
+    return `${wall}:${log}:${ts.nodeId}`;
+  }
+  /**
+   * Deserialize an HLC timestamp from its serialized string form.
+   */
+  static deserialize(s) {
+    const parts = s.split(":");
+    if (parts.length < 3) {
+      throw new Error(`Invalid HLC timestamp string: "${s}"`);
+    }
+    return {
+      wallTime: Number.parseInt(parts[0] ?? "0", 10),
+      logical: Number.parseInt(parts[1] ?? "0", 10),
+      // nodeId may contain colons, so rejoin remaining parts
+      nodeId: parts.slice(2).join(":")
+    };
+  }
+  /**
+   * Reports drift between the HLC and (reference-corrected) physical time.
+   * Reporting only: local timestamp generation is never blocked, because the
+   * user's data always outranks the quality of its timestamps.
+   */
+  checkDrift(physicalTime) {
+    const drift = this.wallTime - this.effectiveTime(physicalTime);
+    if (drift > DRIFT_ERROR_MS) {
+      this.onDriftError?.(drift);
+      return;
+    }
+    if (drift > DRIFT_WARN_MS) {
+      this.onDriftWarning?.(drift);
+    }
+  }
+};
+
+// src/operations/op-data-binary.ts
+function isKoraBytesValue(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const record = value;
+  return Object.keys(record).length === 1 && typeof record.$koraBytes === "string";
+}
+function isLegacyNumericByteObject(value) {
+  if (typeof value !== "object" || value === null || ArrayBuffer.isView(value)) {
+    return false;
+  }
+  const record = value;
+  const keys = Object.keys(record);
+  if (keys.length === 0) {
+    return false;
+  }
+  for (let i = 0; i < keys.length; i++) {
+    const byte = record[String(i)];
+    if (typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255) {
+      return false;
+    }
+  }
+  return true;
+}
+var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var BASE64_REVERSE = new Map(
+  Array.from(BASE64_ALPHABET, (char, index) => [char, index])
+);
+function bytesToBase64(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b0 = bytes[i] ?? 0;
+    const b1 = bytes[i + 1] ?? 0;
+    const b2 = bytes[i + 2] ?? 0;
+    const triple = b0 << 16 | b1 << 8 | b2;
+    out += BASE64_ALPHABET[triple >> 18 & 63] ?? "";
+    out += BASE64_ALPHABET[triple >> 12 & 63] ?? "";
+    out += i + 1 < bytes.length ? BASE64_ALPHABET[triple >> 6 & 63] ?? "" : "=";
+    out += i + 2 < bytes.length ? BASE64_ALPHABET[triple & 63] ?? "" : "=";
+  }
+  return out;
+}
+function base64ToBytes(base64) {
+  const cleaned = base64.replace(/=+$/, "");
+  const out = new Uint8Array(Math.floor(cleaned.length * 6 / 8));
+  let buffer = 0;
+  let bits = 0;
+  let index = 0;
+  for (const char of cleaned) {
+    const value = BASE64_REVERSE.get(char);
+    if (value === void 0) {
+      throw new OperationError(`Invalid base64 character "${char}" in tagged binary value.`, {
+        char
+      });
+    }
+    buffer = buffer << 6 | value;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out[index] = buffer >> bits & 255;
+      index += 1;
+    }
+  }
+  return out;
+}
+function encodeBytesForOpData(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  const bytes = value instanceof Uint8Array ? value : new Uint8Array(value);
+  return { $koraBytes: bytesToBase64(bytes) };
+}
+function decodeBytesFromOpData(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  if (isKoraBytesValue(value)) {
+    return base64ToBytes(value.$koraBytes);
+  }
+  if (isLegacyNumericByteObject(value)) {
+    const keys = Object.keys(value);
+    const bytes = new Uint8Array(keys.length);
+    for (let i = 0; i < keys.length; i++) {
+      bytes[i] = value[String(i)] ?? 0;
+    }
+    return bytes;
+  }
+  throw new OperationError(
+    "Binary op-data value must be a string, Uint8Array, ArrayBuffer, tagged { $koraBytes } object, or legacy numeric-key byte object.",
+    { receivedType: typeof value }
+  );
+}
+
+// src/operations/content-hash.ts
+var DEFAULT_OPERATION_HASH_VERSION = 2;
+async function computeOperationId(input, timestampOrVersion) {
+  if (typeof timestampOrVersion === "string") {
+    return sha256Hex(canonicalize(v1HashInput(input, timestampOrVersion)));
+  }
+  const op = input;
+  const serializedTs = HybridLogicalClock.serialize(op.timestamp);
+  if (timestampOrVersion === 1) return sha256Hex(canonicalize(v1HashInput(op, serializedTs)));
+  return sha256Hex(canonicalize(v2HashInput(op, serializedTs)));
+}
+function v1HashInput(input, timestamp) {
+  const hashInput = {
+    type: input.type,
+    collection: input.collection,
+    recordId: input.recordId,
+    data: input.data,
+    timestamp,
+    nodeId: input.nodeId
+  };
+  if (input.atomicOps !== void 0 && Object.keys(input.atomicOps).length > 0) {
+    hashInput.atomicOps = input.atomicOps;
+  }
+  return hashInput;
+}
+function v2HashInput(op, timestamp) {
+  const body = canonicalizeOperationBody(op);
+  const atomicOps = body.atomicOps !== void 0 && Object.keys(body.atomicOps).length > 0 ? body.atomicOps : null;
+  return {
+    hashVersion: 2,
+    type: op.type,
+    collection: op.collection,
+    recordId: op.recordId,
+    data: body.data,
+    previousData: body.previousData,
+    timestamp,
+    nodeId: op.nodeId,
+    sequenceNumber: op.sequenceNumber,
+    // A set of parents: their order carries no meaning, so a relay that reorders
+    // them neither breaks verification nor creates a second id for one op.
+    causalDeps: [...op.causalDeps].sort(),
+    schemaVersion: op.schemaVersion,
+    atomicOps
+  };
+}
+async function sha256Hex(canonical2) {
+  const encoded = new TextEncoder().encode(canonical2);
+  const hashBuffer = await globalThis.crypto.subtle.digest("SHA-256", encoded);
+  return bufferToHex(hashBuffer);
+}
+function canonicalize(obj) {
+  if (obj === null) {
+    return "null";
+  }
+  if (obj === void 0) {
+    return "null";
+  }
+  if (typeof obj !== "object") {
+    return JSON.stringify(obj);
+  }
+  if (Array.isArray(obj)) {
+    const items = obj.map((item) => canonicalize(item));
+    return `[${items.join(",")}]`;
+  }
+  const keys = Object.keys(obj).sort();
+  const pairs = keys.map((key) => {
+    const value = obj[key];
+    return `${JSON.stringify(key)}:${canonicalize(value === void 0 ? null : value)}`;
+  });
+  return `{${pairs.join(",")}}`;
+}
+function bufferToHex(buffer) {
+  const bytes = new Uint8Array(buffer);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/operations/operation.ts
+async function createOperation(rawInput, clock, options = {}) {
+  validateOperationParams(rawInput);
+  const input = canonicalizeOperationBody(rawInput);
+  const hashVersion = options.hashVersion ?? DEFAULT_OPERATION_HASH_VERSION;
+  const timestamp = clock.now();
+  const id = hashVersion === 1 ? await computeOperationId(input, HybridLogicalClock.serialize(timestamp)) : await computeOperationId({ ...input, timestamp }, hashVersion);
+  const operation = {
+    id,
+    nodeId: input.nodeId,
+    type: input.type,
+    collection: input.collection,
+    recordId: input.recordId,
+    data: input.data ? { ...input.data } : null,
+    previousData: input.previousData ? { ...input.previousData } : null,
+    timestamp,
+    sequenceNumber: input.sequenceNumber,
+    causalDeps: [...input.causalDeps],
+    schemaVersion: input.schemaVersion,
+    ...input.atomicOps !== void 0 && Object.keys(input.atomicOps).length > 0 ? { atomicOps: { ...input.atomicOps } } : {},
+    ...input.transactionId !== void 0 ? { transactionId: input.transactionId } : {},
+    ...input.mutationName !== void 0 ? { mutationName: input.mutationName } : {},
+    ...hashVersion !== 1 ? { hashVersion } : {}
+  };
+  return deepFreeze(operation);
+}
+function validateOperationParams(input) {
+  if (!input.nodeId || typeof input.nodeId !== "string") {
+    throw new OperationError("nodeId is required and must be a non-empty string", {
+      received: input.nodeId
+    });
+  }
+  if (!input.type || !["insert", "update", "delete"].includes(input.type)) {
+    throw new OperationError('type must be "insert", "update", or "delete"', {
+      received: input.type
+    });
+  }
+  if (!input.collection || typeof input.collection !== "string") {
+    throw new OperationError("collection is required and must be a non-empty string", {
+      received: input.collection
+    });
+  }
+  if (!input.recordId || typeof input.recordId !== "string") {
+    throw new OperationError("recordId is required and must be a non-empty string", {
+      received: input.recordId
+    });
+  }
+  if (input.type === "insert" && input.data === null) {
+    throw new OperationError("insert operations must include data", {
+      type: input.type,
+      collection: input.collection
+    });
+  }
+  if (input.type === "update" && input.data === null) {
+    throw new OperationError("update operations must include data with changed fields", {
+      type: input.type,
+      collection: input.collection
+    });
+  }
+  if (input.type === "update" && input.previousData === null) {
+    throw new OperationError(
+      "update operations must include previousData for 3-way merge support",
+      {
+        type: input.type,
+        collection: input.collection
+      }
+    );
+  }
+  if (input.type === "delete" && input.data !== null) {
+    throw new OperationError("delete operations must have null data", {
+      type: input.type,
+      collection: input.collection
+    });
+  }
+  if (typeof input.sequenceNumber !== "number" || input.sequenceNumber < 0) {
+    throw new OperationError("sequenceNumber must be a non-negative number", {
+      received: input.sequenceNumber
+    });
+  }
+  if (!Array.isArray(input.causalDeps)) {
+    throw new OperationError("causalDeps must be an array of operation IDs", {
+      received: typeof input.causalDeps
+    });
+  }
+  if (typeof input.schemaVersion !== "number" || input.schemaVersion < 1) {
+    throw new OperationError("schemaVersion must be a positive number", {
+      received: input.schemaVersion
+    });
+  }
+}
+async function verifyOperationId(op) {
+  const version = op.hashVersion ?? 1;
+  if (version !== 1 && version !== 2) return false;
+  let expectedId;
+  try {
+    expectedId = await computeOperationId(
+      {
+        nodeId: op.nodeId,
+        type: op.type,
+        collection: op.collection,
+        recordId: op.recordId,
+        data: op.data,
+        previousData: op.previousData,
+        timestamp: op.timestamp,
+        sequenceNumber: op.sequenceNumber,
+        causalDeps: op.causalDeps,
+        schemaVersion: op.schemaVersion,
+        ...op.atomicOps !== void 0 ? { atomicOps: op.atomicOps } : {}
+      },
+      version
+    );
+  } catch {
+    return false;
+  }
+  return op.id === expectedId;
+}
+async function verifyOperationIntegrity(op) {
+  return verifyOperationId(op);
+}
+function isValidOperation(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const op = value;
+  return typeof op.id === "string" && typeof op.nodeId === "string" && (op.type === "insert" || op.type === "update" || op.type === "delete") && typeof op.collection === "string" && typeof op.recordId === "string" && typeof op.sequenceNumber === "number" && Array.isArray(op.causalDeps) && typeof op.schemaVersion === "number" && typeof op.timestamp === "object" && op.timestamp !== null;
+}
+function deepFreeze(obj) {
+  if (typeof obj !== "object" || obj === null) return obj;
+  if (ArrayBuffer.isView(obj)) return obj;
+  Object.freeze(obj);
+  for (const value of Object.values(obj)) {
+    if (typeof value === "object" && value !== null && !Object.isFrozen(value)) {
+      deepFreeze(value);
+    }
+  }
+  return obj;
+}
+
+// src/operations/canonical-body.ts
+var NonCanonicalValueError = class extends KoraError {
+  constructor(message, path, receivedType) {
+    super(message, "NON_CANONICAL_VALUE", { path, receivedType });
+    this.path = path;
+    this.receivedType = receivedType;
+    this.name = "NonCanonicalValueError";
+  }
+  path;
+  receivedType;
+};
+function canonicalizeOperationBody(input) {
+  const isUpdate = input.type === "update";
+  const where = `${input.collection}/${input.recordId}`;
+  const data = canonicalTopLevel(input.data, isUpdate, "data", where);
+  const previousData = canonicalTopLevel(input.previousData, isUpdate, "previousData", where);
+  let atomicOps = input.atomicOps;
+  if (atomicOps !== void 0) {
+    const canonical2 = canonicalTopLevel(
+      atomicOps,
+      false,
+      "atomicOps",
+      where
+    );
+    atomicOps = canonical2 ?? void 0;
+  }
+  if (data === input.data && previousData === input.previousData && atomicOps === input.atomicOps) {
+    return input;
+  }
+  return {
+    ...input,
+    data,
+    previousData,
+    ...atomicOps !== void 0 ? { atomicOps } : {}
+  };
+}
+function canonicalValue(value, path) {
+  return canonical(value, path, /* @__PURE__ */ new Set());
+}
+function canonicalTopLevel(record, undefinedIsNull, label, where) {
+  if (record === null || record === void 0) return null;
+  if (!isPlainObject(record)) {
+    throw new NonCanonicalValueError(
+      `Operation ${label} of ${where} must be a plain object, got ${describe(record)}.`,
+      label,
+      describe(record)
+    );
+  }
+  let changed = false;
+  const out = {};
+  for (const [key, member] of Object.entries(record)) {
+    if (member === void 0) {
+      changed = true;
+      if (undefinedIsNull) out[key] = null;
+      continue;
+    }
+    const next = canonical(member, `${where}.${key}`, /* @__PURE__ */ new Set());
+    if (!Object.is(next, member)) changed = true;
+    out[key] = next;
+  }
+  if (Object.getPrototypeOf(record) !== Object.prototype) changed = true;
+  return changed ? out : record;
+}
+function canonical(value, path, ancestors) {
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+      return value;
+    case "number":
+      if (!Number.isFinite(value)) {
+        throw refusal(path, String(value), 'Use a finite number, or null for "no value".');
+      }
+      return Object.is(value, -0) ? 0 : value;
+    case "undefined":
+      return null;
+    case "bigint":
+      throw refusal(path, "bigint", "Convert it to a number or a string.");
+    case "function":
+      throw refusal(path, "function", "Store data only, not functions.");
+    case "symbol":
+      throw refusal(path, "symbol", "Use a string instead.");
+  }
+  if (value === null) return null;
+  const object = value;
+  if (object instanceof Uint8Array) return { $koraBytes: bytesToBase64(object) };
+  if (object instanceof ArrayBuffer) return { $koraBytes: bytesToBase64(new Uint8Array(object)) };
+  if (object instanceof Date) {
+    const time = object.getTime();
+    if (Number.isNaN(time)) {
+      throw refusal(path, "invalid Date", "Pass a valid Date, or null.");
+    }
+    return object.toISOString();
+  }
+  if (ancestors.has(object)) {
+    throw refusal(path, "circular reference", "Remove the cycle: JSON cannot hold it.");
+  }
+  if (Array.isArray(object)) {
+    ancestors.add(object);
+    let changed2 = false;
+    const out2 = [];
+    for (let index = 0; index < object.length; index++) {
+      if (!(index in object)) {
+        ancestors.delete(object);
+        throw refusal(
+          `${path}[${String(index)}]`,
+          "array hole",
+          "Use a dense array (fill the gap with null)."
+        );
+      }
+      const item = object[index];
+      const next = canonical(item, `${path}[${String(index)}]`, ancestors);
+      if (!Object.is(next, item)) changed2 = true;
+      out2.push(next);
+    }
+    ancestors.delete(object);
+    return changed2 ? out2 : object;
+  }
+  if (!isPlainObject(object)) {
+    const type = describe(object);
+    throw refusal(
+      path,
+      type,
+      type === "Map" ? "Convert it with Object.fromEntries(map)." : type === "Set" ? "Convert it with [...set]." : "Convert it to a plain object (JSON data only)."
+    );
+  }
+  if (typeof object.toJSON === "function") {
+    throw refusal(path, "object with toJSON", "Store the value toJSON() returns instead.");
+  }
+  if (Object.prototype.hasOwnProperty.call(object, "__proto__")) {
+    throw refusal(`${path}.__proto__`, '"__proto__" key', "Rename the key.");
+  }
+  ancestors.add(object);
+  let changed = Object.getPrototypeOf(object) !== Object.prototype;
+  const out = {};
+  for (const [key, member] of Object.entries(object)) {
+    if (member === void 0) {
+      changed = true;
+      continue;
+    }
+    const next = canonical(member, `${path}.${key}`, ancestors);
+    if (!Object.is(next, member)) changed = true;
+    out[key] = next;
+  }
+  ancestors.delete(object);
+  return changed ? out : object;
+}
+function refusal(path, receivedType, fix) {
+  return new NonCanonicalValueError(
+    `Value at "${path}" (${receivedType}) has no JSON form, so it cannot be stored or synced unchanged. ${fix}`,
+    path,
+    receivedType
+  );
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function describe(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  if (typeof value !== "object") return typeof value;
+  const ctor = value.constructor;
+  return typeof ctor?.name === "string" && ctor.name.length > 0 ? ctor.name : "object";
+}
+async function canonicalizeProvenLegacyClear(op) {
+  const restored = canonicalizeLegacyOperation(op);
+  if (restored === op) return op;
+  if (await verifyOperationId(op)) return op;
+  if (await verifyOperationId(restored)) return restored;
+  if (op.hashVersion === void 0 && await verifyOperationId({ ...restored, hashVersion: 2 })) {
+    return restored;
+  }
+  return op;
+}
+function canonicalizeLegacyOperation(op) {
+  if (op.type !== "update" || op.hashVersion === 2 || op.encrypted !== void 0) return op;
+  const previous = op.previousData;
+  if (previous === null || previous === void 0) return op;
+  const data = op.data ?? {};
+  const missing = Object.keys(previous).filter((key) => !(key in data));
+  if (missing.length === 0) return op;
+  const out = { ...data };
+  for (const key of missing) out[key] = null;
+  return { ...op, data: out };
+}
+
+// src/fold/field-kind.ts
+var LWW_PLAN = {
+  kind: "reg",
+  appendOnly: false,
+  strategy: "lww",
+  tier: 1,
+  secret: false
+};
+function planField(collection, field) {
+  const descriptor = collection?.fields[field];
+  const secret = descriptor?.kind === "secret";
+  const resolver = collection?.resolvers?.[field];
+  if (resolver) {
+    return { kind: "res", appendOnly: false, resolver, strategy: "custom", tier: 3, secret };
+  }
+  if (!descriptor) return LWW_PLAN;
+  switch (descriptor.mergeStrategy) {
+    case "counter":
+      return { kind: "ctr", appendOnly: false, strategy: "schema-counter", tier: 1, secret };
+    case "max":
+      return { kind: "max", appendOnly: false, strategy: "schema-max", tier: 1, secret };
+    case "min":
+      return { kind: "min", appendOnly: false, strategy: "schema-min", tier: 1, secret };
+    case "append-only":
+      if (descriptor.kind === "array") {
+        return {
+          kind: "set",
+          appendOnly: true,
+          strategy: "schema-append-only",
+          tier: 1,
+          secret
+        };
+      }
+      return { ...LWW_PLAN, secret };
+    case "lww":
+      return { ...LWW_PLAN, secret };
+    case "server-authoritative":
+      return {
+        ...LWW_PLAN,
+        strategy: "schema-server-authoritative",
+        secret,
+        authoritative: true
+      };
+    default:
+      break;
+  }
+  switch (descriptor.kind) {
+    case "array":
+      return { kind: "set", appendOnly: false, strategy: "lww-element-set", tier: 1, secret };
+    case "object":
+    case "json":
+      return { kind: "map", appendOnly: false, strategy: "object-key-lww", tier: 1, secret };
+    case "richtext":
+      return { kind: "rt", appendOnly: false, strategy: "crdt-text", tier: 1, secret };
+    default:
+      return { ...LWW_PLAN, secret };
+  }
+}
+
+// src/fold/stamp.ts
+function compareStamps(a, b) {
+  const ca = a.c ?? 0;
+  const cb = b.c ?? 0;
+  if (ca !== cb) return ca - cb;
+  if (a.t !== b.t) return a.t < b.t ? -1 : 1;
+  if (a.o !== b.o) return a.o < b.o ? -1 : 1;
+  return 0;
+}
+function maxStamp(a, b) {
+  if (a === null) return b;
+  if (b === null) return a;
+  return compareStamps(a, b) >= 0 ? a : b;
+}
+function minStamp(a, b) {
+  if (a === null) return b;
+  if (b === null) return a;
+  return compareStamps(a, b) <= 0 ? a : b;
+}
+function isAfter(a, b) {
+  if (a === null) return false;
+  if (b === null) return true;
+  return compareStamps(a, b) > 0;
+}
+function stampOf(timestamp, opId) {
+  return { t: HybridLogicalClock.serialize(timestamp), o: opId };
+}
+function stampTimestamp(stamp) {
+  return HybridLogicalClock.deserialize(stamp.t);
+}
+
+// src/schema/quote-ident.ts
+function quoteIdent(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+
+// src/schema/sql-gen.ts
+function generateSQL(collectionName, collection, relations) {
+  const statements = [];
+  const columns = ["id TEXT PRIMARY KEY NOT NULL"];
+  const indexedFields = new Set(collection.indexes);
+  const fkFields = [];
+  for (const [fieldName, descriptor] of Object.entries(collection.fields)) {
+    let colDef = columnDefinition(fieldName, descriptor);
+    if (relations) {
+      for (const rel of Object.values(relations)) {
+        if (rel.from === collectionName && rel.field === fieldName) {
+          colDef += ` REFERENCES ${quoteIdent(rel.to)}(id)`;
+          fkFields.push(fieldName);
+          break;
+        }
+      }
+    }
+    columns.push(colDef);
+  }
+  columns.push("_created_at INTEGER NOT NULL");
+  columns.push("_updated_at INTEGER NOT NULL");
+  columns.push("_version TEXT NOT NULL DEFAULT ''");
+  columns.push("_field_versions TEXT NOT NULL DEFAULT '{}'");
+  columns.push("_deleted INTEGER NOT NULL DEFAULT 0");
+  statements.push(
+    `CREATE TABLE IF NOT EXISTS ${quoteIdent(collectionName)} (
+  ${columns.join(",\n  ")}
+)`
+  );
+  for (const [fieldName, descriptor] of Object.entries(collection.fields)) {
+    const colDef = columnDefinition(fieldName, descriptor);
+    statements.push(
+      `--kora:safe-alter
+ALTER TABLE ${quoteIdent(collectionName)} ADD COLUMN ${colDef}`
+    );
+  }
+  statements.push(
+    `--kora:safe-alter
+ALTER TABLE ${quoteIdent(collectionName)} ADD COLUMN _version TEXT NOT NULL DEFAULT ''`
+  );
+  statements.push(
+    `--kora:safe-alter
+ALTER TABLE ${quoteIdent(collectionName)} ADD COLUMN _field_versions TEXT NOT NULL DEFAULT '{}'`
+  );
+  for (const indexField of collection.indexes) {
+    statements.push(
+      `CREATE INDEX IF NOT EXISTS ${quoteIdent(collectionIndexName(collectionName, indexField))} ON ${quoteIdent(collectionName)} (${quoteIdent(indexField)})`
+    );
+  }
+  for (const fkField of fkFields) {
+    if (!indexedFields.has(fkField)) {
+      statements.push(
+        `CREATE INDEX IF NOT EXISTS ${quoteIdent(collectionIndexName(collectionName, fkField))} ON ${quoteIdent(collectionName)} (${quoteIdent(fkField)})`
+      );
+    }
+  }
+  statements.push(
+    `CREATE TABLE IF NOT EXISTS ${quoteIdent(`_kora_ops_${collectionName}`)} (
+  id TEXT PRIMARY KEY NOT NULL,
+  node_id TEXT NOT NULL,
+  type TEXT NOT NULL,
+  record_id TEXT NOT NULL,
+  data TEXT,
+  previous_data TEXT,
+  timestamp TEXT NOT NULL,
+  sequence_number INTEGER NOT NULL,
+  causal_deps TEXT NOT NULL,
+  schema_version INTEGER NOT NULL
+)`
+  );
+  statements.push(
+    `CREATE INDEX IF NOT EXISTS idx_kora_ops_${collectionName}_record_id ON ${quoteIdent(`_kora_ops_${collectionName}`)} (record_id)`
+  );
+  return statements;
+}
+function collectionIndexName(collection, field) {
+  return `idx_${collection.length}_${collection}_${field}`;
+}
+function legacyCollectionIndexName(collection, field) {
+  return `idx_${collection}_${field}`;
+}
+var SCHEMA_CEILING_DIRECTIVE = "--kora:schema-ceiling";
+function generateFullDDL(schema) {
+  const statements = [];
+  statements.push(
+    "CREATE TABLE IF NOT EXISTS _kora_meta (\n  key TEXT PRIMARY KEY NOT NULL,\n  value TEXT NOT NULL\n)"
+  );
+  statements.push(`${SCHEMA_CEILING_DIRECTIVE} ${schema.version}`);
+  statements.push(
+    "CREATE TABLE IF NOT EXISTS _kora_version_vector (\n  node_id TEXT PRIMARY KEY NOT NULL,\n  sequence_number INTEGER NOT NULL\n)"
+  );
+  statements.push(
+    "CREATE TABLE IF NOT EXISTS _kora_sequences (\n  name TEXT NOT NULL,\n  scope TEXT NOT NULL DEFAULT '',\n  node_id TEXT NOT NULL,\n  counter INTEGER NOT NULL DEFAULT 0,\n  PRIMARY KEY (name, scope, node_id)\n)"
+  );
+  statements.push(
+    "CREATE TABLE IF NOT EXISTS _kora_sync_queue (\n  id TEXT PRIMARY KEY NOT NULL,\n  payload TEXT NOT NULL\n)"
+  );
+  statements.push(
+    "CREATE TABLE IF NOT EXISTS _kora_sync_rejected (\n  operation_id TEXT PRIMARY KEY NOT NULL,\n  collection TEXT NOT NULL,\n  record_id TEXT NOT NULL,\n  code TEXT NOT NULL,\n  message TEXT NOT NULL,\n  retriable INTEGER NOT NULL,\n  rejected_at INTEGER NOT NULL\n)"
+  );
+  statements.push(
+    "CREATE TABLE IF NOT EXISTS _kora_audit_traces (\n  id TEXT PRIMARY KEY NOT NULL,\n  recorded_at INTEGER NOT NULL,\n  event_type TEXT NOT NULL,\n  collection TEXT NOT NULL,\n  record_id TEXT NOT NULL,\n  field TEXT NOT NULL,\n  strategy TEXT NOT NULL,\n  tier INTEGER NOT NULL,\n  constraint_name TEXT,\n  trace_json TEXT NOT NULL\n)"
+  );
+  statements.push(
+    "CREATE INDEX IF NOT EXISTS idx_kora_audit_traces_recorded_at ON _kora_audit_traces (recorded_at)"
+  );
+  statements.push(
+    "CREATE INDEX IF NOT EXISTS idx_kora_audit_traces_collection ON _kora_audit_traces (collection)"
+  );
+  for (const [name, collection] of Object.entries(schema.collections)) {
+    statements.push(...generateSQL(name, collection, schema.relations));
+  }
+  return statements;
+}
+function columnDefinition(fieldName, descriptor) {
+  const sqlType = mapFieldType(descriptor);
+  const parts = [quoteIdent(fieldName), sqlType];
+  if (descriptor.defaultValue !== void 0) {
+    parts.push(`DEFAULT ${sqlDefaultLiteral(descriptor.defaultValue)}`);
+  }
+  return parts.join(" ");
+}
+function sqlStringLiteral(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function sqlDefaultLiteral(value) {
+  if (value === null) return "NULL";
+  if (typeof value === "string") return sqlStringLiteral(value);
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? String(value) : "NULL";
+  }
+  if (typeof value === "boolean") return value ? "1" : "0";
+  return sqlStringLiteral(JSON.stringify(value) ?? "null");
+}
+function enumCheckConstraint(fieldName, values) {
+  return `CHECK (${quoteIdent(fieldName)} IN (${values.map(sqlStringLiteral).join(", ")}))`;
+}
+function mapFieldType(descriptor) {
+  switch (descriptor.kind) {
+    case "string":
+      return "TEXT";
+    case "number":
+      return "REAL";
+    case "boolean":
+      return "INTEGER";
+    case "enum":
+      return "TEXT";
+    case "timestamp":
+      return "INTEGER";
+    case "array":
+      return "TEXT";
+    // JSON-serialized
+    case "object":
+      return "TEXT";
+    // JSON-serialized structured object
+    case "json":
+      return "TEXT";
+    // JSON-serialized dynamic-key value
+    case "blob":
+      return "TEXT";
+    // JSON-serialized content-addressed BlobRef (bytes stored out of band)
+    case "secret":
+      return "TEXT";
+    case "richtext":
+      return "BLOB";
+  }
+}
+
+// src/version-vector/topological-sort.ts
+function topologicalSort(operations) {
+  if (operations.length <= 1) return [...operations];
+  const opMap = /* @__PURE__ */ new Map();
+  for (const op of operations) {
+    opMap.set(op.id, op);
+  }
+  const inDegree = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  for (const op of operations) {
+    if (!inDegree.has(op.id)) {
+      inDegree.set(op.id, 0);
+    }
+    if (!dependents.has(op.id)) {
+      dependents.set(op.id, []);
+    }
+    for (const depId of op.causalDeps) {
+      if (opMap.has(depId)) {
+        inDegree.set(op.id, (inDegree.get(op.id) ?? 0) + 1);
+        const deps = dependents.get(depId);
+        if (deps) {
+          deps.push(op.id);
+        } else {
+          dependents.set(depId, [op.id]);
+        }
+      }
+    }
+  }
+  const heap = new MinHeap(compareByTimestamp);
+  for (const op of operations) {
+    if ((inDegree.get(op.id) ?? 0) === 0) {
+      heap.push(op);
+    }
+  }
+  const result = [];
+  while (heap.size > 0) {
+    const current = heap.pop();
+    result.push(current);
+    const deps = dependents.get(current.id) ?? [];
+    for (const depId of deps) {
+      const deg = (inDegree.get(depId) ?? 0) - 1;
+      inDegree.set(depId, deg);
+      if (deg === 0) {
+        const op = opMap.get(depId);
+        if (op) heap.push(op);
+      }
+    }
+  }
+  if (result.length !== operations.length) {
+    throw new OperationError(
+      `Cycle detected in operation dependency graph. Sorted ${result.length} of ${operations.length} operations.`,
+      {
+        sortedCount: result.length,
+        totalCount: operations.length
+      }
+    );
+  }
+  return result;
+}
+function compareByTimestamp(a, b) {
+  return HybridLogicalClock.compare(a.timestamp, b.timestamp);
+}
+var MinHeap = class {
+  data = [];
+  cmp;
+  constructor(comparator) {
+    this.cmp = comparator;
+  }
+  get size() {
+    return this.data.length;
+  }
+  push(item) {
+    this.data.push(item);
+    this.bubbleUp(this.data.length - 1);
+  }
+  pop() {
+    const top = this.data[0];
+    const last = this.data.pop();
+    if (this.data.length > 0) {
+      this.data[0] = last;
+      this.sinkDown(0);
+    }
+    return top;
+  }
+  bubbleUp(index) {
+    let current = index;
+    while (current > 0) {
+      const parentIndex = current - 1 >> 1;
+      if (this.cmp(this.data[current], this.data[parentIndex]) >= 0) break;
+      this.swap(current, parentIndex);
+      current = parentIndex;
+    }
+  }
+  sinkDown(index) {
+    const length = this.data.length;
+    let current = index;
+    while (true) {
+      let smallest = current;
+      const left = 2 * current + 1;
+      const right = 2 * current + 2;
+      if (left < length && this.cmp(this.data[left], this.data[smallest]) < 0) {
+        smallest = left;
+      }
+      if (right < length && this.cmp(this.data[right], this.data[smallest]) < 0) {
+        smallest = right;
+      }
+      if (smallest === current) break;
+      this.swap(current, smallest);
+      current = smallest;
+    }
+  }
+  swap(i, j) {
+    const tmp = this.data[i];
+    this.data[i] = this.data[j];
+    this.data[j] = tmp;
+  }
+};
+
+export {
+  KORA_ERROR_FIX_SUGGESTIONS,
+  getKoraErrorFix,
+  KoraError,
+  SchemaValidationError,
+  OperationError,
+  OperationTooLargeError,
+  MergeConflictError,
+  SyncError,
+  StorageError,
+  AppNotReadyError,
+  RemoteClockDriftError,
+  InvalidTimestampError,
+  ClockDriftError,
+  MAX_LOGICAL,
+  HybridLogicalClock,
+  isKoraBytesValue,
+  isLegacyNumericByteObject,
+  bytesToBase64,
+  base64ToBytes,
+  encodeBytesForOpData,
+  decodeBytesFromOpData,
+  NonCanonicalValueError,
+  canonicalizeOperationBody,
+  canonicalValue,
+  canonicalizeProvenLegacyClear,
+  canonicalizeLegacyOperation,
+  DEFAULT_OPERATION_HASH_VERSION,
+  computeOperationId,
+  canonicalize,
+  createOperation,
+  validateOperationParams,
+  verifyOperationId,
+  verifyOperationIntegrity,
+  isValidOperation,
+  planField,
+  compareStamps,
+  maxStamp,
+  minStamp,
+  isAfter,
+  stampOf,
+  stampTimestamp,
+  quoteIdent,
+  generateSQL,
+  collectionIndexName,
+  legacyCollectionIndexName,
+  SCHEMA_CEILING_DIRECTIVE,
+  generateFullDDL,
+  sqlStringLiteral,
+  sqlDefaultLiteral,
+  enumCheckConstraint,
+  topologicalSort
+};
+//# sourceMappingURL=chunk-QUD3DMSD.js.map