@korajs/core 1.0.0-beta.11 → 1.0.0-beta.13

package/dist/internal.cjs

@@ -20,99 +20,35 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/internal.ts
 var internal_exports = {};
 __export(internal_exports, {
+  SCHEMA_CEILING_DIRECTIVE: () => SCHEMA_CEILING_DIRECTIVE,
   SimpleEventEmitter: () => SimpleEventEmitter,
   canonicalize: () => canonicalize,
+  collectionIndexName: () => collectionIndexName,
+  compareStamps: () => compareStamps,
   computeOperationId: () => computeOperationId,
+  enumCheckConstraint: () => enumCheckConstraint,
+  isKoraInternalColumn: () => isKoraInternalColumn,
+  isKoraSqliteEnumCheck: () => isKoraSqliteEnumCheck,
+  isPostgresEnumCheckDefinition: () => isPostgresEnumCheckDefinition,
+  legacyCollectionIndexName: () => legacyCollectionIndexName,
+  parseEnumCheckDefinition: () => parseEnumCheckDefinition,
+  parseSqliteCheckConstraints: () => parseSqliteCheckConstraints,
+  planField: () => planField,
+  planPostgresConstraintRelaxation: () => planPostgresConstraintRelaxation,
+  planSqliteConstraintRelaxation: () => planSqliteConstraintRelaxation,
+  readSqliteTableCatalog: () => readSqliteTableCatalog,
+  sqlDefaultLiteral: () => sqlDefaultLiteral,
+  sqlStringLiteral: () => sqlStringLiteral,
+  sqliteCheckConstraintDefinition: () => sqliteCheckConstraintDefinition,
+  sqliteCheckReferencesColumn: () => sqliteCheckReferencesColumn,
+  sqliteConstraintRelaxationStatements: () => sqliteConstraintRelaxationStatements,
+  sqliteTableNeedsRelaxation: () => sqliteTableNeedsRelaxation,
+  stampOf: () => stampOf,
   topologicalSort: () => topologicalSort,
   validateOperationParams: () => validateOperationParams
 });
 module.exports = __toCommonJS(internal_exports);
 
-// src/operations/content-hash.ts
-async function computeOperationId(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;
-  }
-  const canonical = canonicalize(hashInput);
-  const encoded = new TextEncoder().encode(canonical);
-  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/events/event-emitter.ts
-var SimpleEventEmitter = class {
-  listeners = /* @__PURE__ */ new Map();
-  on(type, listener) {
-    let set = this.listeners.get(type);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.listeners.set(type, set);
-    }
-    set.add(listener);
-    return () => {
-      this.off(type, listener);
-    };
-  }
-  off(type, listener) {
-    const set = this.listeners.get(type);
-    if (set) {
-      set.delete(listener);
-      if (set.size === 0) {
-        this.listeners.delete(type);
-      }
-    }
-  }
-  emit(event) {
-    const set = this.listeners.get(event.type);
-    if (!set) return;
-    for (const listener of set) {
-      ;
-      listener(event);
-    }
-  }
-  /** Remove all listeners for all event types. */
-  clear() {
-    this.listeners.clear();
-  }
-  /** Get the number of listeners for a specific event type. */
-  listenerCount(type) {
-    return this.listeners.get(type)?.size ?? 0;
-  }
-};
-
 // 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.",
@@ -401,6 +337,26 @@ var HybridLogicalClock = class _HybridLogicalClock {
   }
 };
 
+// src/operations/op-data-binary.ts
+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;
+}
+
 // src/operations/operation.ts
 function validateOperationParams(input) {
   if (!input.nodeId || typeof input.nodeId !== "string") {
@@ -467,6 +423,285 @@ function validateOperationParams(input) {
   }
 }
 
+// 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 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";
+}
+
+// src/operations/content-hash.ts
+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/events/event-emitter.ts
+var SimpleEventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(type, listener) {
+    let set = this.listeners.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(type, set);
+    }
+    set.add(listener);
+    return () => {
+      this.off(type, listener);
+    };
+  }
+  off(type, listener) {
+    const set = this.listeners.get(type);
+    if (set) {
+      set.delete(listener);
+      if (set.size === 0) {
+        this.listeners.delete(type);
+      }
+    }
+  }
+  emit(event) {
+    const set = this.listeners.get(event.type);
+    if (!set) return;
+    for (const listener of set) {
+      ;
+      listener(event);
+    }
+  }
+  /** Remove all listeners for all event types. */
+  clear() {
+    this.listeners.clear();
+  }
+  /** Get the number of listeners for a specific event type. */
+  listenerCount(type) {
+    return this.listeners.get(type)?.size ?? 0;
+  }
+};
+
 // src/version-vector/topological-sort.ts
 function topologicalSort(operations) {
   if (operations.length <= 1) return [...operations];
@@ -584,11 +819,548 @@ var MinHeap = class {
     this.data[j] = tmp;
   }
 };
