@toiroakr/lines-db 0.9.1 → 0.10.0

package/dist/index.cjs

@@ -1,1499 +0,0 @@
-//#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
-let node_fs_promises = require("node:fs/promises");
-node_fs_promises = __toESM(node_fs_promises);
-let node_path = require("node:path");
-node_path = __toESM(node_path);
-let node_url = require("node:url");
-node_url = __toESM(node_url);
-let node_util = require("node:util");
-node_util = __toESM(node_util);
-
-//#region src/runtime.ts
-function detectRuntime() {
-	if (typeof process !== "undefined" && process.versions && process.versions.node) return "node";
-	return "unknown";
-}
-const RUNTIME = detectRuntime();
-
-//#endregion
-//#region src/sqlite-adapter.ts
-/**
-* Create a SQLite database instance for Node.js
-*/
-function createDatabase(path = ":memory:") {
-	if (RUNTIME === "node") return createNodeDatabase(path);
-	else throw new Error(`Unsupported runtime: ${RUNTIME}`);
-}
-/**
-* Create a Node.js SQLite database
-*/
-function createNodeDatabase(path) {
-	const { DatabaseSync } = require("node:sqlite");
-	const db = new DatabaseSync(path);
-	db.exec("PRAGMA foreign_keys = ON");
-	return {
-		prepare(sql) {
-			const stmt = db.prepare(sql);
-			return {
-				run(...params) {
-					return stmt.run(...params);
-				},
-				get(...params) {
-					return stmt.get(...params);
-				},
-				all(...params) {
-					return stmt.all(...params);
-				}
-			};
-		},
-		exec(sql) {
-			db.exec(sql);
-		},
-		close() {
-			db.close();
-		}
-	};
-}
-
-//#endregion
-//#region src/jsonl-reader.ts
-var JsonlReader = class {
-	static overrides = null;
-	/**
-	* Temporarily override the data returned for specific JSONL files.
-	* Useful for scenarios like migration validation where in-memory data should be used.
-	*/
-	static async withOverrides(overrides, fn) {
-		const normalized = /* @__PURE__ */ new Map();
-		for (const [filePath, rows] of overrides) normalized.set((0, node_path.normalize)(filePath), rows);
-		const previousOverrides = this.overrides;
-		this.overrides = normalized;
-		try {
-			return await fn();
-		} finally {
-			this.overrides = previousOverrides;
-		}
-	}
-	/**
-	* Read JSONL file and parse each line as JSON
-	*/
-	static async read(filePath) {
-		const overrideRows = this.overrides?.get((0, node_path.normalize)(filePath));
-		if (overrideRows) return overrideRows.map((row) => JSON.parse(JSON.stringify(row)));
-		return (await (0, node_fs_promises.readFile)(filePath, "utf-8")).trim().split("\n").filter((line) => line.trim().length > 0).map((line) => {
-			try {
-				return JSON.parse(line);
-			} catch (error) {
-				throw new Error(`Failed to parse JSON line: ${line}`, { cause: error });
-			}
-		});
-	}
-	/**
-	* Infer schema from JSONL data
-	*/
-	static inferSchema(tableName, data) {
-		if (data.length === 0) throw new Error("Cannot infer schema from empty data");
-		const columnTypes = /* @__PURE__ */ new Map();
-		const booleanColumns = /* @__PURE__ */ new Set();
-		const nonBooleanColumns = /* @__PURE__ */ new Set();
-		for (const row of data) for (const [key, value] of Object.entries(row)) {
-			if (!columnTypes.has(key)) columnTypes.set(key, /* @__PURE__ */ new Set());
-			columnTypes.get(key).add(this.inferType(value));
-			if (typeof value === "boolean") booleanColumns.add(key);
-			else if (value !== null) nonBooleanColumns.add(key);
-		}
-		const columns = [];
-		for (const [columnName, types] of columnTypes.entries()) {
-			const typeArray = Array.from(types);
-			let sqlType = "TEXT";
-			if (typeArray.length === 1) sqlType = typeArray[0];
-			else if (typeArray.every((t) => t === "INTEGER" || t === "REAL")) sqlType = "REAL";
-			else if (!typeArray.includes("NULL")) sqlType = "TEXT";
-			else if (typeArray.length === 2 && typeArray.includes("NULL")) sqlType = typeArray.find((t) => t !== "NULL");
-			const isBooleanColumn = booleanColumns.has(columnName) && !nonBooleanColumns.has(columnName);
-			columns.push({
-				name: columnName,
-				type: sqlType,
-				notNull: !typeArray.includes("NULL"),
-				valueType: isBooleanColumn ? "boolean" : void 0
-			});
-		}
-		const idColumn = columns.find((col) => col.name === "id");
-		if (idColumn) idColumn.primaryKey = true;
-		return {
-			name: tableName,
-			columns
-		};
-	}
-	static inferType(value) {
-		if (value === null || value === void 0) return "NULL";
-		if (typeof value === "number") return Number.isInteger(value) ? "INTEGER" : "REAL";
-		if (typeof value === "string") return "TEXT";
-		if (typeof value === "boolean") return "INTEGER";
-		if (typeof value === "object") return "JSON";
-		return "TEXT";
-	}
-};
-
-//#endregion
-//#region src/jsonl-writer.ts
-var JsonlWriter = class {
-	/**
-	* Write data to JSONL file
-	*/
-	static async write(filePath, data) {
-		await (0, node_fs_promises.writeFile)(filePath, data.map((obj) => JSON.stringify(obj)).join("\n") + "\n", "utf-8");
-	}
-	/**
-	* Append data to JSONL file
-	*/
-	static async append(filePath, data) {
-		const { readFile: readFile$1, writeFile: writeFile$2 } = await import("node:fs/promises");
-		try {
-			const existing = await readFile$1(filePath, "utf-8");
-			const lines = data.map((obj) => JSON.stringify(obj)).join("\n");
-			await writeFile$2(filePath, existing.trim() + "\n" + lines + "\n", "utf-8");
-		} catch (error) {
-			if (error.code === "ENOENT") await this.write(filePath, data);
-			else throw error;
-		}
-	}
-};
-
-//#endregion
-//#region src/schema-extensions.ts
-/**
-* Supported schema file extensions, in priority order.
-* The first match wins when discovering schema files.
-*/
-const SCHEMA_EXTENSIONS = [
-	".schema.ts",
-	".schema.mts",
-	".schema.cts"
-];
-/**
-* Map from schema extensions to their JavaScript import counterparts.
-*/
-const SCHEMA_TO_JS_IMPORT_MAP = {
-	".schema.ts": ".schema.js",
-	".schema.mts": ".schema.mjs",
-	".schema.cts": ".schema.cjs"
-};
-/**
-* Try each supported schema extension and return the full path of the first
-* one that exists on disk. Returns undefined if none is found.
-*/
-async function findSchemaFile(dir, tableName) {
-	for (const ext of SCHEMA_EXTENSIONS) {
-		const candidate = (0, node_path.join)(dir, `${tableName}${ext}`);
-		try {
-			await (0, node_fs_promises.access)(candidate);
-			return candidate;
-		} catch {}
-	}
-}
-/**
-* Synchronously find a schema file among directory entries.
-* Returns the full path of the first match, or undefined.
-*/
-function findSchemaFileInEntries(dataDirPath, tableName, entries) {
-	for (const ext of SCHEMA_EXTENSIONS) {
-		const candidateName = `${tableName}${ext}`;
-		if (entries.some((e) => e.isFile() && e.name === candidateName)) return (0, node_path.join)(dataDirPath, candidateName);
-	}
-}
-/**
-* Check if a filename matches any supported schema file pattern.
-*/
-function isSchemaFile(fileName) {
-	return SCHEMA_EXTENSIONS.some((ext) => fileName.endsWith(ext));
-}
-/**
-* Extract table name from a schema filename.
-* e.g., "users.schema.ts" -> "users", "users.schema.mts" -> "users"
-*/
-function extractTableNameFromSchemaFile(fileName) {
-	for (const ext of SCHEMA_EXTENSIONS) if (fileName.endsWith(ext)) return fileName.slice(0, -ext.length);
-	return null;
-}
-/**
-* Rewrite a TypeScript path to its JavaScript counterpart for ESM imports.
-* ".schema.ts" -> ".schema.js", ".schema.mts" -> ".schema.mjs", ".schema.cts" -> ".schema.cjs"
-*/
-function rewriteExtensionForImport(filePath) {
-	for (const [tsExt, jsExt] of Object.entries(SCHEMA_TO_JS_IMPORT_MAP)) if (filePath.endsWith(tsExt)) return filePath.slice(0, -tsExt.length) + jsExt;
-	return filePath;
-}
-
-//#endregion
-//#region src/schema-loader.ts
-var SchemaLoader = class {
-	/**
-	* Check if a schema file exists for a table
-	*/
-	static async hasSchema(jsonlPath) {
-		return await findSchemaFile((0, node_path.dirname)(jsonlPath), (0, node_path.basename)(jsonlPath, ".jsonl")) !== void 0;
-	}
-	/**
-	* Load a validation schema file for a table
-	* Requires ${tableName}.schema.{ts,mts,cts} to exist alongside the JSONL file
-	*/
-	static async loadSchema(jsonlPath) {
-		const dir = (0, node_path.dirname)(jsonlPath);
-		const tableName = (0, node_path.basename)(jsonlPath, ".jsonl");
-		const schemaPath = await findSchemaFile(dir, tableName);
-		if (!schemaPath) throw new Error(`Schema file not found for table '${tableName}'. Expected one of: ${SCHEMA_EXTENSIONS.map((ext) => `${tableName}${ext}`).join(", ")}`);
-		try {
-			const module$1 = await import(`${(0, node_url.pathToFileURL)(schemaPath).href}?t=${Date.now()}`);
-			const schema = module$1.default || module$1.schema;
-			if (schema && this.isStandardSchema(schema)) return schema;
-			throw new Error(`Schema file ${schemaPath} does not export a valid StandardSchema`);
-		} catch (error) {
-			throw new Error(`Failed to load schema for table '${tableName}' from ${schemaPath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error instanceof Error ? error : void 0 });
-		}
-	}
-	/**
-	* Check if an object implements the StandardSchema interface
-	*/
-	static isStandardSchema(obj) {
-		if (!obj || typeof obj !== "object") return false;
-		const standard = obj["~standard"];
-		if (!standard || typeof standard !== "object") return false;
-		const standardObj = standard;
-		return standardObj.version === 1 && typeof standardObj.vendor === "string" && typeof standardObj.validate === "function";
-	}
-};
-
-//#endregion
-//#region src/directory-scanner.ts
-var DirectoryScanner = class {
-	/**
-	* Scan directory for JSONL files and create table configurations
-	*/
-	static async scanDirectory(dataDir) {
-		const tables = /* @__PURE__ */ new Map();
-		try {
-			const files = await (0, node_fs_promises.readdir)(dataDir);
-			for (const file of files) if ((0, node_path.extname)(file) === ".jsonl") {
-				const tableName = (0, node_path.basename)(file, ".jsonl");
-				const jsonlPath = (0, node_path.join)(dataDir, file);
-				tables.set(tableName, {
-					jsonlPath,
-					autoInferSchema: true
-				});
-			}
-			if (tables.size === 0) console.warn(`Warning: No JSONL files found in directory: ${dataDir}`);
-			return tables;
-		} catch (error) {
-			throw new Error(`Failed to scan directory ${dataDir}: ${error instanceof Error ? error.message : String(error)}`);
-		}
-	}
-};
-
-//#endregion
-//#region src/schema.ts
-/**
-* Define a bidirectional schema with optional backward transformation
-*
-* @param schema - Standard Schema for validation
-* @param options - SchemaOptions object. When Input and Output types differ, backward transformation is required
-*
-* @example
-* // No transformation - backward not needed
-* const schema = defineSchema(
-*   v.object({ id: v.number(), name: v.string() })
-* );
-*
-* @example
-* // With transformation - backward REQUIRED
-* const schema = defineSchema(
-*   v.pipe(v.string(), v.transform(Number)),
-*   {
-*     backward: (num) => String(num)  // backward: number → string (REQUIRED)
-*   }
-* );
-*
-* @example
-* // With primary key and foreign key
-* const schema = defineSchema(
-*   v.object({ id: v.number(), customerId: v.number() }),
-*   {
-*     primaryKey: 'id',
-*     foreignKeys: [
-*       { column: 'customerId', references: { table: 'users', column: 'id' } }
-*     ]
-*   }
-* );
-*/
-function defineSchema(schema, ...args) {
-	const options = args[0];
-	const bidirectionalSchema = Object.create(schema);
-	if (options) {
-		if (options.backward) bidirectionalSchema.backward = options.backward;
-		if (options.primaryKey) bidirectionalSchema.primaryKey = options.primaryKey;
-		if (options.foreignKeys) bidirectionalSchema.foreignKeys = options.foreignKeys;
-		if (options.indexes) bidirectionalSchema.indexes = options.indexes;
-	}
-	Object.defineProperty(bidirectionalSchema, "~standard", {
-		value: schema["~standard"],
-		enumerable: true,
-		configurable: true
-	});
-	return bidirectionalSchema;
-}
-/**
-* Check if a schema has backward transformation
-*/
-function hasBackward(schema) {
-	return "backward" in schema && typeof schema.backward === "function";
-}
-
-//#endregion
-//#region src/database.ts
-var LinesDB = class LinesDB {
-	db;
-	config;
-	schemas = /* @__PURE__ */ new Map();
-	validationSchemas = /* @__PURE__ */ new Map();
-	tables = /* @__PURE__ */ new Map();
-	inTransaction = false;
-	constructor(config, dbPath) {
-		this.config = config;
-		this.db = createDatabase(dbPath ?? ":memory:");
-	}
-	static create(config, dbPath) {
-		return new LinesDB(config, dbPath);
-	}
-	/**
-	* Initialize database by loading all JSONL files or a specific table
-	* Uses dependency resolution to ensure foreign key references are loaded in correct order
-	* @param options Optional configuration for initialization
-	* @param options.tableName Optional table name to initialize. If not provided, initializes all tables
-	* @param options.detailedValidate If true, performs detailed validation by inserting rows one by one to catch constraint violations
-	* @param options.transform Optional transform function to apply to rows before validation (only applied to the specified tableName)
-	* @returns ValidationResult containing validation status, errors, and warnings
-	*/
-	async initialize(options) {
-		const allErrors = [];
-		const allWarnings = [];
-		const allRowCounts = /* @__PURE__ */ new Map();
-		const tableName = options?.tableName;
-		const detailedValidate = options?.detailedValidate ?? false;
-		const transform = options?.transform;
-		this.tables = await DirectoryScanner.scanDirectory(this.config.dataDir);
-		const tablesToLoad = tableName ? [tableName] : Array.from(this.tables.keys());
-		for (const tableNameToLoad of tablesToLoad) if (!this.tables.has(tableNameToLoad)) throw new Error(`Table '${tableNameToLoad}' not found in directory '${this.config.dataDir}'`);
-		const loadedTables = /* @__PURE__ */ new Set();
-		const loadingTables = /* @__PURE__ */ new Set();
-		const attemptedTables = /* @__PURE__ */ new Set();
-		const allDeferredForeignKeys = [];
-		for (const tableNameToLoad of tablesToLoad) if (!attemptedTables.has(tableNameToLoad)) {
-			const tableTransform = tableNameToLoad === tableName ? transform : void 0;
-			const { errors, warnings, rowCounts: tableRowCounts, deferredForeignKeys } = await this.loadTableWithDependencies(tableNameToLoad, loadedTables, loadingTables, attemptedTables, detailedValidate, tableTransform);
-			allErrors.push(...errors);
-			allWarnings.push(...warnings);
-			allDeferredForeignKeys.push(...deferredForeignKeys);
-			for (const [k, v] of tableRowCounts) allRowCounts.set(k, v);
-		}
-		if (detailedValidate && allDeferredForeignKeys.length > 0) for (const { tableName: tName, foreignKey: fk, filePath } of allDeferredForeignKeys) {
-			if (!loadedTables.has(fk.references.table)) continue;
-			const deferredErrors = this.validateDeferredForeignKey(tName, fk, filePath);
-			allErrors.push(...deferredErrors);
-		}
-		const tableResults = tablesToLoad.map((name) => {
-			const tableErrors = allErrors.filter((e) => e.tableName === name);
-			const tableWarnings = allWarnings.filter((w) => w.includes(`'${name}'`));
-			return {
-				tableName: name,
-				valid: tableErrors.length === 0,
-				rowCount: allRowCounts.get(name) ?? 0,
-				errors: tableErrors,
-				warnings: tableWarnings
-			};
-		});
-		return {
-			valid: allErrors.length === 0,
-			errors: allErrors,
-			warnings: allWarnings,
-			tableResults
-		};
-	}
-	/**
-	* Load a table and its dependencies recursively
-	*/
-	async loadTableWithDependencies(tableName, loadedTables, loadingTables, attemptedTables, detailedValidate, transform) {
-		const errors = [];
-		const warnings = [];
-		const rowCounts = /* @__PURE__ */ new Map();
-		const deferredForeignKeys = [];
-		if (attemptedTables.has(tableName)) return {
-			errors,
-			warnings,
-			rowCounts,
-			deferredForeignKeys
-		};
-		attemptedTables.add(tableName);
-		if (loadingTables.has(tableName)) throw new Error(`Circular dependency detected for table '${tableName}'`);
-		const tableConfig = this.tables.get(tableName);
-		if (!tableConfig) throw new Error(`Table configuration not found for '${tableName}'`);
-		loadingTables.add(tableName);
-		try {
-			let foreignKeys;
-			try {
-				const { pathToFileURL: pathToFileURL$1 } = await import("node:url");
-				const schemaPath = await findSchemaFile((0, node_path.dirname)(tableConfig.jsonlPath), (0, node_path.basename)(tableConfig.jsonlPath, ".jsonl"));
-				if (schemaPath) {
-					const schemaModule = await import(`${pathToFileURL$1(schemaPath).href}?t=${Date.now()}`);
-					foreignKeys = (schemaModule.schema || schemaModule.default)?.foreignKeys || schemaModule.foreignKeys;
-				}
-			} catch {}
-			if (foreignKeys && foreignKeys.length > 0) for (const fk of foreignKeys) {
-				const referencedTable = fk.references.table;
-				if (referencedTable === tableName) continue;
-				if (!attemptedTables.has(referencedTable)) if (this.tables.has(referencedTable)) {
-					const depResult = await this.loadTableWithDependencies(referencedTable, loadedTables, loadingTables, attemptedTables, detailedValidate, void 0);
-					errors.push(...depResult.errors);
-					warnings.push(...depResult.warnings);
-					deferredForeignKeys.push(...depResult.deferredForeignKeys);
-					for (const [k, v] of depResult.rowCounts) rowCounts.set(k, v);
-				} else throw new Error(`Foreign key reference to non-existent table '${referencedTable}' in table '${tableName}'`);
-			}
-			const failedDependencies = /* @__PURE__ */ new Set();
-			const circularDependencies = /* @__PURE__ */ new Set();
-			if (foreignKeys && foreignKeys.length > 0) {
-				for (const fk of foreignKeys) {
-					const referencedTable = fk.references.table;
-					if (referencedTable === tableName) continue;
-					if (attemptedTables.has(referencedTable) && !loadedTables.has(referencedTable)) if (loadingTables.has(referencedTable)) circularDependencies.add(referencedTable);
-					else failedDependencies.add(referencedTable);
-				}
-				if (failedDependencies.size > 0) for (const dep of failedDependencies) warnings.push(`Skipping foreign key validation for table '${tableName}': referenced table '${dep}' has validation errors`);
-			}
-			const allSkippedDependencies = new Set([...failedDependencies, ...circularDependencies]);
-			const { loaded, rowCount, errors: loadErrors } = await this.loadTable(tableName, tableConfig, detailedValidate, transform, allSkippedDependencies);
-			errors.push(...loadErrors);
-			rowCounts.set(tableName, rowCount);
-			if (loaded) {
-				loadedTables.add(tableName);
-				if (foreignKeys && circularDependencies.size > 0) {
-					for (const fk of foreignKeys) if (circularDependencies.has(fk.references.table)) deferredForeignKeys.push({
-						tableName,
-						foreignKey: fk,
-						filePath: tableConfig.jsonlPath
-					});
-				}
-			} else {
-				warnings.push(`Table '${tableName}' was not loaded (no data or skipped)`);
-				this.tables.delete(tableName);
-			}
-		} finally {
-			loadingTables.delete(tableName);
-		}
-		return {
-			errors,
-			warnings,
-			rowCounts,
-			deferredForeignKeys
-		};
-	}
-	/**
-	* Load a single table from JSONL file
-	* @returns Object with loaded status and validation errors
-	*/
-	async loadTable(tableName, config, detailedValidate, transform, failedDependencies) {
-		let data = await JsonlReader.read(config.jsonlPath);
-		if (transform) data = data.map((row) => transform(row));
-		let validationSchema = config.validationSchema;
-		const schemaMetadata = {};
-		if (!validationSchema) try {
-			validationSchema = await SchemaLoader.loadSchema(config.jsonlPath);
-		} catch (_error) {}
-		if (!config.validationSchema) try {
-			const { pathToFileURL: pathToFileURL$1 } = await import("node:url");
-			const schemaPath = await findSchemaFile((0, node_path.dirname)(config.jsonlPath), (0, node_path.basename)(config.jsonlPath, ".jsonl"));
-			if (!schemaPath) throw new Error("Schema file not found");
-			const schemaModule = await import(`${pathToFileURL$1(schemaPath).href}?t=${Date.now()}`);
-			const schemaExport = schemaModule.schema || schemaModule.default;
-			if (schemaExport?.primaryKey) schemaMetadata.primaryKey = schemaExport.primaryKey;
-			else if (schemaModule.primaryKey) schemaMetadata.primaryKey = schemaModule.primaryKey;
-			if (schemaExport?.foreignKeys) schemaMetadata.foreignKeys = schemaExport.foreignKeys;
-			else if (schemaModule.foreignKeys) schemaMetadata.foreignKeys = schemaModule.foreignKeys;
-			if (schemaExport?.indexes) schemaMetadata.indexes = schemaExport.indexes;
-			else if (schemaModule.indexes) schemaMetadata.indexes = schemaModule.indexes;
-			if (process.env.DEBUG_LINES_DB) {
-				console.log(`[lines-db] Schema metadata for ${tableName}:`);
-				console.log(`  primaryKey: ${schemaMetadata.primaryKey}`);
-				console.log(`  foreignKeys: ${JSON.stringify(schemaMetadata.foreignKeys)}`);
-				console.log(`  indexes: ${JSON.stringify(schemaMetadata.indexes)}`);
-			}
-		} catch (_error) {
-			if (process.env.DEBUG_LINES_DB) console.warn(`[lines-db] Failed to load schema metadata for ${tableName}:`, _error instanceof Error ? _error.message : String(_error));
-		}
-		this.validationSchemas.set(tableName, validationSchema);
-		const validationErrors = [];
-		const validatedData = [];
-		for (let rowIndex = 0; rowIndex < data.length; rowIndex++) {
-			const row = data[rowIndex];
-			try {
-				const validatedRow = this.validateAndTransform(tableName, row);
-				validatedData.push(validatedRow);
-			} catch (error) {
-				if (error instanceof Error && error.name === "ValidationError") validationErrors.push({
-					rowIndex,
-					rowData: row,
-					error
-				});
-				else throw error;
-			}
-		}
-		const validationErrorDetails = validationErrors.map((ve) => ({
-			file: config.jsonlPath,
-			tableName,
-			rowIndex: ve.rowIndex,
-			issues: ve.error.issues,
-			type: "schema"
-		}));
-		if (validationErrors.length > 0) return {
-			loaded: false,
-			rowCount: data.length,
-			errors: validationErrorDetails
-		};
-		let schema;
-		let inferredSchema;
-		if (validatedData.length > 0) inferredSchema = JsonlReader.inferSchema(tableName, validatedData);
-		if (config.schema) {
-			schema = config.schema;
-			if (inferredSchema) for (const inferredCol of inferredSchema.columns) {
-				const schemaCol = schema.columns.find((c) => c.name === inferredCol.name);
-				if (schemaCol && inferredCol.valueType && !schemaCol.valueType) schemaCol.valueType = inferredCol.valueType;
-			}
-		} else if (config.autoInferSchema !== false) {
-			if (validatedData.length === 0) return {
-				loaded: false,
-				rowCount: 0,
-				errors: []
-			};
-			schema = inferredSchema;
-		} else throw new Error(`No schema provided for table ${tableName} and autoInferSchema is disabled`);
-		const biSchema = validationSchema;
-		const primaryKey = biSchema?.primaryKey || schemaMetadata.primaryKey;
-		const foreignKeys = biSchema?.foreignKeys || schemaMetadata.foreignKeys;
-		const indexes = biSchema?.indexes || schemaMetadata.indexes;
-		if (primaryKey && !schema.columns.some((col) => col.primaryKey)) {
-			const col = schema.columns.find((c) => c.name === primaryKey);
-			if (col) col.primaryKey = true;
-		} else if (!primaryKey && !schema.columns.some((col) => col.primaryKey)) {
-			const idColumn = schema.columns.find((c) => c.name === "id");
-			if (idColumn) idColumn.primaryKey = true;
-		}
-		if (foreignKeys) schema.foreignKeys = failedDependencies && failedDependencies.size > 0 ? foreignKeys.filter((fk) => !failedDependencies.has(fk.references.table)) : foreignKeys;
-		if (indexes) {
-			schema.indexes = indexes;
-			for (const index of indexes) if (index.unique && index.columns.length === 1) {
-				const col = schema.columns.find((c) => c.name === index.columns[0]);
-				if (col && !col.unique && !col.primaryKey) col.unique = true;
-			}
-		}
-		this.schemas.set(tableName, schema);
-		this.createTable(schema);
-		if (detailedValidate) {
-			const insertErrors = this.insertDataWithDetailedValidation(tableName, schema, validatedData, config.jsonlPath);
-			if (insertErrors.length > 0) return {
-				loaded: false,
-				rowCount: data.length,
-				errors: insertErrors
-			};
-		} else this.insertData(tableName, schema, validatedData);
-		return {
-			loaded: true,
-			rowCount: data.length,
-			errors: []
-		};
-	}
-	/**
-	* Create table in SQLite with constraints and indexes
-	*/
-	createTable(schema) {
-		const quotedTableName = this.quoteTableName(schema.name);
-		const uniqueColumns = /* @__PURE__ */ new Set();
-		for (const col of schema.columns) if (col.unique) uniqueColumns.add(col.name);
-		if (schema.indexes) {
-			for (const index of schema.indexes) if (index.unique && index.columns.length === 1) uniqueColumns.add(index.columns[0]);
-		}
-		const columnDefs = schema.columns.map((col) => {
-			const sqlType = col.type === "JSON" ? "TEXT" : col.type;
-			const parts = [this.quoteIdentifier(col.name), sqlType];
-			if (col.primaryKey) parts.push("PRIMARY KEY");
-			if (col.notNull) parts.push("NOT NULL");
-			if (uniqueColumns.has(col.name) && !col.primaryKey) parts.push("UNIQUE");
-			return parts.join(" ");
-		});
-		const foreignKeyDefs = [];
-		if (schema.foreignKeys && schema.foreignKeys.length > 0) for (const fk of schema.foreignKeys) {
-			const fkParts = [`FOREIGN KEY (${this.quoteIdentifier(fk.column)})`, `REFERENCES ${this.quoteTableName(fk.references.table)}(${this.quoteIdentifier(fk.references.column)})`];
-			if (fk.onDelete) fkParts.push(`ON DELETE ${fk.onDelete}`);
-			if (fk.onUpdate) fkParts.push(`ON UPDATE ${fk.onUpdate}`);
-			foreignKeyDefs.push(fkParts.join(" "));
-		}
-		const sql = `CREATE TABLE IF NOT EXISTS ${quotedTableName} (${[...columnDefs, ...foreignKeyDefs].join(", ")})`;
-		this.db.exec(sql);
-		if (schema.indexes && schema.indexes.length > 0) for (let i = 0; i < schema.indexes.length; i++) {
-			const index = schema.indexes[i];
-			const safeTableName = schema.name.replace(/[^a-zA-Z0-9]/g, "_");
-			const resolvedIndexName = index.name || `idx_${safeTableName}_${index.columns.join("_")}_${i}`;
-			const indexSql = `CREATE ${index.unique ? "UNIQUE " : ""}INDEX IF NOT EXISTS ${this.quoteIdentifier(resolvedIndexName)} ON ${quotedTableName} (${index.columns.map((col) => this.quoteIdentifier(col)).join(", ")})`;
-			this.db.exec(indexSql);
-		}
-	}
-	/**
-	* Quote table name to handle special characters in SQL
-	*/
-	quoteTableName(tableName) {
-		return this.quoteIdentifier(tableName);
-	}
-	/**
-	* Quote identifier for SQL statements, escaping embedded quotes
-	*/
-	quoteIdentifier(identifier) {
-		return `"${identifier.replace(/"/g, "\"\"")}"`;
-	}
-	/**
-	* Insert data into table using batch insert (multiple rows per SQL)
-	* SQLite has a parameter limit (default 999), so we batch rows accordingly
-	* Throws exception if any constraint violation occurs
-	*/
-	insertData(tableName, schema, data) {
-		if (data.length === 0) return;
-		const columnNames = schema.columns.map((col) => col.name);
-		const quotedColumns = columnNames.map((name) => this.quoteIdentifier(name));
-		const columnCount = columnNames.length;
-		const maxBatchSize = Math.floor(900 / columnCount);
-		const batchSize = Math.max(1, Math.min(maxBatchSize, 100));
-		for (let i = 0; i < data.length; i += batchSize) {
-			const batch = data.slice(i, i + batchSize);
-			const rowPlaceholders = columnNames.map(() => "?").join(", ");
-			const valuesPlaceholders = batch.map(() => `(${rowPlaceholders})`).join(", ");
-			const sql = `INSERT INTO ${this.quoteTableName(tableName)} (${quotedColumns.join(", ")}) VALUES ${valuesPlaceholders}`;
-			const values = [];
-			for (const row of batch) for (const col of columnNames) values.push(this.normalizeValue(row[col]));
-			this.db.prepare(sql).run(...values);
-		}
-	}
-	/**
-	* Insert data into table one row at a time with detailed error reporting
-	* This is used for validation to catch constraint violations
-	*/
-	insertDataWithDetailedValidation(tableName, schema, data, filePath) {
-		const errors = [];
-		const columnNames = schema.columns.map((col) => col.name);
-		const quotedColumns = columnNames.map((name) => this.quoteIdentifier(name));
-		const placeholders = columnNames.map(() => "?").join(", ");
-		const sql = `INSERT INTO ${this.quoteTableName(tableName)} (${quotedColumns.join(", ")}) VALUES (${placeholders})`;
-		const stmt = this.db.prepare(sql);
-		for (let rowIndex = 0; rowIndex < data.length; rowIndex++) {
-			const row = data[rowIndex];
-			try {
-				const values = columnNames.map((col) => this.normalizeValue(row[col]));
-				stmt.run(...values);
-			} catch (error) {
-				const constraintError = this.analyzeConstraintError(error, filePath, tableName, rowIndex, row, schema.foreignKeys || []);
-				if (constraintError) errors.push(constraintError);
-			}
-		}
-		return errors;
-	}
-	/**
-	* Analyze constraint error and extract detailed information
-	*/
-	analyzeConstraintError(error, file, tableName, rowIndex, row, foreignKeys) {
-		const errorMessage = error instanceof Error ? error.message : String(error);
-		if (errorMessage.includes("FOREIGN KEY constraint failed")) for (const fk of foreignKeys) {
-			const fkValue = row[fk.column];
-			if (fkValue === null || fkValue === void 0) continue;
-			try {
-				const result = this.query(`SELECT COUNT(*) as count FROM ${this.quoteIdentifier(fk.references.table)} WHERE ${this.quoteIdentifier(fk.references.column)} = ?`, [this.normalizeValue(fkValue)]);
-				if (result.length > 0 && result[0].count === 0) return {
-					file,
-					tableName,
-					rowIndex,
-					issues: [],
-					type: "foreignKey",
-					foreignKeyError: {
-						column: fk.column,
-						value: fkValue,
-						referencedTable: fk.references.table,
-						referencedColumn: fk.references.column
-					}
-				};
-			} catch (_) {}
-		}
-		return {
-			file,
-			tableName,
-			rowIndex,
-			issues: [{
-				message: errorMessage,
-				path: []
-			}],
-			type: "schema"
-		};
-	}
-	/**
-	* Validate a deferred foreign key constraint after all tables have been loaded.
-	* Used for circular dependency FK validation.
-	*/
-	validateDeferredForeignKey(tableName, fk, filePath) {
-		const errors = [];
-		const quotedTable = this.quoteTableName(tableName);
-		const quotedColumn = this.quoteIdentifier(fk.column);
-		const quotedRefTable = this.quoteTableName(fk.references.table);
-		const sql = `SELECT rowid - 1 as idx, ${quotedColumn} as val FROM ${quotedTable} WHERE ${quotedColumn} IS NOT NULL AND ${quotedColumn} NOT IN (SELECT ${this.quoteIdentifier(fk.references.column)} FROM ${quotedRefTable})`;
-		try {
-			const rows = this.query(sql);
-			for (const row of rows) errors.push({
-				file: filePath,
-				tableName,
-				rowIndex: row.idx,
-				issues: [],
-				type: "foreignKey",
-				foreignKeyError: {
-					column: fk.column,
-					value: row.val,
-					referencedTable: fk.references.table,
-					referencedColumn: fk.references.column
-				}
-			});
-		} catch (_) {}
-		return errors;
-	}
-	/**
-	* Execute a raw SQL query
-	*/
-	query(sql, params = []) {
-		return this.db.prepare(sql).all(...params);
-	}
-	/**
-	* Execute a SQL query that returns a single row
-	*/
-	queryOne(sql, params = []) {
-		const result = this.db.prepare(sql).get(...params);
-		return result === void 0 ? null : result;
-	}
-	/**
-	* Execute a SQL statement (INSERT, UPDATE, DELETE)
-	*/
-	execute(sql, params = []) {
-		return this.db.prepare(sql).run(...params);
-	}
-	/**
-	* Find rows by condition (supports OR/AND with arrays and function filters)
-	* If where is not provided, returns all rows
-	*/
-	find(tableName, where) {
-		if (where === void 0) return this.query(`SELECT * FROM ${this.quoteTableName(tableName)}`).map((row) => this.deserializeRow(tableName, row));
-		if (Array.isArray(where) && where.length === 0) return [];
-		const { sql, values, functionFilters, hasOrWithFunctionFilters } = this.buildWhereClause(where);
-		let rows;
-		if (hasOrWithFunctionFilters) {
-			rows = this.query(`SELECT * FROM ${this.quoteTableName(tableName)}`).map((row) => this.deserializeRow(tableName, row));
-			return this.applyOrConditionWithFilters(rows, where);
-		}
-		if (sql) rows = this.query(`SELECT * FROM ${this.quoteTableName(tableName)} WHERE ${sql}`, values).map((row) => this.deserializeRow(tableName, row));
-		else rows = this.query(`SELECT * FROM ${this.quoteTableName(tableName)}`).map((row) => this.deserializeRow(tableName, row));
-		return this.applyFunctionFilters(rows, functionFilters);
-	}
-	/**
-	* Find a single row by condition (supports OR/AND with arrays and function filters)
-	*/
-	findOne(tableName, where) {
-		const { sql, values, functionFilters } = this.buildWhereClause(where);
-		let rows;
-		if (sql) rows = this.query(`SELECT * FROM ${this.quoteTableName(tableName)} WHERE ${sql}`, values).map((row) => this.deserializeRow(tableName, row));
-		else rows = this.query(`SELECT * FROM ${this.quoteTableName(tableName)}`).map((row) => this.deserializeRow(tableName, row));
-		const filtered = this.applyFunctionFilters(rows, functionFilters);
-		return filtered.length > 0 ? filtered[0] : null;
-	}
-	/**
-	* Deserialize JSON columns in a row
-	*/
-	deserializeRow(tableName, row) {
-		const schema = this.schemas.get(tableName);
-		if (!schema) return row;
-		const deserializedRow = { ...row };
-		for (const column of schema.columns) {
-			const colName = column.name;
-			if (!(colName in deserializedRow)) continue;
-			const value = deserializedRow[colName];
-			if (column.type === "JSON" && typeof value === "string") {
-				try {
-					deserializedRow[colName] = JSON.parse(value);
-				} catch (error) {
-					console.warn(`Failed to parse JSON column ${colName}:`, error);
-				}
-				continue;
-			}
-			if (column.valueType === "boolean") {
-				if (typeof value === "number") deserializedRow[colName] = value === 0 ? false : true;
-				else if (typeof value === "bigint") deserializedRow[colName] = value === 0n ? false : true;
-			}
-		}
-		return deserializedRow;
-	}
-	/**
-	* Validate data using StandardSchema and return the transformed value
-	* Note: Only synchronous validation is supported
-	*/
-	validateAndTransform(tableName, data) {
-		const schema = this.validationSchemas.get(tableName);
-		if (!schema) return data;
-		const result = schema["~standard"].validate(data);
-		if (result instanceof Promise) throw new Error("Asynchronous validation is not supported. Please use synchronous validation schemas.");
-		if (result.issues && result.issues.length > 0) {
-			const errorMessage = `Validation failed for table '${tableName}':\n${result.issues.map((issue) => {
-				let pathStr = "root";
-				if (issue.path && issue.path.length > 0) pathStr = issue.path.map((segment) => {
-					if (typeof segment === "object" && segment !== null && "key" in segment) return String(segment.key);
-					return String(segment);
-				}).join(".");
-				return `  - ${pathStr}: ${issue.message}`;
-			}).join("\n")}`;
-			const error = new Error(errorMessage);
-			error.name = "ValidationError";
-			error.issues = result.issues;
-			throw error;
-		}
-		const transformedValue = "value" in result ? result.value : data;
-		const normalizedValue = {};
-		for (const [key, value] of Object.entries(transformedValue)) normalizedValue[key] = value === void 0 ? null : value;
-		return normalizedValue;
-	}
-	/**
-	* Validate data using StandardSchema (without returning transformed value)
-	* Note: Only synchronous validation is supported
-	*/
-	validateData(tableName, data) {
-		this.validateAndTransform(tableName, data);
-	}
-	/**
-	* Insert a row into a table with validation
-	*/
-	insert(tableName, data) {
-		this.validateData(tableName, data);
-		if (!this.schemas.get(tableName)) throw new Error(`Table ${tableName} does not exist`);
-		const columnNames = Object.keys(data);
-		const quotedColumns = columnNames.map((col) => this.quoteIdentifier(col));
-		const placeholders = columnNames.map(() => "?").join(", ");
-		const sql = `INSERT INTO ${this.quoteTableName(tableName)} (${quotedColumns.join(", ")}) VALUES (${placeholders})`;
-		const values = Object.values(data).map((v) => this.normalizeValue(v));
-		const result = this.execute(sql, values);
-		if (!this.inTransaction) this.syncTable(tableName).catch((err) => {
-			console.error(`Failed to sync table ${tableName}:`, err);
-		});
-		return result;
-	}
-	/**
-	* Batch insert rows with validation per record.
-	*/
-	batchInsert(tableName, records) {
-		if (!this.schemas.get(tableName)) throw new Error(`Table ${tableName} does not exist`);
-		if (records.length === 0) return {
-			changes: 0,
-			lastInsertRowid: 0
-		};
-		let totalChanges = 0n;
-		let lastRowid = 0n;
-		for (const record of records) {
-			this.validateData(tableName, record);
-			const columnNames = Object.keys(record);
-			const quotedColumns = columnNames.map((col) => this.quoteIdentifier(col));
-			const placeholders = columnNames.map(() => "?").join(", ");
-			const sql = `INSERT INTO ${this.quoteTableName(tableName)} (${quotedColumns.join(", ")}) VALUES (${placeholders})`;
-			const values = columnNames.map((col) => this.normalizeValue(record[col]));
-			const result = this.execute(sql, values);
-			totalChanges += BigInt(result.changes);
-			lastRowid = BigInt(result.lastInsertRowid);
-		}
-		if (!this.inTransaction) this.syncTable(tableName).catch((err) => {
-			console.error(`Failed to sync table ${tableName}:`, err);
-		});
-		return {
-			changes: totalChanges,
-			lastInsertRowid: lastRowid
-		};
-	}
-	/**
-	* Update rows in a table with validation (supports OR/AND with arrays)
-	* Note: Function filters are not supported for update operations
-	* Note: By default, validation is enabled. For partial updates, existing data is fetched
-	* and merged before validation. Set options.validate = false to disable validation.
-	*/
-	update(tableName, data, where, options) {
-		if (!this.schemas.get(tableName)) throw new Error(`Table ${tableName} does not exist`);
-		const shouldValidate = options?.validate !== false;
-		const hasValidationSchema = this.validationSchemas.has(tableName);
-		if (shouldValidate && hasValidationSchema) {
-			const existingRows = this.find(tableName, where);
-			for (const existingRow of existingRows) {
-				const mergedData = {
-					...existingRow,
-					...data
-				};
-				this.validateData(tableName, mergedData);
-			}
-		}
-		const { sql: whereSql, values: whereValues, functionFilters } = this.buildWhereClause(where);
-		if (functionFilters.length > 0) throw new Error("Function filters are not supported in update operations");
-		const setClauses = Object.keys(data).map((key) => `${this.quoteIdentifier(key)} = ?`).join(", ");
-		const sql = `UPDATE ${this.quoteTableName(tableName)} SET ${setClauses} WHERE ${whereSql}`;
-		const values = [...Object.values(data).map((v) => this.normalizeValue(v)), ...whereValues];
-		const result = this.execute(sql, values);
-		if (!this.inTransaction) this.syncTable(tableName).catch((err) => {
-			console.error(`Failed to sync table ${tableName}:`, err);
-		});
-		return result;
-	}
-	/**
-	* Batch update rows with record-specific values and validation.
-	* Each record must include the primary key to identify the target row.
-	* Validation runs once per merged record unless explicitly disabled.
-	*/
-	batchUpdate(tableName, records, options) {
-		const schema = this.schemas.get(tableName);
-		if (!schema) throw new Error(`Table ${tableName} does not exist`);
-		if (records.length === 0) return {
-			changes: 0,
-			lastInsertRowid: 0
-		};
-		const pkColumn = schema.columns.find((col) => col.primaryKey);
-		if (!pkColumn) throw new Error(`Table ${tableName} does not have a primary key`);
-		const pkName = pkColumn.name;
-		const pkValues = [];
-		for (const record of records) {
-			const pkValue = record[pkName];
-			if (pkValue === void 0) throw new Error(`Record is missing primary key '${String(pkName)}': ${JSON.stringify(record)}`);
-			pkValues.push(pkValue);
-		}
-		const shouldValidate = options?.validate !== false;
-		const hasValidationSchema = this.validationSchemas.has(tableName);
-		if (shouldValidate && hasValidationSchema) {
-			const orCondition = pkValues.map((pkValue) => ({ [pkName]: pkValue }));
-			const existingRows = this.find(tableName, orCondition);
-			const existingRowsMap = /* @__PURE__ */ new Map();
-			for (const row of existingRows) {
-				const pkValue = row[pkName];
-				existingRowsMap.set(pkValue, row);
-			}
-			const validationErrors = [];
-			for (let i = 0; i < records.length; i++) {
-				const record = records[i];
-				const pkValue = record[pkName];
-				const existingRow = existingRowsMap.get(pkValue);
-				if (!existingRow) throw new Error(`No existing row found with ${String(pkName)}=${JSON.stringify(pkValue)}`);
-				const mergedData = {
-					...existingRow,
-					...record
-				};
-				try {
-					this.validateData(tableName, mergedData);
-				} catch (error) {
-					if (error instanceof Error && error.name === "ValidationError") validationErrors.push({
-						rowIndex: i,
-						rowData: mergedData,
-						pkValue,
-						error
-					});
-					else throw error;
-				}
-			}
-			if (validationErrors.length > 0) {
-				const enhancedError = /* @__PURE__ */ new Error(`Validation failed for ${validationErrors.length} row(s)`);
-				enhancedError.name = "ValidationError";
-				enhancedError.validationErrors = validationErrors;
-				enhancedError.issues = validationErrors[0].error.issues;
-				throw enhancedError;
-			}
-		}
-		let totalChanges = 0n;
-		let lastRowid = 0n;
-		for (const record of records) {
-			const pkValue = record[pkName];
-			const where = { [pkName]: pkValue };
-			const result = this.update(tableName, record, where, { validate: false });
-			totalChanges += BigInt(result.changes);
-			lastRowid = BigInt(result.lastInsertRowid);
-		}
-		return {
-			changes: totalChanges,
-			lastInsertRowid: lastRowid
-		};
-	}
-	/**
-	* Delete rows from a table (supports OR/AND with arrays)
-	* Note: Function filters are not supported for delete operations
-	*/
-	delete(tableName, where) {
-		if (!this.schemas.get(tableName)) throw new Error(`Table ${tableName} does not exist`);
-		const { sql: whereSql, values, functionFilters } = this.buildWhereClause(where);
-		if (functionFilters.length > 0) throw new Error("Function filters are not supported in delete operations");
-		const sql = `DELETE FROM ${this.quoteTableName(tableName)} WHERE ${whereSql}`;
-		const result = this.execute(sql, values);
-		if (!this.inTransaction) this.syncTable(tableName).catch((err) => {
-			console.error(`Failed to sync table ${tableName}:`, err);
-		});
-		return result;
-	}
-	/**
-	* Batch delete rows by primary key.
-	*/
-	batchDelete(tableName, records) {
-		const schema = this.schemas.get(tableName);
-		if (!schema) throw new Error(`Table ${tableName} does not exist`);
-		if (records.length === 0) return {
-			changes: 0,
-			lastInsertRowid: 0
-		};
-		const pkColumn = schema.columns.find((col) => col.primaryKey);
-		if (!pkColumn) throw new Error(`Table ${tableName} does not have a primary key`);
-		const pkName = pkColumn.name;
-		const pkValues = records.map((record, index) => {
-			const pkValue = record[pkName];
-			if (pkValue === void 0) throw new Error(`Record at index ${index} is missing primary key '${String(pkName)}'`);
-			return pkValue;
-		});
-		const placeholders = pkValues.map(() => "?").join(", ");
-		const sql = `DELETE FROM ${this.quoteTableName(tableName)} WHERE ${this.quoteIdentifier(pkName)} IN (${placeholders})`;
-		const values = pkValues.map((value) => this.normalizeValue(value));
-		const result = this.execute(sql, values);
-		if (!this.inTransaction) this.syncTable(tableName).catch((err) => {
-			console.error(`Failed to sync table ${tableName}:`, err);
-		});
-		return {
-			changes: BigInt(result.changes),
-			lastInsertRowid: BigInt(result.lastInsertRowid)
-		};
-	}
-	/**
-	* Normalize value for SQLite
-	*/
-	normalizeValue(value) {
-		if (value === null || value === void 0) return null;
-		if (typeof value === "boolean") return value ? 1 : 0;
-		if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") return value;
-		if (value instanceof Uint8Array) return value;
-		return JSON.stringify(value);
-	}
-	/**
-	* Build WHERE clause from condition (supports OR/AND with arrays and functions)
-	*/
-	buildWhereClause(condition) {
-		const values = [];
-		const functionFilters = [];
-		let hasOrWithFunctionFilters = false;
-		const buildCondition = (cond, isInOr = false) => {
-			if (Array.isArray(cond)) return cond.map((item) => {
-				const clause = Array.isArray(item) ? buildCondition(item, true) : buildCondition(item, true);
-				return clause ? `(${clause})` : "";
-			}).filter((clause) => clause !== "").join(" OR ");
-			const conditions = [];
-			let hasFunctionFilter = false;
-			for (const [key, value] of Object.entries(cond)) if (typeof value === "function") {
-				functionFilters.push({
-					key,
-					fn: value
-				});
-				hasFunctionFilter = true;
-			} else {
-				conditions.push(`${this.quoteIdentifier(key)} = ?`);
-				values.push(this.normalizeValue(value));
-			}
-			if (isInOr && hasFunctionFilter) hasOrWithFunctionFilters = true;
-			return conditions.join(" AND ");
-		};
-		return {
-			sql: buildCondition(condition),
-			values,
-			functionFilters,
-			hasOrWithFunctionFilters
-		};
-	}
-	/**
-	* Apply OR condition with function filters by evaluating each row against the condition
-	*/
-	applyOrConditionWithFilters(rows, condition) {
-		return rows.filter((row) => this.matchesOrCondition(row, condition));
-	}
-	/**
-	* Check if a row matches an OR/AND condition (recursively)
-	*/
-	matchesOrCondition(row, condition) {
-		if (Array.isArray(condition)) return condition.some((item) => this.matchesOrCondition(row, item));
-		return Object.entries(condition).every(([key, value]) => {
-			const rowValue = row[key];
-			if (typeof value === "function") return value(rowValue);
-			return rowValue === value;
-		});
-	}
-	/**
-	* Apply function filters to rows
-	*/
-	applyFunctionFilters(rows, functionFilters) {
-		if (functionFilters.length === 0) return rows;
-		return rows.filter((row) => {
-			return functionFilters.every(({ key, fn }) => {
-				const value = row[key];
-				return fn(value);
-			});
-		});
-	}
-	/**
-	* Get table schema
-	*/
-	getSchema(tableName) {
-		return this.schemas.get(tableName);
-	}
-	/**
-	* Get all table names
-	*/
-	getTableNames() {
-		return Array.from(this.schemas.keys());
-	}
-	/**
-	* Sync a specific table back to its JSONL file
-	* Uses backward transformation when available
-	*/
-	async syncTable(tableName) {
-		const tableConfig = this.tables.get(tableName);
-		if (!tableConfig) throw new Error(`Table ${tableName} not found`);
-		const deserializedRows = this.query(`SELECT * FROM ${this.quoteTableName(tableName)}`).map((row) => this.deserializeRow(tableName, row));
-		const validationSchema = this.validationSchemas.get(tableName);
-		let finalRows = deserializedRows;
-		if (validationSchema && hasBackward(validationSchema)) {
-			const biSchema = validationSchema;
-			finalRows = deserializedRows.map((row) => biSchema.backward(row));
-		}
-		await JsonlWriter.write(tableConfig.jsonlPath, finalRows);
-	}
-	/**
-	* Sync database changes back to JSONL files
-	* Uses backward transformation when available
-	* @param tableName Optional table name to sync. If not provided, syncs all loaded tables
-	*/
-	async sync(tableName) {
-		if (tableName) {
-			if (!this.schemas.has(tableName)) throw new Error(`Table '${tableName}' is not loaded`);
-			await this.syncTable(tableName);
-		} else for (const [name] of this.schemas) await this.syncTable(name);
-	}
-	/**
-	* Execute a function within a transaction
-	* Automatically commits on success or rolls back on error
-	*/
-	async transaction(fn) {
-		if (this.inTransaction) throw new Error("Nested transactions are not supported");
-		this.db.exec("BEGIN TRANSACTION");
-		this.inTransaction = true;
-		try {
-			const result = await fn(this);
-			this.db.exec("COMMIT");
-			this.inTransaction = false;
-			await this.sync();
-			return result;
-		} catch (error) {
-			if (this.inTransaction) this.db.exec("ROLLBACK");
-			this.inTransaction = false;
-			throw error;
-		}
-	}
-	/**
-	* Close the database connection
-	*/
-	async close() {
-		try {
-			this.db.close();
-		} catch (_error) {}
-	}
-	/**
-	* Get the underlying SQLite database instance
-	*/
-	getDb() {
-		return this.db;
-	}
-};
-
-//#endregion
-//#region src/type-generator.ts
-var TypeGenerator = class {
-	dataDir;
-	projectRoot;
-	outputFile;
-	dataDirPath;
-	constructor(options) {
-		const envProjectRoot = process.env.LINES_DB_TEST_PROJECT_ROOT;
-		this.projectRoot = envProjectRoot !== void 0 ? envProjectRoot : options.projectRoot || process.cwd();
-		this.dataDir = options.dataDir;
-		this.dataDirPath = (0, node_path.isAbsolute)(this.dataDir) ? this.dataDir : (0, node_path.join)(this.projectRoot, this.dataDir);
-		this.outputFile = options.output ? (0, node_path.isAbsolute)(options.output) ? options.output : (0, node_path.join)(this.projectRoot, options.output) : (0, node_path.join)(this.dataDirPath, "db.ts");
-	}
-	/**
-	* Generate types file from JSONL files and their optional schema files.
-	*/
-	async generate() {
-		const tables = await this.findTables();
-		if (tables.length === 0) throw new Error(`No JSONL files found in ${this.dataDirPath}. Place one or more *.jsonl files in the directory.`);
-		const content = this.generateTypeDeclarations(tables);
-		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(this.outputFile), { recursive: true });
-		await (0, node_fs_promises.writeFile)(this.outputFile, content, "utf-8");
-		console.log(`Generated types at ${this.outputFile}`);
-		return this.outputFile;
-	}
-	/**
-	* Find all *.jsonl files and check if they have corresponding *.schema.ts files
-	*/
-	async findTables() {
-		try {
-			const entries = await (0, node_fs_promises.readdir)(this.dataDirPath, { withFileTypes: true });
-			const tables = [];
-			for (const entry of entries) if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-				const tableName = (0, node_path.basename)(entry.name, ".jsonl");
-				const schemaFilePath = findSchemaFileInEntries(this.dataDirPath, tableName, entries);
-				tables.push({
-					tableName,
-					schemaFile: schemaFilePath
-				});
-			}
-			return tables;
-		} catch (error) {
-			if (error.code === "ENOENT") throw new Error(`Data directory not found: ${this.dataDirPath}. Set lines-db.dataDir to the correct location.`);
-			throw error;
-		}
-	}
-	/**
-	* Generate type declaration content
-	*/
-	generateTypeDeclarations(tables) {
-		const imports = [];
-		const tableEntries = [];
-		const usedAliases = /* @__PURE__ */ new Set();
-		for (const table of tables) {
-			const tableKey = this.formatTableKey(table.tableName);
-			if (table.schemaFile) {
-				const schemaIdentifier = this.createSchemaIdentifier(table.tableName, usedAliases);
-				usedAliases.add(schemaIdentifier);
-				let relativePath = rewriteExtensionForImport((0, node_path.relative)((0, node_path.join)(this.outputFile, ".."), table.schemaFile).replace(/\\/g, "/"));
-				if (!relativePath.startsWith(".")) relativePath = "./" + relativePath;
-				imports.push(`import { schema as ${schemaIdentifier} } from '${relativePath}';`);
-				tableEntries.push(`  ${tableKey}: InferOutput<typeof ${schemaIdentifier}>;`);
-			} else tableEntries.push(`  ${tableKey}: Record<string, unknown>;`);
-		}
-		return `// Auto-generated by lines-db
-// Do not edit this file manually
-
-${imports.length > 0 ? `${imports.join("\n")}\n` : ""}import type { DatabaseConfig${imports.length > 0 ? ", InferOutput" : ""} } from '@toiroakr/lines-db';
-import { fileURLToPath } from 'node:url';
-import { dirname } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-export type Tables = {
-${tableEntries.join("\n")}
-};
-
-export const config: DatabaseConfig<Tables> = {
-  dataDir: __dirname,
-};
-`;
-	}
-	createSchemaIdentifier(tableName, usedAliases) {
-		let base = sanitizeIdentifier(toCamelCase(tableName)) || "table";
-		if (!/^[A-Za-z_$]/.test(base)) base = `_${base}`;
-		let candidate = `${base}Schema`;
-		let suffix = 1;
-		while (usedAliases.has(candidate)) candidate = `${base}${++suffix}Schema`;
-		return candidate;
-	}
-	formatTableKey(tableName) {
-		if (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(tableName)) return tableName;
-		return `'${tableName.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
-	}
-};
-function toCamelCase(value) {
-	const parts = value.split(/[^A-Za-z0-9]+/).filter(Boolean).map((part) => part.toLowerCase());
-	if (parts.length === 0) return value;
-	const [first, ...rest] = parts;
-	return first + rest.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function sanitizeIdentifier(value) {
-	return value.replace(/[^A-Za-z0-9_$]/g, "");
-}
-
-//#endregion
-//#region src/jsonl-migration.ts
-/**
-* Validate a table by temporarily supplying in-memory rows while reusing the existing LinesDB validation pipeline.
-* If validation fails, throws an error with validation details.
-*/
-async function ensureTableRowsValid(options) {
-	const tablePath = (0, node_path.join)(options.dataDir, `${options.tableName}.jsonl`);
-	const overrides = new Map([[tablePath, options.rows]]);
-	await JsonlReader.withOverrides(overrides, async () => {
-		const db = LinesDB.create({ dataDir: options.dataDir });
-		try {
-			const result = await db.initialize({ tableName: options.tableName });
-			if (!result.valid) {
-				const errorCount = result.errors.length;
-				const errorDetails = result.errors.map((e) => {
-					const issueMessages = e.issues.map((issue) => issue.message).join(", ");
-					return `  Row ${e.rowIndex}: ${issueMessages}`;
-				}).join("\n");
-				throw new Error(`Validation failed for table '${options.tableName}' (${errorCount} error(s)):\n${errorDetails}`);
-			}
-		} finally {
-			await db.close();
-		}
-	});
-}
-
-//#endregion
-//#region src/error-formatter.ts
-var ErrorFormatter = class {
-	verbose;
-	constructor(options = {}) {
-		this.verbose = options.verbose ?? false;
-	}
-	/**
-	* Format validation errors
-	*/
-	formatValidationErrors(errors) {
-		if (this.verbose) return this.formatValidationErrorsVerbose(errors);
-		return this.formatValidationErrorsCompact(errors);
-	}
-	/**
-	* Format foreign key error
-	*/
-	formatForeignKeyError(error) {
-		if (this.verbose) return this.formatForeignKeyErrorVerbose(error);
-		return this.formatForeignKeyErrorCompact(error);
-	}
-	/**
-	* Format compact (default) validation errors
-	*/
-	formatValidationErrorsCompact(errors) {
-		const lines = [];
-		for (const error of errors) for (const issue of error.issues) {
-			const fieldPath = this.getFieldPath(issue);
-			const line = `${error.file}:${error.rowIndex + 1} • ${fieldPath}: ${issue.message}`;
-			lines.push(line);
-		}
-		return lines.join("\n");
-	}
-	/**
-	* Format verbose validation errors
-	*/
-	formatValidationErrorsVerbose(errors) {
-		const blocks = [];
-		for (let i = 0; i < errors.length; i++) {
-			const error = errors[i];
-			const isLast = i === errors.length - 1;
-			const prefix = isLast ? "└─" : "├─";
-			const linePrefix = isLast ? "   " : "│  ";
-			const lines = [`${prefix} ${error.file}:${error.rowIndex + 1}`];
-			for (const issue of error.issues) {
-				const fieldPath = this.getFieldPath(issue);
-				lines.push(`${linePrefix}Field: ${fieldPath}`);
-				lines.push(`${linePrefix}Error: ${issue.message}`);
-			}
-			if (error.originalData !== void 0) lines.push(`${linePrefix}Original data: ${JSON.stringify(error.originalData)}`);
-			if (error.data !== void 0) {
-				const label = error.originalData !== void 0 ? "Transformed data" : "Data";
-				lines.push(`${linePrefix}${label}: ${JSON.stringify(error.data)}`);
-			}
-			blocks.push(lines.join("\n"));
-		}
-		return blocks.join("\n│\n");
-	}
-	/**
-	* Format compact foreign key error
-	*/
-	formatForeignKeyErrorCompact(error) {
-		return `${error.file}:${error.rowIndex + 1} • ${error.column}: Foreign key constraint failed - Referenced value ${JSON.stringify(error.value)} does not exist in ${error.referencedTable}(${error.referencedColumn})`;
-	}
-	/**
-	* Format verbose foreign key error
-	*/
-	formatForeignKeyErrorVerbose(error) {
-		const lines = [
-			`└─ ${error.file}:${error.rowIndex + 1}`,
-			`   Type: Foreign Key Violation`,
-			`   Field: ${error.column}`,
-			`   Value: ${JSON.stringify(error.value)}`,
-			`   References: ${error.referencedTable}(${error.referencedColumn})`,
-			`   Error: Referenced value does not exist in target table`
-		];
-		if (error.data !== void 0) lines.push(`   Data: ${JSON.stringify(error.data)}`);
-		return lines.join("\n");
-	}
-	/**
-	* Get field path from issue
-	*/
-	getFieldPath(issue) {
-		if (!issue.path || issue.path.length === 0) return "root";
-		return issue.path.map((segment) => {
-			if (typeof segment === "object" && segment !== null && "key" in segment) return String(segment.key);
-			return String(segment);
-		}).join(".");
-	}
-	/**
-	* Format error header with count
-	*/
-	formatErrorHeader(count, file) {
-		return (0, node_util.styleText)("red", `✗ Found ${count} error(s)${file ? ` in ${file}` : ""}`);
-	}
-	/**
-	* Format migration failure header
-	*/
-	formatMigrationFailureHeader() {
-		return (0, node_util.styleText)("red", "\n✗ Migration failed and was rolled back");
-	}
-};
-
-//#endregion
-exports.DirectoryScanner = DirectoryScanner;
-exports.ErrorFormatter = ErrorFormatter;
-exports.JsonlReader = JsonlReader;
-exports.JsonlWriter = JsonlWriter;
-exports.LinesDB = LinesDB;
-exports.RUNTIME = RUNTIME;
-exports.SCHEMA_EXTENSIONS = SCHEMA_EXTENSIONS;
-exports.SchemaLoader = SchemaLoader;
-exports.TypeGenerator = TypeGenerator;
-exports.defineSchema = defineSchema;
-exports.detectRuntime = detectRuntime;
-exports.ensureTableRowsValid = ensureTableRowsValid;
-exports.extractTableNameFromSchemaFile = extractTableNameFromSchemaFile;
-exports.findSchemaFile = findSchemaFile;
-exports.hasBackward = hasBackward;
-exports.isSchemaFile = isSchemaFile;
-exports.rewriteExtensionForImport = rewriteExtensionForImport;