@korajs/server 1.0.0-beta.1 → 1.0.0-beta.4

package/dist/index.cjs

@@ -176,6 +176,7 @@ __export(index_exports, {
   MixedAuthProvider: () => MixedAuthProvider,
   NoAuthProvider: () => NoAuthProvider,
   PostgresServerStore: () => PostgresServerStore,
+  RETRIABLE_REJECTION_CODES: () => RETRIABLE_REJECTION_CODES,
   SqliteServerStore: () => SqliteServerStore,
   TokenAuthProvider: () => TokenAuthProvider,
   WsServerTransport: () => WsServerTransport,
@@ -186,7 +187,8 @@ __export(index_exports, {
   createPrettyLogger: () => createPrettyLogger,
   createProductionServer: () => createProductionServer,
   createSilentLogger: () => createSilentLogger,
-  createSqliteServerStore: () => createSqliteServerStore
+  createSqliteServerStore: () => createSqliteServerStore,
+  isRetriableRejection: () => isRetriableRejection
 });
 module.exports = __toCommonJS(index_exports);
 init_cjs_shims();
@@ -248,6 +250,13 @@ function createDefaultLogger() {
   }
 }
 
+// src/apply/rejection-taxonomy.ts
+init_cjs_shims();
+var RETRIABLE_REJECTION_CODES = /* @__PURE__ */ new Set(["RATE_LIMIT"]);
+function isRetriableRejection(code) {
+  return RETRIABLE_REJECTION_CODES.has(code);
+}
+
 // src/store/memory-server-store.ts
 init_cjs_shims();
 var import_core2 = require("@korajs/core");
@@ -269,6 +278,14 @@ function fieldTypeToSql(descriptor, dialect) {
       return dialect === "postgres" ? "BIGINT" : "INTEGER";
     case "array":
       return dialect === "postgres" ? "JSONB" : "TEXT";
+    case "object":
+      return dialect === "postgres" ? "JSONB" : "TEXT";
+    case "json":
+      return dialect === "postgres" ? "JSONB" : "TEXT";
+    case "blob":
+      return "TEXT";
+    case "secret":
+      return "TEXT";
     case "richtext":
       return dialect === "postgres" ? "BYTEA" : "BLOB";
   }
@@ -285,13 +302,13 @@ function generateCollectionDDL(name, collection, dialect) {
   const columns = ["id TEXT PRIMARY KEY NOT NULL"];
   for (const [fieldName, descriptor] of Object.entries(collection.fields)) {
     const sqlType = fieldTypeToSql(descriptor, dialect);
-    let colDef = `${fieldName} ${sqlType}`;
+    let colDef = `${(0, import_core.quoteIdent)(fieldName)} ${sqlType}`;
     if (descriptor.defaultValue !== void 0) {
       colDef += ` DEFAULT ${sqlDefaultLiteral(descriptor.defaultValue)}`;
     }
     if (descriptor.kind === "enum" && descriptor.enumValues) {
       const values = descriptor.enumValues.map((v) => `'${v}'`).join(", ");
-      colDef += ` CHECK (${fieldName} IN (${values}))`;
+      colDef += ` CHECK (${(0, import_core.quoteIdent)(fieldName)} IN (${values}))`;
     }
     columns.push(colDef);
   }
@@ -299,24 +316,26 @@ function generateCollectionDDL(name, collection, dialect) {
   columns.push(`_created_at ${tsType} NOT NULL DEFAULT 0`);
   columns.push(`_updated_at ${tsType} NOT NULL DEFAULT 0`);
   columns.push("_deleted INTEGER NOT NULL DEFAULT 0");
-  statements.push(`CREATE TABLE IF NOT EXISTS ${name} (
+  statements.push(`CREATE TABLE IF NOT EXISTS ${(0, import_core.quoteIdent)(name)} (
   ${columns.join(",\n  ")}
 )`);
   for (const [fieldName, descriptor] of Object.entries(collection.fields)) {
     const sqlType = fieldTypeToSql(descriptor, dialect);
-    let colDef = `${fieldName} ${sqlType}`;
+    let colDef = `${(0, import_core.quoteIdent)(fieldName)} ${sqlType}`;
     if (descriptor.defaultValue !== void 0) {
       colDef += ` DEFAULT ${sqlDefaultLiteral(descriptor.defaultValue)}`;
     }
     statements.push(`--kora:safe-alter
-ALTER TABLE ${name} ADD COLUMN ${colDef}`);
+ALTER TABLE ${(0, import_core.quoteIdent)(name)} ADD COLUMN ${colDef}`);
   }
   for (const indexField of collection.indexes) {
     statements.push(
-      `CREATE INDEX IF NOT EXISTS idx_${name}_${indexField} ON ${name} (${indexField})`
+      `CREATE INDEX IF NOT EXISTS idx_${name}_${indexField} ON ${(0, import_core.quoteIdent)(name)} (${(0, import_core.quoteIdent)(indexField)})`
     );
   }
-  statements.push(`CREATE INDEX IF NOT EXISTS idx_${name}__deleted ON ${name} (_deleted)`);
+  statements.push(
+    `CREATE INDEX IF NOT EXISTS idx_${name}__deleted ON ${(0, import_core.quoteIdent)(name)} (_deleted)`
+  );
   return statements;
 }
 function generateAllCollectionDDL(schema, dialect) {
@@ -952,7 +971,7 @@ var PostgresServerStore = class {
     this.assertCollection(collection);
     const schema = this.schema;
     const collectionDef = schema.collections[collection];
-    const query = import_drizzle_orm.sql`SELECT * FROM ${import_drizzle_orm.sql.raw(collection)} WHERE id = ${id} AND _deleted = 0`;
+    const query = import_drizzle_orm.sql`SELECT * FROM ${import_drizzle_orm.sql.raw((0, import_core3.quoteIdent)(collection))} WHERE id = ${id} AND _deleted = 0`;
     const rows = await this.db.execute(query);
     if (rows.length === 0) return null;
     return this.deserializeRow(rows[0], collectionDef);
@@ -969,7 +988,7 @@ var PostgresServerStore = class {
       }
     }
     const whereClause = this.buildWhereClause(where ?? {}, false);
-    const query = import_drizzle_orm.sql`SELECT COUNT(*) as cnt FROM ${import_drizzle_orm.sql.raw(collection)} WHERE ${whereClause}`;
+    const query = import_drizzle_orm.sql`SELECT COUNT(*) as cnt FROM ${import_drizzle_orm.sql.raw((0, import_core3.quoteIdent)(collection))} WHERE ${whereClause}`;
     const rows = await this.db.execute(query);
     const cnt = rows[0]?.cnt;
     return typeof cnt === "string" ? Number.parseInt(cnt, 10) : cnt ?? 0;
@@ -1056,7 +1075,7 @@ var PostgresServerStore = class {
       );
     } else {
       await txOrDb.execute(
-        import_drizzle_orm.sql`UPDATE ${import_drizzle_orm.sql.raw(collection)} SET _deleted = 1, _updated_at = ${Date.now()} WHERE id = ${recordId}`
+        import_drizzle_orm.sql`UPDATE ${import_drizzle_orm.sql.raw((0, import_core3.quoteIdent)(collection))} SET _deleted = 1, _updated_at = ${Date.now()} WHERE id = ${recordId}`
       );
     }
   }
