js-bao 0.5.1 → 0.6.0

package/dist/cloudflare.cjs

@@ -100,6 +100,201 @@ var init_yjsValues = __esm({
   }
 });
 
+// src/models/writeLifecycle.ts
+function assertNever(x) {
+  throw new Error(`Unhandled field type: ${String(x)}`);
+}
+function fieldWriteKind(type) {
+  switch (type) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "date":
+    case "id":
+      return "scalar";
+    case "stringset":
+      return "stringset";
+    default:
+      return assertNever(type);
+  }
+}
+function isKnownFieldType(type) {
+  return KNOWN_FIELD_TYPES.has(type);
+}
+function ensureStringSetYMap(rm, fieldName) {
+  const nested = rm.get(fieldName);
+  if (nested instanceof Y2.Map) return nested;
+  const fresh = new Y2.Map();
+  if (nested && typeof nested === "object") {
+    for (const [member, marker] of Object.entries(
+      nested
+    )) {
+      if (Boolean(marker)) fresh.set(member, true);
+    }
+  }
+  rm.set(fieldName, fresh);
+  return fresh;
+}
+function applyStringSetDelta(target, delta) {
+  if (delta.clear) {
+    for (const member of Array.from(target.keys())) target.delete(member);
+  }
+  if (delta.remove) {
+    for (const member of delta.remove) target.delete(String(member));
+  }
+  if (delta.add) {
+    for (const member of delta.add) {
+      const key = String(member);
+      if (target.get(key) !== true) target.set(key, true);
+    }
+  }
+}
+function replaceStringSet(rm, fieldName, members) {
+  const target = ensureStringSetYMap(rm, fieldName);
+  const desired = /* @__PURE__ */ new Set();
+  for (const member of members) desired.add(String(member));
+  for (const existing of Array.from(target.keys())) {
+    if (!desired.has(existing)) target.delete(existing);
+  }
+  for (const member of desired) {
+    if (target.get(member) !== true) target.set(member, true);
+  }
+}
+function applyStringSetChange(recordYMap, fieldName, change) {
+  const target = ensureStringSetYMap(recordYMap, fieldName);
+  applyStringSetDelta(target, {
+    add: change.additions,
+    remove: change.removals
+  });
+}
+function parseStringSetOp(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value) || value instanceof Y2.AbstractType) {
+    return null;
+  }
+  const keys = Object.keys(value);
+  const opKeys = keys.filter((k) => k.startsWith("$"));
+  if (opKeys.length === 0) return null;
+  const known = /* @__PURE__ */ new Set(["$add", "$remove", "$clear"]);
+  const unknown = keys.filter((k) => !known.has(k));
+  if (unknown.length > 0) {
+    throw new Error(
+      `Invalid stringset op: unexpected key(s) [${unknown.join(", ")}]. Only $add, $remove and $clear are supported.`
+    );
+  }
+  const obj = value;
+  const toMembers = (raw, opName) => {
+    if (raw === void 0) return [];
+    if (!Array.isArray(raw)) {
+      throw new Error(`Invalid stringset op: ${opName} must be an array.`);
+    }
+    return raw.map((m) => String(m));
+  };
+  return {
+    add: toMembers(obj.$add, "$add"),
+    remove: toMembers(obj.$remove, "$remove"),
+    clear: obj.$clear === true
+  };
+}
+function writeField(rm, declaredType, key, value, modelName) {
+  const kind = declaredType && isKnownFieldType(declaredType) ? fieldWriteKind(declaredType) : "scalar";
+  if (Array.isArray(value)) {
+    if (kind !== "stringset") {
+      throw new Error(
+        `Cannot write array value to field "${key}" on model "${modelName}": its declared type could not be resolved to a collection (stringset). Collection fields require schema metadata in the document (_meta_${modelName}); the model must be saved by a client at least once before a workflow writes one of its collection fields.`
+      );
+    }
+    replaceStringSet(rm, key, value);
+    return;
+  }
+  const op = parseStringSetOp(value);
+  if (op) {
+    if (kind !== "stringset") {
+      throw new Error(
+        `Cannot apply a stringset op ({ $add/$remove/$clear }) to field "${key}" on model "${modelName}": its declared type is ${declaredType ? `"${declaredType}"` : "unresolved"}, not a collection (stringset). Op-objects are only valid for stringset / refersToMany fields with schema metadata (_meta_${modelName}).`
+      );
+    }
+    applyStringSetDelta(ensureStringSetYMap(rm, key), op);
+    return;
+  }
+  if (kind === "stringset") {
+    throw new Error(
+      `Field "${key}" on model "${modelName}" is a stringset and requires an array (replace) or { $add/$remove/$clear } (delta) value; received ${value === null ? "null" : typeof value}.`
+    );
+  }
+  rm.set(key, value);
+}
+function registerFunctionDefaultGenerator(name, fn) {
+  FUNCTION_DEFAULT_GENERATORS.set(name, fn);
+}
+function decodeFunctionDefault(name) {
+  return FUNCTION_DEFAULT_GENERATORS.get(name);
+}
+function resolveDefaultValue(rawDefault, opts = {}) {
+  if (typeof rawDefault === "function") return rawDefault();
+  if (typeof rawDefault === "string" && rawDefault.startsWith("$")) {
+    if (rawDefault.startsWith("$$")) return rawDefault.slice(1);
+    const name = rawDefault.slice(1);
+    const gen = opts.decode?.(name) ?? decodeFunctionDefault(name);
+    if (!gen) {
+      throw new Error(
+        `Unknown function default "${rawDefault}" for field "${opts.fieldName ?? "?"}"${opts.modelName ? ` on model "${opts.modelName}"` : ""}: no generator is registered for "${name}". Register it via registerFunctionDefaultGenerator("${name}", fn) so the server can populate the field the same way the client does.`
+      );
+    }
+    return gen();
+  }
+  return rawDefault;
+}
+function applyDefaultsFromSchema(fields, data, opts = {}) {
+  for (const [fieldName, field] of Object.entries(fields)) {
+    if (fieldName === "id") continue;
+    if (!field || field.default === void 0) continue;
+    if (field.default === UNKNOWN_FUNCTION_DEFAULT) {
+      continue;
+    }
+    if (Object.prototype.hasOwnProperty.call(data, fieldName) && data[fieldName] !== void 0) {
+      continue;
+    }
+    data[fieldName] = resolveDefaultValue(field.default, {
+      fieldName,
+      modelName: opts.modelName,
+      decode: opts.decodeFunctionDefault
+    });
+  }
+  return data;
+}
+function applyAutoStampsFromSchema(fields, data, opts) {
+  const { isNew, now } = opts;
+  for (const [fieldName, field] of Object.entries(fields)) {
+    const stamp = field?.autoStamp;
+    if (!stamp) continue;
+    const explicit = Object.prototype.hasOwnProperty.call(data, fieldName) && data[fieldName] !== null && data[fieldName] !== void 0;
+    if (explicit) continue;
+    if (stamp === "create" && !isNew) continue;
+    data[fieldName] = now;
+  }
+  return data;
+}
+var Y2, import_ulid, KNOWN_FIELD_TYPE_MAP, KNOWN_FIELD_TYPES, FUNCTION_DEFAULT_GENERATORS, UNKNOWN_FUNCTION_DEFAULT;
+var init_writeLifecycle = __esm({
+  "src/models/writeLifecycle.ts"() {
+    "use strict";
+    Y2 = __toESM(require("yjs"), 1);
+    import_ulid = require("ulid");
+    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", () => (0, import_ulid.ulid)());
+    UNKNOWN_FUNCTION_DEFAULT = "$unknown_function";
+  }
+});
+
 // src/models/metaSync.ts
 function inferFieldType(value) {
   if (isStringSetYMap(value)) return "stringset";
@@ -121,7 +316,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;
 }
