@sqg/sqg 0.15.0 → 0.16.0

package/dist/index.mjs

@@ -0,0 +1,3369 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import consola, { LogLevels } from "consola";
+import { camelCase, pascalCase, snakeCase } from "es-toolkit/string";
+import Handlebars from "handlebars";
+import YAML from "yaml";
+import { z } from "zod";
+import { DuckDBEnumType, DuckDBInstance, DuckDBListType, DuckDBMapType, DuckDBStructType } from "@duckdb/node-api";
+import { LRParser } from "@lezer/lr";
+import { isNotNil, sortBy } from "es-toolkit";
+import { PostgreSqlContainer } from "@testcontainers/postgresql";
+import { Client } from "pg";
+import types from "pg-types";
+import BetterSqlite3 from "better-sqlite3";
+import prettier from "prettier/standalone";
+import prettierPluginJava from "prettier-plugin-java";
+import { execSync } from "node:child_process";
+import typescriptPlugin from "prettier/parser-typescript";
+import estree from "prettier/plugins/estree";
+import * as clack from "@clack/prompts";
+import pc from "picocolors";
+//#region src/constants.ts
+/**
+* SQG Constants - Centralized definitions for supported generators
+*
+* Generator format: <language>/<engine>/<driver>
+* Short format:  <language>/<engine> (uses default driver)
+*/
+/** Supported database engines */
+const DB_ENGINES = [
+	"sqlite",
+	"duckdb",
+	"postgres"
+];
+/** Supported languages */
+const LANGUAGES = [
+	"typescript",
+	"java",
+	"python"
+];
+/** All supported generators with their full specification */
+const GENERATORS = {
+	"typescript/sqlite/better-sqlite3": {
+		language: "typescript",
+		engine: "sqlite",
+		driver: "better-sqlite3",
+		description: "TypeScript with better-sqlite3 driver",
+		extension: ".ts",
+		template: "better-sqlite3.hbs"
+	},
+	"typescript/sqlite/node": {
+		language: "typescript",
+		engine: "sqlite",
+		driver: "node",
+		description: "TypeScript with Node.js built-in SQLite",
+		extension: ".ts",
+		template: "node-sqlite.hbs"
+	},
+	"typescript/sqlite/libsql": {
+		language: "typescript",
+		engine: "sqlite",
+		driver: "libsql",
+		description: "TypeScript with @libsql/client (Turso)",
+		extension: ".ts",
+		template: "libsql.hbs"
+	},
+	"typescript/sqlite/turso": {
+		language: "typescript",
+		engine: "sqlite",
+		driver: "turso",
+		description: "TypeScript with Turso (limbo) native driver",
+		extension: ".ts",
+		template: "turso.hbs"
+	},
+	"typescript/duckdb/node-api": {
+		language: "typescript",
+		engine: "duckdb",
+		driver: "node-api",
+		description: "TypeScript with @duckdb/node-api driver",
+		extension: ".ts",
+		template: "typescript-duckdb.hbs"
+	},
+	"java/sqlite/jdbc": {
+		language: "java",
+		engine: "sqlite",
+		driver: "jdbc",
+		description: "Java with JDBC for SQLite",
+		extension: ".java",
+		template: "java-jdbc.hbs"
+	},
+	"java/duckdb/jdbc": {
+		language: "java",
+		engine: "duckdb",
+		driver: "jdbc",
+		description: "Java with JDBC for DuckDB",
+		extension: ".java",
+		template: "java-jdbc.hbs"
+	},
+	"java/duckdb/arrow": {
+		language: "java",
+		engine: "duckdb",
+		driver: "arrow",
+		description: "Java with DuckDB Arrow API",
+		extension: ".java",
+		template: "java-duckdb-arrow.hbs"
+	},
+	"java/postgres/jdbc": {
+		language: "java",
+		engine: "postgres",
+		driver: "jdbc",
+		description: "Java with JDBC for PostgreSQL",
+		extension: ".java",
+		template: "java-jdbc.hbs"
+	},
+	"python/sqlite/sqlite3": {
+		language: "python",
+		engine: "sqlite",
+		driver: "sqlite3",
+		description: "Python with sqlite3 standard library",
+		extension: ".py",
+		template: "python.hbs"
+	},
+	"python/duckdb/duckdb": {
+		language: "python",
+		engine: "duckdb",
+		driver: "duckdb",
+		description: "Python with duckdb driver",
+		extension: ".py",
+		template: "python.hbs"
+	},
+	"python/postgres/psycopg": {
+		language: "python",
+		engine: "postgres",
+		driver: "psycopg",
+		description: "Python with psycopg3 driver",
+		extension: ".py",
+		template: "python.hbs"
+	}
+};
+/** Default drivers for language/engine combinations */
+const DEFAULT_DRIVERS = {
+	"typescript/sqlite": "better-sqlite3",
+	"typescript/duckdb": "node-api",
+	"java/sqlite": "jdbc",
+	"java/duckdb": "jdbc",
+	"java/postgres": "jdbc",
+	"python/sqlite": "sqlite3",
+	"python/duckdb": "duckdb",
+	"python/postgres": "psycopg"
+};
+/** List of all full generator names */
+const GENERATOR_NAMES = Object.keys(GENERATORS);
+/** List of short generator names (language/engine) */
+const SHORT_GENERATOR_NAMES = Object.keys(DEFAULT_DRIVERS);
+/**
+* Resolve a generator string to its full form.
+* Accepts both short (language/engine) and full (language/engine/driver) formats.
+*/
+function resolveGenerator(generator) {
+	if (generator in GENERATORS) return generator;
+	if (generator in DEFAULT_DRIVERS) return `${generator}/${DEFAULT_DRIVERS[generator]}`;
+	return generator;
+}
+/**
+* Parse a generator string and return its info.
+* Throws if the generator is invalid.
+*/
+function parseGenerator(generator) {
+	const info = GENERATORS[resolveGenerator(generator)];
+	if (!info) throw new Error(`Invalid generator: ${generator}`);
+	return info;
+}
+/**
+* Check if a generator string is valid (either short or full form).
+*/
+function isValidGenerator(generator) {
+	return resolveGenerator(generator) in GENERATORS;
+}
+/**
+* Get the database engine for a generator.
+*/
+function getGeneratorEngine(generator) {
+	return parseGenerator(generator).engine;
+}
+/**
+* Get the language for a generator.
+*/
+function getGeneratorLanguage(generator) {
+	return parseGenerator(generator).language;
+}
+/**
+* Find similar generator names for typo suggestions.
+*/
+function findSimilarGenerators(input) {
+	const normalized = input.toLowerCase();
+	return [...GENERATOR_NAMES, ...SHORT_GENERATOR_NAMES].filter((name) => {
+		const nameLower = name.toLowerCase();
+		if (nameLower.includes(normalized) || normalized.includes(nameLower)) return true;
+		return [
+			normalized.replace(/\//g, "-"),
+			normalized.replace(/-/g, "/"),
+			normalized.replace(/_/g, "/"),
+			normalized.replace(/_/g, "-")
+		].some((v) => nameLower.includes(v) || v.includes(nameLower));
+	});
+}
+/**
+* Format generators for CLI help output.
+*/
+function formatGeneratorsHelp() {
+	const lines = [];
+	for (const shortName of SHORT_GENERATOR_NAMES) {
+		const fullName = `${shortName}/${DEFAULT_DRIVERS[shortName]}`;
+		const info = GENERATORS[fullName];
+		lines.push(`  ${shortName.padEnd(24)} ${info.description} (default)`);
+		for (const [generatorName, generatorInfo] of Object.entries(GENERATORS)) if (generatorName.startsWith(`${shortName}/`) && generatorName !== fullName) lines.push(`  ${generatorName.padEnd(24)} ${generatorInfo.description}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Format a simple list of valid generators.
+*/
+function formatGeneratorsList() {
+	return [...SHORT_GENERATOR_NAMES, ...GENERATOR_NAMES.filter((t) => !SHORT_GENERATOR_NAMES.some((s) => t === `${s}/${DEFAULT_DRIVERS[s]}`))].join(", ");
+}
+`
+SQL Annotation Syntax:
+  -- QUERY <name> [:one] [:pluck]   Select query (returns rows)
+  -- EXEC <name>                    Execute statement (INSERT/UPDATE/DELETE)
+  -- MIGRATE <number>               Schema migration (run in order)
+  -- TESTDATA <name>                Test data setup (not generated)
+  -- TABLE <name> :appender         Table for bulk insert appender (DuckDB, PostgreSQL)
+
+  @set <varName> = <value>          Define a variable
+  \${varName}                        Reference a variable in SQL
+
+Modifiers:
+  :one      Return single row (or null) instead of array
+  :pluck    Return single column value (requires exactly 1 column)
+  :all      Return all rows (default)
+  :appender Generate bulk insert appender for TABLE annotation
+
+Example:
+  -- MIGRATE 1
+  CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT);
+
+  -- QUERY get_user :one
+  @set id = 1
+  SELECT * FROM users WHERE id = \${id};
+
+  -- TABLE users :appender
+`.trim();
+//#endregion
+//#region src/errors.ts
+/**
+* Base error class for SQG with structured information
+*/
+var SqgError = class SqgError extends Error {
+	constructor(message, code, suggestion, context) {
+		super(message);
+		this.code = code;
+		this.suggestion = suggestion;
+		this.context = context;
+		this.name = "SqgError";
+	}
+	/**
+	* Create error with file context
+	*/
+	static inFile(message, code, file, options) {
+		return new SqgError(`${message} in ${options?.line ? `${file}:${options.line}` : file}`, code, options?.suggestion, {
+			file,
+			line: options?.line,
+			...options?.context
+		});
+	}
+	/**
+	* Create error with query context
+	*/
+	static inQuery(message, code, queryName, file, options) {
+		return new SqgError(`${message} in query '${queryName}' (${file})`, code, options?.suggestion, {
+			file,
+			query: queryName,
+			sql: options?.sql,
+			...options?.context
+		});
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			code: this.code,
+			message: this.message,
+			suggestion: this.suggestion,
+			context: this.context
+		};
+	}
+};
+/**
+* Error for configuration issues
+*/
+var ConfigError = class extends SqgError {
+	constructor(message, suggestion, context) {
+		super(message, "CONFIG_VALIDATION_ERROR", suggestion, context);
+		this.name = "ConfigError";
+	}
+};
+/**
+* Error for invalid generator names
+*/
+var InvalidGeneratorError = class extends SqgError {
+	constructor(generatorName, validGenerators, suggestion) {
+		const similarMsg = suggestion ? ` Did you mean '${suggestion}'?` : "";
+		super(`Invalid generator '${generatorName}'.${similarMsg} Valid generators: ${validGenerators.join(", ")}`, "INVALID_GENERATOR", suggestion ? `Use '${suggestion}' instead` : `Choose from: ${validGenerators.join(", ")}`, { generator: generatorName });
+		this.name = "InvalidGeneratorError";
+	}
+};
+/**
+* Error for database initialization/connection issues
+*/
+var DatabaseError = class extends SqgError {
+	constructor(message, engine, suggestion, context) {
+		super(message, "DATABASE_ERROR", suggestion, {
+			...context,
+			engine
+		});
+		this.name = "DatabaseError";
+	}
+};
+/**
+* Error for SQL execution issues
+*/
+var SqlExecutionError = class extends SqgError {
+	constructor(message, queryName, file, sql, originalError) {
+		super(`Failed to execute query '${queryName}' in ${file}: ${message}`, "SQL_EXECUTION_ERROR", void 0, {
+			query: queryName,
+			file,
+			sql,
+			originalError: originalError?.message
+		});
+		this.name = "SqlExecutionError";
+	}
+};
+/**
+* Error for type mapping issues
+*/
+var TypeMappingError = class extends SqgError {
+	constructor(message, columnName, queryName, file) {
+		const location = queryName && file ? ` in query '${queryName}' (${file})` : "";
+		super(`Type mapping error for column '${columnName}'${location}: ${message}`, "TYPE_MAPPING_ERROR", void 0, {
+			columnName,
+			query: queryName,
+			file
+		});
+		this.name = "TypeMappingError";
+	}
+};
+/**
+* Error for file not found
+*/
+var FileNotFoundError = class extends SqgError {
+	constructor(filePath, searchedFrom) {
+		const suggestion = searchedFrom ? `Check that the path is relative to ${searchedFrom}` : "Check that the file path is correct";
+		super(`File not found: ${filePath}`, "FILE_NOT_FOUND", suggestion, { file: filePath });
+		this.name = "FileNotFoundError";
+	}
+};
+/**
+* Format any error for JSON output
+*/
+function formatErrorForOutput(err) {
+	if (err instanceof SqgError) return {
+		status: "error",
+		error: {
+			code: err.code,
+			message: err.message,
+			suggestion: err.suggestion,
+			context: err.context
+		}
+	};
+	if (err instanceof Error) return {
+		status: "error",
+		error: {
+			code: "UNKNOWN_ERROR",
+			message: err.message
+		}
+	};
+	return {
+		status: "error",
+		error: {
+			code: "UNKNOWN_ERROR",
+			message: String(err)
+		}
+	};
+}
+//#endregion
+//#region src/parser/sql-parser.ts
+const parser = LRParser.deserialize({
+	version: 14,
+	states: "&SOVQPOOO_QPO'#CwOdQPO'#CzOiQPO'#CvO!SQQO'#C^OOQO'#Cn'#CnQVQPOOO!aQSO,59cO!lQPO,59fOOQO'#Cp'#CpO!tQQO,59bOOQO'#C}'#C}O#iQQO'#CiOOQO,58x,58xOOQO-E6l-E6lOOQO'#Co'#CoO!aQSO1G.}O!dQSO1G.}OOQO'#Cb'#CbOOQO1G.}1G.}O#yQPO1G/QOOQO-E6n-E6nO$RQPO'#CdOOQO'#Cq'#CqO$WQQO1G.|OOQO'#Cm'#CmOOQO'#Cr'#CrO$xQQO,59TOOQO-E6m-E6mO!dQSO7+$iOOQO7+$i7+$iO%YQPO,59OOOQO-E6o-E6oOOQO-E6p-E6pOOQO<<HT<<HTO%_QQO1G.jOOQO'#Ce'#CeOiQPO7+$UO%jQQO<<Gp",
+	stateData: "&l~OiOS~ORPOVQO~OSVO~OSWO~OlXO~OYZOZZO[ZO^ZO_ZO`ZO~OR]PV]Pg]P~PnOT_OlXOmbO~OT_Olna~OlXOofORjaVjaYjaZja[ja^ja_ja`jagja~OliOR]XV]Xg]X~PnOT_Olni~OSoO~OofORjiVjiYjiZji[ji^ji_ji`jigji~OliOR]aV]ag]a~PnOpsO~OYtOZtO[tO~OlXORWyVWyYWyZWy[Wy^Wy_Wy`WygWyoWy~OR`o^iZTmYV_[~",
+	goto: "#prPPsPPPwP!R!VPPP!YPPP!]!a!g!q#T#ZPPP#a#ePP#ePP#iTTOUQcVSn`aRrmTgYhRusR]STj[kQUOR^UQ`VQdWTl`dQYRQaVWeYamvQm`RvuQhYRphQk[RqkTSOUTROUQ[STj[k",
+	nodeNames: "⚠ File QueryBlock BlockCommentStartSpecial Name Modifiers Config LineCommentStartSpecial SetVarLine Value StringLiteral StringLiteralSingle SQLText SQLBlock BlockComment LineComment VarRef BR",
+	maxTerm: 33,
+	skippedNodes: [0],
+	repeatNodeCount: 5,
+	tokenData: "$3b~RqOX#YXY'wYZ(iZ]#Y]^$W^p#Ypq'wqr#Yrs(}st#Ytu6^uw#Ywx9[xz#Yz{%_{}#Y}!OKi!O!P#Y!P!Q#%p!Q![$)l![!]$+U!]!_#Y!_!`$.U!`!b#Y!b!c$/U!c!}$)l!}#R#Y#R#S$)l#S#T#Y#T#o$)l#o;'S#Y;'S;=`'q<%lO#YU#_][QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{;'S#Y;'S;=`'q<%lO#YS$ZTOz$Wz{$j{;'S$W;'S;=`%X<%lO$WS$mVOz$Wz{$j{!P$W!P!Q%S!Q;'S$W;'S;=`%X<%lO$WS%XOmSS%[P;=`<%l$WU%d_[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{!P#Y!P!Q&c!Q;'S#Y;'S;=`'q<%lO#YU&jVmS[QOX'PZ]'P^p'Pqt'Pu;'S'P;'S;=`'k<%lO'PQ'UV[QOX'PZ]'P^p'Pqt'Pu;'S'P;'S;=`'k<%lO'PQ'nP;=`<%l'PU'tP;=`<%l#Y~'|Xi~OX$WXY'wYp$Wpq'wqz$Wz{$j{;'S$W;'S;=`%X<%lO$W~(nTl~Oz$Wz{$j{;'S$W;'S;=`%X<%lO$WU)Sb[QOX(}XY*[YZ$WZ](}]^*[^p(}pq*[qr(}rs.yst(}tu*[uz(}z{/y{#O(}#O#P5V#P;'S(};'S;=`6W<%lO(}U*_ZOY*[YZ$WZr*[rs+Qsz*[z{+f{#O*[#O#P.Z#P;'S*[;'S;=`.s<%lO*[U+VTYQOz$Wz{$j{;'S$W;'S;=`%X<%lO$WU+i]OY*[YZ$WZr*[rs+Qsz*[z{+f{!P*[!P!Q,b!Q#O*[#O#P.Z#P;'S*[;'S;=`.s<%lO*[U,gWmSOY-PZr-Prs-ls#O-P#O#P-q#P;'S-P;'S;=`.T<%lO-PQ-SWOY-PZr-Prs-ls#O-P#O#P-q#P;'S-P;'S;=`.T<%lO-PQ-qOYQQ-tTOY-PYZ-PZ;'S-P;'S;=`.T<%lO-PQ.WP;=`<%l-PU.^VOY*[YZ*[Zz*[z{+f{;'S*[;'S;=`.s<%lO*[U.vP;=`<%l*[U/Q]YQ[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{;'S#Y;'S;=`'q<%lO#YU0Od[QOX(}XY*[YZ$WZ](}]^*[^p(}pq*[qr(}rs.yst(}tu*[uz(}z{/y{!P(}!P!Q1^!Q#O(}#O#P5V#P;'S(};'S;=`6W<%lO(}U1e_mS[QOX2dXY-PZ]2d]^-P^p2dpq-Pqr2drs3hst2dtu-Pu#O2d#O#P4U#P;'S2d;'S;=`5P<%lO2dQ2i_[QOX2dXY-PZ]2d]^-P^p2dpq-Pqr2drs3hst2dtu-Pu#O2d#O#P4U#P;'S2d;'S;=`5P<%lO2dQ3oVYQ[QOX'PZ]'P^p'Pqt'Pu;'S'P;'S;=`'k<%lO'PQ4Z[[QOX2dXY-PYZ-PZ]2d]^-P^p2dpq-Pqt2dtu-Pu;'S2d;'S;=`5P<%lO2dQ5SP;=`<%l2dU5[^[QOX(}XY*[YZ*[Z](}]^*[^p(}pq*[qt(}tu*[uz(}z{/y{;'S(};'S;=`6W<%lO(}U6ZP;=`<%l(}U6cV[QOz$Wz{$j{#o$W#o#p6x#p;'S$W;'S;=`%X<%lO$WU6{]Oz$Wz{$j{!Q$W!Q![7t![!c$W!c!}7t!}#R$W#R#S7t#S#T$W#T#o7t#o;'S$W;'S;=`%X<%lO$WU7w_Oz$Wz{$j{!Q$W!Q![7t![!c$W!c!}7t!}#R$W#R#S7t#S#T$W#T#o7t#o#q$W#q#r8v#r;'S$W;'S;=`%X<%lO$WU8{T`QOz$Wz{$j{;'S$W;'S;=`%X<%lO$WU9ab[QOX9[XY:iYZ$WZ]9[]^:i^p9[pq:iqt9[tu:iuw9[wxAVxz9[z{BV{#O9[#O#PHu#P;'S9[;'S;=`Kc<%lO9[U:lZOY:iYZ$WZw:iwx;_xz:iz{;s{#O:i#O#P?c#P;'S:i;'S;=`AP<%lO:iU;dTZQOz$Wz{$j{;'S$W;'S;=`%X<%lO$WU;v]OY:iYZ$WZw:iwx;_xz:iz{;s{!P:i!P!Q<o!Q#O:i#O#P?c#P;'S:i;'S;=`AP<%lO:iU<tWmSOY=^Zw=^wx=yx#O=^#O#P>O#P;'S=^;'S;=`?]<%lO=^Q=aWOY=^Zw=^wx=yx#O=^#O#P>O#P;'S=^;'S;=`?]<%lO=^Q>OOZQQ>RXOY=^YZ=^Zw=^wx>nx#O=^#O#P>O#P;'S=^;'S;=`?]<%lO=^Q>sWZQOY=^Zw=^wx=yx#O=^#O#P>O#P;'S=^;'S;=`?]<%lO=^Q?`P;=`<%l=^U?fZOY:iYZ:iZw:iwx@Xxz:iz{;s{#O:i#O#P?c#P;'S:i;'S;=`AP<%lO:iU@^ZZQOY:iYZ$WZw:iwx;_xz:iz{;s{#O:i#O#P?c#P;'S:i;'S;=`AP<%lO:iUASP;=`<%l:iUA^]ZQ[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{;'S#Y;'S;=`'q<%lO#YUB[d[QOX9[XY:iYZ$WZ]9[]^:i^p9[pq:iqt9[tu:iuw9[wxAVxz9[z{BV{!P9[!P!QCj!Q#O9[#O#PHu#P;'S9[;'S;=`Kc<%lO9[UCq_mS[QOXDpXY=^Z]Dp]^=^^pDppq=^qtDptu=^uwDpwxEtx#ODp#O#PFb#P;'SDp;'S;=`Ho<%lODpQDu_[QOXDpXY=^Z]Dp]^=^^pDppq=^qtDptu=^uwDpwxEtx#ODp#O#PFb#P;'SDp;'S;=`Ho<%lODpQE{VZQ[QOX'PZ]'P^p'Pqt'Pu;'S'P;'S;=`'k<%lO'PQFg`[QOXDpXY=^YZ=^Z]Dp]^=^^pDppq=^qtDptu=^uwDpwxGix#ODp#O#PFb#P;'SDp;'S;=`Ho<%lODpQGp_ZQ[QOXDpXY=^Z]Dp]^=^^pDppq=^qtDptu=^uwDpwxEtx#ODp#O#PFb#P;'SDp;'S;=`Ho<%lODpQHrP;=`<%lDpUHzb[QOX9[XY:iYZ:iZ]9[]^:i^p9[pq:iqt9[tu:iuw9[wxJSxz9[z{BV{#O9[#O#PHu#P;'S9[;'S;=`Kc<%lO9[UJZbZQ[QOX9[XY:iYZ$WZ]9[]^:i^p9[pq:iqt9[tu:iuw9[wxAVxz9[z{BV{#O9[#O#PHu#P;'S9[;'S;=`Kc<%lO9[UKfP;=`<%l9[VKn_[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{}#Y}!OLm!O;'S#Y;'S;=`'q<%lO#YVLtf_Q[QOXNYXY!&vYZ$WZ]NY]^! ]^pNYpq!&vqtNYtu! ]uzNYz{!#k{!gNY!g!h!8V!h!oNY!o!p!<w!p!sNY!s!t!DP!t!vNY!v!w!Hu!w;'SNY;'S;=`!&p<%lONYUNa^_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{;'SNY;'S;=`!&p<%lONYU! bV_QOY! ]YZ$WZz! ]z{! w{;'S! ];'S;=`!#e<%lO! ]U! |X_QOY! ]YZ$WZz! ]z{! w{!P! ]!P!Q!!i!Q;'S! ];'S;=`!#e<%lO! ]U!!pSmS_QOY!!|Z;'S!!|;'S;=`!#_<%lO!!|Q!#RS_QOY!!|Z;'S!!|;'S;=`!#_<%lO!!|Q!#bP;=`<%l!!|U!#hP;=`<%l! ]U!#r`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!PNY!P!Q!$t!Q;'SNY;'S;=`!&p<%lONYU!$}ZmS_Q[QOX!%pXY!!|Z]!%p]^!!|^p!%ppq!!|qt!%ptu!!|u;'S!%p;'S;=`!&j<%lO!%pQ!%wZ_Q[QOX!%pXY!!|Z]!%p]^!!|^p!%ppq!!|qt!%ptu!!|u;'S!%p;'S;=`!&j<%lO!%pQ!&mP;=`<%l!%pU!&sP;=`<%lNYV!&{b_QOX! ]XY!&vYZ$WZp! ]pq!&vqz! ]z{! w{!g! ]!g!h!(T!h!o! ]!o!p!*u!p!s! ]!s!t!.}!t!v! ]!v!w!1s!w;'S! ];'S;=`!#e<%lO! ]V!(YX_QOY! ]YZ$WZz! ]z{! w{!z! ]!z!{!(u!{;'S! ];'S;=`!#e<%lO! ]V!(zX_QOY! ]YZ$WZz! ]z{! w{!g! ]!g!h!)g!h;'S! ];'S;=`!#e<%lO! ]V!)lX_QOY! ]YZ$WZz! ]z{! w{!e! ]!e!f!*X!f;'S! ];'S;=`!#e<%lO! ]V!*`VVR_QOY! ]YZ$WZz! ]z{! w{;'S! ];'S;=`!#e<%lO! ]V!*zX_QOY! ]YZ$WZz! ]z{! w{!k! ]!k!l!+g!l;'S! ];'S;=`!#e<%lO! ]V!+lX_QOY! ]YZ$WZz! ]z{! w{!i! ]!i!j!,X!j;'S! ];'S;=`!#e<%lO! ]V!,^X_QOY! ]YZ$WZz! ]z{! w{!t! ]!t!u!,y!u;'S! ];'S;=`!#e<%lO! ]V!-OX_QOY! ]YZ$WZz! ]z{! w{!c! ]!c!d!-k!d;'S! ];'S;=`!#e<%lO! ]V!-pX_QOY! ]YZ$WZz! ]z{! w{!v! ]!v!w!.]!w;'S! ];'S;=`!#e<%lO! ]V!.bX_QOY! ]YZ$WZz! ]z{! w{!g! ]!g!h!*X!h;'S! ];'S;=`!#e<%lO! ]V!/SX_QOY! ]YZ$WZz! ]z{! w{!w! ]!w!x!/o!x;'S! ];'S;=`!#e<%lO! ]V!/tX_QOY! ]YZ$WZz! ]z{! w{!g! ]!g!h!0a!h;'S! ];'S;=`!#e<%lO! ]V!0fX_QOY! ]YZ$WZz! ]z{! w{!t! ]!t!u!1R!u;'S! ];'S;=`!#e<%lO! ]V!1WX_QOY! ]YZ$WZz! ]z{! w{!{! ]!{!|!*X!|;'S! ];'S;=`!#e<%lO! ]V!1xZ_QOY! ]YZ$WZz! ]z{! w{!c! ]!c!d!2k!d!g! ]!g!h!3}!h;'S! ];'S;=`!#e<%lO! ]V!2pX_QOY! ]YZ$WZz! ]z{! w{!d! ]!d!e!3]!e;'S! ];'S;=`!#e<%lO! ]V!3bX_QOY! ]YZ$WZz! ]z{! w{!n! ]!n!o!.]!o;'S! ];'S;=`!#e<%lO! ]V!4SX_QOY! ]YZ$WZz! ]z{! w{!u! ]!u!v!4o!v;'S! ];'S;=`!#e<%lO! ]V!4tX_QOY! ]YZ$WZz! ]z{! w{!v! ]!v!w!5a!w;'S! ];'S;=`!#e<%lO! ]V!5fX_QOY! ]YZ$WZz! ]z{! w{!f! ]!f!g!6R!g;'S! ];'S;=`!#e<%lO! ]V!6WX_QOY! ]YZ$WZz! ]z{! w{!c! ]!c!d!6s!d;'S! ];'S;=`!#e<%lO! ]V!6xX_QOY! ]YZ$WZz! ]z{! w{!v! ]!v!w!7e!w;'S! ];'S;=`!#e<%lO! ]V!7jX_QOY! ]YZ$WZz! ]z{! w{!c! ]!c!d!*X!d;'S! ];'S;=`!#e<%lO! ]V!8^`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!zNY!z!{!9`!{;'SNY;'S;=`!&p<%lONYV!9g`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!gNY!g!h!:i!h;'SNY;'S;=`!&p<%lONYV!:p`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!eNY!e!f!;r!f;'SNY;'S;=`!&p<%lONYV!;{^VR_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{;'SNY;'S;=`!&p<%lONYV!=O`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!kNY!k!l!>Q!l;'SNY;'S;=`!&p<%lONYV!>X`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!iNY!i!j!?Z!j;'SNY;'S;=`!&p<%lONYV!?b`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!tNY!t!u!@d!u;'SNY;'S;=`!&p<%lONYV!@k`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!cNY!c!d!Am!d;'SNY;'S;=`!&p<%lONYV!At`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!vNY!v!w!Bv!w;'SNY;'S;=`!&p<%lONYV!B}`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!gNY!g!h!;r!h;'SNY;'S;=`!&p<%lONYV!DW`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!wNY!w!x!EY!x;'SNY;'S;=`!&p<%lONYV!Ea`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!gNY!g!h!Fc!h;'SNY;'S;=`!&p<%lONYV!Fj`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!tNY!t!u!Gl!u;'SNY;'S;=`!&p<%lONYV!Gs`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!{NY!{!|!;r!|;'SNY;'S;=`!&p<%lONYV!H|b_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!cNY!c!d!JU!d!gNY!g!h!Lh!h;'SNY;'S;=`!&p<%lONYV!J]`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!dNY!d!e!K_!e;'SNY;'S;=`!&p<%lONYV!Kf`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!nNY!n!o!Bv!o;'SNY;'S;=`!&p<%lONYV!Lo`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!uNY!u!v!Mq!v;'SNY;'S;=`!&p<%lONYV!Mx`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!vNY!v!w!Nz!w;'SNY;'S;=`!&p<%lONYV# R`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!fNY!f!g#!T!g;'SNY;'S;=`!&p<%lONYV#![`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!cNY!c!d##^!d;'SNY;'S;=`!&p<%lONYV##e`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!vNY!v!w#$g!w;'SNY;'S;=`!&p<%lONYV#$n`_Q[QOXNYXY! ]YZ$WZ]NY]^! ]^pNYpq! ]qtNYtu! ]uzNYz{!#k{!cNY!c!d!;r!d;'SNY;'S;=`!&p<%lONYV#%u][QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{#&n{;'S#Y;'S;=`'q<%lO#YV#&sh[QOX#(_XY#,`YZ#,`Z]#(_]^#)]^p#(_pq#,`qt#(_tu#)]uz#(_z{#*f{!P#(_!P!Q#9m!Q!g#(_!g!h#>j!h!o#(_!o!p#Bv!p!s#(_!s!t#I`!t!v#(_!v!w#Mp!w;'S#(_;'S;=`#,Y<%lO#(_U#(d][QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{;'S#(_;'S;=`#,Y<%lO#(_U#)`TOz#)]z{#)o{;'S#)];'S;=`#*`<%lO#)]U#)rVOz#)]z{#)o{!P#)]!P!Q#*X!Q;'S#)];'S;=`#*`<%lO#)]U#*`O^QmSU#*cP;=`<%l#)]U#*k_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!P#(_!P!Q#+j!Q;'S#(_;'S;=`#,Y<%lO#(_U#+sV^QmS[QOX'PZ]'P^p'Pqt'Pu;'S'P;'S;=`'k<%lO'PU#,]P;=`<%l#(_V#,cbOX#)]XY#,`YZ#,`Zp#)]pq#,`qz#)]z{#)o{!g#)]!g!h#-k!h!o#)]!o!p#/k!p!s#)]!s!t#2q!t!v#)]!v!w#4u!w;'S#)];'S;=`#*`<%lO#)]V#-nVOz#)]z{#)o{!z#)]!z!{#.T!{;'S#)];'S;=`#*`<%lO#)]V#.WVOz#)]z{#)o{!g#)]!g!h#.m!h;'S#)];'S;=`#*`<%lO#)]V#.pVOz#)]z{#)o{!e#)]!e!f#/V!f;'S#)];'S;=`#*`<%lO#)]V#/[TRROz#)]z{#)o{;'S#)];'S;=`#*`<%lO#)]V#/nVOz#)]z{#)o{!k#)]!k!l#0T!l;'S#)];'S;=`#*`<%lO#)]V#0WVOz#)]z{#)o{!i#)]!i!j#0m!j;'S#)];'S;=`#*`<%lO#)]V#0pVOz#)]z{#)o{!t#)]!t!u#1V!u;'S#)];'S;=`#*`<%lO#)]V#1YVOz#)]z{#)o{!c#)]!c!d#1o!d;'S#)];'S;=`#*`<%lO#)]V#1rVOz#)]z{#)o{!v#)]!v!w#2X!w;'S#)];'S;=`#*`<%lO#)]V#2[VOz#)]z{#)o{!g#)]!g!h#/V!h;'S#)];'S;=`#*`<%lO#)]V#2tVOz#)]z{#)o{!w#)]!w!x#3Z!x;'S#)];'S;=`#*`<%lO#)]V#3^VOz#)]z{#)o{!g#)]!g!h#3s!h;'S#)];'S;=`#*`<%lO#)]V#3vVOz#)]z{#)o{!t#)]!t!u#4]!u;'S#)];'S;=`#*`<%lO#)]V#4`VOz#)]z{#)o{!{#)]!{!|#/V!|;'S#)];'S;=`#*`<%lO#)]V#4xXOz#)]z{#)o{!c#)]!c!d#5e!d!g#)]!g!h#6g!h;'S#)];'S;=`#*`<%lO#)]V#5hVOz#)]z{#)o{!d#)]!d!e#5}!e;'S#)];'S;=`#*`<%lO#)]V#6QVOz#)]z{#)o{!n#)]!n!o#2X!o;'S#)];'S;=`#*`<%lO#)]V#6jVOz#)]z{#)o{!u#)]!u!v#7P!v;'S#)];'S;=`#*`<%lO#)]V#7SVOz#)]z{#)o{!v#)]!v!w#7i!w;'S#)];'S;=`#*`<%lO#)]V#7lVOz#)]z{#)o{!f#)]!f!g#8R!g;'S#)];'S;=`#*`<%lO#)]V#8UVOz#)]z{#)o{!c#)]!c!d#8k!d;'S#)];'S;=`#*`<%lO#)]V#8nVOz#)]z{#)o{!v#)]!v!w#9T!w;'S#)];'S;=`#*`<%lO#)]V#9WVOz#)]z{#)o{!c#)]!c!d#/V!d;'S#)];'S;=`#*`<%lO#)]U#9t]mS[QOX#:mXZ#;kZ]#:m]^#;k^p#:mpq#;kqt#:mtu#;kuz#:mz{#<r{;'S#:m;'S;=`#>d<%lO#:mQ#:r][QOX#:mXZ#;kZ]#:m]^#;k^p#:mpq#;kqt#:mtu#;kuz#:mz{#<r{;'S#:m;'S;=`#>d<%lO#:mQ#;nTOz#;kz{#;}{;'S#;k;'S;=`#<l<%lO#;kQ#<QVOz#;kz{#;}{!P#;k!P!Q#<g!Q;'S#;k;'S;=`#<l<%lO#;kQ#<lO^QQ#<oP;=`<%l#;kQ#<w_[QOX#:mXZ#;kZ]#:m]^#;k^p#:mpq#;kqt#:mtu#;kuz#:mz{#<r{!P#:m!P!Q#=v!Q;'S#:m;'S;=`#>d<%lO#:mQ#=}V^Q[QOX'PZ]'P^p'Pqt'Pu;'S'P;'S;=`'k<%lO'PQ#>gP;=`<%l#:mV#>o_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!z#(_!z!{#?n!{;'S#(_;'S;=`#,Y<%lO#(_V#?s_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!g#(_!g!h#@r!h;'S#(_;'S;=`#,Y<%lO#(_V#@w_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!e#(_!e!f#Av!f;'S#(_;'S;=`#,Y<%lO#(_V#A}]RR[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{;'S#(_;'S;=`#,Y<%lO#(_V#B{_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!k#(_!k!l#Cz!l;'S#(_;'S;=`#,Y<%lO#(_V#DP_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!i#(_!i!j#EO!j;'S#(_;'S;=`#,Y<%lO#(_V#ET_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!t#(_!t!u#FS!u;'S#(_;'S;=`#,Y<%lO#(_V#FX_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!c#(_!c!d#GW!d;'S#(_;'S;=`#,Y<%lO#(_V#G]_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!v#(_!v!w#H[!w;'S#(_;'S;=`#,Y<%lO#(_V#Ha_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!g#(_!g!h#Av!h;'S#(_;'S;=`#,Y<%lO#(_V#Ie_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!w#(_!w!x#Jd!x;'S#(_;'S;=`#,Y<%lO#(_V#Ji_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!g#(_!g!h#Kh!h;'S#(_;'S;=`#,Y<%lO#(_V#Km_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!t#(_!t!u#Ll!u;'S#(_;'S;=`#,Y<%lO#(_V#Lq_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!{#(_!{!|#Av!|;'S#(_;'S;=`#,Y<%lO#(_V#Mua[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!c#(_!c!d#Nz!d!g#(_!g!h$#S!h;'S#(_;'S;=`#,Y<%lO#(_V$ P_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!d#(_!d!e$!O!e;'S#(_;'S;=`#,Y<%lO#(_V$!T_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!n#(_!n!o#H[!o;'S#(_;'S;=`#,Y<%lO#(_V$#X_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!u#(_!u!v$$W!v;'S#(_;'S;=`#,Y<%lO#(_V$$]_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!v#(_!v!w$%[!w;'S#(_;'S;=`#,Y<%lO#(_V$%a_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!f#(_!f!g$&`!g;'S#(_;'S;=`#,Y<%lO#(_V$&e_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!c#(_!c!d$'d!d;'S#(_;'S;=`#,Y<%lO#(_V$'i_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!v#(_!v!w$(h!w;'S#(_;'S;=`#,Y<%lO#(_V$(m_[QOX#(_XZ#)]Z]#(_]^#)]^p#(_pq#)]qt#(_tu#)]uz#(_z{#*f{!c#(_!c!d#Av!d;'S#(_;'S;=`#,Y<%lO#(_V$)seSP[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{!Q#Y!Q![$)l![!c#Y!c!}$)l!}#R#Y#R#S$)l#S#T#Y#T#o$)l#o;'S#Y;'S;=`'q<%lO#Y~$+Ze[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{!Q#Y!Q![$,l![!c#Y!c!}$,l!}#R#Y#R#S$,l#S#T#Y#T#o$,l#o;'S#Y;'S;=`'q<%lO#Y~$,seT~[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{!Q#Y!Q![$,l![!c#Y!c!}$,l!}#R#Y#R#S$,l#S#T#Y#T#o$,l#o;'S#Y;'S;=`'q<%lO#YV$.]]pP[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{;'S#Y;'S;=`'q<%lO#YU$/Z_[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{#g#Y#g#h$0Y#h;'S#Y;'S;=`'q<%lO#YU$0__[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{#X#Y#X#Y$1^#Y;'S#Y;'S;=`'q<%lO#YU$1c_[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{#h#Y#h#i$2b#i;'S#Y;'S;=`'q<%lO#YU$2i]oQ[QOX#YXZ$WZ]#Y]^$W^p#Ypq$Wqt#Ytu$Wuz#Yz{%_{;'S#Y;'S;=`'q<%lO#Y",
+	tokenizers: [
+		0,
+		1,
+		2
+	],
+	topRules: { "File": [0, 1] },
+	tokenPrec: 245
+});
+//#endregion
+//#region src/sql-query.ts
+var ListType = class {
+	constructor(baseType) {
+		this.baseType = baseType;
+	}
+	toString() {
+		return `${this.baseType.toString()}[]`;
+	}
+};
+var StructType = class {
+	constructor(fields) {
+		this.fields = fields;
+	}
+	toString() {
+		return `STRUCT(${this.fields.map((f) => `"${f.name}" ${f.type.toString()}`).join(", ")})`;
+	}
+};
+var MapType = class {
+	constructor(keyType, valueType) {
+		this.keyType = keyType;
+		this.valueType = valueType;
+	}
+	toString() {
+		return `MAP(${this.keyType.toString()}, ${this.valueType.toString()})`;
+	}
+};
+var EnumType = class {
+	constructor(values, name) {
+		this.values = values;
+		this.name = name;
+	}
+	toString() {
+		return `ENUM(${this.values.map((v) => `'${v}'`).join(", ")})`;
+	}
+};
+var SQLQuery = class {
+	columns;
+	allColumns;
+	/** Database-reported parameter types (variable name → SQL type), set by database adapters */
+	parameterTypes;
+	constructor(filename, id, rawQuery, queryAnonymous, queryNamed, queryPositional, type, isOne, isPluck, variables, config) {
+		this.filename = filename;
+		this.id = id;
+		this.rawQuery = rawQuery;
+		this.queryAnonymous = queryAnonymous;
+		this.queryNamed = queryNamed;
+		this.queryPositional = queryPositional;
+		this.type = type;
+		this.isOne = isOne;
+		this.isPluck = isPluck;
+		this.variables = variables;
+		this.config = config;
+		this.columns = [];
+	}
+	get isQuery() {
+		return this.type === "QUERY";
+	}
+	get isExec() {
+		return this.type === "EXEC";
+	}
+	get isMigrate() {
+		return this.type === "MIGRATE";
+	}
+	get isTestdata() {
+		return this.type === "TESTDATA";
+	}
+	get skipGenerateFunction() {
+		return this.isTestdata || this.isMigrate || this.id.startsWith("_");
+	}
+	validateVariables() {
+		const missingVars = [];
+		const varRegex = /\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
+		let match;
+		while (true) {
+			match = varRegex.exec(this.rawQuery);
+			if (match === null) break;
+			const varName = match[1];
+			if (!this.variables.has(varName)) missingVars.push(varName);
+		}
+		return missingVars;
+	}
+};
+/**
+* Represents a TABLE annotation for generating appenders.
+* TABLE annotations specify a table name for which to generate bulk insert appenders.
+*/
+var TableInfo = class {
+	/** Columns introspected from the database table schema */
+	columns = [];
+	constructor(filename, id, tableName, includeColumns, hasAppender) {
+		this.filename = filename;
+		this.id = id;
+		this.tableName = tableName;
+		this.includeColumns = includeColumns;
+		this.hasAppender = hasAppender;
+	}
+	get skipGenerateFunction() {
+		return !this.hasAppender;
+	}
+};
+function parseSQLQueries(filePath, extraVariables) {
+	const content = readFileSync(filePath, "utf-8");
+	consola.debug(`Parsing SQL file: ${filePath}`);
+	consola.debug(`File start: ${content.slice(0, 200)}`);
+	const queries = [];
+	const tables = [];
+	const cursor = parser.parse(content).cursor();
+	function getLineNumber(position) {
+		return content.slice(0, position).split("\n").length;
+	}
+	function getStr(nodeName, optional = false) {
+		const node = cursor.node.getChild(nodeName);
+		if (!node) {
+			if (optional) return;
+			const lineNumber = getLineNumber(cursor.node.from);
+			throw new Error(`Node '${nodeName}' not found at line ${lineNumber}`);
+		}
+		return nodeStr(node);
+	}
+	function nodeStr(node) {
+		return content.slice(node.from, node.to);
+	}
+	const queryNames = /* @__PURE__ */ new Set();
+	do
+		if (cursor.name === "QueryBlock") {
+			const queryType = (getStr("LineCommentStartSpecial", true) ?? getStr("BlockCommentStartSpecial")).replace("--", "").replace("/*", "").trim();
+			const name = getStr("Name").trim();
+			const modifiers = cursor.node.getChildren("Modifiers").map((node) => nodeStr(node));
+			const isOne = modifiers.includes(":one");
+			const isPluck = modifiers.includes(":pluck");
+			let configStr = getStr("Config", true);
+			if (configStr?.endsWith("*/")) configStr = configStr.slice(0, -2);
+			let config = null;
+			if (configStr) config = Config.fromYaml(name, filePath, configStr);
+			const setVars = cursor.node.getChildren("SetVarLine");
+			const variables = /* @__PURE__ */ new Map();
+			for (const setVar of setVars) {
+				const varName = nodeStr(setVar.getChild("Name"));
+				const value = nodeStr(setVar.getChild("Value"));
+				variables.set(varName, value.trim());
+			}
+			function getVariable(varName) {
+				if (variables.has(varName)) return variables.get(varName);
+				for (const extraVariable of extraVariables) if (extraVariable.name === varName) {
+					variables.set(varName, extraVariable.value);
+					return extraVariable.value;
+				}
+				const definedVars = Array.from(variables.keys());
+				const suggestion = definedVars.length > 0 ? `Add '@set ${varName} = <value>' before the query. Defined variables: ${definedVars.join(", ")}` : `Add '@set ${varName} = <value>' before the query`;
+				throw SqgError.inQuery(`Variable '\${${varName}}' is referenced but not defined`, "MISSING_VARIABLE", name, filePath, { suggestion });
+			}
+			const sqlNode = cursor.node.getChild("SQLBlock");
+			if (!sqlNode) throw SqgError.inQuery("SQL block not found", "SQL_PARSE_ERROR", name, filePath, { suggestion: "Ensure the query has valid SQL content after the annotation comment" });
+			const sqlContentStr = nodeStr(sqlNode).trim();
+			const sqlCursor = sqlNode.cursor();
+			let from = -1;
+			let to = -1;
+			class SQLQueryBuilder {
+				sqlParts = [];
+				appendSql(sql) {
+					this.sqlParts.push(sql);
+				}
+				appendVariable(varName, value) {
+					this.sqlParts.push({
+						name: varName,
+						value
+					});
+				}
+				trim() {
+					const lastPart = this.sqlParts.length > 0 ? this.sqlParts[this.sqlParts.length - 1] : null;
+					if (lastPart && typeof lastPart === "string") this.sqlParts[this.sqlParts.length - 1] = lastPart.trimEnd();
+				}
+				parameters() {
+					return this.sqlParts.filter((part) => typeof part !== "string" && !part.name.startsWith("sources_"));
+				}
+				toSqlWithAnonymousPlaceholders() {
+					let sql = "";
+					const sqlParts = [];
+					for (const part of this.sqlParts) if (typeof part === "string") {
+						sql += part;
+						sqlParts.push(part);
+					} else {
+						if (sql.length > 0) {
+							const last = sql[sql.length - 1];
+							if (last !== " " && last !== "=" && last !== ">" && last !== "<") sql += " ";
+						}
+						sql += "?";
+						if (part.name.startsWith("sources_")) sqlParts.push(part);
+						else sqlParts.push("?");
+					}
+					return {
+						parameters: this.parameters(),
+						sql,
+						sqlParts
+					};
+				}
+				toSqlWithPositionalPlaceholders() {
+					const parameters = [];
+					const sqlParts = [];
+					for (const part of this.sqlParts) if (typeof part === "string") sqlParts.push(part);
+					else {
+						const varName = part.name;
+						const value = part.value;
+						if (varName.startsWith("sources_")) sqlParts.push(part);
+						else {
+							let pos = parameters.findIndex((p) => p.name === varName);
+							if (pos < 0) {
+								parameters.push({
+									name: varName,
+									value
+								});
+								pos = parameters.length;
+							} else pos = pos + 1;
+							sqlParts.push(`$${pos}`);
+						}
+					}
+					return {
+						parameters,
+						sqlParts,
+						sql: sqlParts.map((part) => typeof part === "string" ? part : ` ${part.value} `).join("").trim()
+					};
+				}
+				toSqlWithNamedPlaceholders() {
+					const sqlParts = [];
+					for (const part of this.sqlParts) if (typeof part === "string") sqlParts.push(part);
+					else if (part.name.startsWith("sources_")) sqlParts.push(part);
+					else sqlParts.push(`$${part.name}`);
+					return {
+						parameters: this.parameters(),
+						sqlParts,
+						sql: sqlParts.map((part) => typeof part === "string" ? part : `$${part.name}`).join("").trim()
+					};
+				}
+			}
+			const sql = new SQLQueryBuilder();
+			if (sqlCursor.firstChild()) {
+				do {
+					const child = sqlCursor.node;
+					if (child.name === "BlockComment" || child.name === "LineComment") {
+						if (to > from) sql.appendSql(content.slice(from, to));
+						from = child.to;
+						sql.appendSql(" ");
+						continue;
+					}
+					if (child.name === "VarRef") {
+						const varRef = nodeStr(child);
+						if (!varRef.startsWith("${") || !varRef.endsWith("}")) throw SqgError.inQuery(`Invalid variable reference: ${varRef}`, "SQL_PARSE_ERROR", name, filePath, { suggestion: "Variables should be in the format ${varName}" });
+						const varName = varRef.replace("${", "").replace("}", "");
+						const value = getVariable(varName);
+						if (to > from) sql.appendSql(content.slice(from, to));
+						from = child.to;
+						sql.appendVariable(varName, value);
+					} else {
+						if (from < 0) from = child.from;
+						to = child.to;
+					}
+				} while (sqlCursor.nextSibling());
+				if (to > from) sql.appendSql(content.slice(from, to));
+				sql.trim();
+			}
+			if (queryType === "TABLE") {
+				const hasAppender = modifiers.includes(":appender");
+				const tableName = sqlContentStr.split("\n").map((l) => l.trim()).find((l) => l.length > 0) || name;
+				const includeColumns = [];
+				for (const mod of modifiers) {
+					const match = mod.match(/:appender\(([^)]+)\)/);
+					if (match) includeColumns.push(...match[1].split(",").map((c) => c.trim()));
+				}
+				const table = new TableInfo(filePath, name, tableName, includeColumns, hasAppender);
+				if (queryNames.has(name)) throw SqgError.inFile(`Duplicate name '${name}'`, "DUPLICATE_QUERY", filePath, { suggestion: "Rename one of the tables/queries to have a unique name" });
+				queryNames.add(name);
+				tables.push(table);
+				consola.debug(`Added table: ${name} -> ${tableName} (appender: ${hasAppender})`);
+				continue;
+			}
+			consola.debug("Parsed query:", {
+				type: queryType,
+				name,
+				modifiers,
+				variables: Object.fromEntries(variables),
+				sqlContent: sqlContentStr,
+				sql,
+				config
+			});
+			const query = new SQLQuery(filePath, name, sqlContentStr, sql.toSqlWithAnonymousPlaceholders(), sql.toSqlWithNamedPlaceholders(), sql.toSqlWithPositionalPlaceholders(), queryType, isOne, isPluck, variables, config);
+			if (queryNames.has(name)) throw SqgError.inFile(`Duplicate query name '${name}'`, "DUPLICATE_QUERY", filePath, { suggestion: "Rename one of the queries to have a unique name" });
+			queryNames.add(name);
+			queries.push(query);
+			consola.debug(`Added query: ${name} (${queryType})`);
+		}
+	while (cursor.next());
+	consola.debug(`Total queries parsed: ${queries.length}, tables: ${tables.length}`);
+	consola.debug(`Query names: ${queries.map((q) => q.id).join(", ")}`);
+	if (tables.length > 0) consola.debug(`Table names: ${tables.map((t) => t.id).join(", ")}`);
+	return {
+		queries,
+		tables
+	};
+}
+//#endregion
+//#region src/db/types.ts
+async function initializeDatabase(queries, execQueries, reporter) {
+	const migrationQueries = queries.filter((q) => q.isMigrate);
+	sortBy(migrationQueries, [(q) => Number(q.id.split("_")[1])]);
+	for (const query of migrationQueries) try {
+		await execQueries(query);
+	} catch (error) {
+		consola.error("Failed to initialize database:" + error.message + " when running query:\n\n " + query.rawQuery);
+		throw error;
+	}
+	const testdataQueries = queries.filter((q) => q.isTestdata);
+	for (const query of testdataQueries) try {
+		await execQueries(query);
+	} catch (error) {
+		consola.error("Failed to initialize testdata:" + error.message + " when running query:\n\n " + query.rawQuery);
+		throw error;
+	}
+	if (migrationQueries.length + testdataQueries.length === 0) consola.warn("No migration or testdata queries found");
+	reporter?.onDatabaseInitialized?.();
+}
+//#endregion
+//#region src/db/duckdb.ts
+/** Cache of enum type names, keyed by stringified sorted values for lookup */
+let enumNameCache = /* @__PURE__ */ new Map();
+function enumCacheKey(values) {
+	return values.join("\0");
+}
+function convertType(type) {
+	if (type instanceof DuckDBListType) return new ListType(convertType(type.valueType));
+	if (type instanceof DuckDBStructType) return new StructType(type.entryTypes.map((t, index) => ({
+		name: type.entryNames[index],
+		type: convertType(t),
+		nullable: true
+	})));
+	if (type instanceof DuckDBMapType) return new MapType({
+		name: "key",
+		type: convertType(type.keyType),
+		nullable: true
+	}, {
+		name: "value",
+		type: convertType(type.valueType),
+		nullable: true
+	});
+	if (type instanceof DuckDBEnumType) {
+		const name = type.alias ?? enumNameCache.get(enumCacheKey(type.values));
+		return new EnumType(type.values, name);
+	}
+	return type.toString();
+}
+const duckdb = new class {
+	db;
+	connection;
+	async initializeDatabase(queries, reporter) {
+		this.db = await DuckDBInstance.create(":memory:");
+		this.connection = await this.db.connect();
+		await initializeDatabase(queries, async (query) => {
+			try {
+				await this.connection.run(query.rawQuery);
+			} catch (e) {
+				throw new SqlExecutionError(e.message, query.id, query.filename, query.rawQuery, e);
+			}
+		}, reporter);
+		await this.loadEnumCache();
+	}
+	async loadEnumCache() {
+		enumNameCache = /* @__PURE__ */ new Map();
+		try {
+			const result = await this.connection.runAndReadAll("SELECT type_name, labels FROM duckdb_types() WHERE logical_type = 'ENUM' AND internal = false");
+			for (const row of result.getRows()) {
+				const typeName = row[0];
+				const labels = row[1];
+				if (typeName && labels?.items) enumNameCache.set(enumCacheKey(labels.items), typeName);
+			}
+			consola.debug("DuckDB enum types:", Object.fromEntries(enumNameCache));
+		} catch (e) {
+			consola.debug("Failed to load DuckDB enum types:", e.message);
+		}
+	}
+	async executeQueries(queries, reporter) {
+		const connection = this.connection;
+		if (!connection) throw new DatabaseError("DuckDB connection not initialized", "duckdb", "This is an internal error. Check that migrations completed successfully.");
+		try {
+			const executableQueries = queries.filter((q) => !q.skipGenerateFunction);
+			for (const query of executableQueries) {
+				reporter?.onQueryStart?.(query.id);
+				await this.executeQuery(connection, query);
+				reporter?.onQueryComplete?.(query.id);
+			}
+		} catch (error) {
+			consola.error("Error executing queries:", error.message);
+			throw error;
+		}
+	}
+	async executeQuery(connection, query) {
+		const statement = query.queryAnonymous;
+		try {
+			consola.debug("Query:", statement.sql, statement.sqlParts);
+			const sql = statement.sqlParts.map((part) => {
+				if (typeof part === "string") return part;
+				return ` ${part.value} `;
+			}).join("");
+			const stmt = await connection.prepare(sql);
+			if (stmt.parameterCount > 0) {
+				const paramTypes = /* @__PURE__ */ new Map();
+				for (let i = 0; i < stmt.parameterCount; i++) {
+					const paramType = stmt.parameterType(i + 1);
+					paramTypes.set(statement.parameters[i].name, convertType(paramType));
+				}
+				query.parameterTypes = paramTypes;
+				consola.debug("Parameter types:", Object.fromEntries(paramTypes));
+			}
+			for (let i = 0; i < stmt.parameterCount; i++) {
+				let value = statement.parameters[i].value;
+				if (value.startsWith("'") && value.endsWith("'") || value.startsWith("\"") && value.endsWith("\"")) value = value.slice(1, -1);
+				stmt.bindValue(i + 1, value);
+			}
+			if (query.isQuery) {
+				const result = await stmt.stream();
+				const columnNames = result.columnNames();
+				const columnTypes = result.columnTypes();
+				consola.debug("Columns:", columnNames);
+				consola.debug("Types:", columnTypes.map((t) => `${t.toString()} / ${t.constructor.name}`));
+				query.columns = columnNames.map((name, index) => ({
+					name,
+					type: convertType(columnTypes[index]),
+					nullable: true
+				}));
+			}
+			if (query.isQuery) {
+				if (query.isOne) return await stmt.runAndRead();
+				return await stmt.runAndReadAll();
+			}
+			return await stmt.run();
+		} catch (error) {
+			consola.error(`Failed to execute query '${query.id}':`, error);
+			throw error;
+		}
+	}
+	async introspectTables(tables, reporter) {
+		const connection = this.connection;
+		if (!connection) throw new DatabaseError("DuckDB connection not initialized", "duckdb", "This is an internal error. Check that migrations completed successfully.");
+		for (const table of tables) {
+			reporter?.onTableStart?.(table.tableName);
+			try {
+				const descRows = (await connection.runAndReadAll(`DESCRIBE ${table.tableName}`)).getRows();
+				const nullabilityMap = /* @__PURE__ */ new Map();
+				for (const row of descRows) nullabilityMap.set(row[0], row[2] !== "NO");
+				const stream = await (await connection.prepare(`SELECT * FROM ${table.tableName} LIMIT 0`)).stream();
+				const columnNames = stream.columnNames();
+				const columnTypes = stream.columnTypes();
+				table.columns = columnNames.map((name, index) => ({
+					name,
+					type: convertType(columnTypes[index]),
+					nullable: nullabilityMap.get(name) ?? true
+				}));
+				consola.debug(`Table ${table.tableName} columns:`, table.columns);
+				reporter?.onTableComplete?.(table.tableName, table.columns.length);
+			} catch (error) {
+				consola.error(`Failed to introspect table '${table.tableName}':`, error);
+				throw error;
+			}
+		}
+	}
+	close() {
+		this.connection.closeSync();
+		enumNameCache = /* @__PURE__ */ new Map();
+	}
+}();
+//#endregion
+//#region src/db/postgres.ts
+const tempDatabaseName = "sqg-db-temp";
+const typeIdToName = /* @__PURE__ */ new Map();
+for (const [name, id] of Object.entries(types.builtins)) typeIdToName.set(Number(id), name);
+/**
+* External database mode: connects directly to the user's database.
+* Uses a single transaction for the entire session and rolls back on close,
+* so the database is never modified. Individual queries use savepoints.
+*/
+var ExternalDbMode = class {
+	constructor(connectionString) {
+		this.connectionString = connectionString;
+	}
+	async connect() {
+		const db = new Client({ connectionString: this.connectionString });
+		try {
+			await db.connect();
+		} catch (e) {
+			throw new DatabaseError(`Failed to connect to PostgreSQL: ${e.message}`, "postgres", `Check that PostgreSQL is running and accessible at ${this.connectionString}.`);
+		}
+		await db.query("BEGIN");
+		return db;
+	}
+	async wrapQuery(db, fn) {
+		try {
+			await db.query("SAVEPOINT sqg_query");
+			return await fn();
+		} finally {
+			await db.query("ROLLBACK TO SAVEPOINT sqg_query");
+		}
+	}
+	async close(db) {
+		await db.query("ROLLBACK");
+		await db.end();
+	}
+};
+/**
+* Temp database mode: creates a temporary database for SQG to work in.
+* Connects to the provided server first (dbInitial) to CREATE the temp DB,
+* then connects to the temp DB for all operations.
+* On close, drops the temp DB and optionally stops the testcontainer.
+*/
+var TempDbMode = class {
+	dbInitial;
+	container = null;
+	constructor(connectionString, container) {
+		this.connectionString = connectionString;
+		this.container = container;
+	}
+	async connect() {
+		this.dbInitial = new Client({ connectionString: this.connectionString });
+		try {
+			await this.dbInitial.connect();
+		} catch (e) {
+			throw new DatabaseError(`Failed to connect to PostgreSQL: ${e.message}`, "postgres", `Check that PostgreSQL is running and accessible at ${this.connectionString}. Set SQG_POSTGRES_URL environment variable to use a different connection string.`);
+		}
+		try {
+			await this.dbInitial.query(`DROP DATABASE IF EXISTS "${tempDatabaseName}";`);
+		} catch (error) {}
+		try {
+			await this.dbInitial.query(`CREATE DATABASE "${tempDatabaseName}";`);
+		} catch (error) {
+			throw new DatabaseError(`Failed to create temporary database: ${error.message}`, "postgres", "Check PostgreSQL user permissions to create databases");
+		}
+		const db = new Client({ connectionString: this.connectionString.replace(/\/[^/]+$/, `/${tempDatabaseName}`) });
+		try {
+			await db.connect();
+		} catch (e) {
+			throw new DatabaseError(`Failed to connect to temporary database: ${e.message}`, "postgres");
+		}
+		return db;
+	}
+	async wrapQuery(db, fn) {
+		try {
+			await db.query("BEGIN");
+			return await fn();
+		} finally {
+			await db.query("ROLLBACK");
+		}
+	}
+	async close(db) {
+		await db.end();
+		await this.dbInitial.query(`DROP DATABASE IF EXISTS "${tempDatabaseName}"`);
+		await this.dbInitial.end();
+		if (this.container) {
+			await this.container.stop();
+			this.container = null;
+		}
+	}
+};
+const postgres = new class {
+	db;
+	mode;
+	dynamicTypeCache = /* @__PURE__ */ new Map();
+	enumTypeCache = /* @__PURE__ */ new Map();
+	async startContainer(reporter) {
+		reporter?.onContainerStarting?.();
+		const container = await new PostgreSqlContainer("postgres:16-alpine").withDatabase("sqg-db").withUsername("sqg").withPassword("secret").start();
+		const connectionUri = container.getConnectionUri();
+		reporter?.onContainerStarted?.(connectionUri);
+		return {
+			connectionUri,
+			container
+		};
+	}
+	async loadTypeCache(db) {
+		const result = await db.query(`
+      SELECT t.oid, t.typname, t.typtype, t.typelem, et.typname AS elemtype,
+             e.enumlabel
+      FROM pg_type t
+      LEFT JOIN pg_type et ON t.typelem = et.oid
+      LEFT JOIN pg_enum e ON t.oid = e.enumtypid AND t.typtype = 'e'
+      WHERE t.typtype IN ('b', 'e', 'r', 'c') -- base, enum, range, composite
+         OR t.typelem != 0 -- array types
+      ORDER BY t.oid, e.enumsortorder
+    `);
+		this.dynamicTypeCache = /* @__PURE__ */ new Map();
+		this.enumTypeCache = /* @__PURE__ */ new Map();
+		const enumsByOid = /* @__PURE__ */ new Map();
+		for (const row of result.rows) {
+			const oid = row.oid;
+			let typeName = row.typname;
+			if (typeName.startsWith("_") && row.elemtype) typeName = `_${row.elemtype.toUpperCase()}`;
+			else typeName = typeName.toUpperCase();
+			this.dynamicTypeCache.set(oid, typeName);
+			if (row.enumlabel) {
+				if (!enumsByOid.has(oid)) enumsByOid.set(oid, {
+					name: row.typname,
+					values: []
+				});
+				enumsByOid.get(oid).values.push(row.enumlabel);
+			}
+		}
+		for (const [oid, { name, values }] of enumsByOid) this.enumTypeCache.set(oid, new EnumType(values, name));
+	}
+	getTypeName(dataTypeID) {
+		const cached = this.dynamicTypeCache.get(dataTypeID);
+		if (cached) return cached;
+		return typeIdToName.get(dataTypeID) || `type_${dataTypeID}`;
+	}
+	getColumnType(dataTypeID) {
+		const enumType = this.enumTypeCache.get(dataTypeID);
+		if (enumType) return enumType;
+		return this.getTypeName(dataTypeID);
+	}
+	async initializeDatabase(queries, reporter) {
+		const externalUrl = process.env.SQG_POSTGRES_URL;
+		this.dynamicTypeCache = /* @__PURE__ */ new Map();
+		this.enumTypeCache = /* @__PURE__ */ new Map();
+		if (externalUrl) this.mode = new ExternalDbMode(externalUrl);
+		else {
+			const { connectionUri, container } = await this.startContainer(reporter);
+			this.mode = new TempDbMode(connectionUri, container);
+		}
+		this.db = await this.mode.connect();
+		await initializeDatabase(queries, async (query) => {
+			try {
+				await this.db.query(query.rawQuery);
+			} catch (e) {
+				throw new SqlExecutionError(e.message, query.id, query.filename, query.rawQuery, e);
+			}
+		}, reporter);
+		await this.loadTypeCache(this.db);
+	}
+	async executeQueries(queries, reporter) {
+		const db = this.db;
+		if (!db) throw new DatabaseError("PostgreSQL database not initialized", "postgres", "This is an internal error. Check that migrations completed successfully.");
+		try {
+			const executableQueries = queries.filter((q) => !q.skipGenerateFunction);
+			for (const query of executableQueries) {
+				reporter?.onQueryStart?.(query.id);
+				await this.executeQuery(db, query);
+				reporter?.onQueryComplete?.(query.id);
+			}
+		} catch (error) {
+			consola.error("Error executing queries:", error.message);
+			throw error;
+		}
+	}
+	async executeQuery(db, query) {
+		const statement = query.queryPositional;
+		try {
+			consola.debug("Query:", statement.sql);
+			const parameterValues = statement.parameters.map((p) => {
+				const value = p.value;
+				if (value.startsWith("'") && value.endsWith("'") || value.startsWith("\"") && value.endsWith("\"")) return value.slice(1, -1);
+				return value;
+			});
+			if (statement.parameters.length > 0) try {
+				await db.query("DEALLOCATE ALL");
+				await db.query(`PREPARE sqg_param_check AS ${statement.sql}`);
+				const paramTypeResult = await db.query(`SELECT unnest(parameter_types)::oid AS oid FROM pg_prepared_statements WHERE name = 'sqg_param_check'`);
+				await db.query("DEALLOCATE sqg_param_check");
+				if (paramTypeResult.rows.length === statement.parameters.length) {
+					const paramTypes = /* @__PURE__ */ new Map();
+					for (let i = 0; i < statement.parameters.length; i++) {
+						const oid = Number(paramTypeResult.rows[i].oid);
+						const colType = this.getColumnType(oid);
+						paramTypes.set(statement.parameters[i].name, colType);
+					}
+					query.parameterTypes = paramTypes;
+					consola.debug("Parameter types:", Object.fromEntries(paramTypes));
+				}
+			} catch (e) {
+				consola.debug(`Parameter type introspection failed for ${query.id}, using heuristic:`, e.message);
+			}
+			const result = await this.mode.wrapQuery(db, () => db.query(statement.sql, parameterValues));
+			if (query.isQuery) {
+				const columnNames = result.fields.map((field) => field.name);
+				const columnTypes = result.fields.map((field) => {
+					return this.getColumnType(field.dataTypeID);
+				});
+				consola.debug("Columns:", columnNames);
+				consola.debug("Types:", columnTypes.map((t) => t.toString()));
+				query.columns = columnNames.map((name, index) => ({
+					name,
+					type: columnTypes[index],
+					nullable: true
+				}));
+			}
+			if (query.isQuery) {
+				if (query.isOne) return result.rows[0] || null;
+				return result.rows;
+			}
+			return result;
+		} catch (error) {
+			consola.error(`Failed to execute query '${query.id}':`, error);
+			throw error;
+		}
+	}
+	async introspectTables(tables, reporter) {
+		const db = this.db;
+		if (!db) throw new DatabaseError("PostgreSQL database not initialized", "postgres", "This is an internal error. Check that migrations completed successfully.");
+		for (const table of tables) {
+			reporter?.onTableStart?.(table.tableName);
+			try {
+				table.columns = (await db.query(`SELECT column_name, data_type, udt_name, is_nullable, column_default, is_identity
+           FROM information_schema.columns
+           WHERE table_name = $1
+           ORDER BY ordinal_position`, [table.tableName])).rows.map((row) => ({
+					name: row.column_name,
+					type: row.udt_name.toUpperCase(),
+					nullable: row.is_nullable === "YES",
+					generated: row.is_identity === "YES" || (row.column_default?.startsWith("nextval") ?? false)
+				}));
+				reporter?.onTableComplete?.(table.tableName, table.columns.length);
+			} catch (error) {
+				consola.error(`Failed to introspect table '${table.tableName}':`, error);
+				throw error;
+			}
+		}
+	}
+	async close() {
+		await this.mode.close(this.db);
+		this.dynamicTypeCache = /* @__PURE__ */ new Map();
+		this.enumTypeCache = /* @__PURE__ */ new Map();
+	}
+}();
+//#endregion
+//#region src/db/sqlite.ts
+const sqlite = new class {
+	db;
+	async initializeDatabase(queries, reporter) {
+		const db = new BetterSqlite3(":memory:");
+		await initializeDatabase(queries, (query) => {
+			try {
+				db.exec(query.rawQuery);
+			} catch (e) {
+				throw new SqlExecutionError(e.message, query.id, query.filename, query.rawQuery, e);
+			}
+			return Promise.resolve();
+		}, reporter);
+		this.db = db;
+	}
+	executeQueries(queries, reporter) {
+		const db = this.db;
+		if (!db) throw new DatabaseError("SQLite database not initialized", "sqlite", "This is an internal error. Migrations may have failed silently.");
+		try {
+			const executableQueries = queries.filter((q) => !q.skipGenerateFunction);
+			for (const query of executableQueries) {
+				reporter?.onQueryStart?.(query.id);
+				this.executeQuery(db, query);
+				reporter?.onQueryComplete?.(query.id);
+			}
+		} catch (error) {
+			consola.error("Error executing queries:", error.message);
+			throw error;
+		}
+	}
+	introspectTables(tables, reporter) {
+		const db = this.db;
+		if (!db) throw new DatabaseError("SQLite database not initialized", "sqlite", "This is an internal error. Migrations may have failed silently.");
+		for (const table of tables) {
+			reporter?.onTableStart?.(table.tableName);
+			const info = this.getTableInfo(db, table.tableName);
+			table.columns = Array.from(info.values()).map((col) => ({
+				name: col.name,
+				type: col.type || "TEXT",
+				nullable: col.notnull === 0 && col.pk === 0
+			}));
+			reporter?.onTableComplete?.(table.tableName, table.columns.length);
+		}
+	}
+	close() {
+		this.db.close();
+	}
+	getTableInfo(db, table) {
+		const info = db.pragma(`table_info('${table}')`);
+		return new Map(info.map((col) => [col.name, col]));
+	}
+	executeQuery(db, query) {
+		const statement = query.queryAnonymous;
+		try {
+			consola.debug("Query:", statement.sql);
+			const stmt = db.prepare(statement.sql);
+			if (query.isQuery) {
+				const info = stmt.columns();
+				const tables = new Set(info.map((col) => col.table).filter(isNotNil));
+				const data = new Map(Array.from(tables).map((table) => [table, this.getTableInfo(db, table)]));
+				query.columns = info.map((col) => {
+					const colInfo = col.table ? data.get(col.table)?.get(col.name) : null;
+					return {
+						name: col.name,
+						type: col.type || "unknown",
+						nullable: colInfo?.pk === 0 && colInfo?.notnull === 0
+					};
+				});
+			}
+			if (query.isQuery) {
+				if (query.isOne) return stmt.get(...statement.parameters.map((p) => p.value));
+				return stmt.all(...statement.parameters.map((p) => p.value));
+			}
+			return stmt.run(...statement.parameters.map((p) => p.value));
+		} catch (error) {
+			consola.error(`Failed to execute query '${query.id}' in ${query.filename}:\n ${statement.sql} \n ${statement.parameters.map((p) => p.value).join(", ")}`, error);
+			throw error;
+		}
+	}
+}();
+//#endregion
+//#region src/db/index.ts
+function getDatabaseEngine(engine) {
+	switch (engine) {
+		case "sqlite": return sqlite;
+		case "duckdb": return duckdb;
+		case "postgres": return postgres;
+		default: throw new Error(`Unsupported database engine: ${engine}`);
+	}
+}
+//#endregion
+//#region src/type-mapping.ts
+/**
+* Abstract base class for mapping SQL column types to target language types.
+* Subclasses implement language-specific type mappings (e.g., Java, TypeScript).
+*/
+var TypeMapper = class {
+	/**
+	* Returns the target language type name for a given SQL column.
+	* Handles complex types (lists, structs, maps) by recursively resolving nested types.
+	* @param column - The column information including name, type, and nullability
+	* @param path - Optional prefix path for nested type references (e.g., "OuterStruct.")
+	* @returns The fully qualified type name in the target language
+	*/
+	getTypeName(column, path = "") {
+		if (column.type instanceof ListType) {
+			const elementType = this.getTypeName({
+				name: column.name,
+				type: column.type.baseType,
+				nullable: true
+			});
+			return path + this.formatListType(elementType);
+		}
+		if (column.type instanceof StructType) return path + this.formatStructTypeName(column.name);
+		if (column.type instanceof MapType) return path + this.formatMapTypeName(column.name);
+		if (!column.type) throw new TypeMappingError("Missing type information", column.name);
+		return this.mapPrimitiveType(column.type.toString(), column.nullable);
+	}
+	/**
+	* Wraps a column's type in the target language's list/array type.
+	* @param column - The column whose type should be wrapped in a list
+	* @returns The list type representation (e.g., "List<String>" for Java)
+	*/
+	listType(column) {
+		const baseType = this.getTypeName(column);
+		return this.formatListType(baseType);
+	}
+	/**
+	* Generates type declarations for complex types (structs, nested lists).
+	* For structs, generates a full type/interface declaration.
+	* For lists, recursively processes the element type.
+	* @param column - The column containing a complex type
+	* @param path - Optional prefix path for nested type references
+	* @returns Generated type declaration code, or empty string for primitive types
+	*/
+	getDeclarations(column, path = "") {
+		if (column.type instanceof StructType) return this.generateStructDeclaration(column, path);
+		if (column.type instanceof ListType) return this.getDeclarations({
+			name: column.name,
+			type: column.type.baseType,
+			nullable: true
+		}, path);
+		return "";
+	}
+};
+/**
+* Type mapper for generating Java types from SQL column types.
+* Maps SQL types to Java types (e.g., INTEGER -> Integer, VARCHAR -> String).
+* Generates Java records for struct types and handles Java reserved keywords.
+*/
+var JavaTypeMapper = class JavaTypeMapper extends TypeMapper {
+	typeMap = {
+		INTEGER: "Integer",
+		REAL: "Double",
+		TEXT: "String",
+		BLOB: "byte[]",
+		BOOLEAN: "Boolean",
+		DATE: "LocalDate",
+		DATETIME: "LocalDateTime",
+		TIMESTAMP: "LocalDateTime",
+		NULL: "null",
+		UNKNOWN: "Object",
+		DOUBLE: "Double",
+		FLOAT: "Float",
+		VARCHAR: "String",
+		TINYINT: "Byte",
+		SMALLINT: "Short",
+		BIGINT: "Long",
+		HUGEINT: "BigInteger",
+		UHUGEINT: "BigInteger",
+		UTINYINT: "Short",
+		USMALLINT: "Integer",
+		UINTEGER: "Long",
+		UBIGINT: "BigInteger",
+		TIME: "LocalTime",
+		"TIME WITH TIME ZONE": "OffsetTime",
+		TIMESTAMP_S: "Instant",
+		TIMESTAMP_MS: "Instant",
+		TIMESTAMP_NS: "Instant",
+		"TIMESTAMP WITH TIME ZONE": "OffsetDateTime",
+		UUID: "UUID",
+		INTERVAL: "String",
+		BIT: "String",
+		BIGNUM: "BigDecimal",
+		INT2: "Short",
+		INT4: "Integer",
+		INT8: "Long",
+		FLOAT4: "Float",
+		FLOAT8: "Double",
+		NUMERIC: "BigDecimal",
+		BOOL: "Boolean",
+		BYTEA: "byte[]",
+		TIMESTAMPTZ: "OffsetDateTime",
+		JSON: "String",
+		JSONB: "String",
+		OID: "Long",
+		SERIAL: "Integer",
+		BIGSERIAL: "Long"
+	};
+	static javaReservedKeywords = new Set([
+		"abstract",
+		"assert",
+		"boolean",
+		"break",
+		"byte",
+		"case",
+		"catch",
+		"char",
+		"class",
+		"const",
+		"continue",
+		"default",
+		"do",
+		"double",
+		"else",
+		"enum",
+		"extends",
+		"final",
+		"finally",
+		"float",
+		"for",
+		"goto",
+		"if",
+		"implements",
+		"import",
+		"instanceof",
+		"int",
+		"interface",
+		"long",
+		"native",
+		"new",
+		"package",
+		"private",
+		"protected",
+		"public",
+		"return",
+		"short",
+		"static",
+		"strictfp",
+		"super",
+		"switch",
+		"synchronized",
+		"this",
+		"throw",
+		"throws",
+		"transient",
+		"try",
+		"void",
+		"volatile",
+		"while",
+		"true",
+		"false",
+		"null"
+	]);
+	getTypeName(column, path = "") {
+		if (column.type instanceof EnumType && column.type.name) return path + pascalCase(column.type.name);
+		return super.getTypeName(column, path);
+	}
+	mapPrimitiveType(type, _nullable) {
+		const upperType = type.toString().toUpperCase();
+		const mappedType = this.typeMap[upperType];
+		if (mappedType) return mappedType;
+		if (upperType.startsWith("_")) {
+			const baseType = upperType.substring(1);
+			return `List<${this.typeMap[baseType] || "Object"}>`;
+		}
+		if (upperType.startsWith("DECIMAL(") || upperType.startsWith("NUMERIC(")) return "BigDecimal";
+		if (upperType.startsWith("ENUM(")) return "String";
+		if (upperType.startsWith("UNION(")) return "Object";
+		if (/\[\d+\]/.test(upperType)) return "Object";
+		return "String";
+	}
+	formatListType(elementType) {
+		return `List<${elementType}>`;
+	}
+	formatStructTypeName(fieldName) {
+		return `${pascalCase(fieldName)}Result`;
+	}
+	generateStructDeclaration(column, path = "") {
+		if (!(column.type instanceof StructType)) throw new Error(`Expected StructType ${column}`);
+		const structName = this.formatStructTypeName(column.name);
+		const newPath = `${path}${structName}.`;
+		const children = column.type.fields.map((field) => {
+			return this.getDeclarations({
+				name: field.name,
+				type: field.type,
+				nullable: true
+			}, newPath);
+		}).join("\n");
+		const fields = column.type.fields.map((field) => {
+			return `${this.getTypeName(field)} ${this.varName(field.name)}`;
+		}).join(", ");
+		const fromAttributes = ` private static ${structName} fromAttributes(Object[] v) {
+          return new ${structName}(${column.type.fields.map((f, i) => `${this.parseValue(f, `v[${i}]`, "")}`).join(",\n")});
+      }`;
+		return `public record ${structName}(${fields}) {
+     ${path.length > 0 ? fromAttributes : ""}
+      ${children}
+    }`;
+	}
+	formatMapTypeName(fieldName) {
+		return "HashMap";
+	}
+	varName(str) {
+		const name = camelCase(str);
+		if (JavaTypeMapper.javaReservedKeywords.has(name)) return `${name}_`;
+		return name;
+	}
+	parseValue(column, value, path) {
+		if (column.type instanceof EnumType && column.type.name) return `${pascalCase(column.type.name)}.fromValue((String)${value})`;
+		if (column.type instanceof ListType) {
+			const elementType = this.getTypeName({
+				name: column.name,
+				type: column.type.baseType,
+				nullable: true
+			}, path);
+			if (column.type.baseType instanceof StructType) return `arrayOfStructToList((Array)${value}, ${elementType}::fromAttributes)`;
+			if (column.type.baseType instanceof ListType) return `multiDimArrayToList((Array)${value}, ${this.getInnermostType(column.type)}[].class)`;
+			return `arrayToList((Array)${value}, ${elementType}[].class)`;
+		}
+		if (column.type instanceof StructType) return `${path}${this.formatStructTypeName(column.name)}.fromAttributes(getAttr((Struct)${value}))`;
+		const fieldType = this.getTypeName(column);
+		const upperType = column.type?.toString().toUpperCase() ?? "";
+		if (upperType === "TIMESTAMP" || upperType === "DATETIME") return `toLocalDateTime(${value})`;
+		if (upperType === "TIMESTAMPTZ") return `toOffsetDateTime(${value})`;
+		if (upperType === "TIMESTAMP WITH TIME ZONE") return `(OffsetDateTime)${value}`;
+		if (upperType === "DATE") return `toLocalDate(${value})`;
+		if (upperType === "TIME") return `toLocalTime(${value})`;
+		if (upperType.startsWith("_")) {
+			const baseType = upperType.substring(1);
+			return `arrayToList((Array)${value}, ${this.typeMap[baseType] || "Object"}[].class)`;
+		}
+		if (fieldType === "Short") return `${value} != null ? ((Number)${value}).shortValue() : null`;
+		if (fieldType === "Byte") return `${value} != null ? ((Number)${value}).byteValue() : null`;
+		if (upperType === "JSON" || upperType === "JSONB") return `${value} != null ? ${value}.toString() : null`;
+		return `(${fieldType})${value}`;
+	}
+	getInnermostType(type) {
+		let current = type.baseType;
+		while (current instanceof ListType) current = current.baseType;
+		return this.getTypeName({
+			name: "",
+			type: current,
+			nullable: true
+		});
+	}
+};
+/**
+* Type mapper for generating TypeScript types from SQL column types.
+* Maps SQL types to TypeScript types (e.g., INTEGER -> number, VARCHAR -> string).
+* Generates TypeScript interfaces for struct types and handles DuckDB's complex types.
+*/
+var TypeScriptTypeMapper = class extends TypeMapper {
+	/**
+	* Returns the TypeScript type name for a given SQL column.
+	* Overrides base to handle DuckDB's map type with key-value entry arrays.
+	*/
+	getTypeName(column, path = "") {
+		if (column.type instanceof MapType) return `{ entries: { key: ${this.getTypeName({
+			name: "key",
+			type: column.type.keyType.type,
+			nullable: true
+		})}; value: ${this.getTypeName({
+			name: "value",
+			type: column.type.valueType.type,
+			nullable: true
+		})} }[] }`;
+		return super.getTypeName(column, path);
+	}
+	typeMap = {
+		INTEGER: "number",
+		REAL: "number",
+		TEXT: "string",
+		BLOB: "{ bytes: Uint8Array }",
+		BOOLEAN: "boolean",
+		DATE: "{ days: number }",
+		DATETIME: "{ micros: bigint }",
+		TIMESTAMP: "{ micros: bigint }",
+		NULL: "null",
+		UNKNOWN: "unknown",
+		DOUBLE: "number",
+		FLOAT: "number",
+		VARCHAR: "string",
+		TINYINT: "number",
+		SMALLINT: "number",
+		BIGINT: "bigint",
+		HUGEINT: "bigint",
+		UHUGEINT: "bigint",
+		UTINYINT: "number",
+		USMALLINT: "number",
+		UINTEGER: "number",
+		UBIGINT: "bigint",
+		TIME: "{ micros: bigint }",
+		"TIME WITH TIME ZONE": "{ micros: bigint; offset: number }",
+		TIMESTAMP_S: "{ seconds: bigint }",
+		TIMESTAMP_MS: "{ millis: bigint }",
+		TIMESTAMP_NS: "{ nanos: bigint }",
+		"TIMESTAMP WITH TIME ZONE": "{ micros: bigint }",
+		UUID: "{ hugeint: bigint }",
+		INTERVAL: "{ months: number; days: number; micros: bigint }",
+		BIT: "{ data: Uint8Array }",
+		BIGNUM: "bigint",
+		INT2: "number",
+		INT4: "number",
+		INT8: "bigint",
+		FLOAT4: "number",
+		FLOAT8: "number",
+		NUMERIC: "string",
+		BOOL: "boolean",
+		BYTEA: "Buffer",
+		TIMESTAMPTZ: "Date",
+		JSON: "unknown",
+		JSONB: "unknown",
+		OID: "number",
+		SERIAL: "number",
+		BIGSERIAL: "bigint"
+	};
+	mapPrimitiveType(type, nullable) {
+		const upperType = type.toUpperCase();
+		const mappedType = this.typeMap[upperType];
+		if (mappedType) return nullable ? `${mappedType} | null` : mappedType;
+		if (upperType.startsWith("_")) {
+			const baseType = upperType.substring(1);
+			const arrayType = `${this.typeMap[baseType] || "unknown"}[]`;
+			return nullable ? `${arrayType} | null` : arrayType;
+		}
+		if (upperType.startsWith("DECIMAL(") || upperType.startsWith("NUMERIC(")) {
+			const baseType = "{ width: number; scale: number; value: bigint }";
+			return nullable ? `${baseType} | null` : baseType;
+		}
+		if (upperType.startsWith("ENUM(")) {
+			const baseType = "string";
+			return nullable ? `${baseType} | null` : baseType;
+		}
+		if (upperType.startsWith("UNION(")) {
+			const baseType = "{ tag: string; value: unknown }";
+			return nullable ? `${baseType} | null` : baseType;
+		}
+		const fixedArrayMatch = upperType.match(/^([A-Z_]+)\[(\d+)\](\[\d+\])*$/);
+		if (fixedArrayMatch) {
+			const baseTypeName = fixedArrayMatch[1];
+			const baseType = this.typeMap[baseTypeName];
+			if (baseType) {
+				const dimensions = (upperType.match(/\[\d+\]/g) || []).length;
+				let result = baseType;
+				for (let i = 0; i < dimensions; i++) result = `{ items: (${result} | null)[] }`;
+				return nullable ? `${result} | null` : result;
+			}
+		}
+		if (/\[\d+\]/.test(upperType)) return "{ items: unknown[] }";
+		return nullable ? "string | null" : "string";
+	}
+	formatListType(elementType) {
+		return `{ items: (${elementType})[] }`;
+	}
+	formatStructTypeName(fieldName) {
+		return `${pascalCase(fieldName)}Struct`;
+	}
+	formatMapTypeName(fieldName) {
+		return "Map";
+	}
+	generateStructDeclaration(column) {
+		if (!(column.type instanceof StructType)) throw new Error("Expected StructType");
+		return `interface ${this.formatStructTypeName(column.name)} {\n  entries: {\n${column.type.fields.map((field) => {
+			const fieldType = this.getTypeName({
+				name: field.name,
+				type: field.type,
+				nullable: true
+			});
+			return `    ${field.name}: ${fieldType};`;
+		}).join("\n")}\n  };\n}`;
+	}
+	/**
+	* Generates code to parse/convert a raw DuckDB value to the target TypeScript type.
+	* DuckDB returns complex types with specific wrapper structures that need to be preserved.
+	*/
+	parseValue(column, value, path = "") {
+		if (column.type instanceof ListType) return value;
+		if (column.type instanceof StructType) return value;
+		if (column.type instanceof MapType) return value;
+		return value;
+	}
+};
+/**
+* Type mapper for generating Python types from SQL column types.
+* Maps SQL types to Python types (e.g., INTEGER -> int, VARCHAR -> str).
+* Generates frozen dataclasses for struct types and handles Python reserved keywords.
+*/
+var PythonTypeMapper = class PythonTypeMapper extends TypeMapper {
+	constructor() {
+		super();
+	}
+	typeMap = {
+		INTEGER: "int",
+		INT: "int",
+		INT2: "int",
+		INT4: "int",
+		TINYINT: "int",
+		SMALLINT: "int",
+		BIGINT: "int",
+		INT8: "int",
+		HUGEINT: "int",
+		UHUGEINT: "int",
+		UTINYINT: "int",
+		USMALLINT: "int",
+		UINTEGER: "int",
+		UBIGINT: "int",
+		SERIAL: "int",
+		BIGSERIAL: "int",
+		REAL: "float",
+		DOUBLE: "float",
+		FLOAT: "float",
+		FLOAT4: "float",
+		FLOAT8: "float",
+		TEXT: "str",
+		VARCHAR: "str",
+		INTERVAL: "str",
+		BIT: "str",
+		UUID: "str",
+		BOOLEAN: "bool",
+		BOOL: "bool",
+		BLOB: "bytes",
+		BYTEA: "bytes",
+		DATE: "datetime.date",
+		TIMESTAMP: "datetime.datetime",
+		DATETIME: "datetime.datetime",
+		TIMESTAMPTZ: "datetime.datetime",
+		"TIMESTAMP WITH TIME ZONE": "datetime.datetime",
+		TIMESTAMP_S: "datetime.datetime",
+		TIMESTAMP_MS: "datetime.datetime",
+		TIMESTAMP_NS: "datetime.datetime",
+		TIME: "datetime.time",
+		"TIME WITH TIME ZONE": "datetime.time",
+		NUMERIC: "Decimal",
+		DECIMAL: "Decimal",
+		BIGNUM: "Decimal",
+		JSON: "Any",
+		JSONB: "Any",
+		NULL: "None",
+		UNKNOWN: "Any"
+	};
+	static pythonReservedKeywords = new Set([
+		"False",
+		"None",
+		"True",
+		"and",
+		"as",
+		"assert",
+		"async",
+		"await",
+		"break",
+		"class",
+		"continue",
+		"def",
+		"del",
+		"elif",
+		"else",
+		"except",
+		"finally",
+		"for",
+		"from",
+		"global",
+		"if",
+		"import",
+		"in",
+		"is",
+		"lambda",
+		"nonlocal",
+		"not",
+		"or",
+		"pass",
+		"raise",
+		"return",
+		"try",
+		"while",
+		"with",
+		"yield"
+	]);
+	mapPrimitiveType(type, nullable) {
+		const upperType = type.toString().toUpperCase();
+		const mappedType = this.typeMap[upperType];
+		if (mappedType) return nullable ? `${mappedType} | None` : mappedType;
+		if (upperType.startsWith("DECIMAL(") || upperType.startsWith("NUMERIC(")) return nullable ? "Decimal | None" : "Decimal";
+		if (upperType.startsWith("ENUM(")) return nullable ? "str | None" : "str";
+		if (upperType.startsWith("UNION(")) return nullable ? "Any | None" : "Any";
+		return nullable ? "Any | None" : "Any";
+	}
+	formatListType(elementType) {
+		return `list[${elementType}]`;
+	}
+	formatStructTypeName(fieldName) {
+		return `${pascalCase(fieldName)}Struct`;
+	}
+	formatMapTypeName(_fieldName) {
+		return "dict";
+	}
+	generateStructDeclaration(column, path = "") {
+		if (!(column.type instanceof StructType)) throw new Error(`Expected StructType ${column}`);
+		const structName = this.formatStructTypeName(column.name);
+		const newPath = `${path}${structName}.`;
+		const children = column.type.fields.map((field) => {
+			return this.getDeclarations({
+				name: field.name,
+				type: field.type,
+				nullable: true
+			}, newPath);
+		}).filter(Boolean).join("\n\n");
+		const fields = column.type.fields.map((field) => {
+			const fieldType = this.getTypeName(field);
+			return `    ${this.varName(field.name)}: ${fieldType}`;
+		}).join("\n");
+		let result = "";
+		if (children) result += `${children}\n\n`;
+		result += `@dataclass(frozen=True)\nclass ${structName}:\n${fields}`;
+		return result;
+	}
+	varName(str) {
+		const name = snakeCase(str);
+		if (PythonTypeMapper.pythonReservedKeywords.has(name)) return `${name}_`;
+		return name;
+	}
+	parseValue(column, value, _path) {
+		if (column.type instanceof StructType) return `${this.formatStructTypeName(column.name)}(${column.type.fields.map((field) => {
+			const pyName = this.varName(field.name);
+			const dictAccess = `${value}["${field.name}"]`;
+			if (field.type instanceof StructType) return `${pyName}=${this.parseValue(field, dictAccess, _path)}`;
+			return `${pyName}=${dictAccess}`;
+		}).join(", ")})`;
+		return value;
+	}
+};
+//#endregion
+//#region src/generators/base-generator.ts
+var BaseGenerator = class {
+	constructor(template, typeMapper) {
+		this.template = template;
+		this.typeMapper = typeMapper;
+	}
+	mapType(column) {
+		return this.typeMapper.getTypeName(column);
+	}
+	mapParameterType(type, nullable) {
+		return this.mapType({
+			name: "",
+			type,
+			nullable
+		});
+	}
+	listType(column) {
+		return this.typeMapper.listType(column);
+	}
+	async beforeGenerate(_projectDir, _gen, _queries, _tables) {}
+	isCompatibleWith(_engine) {
+		return true;
+	}
+	supportsAppenders(_engine) {
+		return false;
+	}
+	functionReturnType(query) {
+		if (query.isOne) return this.rowType(query);
+		return this.typeMapper.formatListType(this.rowType(query));
+	}
+	rowType(query) {
+		if (query.isPluck) return this.mapType({
+			...query.columns[0],
+			name: query.id
+		});
+		return this.getClassName(`${query.id}_Result`);
+	}
+	getStatement(q) {
+		return q.queryAnonymous;
+	}
+};
+//#endregion
+//#region src/generators/java-generator.ts
+var JavaGenerator = class extends BaseGenerator {
+	engine;
+	constructor(template, engine = "duckdb") {
+		super(template, new JavaTypeMapper());
+		this.template = template;
+		this.engine = engine;
+	}
+	supportsAppenders(engine) {
+		return engine === "duckdb" || engine === "postgres";
+	}
+	getFunctionName(id) {
+		return camelCase(id);
+	}
+	getFilename(sqlFileName) {
+		return `${pascalCase(sqlFileName)}.java`;
+	}
+	getClassName(name) {
+		return pascalCase(name);
+	}
+	partsToString(parts) {
+		const stringParts = [];
+		function addPart(str, quote) {
+			if (quote && stringParts.length > 0) {
+				const last = stringParts[stringParts.length - 1];
+				if (last.quote) {
+					last.str += str;
+					return;
+				}
+			}
+			stringParts.push({
+				str,
+				quote
+			});
+		}
+		for (const part of parts) if (typeof part === "string") addPart(part, true);
+		else {
+			addPart(" '", true);
+			addPart(part.name, false);
+			addPart("'", true);
+		}
+		return stringParts.map((part) => {
+			if (part.quote && (part.str.includes("\n") || part.str.includes("\""))) return `"""\n${part.str}"""`;
+			if (part.quote) return `"${part.str}"`;
+			return part.str;
+		}).join(" + ");
+	}
+	readColumn(column, index, path) {
+		return this.typeMapper.parseValue(column, `rs.getObject(${index + 1})`, path);
+	}
+	async beforeGenerate(_projectDir, _gen, _queries, _tables) {
+		Handlebars.registerHelper("isDuckDB", () => this.engine === "duckdb");
+		Handlebars.registerHelper("isPostgres", () => this.engine === "postgres");
+		Handlebars.registerHelper("pgBulkType", (column) => {
+			return pgBulkInsertType(column.type.toString().toUpperCase());
+		});
+		Handlebars.registerHelper("pgBulkAccessor", (column) => {
+			return pgBulkInsertAccessor(column.type.toString().toUpperCase());
+		});
+		Handlebars.registerHelper("javaVarName", (name) => {
+			const n = camelCase(name);
+			return JavaTypeMapper.javaReservedKeywords.has(n) ? `${n}_` : n;
+		});
+		Handlebars.registerHelper("partsToString", (parts) => this.partsToString(parts));
+		Handlebars.registerHelper("declareTypes", (queryHelper) => {
+			const query = queryHelper.query;
+			if (queryHelper.isPluck) return queryHelper.typeMapper.getDeclarations({
+				...query.columns[0],
+				name: query.id
+			}, " ");
+			return queryHelper.typeMapper.getDeclarations(query.allColumns);
+		});
+		Handlebars.registerHelper("appenderType", (column) => {
+			return this.mapType(column);
+		});
+		Handlebars.registerHelper("declareEnums", (queryHelpers) => {
+			const enumTypes = /* @__PURE__ */ new Map();
+			for (const qh of queryHelpers) {
+				for (const col of qh.query.columns) if (col.type instanceof EnumType && col.type.name) enumTypes.set(col.type.name, col.type);
+				if (qh.query.parameterTypes) {
+					for (const colType of qh.query.parameterTypes.values()) if (colType instanceof EnumType && colType.name) enumTypes.set(colType.name, colType);
+				}
+			}
+			if (enumTypes.size === 0) return "";
+			const parts = [];
+			for (const [, enumType] of enumTypes) {
+				const enumName = pascalCase(enumType.name);
+				const sanitized = enumType.values.map((v) => {
+					let ident = v.toUpperCase().replace(/[^A-Za-z0-9_]/g, "_");
+					if (ident.length > 0 && /^[0-9]/.test(ident)) ident = `_${ident}`;
+					if (ident.length === 0) ident = "_EMPTY";
+					return ident;
+				});
+				const usedIdents = /* @__PURE__ */ new Set();
+				const finalIdents = sanitized.map((base) => {
+					if (!usedIdents.has(base)) {
+						usedIdents.add(base);
+						return base;
+					}
+					let counter = 2;
+					let candidate = `${base}_${counter}`;
+					while (usedIdents.has(candidate)) {
+						counter++;
+						candidate = `${base}_${counter}`;
+					}
+					usedIdents.add(candidate);
+					return candidate;
+				});
+				const entries = enumType.values.map((v, i) => `${finalIdents[i]}("${v}")`);
+				parts.push(`public enum ${enumName} {
+    ${entries.join(", ")};
+    private final String value;
+    private static final java.util.Map<String, ${enumName}> BY_VALUE =
+        java.util.Map.ofEntries(java.util.Arrays.stream(values()).map(v -> java.util.Map.entry(v.value, v)).toArray(java.util.Map.Entry[]::new));
+    ${enumName}(String value) { this.value = value; }
+    public String getValue() { return value; }
+    public static ${enumName} fromValue(String value) {
+        ${enumName} result = BY_VALUE.get(value);
+        if (result == null) throw new IllegalArgumentException("Unknown value: " + value);
+        return result;
+    }
+}`);
+			}
+			return new Handlebars.SafeString(parts.join("\n\n    "));
+		});
+		Handlebars.registerHelper("readColumns", (queryHelper) => {
+			const query = queryHelper.query;
+			if (queryHelper.isPluck) return this.readColumn({
+				...query.columns[0],
+				name: query.id
+			}, 0, "");
+			const result = [];
+			const rowType = this.rowType(queryHelper.query);
+			for (let i = 0; i < queryHelper.columns.length; i++) {
+				const column = queryHelper.columns[i];
+				result.push(this.readColumn(column, i, `${rowType}.`));
+			}
+			return `new ${rowType}(${result.join(",\n")})`;
+		});
+	}
+	async afterGenerate(outputPath) {
+		try {
+			consola.debug("Formatting file:", outputPath);
+			const code = readFileSync(outputPath, "utf-8");
+			writeFileSync(outputPath, await prettier.format(code, {
+				parser: "java",
+				plugins: [prettierPluginJava],
+				tabWidth: 4
+			}));
+		} catch (error) {
+			consola.error("Failed to format Java file:", error);
+		}
+	}
+};
+const PG_BULK_TYPE_MAP = {
+	SMALLINT: "INT2",
+	INTEGER: "INT4",
+	BIGINT: "INT8",
+	REAL: "FLOAT4",
+	"DOUBLE PRECISION": "FLOAT8",
+	BOOLEAN: "BOOLEAN",
+	TEXT: "TEXT",
+	"CHARACTER VARYING": "TEXT",
+	CHARACTER: "TEXT",
+	NUMERIC: "NUMERIC",
+	DECIMAL: "NUMERIC",
+	DATE: "DATE",
+	"TIME WITHOUT TIME ZONE": "TIME",
+	"TIMESTAMP WITHOUT TIME ZONE": "TIMESTAMP",
+	"TIMESTAMP WITH TIME ZONE": "TIMESTAMPTZ",
+	UUID: "UUID",
+	BYTEA: "BYTEA",
+	JSONB: "JSONB",
+	JSON: "JSONB",
+	INT2: "INT2",
+	INT4: "INT4",
+	INT8: "INT8",
+	FLOAT4: "FLOAT4",
+	FLOAT8: "FLOAT8",
+	BOOL: "BOOLEAN",
+	VARCHAR: "TEXT",
+	TIMESTAMP: "TIMESTAMP",
+	TIMESTAMPTZ: "TIMESTAMPTZ"
+};
+function pgBulkInsertType(sqlType) {
+	if (sqlType.startsWith("_")) return `array(PgBulkInsert.PostgresTypes.${PG_BULK_TYPE_MAP[sqlType.substring(1)] || "TEXT"})`;
+	return PG_BULK_TYPE_MAP[sqlType] || "TEXT";
+}
+function pgBulkInsertAccessor(sqlType) {
+	if (sqlType === "TIMESTAMPTZ") return "offsetDateTime";
+	return "from";
+}
+//#endregion
+//#region src/generators/java-duckdb-arrow-generator.ts
+var JavaDuckDBArrowGenerator = class extends BaseGenerator {
+	javaGenerator;
+	constructor(template) {
+		super(template, new JavaTypeMapper());
+		this.template = template;
+		this.javaGenerator = new JavaGenerator("templates/java-jdbc.hbs");
+	}
+	getFunctionName(id) {
+		return this.javaGenerator.getFunctionName(id);
+	}
+	async beforeGenerate(projectDir, gen, queries, tables) {
+		const q = queries.filter((q) => q.isQuery && q.isOne || q.isMigrate);
+		const name = `${gen.name}-jdbc`;
+		writeGeneratedFile(projectDir, {
+			name,
+			generator: "java/duckdb/jdbc",
+			output: gen.output,
+			config: gen.config,
+			projectName: gen.projectName
+		}, this.javaGenerator, name, q, tables, "duckdb");
+	}
+	isCompatibleWith(engine) {
+		return engine === "duckdb";
+	}
+	supportsAppenders(_engine) {
+		return true;
+	}
+	getFilename(sqlFileName) {
+		return this.javaGenerator.getFilename(sqlFileName);
+	}
+	getClassName(name) {
+		return this.javaGenerator.getClassName(name);
+	}
+	mapType(column) {
+		const { type } = column;
+		if (typeof type === "string") {
+			const mappedType = {
+				INTEGER: "IntVector",
+				BIGINT: "BigIntVector",
+				BOOLEAN: "BitVector",
+				DOUBLE: "Float8Vector",
+				FLOAT: "Float4Vector",
+				VARCHAR: "VarCharVector",
+				TEXT: "VarCharVector",
+				TIMESTAMP: "TimeStampVector",
+				DATE: "DateDayVector",
+				TIME: "TimeMicroVector"
+			}[type.toUpperCase()];
+			if (!mappedType) consola.warn("(duckdb-arrow) Mapped type is unknown:", type);
+			return mappedType ?? "Object";
+		}
+		if (type instanceof ListType) return "ListVector";
+		if (type instanceof StructType) return "StructVector";
+		if (type instanceof MapType) return "MapVector";
+		consola.warn("(duckdb-arrow) Unknown complex type:", type);
+		return "Object";
+	}
+	mapParameterType(type, nullable) {
+		return this.typeMapper.getTypeName({
+			name: "",
+			type,
+			nullable
+		});
+	}
+	listType(type) {
+		const mockColumn = {
+			name: "",
+			type,
+			nullable: false
+		};
+		return this.typeMapper.listType(mockColumn);
+	}
+	async afterGenerate(outputPath) {
+		return this.javaGenerator.afterGenerate(outputPath);
+	}
+	functionReturnType(query) {
+		if (query.isOne) return this.javaGenerator.rowType(query);
+		return this.rowType(query);
+	}
+	rowType(query) {
+		if (query.isOne) return this.javaGenerator.rowType(query);
+		return this.getClassName(`${query.id}_Result`);
+	}
+};
+//#endregion
+//#region src/generators/python-generator.ts
+var PythonGenerator = class extends BaseGenerator {
+	engine;
+	constructor(template, engine) {
+		super(template, new PythonTypeMapper());
+		this.engine = engine;
+	}
+	get isDuckDB() {
+		return this.engine === "duckdb";
+	}
+	get isPostgres() {
+		return this.engine === "postgres";
+	}
+	getFunctionName(id) {
+		return snakeCase(id);
+	}
+	getFilename(sqlFileName) {
+		return `${snakeCase(sqlFileName)}.py`;
+	}
+	getClassName(name) {
+		return pascalCase(name);
+	}
+	rowType(query) {
+		if (query.isPluck) return this.mapType({
+			...query.columns[0],
+			name: query.id
+		});
+		return this.getClassName(`${query.id}_row`);
+	}
+	getStatement(q) {
+		if (this.isDuckDB) return q.queryPositional;
+		if (this.isPostgres) {
+			const anon = q.queryAnonymous;
+			return {
+				...anon,
+				sql: anon.sql.replace(/\?/g, "%s")
+			};
+		}
+		return q.queryAnonymous;
+	}
+	supportsAppenders(_engine) {
+		return this.engine === "duckdb" || this.engine === "postgres";
+	}
+	async beforeGenerate(_projectDir, _gen, _queries, _tables) {
+		const pyMapper = this.typeMapper;
+		Handlebars.registerHelper("isDuckDB", () => this.isDuckDB);
+		Handlebars.registerHelper("isPostgres", () => this.isPostgres);
+		Handlebars.registerHelper("connType", () => {
+			if (this.isDuckDB) return "duckdb.DuckDBPyConnection";
+			if (this.isPostgres) return "psycopg.Connection";
+			return "sqlite3.Connection";
+		});
+		Handlebars.registerHelper("quote", (value) => {
+			if (value.includes("\n") || value.includes("'") || value.includes("\"")) return `"""\\\n${value}"""`;
+			return `"${value}"`;
+		});
+		Handlebars.registerHelper("pyType", (column) => {
+			return this.getPyType(column);
+		});
+		Handlebars.registerHelper("declareTypes", (queryHelper) => {
+			const query = queryHelper.query;
+			if (queryHelper.isPluck) return "";
+			const columns = queryHelper.columns;
+			const rowTypeName = this.getClassName(`${query.id}_row`);
+			const nestedDecls = [];
+			for (const col of columns) {
+				const decl = this.typeMapper.getDeclarations(col);
+				if (decl) nestedDecls.push(decl);
+			}
+			const fields = columns.map((col) => {
+				const pyType = this.getPyType(col);
+				return `    ${pyMapper.varName(col.name)}: ${pyType}`;
+			}).join("\n");
+			let result = "";
+			if (nestedDecls.length > 0) result += `${nestedDecls.join("\n\n")}\n\n`;
+			result += `@dataclass(frozen=True)\nclass ${rowTypeName}:\n${fields}`;
+			return new Handlebars.SafeString(result);
+		});
+		Handlebars.registerHelper("constructRow", (queryHelper) => {
+			const query = queryHelper.query;
+			const columns = queryHelper.columns;
+			return `${this.getClassName(`${query.id}_row`)}(${columns.map((col, i) => {
+				const pyName = pyMapper.varName(col.name);
+				const value = `row[${i}]`;
+				return `${pyName}=${this.typeMapper.parseValue(col, value, "")}`;
+			}).join(", ")})`;
+		});
+		Handlebars.registerHelper("pyTypeOrNone", (column) => {
+			const t = this.getPyType(column);
+			if (t.endsWith(" | None")) return t;
+			return `${t} | None`;
+		});
+		Handlebars.registerHelper("pyVarName", (name) => {
+			return pyMapper.varName(name);
+		});
+		Handlebars.registerHelper("needsDatetime", (queries) => this.queryColumnsContainType(queries, "datetime."));
+		Handlebars.registerHelper("needsDecimal", (queries) => this.queryColumnsContainType(queries, "Decimal"));
+	}
+	queryColumnsContainType(queries, substring) {
+		for (const qh of queries) {
+			if (!qh.isQuery || qh.skipGenerateFunction) continue;
+			for (const col of qh.columns) if (this.getPyType(col).includes(substring)) return true;
+		}
+		return false;
+	}
+	getPyType(column) {
+		const t = column.type;
+		if (t instanceof ListType) {
+			const base = `list[${this.getPyType({
+				name: column.name,
+				type: t.baseType,
+				nullable: true
+			})}]`;
+			return column.nullable ? `${base} | None` : base;
+		}
+		if (t instanceof MapType) {
+			const base = `dict[${this.getPyType({
+				name: "key",
+				type: t.keyType.type,
+				nullable: false
+			})}, ${this.getPyType({
+				name: "value",
+				type: t.valueType.type,
+				nullable: true
+			})}]`;
+			return column.nullable ? `${base} | None` : base;
+		}
+		if (t instanceof StructType) {
+			const structName = `${pascalCase(column.name)}Struct`;
+			return column.nullable ? `${structName} | None` : structName;
+		}
+		return this.typeMapper.getTypeName(column);
+	}
+	async afterGenerate(outputPath) {
+		try {
+			execSync(`ruff format "${outputPath}"`, { stdio: "ignore" });
+		} catch {
+			consola.debug("ruff not available, skipping format for:", outputPath);
+		}
+	}
+};
+//#endregion
+//#region src/generators/typescript-generator.ts
+/** Resolve a ColumnType to its DuckDB type constant name (e.g. "VARCHAR", "INTEGER") for use in generated code. */
+function resolveElementType(baseType) {
+	if (baseType instanceof ListType) return `new DuckDBListType(${resolveElementType(baseType.baseType)})`;
+	return {
+		VARCHAR: "VARCHAR",
+		TEXT: "VARCHAR",
+		INTEGER: "INTEGER",
+		INT: "INTEGER",
+		BIGINT: "BIGINT",
+		DOUBLE: "DOUBLE",
+		FLOAT: "FLOAT",
+		BOOLEAN: "BOOLEAN",
+		DATE: "DATE",
+		TIMESTAMP: "TIMESTAMP",
+		SMALLINT: "SMALLINT",
+		TINYINT: "TINYINT"
+	}[baseType.toString().toUpperCase()] || "VARCHAR";
+}
+var TsGenerator = class extends BaseGenerator {
+	constructor(template) {
+		super(template, new TypeScriptTypeMapper());
+	}
+	getFunctionName(id) {
+		return camelCase(id);
+	}
+	isCompatibleWith(_engine) {
+		return true;
+	}
+	getFilename(sqlFileName) {
+		return `${sqlFileName}.ts`;
+	}
+	getClassName(name) {
+		return pascalCase(name);
+	}
+	async beforeGenerate(_projectDir, _gen, _queries, _tables) {
+		Handlebars.registerHelper("quote", (value) => this.quote(value));
+		Handlebars.registerHelper("appendMethod", (column) => {
+			if (column.type instanceof ListType) return "List";
+			const typeStr = column.type?.toString().toUpperCase() || "";
+			if (typeStr === "INTEGER" || typeStr === "INT" || typeStr === "INT4" || typeStr === "SIGNED") return "Integer";
+			if (typeStr === "SMALLINT" || typeStr === "INT2" || typeStr === "SHORT") return "SmallInt";
+			if (typeStr === "TINYINT" || typeStr === "INT1") return "TinyInt";
+			if (typeStr === "BIGINT" || typeStr === "INT8" || typeStr === "LONG") return "BigInt";
+			if (typeStr === "HUGEINT" || typeStr === "INT128") return "HugeInt";
+			if (typeStr === "UINTEGER" || typeStr === "UINT4") return "UInteger";
+			if (typeStr === "USMALLINT" || typeStr === "UINT2") return "USmallInt";
+			if (typeStr === "UTINYINT" || typeStr === "UINT1") return "UTinyInt";
+			if (typeStr === "UBIGINT" || typeStr === "UINT8") return "UBigInt";
+			if (typeStr === "DOUBLE" || typeStr === "FLOAT8" || typeStr === "NUMERIC" || typeStr === "DECIMAL") return "Double";
+			if (typeStr === "FLOAT" || typeStr === "FLOAT4" || typeStr === "REAL") return "Float";
+			if (typeStr === "BOOLEAN" || typeStr === "BOOL" || typeStr === "LOGICAL") return "Boolean";
+			if (typeStr === "DATE") return "Date";
+			if (typeStr === "TIMESTAMP" || typeStr.includes("TIMESTAMP")) return "Timestamp";
+			if (typeStr === "TIME" || typeStr.includes("TIME")) return "Time";
+			if (typeStr === "BLOB" || typeStr === "BYTEA" || typeStr === "BINARY" || typeStr === "VARBINARY") return "Blob";
+			if (typeStr === "UUID") return "Uuid";
+			if (typeStr === "INTERVAL") return "Interval";
+			return "Varchar";
+		});
+		Handlebars.registerHelper("appendListTypeArg", (column) => {
+			if (!(column.type instanceof ListType)) return "";
+			return `, new DuckDBListType(${resolveElementType(column.type.baseType)})`;
+		});
+		Handlebars.registerHelper("tsTypeForAppender", (column) => {
+			if (column.type instanceof ListType) {
+				const baseType = "readonly DuckDBValue[]";
+				return column.nullable ? `${baseType} | null` : baseType;
+			}
+			const typeStr = column.type?.toString().toUpperCase() || "";
+			let baseType;
+			if (typeStr === "INTEGER" || typeStr === "INT" || typeStr === "INT4" || typeStr === "SMALLINT" || typeStr === "INT2" || typeStr === "TINYINT" || typeStr === "INT1" || typeStr === "UINTEGER" || typeStr === "UINT4" || typeStr === "USMALLINT" || typeStr === "UINT2" || typeStr === "UTINYINT" || typeStr === "UINT1" || typeStr === "DOUBLE" || typeStr === "FLOAT8" || typeStr === "FLOAT" || typeStr === "FLOAT4" || typeStr === "REAL") baseType = "number";
+			else if (typeStr === "BIGINT" || typeStr === "INT8" || typeStr === "HUGEINT" || typeStr === "INT128" || typeStr === "UBIGINT" || typeStr === "UINT8") baseType = "bigint";
+			else if (typeStr === "BOOLEAN" || typeStr === "BOOL") baseType = "boolean";
+			else if (typeStr === "DATE") baseType = "DuckDBDateValue";
+			else if (typeStr === "TIMESTAMP" || typeStr.includes("TIMESTAMP")) baseType = "DuckDBTimestampValue";
+			else if (typeStr === "TIME" || typeStr.includes("TIME")) baseType = "DuckDBTimeValue";
+			else if (typeStr === "BLOB" || typeStr === "BYTEA") baseType = "DuckDBBlobValue";
+			else if (typeStr === "UUID") baseType = "string";
+			else baseType = "string";
+			if (column.nullable) return `${baseType} | null`;
+			return baseType;
+		});
+		Handlebars.registerHelper("tsType", (column) => {
+			const inlineType = (col) => {
+				const t = col.type;
+				const withNullability = (base) => {
+					if (!col.nullable) return base;
+					if (/\bnull\b/.test(base)) return base;
+					return `${base} | null`;
+				};
+				if (t instanceof ListType) {
+					const element = inlineType({
+						name: col.name,
+						type: t.baseType,
+						nullable: true
+					});
+					return withNullability(`${element.includes(" | ") ? `(${element})` : element}[]`);
+				}
+				if (t instanceof MapType) return withNullability(`Map<${inlineType({
+					name: "key",
+					type: t.keyType.type,
+					nullable: false
+				})}, ${inlineType({
+					name: "value",
+					type: t.valueType.type,
+					nullable: true
+				})}>`);
+				if (t instanceof StructType) {
+					const isValidIdent = (name) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+					return withNullability(`{ ${t.fields.map((f) => {
+						return `${isValidIdent(f.name) ? f.name : JSON.stringify(f.name)}: ${inlineType({
+							name: f.name,
+							type: f.type,
+							nullable: true
+						})}`;
+					}).join("; ")} }`);
+				}
+				if (t instanceof EnumType) return withNullability(t.values.map((v) => JSON.stringify(v)).join(" | "));
+				return this.typeMapper.getTypeName(col);
+			};
+			return inlineType(column);
+		});
+		Handlebars.registerHelper("declareTypes", (queryHelper) => {
+			const typeMapper = queryHelper.typeMapper;
+			const declarations = /* @__PURE__ */ new Map();
+			const visit = (column) => {
+				const t = column.type;
+				if (t instanceof ListType) {
+					visit({
+						name: column.name,
+						type: t.baseType,
+						nullable: true
+					});
+					return;
+				}
+				if (t instanceof StructType) {
+					const typeName = typeMapper.getTypeName(column);
+					if (!declarations.has(typeName)) declarations.set(typeName, typeMapper.getDeclarations(column));
+					for (const field of t.fields) visit({
+						name: field.name,
+						type: field.type,
+						nullable: true
+					});
+					return;
+				}
+				if (t instanceof MapType) {
+					visit({
+						name: column.name,
+						type: t.keyType.type,
+						nullable: true
+					});
+					visit({
+						name: column.name,
+						type: t.valueType.type,
+						nullable: true
+					});
+				}
+			};
+			if (queryHelper.isPluck) {
+				const col = queryHelper.columns[0];
+				visit({
+					name: col.name,
+					type: col.type,
+					nullable: true
+				});
+			} else for (const col of queryHelper.columns) visit({
+				name: col.name,
+				type: col.type,
+				nullable: true
+			});
+			return Array.from(declarations.values()).filter(Boolean).join("\n\n");
+		});
+	}
+	async afterGenerate(outputPath) {
+		try {
+			consola.debug("Formatting file:", outputPath);
+			const code = readFileSync(outputPath, "utf-8");
+			writeFileSync(outputPath, await prettier.format(code, {
+				parser: "typescript",
+				plugins: [typescriptPlugin, estree]
+			}));
+		} catch (error) {
+			consola.error("Failed to format file:", error);
+		}
+	}
+	quote(value) {
+		return value.includes("\n") || value.includes("'") ? `\`${value}\`` : `'${value}'`;
+	}
+};
+//#endregion
+//#region src/generators/typescript-duckdb-generator.ts
+/**
+* TypeScript generator for DuckDB.
+* DuckDB's Node API returns complex types as wrapper objects:
+* - Lists as { items: T[] }
+* - Structs as { entries: { field1: T1, ... } }
+* - Maps as { entries: { key: K, value: V }[] }
+*/
+var TsDuckDBGenerator = class extends TsGenerator {
+	constructor(template) {
+		super(template);
+	}
+	supportsAppenders(_engine) {
+		return true;
+	}
+	async beforeGenerate(projectDir, gen, queries, tables) {
+		await super.beforeGenerate(projectDir, gen, queries, tables);
+		Handlebars.registerHelper("hasListParams", (queryHelper) => {
+			const paramTypes = queryHelper.query.parameterTypes;
+			if (!paramTypes) return false;
+			for (const [, colType] of paramTypes) if (colType instanceof ListType) return true;
+			return false;
+		});
+		Handlebars.registerHelper("bindStatements", (queryHelper) => {
+			const paramNames = queryHelper.parameterNames;
+			const paramTypes = queryHelper.query.parameterTypes;
+			return paramNames.map((name, i) => {
+				const colType = paramTypes?.get(name);
+				if (colType instanceof ListType) return `stmt.bindList(${i + 1}, ${name}.items, new DuckDBListType(${resolveElementType(colType.baseType)}));`;
+				return `stmt.bindValue(${i + 1}, ${name});`;
+			}).join("\n        ");
+		});
+		Handlebars.registerHelper("tsType", (column) => {
+			const inlineType = (col) => {
+				const t = col.type;
+				const withNullability = (base) => {
+					if (!col.nullable) return base;
+					if (/\bnull\b/.test(base)) return base;
+					return `${base} | null`;
+				};
+				if (t instanceof ListType) {
+					const element = inlineType({
+						name: col.name,
+						type: t.baseType,
+						nullable: true
+					});
+					return withNullability(`{ items: ${element.includes(" | ") ? `(${element})` : element}[] }`);
+				}
+				if (t instanceof MapType) return withNullability(`{ entries: { key: ${inlineType({
+					name: "key",
+					type: t.keyType.type,
+					nullable: true
+				})}; value: ${inlineType({
+					name: "value",
+					type: t.valueType.type,
+					nullable: true
+				})} }[] }`);
+				if (t instanceof StructType) {
+					const isValidIdent = (name) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+					return withNullability(`{ entries: { ${t.fields.map((f) => {
+						return `${isValidIdent(f.name) ? f.name : JSON.stringify(f.name)}: ${inlineType({
+							name: f.name,
+							type: f.type,
+							nullable: true
+						})}`;
+					}).join("; ")} } }`);
+				}
+				if (t instanceof EnumType) return withNullability(t.values.map((v) => JSON.stringify(v)).join(" | "));
+				return this.typeMapper.getTypeName(col);
+			};
+			return inlineType(column);
+		});
+	}
+};
+//#endregion
+//#region src/generators/index.ts
+/**
+* Get a generator instance for the given generator.
+* Accepts both short (language/engine) and full (language/engine/driver) formats.
+*/
+function getGenerator(generator) {
+	const fullGenerator = resolveGenerator(generator);
+	try {
+		const info = parseGenerator(generator);
+		const key = `${info.language}/${info.driver}`;
+		switch (key) {
+			case "typescript/better-sqlite3":
+			case "typescript/node":
+			case "typescript/libsql":
+			case "typescript/turso": return new TsGenerator(`templates/${info.template}`);
+			case "typescript/node-api": return new TsDuckDBGenerator(`templates/${info.template}`);
+			case "java/jdbc": return new JavaGenerator(`templates/${info.template}`, info.engine);
+			case "java/arrow": return new JavaDuckDBArrowGenerator(`templates/${info.template}`);
+			case "python/sqlite3": return new PythonGenerator(`templates/${info.template}`, "sqlite");
+			case "python/duckdb": return new PythonGenerator(`templates/${info.template}`, "duckdb");
+			case "python/psycopg": return new PythonGenerator(`templates/${info.template}`, "postgres");
+			default: throw new Error(`No generator class for ${key}`);
+		}
+	} catch {
+		const similar = findSimilarGenerators(generator);
+		throw new InvalidGeneratorError(fullGenerator, [...SHORT_GENERATOR_NAMES, ...GENERATOR_NAMES], similar.length > 0 ? similar[0] : void 0);
+	}
+}
+//#endregion
+//#region src/sqltool.ts
+const GENERATED_FILE_COMMENT = "This file is generated by SQG (https://sqg.dev). Do not edit manually.";
+const configSchema = z.object({ result: z.record(z.string(), z.string()).optional() });
+var Config = class Config {
+	constructor(result) {
+		this.result = result;
+	}
+	getColumnInfo(name) {
+		return this.result.get(name);
+	}
+	static fromYaml(name, filePath, configStr) {
+		let configObj;
+		try {
+			configObj = YAML.parse(configStr);
+		} catch (e) {
+			throw new Error(`Error parsing YAML config for query ${name} in ${filePath}: \n${configStr}\n ${e}`);
+		}
+		const result = configSchema.safeParse(configObj);
+		if (!result.success) throw new Error(`Error parsing config for query ${name} in ${filePath}: \n${configStr}\n ${result.error}`);
+		const columnMap = /* @__PURE__ */ new Map();
+		for (const [name, info] of Object.entries(result.data.result ?? {})) {
+			const parts = info.trim().split(" ").map((part) => part.trim());
+			let type;
+			let nullable = true;
+			if (parts.length === 1) type = parts[0];
+			else if (parts.length === 2) {
+				type = parts[0];
+				if (parts[1].toLocaleLowerCase() !== "null") throw new Error(`Invalid config for column ${name} in ${filePath}: \n${configStr}\n ${info}`);
+				nullable = true;
+			} else if (parts.length === 3) {
+				type = parts[0];
+				if (parts[1].toLocaleLowerCase() !== "not" || parts[2].toLocaleLowerCase() !== "null") throw new Error(`Invalid config for column ${name} in ${filePath}: \n${configStr}\n ${info}`);
+				nullable = false;
+			} else throw new Error(`Invalid config for column ${name} in ${filePath}: \n${configStr}\n ${info}`);
+			columnMap.set(name, {
+				name,
+				type,
+				nullable
+			});
+		}
+		return new Config(columnMap);
+	}
+};
+/** Util class to help generating a query with a given generator */
+var SqlQueryHelper = class {
+	constructor(query, generator, statement) {
+		this.query = query;
+		this.generator = generator;
+		this.statement = statement;
+	}
+	get id() {
+		return this.query.id;
+	}
+	get isQuery() {
+		return this.query.isQuery;
+	}
+	get isExec() {
+		return this.query.isExec;
+	}
+	get isMigrate() {
+		return this.query.isMigrate;
+	}
+	get isPluck() {
+		return this.query.isPluck;
+	}
+	get isOne() {
+		return this.query.isOne;
+	}
+	get parameterNames() {
+		return this.statement.parameters.map((param) => param.name);
+	}
+	get skipGenerateFunction() {
+		return this.query.skipGenerateFunction;
+	}
+	get parameters() {
+		const vars = new Map(this.variables.map((param) => [param.name, param.type]));
+		return this.statement.parameters.map((param) => {
+			const rawType = this.query.parameterTypes?.get(param.name);
+			let isArray = false;
+			let arrayBaseType = null;
+			let isEnum = false;
+			let enumClassName = null;
+			if (rawType instanceof EnumType && rawType.name) {
+				isEnum = true;
+				enumClassName = pascalCase(rawType.name);
+			} else if (rawType instanceof ListType) {
+				isArray = true;
+				arrayBaseType = rawType.baseType.toString();
+			} else if (typeof rawType === "string" && rawType.startsWith("_")) {
+				isArray = true;
+				arrayBaseType = rawType.substring(1);
+			}
+			return {
+				name: param.name,
+				type: vars.get(param.name),
+				isArray,
+				arrayBaseType,
+				isEnum,
+				enumClassName
+			};
+		});
+	}
+	get columns() {
+		if (!(this.query.allColumns.type instanceof StructType)) throw new Error(`Expected StructType ${this.query.allColumns.type}`);
+		return this.query.allColumns.type.fields;
+	}
+	get variables() {
+		return Array.from(this.query.variables.entries()).map(([name, value]) => ({
+			name,
+			type: this.generator.mapParameterType(this.query.parameterTypes?.get(name) ?? detectParameterType(value), false)
+		}));
+	}
+	get sqlQuery() {
+		return this.statement.sql;
+	}
+	get sqlQueryParts() {
+		return this.statement.sqlParts;
+	}
+	get rowTypeStr() {
+		return this.generator.rowType(this.query);
+	}
+	get functionReturnType() {
+		return new Handlebars.SafeString(this.generator.functionReturnType(this.query));
+	}
+	get rowType() {
+		return new Handlebars.SafeString(this.rowTypeStr);
+	}
+	get functionName() {
+		return this.generator.getFunctionName(this.query.id);
+	}
+	get typeMapper() {
+		return this.generator.typeMapper;
+	}
+};
+/** Util class to help generating appenders for tables */
+var TableHelper = class {
+	constructor(table, generator) {
+		this.table = table;
+		this.generator = generator;
+	}
+	get id() {
+		return this.table.id;
+	}
+	get tableName() {
+		return this.table.tableName;
+	}
+	get columns() {
+		let cols = this.table.columns;
+		if (this.table.includeColumns.length > 0) cols = cols.filter((c) => this.table.includeColumns.includes(c.name));
+		return cols.filter((c) => !c.generated);
+	}
+	get skipGenerateFunction() {
+		return this.table.skipGenerateFunction;
+	}
+	get functionName() {
+		return this.generator.getFunctionName(`create_${this.table.id}_appender`);
+	}
+	get className() {
+		return this.generator.getClassName(`${this.table.id}_appender`);
+	}
+	get rowTypeName() {
+		return this.generator.getClassName(`${this.table.id}_row`);
+	}
+	get constantName() {
+		return this.table.id.toUpperCase();
+	}
+	get typeMapper() {
+		return this.generator.typeMapper;
+	}
+};
+function generateSourceFile(name, queries, tables, templatePath, generator, engine, projectName, config) {
+	const templateSrc = readFileSync(templatePath, "utf-8");
+	const template = Handlebars.compile(templateSrc);
+	Handlebars.registerHelper("mapType", (column) => generator.mapType(column));
+	Handlebars.registerHelper("plusOne", (value) => value + 1);
+	const migrations = queries.filter((q) => q.isMigrate).map((q) => new SqlQueryHelper(q, generator, generator.getStatement(q)));
+	const tableHelpers = generator.supportsAppenders(engine) ? tables.filter((t) => !t.skipGenerateFunction).map((t) => new TableHelper(t, generator)) : [];
+	return template({
+		generatedComment: GENERATED_FILE_COMMENT,
+		migrations,
+		queries: queries.map((q) => new SqlQueryHelper(q, generator, generator.getStatement(q))),
+		tables: tableHelpers,
+		className: generator.getClassName(name),
+		projectName,
+		config
+	}, {
+		allowProtoPropertiesByDefault: true,
+		allowProtoMethodsByDefault: true
+	});
+}
+/** All valid generator strings for schema validation */
+const validGenerators = [...SHORT_GENERATOR_NAMES, ...GENERATOR_NAMES];
+/**
+* Project configuration schema with descriptions for validation messages
+*/
+const ProjectSchema = z.object({
+	version: z.number().describe("Configuration version (currently 1)"),
+	name: z.string().min(1, "Project name is required").describe("Project name used for generated class names"),
+	sql: z.array(z.object({
+		files: z.array(z.string().min(1)).min(1, "At least one SQL file is required").describe("SQL files to process"),
+		gen: z.array(z.object({
+			generator: z.string().refine((val) => isValidGenerator(val), { message: `Invalid generator. Valid generators: ${validGenerators.join(", ")}` }).describe(`Code generation generator: ${SHORT_GENERATOR_NAMES.join(", ")}`),
+			name: z.string().optional().describe("Override the generated class/module name"),
+			template: z.string().optional().describe("Custom Handlebars template path"),
+			output: z.string().min(1, "Output path is required").describe("Output file or directory path"),
+			config: z.any().optional().describe("Generator-specific configuration")
+		})).min(1, "At least one generator is required").describe("Code generators to run")
+	})).min(1, "At least one SQL configuration is required").describe("SQL file configurations"),
+	sources: z.array(z.object({
+		path: z.string().describe("Path to source file (supports $HOME)"),
+		name: z.string().optional().describe("Variable name override")
+	})).optional().describe("External source files to include as variables")
+});
+var ExtraVariable = class {
+	constructor(name, value) {
+		this.name = name;
+		this.value = value;
+	}
+};
+function createExtraVariables(sources, suppressLogging = false) {
+	return sources.map((source) => {
+		const path = source.path;
+		const resolvedPath = path.replace("$HOME", homedir());
+		const varName = `sources_${(source.name ?? basename(path, extname(resolvedPath))).replace(/\s+/g, "_")}`;
+		if (!suppressLogging) consola.debug("Extra variable:", varName, resolvedPath);
+		return new ExtraVariable(varName, `'${resolvedPath}'`);
+	});
+}
+function buildProjectFromCliOptions(options) {
+	if (!isValidGenerator(options.generator)) {
+		const similar = findSimilarGenerators(options.generator);
+		const allGenerators = [...SHORT_GENERATOR_NAMES, ...GENERATOR_NAMES];
+		throw new InvalidGeneratorError(options.generator, allGenerators, similar.length > 0 ? similar[0] : void 0);
+	}
+	const generatorInfo = parseGenerator(options.generator);
+	const genConfig = {
+		generator: options.generator,
+		output: options.output || "."
+	};
+	if (generatorInfo.language === "java") genConfig.config = { package: "generated" };
+	return {
+		version: 1,
+		name: options.name || "generated",
+		sql: [{
+			files: options.files,
+			gen: [genConfig]
+		}]
+	};
+}
+/**
+* Parse and validate project configuration with helpful error messages
+*/
+function parseProjectConfig(filePath) {
+	if (!existsSync(filePath)) throw new FileNotFoundError(filePath, process.cwd());
+	let content;
+	try {
+		content = readFileSync(filePath, "utf-8");
+	} catch (e) {
+		throw new SqgError(`Cannot read config file: ${filePath}`, "CONFIG_PARSE_ERROR", "Check file permissions and that the path is correct");
+	}
+	let parsed;
+	try {
+		parsed = YAML.parse(content);
+	} catch (e) {
+		throw new SqgError(`Invalid YAML syntax in ${filePath}: ${e.message}`, "CONFIG_PARSE_ERROR", "Check YAML syntax - common issues: incorrect indentation, missing colons, unquoted special characters");
+	}
+	if (parsed && typeof parsed === "object") {
+		const obj = parsed;
+		if (obj.sql && Array.isArray(obj.sql)) for (let i = 0; i < obj.sql.length; i++) {
+			const sqlConfig = obj.sql[i];
+			if (sqlConfig.gen && Array.isArray(sqlConfig.gen)) for (let j = 0; j < sqlConfig.gen.length; j++) {
+				const genConfig = sqlConfig.gen[j];
+				if (genConfig.generator && !isValidGenerator(String(genConfig.generator))) {
+					const similar = findSimilarGenerators(String(genConfig.generator));
+					const allGenerators = [...SHORT_GENERATOR_NAMES, ...GENERATOR_NAMES];
+					throw new InvalidGeneratorError(String(genConfig.generator), allGenerators, similar.length > 0 ? similar[0] : void 0);
+				}
+			}
+		}
+	}
+	const result = ProjectSchema.safeParse(parsed);
+	if (!result.success) throw new ConfigError(`Configuration error in ${filePath}:\n${z.prettifyError(result.error)}`, "Check the configuration format against the documentation at https://sqg.dev", { file: filePath });
+	return result.data;
+}
+function detectParameterType(value) {
+	const num = Number(value);
+	if (!Number.isNaN(num)) {
+		if (Number.isInteger(num)) return "INTEGER";
+		return "REAL";
+	}
+	if (value.toLowerCase() === "true" || value.toLowerCase() === "false") return "BOOLEAN";
+	return "TEXT";
+}
+function getOutputPath(projectDir, sqlFileName, gen, generator) {
+	const pathParts = [];
+	if (!gen.output.startsWith("/")) pathParts.push(projectDir);
+	if (gen.output.endsWith("/")) {
+		const name = generator.getFilename(sqlFileName);
+		pathParts.push(gen.output, name);
+	} else pathParts.push(gen.output);
+	const outputPath = join(...pathParts);
+	mkdirSync(dirname(outputPath), { recursive: true });
+	return outputPath;
+}
+function validateQueries(queries) {
+	for (const query of queries) {
+		if (query.isQuery && query.isPluck && query.columns.length !== 1) throw SqgError.inQuery(`':pluck' modifier requires exactly 1 column, but query has ${query.columns.length} columns`, "VALIDATION_ERROR", query.id, query.filename, { suggestion: query.columns.length === 0 ? "Ensure the query returns at least one column" : `Remove ':pluck' or select only one column. Current columns: ${query.columns.map((c) => c.name).join(", ")}` });
+		const columns = query.columns.map((col) => {
+			const configColumn = query.config?.getColumnInfo(col.name);
+			if (configColumn) return configColumn;
+			return col;
+		});
+		query.allColumns = {
+			name: query.id,
+			nullable: false,
+			type: new StructType(columns)
+		};
+	}
+}
+async function writeGeneratedFile(projectDir, gen, generator, file, queries, tables, engine, writeToStdout = false) {
+	await generator.beforeGenerate(projectDir, gen, queries, tables);
+	const templatePath = join(dirname(new URL(import.meta.url).pathname), gen.template ?? generator.template);
+	const name = gen.name ?? basename(file, extname(file));
+	const sourceFile = generateSourceFile(name, queries, tables, templatePath, generator, engine, gen.projectName ?? name, {
+		migrations: true,
+		...gen.config
+	});
+	if (writeToStdout) {
+		process.stdout.write(sourceFile);
+		if (!sourceFile.endsWith("\n")) process.stdout.write("\n");
+		return null;
+	}
+	const outputPath = getOutputPath(projectDir, name, gen, generator);
+	writeFileSync(outputPath, sourceFile);
+	await generator.afterGenerate(outputPath);
+	return outputPath;
+}
+/**
+* Validate project configuration from a Project object without executing queries
+* Use this for pre-flight checks before generation
+*/
+async function validateProjectFromConfig(project, projectDir) {
+	const errors = [];
+	const sqlFiles = [];
+	const generators = [];
+	for (const sql of project.sql) for (const sqlFile of sql.files) {
+		const fullPath = join(projectDir, sqlFile);
+		sqlFiles.push(sqlFile);
+		if (!existsSync(fullPath)) errors.push({
+			code: "FILE_NOT_FOUND",
+			message: `SQL file not found: ${sqlFile}`,
+			suggestion: `Check that ${sqlFile} exists relative to ${projectDir}`,
+			context: { file: fullPath }
+		});
+		for (const gen of sql.gen) {
+			generators.push(gen.generator);
+			if (!isValidGenerator(gen.generator)) {
+				const similar = findSimilarGenerators(gen.generator);
+				errors.push({
+					code: "INVALID_GENERATOR",
+					message: `Invalid generator '${gen.generator}'`,
+					suggestion: similar.length > 0 ? `Did you mean '${similar[0]}'?` : `Valid generators: ${SHORT_GENERATOR_NAMES.join(", ")}`,
+					context: { generator: gen.generator }
+				});
+			}
+		}
+	}
+	return {
+		valid: errors.length === 0,
+		project: {
+			name: project.name,
+			version: project.version
+		},
+		sqlFiles: [...new Set(sqlFiles)],
+		generators: [...new Set(generators)],
+		errors: errors.length > 0 ? errors : void 0
+	};
+}
+/**
+* Validate project configuration from a YAML file without executing queries
+* Use this for pre-flight checks before generation
+*/
+async function validateProject(projectPath) {
+	const projectDir = resolve(dirname(projectPath));
+	let project;
+	try {
+		project = parseProjectConfig(projectPath);
+	} catch (e) {
+		if (e instanceof SqgError) return {
+			valid: false,
+			errors: [{
+				code: e.code,
+				message: e.message,
+				suggestion: e.suggestion,
+				context: e.context
+			}]
+		};
+		return {
+			valid: false,
+			errors: [{
+				code: "UNKNOWN_ERROR",
+				message: String(e)
+			}]
+		};
+	}
+	return await validateProjectFromConfig(project, projectDir);
+}
+/** Count enum types across queries */
+function countEnums(queries) {
+	const enumNames = /* @__PURE__ */ new Set();
+	for (const query of queries) {
+		if (!query.isQuery) continue;
+		for (const col of query.columns) if (col.type instanceof EnumType && col.type.name) enumNames.add(col.type.name);
+	}
+	return enumNames.size;
+}
+/**
+* Process a project configuration and generate code from a Project object
+*/
+async function processProjectFromConfig(project, projectDir, writeToStdout = false, ui) {
+	const originalLevel = consola.level;
+	if (writeToStdout) consola.level = LogLevels.silent;
+	const totalStart = performance.now();
+	const reporter = ui?.createReporter();
+	const results = [];
+	try {
+		const extraVariables = createExtraVariables(project.sources ?? [], writeToStdout);
+		const files = [];
+		for (const sql of project.sql) {
+			const gensByEngine = /* @__PURE__ */ new Map();
+			for (const gen of sql.gen) {
+				const engine = getGeneratorEngine(gen.generator);
+				if (!gensByEngine.has(engine)) gensByEngine.set(engine, []);
+				gensByEngine.get(engine).push(gen);
+			}
+			for (const sqlFile of sql.files) {
+				const fullPath = join(projectDir, sqlFile);
+				if (!existsSync(fullPath)) throw new FileNotFoundError(fullPath, projectDir);
+				let queries;
+				let tables;
+				try {
+					const parseResult = parseSQLQueries(fullPath, extraVariables);
+					queries = parseResult.queries;
+					tables = parseResult.tables;
+				} catch (e) {
+					if (e instanceof SqgError) throw e;
+					throw SqgError.inFile(`Failed to parse SQL file: ${e.message}`, "SQL_PARSE_ERROR", sqlFile, { suggestion: "Check SQL syntax and annotation format" });
+				}
+				for (const [engine, gens] of gensByEngine) {
+					const executableQueries = queries.filter((q) => !q.skipGenerateFunction);
+					const reporterAny = reporter;
+					if (reporterAny?.setQueryTotal) reporterAny.setQueryTotal(executableQueries.length);
+					try {
+						const dbEngine = getDatabaseEngine(engine);
+						ui?.startPhase(`Initializing ${engine} database...`);
+						await dbEngine.initializeDatabase(queries, reporter);
+						ui?.startPhase(`Introspecting ${executableQueries.length} queries...`);
+						await dbEngine.executeQueries(queries, reporter);
+						if (tables.length > 0) await dbEngine.introspectTables(tables, reporter);
+						ui?.succeedPhase(`Introspected ${executableQueries.length} queries`);
+						validateQueries(queries);
+						await dbEngine.close();
+					} catch (e) {
+						ui?.failPhase(`Failed to process ${sqlFile}`);
+						if (e instanceof SqgError) throw e;
+						throw new SqgError(`Database error processing ${sqlFile}: ${e.message}`, "DATABASE_ERROR", `Check that the SQL is valid for engine '${engine}'`, {
+							file: sqlFile,
+							engine
+						});
+					}
+					ui?.startPhase("Generating code...");
+					const genStart = performance.now();
+					for (const gen of gens) {
+						const generator = getGenerator(gen.generator);
+						const outputPath = await writeGeneratedFile(projectDir, {
+							...gen,
+							projectName: project.name
+						}, generator, sqlFile, queries, tables, engine, writeToStdout);
+						if (outputPath !== null) {
+							files.push(outputPath);
+							results.push({
+								outputPath,
+								queryCount: executableQueries.length,
+								enumCount: countEnums(queries),
+								sqlFile,
+								generator: gen.generator,
+								elapsedMs: performance.now() - genStart
+							});
+						}
+					}
+					ui?.succeedPhase(`Generated ${gens.length} ${gens.length === 1 ? "file" : "files"} from ${sqlFile}`);
+				}
+			}
+		}
+		ui?.summary(results, performance.now() - totalStart);
+		return files;
+	} finally {
+		if (writeToStdout) consola.level = originalLevel;
+	}
+}
+/**
+* Process a project configuration and generate code from a YAML file
+*/
+async function processProject(projectPath, ui) {
+	const projectDir = resolve(dirname(projectPath));
+	return await processProjectFromConfig(parseProjectConfig(projectPath), projectDir, false, ui);
+}
+//#endregion
+//#region src/init.ts
+/**
+* SQG Project Initialization - Creates new SQG projects with example files
+*/
+/**
+* Generate example SQL content based on engine
+*/
+function getExampleSql(engine) {
+	return {
+		sqlite: `-- MIGRATE 1
+-- Create the users table (SQG Example - https://sqg.dev/guides/sql-syntax/)
+CREATE TABLE users (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL,
+  email TEXT UNIQUE NOT NULL,
+  created_at TEXT DEFAULT CURRENT_TIMESTAMP
+);
+
+-- MIGRATE 2
+CREATE TABLE posts (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  user_id INTEGER NOT NULL REFERENCES users(id),
+  title TEXT NOT NULL,
+  content TEXT,
+  published INTEGER DEFAULT 0,
+  created_at TEXT DEFAULT CURRENT_TIMESTAMP
+);
+
+-- TESTDATA seed_data
+INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com');
+INSERT INTO users (name, email) VALUES ('Bob', 'bob@example.com');
+INSERT INTO posts (user_id, title, content, published) VALUES (1, 'Hello World', 'My first post!', 1);
+`,
+		duckdb: `-- MIGRATE 1
+-- Create the users table (SQG Example - https://sqg.dev/guides/sql-syntax/)
+CREATE TABLE users (
+  id INTEGER PRIMARY KEY,
+  name VARCHAR NOT NULL,
+  email VARCHAR UNIQUE NOT NULL,
+  metadata STRUCT(role VARCHAR, active BOOLEAN),
+  tags VARCHAR[],
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- MIGRATE 2
+CREATE TABLE posts (
+  id INTEGER PRIMARY KEY,
+  user_id INTEGER NOT NULL REFERENCES users(id),
+  title VARCHAR NOT NULL,
+  content VARCHAR,
+  published BOOLEAN DEFAULT FALSE,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- TESTDATA seed_data
+INSERT INTO users (id, name, email, metadata, tags)
+VALUES (1, 'Alice', 'alice@example.com', {'role': 'admin', 'active': true}, ['developer', 'lead']);
+INSERT INTO users (id, name, email, metadata, tags)
+VALUES (2, 'Bob', 'bob@example.com', {'role': 'user', 'active': true}, ['developer']);
+INSERT INTO posts (id, user_id, title, content, published)
+VALUES (1, 1, 'Hello World', 'My first post!', TRUE);
+`,
+		postgres: `-- MIGRATE 1
+-- Create the users table (SQG Example - https://sqg.dev/guides/sql-syntax/)
+CREATE TABLE users (
+  id SERIAL PRIMARY KEY,
+  name TEXT NOT NULL,
+  email TEXT UNIQUE NOT NULL,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- MIGRATE 2
+CREATE TABLE posts (
+  id SERIAL PRIMARY KEY,
+  user_id INTEGER NOT NULL REFERENCES users(id),
+  title TEXT NOT NULL,
+  content TEXT,
+  published BOOLEAN DEFAULT FALSE,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- TESTDATA seed_data
+INSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com');
+INSERT INTO users (name, email) VALUES ('Bob', 'bob@example.com');
+INSERT INTO posts (user_id, title, content, published) VALUES (1, 'Hello World', 'My first post!', TRUE);
+`
+	}[engine] + `
+-- QUERY list_users
+SELECT id, name, email, created_at
+FROM users
+ORDER BY created_at DESC;
+
+-- QUERY get_user_by_id :one
+@set id = 1
+SELECT id, name, email, created_at
+FROM users
+WHERE id = \${id};
+
+-- QUERY get_user_by_email :one
+@set email = 'alice@example.com'
+SELECT id, name, email, created_at
+FROM users
+WHERE email = \${email};
+
+-- QUERY count_users :one :pluck
+SELECT COUNT(*) FROM users;
+
+-- QUERY list_posts_by_user
+@set user_id = 1
+SELECT p.id, p.title, p.content, p.published, p.created_at
+FROM posts p
+WHERE p.user_id = \${user_id}
+ORDER BY p.created_at DESC;
+
+-- QUERY list_published_posts
+SELECT
+  p.id,
+  p.title,
+  p.content,
+  p.created_at,
+  u.name as author_name,
+  u.email as author_email
+FROM posts p
+JOIN users u ON p.user_id = u.id
+WHERE p.published = 1
+ORDER BY p.created_at DESC;
+` + {
+		sqlite: `
+-- EXEC create_user
+@set name = 'New User'
+@set email = 'new@example.com'
+INSERT INTO users (name, email)
+VALUES (\${name}, \${email});
+
+-- EXEC create_post
+@set user_id = 1
+@set title = 'New Post'
+@set content = 'Post content here'
+INSERT INTO posts (user_id, title, content)
+VALUES (\${user_id}, \${title}, \${content});
+
+-- EXEC publish_post
+@set id = 1
+UPDATE posts SET published = 1 WHERE id = \${id};
+
+-- EXEC delete_post
+@set id = 1
+DELETE FROM posts WHERE id = \${id};
+`,
+		duckdb: `
+-- EXEC create_user
+@set id = 100
+@set name = 'New User'
+@set email = 'new@example.com'
+INSERT INTO users (id, name, email)
+VALUES (\${id}, \${name}, \${email});
+
+-- EXEC create_post
+@set id = 100
+@set user_id = 1
+@set title = 'New Post'
+@set content = 'Post content here'
+INSERT INTO posts (id, user_id, title, content)
+VALUES (\${id}, \${user_id}, \${title}, \${content});
+
+-- EXEC publish_post
+@set id = 1
+UPDATE posts SET published = TRUE WHERE id = \${id};
+
+-- EXEC delete_post
+@set id = 1
+DELETE FROM posts WHERE id = \${id};
+`,
+		postgres: `
+-- EXEC create_user
+@set name = 'New User'
+@set email = 'new@example.com'
+INSERT INTO users (name, email)
+VALUES (\${name}, \${email});
+
+-- EXEC create_post
+@set user_id = 1
+@set title = 'New Post'
+@set content = 'Post content here'
+INSERT INTO posts (user_id, title, content)
+VALUES (\${user_id}, \${title}, \${content});
+
+-- EXEC publish_post
+@set id = 1
+UPDATE posts SET published = TRUE WHERE id = \${id};
+
+-- EXEC delete_post
+@set id = 1
+DELETE FROM posts WHERE id = \${id};
+`
+	}[engine];
+}
+/**
+* Generate sqg.yaml configuration
+*/
+function getConfigYaml(generator, output, projectName) {
+	const isJava = parseGenerator(generator).language === "java";
+	return `# SQG Configuration
+# Generated by: sqg init
+# Documentation: https://sqg.dev
+
+version: 1
+name: ${projectName}
+
+sql:
+  - files:
+      - queries.sql
+    gen:
+      - generator: ${generator}
+        output: ${output.endsWith("/") ? output : `${output}/`}${isJava ? `
+        config:
+          package: generated` : ""}
+`;
+}
+/**
+* Run interactive wizard when no --generator flag is provided
+*/
+async function runInteractiveInit(options) {
+	clack.intro(pc.bold("Create a new SQG project"));
+	const projectName = await clack.text({
+		message: "Project name",
+		placeholder: "my-project",
+		defaultValue: "my-project",
+		validate: (value) => {
+			if (!value?.trim()) return "Project name is required";
+		}
+	});
+	if (clack.isCancel(projectName)) {
+		clack.cancel("Operation cancelled");
+		process.exit(0);
+	}
+	const generatorOptions = [];
+	for (const shortName of SHORT_GENERATOR_NAMES) {
+		const info = GENERATORS[`${shortName}/${Object.entries(GENERATORS).find(([k]) => k.startsWith(`${shortName}/`))?.[1]?.driver}`];
+		if (info) generatorOptions.push({
+			value: shortName,
+			label: shortName,
+			hint: info.description
+		});
+	}
+	const generator = await clack.select({
+		message: "Generator",
+		options: generatorOptions
+	});
+	if (clack.isCancel(generator)) {
+		clack.cancel("Operation cancelled");
+		process.exit(0);
+	}
+	const output = await clack.text({
+		message: "Output directory",
+		placeholder: "./generated",
+		defaultValue: options.output || "./generated"
+	});
+	if (clack.isCancel(output)) {
+		clack.cancel("Operation cancelled");
+		process.exit(0);
+	}
+	clack.log.step("Files to create:");
+	clack.log.message(`  ${pc.dim("sqg.yaml")}      Project configuration`);
+	clack.log.message(`  ${pc.dim("queries.sql")}    Example SQL queries`);
+	clack.log.message(`  ${pc.dim(`${output}/`)}      Output directory`);
+	const confirm = await clack.confirm({ message: "Create files?" });
+	if (clack.isCancel(confirm) || !confirm) {
+		clack.cancel("Operation cancelled");
+		process.exit(0);
+	}
+	await createProjectFiles({
+		generator,
+		output,
+		force: options.force,
+		projectName
+	});
+	clack.outro(`Done! Run: ${pc.bold("sqg sqg.yaml")}`);
+}
+/**
+* Create project files (shared between interactive and non-interactive modes)
+*/
+async function createProjectFiles(options) {
+	const { generator, output, force, projectName } = options;
+	if (!isValidGenerator(generator)) {
+		const similar = findSimilarGenerators(generator);
+		throw new InvalidGeneratorError(generator, [...SHORT_GENERATOR_NAMES, ...GENERATOR_NAMES], similar.length > 0 ? similar[0] : void 0);
+	}
+	const engine = parseGenerator(generator).engine;
+	const configPath = "sqg.yaml";
+	const sqlPath = "queries.sql";
+	if (!force) {
+		if (existsSync(configPath)) throw new SqgError(`File already exists: ${configPath}`, "VALIDATION_ERROR", "Use --force to overwrite existing files");
+		if (existsSync(sqlPath)) throw new SqgError(`File already exists: ${sqlPath}`, "VALIDATION_ERROR", "Use --force to overwrite existing files");
+	}
+	if (!existsSync(output)) mkdirSync(output, { recursive: true });
+	writeFileSync(configPath, getConfigYaml(generator, output, projectName));
+	writeFileSync(sqlPath, getExampleSql(engine));
+}
+/**
+* Initialize a new SQG project
+*/
+async function initProject(options) {
+	if (!options.generator && process.stdin.isTTY) {
+		await runInteractiveInit(options);
+		return;
+	}
+	const generator = options.generator || "typescript/sqlite";
+	const output = options.output || "./generated";
+	await createProjectFiles({
+		generator,
+		output,
+		force: options.force,
+		projectName: "my-project"
+	});
+	const generatorInfo = parseGenerator(generator);
+	clack.intro(pc.bold("SQG project initialized!"));
+	clack.log.info(`Generator: ${generator}`);
+	clack.log.info(`Engine: ${generatorInfo.engine}`);
+	clack.log.info(`Output: ${output}`);
+	clack.log.step("Next steps:");
+	clack.log.message("  1. Edit queries.sql to add your SQL queries");
+	clack.log.message("  2. Run: sqg sqg.yaml");
+	clack.log.message(`  3. Import the generated code from ${output}`);
+	clack.outro("Documentation: https://sqg.dev");
+}
+//#endregion
+export { BaseGenerator, Config, ConfigError, DB_ENGINES, DEFAULT_DRIVERS, DatabaseError, EnumType, ExtraVariable, FileNotFoundError, GENERATED_FILE_COMMENT, GENERATORS, GENERATOR_NAMES, InvalidGeneratorError, JavaDuckDBArrowGenerator, JavaGenerator, JavaTypeMapper, LANGUAGES, ListType, MapType, PythonGenerator, PythonTypeMapper, SHORT_GENERATOR_NAMES, SQLQuery, SqgError, SqlExecutionError, SqlQueryHelper, StructType, TableHelper, TableInfo, TsDuckDBGenerator, TsGenerator, TypeMapper, TypeMappingError, TypeScriptTypeMapper, buildProjectFromCliOptions, createExtraVariables, findSimilarGenerators, formatErrorForOutput, formatGeneratorsHelp, formatGeneratorsList, getDatabaseEngine, getGenerator, getGeneratorEngine, getGeneratorLanguage, getOutputPath, initProject, initializeDatabase, isValidGenerator, parseGenerator, parseProjectConfig, parseSQLQueries, processProject, processProjectFromConfig, resolveGenerator, validateProject, validateProjectFromConfig, validateQueries, writeGeneratedFile };