@@ -1075,16 +1094,16 @@ var PostgresServerStore = class {
       updatedAt,
       0
     ];
-    const columnsSql = import_drizzle_orm.sql.raw(allColumns.join(", "));
+    const columnsSql = import_drizzle_orm.sql.raw(allColumns.map((c) => (0, import_core3.quoteIdent)(c)).join(", "));
     const valuesSql = import_drizzle_orm.sql.join(
       values.map((v) => import_drizzle_orm.sql`${v}`),
       import_drizzle_orm.sql.raw(", ")
     );
     const updateSet = import_drizzle_orm.sql.raw(
-      allColumns.slice(1).map((c) => `${c} = excluded.${c}`).join(", ")
+      allColumns.slice(1).map((c) => `${(0, import_core3.quoteIdent)(c)} = excluded.${(0, import_core3.quoteIdent)(c)}`).join(", ")
     );
     await txOrDb.execute(
-      import_drizzle_orm.sql`INSERT INTO ${import_drizzle_orm.sql.raw(tableName)} (${columnsSql}) VALUES (${valuesSql}) ON CONFLICT (id) DO UPDATE SET ${updateSet}`
+      import_drizzle_orm.sql`INSERT INTO ${import_drizzle_orm.sql.raw((0, import_core3.quoteIdent)(tableName))} (${columnsSql}) VALUES (${valuesSql}) ON CONFLICT (id) DO UPDATE SET ${updateSet}`
     );
   }
   /**
@@ -1144,7 +1163,7 @@ var PostgresServerStore = class {
         );
       } else {
         await this.db.execute(
-          import_drizzle_orm.sql`INSERT INTO ${import_drizzle_orm.sql.raw(collectionName)} (id, _deleted, _created_at, _updated_at) VALUES (${recordId}, 1, ${Date.now()}, ${Date.now()}) ON CONFLICT (id) DO UPDATE SET _deleted = 1, _updated_at = ${Date.now()}`
+          import_drizzle_orm.sql`INSERT INTO ${import_drizzle_orm.sql.raw((0, import_core3.quoteIdent)(collectionName))} (id, _deleted, _created_at, _updated_at) VALUES (${recordId}, 1, ${Date.now()}, ${Date.now()}) ON CONFLICT (id) DO UPDATE SET _deleted = 1, _updated_at = ${Date.now()}`
         );
       }
     }
@@ -1157,10 +1176,12 @@ var PostgresServerStore = class {
       options?.where ?? {},
       options?.includeDeleted ?? false
     );
-    const parts = [import_drizzle_orm.sql`SELECT * FROM ${import_drizzle_orm.sql.raw(collection)} WHERE ${whereClause}`];
+    const parts = [
+      import_drizzle_orm.sql`SELECT * FROM ${import_drizzle_orm.sql.raw((0, import_core3.quoteIdent)(collection))} WHERE ${whereClause}`
+    ];
     if (options?.orderBy) {
       const dir = options.orderDirection === "desc" ? "DESC" : "ASC";
-      parts.push(import_drizzle_orm.sql.raw(` ORDER BY ${options.orderBy} ${dir}`));
+      parts.push(import_drizzle_orm.sql.raw(` ORDER BY ${(0, import_core3.quoteIdent)(options.orderBy)} ${dir}`));
     }
     if (options?.limit !== void 0) {
       parts.push(import_drizzle_orm.sql` LIMIT ${options.limit}`);
@@ -1176,7 +1197,7 @@ var PostgresServerStore = class {
       conditions.push(import_drizzle_orm.sql.raw("_deleted = 0"));
     }
     for (const [key, value] of Object.entries(where)) {
-      conditions.push(import_drizzle_orm.sql`${import_drizzle_orm.sql.raw(key)} = ${value}`);
+      conditions.push(import_drizzle_orm.sql`${import_drizzle_orm.sql.raw((0, import_core3.quoteIdent)(key))} = ${value}`);
     }
     if (conditions.length === 0) {
       return import_drizzle_orm.sql.raw("1 = 1");
@@ -1528,7 +1549,7 @@ var SqliteServerStore = class {
     this.assertCollection(collection);
     const schema = this.schema;
     const collectionDef = schema.collections[collection];
-    const query = import_drizzle_orm2.sql`SELECT * FROM ${import_drizzle_orm2.sql.raw(collection)} WHERE id = ${id} AND _deleted = 0`;
+    const query = import_drizzle_orm2.sql`SELECT * FROM ${import_drizzle_orm2.sql.raw((0, import_core4.quoteIdent)(collection))} WHERE id = ${id} AND _deleted = 0`;
     const rows = this.db.all(query);
     if (rows.length === 0) return null;
     return this.deserializeRow(rows[0], collectionDef);
@@ -1544,7 +1565,7 @@ var SqliteServerStore = class {
       }
     }
     const whereClause = this.buildWhereClause(where ?? {}, false);
-    const query = import_drizzle_orm2.sql`SELECT COUNT(*) as cnt FROM ${import_drizzle_orm2.sql.raw(collection)} WHERE ${whereClause}`;
+    const query = import_drizzle_orm2.sql`SELECT COUNT(*) as cnt FROM ${import_drizzle_orm2.sql.raw((0, import_core4.quoteIdent)(collection))} WHERE ${whereClause}`;
     const rows = this.db.all(query);
     return rows[0]?.cnt ?? 0;
   }
@@ -1621,7 +1642,7 @@ var SqliteServerStore = class {
       );
     } else {
       txOrDb.run(
-        import_drizzle_orm2.sql`UPDATE ${import_drizzle_orm2.sql.raw(collection)} SET _deleted = 1, _updated_at = ${Date.now()} WHERE id = ${recordId}`
+        import_drizzle_orm2.sql`UPDATE ${import_drizzle_orm2.sql.raw((0, import_core4.quoteIdent)(collection))} SET _deleted = 1, _updated_at = ${Date.now()} WHERE id = ${recordId}`
       );
     }
   }
@@ -1642,16 +1663,16 @@ var SqliteServerStore = class {
       0
       // _deleted = false
     ];
-    const columnsSql = import_drizzle_orm2.sql.raw(allColumns.join(", "));
+    const columnsSql = import_drizzle_orm2.sql.raw(allColumns.map((c) => (0, import_core4.quoteIdent)(c)).join(", "));
     const valuesSql = import_drizzle_orm2.sql.join(
       values.map((v) => import_drizzle_orm2.sql`${v}`),
       import_drizzle_orm2.sql.raw(", ")
     );
     const updateSet = import_drizzle_orm2.sql.raw(
-      allColumns.slice(1).map((c) => `${c} = excluded.${c}`).join(", ")
+      allColumns.slice(1).map((c) => `${(0, import_core4.quoteIdent)(c)} = excluded.${(0, import_core4.quoteIdent)(c)}`).join(", ")
     );
     txOrDb.run(
-      import_drizzle_orm2.sql`INSERT INTO ${import_drizzle_orm2.sql.raw(tableName)} (${columnsSql}) VALUES (${valuesSql}) ON CONFLICT (id) DO UPDATE SET ${updateSet}`
+      import_drizzle_orm2.sql`INSERT INTO ${import_drizzle_orm2.sql.raw((0, import_core4.quoteIdent)(tableName))} (${columnsSql}) VALUES (${valuesSql}) ON CONFLICT (id) DO UPDATE SET ${updateSet}`
     );
   }
   /**
@@ -1709,7 +1730,7 @@ var SqliteServerStore = class {
           );
         } else {
           tx.run(
-            import_drizzle_orm2.sql`INSERT INTO ${import_drizzle_orm2.sql.raw(collectionName)} (id, _deleted, _created_at, _updated_at) VALUES (${recordId}, 1, ${Date.now()}, ${Date.now()}) ON CONFLICT (id) DO UPDATE SET _deleted = 1, _updated_at = ${Date.now()}`
+            import_drizzle_orm2.sql`INSERT INTO ${import_drizzle_orm2.sql.raw((0, import_core4.quoteIdent)(collectionName))} (id, _deleted, _created_at, _updated_at) VALUES (${recordId}, 1, ${Date.now()}, ${Date.now()}) ON CONFLICT (id) DO UPDATE SET _deleted = 1, _updated_at = ${Date.now()}`
           );
         }
       }
@@ -1723,10 +1744,12 @@ var SqliteServerStore = class {
       options?.where ?? {},
       options?.includeDeleted ?? false
     );
-    const parts = [import_drizzle_orm2.sql`SELECT * FROM ${import_drizzle_orm2.sql.raw(collection)} WHERE ${whereClause}`];
+    const parts = [
+      import_drizzle_orm2.sql`SELECT * FROM ${import_drizzle_orm2.sql.raw((0, import_core4.quoteIdent)(collection))} WHERE ${whereClause}`
+    ];
     if (options?.orderBy) {
       const dir = options.orderDirection === "desc" ? "DESC" : "ASC";
-      parts.push(import_drizzle_orm2.sql.raw(` ORDER BY ${options.orderBy} ${dir}`));
+      parts.push(import_drizzle_orm2.sql.raw(` ORDER BY ${(0, import_core4.quoteIdent)(options.orderBy)} ${dir}`));
     }
     if (options?.limit !== void 0) {
       parts.push(import_drizzle_orm2.sql` LIMIT ${options.limit}`);
@@ -1742,7 +1765,7 @@ var SqliteServerStore = class {
       conditions.push(import_drizzle_orm2.sql.raw("_deleted = 0"));
     }
     for (const [key, value] of Object.entries(where)) {
-      conditions.push(import_drizzle_orm2.sql`${import_drizzle_orm2.sql.raw(key)} = ${value}`);
+      conditions.push(import_drizzle_orm2.sql`${import_drizzle_orm2.sql.raw((0, import_core4.quoteIdent)(key))} = ${value}`);
     }
     if (conditions.length === 0) {
       return import_drizzle_orm2.sql.raw("1 = 1");
@@ -2189,12 +2212,14 @@ async function applyServerOperation(store, op, relationLookup) {
   const lookup = relationLookup ?? (schema ? (0, import_merge2.buildMergeRelationLookup)(schema) : /* @__PURE__ */ new Map());
   const constraintCheck = await validateIncomingOperationConstraints(store, op, schema);
   if (!constraintCheck.valid) {
+    const code = constraintCheck.code ?? "CONSTRAINT_VIOLATION";
     return {
       result: "skipped",
       appliedOperations: [],
       rejection: {
-        code: constraintCheck.code ?? "CONSTRAINT_VIOLATION",
-        message: constraintCheck.message ?? `Operation "${op.id}" violates a schema constraint`
+        code,
+        message: constraintCheck.message ?? `Operation "${op.id}" violates a schema constraint`,
+        retriable: isRetriableRejection(code)
       }
     };
   }
