js-bao 0.7.0-alpha.9 → 0.11.1

package/README.md

@@ -1553,3 +1553,19 @@ See the `examples/` directory for complete working examples:
 
 - `examples/simple-node-test.mjs` - Basic Node.js usage without models
 - `examples/node-example.mjs` - Complete Node.js example with models
+
+## Release notes
+
+Changes to the on-disk behaviour of `js-bao/cloudflare/do` (`DurableObjectEngine`)
+that a store's owner can observe. Newest first.
+
+- **`_indexes.created_at` reports the first registration** (#3875). Re-registering
+  a field index whose `field_type` and `is_unique` are unchanged no longer
+  rewrites its `_indexes` row: it writes no row, and `created_at` keeps the time
+  of the first registration. A registration that changes either column still
+  rewrites the row and refreshes `created_at`, as before.
+- **`replaceWithStringSets` is internal** (#3875). The engine gained
+  `replaceWithStringSets` / `replaceWithStringSetsRaw`, a guarded replace used
+  only by the platform's plain-document projection rebuild. They are marked
+  `@internal` and are not a public API; saves keep the merging
+  `insertWithStringSets`.

package/dist/browser.cjs

@@ -1410,12 +1410,18 @@ function fieldUniqueConstraintName(modelName, fieldName) {
 }
 function resolveUniqueConstraints(modelName, fields, customConstraints) {
   const resolved = [];
+  const stringSetFields = /* @__PURE__ */ new Set();
+  for (const [fieldName, options] of fields.entries()) {
+    if (options.type === "stringset") stringSetFields.add(fieldName);
+  }
   for (const [fieldName, options] of fields.entries()) {
     if (options.unique) {
-      resolved.push({
-        name: fieldUniqueConstraintName(modelName, fieldName),
-        fields: [fieldName]
-      });
+      const name = fieldUniqueConstraintName(modelName, fieldName);
+      if (stringSetFields.has(fieldName)) {
+        warnStringsetConstraintSkipped(modelName, name, fieldName);
+        continue;
+      }
+      resolved.push({ name, fields: [fieldName] });
     }
   }
   if (customConstraints) {
@@ -1429,6 +1435,13 @@ function resolveUniqueConstraints(modelName, fields, customConstraints) {
         );
         continue;
       }
+      const stringSetField = constraint.fields.find(
+        (field) => stringSetFields.has(field)
+      );
+      if (stringSetField) {
+        warnStringsetConstraintSkipped(modelName, constraint.name, stringSetField);
+        continue;
+      }
       if (resolved.some((item) => item.name === constraint.name)) {
         console.warn(
           `[defineModelSchema] Duplicate unique constraint name "${constraint.name}" in model "${modelName}".`
@@ -1442,11 +1455,65 @@ function resolveUniqueConstraints(modelName, fields, customConstraints) {
   }
   return resolved;
 }
-var Y2;
+function warnStringsetConstraintSkipped(modelName, constraintName, fieldName) {
+  console.warn(
+    `[defineModelSchema] Unique constraint "${constraintName}" for model "${modelName}" names the stringset field "${fieldName}", which cannot be unique. Skipping.`
+  );
+}
+function uniqueStringsetViolations(modelName, fields, customConstraints) {
+  const entries = fields instanceof Map ? [...fields.entries()] : Object.entries(fields);
+  const stringSetFields = /* @__PURE__ */ new Set();
+  const violations = [];
+  for (const [fieldName, options] of entries) {
+    if (options?.type !== "stringset") continue;
+    stringSetFields.add(fieldName);
+    if (options.unique === true) {
+      violations.push({
+        kind: "field",
+        field: fieldName,
+        constraint: fieldUniqueConstraintName(modelName, fieldName)
+      });
+    }
+  }
+  for (const constraint of customConstraints ?? []) {
+    const field = (constraint?.fields ?? []).find(
+      (name) => stringSetFields.has(name)
+    );
+    if (field !== void 0) {
+      violations.push({ kind: "compound", field, constraint: constraint.name });
+    }
+  }
+  return violations;
+}
+function uniqueStringsetMessage(modelName, violation) {
+  const reason = "A unique constraint applies to scalar fields only.";
+  if (violation.kind === "field") {
+    return `Model "${modelName}": field "${violation.field}" is a stringset and cannot be unique. ${reason}`;
+  }
+  return `Model "${modelName}": unique constraint "${violation.constraint}" names the stringset field "${violation.field}", which cannot be unique. ${reason}`;
+}
+function omitStringsetConstraints(constraints, stringSetFields) {
+  const stringSets = new Set(stringSetFields);
+  const kept = [];
+  const dropped = [];
+  for (const constraint of constraints) {
+    const field = (constraint.fields ?? []).find((name) => stringSets.has(name));
+    if (field === void 0) kept.push(constraint);
+    else dropped.push({ constraint, field });
+  }
+  return { kept, dropped };
+}
+var Y2, UniqueStringsetError;
 var init_uniqueIndex = __esm({
   "src/utils/uniqueIndex.ts"() {
     "use strict";
     Y2 = __toESM(require("yjs"), 1);
+    UniqueStringsetError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "UniqueStringsetError";
+      }
+    };
   }
 });
 
@@ -1727,6 +1794,80 @@ function groupOverlayEntries(entries) {
 function readOverlayRecord(modelMap, recordId) {
   return collectOverlayRecords(modelMap, /* @__PURE__ */ new Set([recordId])).get(recordId);
 }
+function recordSegmentOf(key) {
+  const separator = key.indexOf(OVERLAY_KEY_SEPARATOR);
+  return separator > 0 ? key.slice(0, separator) : null;
+}
+function reindexKey(index, map, key) {
+  const segment = recordSegmentOf(key);
+  if (segment === null) return;
+  if (map.has(key)) {
+    let keys = index.get(segment);
+    if (!keys) index.set(segment, keys = /* @__PURE__ */ new Set());
+    keys.add(key);
+  } else {
+    const keys = index.get(segment);
+    if (!keys) return;
+    keys.delete(key);
+    if (keys.size === 0) index.delete(segment);
+  }
+}
+function recordKeyIndexOf(source) {
+  const map = source;
+  if (typeof map.observe !== "function" || typeof map.has !== "function" || typeof map.get !== "function" || typeof map.keys !== "function") {
+    return null;
+  }
+  const live = map;
+  let index = recordKeyIndexes.get(source);
+  if (!index) {
+    const built = /* @__PURE__ */ new Map();
+    for (const key of live.keys()) {
+      if (typeof key === "string") reindexKey(built, live, key);
+    }
+    live.observe((event) => {
+      for (const key of event.keysChanged) {
+        if (typeof key === "string") reindexKey(built, live, key);
+      }
+    });
+    recordKeyIndexes.set(source, built);
+    index = built;
+  }
+  const pending = live.doc?._transaction?.changed.get(source);
+  if (pending) {
+    for (const key of pending) {
+      if (typeof key === "string") reindexKey(index, live, key);
+    }
+  }
+  return index;
+}
+function foldTouchedOverlayKeys(modelMap, touched) {
+  const present = [];
+  const vanished = /* @__PURE__ */ new Set();
+  const tombstoneTouched = /* @__PURE__ */ new Set();
+  for (const key of touched) {
+    const parsed = parseOverlayKey(key);
+    if (!parsed) continue;
+    if (parsed.marker === OVERLAY_MARKER_DELETED) tombstoneTouched.add(parsed.recordId);
+    if (modelMap.has(key)) present.push([key, modelMap.get(key)]);
+    else vanished.add(parsed.recordId);
+  }
+  const entries = groupOverlayEntries(present);
+  for (const id of vanished) if (!entries.has(id)) entries.set(id, emptyEntry(id));
+  const rebuild = /* @__PURE__ */ new Set();
+  for (const [id, entry] of entries) {
+    if (modelMap.get(overlayMarkerKey(id, OVERLAY_MARKER_DELETED)) === true) {
+      entries.set(id, { ...emptyEntry(id), deleted: true });
+      continue;
+    }
+    if (entry.replace || vanished.has(id) || tombstoneTouched.has(id)) rebuild.add(id);
+  }
+  if (rebuild.size > 0) {
+    for (const [id, entry] of collectOverlayRecords(modelMap, rebuild)) {
+      entries.set(id, entry);
+    }
+  }
+  return entries;
+}
 function completeOverlayEntries(modelMap, entries) {
   const rebuild = /* @__PURE__ */ new Set();
   for (const [id, entry] of entries) {
@@ -1743,6 +1884,23 @@ function collectOverlayRecords(modelMap, recordIds) {
   const wanted = /* @__PURE__ */ new Map();
   for (const id of recordIds) wanted.set(encodeOverlaySegment(id), id);
   const own = /* @__PURE__ */ new Map();
+  const index = recordKeyIndexOf(modelMap);
+  if (index) {
+    const map = modelMap;
+    for (const [segment, id] of wanted) {
+      for (const key of index.get(segment) ?? []) {
+        if (!map.has(key) || !parseOverlayKey(key)) continue;
+        const keys = own.get(id);
+        if (keys) keys.push([key, map.get(key)]);
+        else own.set(id, [[key, map.get(key)]]);
+      }
+    }
+    const out2 = /* @__PURE__ */ new Map();
+    for (const id of recordIds) {
+      out2.set(id, groupOverlayEntries(own.get(id) ?? []).get(id) ?? emptyEntry(id));
+    }
+    return out2;
+  }
   for (const [key, value] of modelMap.entries()) {
     if (typeof key !== "string") continue;
     const separator = key.indexOf(OVERLAY_KEY_SEPARATOR);
@@ -1827,7 +1985,9 @@ function clearStaleRecordOverlay(modelMap, recordId, keep) {
   if (!modelMap.has(overlayMarkerKey(recordId, OVERLAY_MARKER_DELETED))) return;
   const prefix = overlayRecordPrefix(recordId);
   const stale = [];
-  for (const key of modelMap.keys()) {
+  const index = recordKeyIndexOf(modelMap);
+  const candidates = index ? index.get(encodeOverlaySegment(recordId)) ?? [] : modelMap.keys();
+  for (const key of candidates) {
     if (key.startsWith(prefix) && keep?.has(key) !== true) stale.push(key);
   }
   for (const key of stale) modelMap.delete(key);
@@ -1851,7 +2011,7 @@ function format2StringSetMembers(value) {
   if (!(value instanceof Y5.Map)) return [];
   return Array.from(value.entries()).filter(([, present]) => present === true).map(([member]) => member);
 }
-var Y5, OVERLAY_KEY_SEPARATOR, OVERLAY_MARKER_REPLACE, OVERLAY_MARKER_DELETED, OVERLAY_MARKERS, Format2CompositeFieldError;
+var Y5, OVERLAY_KEY_SEPARATOR, OVERLAY_MARKER_REPLACE, OVERLAY_MARKER_DELETED, OVERLAY_MARKERS, recordKeyIndexes, Format2CompositeFieldError;
 var init_largeDocuments = __esm({
   "src/utils/largeDocuments.ts"() {
     "use strict";
@@ -1864,6 +2024,7 @@ var init_largeDocuments = __esm({
       OVERLAY_MARKER_REPLACE,
       OVERLAY_MARKER_DELETED
     ]);
+    recordKeyIndexes = /* @__PURE__ */ new WeakMap();
     Format2CompositeFieldError = class extends Error {
       modelName;
       recordId;
@@ -2243,6 +2404,7 @@ var FORMAT2_MANIFEST_VERSION, FORMAT2_MIN_MANIFEST_VERSION, INGEST_CHUNK_LIMITS,
 var init_snapshotChunks = __esm({
   "src/utils/snapshotChunks.ts"() {
     "use strict";
+    init_uniqueIndex();
     FORMAT2_MANIFEST_VERSION = 3;
     FORMAT2_MIN_MANIFEST_VERSION = 2;
     INGEST_CHUNK_LIMITS = {
@@ -2313,16 +2475,26 @@ function statementsFor(tables) {
     deleteMember: `DELETE FROM ${members} WHERE _type = ? AND _record_id = ? AND field = ? AND value = ?`,
     insertMember: `INSERT OR IGNORE INTO ${members} (_record_id, _type, field, value) VALUES (?, ?, ?, ?)`,
     selectMembers: `SELECT value FROM ${members} WHERE _type = ? AND _record_id = ? AND field = ? ORDER BY rowid`,
+    // `field, rowid`, not `rowid` alone: it is the order the per-record index
+    // `(_type, _record_id, field)` yields, so the planner reads the record's
+    // rows through it. With a bare `rowid` the covering UNIQUE
+    // `(_type, field, _record_id, value)` wins on its `_type` prefix and walks
+    // every member row of the model per record (#3688's figure, broken by
+    // #3874). Stored order within a field, which is all the comparison reads,
+    // is unchanged.
+    selectAllMembers: `SELECT field, value FROM ${members} WHERE _type = ? AND _record_id = ? ORDER BY field, rowid`,
     mergeUpsert: `
 INSERT INTO ${records} (_id, _type, _data)
 VALUES (?, ?, json_patch('{}', ?))
 ON CONFLICT(_type, _id) DO UPDATE SET
-  _data = json_patch(${records}._data, ?)`.trim(),
+  _data = json_patch(${records}._data, ?)
+WHERE json_patch(${records}._data, ?) IS NOT ${records}._data`.trim(),
     replaceUpsert: `
 INSERT INTO ${records} (_id, _type, _data)
 VALUES (?, ?, json_patch('{}', ?))
 ON CONFLICT(_type, _id) DO UPDATE SET
-  _data = json_patch('{}', ?)`.trim()
+  _data = json_patch('{}', ?)
+WHERE json_patch('{}', ?) IS NOT ${records}._data`.trim()
   };
   statementCache.set(cacheKey, statements);
   return statements;
@@ -2335,6 +2507,7 @@ function projectOverlayEntry(sql, modelName, entry, tables = DEFAULT_OVERLAY_TAB
     deleteMember: DELETE_MEMBER,
     insertMember: INSERT_MEMBER,
     selectMembers: SELECT_MEMBERS,
+    selectAllMembers: SELECT_ALL_MEMBERS,
     mergeUpsert: MERGE_UPSERT,
     replaceUpsert: REPLACE_UPSERT
   } = statementsFor(tables);
@@ -2348,10 +2521,20 @@ function projectOverlayEntry(sql, modelName, entry, tables = DEFAULT_OVERLAY_TAB
   if (!entry.replace && touchedFields.length === 0 && touchedSets.length === 0) {
     return;
   }
+  const patch = { ...entry.fields, id };
   if (entry.replace) {
+    const unchanged = unchangedReplaceMembers(
+      sql,
+      SELECT_ALL_MEMBERS,
+      modelName,
+      entry
+    );
+    if (unchanged) {
+      for (const [field, values] of unchanged) patch[field] = values;
+      return upsert(sql, REPLACE_UPSERT, modelName, id, patch);
+    }
     sql.exec(DELETE_ALL_MEMBERS, modelName, id);
   }
-  const patch = { ...entry.fields, id };
   for (const [field, members] of Object.entries(entry.stringSets)) {
     for (const [member, present] of Object.entries(members)) {
       if (present) sql.exec(INSERT_MEMBER, id, modelName, field, member);
@@ -2360,14 +2543,40 @@ function projectOverlayEntry(sql, modelName, entry, tables = DEFAULT_OVERLAY_TAB
     const rows = Array.from(sql.exec(SELECT_MEMBERS, modelName, id, field));
     patch[field] = rows.map((row) => row.value);
   }
+  upsert(sql, entry.replace ? REPLACE_UPSERT : MERGE_UPSERT, modelName, id, patch);
+}
+function upsert(sql, statement, modelName, id, patch) {
   const patchJson = JSON.stringify(patch);
-  sql.exec(
-    entry.replace ? REPLACE_UPSERT : MERGE_UPSERT,
-    id,
-    modelName,
-    patchJson,
-    patchJson
-  );
+  sql.exec(statement, id, modelName, patchJson, patchJson, patchJson);
+}
+function unchangedReplaceMembers(sql, selectAllMembers, modelName, entry) {
+  const wanted = /* @__PURE__ */ new Map();
+  let present = 0;
+  for (const [field, members] of Object.entries(entry.stringSets)) {
+    const values = Object.entries(members).filter(([, isPresent]) => isPresent).map(([member]) => member);
+    wanted.set(field, values);
+    present += values.length;
+  }
+  if (present === 0) return null;
+  const current = /* @__PURE__ */ new Map();
+  for (const row of sql.exec(selectAllMembers, modelName, entry.id)) {
+    const field = String(row.field);
+    const values = current.get(field);
+    if (values) values.push(String(row.value));
+    else current.set(field, [String(row.value)]);
+  }
+  if (current.size === 0) return null;
+  for (const [field, values] of wanted) {
+    const held = current.get(field) ?? [];
+    if (held.length !== values.length) return null;
+    for (let i = 0; i < values.length; i++) {
+      if (held[i] !== values[i]) return null;
+    }
+  }
+  for (const field of current.keys()) {
+    if (!wanted.has(field)) return null;
+  }
+  return wanted;
 }
 var DEFAULT_OVERLAY_TABLES, statementCache;
 var init_overlaySql = __esm({
@@ -4505,15 +4714,7 @@ function materializeOverlayEntries(doc, touched) {
   const out = [];
   for (const [modelName, keys] of touched) {
     const modelMap = doc.getMap(modelName);
-    const delta = [];
-    for (const key of keys) {
-      if (!parseOverlayKey(key) || !modelMap.has(key)) continue;
-      delta.push([key, modelMap.get(key)]);
-    }
-    const grouped = completeOverlayEntries(
-      modelMap,
-      groupOverlayEntries(delta)
-    );
+    const grouped = foldTouchedOverlayKeys(modelMap, keys);
     for (const entry of grouped.values()) out.push({ model: modelName, entry });
   }
   return out;
@@ -12430,7 +12631,40 @@ var init_BaseModel = __esm({
         return { sql, params, aliasMetadata };
       }
       /**
-       * Process aggregation results into nested structure
+       * Read one row's operation values, collapsing a single-operation aggregate
+       * to the bare value of that operation.
+       *
+       * This is the platform's one aggregate leaf rule, shared with the DO engine's
+       * `_extractOpValue` (`engines/cloudflare/createDocumentDO.ts`, behind
+       * database aggregates, registered `aggregate` operations, workflow pipeline
+       * steps and `connectDoDb` bindings) and its mirror `aggregateRowsToResult`
+       * in the platform's `src/document-projection.ts` (the document HTTP
+       * aggregate). These model statics used to collapse a lone `count` only and
+       * keep `<type>_<field>` for a lone `sum`/`avg`/`min`/`max`, so the same
+       * declared aggregation answered differently depending on the path taken;
+       * they were the outlier and moved to the shared rule in #3076 (js-bao 0.10.0).
+       *
+       * Both result-shaping branches below call this, so the StringSet-facet path
+       * and the general path cannot drift apart again. Pinned by
+       * `cli/tests/unit/aggregate-shaper-divergence-3076.test.ts` and, end to end
+       * against the HTTP aggregate, by
+       * `tests/api/http/aggregate-shape-convergence-3076.test.ts`.
+       */
+      static extractAggregationLeaf(row, operations) {
+        const valueFor = (operation) => operation.type === "count" ? row.count : row[`${operation.type}_${operation.field}`];
+        if (operations.length === 1) return valueFor(operations[0]);
+        const leaf = {};
+        for (const operation of operations) {
+          if (operation.type === "count") leaf.count = row.count;
+          else leaf[`${operation.type}_${operation.field}`] = valueFor(operation);
+        }
+        return leaf;
+      }
+      /**
+       * Process aggregation results into nested structure.
+       *
+       * The leaf under the last group value follows the one platform rule — see
+       * {@link BaseModel.extractAggregationLeaf}.
        */
       static processAggregationResults(results, options, aliasMetadata) {
         if (results.length === 0) {
@@ -12446,19 +12680,10 @@ var init_BaseModel = __esm({
         if (options.groupBy.length === 1 && typeof options.groupBy[0] === "string" && results[0].hasOwnProperty("group_key")) {
           const facetResult = {};
           for (const row of results) {
-            const key = row.group_key;
-            facetResult[key] = {};
-            for (const operation of options.operations) {
-              if (operation.type === "count") {
-                facetResult[key].count = row.count;
-              } else {
-                const operationKey = `${operation.type}_${operation.field}`;
-                facetResult[key][operationKey] = row[operationKey];
-              }
-            }
-            if (options.operations.length === 1 && options.operations[0].type === "count") {
-              facetResult[key] = row.count;
-            }
+            facetResult[row.group_key] = this.extractAggregationLeaf(
+              row,
+              options.operations
+            );
           }
           return facetResult;
         }
@@ -12486,18 +12711,7 @@ var init_BaseModel = __esm({
               key = row[resolvedAlias];
             }
             if (i === options.groupBy.length - 1) {
-              current[key] = {};
-              for (const operation of options.operations) {
-                if (operation.type === "count") {
-                  current[key].count = row.count;
-                } else {
-                  const operationKey = `${operation.type}_${operation.field}`;
-                  current[key][operationKey] = row[operationKey];
-                }
-              }
-              if (options.operations.length === 1 && options.operations[0].type === "count") {
-                current[key] = row.count;
-              }
+              current[key] = this.extractAggregationLeaf(row, options.operations);
             } else {
               if (!current[key]) {
                 current[key] = {};
@@ -13337,6 +13551,7 @@ __export(browser_exports, {
   SqljsEngine: () => SqljsEngine,
   StringSet: () => StringSet,
   UniqueConstraintViolationError: () => UniqueConstraintViolationError,
+  UniqueStringsetError: () => UniqueStringsetError,
   applyFastForward: () => applyFastForward,
   applyOverlayMutation: () => applyOverlayMutation,
   assertNoFormat2CompositeFields: () => assertNoFormat2CompositeFields,
@@ -13364,7 +13579,9 @@ __export(browser_exports, {
   estimateMaterializedBytes: () => estimateMaterializedBytes,
   features: () => features,
   findReservedFieldNameInToml: () => findReservedFieldNameInToml,
+  findUniqueStringsetInToml: () => findUniqueStringsetInToml,
   foldFormat2Overlay: () => foldFormat2Overlay,
+  foldTouchedOverlayKeys: () => foldTouchedOverlayKeys,
   followEpoch: () => followEpoch,
   format2ClientDDL: () => format2ClientDDL,
   format2EpochDocName: () => format2EpochDocName,
@@ -13391,6 +13608,7 @@ __export(browser_exports, {
   observeFormat2Overlay: () => observeFormat2Overlay,
   offlineReplayRecordKey: () => offlineReplayRecordKey,
   offlineWindowStatus: () => offlineWindowStatus,
+  omitStringsetConstraints: () => omitStringsetConstraints,
   overlayFieldKey: () => overlayFieldKey,
   overlayKeysSince: () => overlayKeysSince,
   overlayMarkerKey: () => overlayMarkerKey,
@@ -13420,6 +13638,8 @@ __export(browser_exports, {
   suppressSupersededKeys: () => suppressSupersededKeys,
   syncInferredMeta: () => syncInferredMeta,
   syncModelMeta: () => syncModelMeta,
+  uniqueStringsetMessage: () => uniqueStringsetMessage,
+  uniqueStringsetViolations: () => uniqueStringsetViolations,
   validateSnapshotManifest: () => validateSnapshotManifest,
   writeCarriedOverlay: () => writeCarriedOverlay
 });
@@ -19395,6 +19615,17 @@ init_BaseModel();
 init_ModelRegistry();
 init_uniqueIndex();
 function defineModelSchema(input) {
+  const [violation] = uniqueStringsetViolations(
+    input.name,
+    input.fields,
+    input.options?.uniqueConstraints
+  );
+  if (violation) {
+    throw new UniqueStringsetError(uniqueStringsetMessage(input.name, violation));
+  }
+  return buildDefinedModelSchema(input);
+}
+function buildDefinedModelSchema(input) {
   const { name, fields } = input;
   const options = {
     name,
@@ -19722,6 +19953,7 @@ var ReservedFieldNameError = class extends Error {
 };
 
 // src/models/tomlLoader.ts
+init_uniqueIndex();
 var VALID_FIELD_TYPES = /* @__PURE__ */ new Set([
   "string",
   "number",
@@ -19869,6 +20101,7 @@ function parseRelationship(raw, context, strict) {
 function loadSchemaFromTomlString(tomlString, options = {}) {
   const strict = options.strict !== false;
   const rejectReserved = options.rejectReservedFieldNames === true;
+  const rejectUniqueStringset = options.rejectUniqueStringset !== false;
   const parsed = (0, import_smol_toml.parse)(tomlString);
   const models = parsed.models;
   if (!models || typeof models !== "object") {
@@ -19883,6 +20116,7 @@ function loadSchemaFromTomlString(tomlString, options = {}) {
       strict
     );
     const fields = {};
+    const declaredFields = /* @__PURE__ */ new Map();
     if (modelDef.fields) {
       for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
         const context = `[models.${modelName}.fields.${fieldName}]`;
@@ -19892,7 +20126,9 @@ function loadSchemaFromTomlString(tomlString, options = {}) {
             throw new ReservedFieldNameError(`${context}: ${reserved}`);
           }
         }
-        fields[fieldName] = parseFieldOptions(fieldDef, context, strict);
+        const fieldOptions = parseFieldOptions(fieldDef, context, strict);
+        declaredFields.set(fieldName, fieldOptions);
+        fields[fieldName] = fieldOptions;
       }
     }
     let relationships;
@@ -19925,8 +20161,20 @@ function loadSchemaFromTomlString(tomlString, options = {}) {
       }
     }
     const className = typeof modelDef.class_name === "string" ? modelDef.class_name : void 0;
+    if (rejectUniqueStringset) {
+      const [violation] = uniqueStringsetViolations(
+        modelName,
+        declaredFields,
+        uniqueConstraints
+      );
+      if (violation) {
+        throw new UniqueStringsetError(
+          uniqueStringsetMessage(modelName, violation)
+        );
+      }
+    }
     schemas.push(
-      defineModelSchema({
+      buildDefinedModelSchema({
         name: modelName,
         fields,
         options: {
@@ -19943,7 +20191,10 @@ function findReservedFieldNameInToml(tomlString) {
   try {
     loadSchemaFromTomlString(tomlString, {
       strict: false,
-      rejectReservedFieldNames: true
+      rejectReservedFieldNames: true,
+      // Independent of the #3719 check: a unique stringset in one model must
+      // not hide a reserved name in the next.
+      rejectUniqueStringset: false
     });
     return null;
   } catch (error) {
@@ -19951,8 +20202,18 @@ function findReservedFieldNameInToml(tomlString) {
     return null;
   }
 }
+function findUniqueStringsetInToml(tomlString) {
+  try {
+    loadSchemaFromTomlString(tomlString, { strict: false });
+    return null;
+  } catch (error) {
+    if (error instanceof UniqueStringsetError) return error.message;
+    return null;
+  }
+}
 
 // src/browser.ts
+init_uniqueIndex();
 init_metaSync();
 init_format2RecordStore();
 init_format2RecordStoreAsync();