@korajs/core 0.4.0 → 0.5.0

package/dist/index.cjs

@@ -20,12 +20,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  APPLY_FAILURE_CODES: () => APPLY_FAILURE_CODES,
+  APPLY_RESULTS: () => APPLY_RESULTS,
   ArrayFieldBuilder: () => ArrayFieldBuilder,
   CONNECTION_QUALITIES: () => CONNECTION_QUALITIES,
+  CausalTracker: () => CausalTracker,
   ClockDriftError: () => ClockDriftError,
   EnumFieldBuilder: () => EnumFieldBuilder,
   FieldBuilder: () => FieldBuilder,
   HybridLogicalClock: () => HybridLogicalClock,
+  KORA_ERROR_FIX_SUGGESTIONS: () => KORA_ERROR_FIX_SUGGESTIONS,
   KoraError: () => KoraError,
   MERGE_STRATEGIES: () => MERGE_STRATEGIES,
   MergeConflictError: () => MergeConflictError,
@@ -37,17 +41,22 @@ __export(index_exports, {
   StorageError: () => StorageError,
   SyncError: () => SyncError,
   advanceVector: () => advanceVector,
+  applyOperationTransforms: () => applyOperationTransforms,
   buildScopeMap: () => buildScopeMap,
   buildStateMachineConstraints: () => buildStateMachineConstraints,
   canAutoRollback: () => canAutoRollback,
+  collectSchemaScopeFields: () => collectSchemaScopeFields,
+  collectSchemaScopeValueKeys: () => collectSchemaScopeValueKeys,
   computeDelta: () => computeDelta,
   createOperation: () => createOperation,
   createReversibleMigration: () => createReversibleMigration,
   createVersionVector: () => createVersionVector,
+  defaultApplyFailureReason: () => defaultApplyFailureReason,
   defaultSequenceFormat: () => defaultSequenceFormat,
   defineSchema: () => defineSchema,
   deserializeVector: () => deserializeVector,
   dominates: () => dominates,
+  extractScopeValuesFromClaims: () => extractScopeValuesFromClaims,
   extractTimestamp: () => extractTimestamp,
   formatSequenceValue: () => formatSequenceValue,
   generateFullDDL: () => generateFullDDL,
@@ -55,8 +64,13 @@ __export(index_exports, {
   generateRollbackSteps: () => generateRollbackSteps,
   generateSQL: () => generateSQL,
   generateUUIDv7: () => generateUUIDv7,
+  getCollectionScopeBindings: () => getCollectionScopeBindings,
+  getKoraErrorFix: () => getKoraErrorFix,
   getTransitionMap: () => getTransitionMap,
+  hasSchemaSyncRules: () => hasSchemaSyncRules,
+  isApplyFailure: () => isApplyFailure,
   isAtomicOp: () => isAtomicOp,
+  isCollectionSyncScoped: () => isCollectionSyncScoped,
   isValidOperation: () => isValidOperation,
   isValidUUIDv7: () => isValidUUIDv7,
   mergeVectors: () => mergeVectors,
@@ -85,6 +99,23 @@ var MERGE_STRATEGIES = [
 ];
 var CONNECTION_QUALITIES = ["excellent", "good", "fair", "poor", "offline"];
 
+// src/errors/error-fixes.ts
+var KORA_ERROR_FIX_SUGGESTIONS = {
+  SCHEMA_VALIDATION: "Review your defineSchema() definition: every collection needs at least one field and a positive version.",
+  OPERATION_ERROR: "Check the operation payload matches your schema field types and required fields.",
+  MERGE_CONFLICT: "Add a custom resolver for the conflicting field in defineSchema(), or adjust constraint onConflict rules.",
+  SYNC_ERROR: "Verify the sync server URL, auth token, and that the server accepts your schema version.",
+  STORAGE_ERROR: "Confirm the storage adapter is supported in this environment and the database path is writable.",
+  CLOCK_DRIFT: "Sync device wall-clock time (NTP). Kora refuses new timestamps when drift exceeds five minutes.",
+  PERSISTENCE_ERROR: "IndexedDB persistence failed; check browser storage settings and available disk quota.",
+  MISSING_WORKER_URL: "Pass store.workerUrl pointing to sqlite-wasm-worker.js (see create-kora-app templates).",
+  INVALID_SYNC_URL: "Use ws:// or wss:// for WebSocket transport, or http(s):// for HTTP long-polling.",
+  APP_NOT_READY: "Await app.ready before querying or mutating collections, or wrap the tree in <KoraProvider app={app}>."
+};
+function getKoraErrorFix(code) {
+  return KORA_ERROR_FIX_SUGGESTIONS[code];
+}
+
 // src/errors/errors.ts
 var KoraError = class extends Error {
   constructor(message, code, context) {
@@ -95,6 +126,16 @@ var KoraError = class extends Error {
   }
   code;
   context;
+  /**
+   * Actionable hint for resolving this error (from registry or error context).
+   */
+  get fix() {
+    const fromContext = this.context?.fix;
+    if (typeof fromContext === "string" && fromContext.length > 0) {
+      return fromContext;
+    }
+    return getKoraErrorFix(this.code);
+  }
 };
 var SchemaValidationError = class extends KoraError {
   constructor(message, context) {
@@ -192,6 +233,7 @@ var HybridLogicalClock = class {
    */
   receive(remote) {
     const physicalTime = this.timeSource.now();
+    const wasColdStart = this.wallTime === 0;
     if (physicalTime > this.wallTime && physicalTime > remote.wallTime) {
       this.wallTime = physicalTime;
       this.logical = 0;
@@ -203,7 +245,9 @@ var HybridLogicalClock = class {
     } else {
       this.logical++;
     }
-    this.checkDrift(physicalTime);
+    if (!wasColdStart) {
+      this.checkDrift(physicalTime);
+    }
     return { wallTime: this.wallTime, logical: this.logical, nodeId: this.nodeId };
   }
   /**
@@ -252,6 +296,50 @@ var HybridLogicalClock = class {
   }
 };
 
+// src/causal/causal-tracker.ts
+var CausalTracker = class {
+  lastOpIdByCollection = /* @__PURE__ */ new Map();
+  lastTransactionOpId = null;
+  /**
+   * Start a new transaction boundary. Clears in-transaction op ids.
+   */
+  beginTransaction() {
+    this.lastTransactionOpId = null;
+  }
+  /**
+   * Clear the transaction boundary without recording ops (after rollback).
+   */
+  clearTransaction() {
+    this.lastTransactionOpId = null;
+  }
+  /**
+   * Compute causal dependencies for the next operation in a collection.
+   * Uses direct parents only: collection head and the previous op in the open transaction.
+   */
+  nextCausalDeps(collection, inTransaction) {
+    const deps = [];
+    const lastInCollection = this.lastOpIdByCollection.get(collection);
+    if (lastInCollection !== void 0) {
+      deps.push(lastInCollection);
+    }
+    if (inTransaction && this.lastTransactionOpId !== null) {
+      if (!deps.includes(this.lastTransactionOpId)) {
+        deps.push(this.lastTransactionOpId);
+      }
+    }
+    return deps;
+  }
+  /**
+   * Record an operation after it has been created and assigned an id.
+   */
+  afterOperation(collection, operationId, inTransaction) {
+    this.lastOpIdByCollection.set(collection, operationId);
+    if (inTransaction) {
+      this.lastTransactionOpId = operationId;
+    }
+  }
+};
+
 // src/identifiers/uuid-v7.ts
 var defaultRandom = globalThis.crypto;
 function generateUUIDv7(timestamp = Date.now(), randomSource = defaultRandom) {
@@ -288,6 +376,37 @@ function formatUUID(bytes) {
   return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
 }
 
+// src/operations/apply-result.ts
+var APPLY_RESULTS = ["applied", "duplicate", "skipped", "rejected", "deferred"];
+var APPLY_FAILURE_CODES = {
+  APPLY_FAILED: "APPLY_FAILED",
+  APPLY_SKIPPED: "APPLY_SKIPPED",
+  APPLY_REJECTED: "APPLY_REJECTED",
+  APPLY_DEFERRED: "APPLY_DEFERRED",
+  CLOCK_DRIFT: "CLOCK_DRIFT",
+  REFERENTIAL_INTEGRITY: "REFERENTIAL_INTEGRITY",
+  SCHEMA_MISMATCH: "SCHEMA_MISMATCH"
+};
+function isApplyFailure(result) {
+  return result === "skipped" || result === "rejected" || result === "deferred";
+}
+function defaultApplyFailureReason(result, overrides) {
+  const base = result === "deferred" ? {
+    code: APPLY_FAILURE_CODES.APPLY_DEFERRED,
+    message: "Operation apply was deferred.",
+    retriable: true
+  } : result === "rejected" ? {
+    code: APPLY_FAILURE_CODES.APPLY_REJECTED,
+    message: "Operation apply was rejected.",
+    retriable: false
+  } : {
+    code: APPLY_FAILURE_CODES.APPLY_SKIPPED,
+    message: "Operation apply was skipped.",
+    retriable: false
+  };
+  return { ...base, ...overrides };
+}
+
 // src/operations/content-hash.ts
 async function computeOperationId(input, timestamp) {
   const hashInput = {
@@ -307,8 +426,11 @@ async function computeOperationId(input, timestamp) {
   return bufferToHex(hashBuffer);
 }
 function canonicalize(obj) {
-  if (obj === null || obj === void 0) {
-    return JSON.stringify(obj);
+  if (obj === null) {
+    return "null";
+  }
+  if (obj === void 0) {
+    return "null";
   }
   if (typeof obj !== "object") {
     return JSON.stringify(obj);
@@ -320,7 +442,7 @@ function canonicalize(obj) {
   const keys = Object.keys(obj).sort();
   const pairs = keys.map((key) => {
     const value = obj[key];
-    return `${JSON.stringify(key)}:${canonicalize(value)}`;
+    return `${JSON.stringify(key)}:${canonicalize(value === void 0 ? null : value)}`;
   });
   return `{${pairs.join(",")}}`;
 }
@@ -441,6 +563,7 @@ function isValidOperation(value) {
 }
 function deepFreeze(obj) {
   if (typeof obj !== "object" || obj === null) return obj;
+  if (ArrayBuffer.isView(obj)) return obj;
   Object.freeze(obj);
   for (const value of Object.values(obj)) {
     if (typeof value === "object" && value !== null && !Object.isFrozen(value)) {
@@ -548,6 +671,69 @@ function toAtomicOp(sentinel) {
   return { type: sentinel.type, value: sentinel.value };
 }
 
+// src/scopes/sync-scope-bindings.ts
+function hasSchemaSyncRules(schema) {
+  return schema.sync !== void 0 && Object.keys(schema.sync).length > 0;
+}
+function getCollectionScopeBindings(schema, collectionName) {
+  const syncRule = schema.sync?.[collectionName];
+  if (syncRule && Object.keys(syncRule.where).length > 0) {
+    return { ...syncRule.where };
+  }
+  const scopeFields = schema.collections[collectionName]?.scope ?? [];
+  if (scopeFields.length === 0) {
+    return null;
+  }
+  const bindings = {};
+  for (const field of scopeFields) {
+    bindings[field] = field;
+  }
+  return bindings;
+}
+function isCollectionSyncScoped(schema, collectionName) {
+  if (hasSchemaSyncRules(schema)) {
+    if (schema.sync?.[collectionName]) {
+      return true;
+    }
+    const legacyScope = schema.collections[collectionName]?.scope ?? [];
+    return legacyScope.length > 0;
+  }
+  return getCollectionScopeBindings(schema, collectionName) !== null;
+}
+function collectSchemaScopeValueKeys(schema) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const collection of Object.values(schema.collections)) {
+    for (const field of collection.scope) {
+      keys.add(field);
+    }
+  }
+  if (schema.sync) {
+    for (const rule of Object.values(schema.sync)) {
+      for (const scopeKey of Object.values(rule.where)) {
+        keys.add(scopeKey);
+      }
+    }
+  }
+  return [...keys];
+}
+function normalizeSyncRuleWhere(collectionName, where) {
+  const normalized = {};
+  for (const [field, scopeKey] of Object.entries(where)) {
+    if (scopeKey === true) {
+      normalized[field] = field;
+      continue;
+    }
+    if (typeof scopeKey === "string" && scopeKey.length > 0) {
+      normalized[field] = scopeKey;
+      continue;
+    }
+    throw new Error(
+      `Invalid sync rule for collection "${collectionName}": where.${field} must be true or a non-empty scope key string`
+    );
+  }
+  return normalized;
+}
+
 // src/state-machine/state-machine.ts
 function validateTransition(constraint, fromValue, toValue) {
   const from = String(fromValue);
@@ -637,7 +823,7 @@ function validateStateMachineDefinition(collectionName, sm, fields) {
 // src/schema/define.ts
 var COLLECTION_NAME_RE = /^[a-z][a-z0-9_]*$/;
 var FIELD_NAME_RE = /^[a-z][a-zA-Z0-9_]*$/;
-var RESERVED_FIELDS = /* @__PURE__ */ new Set(["id", "_created_at", "_updated_at", "_deleted"]);
+var RESERVED_FIELDS = /* @__PURE__ */ new Set(["id", "_created_at", "_updated_at", "_version", "_deleted"]);
 function defineSchema(input) {
   validateVersion(input.version);
   const collections = {};
@@ -680,7 +866,15 @@ function defineSchema(input) {
       migrations[version] = migration;
     }
   }
-  return { version: input.version, collections, relations, migrations };
+  const sync = buildSyncRules(input.sync, collections);
+  applySyncRulesToCollectionScope(collections, sync);
+  return {
+    version: input.version,
+    collections,
+    relations,
+    migrations,
+    ...sync ? { sync } : {}
+  };
 }
 function validateVersion(version) {
   if (typeof version !== "number" || !Number.isInteger(version) || version < 1) {
@@ -761,6 +955,63 @@ function buildCollection(name, input) {
   }
   return { fields, indexes, constraints, resolvers, scope, stateMachine };
 }
+function buildSyncRules(syncInput, collections) {
+  if (!syncInput) {
+    return void 0;
+  }
+  const sync = {};
+  for (const [collectionName, ruleInput] of Object.entries(syncInput)) {
+    if (!(collectionName in collections)) {
+      throw new SchemaValidationError(
+        `Sync rule references collection "${collectionName}" which does not exist. Available collections: ${Object.keys(collections).join(", ")}`,
+        { collection: collectionName }
+      );
+    }
+    if (!ruleInput.where || Object.keys(ruleInput.where).length === 0) {
+      throw new SchemaValidationError(
+        `Sync rule for collection "${collectionName}" must declare at least one where binding`,
+        { collection: collectionName }
+      );
+    }
+    const collection = collections[collectionName];
+    if (!collection) {
+      continue;
+    }
+    for (const fieldName of Object.keys(ruleInput.where)) {
+      if (!(fieldName in collection.fields)) {
+        throw new SchemaValidationError(
+          `Sync rule where field "${fieldName}" does not exist in collection "${collectionName}". Available fields: ${Object.keys(collection.fields).join(", ")}`,
+          { collection: collectionName, field: fieldName }
+        );
+      }
+    }
+    try {
+      sync[collectionName] = { where: normalizeSyncRuleWhere(collectionName, ruleInput.where) };
+    } catch (error) {
+      throw new SchemaValidationError(
+        error instanceof Error ? error.message : "Invalid sync rule",
+        { collection: collectionName }
+      );
+    }
+  }
+  return sync;
+}
+function applySyncRulesToCollectionScope(collections, sync) {
+  if (!sync) {
+    return;
+  }
+  for (const [collectionName, rule] of Object.entries(sync)) {
+    const collection = collections[collectionName];
+    if (!collection) {
+      continue;
+    }
+    for (const fieldName of Object.keys(rule.where)) {
+      if (!collection.scope.includes(fieldName)) {
+        collection.scope.push(fieldName);
+      }
+    }
+  }
+}
 function validateFieldName(collection, fieldName) {
   if (RESERVED_FIELDS.has(fieldName)) {
     throw new SchemaValidationError(
@@ -848,6 +1099,7 @@ function generateSQL(collectionName, collection, relations) {
   }
   columns.push("_created_at INTEGER NOT NULL");
   columns.push("_updated_at INTEGER NOT NULL");
+  columns.push("_version TEXT NOT NULL DEFAULT ''");
   columns.push("_deleted INTEGER NOT NULL DEFAULT 0");
   statements.push(`CREATE TABLE IF NOT EXISTS ${collectionName} (
   ${columns.join(",\n  ")}
@@ -857,6 +1109,10 @@ function generateSQL(collectionName, collection, relations) {
     statements.push(`--kora:safe-alter
 ALTER TABLE ${collectionName} ADD COLUMN ${colDef}`);
   }
+  statements.push(
+    `--kora:safe-alter
+ALTER TABLE ${collectionName} ADD COLUMN _version TEXT NOT NULL DEFAULT ''`
+  );
   for (const indexField of collection.indexes) {
     statements.push(
       `CREATE INDEX IF NOT EXISTS idx_${collectionName}_${indexField} ON ${collectionName} (${indexField})`
@@ -896,6 +1152,18 @@ function generateFullDDL(schema) {
   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_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));
   }
@@ -1024,10 +1292,24 @@ var EnumFieldBuilder = class _EnumFieldBuilder extends FieldBuilder {
     );
   }
   default(value) {
-    return new _EnumFieldBuilder(this._enumValues, false, value, this._auto, this._mergeStrategy, this._transitions);
+    return new _EnumFieldBuilder(
+      this._enumValues,
+      false,
+      value,
+      this._auto,
+      this._mergeStrategy,
+      this._transitions
+    );
   }
   auto() {
-    return new _EnumFieldBuilder(this._enumValues, false, void 0, true, this._mergeStrategy, this._transitions);
+    return new _EnumFieldBuilder(
+      this._enumValues,
+      false,
+      void 0,
+      true,
+      this._mergeStrategy,
+      this._transitions
+    );
   }
   merge(strategy) {
     return new _EnumFieldBuilder(
@@ -1513,12 +1795,13 @@ function vectorsEqual(a, b) {
   }
   return true;
 }
-function computeDelta(localVector, remoteVector, operationLog) {
+async function computeDelta(localVector, remoteVector, operationLog) {
   const missing = [];
   for (const [nodeId, localSeq] of localVector) {
     const remoteSeq = remoteVector.get(nodeId) ?? 0;
     if (localSeq > remoteSeq) {
-      missing.push(...operationLog.getRange(nodeId, remoteSeq + 1, localSeq));
+      const ops = await operationLog.getRange(nodeId, remoteSeq + 1, localSeq);
+      missing.push(...ops);
     }
   }
   return topologicalSort(missing);
@@ -1535,12 +1818,17 @@ function deserializeVector(s) {
 // src/scopes/build-scope-map.ts
 function buildScopeMap(schema, scopeValues) {
   const result = {};
-  for (const [collName, collDef] of Object.entries(schema.collections)) {
-    if (collDef.scope.length > 0) {
+  const partialSync = hasSchemaSyncRules(schema);
+  for (const collName of Object.keys(schema.collections)) {
+    if (partialSync && !isCollectionSyncScoped(schema, collName)) {
+      continue;
+    }
+    const bindings = getCollectionScopeBindings(schema, collName);
+    if (bindings) {
       const collScope = {};
-      for (const field of collDef.scope) {
-        if (field in scopeValues) {
-          collScope[field] = scopeValues[field];
+      for (const [field, scopeKey] of Object.entries(bindings)) {
+        if (scopeKey in scopeValues) {
+          collScope[field] = scopeValues[scopeKey];
         }
       }
       result[collName] = collScope;
@@ -1551,6 +1839,34 @@ function buildScopeMap(schema, scopeValues) {
   return result;
 }
 
+// src/scopes/extract-scope-from-claims.ts
+function collectSchemaScopeFields(schema) {
+  return collectSchemaScopeValueKeys(schema);
+}
+function extractScopeValuesFromClaims(schema, claims) {
+  const scopeFields = collectSchemaScopeValueKeys(schema);
+  if (scopeFields.length === 0) {
+    return {};
+  }
+  const nestedScope = claims.scope;
+  const scopeObject = typeof nestedScope === "object" && nestedScope !== null && !Array.isArray(nestedScope) ? nestedScope : {};
+  const result = {};
+  for (const field of scopeFields) {
+    if (field in claims) {
+      result[field] = claims[field];
+      continue;
+    }
+    if (field in scopeObject) {
+      result[field] = scopeObject[field];
+      continue;
+    }
+    if (field === "userId" && typeof claims.sub === "string") {
+      result.userId = claims.sub;
+    }
+  }
+  return result;
+}
+
 // src/sequences/sequence-format.ts
 function formatSequenceValue(template, counter, nodeId, now) {
   const date = now ?? /* @__PURE__ */ new Date();
@@ -1577,6 +1893,29 @@ 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 = [];
@@ -2121,12 +2460,16 @@ function generateProtoDefinitions(schema) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  APPLY_FAILURE_CODES,
+  APPLY_RESULTS,
   ArrayFieldBuilder,
   CONNECTION_QUALITIES,
+  CausalTracker,
   ClockDriftError,
   EnumFieldBuilder,
   FieldBuilder,
   HybridLogicalClock,
+  KORA_ERROR_FIX_SUGGESTIONS,
   KoraError,
   MERGE_STRATEGIES,
   MergeConflictError,
@@ -2138,17 +2481,22 @@ function generateProtoDefinitions(schema) {
   StorageError,
   SyncError,
   advanceVector,
+  applyOperationTransforms,
   buildScopeMap,
   buildStateMachineConstraints,
   canAutoRollback,
+  collectSchemaScopeFields,
+  collectSchemaScopeValueKeys,
   computeDelta,
   createOperation,
   createReversibleMigration,
   createVersionVector,
+  defaultApplyFailureReason,
   defaultSequenceFormat,
   defineSchema,
   deserializeVector,
   dominates,
+  extractScopeValuesFromClaims,
   extractTimestamp,
   formatSequenceValue,
   generateFullDDL,
@@ -2156,8 +2504,13 @@ function generateProtoDefinitions(schema) {
   generateRollbackSteps,
   generateSQL,
   generateUUIDv7,
+  getCollectionScopeBindings,
+  getKoraErrorFix,
   getTransitionMap,
+  hasSchemaSyncRules,
+  isApplyFailure,
   isAtomicOp,
+  isCollectionSyncScoped,
   isValidOperation,
   isValidUUIDv7,
   mergeVectors,