js-bao 0.5.0 → 0.5.2

package/dist/cloudflare-do.js

@@ -17,6 +17,21 @@ function assertValidIdentifier(name, context) {
 function quoteIdentifier(name) {
   return `"${name.replace(/"/g, '""')}"`;
 }
+function deterministicIdentifierHash(value) {
+  let hash = 0;
+  for (let i = 0; i < value.length; i++) {
+    hash = (hash << 5) - hash + value.charCodeAt(i);
+    hash |= 0;
+  }
+  const positiveHash = hash === 0 ? 0 : Math.abs(hash);
+  return positiveHash.toString(36);
+}
+function buildSafeAlias(prefix, rawDescriptor) {
+  const suffix = deterministicIdentifierHash(rawDescriptor);
+  const candidate = `${prefix}_${suffix}`;
+  assertValidIdentifier(candidate, "Alias generation");
+  return candidate;
+}
 var IDENTIFIER_PATTERN;
 var init_sql = __esm({
   "src/utils/sql.ts"() {
@@ -214,21 +229,36 @@ var init_CursorManager = __esm({
         return fields;
       }
       /**
-       * Build ORDER BY clause from sort specification
+       * Build ORDER BY clause from sort specification.
+       *
+       * `direction` is the pagination direction (1 = forward, -1 = backward).
+       * For backward pagination each field's effective ORDER BY direction is
+       * reversed so the cursor's flipped inequality (built by
+       * `buildPaginationConditions`) returns the page adjacent to the cursor,
+       * not the globally smallest/largest window. Without this,
+       * `field < cursor ... ORDER BY field ASC LIMIT n` returns the n smallest
+       * rows overall instead of the n rows just below the cursor.
+       *
+       * The returned `directions` array carries the *declared* per-field sort
+       * directions (unaffected by `direction`) — `buildPaginationConditions`
+       * needs the declared directions to pick each field's comparison operator.
        */
-      static buildOrderClause(sort, fieldFormatter = (field) => field) {
+      static buildOrderClause(sort, fieldFormatter = (field) => field, direction = 1) {
         const fields = this.extractSortFields(sort);
         const clauses = [];
         const directions = [];
+        const sqlDir = (declared) => {
+          const effective = direction === -1 ? declared === 1 ? -1 : 1 : declared;
+          return effective === 1 ? "ASC" : "DESC";
+        };
         if (sort && Object.keys(sort).length > 0) {
           for (const [field, dir] of Object.entries(sort)) {
-            const sqlDirection = dir === 1 ? "ASC" : "DESC";
-            clauses.push(`${fieldFormatter(field)} ${sqlDirection}`);
+            clauses.push(`${fieldFormatter(field)} ${sqlDir(dir)}`);
             directions.push(dir);
           }
         }
         if (!sort || !sort.hasOwnProperty("id")) {
-          clauses.push(`${fieldFormatter("id")} ASC`);
+          clauses.push(`${fieldFormatter("id")} ${sqlDir(1)}`);
           directions.push(1);
         } else if (sort && sort.hasOwnProperty("id")) {
           directions.push(sort["id"]);
@@ -251,18 +281,27 @@ var init_CursorManager = __esm({
       /**
        * Generate next and previous cursors from result set
        */
-      static generateResultCursors(results, sortFields, _requestedDirection, hasMore, isFirstPage = false) {
+      static generateResultCursors(results, sortFields, requestedDirection, hasMore, isFirstPage = false) {
         if (results.length === 0) {
           return {};
         }
         const cursors = {};
         if (hasMore && results.length > 0) {
           const lastResult = results[results.length - 1];
-          cursors.nextCursor = this.generateCursor(lastResult, sortFields, 1);
+          cursors.nextCursor = this.generateCursor(
+            lastResult,
+            sortFields,
+            requestedDirection
+          );
         }
         if (results.length > 0 && !isFirstPage) {
           const firstResult = results[0];
-          cursors.prevCursor = this.generateCursor(firstResult, sortFields, -1);
+          const opposite = requestedDirection === 1 ? -1 : 1;
+          cursors.prevCursor = this.generateCursor(
+            firstResult,
+            sortFields,
+            opposite
+          );
         }
         return cursors;
       }
@@ -312,6 +351,21 @@ var init_patterns = __esm({
   }
 });
 
+// src/utils/yjsValues.ts
+import * as Y from "yjs";
+function isStringSetYMap(value) {
+  if (!(value instanceof Y.Map)) return false;
+  for (const v of value.values()) {
+    if (v !== true) return false;
+  }
+  return true;
+}
+var init_yjsValues = __esm({
+  "src/utils/yjsValues.ts"() {
+    "use strict";
+  }
+});
+
 // src/models/StringSet.ts
 var init_StringSet = __esm({
   "src/models/StringSet.ts"() {
@@ -337,10 +391,35 @@ var init_DocumentQueryTranslator = __esm({
   }
 });
 
+// src/models/writeLifecycle.ts
+import * as Y3 from "yjs";
+import { ulid as ulid2 } from "ulid";
+function registerFunctionDefaultGenerator(name, fn) {
+  FUNCTION_DEFAULT_GENERATORS.set(name, fn);
+}
+var KNOWN_FIELD_TYPE_MAP, KNOWN_FIELD_TYPES, FUNCTION_DEFAULT_GENERATORS, UNKNOWN_FUNCTION_DEFAULT;
+var init_writeLifecycle = __esm({
+  "src/models/writeLifecycle.ts"() {
+    "use strict";
+    KNOWN_FIELD_TYPE_MAP = {
+      string: true,
+      number: true,
+      boolean: true,
+      date: true,
+      id: true,
+      stringset: true
+    };
+    KNOWN_FIELD_TYPES = new Set(Object.keys(KNOWN_FIELD_TYPE_MAP));
+    FUNCTION_DEFAULT_GENERATORS = /* @__PURE__ */ new Map();
+    registerFunctionDefaultGenerator("generate_ulid", () => ulid2());
+    UNKNOWN_FUNCTION_DEFAULT = "$unknown_function";
+  }
+});
+
 // src/models/metaSync.ts
-import * as Y2 from "yjs";
+import * as Y4 from "yjs";
 function inferFieldType(value) {
-  if (value instanceof Y2.Map) return "stringset";
+  if (isStringSetYMap(value)) return "stringset";
   switch (typeof value) {
     case "string":
       return "string";
@@ -359,7 +438,10 @@ function encodeDefault(value) {
   if (value === void 0 || value === null) return void 0;
   if (typeof value === "function") {
     const name = KNOWN_FUNCTION_DEFAULTS.get(value);
-    return name ? `$${name}` : "$unknown_function";
+    return name ? `$${name}` : UNKNOWN_FUNCTION_DEFAULT;
+  }
+  if (typeof value === "string" && value.startsWith("$")) {
+    return `$${value}`;
   }
   return value;
 }
@@ -385,7 +467,7 @@ function syncModelMeta(yDoc, modelName, schema) {
   if (compoundConstraints.length > 0) {
     let constraints = meta.get("_constraints");
     if (!constraints) {
-      constraints = new Y2.Map();
+      constraints = new Y4.Map();
       meta.set("_constraints", constraints);
     }
     for (const constraint of compoundConstraints) {
@@ -396,7 +478,7 @@ function syncModelMeta(yDoc, modelName, schema) {
   if (relationships && Object.keys(relationships).length > 0) {
     let rels = meta.get("_relationships");
     if (!rels) {
-      rels = new Y2.Map();
+      rels = new Y4.Map();
       meta.set("_relationships", rels);
     }
     for (const [relName, relConfig] of Object.entries(relationships)) {
@@ -408,7 +490,7 @@ function syncModelMeta(yDoc, modelName, schema) {
 function syncFieldMeta(metaMap, fieldName, fieldOpts) {
   let fieldMeta = metaMap.get(fieldName);
   if (!fieldMeta) {
-    fieldMeta = new Y2.Map();
+    fieldMeta = new Y4.Map();
     metaMap.set(fieldName, fieldMeta);
   }
   setIfChanged(fieldMeta, "type", fieldOpts.type);
@@ -416,6 +498,7 @@ function syncFieldMeta(metaMap, fieldName, fieldOpts) {
   if (fieldOpts.unique) setIfChanged(fieldMeta, "unique", true);
   if (fieldOpts.required) setIfChanged(fieldMeta, "required", true);
   if (fieldOpts.autoAssign) setIfChanged(fieldMeta, "autoAssign", true);
+  if (fieldOpts.autoStamp) setIfChanged(fieldMeta, "autoStamp", fieldOpts.autoStamp);
   if (fieldOpts.maxLength !== void 0) setIfChanged(fieldMeta, "maxLength", fieldOpts.maxLength);
   if (fieldOpts.maxCount !== void 0) setIfChanged(fieldMeta, "maxCount", fieldOpts.maxCount);
   const encoded = encodeDefault(fieldOpts.default);
@@ -424,7 +507,7 @@ function syncFieldMeta(metaMap, fieldName, fieldOpts) {
 function syncConstraintMeta(constraintsMap, constraint) {
   let cMeta = constraintsMap.get(constraint.name);
   if (!cMeta) {
-    cMeta = new Y2.Map();
+    cMeta = new Y4.Map();
     constraintsMap.set(constraint.name, cMeta);
   }
   setIfChanged(cMeta, "type", "unique");
@@ -434,7 +517,7 @@ function syncConstraintMeta(constraintsMap, constraint) {
 function syncRelationshipMeta(relsMap, relName, relConfig) {
   let relMeta = relsMap.get(relName);
   if (!relMeta) {
-    relMeta = new Y2.Map();
+    relMeta = new Y4.Map();
     relsMap.set(relName, relMeta);
   }
   for (const [key, value] of Object.entries(relConfig)) {
@@ -449,7 +532,7 @@ function syncInferredMeta(yDoc, modelName, recordData) {
     if (fieldName.startsWith("_")) continue;
     let fieldMeta = meta.get(fieldName);
     if (!fieldMeta) {
-      fieldMeta = new Y2.Map();
+      fieldMeta = new Y4.Map();
       meta.set(fieldName, fieldMeta);
     }
     if (!fieldMeta.has("type")) {
@@ -469,16 +552,29 @@ var KNOWN_FUNCTION_DEFAULTS, _syncedCache;
 var init_metaSync = __esm({
   "src/models/metaSync.ts"() {
     "use strict";
+    init_yjsValues();
+    init_writeLifecycle();
     KNOWN_FUNCTION_DEFAULTS = /* @__PURE__ */ new WeakMap();
     _syncedCache = /* @__PURE__ */ new WeakMap();
   }
 });
 
+// src/utils/uniqueIndex.ts
+import * as Y5 from "yjs";
+function fieldUniqueConstraintName(modelName, fieldName) {
+  return `${modelName}_${fieldName}_unique`;
+}
+var init_uniqueIndex = __esm({
+  "src/utils/uniqueIndex.ts"() {
+    "use strict";
+  }
+});
+
 // src/models/BaseModel.ts
-import * as Y3 from "yjs";
-import { ulid as ulid2 } from "ulid";
+import * as Y6 from "yjs";
+import { ulid as ulid3 } from "ulid";
 function generateULID() {
-  return ulid2();
+  return ulid3();
 }
 var init_BaseModel = __esm({
   "src/models/BaseModel.ts"() {
@@ -489,6 +585,9 @@ var init_BaseModel = __esm({
     init_CursorManager();
     init_sql();
     init_metaSync();
+    init_writeLifecycle();
+    init_yjsValues();
+    init_uniqueIndex();
     registerFunctionDefault(generateULID, "generate_ulid");
   }
 });
@@ -1518,6 +1617,45 @@ var DurableObjectEngine = class extends JsonSchemaEngine {
 init_queryTypes();
 init_CursorManager();
 init_sql();
+
+// src/query/recordRow.ts
+var PROJECTED_JSON_ALIAS_PREFIX = "_json_";
+function projectedJsonAlias(fieldName) {
+  return `${PROJECTED_JSON_ALIAS_PREFIX}${fieldName}`;
+}
+function parseRecordRow(row) {
+  const { _id, _type, _data, ...rest } = row;
+  let parsed = {};
+  if (_data) {
+    try {
+      parsed = JSON.parse(_data);
+    } catch (e) {
+      console.warn("Failed to parse _data:", e);
+    }
+  }
+  return { id: _id, type: _type, ...parsed, ...decodeProjectedColumns(rest) };
+}
+function decodeProjectedColumns(columns) {
+  const decoded = {};
+  for (const [column, value] of Object.entries(columns)) {
+    if (!column.startsWith(PROJECTED_JSON_ALIAS_PREFIX)) {
+      decoded[column] = value;
+      continue;
+    }
+    decoded[column.slice(PROJECTED_JSON_ALIAS_PREFIX.length)] = parseJsonColumn(value);
+  }
+  return decoded;
+}
+function parseJsonColumn(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+// src/query/JsonQueryTranslator.ts
 init_patterns();
 var SYSTEM_FIELDS = /* @__PURE__ */ new Set(["id", "type"]);
 var JsonQueryTranslator = class {
@@ -1562,7 +1700,8 @@ var JsonQueryTranslator = class {
     const whereClause = this.translateFilter(filter);
     const orderClause = CursorManager.buildOrderClause(
       options?.sort,
-      (field) => this.getFieldSql(field)
+      (field) => this.getFieldSql(field),
+      options?.direction || 1
     );
     const limitClause = this.buildLimitClause(options);
     const paginationClause = this.buildPaginationClause(
@@ -2013,7 +2152,7 @@ var JsonQueryTranslator = class {
       for (const field of includeFields) {
         if (field === "id" || field === "type") continue;
         selectParts.push(
-          `json_extract(_data, '$.${field}') AS ${quoteIdentifier(field)}`
+          `_data -> '$.${field}' AS ${quoteIdentifier(projectedJsonAlias(field))}`
         );
       }
       return selectParts.join(", ");
@@ -2200,6 +2339,86 @@ var JsonQueryTranslator = class {
 init_CursorManager();
 init_sql();
 import { ulid } from "ulid";
+var AtomicBatchAbort = class extends Error {
+  constructor(failedIndex) {
+    super(`atomic batch aborted at operation ${failedIndex}`);
+    this.failedIndex = failedIndex;
+    this.name = "AtomicBatchAbort";
+  }
+};
+function checkReservedFieldName(fieldName) {
+  if (fieldName === "id") return null;
+  if (fieldName === "type") {
+    return `Field 'type' is reserved (maps to internal _type column in queries)`;
+  }
+  if (fieldName.startsWith("_")) {
+    return `Field '${fieldName}' is reserved (fields starting with '_' are internal)`;
+  }
+  return null;
+}
+function checkAutoStampsReservedFields(autoStamps) {
+  if (!autoStamps) return null;
+  for (const field of autoStamps.create || []) {
+    const err = checkReservedFieldName(field);
+    if (err) return `autoStamps.create: ${err}`;
+  }
+  for (const field of autoStamps.update || []) {
+    const err = checkReservedFieldName(field);
+    if (err) return `autoStamps.update: ${err}`;
+  }
+  return null;
+}
+function applyAutoStamps(data, autoStamps, isNew) {
+  if (!autoStamps || !data) return;
+  const reservedError = checkAutoStampsReservedFields(autoStamps);
+  if (reservedError) {
+    throw new Error(reservedError);
+  }
+  const now = Date.now();
+  if (isNew && autoStamps.create) {
+    for (const field of autoStamps.create) {
+      if (data[field] === void 0 || data[field] === null) {
+        data[field] = now;
+      }
+    }
+  }
+  if (autoStamps.update) {
+    for (const field of autoStamps.update) {
+      if (data[field] === void 0 || data[field] === null) {
+        data[field] = now;
+      }
+    }
+  }
+}
+function collectAppliedStamps(data, autoStamps, isNew) {
+  if (!autoStamps || !data) return void 0;
+  const stamps = {};
+  const take = (fields) => {
+    if (!fields) return;
+    for (const field of fields) {
+      const value = data[field];
+      if (typeof value === "number" && Number.isFinite(value)) {
+        stamps[field] = value;
+      }
+    }
+  };
+  if (isNew) take(autoStamps.create);
+  take(autoStamps.update);
+  return Object.keys(stamps).length > 0 ? stamps : void 0;
+}
+function collectAppliedValues(data, fieldNames) {
+  if (!data || !fieldNames || fieldNames.length === 0) return void 0;
+  const out = {};
+  for (const name of fieldNames) {
+    const value = data[name];
+    if (value !== void 0) out[name] = value;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function mergeAppliedFields(stamps, applied) {
+  if (!stamps && !applied) return void 0;
+  return { ...stamps ?? {}, ...applied ?? {} };
+}
 function createDatabaseDO(config = {}) {
   const hooks = config.hooks;
   return class DocumentDO {
@@ -2357,6 +2576,16 @@ function createDatabaseDO(config = {}) {
         hasMore,
         isFirstPage
       );
+      if (options?.projection && Object.keys(options.projection).length > 0) {
+        const isExclusion = Object.values(options.projection).some(
+          (v) => v === 0
+        );
+        if (isExclusion) {
+          data = data.map(
+            (rec) => this._applyProjection(rec, options.projection)
+          );
+        }
+      }
       const response = {
         data,
         hasMore,
@@ -2380,7 +2609,15 @@ function createDatabaseDO(config = {}) {
     /** @internal */
     async _handleSave(request, docId) {
       const body = await request.json();
-      const { modelName, data, stringSets, ifNotExists, condition, upsertOn } = body;
+      const {
+        modelName,
+        data,
+        stringSets,
+        ifNotExists,
+        condition,
+        upsertOn,
+        autoStamps
+      } = body;
       let id = body.id;
       if (!modelName || !id && !upsertOn) {
         return this._errorResponse("modelName is required, and either id or upsertOn must be provided", 400);
@@ -2394,6 +2631,12 @@ function createDatabaseDO(config = {}) {
           return this._errorResponse(reservedError, 400);
         }
       }
+      {
+        const autoStampsReservedError = checkAutoStampsReservedFields(autoStamps);
+        if (autoStampsReservedError) {
+          return this._errorResponse(autoStampsReservedError, 400);
+        }
+      }
       if (upsertOn) {
         if (data[upsertOn] === void 0 || data[upsertOn] === null || data[upsertOn] === "") {
           return this._errorResponse(
@@ -2443,8 +2686,10 @@ function createDatabaseDO(config = {}) {
           409
         );
       }
+      const isNew = !this._engine.recordExists(modelName, id);
+      applyAutoStamps(data, autoStamps, isNew);
+      let hookAppliedNames;
       if (hooks?.beforeSave) {
-        const isNew = !this._engine.recordExists(modelName, id);
         const ctx = {
           modelName,
           docId,
@@ -2459,6 +2704,7 @@ function createDatabaseDO(config = {}) {
         if (!result.allow) {
           return this._errorResponse(result.reason || "Save denied", 403);
         }
+        hookAppliedNames = result.serverAppliedFieldNames;
       }
       const existingForUnique = this._engine.execSqlSync(
         "SELECT _data FROM records WHERE _id = ? AND _type = ?",
@@ -2488,12 +2734,17 @@ function createDatabaseDO(config = {}) {
       }
       this._engine.trackModelFields(modelName, data);
       const response = { success: true, id };
+      const appliedFields = mergeAppliedFields(
+        collectAppliedStamps(data, autoStamps, isNew),
+        collectAppliedValues(data, hookAppliedNames)
+      );
+      if (appliedFields) response.appliedFields = appliedFields;
       return Response.json(response);
     }
     /** @internal — Partial update: merge provided fields into existing record */
     async _handlePatch(request, docId) {
       const body = await request.json();
-      const { modelName, id, data, stringSets, condition } = body;
+      const { modelName, id, data, stringSets, condition, autoStamps } = body;
       if (!modelName || !id || !data) {
         return this._errorResponse("modelName, id, and data are required", 400);
       }
@@ -2501,6 +2752,12 @@ function createDatabaseDO(config = {}) {
       if (reservedError) {
         return this._errorResponse(reservedError, 400);
       }
+      {
+        const autoStampsReservedError = checkAutoStampsReservedFields(autoStamps);
+        if (autoStampsReservedError) {
+          return this._errorResponse(autoStampsReservedError, 400);
+        }
+      }
       if (!this._engine.recordExists(modelName, id)) {
         return this._errorResponse(`Record ${modelName}/${id} not found`, 404);
       }
@@ -2510,6 +2767,8 @@ function createDatabaseDO(config = {}) {
           409
         );
       }
+      applyAutoStamps(data, autoStamps, false);
+      let hookAppliedNames;
       if (hooks?.beforeSave) {
         const ctx = {
           modelName,
@@ -2525,6 +2784,7 @@ function createDatabaseDO(config = {}) {
         if (!result.allow) {
           return this._errorResponse(result.reason || "Save denied", 403);
         }
+        hookAppliedNames = result.serverAppliedFieldNames;
       }
       const existing = this._engine.execSqlSync(
         "SELECT _data FROM records WHERE _id = ? AND _type = ?",
@@ -2548,6 +2808,11 @@ function createDatabaseDO(config = {}) {
       }
       this._engine.trackModelFields(modelName, data);
       const response = { success: true, id };
+      const appliedFields = mergeAppliedFields(
+        collectAppliedStamps(data, autoStamps, false),
+        collectAppliedValues(data, hookAppliedNames)
+      );
+      if (appliedFields) response.appliedFields = appliedFields;
       return Response.json(response);
     }
     /** @internal */
@@ -2589,13 +2854,16 @@ function createDatabaseDO(config = {}) {
     /** @internal — Execute multiple save/patch/delete operations in a single transaction */
     async _handleBatch(request, docId) {
       const body = await request.json();
-      const { operations } = body;
+      const { operations, atomic = false } = body;
       if (!operations || !Array.isArray(operations) || operations.length === 0) {
         return this._errorResponse("operations array is required and must not be empty", 400);
       }
       const hookDenials = /* @__PURE__ */ new Map();
       const resolvedBatchIds = /* @__PURE__ */ new Map();
       const opErrors = /* @__PURE__ */ new Map();
+      const batchCreatedIds = /* @__PURE__ */ new Set();
+      const batchIsNew = /* @__PURE__ */ new Map();
+      const batchAppliedNames = /* @__PURE__ */ new Map();
       for (let i = 0; i < operations.length; i++) {
         const op = operations[i];
         if (!op.modelName || !op.id && !(op.op === "save" && op.upsertOn) || !op.op) {
@@ -2647,9 +2915,31 @@ function createDatabaseDO(config = {}) {
               400
             );
           }
+          const autoStampsReservedError = checkAutoStampsReservedFields(
+            op.autoStamps
+          );
+          if (autoStampsReservedError) {
+            return this._errorResponse(
+              `Operation ${i}: ${autoStampsReservedError}`,
+              400
+            );
+          }
+          const effectiveId = resolvedBatchIds.get(i) || op.id || "";
+          const isNew = op.op === "save" ? (
+            // Codex P2 #3: also treat the id as not-new if a previous
+            // op in this batch already resolved to a save for the same
+            // model+id. Without this, two saves to the same fresh id
+            // both compute isNew=true against the pre-transaction
+            // database, so a `'create'` autoStamp on the second op
+            // would overwrite the first op's stamp.
+            !batchCreatedIds.has(`${op.modelName}/${effectiveId}`) && !this._engine.recordExists(op.modelName, effectiveId)
+          ) : false;
+          if (op.op === "save" && isNew && effectiveId) {
+            batchCreatedIds.add(`${op.modelName}/${effectiveId}`);
+          }
+          batchIsNew.set(i, isNew);
+          applyAutoStamps(op.data, op.autoStamps, isNew);
           if (hooks?.beforeSave) {
-            const effectiveId = resolvedBatchIds.get(i) || op.id || "";
-            const isNew = op.op === "save" ? !this._engine.recordExists(op.modelName, effectiveId) : false;
             const ctx = {
               modelName: op.modelName,
               docId,
@@ -2663,6 +2953,8 @@ function createDatabaseDO(config = {}) {
             const result = await hooks.beforeSave(ctx);
             if (!result.allow) {
               hookDenials.set(i, result.reason || "Save denied");
+            } else if (result.serverAppliedFieldNames) {
+              batchAppliedNames.set(i, result.serverAppliedFieldNames);
             }
           }
         } else if (op.op === "delete") {
@@ -2711,205 +3003,263 @@ function createDatabaseDO(config = {}) {
       }
       const results = [];
       const fieldsToTrack = [];
-      this._engine.transactionSync(() => {
-        for (let i = 0; i < operations.length; i++) {
-          const op = operations[i];
-          if (hookDenials.has(i)) {
-            const effectiveId = resolvedBatchIds.get(i) || op.id || "";
-            results.push({
-              success: false,
-              id: effectiveId,
-              error: hookDenials.get(i)
-            });
-            continue;
-          }
-          if (opErrors.has(i)) {
-            results.push({
-              success: false,
-              id: op.id || "",
-              error: opErrors.get(i)
-            });
-            continue;
-          }
-          const conditionId = resolvedBatchIds.get(i) || op.id;
-          if (op.condition && !this._checkCondition(op.modelName, conditionId, op.condition)) {
-            results.push({
-              success: false,
-              id: conditionId,
-              error: `Condition not met for ${op.modelName}/${conditionId}`
-            });
-            continue;
-          }
-          if (op.op === "save") {
-            let opId = resolvedBatchIds.get(i) || op.id;
-            if (op.ifNotExists && this._engine.recordExists(op.modelName, opId)) {
-              results.push({
-                success: false,
-                id: opId,
-                error: `Record ${op.modelName}/${opId} already exists`
+      const pushFailure = (index, failure) => {
+        results.push({
+          success: false,
+          id: failure.id,
+          error: failure.error,
+          status: failure.status,
+          code: failure.code
+        });
+        if (atomic) throw new AtomicBatchAbort(index);
+      };
+      try {
+        this._engine.transactionSync(() => {
+          for (let i = 0; i < operations.length; i++) {
+            const op = operations[i];
+            if (hookDenials.has(i)) {
+              const effectiveId = resolvedBatchIds.get(i) || op.id || "";
+              pushFailure(i, {
+                id: effectiveId,
+                error: hookDenials.get(i),
+                status: 403,
+                code: "HOOK_DENIED"
               });
               continue;
             }
-            if (op.data) {
-              const existingForUnique = this._engine.execSqlSync(
-                "SELECT _data FROM records WHERE _id = ? AND _type = ?",
-                [opId, op.modelName]
-              );
-              let dataForUnique = op.data;
-              if (existingForUnique.length > 0) {
-                const existingData = JSON.parse(existingForUnique[0]._data);
-                dataForUnique = { ...existingData, ...op.data };
-              }
-              const violation = this._engine.checkUniqueConstraints(
-                op.modelName,
-                opId,
-                dataForUnique
-              );
-              if (violation) {
-                results.push({
-                  success: false,
+            if (opErrors.has(i)) {
+              pushFailure(i, {
+                id: op.id || "",
+                error: opErrors.get(i),
+                status: 400,
+                code: "VALIDATION_ERROR"
+              });
+              continue;
+            }
+            const conditionId = resolvedBatchIds.get(i) || op.id;
+            if (op.condition && !this._checkCondition(op.modelName, conditionId, op.condition)) {
+              pushFailure(i, {
+                id: conditionId,
+                error: `Condition not met for ${op.modelName}/${conditionId}`,
+                status: 409,
+                code: "CONDITION_NOT_MET"
+              });
+              continue;
+            }
+            if (op.op === "save") {
+              let opId = resolvedBatchIds.get(i) || op.id;
+              if (op.ifNotExists && this._engine.recordExists(op.modelName, opId)) {
+                pushFailure(i, {
                   id: opId,
-                  error: violation
+                  error: `Record ${op.modelName}/${opId} already exists`,
+                  status: 409,
+                  code: "ALREADY_EXISTS"
                 });
                 continue;
               }
-            }
-            if (op.stringSets && Object.keys(op.stringSets).length > 0) {
-              const { id: _id, ...fieldsForJson } = op.data;
-              const jsonFields = { ...fieldsForJson, ...op.stringSets };
-              const dataJson = JSON.stringify(jsonFields);
-              this._engine.execSqlSync(
-                "INSERT INTO records (_id, _type, _data) VALUES (?, ?, ?) ON CONFLICT(_type, _id) DO UPDATE SET _data = json_patch(records._data, excluded._data)",
-                [opId, op.modelName, dataJson]
-              );
-              for (const [fieldName, values] of Object.entries(op.stringSets)) {
-                this._engine.execSqlSync(
-                  "DELETE FROM stringset_index WHERE _type = ? AND _record_id = ? AND field = ?",
-                  [op.modelName, opId, fieldName]
+              if (op.data) {
+                const existingForUnique = this._engine.execSqlSync(
+                  "SELECT _data FROM records WHERE _id = ? AND _type = ?",
+                  [opId, op.modelName]
                 );
-                for (const value of values) {
-                  this._engine.execSqlSync(
-                    "INSERT OR IGNORE INTO stringset_index (_record_id, _type, field, value) VALUES (?, ?, ?, ?)",
-                    [opId, op.modelName, fieldName, value]
-                  );
+                let dataForUnique = op.data;
+                if (existingForUnique.length > 0) {
+                  const existingData = JSON.parse(existingForUnique[0]._data);
+                  dataForUnique = { ...existingData, ...op.data };
                 }
-              }
-            } else {
-              const { id: _id, ...fieldsForJson } = op.data;
-              const dataJson = JSON.stringify(fieldsForJson);
-              this._engine.execSqlSync(
-                "INSERT INTO records (_id, _type, _data) VALUES (?, ?, ?) ON CONFLICT(_type, _id) DO UPDATE SET _data = json_patch(records._data, excluded._data)",
-                [opId, op.modelName, dataJson]
-              );
-            }
-            if (op.data) fieldsToTrack.push({ modelName: op.modelName, data: op.data });
-            results.push({ success: true, id: opId });
-          } else if (op.op === "patch") {
-            if (!this._engine.recordExists(op.modelName, op.id)) {
-              results.push({
-                success: false,
-                id: op.id,
-                error: `Record ${op.modelName}/${op.id} not found`
-              });
-              continue;
-            }
-            if (op.data) {
-              const existing = this._engine.execSqlSync(
-                "SELECT _data FROM records WHERE _id = ? AND _type = ?",
-                [op.id, op.modelName]
-              );
-              if (existing.length > 0) {
-                const existingData = JSON.parse(existing[0]._data);
-                const mergedData = { ...existingData, ...op.data };
                 const violation = this._engine.checkUniqueConstraints(
                   op.modelName,
-                  op.id,
-                  mergedData
+                  opId,
+                  dataForUnique
                 );
                 if (violation) {
-                  results.push({
-                    success: false,
-                    id: op.id,
-                    error: violation
+                  pushFailure(i, {
+                    id: opId,
+                    error: violation,
+                    status: 409,
+                    code: "UNIQUE_VIOLATION"
                   });
                   continue;
                 }
               }
-            }
-            const found = this._engine.patchRecordRaw(
-              op.modelName,
-              op.id,
-              op.data,
-              op.stringSets
-            );
-            if (!found) {
-              results.push({
-                success: false,
-                id: op.id,
-                error: `Record ${op.modelName}/${op.id} not found`
-              });
-            } else {
+              if (op.stringSets && Object.keys(op.stringSets).length > 0) {
+                const { id: _id, ...fieldsForJson } = op.data;
+                const jsonFields = { ...fieldsForJson, ...op.stringSets };
+                const dataJson = JSON.stringify(jsonFields);
+                this._engine.execSqlSync(
+                  "INSERT INTO records (_id, _type, _data) VALUES (?, ?, ?) ON CONFLICT(_type, _id) DO UPDATE SET _data = json_patch(records._data, excluded._data)",
+                  [opId, op.modelName, dataJson]
+                );
+                for (const [fieldName, values] of Object.entries(op.stringSets)) {
+                  this._engine.execSqlSync(
+                    "DELETE FROM stringset_index WHERE _type = ? AND _record_id = ? AND field = ?",
+                    [op.modelName, opId, fieldName]
+                  );
+                  for (const value of values) {
+                    this._engine.execSqlSync(
+                      "INSERT OR IGNORE INTO stringset_index (_record_id, _type, field, value) VALUES (?, ?, ?, ?)",
+                      [opId, op.modelName, fieldName, value]
+                    );
+                  }
+                }
+              } else {
+                const { id: _id, ...fieldsForJson } = op.data;
+                const dataJson = JSON.stringify(fieldsForJson);
+                this._engine.execSqlSync(
+                  "INSERT INTO records (_id, _type, _data) VALUES (?, ?, ?) ON CONFLICT(_type, _id) DO UPDATE SET _data = json_patch(records._data, excluded._data)",
+                  [opId, op.modelName, dataJson]
+                );
+              }
               if (op.data) fieldsToTrack.push({ modelName: op.modelName, data: op.data });
+              const saveResult = { success: true, id: opId };
+              const saveApplied = mergeAppliedFields(
+                collectAppliedStamps(
+                  op.data,
+                  op.autoStamps,
+                  batchIsNew.get(i) ?? false
+                ),
+                collectAppliedValues(op.data, batchAppliedNames.get(i))
+              );
+              if (saveApplied) saveResult.appliedFields = saveApplied;
+              results.push(saveResult);
+            } else if (op.op === "patch") {
+              if (!this._engine.recordExists(op.modelName, op.id)) {
+                pushFailure(i, {
+                  id: op.id,
+                  error: `Record ${op.modelName}/${op.id} not found`,
+                  status: 404,
+                  code: "NOT_FOUND"
+                });
+                continue;
+              }
+              if (op.data) {
+                const existing = this._engine.execSqlSync(
+                  "SELECT _data FROM records WHERE _id = ? AND _type = ?",
+                  [op.id, op.modelName]
+                );
+                if (existing.length > 0) {
+                  const existingData = JSON.parse(existing[0]._data);
+                  const mergedData = { ...existingData, ...op.data };
+                  const violation = this._engine.checkUniqueConstraints(
+                    op.modelName,
+                    op.id,
+                    mergedData
+                  );
+                  if (violation) {
+                    pushFailure(i, {
+                      id: op.id,
+                      error: violation,
+                      status: 409,
+                      code: "UNIQUE_VIOLATION"
+                    });
+                    continue;
+                  }
+                }
+              }
+              const found = this._engine.patchRecordRaw(
+                op.modelName,
+                op.id,
+                op.data,
+                op.stringSets
+              );
+              if (!found) {
+                pushFailure(i, {
+                  id: op.id,
+                  error: `Record ${op.modelName}/${op.id} not found`,
+                  status: 404,
+                  code: "NOT_FOUND"
+                });
+              } else {
+                if (op.data) fieldsToTrack.push({ modelName: op.modelName, data: op.data });
+                const patchResult = {
+                  success: true,
+                  id: op.id
+                };
+                const patchApplied = mergeAppliedFields(
+                  collectAppliedStamps(op.data, op.autoStamps, false),
+                  collectAppliedValues(op.data, batchAppliedNames.get(i))
+                );
+                if (patchApplied) patchResult.appliedFields = patchApplied;
+                results.push(patchResult);
+              }
+            } else if (op.op === "delete") {
+              this._engine.execSqlSync(
+                "DELETE FROM records WHERE _id = ? AND _type = ?",
+                [op.id, op.modelName]
+              );
+              this._engine.execSqlSync(
+                "DELETE FROM stringset_index WHERE _record_id = ? AND _type = ?",
+                [op.id, op.modelName]
+              );
+              results.push({ success: true, id: op.id });
+            } else if (op.op === "increment") {
+              const newValues = this._engine.incrementFieldsRaw(
+                op.modelName,
+                op.id,
+                op.fields
+              );
+              if (!newValues) {
+                pushFailure(i, {
+                  id: op.id,
+                  error: `Record ${op.modelName}/${op.id} not found`,
+                  status: 404,
+                  code: "NOT_FOUND"
+                });
+              } else {
+                results.push({ success: true, id: op.id, values: newValues });
+              }
+            } else if (op.op === "addToSet") {
+              if (!this._engine.recordExists(op.modelName, op.id)) {
+                pushFailure(i, {
+                  id: op.id,
+                  error: `Record ${op.modelName}/${op.id} not found`,
+                  status: 404,
+                  code: "NOT_FOUND"
+                });
+                continue;
+              }
+              this._engine.addToStringSetsRaw(
+                op.modelName,
+                op.id,
+                op.stringSets
+              );
+              results.push({ success: true, id: op.id });
+            } else if (op.op === "removeFromSet") {
+              if (!this._engine.recordExists(op.modelName, op.id)) {
+                pushFailure(i, {
+                  id: op.id,
+                  error: `Record ${op.modelName}/${op.id} not found`,
+                  status: 404,
+                  code: "NOT_FOUND"
+                });
+                continue;
+              }
+              this._engine.removeFromStringSetsRaw(
+                op.modelName,
+                op.id,
+                op.stringSets
+              );
               results.push({ success: true, id: op.id });
             }
-          } else if (op.op === "delete") {
-            this._engine.execSqlSync(
-              "DELETE FROM records WHERE _id = ? AND _type = ?",
-              [op.id, op.modelName]
-            );
-            this._engine.execSqlSync(
-              "DELETE FROM stringset_index WHERE _record_id = ? AND _type = ?",
-              [op.id, op.modelName]
-            );
-            results.push({ success: true, id: op.id });
-          } else if (op.op === "increment") {
-            const newValues = this._engine.incrementFieldsRaw(
-              op.modelName,
-              op.id,
-              op.fields
-            );
-            if (!newValues) {
-              results.push({
-                success: false,
-                id: op.id,
-                error: `Record ${op.modelName}/${op.id} not found`
-              });
-            } else {
-              results.push({ success: true, id: op.id, values: newValues });
-            }
-          } else if (op.op === "addToSet") {
-            if (!this._engine.recordExists(op.modelName, op.id)) {
-              results.push({
-                success: false,
-                id: op.id,
-                error: `Record ${op.modelName}/${op.id} not found`
-              });
-              continue;
-            }
-            this._engine.addToStringSetsRaw(
-              op.modelName,
-              op.id,
-              op.stringSets
-            );
-            results.push({ success: true, id: op.id });
-          } else if (op.op === "removeFromSet") {
-            if (!this._engine.recordExists(op.modelName, op.id)) {
-              results.push({
-                success: false,
-                id: op.id,
-                error: `Record ${op.modelName}/${op.id} not found`
-              });
-              continue;
-            }
-            this._engine.removeFromStringSetsRaw(
-              op.modelName,
-              op.id,
-              op.stringSets
-            );
-            results.push({ success: true, id: op.id });
           }
+        });
+      } catch (err) {
+        if (err instanceof AtomicBatchAbort) {
+          const failed = results[err.failedIndex];
+          const failedOp = operations[err.failedIndex];
+          console.warn(
+            `[js-bao batch] atomic rollback: operation ${err.failedIndex} (${failedOp?.op}) failed \u2014 ${failed?.error ?? "unknown error"}`
+          );
+          const errorBody = {
+            error: `Operation ${err.failedIndex} (${failedOp?.op}) failed: ${failed?.error ?? "unknown error"}`,
+            failedIndex: err.failedIndex,
+            op: failedOp?.op,
+            code: failed?.code
+          };
+          return Response.json(errorBody, { status: failed?.status ?? 409 });
         }
-      });
+        throw err;
+      }
       for (const entry of fieldsToTrack) {
         this._engine.trackModelFields(entry.modelName, entry.data);
       }
@@ -3279,6 +3629,18 @@ function createDatabaseDO(config = {}) {
         }
         return facetResult;
       }
+      if (aggOptions.groupBy.length === 0) {
+        const row = results[0];
+        const flat = {};
+        for (const op of aggOptions.operations) {
+          if (op.type === "count") {
+            flat.count = row.count;
+          } else {
+            flat[`${op.type}_${op.field}`] = row[`${op.type}_${op.field}`];
+          }
+        }
+        return flat;
+      }
       const nestedResult = {};
       const aliasLookup = /* @__PURE__ */ new Map();
       for (const entry of aliasMap) {
@@ -3606,16 +3968,7 @@ function createDatabaseDO(config = {}) {
     }
     /** @internal */
     _parseRow(row) {
-      const { _id, _type, _data, ...rest } = row;
-      let parsed = {};
-      if (_data) {
-        try {
-          parsed = JSON.parse(_data);
-        } catch (e) {
-          console.warn("Failed to parse _data:", e);
-        }
-      }
-      return { id: _id, type: _type, ...parsed, ...rest };
+      return parseRecordRow(row);
     }
     // ─── Include (Related Data Loading) ──────────────────────────────
     /** @internal — Validate an IncludeSpec, returning an error message or null */
@@ -3745,8 +4098,9 @@ function createDatabaseDO(config = {}) {
         spec.filter,
         { projection: spec.projection }
       );
+      const relatedProjected = spec.projection ? related.map((r) => this._applyProjection(r, spec.projection)) : related;
       const lookupMap = /* @__PURE__ */ new Map();
-      for (const r of related) {
+      for (const r of relatedProjected) {
         lookupMap.set(r.id, r);
       }
       for (const rec of records) {
@@ -3779,8 +4133,9 @@ function createDatabaseDO(config = {}) {
         spec.filter,
         { projection: spec.projection }
       );
+      const targetsProjected = spec.projection ? targets.map((t) => this._applyProjection(t, spec.projection)) : targets;
       const targetLookup = /* @__PURE__ */ new Map();
-      for (const t of targets) {
+      for (const t of targetsProjected) {
         targetLookup.set(t.id, t);
       }
       for (const rec of records) {
@@ -3924,6 +4279,14 @@ function createDatabaseDO(config = {}) {
       return allResults;
     }
     /** @internal — Apply projection to a single record */
+    // Apply a projection to a single record. Assumes the projection has
+    // already been validated upstream (JsonQueryTranslator.validateProjection /
+    // buildSelectClause reject mixed inclusion+exclusion): `isInclusion` treats
+    // "any value === 1" as inclusion mode, so an unvalidated mixed projection
+    // would silently ignore the excludes. `id` and `type` are system-identity
+    // fields and are always kept in BOTH modes (a record without its `id` is
+    // unusable downstream). `_meta` is NOT forced — an explicit `{ _meta: 0 }`
+    // is honored.
     _applyProjection(record, projection) {
       const fields = Object.entries(projection);
       if (fields.length === 0) return record;
@@ -3942,7 +4305,7 @@ function createDatabaseDO(config = {}) {
       } else {
         const result = { ...record };
         for (const [f, v] of fields) {
-          if (v === 0) delete result[f];
+          if (v === 0 && f !== "id" && f !== "type") delete result[f];
         }
         return result;
       }
@@ -4010,7 +4373,8 @@ async function handleRequest(request, env) {
 }
 
 // src/utils/yDocSchema.ts
-import * as Y from "yjs";
+init_yjsValues();
+import * as Y2 from "yjs";
 function discoverSchema(yDoc) {
   const models = {};
   const metaNames = /* @__PURE__ */ new Set();
@@ -4044,7 +4408,7 @@ function discoverModelNames(yDoc) {
 function materializeMap(yDoc, key) {
   try {
     const map = yDoc.getMap(key);
-    return map instanceof Y.Map ? map : null;
+    return map instanceof Y2.Map ? map : null;
   } catch {
     return null;
   }
@@ -4054,11 +4418,11 @@ function readModelMeta(metaMap) {
   let constraints;
   let relationships;
   for (const [key, value] of metaMap.entries()) {
-    if (key === "_constraints" && value instanceof Y.Map) {
+    if (key === "_constraints" && value instanceof Y2.Map) {
       constraints = readConstraints(value);
-    } else if (key === "_relationships" && value instanceof Y.Map) {
+    } else if (key === "_relationships" && value instanceof Y2.Map) {
       relationships = readRelationships(value);
-    } else if (value instanceof Y.Map) {
+    } else if (value instanceof Y2.Map) {
       fields[key] = readFieldMeta(value);
     }
   }
@@ -4077,6 +4441,10 @@ function readFieldMeta(fieldMap) {
   if (fieldMap.get("unique") === true) field.unique = true;
   if (fieldMap.get("required") === true) field.required = true;
   if (fieldMap.get("autoAssign") === true) field.autoAssign = true;
+  const autoStamp = fieldMap.get("autoStamp");
+  if (typeof autoStamp === "string" && (autoStamp === "create" || autoStamp === "update" || autoStamp === "both")) {
+    field.autoStamp = autoStamp;
+  }
   const def = fieldMap.get("default");
   if (def !== void 0) field.default = def;
   const maxLength = fieldMap.get("maxLength");
@@ -4089,7 +4457,7 @@ function inferModelFromData(dataMap) {
   const fields = {};
   let sampled = 0;
   for (const [_recordId, recordValue] of dataMap.entries()) {
-    if (!(recordValue instanceof Y.Map)) continue;
+    if (!(recordValue instanceof Y2.Map)) continue;
     if (++sampled > 5) break;
     for (const [fieldName, value] of recordValue.entries()) {
       if (fieldName.startsWith("_")) continue;
@@ -4102,7 +4470,7 @@ function inferModelFromData(dataMap) {
   return { fields };
 }
 function inferTypeFromValue(value) {
-  if (value instanceof Y.Map) return "stringset";
+  if (isStringSetYMap(value)) return "stringset";
   switch (typeof value) {
     case "string":
       return "string";
@@ -4117,7 +4485,7 @@ function inferTypeFromValue(value) {
 function readConstraints(constraintsMap) {
   const out = {};
   for (const [name, value] of constraintsMap.entries()) {
-    if (!(value instanceof Y.Map)) continue;
+    if (!(value instanceof Y2.Map)) continue;
     let fields = [];
     const rawFields = value.get("fields");
     if (typeof rawFields === "string") {
@@ -4136,7 +4504,7 @@ function readConstraints(constraintsMap) {
 function readRelationships(relsMap) {
   const out = {};
   for (const [name, value] of relsMap.entries()) {
-    if (!(value instanceof Y.Map)) continue;
+    if (!(value instanceof Y2.Map)) continue;
     const rel = {};
     for (const [k, v] of value.entries()) {
       rel[k] = v;
@@ -4147,6 +4515,7 @@ function readRelationships(relsMap) {
 }
 var CAMEL_TO_SNAKE = {
   autoAssign: "auto_assign",
+  autoStamp: "auto_stamp",
   maxLength: "max_length",
   maxCount: "max_count",
   relatedIdField: "related_id_field",
@@ -4177,6 +4546,7 @@ function schemaToToml(schema) {
       lines.push(`[models.${modelName}.fields.${fieldName}]`);
       lines.push(`type = ${tomlValue(field.type)}`);
       if (field.autoAssign) lines.push("auto_assign = true");
+      if (field.autoStamp) lines.push(`auto_stamp = ${tomlValue(field.autoStamp)}`);
       if (field.indexed) lines.push("indexed = true");
       if (field.unique) lines.push("unique = true");
       if (field.required) lines.push("required = true");
@@ -4213,6 +4583,7 @@ import { parse as parseToml } from "smol-toml";
 // src/models/schema.ts
 init_BaseModel();
 init_ModelRegistry();
+init_uniqueIndex();
 function defineModelSchema(input) {
   const { name, fields } = input;
   const options = {
@@ -4255,7 +4626,7 @@ function resolveUniqueConstraints(modelName, fields, customConstraints) {
   for (const [fieldName, options] of fields.entries()) {
     if (options.unique) {
       resolved.push({
-        name: `${modelName}_${fieldName}_unique`,
+        name: fieldUniqueConstraintName(modelName, fieldName),
         fields: [fieldName]
       });
     }
@@ -4300,10 +4671,13 @@ var KNOWN_FIELD_KEYS = /* @__PURE__ */ new Set([
   "unique",
   "required",
   "auto_assign",
+  "auto_stamp",
   "max_length",
   "max_count",
-  "default"
+  "default",
+  "enum"
 ]);
+var VALID_AUTO_STAMP_VALUES = /* @__PURE__ */ new Set(["create", "update", "both"]);
 var KNOWN_MODEL_KEYS = /* @__PURE__ */ new Set([
   "fields",
   "relationships",
@@ -4345,9 +4719,37 @@ function parseFieldOptions(raw, context, strict) {
   if (raw.unique === true) opts.unique = true;
   if (raw.required === true) opts.required = true;
   if (raw.auto_assign === true) opts.autoAssign = true;
+  if (raw.auto_stamp !== void 0) {
+    if (typeof raw.auto_stamp !== "string" || !VALID_AUTO_STAMP_VALUES.has(raw.auto_stamp)) {
+      throw new Error(
+        `${context}: invalid auto_stamp value "${raw.auto_stamp}". Must be one of: ${[
+          ...VALID_AUTO_STAMP_VALUES
+        ].join(", ")}`
+      );
+    }
+    opts.autoStamp = raw.auto_stamp;
+  }
   if (raw.max_length !== void 0) opts.maxLength = raw.max_length;
   if (raw.max_count !== void 0) opts.maxCount = raw.max_count;
   if (raw.default !== void 0) opts.default = raw.default;
+  if (raw.enum !== void 0) {
+    if (raw.type !== "string") {
+      throw new Error(
+        `${context}: \`enum\` is only valid on a "string" field, not "${raw.type}".`
+      );
+    }
+    if (!Array.isArray(raw.enum) || raw.enum.length === 0) {
+      throw new Error(
+        `${context}: \`enum\` must be a non-empty array of strings.`
+      );
+    }
+    if (!raw.enum.every((v) => typeof v === "string")) {
+      throw new Error(
+        `${context}: \`enum\` values must all be strings.`
+      );
+    }
+    opts.enum = [...raw.enum];
+  }
   return opts;
 }
 function requireField(raw, field, context) {
@@ -4471,18 +4873,26 @@ function loadSchemaFromTomlString(tomlString, options = {}) {
 
 // src/cloudflare-do.ts
 init_metaSync();
+init_sql();
 export {
   DurableObjectEngine,
   JsonQueryTranslator,
   JsonSchemaDDL,
+  PROJECTED_JSON_ALIAS_PREFIX,
+  buildSafeAlias,
+  checkAutoStampsReservedFields,
+  checkReservedFieldName,
   clearMetaSyncCache,
   createDatabaseDO,
   createDocumentDO,
+  deterministicIdentifierHash,
   discoverModelNames,
   discoverSchema,
   handleRequest,
   inferFieldType,
   loadSchemaFromTomlString,
+  parseRecordRow,
+  projectedJsonAlias,
   registerFunctionDefault,
   schemaToToml,
   syncInferredMeta,