+
+// src/schema/quote-ident.ts
+function quoteIdent(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+
+// src/schema/sql-gen.ts
+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 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(", ")}))`;
+}
+
+// src/schema/constraint-relaxation.ts
+function isKoraInternalColumn(name) {
+  return name === "id" || name.startsWith("_");
+}
+function scanSqlTokens(sql) {
+  const tokens = [];
+  const pattern = /\s+|--[^\n]*|\/\*[\s\S]*?(?:\*\/|$)|'(?:[^']|'')*'?|"(?:[^"]|"")*"?|`(?:[^`]|``)*`?|\[[^\]]*\]?|[A-Za-z_][A-Za-z0-9_$]*|[0-9]+(?:\.[0-9]+)?|[(),]|[^\s(),'"`[A-Za-z0-9_]+/g;
+  for (let match = pattern.exec(sql); match !== null; match = pattern.exec(sql)) {
+    const text = match[0];
+    if (/^\s/.test(text) || text.startsWith("--") || text.startsWith("/*")) continue;
+    tokens.push({ text, start: match.index, end: match.index + text.length });
+  }
+  return tokens;
+}
+function unquoteSqliteName(token) {
+  if (token === void 0) return null;
+  if (/^"(?:[^"]|"")*"$/.test(token)) return token.slice(1, -1).replaceAll('""', '"');
+  if (/^`(?:[^`]|``)*`$/.test(token)) return token.slice(1, -1).replaceAll("``", "`");
+  if (/^\[[^\]]*\]$/.test(token)) return token.slice(1, -1);
+  if (/^'(?:[^']|'')*'$/.test(token)) return token.slice(1, -1).replaceAll("''", "'");
+  if (/^[A-Za-z_][A-Za-z0-9_$]*$/.test(token)) return token;
+  return null;
+}
+var TABLE_CONSTRAINT_KEYWORDS = /* @__PURE__ */ new Set([
+  "CONSTRAINT",
+  "PRIMARY",
+  "UNIQUE",
+  "CHECK",
+  "FOREIGN"
+]);
+function parseSqliteCheckConstraints(createTableSql) {
+  const tokens = scanSqlTokens(createTableSql);
+  const open = tokens.findIndex((token) => token.text === "(");
+  if (open < 0) return [];
+  const definitions = [];
+  let current = [];
+  let depth = 0;
+  for (let i = open + 1; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.text === "(") depth++;
+    if (token.text === ")") {
+      if (depth === 0) break;
+      depth--;
+    }
+    if (token.text === "," && depth === 0) {
+      definitions.push(current);
+      current = [];
+      continue;
+    }
+    current.push(token);
+  }
+  if (current.length > 0) definitions.push(current);
+  const checks = [];
+  for (const definition of definitions) {
+    const first = definition[0];
+    if (first === void 0) continue;
+    const column = TABLE_CONSTRAINT_KEYWORDS.has(first.text.toUpperCase()) ? null : unquoteSqliteName(first.text);
+    let level = 0;
+    for (let i = 0; i < definition.length; i++) {
+      const token = definition[i];
+      if (token.text === "(") level++;
+      else if (token.text === ")") level--;
+      if (level !== 0 || token.text.toUpperCase() !== "CHECK") continue;
+      const opening = definition[i + 1];
+      if (opening?.text !== "(") continue;
+      let inner = 0;
+      let closing;
+      for (let j = i + 1; j < definition.length; j++) {
+        const candidate = definition[j];
+        if (candidate.text === "(") inner++;
+        if (candidate.text === ")" && --inner === 0) {
+          closing = candidate;
+          break;
+        }
+      }
+      if (closing === void 0) continue;
+      const named = i >= 2 && definition[i - 2].text.toUpperCase() === "CONSTRAINT" ? unquoteSqliteName(definition[i - 1].text) : null;
+      checks.push({
+        name: named,
+        expression: createTableSql.slice(opening.end, closing.start).trim(),
+        column
+      });
+    }
+  }
+  return checks;
+}
+function isKoraSqliteEnumCheck(check, enumColumns) {
+  const shape = parseEnumCheckDefinition(`CHECK (${check.expression})`);
+  if (shape === null || isKoraInternalColumn(shape.column)) return false;
+  if (check.column !== null && check.column !== shape.column) return false;
+  return enumColumns === void 0 || enumColumns.includes(shape.column);
+}
+function sqliteTableNeedsRelaxation(catalog, enumColumns) {
+  if (parseSqliteCheckConstraints(catalog.sql).some(
+    (check) => isKoraSqliteEnumCheck(check, enumColumns)
+  )) {
+    return true;
+  }
+  return catalog.columns.some(
+    (column) => column.notnull === 1 && !isKoraInternalColumn(column.name)
+  );
+}
+function sqliteCheckReferencesColumn(check, columns) {
+  if (check.column !== null && columns.has(check.column)) return true;
+  return scanSqlTokens(check.expression).some((token) => {
+    if (token.text.startsWith("'")) return false;
+    const name = unquoteSqliteName(token.text);
+    return name !== null && columns.has(name);
+  });
+}
+function sqliteCheckConstraintDefinition(check) {
+  const name = check.name === null ? "" : `CONSTRAINT ${quoteIdent(check.name)} `;
+  return `${name}CHECK (${check.expression})`;
+}
+function sqliteConstraintRelaxationStatements(catalog, enumColumns) {
+  if (!sqliteTableNeedsRelaxation(catalog, enumColumns)) return [];
+  const table = catalog.table;
+  const temp = `_kora_relax_${table}`;
+  const ordered = [...catalog.columns].sort((a, b) => a.cid - b.cid);
+  const pkColumns = ordered.filter((c) => c.pk > 0).sort((a, b) => a.pk - b.pk);
+  const fkGroups = /* @__PURE__ */ new Map();
+  for (const fk of catalog.foreignKeys) {
+    const group = fkGroups.get(fk.id) ?? [];
+    group.push(fk);
+    fkGroups.set(fk.id, group);
+  }
+  const columnReferences = /* @__PURE__ */ new Map();
+  const tableConstraints = [];
+  for (const group of fkGroups.values()) {
+    group.sort((a, b) => a.seq - b.seq);
+    const first = group[0];
+    if (!first) continue;
+    const actions = foreignKeyActions(first);
+    const target = group.every((fk) => fk.to !== null && fk.to !== "") ? `${quoteIdent(first.table)}(${group.map((fk) => quoteIdent(fk.to ?? "")).join(", ")})` : quoteIdent(first.table);
+    if (group.length === 1) {
+      columnReferences.set(first.from, `REFERENCES ${target}${actions}`);
+    } else {
+      tableConstraints.push(
+        `FOREIGN KEY (${group.map((fk) => quoteIdent(fk.from)).join(", ")}) REFERENCES ${target}${actions}`
+      );
+    }
+  }
+  if (pkColumns.length > 1) {
+    tableConstraints.unshift(`PRIMARY KEY (${pkColumns.map((c) => quoteIdent(c.name)).join(", ")})`);
+  }
+  for (const unique of catalog.uniqueConstraints) {
+    tableConstraints.push(`UNIQUE (${unique.map(quoteIdent).join(", ")})`);
+  }
+  for (const check of parseSqliteCheckConstraints(catalog.sql)) {
+    if (!isKoraSqliteEnumCheck(check, enumColumns)) {
+      tableConstraints.push(sqliteCheckConstraintDefinition(check));
+    }
+  }
+  const definitions = ordered.map((column) => {
+    const parts = [quoteIdent(column.name)];
+    if (column.type) parts.push(column.type);
+    if (pkColumns.length === 1 && column.pk === 1) parts.push("PRIMARY KEY");
+    if (column.notnull === 1 && isKoraInternalColumn(column.name)) parts.push("NOT NULL");
+    if (column.dflt_value !== null) parts.push(`DEFAULT (${column.dflt_value})`);
+    const reference = columnReferences.get(column.name);
+    if (reference) parts.push(reference);
+    return parts.join(" ");
+  });
+  const columnList = ordered.map((column) => quoteIdent(column.name)).join(", ");
+  return [
+    `DROP TABLE IF EXISTS ${quoteIdent(temp)}`,
+    `CREATE TABLE ${quoteIdent(temp)} (
+  ${[...definitions, ...tableConstraints].join(",\n  ")}
+)`,
+    `INSERT INTO ${quoteIdent(temp)} (${columnList}) SELECT ${columnList} FROM ${quoteIdent(table)}`,
+    `DROP TABLE ${quoteIdent(table)}`,
+    `ALTER TABLE ${quoteIdent(temp)} RENAME TO ${quoteIdent(table)}`,
+    ...catalog.dependents
+  ];
+}
+function foreignKeyActions(fk) {
+  let out = "";
+  const onDelete = fk.on_delete?.toUpperCase();
+  const onUpdate = fk.on_update?.toUpperCase();
+  if (onDelete && onDelete !== "NO ACTION") out += ` ON DELETE ${onDelete}`;
+  if (onUpdate && onUpdate !== "NO ACTION") out += ` ON UPDATE ${onUpdate}`;
+  return out;
+}
+var EXPRESSION_KEYWORDS = /* @__PURE__ */ new Set([
+  "AND",
+  "ANY",
+  "ARRAY",
+  "IN",
+  "IS",
+  "NOT",
+  "NULL",
+  "OR",
+  "VALID"
+]);
+function tokenizeCheck(definition) {
+  const tokens = [];
+  const pattern = /\s+|'(?:[^']|'')*'|"(?:[^"]|"")+"|::|[A-Za-z_][A-Za-z0-9_$]*|[0-9]+|<>|!=|<=|>=|[()[\],=<>]|./gy;
+  for (let match = pattern.exec(definition); match !== null; match = pattern.exec(definition)) {
+    if (match[0] === "") return null;
+    if (!/^\s+$/.test(match[0])) tokens.push(match[0]);
+    if (pattern.lastIndex >= definition.length) break;
+  }
+  return tokens;
+}
+function isWord(token) {
+  return token !== void 0 && /^[A-Za-z_][A-Za-z0-9_$]*$/.test(token);
+}
+function dropCasts(tokens) {
+  const out = [];
+  let i = 0;
+  while (i < tokens.length) {
+    if (tokens[i] !== "::") {
+      out.push(tokens[i]);
+      i++;
+      continue;
+    }
+    i++;
+    let words = 0;
+    while (isWord(tokens[i]) && !EXPRESSION_KEYWORDS.has(tokens[i].toUpperCase()) || /^"/.test(tokens[i] ?? "")) {
+      i++;
+      words++;
+    }
+    if (words === 0) return ["::invalid"];
+    if (tokens[i] === "(" && /^[0-9]+$/.test(tokens[i + 1] ?? "")) {
+      let j = i + 1;
+      while (/^[0-9]+$/.test(tokens[j] ?? "") || tokens[j] === ",") j++;
+      if (tokens[j] === ")") i = j + 1;
+    }
+    while (tokens[i] === "[" && tokens[i + 1] === "]") i += 2;
+  }
+  return out;
+}
+function unquoteIdentifier(token) {
+  if (/^"(?:[^"]|"")+"$/.test(token)) return token.slice(1, -1).replaceAll('""', '"');
+  if (isWord(token) && !EXPRESSION_KEYWORDS.has(token.toUpperCase())) return token;
+  return null;
+}
+function unquoteLiteral(token) {
+  if (token === void 0 || !/^'(?:[^']|'')*'$/.test(token)) return null;
+  return token.slice(1, -1).replaceAll("''", "'");
+}
+function parseEnumCheckDefinition(definition) {
+  const raw = tokenizeCheck(definition.trim());
+  if (raw === null || raw[0]?.toUpperCase() !== "CHECK") return null;
+  let tokens = dropCasts(raw.slice(1)).filter((token) => token !== "(" && token !== ")");
+  const upper = (index) => (tokens[index] ?? "").toUpperCase();
+  if (upper(tokens.length - 2) === "NOT" && upper(tokens.length - 1) === "VALID") {
+    tokens = tokens.slice(0, -2);
+  }
+  let column = null;
+  const values = [];
+  let allowsNull = false;
+  let i = 0;
+  const readLiteral = () => {
+    const value = unquoteLiteral(tokens[i]);
+    if (value === null) return false;
+    values.push(value);
+    i++;
+    return true;
+  };
+  const readList = () => {
+    if (!readLiteral()) return false;
+    while (tokens[i] === ",") {
+      i++;
+      if (!readLiteral()) return false;
+    }
+    return true;
+  };
+  for (; ; ) {
+    const name = unquoteIdentifier(tokens[i] ?? "");
+    if (name === null || column !== null && name !== column) return null;
+    column = name;
+    i++;
+    if (tokens[i] === "=" && upper(i + 1) === "ANY" && upper(i + 2) === "ARRAY") {
+      if (tokens[i + 3] !== "[") return null;
+      i += 4;
+      if (!readList() || tokens[i] !== "]") return null;
+      i++;
+    } else if (tokens[i] === "=") {
+      i++;
+      if (!readLiteral()) return null;
+    } else if (upper(i) === "IN") {
+      i++;
+      if (!readList()) return null;
+    } else if (upper(i) === "IS" && upper(i + 1) === "NULL") {
+      allowsNull = true;
+      i += 2;
+    } else {
+      return null;
+    }
+    if (i === tokens.length) break;
+    if (upper(i) !== "OR") return null;
+    i++;
+  }
+  if (column === null || values.length === 0) return null;
+  return { column, values, allowsNull };
+}
+function isPostgresEnumCheckDefinition(definition) {
+  return parseEnumCheckDefinition(definition) !== null;
+}
+function isAnyArrayCheck(definition) {
+  return /^CHECK\s*\(\(*\s*(?:"(?:[^"]|"")+"|[A-Za-z_][A-Za-z0-9_$]*)(?:\)?::[A-Za-z ]+)?\s*=\s*ANY\s*\(/i.test(
+    definition.trim()
+  );
+}
+function sqlText(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+async function readSqliteTableCatalog(query, table) {
+  const master = await query(
+    `SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ${sqlText(table)}`
+  );
+  const tableSql = master[0]?.sql;
+  if (typeof tableSql !== "string") return null;
+  const columns = await query(
+    `SELECT cid, name, type, "notnull" AS "notnull", dflt_value, pk FROM pragma_table_info(${sqlText(table)})`
+  );
+  const foreignKeys = await query(
+    `SELECT id, seq, "table" AS "table", "from" AS "from", "to" AS "to", on_update, on_delete FROM pragma_foreign_key_list(${sqlText(table)})`
+  );
+  const uniqueConstraints = [];
+  const indexes = await query(
+    `SELECT name FROM pragma_index_list(${sqlText(table)}) WHERE origin = 'u'`
+  );
+  for (const index of indexes) {
+    const info = await query(
+      `SELECT name FROM pragma_index_info(${sqlText(String(index.name))}) ORDER BY seqno`
+    );
+    uniqueConstraints.push(info.map((row) => String(row.name)));
+  }
+  const dependents = await query(
+    `SELECT sql FROM sqlite_master WHERE type IN ('index', 'trigger') AND tbl_name = ${sqlText(table)} AND sql IS NOT NULL ORDER BY type, name`
+  );
+  return {
+    table,
+    sql: tableSql,
+    columns: columns.map((c) => ({
+      cid: Number(c.cid),
+      name: String(c.name),
+      type: typeof c.type === "string" ? c.type : "",
+      notnull: Number(c.notnull),
+      dflt_value: typeof c.dflt_value === "string" ? c.dflt_value : null,
+      pk: Number(c.pk)
+    })),
+    foreignKeys: foreignKeys.map((fk) => ({
+      id: Number(fk.id),
+      seq: Number(fk.seq),
+      table: String(fk.table),
+      from: String(fk.from),
+      to: typeof fk.to === "string" ? fk.to : null,
+      on_update: String(fk.on_update ?? "NO ACTION"),
+      on_delete: String(fk.on_delete ?? "NO ACTION")
+    })),
+    uniqueConstraints,
+    dependents: dependents.map((row) => String(row.sql))
+  };
+}
+async function planSqliteConstraintRelaxation(query, tables, enumColumnsByTable = {}) {
+  const statements = [];
+  for (const table of tables) {
+    const catalog = await readSqliteTableCatalog(query, table);
+    if (catalog) {
+      statements.push(...sqliteConstraintRelaxationStatements(catalog, enumColumnsByTable[table]));
+    }
+  }
+  return statements;
+}
+async function planPostgresConstraintRelaxation(query, fieldsByTable, enumFieldsByTable = {}) {
+  const tables = Object.keys(fieldsByTable);
+  if (tables.length === 0) return [];
+  const tableList = tables.map(sqlText).join(", ");
+  const statements = [];
+  const checks = await query(
+    `SELECT rel.relname::text AS table_name, con.conname::text AS name, pg_get_constraintdef(con.oid) AS definition,
+			(SELECT array_agg(att.attname::text) FROM pg_attribute att WHERE att.attrelid = con.conrelid AND att.attnum = ANY (con.conkey)) AS columns
+		FROM pg_constraint con
+		JOIN pg_class rel ON rel.oid = con.conrelid
+		JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+		WHERE con.contype = 'c' AND nsp.nspname = current_schema() AND rel.relname IN (${tableList})
+		ORDER BY rel.relname, con.conname`
+  );
+  for (const check of checks) {
+    const columns = Array.isArray(check.columns) ? check.columns.map(String) : [];
+    const column = columns[0];
+    if (columns.length !== 1 || column === void 0 || isKoraInternalColumn(column)) continue;
+    const shape = parseEnumCheckDefinition(String(check.definition));
+    if (shape === null || shape.column !== column) continue;
+    const table = String(check.table_name);
+    const enumColumns = enumFieldsByTable[table] ?? fieldsByTable[table] ?? [];
+    if (!enumColumns.includes(column) && !isAnyArrayCheck(String(check.definition))) continue;
+    statements.push(
+      `ALTER TABLE ${quoteIdent(String(check.table_name))} DROP CONSTRAINT IF EXISTS ${quoteIdent(String(check.name))}`
+    );
+  }
+  const notNull = await query(
+    `SELECT rel.relname::text AS table_name, att.attname::text AS column_name
+		FROM pg_attribute att
+		JOIN pg_class rel ON rel.oid = att.attrelid
+		JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+		WHERE att.attnotnull AND att.attnum > 0 AND NOT att.attisdropped
+			AND rel.relkind = 'r' AND nsp.nspname = current_schema() AND rel.relname IN (${tableList})
+		ORDER BY rel.relname, att.attnum`
+  );
+  for (const row of notNull) {
+    const table = String(row.table_name);
+    const column = String(row.column_name);
+    if (isKoraInternalColumn(column)) continue;
+    if (!(fieldsByTable[table] ?? []).includes(column)) continue;
+    statements.push(
+      `ALTER TABLE ${quoteIdent(table)} ALTER COLUMN ${quoteIdent(column)} DROP NOT NULL`
+    );
+  }
+  return statements;
+}
+
+// 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 stampOf(timestamp, opId) {
+  return { t: HybridLogicalClock.serialize(timestamp), o: opId };
+}
+
+// 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 };
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  SCHEMA_CEILING_DIRECTIVE,
   SimpleEventEmitter,
   canonicalize,
+  collectionIndexName,
+  compareStamps,
   computeOperationId,
+  enumCheckConstraint,
+  isKoraInternalColumn,
+  isKoraSqliteEnumCheck,
+  isPostgresEnumCheckDefinition,
+  legacyCollectionIndexName,
+  parseEnumCheckDefinition,
+  parseSqliteCheckConstraints,
+  planField,
+  planPostgresConstraintRelaxation,
+  planSqliteConstraintRelaxation,
+  readSqliteTableCatalog,
+  sqlDefaultLiteral,
+  sqlStringLiteral,
+  sqliteCheckConstraintDefinition,
+  sqliteCheckReferencesColumn,
+  sqliteConstraintRelaxationStatements,
+  sqliteTableNeedsRelaxation,
+  stampOf,
   topologicalSort,
   validateOperationParams
 });