js-bao 0.3.0 → 0.4.0

package/dist/browser.cjs

@@ -1184,6 +1184,19 @@ 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);
 }
@@ -1195,6 +1208,11 @@ function encodeDefault(value) {
   }
   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;
@@ -1270,6 +1288,23 @@ function syncRelationshipMeta(relsMap, relName, relConfig) {
     }
   }
 }
+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);
@@ -1599,11 +1634,11 @@ var init_ModelRegistry = __esm({
     init_relationshipManager();
     ModelRegistry = class _ModelRegistry {
       static instance;
-      // Stores globally registered model classes by their name (from @Model decorator)
+      // Stores globally registered model classes by their name
       models = /* @__PURE__ */ new Map();
-      // Stores options for globally registered models (from @Model decorator)
+      // Stores options for globally registered models
       modelOptions = /* @__PURE__ */ new Map();
-      // Stores fields for globally registered models (from @Model decorator, or a static getter on class)
+      // Stores fields for globally registered models (or a static getter on class)
       // For simplicity, let's assume fields can be derived or are less critical for this registry part
       // private modelFields: Map<string, Map<string, FieldOptions>> = new Map();
       // Holds the subset of models explicitly set for the current initialization session
@@ -1621,7 +1656,7 @@ var init_ModelRegistry = __esm({
       registerModel(modelClass, options, fields) {
         if (!options.name) {
           throw new Error(
-            `[ModelRegistry] Model class is missing a name in its @Model options. Ensure the @Model decorator includes a 'name' property.`
+            `[ModelRegistry] Model class is missing a name in its options. Ensure the schema passed to defineModelSchema/createModelClass/attachAndRegisterModel includes a 'name' property.`
           );
         }
         if (this.models.has(options.name)) {
@@ -1665,7 +1700,7 @@ var init_ModelRegistry = __esm({
         }
         return infos;
       }
-      // Helper to get model name from class (assuming static property from @Model decorator)
+      // Helper to get model name from class (set by attachAndRegisterModel/createModelClass)
       getModelNameFromClass(modelClass) {
         return modelClass.modelName;
       }
@@ -1676,13 +1711,13 @@ var init_ModelRegistry = __esm({
             const modelName = this.getModelNameFromClass(modelClass);
             if (!modelName) {
               console.warn(
-                `[ModelRegistry] A model class provided to setExplicitModelsForSession does not have a static 'modelName' property or it's undefined. It will be ignored. Ensure @Model decorator sets this.`
+                `[ModelRegistry] A model class provided to setExplicitModelsForSession does not have a static 'modelName' property or it's undefined. It will be ignored. Ensure attachAndRegisterModel (or createModelClass) was called for this model.`
               );
               return;
             }
             if (!this.models.has(modelName) || this.models.get(modelName) !== modelClass) {
               console.warn(
-                `[ModelRegistry] Model class with name ${modelName} provided to setExplicitModelsForSession was not found in the global decorator-based registry or does not match. It will be ignored. Ensure the model file is imported and the @Model decorator has run correctly.`
+                `[ModelRegistry] Model class with name ${modelName} provided to setExplicitModelsForSession was not found in the global registry or does not match. It will be ignored. Ensure the model file is imported and attachAndRegisterModel (or createModelClass) has run.`
               );
               return;
             }
@@ -1712,7 +1747,7 @@ var init_ModelRegistry = __esm({
         } else {
           this.activeSessionModels = null;
           console.log(
-            "[ModelRegistry] No explicit models specified for session (undefined), will use all decorator-registered models."
+            "[ModelRegistry] No explicit models specified for session (undefined), will use all globally registered models."
           );
         }
         this.validateSessionModels();
@@ -1723,7 +1758,7 @@ var init_ModelRegistry = __esm({
         const modelsToInitialize = this.activeSessionModels || this.models;
         if (modelsToInitialize.size === 0) {
           console.warn(
-            "[ModelRegistry] No models to initialize (either no explicit models set for session or no models globally registered via @Model decorator)."
+            "[ModelRegistry] No models to initialize (either no explicit models set for session or no models globally registered via attachAndRegisterModel)."
           );
           return;
         }
@@ -1754,7 +1789,7 @@ var init_ModelRegistry = __esm({
         const modelsToInitialize = this.activeSessionModels || this.models;
         if (modelsToInitialize.size === 0) {
           Logger.warn(
-            "[ModelRegistry] No models to initialize for document (either no explicit models set for session or no models globally registered via @Model decorator)."
+            "[ModelRegistry] No models to initialize for document (either no explicit models set for session or no models globally registered via attachAndRegisterModel)."
           );
           return;
         }
@@ -1792,7 +1827,7 @@ var init_ModelRegistry = __esm({
         const modelsToCleanup = this.activeSessionModels || this.models;
         if (modelsToCleanup.size === 0) {
           console.warn(
-            "[ModelRegistry] No models to cleanup for document (either no explicit models set for session or no models globally registered via @Model decorator)."
+            "[ModelRegistry] No models to cleanup for document (either no explicit models set for session or no models globally registered via attachAndRegisterModel)."
           );
           return;
         }
@@ -2556,7 +2591,7 @@ var init_BaseModel = __esm({
       getDocumentId() {
         return this._metaDocId;
       }
-      // id is now a plain property. Subclasses will define it with @Field.
+      // id is a plain property. Subclasses define it via defineModelSchema.
       id;
       type;
       // This should be the modelName from ModelOptions
@@ -3103,7 +3138,7 @@ var init_BaseModel = __esm({
         const verboseEnabled = Logger.getLogLevel() >= 5 /* VERBOSE */;
         if (!schema || !schema.options || !schema.options.name || !schema.resolvedUniqueConstraints) {
           throw new Error(
-            `[${this.name}] Model schema is not registered, missing options, or missing resolvedUniqueConstraints. Did you forget to use the @Model decorator or has the schema structure changed?`
+            `[${this.name}] Model schema is not registered, missing options, or missing resolvedUniqueConstraints. Did you forget to call attachAndRegisterModel (or autoRegisterModel) for this model?`
           );
         }
         const modelName = schema.options.name;
@@ -5503,10 +5538,8 @@ __export(browser_exports, {
   BaseModel: () => BaseModel2,
   DatabaseEngine: () => DatabaseEngine,
   DatabaseFactory: () => BrowserDatabaseFactory,
-  Field: () => Field,
   LogLevel: () => LogLevel,
   Logger: () => Logger,
-  Model: () => Model,
   ModelRegistry: () => ModelRegistry,
   RecordNotFoundError: () => RecordNotFoundError,
   SqljsEngine: () => SqljsEngine,
@@ -5515,145 +5548,29 @@ __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();
 init_ModelRegistry();
 
-// src/models/decorators.ts
-init_ModelRegistry();
-init_BaseModel();
-init_sql();
-var SCHEMA_FIELDS_PROPERTY = "_jsbaoSchemaFields";
-function Field(options) {
-  return function(target, propertyKey) {
-    const fieldName = String(propertyKey);
-    const modelConstructor = target.constructor || target;
-    assertValidIdentifier(
-      fieldName,
-      `[Field Decorator] Invalid field name on ${modelConstructor?.name || "unknown"}`
-    );
-    if (!modelConstructor) {
-      console.error(
-        "[Field Decorator] Could not determine model constructor for field:",
-        fieldName,
-        "Target:",
-        target
-      );
-      throw new Error(
-        `Failed to resolve model constructor for field '${fieldName}'.`
-      );
-    }
-    if (!Object.prototype.hasOwnProperty.call(
-      modelConstructor,
-      SCHEMA_FIELDS_PROPERTY
-    )) {
-      modelConstructor[SCHEMA_FIELDS_PROPERTY] = /* @__PURE__ */ new Map();
-    }
-    modelConstructor[SCHEMA_FIELDS_PROPERTY].set(
-      fieldName,
-      options
-    );
-    Logger.debug(
-      `[Field Decorator] Staged field "${fieldName}" for class ${modelConstructor.name}:`,
-      options
-    );
-  };
-}
-function Model(options) {
-  return function(targetClass) {
-    Logger.debug(
-      `[Model Decorator] Registering model:`,
-      targetClass.name,
-      options
-    );
-    assertValidIdentifier(
-      options.name,
-      `[Model Decorator] Invalid model name for ${targetClass.name}`
-    );
-    const registry = ModelRegistry.getInstance();
-    targetClass.modelName = options.name;
-    targetClass.getSchema = () => {
-      const combinedFields = /* @__PURE__ */ new Map();
-      const hierarchyStack = [];
-      let currentEvalClass = targetClass;
-      while (currentEvalClass && currentEvalClass.prototype) {
-        hierarchyStack.push(currentEvalClass);
-        const parentPrototype = Object.getPrototypeOf(
-          currentEvalClass.prototype
-        );
-        currentEvalClass = parentPrototype ? parentPrototype.constructor : null;
-        if (currentEvalClass === Object) break;
-      }
-      for (let i = hierarchyStack.length - 1; i >= 0; i--) {
-        const cls = hierarchyStack[i];
-        if (Object.prototype.hasOwnProperty.call(cls, SCHEMA_FIELDS_PROPERTY)) {
-          const fieldsForClass = cls[SCHEMA_FIELDS_PROPERTY];
-          fieldsForClass.forEach((fieldOpts, fieldName) => {
-            combinedFields.set(fieldName, fieldOpts);
-          });
-        }
-      }
-      const resolvedUniqueConstraints = [];
-      combinedFields.forEach((fieldOpts, fieldName) => {
-        if (fieldOpts.unique) {
-          const constraintName = `${options.name}_${fieldName}_unique`;
-          resolvedUniqueConstraints.push({
-            name: constraintName,
-            fields: [fieldName]
-          });
-        }
-      });
-      if (options.uniqueConstraints) {
-        options.uniqueConstraints.forEach(
-          (constraintConfig) => {
-            const allFieldsExist = constraintConfig.fields.every(
-              (f) => combinedFields.has(f)
-            );
-            if (!allFieldsExist) {
-              console.warn(
-                `[Model Decorator] Unique constraint "${constraintConfig.name}" for model "${options.name}" specifies non-existent fields. Skipping.`
-              );
-              return;
-            }
-            if (resolvedUniqueConstraints.some(
-              (rc) => rc.name === constraintConfig.name
-            )) {
-              console.warn(
-                `[Model Decorator] Duplicate unique constraint name "${constraintConfig.name}" in model "${options.name}".`
-              );
-            }
-            resolvedUniqueConstraints.push({
-              name: constraintConfig.name,
-              fields: constraintConfig.fields
-            });
-          }
-        );
-      }
-      return {
-        class: targetClass,
-        options,
-        fields: combinedFields,
-        resolvedUniqueConstraints
-      };
-    };
-    const directFieldsForThisClass = Object.prototype.hasOwnProperty.call(
-      targetClass,
-      SCHEMA_FIELDS_PROPERTY
-    ) ? targetClass[SCHEMA_FIELDS_PROPERTY] : /* @__PURE__ */ new Map();
-    registry.registerModel(targetClass, options, directFieldsForThisClass);
-  };
-}
-
 // src/engines/DatabaseEngine.ts
 var DatabaseEngine = class {
   createTable(_modelName, _schema, _options) {
@@ -5693,7 +5610,7 @@ var DatabaseEngine = class {
 };
 
 // src/engines/SqljsEngine.ts
-var import_sql5 = __toESM(require("sql.js"), 1);
+var import_sql4 = __toESM(require("sql.js"), 1);
 init_BaseModel();
 var import_async_mutex = require("async-mutex");
 init_sql();
@@ -5770,7 +5687,7 @@ var SqljsEngine = class _SqljsEngine {
           "[SqljsEngine] Attempting to load SQL.js WASM from:",
           locateFileConfig("sql-wasm.wasm")
         );
-        _SqljsEngine.SQL = await (0, import_sql5.default)({
+        _SqljsEngine.SQL = await (0, import_sql4.default)({
           locateFile: locateFileConfig
         });
         Logger.info("[SqljsEngine] SQL.js WASM loaded successfully.");
@@ -6560,3 +6477,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();