@@ -2207,7 +2232,8 @@ async function applyServerOperation(store, op, relationLookup) {
         appliedOperations: [],
         rejection: {
           code: "REFERENTIAL_INTEGRITY",
-          message: `Operation "${op.id}" violates referential integrity on "${op.collection}"`
+          message: `Operation "${op.id}" violates referential integrity on "${op.collection}"`,
+          retriable: isRetriableRejection("REFERENTIAL_INTEGRITY")
         }
       };
     }
@@ -2421,6 +2447,8 @@ var ClientSession = class {
   maxOperationBytes;
   maxOpsPerMinute;
   rateLimiter;
+  validateOperation;
+  koraContext;
   constructor(options) {
     this.sessionId = options.sessionId;
     this.transport = options.transport;
@@ -2445,6 +2473,8 @@ var ClientSession = class {
     this.maxOperationBytes = options.maxOperationBytes ?? DEFAULT_MAX_OPERATION_BYTES;
     this.maxOpsPerMinute = options.maxOpsPerMinute ?? DEFAULT_MAX_OPS_PER_MINUTE;
     this.rateLimiter = new SessionRateLimiter(this.maxOpsPerMinute);
+    this.validateOperation = options.validateOperation ?? null;
+    this.koraContext = options.koraContext ?? null;
   }
   /**
    * Start handling messages from the client transport.
@@ -2691,10 +2721,39 @@ var ClientSession = class {
         );
         continue;
       }
+      if (this.validateOperation && this.koraContext) {
+        let decision;
+        try {
+          decision = await this.validateOperation(op, {
+            auth: this.authContext,
+            kora: this.koraContext
+          });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "validator error";
+          this.sendOperationRejected(op, "VALIDATION_ERROR", `Validator threw: ${message}`, true);
+          continue;
+        }
+        if (decision.action === "reject") {
+          this.sendOperationRejected(
+            op,
+            decision.code,
+            decision.message,
+            decision.retriable ?? isRetriableRejection(decision.code)
+          );
+          continue;
+        }
+        if (decision.action === "ignore") {
+          continue;
+        }
+      }
       try {
         const applyResult = await applyServerOperation(this.store, op);
         if (applyResult.rejection) {
-          this.sendError(applyResult.rejection.code, applyResult.rejection.message, false);
+          this.sendError(
+            applyResult.rejection.code,
+            applyResult.rejection.message,
+            applyResult.rejection.retriable
+          );
           continue;
         }
         if (applyResult.result === "applied") {
@@ -2813,6 +2872,25 @@ var ClientSession = class {
     };
     this.sendToClient(errorMsg);
   }
+  /**
+   * Reject one specific client operation, tied to its id, so the submitter can
+   * divert it out of its pending queue into a durable rejected store rather than
+   * losing it or retrying forever. The op is NOT materialized, so no other
+   * replica ever sees it.
+   */
+  sendOperationRejected(op, code, message, retriable) {
+    const rejectedMsg = {
+      type: "operation-rejected",
+      messageId: (0, import_core10.generateUUIDv7)(),
+      operationId: op.id,
+      collection: op.collection,
+      recordId: op.recordId,
+      code,
+      message,
+      retriable
+    };
+    this.sendToClient(rejectedMsg);
+  }
   setSerializerWireFormat(format) {
     if (typeof this.serializer.setWireFormat === "function") {
       this.serializer.setWireFormat(format);
@@ -2834,7 +2912,7 @@ function selectWireFormat(supportedWireFormats) {
 
 // src/server/kora-sync-server.ts
 init_cjs_shims();
-var import_core12 = require("@korajs/core");
+var import_core13 = require("@korajs/core");
 var import_internal2 = require("@korajs/core/internal");
 var import_sync5 = require("@korajs/sync");
 
@@ -3196,6 +3274,311 @@ var YjsDocRelay = class {
   }
 };
 
+// src/server/route-context.ts
+init_cjs_shims();
+var import_core12 = require("@korajs/core");
+
+// src/apply/route-predicate.ts
+init_cjs_shims();
+function evaluateField(actual, operators) {
+  if ("$eq" in operators && !Object.is(actual, operators.$eq)) {
+    return false;
+  }
+  if ("$ne" in operators && Object.is(actual, operators.$ne)) {
+    return false;
+  }
+  if (operators.$in !== void 0 && !operators.$in.some((candidate) => Object.is(actual, candidate))) {
+    return false;
+  }
+  const numericChecks = [
+    ["$lt", (a, b) => a < b],
+    ["$lte", (a, b) => a <= b],
+    ["$gt", (a, b) => a > b],
+    ["$gte", (a, b) => a >= b]
+  ];
+  for (const [operator, compare] of numericChecks) {
+    const bound = operators[operator];
+    if (bound === void 0) {
+      continue;
+    }
+    if (typeof actual !== "number" || typeof bound !== "number") {
+      return false;
+    }
+    if (!compare(actual, bound)) {
+      return false;
+    }
+  }
+  return true;
+}
+function evaluateRoutePredicate(record, predicate) {
+  const fields = Object.keys(predicate);
+  if (fields.length === 0) {
+    return true;
+  }
+  if (record === null) {
+    return false;
+  }
+  for (const field of fields) {
+    const operators = predicate[field];
+    if (operators && !evaluateField(record[field], operators)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/server/route-context.ts
+function recordMatchesScope(collection, record, scope) {
+  const collectionScope = scope[collection];
+  if (!collectionScope) {
+    return false;
+  }
+  for (const [field, expected] of Object.entries(collectionScope)) {
+    if (record[field] !== expected) {
+      return false;
+    }
+  }
+  return true;
+}
+function pickFields(record, keys) {
+  const picked = {};
+  for (const key of keys) {
+    if (key in record) {
+      picked[key] = record[key];
+    }
+  }
+  return picked;
+}
+async function buildRouteOperation(store, mutation) {
+  const nodeId = store.getNodeId();
+  const clock = new import_core12.HybridLogicalClock(nodeId);
+  const schemaVersion = store.getSchema()?.version ?? 1;
+  const sequenceNumber = nextServerSequenceNumber(store);
+  if (mutation.type === "insert") {
+    return (0, import_core12.createOperation)(
+      {
+        nodeId,
+        type: "insert",
+        collection: mutation.collection,
+        recordId: mutation.recordId ?? (0, import_core12.generateUUIDv7)(),
+        data: mutation.data ?? {},
+        previousData: null,
+        sequenceNumber,
+        causalDeps: [],
+        schemaVersion
+      },
+      clock
+    );
+  }
+  if (!mutation.recordId) {
+    throw new RouteMutationError(
+      "MISSING_RECORD_ID",
+      `A ${mutation.type} mutation on "${mutation.collection}" requires a recordId.`
+    );
+  }
+  const current = await store.findRecord(mutation.collection, mutation.recordId);
+  if (mutation.type === "update") {
+    const rawData = mutation.data ?? {};
+    const data = {};
+    const atomicOps = {};
+    for (const key of Object.keys(rawData)) {
+      const value = rawData[key];
+      if ((0, import_core12.isAtomicOp)(value)) {
+        data[key] = (0, import_core12.resolveAtomicOp)(current ? current[key] : void 0, value);
+        atomicOps[key] = (0, import_core12.toAtomicOp)(value);
+      } else {
+        data[key] = value;
+      }
+    }
+    return (0, import_core12.createOperation)(
+      {
+        nodeId,
+        type: "update",
+        collection: mutation.collection,
+        recordId: mutation.recordId,
+        data,
+        previousData: current ? pickFields(current, Object.keys(rawData)) : {},
+        sequenceNumber,
+        causalDeps: [],
+        schemaVersion,
+        ...Object.keys(atomicOps).length > 0 ? { atomicOps } : {}
+      },
+      clock
+    );
+  }
+  return (0, import_core12.createOperation)(
+    {
+      nodeId,
+      type: "delete",
+      collection: mutation.collection,
+      recordId: mutation.recordId,
+      data: null,
+      previousData: current ? { ...current } : null,
+      sequenceNumber,
+      causalDeps: [],
+      schemaVersion
+    },
+    clock
+  );
+}
+var RouteMutationError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "RouteMutationError";
+  }
+  code;
+};
+function createRouteContext(server, store) {
+  let mutationTail = Promise.resolve();
+  function serialize(work) {
+    const run = mutationTail.then(work, work);
+    mutationTail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  async function prepareMutation(mutation, scope) {
+    let op;
+    try {
+      op = await buildRouteOperation(store, mutation);
+    } catch (error) {
+      if (error instanceof RouteMutationError) {
+        return {
+          ok: false,
+          rejection: {
+            ok: false,
+            code: error.code,
+            message: error.message,
+            retriable: isRetriableRejection(error.code)
+          }
+        };
+      }
+      throw error;
+    }
+    if (scope && !operationMatchesScopes(op, scope)) {
+      return {
+        ok: false,
+        rejection: {
+          ok: false,
+          code: "SCOPE_VIOLATION",
+          message: `Mutation on "${mutation.collection}" is outside the provided scope.`,
+          retriable: isRetriableRejection("SCOPE_VIOLATION")
+        }
+      };
+    }
+    return { ok: true, op };
+  }
+  async function commitOperation(op, collection) {
+    const result = await server.applyLocalOperation(op);
+    if (result.result !== "applied") {
+      const code = result.rejection?.code ?? "NOT_APPLIED";
+      return {
+        ok: false,
+        code,
+        message: result.rejection?.message ?? `Operation on "${collection}" was not applied (${result.result}).`,
+        // Prefer the pipeline's own classification when present; fall back
+        // to classifying the code so this stays correct if new codes appear.
+        retriable: result.rejection?.retriable ?? isRetriableRejection(code)
+      };
+    }
+    const record = await store.findRecord(collection, op.recordId);
+    return { ok: true, operation: op, record };
+  }
+  async function rawApply(mutation, scope) {
+    const prepared = await prepareMutation(mutation, scope);
+    if (!prepared.ok) {
+      return prepared.rejection;
+    }
+    return commitOperation(prepared.op, mutation.collection);
+  }
+  return {
+    apply(mutation, options) {
+      return serialize(() => rawApply(mutation, options?.scope));
+    },
+    applyConditional(spec, options) {
+      return serialize(async () => {
+        if (spec.idempotencyKey) {
+          const existing = await store.findRecord(
+            spec.idempotencyKey.collection,
+            spec.idempotencyKey.id
+          );
+          if (existing) {
+            return { ok: true, idempotent: true, operations: [], records: [existing] };
+          }
+        }
+        if (spec.if && Object.keys(spec.if).length > 0) {
+          const target = await store.findRecord(spec.collection, spec.id);
+          if (!evaluateRoutePredicate(target, spec.if)) {
+            const code = spec.reject?.code ?? "CONDITION_NOT_MET";
+            return {
+              ok: false,
+              code,
+              message: spec.reject?.message ?? `Admission condition not met on "${spec.collection}" record "${spec.id}".`,
+              retriable: false
+            };
+          }
+        }
+        const mutations = [];
+        if (spec.update !== void 0 && spec.update !== null) {
+          mutations.push({
+            collection: spec.collection,
+            type: "update",
+            recordId: spec.id,
+            data: spec.update
+          });
+        }
+        if (spec.also) {
+          mutations.push(...spec.also);
+        }
+        const prepared = [];
+        for (const mutation of mutations) {
+          const p = await prepareMutation(mutation, options?.scope);
+          if (!p.ok) {
+            return p.rejection;
+          }
+          prepared.push({ op: p.op, collection: mutation.collection });
+        }
+        const operations2 = [];
+        const records = [];
+        for (const { op, collection } of prepared) {
+          const result = await commitOperation(op, collection);
+          if (!result.ok) {
+            return {
+              ok: false,
+              code: result.code,
+              message: result.message,
+              retriable: result.retriable
+            };
+          }
+          operations2.push(result.operation);
+          records.push(result.record);
+        }
+        return { ok: true, idempotent: false, operations: operations2, records };
+      });
+    },
+    async query(collection, options) {
+      const { scope, ...queryOptions } = options ?? {};
+      const records = await store.queryCollection(collection, queryOptions);
+      if (!scope) {
+        return records;
+      }
+      return records.filter((record) => recordMatchesScope(collection, record, scope));
+    },
+    async findById(collection, id, options) {
+      const record = await store.findRecord(collection, id);
+      if (!record) {
+        return null;
+      }
+      if (options?.scope && !recordMatchesScope(collection, record, options.scope)) {
+        return null;
+      }
+      return record;
+    }
+  };
+}
+
 // src/server/kora-sync-server.ts
 var DEFAULT_MAX_CONNECTIONS = 0;
 var DEFAULT_BATCH_SIZE2 = 100;
@@ -3220,10 +3603,16 @@ var KoraSyncServer = class {
   yjsDocRelay = new YjsDocRelay();
   blobChunkRelay;
   persistBlobChunk;
+  maxOperationBytes;
+  maxOpsPerMinute;
+  validateOperation;
+  koraContext;
   sessions = /* @__PURE__ */ new Map();
   httpClients = /* @__PURE__ */ new Map();
   httpSessionToClient = /* @__PURE__ */ new Map();
-  serverVersion = "0.4.0";
+  // Informational value reported by getStatus(). Keep in sync with the
+  // @korajs/server package version on release; it is not used for protocol negotiation.
+  serverVersion = "1.0.0-beta.0";
   wsServer = null;
   running = false;
   constructor(config) {
@@ -3246,10 +3635,22 @@ var KoraSyncServer = class {
     this.metrics.setSchemaVersion(this.schemaVersion);
     this.blobChunkRelay = new BlobChunkRelay(config.resolveBlobChunk);
     this.persistBlobChunk = config.persistBlobChunk ?? null;
+    this.maxOperationBytes = config.maxOperationBytes;
+    this.maxOpsPerMinute = config.maxOpsPerMinute;
+    this.validateOperation = config.validateOperation;
+    this.koraContext = createRouteContext(this, this.store);
     if (!this.emitter) {
       this.emitter = new import_internal2.SimpleEventEmitter();
     }
   }
+  /**
+   * The trusted, scoped data-plane context (`apply` / `query` / `findById`).
+   * Shared with the production server so HTTP routes, the operation validator,
+   * and `server.kora` are all the same object over the same pipeline.
+   */
+  getKoraContext() {
+    return this.koraContext;
+  }
   /**
    * Subscribe to session-level events for metrics collection and logging.
    * Called when a new session is created.
@@ -3318,10 +3719,10 @@ var KoraSyncServer = class {
    */
   async start(wsServerImpl) {
     if (this.running) {
-      throw new import_core12.SyncError("Server is already running", { port: this.port });
+      throw new import_core13.SyncError("Server is already running", { port: this.port });
     }
     if (!wsServerImpl && this.port === void 0) {
-      throw new import_core12.SyncError(
+      throw new import_core13.SyncError(
         "Port is required for standalone mode. Provide port in config or use handleConnection() for attach mode.",
         {}
       );
@@ -3431,7 +3832,7 @@ var KoraSyncServer = class {
     if (this.maxConnections > 0 && this.sessions.size >= this.maxConnections) {
       transport.send({
         type: "error",
-        messageId: (0, import_core12.generateUUIDv7)(),
+        messageId: (0, import_core13.generateUUIDv7)(),
         code: "MAX_CONNECTIONS",
         message: `Server has reached maximum connections (${this.maxConnections})`,
         retriable: true
@@ -3444,12 +3845,12 @@ var KoraSyncServer = class {
         event: "connection.rejected",
         details: { reason: "max_connections", max: this.maxConnections }
       });
-      throw new import_core12.SyncError("Maximum connections reached", {
+      throw new import_core13.SyncError("Maximum connections reached", {
         current: this.sessions.size,
         max: this.maxConnections
       });
     }
-    const sessionId = (0, import_core12.generateUUIDv7)();
+    const sessionId = (0, import_core13.generateUUIDv7)();
     this.metrics.recordConnection(sessionId);
     const sessionEmitter = new import_internal2.SimpleEventEmitter();
     sessionEmitter.on("sync:connected", (event) => {
@@ -3521,6 +3922,11 @@ var KoraSyncServer = class {
         this.blobChunkRelay.handleResponse(sourceSessionId, message);
       },
       ...this.persistBlobChunk ? { persistBlobChunk: this.persistBlobChunk } : {},
+      // Only forward when configured, so an unset server value leaves the
+      // session on its own documented default rather than `undefined`.
+      ...this.maxOperationBytes !== void 0 ? { maxOperationBytes: this.maxOperationBytes } : {},
+      ...this.maxOpsPerMinute !== void 0 ? { maxOpsPerMinute: this.maxOpsPerMinute } : {},
+      ...this.validateOperation ? { validateOperation: this.validateOperation, koraContext: this.koraContext } : {},
       onClose: (sid) => {
         this.handleSessionClose(sid);
       }
@@ -3607,7 +4013,7 @@ var KoraSyncServer = class {
       const records = await this.store.materializeCollection(name);
       for (const record of records) {
         for (const value of Object.values(record)) {
-          if ((0, import_core12.isBlobRef)(value)) {
+          if ((0, import_core13.isBlobRef)(value)) {
             refs.push(value);
           }
         }
@@ -3787,162 +4193,6 @@ function createKoraServer(config) {
 
 // src/server/production-server.ts
 init_cjs_shims();
-
-// src/server/route-context.ts
-init_cjs_shims();
-var import_core13 = require("@korajs/core");
-function recordMatchesScope(collection, record, scope) {
-  const collectionScope = scope[collection];
-  if (!collectionScope) {
-    return false;
-  }
-  for (const [field, expected] of Object.entries(collectionScope)) {
-    if (record[field] !== expected) {
-      return false;
-    }
-  }
-  return true;
-}
-function pickFields(record, keys) {
-  const picked = {};
-  for (const key of keys) {
-    if (key in record) {
-      picked[key] = record[key];
-    }
-  }
-  return picked;
-}
-async function buildRouteOperation(store, mutation) {
-  const nodeId = store.getNodeId();
-  const clock = new import_core13.HybridLogicalClock(nodeId);
-  const schemaVersion = store.getSchema()?.version ?? 1;
-  const sequenceNumber = nextServerSequenceNumber(store);
-  if (mutation.type === "insert") {
-    return (0, import_core13.createOperation)(
-      {
-        nodeId,
-        type: "insert",
-        collection: mutation.collection,
-        recordId: mutation.recordId ?? (0, import_core13.generateUUIDv7)(),
-        data: mutation.data ?? {},
-        previousData: null,
-        sequenceNumber,
-        causalDeps: [],
-        schemaVersion
-      },
-      clock
-    );
-  }
-  if (!mutation.recordId) {
-    throw new RouteMutationError(
-      "MISSING_RECORD_ID",
-      `A ${mutation.type} mutation on "${mutation.collection}" requires a recordId.`
-    );
-  }
-  const current = await store.findRecord(mutation.collection, mutation.recordId);
-  if (mutation.type === "update") {
-    const data = mutation.data ?? {};
-    return (0, import_core13.createOperation)(
-      {
-        nodeId,
-        type: "update",
-        collection: mutation.collection,
-        recordId: mutation.recordId,
-        data,
-        previousData: current ? pickFields(current, Object.keys(data)) : {},
-        sequenceNumber,
-        causalDeps: [],
-        schemaVersion
-      },
-      clock
-    );
-  }
-  return (0, import_core13.createOperation)(
-    {
-      nodeId,
-      type: "delete",
-      collection: mutation.collection,
-      recordId: mutation.recordId,
-      data: null,
-      previousData: current ? { ...current } : null,
-      sequenceNumber,
-      causalDeps: [],
-      schemaVersion
-    },
-    clock
-  );
-}
-var RouteMutationError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "RouteMutationError";
-  }
-  code;
-};
-function createRouteContext(server, store) {
-  let mutationTail = Promise.resolve();
-  function serialize(work) {
-    const run = mutationTail.then(work, work);
-    mutationTail = run.then(
-      () => void 0,
-      () => void 0
-    );
-    return run;
-  }
-  return {
-    apply(mutation, options) {
-      return serialize(async () => {
-        let op;
-        try {
-          op = await buildRouteOperation(store, mutation);
-        } catch (error) {
-          if (error instanceof RouteMutationError) {
-            return { ok: false, code: error.code, message: error.message };
-          }
-          throw error;
-        }
-        if (options?.scope && !operationMatchesScopes(op, options.scope)) {
-          return {
-            ok: false,
-            code: "SCOPE_VIOLATION",
-            message: `Mutation on "${mutation.collection}" is outside the provided scope.`
-          };
-        }
-        const result = await server.applyLocalOperation(op);
-        if (result.result !== "applied") {
-          return {
-            ok: false,
-            code: result.rejection?.code ?? "NOT_APPLIED",
-            message: result.rejection?.message ?? `Operation on "${mutation.collection}" was not applied (${result.result}).`
-          };
-        }
-        const record = await store.findRecord(mutation.collection, op.recordId);
-        return { ok: true, operation: op, record };
-      });
-    },
-    async query(collection, options) {
-      const { scope, ...queryOptions } = options ?? {};
-      const records = await store.queryCollection(collection, queryOptions);
-      if (!scope) {
-        return records;
-      }
-      return records.filter((record) => recordMatchesScope(collection, record, scope));
-    },
-    async findById(collection, id, options) {
-      const record = await store.findRecord(collection, id);
-      if (!record) {
-        return null;
-      }
-      if (options?.scope && !recordMatchesScope(collection, record, options.scope)) {
-        return null;
-      }
-      return record;
-    }
-  };
-}
-
-// src/server/production-server.ts
 var MIME_TYPES = {
   ".html": "text/html",
   ".js": "text/javascript",
@@ -3966,7 +4216,7 @@ function createProductionServer(config) {
     enableDashboard: true,
     ...config.syncOptions
   });
-  const routeContext = createRouteContext(syncServer, config.store);
+  const routeContext = syncServer.getKoraContext();
   let httpServer = null;
   function getOperationalToken(kind) {
     const auth = config.operationalAuth;
@@ -4106,6 +4356,10 @@ function createProductionServer(config) {
     res.end(JSON.stringify(result.body ?? null));
   }
   return {
+    kora: routeContext,
+    getLiveBlobRefs() {
+      return syncServer.getLiveBlobRefs();
+    },
     async start() {
       const { createServer } = await import("http");
       const { createReadStream, existsSync, statSync } = await import("fs");
@@ -4405,6 +4659,7 @@ function formatUptime(ms) {
   MixedAuthProvider,
   NoAuthProvider,
   PostgresServerStore,
+  RETRIABLE_REJECTION_CODES,
   SqliteServerStore,
   TokenAuthProvider,
   WsServerTransport,
@@ -4415,6 +4670,7 @@ function formatUptime(ms) {
   createPrettyLogger,
   createProductionServer,
   createSilentLogger,
-  createSqliteServerStore
+  createSqliteServerStore,
+  isRetriableRejection
 });
 //# sourceMappingURL=index.cjs.map