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

package/dist/index.js

@@ -1,23 +1,51 @@
 import {
   AppNotReadyError,
   ClockDriftError,
+  DEFAULT_OPERATION_HASH_VERSION,
   HybridLogicalClock,
   InvalidTimestampError,
   KORA_ERROR_FIX_SUGGESTIONS,
   KoraError,
   MAX_LOGICAL,
   MergeConflictError,
+  NonCanonicalValueError,
   OperationError,
+  OperationTooLargeError,
   RemoteClockDriftError,
   SchemaValidationError,
   StorageError,
   SyncError,
+  base64ToBytes,
+  bytesToBase64,
+  canonicalValue,
+  canonicalize,
+  canonicalizeLegacyOperation,
+  canonicalizeOperationBody,
+  canonicalizeProvenLegacyClear,
+  collectionIndexName,
+  compareStamps,
+  computeOperationId,
   createOperation,
+  decodeBytesFromOpData,
+  encodeBytesForOpData,
+  generateFullDDL,
+  generateSQL,
   getKoraErrorFix,
+  isAfter,
+  isKoraBytesValue,
+  isLegacyNumericByteObject,
   isValidOperation,
+  maxStamp,
+  minStamp,
+  planField,
+  quoteIdent,
+  sqlDefaultLiteral,
+  stampOf,
+  stampTimestamp,
   topologicalSort,
+  verifyOperationId,
   verifyOperationIntegrity
-} from "./chunk-5IICSH6H.js";
+} from "./chunk-QUD3DMSD.js";
 
 // src/types.ts
 var MERGE_STRATEGIES = [
@@ -463,6 +491,44 @@ function toAtomicOp(sentinel) {
 }
 
 // src/operations/replay-record.ts
+function mergeArraySet(local, remote, base) {
+  const serialize = (v) => JSON.stringify(v);
+  const baseSet = new Set(base.map(serialize));
+  const localSet = new Set(local.map(serialize));
+  const remoteSet = new Set(remote.map(serialize));
+  const keep = (s) => localSet.has(s) && remoteSet.has(s) || !baseSet.has(s) && (localSet.has(s) || remoteSet.has(s));
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  const addIfKept = (serialized, value) => {
+    if (!seen.has(serialized) && keep(serialized)) {
+      seen.add(serialized);
+      result.push(value);
+    }
+  };
+  for (const item of base) {
+    addIfKept(serialize(item), item);
+  }
+  const others = /* @__PURE__ */ new Map();
+  for (const item of [...local, ...remote]) {
+    const s = serialize(item);
+    if (!baseSet.has(s) && !others.has(s)) {
+      others.set(s, item);
+    }
+  }
+  for (const s of [...others.keys()].sort()) {
+    addIfKept(s, others.get(s));
+  }
+  return result;
+}
+function resolveArrayWrite(running, value, base) {
+  if (!Array.isArray(running) || !Array.isArray(value) || !Array.isArray(base)) {
+    return value;
+  }
+  if (canonicalize(running) === canonicalize(base)) {
+    return value;
+  }
+  return mergeArraySet(running, value, base);
+}
 function replayOperationsForRecord(ops) {
   let record = null;
   let deleted = false;
@@ -485,6 +551,8 @@ function replayOperationsForRecord(ops) {
             const atomicOp = op2.atomicOps?.[field];
             if (atomicOp && lastWriterKind[field] === `atomic:${atomicOp.type}`) {
               next[field] = applyAtomicOp(next[field], atomicOp);
+            } else if (!atomicOp && op2.previousData && field in op2.previousData) {
+              next[field] = resolveArrayWrite(next[field], value, op2.previousData[field]);
             } else {
               next[field] = value;
             }
@@ -499,107 +567,1567 @@ function replayOperationsForRecord(ops) {
         break;
     }
   }
-  return deleted ? null : record;
+  return deleted ? null : record;
+}
+function replayFieldVersionsForRecord(ops) {
+  let fields = null;
+  let deleted = false;
+  const first = ops[0];
+  const last = ops[ops.length - 1];
+  if (!first || !last) return null;
+  for (const op2 of ops) {
+    switch (op2.type) {
+      case "insert":
+        if (op2.data) {
+          fields = {};
+          for (const field of Object.keys(op2.data)) fields[field] = { ...op2.timestamp };
+          deleted = false;
+        }
+        break;
+      case "update":
+        if (op2.data) {
+          const next = { ...fields ?? {} };
+          for (const field of Object.keys(op2.data)) next[field] = { ...op2.timestamp };
+          fields = next;
+          deleted = false;
+        }
+        break;
+      case "delete":
+        deleted = true;
+        break;
+    }
+  }
+  if (deleted || fields === null) return null;
+  return { fields, created: { ...first.timestamp }, latest: { ...last.timestamp } };
+}
+function expandFieldVersionedOperations(ops) {
+  const expanded = [];
+  for (const op2 of ops) {
+    if (op2.type !== "insert" || !op2.fieldVersions || !op2.data) {
+      expanded.push(op2);
+      continue;
+    }
+    const { fieldVersions, ...base } = op2;
+    expanded.push(base);
+    const groups = /* @__PURE__ */ new Map();
+    let newest = op2.timestamp;
+    for (const v of Object.values(fieldVersions)) {
+      if (HybridLogicalClock.compare(v, newest) > 0) newest = v;
+    }
+    for (const [field, value] of Object.entries(op2.data)) {
+      const version = fieldVersions[field] ?? newest;
+      if (HybridLogicalClock.compare(version, op2.timestamp) <= 0) continue;
+      const key = `${version.wallTime}:${version.logical}:${version.nodeId}`;
+      const group = groups.get(key) ?? { timestamp: version, data: {} };
+      group.data[field] = value;
+      groups.set(key, group);
+    }
+    let index = 0;
+    for (const group of groups.values()) {
+      expanded.push({
+        ...base,
+        id: `${op2.id}#field-version-${index++}`,
+        type: "update",
+        data: group.data,
+        previousData: null,
+        timestamp: { ...group.timestamp }
+      });
+    }
+  }
+  return expanded.sort((a, b) => HybridLogicalClock.compare(a.timestamp, b.timestamp));
+}
+
+// src/migration/apply-operation-transforms.ts
+var MAX_TRANSFORM_STEPS = 32;
+function applyOperationTransforms(operation, targetSchemaVersion, transforms) {
+  let current = operation;
+  for (let step = 0; step < MAX_TRANSFORM_STEPS; step++) {
+    if (current.schemaVersion === targetSchemaVersion) {
+      return current;
+    }
+    const transform = transforms.find(
+      (candidate) => candidate.fromVersion === current.schemaVersion
+    );
+    if (!transform) {
+      return null;
+    }
+    const next = transform.transform(current);
+    if (next === null) {
+      return null;
+    }
+    current = next;
+  }
+  return null;
+}
+
+// src/migration/operation-view.ts
+var OperationTransformError = class extends KoraError {
+  constructor(message, context) {
+    super(message, "INVALID_OPERATION_TRANSFORM", {
+      ...context,
+      fix: "An OperationTransform may rewrite data, previousData, atomicOps and schemaVersion only, deterministically, with JSON values."
+    });
+    this.name = "OperationTransformError";
+  }
+};
+function operationSchemaView(op2, targetSchemaVersion, transforms) {
+  if (op2.schemaVersion === targetSchemaVersion) return op2;
+  if (transforms === void 0 || transforms.length === 0) return op2;
+  if (op2.encrypted !== void 0) return op2;
+  let view;
+  try {
+    view = applyOperationTransforms(op2, targetSchemaVersion, transforms);
+  } catch (error) {
+    throw new OperationTransformError(
+      `The schema transform of operation ${op2.id} (schema v${op2.schemaVersion} -> v${targetSchemaVersion}) threw: ${error instanceof Error ? error.message : String(error)}`,
+      { operationId: op2.id, fromVersion: op2.schemaVersion, toVersion: targetSchemaVersion }
+    );
+  }
+  if (view === null || view === op2) return view;
+  for (const key of ["id", "nodeId", "type", "collection", "recordId"]) {
+    if (view[key] !== op2[key]) {
+      throw new OperationTransformError(
+        `The schema transform of operation ${op2.id} changed its ${key} ("${String(op2[key])}" -> "${String(view[key])}"). A transform may rewrite data, previousData, atomicOps and schemaVersion only.`,
+        { operationId: op2.id, field: key }
+      );
+    }
+  }
+  const a = op2.timestamp;
+  const b = view.timestamp;
+  if (a.wallTime !== b.wallTime || a.logical !== b.logical || a.nodeId !== b.nodeId) {
+    throw new OperationTransformError(
+      `The schema transform of operation ${op2.id} changed its timestamp. A transform may rewrite data, previousData, atomicOps and schemaVersion only.`,
+      { operationId: op2.id, field: "timestamp" }
+    );
+  }
+  try {
+    return canonicalizeOperationBody(view);
+  } catch (error) {
+    throw new OperationTransformError(
+      `The schema transform of operation ${op2.id} produced a value with no JSON form: ${error instanceof Error ? error.message : String(error)}`,
+      { operationId: op2.id }
+    );
+  }
+}
+function hashText(text) {
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function operationTransformsFingerprint(targetSchemaVersion, transforms) {
+  if (transforms === void 0 || transforms.length === 0) return "";
+  const parts = transforms.map((t2) => `${t2.fromVersion}>${t2.toVersion}:${hashText(String(t2.transform))}`).sort();
+  return `xf@v${targetSchemaVersion}(${parts.join(",")})`;
+}
+var OperationTransformCoverageError = class extends KoraError {
+  constructor(message, versions, targetSchemaVersion, context = {}) {
+    super(message, "OPERATION_TRANSFORM_MISSING", {
+      ...context,
+      versions: [...versions],
+      targetSchemaVersion,
+      fix: `Keep a transform path registered from every schema version in the operation log to v${targetSchemaVersion} (a transform must stay registered as long as operations of its source version exist, and the log is append-only), or register no transforms at all (operations then fold as written).`
+    });
+    this.versions = versions;
+    this.targetSchemaVersion = targetSchemaVersion;
+    this.name = "OperationTransformCoverageError";
+  }
+  versions;
+  targetSchemaVersion;
+};
+function missingTransformPaths(storedVersions, targetSchemaVersion, transforms) {
+  if (transforms === void 0 || transforms.length === 0) return [];
+  const missing = [];
+  for (const version of new Set(storedVersions)) {
+    if (version === targetSchemaVersion) continue;
+    let current = version;
+    let reached = false;
+    for (let step = 0; step < 32; step++) {
+      if (current === targetSchemaVersion) {
+        reached = true;
+        break;
+      }
+      const next = transforms.find((candidate) => candidate.fromVersion === current);
+      if (!next) break;
+      current = next.toVersion;
+    }
+    if (!reached) missing.push({ version, missingFrom: current });
+  }
+  return missing.sort((a, b) => a.version - b.version);
+}
+function assertOperationTransformCoverage(storedVersions, targetSchemaVersion, transforms, replica) {
+  const missing = missingTransformPaths(storedVersions, targetSchemaVersion, transforms);
+  if (missing.length === 0) return;
+  const versions = missing.map((entry) => entry.version);
+  const steps = [...new Set(missing.map((entry) => entry.missingFrom))];
+  const plural = versions.length > 1;
+  throw new OperationTransformCoverageError(
+    `The ${replica} holds operations of schema version${plural ? "s" : ""} ${versions.map((v) => `v${v}`).join(", ")}, but the registered operationTransforms have no path from ${plural ? "them" : "it"} to the current schema v${targetSchemaVersion} (no transform from ${steps.map((v) => `v${v}`).join(", ")}). Starting would silently drop those operations from their records, so it is refused. Keep the retired transform(s) registered: a transform may be removed only after every operation of its source version has been folded into snapshots by an explicit compaction.`,
+    versions,
+    targetSchemaVersion,
+    { replica, missingFrom: steps }
+  );
+}
+
+// src/fold/authority.ts
+var RESERVED_NODE_ID_PREFIX = "kora:";
+var SERVER_NODE_ID_PREFIX = "kora:server:";
+function isReservedNodeId(nodeId) {
+  return nodeId.startsWith(RESERVED_NODE_ID_PREFIX);
+}
+function isServerNodeId(nodeId) {
+  return nodeId.startsWith(SERVER_NODE_ID_PREFIX) && nodeId.length > SERVER_NODE_ID_PREFIX.length;
+}
+function isAuthoritativeNodeId(nodeId, explicit) {
+  return isServerNodeId(nodeId) || (explicit?.has(nodeId) ?? false);
+}
+
+// src/fold/errors.ts
+var FoldStateError = class extends KoraError {
+  constructor(message, context) {
+    super(message, "FOLD_STATE_INVALID", {
+      fix: "Rebuild the record state from its operation log with foldRecord(ops, schema).",
+      ...context
+    });
+    this.name = "FoldStateError";
+  }
+};
+var FoldConfigurationError = class extends KoraError {
+  constructor(message, context) {
+    super(message, "FOLD_CONFIGURATION", context);
+    this.name = "FoldConfigurationError";
+  }
+};
+
+// src/fold/values.ts
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+function normalizeValue(value) {
+  if (value instanceof Uint8Array) return { $koraBytes: bytesToBase64(value) };
+  if (value instanceof ArrayBuffer) return { $koraBytes: bytesToBase64(new Uint8Array(value)) };
+  if (Array.isArray(value)) return value.map(normalizeValue);
+  if (isPlainObject(value)) {
+    const out = {};
+    for (const [key, member] of Object.entries(value)) {
+      if (member !== void 0) out[key] = normalizeValue(member);
+    }
+    return out;
+  }
+  return value;
+}
+function canonicalKey(value) {
+  return canonicalize(normalizeValue(value));
+}
+
+// src/fold/field-states.ts
+function emptyField(plan) {
+  switch (plan.kind) {
+    case "reg":
+      return { k: "reg", e: [], val: void 0 };
+    case "res":
+      return { k: "res", e: [], val: void 0 };
+    case "set":
+      return { k: "set", ao: plan.appendOnly, sh: null, clr: null, el: {} };
+    case "map":
+      return { k: "map", sh: null, clr: null, keys: {} };
+    case "ctr":
+      return { k: "ctr", base: null, d: [], val: void 0 };
+    case "max":
+    case "min":
+      return { k: plan.kind, best: null, reg: null };
+    case "rt":
+      return { k: "rt", reset: null, u: {} };
+  }
+}
+function entryKind(entry) {
+  return entry.a ? entry.a.type : "set";
+}
+function chainFold(entries) {
+  let value;
+  let last = null;
+  for (const entry of entries) {
+    value = entry.a && last === entry.a.type ? applyAtomicOp(value, entry.a) : entry.v;
+    last = entryKind(entry);
+  }
+  return value;
+}
+function insertionIndex(entries, stamp) {
+  let lo = 0;
+  let hi = entries.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    const entry = entries[mid];
+    const cmp = compareStamps(entry.s, stamp);
+    if (cmp === 0) return -1;
+    if (cmp < 0) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function pruneChain(entries) {
+  for (let i = entries.length - 1; i > 0; i--) {
+    if (!entries[i].a) return entries.slice(i);
+  }
+  return entries;
+}
+function toEntry(write) {
+  return write.a ? { s: write.s, v: write.v, a: write.a } : { s: write.s, v: write.v };
+}
+function applyRegister(state, write) {
+  const entries = state.e;
+  const index = insertionIndex(entries, write.s);
+  if (index === -1) return { state, changed: false };
+  const first = entries[0];
+  if (index === 0 && first !== void 0 && !first.a) return { state, changed: false };
+  const entry = toEntry(write);
+  if (index === entries.length) {
+    if (!entry.a) return { state: { k: "reg", e: [entry], val: entry.v }, changed: true };
+    const last = entries[entries.length - 1];
+    const val = last !== void 0 && entryKind(last) === entry.a.type ? applyAtomicOp(state.val, entry.a) : entry.v;
+    return { state: { k: "reg", e: [...entries, entry], val }, changed: true };
+  }
+  const next = pruneChain([...entries.slice(0, index), entry, ...entries.slice(index)]);
+  return { state: { k: "reg", e: next, val: chainFold(next) }, changed: true };
+}
+function mergeLogs(a, b) {
+  const out = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length || j < b.length) {
+    const x = a[i];
+    const y = b[j];
+    if (y === void 0 || x !== void 0 && compareStamps(x.s, y.s) < 0) {
+      out.push(x);
+      i++;
+    } else if (x === void 0 || compareStamps(x.s, y.s) > 0) {
+      out.push(y);
+      j++;
+    } else {
+      out.push(x);
+      i++;
+      j++;
+    }
+  }
+  return out;
+}
+function resolveStep(plan, current, entry) {
+  try {
+    return { value: canonicalValue(plan.resolver?.(current, entry.v, entry.b), "resolver") };
+  } catch (error) {
+    return { value: entry.v, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function resolverFold(plan, entries) {
+  let value;
+  let error;
+  entries.forEach((entry, index) => {
+    if (index === 0) {
+      value = entry.v;
+      return;
+    }
+    const step = resolveStep(plan, value, entry);
+    value = step.value;
+    if (step.error !== void 0) error = step.error;
+  });
+  return error === void 0 ? { value } : { value, error };
+}
+function pruneResolverLog(entries) {
+  for (let i = entries.length - 1; i > 0; i--) {
+    if (entries[i].z === 1) return entries.slice(i);
+  }
+  return entries;
+}
+function resolverState(entries, result) {
+  return result.error === void 0 ? { k: "res", e: entries, val: result.value } : { k: "res", e: entries, val: result.value, err: result.error };
+}
+function applyResolver(state, write, plan) {
+  const index = insertionIndex(state.e, write.s);
+  if (index === -1) return { state, changed: false };
+  if (index === 0 && state.e[0]?.z === 1) return { state, changed: false };
+  const entry = { s: write.s, v: write.v };
+  if (write.insert) entry.b = null;
+  else if (write.hasPrev) entry.b = write.prev;
+  if (index === state.e.length) {
+    const entries2 = [...state.e, entry];
+    if (state.e.length === 0)
+      return { state: resolverState(entries2, { value: entry.v }), changed: true };
+    const step = resolveStep(plan, state.val, entry);
+    const next = step.error !== void 0 ? { k: "res", e: entries2, val: step.value, err: step.error } : state.err !== void 0 ? { k: "res", e: entries2, val: step.value, err: state.err } : { k: "res", e: entries2, val: step.value };
+    return {
+      state: next,
+      changed: true,
+      ...step.error !== void 0 ? { error: step.error } : {}
+    };
+  }
+  const entries = [...state.e.slice(0, index), entry, ...state.e.slice(index)];
+  const result = resolverFold(plan, entries);
+  return { state: resolverState(entries, result), changed: true };
+}
+function laterShape(current, next) {
+  return current === null || compareStamps(next.s, current.s) > 0 ? next : null;
+}
+function firstAddBefore(a, b) {
+  if (a === null) return true;
+  const cmp = compareStamps(b.s, a.s);
+  return cmp < 0 || cmp === 0 && b.i < a.i;
+}
+function elementKey(canonicalValue2, occurrence) {
+  return `${canonicalValue2}#${occurrence}`;
+}
+function elementWriter(base) {
+  let el = base;
+  let changed = false;
+  const read = (value, occurrence) => {
+    const canonical = canonicalKey(value);
+    const key = elementKey(canonical, occurrence);
+    const existing = el[key];
+    return [
+      key,
+      existing ? { ...existing } : { v: JSON.parse(canonical), n: occurrence, a: null, f: null, r: null }
+    ];
+  };
+  const store = (key, element) => {
+    if (el === base) el = { ...base };
+    el[key] = element;
+    changed = true;
+  };
+  return {
+    add(value, occurrence, stamp, index) {
+      const [key, element] = read(value, occurrence);
+      let touched = false;
+      if (isAfter(stamp, element.a)) {
+        element.a = stamp;
+        touched = true;
+      }
+      const first = { s: stamp, i: index };
+      if (firstAddBefore(element.f, first)) {
+        element.f = first;
+        touched = true;
+      }
+      if (touched) store(key, element);
+    },
+    remove(value, occurrence, stamp) {
+      const [key, element] = read(value, occurrence);
+      if (isAfter(stamp, element.r)) {
+        element.r = stamp;
+        store(key, element);
+      }
+    },
+    result: () => ({ el, changed })
+  };
+}
+function countOccurrences(items) {
+  const counts = /* @__PURE__ */ new Map();
+  const occurrences = items.map((item) => {
+    const canonical = canonicalKey(item);
+    const k = counts.get(canonical) ?? 0;
+    counts.set(canonical, k + 1);
+    return { item, canonical, k };
+  });
+  return { counts, occurrences };
+}
+function applyElementSet(state, write) {
+  const writer = elementWriter(state.el);
+  let sh = state.sh;
+  let clr = state.clr;
+  let changed = false;
+  const setShape = (arr, value) => {
+    const next = arr ? { s: write.s, arr } : { s: write.s, arr, v: value };
+    const later = laterShape(sh, next);
+    if (later) {
+      sh = later;
+      changed = true;
+    }
+  };
+  const atomic = write.a;
+  const prev = !write.insert && Array.isArray(write.prev) ? write.prev : null;
+  const atomicElement = atomic !== void 0 && (atomic.type === "append" || atomic.type === "remove");
+  if (atomicElement && (prev === null || !Array.isArray(write.v))) {
+    setShape(true);
+    if (atomic.type === "append") writer.add(atomic.value, 0, write.s, 0);
+    else if (!state.ao) writer.remove(atomic.value, 0, write.s);
+  } else if (!Array.isArray(write.v)) {
+    setShape(false, write.v);
+    const nextClr = maxStamp(clr, write.s);
+    if (nextClr !== clr) {
+      clr = nextClr;
+      changed = true;
+    }
+  } else {
+    setShape(true);
+    const next = countOccurrences(write.v);
+    const before = prev ? countOccurrences(prev) : null;
+    next.occurrences.forEach(({ item, canonical, k }, index) => {
+      if (k >= (before?.counts.get(canonical) ?? 0)) writer.add(item, k, write.s, index);
+    });
+    if (before && !state.ao) {
+      for (const { item, canonical, k } of before.occurrences) {
+        if (k >= (next.counts.get(canonical) ?? 0)) writer.remove(item, k, write.s);
+      }
+    }
+  }
+  const elements = writer.result();
+  if (!changed && !elements.changed) return { state, changed: false };
+  return { state: { k: "set", ao: state.ao, sh, clr, el: elements.el }, changed: true };
+}
+function isElementPresent(element, state) {
+  if (element.a === null || element.f === null) return false;
+  if (state.ao) return true;
+  return isAfter(element.a, element.r) && isAfter(element.a, state.clr);
+}
+function materializeElementSet(state) {
+  if (state.sh === null) return void 0;
+  if (!state.sh.arr) return state.sh.v;
+  const present = Object.entries(state.el).filter(([, element]) => isElementPresent(element, state));
+  present.sort(([ka, a], [kb, b]) => {
+    const fa = a.f;
+    const fb = b.f;
+    return compareStamps(fa.s, fb.s) || fa.i - fb.i || (ka < kb ? -1 : ka > kb ? 1 : 0);
+  });
+  return present.map(([, element]) => element.v);
+}
+function applyKeyMap(state, write) {
+  let sh = state.sh;
+  let clr = state.clr;
+  let keys = state.keys;
+  let changed = false;
+  const setKey = (key, next) => {
+    const current = keys[key];
+    if (current === void 0 || compareStamps(next.s, current.s) > 0) {
+      if (keys === state.keys) keys = { ...state.keys };
+      keys[key] = next;
+      changed = true;
+    }
+  };
+  if (!isPlainObject(write.v)) {
+    const later = laterShape(sh, { s: write.s, obj: false, v: write.v });
+    if (later) {
+      sh = later;
+      changed = true;
+    }
+    const nextClr = maxStamp(clr, write.s);
+    if (nextClr !== clr) {
+      clr = nextClr;
+      changed = true;
+    }
+  } else {
+    const later = laterShape(sh, { s: write.s, obj: true });
+    if (later) {
+      sh = later;
+      changed = true;
+    }
+    const prev = !write.insert && isPlainObject(write.prev) ? write.prev : null;
+    for (const [key, value] of Object.entries(write.v)) {
+      if (prev && key in prev && canonicalKey(prev[key]) === canonicalKey(value)) continue;
+      setKey(key, { s: write.s, del: false, v: value });
+    }
+    if (prev) {
+      for (const key of Object.keys(prev)) {
+        if (!(key in write.v)) setKey(key, { s: write.s, del: true });
+      }
+    }
+  }
+  if (!changed) return { state, changed: false };
+  return { state: { k: "map", sh, clr, keys }, changed: true };
+}
+function materializeKeyMap(state) {
+  if (state.sh === null) return void 0;
+  if (!state.sh.obj) return state.sh.v;
+  const out = {};
+  for (const key of Object.keys(state.keys).sort()) {
+    const entry = state.keys[key];
+    if (entry.del || !isAfter(entry.s, state.clr)) continue;
+    out[key] = entry.v;
+  }
+  return out;
+}
+function counterDelta(write) {
+  if (write.a?.type === "increment" && typeof write.a.value === "number") return write.a.value;
+  if (!write.insert && !write.a && typeof write.v === "number" && typeof write.prev === "number") {
+    return write.v - write.prev;
+  }
+  return null;
+}
+function deltaIndex(deltas, stamp) {
+  let lo = 0;
+  let hi = deltas.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    const cmp = compareStamps(deltas[mid].s, stamp);
+    if (cmp === 0) return -1;
+    if (cmp < 0) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+function counterValue(base, deltas) {
+  if (deltas.length === 0) return base?.v;
+  let sum = typeof base?.v === "number" ? base.v : 0;
+  for (const delta of deltas) sum += delta.n;
+  return sum;
+}
+function counterState(base, d) {
+  return { k: "ctr", base, d, val: counterValue(base, d) };
+}
+function pruneDeltas(d, base) {
+  if (base === null) return [...d];
+  return d.filter((delta) => compareStamps(delta.s, base.s) > 0);
+}
+function applyCounter(state, write) {
+  const n = counterDelta(write);
+  if (n !== null) {
+    if (state.base !== null && compareStamps(write.s, state.base.s) < 0) {
+      return { state, changed: false };
+    }
+    const index = deltaIndex(state.d, write.s);
+    if (index === -1) return { state, changed: false };
+    const delta = { s: write.s, n };
+    if (index === state.d.length) {
+      const val = state.d.length === 0 ? counterValue(state.base, [delta]) : state.val + n;
+      return { state: { k: "ctr", base: state.base, d: [...state.d, delta], val }, changed: true };
+    }
+    const d = [...state.d.slice(0, index), delta, ...state.d.slice(index)];
+    return { state: counterState(state.base, d), changed: true };
+  }
+  if (state.base !== null && compareStamps(write.s, state.base.s) <= 0) {
+    return { state, changed: false };
+  }
+  const base = { s: write.s, v: write.v };
+  return { state: counterState(base, pruneDeltas(state.d, base)), changed: true };
+}
+function mergeDeltas(a, b) {
+  const out = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length || j < b.length) {
+    const x = a[i];
+    const y = b[j];
+    if (y === void 0 || x !== void 0 && compareStamps(x.s, y.s) < 0) {
+      out.push(x);
+      i++;
+    } else if (x === void 0 || compareStamps(x.s, y.s) > 0) {
+      out.push(y);
+      j++;
+    } else {
+      out.push(x);
+      i++;
+      j++;
+    }
+  }
+  return out;
+}
+function betterExtremum(kind, current, next) {
+  if (current === null) return true;
+  if (next.v !== current.v) return kind === "max" ? next.v > current.v : next.v < current.v;
+  return compareStamps(next.s, current.s) > 0;
+}
+function applyExtremum(state, write) {
+  if (typeof write.v === "number" && !Number.isNaN(write.v)) {
+    const next = { s: write.s, v: write.v };
+    if (!betterExtremum(state.k, state.best, next)) return { state, changed: false };
+    return { state: { k: state.k, best: next, reg: state.reg }, changed: true };
+  }
+  if (state.reg !== null && compareStamps(write.s, state.reg.s) <= 0) {
+    return { state, changed: false };
+  }
+  return { state: { k: state.k, best: state.best, reg: { s: write.s, v: write.v } }, changed: true };
+}
+function decodeRichtext(value) {
+  if (value === null || value === void 0) return { reset: null };
+  try {
+    const decoded = decodeBytesFromOpData(value);
+    if (typeof decoded === "string") return { reset: decoded };
+    return { update: bytesToBase64(decoded) };
+  } catch {
+    return { reset: value };
+  }
+}
+function applyRichtext(state, write, subsumes) {
+  const decoded = decodeRichtext(write.v);
+  if ("reset" in decoded) {
+    if (state.reset !== null && compareStamps(write.s, state.reset.s) <= 0) {
+      return { state, changed: false };
+    }
+    return {
+      state: { k: "rt", reset: { s: write.s, v: decoded.reset }, u: state.u },
+      changed: true
+    };
+  }
+  const current = state.u[decoded.update];
+  if (current !== void 0 && compareStamps(write.s, current) <= 0) {
+    return { state, changed: false };
+  }
+  if (subsumes === void 0) {
+    return {
+      state: { k: "rt", reset: state.reset, u: { ...state.u, [decoded.update]: write.s } },
+      changed: true
+    };
+  }
+  const incoming = base64ToBytes(decoded.update);
+  const u = {};
+  for (const [update, stamp] of Object.entries(state.u)) {
+    if (update === decoded.update) continue;
+    const bytes = base64ToBytes(update);
+    if (compareStamps(write.s, stamp) <= 0 && subsumes(incoming, bytes)) {
+      return { state, changed: false };
+    }
+    if (compareStamps(stamp, write.s) <= 0 && subsumes(bytes, incoming)) continue;
+    u[update] = stamp;
+  }
+  u[decoded.update] = write.s;
+  return { state: { k: "rt", reset: state.reset, u }, changed: true };
+}
+function materializeRichtext(state, merger, field) {
+  const live = Object.entries(state.u).filter(([, stamp]) => isAfter(stamp, state.reset?.s ?? null)).map(([update]) => update).sort();
+  if (live.length === 0) return state.reset ? state.reset.v : void 0;
+  if (live.length === 1) return { $koraBytes: live[0] };
+  if (!merger) {
+    throw new FoldConfigurationError(
+      `Richtext field "${field}" has ${live.length} concurrent Yjs updates and no richtext merger was given.`,
+      {
+        field,
+        updates: live.length,
+        fix: "Pass { richtext: mergeYjsUpdates } (from @korajs/store) in the fold options."
+      }
+    );
+  }
+  return { $koraBytes: bytesToBase64(merger(live.map((update) => base64ToBytes(update)))) };
+}
+function applyFieldWrite(state, write, plan, subsumes) {
+  switch (state.k) {
+    case "reg":
+      return applyRegister(state, write);
+    case "res":
+      return applyResolver(state, write, plan);
+    case "set":
+      return applyElementSet(state, write);
+    case "map":
+      return applyKeyMap(state, write);
+    case "ctr":
+      return applyCounter(state, write);
+    case "max":
+    case "min":
+      return applyExtremum(state, write);
+    case "rt":
+      return applyRichtext(state, write, subsumes);
+  }
+}
+function materializeField(state, field, merger) {
+  switch (state.k) {
+    case "reg":
+    case "res":
+      return state.e.length === 0 ? void 0 : state.val;
+    case "set":
+      return materializeElementSet(state);
+    case "map":
+      return materializeKeyMap(state);
+    case "ctr":
+      return state.val;
+    case "max":
+    case "min":
+      return state.best !== null ? state.best.v : state.reg?.v;
+    case "rt":
+      return materializeRichtext(state, merger, field);
+  }
+}
+function fieldStamp(state) {
+  switch (state.k) {
+    case "reg":
+    case "res":
+      return state.e[state.e.length - 1]?.s ?? null;
+    case "set": {
+      let newest = maxStamp(state.sh?.s ?? null, state.clr);
+      for (const element of Object.values(state.el)) {
+        newest = maxStamp(maxStamp(newest, element.a), element.r);
+      }
+      return newest;
+    }
+    case "map": {
+      let newest = maxStamp(state.sh?.s ?? null, state.clr);
+      for (const entry of Object.values(state.keys)) newest = maxStamp(newest, entry.s);
+      return newest;
+    }
+    case "ctr": {
+      return maxStamp(state.base?.s ?? null, state.d[state.d.length - 1]?.s ?? null);
+    }
+    case "max":
+    case "min":
+      return maxStamp(state.best?.s ?? null, state.reg?.s ?? null);
+    case "rt": {
+      let newest = state.reset?.s ?? null;
+      for (const stamp of Object.values(state.u)) newest = maxStamp(newest, stamp);
+      return newest;
+    }
+  }
+}
+function laterOf(a, b) {
+  if (a === null) return b;
+  if (b === null) return a;
+  return compareStamps(a.s, b.s) >= 0 ? a : b;
+}
+function joinElements(a, b) {
+  const out = { ...a };
+  for (const [key, y] of Object.entries(b)) {
+    const x = out[key];
+    if (x === void 0) {
+      out[key] = y;
+      continue;
+    }
+    out[key] = {
+      v: x.v,
+      n: x.n,
+      a: maxStamp(x.a, y.a),
+      f: y.f !== null && firstAddBefore(x.f, y.f) ? y.f : x.f,
+      r: maxStamp(x.r, y.r)
+    };
+  }
+  return out;
+}
+function joinFieldStates(a, b, plan) {
+  if (a.k !== b.k) return a;
+  switch (a.k) {
+    case "reg": {
+      const entries = pruneChain(mergeLogs(a.e, b.e));
+      return { k: "reg", e: entries, val: chainFold(entries) };
+    }
+    case "res": {
+      const entries = pruneResolverLog(mergeLogs(a.e, b.e));
+      return resolverState(entries, resolverFold(plan, entries));
+    }
+    case "set": {
+      const other = b;
+      return {
+        k: "set",
+        ao: a.ao,
+        sh: laterOf(a.sh, other.sh),
+        clr: maxStamp(a.clr, other.clr),
+        el: joinElements(a.el, other.el)
+      };
+    }
+    case "map": {
+      const other = b;
+      const keys = { ...a.keys };
+      for (const [key, entry] of Object.entries(other.keys)) {
+        const current = keys[key];
+        if (current === void 0 || compareStamps(entry.s, current.s) > 0) keys[key] = entry;
+      }
+      return { k: "map", sh: laterOf(a.sh, other.sh), clr: maxStamp(a.clr, other.clr), keys };
+    }
+    case "ctr": {
+      const other = b;
+      const base = laterOf(a.base, other.base);
+      return counterState(base, pruneDeltas(mergeDeltas(a.d, other.d), base));
+    }
+    case "max":
+    case "min": {
+      const other = b;
+      let best = a.best;
+      if (other.best !== null && betterExtremum(a.k, best, other.best)) best = other.best;
+      return { k: a.k, best, reg: laterOf(a.reg, other.reg) };
+    }
+    case "rt": {
+      const other = b;
+      const u = { ...a.u };
+      for (const [update, stamp] of Object.entries(other.u)) {
+        u[update] = maxStamp(u[update] ?? null, stamp);
+      }
+      return { k: "rt", reset: laterOf(a.reset, other.reset), u };
+    }
+  }
+}
+
+// src/fold/types.ts
+var FOLD_STATE_VERSION = 2;
+
+// src/fold/serialize.ts
+var FIELD_KINDS = /* @__PURE__ */ new Set(["reg", "set", "map", "ctr", "max", "min", "res", "rt"]);
+function serializeFoldState(state) {
+  return canonicalize(state);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deserializeFoldState(json) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (error) {
+    throw new FoldStateError("Stored fold state is not valid JSON.", {
+      reason: error instanceof Error ? error.message : String(error)
+    });
+  }
+  if (!isRecord(parsed)) throw new FoldStateError("Stored fold state is not an object.");
+  if (parsed.v !== FOLD_STATE_VERSION) {
+    throw new FoldStateError(
+      `Stored fold state has format version ${String(parsed.v)}; this build reads version ${FOLD_STATE_VERSION}.`,
+      { found: parsed.v, expected: FOLD_STATE_VERSION }
+    );
+  }
+  if (typeof parsed.c !== "string" || typeof parsed.r !== "string" || !isRecord(parsed.f)) {
+    throw new FoldStateError("Stored fold state is missing its collection, record id or fields.");
+  }
+  for (const [field, state2] of Object.entries(parsed.f)) {
+    if (!isRecord(state2) || typeof state2.k !== "string" || !FIELD_KINDS.has(state2.k)) {
+      throw new FoldStateError(`Stored fold state has an unknown kind for field "${field}".`, {
+        field
+      });
+    }
+  }
+  const state = parsed;
+  for (const fieldState of Object.values(state.f)) {
+    if ((fieldState.k === "reg" || fieldState.k === "res") && fieldState.e.length === 0) {
+      fieldState.val = void 0;
+    }
+    if (fieldState.k === "ctr" && fieldState.d.length === 0 && fieldState.base === null) {
+      fieldState.val = void 0;
+    }
+  }
+  return state;
+}
+
+// src/fold/fold.ts
+var FOLD_RECORD_TRACE_FIELD = "*";
+var SECRET_REDACTED = "[secret]";
+function createFoldState(collection, recordId) {
+  return {
+    v: FOLD_STATE_VERSION,
+    c: collection,
+    r: recordId,
+    cr: null,
+    w: null,
+    d: null,
+    u: null,
+    f: {}
+  };
+}
+function isExcluded(op2, exclude) {
+  if (exclude === void 0) return false;
+  return typeof exclude === "function" ? exclude(op2) : exclude.has(op2.id);
+}
+function samePlanKind(state, plan) {
+  if (state.k !== plan.kind) return false;
+  return state.k !== "set" || state.ao === plan.appendOnly;
+}
+function fieldPlanFor(collection, field, existing, state) {
+  const plan = planField(collection, field);
+  if (existing !== void 0 && !samePlanKind(existing, plan)) {
+    throw new FoldStateError(
+      `Field "${field}" of ${state.c}/${state.r} is stored as fold kind "${existing.k}" but the schema now folds it as "${plan.kind}".`,
+      { collection: state.c, recordId: state.r, field, stored: existing.k, expected: plan.kind }
+    );
+  }
+  return plan;
+}
+function fieldWriteStamp(op2, field, opStamp) {
+  if (op2.type !== "insert" || op2.fieldVersions === void 0) return opStamp;
+  const version = op2.fieldVersions[field];
+  if (version !== void 0) return stampOf(version, op2.id);
+  let oldest = opStamp;
+  for (const candidate of Object.values(op2.fieldVersions)) {
+    const stamp = stampOf(candidate, op2.id);
+    if (compareStamps(stamp, oldest) < 0) oldest = stamp;
+  }
+  return oldest;
+}
+function classify(stamp, op2, field, plan, options) {
+  if (!plan.authoritative) return stamp;
+  const author = op2.type === "insert" ? op2.fieldVersions?.[field]?.nodeId ?? op2.nodeId : op2.nodeId;
+  if (isAuthoritativeNodeId(author, options.authoritativeNodeIds)) {
+    return { ...stamp, c: 1 };
+  }
+  return stamp;
+}
+function mergeCarriedState(state, op2, schema, options) {
+  let carried;
+  try {
+    carried = deserializeFoldState(op2.foldState);
+  } catch (error) {
+    if (error instanceof FoldStateError) return null;
+    throw error;
+  }
+  if (carried.c !== state.c || carried.r !== state.r) {
+    throw new FoldStateError(
+      `Operation ${op2.id} carries the fold state of ${carried.c}/${carried.r} but targets ${state.c}/${state.r}.`,
+      { operationId: op2.id, collection: op2.collection, recordId: op2.recordId }
+    );
+  }
+  let joined;
+  try {
+    joined = joinStates(state, carried, schema);
+  } catch (error) {
+    if (error instanceof FoldStateError) return null;
+    throw error;
+  }
+  const changed = serializeFoldState(joined) !== serializeFoldState(state);
+  const traces = [];
+  if ((options.traces ?? "conflicts") !== "none") {
+    const collection = schema.collections[state.c];
+    for (const [field, incomingState] of Object.entries(carried.f)) {
+      const mine = state.f[field];
+      if (mine === void 0) continue;
+      const prior = safeMaterializeField(mine, field, options);
+      const incoming = safeMaterializeField(incomingState, field, options);
+      if (canonicalKey(prior) === canonicalKey(incoming)) continue;
+      const plan = planField(collection, field);
+      const output = safeMaterializeField(joined.f[field], field, options);
+      const redact = (value) => plan.secret ? SECRET_REDACTED : value;
+      traces.push({
+        field,
+        strategy: `scope-entry-${plan.strategy}`,
+        inputA: redact(prior),
+        inputB: redact(incoming),
+        base: null,
+        output: redact(output),
+        tier: plan.tier,
+        constraintViolated: null,
+        duration: 0,
+        operation: plan.secret ? redactOperation(op2, field) : op2,
+        priorOperationId: fieldStamp(mine)?.o ?? null,
+        conflict: true
+      });
+    }
+  }
+  return { state: changed ? joined : state, traces, changed };
+}
+function buildWrite(op2, field, raw, stamp) {
+  if (raw === void 0) return null;
+  const insert = op2.type === "insert";
+  const v = normalizeValue(raw);
+  const atomic = op2.atomicOps?.[field];
+  const a = atomic ? { type: atomic.type, value: normalizeValue(atomic.value) } : void 0;
+  const prevRaw = insert ? void 0 : op2.previousData?.[field];
+  const hasPrev = !insert && op2.previousData !== null && field in op2.previousData && prevRaw !== void 0;
+  const prev = hasPrev ? normalizeValue(prevRaw) : void 0;
+  if (!insert && a === void 0 && hasPrev && canonicalKey(prev) === canonicalKey(v)) return null;
+  return a ? { s: stamp, insert, v, prev, hasPrev, a } : { s: stamp, insert, v, prev, hasPrev };
+}
+function safeMaterializeField(state, field, options) {
+  if (state === void 0) return void 0;
+  try {
+    return materializeField(state, field, options.richtext);
+  } catch (error) {
+    if (error instanceof FoldConfigurationError) return void 0;
+    throw error;
+  }
+}
+function redactOperation(op2, field) {
+  const redact = (data) => data !== null && field in data ? { ...data, [field]: SECRET_REDACTED } : data;
+  return { ...op2, data: redact(op2.data), previousData: redact(op2.previousData) };
+}
+function fieldTrace(op2, field, plan, write, prior, priorStamp, output, newest, error) {
+  const lost = newest !== null && compareStamps(newest, write.s) > 0;
+  const baseMismatch = prior !== void 0 && !write.insert && canonicalKey(prior) !== canonicalKey(write.prev);
+  const insertOnto = write.insert && prior !== void 0;
+  const strategy = plan.kind === "reg" && write.a ? `atomic-${write.a.type}` : plan.strategy;
+  const trace = {
+    field,
+    strategy,
+    inputA: plan.secret ? SECRET_REDACTED : prior,
+    inputB: plan.secret ? SECRET_REDACTED : write.v,
+    base: write.hasPrev ? plan.secret ? SECRET_REDACTED : write.prev : null,
+    output: plan.secret ? SECRET_REDACTED : output,
+    tier: plan.tier,
+    constraintViolated: null,
+    // The fold is pure: callers time the whole mergeOp if they need a duration.
+    duration: 0,
+    operation: plan.secret ? redactOperation(op2, field) : op2,
+    priorOperationId: priorStamp?.o ?? null,
+    conflict: lost || baseMismatch || insertOnto
+  };
+  if (error !== void 0) trace.error = error;
+  return trace;
+}
+function isAlive(state) {
+  return state.cr !== null && isAfter(state.w, state.d);
+}
+function mergeOp(state, input, schema, options = {}) {
+  if (isExcluded(input, options.exclude)) return { state, traces: [], changed: false };
+  const op2 = operationSchemaView(input, schema.version, options.transforms);
+  if (op2 === null) return { state, traces: [], changed: false };
+  if (op2.collection !== state.c || op2.recordId !== state.r) {
+    throw new FoldStateError(
+      `Operation ${op2.id} targets ${op2.collection}/${op2.recordId} but the fold state is for ${state.c}/${state.r}.`,
+      { operationId: op2.id, collection: op2.collection, recordId: op2.recordId }
+    );
+  }
+  if (op2.foldState !== void 0 && op2.type === "insert") {
+    const carried = mergeCarriedState(state, op2, schema, options);
+    if (carried !== null) return carried;
+  }
+  const mode = options.traces ?? "conflicts";
+  const traces = [];
+  const stamp = stampOf(op2.timestamp, op2.id);
+  const next = { ...state };
+  let changed = false;
+  const setRecordStamp = (key, value) => {
+    if (value !== next[key]) {
+      next[key] = value;
+      changed = true;
+    }
+  };
+  setRecordStamp("u", maxStamp(state.u, stamp));
+  if (op2.type === "delete") {
+    setRecordStamp("d", maxStamp(state.d, stamp));
+    if (mode !== "none" && state.cr !== null && isAfter(state.w, stamp)) {
+      traces.push(recordTrace(op2, true, true));
+    }
+    return { state: changed ? next : state, traces, changed };
+  }
+  if (op2.data === null) {
+    if (op2.encrypted !== void 0) {
+      if (op2.type === "insert") setRecordStamp("cr", minStamp(state.cr, stamp));
+      setRecordStamp("w", maxStamp(state.w, stamp));
+    }
+    return { state: changed ? next : state, traces, changed };
+  }
+  if (op2.type === "insert") setRecordStamp("cr", minStamp(state.cr, stamp));
+  setRecordStamp("w", maxStamp(state.w, stamp));
+  if (mode !== "none" && isAfter(state.d, stamp)) traces.push(recordTrace(op2, false, false));
+  const collection = schema.collections[op2.collection];
+  let fields = state.f;
+  for (const [field, raw] of Object.entries(op2.data)) {
+    if (raw === void 0) continue;
+    const existing = fields[field];
+    const plan = fieldPlanFor(collection, field, existing, state);
+    const write = buildWrite(
+      op2,
+      field,
+      raw,
+      classify(fieldWriteStamp(op2, field, stamp), op2, field, plan, options)
+    );
+    if (write === null) continue;
+    const tracing = mode !== "none";
+    const prior = tracing ? safeMaterializeField(existing, field, options) : void 0;
+    const priorStamp = existing ? fieldStamp(existing) : null;
+    const result = applyFieldWrite(
+      existing ?? emptyField(plan),
+      write,
+      plan,
+      options.richtextSubsumes
+    );
+    if (result.changed) {
+      if (fields === state.f) fields = { ...state.f };
+      fields[field] = result.state;
+      changed = true;
+    }
+    if (tracing) {
+      const trace = fieldTrace(
+        op2,
+        field,
+        plan,
+        write,
+        prior,
+        priorStamp,
+        safeMaterializeField(result.state, field, options),
+        fieldStamp(result.state),
+        result.error
+      );
+      if (mode === "all" || trace.conflict || trace.error !== void 0) traces.push(trace);
+    }
+  }
+  next.f = fields;
+  return { state: changed ? next : state, traces, changed };
+}
+function recordTrace(op2, isDelete, lost) {
+  return {
+    field: FOLD_RECORD_TRACE_FIELD,
+    strategy: "delete-tombstone-lww",
+    inputA: isDelete ? "live" : "deleted",
+    inputB: isDelete ? "deleted" : "live",
+    base: null,
+    // A delete that lost keeps the record live; a write older than the newest
+    // delete stays hidden.
+    output: isDelete ? lost ? "live" : "deleted" : "deleted",
+    tier: 1,
+    constraintViolated: null,
+    duration: 0,
+    operation: op2,
+    priorOperationId: null,
+    conflict: true
+  };
+}
+function foldRecord(ops, schema, options = {}) {
+  const kept = ops.filter((op2) => !isExcluded(op2, options.exclude));
+  const first = kept[0];
+  if (first === void 0) return { state: null, traces: [] };
+  const ordered = kept.map((op2) => ({ op: op2, stamp: stampOf(op2.timestamp, op2.id) })).sort((a, b) => compareStamps(a.stamp, b.stamp));
+  let state = createFoldState(first.collection, first.recordId);
+  const traces = [];
+  const mergeOptions = {
+    ...options,
+    exclude: void 0,
+    traces: options.traces ?? "none"
+  };
+  for (const { op: op2 } of ordered) {
+    const result = mergeOp(state, op2, schema, mergeOptions);
+    state = result.state;
+    traces.push(...result.traces);
+  }
+  return { state, traces };
+}
+function materialize(state, options = {}) {
+  if (!isAlive(state)) return null;
+  const record = {};
+  for (const field of Object.keys(state.f).sort()) {
+    const value = materializeField(state.f[field], field, options.richtext);
+    if (value !== void 0) record[field] = value;
+  }
+  return record;
+}
+function isFoldStateLive(state) {
+  return isAlive(state);
+}
+function joinStates(a, b, schema) {
+  if (a.c !== b.c || a.r !== b.r) {
+    throw new FoldStateError(`Cannot join fold states of ${a.c}/${a.r} and ${b.c}/${b.r}.`, {
+      left: `${a.c}/${a.r}`,
+      right: `${b.c}/${b.r}`
+    });
+  }
+  const collection = schema.collections[a.c];
+  const fields = { ...a.f };
+  for (const [field, other] of Object.entries(b.f)) {
+    const mine = fields[field];
+    if (mine === void 0) {
+      fieldPlanFor(collection, field, other, b);
+      fields[field] = other;
+      continue;
+    }
+    const plan = fieldPlanFor(collection, field, mine, a);
+    fieldPlanFor(collection, field, other, b);
+    fields[field] = joinFieldStates(mine, other, plan);
+  }
+  return {
+    v: FOLD_STATE_VERSION,
+    c: a.c,
+    r: a.r,
+    cr: minStamp(a.cr, b.cr),
+    w: maxStamp(a.w, b.w),
+    d: maxStamp(a.d, b.d),
+    u: maxStamp(a.u, b.u),
+    f: fields
+  };
+}
+function getFoldFieldVersionStrings(state) {
+  const out = {};
+  for (const field of Object.keys(state.f).sort()) {
+    const stamp = fieldStamp(state.f[field]);
+    if (stamp !== null) out[field] = stamp.t;
+  }
+  return out;
+}
+function getFoldFieldVersions(state) {
+  if (!isAlive(state) || state.cr === null || state.u === null) return null;
+  const fields = {};
+  for (const [field, fieldState] of Object.entries(state.f)) {
+    const stamp = fieldStamp(fieldState);
+    if (stamp !== null) fields[field] = stampTimestamp(stamp);
+  }
+  return { fields, created: stampTimestamp(state.cr), latest: stampTimestamp(state.u) };
+}
+
+// src/fold/plan.ts
+function hashText2(text) {
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function collectionFoldPlanFingerprint(name, collection) {
+  const fields = Object.keys(collection.fields).sort().map((field) => {
+    const descriptor = collection.fields[field];
+    const resolver = collection.resolvers?.[field];
+    return `${field}:${descriptor?.kind ?? ""}:${descriptor?.mergeStrategy ?? ""}:${resolver ? hashText2(String(resolver)) : ""}`;
+  });
+  const resolverOnly = Object.keys(collection.resolvers ?? {}).filter((field) => !(field in collection.fields)).sort().map((field) => `${field}:resolver:${hashText2(String(collection.resolvers?.[field]))}`);
+  return `${name}(${[...fields, ...resolverOnly].join(",")})`;
+}
+function foldPlanFingerprint(schema, transforms) {
+  const parts = [`fold-v${FOLD_STATE_VERSION}`];
+  for (const name of Object.keys(schema.collections).sort()) {
+    const collection = schema.collections[name];
+    if (!collection) continue;
+    parts.push(collectionFoldPlanFingerprint(name, collection));
+  }
+  const xf = operationTransformsFingerprint(schema.version, transforms);
+  if (xf !== "") parts.push(xf);
+  return parts.join("|");
+}
+function foldPlanFingerprints(schema, transforms) {
+  const out = {};
+  const xf = operationTransformsFingerprint(schema.version, transforms);
+  for (const name of Object.keys(schema.collections).sort()) {
+    const collection = schema.collections[name];
+    if (!collection) continue;
+    out[name] = `fold-v${FOLD_STATE_VERSION}|${collectionFoldPlanFingerprint(name, collection)}${xf !== "" ? `|${xf}` : ""}`;
+  }
+  return out;
+}
+function fieldStateMatchesPlan(collection, field, state) {
+  const plan = planField(collection, field);
+  if (state.k !== plan.kind) return false;
+  return state.k !== "set" || state.ao === plan.appendOnly;
+}
+function mismatchedFoldFields(state, schema) {
+  const collection = schema.collections[state.c];
+  return Object.keys(state.f).filter((field) => !fieldStateMatchesPlan(collection, field, state.f[field])).sort();
+}
+
+// src/fold/snapshot.ts
+var SNAPSHOT_CLEAR_ID = "\uFFFFkora-snapshot:0";
+var SNAPSHOT_WRITE_ID = "\uFFFFkora-snapshot:1";
+function snapshotField(plan, raw, clear, write) {
+  const v = normalizeValue(raw);
+  switch (plan.kind) {
+    case "reg":
+      return { k: "reg", e: [{ s: write, v }], val: v };
+    case "res":
+      return { k: "res", e: [{ s: write, v, z: 1 }], val: v };
+    case "ctr":
+      return { k: "ctr", base: { s: write, v }, d: [], val: v };
+    case "max":
+    case "min":
+      return typeof v === "number" && !Number.isNaN(v) ? { k: plan.kind, best: { s: write, v }, reg: null } : { k: plan.kind, best: null, reg: { s: write, v } };
+    case "set": {
+      if (!Array.isArray(v)) {
+        return {
+          k: "set",
+          ao: plan.appendOnly,
+          sh: { s: write, arr: false, v },
+          clr: write,
+          el: {}
+        };
+      }
+      const el = {};
+      const counts = /* @__PURE__ */ new Map();
+      v.forEach((item, index) => {
+        const canonical = canonicalKey(item);
+        const n = counts.get(canonical) ?? 0;
+        counts.set(canonical, n + 1);
+        el[elementKey(canonical, n)] = {
+          v: JSON.parse(canonical),
+          n,
+          a: write,
+          f: { s: write, i: index },
+          r: null
+        };
+      });
+      return { k: "set", ao: plan.appendOnly, sh: { s: write, arr: true }, clr: clear, el };
+    }
+    case "map": {
+      if (!isPlainObject(v)) {
+        return { k: "map", sh: { s: write, obj: false, v }, clr: write, keys: {} };
+      }
+      const keys = {};
+      for (const [key, member] of Object.entries(v)) keys[key] = { s: write, del: false, v: member };
+      return { k: "map", sh: { s: write, obj: true }, clr: clear, keys };
+    }
+    case "rt": {
+      if (v === null || typeof v === "string" || !isPlainObject(v) || !("$koraBytes" in v)) {
+        return { k: "rt", reset: { s: write, v }, u: {} };
+      }
+      const update = String(v.$koraBytes);
+      return { k: "rt", reset: { s: clear, v: null }, u: { [update]: write } };
+    }
+  }
+}
+function createSnapshotState(input, schema, options = {}) {
+  const state = createFoldState(input.collection, input.recordId);
+  const collection = schema.collections[input.collection];
+  const seed = options.seed && options.seed.c === input.collection && options.seed.r === input.recordId ? options.seed : null;
+  const fields = {};
+  for (const [field, raw] of Object.entries(input.values)) {
+    if (raw === void 0) continue;
+    const seeded = seed?.f[field];
+    if (seeded !== void 0 && fieldStateMatchesPlan(collection, field, seeded)) {
+      fields[field] = seeded;
+      continue;
+    }
+    const version = input.fieldVersions[field] ?? input.latest;
+    const plan = planField(collection, field);
+    const authoritative = plan.authoritative === true && isAuthoritativeNodeId(version.nodeId, options.authoritativeNodeIds);
+    fields[field] = snapshotField(
+      plan,
+      raw,
+      classed(stampOf(version, SNAPSHOT_CLEAR_ID), authoritative),
+      classed(stampOf(version, SNAPSHOT_WRITE_ID), authoritative)
+    );
+  }
+  if (seed !== null && seed.cr !== null && seed.u !== null) {
+    return { ...state, cr: seed.cr, w: seed.w, d: seed.d, u: seed.u, f: fields };
+  }
+  const latestClear = stampOf(input.latest, SNAPSHOT_CLEAR_ID);
+  const latestWrite = stampOf(input.latest, SNAPSHOT_WRITE_ID);
+  return {
+    ...state,
+    cr: stampOf(input.created, SNAPSHOT_WRITE_ID),
+    w: input.deleted ? latestClear : latestWrite,
+    d: input.deleted ? latestWrite : null,
+    u: latestWrite,
+    f: fields
+  };
+}
+function classed(stamp, authoritative) {
+  return authoritative ? { ...stamp, c: 1 } : stamp;
+}
+function adaptFoldState(state, schema, options = {}) {
+  const mismatched = mismatchedFoldFields(state, schema);
+  if (mismatched.length === 0) return { state, adapted: [] };
+  const collection = schema.collections[state.c];
+  const fields = { ...state.f };
+  for (const field of mismatched) {
+    const old = fields[field];
+    delete fields[field];
+    const stamp = fieldStamp(old);
+    if (stamp === null) continue;
+    let value;
+    try {
+      value = materializeField(old, field, options.richtext);
+    } catch (error) {
+      if (error instanceof FoldConfigurationError) continue;
+      throw error;
+    }
+    if (value === void 0) continue;
+    const plan = planField(collection, field);
+    const authoritative = stamp.c === 1 && plan.authoritative === true;
+    fields[field] = snapshotField(
+      plan,
+      value,
+      classed({ t: stamp.t, o: SNAPSHOT_CLEAR_ID }, authoritative),
+      classed({ t: stamp.t, o: SNAPSHOT_WRITE_ID }, authoritative)
+    );
+  }
+  return { state: { ...state, f: fields }, adapted: mismatched };
 }
 
-// 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";
+// src/fold/trace.ts
+function toMergeTrace(trace, operationA) {
+  return {
+    operationA: operationA ?? trace.operation,
+    operationB: trace.operation,
+    field: trace.field,
+    strategy: trace.strategy,
+    inputA: trace.inputA,
+    inputB: trace.inputB,
+    base: trace.base,
+    output: trace.output,
+    tier: trace.tier,
+    constraintViolated: trace.constraintViolated,
+    duration: trace.duration
+  };
 }
-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;
+
+// src/text/stored-text.ts
+var STORED_TEXT_ESCAPE = "\uFFFF";
+var NEEDS_ENCODING = /[\u0000￿\ud800-\udfff]/;
+function needsStoredTextEncoding(s) {
+  return NEEDS_ENCODING.test(s);
 }
-var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-var BASE64_REVERSE = new Map(
-  Array.from(BASE64_ALPHABET, (char, index) => [char, index])
-);
-function bytesToBase64(bytes) {
+function encodeStoredText(s) {
+  if (!NEEDS_ENCODING.test(s)) return s;
   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] ?? "" : "=";
+  for (let i = 0; i < s.length; i++) {
+    const code = s.charCodeAt(i);
+    if (code === 0) {
+      out += `${STORED_TEXT_ESCAPE}0`;
+    } else if (code === 65535) {
+      out += `${STORED_TEXT_ESCAPE}F`;
+    } else if (code >= 55296 && code <= 56319) {
+      const next = s.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        out += s.slice(i, i + 2);
+        i++;
+      } else {
+        out += `${STORED_TEXT_ESCAPE}s${code.toString(16)}`;
+      }
+    } else if (code >= 56320 && code <= 57343) {
+      out += `${STORED_TEXT_ESCAPE}s${code.toString(16)}`;
+    } else {
+      out += s.charAt(i);
+    }
   }
   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
-      });
+function decodeStoredText(s) {
+  if (!s.includes(STORED_TEXT_ESCAPE)) return s;
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    const char = s[i];
+    if (char !== STORED_TEXT_ESCAPE) {
+      out += char;
+      continue;
     }
-    buffer = buffer << 6 | value;
-    bits += 6;
-    if (bits >= 8) {
-      bits -= 8;
-      out[index] = buffer >> bits & 255;
-      index += 1;
+    const tag = s[i + 1];
+    if (tag === "0") {
+      out += "\0";
+      i += 1;
+    } else if (tag === "F") {
+      out += STORED_TEXT_ESCAPE;
+      i += 1;
+    } else if (tag === "s") {
+      const hex = s.slice(i + 2, i + 6);
+      const code = Number.parseInt(hex, 16);
+      if (hex.length === 4 && Number.isInteger(code) && code >= 55296 && code <= 57343) {
+        out += String.fromCharCode(code);
+        i += 5;
+      } else {
+        out += char;
+      }
+    } else {
+      out += char;
     }
   }
   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 encodeStoredJsonValue(value) {
+  return mapStrings(value, encodeStoredText);
 }
-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;
+function decodeStoredJsonValue(value) {
+  return mapStrings(value, decodeStoredText);
+}
+function mapStrings(value, map) {
+  if (typeof value === "string") return map(value);
+  if (Array.isArray(value)) return value.map((member) => mapStrings(member, map));
+  if (value !== null && typeof value === "object" && !ArrayBuffer.isView(value)) {
+    const out = {};
+    for (const [key, member] of Object.entries(value)) out[map(key)] = mapStrings(member, map);
+    return out;
+  }
+  return value;
+}
+
+// src/fold/side-effect-id.ts
+var SIDE_EFFECT_DOMAIN = "kora/side-effect/v1";
+async function deriveSideEffectOpId(parentOpId, ruleId, targetRecordId) {
+  for (const [name, value] of [
+    ["parentOpId", parentOpId],
+    ["ruleId", ruleId],
+    ["targetRecordId", targetRecordId]
+  ]) {
+    if (typeof value !== "string" || value.length === 0) {
+      throw new OperationError(`deriveSideEffectOpId: ${name} must be a non-empty string`, {
+        [name]: value
+      });
     }
-    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 }
+  const canonical = canonicalize({
+    domain: SIDE_EFFECT_DOMAIN,
+    parent: parentOpId,
+    rule: ruleId,
+    target: targetRecordId
+  });
+  const digest = await globalThis.crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(canonical)
   );
+  return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
 }
 
 // src/scopes/sync-scope-bindings.ts
@@ -884,6 +2412,21 @@ function buildCollection(name, input) {
     validateStateMachineDefinition(name, input.stateMachine, fields);
     stateMachine = { ...input.stateMachine };
   }
+  if (!stateMachine) {
+    const transitionFields = Object.entries(fields).filter(
+      ([, descriptor]) => descriptor.kind === "enum" && descriptor.transitions
+    );
+    const only = transitionFields.length === 1 ? transitionFields[0] : void 0;
+    if (only?.[1].transitions) {
+      const derived = {
+        field: only[0],
+        transitions: { ...only[1].transitions },
+        onInvalidTransition: "reject"
+      };
+      validateStateMachineDefinition(name, derived, fields);
+      stateMachine = derived;
+    }
+  }
   return { fields, indexes, constraints, resolvers, scope, stateMachine };
 }
 function buildSyncRules(syncInput, collections) {
@@ -1009,170 +2552,6 @@ function validateRelation(name, relation, collections) {
   }
 }
 
-// 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 idx_${collectionName}_${indexField} ON ${quoteIdent(collectionName)} (${quoteIdent(indexField)})`
-    );
-  }
-  for (const fkField of fkFields) {
-    if (!indexedFields.has(fkField)) {
-      statements.push(
-        `CREATE INDEX IF NOT EXISTS idx_${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 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(
-    "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.required && descriptor.defaultValue === void 0 && !descriptor.auto) {
-    parts.push("NOT NULL");
-  }
-  if (descriptor.defaultValue !== void 0) {
-    parts.push(`DEFAULT ${sqlDefault(descriptor.defaultValue)}`);
-  }
-  if (descriptor.kind === "enum" && descriptor.enumValues) {
-    const values = descriptor.enumValues.map((v) => `'${v}'`).join(", ");
-    parts.push(`CHECK (${quoteIdent(fieldName)} IN (${values}))`);
-  }
-  return parts.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";
-  }
-}
-function sqlDefault(value) {
-  if (value === null) return "NULL";
-  if (typeof value === "string") return `'${value}'`;
-  if (typeof value === "number") return String(value);
-  if (typeof value === "boolean") return value ? "1" : "0";
-  return `'${JSON.stringify(value)}'`;
-}
-
 // src/schema/types.ts
 var FieldBuilder = class _FieldBuilder {
   _kind;
@@ -1187,15 +2566,21 @@ var FieldBuilder = class _FieldBuilder {
     this._auto = auto;
     this._mergeStrategy = mergeStrategy;
   }
-  /** Mark this field as optional (not required on insert) */
+  /** Mark this field as optional (not required on insert; reads may return `null`). */
   optional() {
     return new _FieldBuilder(this._kind, false, this._defaultValue, this._auto, this._mergeStrategy);
   }
-  /** Set a default value for this field. Implicitly makes the field optional. */
+  /**
+   * Set a default value for this field. Implicitly makes the field optional on insert.
+   * The value must be of the field's type (`t.number().default('x')` is a type error).
+   */
   default(value) {
     return new _FieldBuilder(this._kind, false, value, this._auto, this._mergeStrategy);
   }
-  /** Mark this field as auto-populated (e.g., createdAt timestamps). Developers cannot set auto fields. */
+  /**
+   * Mark this field as auto-populated (e.g., createdAt timestamps). Developers cannot
+   * set auto fields; the framework fills `t.timestamp().auto()` with the insert time.
+   */
   auto() {
     return new _FieldBuilder(this._kind, false, void 0, true, this._mergeStrategy);
   }
@@ -1213,13 +2598,7 @@ var FieldBuilder = class _FieldBuilder {
    *   - `'server-authoritative'`: Always prefer the remote/server value
    */
   merge(strategy) {
-    return new _FieldBuilder(
-      this._kind,
-      this._required,
-      this._defaultValue,
-      this._auto,
-      strategy
-    );
+    return new _FieldBuilder(this._kind, this._required, this._defaultValue, this._auto, strategy);
   }
   /** @internal Build the final FieldDescriptor. Used by defineSchema(). */
   _build() {
@@ -1235,6 +2614,16 @@ var FieldBuilder = class _FieldBuilder {
     };
   }
 };
+function assertStorableEnumValues(values) {
+  for (const value of values) {
+    if (typeof value !== "string" || encodeStoredText(value) !== value) {
+      throw new SchemaValidationError(
+        `Enum value ${JSON.stringify(value)} cannot be stored: enum values must be well-formed strings without U+0000 or U+FFFF.`,
+        { value: String(value) }
+      );
+    }
+  }
+}
 var EnumFieldBuilder = class _EnumFieldBuilder extends FieldBuilder {
   _enumValues;
   _transitions;
@@ -1340,14 +2729,14 @@ var EnumFieldBuilder = class _EnumFieldBuilder extends FieldBuilder {
   }
 };
 var ArrayFieldBuilder = class _ArrayFieldBuilder extends FieldBuilder {
-  _itemKind;
+  _item;
   constructor(itemBuilder, required = true, defaultValue = void 0, auto = false, mergeStrategy = null) {
     super("array", required, defaultValue, auto, mergeStrategy);
-    this._itemKind = itemBuilder._build().kind;
+    this._item = itemBuilder;
   }
   optional() {
     return new _ArrayFieldBuilder(
-      new FieldBuilder(this._itemKind),
+      this._item,
       false,
       this._defaultValue,
       this._auto,
@@ -1355,26 +2744,14 @@ var ArrayFieldBuilder = class _ArrayFieldBuilder extends FieldBuilder {
     );
   }
   default(value) {
-    return new _ArrayFieldBuilder(
-      new FieldBuilder(this._itemKind),
-      false,
-      value,
-      this._auto,
-      this._mergeStrategy
-    );
+    return new _ArrayFieldBuilder(this._item, false, value, this._auto, this._mergeStrategy);
   }
   auto() {
-    return new _ArrayFieldBuilder(
-      new FieldBuilder(this._itemKind),
-      false,
-      void 0,
-      true,
-      this._mergeStrategy
-    );
+    return new _ArrayFieldBuilder(this._item, false, void 0, true, this._mergeStrategy);
   }
   merge(strategy) {
     return new _ArrayFieldBuilder(
-      new FieldBuilder(this._itemKind),
+      this._item,
       this._required,
       this._defaultValue,
       this._auto,
@@ -1388,7 +2765,7 @@ var ArrayFieldBuilder = class _ArrayFieldBuilder extends FieldBuilder {
       defaultValue: this._defaultValue,
       auto: this._auto,
       enumValues: null,
-      itemKind: this._itemKind,
+      itemKind: this._item._build().kind,
       mergeStrategy: this._mergeStrategy,
       transitions: null
     };
@@ -1522,6 +2899,9 @@ var SecretFieldBuilder = class _SecretFieldBuilder extends FieldBuilder {
       this._mergeStrategy
     );
   }
+  default(value) {
+    return new _SecretFieldBuilder(this._secretMode, false, value, this._auto, this._mergeStrategy);
+  }
   auto() {
     return new _SecretFieldBuilder(this._secretMode, false, void 0, true, this._mergeStrategy);
   }
@@ -1548,42 +2928,220 @@ var SecretFieldBuilder = class _SecretFieldBuilder extends FieldBuilder {
     };
   }
 };
+function scalar(kind) {
+  return new FieldBuilder(kind, true, void 0, false);
+}
 var t = {
+  /** A string field. */
   string() {
-    return new FieldBuilder("string", true, void 0, false);
+    return scalar("string");
   },
+  /** A finite-number field. */
   number() {
-    return new FieldBuilder("number", true, void 0, false);
+    return scalar("number");
   },
+  /** A boolean field. */
   boolean() {
-    return new FieldBuilder("boolean", true, void 0, false);
+    return scalar("boolean");
   },
+  /** A timestamp field: integer milliseconds since the epoch (not a `Date`). */
   timestamp() {
-    return new FieldBuilder("timestamp", true, void 0, false);
+    return scalar("timestamp");
   },
+  /** A collaborative rich-text field (Yjs). Reads return the Yjs update bytes. */
   richtext() {
-    return new FieldBuilder("richtext", true, void 0, false);
+    return scalar("richtext");
   },
+  /** An enum field whose value is one of `values`. */
   enum(values) {
+    assertStorableEnumValues(values);
     return new EnumFieldBuilder(values, true, void 0, false);
   },
+  /** An array field whose items have the type of `itemBuilder`. */
   array(itemBuilder) {
     return new ArrayFieldBuilder(itemBuilder, true, void 0, false);
   },
+  /** A structured object field whose keys are declared by nested builders. */
   object(fields) {
     return new ObjectFieldBuilder(fields, true, void 0, false);
   },
+  /** A dynamic JSON field typed as `T` (compile-time only; not validated against `T`). */
   json() {
     return new JsonFieldBuilder("json", true, void 0, false);
   },
+  /** A blob reference field (`BlobRef`); the bytes live in the blob store. */
   blob() {
-    return new FieldBuilder("blob", true, void 0, false);
+    return scalar("blob");
   },
+  /** A secret field (password, token): redacted from traces, hashed or encrypted at rest. */
   secret() {
     return new SecretFieldBuilder("encrypted", true, void 0, false);
   }
 };
 
+// src/schema/value-domain.ts
+var TIMESTAMP_MIN_MS = -864e13;
+var TIMESTAMP_MAX_MS = 864e13;
+var MAX_VALUE_DEPTH = 64;
+var DEFAULT_MAX_OPERATION_BYTES = 256 * 1024;
+function timestampDomainViolation(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return `must be a timestamp (integer milliseconds), got ${describe(value)}`;
+  }
+  if (!Number.isInteger(value)) {
+    return `must be a timestamp in whole milliseconds, got ${String(value)}. Round it (Math.round) or use Date.getTime()`;
+  }
+  if (value < TIMESTAMP_MIN_MS || value > TIMESTAMP_MAX_MS) {
+    return `must be a timestamp between ${TIMESTAMP_MIN_MS} and ${TIMESTAMP_MAX_MS} (the range of a JavaScript Date), got ${String(value)}`;
+  }
+  return null;
+}
+function valueDepthViolation(value, maxDepth = MAX_VALUE_DEPTH) {
+  const walk = (current, depth, path) => {
+    if (current === null || typeof current !== "object") return null;
+    if (depth > maxDepth) return path;
+    if (current instanceof Uint8Array || current instanceof ArrayBuffer) return null;
+    const entries = Array.isArray(current) ? current.map((item, index) => [`[${index}]`, item]) : Object.entries(current).map(
+      ([key, item]) => [`.${key}`, item]
+    );
+    for (const [suffix, item] of entries) {
+      const found = walk(item, depth + 1, `${path}${suffix}`);
+      if (found !== null) return found;
+    }
+    return null;
+  };
+  return walk(value, 1, "");
+}
+function protoKeyViolation(value) {
+  const walk = (current, path) => {
+    if (current === null || typeof current !== "object") return null;
+    if (current instanceof Uint8Array || current instanceof ArrayBuffer) return null;
+    if (Array.isArray(current)) {
+      for (let index = 0; index < current.length; index++) {
+        const found = walk(current[index], `${path}[${index}]`);
+        if (found !== null) return found;
+      }
+      return null;
+    }
+    if (Object.prototype.hasOwnProperty.call(current, "__proto__")) return `${path}.__proto__`;
+    for (const [key, item] of Object.entries(current)) {
+      const found = walk(item, `${path}.${key}`);
+      if (found !== null) return found;
+    }
+    return null;
+  };
+  return walk(value, "");
+}
+function operationValueViolation(descriptor, value) {
+  if (value === null || value === void 0) return null;
+  switch (descriptor.kind) {
+    case "string":
+    case "secret":
+      return typeof value === "string" ? null : `must be a string, got ${describe(value)}`;
+    case "enum":
+      if (typeof value !== "string") return `must be a string (enum), got ${describe(value)}`;
+      if (descriptor.enumValues && !descriptor.enumValues.includes(value)) {
+        return `must be one of: ${descriptor.enumValues.join(", ")}. Got "${value}"`;
+      }
+      return null;
+    case "number":
+      return typeof value === "number" && Number.isFinite(value) ? null : `must be a finite number, got ${describe(value)}`;
+    case "boolean":
+      return typeof value === "boolean" ? null : `must be a boolean, got ${describe(value)}`;
+    case "timestamp":
+      return timestampDomainViolation(value);
+    case "richtext":
+      return typeof value === "string" || isKoraBytesValue(value) || value instanceof Uint8Array ? null : `must be richtext (Yjs bytes or a string), got ${describe(value)}`;
+    case "blob":
+      return isBlobRef(value) ? null : `must be a BlobRef, got ${describe(value)}`;
+    case "array": {
+      if (!Array.isArray(value)) return `must be an array, got ${describe(value)}`;
+      const item = descriptor.itemKind;
+      for (let index = 0; index < value.length; index++) {
+        const element = value[index];
+        if (item === "timestamp") {
+          const violation = timestampDomainViolation(element);
+          if (violation) return `[${index}] ${violation}`;
+        } else if (item === "number" && (typeof element !== "number" || !Number.isFinite(element))) {
+          return `[${index}] must be a finite number, got ${describe(element)}`;
+        } else if ((item === "string" || item === "enum") && typeof element !== "string") {
+          return `[${index}] must be a string, got ${describe(element)}`;
+        } else if (item === "boolean" && typeof element !== "boolean") {
+          return `[${index}] must be a boolean, got ${describe(element)}`;
+        }
+      }
+      return structureViolation(value);
+    }
+    case "object": {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        return `must be a plain object, got ${describe(value)}`;
+      }
+      for (const [name, nested] of Object.entries(descriptor.nestedFields ?? {})) {
+        const violation = operationValueViolation(nested, value[name]);
+        if (violation) return `.${name} ${violation}`;
+      }
+      return structureViolation(value);
+    }
+    case "json":
+      return structureViolation(value);
+  }
+}
+var WIRE_BYTES_KEY = "__kora_bytes__";
+function reservedWireShapeViolation(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
+  const keys = Object.keys(value);
+  return keys.length === 1 && keys[0] === WIRE_BYTES_KEY ? `is an object whose only key is "${WIRE_BYTES_KEY}", which the sync wire reserves for binary values; add another key or rename it` : null;
+}
+function structureViolation(value) {
+  const reserved = reservedWireShapeViolation(value);
+  if (reserved !== null) return reserved;
+  const deep = valueDepthViolation(value);
+  if (deep !== null) return `nests deeper than ${MAX_VALUE_DEPTH} levels at "${deep}"`;
+  const proto = protoKeyViolation(value);
+  if (proto !== null) return `holds a "__proto__" key at "${proto}", which is not supported`;
+  const walk = (current, path) => {
+    if (typeof current === "number") {
+      return Number.isFinite(current) ? null : `holds ${String(current)} at "${path}"`;
+    }
+    if (current === null || typeof current !== "object") return null;
+    const entries = Array.isArray(current) ? current.map((item, index) => [`${path}[${index}]`, item]) : Object.entries(current).map(
+      ([key, item]) => [`${path}.${key}`, item]
+    );
+    for (const [next, item] of entries) {
+      const found = walk(item, next);
+      if (found !== null) return found;
+    }
+    return null;
+  };
+  return walk(value, "");
+}
+function measureOperationBytes(op2) {
+  return utf8Length(JSON.stringify(op2));
+}
+function utf8Length(text) {
+  let bytes = 0;
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    if (code < 128) bytes += 1;
+    else if (code < 2048) bytes += 2;
+    else if (code >= 55296 && code <= 56319 && i + 1 < text.length) {
+      const next = text.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        i++;
+      } else bytes += 3;
+    } else bytes += 3;
+  }
+  return bytes;
+}
+function describe(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "number") return Number.isFinite(value) ? "number" : String(value);
+  if (value instanceof Date) return "Date";
+  return typeof value;
+}
+
 // src/schema/validation.ts
 function validateRecord(collection, collectionDef, data, operationType) {
   if (operationType === "delete") {
@@ -1614,7 +3172,7 @@ function validateRecord(collection, collectionDef, data, operationType) {
           result[fieldName] = value;
         } else if (value !== void 0 && value !== null) {
           validateFieldValue(collection, fieldName, descriptor, value);
-          result[fieldName] = value;
+          result[fieldName] = canonicalFieldValue(collection, fieldName, descriptor, value);
         } else {
           result[fieldName] = value;
         }
@@ -1638,10 +3196,29 @@ function validateRecord(collection, collectionDef, data, operationType) {
       continue;
     }
     validateFieldValue(collection, fieldName, descriptor, value);
-    result[fieldName] = value;
+    result[fieldName] = canonicalFieldValue(collection, fieldName, descriptor, value);
   }
   return result;
 }
+function canonicalFieldValue(collection, fieldName, descriptor, value) {
+  if (descriptor.kind === "richtext") return value;
+  try {
+    return canonicalValue(value, `${collection}.${fieldName}`);
+  } catch (error) {
+    if (error instanceof NonCanonicalValueError) {
+      throw new SchemaValidationError(
+        `Field "${fieldName}" in collection "${collection}": ${error.message}`,
+        {
+          collection,
+          field: fieldName,
+          path: error.path,
+          receivedType: error.receivedType
+        }
+      );
+    }
+    throw error;
+  }
+}
 function validateFieldValue(collection, fieldName, descriptor, value) {
   switch (descriptor.kind) {
     case "string": {
@@ -1654,9 +3231,9 @@ function validateFieldValue(collection, fieldName, descriptor, value) {
       break;
     }
     case "number": {
-      if (typeof value !== "number" || Number.isNaN(value)) {
+      if (typeof value !== "number" || !Number.isFinite(value)) {
         throw new SchemaValidationError(
-          `Field "${fieldName}" in collection "${collection}" must be a number, got ${typeof value}`,
+          `Field "${fieldName}" in collection "${collection}" must be a finite number, got ${typeof value === "number" ? String(value) : typeof value}`,
           { collection, field: fieldName, expectedType: "number", receivedType: typeof value }
         );
       }
@@ -1672,14 +3249,16 @@ function validateFieldValue(collection, fieldName, descriptor, value) {
       break;
     }
     case "timestamp": {
-      if (typeof value !== "number" || !Number.isFinite(value)) {
+      const violation = timestampDomainViolation(value);
+      if (violation !== null) {
         throw new SchemaValidationError(
-          `Field "${fieldName}" in collection "${collection}" must be a timestamp (number), got ${typeof value}`,
+          `Field "${fieldName}" in collection "${collection}" ${violation}`,
           {
             collection,
             field: fieldName,
             expectedType: "timestamp",
-            receivedType: typeof value
+            receivedType: typeof value,
+            received: value
           }
         );
       }
@@ -1716,6 +3295,14 @@ function validateFieldValue(collection, fieldName, descriptor, value) {
         const expectedType = jsTypeForKind(descriptor.itemKind);
         for (let i = 0; i < value.length; i++) {
           const item = value[i];
+          if ((descriptor.itemKind === "timestamp" || descriptor.itemKind === "number") && item !== null && item !== void 0) {
+            validateFieldValue(
+              collection,
+              `${fieldName}[${i}]`,
+              { ...descriptor, kind: descriptor.itemKind, itemKind: null },
+              item
+            );
+          }
           if (!matchesJsType(item, expectedType)) {
             throw new SchemaValidationError(
               `Field "${fieldName}[${i}]" in collection "${collection}" must be a ${descriptor.itemKind}, got ${typeof item}`,
@@ -1729,6 +3316,7 @@ function validateFieldValue(collection, fieldName, descriptor, value) {
           }
         }
       }
+      assertStructureInDomain(collection, fieldName, value);
       break;
     }
     case "richtext": {
@@ -1746,7 +3334,7 @@ function validateFieldValue(collection, fieldName, descriptor, value) {
       break;
     }
     case "object": {
-      if (!isPlainObject(value)) {
+      if (!isPlainObject2(value)) {
         throw new SchemaValidationError(
           `Field "${fieldName}" in collection "${collection}" must be a plain object, got ${describeType(value)}`,
           {
@@ -1770,6 +3358,7 @@ function validateFieldValue(collection, fieldName, descriptor, value) {
           }
         }
       }
+      assertStructureInDomain(collection, fieldName, value);
       break;
     }
     case "json": {
@@ -1786,6 +3375,7 @@ function validateFieldValue(collection, fieldName, descriptor, value) {
           }
         );
       }
+      assertStructureInDomain(collection, fieldName, value);
       break;
     }
     case "blob": {
@@ -1813,7 +3403,34 @@ function validateFieldValue(collection, fieldName, descriptor, value) {
     }
   }
 }
-function isPlainObject(value) {
+function assertStructureInDomain(collection, fieldName, value) {
+  const reserved = reservedWireShapeViolation(value);
+  if (reserved !== null) {
+    throw new SchemaValidationError(
+      `Field "${fieldName}" in collection "${collection}" ${reserved}.`,
+      { collection, field: fieldName }
+    );
+  }
+  const deep = valueDepthViolation(value);
+  if (deep !== null) {
+    throw new SchemaValidationError(
+      `Field "${fieldName}" in collection "${collection}" nests deeper than ${MAX_VALUE_DEPTH} levels (at "${fieldName}${deep}"). Flatten the value.`,
+      { collection, field: fieldName, path: `${fieldName}${deep}`, maxDepth: MAX_VALUE_DEPTH }
+    );
+  }
+  const proto = protoKeyViolation(value);
+  if (proto !== null) {
+    throw new SchemaValidationError(
+      `Field "${fieldName}" in collection "${collection}" holds a "__proto__" key (at "${fieldName}${proto}"), which cannot be stored and synced unchanged. Rename the key.`,
+      { collection, field: fieldName, path: `${fieldName}${proto}` }
+    );
+  }
+}
+function assertResolvedFieldValue(collection, fieldName, descriptor, value) {
+  if (value === null || value === void 0 || descriptor.kind === "richtext") return;
+  validateFieldValue(collection, fieldName, descriptor, value);
+}
+function isPlainObject2(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return false;
   }
@@ -1967,6 +3584,17 @@ function buildScopeMap(schema, scopeValues) {
   return result;
 }
 
+// src/scopes/scope-grant.ts
+var SCOPE_CLAIMS_KEY = "$claims";
+function claimScopes(claims, explicit) {
+  return { ...explicit ?? {}, [SCOPE_CLAIMS_KEY]: { ...claims } };
+}
+function getScopeClaims(grant) {
+  if (!grant) return null;
+  const claims = grant[SCOPE_CLAIMS_KEY];
+  return claims && typeof claims === "object" ? claims : null;
+}
+
 // src/scopes/extract-scope-from-claims.ts
 function collectSchemaScopeFields(schema) {
   return collectSchemaScopeValueKeys(schema);
@@ -2021,29 +3649,6 @@ function defaultSequenceFormat(name) {
   return `${name}-{seq:4}`;
 }
 
-// src/migration/apply-operation-transforms.ts
-var MAX_TRANSFORM_STEPS = 32;
-function applyOperationTransforms(operation, targetSchemaVersion, transforms) {
-  let current = operation;
-  for (let step = 0; step < MAX_TRANSFORM_STEPS; step++) {
-    if (current.schemaVersion === targetSchemaVersion) {
-      return current;
-    }
-    const transform = transforms.find(
-      (candidate) => candidate.fromVersion === current.schemaVersion
-    );
-    if (!transform) {
-      return null;
-    }
-    const next = transform.transform(current);
-    if (next === null) {
-      return null;
-    }
-    current = next;
-  }
-  return null;
-}
-
 // src/migrations/migration-builder.ts
 var RollbackBuilder = class {
   _steps = [];
@@ -2149,17 +3754,29 @@ var MigrationBuilder = class _MigrationBuilder {
   }
   /**
    * Backfill records in a collection using a transform function.
-   * The transform receives each record and returns the fields to update.
-   * Runs after structural changes (addField, renameField, etc.).
+   * The transform receives each live record (typed values, as the app reads them) and
+   * returns the fields to change. Runs after structural changes (addField, renameField,
+   * etc.), in the same transaction as them and the schema version write.
+   *
+   * Changed records are written as update operations (mutation name `migration:v<N>`)
+   * through the normal local write path, so backfilled values sync. Pass
+   * `{ localOnly: true }` for device-local data that must not sync.
    *
    * @param collection - The collection name
    * @param transform - Forward transform function
-   * @param reverseTransform - Optional reverse transform for rollback support
+   * @param reverseOrOptions - Reverse transform for rollback support, or options
    */
-  backfill(collection, transform, reverseTransform) {
+  backfill(collection, transform, reverseOrOptions) {
+    const options = typeof reverseOrOptions === "function" ? { reverseTransform: reverseOrOptions } : reverseOrOptions ?? {};
     return new _MigrationBuilder([
       ...this.steps,
-      { type: "backfill", collection, transform, reverseTransform }
+      {
+        type: "backfill",
+        collection,
+        transform,
+        ...options.reverseTransform ? { reverseTransform: options.reverseTransform } : {},
+        ...options.localOnly ? { localOnly: true } : {}
+      }
     ]);
   }
   /**
@@ -2306,11 +3923,13 @@ function migrationStepsToSQL(steps) {
         break;
       case "addIndex":
         statements.push(
-          `CREATE INDEX IF NOT EXISTS idx_${step.collection}_${step.field} ON ${quoteIdent(step.collection)} (${quoteIdent(step.field)})`
+          `CREATE INDEX IF NOT EXISTS ${quoteIdent(collectionIndexName(step.collection, step.field))} ON ${quoteIdent(step.collection)} (${quoteIdent(step.field)})`
         );
         break;
       case "removeIndex":
-        statements.push(`DROP INDEX IF EXISTS idx_${step.collection}_${step.field}`);
+        statements.push(
+          `DROP INDEX IF EXISTS ${quoteIdent(collectionIndexName(step.collection, step.field))}`
+        );
         break;
       case "backfill":
         break;
@@ -2323,18 +3942,14 @@ function rollbackStepsToSQL(migration) {
   return migrationStepsToSQL(rollbackSteps);
 }
 function addFieldSQL(collection, field, descriptor) {
-  const sqlType = mapFieldType2(descriptor);
+  const sqlType = mapFieldType(descriptor);
   const parts = [`ALTER TABLE ${quoteIdent(collection)} ADD COLUMN ${quoteIdent(field)}`, sqlType];
   if (descriptor.defaultValue !== void 0) {
-    parts.push(`DEFAULT ${sqlDefault2(descriptor.defaultValue)}`);
-  }
-  if (descriptor.kind === "enum" && descriptor.enumValues) {
-    const values = descriptor.enumValues.map((v) => `'${v}'`).join(", ");
-    parts.push(`CHECK (${quoteIdent(field)} IN (${values}))`);
+    parts.push(`DEFAULT ${sqlDefaultLiteral(descriptor.defaultValue)}`);
   }
   return parts.join(" ");
 }
-function mapFieldType2(descriptor) {
+function mapFieldType(descriptor) {
   switch (descriptor.kind) {
     case "string":
       return "TEXT";
@@ -2360,13 +3975,6 @@ function mapFieldType2(descriptor) {
       return "BLOB";
   }
 }
-function sqlDefault2(value) {
-  if (value === null) return "NULL";
-  if (typeof value === "string") return `'${value}'`;
-  if (typeof value === "number") return String(value);
-  if (typeof value === "boolean") return value ? "1" : "0";
-  return `'${JSON.stringify(value)}'`;
-}
 
 // src/codegen/proto-generator.ts
 var SCALAR_TYPE_MAP = {
@@ -2471,15 +4079,20 @@ var KORA_OPERATION_MESSAGE = `message KoraOperation {
 var OPERATION_BATCH_MESSAGE = `message OperationBatch {
 	repeated KoraOperation operations = 1;
 	bool is_final = 2;
+	bytes retractions_json = 3;
 }`;
 var HANDSHAKE_MESSAGE = `message HandshakeMessage {
 	map<string, int64> version_vector = 1;
 	int32 schema_version = 2;
 	string node_id = 3;
+	string scope_exit_policy = 4;
 }`;
 var HANDSHAKE_RESPONSE_MESSAGE = `message HandshakeResponse {
 	map<string, int64> version_vector = 1;
 	int32 schema_version = 2;
+	bytes accepted_scope_json = 3;
+	bytes accepted_downlink_scopes_json = 4;
+	bytes accepted_uplink_scopes_json = 5;
 }`;
 var ACKNOWLEDGMENT_MESSAGE = `message Acknowledgment {
 	int64 sequence_number = 1;
@@ -2545,20 +4158,25 @@ function buildJsonDescriptor(schema) {
   nested.OperationBatch = {
     fields: {
       operations: { type: "KoraOperation", id: 1, rule: "repeated" },
-      is_final: { type: "bool", id: 2 }
+      is_final: { type: "bool", id: 2 },
+      retractions_json: { type: "bytes", id: 3 }
     }
   };
   nested.HandshakeMessage = {
     fields: {
       version_vector: { keyType: "string", type: "int64", id: 1 },
       schema_version: { type: "int32", id: 2 },
-      node_id: { type: "string", id: 3 }
+      node_id: { type: "string", id: 3 },
+      scope_exit_policy: { type: "string", id: 4 }
     }
   };
   nested.HandshakeResponse = {
     fields: {
       version_vector: { keyType: "string", type: "int64", id: 1 },
-      schema_version: { type: "int32", id: 2 }
+      schema_version: { type: "int32", id: 2 },
+      accepted_scope_json: { type: "bytes", id: 3 },
+      accepted_downlink_scopes_json: { type: "bytes", id: 4 },
+      accepted_uplink_scopes_json: { type: "bytes", id: 5 }
     }
   };
   nested.Acknowledgment = {
@@ -2613,50 +4231,91 @@ export {
   CONNECTION_QUALITIES,
   CausalTracker,
   ClockDriftError,
+  DEFAULT_MAX_OPERATION_BYTES,
+  DEFAULT_OPERATION_HASH_VERSION,
   EnumFieldBuilder,
+  FOLD_RECORD_TRACE_FIELD,
+  FOLD_STATE_VERSION,
   FieldBuilder,
+  FoldConfigurationError,
+  FoldStateError,
   HybridLogicalClock,
   InvalidTimestampError,
+  JsonFieldBuilder,
   KORA_ERROR_FIX_SUGGESTIONS,
   KoraError,
   MAX_LOGICAL,
+  MAX_VALUE_DEPTH,
   MERGE_STRATEGIES,
   MergeConflictError,
   MigrationBuilder,
   MigrationRollbackError,
   MissingSecretKeyError,
+  NonCanonicalValueError,
+  ObjectFieldBuilder,
   OperationError,
+  OperationTooLargeError,
+  OperationTransformCoverageError,
+  OperationTransformError,
+  RESERVED_NODE_ID_PREFIX,
   RemoteClockDriftError,
   RollbackBuilder,
+  SCOPE_CLAIMS_KEY,
+  SERVER_NODE_ID_PREFIX,
+  STORED_TEXT_ESCAPE,
   SchemaValidationError,
+  SecretFieldBuilder,
   StorageError,
   SyncError,
+  TIMESTAMP_MAX_MS,
+  TIMESTAMP_MIN_MS,
+  adaptFoldState,
   advanceVector,
   applyAtomicOp,
   applyOperationTransforms,
+  assertOperationTransformCoverage,
+  assertResolvedFieldValue,
   base64ToBytes,
   buildScopeMap,
   buildStateMachineConstraints,
   bytesToBase64,
   canAutoRollback,
+  canonicalValue,
+  canonicalizeLegacyOperation,
+  canonicalizeOperationBody,
+  canonicalizeProvenLegacyClear,
+  claimScopes,
   collectSchemaScopeFields,
   collectSchemaScopeValueKeys,
   computeDelta,
+  computeOperationId,
   createBlobRef,
+  createFoldState,
   createOperation,
   createReversibleMigration,
+  createSnapshotState,
   createVersionVector,
   decodeBytesFromOpData,
+  decodeStoredJsonValue,
+  decodeStoredText,
   decryptSecret,
   defaultApplyFailureReason,
   defaultSequenceFormat,
   defineSchema,
+  deriveSideEffectOpId,
+  deserializeFoldState,
   deserializeVector,
   dominates,
   encodeBytesForOpData,
+  encodeStoredJsonValue,
+  encodeStoredText,
   encryptSecret,
+  expandFieldVersionedOperations,
   extractScopeValuesFromClaims,
   extractTimestamp,
+  foldPlanFingerprint,
+  foldPlanFingerprints,
+  foldRecord,
   formatSequenceValue,
   generateFullDDL,
   generateProtoDefinitions,
@@ -2664,35 +4323,61 @@ export {
   generateSQL,
   generateUUIDv7,
   getCollectionScopeBindings,
+  getFoldFieldVersionStrings,
+  getFoldFieldVersions,
   getKoraErrorFix,
+  getScopeClaims,
   getTransitionMap,
   hasSchemaSyncRules,
   hashBlob,
   hashSecret,
   isApplyFailure,
   isAtomicOp,
+  isAuthoritativeNodeId,
   isBlobRef,
   isCollectionSyncScoped,
+  isFoldStateLive,
   isKoraBytesValue,
   isLegacyNumericByteObject,
+  isReservedNodeId,
+  isServerNodeId,
   isValidOperation,
   isValidUUIDv7,
+  joinStates,
+  materialize,
+  measureOperationBytes,
+  mergeArraySet,
+  mergeOp,
   mergeVectors,
   migrate,
   migrationStepsToSQL,
+  mismatchedFoldFields,
+  missingTransformPaths,
+  needsStoredTextEncoding,
   op,
+  operationSchemaView,
+  operationTransformsFingerprint,
+  operationValueViolation,
+  protoKeyViolation,
   quoteIdent,
+  replayFieldVersionsForRecord,
   replayOperationsForRecord,
+  reservedWireShapeViolation,
   resolveAtomicOp,
   revealSecret,
   rollbackStepsToSQL,
+  serializeFoldState,
   serializeVector,
   t,
+  timestampDomainViolation,
   toAtomicOp,
+  toMergeTrace,
   transformSecretFieldsForWrite,
   validateRecord,
   validateTransition,
+  valueDepthViolation,
   vectorsEqual,
+  verifyOperationId,
   verifyOperationIntegrity,
   verifySecret,
   verifySecretValue