@atscript/db-sqlite 0.1.39 → 0.1.40

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="https://atscript.moost.org/logo.svg" alt="Atscript" width="120" />
+  <img src="https://atscript.dev/logo.svg" alt="Atscript" width="120" />
 </p>
 
 <h1 align="center">@atscript/db-sqlite</h1>
@@ -9,7 +9,7 @@
 </p>
 
 <p align="center">
-  <a href="https://atscript.moost.org">Documentation</a> · <a href="https://atscript.moost.org/db/adapters/sqlite">SQLite Adapter</a>
+  <a href="https://db.atscript.dev">Documentation</a> · <a href="https://db.atscript.dev/adapters/sqlite">SQLite Adapter</a>
 </p>
 
 ---
@@ -25,13 +25,13 @@ pnpm add @atscript/db-sqlite better-sqlite3
 ## Quick Start
 
 ```typescript
-import { DbSpace } from '@atscript/db'
-import { createAdapter } from '@atscript/db-sqlite'
+import { DbSpace } from "@atscript/db";
+import { createAdapter } from "@atscript/db-sqlite";
 
-const db = createAdapter('./myapp.db')
-const users = db.getTable(UsersType)
+const db = createAdapter("./myapp.db");
+const users = db.getTable(UsersType);
 
-await users.insertOne({ name: 'John', email: 'john@example.com' })
+await users.insertOne({ name: "John", email: "john@example.com" });
 ```
 
 ## Features
@@ -46,8 +46,8 @@ await users.insertOne({ name: 'John', email: 'john@example.com' })
 
 ## Documentation
 
