js-bao 0.3.0-alpha.5 → 0.3.1

package/dist/browser.cjs

@@ -1183,6 +1183,143 @@ var init_DocumentQueryTranslator = __esm({
   }
 });
 
+// src/models/metaSync.ts
+function inferFieldType(value) {
+  if (value instanceof Y.Map) return "stringset";
+  switch (typeof value) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return null;
+  }
+}
+function registerFunctionDefault(fn, name) {
+  KNOWN_FUNCTION_DEFAULTS.set(fn, name);
+}
+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 value;
+}
+function clearMetaSyncCache(yDoc) {
+  if (yDoc) {
+    _syncedCache.delete(yDoc);
+  }
+}
+function syncModelMeta(yDoc, modelName, schema) {
+  let synced = _syncedCache.get(yDoc);
+  if (synced?.has(modelName)) return;
+  if (!synced) {
+    synced = /* @__PURE__ */ new Set();
+    _syncedCache.set(yDoc, synced);
+  }
+  const meta = yDoc.getMap(`_meta_${modelName}`);
+  for (const [fieldName, fieldOpts] of schema.fields.entries()) {
+    syncFieldMeta(meta, fieldName, fieldOpts);
+  }
+  const compoundConstraints = schema.resolvedUniqueConstraints.filter(
+    (c) => c.fields.length > 1
+  );
+  if (compoundConstraints.length > 0) {
+    let constraints = meta.get("_constraints");
+    if (!constraints) {
+      constraints = new Y.Map();
+      meta.set("_constraints", constraints);
+    }
+    for (const constraint of compoundConstraints) {
+      syncConstraintMeta(constraints, constraint);
+    }
+  }
+  const relationships = schema.options.relationships;
+  if (relationships && Object.keys(relationships).length > 0) {
+    let rels = meta.get("_relationships");
+    if (!rels) {
+      rels = new Y.Map();
+      meta.set("_relationships", rels);
+    }
+    for (const [relName, relConfig] of Object.entries(relationships)) {
+      syncRelationshipMeta(rels, relName, relConfig);
+    }
+  }
+  synced.add(modelName);
+}
+function syncFieldMeta(metaMap, fieldName, fieldOpts) {
+  let fieldMeta = metaMap.get(fieldName);
+  if (!fieldMeta) {
+    fieldMeta = new Y.Map();
+    metaMap.set(fieldName, fieldMeta);
+  }
+  setIfChanged(fieldMeta, "type", fieldOpts.type);
+  if (fieldOpts.indexed) setIfChanged(fieldMeta, "indexed", true);
+  if (fieldOpts.unique) setIfChanged(fieldMeta, "unique", true);
+  if (fieldOpts.required) setIfChanged(fieldMeta, "required", true);
+  if (fieldOpts.autoAssign) setIfChanged(fieldMeta, "autoAssign", true);
+  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);
+  if (encoded !== void 0) setIfChanged(fieldMeta, "default", encoded);
+}
+function syncConstraintMeta(constraintsMap, constraint) {
+  let cMeta = constraintsMap.get(constraint.name);
+  if (!cMeta) {
+    cMeta = new Y.Map();
+    constraintsMap.set(constraint.name, cMeta);
+  }
+  setIfChanged(cMeta, "type", "unique");
+  const fieldsJson = JSON.stringify(constraint.fields);
+  setIfChanged(cMeta, "fields", fieldsJson);
+}
+function syncRelationshipMeta(relsMap, relName, relConfig) {
+  let relMeta = relsMap.get(relName);
+  if (!relMeta) {
+    relMeta = new Y.Map();
+    relsMap.set(relName, relMeta);
+  }
+  for (const [key, value] of Object.entries(relConfig)) {
+    if (value !== void 0) {
+      setIfChanged(relMeta, key, value);
+    }
+  }
+}
+function syncInferredMeta(yDoc, modelName, recordData) {
+  const meta = yDoc.getMap(`_meta_${modelName}`);
+  for (const [fieldName, value] of Object.entries(recordData)) {
+    if (fieldName.startsWith("_")) continue;
+    let fieldMeta = meta.get(fieldName);
+    if (!fieldMeta) {
+      fieldMeta = new Y.Map();
+      meta.set(fieldName, fieldMeta);
+    }
+    if (!fieldMeta.has("type")) {
+      const inferredType = inferFieldType(value);
+      if (inferredType) {
+        fieldMeta.set("type", inferredType);
+      }
+    }
+  }
+}
+function setIfChanged(map, key, value) {
+  if (map.get(key) !== value) {
+    map.set(key, value);
+  }
+}
+var Y, KNOWN_FUNCTION_DEFAULTS, _syncedCache;
+var init_metaSync = __esm({
+  "src/models/metaSync.ts"() {
+    "use strict";
+    Y = __toESM(require("yjs"), 1);
+    KNOWN_FUNCTION_DEFAULTS = /* @__PURE__ */ new WeakMap();
+    _syncedCache = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // src/models/relationshipManager.ts
 function generateRefersToMethod(_sourceModelClass, config, targetModelClass) {
   return async function() {
@@ -2296,17 +2433,18 @@ __export(BaseModel_exports, {
 function generateULID() {
   return (0, import_ulid.ulid)();
 }
-var Y, import_ulid, LogLevel, Logger, UniqueConstraintViolationError, RecordNotFoundError, SCHEMA_ACCESSORS_KEY, BaseModel2;
+var Y2, import_ulid, LogLevel, Logger, UniqueConstraintViolationError, RecordNotFoundError, SCHEMA_ACCESSORS_KEY, BaseModel2;
 var init_BaseModel = __esm({
   "src/models/BaseModel.ts"() {
     "use strict";
-    Y = __toESM(require("yjs"), 1);
+    Y2 = __toESM(require("yjs"), 1);
     import_ulid = require("ulid");
     init_StringSet();
     init_documentTypes();
     init_DocumentQueryTranslator();
     init_CursorManager();
     init_sql();
+    init_metaSync();
     LogLevel = /* @__PURE__ */ ((LogLevel2) => {
       LogLevel2[LogLevel2["SILENT"] = 0] = "SILENT";
       LogLevel2[LogLevel2["ERROR"] = 1] = "ERROR";
@@ -2410,6 +2548,7 @@ var init_BaseModel = __esm({
         Object.setPrototypeOf(this, _RecordNotFoundError.prototype);
       }
     };
+    registerFunctionDefault(generateULID, "generate_ulid");
     SCHEMA_ACCESSORS_KEY = /* @__PURE__ */ Symbol("jsBaoSchemaAccessors");
     BaseModel2 = class _BaseModel {
       static modelName;
@@ -2440,6 +2579,9 @@ var init_BaseModel = __esm({
       // Flag to distinguish loading vs user changes
       // StringSet field caching
       _stringSetFields = /* @__PURE__ */ new Map();
+      // upsertOn: track what the caller explicitly provided in the constructor
+      _constructorProvidedId = false;
+      _constructorProvidedFields = /* @__PURE__ */ new Set();
       // Multi-document instance metadata
       _metaDocId = null;
       _metaPermissionHint = null;
@@ -2601,6 +2743,7 @@ var init_BaseModel = __esm({
         const idFieldOptions = schema.fields.get("id");
         if (data.id) {
           this.id = data.id;
+          this._constructorProvidedId = true;
         } else if (idFieldOptions?.autoAssign) {
           this.id = generateULID();
         } else if (idFieldOptions?.default) {
@@ -2681,6 +2824,7 @@ var init_BaseModel = __esm({
             if (fieldKey === "id") continue;
             if (data.hasOwnProperty(fieldKey)) {
               this.setValue(fieldKey, data[fieldKey]);
+              this._constructorProvidedFields.add(fieldKey);
             } else if (fieldOptions.default !== void 0) {
               const defaultValue = typeof fieldOptions.default === "function" ? fieldOptions.default() : fieldOptions.default;
               this.setValue(fieldKey, defaultValue);
@@ -3060,7 +3204,7 @@ var init_BaseModel = __esm({
         }
         const extractStringSetValues = (value) => {
           if (!value) return [];
-          if (value instanceof Y.Map) {
+          if (value instanceof Y2.Map) {
             return Array.from(value.entries()).filter(([, isMember]) => Boolean(isMember)).map(([key]) => key);
           }
           if (Array.isArray(value)) {
@@ -3077,7 +3221,7 @@ var init_BaseModel = __esm({
             if (!recordId) continue;
             let itemData;
             const stringSetValuesByField = {};
-            if (recordData instanceof Y.Map) {
+            if (recordData instanceof Y2.Map) {
               itemData = {};
               const unknownFields = [];
               for (const [fieldKey, value] of recordData.entries()) {
@@ -3196,7 +3340,7 @@ var init_BaseModel = __esm({
         const buildUniqueKey = (recordData, fields) => {
           const keyParts = [];
           for (const field of fields) {
-            const value = recordData instanceof Y.Map ? recordData.get(field) : recordData[field];
+            const value = recordData instanceof Y2.Map ? recordData.get(field) : recordData[field];
             if (value === null || value === void 0) {
               return null;
             }
@@ -3206,7 +3350,7 @@ var init_BaseModel = __esm({
         };
         const extractItemData = (key, recordData) => {
           let itemData;
-          if (recordData instanceof Y.Map) {
+          if (recordData instanceof Y2.Map) {
             itemData = {};
             const unknownFields = [];
             for (const [fieldKey, value] of recordData.entries()) {
@@ -3322,7 +3466,7 @@ var init_BaseModel = __esm({
               if (!recordData || !key) continue;
               const itemData = extractItemData(key, recordData);
               if (!itemData) continue;
-              if (change.action === "add" && recordData instanceof Y.Map) {
+              if (change.action === "add" && recordData instanceof Y2.Map) {
                 Logger.verbose(
                   `[${this.name}] Setting up observer on newly added nested YMap for record ${key} in document ${docId}`
                 );
@@ -3467,7 +3611,7 @@ var init_BaseModel = __esm({
           `[${this.name}] Setting up observers on existing nested YMaps for ${modelName}/${docId}...`
         );
         for (const [recordId, recordData] of documentYMap.entries()) {
-          if (recordData instanceof Y.Map) {
+          if (recordData instanceof Y2.Map) {
             Logger.verbose(
               `[${this.name}] Setting up observer on existing nested YMap for record ${recordId} in document ${docId}`
             );
@@ -3815,6 +3959,39 @@ var init_BaseModel = __esm({
           );
         }
         const yDoc = targetYDoc;
+        let upsertOnConstraint = null;
+        let upsertOnKey = null;
+        if (options?.upsertOn) {
+          const upsertField = options.upsertOn;
+          assertValidIdentifier(upsertField, "upsertOn field");
+          const upsertValue = this[upsertField];
+          if (upsertValue === null || upsertValue === void 0 || upsertValue === "") {
+            throw new Error(
+              `[${modelName}] upsertOn field '${upsertField}' must be present in data and not null/empty`
+            );
+          }
+          const constraint = schema.resolvedUniqueConstraints.find(
+            (c) => c.fields.length === 1 && c.fields[0] === upsertField
+          );
+          if (!constraint) {
+            throw new Error(
+              `[${modelName}] upsertOn field '${upsertField}' does not have a registered unique index`
+            );
+          }
+          const uniqueKey = modelConstructor._buildKeyFromValues(
+            constraint.fields,
+            [upsertValue],
+            modelName,
+            constraint.name
+          );
+          if (uniqueKey === null) {
+            throw new Error(
+              `[${modelName}] upsertOn: unable to build unique key for field '${upsertField}'`
+            );
+          }
+          upsertOnConstraint = constraint;
+          upsertOnKey = uniqueKey;
+        }
         if (!this.id) {
           Logger.error(
             "[BaseModel.save()] ID is undefined before saving! Instance dump:",
@@ -3832,6 +4009,28 @@ var init_BaseModel = __esm({
           dataToSave
         );
         await yDoc.transact(async () => {
+          if (upsertOnConstraint && upsertOnKey) {
+            const constraintMapName = `_uniqueIdx_${modelName}_${upsertOnConstraint.name}`;
+            const constraintMap = yDoc.getMap(constraintMapName);
+            const existingId = constraintMap.get(upsertOnKey);
+            if (existingId) {
+              if (this._constructorProvidedId && this.id !== existingId) {
+                throw new Error(
+                  `[${modelName}] upsertOn conflict: caller id '${this.id}' does not match existing record '${existingId}'`
+                );
+              }
+              this.id = existingId;
+              this._metaDocId = targetDocId;
+              this._metaPermissionHint = permissionHint;
+              if (this._localChanges) {
+                for (const key of Object.keys(this._localChanges)) {
+                  if (!this._constructorProvidedFields.has(key)) {
+                    delete this._localChanges[key];
+                  }
+                }
+              }
+            }
+          }
           if (!targetYMap) {
             throw new Error(
               `[${modelName}] Target YMap not found for save operation`
@@ -3842,7 +4041,7 @@ var init_BaseModel = __esm({
           Logger.debug(`[${modelName}.save] isUpdate: ${isUpdate}`);
           Logger.debug(`[${modelName}.save] recordYMap exists: ${!!recordYMap}`);
           if (!recordYMap) {
-            recordYMap = new Y.Map();
+            recordYMap = new Y2.Map();
             Logger.verbose(
               `[${modelName}] Creating new nested YMap for record ${this.id} in document ${targetDocId || "legacy"}`
             );
@@ -4014,6 +4213,7 @@ var init_BaseModel = __esm({
             }
           }
           Logger.verbose(`[${modelName}] Save completed for ${this.id}`);
+          syncModelMeta(yDoc, modelName, schema);
           if (_BaseModel.dbInstance) {
             Logger.verbose(
               `[${modelName}] Syncing StringSet changes to database for ${this.id}`
@@ -4858,7 +5058,7 @@ var init_BaseModel = __esm({
                 );
               }
               for (const [recordId, recordYMap] of documentYMap.entries()) {
-                if (recordYMap instanceof Y.Map) {
+                if (recordYMap instanceof Y2.Map) {
                   const instance = new this({ id: recordId });
                   instance._metaDocId = docId;
                   const connectedDoc = modelConstructor.connectedDocuments.get(docId);
@@ -4929,7 +5129,7 @@ var init_BaseModel = __esm({
               const documentYMap = modelConstructor.documentYMaps.get(documentYMapKey);
               if (documentYMap) {
                 const recordYMap2 = documentYMap.get(recordId2);
-                if (recordYMap2 && recordYMap2 instanceof Y.Map) {
+                if (recordYMap2 && recordYMap2 instanceof Y2.Map) {
                   const instance = new modelConstructor({
                     id: recordId2
                   });
@@ -4966,7 +5166,7 @@ var init_BaseModel = __esm({
         if (!recordYMap) {
           return null;
         }
-        if (recordYMap instanceof Y.Map) {
+        if (recordYMap instanceof Y2.Map) {
           const instance = new modelConstructor({
             id: recordId
           });
@@ -5350,15 +5550,24 @@ __export(browser_exports, {
   attachAndRegisterModel: () => attachAndRegisterModel,
   attachSchemaToClass: () => attachSchemaToClass,
   autoRegisterModel: () => autoRegisterModel,
+  clearMetaSyncCache: () => clearMetaSyncCache,
   createModelClass: () => createModelClass,
   defineModelSchema: () => defineModelSchema,
   detectEnvironment: () => detectEnvironment,
+  discoverModelNames: () => discoverModelNames,
+  discoverSchema: () => discoverSchema,
   features: () => features,
   generateULID: () => generateULID,
+  inferFieldType: () => inferFieldType,
   initJsBao: () => initJsBao,
   isBrowser: () => isBrowser,
   isNode: () => isNode,
-  resetJsBao: () => resetJsBao
+  loadSchemaFromTomlString: () => loadSchemaFromTomlString,
+  registerFunctionDefault: () => registerFunctionDefault,
+  resetJsBao: () => resetJsBao,
+  schemaToToml: () => schemaToToml,
+  syncInferredMeta: () => syncInferredMeta,
+  syncModelMeta: () => syncModelMeta
 });
 module.exports = __toCommonJS(browser_exports);
 init_BaseModel();
@@ -5549,9 +5758,12 @@ var TransactionalSQLJSOperations = class {
     const quotedColumns = columns.map((column) => quoteIdentifier(column));
     const placeholders = columns.map(() => "?").join(", ");
     const values = Object.values(data);
-    const insertSQL = `INSERT OR REPLACE INTO ${quotedTableName} (${quotedColumns.join(
+    const nonIdColumns = columns.filter((c) => c !== "id");
+    const quotedNonIdColumns = nonIdColumns.map((c) => quoteIdentifier(c));
+    const updateClause = nonIdColumns.length > 0 ? `ON CONFLICT(${quoteIdentifier("id")}) DO UPDATE SET ${quotedNonIdColumns.map((c) => `${c}=excluded.${c}`).join(", ")}` : `ON CONFLICT(${quoteIdentifier("id")}) DO NOTHING`;
+    const insertSQL = `INSERT INTO ${quotedTableName} (${quotedColumns.join(
       ", "
-    )}) VALUES (${placeholders});`;
+    )}) VALUES (${placeholders}) ${updateClause};`;
     this.db.run(insertSQL, values);
   }
   async delete(modelName, id) {
@@ -5762,9 +5974,12 @@ var SqljsEngine = class _SqljsEngine {
     const quotedColumns = columns.map((column) => quoteIdentifier(column));
     const placeholders = columns.map(() => "?").join(", ");
     const values = Object.values(data);
-    const insertSQL = `INSERT OR REPLACE INTO ${quotedTableName} (${quotedColumns.join(
+    const nonIdColumns = columns.filter((c) => c !== "id");
+    const quotedNonIdColumns = nonIdColumns.map((c) => quoteIdentifier(c));
+    const updateClause = nonIdColumns.length > 0 ? `ON CONFLICT(${quoteIdentifier("id")}) DO UPDATE SET ${quotedNonIdColumns.map((c) => `${c}=excluded.${c}`).join(", ")}` : `ON CONFLICT(${quoteIdentifier("id")}) DO NOTHING`;
+    const insertSQL = `INSERT INTO ${quotedTableName} (${quotedColumns.join(
       ", "
-    )}) VALUES (${placeholders});`;
+    )}) VALUES (${placeholders}) ${updateClause};`;
     this.db.run(insertSQL, values);
   }
   async delete(modelName, id) {
@@ -6389,3 +6604,325 @@ function attachAndRegisterModel(modelClass, schema) {
   const runtimeShape = attachSchemaToClass(modelClass, schema);
   autoRegisterModel(modelClass, runtimeShape);
 }
+
+// src/utils/yDocSchema.ts
+var Y3 = __toESM(require("yjs"), 1);
+function discoverSchema(yDoc) {
+  const models = {};
+  const metaNames = /* @__PURE__ */ new Set();
+  for (const key of yDoc.share.keys()) {
+    if (!key.startsWith("_meta_")) continue;
+    const map = materializeMap(yDoc, key);
+    if (!map) continue;
+    const modelName = key.slice("_meta_".length);
+    metaNames.add(modelName);
+    models[modelName] = readModelMeta(map);
+  }
+  for (const key of yDoc.share.keys()) {
+    if (key.startsWith("_")) continue;
+    if (metaNames.has(key)) continue;
+    const map = materializeMap(yDoc, key);
+    if (!map || map.size === 0) continue;
+    const inferred = inferModelFromData(map);
+    if (inferred) models[key] = inferred;
+  }
+  return { models };
+}
+function discoverModelNames(yDoc) {
+  const names = [];
+  for (const key of yDoc.share.keys()) {
+    if (key.startsWith("_")) continue;
+    const map = materializeMap(yDoc, key);
+    if (map) names.push(key);
+  }
+  return names.sort();
+}
+function materializeMap(yDoc, key) {
+  try {
+    const map = yDoc.getMap(key);
+    return map instanceof Y3.Map ? map : null;
+  } catch {
+    return null;
+  }
+}
+function readModelMeta(metaMap) {
+  const fields = {};
+  let constraints;
+  let relationships;
+  for (const [key, value] of metaMap.entries()) {
+    if (key === "_constraints" && value instanceof Y3.Map) {
+      constraints = readConstraints(value);
+    } else if (key === "_relationships" && value instanceof Y3.Map) {
+      relationships = readRelationships(value);
+    } else if (value instanceof Y3.Map) {
+      fields[key] = readFieldMeta(value);
+    }
+  }
+  const model = { fields };
+  if (constraints && Object.keys(constraints).length > 0) {
+    model.constraints = constraints;
+  }
+  if (relationships && Object.keys(relationships).length > 0) {
+    model.relationships = relationships;
+  }
+  return model;
+}
+function readFieldMeta(fieldMap) {
+  const field = { type: fieldMap.get("type") ?? "unknown" };
+  if (fieldMap.get("indexed") === true) field.indexed = true;
+  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 def = fieldMap.get("default");
+  if (def !== void 0) field.default = def;
+  const maxLength = fieldMap.get("maxLength");
+  if (maxLength !== void 0) field.maxLength = maxLength;
+  const maxCount = fieldMap.get("maxCount");
+  if (maxCount !== void 0) field.maxCount = maxCount;
+  return field;
+}
+function inferModelFromData(dataMap) {
+  const fields = {};
+  let sampled = 0;
+  for (const [_recordId, recordValue] of dataMap.entries()) {
+    if (!(recordValue instanceof Y3.Map)) continue;
+    if (++sampled > 5) break;
+    for (const [fieldName, value] of recordValue.entries()) {
+      if (fieldName.startsWith("_")) continue;
+      if (fields[fieldName]) continue;
+      const type = inferTypeFromValue(value);
+      if (type) fields[fieldName] = { type };
+    }
+  }
+  if (Object.keys(fields).length === 0) return null;
+  return { fields };
+}
+function inferTypeFromValue(value) {
+  if (value instanceof Y3.Map) return "stringset";
+  switch (typeof value) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return null;
+  }
+}
+function readConstraints(constraintsMap) {
+  const out = {};
+  for (const [name, value] of constraintsMap.entries()) {
+    if (!(value instanceof Y3.Map)) continue;
+    let fields = [];
+    const rawFields = value.get("fields");
+    if (typeof rawFields === "string") {
+      try {
+        fields = JSON.parse(rawFields);
+      } catch {
+      }
+    }
+    out[name] = {
+      type: value.get("type") ?? "unknown",
+      fields
+    };
+  }
+  return out;
+}
+function readRelationships(relsMap) {
+  const out = {};
+  for (const [name, value] of relsMap.entries()) {
+    if (!(value instanceof Y3.Map)) continue;
+    const rel = {};
+    for (const [k, v] of value.entries()) {
+      rel[k] = v;
+    }
+    out[name] = rel;
+  }
+  return out;
+}
+var CAMEL_TO_SNAKE = {
+  autoAssign: "auto_assign",
+  maxLength: "max_length",
+  maxCount: "max_count",
+  relatedIdField: "related_id_field",
+  joinModel: "join_model",
+  joinModelLocalField: "join_model_local_field",
+  joinModelRelatedField: "join_model_related_field",
+  joinModelOrderByField: "join_model_order_by_field",
+  joinModelOrderDirection: "join_model_order_direction",
+  orderByField: "order_by_field",
+  orderDirection: "order_direction"
+};
+function toSnake(key) {
+  return CAMEL_TO_SNAKE[key] ?? key;
+}
+function tomlValue(v) {
+  if (typeof v === "string") {
+    return `"${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t")}"`;
+  }
+  return String(v);
+}
+function schemaToToml(schema) {
+  const lines = [];
+  for (const [modelName, model] of Object.entries(schema.models)) {
+    if (lines.length > 0) lines.push("", "");
+    lines.push(`[models.${modelName}]`);
+    for (const [fieldName, field] of Object.entries(model.fields)) {
+      lines.push("");
+      lines.push(`[models.${modelName}.fields.${fieldName}]`);
+      lines.push(`type = ${tomlValue(field.type)}`);
+      if (field.autoAssign) lines.push("auto_assign = true");
+      if (field.indexed) lines.push("indexed = true");
+      if (field.unique) lines.push("unique = true");
+      if (field.required) lines.push("required = true");
+      if (field.maxLength !== void 0) lines.push(`max_length = ${field.maxLength}`);
+      if (field.maxCount !== void 0) lines.push(`max_count = ${field.maxCount}`);
+      if (field.default !== void 0) lines.push(`default = ${tomlValue(field.default)}`);
+    }
+    if (model.relationships) {
+      for (const [relName, rel] of Object.entries(model.relationships)) {
+        lines.push("");
+        lines.push(`[models.${modelName}.relationships.${relName}]`);
+        for (const [k, v] of Object.entries(rel)) {
+          if (v === void 0) continue;
+          lines.push(`${toSnake(k)} = ${tomlValue(v)}`);
+        }
+      }
+    }
+    if (model.constraints) {
+      for (const [cName, c] of Object.entries(model.constraints)) {
+        lines.push("");
+        lines.push(`[[models.${modelName}.unique_constraints]]`);
+        lines.push(`name = ${tomlValue(cName)}`);
+        lines.push(`fields = [${c.fields.map((f) => tomlValue(f)).join(", ")}]`);
+      }
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/models/tomlLoader.ts
+var import_smol_toml = require("smol-toml");
+var VALID_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "date",
+  "id",
+  "stringset"
+]);
+function parseFieldOptions(raw) {
+  if (!raw.type || !VALID_FIELD_TYPES.has(raw.type)) {
+    throw new Error(
+      `Invalid field type "${raw.type}". Must be one of: ${[...VALID_FIELD_TYPES].join(", ")}`
+    );
+  }
+  const opts = { type: raw.type };
+  if (raw.indexed === true) opts.indexed = true;
+  if (raw.unique === true) opts.unique = true;
+  if (raw.required === true) opts.required = true;
+  if (raw.auto_assign === true) opts.autoAssign = true;
+  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;
+  return opts;
+}
+function requireField(raw, field, context) {
+  if (!raw[field]) {
+    throw new Error(`Relationship ${context}: missing required field "${field}"`);
+  }
+}
+function parseRelationship(raw) {
+  const type = raw.type;
+  if (type === "refersTo") {
+    requireField(raw, "model", "refersTo");
+    requireField(raw, "related_id_field", "refersTo");
+    return {
+      type: "refersTo",
+      model: raw.model,
+      relatedIdField: raw.related_id_field
+    };
+  }
+  if (type === "hasMany") {
+    requireField(raw, "model", "hasMany");
+    requireField(raw, "related_id_field", "hasMany");
+    const rel = {
+      type: "hasMany",
+      model: raw.model,
+      relatedIdField: raw.related_id_field
+    };
+    if (raw.order_by_field) rel.orderByField = raw.order_by_field;
+    if (raw.order_direction) rel.orderDirection = raw.order_direction;
+    return rel;
+  }
+  if (type === "hasManyThrough") {
+    requireField(raw, "model", "hasManyThrough");
+    requireField(raw, "join_model", "hasManyThrough");
+    requireField(raw, "join_model_local_field", "hasManyThrough");
+    requireField(raw, "join_model_related_field", "hasManyThrough");
+    const rel = {
+      type: "hasManyThrough",
+      model: raw.model,
+      joinModel: raw.join_model,
+      joinModelLocalField: raw.join_model_local_field,
+      joinModelRelatedField: raw.join_model_related_field
+    };
+    if (raw.join_model_order_by_field)
+      rel.joinModelOrderByField = raw.join_model_order_by_field;
+    if (raw.join_model_order_direction)
+      rel.joinModelOrderDirection = raw.join_model_order_direction;
+    return rel;
+  }
+  throw new Error(`Unknown relationship type: ${type}`);
+}
+function loadSchemaFromTomlString(tomlString) {
+  const parsed = (0, import_smol_toml.parse)(tomlString);
+  const models = parsed.models;
+  if (!models || typeof models !== "object") {
+    throw new Error("TOML schema must have a [models] section");
+  }
+  const schemas = [];
+  for (const [modelName, modelDef] of Object.entries(models)) {
+    const fields = {};
+    if (modelDef.fields) {
+      for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
+        fields[fieldName] = parseFieldOptions(fieldDef);
+      }
+    }
+    let relationships;
+    if (modelDef.relationships) {
+      relationships = {};
+      for (const [relName, relDef] of Object.entries(
+        modelDef.relationships
+      )) {
+        relationships[relName] = parseRelationship(relDef);
+      }
+    }
+    let uniqueConstraints;
+    if (modelDef.unique_constraints) {
+      uniqueConstraints = [];
+      for (const raw of modelDef.unique_constraints) {
+        uniqueConstraints.push({
+          name: raw.name,
+          fields: [...raw.fields]
+        });
+      }
+    }
+    schemas.push(
+      defineModelSchema({
+        name: modelName,
+        fields,
+        options: {
+          uniqueConstraints,
+          relationships
+        }
+      })
+    );
+  }
+  return schemas;
+}
+
+// src/browser.ts
+init_metaSync();