@pineliner/odb-client 1.0.5 → 1.0.7

package/dist/index.cjs

@@ -1,40 +1,366 @@
 "use strict";
-// The require scope
-var __webpack_require__ = {};
-/************************************************************************/ // webpack/runtime/compat_get_default_export
+var __webpack_modules__ = {
+    "./src/orm/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
+        __webpack_require__.d(__webpack_exports__, {
+            ORM: ()=>ORM,
+            and: ()=>and,
+            createORM: ()=>createORM,
+            eq: ()=>eq,
+            gt: ()=>gt,
+            gte: ()=>gte,
+            inArray: ()=>inArray,
+            isNotNull: ()=>isNotNull,
+            isNull: ()=>isNull,
+            like: ()=>like,
+            lt: ()=>lt,
+            lte: ()=>lte,
+            ne: ()=>ne,
+            or: ()=>or
+        });
+        function eq(field, value) {
+            return {
+                sql: `${field} = ?`,
+                params: [
+                    value
+                ]
+            };
+        }
+        function ne(field, value) {
+            return {
+                sql: `${field} != ?`,
+                params: [
+                    value
+                ]
+            };
+        }
+        function gt(field, value) {
+            return {
+                sql: `${field} > ?`,
+                params: [
+                    value
+                ]
+            };
+        }
+        function gte(field, value) {
+            return {
+                sql: `${field} >= ?`,
+                params: [
+                    value
+                ]
+            };
+        }
+        function lt(field, value) {
+            return {
+                sql: `${field} < ?`,
+                params: [
+                    value
+                ]
+            };
+        }
+        function lte(field, value) {
+            return {
+                sql: `${field} <= ?`,
+                params: [
+                    value
+                ]
+            };
+        }
+        function like(field, pattern) {
+            return {
+                sql: `${field} LIKE ?`,
+                params: [
+                    pattern
+                ]
+            };
+        }
+        function inArray(field, values) {
+            const placeholders = values.map(()=>'?').join(', ');
+            return {
+                sql: `${field} IN (${placeholders})`,
+                params: values
+            };
+        }
+        function isNull(field) {
+            return {
+                sql: `${field} IS NULL`,
+                params: []
+            };
+        }
+        function isNotNull(field) {
+            return {
+                sql: `${field} IS NOT NULL`,
+                params: []
+            };
+        }
+        function and(...conditions) {
+            const sql = conditions.map((c)=>`(${c.sql})`).join(' AND ');
+            const params = conditions.flatMap((c)=>c.params);
+            return {
+                sql,
+                params
+            };
+        }
+        function or(...conditions) {
+            const sql = conditions.map((c)=>`(${c.sql})`).join(' OR ');
+            const params = conditions.flatMap((c)=>c.params);
+            return {
+                sql,
+                params
+            };
+        }
+        class SelectBuilder {
+            db;
+            tableName;
+            selectFields = [
+                '*'
+            ];
+            whereConditions = [];
+            orderByField;
+            orderByDir = 'ASC';
+            limitValue;
+            offsetValue;
+            constructor(db, tableName){
+                this.db = db;
+                this.tableName = tableName;
+            }
+            select(fields = {}) {
+                if (0 === Object.keys(fields).length) this.selectFields = [
+                    '*'
+                ];
+                else this.selectFields = Object.keys(fields);
+                return this;
+            }
+            where(condition) {
+                this.whereConditions.push(condition);
+                return this;
+            }
+            orderBy(field, direction = 'ASC') {
+                this.orderByField = field;
+                this.orderByDir = direction;
+                return this;
+            }
+            limit(value) {
+                this.limitValue = value;
+                return this;
+            }
+            offset(value) {
+                this.offsetValue = value;
+                return this;
+            }
+            async execute() {
+                const fields = this.selectFields.join(', ');
+                const params = [];
+                let sql = `SELECT ${fields} FROM ${this.tableName}`;
+                if (this.whereConditions.length > 0) {
+                    const combinedCondition = 1 === this.whereConditions.length ? this.whereConditions[0] : and(...this.whereConditions);
+                    sql += ` WHERE ${combinedCondition.sql}`;
+                    params.push(...combinedCondition.params);
+                }
+                if (this.orderByField) sql += ` ORDER BY ${this.orderByField} ${this.orderByDir}`;
+                if (void 0 !== this.limitValue) {
+                    sql += " LIMIT ?";
+                    params.push(this.limitValue);
+                }
+                if (void 0 !== this.offsetValue) {
+                    sql += " OFFSET ?";
+                    params.push(this.offsetValue);
+                }
+                const result = await this.db.execute(sql, params);
+                return result.rows;
+            }
+        }
+        class InsertBuilder {
+            db;
+            tableName;
+            insertValues = {};
+            shouldReturn = false;
+            constructor(db, tableName){
+                this.db = db;
+                this.tableName = tableName;
+            }
+            values(data) {
+                this.insertValues = data;
+                return this;
+            }
+            returning() {
+                this.shouldReturn = true;
+                return this;
+            }
+            async execute() {
+                const fields = Object.keys(this.insertValues);
+                const placeholders = fields.map(()=>'?').join(', ');
+                const values = fields.map((f)=>this.insertValues[f]);
+                let sql = `
+      INSERT INTO ${this.tableName} (${fields.join(', ')})
+      VALUES (${placeholders})
+    `;
+                await this.db.execute(sql, values);
+                if (this.shouldReturn) {
+                    const selectSql = `SELECT * FROM ${this.tableName} ORDER BY id DESC LIMIT 1`;
+                    const result = await this.db.execute(selectSql, []);
+                    return result.rows;
+                }
+                return [];
+            }
+        }
+        class UpdateBuilder {
+            db;
+            tableName;
+            updateValues = {};
+            whereConditions = [];
+            shouldReturn = false;
+            constructor(db, tableName){
+                this.db = db;
+                this.tableName = tableName;
+            }
+            set(data) {
+                this.updateValues = data;
+                return this;
+            }
+            where(condition) {
+                this.whereConditions.push(condition);
+                return this;
+            }
+            returning() {
+                this.shouldReturn = true;
+                return this;
+            }
+            async execute() {
+                const fields = Object.keys(this.updateValues);
+                const setClause = fields.map((f)=>`${f} = ?`).join(', ');
+                const values = fields.map((f)=>this.updateValues[f]);
+                let sql = `UPDATE ${this.tableName} SET ${setClause}`;
+                const params = [
+                    ...values
+                ];
+                if (this.whereConditions.length > 0) {
+                    const combinedCondition = 1 === this.whereConditions.length ? this.whereConditions[0] : and(...this.whereConditions);
+                    sql += ` WHERE ${combinedCondition.sql}`;
+                    params.push(...combinedCondition.params);
+                }
+                await this.db.execute(sql, params);
+                if (this.shouldReturn && this.whereConditions.length > 0) {
+                    const combinedCondition = 1 === this.whereConditions.length ? this.whereConditions[0] : and(...this.whereConditions);
+                    const selectSql = `SELECT * FROM ${this.tableName} WHERE ${combinedCondition.sql}`;
+                    const result = await this.db.execute(selectSql, combinedCondition.params);
+                    return result.rows;
+                }
+                return [];
+            }
+        }
+        class DeleteBuilder {
+            db;
+            tableName;
+            whereConditions = [];
+            constructor(db, tableName){
+                this.db = db;
+                this.tableName = tableName;
+            }
+            where(condition) {
+                this.whereConditions.push(condition);
+                return this;
+            }
+            async execute() {
+                let sql = `DELETE FROM ${this.tableName}`;
+                const params = [];
+                if (this.whereConditions.length > 0) {
+                    const combinedCondition = 1 === this.whereConditions.length ? this.whereConditions[0] : and(...this.whereConditions);
+                    sql += ` WHERE ${combinedCondition.sql}`;
+                    params.push(...combinedCondition.params);
+                }
+                await this.db.execute(sql, params);
+            }
+        }
+        class TableQueryBuilder {
+            db;
+            tableName;
+            constructor(db, tableName){
+                this.db = db;
+                this.tableName = tableName;
+            }
+            select(fields) {
+                const builder = new SelectBuilder(this.db, this.tableName);
+                if (fields) builder.select(fields);
+                return builder;
+            }
+            insert() {
+                return new InsertBuilder(this.db, this.tableName);
+            }
+            update() {
+                return new UpdateBuilder(this.db, this.tableName);
+            }
+            delete() {
+                return new DeleteBuilder(this.db, this.tableName);
+            }
+        }
+        class ORM {
+            db;
+            constructor(db){
+                this.db = db;
+            }
+            table(tableName) {
+                return new TableQueryBuilder(this.db, tableName);
+            }
+            select(fields) {
+                return {
+                    from: (tableName)=>{
+                        const builder = new SelectBuilder(this.db, tableName);
+                        if (fields) builder.select(fields);
+                        return builder;
+                    }
+                };
+            }
+            insert(tableName) {
+                return new InsertBuilder(this.db, tableName);
+            }
+            update(tableName) {
+                return new UpdateBuilder(this.db, tableName);
+            }
+            delete(tableName) {
+                return new DeleteBuilder(this.db, tableName);
+            }
+            execute(sql, params) {
+                return this.db.execute(sql, params);
+            }
+        }
+        function createORM(db) {
+            return new ORM(db);
+        }
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
 (()=>{
-    // getDefaultExport function for compatibility with non-ESM modules
-    __webpack_require__.n = function(module) {
-        var getter = module && module.__esModule ? function() {
-            return module['default'];
-        } : function() {
-            return module;
-        };
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
         __webpack_require__.d(getter, {
             a: getter
         });
         return getter;
     };
 })();
-// webpack/runtime/define_property_getters
 (()=>{
-    __webpack_require__.d = function(exports1, definition) {
+    __webpack_require__.d = (exports1, definition)=>{
         for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
             enumerable: true,
             get: definition[key]
         });
     };
 })();
-// webpack/runtime/has_own_property
 (()=>{
-    __webpack_require__.o = function(obj, prop) {
-        return Object.prototype.hasOwnProperty.call(obj, prop);
-    };
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
 })();
-// webpack/runtime/make_namespace_object
 (()=>{
-    // define __esModule on exports
-    __webpack_require__.r = function(exports1) {
+    __webpack_require__.r = (exports1)=>{
         if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
             value: 'Module'
         });
@@ -43,117 +369,144 @@ var __webpack_require__ = {};
         });
     };
 })();
-/************************************************************************/ var __webpack_exports__ = {};
-// ESM COMPAT FLAG
-__webpack_require__.r(__webpack_exports__);
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-    fragment: ()=>/* reexport */ fragment,
-    HTTPClient: ()=>/* reexport */ HTTPClient,
-    default: ()=>/* reexport */ odblite,
-    identifier: ()=>/* binding */ src_identifier,
-    ODBLiteAdapter: ()=>/* reexport */ ODBLiteAdapter,
-    BunSQLiteAdapter: ()=>/* reexport */ BunSQLiteAdapter,
-    raw: ()=>/* binding */ src_raw,
-    insertValues: ()=>/* binding */ src_insertValues,
-    sql: ()=>/* reexport */ sql_parser_sql,
-    where: ()=>/* binding */ src_where,
-    DatabaseManager: ()=>/* reexport */ DatabaseManager,
-    LibSQLAdapter: ()=>/* reexport */ LibSQLAdapter,
-    updateSet: ()=>/* binding */ src_updateSet,
-    ODBLiteClient: ()=>/* reexport */ ODBLiteClient,
-    ODBLiteTransaction: ()=>/* reexport */ ODBLiteTransaction,
-    join: ()=>/* binding */ src_join,
-    ODBLiteError: ()=>/* reexport */ ODBLiteError,
-    parseSQL: ()=>/* reexport */ parseSQL,
-    ConnectionError: ()=>/* reexport */ ConnectionError,
-    SQLParser: ()=>/* reexport */ sql_parser_SQLParser,
-    SimpleTransaction: ()=>/* reexport */ SimpleTransaction,
-    odblite: ()=>/* reexport */ odblite,
-    splitSQLStatements: ()=>/* reexport */ splitSQLStatements,
-    QueryError: ()=>/* reexport */ types_QueryError,
-    ServiceClient: ()=>/* reexport */ ServiceClient
-});
-// Core types for the ODBLite client
-// Error types
-class ODBLiteError extends Error {
-    code;
-    query;
-    params;
-    constructor(message, code, query, params){
-        super(message), this.code = code, this.query = query, this.params = params;
-        this.name = 'ODBLiteError';
-    }
-}
-class ConnectionError extends ODBLiteError {
-    originalError;
-    constructor(message, originalError){
-        super(message, 'CONNECTION_ERROR'), this.originalError = originalError;
-        this.name = 'ConnectionError';
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        insertValues: ()=>src_insertValues,
+        updateSet: ()=>src_updateSet,
+        gte: ()=>orm.gte,
+        ODBLiteClient: ()=>ODBLiteClient,
+        QueryError: ()=>types_QueryError,
+        sql: ()=>sql_parser_sql,
+        sqlFragment: ()=>sql_template_fragment,
+        ODBLiteError: ()=>ODBLiteError,
+        ORM: ()=>orm.ORM,
+        ConnectionError: ()=>ConnectionError,
+        join: ()=>src_join,
+        convertTemplateToQuery: ()=>convertTemplateToQuery,
+        HTTPClient: ()=>HTTPClient,
+        BunSQLiteAdapter: ()=>BunSQLiteAdapter,
+        SQLParser: ()=>sql_parser_SQLParser,
+        default: ()=>odblite,
+        gt: ()=>orm.gt,
+        eq: ()=>orm.eq,
+        identifier: ()=>src_identifier,
+        lte: ()=>orm.lte,
+        ne: ()=>orm.ne,
+        parseSQL: ()=>parseSQL,
+        splitSQLStatements: ()=>splitSQLStatements,
+        where: ()=>src_where,
+        LibSQLAdapter: ()=>LibSQLAdapter,
+        lt: ()=>orm.lt,
+        fragment: ()=>fragment,
+        isNull: ()=>orm.isNull,
+        DatabaseManager: ()=>DatabaseManager,
+        or: ()=>orm.or,
+        ODBLiteTransaction: ()=>ODBLiteTransaction,
+        ServiceClient: ()=>ServiceClient,
+        and: ()=>orm.and,
+        odblite: ()=>odblite,
+        rawSQL: ()=>sql_template_raw,
+        set: ()=>set,
+        sqlJoin: ()=>sql_template_join,
+        createORM: ()=>orm.createORM,
+        empty: ()=>empty,
+        sqlTemplate: ()=>sql_template_sql,
+        SimpleTransaction: ()=>SimpleTransaction,
+        inArray: ()=>orm.inArray,
+        sqlWhere: ()=>sql_template_where,
+        ODBLiteAdapter: ()=>ODBLiteAdapter,
+        isNotNull: ()=>orm.isNotNull,
+        like: ()=>orm.like,
+        raw: ()=>src_raw
+    });
+    class ODBLiteError extends Error {
+        code;
+        query;
+        params;
+        constructor(message, code, query, params){
+            super(message), this.code = code, this.query = query, this.params = params;
+            this.name = 'ODBLiteError';
+        }
     }
