@korajs/core 1.0.0-beta.12 → 1.0.0-beta.14

package/dist/{chunk-5IICSH6H.js → chunk-QUD3DMSD.js}

@@ -49,6 +49,24 @@ var OperationError = class extends KoraError {
     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(
@@ -343,8 +361,118 @@ var HybridLogicalClock = class _HybridLogicalClock {
   }
 };
 
+// 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
-async function computeOperationId(input, timestamp) {
+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,
@@ -356,8 +484,30 @@ async function computeOperationId(input, timestamp) {
   if (input.atomicOps !== void 0 && Object.keys(input.atomicOps).length > 0) {
     hashInput.atomicOps = input.atomicOps;
   }
-  const canonical = canonicalize(hashInput);
-  const encoded = new TextEncoder().encode(canonical);
+  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);
 }
@@ -388,11 +538,12 @@ function bufferToHex(buffer) {
 }
 
 // src/operations/operation.ts
-async function createOperation(input, clock) {
-  validateOperationParams(input);
+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 serializedTs = HybridLogicalClock.serialize(timestamp);
-  const id = await computeOperationId(input, serializedTs);
+  const id = hashVersion === 1 ? await computeOperationId(input, HybridLogicalClock.serialize(timestamp)) : await computeOperationId({ ...input, timestamp }, hashVersion);
   const operation = {
     id,
     nodeId: input.nodeId,
@@ -407,7 +558,8 @@ async function createOperation(input, clock) {
     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 } : {}
+    ...input.mutationName !== void 0 ? { mutationName: input.mutationName } : {},
+    ...hashVersion !== 1 ? { hashVersion } : {}
   };
   return deepFreeze(operation);
 }
@@ -475,23 +627,35 @@ function validateOperationParams(input) {
     });
   }
 }
-async function verifyOperationIntegrity(op) {
-  const input = {
-    nodeId: op.nodeId,
-    type: op.type,
-    collection: op.collection,
-    recordId: op.recordId,
-    data: op.data,
-    previousData: op.previousData,
-    sequenceNumber: op.sequenceNumber,
-    causalDeps: op.causalDeps,
-    schemaVersion: op.schemaVersion,
-    ...op.atomicOps !== void 0 ? { atomicOps: op.atomicOps } : {}
-  };
-  const serializedTs = HybridLogicalClock.serialize(op.timestamp);
-  const expectedId = await computeOperationId(input, serializedTs);
+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;
@@ -509,6 +673,456 @@ function deepFreeze(obj) {
   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];
@@ -633,6 +1247,7 @@ export {
   KoraError,
   SchemaValidationError,
   OperationError,
+  OperationTooLargeError,
   MergeConflictError,
   SyncError,
   StorageError,
@@ -642,12 +1257,41 @@ export {
   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-5IICSH6H.js.map
+//# sourceMappingURL=chunk-QUD3DMSD.js.map