js-bao 0.2.11 → 0.2.12

package/dist/index.cjs

@@ -349,7 +349,7 @@ var init_CursorManager = __esm({
           conditions.push(`(${levelCondition})`);
           params.push(...fieldParams);
         }
-        const sql = conditions.join(" OR ");
+        const sql = `(${conditions.join(" OR ")})`;
         return { sql, params };
       }
       /**
@@ -1183,6 +1183,392 @@ var init_DocumentQueryTranslator = __esm({
   }
 });
 
+// src/query/IncludeResolver.ts
+var IncludeResolver_exports = {};
+__export(IncludeResolver_exports, {
+  IncludeResolver: () => IncludeResolver
+});
+var IncludeResolver;
+var init_IncludeResolver = __esm({
+  "src/query/IncludeResolver.ts"() {
+    "use strict";
+    init_ModelRegistry();
+    init_DocumentQueryTranslator();
+    init_sql();
+    IncludeResolver = class {
+      db;
+      constructor(db) {
+        this.db = db;
+      }
+      /** Main entry — resolve all includes for a set of records. */
+      async resolve(records, includes, depth, parentModelName) {
+        if (records.length === 0) return;
+        if (depth >= 3) return;
+        for (const spec of includes) {
+          const error = this._validateIncludeSpec(spec);
+          if (error) {
+            console.warn(`[include] Skipping invalid spec: ${error}`);
+            continue;
+          }
+          const resultKey = spec.as || spec.model;
+          for (const rec of records) {
+            if (!rec._related) rec._related = {};
+          }
+          if (spec.type === "refersTo") {
+            await this._resolveRefersTo(records, spec, resultKey);
+          } else if (spec.type === "refersToMany") {
+            await this._resolveRefersToMany(records, spec, resultKey, parentModelName);
+          } else {
+            await this._resolveHasMany(records, spec, resultKey);
+          }
+          if (spec.include && spec.include.length > 0) {
+            const allRelated = [];
+            for (const rec of records) {
+              const val = rec._related[resultKey];
+              if (Array.isArray(val)) {
+                allRelated.push(...val);
+              } else if (val) {
+                allRelated.push(val);
+              }
+            }
+            if (allRelated.length > 0) {
+              await this.resolve(allRelated, spec.include, depth + 1, spec.model);
+            }
+          }
+        }
+      }
+      /** Resolve a refersTo include (parent FK → single related record). */
+      async _resolveRefersTo(records, spec, resultKey) {
+        const sourceField = spec.sourceField;
+        const uniqueValues = [
+          ...new Set(
+            records.map((r) => r[sourceField]).filter((v) => v != null && v !== "")
+          )
+        ];
+        if (uniqueValues.length === 0) {
+          for (const rec of records) {
+            rec._related[resultKey] = null;
+          }
+          return;
+        }
+        const related = await this._chunkedIn(
+          spec.model,
+          "id",
+          uniqueValues,
+          spec.filter,
+          { projection: spec.projection }
+        );
+        const lookupMap = /* @__PURE__ */ new Map();
+        for (const r of related) {
+          lookupMap.set(r.id, r);
+        }
+        for (const rec of records) {
+          const fk = rec[sourceField];
+          rec._related[resultKey] = fk && lookupMap.get(fk) || null;
+        }
+      }
+      /** Resolve a refersToMany include (parent StringSet field → array of related records). */
+      async _resolveRefersToMany(records, spec, resultKey, parentModelName) {
+        const sourceField = spec.sourceField;
+        if (!parentModelName) {
+          console.warn(
+            `[include] refersToMany requires parentModelName, skipping`
+          );
+          for (const rec of records) {
+            rec._related[resultKey] = [];
+          }
+          return;
+        }
+        const junctionTable = `model_${parentModelName.toLowerCase()}_${sourceField.toLowerCase()}`;
+        const fkColumn = `${parentModelName.toLowerCase()}_id`;
+        const parentIds = [
+          ...new Set(
+            records.map((r) => r.id).filter((v) => v != null && v !== "")
+          )
+        ];
+        if (parentIds.length === 0) {
+          for (const rec of records) {
+            rec._related[resultKey] = [];
+          }
+          return;
+        }
+        const junctionMap = /* @__PURE__ */ new Map();
+        const chunkSize = 99;
+        for (let i = 0; i < parentIds.length; i += chunkSize) {
+          const chunk = parentIds.slice(i, i + chunkSize);
+          const inPlaceholders = chunk.map(() => "?").join(", ");
+          const sql = `SELECT ${quoteIdentifier(fkColumn)}, "value" FROM ${quoteIdentifier(junctionTable)} WHERE ${quoteIdentifier(fkColumn)} IN (${inPlaceholders})`;
+          const rows = await this.db.query(sql, chunk);
+          for (const row of rows) {
+            const parentId = row[fkColumn];
+            const value = row.value;
+            if (!junctionMap.has(parentId)) junctionMap.set(parentId, []);
+            junctionMap.get(parentId).push(value);
+          }
+        }
+        const allTargetIds = [...new Set(
+          Array.from(junctionMap.values()).flat()
+        )];
+        if (allTargetIds.length === 0) {
+          for (const rec of records) {
+            rec._related[resultKey] = [];
+          }
+          return;
+        }
+        const targets = await this._chunkedIn(
+          spec.model,
+          "id",
+          allTargetIds,
+          spec.filter,
+          { projection: spec.projection }
+        );
+        const targetLookup = /* @__PURE__ */ new Map();
+        for (const t of targets) {
+          targetLookup.set(t.id, t);
+        }
+        for (const rec of records) {
+          const targetIds = junctionMap.get(rec.id) || [];
+          rec._related[resultKey] = targetIds.map((id) => targetLookup.get(id)).filter(Boolean);
+        }
+      }
+      /** Resolve a hasMany include (target FK → array of related records). */
+      async _resolveHasMany(records, spec, resultKey) {
+        const localField = spec.localField || "id";
+        const uniqueValues = [
+          ...new Set(
+            records.map((r) => r[localField]).filter((v) => v != null && v !== "")
+          )
+        ];
+        if (uniqueValues.length === 0) {
+          for (const rec of records) {
+            rec._related[resultKey] = [];
+          }
+          return;
+        }
+        let related;
+        if (spec.limit) {
+          related = await this._resolveHasManyWithLimit(spec, uniqueValues);
+        } else {
+          related = await this._resolveHasManySimple(spec, uniqueValues);
+        }
+        const foreignKey = spec.foreignKey;
+        const grouped = /* @__PURE__ */ new Map();
+        for (const r of related) {
+          const fk = r[foreignKey];
+          if (!grouped.has(fk)) grouped.set(fk, []);
+          grouped.get(fk).push(r);
+        }
+        if (spec.projection) {
+          for (const [key, list] of grouped) {
+            grouped.set(
+              key,
+              list.map((r) => this._applyProjection(r, spec.projection))
+            );
+          }
+        }
+        for (const rec of records) {
+          rec._related[resultKey] = grouped.get(rec[localField]) || [];
+        }
+      }
+      /** Simple hasMany without per-parent limit. */
+      async _resolveHasManySimple(spec, parentValues) {
+        return this._chunkedIn(spec.model, spec.foreignKey, parentValues, spec.filter, {
+          sort: spec.sort
+        });
+      }
+      /** hasMany with per-parent limit using ROW_NUMBER(). */
+      async _resolveHasManyWithLimit(spec, parentValues) {
+        const foreignKey = spec.foreignKey;
+        assertValidIdentifier(foreignKey, "include foreignKey");
+        const modelInfo = ModelRegistry.getInstance().getModelInfo(spec.model);
+        if (!modelInfo) {
+          console.warn(
+            `[include] Target model "${spec.model}" not found in registry, skipping`
+          );
+          return [];
+        }
+        const tableName = `model_${spec.model.toLowerCase()}`;
+        const quotedTable = quoteIdentifier(tableName);
+        let sortClause = `"id" ASC`;
+        if (spec.sort) {
+          const parts = [];
+          for (const [field, dir] of Object.entries(spec.sort)) {
+            assertValidIdentifier(field, "include sort field");
+            parts.push(`${quoteIdentifier(field)} ${dir === -1 ? "DESC" : "ASC"}`);
+          }
+          sortClause = parts.join(", ");
+        }
+        const translator = new DocumentQueryTranslator(
+          spec.model,
+          modelInfo.fields
+        );
+        let filterClause = "";
+        let filterParams = [];
+        if (spec.filter) {
+          const translated = translator.translateFilter(spec.filter);
+          if (translated.sql) {
+            filterClause = ` AND ${translated.sql}`;
+            filterParams = translated.params;
+          }
+        }
+        const reservedParams = filterParams.length + 1;
+        const chunkSize = Math.max(1, 100 - reservedParams);
+        const allResults = [];
+        for (let i = 0; i < parentValues.length; i += chunkSize) {
+          const chunk = parentValues.slice(i, i + chunkSize);
+          const inPlaceholders = chunk.map(() => "?").join(", ");
+          const sql = `
+        SELECT * FROM (
+          SELECT *,
+            ROW_NUMBER() OVER (
+              PARTITION BY ${quoteIdentifier(foreignKey)}
+              ORDER BY ${sortClause}
+            ) as _rn
+          FROM ${quotedTable}
+          WHERE ${quoteIdentifier(foreignKey)} IN (${inPlaceholders})
+            ${filterClause}
+        ) WHERE _rn <= ?
+      `;
+          const params = [...chunk, ...filterParams, spec.limit];
+          const rows = await this.db.query(sql, params);
+          for (const row of rows) {
+            delete row._rn;
+            allResults.push(row);
+          }
+        }
+        return allResults;
+      }
+      /**
+       * Execute IN queries in chunks to stay under SQLite's parameter limit.
+       * Uses 100-param chunks for consistency with the DO backend.
+       */
+      async _chunkedIn(model, field, values, extraFilter, extraOptions) {
+        const modelInfo = ModelRegistry.getInstance().getModelInfo(model);
+        if (!modelInfo) {
+          console.warn(
+            `[include] Target model "${model}" not found in registry, skipping`
+          );
+          return [];
+        }
+        const translator = new DocumentQueryTranslator(model, modelInfo.fields);
+        let filterParamCount = 0;
+        if (extraFilter) {
+          const translated = translator.translateFilter(extraFilter);
+          filterParamCount = translated.params.length;
+        }
+        const chunkSize = Math.max(1, 100 - filterParamCount);
+        const allResults = [];
+        for (let i = 0; i < values.length; i += chunkSize) {
+          const chunk = values.slice(i, i + chunkSize);
+          const filter = {
+            [field]: { $in: chunk },
+            ...extraFilter || {}
+          };
+          const options = {};
+          if (extraOptions?.sort) options.sort = extraOptions.sort;
+          if (extraOptions?.projection) options.projection = extraOptions.projection;
+          const { sql, params } = translator.translateFind(filter, options);
+          const rows = await this.db.query(sql, params);
+          allResults.push(...rows);
+        }
+        return allResults;
+      }
+      /** Validate an include spec, returning an error string or null if valid. */
+      _validateIncludeSpec(spec) {
+        if (!spec.model || typeof spec.model !== "string") {
+          return "include: 'model' is required";
+        }
+        try {
+          assertValidIdentifier(spec.model, "include model");
+        } catch {
+          return `include: invalid model name '${spec.model}'`;
+        }
+        if (spec.type !== "refersTo" && spec.type !== "hasMany" && spec.type !== "refersToMany") {
+          return `include: 'type' must be 'refersTo', 'hasMany', or 'refersToMany', got '${spec.type}'`;
+        }
+        if (spec.type === "refersTo") {
+          if (!spec.sourceField) {
+            return "include refersTo: 'sourceField' is required";
+          }
+          try {
+            assertValidIdentifier(spec.sourceField, "include sourceField");
+          } catch {
+            return `include refersTo: invalid sourceField '${spec.sourceField}'`;
+          }
+        }
+        if (spec.type === "refersToMany") {
+          if (!spec.sourceField) {
+            return "include refersToMany: 'sourceField' is required";
+          }
+          try {
+            assertValidIdentifier(spec.sourceField, "include sourceField");
+          } catch {
+            return `include refersToMany: invalid sourceField '${spec.sourceField}'`;
+          }
+        }
+        if (spec.type === "hasMany") {
+          if (!spec.foreignKey) {
+            return "include hasMany: 'foreignKey' is required";
+          }
+          try {
+            assertValidIdentifier(spec.foreignKey, "include foreignKey");
+          } catch {
+            return `include hasMany: invalid foreignKey '${spec.foreignKey}'`;
+          }
+          if (spec.localField) {
+            try {
+              assertValidIdentifier(spec.localField, "include localField");
+            } catch {
+              return `include hasMany: invalid localField '${spec.localField}'`;
+            }
+          }
+        }
+        if (spec.as) {
+          try {
+            assertValidIdentifier(spec.as, "include as");
+          } catch {
+            return `include: invalid alias '${spec.as}'`;
+          }
+        }
+        if (spec.sort) {
+          for (const field of Object.keys(spec.sort)) {
+            try {
+              assertValidIdentifier(field, "include sort field");
+            } catch {
+              return `include: invalid sort field '${field}'`;
+            }
+          }
+        }
+        return null;
+      }
+      /** Apply projection to a single record. */
+      _applyProjection(record, projection) {
+        const fields = Object.entries(projection);
+        if (fields.length === 0) return record;
+        const isInclusion = fields.some(([, v]) => v === 1);
+        if (isInclusion) {
+          const result = {};
+          if (record.id !== void 0) result.id = record.id;
+          if (record.type !== void 0) result.type = record.type;
+          if (record._related !== void 0) result._related = record._related;
+          for (const [f, v] of fields) {
+            if (v === 1 && record[f] !== void 0) {
+              result[f] = record[f];
+            }
+          }
+          return result;
+        } else {
+          const result = { ...record };
+          for (const [f, v] of fields) {
+            if (v === 0) delete result[f];
+          }
+          return result;
+        }
+      }
+    };
+  }
+});
+
 // src/models/BaseModel.ts
 var BaseModel_exports = {};
 __export(BaseModel_exports, {
@@ -3154,8 +3540,10 @@ var init_BaseModel = __esm({
         }
         const modelName = schema.options.name;
         Logger.verbose(`[${modelName}] Executing query:`, { filter, options });
+        const hasIncludes = options?.include && options.include.length > 0;
+        const translatorOptions = hasIncludes && options?.projection ? { ...options, projection: void 0 } : options;
         const translator = new DocumentQueryTranslator(modelName, schema.fields);
-        const translatedQuery = translator.translateFind(filter, options);
+        const translatedQuery = translator.translateFind(filter, translatorOptions);
         Logger.verbose(`[${modelName}] Translated SQL:`, translatedQuery.sql);
         Logger.verbose(`[${modelName}] SQL params:`, translatedQuery.params);
         const results = await _BaseModel.dbInstance.query(
@@ -3163,6 +3551,11 @@ var init_BaseModel = __esm({
           translatedQuery.params
         );
         Logger.verbose(`[${modelName}] Query returned ${results.length} results`);
+        if (options?.include && options.include.length > 0) {
+          const { IncludeResolver: IncludeResolver2 } = await Promise.resolve().then(() => (init_IncludeResolver(), IncludeResolver_exports));
+          const resolver = new IncludeResolver2(_BaseModel.dbInstance);
+          await resolver.resolve(results, options.include, 0, modelName);
+        }
         const requestedLimit = options?.limit;
         const hasMore = CursorManager.hasMoreResults(
           requestedLimit,
@@ -3188,6 +3581,7 @@ var init_BaseModel = __esm({
                 projected[field] = row[field];
               }
             }
+            if (row._related) projected._related = row._related;
             return projected;
           });
         } else {
@@ -3219,6 +3613,7 @@ var init_BaseModel = __esm({
             if (instance && typeof instance === "object" && instance instanceof _BaseModel) {
               instance._metaDocId = foundDocId;
               instance._metaPermissionHint = "read-write";
+              if (data._related) instance._related = data._related;
             }
             return instance;
           }).filter(Boolean);
@@ -4223,536 +4618,877 @@ var init_BaseModel = __esm({
   }
 });
 
-// src/utils/environment.ts
-function detectEnvironment() {
-  if (typeof process !== "undefined" && process.versions && process.versions.node) {
-    return "node";
-  }
-  if (typeof window !== "undefined" && typeof document !== "undefined") {
-    return "browser";
-  }
-  if (typeof self !== "undefined" && typeof self.importScripts === "function") {
-    return "browser";
-  }
-  return "unknown";
-}
-function isNode() {
-  return detectEnvironment() === "node";
-}
-function isBrowser() {
-  return detectEnvironment() === "browser";
-}
-async function isNodeModuleAvailable(moduleName) {
-  if (!isNode()) {
-    return false;
-  }
-  try {
-    await import(
-      /* @vite-ignore */
-      moduleName
-    );
-    return true;
-  } catch {
-    return false;
-  }
+// src/models/relationshipManager.ts
+function generateRefersToMethod(_sourceModelClass, config, targetModelClass) {
+  return async function() {
+    const relatedId = this[config.relatedIdField];
+    if (relatedId === null || typeof relatedId === "undefined") return null;
+    return targetModelClass.find(relatedId);
+  };
 }
-var features;
-var init_environment = __esm({
-  "src/utils/environment.ts"() {
-    "use strict";
-    features = {
-      get hasWebWorkers() {
-        return isBrowser() && typeof Worker !== "undefined";
-      },
-      get hasFileSystem() {
-        return isNode();
-      },
-      get hasWebAssembly() {
-        return typeof WebAssembly !== "undefined";
-      },
-      async hasBetterSqlite3() {
-        return await isNodeModuleAvailable("better-sqlite3");
-      }
+function generateHasManyMethod(_sourceModelClass, config, targetModelClass, _dbEngine) {
+  return async function(paginationArgs) {
+    const {
+      limit,
+      afterCursor,
+      beforeCursor,
+      direction = "forward"
+    } = paginationArgs || {};
+    const {
+      relatedIdField,
+      orderByField = "id",
+      orderDirection = "ASC"
+    } = config;
+    const targetSchema = targetModelClass.getSchema();
+    if (!targetSchema || !targetSchema.options || !targetSchema.options.name) {
+      Logger.error(
+        `[RelationshipManager] Target model ${targetModelClass.name} for hasMany relationship has no valid schema name.`
+      );
+      return { data: [], nextCursor: null, prevCursor: null };
+    }
+    const filter = { [relatedIdField]: this.id };
+    const queryOptions = {
+      sort: { [orderByField]: orderDirection === "ASC" ? 1 : -1 }
     };
-  }
-});
-
-// src/engines/SqljsEngine.ts
-var import_sql3, import_async_mutex, SQL_WASM_URL, TransactionalSQLJSOperations, SqljsEngine;
-var init_SqljsEngine = __esm({
-  "src/engines/SqljsEngine.ts"() {
-    "use strict";
-    import_sql3 = __toESM(require("sql.js"), 1);
-    init_BaseModel();
-    import_async_mutex = require("async-mutex");
-    init_sql();
-    SQL_WASM_URL = "/sql-wasm.wasm";
-    TransactionalSQLJSOperations = class {
-      db;
-      engine;
-      // For helper methods, changed type to SqljsEngine
-      constructor(db, engine) {
-        this.db = db;
-        this.engine = engine;
-      }
-      async insert(modelName, data) {
-        if (!this.db) throw new Error("SQL.js DB not available in transaction");
-        const tableName = this.engine.getTableName(modelName);
-        const quotedTableName = quoteIdentifier(tableName);
-        const columns = Object.keys(data);
-        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(
-          ", "
-        )}) VALUES (${placeholders});`;
-        this.db.run(insertSQL, values);
-      }
-      async delete(modelName, id) {
-        if (!this.db) throw new Error("SQL.js DB not available in transaction");
-        const tableName = this.engine.getTableName(modelName);
-        const deleteSQL = `DELETE FROM ${quoteIdentifier(tableName)} WHERE ${quoteIdentifier(
-          "id"
-        )} = ?;`;
-        this.db.run(deleteSQL, [id]);
+    if (limit !== void 0) {
+      queryOptions.limit = limit + 1;
+    }
+    if (direction === "forward" && afterCursor) {
+      filter[orderByField] = {
+        [orderDirection === "ASC" ? "$gt" : "$lt"]: afterCursor
+      };
+    } else if (direction === "backward") {
+      if (beforeCursor) {
+        filter[orderByField] = {
+          [orderDirection === "ASC" ? "$lt" : "$gt"]: beforeCursor
+        };
       }
-      async query(sql, params) {
-        if (!this.db) throw new Error("SQL.js DB not available in transaction");
-        const results = [];
-        const stmt = this.db.prepare(sql);
-        if (params) {
-          stmt.bind(params);
-        }
-        while (stmt.step()) {
-          results.push(stmt.getAsObject());
-        }
-        stmt.free();
-        return results;
+      queryOptions.sort = { [orderByField]: orderDirection === "ASC" ? -1 : 1 };
+    }
+    const result = await targetModelClass.query(filter, queryOptions);
+    const results = result.data;
+    let nextCursor = null;
+    let prevCursor = null;
+    const isFirstPage = direction === "forward" && !afterCursor;
+    if (limit !== void 0) {
+      if (direction === "forward") {
+        if (results.length > limit) {
+          nextCursor = results[limit - 1][orderByField];
+          results.pop();
+        }
+        if (results.length > 0 && !isFirstPage) {
+          prevCursor = results[0][orderByField];
+        }
+      } else {
+        if (results.length > limit) {
+          prevCursor = results[limit - 1][orderByField];
+          results.pop();
+        }
+        results.reverse();
+        if (results.length > 0 && beforeCursor) {
+          nextCursor = results[results.length - 1][orderByField];
+        }
+        if (results.length > 0 && !beforeCursor) {
+          if (results.length === limit) {
+            prevCursor = results[0][orderByField];
+          }
+        }
       }
+    }
+    return { data: results, nextCursor, prevCursor };
+  };
+}
+function generateHasManyThroughMethod(_sourceModelClass, config, targetModelClass, joinModelClass, _dbEngine) {
+  return async function(paginationArgs) {
+    const {
+      limit,
+      afterCursor,
+      beforeCursor,
+      direction = "forward"
+    } = paginationArgs || {};
+    const joinSchema = joinModelClass.getSchema();
+    const targetSchema = targetModelClass.getSchema();
+    if (!joinSchema || !joinSchema.options || !joinSchema.options.name) {
+      Logger.error(
+        `[RelationshipManager] Join model ${joinModelClass.name} for hasManyThrough relationship has no valid schema name.`
+      );
+      return { data: [], nextCursor: null, prevCursor: null };
+    }
+    if (!targetSchema || !targetSchema.options || !targetSchema.options.name) {
+      Logger.error(
+        `[RelationshipManager] Target model ${targetModelClass.name} for hasManyThrough relationship has no valid schema name.`
+      );
+      return { data: [], nextCursor: null, prevCursor: null };
+    }
+    const {
+      joinModelLocalField,
+      joinModelRelatedField,
+      joinModelOrderByField = "id",
+      joinModelOrderDirection = "ASC"
+    } = config;
+    const joinFilter = { [joinModelLocalField]: this.id };
+    const joinQueryOptions = {
+      sort: {
+        [joinModelOrderByField]: joinModelOrderDirection === "ASC" ? 1 : -1
+      },
+      projection: { [joinModelRelatedField]: 1, [joinModelOrderByField]: 1 }
     };
-    SqljsEngine = class _SqljsEngine {
-      static SQL = null;
-      db = null;
-      tableNames = /* @__PURE__ */ new Set();
-      numOpenTransactions = 0;
-      mutex = new import_async_mutex.Mutex();
-      readyPromise;
-      constructor(options) {
-        Logger.debug("[SqljsEngine] Constructor called. Initializing...");
-        this.numOpenTransactions = 0;
-        this.readyPromise = this.initialize(options);
-      }
-      // Make readyPromise accessible if DatabaseFactory wants to await it,
-      // though direct call to initialize from constructor and awaiting it is simpler here.
-      async ensureReady() {
-        return this.readyPromise;
+    if (limit !== void 0) {
+      joinQueryOptions.limit = limit + 1;
+    }
+    if (direction === "forward" && afterCursor) {
+      joinFilter[joinModelOrderByField] = {
+        [joinModelOrderDirection === "ASC" ? "$gt" : "$lt"]: afterCursor
+      };
+    } else if (direction === "backward") {
+      if (beforeCursor) {
+        joinFilter[joinModelOrderByField] = {
+          [joinModelOrderDirection === "ASC" ? "$lt" : "$gt"]: beforeCursor
+        };
       }
-      async initialize(engineOptions) {
-        Logger.info("[SqljsEngine] Initializing SQL.js engine...");
-        try {
-          if (!_SqljsEngine.SQL) {
-            const locateFileConfig = engineOptions?.locateFile || ((_file) => engineOptions?.wasmURL || SQL_WASM_URL);
-            Logger.debug(
-              "[SqljsEngine] Attempting to load SQL.js WASM from:",
-              locateFileConfig("sql-wasm.wasm")
-            );
-            _SqljsEngine.SQL = await (0, import_sql3.default)({
-              locateFile: locateFileConfig
-            });
-            Logger.info("[SqljsEngine] SQL.js WASM loaded successfully.");
+      joinQueryOptions.sort = {
+        [joinModelOrderByField]: joinModelOrderDirection === "ASC" ? -1 : 1
+      };
+    }
+    const joinResult = await joinModelClass.query(
+      joinFilter,
+      joinQueryOptions
+    );
+    const joinResults = joinResult.data;
+    let nextCursorFromJoin = null;
+    let prevCursorFromJoin = null;
+    const isFirstPage = direction === "forward" && !afterCursor;
+    if (limit !== void 0) {
+      if (direction === "forward") {
+        if (joinResults.length > limit) {
+          nextCursorFromJoin = joinResults[limit - 1][joinModelOrderByField];
+          joinResults.pop();
+        }
+        if (joinResults.length > 0 && !isFirstPage) {
+          prevCursorFromJoin = joinResults[0][joinModelOrderByField];
+        }
+      } else {
+        if (joinResults.length > limit) {
+          prevCursorFromJoin = joinResults[limit - 1][joinModelOrderByField];
+          joinResults.pop();
+        }
+        joinResults.reverse();
+        if (joinResults.length > 0 && beforeCursor) {
+          nextCursorFromJoin = joinResults[joinResults.length - 1][joinModelOrderByField];
+        }
+        if (joinResults.length > 0 && !beforeCursor) {
+          if (joinResults.length === limit) {
+            prevCursorFromJoin = joinResults[0][joinModelOrderByField];
           }
-          this.db = new _SqljsEngine.SQL.Database();
-          Logger.info("[SqljsEngine] SQL.js Database initialized in memory.");
-          this.updateTableNames();
-        } catch (error) {
-          Logger.error("[SqljsEngine] Error during SQL.js initialization:", error);
-          throw error;
         }
       }
-      updateTableNames() {
-        if (!this.db) return;
-        const results = this.db.exec(
-          "SELECT name FROM sqlite_master WHERE type='table';"
-        );
-        this.tableNames.clear();
-        if (results.length > 0 && results[0].values) {
-          results[0].values.forEach(
-            (row) => this.tableNames.add(row[0])
-          );
+    }
+    const relatedIds = joinResults.map((r) => r[joinModelRelatedField]).filter((id) => id != null && typeof id === "string");
+    if (relatedIds.length === 0)
+      return { data: [], nextCursor: null, prevCursor: null };
+    const targetResult = await targetModelClass.query({
+      id: { $in: relatedIds }
+    });
+    return {
+      data: targetResult.data,
+      nextCursor: nextCursorFromJoin,
+      prevCursor: prevCursorFromJoin
+    };
+  };
+}
+function generateHasManyThroughAddMethod(_sourceModelClass, config, _targetModelClass, joinModelClass) {
+  return async function(targetInstanceOrId) {
+    const targetId = typeof targetInstanceOrId === "string" ? targetInstanceOrId : targetInstanceOrId.id;
+    if (!targetId) {
+      Logger.error("[RelationshipManager.add] Target ID is missing.");
+      throw new Error("Target ID is missing for add operation.");
+    }
+    const joinData = {};
+    joinData[config.joinModelLocalField] = this.id;
+    joinData[config.joinModelRelatedField] = targetId;
+    let yDoc = null;
+    let targetDocId = null;
+    const sourceModelConstructor = this.constructor;
+    const connectedDocuments = sourceModelConstructor.connectedDocuments;
+    if (this._metaDocId && connectedDocuments) {
+      targetDocId = this._metaDocId;
+      if (targetDocId) {
+        const documentInfo = connectedDocuments.get(targetDocId);
+        if (documentInfo) {
+          yDoc = documentInfo.yDoc;
         }
       }
-      getTableName(modelName) {
-        return `model_${modelName.toLowerCase()}`;
+    }
+    if (!yDoc) {
+      const legacyDocId = "__legacy_default__";
+      const legacyDocInfo = joinModelClass.connectedDocuments?.get(
+        legacyDocId
+      );
+      if (legacyDocInfo) {
+        yDoc = legacyDocInfo.yDoc;
       }
-      mapTypeToSQL(type) {
-        switch (type.toLowerCase()) {
-          case "string":
-            return "TEXT";
-          case "number":
-            return "REAL";
-          case "boolean":
-            return "INTEGER";
-          case "date":
-            return "TEXT";
-          default:
-            return "TEXT";
+    }
+    if (!yDoc) {
+      throw new Error(
+        `[${joinModelClass.name}] No Y.Doc is connected for this join model. Connect a document via initJsBao(...).connectDocument or call initializeForDocument(yDoc, db, docId, permissionHint) before managing relationships.`
+      );
+    }
+    await yDoc.transact(async () => {
+      const newJoinInstance = new joinModelClass(joinData);
+      if (targetDocId) {
+        await newJoinInstance.save({ targetDocument: targetDocId });
+      } else {
+        await newJoinInstance.save();
+      }
+      Logger.debug(
+        `[RelationshipManager.add] Created join entry in ${config.joinModel}:`,
+        newJoinInstance.toJSON()
+      );
+    }, `add-join-${config.joinModel}-${this.id}-${targetId}`);
+  };
+}
+function generateHasManyThroughRemoveMethod(_sourceModelClass, config, _targetModelClass, joinModelClass) {
+  return async function(targetInstanceOrId) {
+    const targetId = typeof targetInstanceOrId === "string" ? targetInstanceOrId : targetInstanceOrId.id;
+    if (!targetId) {
+      Logger.error("[RelationshipManager.remove] Target ID is missing.");
+      throw new Error("Target ID is missing for remove operation.");
+    }
+    let yDoc = null;
+    let targetDocId = null;
+    const sourceModelConstructor = this.constructor;
+    const connectedDocuments = sourceModelConstructor.connectedDocuments;
+    if (this._metaDocId && connectedDocuments) {
+      targetDocId = this._metaDocId;
+      if (targetDocId) {
+        const documentInfo = connectedDocuments.get(targetDocId);
+        if (documentInfo) {
+          yDoc = documentInfo.yDoc;
         }
       }
-      async createTable(modelName, schema, _options) {
-        await this.readyPromise;
-        if (!this.db) throw new Error("SQL.js not initialized for createTable");
-        const tableName = this.getTableName(modelName);
-        const quotedTableName = quoteIdentifier(tableName);
-        const idColumn = quoteIdentifier("id");
-        const typeColumn = quoteIdentifier("type");
-        if (this.tableNames.has(tableName)) {
-          return;
+    }
+    if (!yDoc) {
+      const legacyDocId = "__legacy_default__";
+      const legacyDocInfo = joinModelClass.connectedDocuments?.get(
+        legacyDocId
+      );
+      if (legacyDocInfo) {
+        yDoc = legacyDocInfo.yDoc;
+      }
+    }
+    if (!yDoc) {
+      throw new Error(
+        `[${joinModelClass.name}] No Y.Doc is connected for this join model. Connect a document via initJsBao(...).connectDocument or call initializeForDocument(yDoc, db, docId, permissionHint) before managing relationships.`
+      );
+    }
+    await yDoc.transact(async () => {
+      const joinRecordsResult = await joinModelClass.query(
+        {
+          [config.joinModelLocalField]: this.id,
+          [config.joinModelRelatedField]: targetId
+        },
+        {
+          limit: 1,
+          projection: { id: 1 }
         }
-        const columns = Array.from(schema.entries()).filter(([field]) => field !== "id" && field !== "type").map(
-          ([field, fieldOptions]) => `${quoteIdentifier(field)} ${this.mapTypeToSQL(fieldOptions.type)}`
-        );
-        const metadataColumns = [
-          `${quoteIdentifier("_meta_doc_id")} TEXT`,
-          `${quoteIdentifier("_meta_permission_hint")} TEXT`
-        ];
-        const createTableSQL = `CREATE TABLE IF NOT EXISTS ${quotedTableName} (
-      ${idColumn} TEXT PRIMARY KEY, 
-      ${typeColumn} TEXT, 
-      ${columns.join(", ")}${columns.length > 0 ? ", " : ""}${metadataColumns.join(", ")}
-    );`;
-        this.db.run(createTableSQL);
-        for (const [field, fieldOptions] of schema.entries()) {
-          if (fieldOptions && fieldOptions.indexed && field !== "id") {
-            const indexName = `idx_${tableName}_${field}`;
-            const createIndexSQL = `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(
-              indexName
-            )} ON ${quotedTableName} (${quoteIdentifier(field)});`;
-            this.db.run(createIndexSQL);
+      );
+      if (joinRecordsResult.data.length > 0) {
+        for (const record of joinRecordsResult.data) {
+          const instanceToDelete = await joinModelClass.find(
+            record.id
+          );
+          if (instanceToDelete) {
+            await instanceToDelete.delete();
+            Logger.debug(
+              `[RelationshipManager.remove] Deleted join entry from ${config.joinModel} with ID: ${record.id}`
+            );
+          } else {
+            Logger.warn(
+              `[RelationshipManager.remove] Join entry with ID ${record.id} found by query but not in YMap for deletion.`
+            );
           }
         }
-        const docIdIndexName = `idx_${tableName}_meta_doc_id`;
-        const docIdIndexSQL = `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(
-          docIdIndexName
-        )} ON ${quotedTableName} (${quoteIdentifier("_meta_doc_id")});`;
-        this.db.run(docIdIndexSQL);
-        this.updateTableNames();
+      } else {
+        Logger.debug(
+          `[RelationshipManager.remove] No join entry found in ${config.joinModel} for localId: ${this.id}, relatedId: ${targetId}. No action taken.`
+        );
       }
-      async createStringSetJunctionTable(modelName, fieldName) {
-        await this.readyPromise;
-        if (!this.db)
+    }, `remove-join-${config.joinModel}-${this.id}-${targetId}`);
+  };
+}
+var init_relationshipManager = __esm({
+  "src/models/relationshipManager.ts"() {
+    "use strict";
+    init_BaseModel();
+  }
+});
+
+// src/models/ModelRegistry.ts
+var ModelRegistry;
+var init_ModelRegistry = __esm({
+  "src/models/ModelRegistry.ts"() {
+    "use strict";
+    init_BaseModel();
+    init_relationshipManager();
+    ModelRegistry = class _ModelRegistry {
+      static instance;
+      // Stores globally registered model classes by their name (from @Model decorator)
+      models = /* @__PURE__ */ new Map();
+      // Stores options for globally registered models (from @Model decorator)
+      modelOptions = /* @__PURE__ */ new Map();
+      // Stores fields for globally registered models (from @Model decorator, 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
+      activeSessionModels = null;
+      dbEngine = null;
+      // Store dbEngine for relationship methods
+      constructor() {
+      }
+      static getInstance() {
+        if (!_ModelRegistry.instance) {
+          _ModelRegistry.instance = new _ModelRegistry();
+        }
+        return _ModelRegistry.instance;
+      }
+      registerModel(modelClass, options, fields) {
+        if (!options.name) {
           throw new Error(
-            "SQL.js not initialized for createStringSetJunctionTable"
+            `[ModelRegistry] Model class is missing a name in its @Model options. Ensure the @Model decorator includes a 'name' property.`
           );
-        const junctionTableName = `${this.getTableName(modelName)}_${fieldName}`;
-        const quotedJunctionTable = quoteIdentifier(junctionTableName);
-        const foreignKeyColumn = `${modelName.toLowerCase()}_id`;
-        const quotedForeignKey = quoteIdentifier(foreignKeyColumn);
-        const quotedIdColumn = quoteIdentifier("id");
-        const quotedValueColumn = quoteIdentifier("value");
-        if (this.tableNames.has(junctionTableName)) {
-          Logger.debug(
-            `[SqljsEngine] StringSet junction table ${junctionTableName} already exists, skipping creation.`
+        }
+        if (this.models.has(options.name)) {
+          console.warn(
+            `[ModelRegistry] Model "${options.name}" is already registered. Overwriting.`
           );
-          return;
         }
-        const createTableSQL = `CREATE TABLE IF NOT EXISTS ${quotedJunctionTable} (
-      ${quotedIdColumn} TEXT PRIMARY KEY,
-      ${quotedForeignKey} TEXT NOT NULL,
-      ${quotedValueColumn} TEXT NOT NULL,
-      UNIQUE(${quotedForeignKey}, ${quotedValueColumn})
-    );`;
-        Logger.info(
-          `[SqljsEngine] Creating StringSet junction table ${junctionTableName} for ${modelName}.${fieldName}`
-        );
-        this.db.run(createTableSQL);
-        const indexName = `idx_${junctionTableName}_${modelName.toLowerCase()}_id_value`;
-        const indexSQL = `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(
-          indexName
-        )} ON ${quotedJunctionTable} (${quotedForeignKey}, ${quotedValueColumn});`;
-        this.db.run(indexSQL);
-        this.updateTableNames();
-        Logger.info(
-          `[SqljsEngine] StringSet junction table ${junctionTableName} created successfully.`
+        this.models.set(options.name, modelClass);
+        if (fields) {
+          BaseModel.attachFieldAccessors(modelClass, fields);
+        }
+        this.modelOptions.set(options.name, options);
+        console.log(
+          `[ModelRegistry] Model "${options.name}" registered successfully.`
         );
       }
-      async insertStringSetValues(modelName, fieldName, recordId, values) {
-        await this.readyPromise;
-        if (!this.db)
-          throw new Error("SQL.js not initialized for insertStringSetValues");
-        if (values.length === 0) return;
-        const junctionTableName = `${this.getTableName(modelName)}_${fieldName}`;
-        const modelIdColumn = `${modelName.toLowerCase()}_id`;
-        const quotedJunctionTable = quoteIdentifier(junctionTableName);
-        const quotedIdColumn = quoteIdentifier("id");
-        const quotedModelIdColumn = quoteIdentifier(modelIdColumn);
-        const quotedValueColumn = quoteIdentifier("value");
-        for (const value of values) {
-          const insertSQL = `INSERT OR IGNORE INTO ${quotedJunctionTable} (${quotedIdColumn}, ${quotedModelIdColumn}, ${quotedValueColumn}) VALUES (?, ?, ?);`;
-          const junctionId = `${recordId}_${value}`;
-          this.db.run(insertSQL, [junctionId, recordId, value]);
-        }
+      // Gets the class for a globally registered model
+      getModelClass(name) {
+        return this.models.get(name);
       }
-      async removeStringSetValues(modelName, fieldName, recordId, values) {
-        await this.readyPromise;
-        if (!this.db)
-          throw new Error("SQL.js not initialized for removeStringSetValues");
-        if (values.length === 0) return;
-        const junctionTableName = `${this.getTableName(modelName)}_${fieldName}`;
-        const modelIdColumn = `${modelName.toLowerCase()}_id`;
-        const quotedJunctionTable = quoteIdentifier(junctionTableName);
-        const quotedModelIdColumn = quoteIdentifier(modelIdColumn);
-        const quotedValueColumn = quoteIdentifier("value");
-        for (const value of values) {
-          const deleteSQL = `DELETE FROM ${quotedJunctionTable} WHERE ${quotedModelIdColumn} = ? AND ${quotedValueColumn} = ?;`;
-          this.db.run(deleteSQL, [recordId, value]);
+      getModelOptions(name) {
+        return this.modelOptions.get(name);
+      }
+      // This method might need to be adapted based on how fields are ultimately managed
+      getModelInfo(modelName) {
+        const modelClass = this.models.get(modelName);
+        const options = this.modelOptions.get(modelName);
+        if (modelClass && options) {
+          const fields = modelClass.getSchema ? modelClass.getSchema().fields : /* @__PURE__ */ new Map();
+          return { class: modelClass, options, fields };
         }
+        return void 0;
       }
-      async insert(modelName, data) {
-        await this.readyPromise;
-        if (!this.db) throw new Error("SQL.js not initialized for insert");
-        const tableName = this.getTableName(modelName);
-        const quotedTableName = quoteIdentifier(tableName);
-        const columns = Object.keys(data);
-        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(
-          ", "
-        )}) VALUES (${placeholders});`;
-        this.db.run(insertSQL, values);
+      getAllRegisteredModelsInfo() {
+        const infos = [];
+        for (const modelName of this.models.keys()) {
+          const info = this.getModelInfo(modelName);
+          if (info) {
+            infos.push(info);
+          }
+        }
+        return infos;
       }
-      async delete(modelName, id) {
-        await this.readyPromise;
-        if (!this.db) throw new Error("SQL.js not initialized for delete");
-        const tableName = this.getTableName(modelName);
-        const deleteSQL = `DELETE FROM ${quoteIdentifier(tableName)} WHERE ${quoteIdentifier(
-          "id"
-        )} = ?;`;
-        this.db.run(deleteSQL, [id]);
+      // Helper to get model name from class (assuming static property from @Model decorator)
+      getModelNameFromClass(modelClass) {
+        return modelClass.modelName;
       }
-      async deleteByDocumentId(modelName, docId) {
-        await this.readyPromise;
-        if (!this.db)
-          throw new Error("SQL.js not initialized for deleteByDocumentId");
-        const tableName = this.getTableName(modelName);
-        const quotedTableName = quoteIdentifier(tableName);
-        if (!this.tableNames.has(tableName)) {
-          Logger.debug(
-            `[SqljsEngine] Skipping deleteByDocumentId for ${tableName}; table does not exist.`
-          );
-          return;
-        }
-        const deleteSQL = `DELETE FROM ${quotedTableName} WHERE ${quoteIdentifier(
-          "_meta_doc_id"
-        )} = ?;`;
-        this.db.run(deleteSQL, [docId]);
-        for (const existingTableName of this.tableNames) {
-          if (existingTableName.startsWith(`${tableName}_`)) {
-            const quotedExistingTable = quoteIdentifier(existingTableName);
-            const quotedForeignKey = quoteIdentifier(`${modelName.toLowerCase()}_id`);
-            const junctionDeleteSQL = `DELETE FROM ${quotedExistingTable} WHERE ${quotedForeignKey} IN (
-          SELECT ${quoteIdentifier("id")} FROM ${quotedTableName} WHERE ${quoteIdentifier(
-              "_meta_doc_id"
-            )} = ?
-        );`;
-            try {
-              this.db.run(junctionDeleteSQL, [docId]);
-              const rowsCleared = this.db.getRowsModified();
-              Logger.info(
-                `[SqljsEngine] Cleared junction table ${existingTableName} for document ${docId}; removed ${rowsCleared} rows.`
+      setExplicitModelsForSession(modelClasses) {
+        if (modelClasses && modelClasses.length > 0) {
+          this.activeSessionModels = /* @__PURE__ */ new Map();
+          modelClasses.forEach((modelClass) => {
+            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.`
               );
-            } catch (error) {
-              Logger.warn(
-                `[SqljsEngine] Warning: Could not clean up junction table ${existingTableName}:`,
-                error
+              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.`
               );
+              return;
+            }
+            if (this.activeSessionModels) {
+              this.activeSessionModels.set(modelName, modelClass);
+            }
+          });
+          let sessionModelNamesMessage = "none (no models were successfully added or session map is null)";
+          if (this.activeSessionModels) {
+            const currentSessionModelKeys = Array.from(
+              this.activeSessionModels.keys()
+            );
+            if (currentSessionModelKeys.length > 0) {
+              sessionModelNamesMessage = currentSessionModelKeys.join(", ");
+            } else {
+              sessionModelNamesMessage = "none (session map initialized but no models added)";
             }
           }
+          Logger.debug(
+            `[ModelRegistry] Explicit models set for session: ${sessionModelNamesMessage}`
+          );
+        } else if (modelClasses && modelClasses.length === 0) {
+          this.activeSessionModels = /* @__PURE__ */ new Map();
+          Logger.debug(
+            "[ModelRegistry] Explicitly no models for session (empty array passed)."
+          );
+        } else {
+          this.activeSessionModels = null;
+          console.log(
+            "[ModelRegistry] No explicit models specified for session (undefined), will use all decorator-registered models."
+          );
         }
+        this.validateSessionModels();
       }
-      async query(sql, params) {
-        await this.readyPromise;
-        if (!this.db) throw new Error("SQL.js not initialized for query");
-        const results = [];
-        const stmt = this.db.prepare(sql);
-        if (params) {
-          stmt.bind(params);
+      async initializeAll(yDoc, dbEngine) {
+        Logger.debug("[ModelRegistry] Attempting to initialize models...");
+        this.dbEngine = dbEngine;
+        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)."
+          );
+          return;
         }
-        while (stmt.step()) {
-          results.push(stmt.getAsObject());
+        console.log(
+          `[ModelRegistry] Initializing models: ${Array.from(
+            modelsToInitialize.keys()
+          ).join(", ")}`
+        );
+        for (const [modelName, modelClass] of modelsToInitialize.entries()) {
+          if (modelClass && typeof modelClass.initialize === "function") {
+            Logger.debug(`[ModelRegistry] Initializing model: ${modelName}`);
+            await modelClass.initialize(yDoc, dbEngine);
+          } else {
+            const staticModelName = modelClass?.modelName || "unknown";
+            console.warn(
+              `[ModelRegistry] Model ${staticModelName} (class name: ${modelClass?.name}) does not have a static initialize method or class is not defined.`
+            );
+          }
         }
-        stmt.free();
-        return results;
+        Logger.debug("[ModelRegistry] Model initialization phase complete.");
       }
-      async withTransaction(callback) {
-        await this.readyPromise;
-        if (!this.db)
-          throw new Error("SQL.js Database instance not available for transaction");
-        let transactionStartedHere = false;
-        await this.mutex.runExclusive(async () => {
-          if (this.numOpenTransactions === 0) {
-            if (!this.db) throw new Error("SQL.js DB not available for BEGIN");
-            this.db.run("BEGIN TRANSACTION");
-            transactionStartedHere = true;
-          }
-          this.numOpenTransactions++;
-        });
-        const transactionalOps = new TransactionalSQLJSOperations(this.db, this);
-        try {
-          const result = await callback(transactionalOps);
-          await this.mutex.runExclusive(async () => {
-            this.numOpenTransactions--;
-            if (this.numOpenTransactions === 0) {
-              if (!this.db) throw new Error("SQL.js DB not available for COMMIT");
-              this.db.run("COMMIT");
+      // New method to initialize models for a specific document
+      async initializeAllForDocument(yDoc, dbEngine, docId, permissionHint) {
+        Logger.debug(
+          `[ModelRegistry] Initializing models for document ${docId}...`
+        );
+        this.dbEngine = dbEngine;
+        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)."
+          );
+          return;
+        }
+        Logger.debug(
+          `[ModelRegistry] Initializing models for document ${docId}: ${Array.from(
+            modelsToInitialize.keys()
+          ).join(", ")}`
+        );
+        for (const [modelName, modelClass] of modelsToInitialize.entries()) {
+          if (modelClass && typeof modelClass.initializeForDocument === "function") {
+            Logger.debug(
+              `[ModelRegistry] Initializing model ${modelName} for document ${docId}`
+            );
+            await modelClass.initializeForDocument(
+              yDoc,
+              dbEngine,
+              docId,
+              permissionHint
+            );
+          } else {
+            const staticModelName = modelClass?.modelName || "unknown";
+            console.warn(
+              `[ModelRegistry] Model ${staticModelName} (class name: ${modelClass?.name}) does not have a static initializeForDocument method or class is not defined.`
+            );
+          }
+        }
+        await this.initializeRelationships();
+        Logger.debug(
+          `[ModelRegistry] Model initialization complete for document ${docId}`
+        );
+      }
+      // New method to remove data from a disconnected document
+      async removeDocumentData(docId, dbEngine) {
+        Logger.debug(`[ModelRegistry] Removing data for document ${docId}...`);
+        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)."
+          );
+          return;
+        }
+        for (const [modelName, modelClass] of modelsToCleanup.entries()) {
+          try {
+            Logger.debug(
+              `[ModelRegistry] Removing ${modelName} data for document ${docId}`
+            );
+            await dbEngine.deleteByDocumentId(modelName, docId);
+            if (modelClass && typeof modelClass.cleanupDocumentData === "function") {
+              await modelClass.cleanupDocumentData(docId);
             }
-          });
-          return result;
-        } catch (error) {
-          Logger.error("[SqljsEngine] Error in transaction, rolling back:", error);
-          await this.mutex.runExclusive(async () => {
-            if (this.db && this.numOpenTransactions > 0 && transactionStartedHere) {
-              try {
-                if (!this.db)
-                  throw new Error("SQL.js DB not available for ROLLBACK");
-                this.db.run("ROLLBACK");
-              } catch (rollbackError) {
-                Logger.error("[SqljsEngine] Error during ROLLBACK:", rollbackError);
+          } catch (error) {
+            console.error(
+              `[ModelRegistry] Error removing ${modelName} data for document ${docId}:`,
+              error
+            );
+          }
+        }
+        Logger.debug(`[ModelRegistry] Data removal complete for document ${docId}`);
+      }
+      // New method to initialize relationships
+      async initializeRelationships() {
+        if (!this.dbEngine) {
+          console.error(
+            "[ModelRegistry] DB engine not available for initializing relationships. Ensure initializeAll has been called."
+          );
+          return;
+        }
+        const dbEngine = this.dbEngine;
+        Logger.debug(
+          "[ModelRegistry] Initializing relationships for active models..."
+        );
+        const activeModels = this.getActiveModels();
+        for (const [modelName, modelClass] of activeModels.entries()) {
+          const modelSchema = modelClass.getSchema ? modelClass.getSchema() : null;
+          const relationshipsConfig = modelSchema?.options?.relationships;
+          if (relationshipsConfig) {
+            Logger.debug(
+              `[ModelRegistry] Setting up relationships for ${modelName}`
+            );
+            for (const relName in relationshipsConfig) {
+              const config = relationshipsConfig[relName];
+              if (!config.model) {
+                throw new Error(
+                  `[ModelRegistry] Relationship "${relName}" on model "${modelName}" is missing a target model name.`
+                );
+              }
+              const targetModelClass = this.getModelClass(config.model);
+              if (!targetModelClass) {
+                throw new Error(
+                  `[ModelRegistry] Relationship "${relName}" on model "${modelName}" refers to an unknown model "${config.model}". Ensure "${config.model}" is registered and included in the session.`
+                );
+              }
+              if (typeof targetModelClass.getSchema !== "function") {
+                throw new Error(
+                  `[ModelRegistry] Target model "${config.model}" for relationship "${relName}" on "${modelName}" does not have a getSchema method.`
+                );
+              }
+              switch (config.type) {
+                case "refersTo":
+                  Logger.debug(
+                    `   - Adding '${relName}' (refersTo ${config.model}) to ${modelName}`
+                  );
+                  const refersToMethod = generateRefersToMethod(
+                    modelClass,
+                    config,
+                    targetModelClass
+                  );
+                  this.addPrototypeMethod(modelClass, relName, refersToMethod);
+                  break;
+                case "hasMany":
+                  Logger.debug(
+                    `   - Adding '${relName}' (hasMany ${config.model}) to ${modelName}`
+                  );
+                  const hasManyMethod = generateHasManyMethod(
+                    modelClass,
+                    config,
+                    targetModelClass,
+                    dbEngine
+                  );
+                  this.addPrototypeMethod(modelClass, relName, hasManyMethod);
+                  break;
+                case "hasManyThrough":
+                  const joinModelName = config.joinModel;
+                  const joinModelClass = this.getModelClass(joinModelName);
+                  if (!joinModelClass) {
+                    throw new Error(
+                      `[ModelRegistry] Join model "${joinModelName}" for relationship "${relName}" on model "${modelName}" not found. Ensure it is registered and included in the session.`
+                    );
+                  }
+                  if (typeof joinModelClass.getSchema !== "function") {
+                    throw new Error(
+                      `[ModelRegistry] Join model "${joinModelName}" for relationship "${relName}" on "${modelName}" does not have a getSchema method.`
+                    );
+                  }
+                  Logger.debug(
+                    `   - Adding '${relName}' (hasManyThrough ${config.model} via ${joinModelName}) to ${modelName}`
+                  );
+                  const hasManyThroughFetchMethod = generateHasManyThroughMethod(
+                    modelClass,
+                    config,
+                    targetModelClass,
+                    joinModelClass,
+                    dbEngine
+                  );
+                  this.addPrototypeMethod(
+                    modelClass,
+                    relName,
+                    hasManyThroughFetchMethod
+                  );
+                  const relNameSingular = config.model.endsWith("s") ? config.model.slice(0, -1) : config.model;
+                  const capitalizedSingularRelName = relNameSingular.charAt(0).toUpperCase() + relNameSingular.slice(1);
+                  const addMethodName = `add${capitalizedSingularRelName}`;
+                  const addMethodLogic = generateHasManyThroughAddMethod(
+                    modelClass,
+                    config,
+                    targetModelClass,
+                    joinModelClass
+                  );
+                  this.addPrototypeMethod(
+                    modelClass,
+                    addMethodName,
+                    addMethodLogic
+                  );
+                  Logger.debug(
+                    `   - Adding '${addMethodName}' helper to ${modelName} (for relationship ${relName})`
+                  );
+                  const removeMethodName = `remove${capitalizedSingularRelName}`;
+                  const removeMethodLogic = generateHasManyThroughRemoveMethod(
+                    modelClass,
+                    config,
+                    targetModelClass,
+                    joinModelClass
+                  );
+                  this.addPrototypeMethod(
+                    modelClass,
+                    removeMethodName,
+                    removeMethodLogic
+                  );
+                  Logger.debug(
+                    `   - Adding '${removeMethodName}' helper to ${modelName} (for relationship ${relName})`
+                  );
+                  break;
+                default:
+                  console.warn(
+                    `[ModelRegistry] Unknown relationship type "${config.type}" for ${relName} on ${modelName}. Skipping.`
+                  );
               }
             }
-            this.numOpenTransactions = 0;
-          });
-          throw error;
+          }
         }
+        Logger.debug("[ModelRegistry] Relationship initialization phase complete.");
       }
-      async close() {
-        await this.readyPromise;
-        if (this.db) {
-          this.db.close();
-          this.db = null;
-          _SqljsEngine.SQL = null;
-        }
+      // Helper to add methods to prototype
+      addPrototypeMethod(modelClass, methodName, methodLogic) {
+        Object.defineProperty(modelClass.prototype, methodName, {
+          value: methodLogic,
+          writable: true,
+          enumerable: false,
+          // Keep it clean, like other prototype methods
+          configurable: true
+        });
       }
-      async getTableSchema(_tableName) {
-        return void 0;
+      clearSessionState() {
+        this.activeSessionModels = null;
+        Logger.debug(
+          "[ModelRegistry] Session state cleared (activeSessionModels reset)."
+        );
       }
-      async destroy() {
-        if (this.db) {
-          this.db.close();
-          Logger.info("[SqljsEngine] Database closed.");
-        }
+      getActiveModels() {
+        return this.activeSessionModels || this.models;
       }
-      getLastErrorMessage() {
-        return void 0;
+      validateSessionModels() {
+        const activeModels = this.getActiveModels();
+        if (!activeModels || activeModels.size === 0) {
+          return;
+        }
+        for (const [modelName, modelClass] of activeModels.entries()) {
+          const modelSchema = modelClass.getSchema ? modelClass.getSchema() : null;
+          const relationships = modelSchema?.options?.relationships;
+          if (relationships) {
+            for (const relName in relationships) {
+              const config = relationships[relName];
+              const targetModelName = config.model;
+              if (!activeModels.has(targetModelName)) {
+                throw new Error(
+                  `[ModelRegistry] Validation Error: Model "${modelName}" has a relationship "${relName}" that refers to model "${targetModelName}", but "${targetModelName}" is not active in the current session. Please include it in the 'models' array during initialization.`
+                );
+              }
+              if (config.type === "hasManyThrough") {
+                const joinModelName = config.joinModel;
+                if (!activeModels.has(joinModelName)) {
+                  throw new Error(
+                    `[ModelRegistry] Validation Error: Model "${modelName}" has a relationship "${relName}" that uses join model "${joinModelName}", but "${joinModelName}" is not active in the current session. Please include it in the 'models' array during initialization.`
+                  );
+                }
+              }
+            }
+          }
+        }
       }
     };
   }
 });
 
-// src/engines/node/NodeSqliteEngine.ts
-var NodeSqliteEngine_exports = {};
-__export(NodeSqliteEngine_exports, {
-  NodeSqliteEngine: () => NodeSqliteEngine
+// src/utils/environment.ts
+function detectEnvironment() {
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    return "node";
+  }
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    return "browser";
+  }
+  if (typeof self !== "undefined" && typeof self.importScripts === "function") {
+    return "browser";
+  }
+  return "unknown";
+}
+function isNode() {
+  return detectEnvironment() === "node";
+}
+function isBrowser() {
+  return detectEnvironment() === "browser";
+}
+async function isNodeModuleAvailable(moduleName) {
+  if (!isNode()) {
+    return false;
+  }
+  try {
+    await import(
+      /* @vite-ignore */
+      moduleName
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+var features;
+var init_environment = __esm({
+  "src/utils/environment.ts"() {
+    "use strict";
+    features = {
+      get hasWebWorkers() {
+        return isBrowser() && typeof Worker !== "undefined";
+      },
+      get hasFileSystem() {
+        return isNode();
+      },
+      get hasWebAssembly() {
+        return typeof WebAssembly !== "undefined";
+      },
+      async hasBetterSqlite3() {
+        return await isNodeModuleAvailable("better-sqlite3");
+      }
+    };
+  }
 });
-var import_async_mutex2, TransactionalNodeSqliteOperations, NodeSqliteEngine;
-var init_NodeSqliteEngine = __esm({
-  "src/engines/node/NodeSqliteEngine.ts"() {
+
+// src/engines/SqljsEngine.ts
+var import_sql4, import_async_mutex, SQL_WASM_URL, TransactionalSQLJSOperations, SqljsEngine;
+var init_SqljsEngine = __esm({
+  "src/engines/SqljsEngine.ts"() {
     "use strict";
+    import_sql4 = __toESM(require("sql.js"), 1);
     init_BaseModel();
-    import_async_mutex2 = require("async-mutex");
+    import_async_mutex = require("async-mutex");
     init_sql();
-    TransactionalNodeSqliteOperations = class {
+    SQL_WASM_URL = "/sql-wasm.wasm";
+    TransactionalSQLJSOperations = class {
       db;
       engine;
+      // For helper methods, changed type to SqljsEngine
       constructor(db, engine) {
         this.db = db;
         this.engine = engine;
       }
       async insert(modelName, data) {
+        if (!this.db) throw new Error("SQL.js DB not available in transaction");
         const tableName = this.engine.getTableName(modelName);
+        const quotedTableName = quoteIdentifier(tableName);
         const columns = Object.keys(data);
+        const quotedColumns = columns.map((column) => quoteIdentifier(column));
         const placeholders = columns.map(() => "?").join(", ");
-        const values = Object.values(data).map((value) => {
-          if (typeof value === "boolean") {
-            return value ? 1 : 0;
-          }
-          return value;
-        });
-        const insertSQL = `INSERT OR REPLACE INTO ${tableName} (${columns.join(
+        const values = Object.values(data);
+        const insertSQL = `INSERT OR REPLACE INTO ${quotedTableName} (${quotedColumns.join(
           ", "
-        )}) VALUES (${placeholders})`;
-        const stmt = this.db.prepare(insertSQL);
-        stmt.run(...values);
+        )}) VALUES (${placeholders});`;
+        this.db.run(insertSQL, values);
       }
       async delete(modelName, id) {
+        if (!this.db) throw new Error("SQL.js DB not available in transaction");
         const tableName = this.engine.getTableName(modelName);
-        const deleteSQL = `DELETE FROM ${tableName} WHERE id = ?`;
-        const stmt = this.db.prepare(deleteSQL);
-        stmt.run(id);
+        const deleteSQL = `DELETE FROM ${quoteIdentifier(tableName)} WHERE ${quoteIdentifier(
+          "id"
+        )} = ?;`;
+        this.db.run(deleteSQL, [id]);
       }
       async query(sql, params) {
+        if (!this.db) throw new Error("SQL.js DB not available in transaction");
+        const results = [];
         const stmt = this.db.prepare(sql);
-        const results = params ? stmt.all(...params) : stmt.all();
+        if (params) {
+          stmt.bind(params);
+        }
+        while (stmt.step()) {
+          results.push(stmt.getAsObject());
+        }
+        stmt.free();
         return results;
       }
     };
-    NodeSqliteEngine = class {
+    SqljsEngine = class _SqljsEngine {
+      static SQL = null;
       db = null;
       tableNames = /* @__PURE__ */ new Set();
-      mutex = new import_async_mutex2.Mutex();
-      readyPromise;
-      betterSqlite3 = null;
       numOpenTransactions = 0;
+      mutex = new import_async_mutex.Mutex();
+      readyPromise;
       constructor(options) {
-        Logger.debug("[NodeSqliteEngine] Constructor called. Initializing...");
+        Logger.debug("[SqljsEngine] Constructor called. Initializing...");
+        this.numOpenTransactions = 0;
         this.readyPromise = this.initialize(options);
       }
+      // Make readyPromise accessible if DatabaseFactory wants to await it,
+      // though direct call to initialize from constructor and awaiting it is simpler here.
       async ensureReady() {
         return this.readyPromise;
       }
-      async initialize(options) {
-        Logger.info("[NodeSqliteEngine] Initializing Node.js SQLite engine...");
+      async initialize(engineOptions) {
+        Logger.info("[SqljsEngine] Initializing SQL.js engine...");
         try {
-          const betterSqlite3Module = await import("better-sqlite3");
-          this.betterSqlite3 = betterSqlite3Module.default || betterSqlite3Module;
-          const filePath = options?.filePath || ":memory:";
-          const dbOptions = options?.options || {};
-          Logger.debug(
-            `[NodeSqliteEngine] Opening SQLite database at: ${filePath}`
-          );
-          this.db = new this.betterSqlite3(filePath, dbOptions);
-          if (!this.db) {
-            throw new Error("Failed to create SQLite database instance");
-          }
-          if (filePath !== ":memory:") {
-            this.db.exec("PRAGMA journal_mode = WAL");
+          if (!_SqljsEngine.SQL) {
+            const locateFileConfig = engineOptions?.locateFile || ((_file) => engineOptions?.wasmURL || SQL_WASM_URL);
+            Logger.debug(
+              "[SqljsEngine] Attempting to load SQL.js WASM from:",
+              locateFileConfig("sql-wasm.wasm")
+            );
+            _SqljsEngine.SQL = await (0, import_sql4.default)({
+              locateFile: locateFileConfig
+            });
+            Logger.info("[SqljsEngine] SQL.js WASM loaded successfully.");
           }
-          Logger.info(
-            "[NodeSqliteEngine] SQLite database initialized successfully."
-          );
+          this.db = new _SqljsEngine.SQL.Database();
+          Logger.info("[SqljsEngine] SQL.js Database initialized in memory.");
           this.updateTableNames();
         } catch (error) {
-          Logger.error(
-            "[NodeSqliteEngine] Error during SQLite initialization:",
-            error
-          );
-          throw new Error(
-            `Failed to initialize Node.js SQLite engine: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
+          Logger.error("[SqljsEngine] Error during SQL.js initialization:", error);
+          throw error;
         }
       }
       updateTableNames() {
         if (!this.db) return;
-        const stmt = this.db.prepare(
-          "SELECT name FROM sqlite_master WHERE type='table'"
+        const results = this.db.exec(
+          "SELECT name FROM sqlite_master WHERE type='table';"
         );
-        const tables = stmt.all();
         this.tableNames.clear();
-        tables.forEach((table) => this.tableNames.add(table.name));
-        Logger.debug(
-          "[NodeSqliteEngine] Updated table names:",
-          Array.from(this.tableNames)
-        );
+        if (results.length > 0 && results[0].values) {
+          results[0].values.forEach(
+            (row) => this.tableNames.add(row[0])
+          );
+        }
       }
       getTableName(modelName) {
         return `model_${modelName.toLowerCase()}`;
@@ -4772,16 +5508,13 @@ var init_NodeSqliteEngine = __esm({
         }
       }
       async createTable(modelName, schema, _options) {
-        await this.ensureReady();
-        if (!this.db) throw new Error("SQLite not initialized for createTable");
+        await this.readyPromise;
+        if (!this.db) throw new Error("SQL.js not initialized for createTable");
         const tableName = this.getTableName(modelName);
         const quotedTableName = quoteIdentifier(tableName);
         const idColumn = quoteIdentifier("id");
         const typeColumn = quoteIdentifier("type");
         if (this.tableNames.has(tableName)) {
-          Logger.debug(
-            `[NodeSqliteEngine] Table ${tableName} already exists, skipping creation.`
-          );
           return;
         }
         const columns = Array.from(schema.entries()).filter(([field]) => field !== "id" && field !== "type").map(
@@ -4792,38 +5525,32 @@ var init_NodeSqliteEngine = __esm({
           `${quoteIdentifier("_meta_permission_hint")} TEXT`
         ];
         const createTableSQL = `CREATE TABLE IF NOT EXISTS ${quotedTableName} (
-      ${idColumn} TEXT PRIMARY KEY,
-      ${typeColumn} TEXT,
+      ${idColumn} TEXT PRIMARY KEY, 
+      ${typeColumn} TEXT, 
       ${columns.join(", ")}${columns.length > 0 ? ", " : ""}${metadataColumns.join(", ")}
-    )`;
-        Logger.debug(
-          `[NodeSqliteEngine] Creating table ${tableName}:`,
-          createTableSQL
-        );
-        this.db.exec(createTableSQL);
+    );`;
+        this.db.run(createTableSQL);
         for (const [field, fieldOptions] of schema.entries()) {
           if (fieldOptions && fieldOptions.indexed && field !== "id") {
             const indexName = `idx_${tableName}_${field}`;
-            const quotedIndexName = quoteIdentifier(indexName);
-            const quotedField = quoteIdentifier(field);
-            const createIndexSQL = `CREATE INDEX IF NOT EXISTS ${quotedIndexName} ON ${quotedTableName} (${quotedField})`;
-            Logger.debug(`[NodeSqliteEngine] Creating index ${indexName}`);
-            this.db.exec(createIndexSQL);
+            const createIndexSQL = `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(
+              indexName
+            )} ON ${quotedTableName} (${quoteIdentifier(field)});`;
+            this.db.run(createIndexSQL);
           }
         }
         const docIdIndexName = `idx_${tableName}_meta_doc_id`;
         const docIdIndexSQL = `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(
           docIdIndexName
-        )} ON ${quotedTableName} (${quoteIdentifier("_meta_doc_id")})`;
-        this.db.exec(docIdIndexSQL);
+        )} ON ${quotedTableName} (${quoteIdentifier("_meta_doc_id")});`;
+        this.db.run(docIdIndexSQL);
         this.updateTableNames();
-        Logger.info(`[NodeSqliteEngine] Table ${tableName} created successfully.`);
       }
       async createStringSetJunctionTable(modelName, fieldName) {
-        await this.ensureReady();
+        await this.readyPromise;
         if (!this.db)
           throw new Error(
-            "SQLite not initialized for createStringSetJunctionTable"
+            "SQL.js not initialized for createStringSetJunctionTable"
           );
         const junctionTableName = `${this.getTableName(modelName)}_${fieldName}`;
         const quotedJunctionTable = quoteIdentifier(junctionTableName);
@@ -4833,7 +5560,7 @@ var init_NodeSqliteEngine = __esm({
         const quotedValueColumn = quoteIdentifier("value");
         if (this.tableNames.has(junctionTableName)) {
           Logger.debug(
-            `[NodeSqliteEngine] StringSet junction table ${junctionTableName} already exists, skipping creation.`
+            `[SqljsEngine] StringSet junction table ${junctionTableName} already exists, skipping creation.`
           );
           return;
         }
@@ -4842,100 +5569,92 @@ var init_NodeSqliteEngine = __esm({
       ${quotedForeignKey} TEXT NOT NULL,
       ${quotedValueColumn} TEXT NOT NULL,
       UNIQUE(${quotedForeignKey}, ${quotedValueColumn})
-    )`;
+    );`;
         Logger.info(
-          `[NodeSqliteEngine] Creating StringSet junction table ${junctionTableName} for ${modelName}.${fieldName}`
+          `[SqljsEngine] Creating StringSet junction table ${junctionTableName} for ${modelName}.${fieldName}`
         );
-        this.db.exec(createTableSQL);
-        const indexName = `idx_${junctionTableName}_${modelName.toLowerCase()}_id`;
+        this.db.run(createTableSQL);
+        const indexName = `idx_${junctionTableName}_${modelName.toLowerCase()}_id_value`;
         const indexSQL = `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(
           indexName
-        )} ON ${quotedJunctionTable} (${quotedForeignKey})`;
-        this.db.exec(indexSQL);
+        )} ON ${quotedJunctionTable} (${quotedForeignKey}, ${quotedValueColumn});`;
+        this.db.run(indexSQL);
         this.updateTableNames();
         Logger.info(
-          `[NodeSqliteEngine] StringSet junction table ${junctionTableName} created successfully.`
+          `[SqljsEngine] StringSet junction table ${junctionTableName} created successfully.`
         );
       }
       async insertStringSetValues(modelName, fieldName, recordId, values) {
-        await this.ensureReady();
+        await this.readyPromise;
         if (!this.db)
-          throw new Error("SQLite not initialized for insertStringSetValues");
+          throw new Error("SQL.js not initialized for insertStringSetValues");
         if (values.length === 0) return;
         const junctionTableName = `${this.getTableName(modelName)}_${fieldName}`;
+        const modelIdColumn = `${modelName.toLowerCase()}_id`;
         const quotedJunctionTable = quoteIdentifier(junctionTableName);
         const quotedIdColumn = quoteIdentifier("id");
-        const quotedForeignKey = quoteIdentifier(`${modelName.toLowerCase()}_id`);
+        const quotedModelIdColumn = quoteIdentifier(modelIdColumn);
         const quotedValueColumn = quoteIdentifier("value");
-        const insertSQL = `INSERT OR IGNORE INTO ${quotedJunctionTable} (${quotedIdColumn}, ${quotedForeignKey}, ${quotedValueColumn}) VALUES (?, ?, ?)`;
-        const stmt = this.db.prepare(insertSQL);
         for (const value of values) {
-          const id = `${recordId}_${value}`;
-          stmt.run(id, recordId, value);
+          const insertSQL = `INSERT OR IGNORE INTO ${quotedJunctionTable} (${quotedIdColumn}, ${quotedModelIdColumn}, ${quotedValueColumn}) VALUES (?, ?, ?);`;
+          const junctionId = `${recordId}_${value}`;
+          this.db.run(insertSQL, [junctionId, recordId, value]);
         }
       }
       async removeStringSetValues(modelName, fieldName, recordId, values) {
-        await this.ensureReady();
+        await this.readyPromise;
         if (!this.db)
-          throw new Error("SQLite not initialized for removeStringSetValues");
+          throw new Error("SQL.js not initialized for removeStringSetValues");
         if (values.length === 0) return;
         const junctionTableName = `${this.getTableName(modelName)}_${fieldName}`;
+        const modelIdColumn = `${modelName.toLowerCase()}_id`;
         const quotedJunctionTable = quoteIdentifier(junctionTableName);
-        const quotedForeignKey = quoteIdentifier(`${modelName.toLowerCase()}_id`);
+        const quotedModelIdColumn = quoteIdentifier(modelIdColumn);
         const quotedValueColumn = quoteIdentifier("value");
-        const deleteSQL = `DELETE FROM ${quotedJunctionTable} WHERE ${quotedForeignKey} = ? AND ${quotedValueColumn} = ?`;
-        const stmt = this.db.prepare(deleteSQL);
         for (const value of values) {
-          stmt.run(recordId, value);
+          const deleteSQL = `DELETE FROM ${quotedJunctionTable} WHERE ${quotedModelIdColumn} = ? AND ${quotedValueColumn} = ?;`;
+          this.db.run(deleteSQL, [recordId, value]);
         }
       }
       async insert(modelName, data) {
-        await this.ensureReady();
-        if (!this.db) throw new Error("SQLite not initialized for insert");
+        await this.readyPromise;
+        if (!this.db) throw new Error("SQL.js not initialized for insert");
         const tableName = this.getTableName(modelName);
         const quotedTableName = quoteIdentifier(tableName);
         const columns = Object.keys(data);
         const quotedColumns = columns.map((column) => quoteIdentifier(column));
         const placeholders = columns.map(() => "?").join(", ");
-        const values = Object.values(data).map((value) => {
-          if (typeof value === "boolean") {
-            return value ? 1 : 0;
-          }
-          return value;
-        });
+        const values = Object.values(data);
         const insertSQL = `INSERT OR REPLACE INTO ${quotedTableName} (${quotedColumns.join(
           ", "
-        )}) VALUES (${placeholders})`;
-        const stmt = this.db.prepare(insertSQL);
-        stmt.run(...values);
+        )}) VALUES (${placeholders});`;
+        this.db.run(insertSQL, values);
       }
       async delete(modelName, id) {
-        await this.ensureReady();
-        if (!this.db) throw new Error("SQLite not initialized for delete");
+        await this.readyPromise;
+        if (!this.db) throw new Error("SQL.js not initialized for delete");
         const tableName = this.getTableName(modelName);
-        const deleteSQL = `DELETE FROM ${quoteIdentifier(
-          tableName
-        )} WHERE ${quoteIdentifier("id")} = ?`;
-        const stmt = this.db.prepare(deleteSQL);
-        stmt.run(id);
+        const deleteSQL = `DELETE FROM ${quoteIdentifier(tableName)} WHERE ${quoteIdentifier(
+          "id"
+        )} = ?;`;
+        this.db.run(deleteSQL, [id]);
       }
       async deleteByDocumentId(modelName, docId) {
-        await this.ensureReady();
+        await this.readyPromise;
         if (!this.db)
-          throw new Error("SQLite not initialized for deleteByDocumentId");
+          throw new Error("SQL.js not initialized for deleteByDocumentId");
         const tableName = this.getTableName(modelName);
         const quotedTableName = quoteIdentifier(tableName);
         if (!this.tableNames.has(tableName)) {
           Logger.debug(
-            `[NodeSqliteEngine] Skipping deleteByDocumentId for ${tableName}; table does not exist.`
+            `[SqljsEngine] Skipping deleteByDocumentId for ${tableName}; table does not exist.`
           );
           return;
         }
         const deleteSQL = `DELETE FROM ${quotedTableName} WHERE ${quoteIdentifier(
           "_meta_doc_id"
-        )} = ?`;
-        const stmt = this.db.prepare(deleteSQL);
-        stmt.run(docId);
+        )} = ?;`;
+        this.db.run(deleteSQL, [docId]);
         for (const existingTableName of this.tableNames) {
           if (existingTableName.startsWith(`${tableName}_`)) {
             const quotedExistingTable = quoteIdentifier(existingTableName);
@@ -4944,16 +5663,16 @@ var init_NodeSqliteEngine = __esm({
           SELECT ${quoteIdentifier("id")} FROM ${quotedTableName} WHERE ${quoteIdentifier(
               "_meta_doc_id"
             )} = ?
-        )`;
+        );`;
             try {
-              const junctionStmt = this.db.prepare(junctionDeleteSQL);
-              const result = junctionStmt.run(docId);
+              this.db.run(junctionDeleteSQL, [docId]);
+              const rowsCleared = this.db.getRowsModified();
               Logger.info(
-                `[NodeSqliteEngine] Cleared junction table ${existingTableName} for document ${docId}; removed ${result.changes} rows.`
+                `[SqljsEngine] Cleared junction table ${existingTableName} for document ${docId}; removed ${rowsCleared} rows.`
               );
             } catch (error) {
-              console.warn(
-                `[NodeSqliteEngine] Warning: Could not clean up junction table ${existingTableName}:`,
+              Logger.warn(
+                `[SqljsEngine] Warning: Could not clean up junction table ${existingTableName}:`,
                 error
               );
             }
@@ -4961,50 +5680,53 @@ var init_NodeSqliteEngine = __esm({
         }
       }
       async query(sql, params) {
-        await this.ensureReady();
-        if (!this.db) throw new Error("SQLite not initialized for query");
+        await this.readyPromise;
+        if (!this.db) throw new Error("SQL.js not initialized for query");
+        const results = [];
         const stmt = this.db.prepare(sql);
-        const results = params ? stmt.all(...params) : stmt.all();
+        if (params) {
+          stmt.bind(params);
+        }
+        while (stmt.step()) {
+          results.push(stmt.getAsObject());
+        }
+        stmt.free();
         return results;
       }
       async withTransaction(callback) {
-        await this.ensureReady();
-        if (!this.db) throw new Error("SQLite not initialized for transaction");
+        await this.readyPromise;
+        if (!this.db)
+          throw new Error("SQL.js Database instance not available for transaction");
         let transactionStartedHere = false;
         await this.mutex.runExclusive(async () => {
           if (this.numOpenTransactions === 0) {
-            this.db.exec("BEGIN TRANSACTION");
+            if (!this.db) throw new Error("SQL.js DB not available for BEGIN");
+            this.db.run("BEGIN TRANSACTION");
             transactionStartedHere = true;
           }
           this.numOpenTransactions++;
         });
-        const transactionalOps = new TransactionalNodeSqliteOperations(
-          this.db,
-          this
-        );
+        const transactionalOps = new TransactionalSQLJSOperations(this.db, this);
         try {
           const result = await callback(transactionalOps);
           await this.mutex.runExclusive(async () => {
             this.numOpenTransactions--;
             if (this.numOpenTransactions === 0) {
-              this.db.exec("COMMIT");
+              if (!this.db) throw new Error("SQL.js DB not available for COMMIT");
+              this.db.run("COMMIT");
             }
           });
           return result;
         } catch (error) {
-          console.error(
-            "[NodeSqliteEngine] Error in transaction, rolling back:",
-            error
-          );
+          Logger.error("[SqljsEngine] Error in transaction, rolling back:", error);
           await this.mutex.runExclusive(async () => {
             if (this.db && this.numOpenTransactions > 0 && transactionStartedHere) {
               try {
-                this.db.exec("ROLLBACK");
+                if (!this.db)
+                  throw new Error("SQL.js DB not available for ROLLBACK");
+                this.db.run("ROLLBACK");
               } catch (rollbackError) {
-                console.error(
-                  "[NodeSqliteEngine] Error during ROLLBACK:",
-                  rollbackError
-                );
+                Logger.error("[SqljsEngine] Error during ROLLBACK:", rollbackError);
               }
             }
             this.numOpenTransactions = 0;
@@ -5015,19 +5737,19 @@ var init_NodeSqliteEngine = __esm({
       async close() {
         await this.readyPromise;
         if (this.db) {
-          Logger.info("[NodeSqliteEngine] Closing SQLite database...");
           this.db.close();
           this.db = null;
-          Logger.info("[NodeSqliteEngine] SQLite database closed.");
+          _SqljsEngine.SQL = null;
         }
       }
-      async destroy() {
-        await this.close();
-        this.tableNames.clear();
-        Logger.info("[NodeSqliteEngine] SQLite engine destroyed.");
-      }
       async getTableSchema(_tableName) {
-        return {};
+        return void 0;
+      }
+      async destroy() {
+        if (this.db) {
+          this.db.close();
+          Logger.info("[SqljsEngine] Database closed.");
+        }
       }
       getLastErrorMessage() {
         return void 0;
@@ -5036,1024 +5758,708 @@ var init_NodeSqliteEngine = __esm({
   }
 });
 
-// src/engines/NodeDatabaseFactory.ts
-var NodeDatabaseFactory_exports = {};
-__export(NodeDatabaseFactory_exports, {
-  NodeDatabaseFactory: () => NodeDatabaseFactory
+// src/engines/node/NodeSqliteEngine.ts
+var NodeSqliteEngine_exports = {};
+__export(NodeSqliteEngine_exports, {
+  NodeSqliteEngine: () => NodeSqliteEngine
 });
-var NodeSqliteEngine2, NodeDatabaseFactory;
-var init_NodeDatabaseFactory = __esm({
-  "src/engines/NodeDatabaseFactory.ts"() {
+var import_async_mutex2, TransactionalNodeSqliteOperations, NodeSqliteEngine;
+var init_NodeSqliteEngine = __esm({
+  "src/engines/node/NodeSqliteEngine.ts"() {
     "use strict";
-    init_SqljsEngine();
-    init_environment();
-    NodeSqliteEngine2 = null;
-    NodeDatabaseFactory = class {
-      static engines = /* @__PURE__ */ new Map();
-      /**
-       * Dynamically loads Node.js engines
-       */
-      static async loadNodeEngines() {
-        try {
-          const hasBetterSqlite3 = await features.hasBetterSqlite3();
-          if (hasBetterSqlite3 && !NodeSqliteEngine2) {
-            const module2 = await Promise.resolve().then(() => (init_NodeSqliteEngine(), NodeSqliteEngine_exports));
-            NodeSqliteEngine2 = module2.NodeSqliteEngine;
-            console.log(
-              "[NodeDatabaseFactory] NodeSqliteEngine loaded successfully"
-            );
+    init_BaseModel();
+    import_async_mutex2 = require("async-mutex");
+    init_sql();
+    TransactionalNodeSqliteOperations = class {
+      db;
+      engine;
+      constructor(db, engine) {
+        this.db = db;
+        this.engine = engine;
+      }
+      async insert(modelName, data) {
+        const tableName = this.engine.getTableName(modelName);
+        const columns = Object.keys(data);
+        const placeholders = columns.map(() => "?").join(", ");
+        const values = Object.values(data).map((value) => {
+          if (typeof value === "boolean") {
+            return value ? 1 : 0;
+          }
+          return value;
+        });
+        const insertSQL = `INSERT OR REPLACE INTO ${tableName} (${columns.join(
+          ", "
+        )}) VALUES (${placeholders})`;
+        const stmt = this.db.prepare(insertSQL);
+        stmt.run(...values);
+      }
+      async delete(modelName, id) {
+        const tableName = this.engine.getTableName(modelName);
+        const deleteSQL = `DELETE FROM ${tableName} WHERE id = ?`;
+        const stmt = this.db.prepare(deleteSQL);
+        stmt.run(id);
+      }
+      async query(sql, params) {
+        const stmt = this.db.prepare(sql);
+        const results = params ? stmt.all(...params) : stmt.all();
+        return results;
+      }
+    };
+    NodeSqliteEngine = class {
+      db = null;
+      tableNames = /* @__PURE__ */ new Set();
+      mutex = new import_async_mutex2.Mutex();
+      readyPromise;
+      betterSqlite3 = null;
+      numOpenTransactions = 0;
+      constructor(options) {
+        Logger.debug("[NodeSqliteEngine] Constructor called. Initializing...");
+        this.readyPromise = this.initialize(options);
+      }
+      async ensureReady() {
+        return this.readyPromise;
+      }
+      async initialize(options) {
+        Logger.info("[NodeSqliteEngine] Initializing Node.js SQLite engine...");
+        try {
+          const betterSqlite3Module = await import("better-sqlite3");
+          this.betterSqlite3 = betterSqlite3Module.default || betterSqlite3Module;
+          const filePath = options?.filePath || ":memory:";
+          const dbOptions = options?.options || {};
+          Logger.debug(
+            `[NodeSqliteEngine] Opening SQLite database at: ${filePath}`
+          );
+          this.db = new this.betterSqlite3(filePath, dbOptions);
+          if (!this.db) {
+            throw new Error("Failed to create SQLite database instance");
           }
+          if (filePath !== ":memory:") {
+            this.db.exec("PRAGMA journal_mode = WAL");
+          }
+          Logger.info(
+            "[NodeSqliteEngine] SQLite database initialized successfully."
+          );
+          this.updateTableNames();
         } catch (error) {
-          console.warn(
-            "[NodeDatabaseFactory] Failed to load NodeSqliteEngine:",
+          Logger.error(
+            "[NodeSqliteEngine] Error during SQLite initialization:",
             error
           );
+          throw new Error(
+            `Failed to initialize Node.js SQLite engine: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
         }
       }
-      /**
-       * Auto-detects the best available engine for Node.js
-       */
-      static async getRecommendedEngineType() {
-        const hasBetterSqlite3 = await features.hasBetterSqlite3();
-        if (hasBetterSqlite3) {
-          return "node-sqlite";
-        }
-        if (features.hasWebAssembly) {
-          return "sqljs";
-        }
-        throw new Error(
-          "No compatible database engine found. Please install better-sqlite3."
+      updateTableNames() {
+        if (!this.db) return;
+        const stmt = this.db.prepare(
+          "SELECT name FROM sqlite_master WHERE type='table'"
         );
-      }
-      /**
-       * Creates a fallback engine when the requested engine is not available
-       */
-      static async createFallbackEngine(requestedType, config) {
-        const fallbackType = await this.getRecommendedEngineType();
-        console.warn(
-          `[NodeDatabaseFactory] Requested engine '${requestedType}' is not available. Falling back to '${fallbackType}'.`
+        const tables = stmt.all();
+        this.tableNames.clear();
+        tables.forEach((table) => this.tableNames.add(table.name));
+        Logger.debug(
+          "[NodeSqliteEngine] Updated table names:",
+          Array.from(this.tableNames)
         );
-        const fallbackConfig = { ...config, type: fallbackType };
-        return this.createEngine(fallbackConfig, false);
       }
-      /**
-       * Creates the specified database engine (Node.js compatible only)
-       */
-      static async createEngine(config, allowFallback = true) {
-        const { type, options } = config;
-        switch (type) {
-          case "sqljs":
-            const sqljsEngine = new SqljsEngine(options);
-            await sqljsEngine.ensureReady();
-            return sqljsEngine;
-          case "node-sqlite":
-            if (!NodeSqliteEngine2) {
-              const hasBetterSqlite3 = await features.hasBetterSqlite3();
-              if (!hasBetterSqlite3) {
-                if (allowFallback) {
-                  console.warn(
-                    "[NodeDatabaseFactory] better-sqlite3 not installed, falling back to alternative engine"
-                  );
-                  return this.createFallbackEngine(type, config);
-                }
-                throw new Error(
-                  "better-sqlite3 package is required for node-sqlite engine. Install it with: npm install better-sqlite3"
-                );
-              }
-              throw new Error(
-                "NodeSqliteEngine not loaded. This should not happen."
-              );
-            }
-            const nodeSqliteEngine = new NodeSqliteEngine2(options);
-            await nodeSqliteEngine.ensureReady();
-            return nodeSqliteEngine;
-          case "alasql":
-            throw new Error("AlaSQLEngine not yet implemented.");
+      getTableName(modelName) {
+        return `model_${modelName.toLowerCase()}`;
+      }
+      mapTypeToSQL(type) {
+        switch (type.toLowerCase()) {
+          case "string":
+            return "TEXT";
+          case "number":
+            return "REAL";
+          case "boolean":
+            return "INTEGER";
+          case "date":
+            return "TEXT";
           default:
-            const typeStr = type;
-            if (typeStr === "duckdb") {
-              if (allowFallback) {
-                console.warn(
-                  "[NodeDatabaseFactory] DuckDB-WASM not available in Node.js, falling back to alternative engine"
-                );
-                return this.createFallbackEngine(typeStr, config);
-              }
-              throw new Error(
-                "DuckDB-WASM engine is only available in browser environments"
-              );
-            }
-            if (typeStr === "node-duckdb") {
-              if (allowFallback) {
-                console.warn(
-                  "[NodeDatabaseFactory] Node DuckDB engine is no longer supported, falling back to alternative engine"
-                );
-                return this.createFallbackEngine(typeStr, config);
-              }
-              throw new Error("Node DuckDB engine is no longer supported");
-            }
-            throw new Error(`Unsupported database engine type: ${typeStr}`);
+            return "TEXT";
         }
       }
-      static async getEngine(config) {
-        await this.loadNodeEngines();
-        const configKey = JSON.stringify(config);
-        if (this.engines.has(configKey)) {
-          console.log(
-            `[NodeDatabaseFactory] Returning cached engine for config: ${configKey}`
+      async createTable(modelName, schema, _options) {
+        await this.ensureReady();
+        if (!this.db) throw new Error("SQLite not initialized for createTable");
+        const tableName = this.getTableName(modelName);
+        const quotedTableName = quoteIdentifier(tableName);
+        const idColumn = quoteIdentifier("id");
+        const typeColumn = quoteIdentifier("type");
+        if (this.tableNames.has(tableName)) {
+          Logger.debug(
+            `[NodeSqliteEngine] Table ${tableName} already exists, skipping creation.`
           );
+          return;
         }
-        console.log(
-          `[NodeDatabaseFactory] Creating engine for type: ${config.type}`
+        const columns = Array.from(schema.entries()).filter(([field]) => field !== "id" && field !== "type").map(
+          ([field, fieldOptions]) => `${quoteIdentifier(field)} ${this.mapTypeToSQL(fieldOptions.type)}`
         );
-        try {
-          const engine = await this.createEngine(config);
-          console.log(
-            `[NodeDatabaseFactory] Engine for type ${config.type} is ready.`
-          );
-          return engine;
-        } catch (error) {
-          console.error(
-            `[NodeDatabaseFactory] Failed to create engine for type ${config.type}:`,
-            error
-          );
-          throw error;
+        const metadataColumns = [
+          `${quoteIdentifier("_meta_doc_id")} TEXT`,
+          `${quoteIdentifier("_meta_permission_hint")} TEXT`
+        ];
+        const createTableSQL = `CREATE TABLE IF NOT EXISTS ${quotedTableName} (
+      ${idColumn} TEXT PRIMARY KEY,
+      ${typeColumn} TEXT,
+      ${columns.join(", ")}${columns.length > 0 ? ", " : ""}${metadataColumns.join(", ")}
+    )`;
+        Logger.debug(
+          `[NodeSqliteEngine] Creating table ${tableName}:`,
+          createTableSQL
+        );
+        this.db.exec(createTableSQL);
+        for (const [field, fieldOptions] of schema.entries()) {
+          if (fieldOptions && fieldOptions.indexed && field !== "id") {
+            const indexName = `idx_${tableName}_${field}`;
+            const quotedIndexName = quoteIdentifier(indexName);
+            const quotedField = quoteIdentifier(field);
+            const createIndexSQL = `CREATE INDEX IF NOT EXISTS ${quotedIndexName} ON ${quotedTableName} (${quotedField})`;
+            Logger.debug(`[NodeSqliteEngine] Creating index ${indexName}`);
+            this.db.exec(createIndexSQL);
+          }
         }
+        const docIdIndexName = `idx_${tableName}_meta_doc_id`;
+        const docIdIndexSQL = `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(
+          docIdIndexName
+        )} ON ${quotedTableName} (${quoteIdentifier("_meta_doc_id")})`;
+        this.db.exec(docIdIndexSQL);
+        this.updateTableNames();
+        Logger.info(`[NodeSqliteEngine] Table ${tableName} created successfully.`);
       }
-      /**
-       * Gets information about available engines in Node.js environment
-       */
-      static async getAvailableEngines() {
-        const hasBetterSqlite3 = await features.hasBetterSqlite3();
-        const engines = [
-          {
-            type: "sqljs",
-            available: features.hasWebAssembly,
-            reason: !features.hasWebAssembly ? "WebAssembly not supported" : void 0
-          },
-          {
-            type: "node-sqlite",
-            available: hasBetterSqlite3,
-            reason: !hasBetterSqlite3 ? "better-sqlite3 package not installed" : void 0
-          }
-        ];
-        return engines;
-      }
-    };
-  }
-});
-
-// src/engines/BrowserDatabaseFactory.ts
-var BrowserDatabaseFactory_exports = {};
-__export(BrowserDatabaseFactory_exports, {
-  BrowserDatabaseFactory: () => BrowserDatabaseFactory
-});
-var BrowserDatabaseFactory;
-var init_BrowserDatabaseFactory = __esm({
-  "src/engines/BrowserDatabaseFactory.ts"() {
-    "use strict";
-    init_SqljsEngine();
-    init_environment();
-    init_BaseModel();
-    BrowserDatabaseFactory = class {
-      /**
-       * Dynamically loads browser-compatible engines only
-       */
-      static async loadBrowserEngines() {
-        Logger.debug("[BrowserDatabaseFactory] Browser engines ready");
-      }
-      /**
-       * Auto-detects the best available engine for browser
-       */
-      static getRecommendedEngineType() {
-        if (features.hasWebAssembly) {
-          return "sqljs";
+      async createStringSetJunctionTable(modelName, fieldName) {
+        await this.ensureReady();
+        if (!this.db)
+          throw new Error(
+            "SQLite not initialized for createStringSetJunctionTable"
+          );
+        const junctionTableName = `${this.getTableName(modelName)}_${fieldName}`;
+        const quotedJunctionTable = quoteIdentifier(junctionTableName);
+        const foreignKeyColumn = `${modelName.toLowerCase()}_id`;
+        const quotedForeignKey = quoteIdentifier(foreignKeyColumn);
+        const quotedIdColumn = quoteIdentifier("id");
+        const quotedValueColumn = quoteIdentifier("value");
+        if (this.tableNames.has(junctionTableName)) {
+          Logger.debug(
+            `[NodeSqliteEngine] StringSet junction table ${junctionTableName} already exists, skipping creation.`
+          );
+          return;
         }
-        throw new Error(
-          "No compatible database engine found. WebAssembly is required for browser environments."
+        const createTableSQL = `CREATE TABLE IF NOT EXISTS ${quotedJunctionTable} (
+      ${quotedIdColumn} TEXT PRIMARY KEY,
+      ${quotedForeignKey} TEXT NOT NULL,
+      ${quotedValueColumn} TEXT NOT NULL,
+      UNIQUE(${quotedForeignKey}, ${quotedValueColumn})
+    )`;
+        Logger.info(
+          `[NodeSqliteEngine] Creating StringSet junction table ${junctionTableName} for ${modelName}.${fieldName}`
         );
-      }
-      /**
-       * Creates a fallback engine when the requested engine is not available
-       */
-      static async createFallbackEngine(requestedType, config) {
-        const fallbackType = this.getRecommendedEngineType();
-        console.warn(
-          `[BrowserDatabaseFactory] Requested engine '${requestedType}' is not available. Falling back to '${fallbackType}'.`
+        this.db.exec(createTableSQL);
+        const indexName = `idx_${junctionTableName}_${modelName.toLowerCase()}_id`;
+        const indexSQL = `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(
+          indexName
+        )} ON ${quotedJunctionTable} (${quotedForeignKey})`;
+        this.db.exec(indexSQL);
+        this.updateTableNames();
+        Logger.info(
+          `[NodeSqliteEngine] StringSet junction table ${junctionTableName} created successfully.`
         );
-        const fallbackConfig = { ...config, type: fallbackType };
-        return this.createEngine(fallbackConfig, false);
       }
-      /**
-       * Creates the specified database engine (browser-compatible only)
-       */
-      static async createEngine(config, allowFallback = true) {
-        const { type, options } = config;
-        const typeStr = type;
-        switch (type) {
-          case "sqljs":
-            const sqljsEngine = new SqljsEngine(options);
-            await sqljsEngine.ensureReady();
-            return sqljsEngine;
-          case "alasql":
-            throw new Error("AlaSQLEngine not yet implemented.");
-          default:
-            if (typeStr === "duckdb") {
-              if (allowFallback) {
-                console.warn(
-                  "[BrowserDatabaseFactory] DuckDB engine is no longer supported, falling back to alternative engine"
-                );
-                return this.createFallbackEngine(typeStr, config);
-              }
-              throw new Error("DuckDB engine is no longer supported");
-            }
-            if (typeStr === "node-sqlite" || typeStr === "node-duckdb") {
-              if (allowFallback) {
-                console.warn(
-                  `[BrowserDatabaseFactory] Engine '${typeStr}' is not available in browser. Falling back to browser-compatible engine.`
-                );
-                return this.createFallbackEngine(typeStr, config);
-              }
-              throw new Error(
-                `Engine '${typeStr}' is only available in Node.js environments`
-              );
-            }
-            throw new Error(`Unsupported database engine type: ${typeStr}`);
+      async insertStringSetValues(modelName, fieldName, recordId, values) {
+        await this.ensureReady();
+        if (!this.db)
+          throw new Error("SQLite not initialized for insertStringSetValues");
+        if (values.length === 0) return;
+        const junctionTableName = `${this.getTableName(modelName)}_${fieldName}`;
+        const quotedJunctionTable = quoteIdentifier(junctionTableName);
+        const quotedIdColumn = quoteIdentifier("id");
+        const quotedForeignKey = quoteIdentifier(`${modelName.toLowerCase()}_id`);
+        const quotedValueColumn = quoteIdentifier("value");
+        const insertSQL = `INSERT OR IGNORE INTO ${quotedJunctionTable} (${quotedIdColumn}, ${quotedForeignKey}, ${quotedValueColumn}) VALUES (?, ?, ?)`;
+        const stmt = this.db.prepare(insertSQL);
+        for (const value of values) {
+          const id = `${recordId}_${value}`;
+          stmt.run(id, recordId, value);
         }
       }
-      static async getEngine(config) {
-        await this.loadBrowserEngines();
-        Logger.debug(
-          `[BrowserDatabaseFactory] Creating engine for type: ${config.type}`
-        );
-        try {
-          const engine = await this.createEngine(config);
+      async removeStringSetValues(modelName, fieldName, recordId, values) {
+        await this.ensureReady();
+        if (!this.db)
+          throw new Error("SQLite not initialized for removeStringSetValues");
+        if (values.length === 0) return;
+        const junctionTableName = `${this.getTableName(modelName)}_${fieldName}`;
+        const quotedJunctionTable = quoteIdentifier(junctionTableName);
+        const quotedForeignKey = quoteIdentifier(`${modelName.toLowerCase()}_id`);
+        const quotedValueColumn = quoteIdentifier("value");
+        const deleteSQL = `DELETE FROM ${quotedJunctionTable} WHERE ${quotedForeignKey} = ? AND ${quotedValueColumn} = ?`;
+        const stmt = this.db.prepare(deleteSQL);
+        for (const value of values) {
+          stmt.run(recordId, value);
+        }
+      }
+      async insert(modelName, data) {
+        await this.ensureReady();
+        if (!this.db) throw new Error("SQLite not initialized for insert");
+        const tableName = this.getTableName(modelName);
+        const quotedTableName = quoteIdentifier(tableName);
+        const columns = Object.keys(data);
+        const quotedColumns = columns.map((column) => quoteIdentifier(column));
+        const placeholders = columns.map(() => "?").join(", ");
+        const values = Object.values(data).map((value) => {
+          if (typeof value === "boolean") {
+            return value ? 1 : 0;
+          }
+          return value;
+        });
+        const insertSQL = `INSERT OR REPLACE INTO ${quotedTableName} (${quotedColumns.join(
+          ", "
+        )}) VALUES (${placeholders})`;
+        const stmt = this.db.prepare(insertSQL);
+        stmt.run(...values);
+      }
+      async delete(modelName, id) {
+        await this.ensureReady();
+        if (!this.db) throw new Error("SQLite not initialized for delete");
+        const tableName = this.getTableName(modelName);
+        const deleteSQL = `DELETE FROM ${quoteIdentifier(
+          tableName
+        )} WHERE ${quoteIdentifier("id")} = ?`;
+        const stmt = this.db.prepare(deleteSQL);
+        stmt.run(id);
+      }
+      async deleteByDocumentId(modelName, docId) {
+        await this.ensureReady();
+        if (!this.db)
+          throw new Error("SQLite not initialized for deleteByDocumentId");
+        const tableName = this.getTableName(modelName);
+        const quotedTableName = quoteIdentifier(tableName);
+        if (!this.tableNames.has(tableName)) {
           Logger.debug(
-            `[BrowserDatabaseFactory] Engine for type ${config.type} is ready.`
-          );
-          return engine;
-        } catch (error) {
-          console.error(
-            `[BrowserDatabaseFactory] Failed to create engine for type ${config.type}:`,
-            error
+            `[NodeSqliteEngine] Skipping deleteByDocumentId for ${tableName}; table does not exist.`
           );
-          throw error;
+          return;
         }
-      }
-      /**
-       * Gets information about available engines in browser environment
-       */
-      static getAvailableEngines() {
-        const engines = [
-          {
-            type: "sqljs",
-            available: features.hasWebAssembly,
-            reason: !features.hasWebAssembly ? "WebAssembly not supported" : void 0
-          },
-          {
-            type: "node-sqlite",
-            available: false,
-            reason: "Node.js engines not available in browser"
+        const deleteSQL = `DELETE FROM ${quotedTableName} WHERE ${quoteIdentifier(
+          "_meta_doc_id"
+        )} = ?`;
+        const stmt = this.db.prepare(deleteSQL);
+        stmt.run(docId);
+        for (const existingTableName of this.tableNames) {
+          if (existingTableName.startsWith(`${tableName}_`)) {
+            const quotedExistingTable = quoteIdentifier(existingTableName);
+            const quotedForeignKey = quoteIdentifier(`${modelName.toLowerCase()}_id`);
+            const junctionDeleteSQL = `DELETE FROM ${quotedExistingTable} WHERE ${quotedForeignKey} IN (
+          SELECT ${quoteIdentifier("id")} FROM ${quotedTableName} WHERE ${quoteIdentifier(
+              "_meta_doc_id"
+            )} = ?
+        )`;
+            try {
+              const junctionStmt = this.db.prepare(junctionDeleteSQL);
+              const result = junctionStmt.run(docId);
+              Logger.info(
+                `[NodeSqliteEngine] Cleared junction table ${existingTableName} for document ${docId}; removed ${result.changes} rows.`
+              );
+            } catch (error) {
+              console.warn(
+                `[NodeSqliteEngine] Warning: Could not clean up junction table ${existingTableName}:`,
+                error
+              );
+            }
           }
-        ];
-        return engines;
+        }
       }
-    };
-  }
-});
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  BaseModel: () => BaseModel,
-  DatabaseEngine: () => DatabaseEngine,
-  DocumentClosedError: () => DocumentClosedError,
-  DocumentResolutionError: () => DocumentResolutionError,
-  Field: () => Field,
-  LogLevel: () => LogLevel,
-  Logger: () => Logger,
-  Model: () => Model,
-  ModelRegistry: () => ModelRegistry,
-  RecordNotFoundError: () => RecordNotFoundError,
-  StringSet: () => StringSet,
-  UniqueConstraintViolationError: () => UniqueConstraintViolationError,
-  attachAndRegisterModel: () => attachAndRegisterModel,
-  attachSchemaToClass: () => attachSchemaToClass,
-  autoRegisterModel: () => autoRegisterModel,
-  createModelClass: () => createModelClass,
-  defineModelSchema: () => defineModelSchema,
-  dumpYDocToPlain: () => dumpYDocToPlain,
-  generateULID: () => generateULID,
-  initJsBao: () => initJsBao,
-  resetJsBao: () => resetJsBao,
-  summarizePlainYDoc: () => summarizePlainYDoc
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/models/ModelRegistry.ts
-init_BaseModel();
-
-// src/models/relationshipManager.ts
-init_BaseModel();
-function generateRefersToMethod(_sourceModelClass, config, targetModelClass) {
-  return async function() {
-    const relatedId = this[config.relatedIdField];
-    if (relatedId === null || typeof relatedId === "undefined") return null;
-    return targetModelClass.find(relatedId);
-  };
-}
-function generateHasManyMethod(_sourceModelClass, config, targetModelClass, _dbEngine) {
-  return async function(paginationArgs) {
-    const {
-      limit,
-      afterCursor,
-      beforeCursor,
-      direction = "forward"
-    } = paginationArgs || {};
-    const {
-      relatedIdField,
-      orderByField = "id",
-      orderDirection = "ASC"
-    } = config;
-    const targetSchema = targetModelClass.getSchema();
-    if (!targetSchema || !targetSchema.options || !targetSchema.options.name) {
-      Logger.error(
-        `[RelationshipManager] Target model ${targetModelClass.name} for hasMany relationship has no valid schema name.`
-      );
-      return { data: [], nextCursor: null, prevCursor: null };
-    }
-    const filter = { [relatedIdField]: this.id };
-    const queryOptions = {
-      sort: { [orderByField]: orderDirection === "ASC" ? 1 : -1 }
-    };
-    if (limit !== void 0) {
-      queryOptions.limit = limit + 1;
-    }
-    if (direction === "forward" && afterCursor) {
-      filter[orderByField] = {
-        [orderDirection === "ASC" ? "$gt" : "$lt"]: afterCursor
-      };
-    } else if (direction === "backward") {
-      if (beforeCursor) {
-        filter[orderByField] = {
-          [orderDirection === "ASC" ? "$lt" : "$gt"]: beforeCursor
-        };
-      }
-      queryOptions.sort = { [orderByField]: orderDirection === "ASC" ? -1 : 1 };
-    }
-    const result = await targetModelClass.query(filter, queryOptions);
-    const results = result.data;
-    let nextCursor = null;
-    let prevCursor = null;
-    const isFirstPage = direction === "forward" && !afterCursor;
-    if (limit !== void 0) {
-      if (direction === "forward") {
-        if (results.length > limit) {
-          nextCursor = results[limit - 1][orderByField];
-          results.pop();
-        }
-        if (results.length > 0 && !isFirstPage) {
-          prevCursor = results[0][orderByField];
-        }
-      } else {
-        if (results.length > limit) {
-          prevCursor = results[limit - 1][orderByField];
-          results.pop();
-        }
-        results.reverse();
-        if (results.length > 0 && beforeCursor) {
-          nextCursor = results[results.length - 1][orderByField];
-        }
-        if (results.length > 0 && !beforeCursor) {
-          if (results.length === limit) {
-            prevCursor = results[0][orderByField];
-          }
-        }
-      }
-    }
-    return { data: results, nextCursor, prevCursor };
-  };
-}
-function generateHasManyThroughMethod(_sourceModelClass, config, targetModelClass, joinModelClass, _dbEngine) {
-  return async function(paginationArgs) {
-    const {
-      limit,
-      afterCursor,
-      beforeCursor,
-      direction = "forward"
-    } = paginationArgs || {};
-    const joinSchema = joinModelClass.getSchema();
-    const targetSchema = targetModelClass.getSchema();
-    if (!joinSchema || !joinSchema.options || !joinSchema.options.name) {
-      Logger.error(
-        `[RelationshipManager] Join model ${joinModelClass.name} for hasManyThrough relationship has no valid schema name.`
-      );
-      return { data: [], nextCursor: null, prevCursor: null };
-    }
-    if (!targetSchema || !targetSchema.options || !targetSchema.options.name) {
-      Logger.error(
-        `[RelationshipManager] Target model ${targetModelClass.name} for hasManyThrough relationship has no valid schema name.`
-      );
-      return { data: [], nextCursor: null, prevCursor: null };
-    }
-    const {
-      joinModelLocalField,
-      joinModelRelatedField,
-      joinModelOrderByField = "id",
-      joinModelOrderDirection = "ASC"
-    } = config;
-    const joinFilter = { [joinModelLocalField]: this.id };
-    const joinQueryOptions = {
-      sort: {
-        [joinModelOrderByField]: joinModelOrderDirection === "ASC" ? 1 : -1
-      },
-      projection: { [joinModelRelatedField]: 1, [joinModelOrderByField]: 1 }
-    };
-    if (limit !== void 0) {
-      joinQueryOptions.limit = limit + 1;
-    }
-    if (direction === "forward" && afterCursor) {
-      joinFilter[joinModelOrderByField] = {
-        [joinModelOrderDirection === "ASC" ? "$gt" : "$lt"]: afterCursor
-      };
-    } else if (direction === "backward") {
-      if (beforeCursor) {
-        joinFilter[joinModelOrderByField] = {
-          [joinModelOrderDirection === "ASC" ? "$lt" : "$gt"]: beforeCursor
-        };
+      async query(sql, params) {
+        await this.ensureReady();
+        if (!this.db) throw new Error("SQLite not initialized for query");
+        const stmt = this.db.prepare(sql);
+        const results = params ? stmt.all(...params) : stmt.all();
+        return results;
       }
-      joinQueryOptions.sort = {
-        [joinModelOrderByField]: joinModelOrderDirection === "ASC" ? -1 : 1
-      };
-    }
-    const joinResult = await joinModelClass.query(
-      joinFilter,
-      joinQueryOptions
-    );
-    const joinResults = joinResult.data;
-    let nextCursorFromJoin = null;
-    let prevCursorFromJoin = null;
-    const isFirstPage = direction === "forward" && !afterCursor;
-    if (limit !== void 0) {
-      if (direction === "forward") {
-        if (joinResults.length > limit) {
-          nextCursorFromJoin = joinResults[limit - 1][joinModelOrderByField];
-          joinResults.pop();
-        }
-        if (joinResults.length > 0 && !isFirstPage) {
-          prevCursorFromJoin = joinResults[0][joinModelOrderByField];
-        }
-      } else {
-        if (joinResults.length > limit) {
-          prevCursorFromJoin = joinResults[limit - 1][joinModelOrderByField];
-          joinResults.pop();
-        }
-        joinResults.reverse();
-        if (joinResults.length > 0 && beforeCursor) {
-          nextCursorFromJoin = joinResults[joinResults.length - 1][joinModelOrderByField];
-        }
-        if (joinResults.length > 0 && !beforeCursor) {
-          if (joinResults.length === limit) {
-            prevCursorFromJoin = joinResults[0][joinModelOrderByField];
+      async withTransaction(callback) {
+        await this.ensureReady();
+        if (!this.db) throw new Error("SQLite not initialized for transaction");
+        let transactionStartedHere = false;
+        await this.mutex.runExclusive(async () => {
+          if (this.numOpenTransactions === 0) {
+            this.db.exec("BEGIN TRANSACTION");
+            transactionStartedHere = true;
           }
-        }
-      }
-    }
-    const relatedIds = joinResults.map((r) => r[joinModelRelatedField]).filter((id) => id != null && typeof id === "string");
-    if (relatedIds.length === 0)
-      return { data: [], nextCursor: null, prevCursor: null };
-    const targetResult = await targetModelClass.query({
-      id: { $in: relatedIds }
-    });
-    return {
-      data: targetResult.data,
-      nextCursor: nextCursorFromJoin,
-      prevCursor: prevCursorFromJoin
-    };
-  };
-}
-function generateHasManyThroughAddMethod(_sourceModelClass, config, _targetModelClass, joinModelClass) {
-  return async function(targetInstanceOrId) {
-    const targetId = typeof targetInstanceOrId === "string" ? targetInstanceOrId : targetInstanceOrId.id;
-    if (!targetId) {
-      Logger.error("[RelationshipManager.add] Target ID is missing.");
-      throw new Error("Target ID is missing for add operation.");
-    }
-    const joinData = {};
-    joinData[config.joinModelLocalField] = this.id;
-    joinData[config.joinModelRelatedField] = targetId;
-    let yDoc = null;
-    let targetDocId = null;
-    const sourceModelConstructor = this.constructor;
-    const connectedDocuments = sourceModelConstructor.connectedDocuments;
-    if (this._metaDocId && connectedDocuments) {
-      targetDocId = this._metaDocId;
-      if (targetDocId) {
-        const documentInfo = connectedDocuments.get(targetDocId);
-        if (documentInfo) {
-          yDoc = documentInfo.yDoc;
-        }
-      }
-    }
-    if (!yDoc) {
-      const legacyDocId = "__legacy_default__";
-      const legacyDocInfo = joinModelClass.connectedDocuments?.get(
-        legacyDocId
-      );
-      if (legacyDocInfo) {
-        yDoc = legacyDocInfo.yDoc;
-      }
-    }
-    if (!yDoc) {
-      throw new Error(
-        `[${joinModelClass.name}] No Y.Doc is connected for this join model. Connect a document via initJsBao(...).connectDocument or call initializeForDocument(yDoc, db, docId, permissionHint) before managing relationships.`
-      );
-    }
-    await yDoc.transact(async () => {
-      const newJoinInstance = new joinModelClass(joinData);
-      if (targetDocId) {
-        await newJoinInstance.save({ targetDocument: targetDocId });
-      } else {
-        await newJoinInstance.save();
+          this.numOpenTransactions++;
+        });
+        const transactionalOps = new TransactionalNodeSqliteOperations(
+          this.db,
+          this
+        );
+        try {
+          const result = await callback(transactionalOps);
+          await this.mutex.runExclusive(async () => {
+            this.numOpenTransactions--;
+            if (this.numOpenTransactions === 0) {
+              this.db.exec("COMMIT");
+            }
+          });
+          return result;
+        } catch (error) {
+          console.error(
+            "[NodeSqliteEngine] Error in transaction, rolling back:",
+            error
+          );
+          await this.mutex.runExclusive(async () => {
+            if (this.db && this.numOpenTransactions > 0 && transactionStartedHere) {
+              try {
+                this.db.exec("ROLLBACK");
+              } catch (rollbackError) {
+                console.error(
+                  "[NodeSqliteEngine] Error during ROLLBACK:",
+                  rollbackError
+                );
+              }
+            }
+            this.numOpenTransactions = 0;
+          });
+          throw error;
+        }
       }
-      Logger.debug(
-        `[RelationshipManager.add] Created join entry in ${config.joinModel}:`,
-        newJoinInstance.toJSON()
-      );
-    }, `add-join-${config.joinModel}-${this.id}-${targetId}`);
-  };
-}
-function generateHasManyThroughRemoveMethod(_sourceModelClass, config, _targetModelClass, joinModelClass) {
-  return async function(targetInstanceOrId) {
-    const targetId = typeof targetInstanceOrId === "string" ? targetInstanceOrId : targetInstanceOrId.id;
-    if (!targetId) {
-      Logger.error("[RelationshipManager.remove] Target ID is missing.");
-      throw new Error("Target ID is missing for remove operation.");
-    }
-    let yDoc = null;
-    let targetDocId = null;
-    const sourceModelConstructor = this.constructor;
-    const connectedDocuments = sourceModelConstructor.connectedDocuments;
-    if (this._metaDocId && connectedDocuments) {
-      targetDocId = this._metaDocId;
-      if (targetDocId) {
-        const documentInfo = connectedDocuments.get(targetDocId);
-        if (documentInfo) {
-          yDoc = documentInfo.yDoc;
+      async close() {
+        await this.readyPromise;
+        if (this.db) {
+          Logger.info("[NodeSqliteEngine] Closing SQLite database...");
+          this.db.close();
+          this.db = null;
+          Logger.info("[NodeSqliteEngine] SQLite database closed.");
         }
       }
-    }
-    if (!yDoc) {
-      const legacyDocId = "__legacy_default__";
-      const legacyDocInfo = joinModelClass.connectedDocuments?.get(
-        legacyDocId
-      );
-      if (legacyDocInfo) {
-        yDoc = legacyDocInfo.yDoc;
+      async destroy() {
+        await this.close();
+        this.tableNames.clear();
+        Logger.info("[NodeSqliteEngine] SQLite engine destroyed.");
       }
-    }
-    if (!yDoc) {
-      throw new Error(
-        `[${joinModelClass.name}] No Y.Doc is connected for this join model. Connect a document via initJsBao(...).connectDocument or call initializeForDocument(yDoc, db, docId, permissionHint) before managing relationships.`
-      );
-    }
-    await yDoc.transact(async () => {
-      const joinRecordsResult = await joinModelClass.query(
-        {
-          [config.joinModelLocalField]: this.id,
-          [config.joinModelRelatedField]: targetId
-        },
-        {
-          limit: 1,
-          projection: { id: 1 }
-        }
-      );
-      if (joinRecordsResult.data.length > 0) {
-        for (const record of joinRecordsResult.data) {
-          const instanceToDelete = await joinModelClass.find(
-            record.id
-          );
-          if (instanceToDelete) {
-            await instanceToDelete.delete();
-            Logger.debug(
-              `[RelationshipManager.remove] Deleted join entry from ${config.joinModel} with ID: ${record.id}`
-            );
-          } else {
-            Logger.warn(
-              `[RelationshipManager.remove] Join entry with ID ${record.id} found by query but not in YMap for deletion.`
-            );
-          }
-        }
-      } else {
-        Logger.debug(
-          `[RelationshipManager.remove] No join entry found in ${config.joinModel} for localId: ${this.id}, relatedId: ${targetId}. No action taken.`
-        );
+      async getTableSchema(_tableName) {
+        return {};
       }
-    }, `remove-join-${config.joinModel}-${this.id}-${targetId}`);
-  };
-}
-
-// src/models/ModelRegistry.ts
-var ModelRegistry = class _ModelRegistry {
-  static instance;
-  // Stores globally registered model classes by their name (from @Model decorator)
-  models = /* @__PURE__ */ new Map();
-  // Stores options for globally registered models (from @Model decorator)
-  modelOptions = /* @__PURE__ */ new Map();
-  // Stores fields for globally registered models (from @Model decorator, 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
-  activeSessionModels = null;
-  dbEngine = null;
-  // Store dbEngine for relationship methods
-  constructor() {
-  }
-  static getInstance() {
-    if (!_ModelRegistry.instance) {
-      _ModelRegistry.instance = new _ModelRegistry();
-    }
-    return _ModelRegistry.instance;
-  }
-  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.`
-      );
-    }
-    if (this.models.has(options.name)) {
-      console.warn(
-        `[ModelRegistry] Model "${options.name}" is already registered. Overwriting.`
-      );
-    }
-    this.models.set(options.name, modelClass);
-    if (fields) {
-      BaseModel.attachFieldAccessors(modelClass, fields);
-    }
-    this.modelOptions.set(options.name, options);
-    console.log(
-      `[ModelRegistry] Model "${options.name}" registered successfully.`
-    );
-  }
-  // Gets the class for a globally registered model
-  getModelClass(name) {
-    return this.models.get(name);
-  }
-  getModelOptions(name) {
-    return this.modelOptions.get(name);
-  }
-  // This method might need to be adapted based on how fields are ultimately managed
-  getModelInfo(modelName) {
-    const modelClass = this.models.get(modelName);
-    const options = this.modelOptions.get(modelName);
-    if (modelClass && options) {
-      const fields = modelClass.getSchema ? modelClass.getSchema().fields : /* @__PURE__ */ new Map();
-      return { class: modelClass, options, fields };
-    }
-    return void 0;
-  }
-  getAllRegisteredModelsInfo() {
-    const infos = [];
-    for (const modelName of this.models.keys()) {
-      const info = this.getModelInfo(modelName);
-      if (info) {
-        infos.push(info);
+      getLastErrorMessage() {
+        return void 0;
       }
-    }
-    return infos;
-  }
-  // Helper to get model name from class (assuming static property from @Model decorator)
-  getModelNameFromClass(modelClass) {
-    return modelClass.modelName;
+    };
   }
-  setExplicitModelsForSession(modelClasses) {
-    if (modelClasses && modelClasses.length > 0) {
-      this.activeSessionModels = /* @__PURE__ */ new Map();
-      modelClasses.forEach((modelClass) => {
-        const modelName = this.getModelNameFromClass(modelClass);
-        if (!modelName) {
+});
+
+// src/engines/NodeDatabaseFactory.ts
+var NodeDatabaseFactory_exports = {};
+__export(NodeDatabaseFactory_exports, {
+  NodeDatabaseFactory: () => NodeDatabaseFactory
+});
+var NodeSqliteEngine2, NodeDatabaseFactory;
+var init_NodeDatabaseFactory = __esm({
+  "src/engines/NodeDatabaseFactory.ts"() {
+    "use strict";
+    init_SqljsEngine();
+    init_environment();
+    NodeSqliteEngine2 = null;
+    NodeDatabaseFactory = class {
+      static engines = /* @__PURE__ */ new Map();
+      /**
+       * Dynamically loads Node.js engines
+       */
+      static async loadNodeEngines() {
+        try {
+          const hasBetterSqlite3 = await features.hasBetterSqlite3();
+          if (hasBetterSqlite3 && !NodeSqliteEngine2) {
+            const module2 = await Promise.resolve().then(() => (init_NodeSqliteEngine(), NodeSqliteEngine_exports));
+            NodeSqliteEngine2 = module2.NodeSqliteEngine;
+            console.log(
+              "[NodeDatabaseFactory] NodeSqliteEngine loaded successfully"
+            );
+          }
+        } catch (error) {
           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.`
+            "[NodeDatabaseFactory] Failed to load NodeSqliteEngine:",
+            error
           );
-          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.`
-          );
-          return;
+      }
+      /**
+       * Auto-detects the best available engine for Node.js
+       */
+      static async getRecommendedEngineType() {
+        const hasBetterSqlite3 = await features.hasBetterSqlite3();
+        if (hasBetterSqlite3) {
+          return "node-sqlite";
         }
-        if (this.activeSessionModels) {
-          this.activeSessionModels.set(modelName, modelClass);
+        if (features.hasWebAssembly) {
+          return "sqljs";
         }
-      });
-      let sessionModelNamesMessage = "none (no models were successfully added or session map is null)";
-      if (this.activeSessionModels) {
-        const currentSessionModelKeys = Array.from(
-          this.activeSessionModels.keys()
+        throw new Error(
+          "No compatible database engine found. Please install better-sqlite3."
         );
-        if (currentSessionModelKeys.length > 0) {
-          sessionModelNamesMessage = currentSessionModelKeys.join(", ");
-        } else {
-          sessionModelNamesMessage = "none (session map initialized but no models added)";
-        }
       }
-      Logger.debug(
-        `[ModelRegistry] Explicit models set for session: ${sessionModelNamesMessage}`
-      );
-    } else if (modelClasses && modelClasses.length === 0) {
-      this.activeSessionModels = /* @__PURE__ */ new Map();
-      Logger.debug(
-        "[ModelRegistry] Explicitly no models for session (empty array passed)."
-      );
-    } else {
-      this.activeSessionModels = null;
-      console.log(
-        "[ModelRegistry] No explicit models specified for session (undefined), will use all decorator-registered models."
-      );
-    }
-    this.validateSessionModels();
-  }
-  async initializeAll(yDoc, dbEngine) {
-    Logger.debug("[ModelRegistry] Attempting to initialize models...");
-    this.dbEngine = dbEngine;
-    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)."
-      );
-      return;
-    }
-    console.log(
-      `[ModelRegistry] Initializing models: ${Array.from(
-        modelsToInitialize.keys()
-      ).join(", ")}`
-    );
-    for (const [modelName, modelClass] of modelsToInitialize.entries()) {
-      if (modelClass && typeof modelClass.initialize === "function") {
-        Logger.debug(`[ModelRegistry] Initializing model: ${modelName}`);
-        await modelClass.initialize(yDoc, dbEngine);
-      } else {
-        const staticModelName = modelClass?.modelName || "unknown";
+      /**
+       * Creates a fallback engine when the requested engine is not available
+       */
+      static async createFallbackEngine(requestedType, config) {
+        const fallbackType = await this.getRecommendedEngineType();
         console.warn(
-          `[ModelRegistry] Model ${staticModelName} (class name: ${modelClass?.name}) does not have a static initialize method or class is not defined.`
+          `[NodeDatabaseFactory] Requested engine '${requestedType}' is not available. Falling back to '${fallbackType}'.`
         );
+        const fallbackConfig = { ...config, type: fallbackType };
+        return this.createEngine(fallbackConfig, false);
       }
-    }
-    Logger.debug("[ModelRegistry] Model initialization phase complete.");
-  }
-  // New method to initialize models for a specific document
-  async initializeAllForDocument(yDoc, dbEngine, docId, permissionHint) {
-    Logger.debug(
-      `[ModelRegistry] Initializing models for document ${docId}...`
-    );
-    this.dbEngine = dbEngine;
-    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)."
-      );
-      return;
-    }
-    Logger.debug(
-      `[ModelRegistry] Initializing models for document ${docId}: ${Array.from(
-        modelsToInitialize.keys()
-      ).join(", ")}`
-    );
-    for (const [modelName, modelClass] of modelsToInitialize.entries()) {
-      if (modelClass && typeof modelClass.initializeForDocument === "function") {
-        Logger.debug(
-          `[ModelRegistry] Initializing model ${modelName} for document ${docId}`
-        );
-        await modelClass.initializeForDocument(
-          yDoc,
-          dbEngine,
-          docId,
-          permissionHint
-        );
-      } else {
-        const staticModelName = modelClass?.modelName || "unknown";
-        console.warn(
-          `[ModelRegistry] Model ${staticModelName} (class name: ${modelClass?.name}) does not have a static initializeForDocument method or class is not defined.`
+      /**
+       * Creates the specified database engine (Node.js compatible only)
+       */
+      static async createEngine(config, allowFallback = true) {
+        const { type, options } = config;
+        switch (type) {
+          case "sqljs":
+            const sqljsEngine = new SqljsEngine(options);
+            await sqljsEngine.ensureReady();
+            return sqljsEngine;
+          case "node-sqlite":
+            if (!NodeSqliteEngine2) {
+              const hasBetterSqlite3 = await features.hasBetterSqlite3();
+              if (!hasBetterSqlite3) {
+                if (allowFallback) {
+                  console.warn(
+                    "[NodeDatabaseFactory] better-sqlite3 not installed, falling back to alternative engine"
+                  );
+                  return this.createFallbackEngine(type, config);
+                }
+                throw new Error(
+                  "better-sqlite3 package is required for node-sqlite engine. Install it with: npm install better-sqlite3"
+                );
+              }
+              throw new Error(
+                "NodeSqliteEngine not loaded. This should not happen."
+              );
+            }
+            const nodeSqliteEngine = new NodeSqliteEngine2(options);
+            await nodeSqliteEngine.ensureReady();
+            return nodeSqliteEngine;
+          case "alasql":
+            throw new Error("AlaSQLEngine not yet implemented.");
+          default:
+            const typeStr = type;
+            if (typeStr === "duckdb") {
+              if (allowFallback) {
+                console.warn(
+                  "[NodeDatabaseFactory] DuckDB-WASM not available in Node.js, falling back to alternative engine"
+                );
+                return this.createFallbackEngine(typeStr, config);
+              }
+              throw new Error(
+                "DuckDB-WASM engine is only available in browser environments"
+              );
+            }
+            if (typeStr === "node-duckdb") {
+              if (allowFallback) {
+                console.warn(
+                  "[NodeDatabaseFactory] Node DuckDB engine is no longer supported, falling back to alternative engine"
+                );
+                return this.createFallbackEngine(typeStr, config);
+              }
+              throw new Error("Node DuckDB engine is no longer supported");
+            }
+            throw new Error(`Unsupported database engine type: ${typeStr}`);
+        }
+      }
+      static async getEngine(config) {
+        await this.loadNodeEngines();
+        const configKey = JSON.stringify(config);
+        if (this.engines.has(configKey)) {
+          console.log(
+            `[NodeDatabaseFactory] Returning cached engine for config: ${configKey}`
+          );
+        }
+        console.log(
+          `[NodeDatabaseFactory] Creating engine for type: ${config.type}`
         );
+        try {
+          const engine = await this.createEngine(config);
+          console.log(
+            `[NodeDatabaseFactory] Engine for type ${config.type} is ready.`
+          );
+          return engine;
+        } catch (error) {
+          console.error(
+            `[NodeDatabaseFactory] Failed to create engine for type ${config.type}:`,
+            error
+          );
+          throw error;
+        }
       }
-    }
-    await this.initializeRelationships();
-    Logger.debug(
-      `[ModelRegistry] Model initialization complete for document ${docId}`
-    );
+      /**
+       * Gets information about available engines in Node.js environment
+       */
+      static async getAvailableEngines() {
+        const hasBetterSqlite3 = await features.hasBetterSqlite3();
+        const engines = [
+          {
+            type: "sqljs",
+            available: features.hasWebAssembly,
+            reason: !features.hasWebAssembly ? "WebAssembly not supported" : void 0
+          },
+          {
+            type: "node-sqlite",
+            available: hasBetterSqlite3,
+            reason: !hasBetterSqlite3 ? "better-sqlite3 package not installed" : void 0
+          }
+        ];
+        return engines;
+      }
+    };
   }
-  // New method to remove data from a disconnected document
-  async removeDocumentData(docId, dbEngine) {
-    Logger.debug(`[ModelRegistry] Removing data for document ${docId}...`);
-    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)."
-      );
-      return;
-    }
-    for (const [modelName, modelClass] of modelsToCleanup.entries()) {
-      try {
-        Logger.debug(
-          `[ModelRegistry] Removing ${modelName} data for document ${docId}`
-        );
-        await dbEngine.deleteByDocumentId(modelName, docId);
-        if (modelClass && typeof modelClass.cleanupDocumentData === "function") {
-          await modelClass.cleanupDocumentData(docId);
+});
+
+// src/engines/BrowserDatabaseFactory.ts
+var BrowserDatabaseFactory_exports = {};
+__export(BrowserDatabaseFactory_exports, {
+  BrowserDatabaseFactory: () => BrowserDatabaseFactory
+});
+var BrowserDatabaseFactory;
+var init_BrowserDatabaseFactory = __esm({
+  "src/engines/BrowserDatabaseFactory.ts"() {
+    "use strict";
+    init_SqljsEngine();
+    init_environment();
+    init_BaseModel();
+    BrowserDatabaseFactory = class {
+      /**
+       * Dynamically loads browser-compatible engines only
+       */
+      static async loadBrowserEngines() {
+        Logger.debug("[BrowserDatabaseFactory] Browser engines ready");
+      }
+      /**
+       * Auto-detects the best available engine for browser
+       */
+      static getRecommendedEngineType() {
+        if (features.hasWebAssembly) {
+          return "sqljs";
         }
-      } catch (error) {
-        console.error(
-          `[ModelRegistry] Error removing ${modelName} data for document ${docId}:`,
-          error
+        throw new Error(
+          "No compatible database engine found. WebAssembly is required for browser environments."
         );
       }
-    }
-    Logger.debug(`[ModelRegistry] Data removal complete for document ${docId}`);
-  }
-  // New method to initialize relationships
-  async initializeRelationships() {
-    if (!this.dbEngine) {
-      console.error(
-        "[ModelRegistry] DB engine not available for initializing relationships. Ensure initializeAll has been called."
-      );
-      return;
-    }
-    const dbEngine = this.dbEngine;
-    Logger.debug(
-      "[ModelRegistry] Initializing relationships for active models..."
-    );
-    const activeModels = this.getActiveModels();
-    for (const [modelName, modelClass] of activeModels.entries()) {
-      const modelSchema = modelClass.getSchema ? modelClass.getSchema() : null;
-      const relationshipsConfig = modelSchema?.options?.relationships;
-      if (relationshipsConfig) {
-        Logger.debug(
-          `[ModelRegistry] Setting up relationships for ${modelName}`
+      /**
+       * Creates a fallback engine when the requested engine is not available
+       */
+      static async createFallbackEngine(requestedType, config) {
+        const fallbackType = this.getRecommendedEngineType();
+        console.warn(
+          `[BrowserDatabaseFactory] Requested engine '${requestedType}' is not available. Falling back to '${fallbackType}'.`
         );
-        for (const relName in relationshipsConfig) {
-          const config = relationshipsConfig[relName];
-          if (!config.model) {
-            throw new Error(
-              `[ModelRegistry] Relationship "${relName}" on model "${modelName}" is missing a target model name.`
-            );
-          }
-          const targetModelClass = this.getModelClass(config.model);
-          if (!targetModelClass) {
-            throw new Error(
-              `[ModelRegistry] Relationship "${relName}" on model "${modelName}" refers to an unknown model "${config.model}". Ensure "${config.model}" is registered and included in the session.`
-            );
-          }
-          if (typeof targetModelClass.getSchema !== "function") {
-            throw new Error(
-              `[ModelRegistry] Target model "${config.model}" for relationship "${relName}" on "${modelName}" does not have a getSchema method.`
-            );
-          }
-          switch (config.type) {
-            case "refersTo":
-              Logger.debug(
-                `   - Adding '${relName}' (refersTo ${config.model}) to ${modelName}`
-              );
-              const refersToMethod = generateRefersToMethod(
-                modelClass,
-                config,
-                targetModelClass
-              );
-              this.addPrototypeMethod(modelClass, relName, refersToMethod);
-              break;
-            case "hasMany":
-              Logger.debug(
-                `   - Adding '${relName}' (hasMany ${config.model}) to ${modelName}`
-              );
-              const hasManyMethod = generateHasManyMethod(
-                modelClass,
-                config,
-                targetModelClass,
-                dbEngine
-              );
-              this.addPrototypeMethod(modelClass, relName, hasManyMethod);
-              break;
-            case "hasManyThrough":
-              const joinModelName = config.joinModel;
-              const joinModelClass = this.getModelClass(joinModelName);
-              if (!joinModelClass) {
-                throw new Error(
-                  `[ModelRegistry] Join model "${joinModelName}" for relationship "${relName}" on model "${modelName}" not found. Ensure it is registered and included in the session.`
+        const fallbackConfig = { ...config, type: fallbackType };
+        return this.createEngine(fallbackConfig, false);
+      }
+      /**
+       * Creates the specified database engine (browser-compatible only)
+       */
+      static async createEngine(config, allowFallback = true) {
+        const { type, options } = config;
+        const typeStr = type;
+        switch (type) {
+          case "sqljs":
+            const sqljsEngine = new SqljsEngine(options);
+            await sqljsEngine.ensureReady();
+            return sqljsEngine;
+          case "alasql":
+            throw new Error("AlaSQLEngine not yet implemented.");
+          default:
+            if (typeStr === "duckdb") {
+              if (allowFallback) {
+                console.warn(
+                  "[BrowserDatabaseFactory] DuckDB engine is no longer supported, falling back to alternative engine"
                 );
+                return this.createFallbackEngine(typeStr, config);
               }
-              if (typeof joinModelClass.getSchema !== "function") {
-                throw new Error(
-                  `[ModelRegistry] Join model "${joinModelName}" for relationship "${relName}" on "${modelName}" does not have a getSchema method.`
+              throw new Error("DuckDB engine is no longer supported");
+            }
+            if (typeStr === "node-sqlite" || typeStr === "node-duckdb") {
+              if (allowFallback) {
+                console.warn(
+                  `[BrowserDatabaseFactory] Engine '${typeStr}' is not available in browser. Falling back to browser-compatible engine.`
                 );
+                return this.createFallbackEngine(typeStr, config);
               }
-              Logger.debug(
-                `   - Adding '${relName}' (hasManyThrough ${config.model} via ${joinModelName}) to ${modelName}`
-              );
-              const hasManyThroughFetchMethod = generateHasManyThroughMethod(
-                modelClass,
-                config,
-                targetModelClass,
-                joinModelClass,
-                dbEngine
-              );
-              this.addPrototypeMethod(
-                modelClass,
-                relName,
-                hasManyThroughFetchMethod
-              );
-              const relNameSingular = config.model.endsWith("s") ? config.model.slice(0, -1) : config.model;
-              const capitalizedSingularRelName = relNameSingular.charAt(0).toUpperCase() + relNameSingular.slice(1);
-              const addMethodName = `add${capitalizedSingularRelName}`;
-              const addMethodLogic = generateHasManyThroughAddMethod(
-                modelClass,
-                config,
-                targetModelClass,
-                joinModelClass
-              );
-              this.addPrototypeMethod(
-                modelClass,
-                addMethodName,
-                addMethodLogic
-              );
-              Logger.debug(
-                `   - Adding '${addMethodName}' helper to ${modelName} (for relationship ${relName})`
-              );
-              const removeMethodName = `remove${capitalizedSingularRelName}`;
-              const removeMethodLogic = generateHasManyThroughRemoveMethod(
-                modelClass,
-                config,
-                targetModelClass,
-                joinModelClass
-              );
-              this.addPrototypeMethod(
-                modelClass,
-                removeMethodName,
-                removeMethodLogic
-              );
-              Logger.debug(
-                `   - Adding '${removeMethodName}' helper to ${modelName} (for relationship ${relName})`
-              );
-              break;
-            default:
-              console.warn(
-                `[ModelRegistry] Unknown relationship type "${config.type}" for ${relName} on ${modelName}. Skipping.`
-              );
-          }
-        }
-      }
-    }
-    Logger.debug("[ModelRegistry] Relationship initialization phase complete.");
-  }
-  // Helper to add methods to prototype
-  addPrototypeMethod(modelClass, methodName, methodLogic) {
-    Object.defineProperty(modelClass.prototype, methodName, {
-      value: methodLogic,
-      writable: true,
-      enumerable: false,
-      // Keep it clean, like other prototype methods
-      configurable: true
-    });
-  }
-  clearSessionState() {
-    this.activeSessionModels = null;
-    Logger.debug(
-      "[ModelRegistry] Session state cleared (activeSessionModels reset)."
-    );
-  }
-  getActiveModels() {
-    return this.activeSessionModels || this.models;
-  }
-  validateSessionModels() {
-    const activeModels = this.getActiveModels();
-    if (!activeModels || activeModels.size === 0) {
-      return;
-    }
-    for (const [modelName, modelClass] of activeModels.entries()) {
-      const modelSchema = modelClass.getSchema ? modelClass.getSchema() : null;
-      const relationships = modelSchema?.options?.relationships;
-      if (relationships) {
-        for (const relName in relationships) {
-          const config = relationships[relName];
-          const targetModelName = config.model;
-          if (!activeModels.has(targetModelName)) {
-            throw new Error(
-              `[ModelRegistry] Validation Error: Model "${modelName}" has a relationship "${relName}" that refers to model "${targetModelName}", but "${targetModelName}" is not active in the current session. Please include it in the 'models' array during initialization.`
-            );
-          }
-          if (config.type === "hasManyThrough") {
-            const joinModelName = config.joinModel;
-            if (!activeModels.has(joinModelName)) {
               throw new Error(
-                `[ModelRegistry] Validation Error: Model "${modelName}" has a relationship "${relName}" that uses join model "${joinModelName}", but "${joinModelName}" is not active in the current session. Please include it in the 'models' array during initialization.`
+                `Engine '${typeStr}' is only available in Node.js environments`
               );
             }
-          }
+            throw new Error(`Unsupported database engine type: ${typeStr}`);
         }
       }
-    }
+      static async getEngine(config) {
+        await this.loadBrowserEngines();
+        Logger.debug(
+          `[BrowserDatabaseFactory] Creating engine for type: ${config.type}`
+        );
+        try {
+          const engine = await this.createEngine(config);
+          Logger.debug(
+            `[BrowserDatabaseFactory] Engine for type ${config.type} is ready.`
+          );
+          return engine;
+        } catch (error) {
+          console.error(
+            `[BrowserDatabaseFactory] Failed to create engine for type ${config.type}:`,
+            error
+          );
+          throw error;
+        }
+      }
+      /**
+       * Gets information about available engines in browser environment
+       */
+      static getAvailableEngines() {
+        const engines = [
+          {
+            type: "sqljs",
+            available: features.hasWebAssembly,
+            reason: !features.hasWebAssembly ? "WebAssembly not supported" : void 0
+          },
+          {
+            type: "node-sqlite",
+            available: false,
+            reason: "Node.js engines not available in browser"
+          }
+        ];
+        return engines;
+      }
+    };
   }
-};
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BaseModel: () => BaseModel,
+  DatabaseEngine: () => DatabaseEngine,
+  DocumentClosedError: () => DocumentClosedError,
+  DocumentResolutionError: () => DocumentResolutionError,
+  Field: () => Field,
+  LogLevel: () => LogLevel,
+  Logger: () => Logger,
+  Model: () => Model,
+  ModelRegistry: () => ModelRegistry,
+  RecordNotFoundError: () => RecordNotFoundError,
+  StringSet: () => StringSet,
+  UniqueConstraintViolationError: () => UniqueConstraintViolationError,
+  attachAndRegisterModel: () => attachAndRegisterModel,
+  attachSchemaToClass: () => attachSchemaToClass,
+  autoRegisterModel: () => autoRegisterModel,
+  createModelClass: () => createModelClass,
+  defineModelSchema: () => defineModelSchema,
+  dumpYDocToPlain: () => dumpYDocToPlain,
+  generateULID: () => generateULID,
+  initJsBao: () => initJsBao,
+  resetJsBao: () => resetJsBao,
+  summarizePlainYDoc: () => summarizePlainYDoc
+});
+module.exports = __toCommonJS(index_exports);
 
 // src/initialize.ts
+init_ModelRegistry();
 init_BaseModel();
 init_environment();
 async function getDatabaseFactory() {
@@ -6250,12 +6656,16 @@ async function resetJsBao() {
   ormInitializationPromise = null;
   const { BaseModel: BaseModel3 } = await Promise.resolve().then(() => (init_BaseModel(), BaseModel_exports));
   BaseModel3.dbInstance = null;
-  Logger.debug("[resetJsBao] BaseModel database instance cleared.");
+  BaseModel3.connectedDocuments = /* @__PURE__ */ new Map();
+  BaseModel3.documentYMaps = /* @__PURE__ */ new Map();
+  BaseModel3.clearModelDefaultDocumentIds();
+  BaseModel3.clearGlobalDefaultDocumentId();
+  Logger.debug("[resetJsBao] BaseModel database instance and document state cleared.");
   const modelRegistryInstance = ModelRegistry.getInstance();
   modelRegistryInstance.clearSessionState();
   Logger.debug("[resetJsBao] ModelRegistry session state cleared.");
   Logger.info(
-    "[resetJsBao] js-bao initialization promise has been reset. DB engine (if any) destroyed. ModelRegistry session cleared."
+    "[resetJsBao] js-bao state fully reset. DB engine destroyed. Document mappings cleared. ModelRegistry session cleared."
   );
 }
 
@@ -6264,6 +6674,7 @@ init_documentTypes();
 init_BaseModel();
 
 // src/models/decorators.ts
+init_ModelRegistry();
 init_BaseModel();
 init_sql();
 var SCHEMA_FIELDS_PROPERTY = "_jsbaoSchemaFields";
@@ -6392,6 +6803,7 @@ init_StringSet();
 
 // src/models/schema.ts
 init_BaseModel();
+init_ModelRegistry();
 function defineModelSchema(input) {
   const { name, fields } = input;
   const options = {
@@ -6570,6 +6982,7 @@ var DatabaseEngine = class {
 };
 
 // src/index.ts
+init_ModelRegistry();
 init_BaseModel();
 
 // src/utils/yDocDump.ts