@korajs/store 0.6.0 → 1.0.0-beta.1

package/dist/index.cjs

@@ -30,6 +30,38 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/serialization/op-data-encoding.ts
+function encodeRichtextFieldsForOpData(data, fields) {
+  const result = { ...data };
+  for (const [key, value] of Object.entries(data)) {
+    if (fields[key]?.kind !== "richtext") {
+      continue;
+    }
+    if (typeof value === "string" || value instanceof Uint8Array || value instanceof ArrayBuffer) {
+      result[key] = (0, import_core4.encodeBytesForOpData)(value);
+    }
+  }
+  return result;
+}
+function decodeRichtextFieldsFromOpData(data, fields) {
+  const result = { ...data };
+  for (const [key, value] of Object.entries(data)) {
+    if (fields[key]?.kind !== "richtext" || value === null || value === void 0) {
+      continue;
+    }
+    result[key] = (0, import_core4.decodeBytesFromOpData)(value);
+  }
+  return result;
+}
+var import_core4, decodeRichtextOpDataValue;
+var init_op_data_encoding = __esm({
+  "src/serialization/op-data-encoding.ts"() {
+    "use strict";
+    import_core4 = require("@korajs/core");
+    decodeRichtextOpDataValue = import_core4.decodeBytesFromOpData;
+  }
+});
+
 // src/serialization/richtext-serializer.ts
 function encodeRichtext(value) {
   if (value === null || value === void 0) {
@@ -46,6 +78,10 @@ function encodeRichtext(value) {
   if (value instanceof ArrayBuffer) {
     return new Uint8Array(value);
   }
+  if ((0, import_core4.isKoraBytesValue)(value) || (0, import_core4.isLegacyNumericByteObject)(value)) {
+    const decoded = decodeRichtextOpDataValue(value);
+    return decoded instanceof Uint8Array ? decoded : null;
+  }
   throw new Error("Richtext value must be a string, Uint8Array, ArrayBuffer, null, or undefined.");
 }
 function decodeRichtext(value) {
@@ -84,6 +120,7 @@ var init_richtext_serializer = __esm({
   "src/serialization/richtext-serializer.ts"() {
     "use strict";
     Y = __toESM(require("yjs"), 1);
+    init_op_data_encoding();
     TEXT_KEY = "content";
   }
 });
@@ -147,7 +184,7 @@ function serializeOperation(op) {
     record_id: op.recordId,
     data: dataPayload ? JSON.stringify(dataPayload) : null,
     previous_data: op.previousData ? JSON.stringify(op.previousData) : null,
-    timestamp: import_core4.HybridLogicalClock.serialize(op.timestamp),
+    timestamp: import_core5.HybridLogicalClock.serialize(op.timestamp),
     sequence_number: op.sequenceNumber,
     causal_deps: JSON.stringify(op.causalDeps),
     schema_version: op.schemaVersion
@@ -181,7 +218,7 @@ function deserializeOperation(row) {
     recordId: row.record_id,
     data,
     previousData: row.previous_data ? JSON.parse(row.previous_data) : null,
-    timestamp: import_core4.HybridLogicalClock.deserialize(row.timestamp),
+    timestamp: import_core5.HybridLogicalClock.deserialize(row.timestamp),
     sequenceNumber: row.sequence_number,
     causalDeps: JSON.parse(row.causal_deps),
     schemaVersion: row.schema_version,
@@ -202,6 +239,9 @@ function serializeValue(value, descriptor) {
     case "boolean":
       return value ? 1 : 0;
     case "array":
+    case "object":
+    case "json":
+    case "blob":
       return JSON.stringify(value);
     case "richtext":
       return encodeRichtext(value);
@@ -218,17 +258,24 @@ function deserializeValue(value, descriptor) {
         return JSON.parse(value);
       }
       return value;
+    case "object":
+    case "json":
+    case "blob":
+      if (typeof value === "string") {
+        return JSON.parse(value);
+      }
+      return value;
     case "richtext":
       return decodeRichtext(value);
     default:
       return value;
   }
 }
-var import_core4, ATOMIC_OPS_KEY, TX_ID_KEY, MUTATION_NAME_KEY;
+var import_core5, ATOMIC_OPS_KEY, TX_ID_KEY, MUTATION_NAME_KEY;
 var init_serializer = __esm({
   "src/serialization/serializer.ts"() {
     "use strict";
-    import_core4 = require("@korajs/core");
+    import_core5 = require("@korajs/core");
     init_richtext_serializer();
     ATOMIC_OPS_KEY = "__kora_atomic_ops__";
     TX_ID_KEY = "__kora_tx_id__";
@@ -609,11 +656,11 @@ async function computeSha256(data) {
   const hashArray = Array.from(new Uint8Array(hashBuffer));
   return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
 }
-var import_core5, BACKUP_VERSION;
+var import_core6, BACKUP_VERSION;
 var init_backup = __esm({
   "src/backup/backup.ts"() {
     "use strict";
-    import_core5 = require("@korajs/core");
+    import_core6 = require("@korajs/core");
     init_serializer();
     BACKUP_VERSION = 1;
   }
@@ -670,7 +717,7 @@ __export(audit_trace_store_exports, {
 });
 function persistedAuditTraceFromEvent(event) {
   return {
-    id: (0, import_core16.generateUUIDv7)(),
+    id: (0, import_core18.generateUUIDv7)(),
     recordedAt: Date.now(),
     eventType: event.type,
     constraint: event.type === "constraint:violated" ? event.constraint : void 0,
@@ -736,11 +783,11 @@ function auditTraceIndexFields(trace) {
     recordId: trace.operationA.recordId
   };
 }
-var import_core16;
+var import_core18;
 var init_audit_trace_store = __esm({
   "src/audit/audit-trace-store.ts"() {
     "use strict";
-    import_core16 = require("@korajs/core");
+    import_core18 = require("@korajs/core");
     init_audit_json();
   }
 });
@@ -936,10 +983,15 @@ var init_export_audit = __esm({
 var index_exports = {};
 __export(index_exports, {
   AdapterError: () => AdapterError,
+  BlobIntegrityError: () => BlobIntegrityError,
   COMPACTION_BASELINE_META_KEY: () => COMPACTION_BASELINE_META_KEY,
   Collection: () => Collection,
+  DEFAULT_CHUNK_SIZE: () => DEFAULT_CHUNK_SIZE,
   InvalidStateTransitionError: () => InvalidStateTransitionError,
   LAST_ACKED_SERVER_VECTOR_META_KEY: () => LAST_ACKED_SERVER_VECTOR_META_KEY,
+  MemoryBlobStore: () => MemoryBlobStore,
+  OpfsBlobStore: () => OpfsBlobStore,
+  OptimisticLockError: () => OptimisticLockError,
   PersistenceError: () => PersistenceError,
   QueryBuilder: () => QueryBuilder,
   QueryError: () => QueryError,
@@ -956,26 +1008,44 @@ __export(index_exports, {
   WorkerTimeoutError: () => WorkerTimeoutError,
   asRichTextSyncEngine: () => asRichTextSyncEngine,
   assertQueryReady: () => assertQueryReady,
+  chunkBlob: () => chunkBlob,
+  collectBlobGarbage: () => collectBlobGarbage,
   collectOperationsAheadOfServer: () => collectOperationsAheadOfServer,
   compactOperationLog: () => compactOperationLog,
   computeAckCompactionWatermark: () => computeAckCompactionWatermark,
+  createChunkPortPair: () => createChunkPortPair,
+  createMemoryServerBlobStore: () => createMemoryServerBlobStore,
+  createOpfsBlobDirectory: () => createOpfsBlobDirectory,
+  createOpfsBlobStore: () => createOpfsBlobStore,
+  createRemoteChunkProvider: () => createRemoteChunkProvider,
   createRichTextController: () => createRichTextController,
   decodeAuditExport: () => decodeAuditExport,
   decodeRichtext: () => decodeRichtext,
   deserializeVersionVectorFromMeta: () => deserializeVersionVectorFromMeta,
   encodeRichtext: () => encodeRichtext,
   exportBackup: () => exportBackup,
+  extractBlobRefs: () => extractBlobRefs,
+  fetchBlobManifest: () => fetchBlobManifest,
   getSharedQueryStoreCache: () => getSharedQueryStoreCache,
   mergeVersionVectors: () => mergeVersionVectors,
+  parseBlobManifest: () => parseBlobManifest,
   persistedAuditTraceFromEvent: () => persistedAuditTraceFromEvent,
   pluralize: () => pluralize,
+  prepareBlobForSend: () => prepareBlobForSend,
+  putBlobForTransfer: () => putBlobForTransfer,
   readAuditExportManifest: () => readAuditExportManifest,
   readBackupManifest: () => readBackupManifest,
+  reassembleBlob: () => reassembleBlob,
+  receiveBlob: () => receiveBlob,
+  resolveBlobManifest: () => resolveBlobManifest,
   restoreBackup: () => restoreBackup,
   richtextStatesEqual: () => richtextStatesEqual,
   richtextToPlainText: () => richtextToPlainText,
+  serializeBlobManifest: () => serializeBlobManifest,
   serializeVersionVectorToMeta: () => serializeVersionVectorToMeta,
+  serveBlobChunks: () => serveBlobChunks,
   singularize: () => singularize,
+  toServerBlobCallbacks: () => toServerBlobCallbacks,
   validateStateTransition: () => validateStateTransition,
   validateUpdateStateMachine: () => validateUpdateStateMachine,
   verifyAuditExportChecksum: () => verifyAuditExportChecksum,
@@ -1000,6 +1070,16 @@ var RecordNotFoundError = class extends import_core.KoraError {
     this.name = "RecordNotFoundError";
   }
 };
+var OptimisticLockError = class extends import_core.KoraError {
+  constructor(collection, recordId) {
+    super(
+      `Row version changed while merging record "${recordId}" in "${collection}"; retry with fresh state`,
+      "OPTIMISTIC_LOCK",
+      { collection, recordId }
+    );
+    this.name = "OptimisticLockError";
+  }
+};
 var AdapterError = class extends import_core.KoraError {
   constructor(message, context) {
     super(message, "ADAPTER_ERROR", context);
@@ -1176,27 +1256,27 @@ async function saveDeltaCursor(adapter, cursor) {
 }
 
 // src/store/store.ts
-var import_core17 = require("@korajs/core");
+var import_core19 = require("@korajs/core");
 init_backup();
 
 // src/mutations/execute-delete.ts
-var import_core7 = require("@korajs/core");
+var import_core8 = require("@korajs/core");
 
 // src/lww/row-version.ts
-var import_core6 = require("@korajs/core");
+var import_core7 = require("@korajs/core");
 var EMPTY_ROW_VERSION = "";
 function serializeRowVersion(timestamp) {
-  return import_core6.HybridLogicalClock.serialize(timestamp);
+  return import_core7.HybridLogicalClock.serialize(timestamp);
 }
 function rowVersionFromRecord(row) {
   const version = row._version;
   if (typeof version === "string" && version.length > 0) {
-    return import_core6.HybridLogicalClock.deserialize(version);
+    return import_core7.HybridLogicalClock.deserialize(version);
   }
   return { wallTime: row._updated_at, logical: 0, nodeId: "" };
 }
 function isIncomingNewerThanRow(incoming, row) {
-  return import_core6.HybridLogicalClock.compare(incoming, rowVersionFromRecord(row)) > 0;
+  return import_core7.HybridLogicalClock.compare(incoming, rowVersionFromRecord(row)) > 0;
 }
 function lwwVersionWhereClause(remoteVersion) {
   return {
@@ -1256,6 +1336,28 @@ function buildUpdateQuery(collection, id, changes) {
   const sql = `UPDATE ${collection} SET ${setClauses.join(", ")} WHERE id = ?`;
   return { sql, params };
 }
+function buildFieldFastForwardUpdateQuery(collection, id, fieldChanges, remoteVersion, wallTime, options) {
+  const fieldClauses = Object.keys(fieldChanges).map((col) => `${col} = ?`);
+  const setClauses = [
+    ...fieldClauses,
+    "_version = CASE WHEN _version >= ? THEN _version ELSE ? END",
+    "_updated_at = CASE WHEN _updated_at >= ? THEN _updated_at ELSE ? END"
+  ];
+  const params = [
+    ...Object.values(fieldChanges),
+    remoteVersion,
+    remoteVersion,
+    wallTime,
+    wallTime
+  ];
+  if (options?.maxCreatedAt !== void 0) {
+    setClauses.push("_created_at = CASE WHEN _created_at >= ? THEN _created_at ELSE ? END");
+    params.push(options.maxCreatedAt, options.maxCreatedAt);
+  }
+  params.push(id);
+  const sql = `UPDATE ${collection} SET ${setClauses.join(", ")} WHERE id = ?`;
+  return { sql, params };
+}
 function buildSoftDeleteQuery(collection, id, updatedAt, version) {
   if (version !== void 0) {
     return {
@@ -1268,13 +1370,6 @@ function buildSoftDeleteQuery(collection, id, updatedAt, version) {
     params: [updatedAt, id]
   };
 }
-function buildLwwUpdateQuery(collection, id, changes, remoteVersion) {
-  const setClauses = Object.keys(changes).map((col) => `${col} = ?`);
-  const lww = lwwVersionWhereClause(remoteVersion);
-  const sql = `UPDATE ${collection} SET ${setClauses.join(", ")} WHERE id = ? AND ${lww.sql}`;
-  const params = [...Object.values(changes), id, ...lww.params];
-  return { sql, params };
-}
 function buildLwwSoftDeleteQuery(collection, id, updatedAt, version) {
   const lww = lwwVersionWhereClause(version);
   return {
@@ -1439,7 +1534,7 @@ async function executeDelete(ctx, id, options) {
   await ctx.adapter.transaction(async (tx) => {
     if (!operation) {
       const sequenceNumber = await allocateNextSequenceInTransaction(tx, ctx.nodeId);
-      operation = await (0, import_core7.createOperation)(
+      operation = await (0, import_core8.createOperation)(
         {
           nodeId: ctx.nodeId,
           type: "delete",
@@ -1486,28 +1581,90 @@ async function executeDelete(ctx, id, options) {
 }
 
 // src/mutations/execute-insert.ts
-var import_core8 = require("@korajs/core");
+var import_core9 = require("@korajs/core");
+
+// src/lww/field-versions.ts
+function parseFieldVersions(raw) {
+  if (typeof raw !== "string" || raw.length === 0) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {};
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(parsed)) {
+      if (typeof value === "string") {
+        result[key] = value;
+      }
+    }
+    return result;
+  } catch {
+    return {};
+  }
+}
+function serializeFieldVersions(versions) {
+  return JSON.stringify(versions);
+}
+function fieldVersionsForFields(fieldNames, version) {
+  const versions = {};
+  for (const field of fieldNames) {
+    versions[field] = version;
+  }
+  return versions;
+}
+function effectiveFieldVersion(current, field, rowVersion) {
+  const own = current[field];
+  if (own !== void 0) {
+    return own;
+  }
+  return rowVersion ?? EMPTY_ROW_VERSION;
+}
+function resolvePerFieldLww(current, incomingFields, incomingVersion, rowVersion) {
+  const winners = [];
+  const merged = { ...current };
+  for (const field of incomingFields) {
+    const stored = effectiveFieldVersion(current, field, rowVersion);
+    if (incomingVersion > stored) {
+      winners.push(field);
+      merged[field] = incomingVersion;
+    }
+  }
+  return { winners, merged };
+}
+
+// src/mutations/execute-insert.ts
+init_op_data_encoding();
 init_serializer();
 async function executeInsert(ctx, data) {
-  const validated = (0, import_core8.validateRecord)(ctx.collection, ctx.definition, data, "insert");
-  const recordId = (0, import_core8.generateUUIDv7)();
+  const validated = (0, import_core9.validateRecord)(ctx.collection, ctx.definition, data, "insert");
+  const recordId = (0, import_core9.generateUUIDv7)();
   for (const [fieldName, descriptor] of Object.entries(ctx.definition.fields)) {
     if (descriptor.auto && descriptor.kind === "timestamp") {
       validated[fieldName] = Date.now();
     }
   }
+  const writeData = await (0, import_core9.transformSecretFieldsForWrite)(
+    validated,
+    ctx.definition,
+    ctx.secretKeyProvider
+  );
   const causalDeps = resolveCausalDeps(ctx);
   let operation;
   let record;
   await ctx.adapter.transaction(async (tx) => {
     const sequenceNumber = await allocateNextSequenceInTransaction(tx, ctx.nodeId);
-    operation = await (0, import_core8.createOperation)(
+    operation = await (0, import_core9.createOperation)(
       {
         nodeId: ctx.nodeId,
         type: "insert",
         collection: ctx.collection,
         recordId,
-        data: { ...validated },
+        // Binary richtext values are tagged as canonical JSON BEFORE the
+        // operation is content-hashed, so the hash input, persisted JSON,
+        // and wire payload are the identical value.
+        data: encodeRichtextFieldsForOpData(writeData, ctx.definition.fields),
         previousData: null,
         sequenceNumber,
         causalDeps,
@@ -1516,14 +1673,19 @@ async function executeInsert(ctx, data) {
       ctx.clock
     );
     ctx.causalTracker?.afterOperation(ctx.collection, operation.id, ctx.inTransaction);
-    const serializedData = serializeRecord(validated, ctx.definition.fields);
+    const serializedData = serializeRecord(writeData, ctx.definition.fields);
     const version = serializeRowVersion(operation.timestamp);
     record = {
       id: recordId,
       ...serializedData,
       _created_at: operation.timestamp.wallTime,
       _updated_at: operation.timestamp.wallTime,
-      _version: version
+      _version: version,
+      // Stamp every inserted field with this operation's version so later
+      // per-field LWW compares against a real writer, not the fallback.
+      _field_versions: serializeFieldVersions(
+        fieldVersionsForFields(Object.keys(serializedData), version)
+      )
     };
     const builtInsert = buildInsertQuery(ctx.collection, record);
     const opInsert = buildInsertQuery(
@@ -1536,19 +1698,20 @@ async function executeInsert(ctx, data) {
   ctx.onMutation(ctx.collection, operation);
   return {
     id: recordId,
-    ...validated,
+    ...writeData,
     createdAt: operation.timestamp.wallTime,
     updatedAt: operation.timestamp.wallTime
   };
 }
 
 // src/mutations/execute-update.ts
-var import_core10 = require("@korajs/core");
+var import_core11 = require("@korajs/core");
+init_op_data_encoding();
 init_serializer();
 
 // src/state-machine/state-validator.ts
-var import_core9 = require("@korajs/core");
-var InvalidStateTransitionError = class extends import_core9.KoraError {
+var import_core10 = require("@korajs/core");
+var InvalidStateTransitionError = class extends import_core10.KoraError {
   constructor(collection, recordId, field, fromState, toState, allowedStates) {
     super(
       `Invalid state transition in collection "${collection}": cannot transition field "${field}" from "${fromState}" to "${toState}". Allowed transitions from "${fromState}": ${allowedStates.length > 0 ? allowedStates.join(", ") : "(none -- terminal state)"}`,
@@ -1582,7 +1745,7 @@ function validateStateTransition(collectionName, recordId, stateMachine, current
     collection: collectionName,
     transitions: stateMachine.transitions
   };
-  const transitionResult = (0, import_core9.validateTransition)(constraint, currentState, newState);
+  const transitionResult = (0, import_core10.validateTransition)(constraint, currentState, newState);
   if (transitionResult.valid) {
     return { valid: true, allowedStates: transitionResult.allowedTargets };
   }
@@ -1638,7 +1801,7 @@ async function executeUpdate(ctx, id, data) {
   if (!currentRow) {
     throw new RecordNotFoundError(ctx.collection, id);
   }
-  let validated = (0, import_core10.validateRecord)(ctx.collection, ctx.definition, data, "update");
+  let validated = (0, import_core11.validateRecord)(ctx.collection, ctx.definition, data, "update");
   const currentRecord = deserializeRecord(currentRow, ctx.definition.fields);
   validated = validateUpdateStateMachine(
     ctx.collection,
@@ -1656,26 +1819,34 @@ async function executeUpdate(ctx, id, data) {
   for (const key of Object.keys(validated)) {
     const value = validated[key];
     previousData[key] = currentRecord[key];
-    if ((0, import_core10.isAtomicOp)(value)) {
-      resolvedData[key] = (0, import_core10.resolveAtomicOp)(currentRecord[key], value);
-      atomicOps[key] = (0, import_core10.toAtomicOp)(value);
+    if ((0, import_core11.isAtomicOp)(value)) {
+      resolvedData[key] = (0, import_core11.resolveAtomicOp)(currentRecord[key], value);
+      atomicOps[key] = (0, import_core11.toAtomicOp)(value);
     } else {
       resolvedData[key] = value;
     }
   }
+  const writeData = await (0, import_core11.transformSecretFieldsForWrite)(
+    resolvedData,
+    ctx.definition,
+    ctx.secretKeyProvider
+  );
   const hasAtomicOps = Object.keys(atomicOps).length > 0;
   const causalDeps = resolveCausalDeps(ctx);
   let operation;
   await ctx.adapter.transaction(async (tx) => {
     const sequenceNumber = await allocateNextSequenceInTransaction(tx, ctx.nodeId);
-    operation = await (0, import_core10.createOperation)(
+    operation = await (0, import_core11.createOperation)(
       {
         nodeId: ctx.nodeId,
         type: "update",
         collection: ctx.collection,
         recordId: id,
-        data: { ...resolvedData },
-        previousData,
+        // Binary richtext values (new and previous) are tagged as canonical
+        // JSON BEFORE the operation is content-hashed, so the hash input,
+        // persisted JSON, and wire payload are the identical value.
+        data: encodeRichtextFieldsForOpData(writeData, ctx.definition.fields),
+        previousData: encodeRichtextFieldsForOpData(previousData, ctx.definition.fields),
         sequenceNumber,
         causalDeps,
         schemaVersion: ctx.schema.version,
@@ -1684,12 +1855,17 @@ async function executeUpdate(ctx, id, data) {
       ctx.clock
     );
     ctx.causalTracker?.afterOperation(ctx.collection, operation.id, ctx.inTransaction);
-    const serializedChanges = serializeRecord(resolvedData, ctx.definition.fields);
+    const serializedChanges = serializeRecord(writeData, ctx.definition.fields);
     const version = serializeRowVersion(operation.timestamp);
+    const mergedFieldVersions = parseFieldVersions(currentRow._field_versions);
+    for (const changedField of Object.keys(serializedChanges)) {
+      mergedFieldVersions[changedField] = version;
+    }
     const updateQuery = buildUpdateQuery(ctx.collection, id, {
       ...serializedChanges,
       _updated_at: operation.timestamp.wallTime,
-      _version: version
+      _version: version,
+      _field_versions: serializeFieldVersions(mergedFieldVersions)
     });
     const opInsert = buildInsertQuery(
       `_kora_ops_${ctx.collection}`,
@@ -1713,7 +1889,7 @@ async function executeUpdate(ctx, id, data) {
 // src/collection/collection.ts
 init_serializer();
 var Collection = class {
-  constructor(name, definition, schema, adapter, clock, nodeId, allocateSequenceNumber, onMutation, relationEnforcer, mutationHandler, causalTracker) {
+  constructor(name, definition, schema, adapter, clock, nodeId, allocateSequenceNumber, onMutation, relationEnforcer, mutationHandler, causalTracker, secretKeyProvider) {
     this.name = name;
     this.definition = definition;
     this.schema = schema;
@@ -1725,6 +1901,7 @@ var Collection = class {
     this.relationEnforcer = relationEnforcer;
     this.mutationHandler = mutationHandler;
     this.causalTracker = causalTracker;
+    this.secretKeyProvider = secretKeyProvider;
   }
   name;
   definition;
@@ -1737,6 +1914,7 @@ var Collection = class {
   relationEnforcer;
   mutationHandler;
   causalTracker;
+  secretKeyProvider;
   mutationContext() {
     return {
       collection: this.name,
@@ -1749,7 +1927,8 @@ var Collection = class {
       onMutation: this.onMutation,
       relationEnforcer: this.relationEnforcer,
       causalTracker: this.causalTracker,
-      inTransaction: false
+      inTransaction: false,
+      secretKeyProvider: this.secretKeyProvider
     };
   }
   async insert(data) {
@@ -2089,7 +2268,7 @@ var QueryError2 = class extends Error {
 };
 
 // src/relations/relation-enforcer.ts
-var import_core11 = require("@korajs/core");
+var import_core12 = require("@korajs/core");
 init_serializer();
 
 // src/relations/relation-lookup.ts
@@ -2114,7 +2293,7 @@ function getIncomingRelations(lookup, collection) {
 }
 
 // src/relations/relation-enforcer.ts
-var ReferentialIntegrityError = class extends import_core11.KoraError {
+var ReferentialIntegrityError = class extends import_core12.KoraError {
   constructor(collection, recordId, referencingCollection, relationName, referencingCount) {
     super(
       `Cannot delete record "${recordId}" from "${collection}": ${referencingCount} record(s) in "${referencingCollection}" reference it via relation "${relationName}" with onDelete: 'restrict'. Delete or reassign the referencing records first.`,
@@ -2203,7 +2382,7 @@ var RelationEnforcer = class {
     for (const row of referencingRows) {
       const now = Date.now();
       const sequenceNumber = await allocateNextSequenceInTransaction(tx, this.nodeId);
-      const operation = await (0, import_core11.createOperation)(
+      const operation = await (0, import_core12.createOperation)(
         {
           nodeId: this.nodeId,
           type: "delete",
@@ -2252,7 +2431,7 @@ var RelationEnforcer = class {
       const sequenceNumber = await allocateNextSequenceInTransaction(tx, this.nodeId);
       const updateData = { [foreignKeyField]: null };
       const previousData = { [foreignKeyField]: deletedRecordId };
-      const operation = await (0, import_core11.createOperation)(
+      const operation = await (0, import_core12.createOperation)(
         {
           nodeId: this.nodeId,
           type: "update",
@@ -2313,8 +2492,9 @@ var RelationEnforcer = class {
 };
 
 // src/replay/replay-to.ts
-var import_core12 = require("@korajs/core");
+var import_core13 = require("@korajs/core");
 var import_internal = require("@korajs/core/internal");
+init_op_data_encoding();
 function collectCausalClosure(allOps, targetOperationId) {
   const opMap = /* @__PURE__ */ new Map();
   for (const op of allOps) {
@@ -2322,7 +2502,7 @@ function collectCausalClosure(allOps, targetOperationId) {
   }
   const target = opMap.get(targetOperationId);
   if (!target) {
-    throw new import_core12.OperationError(
+    throw new import_core13.OperationError(
       `Operation "${targetOperationId}" not found in the local operation log`,
       {
         operationId: targetOperationId
@@ -2354,7 +2534,7 @@ function buildReplaySnapshot(schema, allOps, targetOperationId) {
   const operationsApplied = collectCausalClosure(allOps, targetOperationId);
   const targetOperation = operationsApplied.find((op) => op.id === targetOperationId);
   if (!targetOperation) {
-    throw new import_core12.OperationError(`Operation "${targetOperationId}" not found after causal sort`, {
+    throw new import_core13.OperationError(`Operation "${targetOperationId}" not found after causal sort`, {
       operationId: targetOperationId
     });
   }
@@ -2399,7 +2579,9 @@ function applyOperationToMemory(state, op, schema) {
       }
       colMap.set(op.recordId, {
         id: op.recordId,
-        fields: { ...op.data },
+        // op.data stores binary richtext as tagged JSON; snapshots must
+        // expose record-shaped values (Uint8Array/string).
+        fields: decodeRichtextFieldsFromOpData(op.data, definition.fields),
         deleted: false,
         createdAt: wallTime,
         updatedAt: wallTime
@@ -2410,9 +2592,10 @@ function applyOperationToMemory(state, op, schema) {
       if (!op.data) {
         return;
       }
+      const decodedData = decodeRichtextFieldsFromOpData(op.data, definition.fields);
       const existing = colMap.get(op.recordId);
       if (existing && !existing.deleted) {
-        existing.fields = { ...existing.fields, ...op.data };
+        existing.fields = { ...existing.fields, ...decodedData };
         existing.updatedAt = wallTime;
         break;
       }
@@ -2421,7 +2604,7 @@ function applyOperationToMemory(state, op, schema) {
       }
       colMap.set(op.recordId, {
         id: op.recordId,
-        fields: { ...op.data },
+        fields: decodedData,
         deleted: false,
         createdAt: wallTime,
         updatedAt: wallTime
@@ -2477,7 +2660,7 @@ function toCollectionRecord(record, definition) {
 }
 
 // src/sequences/sequence-manager.ts
-var import_core13 = require("@korajs/core");
+var import_core14 = require("@korajs/core");
 var SequenceManager = class {
   adapter;
   nodeId;
@@ -2495,7 +2678,7 @@ var SequenceManager = class {
   async next(name, config) {
     const scope = config?.scope ?? "";
     const startAt = config?.startAt ?? 1;
-    const format = config?.format ?? (0, import_core13.defaultSequenceFormat)(name);
+    const format = config?.format ?? (0, import_core14.defaultSequenceFormat)(name);
     let counter = 0;
     await this.adapter.transaction(async (tx) => {
       const rows = await tx.query(
@@ -2517,7 +2700,7 @@ var SequenceManager = class {
         );
       }
     });
-    return (0, import_core13.formatSequenceValue)(format, counter, this.nodeId);
+    return (0, import_core14.formatSequenceValue)(format, counter, this.nodeId);
   }
   /**
    * Get the current counter value without incrementing.
@@ -2975,8 +3158,141 @@ var SubscriptionManager = class {
   }
 };
 
+// src/sync/rebase-unsynced-operations.ts
+var import_core15 = require("@korajs/core");
+var import_internal2 = require("@korajs/core/internal");
+init_serializer();
+var LOGICAL_COUNTER_LIMIT = import_core15.MAX_LOGICAL + 1;
+function emptyResult() {
+  return { operations: [], idMapping: {}, rebasedCount: 0, newMaxTimestamp: null };
+}
+async function rebaseUnsyncedOperationsInLog(adapter, schema, unsyncedOpIds, correctedNowMs) {
+  if (unsyncedOpIds.length === 0) {
+    return emptyResult();
+  }
+  const rebaseIds = new Set(unsyncedOpIds);
+  const rebased = [];
+  let maxOtherSerializedTs = null;
+  for (const collectionName of Object.keys(schema.collections)) {
+    const rows = await adapter.query(`SELECT * FROM _kora_ops_${collectionName}`);
+    for (const row of rows) {
+      if (rebaseIds.has(row.id)) {
+        rebased.push(deserializeOperationWithCollection(row, collectionName));
+      } else if (maxOtherSerializedTs === null || row.timestamp > maxOtherSerializedTs) {
+        maxOtherSerializedTs = row.timestamp;
+      }
+    }
+  }
+  if (rebased.length === 0) {
+    return emptyResult();
+  }
+  const maxOtherWallTime = maxOtherSerializedTs === null ? Number.NEGATIVE_INFINITY : import_core15.HybridLogicalClock.deserialize(maxOtherSerializedTs).wallTime;
+  const baseWallTime = Math.max(correctedNowMs, maxOtherWallTime + 1);
+  rebased.sort((a, b) => import_core15.HybridLogicalClock.compare(a.timestamp, b.timestamp));
+  const newTimestamps = rebased.map((op, i) => ({
+    // Spill into wallTime past the 5-digit logical serialization limit so the
+    // serialized order stays correct even for enormous offline queues.
+    wallTime: baseWallTime + Math.floor(i / LOGICAL_COUNTER_LIMIT),
+    logical: i % LOGICAL_COUNTER_LIMIT,
+    nodeId: op.nodeId
+  }));
+  const idMapping = {};
+  const newIds = [];
+  for (let i = 0; i < rebased.length; i++) {
+    const op = rebased[i];
+    const ts = newTimestamps[i];
+    if (!op || !ts) {
+      continue;
+    }
+    const input = {
+      nodeId: op.nodeId,
+      type: op.type,
+      collection: op.collection,
+      recordId: op.recordId,
+      data: op.data,
+      previousData: op.previousData,
+      sequenceNumber: op.sequenceNumber,
+      causalDeps: op.causalDeps,
+      schemaVersion: op.schemaVersion,
+      ...op.atomicOps !== void 0 ? { atomicOps: op.atomicOps } : {}
+    };
+    const newId = await (0, import_internal2.computeOperationId)(input, import_core15.HybridLogicalClock.serialize(ts));
+    idMapping[op.id] = newId;
+    newIds.push(newId);
+  }
+  const newOperations = [];
+  for (let i = 0; i < rebased.length; i++) {
+    const op = rebased[i];
+    const ts = newTimestamps[i];
+    const newId = newIds[i];
+    if (!op || !ts || newId === void 0) {
+      continue;
+    }
+    newOperations.push({
+      ...op,
+      id: newId,
+      timestamp: ts,
+      causalDeps: op.causalDeps.map((dep) => idMapping[dep] ?? dep)
+    });
+  }
+  await adapter.transaction(async (tx) => {
+    for (let i = 0; i < rebased.length; i++) {
+      const oldOp = rebased[i];
+      const newOp = newOperations[i];
+      if (!oldOp || !newOp) {
+        continue;
+      }
+      const opsTable = `_kora_ops_${oldOp.collection}`;
+      await tx.execute(`DELETE FROM ${opsTable} WHERE id = ?`, [oldOp.id]);
+      const opInsert = buildInsertQuery(
+        opsTable,
+        serializeOperation(newOp)
+      );
+      await tx.execute(opInsert.sql, opInsert.params);
+      const oldVersion = serializeRowVersion(oldOp.timestamp);
+      const newVersion = serializeRowVersion(newOp.timestamp);
+      await tx.execute(
+        `UPDATE ${oldOp.collection} SET _version = ?, _updated_at = ? WHERE id = ? AND _version = ?`,
+        [newVersion, newOp.timestamp.wallTime, oldOp.recordId, oldVersion]
+      );
+      const rows = await tx.query(
+        `SELECT _field_versions FROM ${oldOp.collection} WHERE id = ?`,
+        [oldOp.recordId]
+      );
+      const fieldVersions = parseFieldVersions(rows[0]?._field_versions);
+      let changed = false;
+      for (const [field, version] of Object.entries(fieldVersions)) {
+        if (version === oldVersion) {
+          fieldVersions[field] = newVersion;
+          changed = true;
+        }
+      }
+      if (changed) {
+        await tx.execute(`UPDATE ${oldOp.collection} SET _field_versions = ? WHERE id = ?`, [
+          serializeFieldVersions(fieldVersions),
+          oldOp.recordId
+        ]);
+      }
+      if (oldOp.type === "insert") {
+        await tx.execute(
+          `UPDATE ${oldOp.collection} SET _created_at = ? WHERE id = ? AND _created_at = ?`,
+          [newOp.timestamp.wallTime, oldOp.recordId, oldOp.timestamp.wallTime]
+        );
+      }
+    }
+  });
+  const newMaxTimestamp = newTimestamps[newTimestamps.length - 1] ?? null;
+  return {
+    operations: newOperations,
+    idMapping,
+    rebasedCount: newOperations.length,
+    newMaxTimestamp
+  };
+}
+
 // src/transaction/transaction-context.ts
-var import_core14 = require("@korajs/core");
+var import_core16 = require("@korajs/core");
+init_op_data_encoding();
 init_serializer();
 var TransactionContext = class {
   transactionId;
@@ -2987,7 +3303,7 @@ var TransactionContext = class {
   config;
   constructor(config) {
     this.config = config;
-    this.transactionId = (0, import_core14.generateUUIDv7)();
+    this.transactionId = (0, import_core16.generateUUIDv7)();
   }
   /**
    * Set a human-readable mutation name for this transaction.
@@ -3102,8 +3418,8 @@ var TransactionContext = class {
   }
   async insert(collectionName, definition, data) {
     this.ensureActive();
-    const validated = (0, import_core14.validateRecord)(collectionName, definition, data, "insert");
-    const recordId = (0, import_core14.generateUUIDv7)();
+    const validated = (0, import_core16.validateRecord)(collectionName, definition, data, "insert");
+    const recordId = (0, import_core16.generateUUIDv7)();
     const now = Date.now();
     for (const [fieldName, descriptor] of Object.entries(definition.fields)) {
       if (descriptor.auto && descriptor.kind === "timestamp") {
@@ -3112,13 +3428,15 @@ var TransactionContext = class {
     }
     const sequenceNumber = await this.config.sequenceAllocator.allocate();
     const causalDeps = this.config.causalTracker?.nextCausalDeps(collectionName, true) ?? [];
-    const operation = await (0, import_core14.createOperation)(
+    const operation = await (0, import_core16.createOperation)(
       {
         nodeId: this.config.nodeId,
         type: "insert",
         collection: collectionName,
         recordId,
-        data: { ...validated },
+        // Binary richtext values are tagged as canonical JSON before the
+        // operation is content-hashed (see encodeRichtextFieldsForOpData).
+        data: encodeRichtextFieldsForOpData(validated, definition.fields),
         previousData: null,
         sequenceNumber,
         causalDeps,
@@ -3165,7 +3483,7 @@ var TransactionContext = class {
     if (!currentRecord) {
       throw new RecordNotFoundError(collectionName, id);
     }
-    const validated = (0, import_core14.validateRecord)(collectionName, definition, data, "update");
+    const validated = (0, import_core16.validateRecord)(collectionName, definition, data, "update");
     const now = Date.now();
     const previousData = {};
     const resolvedData = {};
@@ -3173,9 +3491,9 @@ var TransactionContext = class {
     for (const key of Object.keys(validated)) {
       const value = validated[key];
       previousData[key] = currentRecord[key];
-      if ((0, import_core14.isAtomicOp)(value)) {
-        resolvedData[key] = (0, import_core14.resolveAtomicOp)(currentRecord[key], value);
-        atomicOps[key] = (0, import_core14.toAtomicOp)(value);
+      if ((0, import_core16.isAtomicOp)(value)) {
+        resolvedData[key] = (0, import_core16.resolveAtomicOp)(currentRecord[key], value);
+        atomicOps[key] = (0, import_core16.toAtomicOp)(value);
       } else {
         resolvedData[key] = value;
       }
@@ -3183,14 +3501,16 @@ var TransactionContext = class {
     const hasAtomicOps = Object.keys(atomicOps).length > 0;
     const sequenceNumber = await this.config.sequenceAllocator.allocate();
     const causalDeps = this.config.causalTracker?.nextCausalDeps(collectionName, true) ?? [];
-    const operation = await (0, import_core14.createOperation)(
+    const operation = await (0, import_core16.createOperation)(
       {
         nodeId: this.config.nodeId,
         type: "update",
         collection: collectionName,
         recordId: id,
-        data: { ...resolvedData },
-        previousData,
+        // Binary richtext values (new and previous) are tagged as canonical
+        // JSON before the operation is content-hashed.
+        data: encodeRichtextFieldsForOpData(resolvedData, definition.fields),
+        previousData: encodeRichtextFieldsForOpData(previousData, definition.fields),
         sequenceNumber,
         causalDeps,
         schemaVersion: this.config.schema.version,
@@ -3236,7 +3556,7 @@ var TransactionContext = class {
     const now = Date.now();
     const sequenceNumber = await this.config.sequenceAllocator.allocate();
     const causalDeps = this.config.causalTracker?.nextCausalDeps(collectionName, true) ?? [];
-    const operation = await (0, import_core14.createOperation)(
+    const operation = await (0, import_core16.createOperation)(
       {
         nodeId: this.config.nodeId,
         type: "delete",
@@ -3297,14 +3617,16 @@ var TransactionContext = class {
       if (entry.operation.type === "insert" && entry.operation.data) {
         record = {
           id,
-          ...entry.operation.data,
+          // op.data stores binary richtext as tagged JSON; the effective
+          // record must expose record-shaped values (Uint8Array/string).
+          ...decodeRichtextFieldsFromOpData(entry.operation.data, definition.fields),
           createdAt: entry.operation.timestamp.wallTime,
           updatedAt: entry.operation.timestamp.wallTime
         };
       } else if (entry.operation.type === "update" && entry.operation.data && record) {
         record = {
           ...record,
-          ...entry.operation.data,
+          ...decodeRichtextFieldsFromOpData(entry.operation.data, definition.fields),
           updatedAt: entry.operation.timestamp.wallTime
         };
       } else if (entry.operation.type === "delete") {
@@ -3339,7 +3661,7 @@ var TransactionSequenceAllocator = class {
 };
 
 // src/store/tab-node-id.ts
-var import_core15 = require("@korajs/core");
+var import_core17 = require("@korajs/core");
 function perTabStorageKey(dbName) {
   return `kora-tab-node-${dbName}`;
 }
@@ -3360,7 +3682,7 @@ function resolvePerTabNodeId(dbName) {
   if (existing) {
     return existing;
   }
-  const nodeId = (0, import_core15.generateUUIDv7)();
+  const nodeId = (0, import_core17.generateUUIDv7)();
   savePerTabNodeId(dbName, nodeId);
   return nodeId;
 }
@@ -3370,7 +3692,7 @@ var Store = class {
   opened = false;
   nodeId = "";
   sequenceNumber = 0;
-  versionVector = (0, import_core17.createVersionVector)();
+  versionVector = (0, import_core19.createVersionVector)();
   clock = null;
   collections = /* @__PURE__ */ new Map();
   subscriptionManager;
@@ -3384,6 +3706,7 @@ var Store = class {
   localMutationHandler;
   relationEnforcer = null;
   causalTracker = null;
+  secretKeyProvider;
   constructor(config) {
     this.schema = config.schema;
     this.adapter = config.adapter;
@@ -3392,6 +3715,7 @@ var Store = class {
     this.isolation = config.isolation ?? "shared";
     this.emitter = config.emitter ?? null;
     this.localMutationHandler = config.localMutationHandler ?? null;
+    this.secretKeyProvider = config.secretKeyProvider;
     this.subscriptionManager = new SubscriptionManager({
       onQuerySubscribed: config.onQuerySubscribed
     });
@@ -3404,8 +3728,8 @@ var Store = class {
     await this.adapter.open(this.schema);
     await this.runMigrationsIfNeeded();
     this.nodeId = await this.loadOrGenerateNodeId();
-    this.clock = new import_core17.HybridLogicalClock(this.nodeId);
-    this.causalTracker = new import_core17.CausalTracker();
+    this.clock = new import_core19.HybridLogicalClock(this.nodeId);
+    this.causalTracker = new import_core19.CausalTracker();
     this.sequenceManager = new SequenceManager(this.adapter, this.nodeId);
     this.sequenceNumber = await this.loadSequenceNumber();
     this.versionVector = await this.loadVersionVector();
@@ -3434,7 +3758,8 @@ var Store = class {
         },
         this.relationEnforcer,
         this.localMutationHandler,
-        this.causalTracker
+        this.causalTracker,
+        this.secretKeyProvider
       );
       this.collections.set(name, col);
     }
@@ -3491,6 +3816,14 @@ var Store = class {
   /**
    * Get the node ID for this store instance.
    */
+  /**
+   * Records the offset between server time and this device's clock
+   * (serverTime - localTime), learned at sync handshake. Lets the store's HLC
+   * validate remote timestamps correctly even when the local clock is wrong.
+   */
+  setClockReferenceOffset(offsetMs) {
+    this.clock?.setReferenceOffset(offsetMs);
+  }
   getNodeId() {
     this.ensureOpen();
     return this.nodeId;
@@ -3517,45 +3850,158 @@ var Store = class {
     if (this.clock) {
       this.clock.receive(op.timestamp);
     }
-    const remoteVersion = serializeRowVersion(op.timestamp);
-    const wallTime = op.timestamp.wallTime;
+    const materializeTimestamp = options?.materializeTimestamp ?? op.timestamp;
+    const remoteVersion = serializeRowVersion(materializeTimestamp);
+    const wallTime = materializeTimestamp.wallTime;
+    const materializeSource = options?.materializeData ?? op.data;
     await this.adapter.transaction(async (tx) => {
-      if (op.type === "insert" && op.data) {
+      const checkGuard = (row) => {
+        const guard = options?.guardRowState;
+        if (!guard) {
+          return;
+        }
+        const version = typeof row?._version === "string" ? row._version : null;
+        const fieldVersions = typeof row?._field_versions === "string" ? row._field_versions : null;
+        if (version !== guard.version || fieldVersions !== guard.fieldVersions) {
+          throw new OptimisticLockError(collection, op.recordId);
+        }
+      };
+      if (op.type === "insert" && materializeSource) {
+        const serializedData = serializeRecord(materializeSource, definition.fields);
         const existing2 = await tx.query(
-          `SELECT _updated_at, _version FROM ${collection} WHERE id = ?`,
+          `SELECT _updated_at, _version, _field_versions, _deleted FROM ${collection} WHERE id = ?`,
           [op.recordId]
         );
         const row = existing2[0];
-        if (row && !isIncomingNewerThanRow(op.timestamp, row)) {
-        } else {
-          const serializedData = serializeRecord(op.data, definition.fields);
+        checkGuard(row);
+        if (!row) {
           const record = {
             id: op.recordId,
             ...serializedData,
             _created_at: wallTime,
             _updated_at: wallTime,
-            _version: remoteVersion
+            _version: remoteVersion,
+            // Stamp every inserted field so per-field LWW has a real baseline.
+            _field_versions: serializeFieldVersions(
+              fieldVersionsForFields(Object.keys(serializedData), remoteVersion)
+            )
           };
           const insertQuery = buildInsertQuery(collection, record);
           await tx.execute(insertQuery.sql, insertQuery.params);
+          await this.foldOrphanedOperations(tx, collection, definition, op.recordId);
+        } else if (row._deleted === 1) {
+          if (isIncomingNewerThanRow(materializeTimestamp, row)) {
+            const fieldChanges = {
+              ...serializedData,
+              _deleted: 0,
+              _field_versions: serializeFieldVersions(
+                fieldVersionsForFields(Object.keys(serializedData), remoteVersion)
+              )
+            };
+            const upsert = buildFieldFastForwardUpdateQuery(
+              collection,
+              op.recordId,
+              fieldChanges,
+              remoteVersion,
+              wallTime,
+              { maxCreatedAt: wallTime }
+            );
+            await tx.execute(upsert.sql, upsert.params);
+          }
+        } else {
+          const currentVersions = parseFieldVersions(row._field_versions);
+          const rowVersion = typeof row._version === "string" ? row._version : void 0;
+          const fieldChanges = {};
+          let fieldVersionsJson;
+          if (options?.forceMaterialize) {
+            const merged = { ...currentVersions };
+            for (const field of Object.keys(serializedData)) {
+              fieldChanges[field] = serializedData[field];
+              merged[field] = remoteVersion;
+            }
+            fieldVersionsJson = serializeFieldVersions(merged);
+          } else {
+            const { winners, merged } = resolvePerFieldLww(
+              currentVersions,
+              Object.keys(serializedData),
+              remoteVersion,
+              rowVersion
+            );
+            for (const field of winners) {
+              fieldChanges[field] = serializedData[field];
+            }
+            fieldVersionsJson = serializeFieldVersions(merged);
+          }
+          const upsert = buildFieldFastForwardUpdateQuery(
+            collection,
+            op.recordId,
+            { ...fieldChanges, _field_versions: fieldVersionsJson },
+            remoteVersion,
+            wallTime,
+            { maxCreatedAt: wallTime }
+          );
+          await tx.execute(upsert.sql, upsert.params);
         }
-      } else if (op.type === "update" && op.data) {
-        const serializedChanges = serializeRecord(op.data, definition.fields);
-        const updatePayload = {
-          ...serializedChanges,
-          _updated_at: wallTime,
-          _version: remoteVersion
-        };
-        if (options?.reactivateIfDeleted) {
-          updatePayload._deleted = 0;
-        }
-        const updateQuery = buildLwwUpdateQuery(
-          collection,
-          op.recordId,
-          updatePayload,
-          remoteVersion
+      } else if (op.type === "update" && materializeSource) {
+        const serializedChanges = serializeRecord(materializeSource, definition.fields);
+        const changedFields = Object.keys(serializedChanges);
+        const currentRows = await tx.query(
+          `SELECT _version, _field_versions FROM ${collection} WHERE id = ?`,
+          [op.recordId]
         );
-        await tx.execute(updateQuery.sql, updateQuery.params);
+        const currentRow = currentRows[0];
+        checkGuard(currentRow);
+        if (currentRow) {
+          const currentVersions = parseFieldVersions(currentRow._field_versions);
+          const rowVersion = typeof currentRow._version === "string" ? currentRow._version : void 0;
+          if (options?.forceMaterialize) {
+            const merged = { ...currentVersions };
+            for (const field of changedFields) {
+              merged[field] = remoteVersion;
+            }
+            const fieldChanges = {
+              ...serializedChanges,
+              _field_versions: serializeFieldVersions(merged)
+            };
+            if (options?.reactivateIfDeleted) {
+              fieldChanges._deleted = 0;
+            }
+            const forceQuery = buildFieldFastForwardUpdateQuery(
+              collection,
+              op.recordId,
+              fieldChanges,
+              remoteVersion,
+              wallTime
+            );
+            await tx.execute(forceQuery.sql, forceQuery.params);
+          } else {
+            const { winners, merged } = resolvePerFieldLww(
+              currentVersions,
+              changedFields,
+              remoteVersion,
+              rowVersion
+            );
+            if (winners.length > 0 || options?.reactivateIfDeleted) {
+              const winningChanges = {
+                _field_versions: serializeFieldVersions(merged)
+              };
+              for (const field of winners) {
+                winningChanges[field] = serializedChanges[field];
+              }
+              if (options?.reactivateIfDeleted) {
+                winningChanges._deleted = 0;
+              }
+              const forceQuery = buildFieldFastForwardUpdateQuery(
+                collection,
+                op.recordId,
+                winningChanges,
+                remoteVersion,
+                wallTime
+              );
+              await tx.execute(forceQuery.sql, forceQuery.params);
+            }
+          }
+        }
       } else if (op.type === "delete") {
         const deleteQuery = buildLwwSoftDeleteQuery(
           collection,
@@ -3583,6 +4029,67 @@ var Store = class {
     this.subscriptionManager.notify(collection, op);
     return "applied";
   }
+  /**
+   * Materialize update/delete operations that were logged for a record BEFORE
+   * its insert arrived (reordered delivery). Runs inside the insert's write
+   * transaction, folding each orphan in timestamp order through the exact
+   * per-field LWW / LWW-delete rules the normal apply paths use, so the final
+   * row state equals what a device that received the operations in causal
+   * order computed. Called only when the insert created a previously-absent
+   * row — in that case every logged update/delete for the record is
+   * necessarily an orphan (rows are soft-deleted, never removed, so a row
+   * that is absent now was never materialized).
+   */
+  async foldOrphanedOperations(tx, collection, definition, recordId) {
+    const orphanRows = await tx.query(
+      `SELECT * FROM _kora_ops_${collection} WHERE record_id = ? AND type IN ('update', 'delete')`,
+      [recordId]
+    );
+    if (orphanRows.length === 0) {
+      return;
+    }
+    const orphans = orphanRows.map((r) => deserializeOperationWithCollection(r, collection)).sort((a, b) => import_core19.HybridLogicalClock.compare(a.timestamp, b.timestamp));
+    for (const orphan of orphans) {
+      const orphanVersion = serializeRowVersion(orphan.timestamp);
+      const orphanWall = orphan.timestamp.wallTime;
+      if (orphan.type === "update" && orphan.data) {
+        const orphanChanges = serializeRecord(orphan.data, definition.fields);
+        const rows = await tx.query(
+          `SELECT _version, _field_versions FROM ${collection} WHERE id = ?`,
+          [recordId]
+        );
+        const current = rows[0];
+        if (!current) {
+          continue;
+        }
+        const { winners, merged } = resolvePerFieldLww(
+          parseFieldVersions(current._field_versions),
+          Object.keys(orphanChanges),
+          orphanVersion,
+          typeof current._version === "string" ? current._version : void 0
+        );
+        if (winners.length > 0) {
+          const winningChanges = {
+            _field_versions: serializeFieldVersions(merged)
+          };
+          for (const field of winners) {
+            winningChanges[field] = orphanChanges[field];
+          }
+          const query = buildFieldFastForwardUpdateQuery(
+            collection,
+            recordId,
+            winningChanges,
+            orphanVersion,
+            orphanWall
+          );
+          await tx.execute(query.sql, query.params);
+        }
+      } else if (orphan.type === "delete") {
+        const query = buildLwwSoftDeleteQuery(collection, recordId, orphanWall, orphanVersion);
+        await tx.execute(query.sql, query.params);
+      }
+    }
+  }
   /**
    * Get operations from a node within a sequence number range.
    * Implements the OperationLog interface for computeDelta.
@@ -3713,7 +4220,8 @@ var Store = class {
       relationEnforcer: this.relationEnforcer,
       causalTracker: this.causalTracker,
       inTransaction: options?.inTransaction ?? false,
-      extraCausalDeps: options?.extraCausalDeps
+      extraCausalDeps: options?.extraCausalDeps,
+      secretKeyProvider: this.secretKeyProvider
     };
   }
   /**
@@ -3738,6 +4246,31 @@ var Store = class {
       deleted: row._deleted === 1
     };
   }
+  /**
+   * Raw version state of a materialized row, for optimistic-concurrency guarded
+   * applies: capture this snapshot before computing a merge, pass it as
+   * `guardRowState`, and the apply refuses to write if the row changed since.
+   * Returns null when no row exists (which is itself a valid guard state — the
+   * apply then requires the row to still be absent).
+   */
+  async getRowVersionState(collection, recordId) {
+    this.ensureOpen();
+    if (!this.schema.collections[collection]) {
+      return null;
+    }
+    const rows = await this.adapter.query(
+      `SELECT _version, _field_versions FROM ${collection} WHERE id = ?`,
+      [recordId]
+    );
+    const row = rows[0];
+    if (!row) {
+      return null;
+    }
+    return {
+      version: typeof row._version === "string" ? row._version : null,
+      fieldVersions: typeof row._field_versions === "string" ? row._field_versions : null
+    };
+  }
   /**
    * Latest operation from this device for a record (used for delete-vs-update merge on sync).
    */
@@ -3780,6 +4313,30 @@ var Store = class {
       (nodeId, fromSeq, toSeq) => this.getOperationRange(nodeId, fromSeq, toSeq)
     );
   }
+  /**
+   * Re-stamp never-acknowledged local operations after a fast device clock was
+   * corrected, so sync can resume immediately. Safe because unacknowledged
+   * operations are private to this device (like unpushed git commits);
+   * acknowledged/shared operations are immutable and never touched.
+   *
+   * After the rewrite the store's HLC is advanced past the highest new
+   * timestamp so subsequent local writes keep sorting after the rebased ops.
+   * No data-change notifications are emitted: materialized values are
+   * unchanged, only version stamps move.
+   */
+  async rebaseUnsyncedOperations(unsyncedOpIds, correctedNowMs) {
+    this.ensureOpen();
+    const result = await rebaseUnsyncedOperationsInLog(
+      this.adapter,
+      this.schema,
+      unsyncedOpIds,
+      correctedNowMs
+    );
+    if (result.newMaxTimestamp && this.clock) {
+      this.clock.advanceTo(result.newMaxTimestamp);
+    }
+    return result;
+  }
   /**
    * Count of local operations ahead of the server version vector.
    */
@@ -3794,7 +4351,7 @@ var Store = class {
   async compact(strategy) {
     this.ensureOpen();
     if (strategy.mode === "never") {
-      return compactOperationLog(this.adapter, this.schema, strategy, (0, import_core17.createVersionVector)());
+      return compactOperationLog(this.adapter, this.schema, strategy, (0, import_core19.createVersionVector)());
     }
     const serverVector = strategy.serverVector ?? await loadLastAckedServerVector(this.adapter);
     return compactOperationLog(this.adapter, this.schema, strategy, serverVector);
@@ -3829,7 +4386,7 @@ var Store = class {
     let latest = null;
     for (const row of rows) {
       const op = deserializeOperationWithCollection(row, collection);
-      if (!latest || import_core17.HybridLogicalClock.compare(op.timestamp, latest.timestamp) > 0) {
+      if (!latest || import_core19.HybridLogicalClock.compare(op.timestamp, latest.timestamp) > 0) {
         latest = op;
       }
     }
@@ -3972,7 +4529,7 @@ var Store = class {
     for (let v = storedVersion + 1; v <= targetVersion; v++) {
       const migration = migrations[v];
       if (!migration) continue;
-      const sqlStatements = (0, import_core17.migrationStepsToSQL)(migration.steps);
+      const sqlStatements = (0, import_core19.migrationStepsToSQL)(migration.steps);
       for (const sql of sqlStatements) {
         try {
           await this.adapter.execute(sql);
@@ -4050,7 +4607,7 @@ var Store = class {
     if (rows[0]) {
       return rows[0].value;
     }
-    const newNodeId = (0, import_core17.generateUUIDv7)();
+    const newNodeId = (0, import_core19.generateUUIDv7)();
     await this.adapter.execute("INSERT INTO _kora_meta (key, value) VALUES ('node_id', ?)", [
       newNodeId
     ]);
@@ -4067,7 +4624,7 @@ var Store = class {
     const rows = await this.adapter.query(
       "SELECT node_id, sequence_number FROM _kora_version_vector"
     );
-    const vector = (0, import_core17.createVersionVector)();
+    const vector = (0, import_core19.createVersionVector)();
     for (const row of rows) {
       vector.set(row.node_id, row.sequence_number);
     }
@@ -4141,12 +4698,12 @@ var QueryStore = class {
 };
 
 // src/reactivity/assert-query-ready.ts
-var import_core18 = require("@korajs/core");
+var import_core20 = require("@korajs/core");
 var LEGACY_PENDING_COLLECTION = "__pending__";
 function assertQueryReady(query) {
   const descriptor = query.getDescriptor();
   if (descriptor.collection === LEGACY_PENDING_COLLECTION) {
-    throw new import_core18.AppNotReadyError(
+    throw new import_core20.AppNotReadyError(
       "Cannot use useQuery() before app.ready. Await app.ready or wrap your UI in <KoraProvider app={app}>."
     );
   }
@@ -4567,13 +5124,570 @@ init_backup();
 init_audit_trace_store();
 init_audit_json();
 init_export_audit();
+
+// src/blob/content-addressed-blob-store.ts
+var import_core21 = require("@korajs/core");
+var BlobIntegrityError = class extends Error {
+  constructor(expectedHash, actualHash) {
+    super(`Blob integrity check failed: content under hash ${expectedHash} hashes to ${actualHash}`);
+    this.expectedHash = expectedHash;
+    this.actualHash = actualHash;
+    this.name = "BlobIntegrityError";
+  }
+  expectedHash;
+  actualHash;
+};
+var MemoryBlobStore = class {
+  blobs = /* @__PURE__ */ new Map();
+  async put(bytes, metadata = {}) {
+    const ref = await (0, import_core21.createBlobRef)(bytes, metadata);
+    if (!this.blobs.has(ref.hash)) {
+      const stored = new Uint8Array(bytes.byteLength);
+      stored.set(bytes);
+      this.blobs.set(ref.hash, stored);
+    }
+    return ref;
+  }
+  async get(hash) {
+    const stored = this.blobs.get(hash);
+    if (stored === void 0) {
+      return null;
+    }
+    const actualHash = await (0, import_core21.hashBlob)(stored);
+    if (actualHash !== hash) {
+      throw new BlobIntegrityError(hash, actualHash);
+    }
+    const out = new Uint8Array(stored.byteLength);
+    out.set(stored);
+    return out;
+  }
+  async has(hash) {
+    return this.blobs.has(hash);
+  }
+  async delete(hash) {
+    return this.blobs.delete(hash);
+  }
+  async size() {
+    return this.blobs.size;
+  }
+  async list() {
+    return [...this.blobs.keys()];
+  }
+};
+
+// src/blob/opfs-blob-store.ts
+var import_core22 = require("@korajs/core");
+var OpfsBlobStore = class {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  dir;
+  shardFor(hash) {
+    return hash.slice(0, 2);
+  }
+  async put(bytes, metadata = {}) {
+    const ref = await (0, import_core22.createBlobRef)(bytes, metadata);
+    const shard = this.shardFor(ref.hash);
+    if (await this.dir.has(shard, ref.hash)) {
+      return ref;
+    }
+    const out = new Uint8Array(bytes.byteLength);
+    out.set(bytes);
+    await this.dir.write(shard, ref.hash, out);
+    return ref;
+  }
+  async get(hash) {
+    const bytes = await this.dir.read(this.shardFor(hash), hash);
+    if (bytes === null) {
+      return null;
+    }
+    const actual = await (0, import_core22.hashBlob)(bytes);
+    if (actual !== hash) {
+      throw new BlobIntegrityError(hash, actual);
+    }
+    return bytes;
+  }
+  async has(hash) {
+    return this.dir.has(this.shardFor(hash), hash);
+  }
+  async delete(hash) {
+    return this.dir.remove(this.shardFor(hash), hash);
+  }
+  async size() {
+    return this.dir.count();
+  }
+  async list() {
+    return this.dir.keys();
+  }
+};
+function getStorageManager() {
+  const nav = globalThis.navigator;
+  if (!nav?.storage || typeof nav.storage.getDirectory !== "function") {
+    throw new Error(
+      "OPFS is unavailable in this environment. The OPFS blob store requires a browser with Origin Private File System support; use MemoryBlobStore or a server-side store elsewhere."
+    );
+  }
+  return nav.storage;
+}
+function isNotFoundError(error) {
+  return typeof error === "object" && error !== null && error.name === "NotFoundError";
+}
+async function createOpfsBlobDirectory(rootDirName = "kora-blobs") {
+  const storage = getStorageManager();
+  if (typeof storage.persist === "function") {
+    try {
+      await storage.persist();
+    } catch {
+    }
+  }
+  const opfsRoot = await storage.getDirectory();
+  const root = await opfsRoot.getDirectoryHandle(rootDirName, { create: true });
+  async function shardHandle(shard, create) {
+    try {
+      return await root.getDirectoryHandle(shard, { create });
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  return {
+    async read(shard, name) {
+      const dir = await shardHandle(shard, false);
+      if (!dir) {
+        return null;
+      }
+      let handle;
+      try {
+        handle = await dir.getFileHandle(name, { create: false });
+      } catch (error) {
+        if (isNotFoundError(error)) {
+          return null;
+        }
+        throw error;
+      }
+      const file = await handle.getFile();
+      return new Uint8Array(await file.arrayBuffer());
+    },
+    async write(shard, name, bytes) {
+      const dir = await root.getDirectoryHandle(shard, { create: true });
+      const handle = await dir.getFileHandle(name, { create: true });
+      const writable = await handle.createWritable({ keepExistingData: false });
+      try {
+        await writable.write(bytes);
+      } finally {
+        await writable.close();
+      }
+    },
+    async remove(shard, name) {
+      const dir = await shardHandle(shard, false);
+      if (!dir) {
+        return false;
+      }
+      try {
+        await dir.removeEntry(name);
+        return true;
+      } catch (error) {
+        if (isNotFoundError(error)) {
+          return false;
+        }
+        throw error;
+      }
+    },
+    async has(shard, name) {
+      const dir = await shardHandle(shard, false);
+      if (!dir) {
+        return false;
+      }
+      try {
+        await dir.getFileHandle(name, { create: false });
+        return true;
+      } catch (error) {
+        if (isNotFoundError(error)) {
+          return false;
+        }
+        throw error;
+      }
+    },
+    async count() {
+      let total = 0;
+      for await (const shard of root.keys()) {
+        const dir = await shardHandle(shard, false);
+        if (!dir) {
+          continue;
+        }
+        for await (const name of dir.keys()) {
+          if (!name.endsWith(".tmp")) {
+            total++;
+          }
+        }
+      }
+      return total;
+    },
+    async keys() {
+      const names = [];
+      for await (const shard of root.keys()) {
+        const dir = await shardHandle(shard, false);
+        if (!dir) {
+          continue;
+        }
+        for await (const name of dir.keys()) {
+          if (!name.endsWith(".tmp")) {
+            names.push(name);
+          }
+        }
+      }
+      return names;
+    }
+  };
+}
+async function createOpfsBlobStore(rootDirName = "kora-blobs") {
+  return new OpfsBlobStore(await createOpfsBlobDirectory(rootDirName));
+}
+
+// src/blob/blob-chunking.ts
+var import_core23 = require("@korajs/core");
+var DEFAULT_CHUNK_SIZE = 256 * 1024;
+async function chunkBlob(bytes, chunkSize = DEFAULT_CHUNK_SIZE, metadata = {}) {
+  if (chunkSize <= 0) {
+    throw new Error(`chunkBlob requires a positive chunkSize, got ${chunkSize}`);
+  }
+  const chunkHashes = [];
+  const chunks = /* @__PURE__ */ new Map();
+  for (let offset = 0; offset < bytes.byteLength; offset += chunkSize) {
+    const end = Math.min(offset + chunkSize, bytes.byteLength);
+    const chunk = new Uint8Array(end - offset);
+    chunk.set(bytes.subarray(offset, end));
+    const hash = await (0, import_core23.hashBlob)(chunk);
+    chunkHashes.push(hash);
+    if (!chunks.has(hash)) {
+      chunks.set(hash, chunk);
+    }
+  }
+  const blobHash = await (0, import_core23.hashBlob)(bytes);
+  const manifest = {
+    blobHash,
+    size: bytes.byteLength,
+    chunkSize,
+    chunkHashes
+  };
+  if (metadata.mimeType !== void 0) {
+    manifest.mimeType = metadata.mimeType;
+  }
+  if (metadata.filename !== void 0) {
+    manifest.filename = metadata.filename;
+  }
+  return { manifest, chunks };
+}
+async function reassembleBlob(manifest, chunkStore) {
+  const parts = [];
+  let total = 0;
+  for (const hash of manifest.chunkHashes) {
+    const chunk = await chunkStore.get(hash);
+    if (chunk === null) {
+      throw new Error(`Cannot reassemble blob ${manifest.blobHash}: missing chunk ${hash}`);
+    }
+    parts.push(chunk);
+    total += chunk.byteLength;
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.byteLength;
+  }
+  const actual = await (0, import_core23.hashBlob)(out);
+  if (actual !== manifest.blobHash) {
+    throw new BlobIntegrityError(manifest.blobHash, actual);
+  }
+  return out;
+}
+
+// src/blob/blob-transfer.ts
+var import_core24 = require("@korajs/core");
+async function receiveBlob(manifest, provider, stores) {
+  let chunksFetched = 0;
+  let chunksSkipped = 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (const hash of manifest.chunkHashes) {
+    if (seen.has(hash)) {
+      continue;
+    }
+    seen.add(hash);
+    if (await stores.chunkStore.has(hash)) {
+      chunksSkipped++;
+      continue;
+    }
+    const bytes = await provider.getChunk(hash);
+    if (bytes === null) {
+      throw new Error(`Blob transfer failed: provider could not supply chunk ${hash}`);
+    }
+    const actual = await (0, import_core24.hashBlob)(bytes);
+    if (actual !== hash) {
+      throw new BlobIntegrityError(hash, actual);
+    }
+    await stores.chunkStore.put(bytes);
+    chunksFetched++;
+  }
+  const full = await reassembleBlob(manifest, stores.chunkStore);
+  const ref = await stores.blobStore.put(full, {
+    mimeType: manifest.mimeType,
+    filename: manifest.filename
+  });
+  return { ref, chunksFetched, chunksSkipped };
+}
+async function prepareBlobForSend(bytes, chunkStore, options = {}) {
+  const { manifest, chunks } = await chunkBlob(bytes, options.chunkSize, {
+    mimeType: options.mimeType,
+    filename: options.filename
+  });
+  for (const chunk of chunks.values()) {
+    await chunkStore.put(chunk);
+  }
+  const provider = {
+    getChunk: (hash) => chunkStore.get(hash)
+  };
+  return { manifest, provider };
+}
+
+// src/blob/blob-manifest-transfer.ts
+var import_core25 = require("@korajs/core");
+function serializeBlobManifest(manifest) {
+  const canonical = {
+    blobHash: manifest.blobHash,
+    size: manifest.size,
+    chunkSize: manifest.chunkSize,
+    chunkHashes: manifest.chunkHashes
+  };
+  if (manifest.mimeType !== void 0) {
+    canonical.mimeType = manifest.mimeType;
+  }
+  if (manifest.filename !== void 0) {
+    canonical.filename = manifest.filename;
+  }
+  return new TextEncoder().encode(JSON.stringify(canonical));
+}
+function parseBlobManifest(bytes) {
+  const parsed = JSON.parse(new TextDecoder().decode(bytes));
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error("Invalid blob manifest: not an object");
+  }
+  const obj = parsed;
+  if (typeof obj.blobHash !== "string") {
+    throw new Error("Invalid blob manifest: missing blobHash");
+  }
+  if (typeof obj.size !== "number" || typeof obj.chunkSize !== "number") {
+    throw new Error("Invalid blob manifest: missing size or chunkSize");
+  }
+  if (!Array.isArray(obj.chunkHashes) || obj.chunkHashes.some((h) => typeof h !== "string")) {
+    throw new Error("Invalid blob manifest: chunkHashes must be an array of strings");
+  }
+  const manifest = {
+    blobHash: obj.blobHash,
+    size: obj.size,
+    chunkSize: obj.chunkSize,
+    chunkHashes: obj.chunkHashes
+  };
+  if (typeof obj.mimeType === "string") {
+    manifest.mimeType = obj.mimeType;
+  }
+  if (typeof obj.filename === "string") {
+    manifest.filename = obj.filename;
+  }
+  return manifest;
+}
+async function putBlobForTransfer(store, bytes, options = {}) {
+  const { manifest, chunks } = await chunkBlob(bytes, options.chunkSize, {
+    ...options.mimeType !== void 0 ? { mimeType: options.mimeType } : {},
+    ...options.filename !== void 0 ? { filename: options.filename } : {}
+  });
+  for (const chunk of chunks.values()) {
+    await store.put(chunk);
+  }
+  const baseRef = await store.put(bytes, {
+    ...options.mimeType !== void 0 ? { mimeType: options.mimeType } : {},
+    ...options.filename !== void 0 ? { filename: options.filename } : {}
+  });
+  const manifestRef = await store.put(serializeBlobManifest(manifest));
+  return { ref: { ...baseRef, manifestHash: manifestRef.hash }, manifest };
+}
+async function fetchBlobManifest(provider, manifestHash) {
+  const bytes = await provider.getChunk(manifestHash);
+  if (bytes === null) {
+    throw new Error(`Blob manifest ${manifestHash} could not be fetched from the provider`);
+  }
+  const actual = await (0, import_core25.hashBlob)(bytes);
+  if (actual !== manifestHash) {
+    throw new BlobIntegrityError(manifestHash, actual);
+  }
+  return parseBlobManifest(bytes);
+}
+async function resolveBlobManifest(provider, ref) {
+  if (ref.manifestHash === void 0) {
+    throw new Error(
+      `Blob ${ref.hash} has no manifest to resolve. Store it with putBlobForTransfer (or app.blobs.put) so its reference carries a manifestHash, or pull with an explicit manifest.`
+    );
+  }
+  return fetchBlobManifest(provider, ref.manifestHash);
+}
+
+// src/blob/server-blob-callbacks.ts
+var import_core26 = require("@korajs/core");
+function toServerBlobCallbacks(store) {
+  return {
+    resolveBlobChunk: (hash) => store.get(hash),
+    async persistBlobChunk(hash, bytes) {
+      const actual = await (0, import_core26.hashBlob)(bytes);
+      if (actual !== hash) {
+        return;
+      }
+      await store.put(bytes);
+    }
+  };
+}
+function createMemoryServerBlobStore() {
+  const store = new MemoryBlobStore();
+  return { store, callbacks: toServerBlobCallbacks(store) };
+}
+
+// src/blob/blob-gc.ts
+var import_core27 = require("@korajs/core");
+function extractBlobRefs(record) {
+  const refs = [];
+  for (const value of Object.values(record)) {
+    if ((0, import_core27.isBlobRef)(value)) {
+      refs.push(value);
+    }
+  }
+  return refs;
+}
+async function collectBlobGarbage(store, liveRefs, options = {}) {
+  const live = /* @__PURE__ */ new Set();
+  for (const ref of liveRefs) {
+    live.add(ref.hash);
+    if (ref.manifestHash === void 0) {
+      continue;
+    }
+    live.add(ref.manifestHash);
+    try {
+      const manifestBytes = await store.get(ref.manifestHash);
+      if (manifestBytes !== null) {
+        const manifest = parseBlobManifest(manifestBytes);
+        for (const chunkHash of manifest.chunkHashes) {
+          live.add(chunkHash);
+        }
+      }
+    } catch {
+    }
+  }
+  const all = await store.list();
+  const collectedHashes = [];
+  for (const hash of all) {
+    if (live.has(hash)) {
+      continue;
+    }
+    collectedHashes.push(hash);
+    if (!options.dryRun) {
+      await store.delete(hash);
+    }
+  }
+  return {
+    scanned: all.length,
+    live: live.size,
+    collected: collectedHashes.length,
+    collectedHashes
+  };
+}
+
+// src/blob/blob-chunk-transport.ts
+var import_core28 = require("@korajs/core");
+function createRemoteChunkProvider(port, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const pending = /* @__PURE__ */ new Map();
+  port.onMessage((message) => {
+    if (message.type !== "blob-chunk-response") {
+      return;
+    }
+    const entry = pending.get(message.requestId);
+    if (!entry) {
+      return;
+    }
+    pending.delete(message.requestId);
+    clearTimeout(entry.timer);
+    entry.resolve(message.bytes);
+  });
+  return {
+    pendingCount: () => pending.size,
+    getChunk(hash) {
+      const requestId = (0, import_core28.generateUUIDv7)();
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pending.delete(requestId);
+          reject(new Error(`Blob chunk request for ${hash} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        pending.set(requestId, { resolve, reject, timer });
+        port.send({ type: "blob-chunk-request", requestId, hash });
+      });
+    }
+  };
+}
+function serveBlobChunks(port, blobStore) {
+  port.onMessage((message) => {
+    if (message.type !== "blob-chunk-request") {
+      return;
+    }
+    void blobStore.get(message.hash).then(
+      (bytes) => {
+        port.send({ type: "blob-chunk-response", requestId: message.requestId, bytes });
+      },
+      () => {
+        port.send({ type: "blob-chunk-response", requestId: message.requestId, bytes: null });
+      }
+    );
+  });
+}
+function createChunkPortPair() {
+  const handlersA = [];
+  const handlersB = [];
+  const a = {
+    send(message) {
+      queueMicrotask(() => {
+        for (const handler of handlersB) {
+          handler(message);
+        }
+      });
+    },
+    onMessage(handler) {
+      handlersA.push(handler);
+    }
+  };
+  const b = {
+    send(message) {
+      queueMicrotask(() => {
+        for (const handler of handlersA) {
+          handler(message);
+        }
+      });
+    },
+    onMessage(handler) {
+      handlersB.push(handler);
+    }
+  };
+  return { a, b };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AdapterError,
+  BlobIntegrityError,
   COMPACTION_BASELINE_META_KEY,
   Collection,
+  DEFAULT_CHUNK_SIZE,
   InvalidStateTransitionError,
   LAST_ACKED_SERVER_VECTOR_META_KEY,
+  MemoryBlobStore,
+  OpfsBlobStore,
+  OptimisticLockError,
   PersistenceError,
   QueryBuilder,
   QueryError,
@@ -4590,26 +5704,44 @@ init_export_audit();
   WorkerTimeoutError,
   asRichTextSyncEngine,
   assertQueryReady,
+  chunkBlob,
+  collectBlobGarbage,
   collectOperationsAheadOfServer,
   compactOperationLog,
   computeAckCompactionWatermark,
+  createChunkPortPair,
+  createMemoryServerBlobStore,
+  createOpfsBlobDirectory,
+  createOpfsBlobStore,
+  createRemoteChunkProvider,
   createRichTextController,
   decodeAuditExport,
   decodeRichtext,
   deserializeVersionVectorFromMeta,
   encodeRichtext,
   exportBackup,
+  extractBlobRefs,
+  fetchBlobManifest,
   getSharedQueryStoreCache,
   mergeVersionVectors,
+  parseBlobManifest,
   persistedAuditTraceFromEvent,
   pluralize,
+  prepareBlobForSend,
+  putBlobForTransfer,
   readAuditExportManifest,
   readBackupManifest,
+  reassembleBlob,
+  receiveBlob,
+  resolveBlobManifest,
   restoreBackup,
   richtextStatesEqual,
   richtextToPlainText,
+  serializeBlobManifest,
   serializeVersionVectorToMeta,
+  serveBlobChunks,
   singularize,
+  toServerBlobCallbacks,
   validateStateTransition,
   validateUpdateStateMachine,
   verifyAuditExportChecksum,