-}
-class types_QueryError extends ODBLiteError {
-    originalError;
-    constructor(message, query, params, originalError){
-        super(message, 'QUERY_ERROR', query, params), this.originalError = originalError;
-        this.name = 'QueryError';
+    class ConnectionError extends ODBLiteError {
+        originalError;
+        constructor(message, originalError){
+            super(message, 'CONNECTION_ERROR'), this.originalError = originalError;
+            this.name = 'ConnectionError';
+        }
     }
-}
-/**
- * HTTP client for communicating with ODBLite service
- */ class HTTPClient {
-    config;
-    constructor(config){
-        this.config = {
-            timeout: 30000,
-            retries: 3,
-            ...config
-        };
-        // Ensure baseUrl doesn't end with slash
-        if ('string' == typeof this.config.baseUrl) this.config.baseUrl = this.config.baseUrl.replace(/\/$/, '');
+    class types_QueryError extends ODBLiteError {
+        originalError;
+        constructor(message, query, params, originalError){
+            super(message, 'QUERY_ERROR', query, params), this.originalError = originalError;
+            this.name = 'QueryError';
+        }
     }
-    /**
-   * Execute a query against the ODBLite service
-   */ async query(sql, params = []) {
-        if (!this.config.databaseId) throw new ConnectionError('No database ID configured. Use setDatabase() first.');
-        const url = `${this.config.baseUrl}/query/${this.config.databaseId}`;
-        const body = {
-            sql,
-            params
-        };
-        try {
-            const response = await this.makeRequest(url, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Authorization: `Bearer ${this.config.apiKey}`
-                },
-                body: JSON.stringify(body)
-            });
-            const data = await response.json();
-            if (!data.success) throw new types_QueryError(data.error || 'Query failed', sql, params);
-            // Handle nested data structure: { success: true, data: { rows: [...] } }
-            let rows = [];
-            if (data.data && 'object' == typeof data.data && 'rows' in data.data) rows = data.data.rows;
-            else if (Array.isArray(data.data)) rows = data.data;
-            else if (Array.isArray(data.rows)) rows = data.rows;
-            return {
-                rows: rows,
-                rowsAffected: data.rowsAffected || data.data?.rowsAffected || 0,
-                executionTime: data.executionTime || data.data?.executionTime || 0,
-                databaseName: data.databaseName || data.data?.databaseName
+    class HTTPClient {
+        config;
+        constructor(config){
+            this.config = {
+                timeout: 30000,
+                retries: 3,
+                ...config
             };
-        } catch (error) {
-            if (error instanceof types_QueryError || error instanceof ConnectionError) throw error;
-            throw new types_QueryError(error instanceof Error ? error.message : 'Unknown error occurred', sql, params, error instanceof Error ? error : void 0);
+            if ('string' == typeof this.config.baseUrl) this.config.baseUrl = this.config.baseUrl.replace(/\/$/, '');
         }
-    }
-    /**
-   * Check database health
-   */ async ping() {
-        if (!this.config.databaseId) return false;
-        try {
-            const url = `${this.config.baseUrl}/api/db/${this.config.databaseId}/health`;
+        async query(sql, params = []) {
+            if (!this.config.databaseId) throw new ConnectionError('No database ID configured. Use setDatabase() first.');
+            const url = `${this.config.baseUrl}/query/${this.config.databaseId}`;
+            const body = {
+                sql,
+                params
+            };
+            try {
+                const response = await this.makeRequest(url, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${this.config.apiKey}`
+                    },
+                    body: JSON.stringify(body)
+                });
+                const data = await response.json();
+                if (!data.success) throw new types_QueryError(data.error || 'Query failed', sql, params);
+                let rows = [];
+                if (data.data && 'object' == typeof data.data && 'rows' in data.data) rows = data.data.rows;
+                else if (Array.isArray(data.data)) rows = data.data;
+                else if (Array.isArray(data.rows)) rows = data.rows;
+                return {
+                    rows: rows,
+                    rowsAffected: data.rowsAffected || data.data?.rowsAffected || 0,
+                    lastInsertRowid: data.lastInsertRowid || data.data?.lastInsertRowid,
+                    executionTime: data.executionTime || data.data?.executionTime || 0,
+                    databaseName: data.databaseName || data.data?.databaseName
+                };
+            } catch (error) {
+                if (error instanceof types_QueryError || error instanceof ConnectionError) throw error;
+                throw new types_QueryError(error instanceof Error ? error.message : 'Unknown error occurred', sql, params, error instanceof Error ? error : void 0);
+            }
+        }
+        async ping() {
+            if (!this.config.databaseId) return false;
+            try {
+                const url = `${this.config.baseUrl}/api/db/${this.config.databaseId}/health`;
+                const response = await this.makeRequest(url, {
+                    method: 'GET',
+                    headers: {
+                        Authorization: `Bearer ${this.config.apiKey}`
+                    }
+                });
+                const data = await response.json();
+                return 'healthy' === data.status;
+            } catch  {
+                return false;
+            }
+        }
+        async getDatabaseInfo() {
+            if (!this.config.databaseId) throw new ConnectionError('No database ID configured');
+            const url = `${this.config.baseUrl}/query/${this.config.databaseId}`;
             const response = await this.makeRequest(url, {
                 method: 'GET',
                 headers: {
@@ -161,1390 +514,1233 @@ class types_QueryError extends ODBLiteError {
                 }
             });
             const data = await response.json();
-            return 'healthy' === data.status;
-        } catch  {
-            return false;
+            if (!data.success) throw new ConnectionError(data.error || 'Failed to get database info');
+            return data;
         }
-    }
-    /**
-   * Get database information
-   */ async getDatabaseInfo() {
-        if (!this.config.databaseId) throw new ConnectionError('No database ID configured');
-        const url = `${this.config.baseUrl}/query/${this.config.databaseId}`;
-        const response = await this.makeRequest(url, {
-            method: 'GET',
-            headers: {
-                Authorization: `Bearer ${this.config.apiKey}`
+        setDatabase(databaseId) {
+            this.config.databaseId = databaseId;
+        }
+        async makeRequest(url, options) {
+            let lastError;
+            for(let attempt = 1; attempt <= (this.config.retries || 3); attempt++)try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(()=>controller.abort(), this.config.timeout);
+                const response = await fetch(url, {
+                    ...options,
+                    signal: controller.signal
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    const errorText = await response.text();
+                    let errorData;
+                    try {
+                        errorData = JSON.parse(errorText);
+                    } catch  {
+                        errorData = {
+                            error: errorText
+                        };
+                    }
+                    throw new ConnectionError(`HTTP ${response.status}: ${errorData.error || response.statusText}`);
+                }
+                return response;
+            } catch (error) {
+                lastError = error instanceof Error ? error : new Error('Unknown error');
+                if (error instanceof ConnectionError && error.message.includes('HTTP 4')) throw error;
+                if (attempt < (this.config.retries || 3)) {
+                    const delay = Math.min(1000 * 2 ** (attempt - 1), 10000);
+                    await new Promise((resolve)=>setTimeout(resolve, delay));
+                }
             }
-        });
-        const data = await response.json();
-        if (!data.success) throw new ConnectionError(data.error || 'Failed to get database info');
-        return data;
-    }
-    /**
-   * Set the database ID for subsequent queries
-   */ setDatabase(databaseId) {
-        this.config.databaseId = databaseId;
-    }
-    /**
-   * Make HTTP request with retry logic
-   */ async makeRequest(url, options) {
-        let lastError;
-        for(let attempt = 1; attempt <= (this.config.retries || 3); attempt++)try {
-            const controller = new AbortController();
-            const timeoutId = setTimeout(()=>controller.abort(), this.config.timeout);
-            const response = await fetch(url, {
-                ...options,
-                signal: controller.signal
+            throw new ConnectionError(`Failed after ${this.config.retries} attempts: ${lastError?.message}`, lastError);
+        }
+        configure(updates) {
+            return new HTTPClient({
+                ...this.config,
+                ...updates
             });
-            clearTimeout(timeoutId);
-            if (!response.ok) {
-                const errorText = await response.text();
-                let errorData;
-                try {
-                    errorData = JSON.parse(errorText);
-                } catch  {
-                    errorData = {
-                        error: errorText
+        }
+        getConfig() {
+            return {
+                ...this.config
+            };
+        }
+    }
+    class sql_parser_SQLParser {
+        static parse(sql, values) {
+            if (Array.isArray(sql) && ('raw' in sql || 'string' == typeof sql[0] && void 0 !== values)) return this.parseTemplateString(sql, values || []);
+            return this.parseContextualInput(sql, values);
+        }
+        static parseContextualInput(input, values, context) {
+            if (Array.isArray(input)) {
+                if (input.length > 0 && input[0] && 'object' == typeof input[0] && input[0].constructor === Object) {
+                    const insertResult = this.insertValues(input);
+                    return {
+                        sql: insertResult.text,
+                        params: insertResult.values
                     };
                 }
-                throw new ConnectionError(`HTTP ${response.status}: ${errorData.error || response.statusText}`);
-            }
-            return response;
-        } catch (error) {
-            lastError = error instanceof Error ? error : new Error('Unknown error');
-            // Don't retry on client errors (4xx)
-            if (error instanceof ConnectionError && error.message.includes('HTTP 4')) throw error;
-            // Wait before retry (exponential backoff)
-            if (attempt < (this.config.retries || 3)) {
-                const delay = Math.min(1000 * 2 ** (attempt - 1), 10000);
-                await new Promise((resolve)=>setTimeout(resolve, delay));
+                const placeholders = input.map(()=>'?').join(', ');
+                return {
+                    sql: `(${placeholders})`,
+                    params: input.map((v)=>this.convertValue(v))
+                };
             }
-        }
-        throw new ConnectionError(`Failed after ${this.config.retries} attempts: ${lastError?.message}`, lastError);
-    }
-    /**
-   * Create a new HTTPClient with updated config
-   */ configure(updates) {
-        return new HTTPClient({
-            ...this.config,
-            ...updates
-        });
-    }
-    /**
-   * Get current configuration
-   */ getConfig() {
-        return {
-            ...this.config
-        };
-    }
-}
-/**
- * SQL template string parser that converts postgres.js-style template strings
- * into LibSQL-compatible parameterized queries
- */ class sql_parser_SQLParser {
-    /**
-   * Parse input that can be template strings, objects, or arrays
-   * Context-aware like postgres.js
-   */ static parse(sql, values) {
-        // Handle template string arrays (have the raw property or look like template strings)
-        if (Array.isArray(sql) && ('raw' in sql || 'string' == typeof sql[0] && void 0 !== values)) return this.parseTemplateString(sql, values || []);
-        // Handle direct object/array inputs (context detection)
-        return this.parseContextualInput(sql, values);
-    }
-    /**
-   * Parse contextual input (objects, arrays, etc.)
-   * Uses heuristics to detect the intended context
-   */ static parseContextualInput(input, values, context) {
-        if (Array.isArray(input)) {
-            // Check if this is an array of objects (for INSERT VALUES)
-            if (input.length > 0 && input[0] && 'object' == typeof input[0] && input[0].constructor === Object) {
+            if (input && 'object' == typeof input && input.constructor === Object) {
+                const entries = Object.entries(input).filter(([, value])=>void 0 !== value);
+                if (0 === entries.length) return {
+                    sql: '',
+                    params: []
+                };
+                const hasNullValues = entries.some(([, value])=>null === value);
+                const hasArrayValues = entries.some(([, value])=>Array.isArray(value));
+                const hasComplexValues = entries.some(([, value])=>null !== value && 'object' == typeof value && !Array.isArray(value));
+                if (hasNullValues || hasArrayValues || hasComplexValues) {
+                    const whereResult = this.where(input);
+                    return {
+                        sql: whereResult.text,
+                        params: whereResult.values
+                    };
+                }
+                if (entries.length <= 3 && !Array.isArray(input)) return this.buildSetClause(input);
                 const insertResult = this.insertValues(input);
                 return {
                     sql: insertResult.text,
                     params: insertResult.values
                 };
             }
-            // Array of primitives - assume it's for IN clause
-            const placeholders = input.map(()=>'?').join(', ');
             return {
-                sql: `(${placeholders})`,
-                params: input.map((v)=>this.convertValue(v))
+                sql: '?',
+                params: [
+                    this.convertValue(input)
+                ]
             };
         }
-        if (input && 'object' == typeof input && input.constructor === Object) {
-            // Plain object - try to detect context based on structure and usage patterns
-            const entries = Object.entries(input).filter(([, value])=>void 0 !== value);
+        static buildSetClause(data) {
+            const entries = Object.entries(data).filter(([, value])=>void 0 !== value);
             if (0 === entries.length) return {
                 sql: '',
                 params: []
             };
-            // Analyze the object structure to determine intent
-            const hasNullValues = entries.some(([, value])=>null === value);
-            const hasArrayValues = entries.some(([, value])=>Array.isArray(value));
-            const hasComplexValues = entries.some(([, value])=>null !== value && 'object' == typeof value && !Array.isArray(value));
-            // Strong indicators for WHERE clauses:
-            // - null values (for IS NULL checks)
-            // - array values (for IN clauses)
-            // - complex nested objects
-            if (hasNullValues || hasArrayValues || hasComplexValues) {
-                const whereResult = this.where(input);
-                return {
-                    sql: whereResult.text,
-                    params: whereResult.values
-                };
+            const setClauses = entries.map(([key])=>`${this.escapeIdentifier(key)} = ?`).join(', ');
+            const values = entries.map(([, value])=>this.convertValue(value));
+            return {
+                sql: setClauses,
+                params: values
+            };
+        }
+        static parseTemplateString(sql, values) {
+            const fragments = [
+                ...sql
+            ];
+            const params = [];
+            let query = '';
+            for(let i = 0; i < fragments.length; i++){
+                query += fragments[i];
+                if (i < values.length) {
+                    const value = values[i];
+                    if (Array.isArray(value)) {
+                        const placeholders = value.map(()=>"?").join(', ');
+                        query += `(${placeholders})`;
+                        params.push(...value.map((v)=>this.convertValue(v)));
+                    } else if (value && 'object' == typeof value && value.constructor === Object) {
+                        const contextResult = this.parseContextualInput(value);
+                        query += contextResult.sql;
+                        params.push(...contextResult.params);
+                    } else if ('string' == typeof value && value.startsWith('__RAW__')) query += value.slice(7);
+                    else {
+                        query += '?';
+                        params.push(this.convertValue(value));
+                    }
+                }
             }
-            // For simple objects with primitive values, we need to guess context
-            // This is inherently ambiguous - could be SET or VALUES
-            // We'll default to a flexible format that works for both
-            // If single object, more likely to be SET clause
-            if (entries.length <= 3 && !Array.isArray(input)) // Return SET format by default
-            return this.buildSetClause(input);
-            // For larger objects or arrays of objects, likely INSERT VALUES
-            const insertResult = this.insertValues(input);
             return {
-                sql: insertResult.text,
-                params: insertResult.values
+                sql: query.trim(),
+                params
             };
         }
-        // Fallback for other types
-        return {
-            sql: '?',
-            params: [
-                this.convertValue(input)
-            ]
-        };
-    }
-    /**
-   * Build a SET clause for UPDATE statements
-   */ static buildSetClause(data) {
-        const entries = Object.entries(data).filter(([, value])=>void 0 !== value);
-        if (0 === entries.length) return {
-            sql: '',
-            params: []
-        };
-        const setClauses = entries.map(([key])=>`${this.escapeIdentifier(key)} = ?`).join(', ');
-        const values = entries.map(([, value])=>this.convertValue(value));
-        return {
-            sql: setClauses,
-            params: values
-        };
-    }
-    /**
-   * Parse template string SQL into LibSQL format
-   */ static parseTemplateString(sql, values) {
-        const fragments = [
-            ...sql
-        ];
-        const params = [];
-        let query = '';
-        for(let i = 0; i < fragments.length; i++){
-            query += fragments[i];
-            if (i < values.length) {
-                const value = values[i];
-                // Handle different value types using context detection
+        static raw(text) {
+            return `__RAW__${text}`;
+        }
+        static identifier(name) {
+            return this.escapeIdentifier(name);
+        }
+        static escapeIdentifier(identifier) {
+            return `"${identifier.replace(/"/g, '""')}"`;
+        }
+        static convertValue(value) {
+            if (null == value) return null;
+            if (value instanceof Date) return value.toISOString();
+            if (value instanceof Buffer) return new Uint8Array(value);
+            if ('boolean' == typeof value) return value ? 1 : 0;
+            if ('bigint' == typeof value) return value.toString();
+            if ('object' == typeof value) return JSON.stringify(value);
+            return value;
+        }
+        static fragment(sql, ...values) {
+            const parsed = this.parse(sql, values);
+            return {
+                text: parsed.sql,
+                values: parsed.params
+            };
+        }
+        static join(fragments, separator = ' ') {
+            const text = fragments.map((f)=>f.text).join(separator);
+            const values = fragments.flatMap((f)=>f.values);
+            return {
+                text,
+                values
+            };
+        }
+        static where(conditions) {
+            const entries = Object.entries(conditions).filter(([, value])=>void 0 !== value);
+            if (0 === entries.length) return {
+                text: '',
+                values: []
+            };
+            const clauses = entries.map(([key, value])=>{
+                if (null === value) return `${this.escapeIdentifier(key)} IS NULL`;
                 if (Array.isArray(value)) {
-                    // Handle IN clauses: sql`SELECT * FROM users WHERE id IN ${[1, 2, 3]}`
-                    const placeholders = value.map(()=>"?").join(', ');
-                    query += `(${placeholders})`;
-                    params.push(...value.map((v)=>this.convertValue(v)));
-                } else if (value && 'object' == typeof value && value.constructor === Object) {
-                    // Use context detection for objects
-                    const contextResult = this.parseContextualInput(value);
-                    query += contextResult.sql;
-                    params.push(...contextResult.params);
-                } else if ('string' == typeof value && value.startsWith('__RAW__')) // Handle raw SQL: sql`SELECT * FROM ${raw('users')}`
-                query += value.slice(7); // Remove __RAW__ prefix
-                else {
-                    // Regular parameter
-                    query += '?';
-                    params.push(this.convertValue(value));
+                    const placeholders = value.map(()=>'?').join(', ');
+                    return `${this.escapeIdentifier(key)} IN (${placeholders})`;
                 }
-            }
+                return `${this.escapeIdentifier(key)} = ?`;
+            });
+            const values = entries.flatMap(([, value])=>{
+                if (null === value) return [];
+                if (Array.isArray(value)) return value.map((v)=>this.convertValue(v));
+                return [
+                    this.convertValue(value)
+                ];
+            });
+            return {
+                text: clauses.join(' AND '),
+                values
+            };
         }
-        return {
-            sql: query.trim(),
-            params
-        };
-    }
-    /**
-   * Create a raw SQL fragment (not parameterized)
-   */ static raw(text) {
-        return `__RAW__${text}`;
-    }
-    /**
-   * Create an identifier (table name, column name, etc.)
-   */ static identifier(name) {
-        return this.escapeIdentifier(name);
-    }
-    /**
-   * Escape SQL identifiers (table names, column names)
-   */ static escapeIdentifier(identifier) {
-        // SQLite uses double quotes for identifiers
-        return `"${identifier.replace(/"/g, '""')}"`;
-    }
-    /**
-   * Convert JavaScript values to LibSQL-compatible values
-   */ static convertValue(value) {
-        if (null == value) return null;
-        if (value instanceof Date) // Convert Date to ISO string for SQLite
-        return value.toISOString();
-        if (value instanceof Buffer) // Convert Buffer to Uint8Array for LibSQL
-        return new Uint8Array(value);
-        if ('boolean' == typeof value) // SQLite uses 0/1 for booleans
-        return value ? 1 : 0;
-        if ('bigint' == typeof value) // Convert BigInt to string to avoid precision loss
-        return value.toString();
-        if ('object' == typeof value) // Serialize objects as JSON
-        return JSON.stringify(value);
-        return value;
-    }
-    /**
-   * Create a SQL fragment for building complex queries
-   */ static fragment(sql, ...values) {
-        const parsed = this.parse(sql, values);
-        return {
-            text: parsed.sql,
-            values: parsed.params
-        };
-    }
-    /**
-   * Join multiple SQL fragments
-   */ static join(fragments, separator = ' ') {
-        const text = fragments.map((f)=>f.text).join(separator);
-        const values = fragments.flatMap((f)=>f.values);
-        return {
-            text,
-            values
-        };
-    }
-    /**
-   * Helper for building WHERE clauses from objects
-   */ static where(conditions) {
-        const entries = Object.entries(conditions).filter(([, value])=>void 0 !== value);
-        if (0 === entries.length) return {
-            text: '',
-            values: []
-        };
-        const clauses = entries.map(([key, value])=>{
-            if (null === value) return `${this.escapeIdentifier(key)} IS NULL`;
-            if (Array.isArray(value)) {
-                const placeholders = value.map(()=>'?').join(', ');
-                return `${this.escapeIdentifier(key)} IN (${placeholders})`;
-            }
-            return `${this.escapeIdentifier(key)} = ?`;
-        });
-        const values = entries.flatMap(([, value])=>{
-            if (null === value) return [];
-            if (Array.isArray(value)) return value.map((v)=>this.convertValue(v));
-            return [
-                this.convertValue(value)
+        static insertValues(data) {
+            const records = Array.isArray(data) ? data : [
+                data
             ];
-        });
-        return {
-            text: clauses.join(' AND '),
-            values
-        };
-    }
-    /**
-   * Helper for building INSERT VALUES from objects
-   */ static insertValues(data) {
-        const records = Array.isArray(data) ? data : [
-            data
-        ];
-        if (0 === records.length) throw new Error('No data provided for insert');
-        const keys = Object.keys(records[0]);
-        const columns = keys.map((key)=>this.escapeIdentifier(key)).join(', ');
-        const valueClauses = records.map((record)=>{
-            const placeholders = keys.map(()=>'?').join(', ');
-            return `(${placeholders})`;
-        }).join(', ');
-        const values = records.flatMap((record)=>keys.map((key)=>this.convertValue(record[key])));
-        return {
-            text: `(${columns}) VALUES ${valueClauses}`,
-            values
-        };
-    }
-    /**
-   * Helper for building UPDATE SET clauses from objects
-   */ static updateSet(data) {
-        const entries = Object.entries(data).filter(([, value])=>void 0 !== value);
-        if (0 === entries.length) throw new Error('No data provided for update');
-        const setClauses = entries.map(([key])=>`${this.escapeIdentifier(key)} = ?`).join(', ');
-        const values = entries.map(([, value])=>this.convertValue(value));
-        return {
-            text: setClauses,
-            values
-        };
-    }
-}
-// Export convenience functions
-const sql_parser_sql = sql_parser_SQLParser.parse.bind(sql_parser_SQLParser);
-sql_parser_SQLParser.raw.bind(sql_parser_SQLParser);
-sql_parser_SQLParser.identifier.bind(sql_parser_SQLParser);
-const fragment = sql_parser_SQLParser.fragment.bind(sql_parser_SQLParser);
-sql_parser_SQLParser.join.bind(sql_parser_SQLParser);
-sql_parser_SQLParser.where.bind(sql_parser_SQLParser);
-sql_parser_SQLParser.insertValues.bind(sql_parser_SQLParser);
-sql_parser_SQLParser.updateSet.bind(sql_parser_SQLParser);
-/**
- * Transaction implementation for ODBLite
- * Note: SQLite transactions are simulated at the client level since ODBLite
- * operates on individual queries. This provides a familiar API but doesn't
- * provide true ACID guarantees across multiple HTTP requests.
- */ class ODBLiteTransaction {
-    httpClient;
-    isCommitted = false;
-    isRolledBack = false;
-    queries = [];
-    constructor(httpClient){
-        this.httpClient = httpClient;
-    }
-    /**
-   * Execute a query within the transaction
-   * For SQLite, we'll queue queries and execute them in batch on commit
-   */ async sql(sql, ...values) {
-        this.checkTransactionState();
-        const parsed = sql_parser_SQLParser.parse(sql, values);
-        // For read queries, execute immediately
-        if (this.isReadQuery(parsed.sql)) return await this.httpClient.query(parsed.sql, parsed.params);
-        // For write queries, queue them for batch execution
-        this.queries.push(parsed);
-        // Return a placeholder result for queued queries
-        return {
-            rows: [],
-            rowsAffected: 0,
-            executionTime: 0
-        };
+            if (0 === records.length) throw new Error('No data provided for insert');
+            const keys = Object.keys(records[0]);
+            const columns = keys.map((key)=>this.escapeIdentifier(key)).join(', ');
+            const valueClauses = records.map((record)=>{
+                const placeholders = keys.map(()=>'?').join(', ');
+                return `(${placeholders})`;
+            }).join(', ');
+            const values = records.flatMap((record)=>keys.map((key)=>this.convertValue(record[key])));
+            return {
+                text: `(${columns}) VALUES ${valueClauses}`,
+                values
+            };
+        }
+        static updateSet(data) {
+            const entries = Object.entries(data).filter(([, value])=>void 0 !== value);
+            if (0 === entries.length) throw new Error('No data provided for update');
+            const setClauses = entries.map(([key])=>`${this.escapeIdentifier(key)} = ?`).join(', ');
+            const values = entries.map(([, value])=>this.convertValue(value));
+            return {
+                text: setClauses,
+                values
+            };
+        }
     }
-    /**
-   * Commit the transaction by executing all queued queries
-   */ async commit() {
-        this.checkTransactionState();
-        try {
-            // Execute BEGIN
-            await this.httpClient.query('BEGIN');
-            // Execute all queued queries
-            for (const query of this.queries)await this.httpClient.query(query.sql, query.params);
-            // Commit the transaction
-            await this.httpClient.query('COMMIT');
-            this.isCommitted = true;
-        } catch (error) {
-            // Rollback on any error
+    const sql_parser_sql = sql_parser_SQLParser.parse.bind(sql_parser_SQLParser);
+    sql_parser_SQLParser.raw.bind(sql_parser_SQLParser);
+    sql_parser_SQLParser.identifier.bind(sql_parser_SQLParser);
+    const fragment = sql_parser_SQLParser.fragment.bind(sql_parser_SQLParser);
+    sql_parser_SQLParser.join.bind(sql_parser_SQLParser);
+    sql_parser_SQLParser.where.bind(sql_parser_SQLParser);
+    sql_parser_SQLParser.insertValues.bind(sql_parser_SQLParser);
+    sql_parser_SQLParser.updateSet.bind(sql_parser_SQLParser);
+    class ODBLiteTransaction {
+        httpClient;
+        isCommitted = false;
+        isRolledBack = false;
+        queries = [];
+        constructor(httpClient){
+            this.httpClient = httpClient;
+        }
+        async sql(sql, ...values) {
+            this.checkTransactionState();
+            const parsed = sql_parser_SQLParser.parse(sql, values);
+            if (this.isReadQuery(parsed.sql)) return await this.httpClient.query(parsed.sql, parsed.params);
+            this.queries.push(parsed);
+            return {
+                rows: [],
+                rowsAffected: 0,
+                executionTime: 0
+            };
+        }
+        async commit() {
+            this.checkTransactionState();
             try {
-                await this.httpClient.query('ROLLBACK');
-            } catch (rollbackError) {
-            // Ignore rollback errors
+                await this.httpClient.query('BEGIN');
+                for (const query of this.queries)await this.httpClient.query(query.sql, query.params);
+                await this.httpClient.query('COMMIT');
+                this.isCommitted = true;
+            } catch (error) {
+                try {
+                    await this.httpClient.query('ROLLBACK');
+                } catch (rollbackError) {}
+                this.isRolledBack = true;
+                throw new types_QueryError(`Transaction failed: ${error instanceof Error ? error.message : 'Unknown error'}`, void 0, void 0, error instanceof Error ? error : void 0);
             }
-            this.isRolledBack = true;
-            throw new types_QueryError(`Transaction failed: ${error instanceof Error ? error.message : 'Unknown error'}`, void 0, void 0, error instanceof Error ? error : void 0);
         }
-    }
-    /**
-   * Rollback the transaction
-   */ async rollback() {
-        this.checkTransactionState();
-        try {
-            // If we have any queries, we need to actually rollback
-            if (this.queries.length > 0) await this.httpClient.query('ROLLBACK');
-        } finally{
-            this.isRolledBack = true;
+        async rollback() {
+            this.checkTransactionState();
+            try {
+                if (this.queries.length > 0) await this.httpClient.query('ROLLBACK');
+            } finally{
+                this.isRolledBack = true;
+            }
         }
-    }
-    /**
-   * Check if transaction is still active
-   */ checkTransactionState() {
-        if (this.isCommitted) throw new types_QueryError('Transaction has already been committed');
-        if (this.isRolledBack) throw new types_QueryError('Transaction has been rolled back');
-    }
-    /**
-   * Determine if a query is a read operation
-   */ isReadQuery(sql) {
-        const trimmed = sql.trim().toUpperCase();
-        return trimmed.startsWith('SELECT') || trimmed.startsWith('WITH') || trimmed.startsWith('EXPLAIN') || trimmed.startsWith('PRAGMA');
-    }
-}
-/**
- * Create a simple transaction function that executes immediately
- * This is more suitable for HTTP-based databases where true transactions
- * across multiple requests are not practical
- */ function createSimpleTransaction(httpClient) {
-    let isActive = true;
-    // Create the callable transaction function with context awareness
-    const txFunction = (sql, ...values)=>{
-        if (!isActive) throw new types_QueryError('Transaction is no longer active');
-        // Handle template string queries (returns Promise)
-        if (Array.isArray(sql) && ('raw' in sql || 'string' == typeof sql[0] && values.length >= 0)) {
-            const parsed = sql_parser_SQLParser.parse(sql, values);
-            return httpClient.query(parsed.sql, parsed.params);
+        checkTransactionState() {
+            if (this.isCommitted) throw new types_QueryError('Transaction has already been committed');
+            if (this.isRolledBack) throw new types_QueryError('Transaction has been rolled back');
         }
-        // Handle direct object/array inputs (returns SQLFragment for composing)
-        const parsed = sql_parser_SQLParser.parse(sql, values);
-        return {
-            text: parsed.sql,
-            values: parsed.params
-        };
-    };
-    // Attach utility methods to the transaction function
-    txFunction.raw = (text)=>sql_parser_SQLParser.raw(text);
-    txFunction.identifier = (name)=>sql_parser_SQLParser.identifier(name);
-    // Add execute method for compatibility
-    txFunction.execute = async (sql, args)=>{
-        if (!isActive) throw new types_QueryError('Transaction is no longer active');
-        if ('string' == typeof sql) return await httpClient.query(sql, args || []);
-        return await httpClient.query(sql.sql, sql.args || []);
-    };
-    // Add query method for compatibility
-    txFunction.query = async (sql, params = [])=>{
-        if (!isActive) throw new types_QueryError('Transaction is no longer active');
-        return await httpClient.query(sql, params);
-    };
-    txFunction.commit = async ()=>{
-        isActive = false;
-    // No-op for simple transactions
-    };
-    txFunction.rollback = async ()=>{
-        isActive = false;
-    // No-op for simple transactions - individual queries are atomic
-    };
-    txFunction.savepoint = async (callback)=>{
-        if (!isActive) throw new types_QueryError('Transaction is no longer active');
-        // Create a nested transaction for the savepoint
-        const savepointTx = createSimpleTransaction(httpClient);
-        try {
-            // Execute the callback with the savepoint transaction
-            const result = await callback(savepointTx);
-            // Commit the savepoint (no-op for simple transactions)
-            await savepointTx.commit();
-            return result;
-        } catch (error) {
-            // Rollback the savepoint on error
-            await savepointTx.rollback();
-            throw error;
+        isReadQuery(sql) {
+            const trimmed = sql.trim().toUpperCase();
+            return trimmed.startsWith('SELECT') || trimmed.startsWith('WITH') || trimmed.startsWith('EXPLAIN') || trimmed.startsWith('PRAGMA');
         }
-    };
-    return txFunction;
-}
-/**
- * Simple transaction implementation that executes immediately
- * This is more suitable for HTTP-based databases where true transactions
- * across multiple requests are not practical
- */ class SimpleTransaction {
-    httpClient;
-    isActive = true;
-    constructor(httpClient){
-        this.httpClient = httpClient;
-    }
-    async sql(sql, ...values) {
-        if (!this.isActive) throw new types_QueryError('Transaction is no longer active');
-        const parsed = sql_parser_SQLParser.parse(sql, values);
-        return await this.httpClient.query(parsed.sql, parsed.params);
     }
-    async commit() {
-        this.isActive = false;
-    // No-op for simple transactions
-    }
-    async rollback() {
-        this.isActive = false;
-    // No-op for simple transactions - individual queries are atomic
-    }
-}
-/**
- * Main ODBLite client that provides postgres.js-like interface
- */ class ODBLiteClient {
-    httpClient;
-    config;
-    sql;
-    constructor(config){
-        this.config = config;
-        this.httpClient = new HTTPClient(config);
-        // Create the callable sql function with attached utility methods
-        const sqlFunction = (sql, ...values)=>{
-            // Handle template string queries (returns Promise)
+    function createSimpleTransaction(httpClient) {
+        let isActive = true;
+        const txFunction = (sql, ...values)=>{
+            if (!isActive) throw new types_QueryError('Transaction is no longer active');
             if (Array.isArray(sql) && ('raw' in sql || 'string' == typeof sql[0] && values.length >= 0)) {
                 const parsed = sql_parser_SQLParser.parse(sql, values);
-                return this.httpClient.query(parsed.sql, parsed.params);
+                return httpClient.query(parsed.sql, parsed.params);
             }
-            // Handle direct object/array inputs (returns SQLFragment for composing)
             const parsed = sql_parser_SQLParser.parse(sql, values);
             return {
                 text: parsed.sql,
                 values: parsed.params
             };
         };
-        // Attach minimal utility methods to the function
-        sqlFunction.raw = (text)=>sql_parser_SQLParser.raw(text);
-        sqlFunction.identifier = (name)=>sql_parser_SQLParser.identifier(name);
-        // Attach client methods to the function
-        sqlFunction.query = async (sql, params = [])=>await this.httpClient.query(sql, params);
-        // libsql-compatible execute method (for backward compatibility)
-        sqlFunction.execute = async (sql, args)=>{
-            if ('string' == typeof sql) return await this.httpClient.query(sql, args || []);
-            return await this.httpClient.query(sql.sql, sql.args || []);
+        txFunction.raw = (text)=>sql_parser_SQLParser.raw(text);
+        txFunction.identifier = (name)=>sql_parser_SQLParser.identifier(name);
+        txFunction.execute = async (sql, args)=>{
+            if (!isActive) throw new types_QueryError('Transaction is no longer active');
+            if ('string' == typeof sql) return await httpClient.query(sql, args || []);
+            return await httpClient.query(sql.sql, sql.args || []);
         };
-        // Enhanced begin method with callback support
-        sqlFunction.begin = async (modeOrCallback, callback)=>{
-            // Determine if this is callback-style or traditional
-            if ('function' == typeof modeOrCallback) // begin(callback)
-            return this.executeTransactionWithCallback(modeOrCallback);
-            if ('string' == typeof modeOrCallback && callback) // begin(mode, callback)
-            return this.executeTransactionWithCallback(callback, modeOrCallback);
-            // begin() - traditional style
-            return createSimpleTransaction(this.httpClient);
+        txFunction.query = async (sql, params = [])=>{
+            if (!isActive) throw new types_QueryError('Transaction is no longer active');
+            return await httpClient.query(sql, params);
+        };
+        txFunction.commit = async ()=>{
+            isActive = false;
         };
-        sqlFunction.ping = async ()=>await this.httpClient.ping();
-        sqlFunction.end = async ()=>{
-        // No-op for HTTP-based client
+        txFunction.rollback = async ()=>{
+            isActive = false;
         };
-        sqlFunction.setDatabase = (databaseId)=>{
+        txFunction.savepoint = async (callback)=>{
+            if (!isActive) throw new types_QueryError('Transaction is no longer active');
+            const savepointTx = createSimpleTransaction(httpClient);
+            try {
+                const result = await callback(savepointTx);
+                await savepointTx.commit();
+                return result;
+            } catch (error) {
+                await savepointTx.rollback();
+                throw error;
+            }
+        };
+        return txFunction;
+    }
+    class SimpleTransaction {
+        httpClient;
+        isActive = true;
+        constructor(httpClient){
+            this.httpClient = httpClient;
+        }
+        async sql(sql, ...values) {
+            if (!this.isActive) throw new types_QueryError('Transaction is no longer active');
+            const parsed = sql_parser_SQLParser.parse(sql, values);
+            return await this.httpClient.query(parsed.sql, parsed.params);
+        }
+        async commit() {
+            this.isActive = false;
+        }
+        async rollback() {
+            this.isActive = false;
+        }
+    }
+    class ODBLiteClient {
+        httpClient;
+        config;
+        sql;
+        constructor(config){
+            this.config = config;
+            this.httpClient = new HTTPClient(config);
+            const sqlFunction = (sql, ...values)=>{
+                if (Array.isArray(sql) && ('raw' in sql || 'string' == typeof sql[0] && values.length >= 0)) {
+                    const parsed = sql_parser_SQLParser.parse(sql, values);
+                    return this.httpClient.query(parsed.sql, parsed.params);
+                }
+                const parsed = sql_parser_SQLParser.parse(sql, values);
+                return {
+                    text: parsed.sql,
+                    values: parsed.params
+                };
+            };
+            sqlFunction.raw = (text)=>sql_parser_SQLParser.raw(text);
+            sqlFunction.identifier = (name)=>sql_parser_SQLParser.identifier(name);
+            sqlFunction.query = async (sql, params = [])=>await this.httpClient.query(sql, params);
+            sqlFunction.execute = async (sql, args)=>{
+                if ('string' == typeof sql) return await this.httpClient.query(sql, args || []);
+                return await this.httpClient.query(sql.sql, sql.args || []);
+            };
+            sqlFunction.begin = async (modeOrCallback, callback)=>{
+                if ('function' == typeof modeOrCallback) return this.executeTransactionWithCallback(modeOrCallback);
+                if ('string' == typeof modeOrCallback && callback) return this.executeTransactionWithCallback(callback, modeOrCallback);
+                return createSimpleTransaction(this.httpClient);
+            };
+            sqlFunction.ping = async ()=>await this.httpClient.ping();
+            sqlFunction.end = async ()=>{};
+            sqlFunction.setDatabase = (databaseId)=>{
+                this.httpClient.setDatabase(databaseId);
+                this.config.databaseId = databaseId;
+                return sqlFunction;
+            };
+            sqlFunction.getDatabaseInfo = async ()=>await this.httpClient.getDatabaseInfo();
+            sqlFunction.configure = (updates)=>{
+                const newConfig = {
+                    ...this.config,
+                    ...updates
+                };
+                return new ODBLiteClient(newConfig).sql;
+            };
+            this.sql = sqlFunction;
+        }
+        async executeTransactionWithCallback(callback, mode) {
+            const tx = createSimpleTransaction(this.httpClient);
+            try {
+                const result = await callback(tx);
+                await tx.commit();
+                return result;
+            } catch (error) {
+                await tx.rollback();
+                throw error;
+            }
+        }
+        async query(sql, params = []) {
+            return await this.httpClient.query(sql, params);
+        }
+        async begin() {
+            return createSimpleTransaction(this.httpClient);
+        }
+        async ping() {
+            return await this.httpClient.ping();
+        }
+        async end() {}
+        setDatabase(databaseId) {
             this.httpClient.setDatabase(databaseId);
             this.config.databaseId = databaseId;
-            return sqlFunction;
-        };
-        sqlFunction.getDatabaseInfo = async ()=>await this.httpClient.getDatabaseInfo();
-        sqlFunction.configure = (updates)=>{
+            return this;
+        }
+        async getDatabaseInfo() {
+            return await this.httpClient.getDatabaseInfo();
+        }
+        configure(updates) {
             const newConfig = {
                 ...this.config,
                 ...updates
             };
-            return new ODBLiteClient(newConfig).sql;
-        };
-        this.sql = sqlFunction;
-    }
-    /**
-   * Execute a transaction with callback (postgres.js style)
-   */ async executeTransactionWithCallback(callback, mode) {
-        const tx = createSimpleTransaction(this.httpClient);
-        try {
-            // Execute the callback with the transaction
-            const result = await callback(tx);
-            // Commit the transaction
-            await tx.commit();
-            return result;
-        } catch (error) {
-            // Rollback on any error
-            await tx.rollback();
-            throw error;
+            return new ODBLiteClient(newConfig);
         }
-    }
-    /**
-   * Raw query method
-   * Usage: client.query('SELECT * FROM users WHERE id = ?', [123])
-   */ async query(sql, params = []) {
-        return await this.httpClient.query(sql, params);
-    }
-    /**
-   * Begin a transaction
-   * Note: Uses simple transaction model suitable for HTTP-based access
-   */ async begin() {
-        return createSimpleTransaction(this.httpClient);
-    }
-    /**
-   * Health check
-   */ async ping() {
-        return await this.httpClient.ping();
-    }
-    /**
-   * Close connection (no-op for HTTP client)
-   */ async end() {
-    // No-op for HTTP-based client
-    }
-    /**
-   * Set the database ID for queries
-   */ setDatabase(databaseId) {
-        this.httpClient.setDatabase(databaseId);
-        this.config.databaseId = databaseId;
-        return this;
-    }
-    /**
-   * Get database information
-   */ async getDatabaseInfo() {
-        return await this.httpClient.getDatabaseInfo();
-    }
-    /**
-   * Create a new client instance with updated configuration
-   */ configure(updates) {
-        const newConfig = {
-            ...this.config,
-            ...updates
-        };
-        return new ODBLiteClient(newConfig);
-    }
-    /**
-   * Create raw SQL that won't be parameterized
-   * Usage: sql`SELECT * FROM ${raw('users')}`
-   */ static raw(text) {
-        return sql_parser_SQLParser.raw(text);
-    }
-    /**
-   * Escape identifier (table/column names)
-   * Usage: sql`SELECT * FROM ${identifier('user-table')}`
-   */ static identifier(name) {
-        return sql_parser_SQLParser.identifier(name);
-    }
-    /**
-   * Build WHERE clause from object
-   * Usage: const whereClause = ODBLiteClient.where({ id: 1, name: 'John' });
-   */ static where(conditions) {
-        return sql_parser_SQLParser.where(conditions);
-    }
-    /**
-   * Build INSERT VALUES from object(s)
-   * Usage: const insertClause = ODBLiteClient.insertValues({ name: 'John', age: 30 });
-   */ static insertValues(data) {
-        return sql_parser_SQLParser.insertValues(data);
-    }
-    /**
-   * Build UPDATE SET clause from object
-   * Usage: const setClause = ODBLiteClient.updateSet({ name: 'John', age: 30 });
-   */ static updateSet(data) {
-        return sql_parser_SQLParser.updateSet(data);
-    }
-    /**
-   * Join SQL fragments
-   * Usage: const query = ODBLiteClient.join([baseQuery, whereClause], ' WHERE ');
-   */ static join(fragments, separator = ' ') {
-        return sql_parser_SQLParser.join(fragments, separator);
-    }
-}
-function odblite(configOrBaseUrl, apiKey, databaseId) {
-    const client = 'string' == typeof configOrBaseUrl ? new ODBLiteClient({
-        baseUrl: configOrBaseUrl,
-        apiKey: apiKey,
-        databaseId
-    }) : new ODBLiteClient(configOrBaseUrl);
-    return client.sql;
-}
-// Export static utility functions
-ODBLiteClient.raw;
-ODBLiteClient.identifier;
-ODBLiteClient.where;
-ODBLiteClient.insertValues;
-ODBLiteClient.updateSet;
-ODBLiteClient.join;
-/**
- * Service Client - High-level client for managing tenant databases via ODB-Lite Tenant API
- *
- * This client provides automatic database provisioning and management for multi-tenant applications.
- * It handles:
- * - Automatic database creation on first use
- * - Database hash caching for performance
- * - Tenant API integration with ODB-Lite
- * - Query execution via ODB-Lite's query API
- *
- * @example
- * ```typescript
- * const service = new ServiceClient({
- *   baseUrl: 'http://localhost:8671',
- *   apiKey: 'odblite_tenant_key'
- * });
- *
- * // Automatically creates database if it doesn't exist
- * const dbHash = await service.ensureDatabaseForTenant('wallet', 'tenant-123');
- *
- * // Execute queries
- * const result = await service.query(dbHash, 'SELECT * FROM wallets', []);
- * ```
- */ /**
- * Service Client for managing tenant databases in ODB-Lite
- *
- * This is a higher-level client that sits on top of the base ODB client.
- * It provides automatic database provisioning and management for services
- * that need per-tenant database isolation.
- */ class ServiceClient {
-    apiUrl;
-    apiKey;
-    databaseCache;
-    constructor(config){
-        this.apiUrl = config.baseUrl;
-        this.apiKey = config.apiKey;
-        this.databaseCache = new Map();
-    }
-    /**
-   * Get or create a database for a tenant
-   *
-   * This is the main method used by services. It will:
-   * 1. Check the cache for an existing database hash
-   * 2. Query ODB-Lite to see if the database exists
-   * 3. Create the database if it doesn't exist
-   * 4. Cache and return the database hash
-   *
-   * @param prefix - Database name prefix (e.g., 'wallet', 'tracking')
-   * @param tenantId - Tenant identifier
-   * @returns Database hash for querying
-   *
-   * @example
-   * ```typescript
-   * const hash = await service.ensureDatabaseForTenant('wallet', 'tenant-123');
-   * // Returns hash for database named 'wallet_tenant-123'
-   * ```
-   */ async ensureDatabaseForTenant(prefix, tenantId) {
-        const cacheKey = `${prefix}_${tenantId}`;
-        console.log(`📊 Ensuring database for ${cacheKey}`);
-        // Check cache first
-        const cached = this.databaseCache.get(cacheKey);
-        if (cached) {
-            console.log(`✅ Found cached database hash: ${cached}`);
-            return cached;
-        }
-        try {
-            // Check if database already exists
-            console.log(`🔍 Checking if database exists: ${cacheKey}`);
-            const existing = await this.getDatabaseByName(cacheKey);
-            if (existing) {
-                console.log(`✅ Database already exists: ${cacheKey} (${existing.hash})`);
-                this.databaseCache.set(cacheKey, existing.hash);
-                return existing.hash;
-            }
-            // Create new database
-            console.log(`🆕 Creating new database: ${cacheKey}`);
-            const nodes = await this.listNodes();
-            console.log(`📡 Available nodes: ${nodes.length}`);
-            if (0 === nodes.length) throw new Error('No available nodes to create database');
-            // Use first healthy node
-            const node = nodes.find((n)=>'healthy' === n.status) || nodes[0];
-            if (!node) throw new Error('No available nodes to create database');
-            console.log(`🎯 Using node: ${node.nodeId}`);
-            const database = await this.createDatabase(cacheKey, node.nodeId);
-            console.log(`✅ Database created successfully: ${database.hash}`);
-            this.databaseCache.set(cacheKey, database.hash);
-            return database.hash;
-        } catch (error) {
-            console.error(`❌ Error ensuring database for ${cacheKey}:`, error.message);
-            throw error;
+        static raw(text) {
+            return sql_parser_SQLParser.raw(text);
+        }
+        static identifier(name) {
+            return sql_parser_SQLParser.identifier(name);
+        }
+        static where(conditions) {
+            return sql_parser_SQLParser.where(conditions);
+        }
+        static insertValues(data) {
+            return sql_parser_SQLParser.insertValues(data);
+        }
+        static updateSet(data) {
+            return sql_parser_SQLParser.updateSet(data);
+        }
+        static join(fragments, separator = ' ') {
+            return sql_parser_SQLParser.join(fragments, separator);
         }
     }
-    /**
-   * List all databases owned by this tenant
-   *
-   * Queries ODB-Lite's tenant API to get all databases accessible with the current API key.
-   *
-   * @returns Array of database objects
-   */ async listDatabases() {
-        const response = await fetch(`${this.apiUrl}/api/tenant/databases`, {
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`
+    function odblite(configOrBaseUrl, apiKey, databaseId) {
+        const client = 'string' == typeof configOrBaseUrl ? new ODBLiteClient({
+            baseUrl: configOrBaseUrl,
+            apiKey: apiKey,
+            databaseId
+        }) : new ODBLiteClient(configOrBaseUrl);
+        return client.sql;
+    }
+    ODBLiteClient.raw;
+    ODBLiteClient.identifier;
+    ODBLiteClient.where;
+    ODBLiteClient.insertValues;
+    ODBLiteClient.updateSet;
+    ODBLiteClient.join;
+    class ServiceClient {
+        apiUrl;
+        apiKey;
+        databaseCache;
+        constructor(config){
+            this.apiUrl = config.baseUrl;
+            this.apiKey = config.apiKey;
+            this.databaseCache = new Map();
+        }
+        async ensureDatabaseForTenant(prefix, tenantId) {
+            const cacheKey = `${prefix}_${tenantId}`;
+            console.log(`📊 Ensuring database for ${cacheKey}`);
+            const cached = this.databaseCache.get(cacheKey);
+            if (cached) {
+                console.log(`✅ Found cached database hash: ${cached}`);
+                return cached;
             }
-        });
-        const result = await response.json();
-        if (!result.success) throw new Error(result.error || 'Failed to list databases');
-        return result.databases;
-    }
-    /**
-   * Create a new database
-   *
-   * @param name - Database name (should be unique)
-   * @param nodeId - ID of the node to host the database (optional - server will select if null)
-   * @returns Created database object with hash
-   */ async createDatabase(name, nodeId) {
-        const body = {
-            name
-        };
-        if (nodeId) body.nodeId = nodeId;
-        const response = await fetch(`${this.apiUrl}/api/tenant/databases`, {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify(body)
-        });
-        const result = await response.json();
-        if (!result.success) throw new Error(result.error || 'Failed to create database');
-        return result.database;
-    }
-    /**
-   * Get database details by hash
-   *
-   * @param hash - Database hash
-   * @returns Database object
-   */ async getDatabase(hash) {
-        const response = await fetch(`${this.apiUrl}/api/tenant/databases/${hash}`, {
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`
+            try {
+                console.log(`🔍 Checking if database exists: ${cacheKey}`);
+                const existing = await this.getDatabaseByName(cacheKey);
+                if (existing) {
+                    console.log(`✅ Database already exists: ${cacheKey} (${existing.hash})`);
+                    this.databaseCache.set(cacheKey, existing.hash);
+                    return existing.hash;
+                }
+                console.log(`🆕 Creating new database: ${cacheKey}`);
+                const nodes = await this.listNodes();
+                console.log(`📡 Available nodes: ${nodes.length}`);
+                if (0 === nodes.length) throw new Error('No available nodes to create database');
+                const node = nodes.find((n)=>'healthy' === n.status) || nodes[0];
+                if (!node) throw new Error('No available nodes to create database');
+                console.log(`🎯 Using node: ${node.nodeId}`);
+                const database = await this.createDatabase(cacheKey, node.nodeId);
+                console.log(`✅ Database created successfully: ${database.hash}`);
+                this.databaseCache.set(cacheKey, database.hash);
+                return database.hash;
+            } catch (error) {
+                console.error(`❌ Error ensuring database for ${cacheKey}:`, error.message);
+                throw error;
             }
-        });
-        const result = await response.json();
-        if (!result.success) throw new Error(result.error || 'Failed to get database');
-        return result.database;
+        }
+        async listDatabases() {
+            const response = await fetch(`${this.apiUrl}/api/tenant/databases`, {
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`
+                }
+            });
+            const result = await response.json();
+            if (!result.success) throw new Error(result.error || 'Failed to list databases');
+            return result.databases;
+        }
+        async createDatabase(name, nodeId) {
+            const body = {
+                name
+            };
+            if (nodeId) body.nodeId = nodeId;
+            const response = await fetch(`${this.apiUrl}/api/tenant/databases`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(body)
+            });
+            const result = await response.json();
+            if (!result.success) throw new Error(result.error || 'Failed to create database');
+            return result.database;
+        }
+        async getDatabase(hash) {
+            const response = await fetch(`${this.apiUrl}/api/tenant/databases/${hash}`, {
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`
+                }
+            });
+            const result = await response.json();
+            if (!result.success) throw new Error(result.error || 'Failed to get database');
+            return result.database;
+        }
+        async getDatabaseByName(name) {
+            const response = await fetch(`${this.apiUrl}/api/tenant/databases/by-name/${name}`, {
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`
+                }
+            });
+            if (404 === response.status) return null;
+            const result = await response.json();
+            if (!result.success) throw new Error(result.error || 'Failed to get database');
+            return result.database;
+        }
+        async deleteDatabase(hash) {
+            const response = await fetch(`${this.apiUrl}/api/tenant/databases/${hash}`, {
+                method: 'DELETE',
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`
+                }
+            });
+            const result = await response.json();
+            if (!result.success) throw new Error(result.error || 'Failed to delete database');
+            for (const [key, cachedHash] of this.databaseCache.entries())if (cachedHash === hash) {
+                this.databaseCache.delete(key);
+                break;
+            }
+        }
+        async listNodes() {
+            const response = await fetch(`${this.apiUrl}/api/tenant/nodes`, {
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`
+                }
+            });
+            const result = await response.json();
+            if (!result.success) throw new Error(result.error || 'Failed to list nodes');
+            return result.nodes;
+        }
+        async query(databaseHash, sql, params = []) {
+            const response = await fetch(`${this.apiUrl}/query/${databaseHash}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.apiKey}`
+                },
+                body: JSON.stringify({
+                    sql,
+                    params
+                })
+            });
+            const result = await response.json();
+            if (!result.success) throw new Error(result.error || 'Query failed');
+            return result.data;
+        }
+        clearCache() {
+            this.databaseCache.clear();
+        }
+        getCachedHash(prefix, tenantId) {
+            const cacheKey = `${prefix}_${tenantId}`;
+            return this.databaseCache.get(cacheKey);
+        }
+        setCachedHash(prefix, tenantId, hash) {
+            const cacheKey = `${prefix}_${tenantId}`;
+            this.databaseCache.set(cacheKey, hash);
+        }
     }
-    /**
-   * Get database details by name
-   *
-   * @param name - Database name
-   * @returns Database object or null if not found
-   */ async getDatabaseByName(name) {
-        const response = await fetch(`${this.apiUrl}/api/tenant/databases/by-name/${name}`, {
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`
+    const external_bun_sqlite_namespaceObject = require("bun:sqlite");
+    function convertTemplateToQuery(strings, values) {
+        let sql = '';
+        const args = [];
+        for(let i = 0; i < strings.length; i++){
+            sql += strings[i];
+            if (i < values.length) {
+                const value = values[i];
+                if (isSqlFragment(value)) {
+                    sql += value.sql;
+                    args.push(...value.args);
+                } else if (Array.isArray(value)) if (value.length > 0 && Array.isArray(value[0])) {
+                    const rowPlaceholders = value.map((row)=>`(${row.map(()=>'?').join(', ')})`).join(', ');
+                    sql += rowPlaceholders;
+                    args.push(...value.flat());
+                } else {
+                    const placeholders = value.map(()=>'?').join(', ');
+                    sql += `(${placeholders})`;
+                    args.push(...value);
+                }
+                else {
+                    sql += '?';
+                    args.push(value);
+                }
             }
-        });
-        if (404 === response.status) return null;
-        const result = await response.json();
-        if (!result.success) throw new Error(result.error || 'Failed to get database');
-        return result.database;
+        }
+        return {
+            sql,
+            args
+        };
+    }
+    function isSqlFragment(value) {
+        return value && 'object' == typeof value && true === value._isSqlFragment;
     }
-    /**
-   * Delete a database
-   *
-   * @param hash - Database hash to delete
-   */ async deleteDatabase(hash) {
-        const response = await fetch(`${this.apiUrl}/api/tenant/databases/${hash}`, {
-            method: 'DELETE',
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`
+    function sql_template_sql(value, ...keys) {
+        let columnKeys = [];
+        if (keys.length > 0) columnKeys = Array.isArray(keys[0]) ? keys[0] : keys;
+        if ('string' == typeof value && 0 === columnKeys.length) return {
+            _isSqlFragment: true,
+            sql: value,
+            args: []
+        };
+        if (Array.isArray(value) && value.length > 0 && 'string' == typeof value[0]) return {
+            _isSqlFragment: true,
+            sql: value.join(', '),
+            args: []
+        };
+        if (Array.isArray(value) && value.length > 0 && 'object' == typeof value[0] && !Array.isArray(value[0])) {
+            if (0 === columnKeys.length) columnKeys = Object.keys(value[0]);
+            const allValues = [];
+            const rowPlaceholders = [];
+            for (const obj of value){
+                const rowValues = columnKeys.map((key)=>obj[key]);
+                allValues.push(...rowValues);
+                rowPlaceholders.push(`(${columnKeys.map(()=>'?').join(', ')})`);
             }
-        });
-        const result = await response.json();
-        if (!result.success) throw new Error(result.error || 'Failed to delete database');
-        // Remove from cache
-        for (const [key, cachedHash] of this.databaseCache.entries())if (cachedHash === hash) {
-            this.databaseCache.delete(key);
-            break;
+            return {
+                _isSqlFragment: true,
+                sql: `(${columnKeys.join(', ')}) VALUES ${rowPlaceholders.join(', ')}`,
+                args: allValues
+            };
+        }
+        if (value && 'object' == typeof value && !Array.isArray(value)) {
+            if (0 === columnKeys.length) columnKeys = Object.keys(value);
+            const values = columnKeys.map((key)=>value[key]);
+            const placeholders = columnKeys.map(()=>'?').join(', ');
+            return {
+                _isSqlFragment: true,
+                sql: `(${columnKeys.join(', ')}) VALUES (${placeholders})`,
+                args: values
+            };
+        }
+        if (Array.isArray(value) && value.length > 0 && Array.isArray(value[0])) {
+            const rowPlaceholders = value.map((row)=>`(${row.map(()=>'?').join(', ')})`).join(', ');
+            return {
+                _isSqlFragment: true,
+                sql: rowPlaceholders,
+                args: value.flat()
+            };
         }
+        return {
+            _isSqlFragment: true,
+            sql: '',
+            args: []
+        };
     }
-    /**
-   * List available nodes
-   *
-   * @returns Array of node objects
-   */ async listNodes() {
-        const response = await fetch(`${this.apiUrl}/api/tenant/nodes`, {
-            headers: {
-                Authorization: `Bearer ${this.apiKey}`
-            }
-        });
-        const result = await response.json();
-        if (!result.success) throw new Error(result.error || 'Failed to list nodes');
-        return result.nodes;
-    }
-    /**
-   * Execute a query on a specific database
-   *
-   * This is a low-level query method. For most use cases, you should use
-   * the full ODB client (`odblite()` function) instead, which provides
-   * template tag support and better ergonomics.
-   *
-   * @param databaseHash - Hash of the database to query
-   * @param sql - SQL query string
-   * @param params - Query parameters
-   * @returns Query result
-   */ async query(databaseHash, sql, params = []) {
-        const response = await fetch(`${this.apiUrl}/query/${databaseHash}`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${this.apiKey}`
-            },
-            body: JSON.stringify({
-                sql,
-                params
-            })
-        });
-        const result = await response.json();
-        if (!result.success) throw new Error(result.error || 'Query failed');
-        return result.data;
-    }
-    /**
-   * Clear the database hash cache
-   *
-   * Useful when database mappings have changed or for testing.
-   */ clearCache() {
-        this.databaseCache.clear();
+    function empty() {
+        return {
+            _isSqlFragment: true,
+            sql: '',
+            args: []
+        };
     }
-    /**
-   * Get cached database hash for a specific tenant (if exists)
-   *
-   * @param prefix - Database name prefix
-   * @param tenantId - Tenant identifier
-   * @returns Cached hash or undefined
-   */ getCachedHash(prefix, tenantId) {
-        const cacheKey = `${prefix}_${tenantId}`;
-        return this.databaseCache.get(cacheKey);
+    function sql_template_raw(value) {
+        return {
+            _isSqlFragment: true,
+            sql: value,
+            args: []
+        };
     }
-    /**
-   * Pre-cache a database hash
-   *
-   * Useful when you know the mapping ahead of time and want to avoid
-   * the initial lookup.
-   *
-   * @param prefix - Database name prefix
-   * @param tenantId - Tenant identifier
-   * @param hash - Database hash
-   */ setCachedHash(prefix, tenantId, hash) {
-        const cacheKey = `${prefix}_${tenantId}`;
-        this.databaseCache.set(cacheKey, hash);
+    function sql_template_fragment(strings, ...values) {
+        const query = convertTemplateToQuery(strings, values);
+        return {
+            _isSqlFragment: true,
+            ...query
+        };
     }
-}
-const external_bun_sqlite_namespaceObject = require("bun:sqlite");
-/**
- * Bun SQLite adapter for DatabaseManager
- * Wraps bun:sqlite with Connection interface
- */ class BunSQLiteAdapter {
-    type = 'bun-sqlite';
-    config;
-    constructor(config){
-        this.config = config;
+    function sql_template_join(fragments, separator = ', ') {
+        if (0 === fragments.length) return empty();
+        const sql = fragments.map((f)=>f.sql).join(separator);
+        const args = fragments.flatMap((f)=>f.args);
+        return {
+            _isSqlFragment: true,
+            sql,
+            args
+        };
     }
-    async connect(config) {
-        const db = new external_bun_sqlite_namespaceObject.Database(config.databasePath, {
-            readonly: config.readonly,
-            create: config.create ?? true
-        });
-        return new BunSQLiteConnection(db);
+    function set(data, ...keys) {
+        let columns;
+        columns = keys.length > 0 ? keys : Object.keys(data);
+        if (0 === columns.length) return empty();
+        const setClauses = columns.map((key)=>`${key} = ?`);
+        const values = columns.map((key)=>data[key]);
+        return {
+            _isSqlFragment: true,
+            sql: setClauses.join(', '),
+            args: values
+        };
     }
-    async disconnect(tenantId) {
-    // bun:sqlite doesn't require explicit disconnection
-    // File handles are cleaned up by GC
+    function sql_template_where(conditions) {
+        const entries = Object.entries(conditions);
+        if (0 === entries.length) return empty();
+        const whereClauses = entries.map(([key])=>`${key} = ?`);
+        const values = entries.map(([, value])=>value);
+        return {
+            _isSqlFragment: true,
+            sql: whereClauses.join(' AND '),
+            args: values
+        };
     }
-    async isHealthy() {
-        try {
-            const db = new external_bun_sqlite_namespaceObject.Database(this.config.databasePath, {
-                readonly: true,
-                create: false
+    class BunSQLiteAdapter {
+        type = 'bun-sqlite';
+        config;
+        constructor(config){
+            this.config = config;
+        }
+        async connect(config) {
+            const db = new external_bun_sqlite_namespaceObject.Database(config.databasePath, {
+                readonly: config.readonly,
+                create: config.create ?? true
             });
-            db.query('SELECT 1').get();
-            db.close();
-            return true;
-        } catch  {
-            return false;
+            return new BunSQLiteConnection(db);
         }
-    }
-}
-/**
- * Connection implementation for Bun SQLite
- */ class BunSQLiteConnection {
-    db;
-    inTransaction = false;
-    constructor(db){
-        this.db = db;
-    }
-    /**
-   * Template tag query (postgres.js-like)
-   */ async sql(strings, ...values) {
-        // Build SQL from template
-        const sqlStr = strings.reduce((acc, str, i)=>acc + str + (i < values.length ? '?' : ''), '');
-        return this.execute(sqlStr, values);
-    }
-    /**
-   * Query with SQL string and parameters (alias for execute)
-   */ async query(sql, params = []) {
-        return this.execute(sql, params);
-    }
-    /**
-   * Execute SQL with parameters
-   */ async execute(sql, params = []) {
-        try {
-            // Handle object format { sql, args }
-            let sqlStr;
-            let sqlParams;
-            if ('object' == typeof sql) {
-                sqlStr = sql.sql;
-                sqlParams = sql.args || [];
-            } else {
-                sqlStr = sql;
-                sqlParams = params;
-            }
-            const stmt = this.db.query(sqlStr);
-            const isSelect = sqlStr.trim().toUpperCase().startsWith('SELECT') || sqlStr.trim().toUpperCase().includes('RETURNING');
-            if (isSelect) {
-                const rows = stmt.all(...sqlParams);
-                return {
-                    rows: rows,
-                    rowsAffected: 0
-                };
-            }
-            {
-                const result = stmt.run(...sqlParams);
-                return {
-                    rows: [],
-                    rowsAffected: result.changes || 0,
-                    lastInsertRowid: result.lastInsertRowid
-                };
+        async disconnect(tenantId) {}
+        async isHealthy() {
+            try {
+                const db = new external_bun_sqlite_namespaceObject.Database(this.config.databasePath, {
+                    readonly: true,
+                    create: false
+                });
+                db.query('SELECT 1').get();
+                db.close();
+                return true;
+            } catch  {
+                return false;
             }
-        } catch (error) {
-            throw new Error(`SQL execution failed: ${error.message}`);
         }
     }
-    /**
-   * Prepare statement for repeated execution
-   */ prepare(sql) {
-        const stmt = this.db.query(sql);
-        return {
-            execute: async (params = [])=>{
-                const isSelect = sql.trim().toUpperCase().startsWith('SELECT');
+    class BunSQLiteConnection {
+        db;
+        inTransaction = false;
+        sql;
+        constructor(db){
+            this.db = db;
+            const self = this;
+            this.sql = function(stringsOrValue, ...values) {
+                if (!stringsOrValue || 'object' != typeof stringsOrValue || !('raw' in stringsOrValue)) return sql_template_sql(stringsOrValue, ...values);
+                {
+                    const query = convertTemplateToQuery(stringsOrValue, values);
+                    const thenableFragment = {
+                        _isSqlFragment: true,
+                        sql: query.sql,
+                        args: query.args
+                    };
+                    thenableFragment['then'] = function(onFulfilled, onRejected) {
+                        return self.execute(query).then((result)=>result.rows).then(onFulfilled, onRejected);
+                    };
+                    return thenableFragment;
+                }
+            };
+            this.sql.empty = empty;
+            this.sql.raw = sql_template_raw;
+            this.sql.fragment = sql_template_fragment;
+            this.sql.join = sql_template_join;
+            this.sql.set = set;
+            this.sql.where = sql_template_where;
+        }
+        async query(sql, params = []) {
+            return this.execute(sql, params);
+        }
+        async execute(sql, params = []) {
+            try {
+                let sqlStr;
+                let sqlParams;
+                if ('object' == typeof sql) {
+                    if (process.env.DEBUG_SQL) {
+                        console.log('[BunSQLite] Executing SQL:', sql.sql);
+                        console.log('[BunSQLite] With args:', sql.args);
+                    }
+                    sqlStr = sql.sql;
+                    sqlParams = sql.args || [];
+                } else {
+                    if (process.env.DEBUG_SQL) {
+                        console.log('[BunSQLite] Executing SQL:', sql);
+                        console.log('[BunSQLite] With params:', params);
+                    }
+                    sqlStr = sql;
+                    sqlParams = params;
+                }
+                const stmt = this.db.query(sqlStr);
+                const isSelect = sqlStr.trim().toUpperCase().startsWith('SELECT') || sqlStr.trim().toUpperCase().includes('RETURNING');
                 if (isSelect) {
-                    const rows = stmt.all(...params);
+                    const rows = stmt.all(...sqlParams);
                     return {
                         rows: rows,
                         rowsAffected: 0
                     };
                 }
                 {
-                    const result = stmt.run(...params);
+                    const result = stmt.run(...sqlParams);
                     return {
                         rows: [],
                         rowsAffected: result.changes || 0,
                         lastInsertRowid: result.lastInsertRowid
                     };
                 }
-            },
-            all: async (params = [])=>stmt.all(...params),
-            get: async (params = [])=>stmt.get(...params)
-        };
-    }
-    /**
-   * Execute function in transaction
-   */ async transaction(fn) {
-        if (this.inTransaction) // Nested transaction - just execute the function
-        return fn(this);
-        this.inTransaction = true;
-        try {
-            await this.execute('BEGIN');
-            const result = await fn(this);
-            await this.execute('COMMIT');
-            return result;
-        } catch (error) {
-            await this.execute('ROLLBACK');
-            throw error;
-        } finally{
-            this.inTransaction = false;
+            } catch (error) {
+                throw error;
+            }
+        }
+        prepare(sql) {
+            const stmt = this.db.query(sql);
+            return {
+                execute: async (params = [])=>{
+                    const isSelect = sql.trim().toUpperCase().startsWith('SELECT');
+                    if (isSelect) {
+                        const rows = stmt.all(...params);
+                        return {
+                            rows: rows,
+                            rowsAffected: 0
+                        };
+                    }
+                    {
+                        const result = stmt.run(...params);
+                        return {
+                            rows: [],
+                            rowsAffected: result.changes || 0,
+                            lastInsertRowid: result.lastInsertRowid
+                        };
+                    }
+                },
+                all: async (params = [])=>stmt.all(...params),
+                get: async (params = [])=>stmt.get(...params)
+            };
+        }
+        async transaction(fn) {
+            if (this.inTransaction) return fn(this);
+            this.inTransaction = true;
+            try {
+                await this.execute('BEGIN');
+                const result = await fn(this);
+                await this.execute('COMMIT');
+                return result;
+            } catch (error) {
+                await this.execute('ROLLBACK');
+                throw error;
+            } finally{
+                this.inTransaction = false;
+            }
+        }
+        async begin(fn) {
+            return this.transaction(fn);
+        }
+        async close() {
+            this.db.close();
+        }
+        createORM() {
+            const { createORM } = __webpack_require__("./src/orm/index.ts");
+            return createORM(this);
         }
     }
-    /**
-   * Execute function in transaction (alias for transaction)
-   */ async begin(fn) {
-        return this.transaction(fn);
-    }
-    /**
-   * Close connection
-   */ async close() {
-        this.db.close();
-    }
-}
-const external_libsql_client_namespaceObject = require("@libsql/client");
-/**
- * LibSQL adapter for DatabaseManager
- * Wraps @libsql/client with Connection interface
- */ class LibSQLAdapter {
-    type = 'libsql';
-    config;
-    constructor(config){
-        this.config = config;
-    }
-    async connect(config) {
-        const client = (0, external_libsql_client_namespaceObject.createClient)({
-            url: config.url,
-            authToken: config.authToken,
-            encryptionKey: config.encryptionKey
-        });
-        return new LibSQLConnection(client);
-    }
-    async disconnect(tenantId) {
-    // LibSQL clients don't require explicit disconnection
-    // Connections are pooled internally
-    }
-    async isHealthy() {
-        try {
+    const external_libsql_client_namespaceObject = require("@libsql/client");
+    class LibSQLAdapter {
+        type = 'libsql';
+        config;
+        constructor(config){
+            this.config = config;
+        }
+        async connect(config) {
             const client = (0, external_libsql_client_namespaceObject.createClient)({
-                url: this.config.url,
-                authToken: this.config.authToken
+                url: config.url,
+                authToken: config.authToken,
+                encryptionKey: config.encryptionKey
             });
-            await client.execute('SELECT 1');
-            return true;
-        } catch  {
-            return false;
+            return new LibSQLConnection(client);
+        }
+        async disconnect(tenantId) {}
+        async isHealthy() {
+            try {
+                const client = (0, external_libsql_client_namespaceObject.createClient)({
+                    url: this.config.url,
+                    authToken: this.config.authToken
+                });
+                await client.execute('SELECT 1');
+                return true;
+            } catch  {
+                return false;
+            }
         }
     }
-}
-/**
- * Connection implementation for LibSQL
- */ class LibSQLConnection {
-    client;
-    txClient;
-    constructor(client){
-        this.client = client;
-    }
-    /**
-   * Template tag query (postgres.js-like)
-   */ async sql(strings, ...values) {
-        // Build SQL from template
-        const sqlStr = strings.reduce((acc, str, i)=>acc + str + (i < values.length ? '?' : ''), '');
-        return this.execute(sqlStr, values);
-    }
-    /**
-   * Query with SQL string and parameters (alias for execute)
-   */ async query(sql, params = []) {
-        return this.execute(sql, params);
-    }
-    /**
-   * Execute SQL with parameters
-   * Supports both formats: execute(sql, params) and execute({sql, args})
-   */ async execute(sql, params = []) {
-        try {
-            const target = this.txClient || this.client;
-            // Support both execute(sql, params) and execute({sql, args}) formats
-            let query;
-            query = 'string' == typeof sql ? {
-                sql,
-                args: params
-            } : {
-                sql: sql.sql,
-                args: sql.args || []
+    class LibSQLConnection {
+        client;
+        txClient;
+        sql;
+        constructor(client){
+            this.client = client;
+            const self = this;
+            this.sql = function(stringsOrValue, ...values) {
+                if (!stringsOrValue || 'object' != typeof stringsOrValue || !('raw' in stringsOrValue)) return sql_template_sql(stringsOrValue, ...values);
+                {
+                    const query = convertTemplateToQuery(stringsOrValue, values);
+                    const thenableFragment = {
+                        _isSqlFragment: true,
+                        sql: query.sql,
+                        args: query.args
+                    };
+                    thenableFragment['then'] = function(onFulfilled, onRejected) {
+                        return self.execute(query).then((result)=>result.rows).then(onFulfilled, onRejected);
+                    };
+                    return thenableFragment;
+                }
             };
-            const result = await target.execute(query);
+            this.sql.empty = empty;
+            this.sql.raw = sql_template_raw;
+            this.sql.fragment = sql_template_fragment;
+            this.sql.join = sql_template_join;
+            this.sql.set = set;
+            this.sql.where = sql_template_where;
+        }
+        async query(sql, params = []) {
+            return this.execute(sql, params);
+        }
+        async execute(sql, params = []) {
+            try {
+                const target = this.txClient || this.client;
+                let query;
+                if ('string' == typeof sql) {
+                    if (process.env.DEBUG_SQL) {
+                        console.log('[LibSQL] Executing SQL:', sql);
+                        console.log('[LibSQL] With params:', params);
+                    }
+                    query = {
+                        sql,
+                        args: params
+                    };
+                } else {
+                    if (process.env.DEBUG_SQL) {
+                        console.log('[LibSQL] Executing SQL:', sql.sql);
+                        console.log('[LibSQL] With args:', sql.args);
+                    }
+                    query = {
+                        sql: sql.sql,
+                        args: sql.args || []
+                    };
+                }
+                const result = await target.execute(query);
+                return {
+                    rows: result.rows,
+                    rowsAffected: Number(result.rowsAffected),
+                    lastInsertRowid: result.lastInsertRowid ? BigInt(result.lastInsertRowid.toString()) : void 0
+                };
+            } catch (error) {
+                throw error;
+            }
+        }
+        prepare(sql) {
             return {
-                rows: result.rows,
-                rowsAffected: Number(result.rowsAffected),
-                lastInsertRowid: result.lastInsertRowid ? BigInt(result.lastInsertRowid.toString()) : void 0
+                execute: async (params = [])=>this.execute(sql, params),
+                all: async (params = [])=>{
+                    const result = await this.execute(sql, params);
+                    return result.rows;
+                },
+                get: async (params = [])=>{
+                    const result = await this.execute(sql, params);
+                    return result.rows[0] || null;
+                }
             };
-        } catch (error) {
-            throw new Error(`SQL execution failed: ${error.message}`);
         }
-    }
-    /**
-   * Prepare statement for repeated execution
-   */ prepare(sql) {
-        return {
-            execute: async (params = [])=>this.execute(sql, params),
-            all: async (params = [])=>{
-                const result = await this.execute(sql, params);
-                return result.rows;
-            },
-            get: async (params = [])=>{
-                const result = await this.execute(sql, params);
-                return result.rows[0] || null;
+        async transaction(fn) {
+            if (this.txClient) return fn(this);
+            try {
+                await this.execute('BEGIN');
+                const result = await fn(this);
+                await this.execute('COMMIT');
+                return result;
+            } catch (error) {
+                await this.execute('ROLLBACK');
+                throw error;
             }
-        };
-    }
-    /**
-   * Execute function in transaction
-   */ async transaction(fn) {
-        if (this.txClient) // Nested transaction - just execute the function
-        return fn(this);
-        // Use manual BEGIN/COMMIT/ROLLBACK for simplicity
-        try {
-            await this.execute('BEGIN');
-            const result = await fn(this);
-            await this.execute('COMMIT');
-            return result;
-        } catch (error) {
-            await this.execute('ROLLBACK');
-            throw error;
+        }
+        async begin(fn) {
+            return this.transaction(fn);
+        }
+        async close() {}
+        createORM() {
+            const { createORM } = __webpack_require__("./src/orm/index.ts");
+            return createORM(this);
         }
     }
-    /**
-   * Execute function in transaction (alias for transaction)
-   */ async begin(fn) {
-        return this.transaction(fn);
-    }
-    /**
-   * Close connection
-   */ async close() {
-    // LibSQL client.close() if available in future versions
-    // For now, connections are managed by the client pool
-    }
-}
-/**
- * ODB-Lite adapter for DatabaseManager
- * Wraps ServiceClient and ODBLiteClient with Connection interface
- */ class ODBLiteAdapter {
-    type = 'odblite';
-    config;
-    serviceClient;
-    constructor(config){
-        this.config = config;
-        this.serviceClient = new ServiceClient({
-            baseUrl: config.serviceUrl,
-            apiKey: config.apiKey
-        });
-    }
-    async connect(config) {
-        const databaseName = config.databaseName || 'default';
-        // Ensure database exists
-        const dbInfo = await this.serviceClient.getDatabaseByName(databaseName);
-        if (!dbInfo) // Create database - pass nodeId from config if provided, otherwise server selects
-        await this.serviceClient.createDatabase(databaseName, this.config.nodeId);
-        // Get fresh database info
-        const db = await this.serviceClient.getDatabaseByName(databaseName);
-        if (!db) throw new Error(`Database ${databaseName} not found after creation`);
-        // Create ODBLiteClient for this database
-        const client = new ODBLiteClient({
-            baseUrl: this.config.serviceUrl,
-            apiKey: this.config.apiKey,
-            databaseId: db.hash
-        });
-        return new ODBLiteConnection(client, this.serviceClient, databaseName);
-    }
-    async disconnect(tenantId) {
-        if (tenantId) {
-            const prefix = 'pipeline_tenant_' // TODO: make configurable
-            ;
-            const databaseName = `${prefix}${tenantId}`;
+    class ODBLiteAdapter {
+        type = 'odblite';
+        config;
+        serviceClient;
+        constructor(config){
+            this.config = config;
+            this.serviceClient = new ServiceClient({
+                baseUrl: config.serviceUrl,
+                apiKey: config.apiKey
+            });
+        }
+        async connect(config) {
+            const databaseName = config.databaseName || 'default';
+            const databaseHash = config.databaseHash;
+            if (databaseHash) {
+                const client = new ODBLiteClient({
+                    baseUrl: this.config.serviceUrl,
+                    apiKey: this.config.apiKey,
+                    databaseId: databaseHash
+                });
+                return new ODBLiteConnection(client, this.serviceClient, databaseName, databaseHash);
+            }
+            const db = await this.serviceClient.getDatabaseByName(databaseName);
+            if (!db) throw new Error(`Database ${databaseName} not found. Please create it first using the admin API.`);
+            const client = new ODBLiteClient({
+                baseUrl: this.config.serviceUrl,
+                apiKey: this.config.apiKey,
+                databaseId: db.hash
+            });
+            return new ODBLiteConnection(client, this.serviceClient, databaseName, db.hash);
+        }
+        async disconnect(tenantId) {
+            if (tenantId) {
+                const prefix = 'pipeline_tenant_';
+                const databaseName = `${prefix}${tenantId}`;
+                try {
+                    await this.serviceClient.deleteDatabase(databaseName);
+                } catch (error) {
+                    console.warn(`Failed to delete database ${databaseName}:`, error.message);
+                }
+            }
+        }
+        async isHealthy() {
             try {
-                await this.serviceClient.deleteDatabase(databaseName);
-            } catch (error) {
-                console.warn(`Failed to delete database ${databaseName}:`, error.message);
+                await this.serviceClient.listDatabases();
+                return true;
+            } catch  {
+                return false;
             }
         }
     }
-    async isHealthy() {
-        try {
-            await this.serviceClient.listDatabases();
-            return true;
-        } catch  {
-            return false;
+    class ODBLiteConnection {
+        client;
+        serviceClient;
+        inTransaction = false;
+        databaseName;
+        databaseHash;
+        sql;
+        constructor(client, serviceClient, databaseName, databaseHash){
+            this.client = client;
+            this.serviceClient = serviceClient;
+            this.databaseName = databaseName;
+            this.databaseHash = databaseHash;
+            const self = this;
+            this.sql = function(stringsOrValue, ...values) {
+                if (!stringsOrValue || 'object' != typeof stringsOrValue || !('raw' in stringsOrValue)) return sql_template_sql(stringsOrValue, ...values);
+                {
+                    const query = convertTemplateToQuery(stringsOrValue, values);
+                    const thenableFragment = {
+                        _isSqlFragment: true,
+                        sql: query.sql,
+                        args: query.args
+                    };
+                    thenableFragment['then'] = function(onFulfilled, onRejected) {
+                        return self.execute(query).then((result)=>result.rows).then(onFulfilled, onRejected);
+                    };
+                    return thenableFragment;
+                }
+            };
+            this.sql.empty = empty;
+            this.sql.raw = sql_template_raw;
+            this.sql.fragment = sql_template_fragment;
+            this.sql.join = sql_template_join;
+            this.sql.set = set;
+            this.sql.where = sql_template_where;
         }
-    }
-}
-/**
- * Connection implementation for ODB-Lite
- */ class ODBLiteConnection {
-    client;
-    serviceClient;
-    databaseName;
-    inTransaction = false;
-    constructor(client, serviceClient, databaseName){
-        this.client = client;
-        this.serviceClient = serviceClient;
-        this.databaseName = databaseName;
-    }
-    /**
-   * Template tag query (postgres.js-like)
-   */ async sql(strings, ...values) {
-        // ODBLiteClient.sql is a function that returns a Promise
-        const result = await this.client.sql(strings, ...values);
-        return {
-            rows: result.rows,
-            rowsAffected: result.rowsAffected || 0
-        };
-    }
-    /**
-   * Query with SQL string and parameters (alias for execute)
-   */ async query(sql, params = []) {
-        return this.execute(sql, params);
-    }
-    /**
-   * Execute SQL with parameters
-   */ async execute(sql, params = []) {
-        try {
-            // Handle object format { sql, args }
-            if ('object' == typeof sql) {
-                const result = await this.client.sql.execute(sql.sql, sql.args || []);
+        async query(sql, params = []) {
+            return this.execute(sql, params);
+        }
+        async execute(sql, params = []) {
+            try {
+                if ('object' == typeof sql) {
+                    if (process.env.DEBUG_SQL) {
+                        console.log('[ODBLite] Executing SQL:', sql.sql);
+                        console.log('[ODBLite] With args:', sql.args);
+                    }
+                    const result = await this.client.sql.execute(sql.sql, sql.args || []);
+                    return {
+                        rows: result.rows,
+                        rowsAffected: result.rowsAffected || 0,
+                        lastInsertRowid: result.lastInsertRowid
+                    };
+                }
+                if (process.env.DEBUG_SQL) {
+                    console.log('[ODBLite] Executing SQL:', sql);
+                    console.log('[ODBLite] With params:', params);
+                }
+                const result = await this.client.sql.execute(sql, params);
                 return {
                     rows: result.rows,
-                    rowsAffected: result.rowsAffected || 0
+                    rowsAffected: result.rowsAffected || 0,
+                    lastInsertRowid: result.lastInsertRowid
                 };
+            } catch (error) {
+                throw error;
             }
-            // Handle string format
-            const result = await this.client.sql.execute(sql, params);
+        }
+        prepare(sql) {
             return {
-                rows: result.rows,
-                rowsAffected: result.rowsAffected || 0
+                execute: async (params = [])=>this.execute(sql, params),
+                all: async (params = [])=>{
+                    const result = await this.execute(sql, params);
+                    return result.rows;
+                },
+                get: async (params = [])=>{
+                    const result = await this.execute(sql, params);
+                    return result.rows[0] || null;
+                }
             };
-        } catch (error) {
-            throw new Error(`SQL execution failed: ${error.message}`);
         }
-    }
-    /**
-   * Prepare statement for repeated execution
-   */ prepare(sql) {
-        return {
-            execute: async (params = [])=>this.execute(sql, params),
-            all: async (params = [])=>{
-                const result = await this.execute(sql, params);
-                return result.rows;
-            },
-            get: async (params = [])=>{
-                const result = await this.execute(sql, params);
-                return result.rows[0] || null;
+        async transaction(fn) {
+            if (this.inTransaction) return fn(this);
+            this.inTransaction = true;
+            try {
+                await this.execute('BEGIN');
+                const result = await fn(this);
+                await this.execute('COMMIT');
+                return result;
+            } catch (error) {
+                await this.execute('ROLLBACK');
+                throw error;
+            } finally{
+                this.inTransaction = false;
             }
-        };
-    }
-    /**
-   * Execute function in transaction
-   */ async transaction(fn) {
-        if (this.inTransaction) // Nested transaction - just execute the function
-        return fn(this);
-        this.inTransaction = true;
-        try {
-            await this.execute('BEGIN');
-            const result = await fn(this);
-            await this.execute('COMMIT');
-            return result;
-        } catch (error) {
-            await this.execute('ROLLBACK');
-            throw error;
-        } finally{
-            this.inTransaction = false;
+        }
+        async begin(fn) {
+            return this.transaction(fn);
+        }
+        async close() {}
+        createORM() {
+            const { createORM } = __webpack_require__("./src/orm/index.ts");
+            return createORM(this);
         }
     }
-    /**
-   * Execute function in transaction (alias for transaction)
-   */ async begin(fn) {
-        return this.transaction(fn);
-    }
-    /**
-   * Close connection
-   */ async close() {
-    // ODBLiteClient connections are stateless HTTP requests
-    // No explicit close needed
-    }
-}
-/**
- * Parse SQL file into statements, separating PRAGMA from regular SQL
- * Uses custom parser that handles BEGIN...END blocks
- */ function parseSQL(sqlContent, options = {}) {
-    const separatePragma = options.separatePragma ?? true;
-    // Split SQL statements manually
-    const statements = splitStatements(sqlContent);
-    if (!separatePragma) return {
-        pragmaStatements: [],
-        regularStatements: statements
-    };
-    const pragmaStatements = [];
-    const regularStatements = [];
-    for (const statement of statements){
-        const trimmed = statement.trim().toUpperCase();
-        if (trimmed.startsWith('PRAGMA')) pragmaStatements.push(statement);
-        else regularStatements.push(statement);
+    function parseSQL(sqlContent, options = {}) {
+        const separatePragma = options.separatePragma ?? true;
+        const statements = splitStatements(sqlContent);
+        if (!separatePragma) return {
+            pragmaStatements: [],
+            regularStatements: statements
+        };
+        const pragmaStatements = [];
+        const regularStatements = [];
+        for (const statement of statements){
+            const trimmed = statement.trim().toUpperCase();
+            if (trimmed.startsWith('PRAGMA')) pragmaStatements.push(statement);
+            else regularStatements.push(statement);
+        }
+        return {
+            pragmaStatements,
+            regularStatements
+        };
     }
-    return {
-        pragmaStatements,
-        regularStatements
-    };
-}
-/**
- * Split SQL content into individual statements
- * Handles comments, quotes, semicolons, and BEGIN...END blocks properly
- */ function splitStatements(sqlContent) {
-    const statements = [];
-    let currentStatement = '';
-    let inQuote = false;
-    let quoteChar = '';
-    let beginEndDepth = 0;
-    const lines = sqlContent.split('\n');
-    for (const line of lines){
-        let processedLine = '';
-        const lineWithoutComments = line.replace(/--.*$/, '');
-        // Track BEGIN...END depth for this line BEFORE processing characters
-        if (!inQuote && lineWithoutComments.trim()) {
-            const beginMatches = lineWithoutComments.match(/\bBEGIN\b/gi);
-            const endMatches = lineWithoutComments.match(/\bEND\b/gi);
-            if (beginMatches) beginEndDepth += beginMatches.length;
-            if (endMatches) {
-                beginEndDepth -= endMatches.length;
-                if (beginEndDepth < 0) beginEndDepth = 0;
-            }
-        }
-        for(let i = 0; i < line.length; i++){
-            const char = line[i];
-            const prevChar = i > 0 ? line[i - 1] : '';
-            const nextChar = i < line.length - 1 ? line[i + 1] : '';
-            // Handle single-line comments
-            if (!inQuote && '-' === char && '-' === nextChar) break; // Skip rest of line
-            // Track quotes
-            if (("'" === char || '"' === char) && '\\' !== prevChar) {
-                if (inQuote) {
+    function splitStatements(sqlContent) {
+        const statements = [];
+        let currentStatement = '';
+        let inQuote = false;
+        let quoteChar = '';
+        let beginEndDepth = 0;
+        const lines = sqlContent.split('\n');
+        for (const line of lines){
+            let processedLine = '';
+            const lineWithoutComments = line.replace(/--.*$/, '');
+            if (!inQuote && lineWithoutComments.trim()) {
+                const beginMatches = lineWithoutComments.match(/\bBEGIN\b/gi);
+                const endMatches = lineWithoutComments.match(/\bEND\b/gi);
+                if (beginMatches) beginEndDepth += beginMatches.length;
+                if (endMatches) {
+                    beginEndDepth -= endMatches.length;
+                    if (beginEndDepth < 0) beginEndDepth = 0;
+                }
+            }
+            for(let i = 0; i < line.length; i++){
+                const char = line[i];
+                const prevChar = i > 0 ? line[i - 1] : '';
+                const nextChar = i < line.length - 1 ? line[i + 1] : '';
+                if (!inQuote && '-' === char && '-' === nextChar) break;
+                if (("'" === char || '"' === char) && '\\' !== prevChar) if (inQuote) {
                     if (char === quoteChar) {
                         inQuote = false;
                         quoteChar = '';
@@ -1553,289 +1749,291 @@ const external_libsql_client_namespaceObject = require("@libsql/client");
                     inQuote = true;
                     quoteChar = char;
                 }
-            }
-            processedLine += char;
-            // Split on semicolon when not in quotes AND not inside BEGIN...END
-            if (';' === char && !inQuote && 0 === beginEndDepth) {
-                currentStatement += processedLine;
-                const stmt = currentStatement.trim();
-                if (stmt && !stmt.startsWith('--')) statements.push(stmt);
-                currentStatement = '';
-                processedLine = '';
-            }
-        }
-        if (processedLine.trim()) currentStatement += `${processedLine}\n`;
-    }
-    // Handle remaining statement
-    const finalStmt = currentStatement.trim();
-    if (finalStmt && !finalStmt.startsWith('--')) statements.push(finalStmt);
-    return statements;
-}
-/**
- * Simple split for systems that don't need PRAGMA separation
- */ function splitSQLStatements(sqlContent) {
-    const { pragmaStatements, regularStatements } = parseSQL(sqlContent);
-    return [
-        ...pragmaStatements,
-        ...regularStatements
-    ];
-}
-const external_node_fs_namespaceObject = require("node:fs");
-var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
-/**
- * Database factory for creating and managing multiple databases
- *
- * Features:
- * - Creates multiple databases from single manager instance
- * - Supports libsql, bun:sqlite, and ODB-Lite backends
- * - Connection pooling with LRU eviction
- * - Automatic schema migrations
- *
- * @example
- * ```ts
- * const dbManager = new DatabaseManager({
- *   backend: 'libsql',
- *   databasePath: './data'
- * })
- *
- * // Create databases
- * await dbManager.createDatabase('identity', { schemaContent })
- * await dbManager.createDatabase('analytics', { schemaContent })
- *
- * // Get connections
- * const identityDB = await dbManager.getConnection('identity')
- * const analyticsDB = await dbManager.getConnection('analytics')
- * ```
- */ class DatabaseManager {
-    config;
-    adapter;
-    connections = new Map();
-    // Connection pool management (LRU)
-    connectionTimestamps = new Map();
-    maxConnections;
-    constructor(config){
-        this.config = config;
-        this.maxConnections = config.connectionPoolSize || 10;
-        // Create appropriate adapter based on backend
-        switch(config.backend){
-            case 'bun-sqlite':
-                this.adapter = new BunSQLiteAdapter({
-                    databasePath: config.databasePath,
-                    create: true
-                });
-                break;
-            case 'libsql':
-                this.adapter = new LibSQLAdapter({
-                    url: `file:${config.databasePath}`,
-                    ...config.libsql
-                });
-                break;
-            case 'odblite':
-                if (!config.odblite) throw new Error('odblite config required for odblite backend');
-                this.adapter = new ODBLiteAdapter(config.odblite);
-                break;
-            default:
-                throw new Error(`Unknown backend type: ${config.backend}`);
-        }
-    }
-    /**
-   * Create a new database
-   * @param name - Database name (becomes filename or ODB-Lite database name)
-   * @param options - Optional creation options
-   */ async createDatabase(name, options) {
-        console.log(`📦 Creating database: ${name}`);
-        // Build database-specific config
-        const dbConfig = this.getDatabaseConfig(name);
-        // Create connection
-        const conn = await this.adapter.connect(dbConfig);
-        // Run migrations if schema provided
-        if (options?.schemaContent) await this.runMigrations(conn, {
-            schemaContent: options.schemaContent
-        });
-        // Store connection
-        this.connections.set(name, conn);
-        this.connectionTimestamps.set(name, Date.now());
-        // Evict LRU if pool is full
-        if (this.connections.size > this.maxConnections) await this.evictLRU();
-        console.log(`✅ Database created: ${name}`);
-    }
-    /**
-   * Check if a database exists
-   * @param name - Database name
-   * @returns true if database exists, false otherwise
-   *
-   * Note: For local backends (libsql, bun-sqlite), checks file existence.
-   * For ODB-Lite, checks if database is in connection cache.
-   */ async databaseExists(name) {
-        // Check if already in connection cache
-        if (this.connections.has(name)) return true;
-        // For local file-based backends, check if file exists
-        switch(this.config.backend){
-            case 'bun-sqlite':
-                {
-                    const dbPath = `${this.config.databasePath}/${name}.db`;
-                    return external_node_fs_default().existsSync(dbPath);
-                }
-            case 'libsql':
-                {
-                    const dbPath = `${this.config.databasePath}/${name}.db`;
-                    return external_node_fs_default().existsSync(dbPath);
+                processedLine += char;
+                if (';' === char && !inQuote && 0 === beginEndDepth) {
+                    currentStatement += processedLine;
+                    const stmt = currentStatement.trim();
+                    if (stmt && !stmt.startsWith('--')) statements.push(stmt);
+                    currentStatement = '';
+                    processedLine = '';
                 }
-            case 'odblite':
-                // For ODB-Lite, only return true if in cache
-                // (no way to check remote database existence without connecting)
-                return false;
-            default:
-                return false;
+            }
+            if (processedLine.trim()) currentStatement += `${processedLine}\n`;
         }
+        const finalStmt = currentStatement.trim();
+        if (finalStmt && !finalStmt.startsWith('--')) statements.push(finalStmt);
+        return statements;
+    }
+    function splitSQLStatements(sqlContent) {
+        const { pragmaStatements, regularStatements } = parseSQL(sqlContent);
+        return [
+            ...pragmaStatements,
+            ...regularStatements
+        ];
     }
-    /**
-   * Get connection to a database
-   * @param name - Database name
-   *
-   * If database exists on disk but not in cache, it will be connected automatically.
-   * If database doesn't exist at all, an error will be thrown.
-   */ async getConnection(name) {
-        // Check if connection exists in cache
-        let conn = this.connections.get(name);
-        if (conn) {
-            this.connectionTimestamps.set(name, Date.now());
-            return conn;
+    const external_node_fs_namespaceObject = require("node:fs");
+    var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+    class DatabaseManager {
+        config;
+        adapter;
+        connections = new Map();
+        connectionTimestamps = new Map();
+        maxConnections;
+        constructor(config){
+            this.config = config;
+            this.maxConnections = config.connectionPoolSize || 10;
+            switch(config.backend){
+                case 'bun-sqlite':
+                    this.adapter = new BunSQLiteAdapter({
+                        databasePath: config.databasePath,
+                        create: true
+                    });
+                    break;
+                case 'libsql':
+                    this.adapter = new LibSQLAdapter({
+                        url: `file:${config.databasePath}`,
+                        ...config.libsql
+                    });
+                    break;
+                case 'odblite':
+                    if (!config.odblite) throw new Error('odblite config required for odblite backend');
+                    this.adapter = new ODBLiteAdapter(config.odblite);
+                    break;
+                default:
+                    throw new Error(`Unknown backend type: ${config.backend}`);
+            }
         }
-        // Check if database exists on disk
-        const exists = await this.databaseExists(name);
-        if (exists) {
-            // Connect to existing database
+        async createDatabase(name, options) {
+            console.log(`📦 Creating database: ${name}`);
             const dbConfig = this.getDatabaseConfig(name);
-            conn = await this.adapter.connect(dbConfig);
-            // Store connection
+            const conn = await this.adapter.connect(dbConfig);
+            if (options?.schemaContent) await this.runMigrations(conn, {
+                schemaContent: options.schemaContent
+            });
             this.connections.set(name, conn);
             this.connectionTimestamps.set(name, Date.now());
-            // Evict LRU if pool is full
             if (this.connections.size > this.maxConnections) await this.evictLRU();
+            console.log(`✅ Database created: ${name}`);
             return conn;
         }
-        // If database doesn't exist, throw error
-        throw new Error(`Database "${name}" not found. Call createDatabase("${name}", { schemaContent }) first.`);
-    }
-    /**
-   * Delete a database
-   * @param name - Database name
-   */ async deleteDatabase(name) {
-        console.log(`🗑️  Deleting database: ${name}`);
-        // Close connection if exists
-        const conn = this.connections.get(name);
-        if (conn) {
-            await conn.close();
-            this.connections.delete(name);
-            this.connectionTimestamps.delete(name);
-        }
-        // Backend-specific deletion
-        await this.adapter.disconnect(name);
-        console.log(`✅ Database deleted: ${name}`);
-    }
-    /**
-   * Execute SQL content on a database connection
-   * Useful for running migrations or initial schema
-   * @param name - Database name
-   * @param sqlContent - SQL content to execute
-   */ async executeSQLFile(name, sqlContent) {
-        const conn = await this.getConnection(name);
-        await this.runMigrations(conn, {
-            schemaContent: sqlContent
-        });
-    }
-    /**
-   * List all managed databases
-   */ async listDatabases() {
-        return Array.from(this.connections.keys());
-    }
-    /**
-   * Close all connections
-   */ async close() {
-        console.log(`🔌 Closing all database connections...`);
-        for (const [name, conn] of this.connections)await conn.close();
-        this.connections.clear();
-        this.connectionTimestamps.clear();
-        console.log(`✅ All connections closed`);
-    }
-    /**
-   * Run migrations on a connection
-   */ async runMigrations(conn, config) {
-        // Parse SQL statements
-        const { pragmaStatements, regularStatements } = parseSQL(config.schemaContent);
-        // Execute PRAGMA statements first
-        for (const pragma of pragmaStatements)try {
-            await conn.execute(pragma);
-        } catch (error) {
-            // Ignore PRAGMA errors (they might not be supported on all backends)
-            console.log(`⚠️  PRAGMA note: ${error.message}`);
-        }
-        // Execute regular statements
-        for (const statement of regularStatements)try {
-            await conn.execute(statement);
-        } catch (error) {
-            // Ignore "already exists" errors for idempotency
-            if (error.message?.includes('already exists') || error.message?.includes('no such column') || error.message?.includes('no such table')) {
-                console.log(`  ⚠️  Skipping: ${error.message}`);
-                continue;
-            }
-            console.error(`❌ Migration failed: ${statement.substring(0, 100)}...`);
-            throw error;
-        }
-        console.log(`✅ Migrations completed (${regularStatements.length} statements)`);
-    }
-    /**
-   * Get database-specific configuration
-   */ getDatabaseConfig(name) {
-        switch(this.config.backend){
-            case 'bun-sqlite':
-                return {
-                    databasePath: `${this.config.databasePath}/${name}.db`,
-                    create: true
-                };
-            case 'libsql':
-                return {
-                    url: `file:${this.config.databasePath}/${name}.db`,
-                    ...this.config.libsql
-                };
-            case 'odblite':
-                return {
-                    databaseName: `${this.config.databasePath}_${name}`,
-                    ...this.config.odblite
-                };
-            default:
-                throw new Error(`Unknown backend: ${this.config.backend}`);
+        async databaseExists(name) {
+            if (this.connections.has(name)) return true;
+            switch(this.config.backend){
+                case 'bun-sqlite':
+                    {
+                        const dbPath = `${this.config.databasePath}/${name}.db`;
+                        return external_node_fs_default().existsSync(dbPath);
+                    }
+                case 'libsql':
+                    {
+                        const dbPath = `${this.config.databasePath}/${name}.db`;
+                        return external_node_fs_default().existsSync(dbPath);
+                    }
+                case 'odblite':
+                    return false;
+                default:
+                    return false;
+            }
         }
-    }
-    /**
-   * Evict least recently used connection
-   */ async evictLRU() {
-        let oldestKey = null;
-        let oldestTime = 1 / 0;
-        for (const [key, timestamp] of this.connectionTimestamps)if (timestamp < oldestTime) {
-            oldestTime = timestamp;
-            oldestKey = key;
-        }
-        if (oldestKey) {
-            const conn = this.connections.get(oldestKey);
-            if (conn) await conn.close();
-            this.connections.delete(oldestKey);
-            this.connectionTimestamps.delete(oldestKey);
-            console.log(`♻️  Evicted LRU connection: ${oldestKey}`);
+        async getConnection(name) {
+            let conn = this.connections.get(name);
+            if (conn) {
+                this.connectionTimestamps.set(name, Date.now());
+                return conn;
+            }
+            const exists = await this.databaseExists(name);
+            if (exists) {
+                const dbConfig = this.getDatabaseConfig(name);
+                conn = await this.adapter.connect(dbConfig);
+                this.connections.set(name, conn);
+                this.connectionTimestamps.set(name, Date.now());
+                if (this.connections.size > this.maxConnections) await this.evictLRU();
+                return conn;
+            }
+            throw new Error(`Database "${name}" not found. Call createDatabase("${name}", { schemaContent }) first.`);
+        }
+        async deleteDatabase(name) {
+            console.log(`🗑️  Deleting database: ${name}`);
+            const conn = this.connections.get(name);
+            if (conn) {
+                await conn.close();
+                this.connections.delete(name);
+                this.connectionTimestamps.delete(name);
+            }
+            await this.adapter.disconnect(name);
+            console.log(`✅ Database deleted: ${name}`);
+        }
+        async executeSQLFile(name, sqlContent) {
+            const conn = await this.getConnection(name);
+            await this.runMigrations(conn, {
+                schemaContent: sqlContent
+            });
+        }
+        async listDatabases() {
+            return Array.from(this.connections.keys());
+        }
+        async close() {
+            console.log(`🔌 Closing all database connections...`);
+            for (const [name, conn] of this.connections)await conn.close();
+            this.connections.clear();
+            this.connectionTimestamps.clear();
+            console.log(`✅ All connections closed`);
+        }
+        async runMigrations(conn, config) {
+            const { pragmaStatements, regularStatements } = parseSQL(config.schemaContent);
+            for (const pragma of pragmaStatements)try {
+                await conn.execute(pragma);
+            } catch (error) {
+                console.log(`⚠️  PRAGMA note: ${error.message}`);
+            }
+            for (const statement of regularStatements)try {
+                await conn.execute(statement);
+            } catch (error) {
+                if (error.message?.includes('already exists') || error.message?.includes('no such column') || error.message?.includes('no such table')) {
+                    console.log(`  ⚠️  Skipping: ${error.message}`);
+                    continue;
+                }
+                console.error(`❌ Migration failed: ${statement.substring(0, 100)}...`);
+                throw error;
+            }
+            console.log(`✅ Migrations completed (${regularStatements.length} statements)`);
+        }
+        getDatabaseConfig(name) {
+            switch(this.config.backend){
+                case 'bun-sqlite':
+                    return {
+                        databasePath: `${this.config.databasePath}/${name}.db`,
+                        create: true
+                    };
+                case 'libsql':
+                    return {
+                        url: `file:${this.config.databasePath}/${name}.db`,
+                        ...this.config.libsql
+                    };
+                case 'odblite':
+                    return {
+                        databaseName: `${this.config.databasePath}_${name}`,
+                        ...this.config.odblite
+                    };
+                default:
+                    throw new Error(`Unknown backend: ${this.config.backend}`);
+            }
+        }
+        async evictLRU() {
+            let oldestKey = null;
+            let oldestTime = 1 / 0;
+            for (const [key, timestamp] of this.connectionTimestamps)if (timestamp < oldestTime) {
+                oldestTime = timestamp;
+                oldestKey = key;
+            }
+            if (oldestKey) {
+                const conn = this.connections.get(oldestKey);
+                if (conn) await conn.close();
+                this.connections.delete(oldestKey);
+                this.connectionTimestamps.delete(oldestKey);
+                console.log(`♻️  Evicted LRU connection: ${oldestKey}`);
+            }
         }
     }
-}
-// Main entry point for ODB Client
-// Core query client exports (postgres.js-like interface)
-// Service management exports (high-level tenant database management)
-// Database Manager exports (unified multi-backend database abstraction)
-// Export error classes
-// Export static utility functions for easy access
-const { raw: src_raw, identifier: src_identifier, where: src_where, insertValues: src_insertValues, updateSet: src_updateSet, join: src_join } = ODBLiteClient;
-// Default export for convenient usage
-var __webpack_export_target__ = exports;
-for(var i in __webpack_exports__)__webpack_export_target__[i] = __webpack_exports__[i];
-if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    var orm = __webpack_require__("./src/orm/index.ts");
+    const { raw: src_raw, identifier: src_identifier, where: src_where, insertValues: src_insertValues, updateSet: src_updateSet, join: src_join } = ODBLiteClient;
+})();
+exports.BunSQLiteAdapter = __webpack_exports__.BunSQLiteAdapter;
+exports.ConnectionError = __webpack_exports__.ConnectionError;
+exports.DatabaseManager = __webpack_exports__.DatabaseManager;
+exports.HTTPClient = __webpack_exports__.HTTPClient;
+exports.LibSQLAdapter = __webpack_exports__.LibSQLAdapter;
+exports.ODBLiteAdapter = __webpack_exports__.ODBLiteAdapter;
+exports.ODBLiteClient = __webpack_exports__.ODBLiteClient;
+exports.ODBLiteError = __webpack_exports__.ODBLiteError;
+exports.ODBLiteTransaction = __webpack_exports__.ODBLiteTransaction;
+exports.ORM = __webpack_exports__.ORM;
+exports.QueryError = __webpack_exports__.QueryError;
+exports.SQLParser = __webpack_exports__.SQLParser;
+exports.ServiceClient = __webpack_exports__.ServiceClient;
+exports.SimpleTransaction = __webpack_exports__.SimpleTransaction;
+exports.and = __webpack_exports__.and;
+exports.convertTemplateToQuery = __webpack_exports__.convertTemplateToQuery;
+exports.createORM = __webpack_exports__.createORM;
+exports["default"] = __webpack_exports__["default"];
+exports.empty = __webpack_exports__.empty;
+exports.eq = __webpack_exports__.eq;
+exports.fragment = __webpack_exports__.fragment;
+exports.gt = __webpack_exports__.gt;
+exports.gte = __webpack_exports__.gte;
+exports.identifier = __webpack_exports__.identifier;
+exports.inArray = __webpack_exports__.inArray;
+exports.insertValues = __webpack_exports__.insertValues;
+exports.isNotNull = __webpack_exports__.isNotNull;
+exports.isNull = __webpack_exports__.isNull;
+exports.join = __webpack_exports__.join;
+exports.like = __webpack_exports__.like;
+exports.lt = __webpack_exports__.lt;
+exports.lte = __webpack_exports__.lte;
+exports.ne = __webpack_exports__.ne;
+exports.odblite = __webpack_exports__.odblite;
+exports.or = __webpack_exports__.or;
+exports.parseSQL = __webpack_exports__.parseSQL;
+exports.raw = __webpack_exports__.raw;
+exports.rawSQL = __webpack_exports__.rawSQL;
+exports.set = __webpack_exports__.set;
+exports.splitSQLStatements = __webpack_exports__.splitSQLStatements;
+exports.sql = __webpack_exports__.sql;
+exports.sqlFragment = __webpack_exports__.sqlFragment;
+exports.sqlJoin = __webpack_exports__.sqlJoin;
+exports.sqlTemplate = __webpack_exports__.sqlTemplate;
+exports.sqlWhere = __webpack_exports__.sqlWhere;
+exports.updateSet = __webpack_exports__.updateSet;
+exports.where = __webpack_exports__.where;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "BunSQLiteAdapter",
+    "ConnectionError",
+    "DatabaseManager",
+    "HTTPClient",
+    "LibSQLAdapter",
+    "ODBLiteAdapter",
+    "ODBLiteClient",
+    "ODBLiteError",
+    "ODBLiteTransaction",
+    "ORM",
+    "QueryError",
+    "SQLParser",
+    "ServiceClient",
+    "SimpleTransaction",
+    "and",
+    "convertTemplateToQuery",
+    "createORM",
+    "default",
+    "empty",
+    "eq",
+    "fragment",
+    "gt",
+    "gte",
+    "identifier",
+    "inArray",
+    "insertValues",
+    "isNotNull",
+    "isNull",
+    "join",
+    "like",
+    "lt",
+    "lte",
+    "ne",
+    "odblite",
+    "or",
+    "parseSQL",
+    "raw",
+    "rawSQL",
+    "set",
+    "splitSQLStatements",
+    "sql",
+    "sqlFragment",
+    "sqlJoin",
+    "sqlTemplate",
+    "sqlWhere",
+    "updateSet",
+    "where"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
     value: true
 });