@korajs/core 1.0.0-beta.4 → 1.0.0-beta.6

package/dist/bindings/index.d.cts

@@ -1,5 +1,5 @@
-import { p as KoraEventEmitter } from '../events-DhblJN4r.cjs';
-import { S as ScopeMap } from '../build-scope-map-K25AyQXb.cjs';
+import { p as KoraEventEmitter } from '../events-CT9y24ht.cjs';
+import { S as ScopeMap } from '../build-scope-map-Bm6Lqo9F.cjs';
 
 /** Sync status shape consumed by framework binding hooks (matches {@link SyncStatusInfo} in `@korajs/sync`). */
 interface KoraBindingSyncStatus {

package/dist/bindings/index.d.ts

@@ -1,5 +1,5 @@
-import { p as KoraEventEmitter } from '../events-DhblJN4r.js';
-import { S as ScopeMap } from '../build-scope-map-BvdTzmm4.js';
+import { p as KoraEventEmitter } from '../events-CT9y24ht.js';
+import { S as ScopeMap } from '../build-scope-map-C60lT-4I.js';
 
 /** Sync status shape consumed by framework binding hooks (matches {@link SyncStatusInfo} in `@korajs/sync`). */
 interface KoraBindingSyncStatus {

package/dist/{build-scope-map-K25AyQXb.d.cts → build-scope-map-Bm6Lqo9F.d.cts}

@@ -1,4 +1,4 @@
-import { S as SchemaDefinition } from './events-DhblJN4r.cjs';
+import { S as SchemaDefinition } from './events-CT9y24ht.cjs';
 
 /**
  * Per-collection scope map: `{ collectionName: { field: value, ... } }`

package/dist/{build-scope-map-BvdTzmm4.d.ts → build-scope-map-C60lT-4I.d.ts}

@@ -1,4 +1,4 @@
-import { S as SchemaDefinition } from './events-DhblJN4r.js';
+import { S as SchemaDefinition } from './events-CT9y24ht.js';
 
 /**
  * Per-collection scope map: `{ collectionName: { field: value, ... } }`

package/dist/{events-DhblJN4r.d.cts → events-CT9y24ht.d.cts}

@@ -912,6 +912,18 @@ type KoraEvent = {
      */
     reason: 'lock-conflict' | 'timeout' | 'unsupported';
     message: string;
+} | {
+    /**
+     * A preferred storage backend could not provide durable storage, so Kora
+     * promoted the app to another durable backend before user code observed the
+     * store. This is informational: data still survives reloads.
+     */
+    type: 'store:storage-fallback';
+    dbName: string;
+    from: 'opfs' | 'sqlite-wasm';
+    to: 'indexeddb';
+    reason: 'lock-conflict' | 'timeout' | 'unsupported';
+    message: string;
 } | {
     /**
      * Another runtime on this origin was already using this database name, so

package/dist/{events-DhblJN4r.d.ts → events-CT9y24ht.d.ts}

@@ -912,6 +912,18 @@ type KoraEvent = {
      */
     reason: 'lock-conflict' | 'timeout' | 'unsupported';
     message: string;
+} | {
+    /**
+     * A preferred storage backend could not provide durable storage, so Kora
+     * promoted the app to another durable backend before user code observed the
+     * store. This is informational: data still survives reloads.
+     */
+    type: 'store:storage-fallback';
+    dbName: string;
+    from: 'opfs' | 'sqlite-wasm';
+    to: 'indexeddb';
+    reason: 'lock-conflict' | 'timeout' | 'unsupported';
+    message: string;
 } | {
     /**
      * Another runtime on this origin was already using this database name, so

package/dist/index.cjs

@@ -46,6 +46,7 @@ __export(index_exports, {
   StorageError: () => StorageError,
   SyncError: () => SyncError,
   advanceVector: () => advanceVector,
+  applyAtomicOp: () => applyAtomicOp,
   applyOperationTransforms: () => applyOperationTransforms,
   base64ToBytes: () => base64ToBytes,
   buildScopeMap: () => buildScopeMap,
@@ -95,6 +96,7 @@ __export(index_exports, {
   migrationStepsToSQL: () => migrationStepsToSQL,
   op: () => op,
   quoteIdent: () => quoteIdent,
+  replayOperationsForRecord: () => replayOperationsForRecord,
   resolveAtomicOp: () => resolveAtomicOp,
   revealSecret: () => revealSecret,
   rollbackStepsToSQL: () => rollbackStepsToSQL,
@@ -968,32 +970,36 @@ var KORA_ATOMIC_OP = /* @__PURE__ */ Symbol.for("kora.atomic_op");
 function isAtomicOp(value) {
   return typeof value === "object" && value !== null && KORA_ATOMIC_OP in value && value[KORA_ATOMIC_OP] === true;
 }
-function resolveAtomicOp(currentValue, sentinel) {
-  switch (sentinel.type) {
+function applyAtomicOp(currentValue, atomicOp) {
+  switch (atomicOp.type) {
     case "increment": {
       const current = typeof currentValue === "number" ? currentValue : 0;
-      const operand = sentinel.value;
+      const operand = atomicOp.value;
       return current + operand;
     }
     case "max": {
       const current = typeof currentValue === "number" ? currentValue : Number.NEGATIVE_INFINITY;
-      return Math.max(current, sentinel.value);
+      return Math.max(current, atomicOp.value);
     }
     case "min": {
       const current = typeof currentValue === "number" ? currentValue : Number.POSITIVE_INFINITY;
-      return Math.min(current, sentinel.value);
+      return Math.min(current, atomicOp.value);
     }
     case "append": {
       const current = Array.isArray(currentValue) ? [...currentValue] : [];
-      current.push(sentinel.value);
+      current.push(atomicOp.value);
       return current;
     }
     case "remove": {
       if (!Array.isArray(currentValue)) return [];
-      return currentValue.filter((item) => item !== sentinel.value);
+      const target = JSON.stringify(atomicOp.value);
+      return currentValue.filter((item) => JSON.stringify(item) !== target);
     }
   }
 }
+function resolveAtomicOp(currentValue, sentinel) {
+  return applyAtomicOp(currentValue, { type: sentinel.type, value: sentinel.value });
+}
 function createSentinel(type, value) {
   return Object.freeze({
     [KORA_ATOMIC_OP]: true,
@@ -1061,6 +1067,46 @@ function toAtomicOp(sentinel) {
   return { type: sentinel.type, value: sentinel.value };
 }
 
+// src/operations/replay-record.ts
+function replayOperationsForRecord(ops) {
+  let record = null;
+  let deleted = false;
+  const lastWriterKind = {};
+  for (const op2 of ops) {
+    switch (op2.type) {
+      case "insert":
+        if (op2.data) {
+          record = { ...op2.data };
+          deleted = false;
+          for (const field of Object.keys(op2.data)) {
+            lastWriterKind[field] = "lww";
+          }
+        }
+        break;
+      case "update":
+        if (op2.data) {
+          const next = { ...record ?? {} };
+          for (const [field, value] of Object.entries(op2.data)) {
+            const atomicOp = op2.atomicOps?.[field];
+            if (atomicOp && lastWriterKind[field] === `atomic:${atomicOp.type}`) {
+              next[field] = applyAtomicOp(next[field], atomicOp);
+            } else {
+              next[field] = value;
+            }
+            lastWriterKind[field] = atomicOp ? `atomic:${atomicOp.type}` : "lww";
+          }
+          record = next;
+          deleted = false;
+        }
+        break;
+      case "delete":
+        deleted = true;
+        break;
+    }
+  }
+  return deleted ? null : record;
+}
+
 // src/operations/op-data-binary.ts
 function isKoraBytesValue(value) {
   if (typeof value !== "object" || value === null) {
@@ -2332,10 +2378,17 @@ function validateFieldValue(collection, fieldName, descriptor, value) {
       break;
     }
     case "json": {
-      if (!isJsonSerializable(value)) {
+      const nonJson = findNonJsonSerializable(value, fieldName);
+      if (nonJson) {
         throw new SchemaValidationError(
-          `Field "${fieldName}" in collection "${collection}" must be JSON-serializable, got ${describeType(value)}`,
-          { collection, field: fieldName, expectedType: "json", receivedType: describeType(value) }
+          `Field "${fieldName}" in collection "${collection}" must be JSON-serializable; found ${nonJson.receivedType} at "${nonJson.path}"`,
+          {
+            collection,
+            field: fieldName,
+            expectedType: "json",
+            receivedType: nonJson.receivedType,
+            path: nonJson.path
+          }
         );
       }
       break;
@@ -2372,21 +2425,41 @@ function isPlainObject(value) {
   const proto = Object.getPrototypeOf(value);
   return proto === null || proto === Object.prototype;
 }
-function isJsonSerializable(value) {
+function findNonJsonSerializable(value, path, seen = /* @__PURE__ */ new WeakSet()) {
   if (value === null) {
-    return true;
+    return null;
   }
   const type = typeof value;
   if (type === "string" || type === "number" || type === "boolean") {
-    return Number.isFinite(value) || type !== "number";
+    if (type === "number" && !Number.isFinite(value)) {
+      return { path, receivedType: describeType(value) };
+    }
+    return null;
+  }
+  if (type === "undefined" || type === "function" || type === "symbol" || type === "bigint") {
+    return { path, receivedType: describeType(value) };
   }
   if (Array.isArray(value)) {
-    return value.every(isJsonSerializable);
+    for (let index = 0; index < value.length; index++) {
+      const invalid = findNonJsonSerializable(value[index], `${path}[${index}]`, seen);
+      if (invalid) return invalid;
+    }
+    return null;
   }
   if (type === "object") {
-    return Object.values(value).every(isJsonSerializable);
+    const objectValue = value;
+    if (seen.has(objectValue)) {
+      return { path, receivedType: "circular object" };
+    }
+    seen.add(objectValue);
+    for (const [key, nestedValue] of Object.entries(objectValue)) {
+      const invalid = findNonJsonSerializable(nestedValue, `${path}.${key}`, seen);
+      if (invalid) return invalid;
+    }
+    seen.delete(objectValue);
+    return null;
   }
-  return false;
+  return { path, receivedType: describeType(value) };
 }
 function describeType(value) {
   if (value === null) {
@@ -3283,6 +3356,7 @@ function generateProtoDefinitions(schema) {
   StorageError,
   SyncError,
   advanceVector,
+  applyAtomicOp,
   applyOperationTransforms,
   base64ToBytes,
   buildScopeMap,
@@ -3332,6 +3406,7 @@ function generateProtoDefinitions(schema) {
   migrationStepsToSQL,
   op,
   quoteIdent,
+  replayOperationsForRecord,
   resolveAtomicOp,
   revealSecret,
   rollbackStepsToSQL,