-- [SQLite Adapter Guide](https://atscript.moost.org/db/adapters/sqlite)
-- [Full Documentation](https://atscript.moost.org)
+- [SQLite Adapter Guide](https://db.atscript.dev/adapters/sqlite)
+- [Full Documentation](https://db.atscript.dev)
 
 ## License
 

package/dist/index.cjs

@@ -1,43 +1,40 @@
-"use strict";
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-const __atscript_db = __toESM(require("@atscript/db"));
-const node_module = __toESM(require("node:module"));
-const __atscript_db_sql_tools = __toESM(require("@atscript/db-sql-tools"));
-
-//#region packages/db-sqlite/src/better-sqlite3-driver.ts
-function _define_property$1(obj, key, value) {
-	if (key in obj) Object.defineProperty(obj, key, {
-		value,
-		enumerable: true,
-		configurable: true,
-		writable: true
-	});
-else obj[key] = value;
-	return obj;
-}
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _atscript_db = require("@atscript/db");
+let node_module = require("node:module");
+let _atscript_db_sql_tools = require("@atscript/db-sql-tools");
+//#region src/better-sqlite3-driver.ts
+/**
+* {@link TSqliteDriver} implementation backed by `better-sqlite3`.
+*
+* Accepts either a file path (opens a new database) or a pre-created
+* `Database` instance from `better-sqlite3`.
+*
+* ```typescript
+* import { BetterSqlite3Driver } from '@atscript/db-sqlite'
+*
+* // In-memory database
+* const driver = new BetterSqlite3Driver(':memory:')
+*
+* // File-based database
+* const driver = new BetterSqlite3Driver('./my-data.db')
+*
+* // Pre-created instance
+* import Database from 'better-sqlite3'
+* const db = new Database(':memory:', { verbose: console.log })
+* const driver = new BetterSqlite3Driver(db)
+* ```
+*
+* Requires `better-sqlite3` to be installed:
+* ```bash
+* pnpm add better-sqlite3
+* ```
+*/
 var BetterSqlite3Driver = class {
+	db;
+	constructor(pathOrDb, options) {
+		if (typeof pathOrDb === "string") this.db = new ((0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)("better-sqlite3"))(pathOrDb, options);
+		else this.db = pathOrDb;
+	}
 	run(sql, params) {
 		const stmt = this.db.prepare(sql);
 		const result = params ? stmt.run(...params) : stmt.run();
@@ -60,18 +57,9 @@ var BetterSqlite3Driver = class {
 	close() {
 		this.db.close();
 	}
-	constructor(pathOrDb, options) {
-		_define_property$1(this, "db", void 0);
-		if (typeof pathOrDb === "string") {
-			const req = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
-			const Database = req("better-sqlite3");
-			this.db = new Database(pathOrDb, options);
-		} else this.db = pathOrDb;
-	}
 };
-
 //#endregion
-//#region packages/db-sqlite/src/sql-builder.ts
+//#region src/sql-builder.ts
 function esc(name) {
 	return name.replace(/"/g, "\"\"");
 }
@@ -81,7 +69,8 @@ function esc(name) {
 * - `abc$` → `%abc`
 * - `^abc$` → `abc`
 * - `abc` → `%abc%`
-*/ function regexToLike(pattern) {
+*/
+function regexToLike(pattern) {
 	const hasStart = pattern.startsWith("^");
 	const hasEnd = pattern.endsWith("$");
 	let core = pattern;
@@ -102,9 +91,9 @@ const sqliteDialect = {
 		return `"${esc(name)}"`;
 	},
 	unlimitedLimit: "-1",
-	toValue: __atscript_db_sql_tools.toSqlValue,
+	toValue: _atscript_db_sql_tools.toSqlValue,
 	toParam(value) {
-		if (value === undefined) return null;
+		if (value === void 0) return null;
 		return typeof value === "boolean" ? value ? 1 : 0 : value;
 	},
 	regex(quotedCol, value) {
@@ -116,27 +105,60 @@ const sqliteDialect = {
 	},
 	createViewPrefix: "CREATE VIEW IF NOT EXISTS"
 };
+/**
+* Builds an INSERT statement.
+*
+* @param table - Table name.
+* @param data - Column→value map.
+* @returns `{ sql, params }` ready for `driver.run()`.
+*/
 function buildInsert(table, data) {
-	return (0, __atscript_db_sql_tools.buildInsert)(sqliteDialect, table, data);
+	return (0, _atscript_db_sql_tools.buildInsert)(sqliteDialect, table, data);
 }
+/**
+* Builds a SELECT statement with optional sort, limit, offset, projection.
+*/
 function buildSelect(table, where, controls) {
-	return (0, __atscript_db_sql_tools.buildSelect)(sqliteDialect, table, where, controls);
+	return (0, _atscript_db_sql_tools.buildSelect)(sqliteDialect, table, where, controls);
 }
-function buildUpdate(table, data, where) {
-	return (0, __atscript_db_sql_tools.buildUpdate)(sqliteDialect, table, data, where);
+/**
+* Builds an UPDATE ... SET ... WHERE statement.
+*/
+function buildUpdate(table, data, where, ops) {
+	return (0, _atscript_db_sql_tools.buildUpdate)(sqliteDialect, table, data, where, void 0, ops);
 }
+/**
+* Builds a DELETE ... WHERE statement.
+*/
 function buildDelete(table, where) {
-	return (0, __atscript_db_sql_tools.buildDelete)(sqliteDialect, table, where);
+	return (0, _atscript_db_sql_tools.buildDelete)(sqliteDialect, table, where);
 }
+/**
+* Builds a CREATE VIEW IF NOT EXISTS statement from a view plan and column mappings.
+*
+* @param viewName - The view name.
+* @param plan - Resolved view plan (entry table, joins, filter).
+* @param columns - Column mappings (view column → source table.column).
+* @param resolveFieldRef - Resolves a query field ref to `"table"."column"` SQL.
+*/
 function buildCreateView(viewName, plan, columns, resolveFieldRef) {
-	return (0, __atscript_db_sql_tools.buildCreateView)(sqliteDialect, viewName, plan, columns, resolveFieldRef);
+	return (0, _atscript_db_sql_tools.buildCreateView)(sqliteDialect, viewName, plan, columns, resolveFieldRef);
 }
+/**
+* Builds a SELECT ... GROUP BY statement with aggregate functions.
+*/
 function buildAggregateSelect(table, where, controls) {
-	return (0, __atscript_db_sql_tools.buildAggregateSelect)(sqliteDialect, table, where, controls);
+	return (0, _atscript_db_sql_tools.buildAggregateSelect)(sqliteDialect, table, where, controls);
 }
+/**
+* Builds a COUNT query for the number of distinct groups.
+*/
 function buildAggregateCount(table, where, controls) {
-	return (0, __atscript_db_sql_tools.buildAggregateCount)(sqliteDialect, table, where, controls);
+	return (0, _atscript_db_sql_tools.buildAggregateCount)(sqliteDialect, table, where, controls);
 }
+/**
+* Maps Atscript design types to SQLite storage types.
+*/
 function sqliteTypeFromDesignType(designType) {
 	switch (designType) {
 		case "number":
@@ -147,6 +169,10 @@ function sqliteTypeFromDesignType(designType) {
 		default: return "TEXT";
 	}
 }
+/**
+* Builds a CREATE TABLE IF NOT EXISTS statement from field descriptors.
+* Uses pre-computed {@link TDbFieldMeta} — no raw type introspection needed.
+*/
 function buildCreateTable(table, fields, foreignKeys) {
 	const colDefs = [];
 	const primaryKeys = fields.filter((f) => f.isPrimaryKey);
@@ -159,7 +185,7 @@ function buildCreateTable(table, fields, foreignKeys) {
 			if (field.defaultValue?.kind === "fn" && field.defaultValue.fn === "increment" && (field.designType === "number" || field.designType === "integer")) def += " AUTOINCREMENT";
 		}
 		if (!field.optional && !field.isPrimaryKey) def += " NOT NULL";
-		if (field.defaultValue?.kind === "value") def += ` DEFAULT ${(0, __atscript_db_sql_tools.defaultValueToSqlLiteral)(field.designType, field.defaultValue.value)}`;
+		if (field.defaultValue?.kind === "value") def += ` DEFAULT ${(0, _atscript_db_sql_tools.defaultValueToSqlLiteral)(field.designType, field.defaultValue.value)}`;
 		if (field.collate) def += ` COLLATE ${field.collate.toUpperCase()}`;
 		colDefs.push(def);
 	}
@@ -171,47 +197,64 @@ function buildCreateTable(table, fields, foreignKeys) {
 		const localCols = fk.fields.map((f) => `"${esc(f)}"`).join(", ");
 		const targetCols = fk.targetFields.map((f) => `"${esc(f)}"`).join(", ");
 		let constraint = `FOREIGN KEY (${localCols}) REFERENCES "${esc(fk.targetTable)}" (${targetCols})`;
-		if (fk.onDelete) constraint += ` ON DELETE ${(0, __atscript_db_sql_tools.refActionToSql)(fk.onDelete)}`;
-		if (fk.onUpdate) constraint += ` ON UPDATE ${(0, __atscript_db_sql_tools.refActionToSql)(fk.onUpdate)}`;
+		if (fk.onDelete) constraint += ` ON DELETE ${(0, _atscript_db_sql_tools.refActionToSql)(fk.onDelete)}`;
+		if (fk.onUpdate) constraint += ` ON UPDATE ${(0, _atscript_db_sql_tools.refActionToSql)(fk.onUpdate)}`;
 		colDefs.push(constraint);
 	}
 	return `CREATE TABLE IF NOT EXISTS "${esc(table)}" (${colDefs.join(", ")})`;
 }
-
 //#endregion
-//#region packages/db-sqlite/src/filter-builder.ts
+//#region src/filter-builder.ts
+/**
+* Translates a uniqu filter expression into a parameterized SQL WHERE clause.
+*
+* @returns `{ sql, params }` — the WHERE clause (without "WHERE") and bound params.
+*          Returns `{ sql: '1=1', params: [] }` for empty/null filters.
+*/
 function buildWhere(filter) {
-	return (0, __atscript_db_sql_tools.buildWhere)(sqliteDialect, filter);
+	return (0, _atscript_db_sql_tools.buildWhere)(sqliteDialect, filter);
 }
+/**
+* Like {@link buildWhere} but prefixes all column references with a table alias.
+* Produces `alias."col"` instead of `"col"` — needed for JOINed queries (e.g. FTS5 search).
+*/
 function buildPrefixedWhere(alias, filter) {
-	return (0, __atscript_db_sql_tools.buildWhere)({
+	return (0, _atscript_db_sql_tools.buildWhere)({
 		...sqliteDialect,
 		quoteIdentifier(name) {
 			return `${alias}."${esc(name)}"`;
 		}
 	}, filter);
 }
-
 //#endregion
-//#region packages/db-sqlite/src/sqlite-adapter.ts
-function _define_property(obj, key, value) {
-	if (key in obj) Object.defineProperty(obj, key, {
-		value,
-		enumerable: true,
-		configurable: true,
-		writable: true
-	});
-else obj[key] = value;
-	return obj;
-}
-var SqliteAdapter = class extends __atscript_db.BaseDbAdapter {
+//#region src/sqlite-adapter.ts
+/**
+* SQLite adapter for {@link AtscriptDbTable}.
+*
+* Accepts any {@link TSqliteDriver} implementation — the actual SQLite engine
+* is fully swappable (better-sqlite3, node:sqlite, sql.js, etc.).
+*
+* Usage:
+* ```typescript
+* import { BetterSqlite3Driver } from '@atscript/db-sqlite'
+*
+* const driver = new BetterSqlite3Driver(':memory:')
+* const adapter = new SqliteAdapter(driver)
+* const users = new AtscriptDbTable(UsersType, adapter)
+* ```
+*/
+var SqliteAdapter = class extends _atscript_db.BaseDbAdapter {
 	supportsNativeValueDefaults() {
 		return true;
 	}
+	constructor(driver) {
+		super();
+		this.driver = driver;
+		this.driver.exec("PRAGMA foreign_keys = ON");
+	}
 	async _beginTransaction() {
 		this._log("BEGIN");
 		this.driver.exec("BEGIN");
-		return undefined;
 	}
 	async _commitTransaction() {
 		this._log("COMMIT");
@@ -221,10 +264,12 @@ var SqliteAdapter = class extends __atscript_db.BaseDbAdapter {
 		this._log("ROLLBACK");
 		this.driver.exec("ROLLBACK");
 	}
-	/** SQLite does not use schemas — override to always exclude schema. */ resolveTableName() {
+	/** SQLite does not use schemas — override to always exclude schema. */
+	resolveTableName() {
 		return super.resolveTableName(false);
 	}
-	/** SQLite enforces FK constraints natively via PRAGMA foreign_keys. */ supportsNativeForeignKeys() {
+	/** SQLite enforces FK constraints natively via PRAGMA foreign_keys. */
+	supportsNativeForeignKeys() {
 		return true;
 	}
 	prepareId(id, _fieldType) {
@@ -233,21 +278,22 @@ var SqliteAdapter = class extends __atscript_db.BaseDbAdapter {
 	/**
 	* Wraps a write operation to catch native SQLite constraint errors
 	* and rethrow as structured `DbError`.
-	*/ _wrapConstraintError(fn) {
+	*/
+	_wrapConstraintError(fn) {
 		try {
 			return fn();
 		} catch (error) {
 			if (error instanceof Error) {
-				if (error.message.includes("FOREIGN KEY constraint failed")) throw new __atscript_db.DbError("FK_VIOLATION", [{
+				if (error.message.includes("FOREIGN KEY constraint failed")) throw new _atscript_db.DbError("FK_VIOLATION", [{
 					path: "",
 					message: error.message
 				}]);
 				const uniqueMatch = error.message.match(/UNIQUE constraint failed:\s*\S+\.(\S+)/);
-				if (uniqueMatch) throw new __atscript_db.DbError("CONFLICT", [{
+				if (uniqueMatch) throw new _atscript_db.DbError("CONFLICT", [{
 					path: uniqueMatch[1],
 					message: error.message
 				}]);
-				if (error.message.includes("UNIQUE constraint failed")) throw new __atscript_db.DbError("CONFLICT", [{
+				if (error.message.includes("UNIQUE constraint failed")) throw new _atscript_db.DbError("CONFLICT", [{
 					path: "",
 					message: error.message
 				}]);
@@ -294,46 +340,39 @@ var SqliteAdapter = class extends __atscript_db.BaseDbAdapter {
 	}
 	async count(query) {
 		const where = buildWhere(query.filter);
-		const tableName = this.resolveTableName();
-		const sql = `SELECT COUNT(*) as cnt FROM "${esc(tableName)}" WHERE ${where.sql}`;
+		const sql = `SELECT COUNT(*) as cnt FROM "${esc(this.resolveTableName())}" WHERE ${where.sql}`;
 		this._log(sql, where.params);
-		const row = this.driver.get(sql, where.params);
-		return row?.cnt ?? 0;
+		return this.driver.get(sql, where.params)?.cnt ?? 0;
 	}
 	async aggregate(query) {
 		const where = buildWhere(query.filter);
 		const tableName = this.resolveTableName();
 		if (query.controls.$count) {
-			const { sql: sql$1, params: params$1 } = buildAggregateCount(tableName, where, query.controls);
-			this._log(sql$1, params$1);
-			const row = this.driver.get(sql$1, params$1);
-			return [{ count: row?.count ?? 0 }];
+			const { sql, params } = buildAggregateCount(tableName, where, query.controls);
+			this._log(sql, params);
+			return [{ count: this.driver.get(sql, params)?.count ?? 0 }];
 		}
 		const { sql, params } = buildAggregateSelect(tableName, where, query.controls);
 		this._log(sql, params);
 		return this.driver.all(sql, params);
 	}
-	async updateOne(filter, data) {
+	async updateOne(filter, data, ops) {
 		const where = buildWhere(filter);
 		const tableName = this.resolveTableName();
-		const setClauses = [];
-		const setParams = [];
-		for (const [key, value] of Object.entries(data)) {
-			setClauses.push(`"${esc(key)}" = ?`);
-			setParams.push((0, __atscript_db_sql_tools.toSqlValue)(value));
-		}
-		const sql = `UPDATE "${esc(tableName)}" SET ${setClauses.join(", ")} WHERE rowid = (SELECT rowid FROM "${esc(tableName)}" WHERE ${where.sql} LIMIT 1)`;
-		const allParams = [...setParams, ...where.params];
-		this._log(sql, allParams);
-		const result = this._wrapConstraintError(() => this.driver.run(sql, allParams));
+		const { sql, params } = buildUpdate(tableName, data, {
+			sql: `rowid = (SELECT rowid FROM "${esc(tableName)}" WHERE ${where.sql} LIMIT 1)`,
+			params: where.params
+		}, ops);
+		this._log(sql, params);
+		const result = this._wrapConstraintError(() => this.driver.run(sql, params));
 		return {
 			matchedCount: result.changes,
 			modifiedCount: result.changes
 		};
 	}
-	async updateMany(filter, data) {
+	async updateMany(filter, data, ops) {
 		const where = buildWhere(filter);
-		const { sql, params } = buildUpdate(this.resolveTableName(), data, where);
+		const { sql, params } = buildUpdate(this.resolveTableName(), data, where, ops);
 		this._log(sql, params);
 		const result = this._wrapConstraintError(() => this.driver.run(sql, params));
 		return {
@@ -344,11 +383,10 @@ var SqliteAdapter = class extends __atscript_db.BaseDbAdapter {
 	async replaceOne(filter, data) {
 		const where = buildWhere(filter);
 		const tableName = this.resolveTableName();
-		const limitedWhere = {
+		const { sql, params } = buildUpdate(tableName, data, {
 			sql: `rowid = (SELECT rowid FROM "${esc(tableName)}" WHERE ${where.sql} LIMIT 1)`,
 			params: where.params
-		};
-		const { sql, params } = buildUpdate(tableName, data, limitedWhere);
+		});
 		this._log(sql, params);
 		const result = this._wrapConstraintError(() => this.driver.run(sql, params));
 		return {
@@ -371,27 +409,27 @@ var SqliteAdapter = class extends __atscript_db.BaseDbAdapter {
 		const tableName = this.resolveTableName();
 		const sql = `DELETE FROM "${esc(tableName)}" WHERE rowid = (SELECT rowid FROM "${esc(tableName)}" WHERE ${where.sql} LIMIT 1)`;
 		this._log(sql, where.params);
-		const result = this._wrapConstraintError(() => this.driver.run(sql, where.params));
-		return { deletedCount: result.changes };
+		return { deletedCount: this._wrapConstraintError(() => this.driver.run(sql, where.params)).changes };
 	}
 	async deleteMany(filter) {
 		const where = buildWhere(filter);
 		const { sql, params } = buildDelete(this.resolveTableName(), where);
 		this._log(sql, params);
-		const result = this._wrapConstraintError(() => this.driver.run(sql, params));
-		return { deletedCount: result.changes };
+		return { deletedCount: this._wrapConstraintError(() => this.driver.run(sql, params)).changes };
 	}
 	async ensureTable() {
-		if (this._table instanceof __atscript_db.AtscriptDbView) return this.ensureView();
+		if (this._table instanceof _atscript_db.AtscriptDbView) return this.ensureView();
 		const sql = buildCreateTable(this.resolveTableName(), this._table.fieldDescriptors, this._table.foreignKeys);
 		this._log(sql);
 		this.driver.exec(sql);
 		this._seedIncrementStart();
 	}
+	_incrementSeeded = false;
 	/**
 	* Seeds the sqlite_sequence table for auto-increment fields that have a start value.
 	* Only applies once per adapter instance (idempotent via INSERT OR IGNORE + flag).
-	*/ _seedIncrementStart() {
+	*/
+	_seedIncrementStart() {
 		if (this._incrementSeeded) return;
 		this._incrementSeeded = true;
 		const tableName = this.resolveTableName();
@@ -426,8 +464,8 @@ var SqliteAdapter = class extends __atscript_db.BaseDbAdapter {
 			const sqlType = this.typeMapper(field);
 			let ddl = `ALTER TABLE "${esc(tableName)}" ADD COLUMN "${esc(field.physicalName)}" ${sqlType}`;
 			if (!field.optional && !field.isPrimaryKey) ddl += " NOT NULL";
-			if (field.defaultValue?.kind === "value") ddl += ` DEFAULT ${(0, __atscript_db_sql_tools.defaultValueToSqlLiteral)(field.designType, field.defaultValue.value)}`;
-else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${(0, __atscript_db_sql_tools.defaultValueForType)(field.designType)}`;
+			if (field.defaultValue?.kind === "value") ddl += ` DEFAULT ${(0, _atscript_db_sql_tools.defaultValueToSqlLiteral)(field.designType, field.defaultValue.value)}`;
+			else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${(0, _atscript_db_sql_tools.defaultValueForType)(field.designType)}`;
 			if (field.collate) ddl += ` COLLATE ${field.collate.toUpperCase()}`;
 			this._log(ddl);
 			this.driver.exec(ddl);
@@ -458,7 +496,7 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${(0, __atscri
 				const selectExprs = commonCols.map((c) => {
 					const field = fieldsByName.get(c);
 					if (field && !field.optional && !field.isPrimaryKey) {
-						const fallback = field.defaultValue?.kind === "value" ? (0, __atscript_db_sql_tools.defaultValueToSqlLiteral)(field.designType, field.defaultValue.value) : (0, __atscript_db_sql_tools.defaultValueForType)(field.designType);
+						const fallback = field.defaultValue?.kind === "value" ? (0, _atscript_db_sql_tools.defaultValueToSqlLiteral)(field.designType, field.defaultValue.value) : (0, _atscript_db_sql_tools.defaultValueForType)(field.designType);
 						return `COALESCE("${esc(c)}", ${fallback}) AS "${esc(c)}"`;
 					}
 					return `"${esc(c)}"`;
@@ -515,8 +553,7 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${(0, __atscri
 		return sqliteTypeFromDesignType(field.designType);
 	}
 	async getExistingColumnsForTable(tableName) {
-		const rows = this.driver.all(`PRAGMA table_info("${esc(tableName)}")`);
-		return rows.map((r) => ({
+		return this.driver.all(`PRAGMA table_info("${esc(tableName)}")`).map((r) => ({
 			name: r.name,
 			type: r.type,
 			notnull: r.notnull === 1,
@@ -564,12 +601,12 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${(0, __atscri
 			for (const [col, dir] of Object.entries(controls.$sort)) orderParts.push(`t."${esc(col)}" ${dir === -1 ? "DESC" : "ASC"}`);
 			if (orderParts.length > 0) sql += ` ORDER BY ${orderParts.join(", ")}`;
 		}
-		if (controls.$limit !== undefined) {
+		if (controls.$limit !== void 0) {
 			sql += ` LIMIT ?`;
 			params.push(controls.$limit);
 		}
-		if (controls.$skip !== undefined) {
-			if (controls.$limit === undefined) sql += ` LIMIT -1`;
+		if (controls.$skip !== void 0) {
+			if (controls.$limit === void 0) sql += ` LIMIT -1`;
 			sql += ` OFFSET ?`;
 			params.push(controls.$skip);
 		}
@@ -585,21 +622,23 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${(0, __atscri
 		const base = this._buildFtsBase(text, query.filter, indexName);
 		const countSql = `SELECT COUNT(*) as cnt ${base.fromWhere}`;
 		this._log(countSql, base.params);
-		const row = this.driver.get(countSql, base.params);
 		return {
 			data,
-			count: row?.cnt ?? 0
+			count: this.driver.get(countSql, base.params)?.cnt ?? 0
 		};
 	}
-	/** Builds FTS table name from index name: `<table>__fts__<indexName>`. */ _ftsTableName(indexName) {
+	/** Builds FTS table name from index name: `<table>__fts__<indexName>`. */
+	_ftsTableName(indexName) {
 		return `${this.resolveTableName()}__fts__${indexName}`;
 	}
-	/** Returns fulltext indexes from table metadata. */ _getFulltextIndexes() {
+	/** Returns fulltext indexes from table metadata. */
+	_getFulltextIndexes() {
 		const result = [];
 		for (const index of this._table.indexes.values()) if (index.type === "fulltext") result.push(index);
 		return result;
 	}
-	/** Resolves a fulltext index by name, or returns the first available. */ _resolveFtsIndex(indexName) {
+	/** Resolves a fulltext index by name, or returns the first available. */
+	_resolveFtsIndex(indexName) {
 		const ftIndexes = this._getFulltextIndexes();
 		if (ftIndexes.length === 0) throw new Error("No search index available");
 		if (indexName) {
@@ -612,7 +651,8 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${(0, __atscri
 	/**
 	* Builds the shared FROM+JOIN+WHERE fragment for FTS5 queries.
 	* Both data and count queries reuse this to avoid duplicating index resolution and filter translation.
-	*/ _buildFtsBase(text, filter, indexName) {
+	*/
+	_buildFtsBase(text, filter, indexName) {
 		const ftsIndex = this._resolveFtsIndex(indexName);
 		const ftsTable = this._ftsTableName(ftsIndex.name);
 		const tableName = this.resolveTableName();
@@ -632,7 +672,8 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${(0, __atscri
 	}
 	/**
 	* Creates/drops FTS5 virtual tables and sync triggers to match desired fulltext indexes.
-	*/ _syncFtsIndexes(tableName) {
+	*/
+	_syncFtsIndexes(tableName) {
 		const ftIndexes = this._getFulltextIndexes();
 		const desiredFtsTables = new Set(ftIndexes.map((idx) => this._ftsTableName(idx.name)));
 		const existingFts = this.driver.all(`SELECT name, sql FROM sqlite_master WHERE type='table' AND name LIKE ?`, [`${tableName}__fts__%`]).filter((r) => r.sql.startsWith("CREATE VIRTUAL TABLE")).map((r) => r.name);
@@ -643,9 +684,9 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${(0, __atscri
 			if (!existingSet.has(ftsTable)) this._createFtsTable(tableName, ftsTable, index);
 		}
 	}
-	/** Creates an FTS5 virtual table with sync triggers and rebuilds the index. */ _createFtsTable(tableName, ftsTable, index) {
-		const fieldNames = index.fields.map((f) => `"${esc(f.name)}"`);
-		const fieldList = fieldNames.join(", ");
+	/** Creates an FTS5 virtual table with sync triggers and rebuilds the index. */
+	_createFtsTable(tableName, ftsTable, index) {
+		const fieldList = index.fields.map((f) => `"${esc(f.name)}"`).join(", ");
 		const createSql = `CREATE VIRTUAL TABLE IF NOT EXISTS "${esc(ftsTable)}" USING fts5(${fieldList}, content='${tableName.replace(/'/g, "''")}', content_rowid='rowid')`;
 		this._log(createSql);
 		this.driver.exec(createSql);
@@ -665,7 +706,8 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${(0, __atscri
 		this._log(rebuildSql);
 		this.driver.exec(rebuildSql);
 	}
-	/** Drops an FTS5 virtual table and its sync triggers. */ _dropFtsTable(ftsTable) {
+	/** Drops an FTS5 virtual table and its sync triggers. */
+	_dropFtsTable(ftsTable) {
 		for (const suffix of [
 			"__ai",
 			"__ad",
@@ -675,31 +717,27 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${(0, __atscri
 		this._log(sql);
 		this.driver.exec(sql);
 	}
-	/** Drops all FTS virtual tables and triggers for a content table. */ _dropAllFtsTables(tableName) {
+	/** Drops all FTS virtual tables and triggers for a content table. */
+	_dropAllFtsTables(tableName) {
 		const ftsTables = this.driver.all(`SELECT name, sql FROM sqlite_master WHERE type='table' AND name LIKE ?`, [`${tableName}__fts__%`]).filter((r) => r.sql.startsWith("CREATE VIRTUAL TABLE"));
 		for (const { name } of ftsTables) this._dropFtsTable(name);
 	}
-	constructor(driver) {
-		super(), _define_property(this, "driver", void 0), _define_property(this, "_incrementSeeded", void 0), this.driver = driver, this._incrementSeeded = false;
-		this.driver.exec("PRAGMA foreign_keys = ON");
-	}
 };
 /** Normalizes SQLite PRAGMA dflt_value to match serialized format.
-*  PRAGMA returns `'active'` (SQL-quoted), we store `active` (raw). */ function normalizeSqliteDefault(value) {
-	if (value === null) return undefined;
+*  PRAGMA returns `'active'` (SQL-quoted), we store `active` (raw). */
+function normalizeSqliteDefault(value) {
+	if (value === null) return;
 	if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
 	return value;
 }
-
 //#endregion
-//#region packages/db-sqlite/src/index.ts
+//#region src/index.ts
 function createAdapter(connection, options) {
 	const driver = new BetterSqlite3Driver(connection, options);
-	return new __atscript_db.DbSpace(() => new SqliteAdapter(driver));
+	return new _atscript_db.DbSpace(() => new SqliteAdapter(driver));
 }
-
 //#endregion
-exports.BetterSqlite3Driver = BetterSqlite3Driver
-exports.SqliteAdapter = SqliteAdapter
-exports.buildWhere = buildWhere
-exports.createAdapter = createAdapter
+exports.BetterSqlite3Driver = BetterSqlite3Driver;
+exports.SqliteAdapter = SqliteAdapter;
+exports.buildWhere = buildWhere;
+exports.createAdapter = createAdapter;