@@ -147,7 +345,7 @@ function syncModelMeta(yDoc, modelName, schema) {
   if (compoundConstraints.length > 0) {
     let constraints = meta.get("_constraints");
     if (!constraints) {
-      constraints = new Y2.Map();
+      constraints = new Y3.Map();
       meta.set("_constraints", constraints);
     }
     for (const constraint of compoundConstraints) {
@@ -158,7 +356,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 Y3.Map();
       meta.set("_relationships", rels);
     }
     for (const [relName, relConfig] of Object.entries(relationships)) {
@@ -170,7 +368,7 @@ function syncModelMeta(yDoc, modelName, schema) {
 function syncFieldMeta(metaMap, fieldName, fieldOpts) {
   let fieldMeta = metaMap.get(fieldName);
   if (!fieldMeta) {
-    fieldMeta = new Y2.Map();
+    fieldMeta = new Y3.Map();
     metaMap.set(fieldName, fieldMeta);
   }
   setIfChanged(fieldMeta, "type", fieldOpts.type);
@@ -187,7 +385,7 @@ function syncFieldMeta(metaMap, fieldName, fieldOpts) {
 function syncConstraintMeta(constraintsMap, constraint) {
   let cMeta = constraintsMap.get(constraint.name);
   if (!cMeta) {
-    cMeta = new Y2.Map();
+    cMeta = new Y3.Map();
     constraintsMap.set(constraint.name, cMeta);
   }
   setIfChanged(cMeta, "type", "unique");
@@ -197,7 +395,7 @@ function syncConstraintMeta(constraintsMap, constraint) {
 function syncRelationshipMeta(relsMap, relName, relConfig) {
   let relMeta = relsMap.get(relName);
   if (!relMeta) {
-    relMeta = new Y2.Map();
+    relMeta = new Y3.Map();
     relsMap.set(relName, relMeta);
   }
   for (const [key, value] of Object.entries(relConfig)) {
@@ -212,7 +410,7 @@ function syncInferredMeta(yDoc, modelName, recordData) {
     if (fieldName.startsWith("_")) continue;
     let fieldMeta = meta.get(fieldName);
     if (!fieldMeta) {
-      fieldMeta = new Y2.Map();
+      fieldMeta = new Y3.Map();
       meta.set(fieldName, fieldMeta);
     }
     if (!fieldMeta.has("type")) {
@@ -228,34 +426,378 @@ function setIfChanged(map, key, value) {
     map.set(key, value);
   }
 }
-var Y2, KNOWN_FUNCTION_DEFAULTS, _syncedCache;
+var Y3, KNOWN_FUNCTION_DEFAULTS, _syncedCache;
 var init_metaSync = __esm({
   "src/models/metaSync.ts"() {
     "use strict";
-    Y2 = __toESM(require("yjs"), 1);
+    Y3 = __toESM(require("yjs"), 1);
     init_yjsValues();
+    init_writeLifecycle();
     KNOWN_FUNCTION_DEFAULTS = /* @__PURE__ */ new WeakMap();
     _syncedCache = /* @__PURE__ */ new WeakMap();
   }
 });
 
+// src/utils/uniqueIndex.ts
+function buildUniqueKey(recordData, fields) {
+  const keyParts = [];
+  for (const field of fields) {
+    const value = recordData instanceof Y4.Map ? recordData.get(field) : recordData[field];
+    if (value === null || value === void 0) {
+      return null;
+    }
+    keyParts.push(String(value));
+  }
+  return keyParts.join("|");
+}
+function uniqueIndexMapName(modelName, constraintName) {
+  return `_uniqueIdx_${modelName}_${constraintName}`;
+}
+function fieldUniqueConstraintName(modelName, fieldName) {
+  return `${modelName}_${fieldName}_unique`;
+}
+var Y4;
+var init_uniqueIndex = __esm({
+  "src/utils/uniqueIndex.ts"() {
+    "use strict";
+    Y4 = __toESM(require("yjs"), 1);
+  }
+});
+
+// src/utils/largeDocuments.ts
+var Y5;
+var init_largeDocuments = __esm({
+  "src/utils/largeDocuments.ts"() {
+    "use strict";
+    Y5 = __toESM(require("yjs"), 1);
+    init_yjsValues();
+  }
+});
+
+// src/models/OrmContext.ts
+var OrmContext, defaultOrmContext, liveOrmContexts;
+var init_OrmContext = __esm({
+  "src/models/OrmContext.ts"() {
+    "use strict";
+    OrmContext = class _OrmContext {
+      /** Declared before the field that reads it: static initialization is ordered. */
+      static instanceCounter = 0;
+      /**
+       * Which instance this is, for diagnostics. A process holding several clients
+       * needs a way to say WHICH one a warning is about, so every context takes the
+       * next number as it is created and keeps it for its lifetime.
+       */
+      instanceId = ++_OrmContext.instanceCounter;
+      /** The engine this instance's models read and write through. */
+      dbEngine = null;
+      connectedDocuments = /* @__PURE__ */ new Map();
+      /** `docId_modelName` → the Y.Map that document holds for that model. */
+      documentYMaps = /* @__PURE__ */ new Map();
+      /** `subscribe()` callbacks, by model name. */
+      listenersMap = /* @__PURE__ */ new Map();
+      // Default-document resolution
+      modelNameToDefaultDocId = /* @__PURE__ */ new Map();
+      globalDefaultDocId = void 0;
+      defaultDocChangedListeners = /* @__PURE__ */ new Set();
+      modelDocMappingChangedListeners = /* @__PURE__ */ new Set();
+      /** Format-2 ("large document", #2816) record stores by document id. */
+      format2Documents = /* @__PURE__ */ new Map();
+      /** Format-2 epoch moves in flight (#2816). */
+      format2Transitions = /* @__PURE__ */ new Map();
+      /**
+       * Nested-Y.Map stringset fields this context has already observed. Per
+       * context, not global: a Y.Doc reconnected to a fresh instance has to be
+       * observed again by that instance, and a global guard would silently
+       * suppress it.
+       */
+      observedStringSetMaps = /* @__PURE__ */ new WeakSet();
+      /**
+       * The registry this instance's schema lookups use. `null` on the standing
+       * default context, where callers fall back to the global singleton.
+       */
+      modelRegistry = null;
+      /** Model classes routed to this context. */
+      boundModels = /* @__PURE__ */ new Set();
+      /** True once {@link destroy} has run; bound classes keep pointing here. */
+      destroyed = false;
+      /** Yjs `unobserve` thunks by owning document id. */
+      observerDisposers = /* @__PURE__ */ new Map();
+      /** Teardown the owner (the document manager) registers for `destroy()`. */
+      teardownHooks = /* @__PURE__ */ new Set();
+      static NO_DOCUMENT_KEY = "__no_document__";
+      /**
+       * Record how to remove an observer this context installed. Every `observe()`
+       * in the ORM pairs with one of these: without it a torn-down instance's
+       * callbacks keep firing on a Y.Doc that outlives it.
+       */
+      registerObserverDisposer(docId, dispose) {
+        const key = docId ?? _OrmContext.NO_DOCUMENT_KEY;
+        const list = this.observerDisposers.get(key);
+        if (list) list.push(dispose);
+        else this.observerDisposers.set(key, [dispose]);
+      }
+      /** Remove every observer this context installed for `docId`. */
+      disposeObserversForDocument(docId) {
+        const list = this.observerDisposers.get(docId);
+        if (!list) return;
+        this.observerDisposers.delete(docId);
+        for (const dispose of list) {
+          try {
+            dispose();
+          } catch {
+          }
+        }
+      }
+      disposeAllObservers() {
+        const buckets = Array.from(this.observerDisposers.values());
+        this.observerDisposers.clear();
+        for (const list of buckets) {
+          for (const dispose of list) {
+            try {
+              dispose();
+            } catch {
+            }
+          }
+        }
+      }
+      /** Run `hook` as part of `destroy()` (the format-2 binding registers here). */
+      onDestroy(hook) {
+        this.teardownHooks.add(hook);
+      }
+      /** The record store for `docId`, or `null` when the document is format 1. */
+      getFormat2Store(docId) {
+        if (!docId) return null;
+        return this.format2Documents.get(docId) ?? null;
+      }
+      /**
+       * The epoch move a write to `docId` has to wait out (#2816, behavior 10), or
+       * `null` when none is in flight.
+       */
+      format2WritesHeld(docId) {
+        if (!docId) return null;
+        return this.format2Transitions.get(docId) ?? null;
+      }
+      /** Run an epoch move with `docId`'s local writes held back (#2816). */
+      async holdFormat2Writes(docId, run) {
+        const inFlight = this.format2Transitions.get(docId);
+        if (inFlight) await inFlight.catch(() => {
+        });
+        let release;
+        const held = new Promise((resolve) => {
+          release = resolve;
+        });
+        this.format2Transitions.set(docId, held);
+        try {
+          return await run();
+        } finally {
+          if (this.format2Transitions.get(docId) === held) {
+            this.format2Transitions.delete(docId);
+          }
+          release();
+        }
+      }
+      /** Notify `subscribe()` callbacks registered on this context for `modelName`. */
+      notifyListeners(modelName, log, onError) {
+        const listeners = this.listenersMap.get(modelName);
+        if (!listeners) return;
+        log?.(`Notifying ${listeners.size} listeners for ${modelName}`);
+        listeners.forEach((callback) => {
+          try {
+            callback();
+          } catch (e) {
+            onError?.(e);
+          }
+        });
+      }
+      // ---- Default-document resolution (the `BaseModel` statics delegate here) ----
+      setModelDefaultDocumentId(modelName, docId) {
+        const previous = this.modelNameToDefaultDocId.get(modelName);
+        this.modelNameToDefaultDocId.set(modelName, docId);
+        this.announceModelDocMapping(modelName, previous, docId);
+      }
+      removeModelDefaultDocumentId(modelName) {
+        const previous = this.modelNameToDefaultDocId.get(modelName);
+        this.modelNameToDefaultDocId.delete(modelName);
+        this.announceModelDocMapping(modelName, previous, void 0);
+      }
+      clearModelDefaultDocumentIds() {
+        const entries = Array.from(this.modelNameToDefaultDocId.entries());
+        this.modelNameToDefaultDocId.clear();
+        for (const [modelName, previous] of entries) {
+          this.announceModelDocMapping(modelName, previous, void 0);
+        }
+      }
+      setGlobalDefaultDocumentId(docId) {
+        const previous = this.globalDefaultDocId;
+        this.globalDefaultDocId = docId;
+        this.announceDefaultDoc(previous, docId);
+      }
+      clearGlobalDefaultDocumentId() {
+        const previous = this.globalDefaultDocId;
+        this.globalDefaultDocId = void 0;
+        this.announceDefaultDoc(previous, void 0);
+      }
+      getModelDefaultDocumentMapping() {
+        return Object.fromEntries(this.modelNameToDefaultDocId.entries());
+      }
+      getDocumentIdForModel(modelName) {
+        return this.modelNameToDefaultDocId.get(modelName);
+      }
+      getGlobalDefaultDocumentId() {
+        return this.globalDefaultDocId;
+      }
+      onDefaultDocChanged(listener) {
+        this.defaultDocChangedListeners.add(listener);
+        return () => this.defaultDocChangedListeners.delete(listener);
+      }
+      onModelDocMappingChanged(listener) {
+        this.modelDocMappingChangedListeners.add(listener);
+        return () => this.modelDocMappingChangedListeners.delete(listener);
+      }
+      /** Drop the model→document defaults that point at a disconnected document. */
+      clearMappingsForDocId(docId) {
+        const toRemove = [];
+        for (const [modelName, mappedDocId] of this.modelNameToDefaultDocId) {
+          if (mappedDocId === docId) toRemove.push(modelName);
+        }
+        for (const modelName of toRemove) {
+          this.removeModelDefaultDocumentId(modelName);
+        }
+        if (this.globalDefaultDocId === docId) {
+          this.clearGlobalDefaultDocumentId();
+        }
+      }
+      announceDefaultDoc(previous, current) {
+        for (const listener of this.defaultDocChangedListeners) {
+          try {
+            listener({ previous, current });
+          } catch {
+          }
+        }
+      }
+      announceModelDocMapping(modelName, previous, current) {
+        for (const listener of this.modelDocMappingChangedListeners) {
+          try {
+            listener({ modelName, previous, current });
+          } catch {
+          }
+        }
+      }
+      /**
+       * Tear this instance down: observers off, engine destroyed, state cleared.
+       *
+       * Deliberately does NOT unbind its model classes. They keep resolving this
+       * context, whose engine is now null, so an operation through them throws the
+       * ordinary not-initialized error instead of silently landing on whatever
+       * other instance happens to be live (#3039, behavior 7). Only a later
+       * `initJsBao` may rebind a class whose context is destroyed.
+       */
+      async destroy() {
+        if (this.destroyed) return;
+        this.destroyed = true;
+        this.disposeAllObservers();
+        const hooks = Array.from(this.teardownHooks);
+        this.teardownHooks.clear();
+        for (const hook of hooks) {
+          try {
+            await hook();
+          } catch {
+          }
+        }
+        const engine = this.dbEngine;
+        this.dbEngine = null;
+        if (engine) {
+          try {
+            await engine.destroy();
+          } catch {
+          }
+        }
+        this.connectedDocuments.clear();
+        this.documentYMaps.clear();
+        this.listenersMap.clear();
+        this.modelNameToDefaultDocId.clear();
+        this.globalDefaultDocId = void 0;
+        this.defaultDocChangedListeners.clear();
+        this.modelDocMappingChangedListeners.clear();
+        this.format2Documents.clear();
+        this.format2Transitions.clear();
+        this.observedStringSetMaps = /* @__PURE__ */ new WeakSet();
+        liveOrmContexts.delete(this);
+        if (defaultOrmContext === this) {
+          defaultOrmContext = new _OrmContext();
+        }
+      }
+    };
+    defaultOrmContext = new OrmContext();
+    liveOrmContexts = /* @__PURE__ */ new Set();
+  }
+});
+
+// src/models/format2QueryProjection.ts
+var FORMAT2_QUERY_PROJECTION_DDL;
+var init_format2QueryProjection = __esm({
+  "src/models/format2QueryProjection.ts"() {
+    "use strict";
+    FORMAT2_QUERY_PROJECTION_DDL = `
+CREATE TABLE IF NOT EXISTS _query_projection (
+  doc_id TEXT NOT NULL,
+  model TEXT NOT NULL,
+  PRIMARY KEY (doc_id, model)
+)`.trim();
+  }
+});
+
+// src/models/format2Observer.ts
+var Y6;
+var init_format2Observer = __esm({
+  "src/models/format2Observer.ts"() {
+    "use strict";
+    Y6 = __toESM(require("yjs"), 1);
+    init_largeDocuments();
+  }
+});
+
+// src/models/format2ClientWrite.ts
+var init_format2ClientWrite = __esm({
+  "src/models/format2ClientWrite.ts"() {
+    "use strict";
+  }
+});
+
+// src/models/format2OfflineWindow.ts
+var DAY_MS;
+var init_format2OfflineWindow = __esm({
+  "src/models/format2OfflineWindow.ts"() {
+    "use strict";
+    DAY_MS = 24 * 60 * 60 * 1e3;
+  }
+});
+
 // src/models/BaseModel.ts
 function generateULID() {
-  return (0, import_ulid.ulid)();
+  return (0, import_ulid2.ulid)();
 }
-var Y3, import_ulid, Logger;
+var Y7, import_ulid2, Logger;
 var init_BaseModel = __esm({
   "src/models/BaseModel.ts"() {
     "use strict";
-    Y3 = __toESM(require("yjs"), 1);
-    import_ulid = require("ulid");
+    Y7 = __toESM(require("yjs"), 1);
+    import_ulid2 = require("ulid");
     init_StringSet();
     init_documentTypes();
     init_DocumentQueryTranslator();
     init_CursorManager();
     init_sql();
     init_metaSync();
+    init_writeLifecycle();
     init_yjsValues();
+    init_uniqueIndex();
+    init_largeDocuments();
+    init_OrmContext();
+    init_format2QueryProjection();
+    init_format2Observer();
+    init_format2ClientWrite();
+    init_format2OfflineWindow();
     Logger = class {
       static _logLevel = 1 /* ERROR */;
       static _logCallback = null;
@@ -342,6 +884,7 @@ var init_ModelRegistry = __esm({
     "use strict";
     init_BaseModel();
     init_relationshipManager();
+    init_format2QueryProjection();
   }
 });
 
@@ -349,19 +892,37 @@ var init_ModelRegistry = __esm({
 var cloudflare_exports = {};
 __export(cloudflare_exports, {
   DOClientEngine: () => DOClientEngine,
+  applyAutoStampsFromSchema: () => applyAutoStampsFromSchema,
+  applyDefaultsFromSchema: () => applyDefaultsFromSchema,
+  applyStringSetChange: () => applyStringSetChange,
+  applyStringSetDelta: () => applyStringSetDelta,
+  assertNever: () => assertNever,
+  buildUniqueKey: () => buildUniqueKey,
   clearMetaSyncCache: () => clearMetaSyncCache,
   connectDoDb: () => connectDoDb,
+  decodeFunctionDefault: () => decodeFunctionDefault,
+  discoverDeclaredModel: () => discoverDeclaredModel,
   discoverModelNames: () => discoverModelNames,
   discoverSchema: () => discoverSchema,
+  ensureStringSetYMap: () => ensureStringSetYMap,
+  fieldUniqueConstraintName: () => fieldUniqueConstraintName,
+  fieldWriteKind: () => fieldWriteKind,
   getActiveDOEngine: () => getActiveDOEngine,
   inferFieldType: () => inferFieldType,
   initJsBaoDO: () => initJsBaoDO,
+  isKnownFieldType: () => isKnownFieldType,
   loadSchemaFromTomlString: () => loadSchemaFromTomlString,
+  parseStringSetOp: () => parseStringSetOp,
   registerFunctionDefault: () => registerFunctionDefault,
+  registerFunctionDefaultGenerator: () => registerFunctionDefaultGenerator,
+  replaceStringSet: () => replaceStringSet,
   resetJsBaoDO: () => resetJsBaoDO,
+  resolveDefaultValue: () => resolveDefaultValue,
   schemaToToml: () => schemaToToml,
   syncInferredMeta: () => syncInferredMeta,
-  syncModelMeta: () => syncModelMeta
+  syncModelMeta: () => syncModelMeta,
+  uniqueIndexMapName: () => uniqueIndexMapName,
+  writeField: () => writeField
 });
 module.exports = __toCommonJS(cloudflare_exports);
 
@@ -400,6 +961,32 @@ var DatabaseEngine = class {
   getTableName(_modelName) {
     throw new Error("Method not implemented.");
   }
+  /**
+   * A SYNCHRONOUS SQL executor over this engine's database, used by the
+   * large-document (format 2) record store. That store commits a merged
+   * record row and its pending-operation entry as one transaction — the
+   * barrier a `save()` resolves behind — which the async `query()` API cannot
+   * express. Engines whose underlying SQLite is synchronous (better-sqlite3,
+   * SQL.js) provide it; anything else leaves it undefined and cannot host a
+   * large document.
+   */
+  createFormat2Sql;
+  /**
+   * Whether what {@link createFormat2Sql} writes survives this process.
+   *
+   * On a large document the merged record view IS the document: the Y.Doc
+   * holds one epoch's overlay, and everything else — including a record a
+   * `save()` has already resolved, and the pending write that still owes it to
+   * the server — lives only in this store. An engine whose database is in
+   * memory therefore cannot host one: a reload does not cost a cache, it costs
+   * the document and the writes nobody has acknowledged yet.
+   *
+   * The platform is asked separately about its storage quota; this answers the
+   * half only the engine knows. An engine that does not implement it is taken
+   * at the platform's word, which is what keeps hosts with storage of their
+   * own — a worker handed a file store, a test — working unchanged.
+   */
+  format2StorageIsDurable;
   // Transaction support
   async withTransaction(_callback) {
     throw new Error("Method not implemented.");
@@ -1242,7 +1829,7 @@ function connectDoDb(options) {
 }
 
 // src/utils/yDocSchema.ts
-var Y4 = __toESM(require("yjs"), 1);
+var Y8 = __toESM(require("yjs"), 1);
 init_yjsValues();
 function discoverSchema(yDoc) {
   const models = {};
@@ -1265,6 +1852,12 @@ function discoverSchema(yDoc) {
   }
   return { models };
 }
+function discoverDeclaredModel(yDoc, modelName) {
+  const key = `_meta_${modelName}`;
+  if (!yDoc.share.has(key)) return void 0;
+  const map = materializeMap(yDoc, key);
+  return map ? readModelMeta(map) : void 0;
+}
 function discoverModelNames(yDoc) {
   const names = [];
   for (const key of yDoc.share.keys()) {
@@ -1277,7 +1870,7 @@ function discoverModelNames(yDoc) {
 function materializeMap(yDoc, key) {
   try {
     const map = yDoc.getMap(key);
-    return map instanceof Y4.Map ? map : null;
+    return map instanceof Y8.Map ? map : null;
   } catch {
     return null;
   }
@@ -1287,11 +1880,11 @@ function readModelMeta(metaMap) {
   let constraints;
   let relationships;
   for (const [key, value] of metaMap.entries()) {
-    if (key === "_constraints" && value instanceof Y4.Map) {
+    if (key === "_constraints" && value instanceof Y8.Map) {
       constraints = readConstraints(value);
-    } else if (key === "_relationships" && value instanceof Y4.Map) {
+    } else if (key === "_relationships" && value instanceof Y8.Map) {
       relationships = readRelationships(value);
-    } else if (value instanceof Y4.Map) {
+    } else if (value instanceof Y8.Map) {
       fields[key] = readFieldMeta(value);
     }
   }
@@ -1326,7 +1919,7 @@ function inferModelFromData(dataMap) {
   const fields = {};
   let sampled = 0;
   for (const [_recordId, recordValue] of dataMap.entries()) {
-    if (!(recordValue instanceof Y4.Map)) continue;
+    if (!(recordValue instanceof Y8.Map)) continue;
     if (++sampled > 5) break;
     for (const [fieldName, value] of recordValue.entries()) {
       if (fieldName.startsWith("_")) continue;
@@ -1354,7 +1947,7 @@ function inferTypeFromValue(value) {
 function readConstraints(constraintsMap) {
   const out = {};
   for (const [name, value] of constraintsMap.entries()) {
-    if (!(value instanceof Y4.Map)) continue;
+    if (!(value instanceof Y8.Map)) continue;
     let fields = [];
     const rawFields = value.get("fields");
     if (typeof rawFields === "string") {
@@ -1373,7 +1966,7 @@ function readConstraints(constraintsMap) {
 function readRelationships(relsMap) {
   const out = {};
   for (const [name, value] of relsMap.entries()) {
-    if (!(value instanceof Y4.Map)) continue;
+    if (!(value instanceof Y8.Map)) continue;
     const rel = {};
     for (const [k, v] of value.entries()) {
       rel[k] = v;
@@ -1452,6 +2045,7 @@ var import_smol_toml = require("smol-toml");
 // src/models/schema.ts
 init_BaseModel();
 init_ModelRegistry();
+init_uniqueIndex();
 function defineModelSchema(input) {
   const { name, fields } = input;
   const options = {
@@ -1494,7 +2088,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]
       });
     }
@@ -1740,4 +2334,6 @@ function loadSchemaFromTomlString(tomlString, options = {}) {
 }
 
 // src/cloudflare.ts
+init_uniqueIndex();
 init_metaSync();
+init_writeLifecycle();