@atscript/db-sqlite 0.1.37 → 0.1.39

package/dist/index.cjs

@@ -22,8 +22,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const __atscript_utils_db = __toESM(require("@atscript/utils-db"));
-const __uniqu_core = __toESM(require("@uniqu/core"));
+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) {
@@ -62,7 +63,8 @@ var BetterSqlite3Driver = class {
 	constructor(pathOrDb, options) {
 		_define_property$1(this, "db", void 0);
 		if (typeof pathOrDb === "string") {
-			const Database = require("better-sqlite3");
+			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;
 	}
@@ -70,55 +72,80 @@ var BetterSqlite3Driver = class {
 
 //#endregion
 //#region packages/db-sqlite/src/sql-builder.ts
+function esc(name) {
+	return name.replace(/"/g, "\"\"");
+}
+/**
+* Basic regex-to-LIKE conversion.
+* - `^abc` → `abc%`
+* - `abc$` → `%abc`
+* - `^abc$` → `abc`
+* - `abc` → `%abc%`
+*/ function regexToLike(pattern) {
+	const hasStart = pattern.startsWith("^");
+	const hasEnd = pattern.endsWith("$");
+	let core = pattern;
+	if (hasStart) core = core.slice(1);
+	if (hasEnd) core = core.slice(0, -1);
+	core = core.replace(/%/g, "\\%").replace(/_/g, "\\_");
+	core = core.replace(/\.\*/g, "%").replace(/\./g, "_");
+	if (hasStart && hasEnd) return core;
+	if (hasStart) return `${core}%`;
+	if (hasEnd) return `%${core}`;
+	return `%${core}%`;
+}
+const sqliteDialect = {
+	quoteIdentifier(name) {
+		return `"${esc(name)}"`;
+	},
+	quoteTable(name) {
+		return `"${esc(name)}"`;
+	},
+	unlimitedLimit: "-1",
+	toValue: __atscript_db_sql_tools.toSqlValue,
+	toParam(value) {
+		if (value === undefined) return null;
+		return typeof value === "boolean" ? value ? 1 : 0 : value;
+	},
+	regex(quotedCol, value) {
+		const pattern = regexToLike(value instanceof RegExp ? value.source : String(value));
+		return {
+			sql: `${quotedCol} LIKE ?`,
+			params: [pattern]
+		};
+	},
+	createViewPrefix: "CREATE VIEW IF NOT EXISTS"
+};
 function buildInsert(table, data) {
-	const keys = Object.keys(data);
-	const cols = keys.map((k) => `"${esc(k)}"`).join(", ");
-	const placeholders = keys.map(() => "?").join(", ");
-	return {
-		sql: `INSERT INTO "${esc(table)}" (${cols}) VALUES (${placeholders})`,
-		params: keys.map((k) => toSqliteValue(data[k]))
-	};
+	return (0, __atscript_db_sql_tools.buildInsert)(sqliteDialect, table, data);
 }
 function buildSelect(table, where, controls) {
-	const cols = buildProjection(controls?.$select);
-	let sql = `SELECT ${cols} FROM "${esc(table)}" WHERE ${where.sql}`;
-	const params = [...where.params];
-	if (controls?.$sort) {
-		const orderParts = [];
-		for (const [col, dir] of Object.entries(controls.$sort)) orderParts.push(`"${esc(col)}" ${dir === -1 ? "DESC" : "ASC"}`);
-		if (orderParts.length > 0) sql += ` ORDER BY ${orderParts.join(", ")}`;
-	}
-	if (controls?.$limit !== undefined) {
-		sql += ` LIMIT ?`;
-		params.push(controls.$limit);
-	}
-	if (controls?.$skip !== undefined) {
-		if (controls.$limit === undefined) sql += ` LIMIT -1`;
-		sql += ` OFFSET ?`;
-		params.push(controls.$skip);
-	}
-	return {
-		sql,
-		params
-	};
+	return (0, __atscript_db_sql_tools.buildSelect)(sqliteDialect, table, where, controls);
 }
 function buildUpdate(table, data, where) {
-	const setClauses = [];
-	const params = [];
-	for (const [key, value] of Object.entries(data)) {
-		setClauses.push(`"${esc(key)}" = ?`);
-		params.push(toSqliteValue(value));
-	}
-	return {
-		sql: `UPDATE "${esc(table)}" SET ${setClauses.join(", ")} WHERE ${where.sql}`,
-		params: [...params, ...where.params]
-	};
+	return (0, __atscript_db_sql_tools.buildUpdate)(sqliteDialect, table, data, where);
 }
 function buildDelete(table, where) {
-	return {
-		sql: `DELETE FROM "${esc(table)}" WHERE ${where.sql}`,
-		params: [...where.params]
-	};
+	return (0, __atscript_db_sql_tools.buildDelete)(sqliteDialect, table, where);
+}
+function buildCreateView(viewName, plan, columns, resolveFieldRef) {
+	return (0, __atscript_db_sql_tools.buildCreateView)(sqliteDialect, viewName, plan, columns, resolveFieldRef);
+}
+function buildAggregateSelect(table, where, controls) {
+	return (0, __atscript_db_sql_tools.buildAggregateSelect)(sqliteDialect, table, where, controls);
+}
+function buildAggregateCount(table, where, controls) {
+	return (0, __atscript_db_sql_tools.buildAggregateCount)(sqliteDialect, table, where, controls);
+}
+function sqliteTypeFromDesignType(designType) {
+	switch (designType) {
+		case "number":
+		case "integer":
+		case "decimal": return "REAL";
+		case "boolean": return "INTEGER";
+		case "string": return "TEXT";
+		default: return "TEXT";
+	}
 }
 function buildCreateTable(table, fields, foreignKeys) {
 	const colDefs = [];
@@ -127,9 +154,13 @@ function buildCreateTable(table, fields, foreignKeys) {
 		if (field.ignored) continue;
 		const sqlType = field.isPrimaryKey && (field.designType === "number" || field.designType === "integer") ? "INTEGER" : sqliteTypeFromDesignType(field.designType);
 		let def = `"${esc(field.physicalName)}" ${sqlType}`;
-		if (field.isPrimaryKey && primaryKeys.length === 1) def += " PRIMARY KEY";
+		if (field.isPrimaryKey && primaryKeys.length === 1) {
+			def += " PRIMARY KEY";
+			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 ${sqlStringLiteral(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);
 	}
 	if (primaryKeys.length > 1) {
@@ -140,234 +171,25 @@ 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 ${refActionToSql(fk.onDelete)}`;
-		if (fk.onUpdate) constraint += ` ON UPDATE ${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(", ")})`;
 }
-function refActionToSql(action) {
-	switch (action) {
-		case "cascade": return "CASCADE";
-		case "restrict": return "RESTRICT";
-		case "setNull": return "SET NULL";
-		case "setDefault": return "SET DEFAULT";
-		default: return "NO ACTION";
-	}
-}
-function sqliteTypeFromDesignType(designType) {
-	switch (designType) {
-		case "number":
-		case "integer": return "REAL";
-		case "boolean": return "INTEGER";
-		case "string": return "TEXT";
-		default: return "TEXT";
-	}
-}
-function buildProjection(select) {
-	const fields = select?.asArray;
-	if (!fields) return "*";
-	let sql = "";
-	for (let i = 0; i < fields.length; i++) {
-		if (i > 0) sql += ", ";
-		sql += `"${esc(fields[i])}"`;
-	}
-	return sql || "*";
-}
-function esc(name) {
-	return name.replace(/"/g, "\"\"");
-}
-function sqlStringLiteral(value) {
-	return `'${value.replace(/'/g, "''")}'`;
-}
-function toSqliteValue(value) {
-	if (value === undefined) return null;
-	if (value === null) return null;
-	if (typeof value === "object") return JSON.stringify(value);
-	if (typeof value === "boolean") return value ? 1 : 0;
-	return value;
-}
-function buildCreateView(viewName, plan, columns, resolveFieldRef) {
-	const selectCols = columns.map((c) => `"${esc(c.sourceTable)}"."${esc(c.sourceColumn)}" AS "${esc(c.viewColumn)}"`).join(", ");
-	let sql = `CREATE VIEW IF NOT EXISTS "${esc(viewName)}" AS SELECT ${selectCols} FROM "${esc(plan.entryTable)}"`;
-	for (const join of plan.joins) {
-		const onClause = queryNodeToSql(join.condition, resolveFieldRef);
-		sql += ` JOIN "${esc(join.targetTable)}" ON ${onClause}`;
-	}
-	if (plan.filter) {
-		const whereClause = queryNodeToSql(plan.filter, resolveFieldRef);
-		sql += ` WHERE ${whereClause}`;
-	}
-	return sql;
-}
-const queryOpToSql = {
-	$eq: "=",
-	$ne: "!=",
-	$gt: ">",
-	$gte: ">=",
-	$lt: "<",
-	$lte: "<="
-};
-/**
-* Renders an AtscriptQueryNode tree to raw SQL (no parameters — for DDL use only).
-*/ function queryNodeToSql(node, resolveFieldRef) {
-	if ("$and" in node) {
-		const children = node.$and;
-		return children.map((n) => queryNodeToSql(n, resolveFieldRef)).join(" AND ");
-	}
-	if ("$or" in node) {
-		const children = node.$or;
-		return `(${children.map((n) => queryNodeToSql(n, resolveFieldRef)).join(" OR ")})`;
-	}
-	if ("$not" in node) return `NOT (${queryNodeToSql(node.$not, resolveFieldRef)})`;
-	const comp = node;
-	const leftSql = resolveFieldRef(comp.left);
-	const sqlOp = queryOpToSql[comp.op] || "=";
-	if (comp.right && typeof comp.right === "object" && "field" in comp.right) return `${leftSql} ${sqlOp} ${resolveFieldRef(comp.right)}`;
-	if (comp.right === null || comp.right === undefined) return comp.op === "$ne" ? `${leftSql} IS NOT NULL` : `${leftSql} IS NULL`;
-	if (typeof comp.right === "string") return `${leftSql} ${sqlOp} '${comp.right.replace(/'/g, "''")}'`;
-	return `${leftSql} ${sqlOp} ${comp.right}`;
-}
 
 //#endregion
 //#region packages/db-sqlite/src/filter-builder.ts
-const EMPTY_AND = {
-	sql: "1=1",
-	params: []
-};
-const EMPTY_OR = {
-	sql: "0=1",
-	params: []
-};
-/**
-* SQL visitor for `walkFilter` — renders a filter expression tree
-* into a parameterized SQL WHERE clause.
-*/ const sqlVisitor = {
-	comparison(field, op, value) {
-		const col = `"${esc(field)}"`;
-		const v = toSqliteParam(value);
-		switch (op) {
-			case "$eq": {
-				if (v === null) return {
-					sql: `${col} IS NULL`,
-					params: []
-				};
-				return {
-					sql: `${col} = ?`,
-					params: [v]
-				};
-			}
-			case "$ne": {
-				if (v === null) return {
-					sql: `${col} IS NOT NULL`,
-					params: []
-				};
-				return {
-					sql: `${col} != ?`,
-					params: [v]
-				};
-			}
-			case "$gt": return {
-				sql: `${col} > ?`,
-				params: [v]
-			};
-			case "$gte": return {
-				sql: `${col} >= ?`,
-				params: [v]
-			};
-			case "$lt": return {
-				sql: `${col} < ?`,
-				params: [v]
-			};
-			case "$lte": return {
-				sql: `${col} <= ?`,
-				params: [v]
-			};
-			case "$in": {
-				const arr = value.map(toSqliteParam);
-				if (arr.length === 0) return EMPTY_OR;
-				const placeholders = arr.map(() => "?").join(", ");
-				return {
-					sql: `${col} IN (${placeholders})`,
-					params: [...arr]
-				};
-			}
-			case "$nin": {
-				const arr = value.map(toSqliteParam);
-				if (arr.length === 0) return EMPTY_AND;
-				const placeholders = arr.map(() => "?").join(", ");
-				return {
-					sql: `${col} NOT IN (${placeholders})`,
-					params: [...arr]
-				};
-			}
-			case "$exists": return value ? {
-				sql: `${col} IS NOT NULL`,
-				params: []
-			} : {
-				sql: `${col} IS NULL`,
-				params: []
-			};
-			case "$regex": {
-				const pattern = regexToLike(value instanceof RegExp ? value.source : String(value));
-				return {
-					sql: `${col} LIKE ?`,
-					params: [pattern]
-				};
-			}
-			default: throw new Error(`Unsupported filter operator: ${op}`);
-		}
-	},
-	and(children) {
-		if (children.length === 0) return EMPTY_AND;
-		return {
-			sql: children.map((c) => c.sql).join(" AND "),
-			params: children.flatMap((c) => c.params)
-		};
-	},
-	or(children) {
-		if (children.length === 0) return EMPTY_OR;
-		return {
-			sql: `(${children.map((c) => c.sql).join(" OR ")})`,
-			params: children.flatMap((c) => c.params)
-		};
-	},
-	not(child) {
-		return {
-			sql: `NOT (${child.sql})`,
-			params: child.params
-		};
-	}
-};
 function buildWhere(filter) {
-	if (!filter || Object.keys(filter).length === 0) return EMPTY_AND;
-	return (0, __uniqu_core.walkFilter)(filter, sqlVisitor) ?? EMPTY_AND;
+	return (0, __atscript_db_sql_tools.buildWhere)(sqliteDialect, filter);
 }
-/**
-* Basic regex-to-LIKE conversion.
-* - `^abc` → `abc%`
-* - `abc$` → `%abc`
-* - `^abc$` → `abc`
-* - `abc` → `%abc%`
-*/ function regexToLike(pattern) {
-	const hasStart = pattern.startsWith("^");
-	const hasEnd = pattern.endsWith("$");
-	let core = pattern;
-	if (hasStart) core = core.slice(1);
-	if (hasEnd) core = core.slice(0, -1);
-	core = core.replace(/%/g, "\\%").replace(/_/g, "\\_");
-	core = core.replace(/\.\*/g, "%").replace(/\./g, "_");
-	if (hasStart && hasEnd) return core;
-	if (hasStart) return `${core}%`;
-	if (hasEnd) return `%${core}`;
-	return `%${core}%`;
-}
-/**
-* Converts a JS value to a SQLite-bindable parameter.
-* SQLite cannot bind booleans — they must be 0/1.
-*/ function toSqliteParam(value) {
-	if (typeof value === "boolean") return value ? 1 : 0;
-	return value;
+function buildPrefixedWhere(alias, filter) {
+	return (0, __atscript_db_sql_tools.buildWhere)({
+		...sqliteDialect,
+		quoteIdentifier(name) {
+			return `${alias}."${esc(name)}"`;
+		}
+	}, filter);
 }
 
 //#endregion
@@ -382,7 +204,10 @@ function _define_property(obj, key, value) {
 else obj[key] = value;
 	return obj;
 }
-var SqliteAdapter = class extends __atscript_utils_db.BaseDbAdapter {
+var SqliteAdapter = class extends __atscript_db.BaseDbAdapter {
+	supportsNativeValueDefaults() {
+		return true;
+	}
 	async _beginTransaction() {
 		this._log("BEGIN");
 		this.driver.exec("BEGIN");
@@ -411,30 +236,30 @@ var SqliteAdapter = class extends __atscript_utils_db.BaseDbAdapter {
 	*/ _wrapConstraintError(fn) {
 		try {
 			return fn();
-		} catch (e) {
-			if (e instanceof Error) {
-				if (e.message.includes("FOREIGN KEY constraint failed")) throw new __atscript_utils_db.DbError("FK_VIOLATION", [{
+		} catch (error) {
+			if (error instanceof Error) {
+				if (error.message.includes("FOREIGN KEY constraint failed")) throw new __atscript_db.DbError("FK_VIOLATION", [{
 					path: "",
-					message: e.message
+					message: error.message
 				}]);
-				const uniqueMatch = e.message.match(/UNIQUE constraint failed:\s*\S+\.(\S+)/);
-				if (uniqueMatch) throw new __atscript_utils_db.DbError("CONFLICT", [{
+				const uniqueMatch = error.message.match(/UNIQUE constraint failed:\s*\S+\.(\S+)/);
+				if (uniqueMatch) throw new __atscript_db.DbError("CONFLICT", [{
 					path: uniqueMatch[1],
-					message: e.message
+					message: error.message
 				}]);
-				if (e.message.includes("UNIQUE constraint failed")) throw new __atscript_utils_db.DbError("CONFLICT", [{
+				if (error.message.includes("UNIQUE constraint failed")) throw new __atscript_db.DbError("CONFLICT", [{
 					path: "",
-					message: e.message
+					message: error.message
 				}]);
 			}
-			throw e;
+			throw error;
 		}
 	}
 	async insertOne(data) {
 		const { sql, params } = buildInsert(this.resolveTableName(), data);
 		this._log(sql, params);
 		const result = this._wrapConstraintError(() => this.driver.run(sql, params));
-		return { insertedId: result.lastInsertRowid };
+		return { insertedId: this._resolveInsertedId(data, result.lastInsertRowid) };
 	}
 	async insertMany(data) {
 		return this.withTransaction(async () => {
@@ -443,7 +268,7 @@ var SqliteAdapter = class extends __atscript_utils_db.BaseDbAdapter {
 				const { sql, params } = buildInsert(this.resolveTableName(), row);
 				this._log(sql, params);
 				const result = this._wrapConstraintError(() => this.driver.run(sql, params));
-				ids.push(result.lastInsertRowid);
+				ids.push(this._resolveInsertedId(row, result.lastInsertRowid));
 			}
 			return {
 				insertedCount: ids.length,
@@ -475,6 +300,19 @@ var SqliteAdapter = class extends __atscript_utils_db.BaseDbAdapter {
 		const row = this.driver.get(sql, where.params);
 		return row?.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 } = buildAggregateSelect(tableName, where, query.controls);
+		this._log(sql, params);
+		return this.driver.all(sql, params);
+	}
 	async updateOne(filter, data) {
 		const where = buildWhere(filter);
 		const tableName = this.resolveTableName();
@@ -482,7 +320,7 @@ var SqliteAdapter = class extends __atscript_utils_db.BaseDbAdapter {
 		const setParams = [];
 		for (const [key, value] of Object.entries(data)) {
 			setClauses.push(`"${esc(key)}" = ?`);
-			setParams.push(toSqliteValue(value));
+			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];
@@ -544,10 +382,26 @@ var SqliteAdapter = class extends __atscript_utils_db.BaseDbAdapter {
 		return { deletedCount: result.changes };
 	}
 	async ensureTable() {
-		if (this._table instanceof __atscript_utils_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();
+	}
+	/**
+	* 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() {
+		if (this._incrementSeeded) return;
+		this._incrementSeeded = true;
+		const tableName = this.resolveTableName();
+		for (const def of this._table.defaults.values()) if (def.kind === "fn" && def.fn === "increment" && typeof def.start === "number") {
+			const seedSql = `INSERT OR IGNORE INTO sqlite_sequence(name, seq) VALUES(?, ?)`;
+			const params = [tableName, def.start - 1];
+			this._log(seedSql, params);
+			this.driver.run(seedSql, params);
+			break;
+		}
 	}
 	async ensureView() {
 		const view = this._table;
@@ -572,8 +426,9 @@ var SqliteAdapter = class extends __atscript_utils_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 ${sqlStringLiteral(field.defaultValue.value)}`;
-else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${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);
 			added.push(field.physicalName);
@@ -586,6 +441,7 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 	async recreateTable() {
 		const tableName = this.resolveTableName();
 		const tempName = `${tableName}__tmp_${Date.now()}`;
+		this._dropAllFtsTables(tableName);
 		this.driver.exec("PRAGMA foreign_keys = OFF");
 		this.driver.exec("PRAGMA legacy_alter_table = ON");
 		try {
@@ -602,7 +458,7 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 				const selectExprs = commonCols.map((c) => {
 					const field = fieldsByName.get(c);
 					if (field && !field.optional && !field.isPrimaryKey) {
-						const fallback = field.defaultValue?.kind === "value" ? sqlStringLiteral(field.defaultValue.value) : 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)}"`;
@@ -622,6 +478,7 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 	}
 	async dropTable() {
 		const tableName = this.resolveTableName();
+		this._dropAllFtsTables(tableName);
 		const ddl = `DROP TABLE IF EXISTS "${esc(tableName)}"`;
 		this._log(ddl);
 		this.driver.exec(ddl);
@@ -637,6 +494,7 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 		});
 	}
 	async dropTableByName(tableName) {
+		this._dropAllFtsTables(tableName);
 		const ddl = `DROP TABLE IF EXISTS "${esc(tableName)}"`;
 		this._log(ddl);
 		this.driver.exec(ddl);
@@ -684,23 +542,151 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 			},
 			shouldSkipType: (type) => type === "fulltext"
 		});
+		this._syncFtsIndexes(tableName);
+	}
+	getSearchIndexes() {
+		return this._getFulltextIndexes().map((idx) => ({
+			name: idx.name,
+			description: `FTS5 index (${idx.fields.map((f) => f.name).join(", ")})`,
+			type: "text"
+		}));
+	}
+	async search(text, query, indexName) {
+		if (!text.trim()) return [];
+		const base = this._buildFtsBase(text, query.filter, indexName);
+		const controls = query.controls || {};
+		let cols = "t.*";
+		if (controls.$select?.asArray?.length) cols = controls.$select.asArray.map((c) => `t."${esc(c)}"`).join(", ");
+		let sql = `SELECT ${cols} ${base.fromWhere}`;
+		const params = [...base.params];
+		if (controls.$sort) {
+			const orderParts = [];
+			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) {
+			sql += ` LIMIT ?`;
+			params.push(controls.$limit);
+		}
+		if (controls.$skip !== undefined) {
+			if (controls.$limit === undefined) sql += ` LIMIT -1`;
+			sql += ` OFFSET ?`;
+			params.push(controls.$skip);
+		}
+		this._log(sql, params);
+		return this.driver.all(sql, params);
+	}
+	async searchWithCount(text, query, indexName) {
+		if (!text.trim()) return {
+			data: [],
+			count: 0
+		};
+		const data = await this.search(text, query, indexName);
+		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
+		};
+	}
+	/** Builds FTS table name from index name: `<table>__fts__<indexName>`. */ _ftsTableName(indexName) {
+		return `${this.resolveTableName()}__fts__${indexName}`;
+	}
+	/** 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) {
+		const ftIndexes = this._getFulltextIndexes();
+		if (ftIndexes.length === 0) throw new Error("No search index available");
+		if (indexName) {
+			const found = ftIndexes.find((idx) => idx.name === indexName);
+			if (!found) throw new Error(`Search index "${indexName}" not found`);
+			return found;
+		}
+		return ftIndexes[0];
+	}
+	/**
+	* 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) {
+		const ftsIndex = this._resolveFtsIndex(indexName);
+		const ftsTable = this._ftsTableName(ftsIndex.name);
+		const tableName = this.resolveTableName();
+		const where = buildPrefixedWhere("t", filter);
+		let fromWhere = `FROM "${esc(tableName)}" AS t`;
+		fromWhere += ` JOIN "${esc(ftsTable)}" AS fts ON t.rowid = fts.rowid`;
+		fromWhere += ` WHERE fts."${esc(ftsTable)}" MATCH ?`;
+		const params = [text];
+		if (where.sql !== "1=1") {
+			fromWhere += ` AND (${where.sql})`;
+			params.push(...where.params);
+		}
+		return {
+			fromWhere,
+			params
+		};
+	}
+	/**
+	* Creates/drops FTS5 virtual tables and sync triggers to match desired fulltext indexes.
+	*/ _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);
+		for (const name of existingFts) if (!desiredFtsTables.has(name)) this._dropFtsTable(name);
+		const existingSet = new Set(existingFts);
+		for (const index of ftIndexes) {
+			const ftsTable = this._ftsTableName(index.name);
+			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(", ");
+		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);
+		const newFields = index.fields.map((f) => `new."${esc(f.name)}"`).join(", ");
+		const oldFields = index.fields.map((f) => `old."${esc(f.name)}"`).join(", ");
+		const ef = esc(ftsTable);
+		const aiSql = `CREATE TRIGGER IF NOT EXISTS "${esc(ftsTable + "__ai")}" AFTER INSERT ON "${esc(tableName)}" BEGIN INSERT INTO "${ef}"(rowid, ${fieldList}) VALUES (new.rowid, ${newFields}); END`;
+		this._log(aiSql);
+		this.driver.exec(aiSql);
+		const adSql = `CREATE TRIGGER IF NOT EXISTS "${esc(ftsTable + "__ad")}" AFTER DELETE ON "${esc(tableName)}" BEGIN INSERT INTO "${ef}"("${ef}", rowid, ${fieldList}) VALUES ('delete', old.rowid, ${oldFields}); END`;
+		this._log(adSql);
+		this.driver.exec(adSql);
+		const auSql = `CREATE TRIGGER IF NOT EXISTS "${esc(ftsTable + "__au")}" AFTER UPDATE ON "${esc(tableName)}" BEGIN INSERT INTO "${ef}"("${ef}", rowid, ${fieldList}) VALUES ('delete', old.rowid, ${oldFields}); INSERT INTO "${ef}"(rowid, ${fieldList}) VALUES (new.rowid, ${newFields}); END`;
+		this._log(auSql);
+		this.driver.exec(auSql);
+		const rebuildSql = `INSERT INTO "${ef}"("${ef}") VALUES ('rebuild')`;
+		this._log(rebuildSql);
+		this.driver.exec(rebuildSql);
+	}
+	/** Drops an FTS5 virtual table and its sync triggers. */ _dropFtsTable(ftsTable) {
+		for (const suffix of [
+			"__ai",
+			"__ad",
+			"__au"
+		]) this.driver.exec(`DROP TRIGGER IF EXISTS "${esc(ftsTable + suffix)}"`);
+		const sql = `DROP TABLE IF EXISTS "${esc(ftsTable)}"`;
+		this._log(sql);
+		this.driver.exec(sql);
+	}
+	/** 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), this.driver = 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");
 	}
 };
-/** Returns a safe SQLite DEFAULT literal for a given design type. */ function defaultValueForType(designType) {
-	switch (designType) {
-		case "number":
-		case "integer": return "0";
-		case "boolean": return "0";
-		default: return "''";
-	}
-}
 /** 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;
+	if (value === null) return undefined;
 	if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
 	return value;
 }
@@ -709,7 +695,7 @@ else if (!field.optional && !field.isPrimaryKey) ddl += ` DEFAULT ${defaultValue
 //#region packages/db-sqlite/src/index.ts
 function createAdapter(connection, options) {
 	const driver = new BetterSqlite3Driver(connection, options);
-	return new __atscript_utils_db.DbSpace(() => new SqliteAdapter(driver));
+	return new __atscript_db.DbSpace(() => new SqliteAdapter(driver));
 }
 
 //#endregion