@fastybird/smart-panel-backend 1.1.0-alpha.64 → 1.1.0-alpha.65

package/dist/common/database/sqlite-data-source.js

@@ -0,0 +1,2131 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _CoordinatedSqliteQueryRunner_instances, _CoordinatedSqliteQueryRunner_coordinator, _CoordinatedSqliteQueryRunner_managedLifecycle, _CoordinatedSqliteQueryRunner_checkNoMutationPins, _CoordinatedSqliteQueryRunner_recordNoMutationAttempt, _CoordinatedSqliteQueryRunner_retainQueryRefusal, _CoordinatedSqliteQueryRunner_nativeDispatchRefusal, _CoordinatedSqliteQueryRunner_finalValidationActive, _CoordinatedSqliteQueryRunner_finalValidationRefusal, _CoordinatedSqliteQueryRunner_assertFinalControlOrigin, _CoordinatedSqliteQueryRunner_validateNoMutationDispatch, _CoordinatedSqliteQueryRunner_blockedQuery, _CoordinatedSqliteQueryRunner_beginFullAbort, _CoordinatedSqliteQueryRunner_captureQueryFailure, _CoordinatedSqliteQueryRunner_latchNativeFailure, _CoordinatedSqliteQueryRunner_pumpNative, _CoordinatedSqliteQueryRunner_dispatchQueued, _CoordinatedSqliteQueryRunner_submitNative, _CoordinatedSqliteQueryRunner_noMutationTransactionControl, _CoordinatedSqliteQueryRunner_startManagedTransaction, _CoordinatedSqliteQueryRunner_startOriginalTransaction, _CoordinatedSqliteQueryRunner_startWithWriteIntent, _CoordinatedSqliteQueryRunner_commitManagedTransaction, _CoordinatedSqliteQueryRunner_rollbackManagedTransaction, _CoordinatedSqliteQueryRunner_dispatchGuardedCommit, _CoordinatedSqliteQueryRunner_refuseCommit, _CoordinatedSqliteQueryRunner_settleCommitScope, _CoordinatedSqliteQueryRunner_withTransactionControl, _CoordinatedSqliteQueryRunner_recoverTransaction, _CoordinatedSqliteQueryRunner_recoverOwnedTransaction;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteDataSource = exports.SqliteCommitGuardRefusedError = void 0;
+exports.createSqliteDataSource = createSqliteDataSource;
+exports.registerSqliteCommitGuard = registerSqliteCommitGuard;
+exports.captureSqliteNoMutationWindow = captureSqliteNoMutationWindow;
+exports.observeSqliteOuterOutcome = observeSqliteOuterOutcome;
+exports.hasCurrentSqliteConnectionLease = hasCurrentSqliteConnectionLease;
+exports.isSqliteTransactionActive = isSqliteTransactionActive;
+exports.outsideSqliteTransaction = outsideSqliteTransaction;
+const node_async_hooks_1 = require("node:async_hooks");
+const node_util_1 = require("node:util");
+const typeorm_1 = require("typeorm");
+const SqliteQueryRunner_1 = require("typeorm/driver/sqlite/SqliteQueryRunner");
+class SqliteCommitGuardRefusedError extends Error {
+    constructor(cause) {
+        super('SQLite outer COMMIT admission was refused before native submission', { cause });
+        this.name = 'SqliteCommitGuardRefusedError';
+    }
+}
+exports.SqliteCommitGuardRefusedError = SqliteCommitGuardRefusedError;
+const leaseReleases = new WeakMap();
+const nestedWakes = new WeakMap();
+const nestedWaiters = new WeakMap();
+const abortResolvers = new WeakMap();
+const blockedRefusals = new WeakMap();
+const queryDispatchFailures = new WeakMap();
+const nativeActions = new WeakMap();
+function tailWaiters(tail) {
+    let waiters = nestedWaiters.get(tail);
+    if (!waiters)
+        nestedWaiters.set(tail, (waiters = new Set()));
+    return waiters;
+}
+const noMutationCounterLimit = (1n << 64n) - 1n;
+function isSqliteTransactionControl(sql) {
+    const command = sql.replace(/^(?:\s|;|--[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\/)*/, '');
+    return /^(BEGIN|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i.test(command);
+}
+function isNoMutationRead(sql, tables) {
+    if (typeof sql !== 'string')
+        return false;
+    const tokens = [];
+    const pattern = /\s+|"(?:[^"]|"")*"|`(?:[^`]|``)*`|\[(?:[^\]])*\]|'(?:[^']|'')*'|\?(?:\d+)?|[:@$][A-Za-z_][A-Za-z_0-9]*|(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?|[A-Za-z_][A-Za-z_0-9]*|<>|!=|<=|>=|\|\||[(),.*+/%=<>-]/gy;
+    let offset = 0;
+    while (offset < sql.length) {
+        pattern.lastIndex = offset;
+        const match = pattern.exec(sql);
+        if (!match || sql.includes('\0'))
+            return false;
+        offset = pattern.lastIndex;
+        const text = match[0];
+        if ((text === '-' && sql[offset] === '-') || (text === '/' && sql[offset] === '*'))
+            return false;
+        if (/^\s+$/.test(text))
+            continue;
+        const kind = /^["`[]/.test(text)
+            ? 'identifier'
+            : /^[A-Za-z_]/.test(text)
+                ? 'word'
+                : /^[?'\d.:@$]/.test(text)
+                    ? 'literal'
+                    : 'symbol';
+        tokens.push({ text, kind });
+    }
+    let index = 0;
+    const peek = () => tokens[index]?.text.toUpperCase();
+    const take = (text) => {
+        if (peek() !== text)
+            return false;
+        index++;
+        return true;
+    };
+    const need = (text) => {
+        if (!take(text))
+            throw new Error('syntax');
+    };
+    const reserved = new Set('SELECT FROM WHERE JOIN LEFT RIGHT INNER OUTER CROSS ON AS DISTINCT AND OR NOT IS NULL TRUE FALSE BETWEEN IN ORDER BY GROUP HAVING LIMIT OFFSET ASC DESC UNION EXCEPT INTERSECT CASE WHEN THEN ELSE END COLLATE'.split(' '));
+    const identifier = () => {
+        const token = tokens[index++];
+        if (!token || (token.kind !== 'identifier' && (token.kind !== 'word' || reserved.has(token.text.toUpperCase()))))
+            throw new Error('identifier');
+        return token.kind === 'identifier' ? token.text.slice(1, -1).replace(/""/g, '"').replace(/``/g, '`') : token.text;
+    };
+    const alias = () => {
+        if (take('AS'))
+            identifier();
+        else if (tokens[index]?.kind === 'identifier' || (tokens[index]?.kind === 'word' && !reserved.has(peek())))
+            identifier();
+    };
+    const list = (operation) => {
+        operation();
+        while (take(','))
+            operation();
+    };
+    const expression = (minimum = 0) => {
+        if (take('NOT') || take('+') || take('-'))
+            expression(7);
+        else if (take('(')) {
+            if (peek() === 'SELECT')
+                select();
+            else
+                expression();
+            need(')');
+        }
+        else if (tokens[index]?.kind === 'literal' || ['NULL', 'TRUE', 'FALSE'].includes(peek()))
+            index++;
+        else if (take('*')) {
+        }
+        else {
+            const token = tokens[index];
+            const name = identifier();
+            if (take('(')) {
+                if (token.kind !== 'word' || name.toUpperCase() !== 'COUNT')
+                    throw new Error('function');
+                take('DISTINCT');
+                expression();
+                need(')');
+            }
+            else if (take('.')) {
+                if (!take('*'))
+                    identifier();
+                if (peek() === '(')
+                    throw new Error('qualified function');
+            }
+        }
+        while (true) {
+            const op = peek();
+            const precedence = op === 'OR'
+                ? 1
+                : op === 'AND'
+                    ? 2
+                    : ['=', '!=', '<>', '<', '>', '<=', '>=', 'IS', 'IN', 'BETWEEN', 'NOT'].includes(op)
+                        ? 3
+                        : ['+', '-', '||'].includes(op)
+                            ? 4
+                            : ['*', '/', '%'].includes(op)
+                                ? 5
+                                : 0;
+            if (!precedence || precedence <= minimum)
+                return;
+            index++;
+            let comparison = op;
+            if (op === 'NOT') {
+                comparison = peek();
+                if (!['IN', 'BETWEEN'].includes(comparison))
+                    throw new Error('not');
+                index++;
+            }
+            if (comparison === 'IS')
+                take('NOT');
+            if (comparison === 'IN') {
+                need('(');
+                if (peek() === 'SELECT')
+                    select();
+                else if (peek() !== ')')
+                    list(() => expression());
+                need(')');
+            }
+            else if (comparison === 'BETWEEN') {
+                expression(3);
+                need('AND');
+                expression(3);
+            }
+            else
+                expression(precedence);
+        }
+    };
+    const source = () => {
+        if (take('(')) {
+            select();
+            need(')');
+        }
+        else {
+            const table = identifier();
+            if (!tables.has(table) || table.toLowerCase().startsWith('pragma_') || peek() === '(' || peek() === '.')
+                throw new Error('table');
+        }
+        alias();
+    };
+    const select = () => {
+        need('SELECT');
+        take('DISTINCT');
+        list(() => {
+            expression();
+            alias();
+        });
+        if (take('FROM')) {
+            source();
+            while (true) {
+                if (take(',')) {
+                    source();
+                    continue;
+                }
+                const join = take('LEFT') || take('INNER') || take('CROSS');
+                if (join)
+                    take('OUTER');
+                if (!take('JOIN')) {
+                    if (join)
+                        throw new Error('join');
+                    break;
+                }
+                source();
+                if (take('ON'))
+                    expression();
+            }
+        }
+        if (take('WHERE'))
+            expression();
+        if (take('GROUP')) {
+            need('BY');
+            list(() => expression());
+        }
+        if (take('HAVING'))
+            expression();
+        if (take('ORDER')) {
+            need('BY');
+            list(() => {
+                expression();
+                if (!take('ASC'))
+                    take('DESC');
+            });
+        }
+        if (take('LIMIT')) {
+            expression();
+            if (take(',') || take('OFFSET'))
+                expression();
+        }
+    };
+    try {
+        select();
+        return index === tokens.length;
+    }
+    catch {
+        return false;
+    }
+}
+class SqliteConnectionCoordinator {
+    constructor() {
+        this.context = new node_async_hooks_1.AsyncLocalStorage();
+        this.queue = [];
+        this.contexts = new Set();
+        this.closed = false;
+        this.acquisitionTimeoutMs = 5_000;
+    }
+    get isClosed() {
+        return this.closed;
+    }
+    configure(options) {
+        if (options.acquisitionTimeoutMs !== undefined) {
+            if (!Number.isFinite(options.acquisitionTimeoutMs) || options.acquisitionTimeoutMs <= 0) {
+                throw new Error('SQLite acquisition timeout must be a positive finite number');
+            }
+            this.acquisitionTimeoutMs = options.acquisitionTimeoutMs;
+        }
+    }
+    assertAvailable() {
+        if (this.closed)
+            throw new Error('SQLite DataSource has been destroyed; create a new DataSource instance');
+        if (this.failure)
+            throw this.failure;
+    }
+    close() {
+        this.closed = true;
+        if (this.owner)
+            this.owner.active = false;
+        this.owner = undefined;
+        this.rejectWaiters(new Error('SQLite DataSource was destroyed while waiting for connection ownership'));
+    }
+    get currentRunner() {
+        const context = this.context.getStore();
+        return context?.lease?.active ? context.lease.runner : undefined;
+    }
+    get isTransactionActive() {
+        return this.owner?.runner.isTransactionActive ?? false;
+    }
+    detach(operation) {
+        return this.context.exit(operation);
+    }
+    acquire(runner) {
+        this.assertAvailable();
+        return new Promise((resolve, reject) => {
+            const waiter = { runner, resolve, reject };
+            waiter.timer = setTimeout(() => {
+                const index = this.queue.indexOf(waiter);
+                if (index === -1)
+                    return;
+                this.queue.splice(index, 1);
+                reject(new Error(`Timed out after ${this.acquisitionTimeoutMs}ms waiting for SQLite connection ownership. ` +
+                    'Use runner.manager inside manual transactions; do not await independent database work or acquire other locks while holding a transaction.'));
+            }, this.acquisitionTimeoutMs);
+            this.queue.push(waiter);
+            this.admitNext();
+        });
+    }
+    admitNext() {
+        if (this.owner || this.closed || this.failure)
+            return;
+        const waiter = this.queue.shift();
+        if (!waiter)
+            return;
+        clearTimeout(waiter.timer);
+        const lease = { runner: waiter.runner, active: true };
+        leaseReleases.set(lease, () => {
+            if (!lease.active)
+                return;
+            lease.active = false;
+            if (this.owner === lease)
+                this.owner = undefined;
+            this.admitNext();
+        });
+        this.owner = lease;
+        waiter.resolve(lease);
+    }
+    rejectWaiters(error) {
+        for (const waiter of this.queue.splice(0)) {
+            clearTimeout(waiter.timer);
+            waiter.reject(error);
+        }
+    }
+    run(lease, operation) {
+        this.assertAvailable();
+        if (lease?.aborted)
+            throw lease.aborted;
+        if (!lease?.active)
+            return operation();
+        return this.runContext(this.createContext(lease), operation);
+    }
+    createContext(lease) {
+        const parent = this.context.getStore();
+        return {
+            lease,
+            parent: parent?.lease === lease ? parent : undefined,
+            active: true,
+            accepting: true,
+            children: { finished: true },
+            completion: undefined,
+            operations: new Map(),
+        };
+    }
+    runContext(context, operation) {
+        let complete, fail;
+        context.completion = new Promise((resolve, reject) => {
+            complete = resolve;
+            fail = reject;
+        });
+        void context.completion.catch(() => undefined);
+        const recordFailure = context.lease.runner.captureOwnFailureRecorder(context.lease);
+        this.contexts.add(context);
+        const result = this.context.run(context, async () => {
+            try {
+                const value = await operation();
+                await this.drainOperations(context, true, true);
+                return value;
+            }
+            catch (error) {
+                if (!context.nested?.refusal) {
+                    recordFailure?.(error);
+                    context.lease.runner.recordEarlyChildFailure(context.lease, error);
+                }
+                await this.drainOperations(context, false, true);
+                throw error;
+            }
+            finally {
+                context.active = false;
+            }
+        });
+        const retire = () => {
+            this.contexts.delete(context);
+            if (context.lease.closing)
+                context.lease.runner.releaseIfSettled();
+        };
+        void result.then(() => {
+            complete();
+            retire();
+        }, (cause) => {
+            fail(cause);
+            retire();
+        });
+        return result;
+    }
+    track(operation, nested = false) {
+        let parent = this.context.getStore();
+        if (!parent?.lease.active)
+            return operation();
+        const lease = parent.lease;
+        while (!parent.active || !parent.accepting) {
+            parent = parent.parent;
+            if (!parent || parent.lease !== lease) {
+                return Promise.reject(new Error('SQLite operation requires an active owning context on its original lease'));
+            }
+        }
+        const owner = parent;
+        const child = this.createContext(lease);
+        if (nested)
+            child.nested = this.prepareNested(owner, child);
+        const recordFailure = owner.lease.runner.captureChildFailureRecorder(owner.lease);
+        const promise = this.runContext(child, nested ? () => this.runNested(operation, owner) : operation);
+        owner.operations.set(promise, child);
+        void promise.then(() => owner.operations.delete(promise), (cause) => {
+            if (!child.nested?.refusal)
+                recordFailure?.(cause);
+            owner.operations.delete(promise);
+        });
+        return promise;
+    }
+    captureCommitContext(lease) {
+        const context = this.context.getStore();
+        if (!context?.active || context.lease !== lease || !lease.active || this.owner !== lease) {
+            throw new Error('SQLite COMMIT guard requires its current owning connection lease');
+        }
+        return context;
+    }
+    hasOutstanding(context) {
+        const ancestors = new Set();
+        for (let current = context; current; current = current.parent)
+            ancestors.add(current);
+        for (const candidate of this.contexts) {
+            if (candidate.lease !== context.lease)
+                continue;
+            if (!ancestors.has(candidate))
+                return true;
+            for (const child of candidate.operations.values())
+                if (!ancestors.has(child))
+                    return true;
+        }
+        return false;
+    }
+    isCurrent(context) {
+        return context?.active && this.context.getStore() === context;
+    }
+    async drainCommitChildren(context, dispatch, propagateFailure = true) {
+        let failure;
+        while (true) {
+            this.assertAvailable();
+            if (!context.active || !context.lease.active || this.owner !== context.lease) {
+                throw new Error('SQLite guarded COMMIT lease expired');
+            }
+            const ancestors = new Set();
+            for (let ancestor = context; ancestor; ancestor = ancestor.parent) {
+                ancestors.add(ancestor);
+            }
+            const children = new Set();
+            for (const candidate of this.contexts) {
+                if (candidate.lease !== context.lease)
+                    continue;
+                if (!ancestors.has(candidate))
+                    children.add(candidate.completion);
+                for (const [promise, child] of candidate.operations) {
+                    if (!ancestors.has(child))
+                        children.add(promise);
+                }
+            }
+            if (children.size === 0) {
+                if (propagateFailure && failure)
+                    throw failure.cause;
+                dispatch();
+                return;
+            }
+            const results = await Promise.allSettled(children);
+            const failed = results.find((result) => result.status === 'rejected');
+            if (failed?.status === 'rejected')
+                failure ??= { cause: failed.reason };
+        }
+    }
+    async drainCurrent(propagateFailure = true) {
+        const context = this.context.getStore();
+        if (context?.lease.active)
+            await this.drainOperations(context, propagateFailure);
+    }
+    markFailedStart() {
+        const context = this.context.getStore();
+        if (context?.lease.active && context.managedStart)
+            context.failedStart = true;
+    }
+    async managedTransaction(args, invoke) {
+        const context = this.context.getStore();
+        const callbackIndex = typeof args[0] === 'function' ? 0 : 1;
+        const callback = args[callbackIndex];
+        const wrappedArgs = [...args];
+        context.managedStart = true;
+        context.managed = true;
+        if (typeof callback === 'function') {
+            wrappedArgs[callbackIndex] = function (...callbackArgs) {
+                context.managedStart = false;
+                context.failedStart = false;
+                try {
+                    const result = Reflect.apply(callback, this, callbackArgs);
+                    const ordinary = node_util_1.types.isPromise(result) &&
+                        Object.getPrototypeOf(result) === Promise.prototype &&
+                        !Object.hasOwn(result, 'constructor') &&
+                        !Object.hasOwn(result, 'then');
+                    const observed = ordinary
+                        ? result
+                        : result !== null && (typeof result === 'object' || typeof result === 'function')
+                            ? new Promise((resolve) => resolve(result))
+                            : undefined;
+                    if (observed !== undefined)
+                        void Promise.prototype.then.call(observed, undefined, (cause) => {
+                            context.primary ??= { cause };
+                        });
+                    return observed ?? result;
+                }
+                catch (cause) {
+                    context.primary ??= { cause };
+                    throw cause;
+                }
+            };
+        }
+        try {
+            return await invoke(wrappedArgs);
+        }
+        finally {
+            context.managedStart = false;
+            context.failedStart = false;
+        }
+    }
+    consumeFailedStart() {
+        const context = this.context.getStore();
+        if (!context?.failedStart)
+            return false;
+        context.failedStart = false;
+        return true;
+    }
+    async drainOperations(context, propagateFailure = true, retire = false) {
+        while (context.operations.size > 0) {
+            const results = await Promise.allSettled([...context.operations.keys()]);
+            const failed = results.find((result) => result.status === 'rejected');
+            if (propagateFailure && failed?.status === 'rejected')
+                throw failed.reason;
+        }
+        if (retire)
+            context.accepting = false;
+    }
+    managedPrimary() {
+        for (let context = this.context.getStore(); context; context = context.parent) {
+            if (context.managed)
+                return context.primary;
+        }
+    }
+    recordManagedFailure(cause) {
+        for (let context = this.context.getStore(); context; context = context.parent) {
+            if (context.managed) {
+                context.primary ??= { cause };
+                return;
+            }
+        }
+    }
+    hasContexts(lease) {
+        return [...this.contexts].some((context) => context.lease === lease);
+    }
+    refuseQueued(lease) {
+        for (const context of this.contexts) {
+            const admission = context.nested;
+            if (context.lease !== lease || admission?.state !== 'queued')
+                continue;
+            admission.state = 'refused';
+            admission.refusal = lease.closing;
+            if (admission.previous)
+                tailWaiters(admission.previous).delete(nestedWakes.get(admission));
+            admission.previous = undefined;
+            nestedWakes.get(admission)();
+        }
+    }
+    async drainOwned(lease) {
+        await this.drainCommitChildren(this.captureCommitContext(lease), () => undefined, false);
+    }
+    prepareNested(owner, invocation) {
+        const previous = owner.children;
+        let wake;
+        const gate = new Promise((resolve) => {
+            wake = resolve;
+        });
+        const tail = { owner: invocation, finished: false };
+        const admission = { owner, invocation, previous, tail, state: 'queued', gate };
+        nestedWakes.set(admission, wake);
+        owner.children = tail;
+        if (previous.finished)
+            wake();
+        else
+            tailWaiters(previous).add(wake);
+        if (owner.lease.closing) {
+            admission.state = 'refused';
+            admission.refusal = owner.lease.closing;
+            tailWaiters(previous).delete(wake);
+            admission.previous = undefined;
+            wake();
+        }
+        return admission;
+    }
+    async runNested(operation, owner = this.context.getStore()) {
+        if (!owner?.lease.active)
+            return operation();
+        const admission = this.context.getStore().nested;
+        const { gate, tail } = admission;
+        const wake = nestedWakes.get(admission);
+        try {
+            await gate;
+            if (owner.lease.closing) {
+                admission.state = 'refused';
+                admission.refusal = owner.lease.closing;
+                await admission.refusal.ready;
+                throw admission.refusal.reason.cause;
+            }
+            if (!owner.lease.active)
+                throw new Error('Nested SQLite original lease expired');
+            admission.state = 'started';
+            return await this.run(owner.lease, operation);
+        }
+        finally {
+            if (admission.previous)
+                tailWaiters(admission.previous).delete(wake);
+            admission.previous = undefined;
+            admission.state = 'finished';
+            tail.finished = true;
+            for (const signal of tailWaiters(tail))
+                signal();
+            tailWaiters(tail).clear();
+            tail.owner = undefined;
+        }
+    }
+    poison(error) {
+        this.failure = new Error('SQLite transaction recovery failed; create a new DataSource to replace this connection', {
+            cause: error,
+        });
+        this.rejectWaiters(this.failure);
+    }
+}
+const managedLifecycles = new WeakMap();
+const coordinators = new WeakMap();
+function coordinatorFor(dataSource) {
+    let coordinator = coordinators.get(dataSource);
+    if (!coordinator) {
+        coordinator = new SqliteConnectionCoordinator();
+        coordinators.set(dataSource, coordinator);
+    }
+    return coordinator;
+}
+function configureSqliteSchemaComparison(driver) {
+    const normalizeType = driver.normalizeType.bind(driver);
+    const findChangedColumns = driver.findChangedColumns.bind(driver);
+    driver.normalizeType = (column) => ('enum' in column && column.enum ? 'varchar' : normalizeType(column));
+    driver.findChangedColumns = (tableColumns, columnMetadatas) => {
+        const changed = new Set(findChangedColumns(tableColumns, columnMetadatas));
+        return [...new Set(columnMetadatas)].filter((column) => changed.has(column) ||
+            tableColumns.some((loaded) => loaded.name === column.databaseName && Boolean(loaded.enum) !== Boolean(column.enum)));
+    };
+}
+class SqliteDataSource extends typeorm_1.DataSource {
+    constructor(options, coordinationOptions = {}) {
+        super(options);
+        if (options.type !== 'sqlite')
+            throw new Error('SqliteDataSource requires the sqlite driver');
+        configureSqliteSchemaComparison(this.driver);
+        const coordinator = coordinatorFor(this);
+        coordinator.configure(coordinationOptions);
+        this.driver.createQueryRunner = () => new CoordinatedSqliteQueryRunner(this.driver, coordinator);
+    }
+    async initialize() {
+        coordinatorFor(this).assertAvailable();
+        return super.initialize();
+    }
+    async destroy() {
+        coordinatorFor(this).close();
+        await super.destroy();
+    }
+    createQueryRunner(mode = 'master') {
+        return coordinatorFor(this).currentRunner ?? super.createQueryRunner(mode);
+    }
+    async transactionWithWriteIntent(callback) {
+        const coordinator = coordinatorFor(this);
+        coordinator.assertAvailable();
+        if (!this.isInitialized)
+            throw new Error('SQLite write admission requires an initialized DataSource');
+        if (coordinator.currentRunner)
+            throw new Error('SQLite write admission requires a fresh connection lease');
+        const runner = this.createQueryRunner();
+        return runner.transactionWithWriteIntent(callback);
+    }
+    createEntityManager(queryRunner) {
+        const manager = super.createEntityManager(queryRunner);
+        const coordinator = coordinatorFor(this);
+        for (const method of ['transaction', 'save', 'remove', 'softRemove', 'recover']) {
+            const original = manager[method];
+            Object.defineProperty(manager, method, {
+                value: (...args) => {
+                    const execute = async () => {
+                        const runner = (manager.queryRunner ?? this.createQueryRunner());
+                        return runner.withConnection(() => {
+                            const invoke = (parameters) => Reflect.apply(original, runner.manager, parameters);
+                            return method === 'transaction'
+                                ? coordinator.managedTransaction(args, (parameters) => managedLifecycles.get(runner)(parameters, original))
+                                : invoke(args);
+                        });
+                    };
+                    return coordinator.track(execute, method === 'transaction');
+                },
+                configurable: true,
+                writable: true,
+            });
+        }
+        return manager;
+    }
+}
+exports.SqliteDataSource = SqliteDataSource;
+function createSqliteDataSource(options) {
+    return new SqliteDataSource(options).initialize();
+}
+class CoordinatedSqliteQueryRunner extends SqliteQueryRunner_1.SqliteQueryRunner {
+    constructor(driver, coordinator) {
+        super(driver);
+        _CoordinatedSqliteQueryRunner_instances.add(this);
+        _CoordinatedSqliteQueryRunner_coordinator.set(this, void 0);
+        this.operationDepth = 0;
+        this.transactionControlDepth = 0;
+        this.terminalQuery = new node_async_hooks_1.AsyncLocalStorage();
+        this.startupQuery = new node_async_hooks_1.AsyncLocalStorage();
+        this.writeIntentRequested = false;
+        this.nativeCommitContext = new node_async_hooks_1.AsyncLocalStorage();
+        this.noMutationQuery = new node_async_hooks_1.AsyncLocalStorage();
+        this.noMutationOwnerCheck = new node_async_hooks_1.AsyncLocalStorage();
+        __classPrivateFieldSet(this, _CoordinatedSqliteQueryRunner_coordinator, coordinator, "f");
+        managedLifecycles.set(this, (args, original) => __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_managedLifecycle).call(this, args, original));
+    }
+    async withConnection(operation) {
+        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").assertAvailable();
+        const ownsLease = !this.lease?.active;
+        if (ownsLease)
+            this.lease = await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").acquire(this);
+        const lease = this.lease;
+        this.operationDepth++;
+        try {
+            return await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").run(lease, operation);
+        }
+        finally {
+            this.operationDepth--;
+            this.releaseIfSettled();
+        }
+    }
+    async query(query, parameters, useStructuredResult = false) {
+        const closing = this.lease?.active ? this.lease.closing : undefined;
+        const permit = this.terminalControlPermit;
+        this.terminalControlPermit = undefined;
+        if (closing &&
+            !((query === 'ROLLBACK' || query === 'COMMIT') &&
+                permit?.sql === query &&
+                permit?.scope === closing.scope &&
+                permit.context === __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").captureCommitContext(closing.scope.lease))) {
+            await closing.ready;
+            throw closing.reason.cause;
+        }
+        const terminal = closing
+            ? { closing, sql: query, connected: false, dispatched: false }
+            : undefined;
+        const startup = this.startupPermit === query;
+        this.startupPermit = undefined;
+        if (this.guardedCommit && !this.guardedCommit.noMutation && !startup)
+            this.guardedCommit.issuedBeforeCapture = true;
+        const entryScope = this.guardedCommit;
+        let ticket;
+        try {
+            ticket = __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_recordNoMutationAttempt).call(this, query);
+            if (this.writeAdmission) {
+                const permitted = this.writeAdmission === 'armed' && query === 'BEGIN IMMEDIATE TRANSACTION';
+                this.writeAdmission = 'pending';
+                if (!permitted) {
+                    return __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").track(() => Promise.reject(new Error('SQLite write admission forbids queries before BEGIN acknowledgement')));
+                }
+            }
+            const command = query.replace(/^(?:\s|;|--[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\/)*/, '');
+            if (this.transactionControlDepth === 0 && /^(BEGIN|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i.test(command)) {
+                throw new Error('Use QueryRunner transaction methods for SQLite transaction control');
+            }
+            const scope = this.guardedCommit;
+            if ((scope?.guards.length || scope?.noMutation) && (scope.phase === 'sealed' || scope.phase === 'submitted')) {
+                const cause = new Error('SQLite guarded COMMIT is sealed against new candidate queries');
+                if (scope.noMutation)
+                    scope.noMutation.anomaly ??= { cause };
+                throw cause;
+            }
+            const outerCommit = command === 'COMMIT' && this.transactionDepth === 1 ? scope : undefined;
+            const invoke = () => {
+                if (terminal)
+                    terminal.context = __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").captureCommitContext(terminal.closing.scope.lease);
+                return this.terminalQuery.run(terminal, () => this.nativeCommitContext.run(outerCommit, () => super.query(query, parameters, useStructuredResult)));
+            };
+            if (!ticket)
+                return __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").track(() => this.withConnection(() => this.startupQuery.run({ connected: !startup }, invoke)));
+            return await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").track(() => this.withConnection(async () => {
+                try {
+                    if (ticket.scope.noMutation.terminal && !ticket.cleanup && query !== 'COMMIT')
+                        return await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_blockedQuery).call(this, ticket);
+                    const failed = new Promise((_resolve, reject) => {
+                        queryDispatchFailures.set(ticket, reject);
+                    });
+                    const original = this.noMutationQuery.run(ticket, () => invoke());
+                    return (await Promise.race([original, failed]));
+                }
+                catch (cause) {
+                    __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_captureQueryFailure).call(this, ticket, cause);
+                    throw cause;
+                }
+                finally {
+                    if (ticket) {
+                        ticket.active = false;
+                        ticket.sql = undefined;
+                        queryDispatchFailures.delete(ticket);
+                        ticket.scope.noMutation?.pending.delete(ticket);
+                    }
+                }
+            }));
+        }
+        catch (cause) {
+            __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_retainQueryRefusal).call(this, entryScope, cause);
+            throw cause;
+        }
+        finally {
+            if (ticket) {
+                ticket.active = false;
+                ticket.sql = undefined;
+                queryDispatchFailures.delete(ticket);
+                ticket.scope.noMutation?.pending.delete(ticket);
+            }
+        }
+    }
+    captureNoMutationWindow(manager, ownerCurrent) {
+        const receipt = this.observeOuterOutcome(manager);
+        const scope = this.guardedCommit;
+        if (scope.noMutation)
+            throw new Error('Original SQLite no-mutation window already exists');
+        const evidence = {
+            queue: [],
+            physical: () => false,
+            decision: 'undecided',
+            attempts: 0n,
+            mutations: 0n,
+            pending: new Set(),
+            current: () => false,
+            pinned: () => false,
+            read: () => false,
+        };
+        scope.noMutation = evidence;
+        blockedRefusals.set(evidence, []);
+        try {
+            const source = this.connection, driver = this.driver;
+            const native = driver.databaseConnection;
+            const all = native.all, run = native.run;
+            Object.assign(evidence, {
+                native,
+                all,
+                run,
+                physical: () => scope === this.guardedCommit &&
+                    scope.lease === this.lease &&
+                    scope.lease.active &&
+                    !__classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").isClosed &&
+                    source.isInitialized &&
+                    this.connection === source &&
+                    this.driver === driver &&
+                    driver.databaseConnection === native &&
+                    native.all === all &&
+                    native.run === run &&
+                    manager === this.manager &&
+                    manager.queryRunner === this &&
+                    manager.connection === source,
+            });
+            if (scope.issuedBeforeCapture)
+                throw new Error('SQLite no-mutation capture must precede candidate query/connect issuance');
+            this.registerCommitGuard(manager, () => {
+                if (evidence.decision !== 'applied' && evidence.decision !== 'unchanged')
+                    throw new SqliteCommitGuardRefusedError(evidence.anomaly?.cause);
+                return true;
+            });
+            const context = __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").captureCommitContext(scope.lease);
+            evidence.owner = context;
+            const pin = (target, keys) => {
+                const prototype = Object.getPrototypeOf(target);
+                const descriptor = (key) => {
+                    for (let owner = target; owner; owner = Object.getPrototypeOf(owner)) {
+                        const value = Object.getOwnPropertyDescriptor(owner, key);
+                        if (value)
+                            return { owner, value };
+                    }
+                    return undefined;
+                };
+                const fields = keys.map((key) => descriptor(key));
+                if (fields.some((field) => field && !('value' in field.value)))
+                    throw new Error('SQLite original dispatch accessor is unsupported');
+                return () => Object.getPrototypeOf(target) === prototype &&
+                    keys.every((key, index) => {
+                        const before = fields[index], after = descriptor(key);
+                        return before === undefined
+                            ? after === undefined
+                            : after !== undefined &&
+                                before.owner === after.owner &&
+                                'value' in after.value &&
+                                ['value', 'writable', 'enumerable', 'configurable'].every((field) => before.value[field] === after.value[field]);
+                    });
+            };
+            const sourcePin = pin(source, ['isInitialized', 'driver', 'manager', 'query', 'createQueryRunner']);
+            const driverPin = pin(driver, ['databaseConnection', 'connection']);
+            const runnerPin = pin(this, [
+                'query',
+                'connect',
+                'startTransaction',
+                'commitTransaction',
+                'rollbackTransaction',
+                'release',
+                'manager',
+                'connection',
+                'driver',
+                'broadcaster',
+            ]);
+            const managerPin = pin(manager, ['queryRunner', 'connection', 'query']);
+            const broadcasterPin = pin(this.broadcaster, [
+                'broadcast',
+                'broadcastBeforeQueryEvent',
+                'broadcastBeforeTransactionCommitEvent',
+            ]);
+            const nativePin = pin(native, ['all', 'run']);
+            const tables = new Set(source.entityMetadatas.filter((meta) => meta.tableType !== 'view').map((meta) => meta.tableName));
+            Object.assign(evidence, {
+                native,
+                all,
+                run,
+                read: (sql) => isNoMutationRead(sql, tables),
+                physical: () => scope === this.guardedCommit &&
+                    scope.lease === this.lease &&
+                    scope.lease.active &&
+                    !__classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").isClosed &&
+                    source.isInitialized &&
+                    this.connection === source &&
+                    this.driver === driver &&
+                    driver.databaseConnection === native &&
+                    nativePin() &&
+                    manager === this.manager &&
+                    manager.queryRunner === this &&
+                    manager.connection === source,
+                current: () => evidence.pinned() &&
+                    this.noMutationOwnerCheck.run(scope, ownerCurrent) &&
+                    (!evidence.finalValidation || evidence.pinned()),
+                pinned: () => runnerPin() &&
+                    managerPin() &&
+                    sourcePin() &&
+                    driverPin() &&
+                    nativePin() &&
+                    broadcasterPin() &&
+                    scope === this.guardedCommit &&
+                    scope.lease === this.lease &&
+                    scope.lease.active &&
+                    context.active &&
+                    __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").currentRunner === this &&
+                    !__classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").isClosed &&
+                    source.isInitialized &&
+                    this.connection === source &&
+                    this.driver === driver &&
+                    driver.databaseConnection === native &&
+                    native.all === all &&
+                    native.run === run &&
+                    nativePin() &&
+                    this.transactionDepth >= 1 &&
+                    (!evidence.finalValidation || this.transactionDepth === 1) &&
+                    this.isTransactionActive &&
+                    manager === this.manager &&
+                    manager.queryRunner === this &&
+                    manager.connection === source &&
+                    runnerPin() &&
+                    managerPin() &&
+                    broadcasterPin(),
+            });
+            const refuse = () => {
+                evidence.decision = 'refused';
+                throw new SqliteCommitGuardRefusedError(evidence.anomaly?.cause);
+            };
+            const clean = () => __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_checkNoMutationPins).call(this, evidence) && !evidence.anomaly && evidence.mutations === 0n;
+            if (!clean())
+                refuse();
+            const thisRunnerCurrent = () => __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_checkNoMutationPins).call(this, evidence);
+            const finalReady = () => {
+                try {
+                    return (scope.phase === 'open' &&
+                        scope.managedOwner === context &&
+                        !evidence.ownerControlAttempted &&
+                        this.transactionDepth === 1 &&
+                        this.isTransactionActive &&
+                        evidence.pinned() &&
+                        !scope.lease.closing &&
+                        !scope.lease.aborted &&
+                        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").captureCommitContext(scope.lease) === context &&
+                        !__classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").hasOutstanding(context) &&
+                        !__classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").managedPrimary() &&
+                        !scope.childFailure &&
+                        !evidence.anomaly &&
+                        !evidence.terminal &&
+                        !evidence.pending.size &&
+                        !evidence.inFlight &&
+                        !evidence.queue.length &&
+                        !evidence.reservation &&
+                        evidence.attempts < noMutationCounterLimit &&
+                        evidence.mutations < noMutationCounterLimit);
+                }
+                catch {
+                    return false;
+                }
+            };
+            const activate = () => {
+                if (scope !== this.guardedCommit ||
+                    !scope.lease.active ||
+                    scope.phase === 'committed' ||
+                    scope.phase === 'settled')
+                    throw new SqliteCommitGuardRefusedError();
+                const repeated = evidence.finalValidation;
+                evidence.finalValidation = true;
+                if (repeated ||
+                    evidence.decision !== 'undecided' ||
+                    !finalReady() ||
+                    !thisRunnerCurrent() ||
+                    !finalReady() ||
+                    evidence.decision !== 'undecided') {
+                    const cause = __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_nativeDispatchRefusal).call(this, scope, scope.childFailure
+                        ? scope.childFailure.cause
+                        : evidence.anomaly
+                            ? evidence.anomaly.cause
+                            : new Error('SQLite final validation requires its settled original outer scope'));
+                    evidence.decision = 'refused';
+                    throw cause;
+                }
+            };
+            let checkpoint, reserved = false;
+            return Object.freeze({
+                beginFinalValidation: activate,
+                async reserveZeroRows(table, column) {
+                    if (evidence.finalValidation ||
+                        reserved ||
+                        checkpoint ||
+                        evidence.decision !== 'undecided' ||
+                        !/^[A-Za-z_][A-Za-z_0-9]*$/.test(table) ||
+                        !/^[A-Za-z_][A-Za-z_0-9]*$/.test(column) ||
+                        !clean())
+                        refuse();
+                    reserved = true;
+                    const sql = `UPDATE "${table}" SET "${column}"="${column}" WHERE 0`;
+                    evidence.reservation = sql;
+                    try {
+                        await manager.query(sql);
+                    }
+                    finally {
+                        evidence.reservation = undefined;
+                    }
+                },
+                beginReads() {
+                    if (evidence.finalValidation ||
+                        checkpoint ||
+                        evidence.decision !== 'undecided' ||
+                        evidence.pending.size ||
+                        !clean())
+                        refuse();
+                    checkpoint = Object.freeze({ kind: 'sqlite-read-checkpoint' });
+                    return checkpoint;
+                },
+                armUnchanged(candidate) {
+                    if (evidence.finalValidation ||
+                        !checkpoint ||
+                        candidate !== checkpoint ||
+                        evidence.decision !== 'undecided' ||
+                        evidence.pending.size ||
+                        !clean())
+                        refuse();
+                    evidence.decision = 'unchanged';
+                },
+                applied() {
+                    if (evidence.decision !== 'undecided' ||
+                        scope.phase !== 'open' ||
+                        !scope.lease.active ||
+                        evidence.terminal !== undefined ||
+                        !thisRunnerCurrent() ||
+                        (evidence.finalValidation && (!finalReady() || evidence.decision !== 'undecided')))
+                        refuse();
+                    evidence.decision = 'applied';
+                },
+                get outcome() {
+                    return receipt.outcome;
+                },
+            });
+        }
+        catch (cause) {
+            evidence.decision = 'refused';
+            evidence.anomaly ??= {
+                cause: cause instanceof SqliteCommitGuardRefusedError ? cause.cause : cause,
+            };
+            throw cause;
+        }
+    }
+    captureOwnFailureRecorder(lease) {
+        const scope = this.guardedCommit;
+        if (!scope || scope.lease !== lease)
+            return;
+        return (cause) => {
+            if (scope === this.guardedCommit &&
+                lease.active &&
+                (scope.guards.length || scope.noMutation) &&
+                scope.phase !== 'committed' &&
+                scope.phase !== 'settled' &&
+                !scope.noMutation?.terminal)
+                scope.childFailure ??= { cause };
+        };
+    }
+    recordEarlyChildFailure(lease, cause) {
+        const scope = this.guardedCommit;
+        if (scope?.lease === lease && scope.noMutation && !scope.noMutation.terminal)
+            this.captureChildFailureRecorder(lease)?.(cause);
+    }
+    async startTransaction(isolationLevel) {
+        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_assertFinalControlOrigin).call(this, 'start');
+        return __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_startManagedTransaction).call(this, isolationLevel);
+    }
+    async transactionWithWriteIntent(callback) {
+        this.writeIntentRequested = true;
+        try {
+            return await this.withConnection(() => this.manager.transaction(callback));
+        }
+        finally {
+            this.writeIntentRequested = false;
+            this.writeAdmission = undefined;
+            await this.release();
+        }
+    }
+    async commitTransaction() {
+        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_assertFinalControlOrigin).call(this, 'commit');
+        return __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_commitManagedTransaction).call(this);
+    }
+    async rollbackTransaction() {
+        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_assertFinalControlOrigin).call(this, 'rollback');
+        return __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_rollbackManagedTransaction).call(this);
+    }
+    captureChildFailureRecorder(lease) {
+        const scope = this.guardedCommit;
+        if (!scope || scope.lease !== lease || (scope.phase !== 'starting' && scope.phase !== 'open'))
+            return undefined;
+        return (cause) => {
+            if (scope === this.guardedCommit &&
+                lease.active &&
+                (scope.phase === 'starting' || scope.phase === 'open') &&
+                !scope.childFailure &&
+                !scope.noMutation?.terminal) {
+                scope.childFailure = { cause };
+            }
+        };
+    }
+    observeOuterOutcome(manager) {
+        const scope = this.guardedCommit;
+        if (manager !== this.manager ||
+            manager.queryRunner !== this ||
+            !scope ||
+            !this.isTransactionActive ||
+            this.transactionDepth !== 1 ||
+            scope.phase !== 'open') {
+            throw new Error('Native outcome observation requires its exact open outer manager');
+        }
+        scope.observed = true;
+        return Object.freeze({
+            get outcome() {
+                return scope.outcome;
+            },
+        });
+    }
+    registerCommitGuard(manager, guard) {
+        const scope = this.guardedCommit;
+        if (manager.queryRunner !== this || !scope || !this.isTransactionActive || scope.phase !== 'open') {
+            throw new Error('SQLite COMMIT guards require an open transaction on its exact scoped manager');
+        }
+        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").captureCommitContext(scope.lease);
+        scope.guards.push(guard);
+        return {
+            get outcome() {
+                return scope.outcome;
+            },
+        };
+    }
+    async connect() {
+        const entryScope = this.guardedCommit;
+        const terminal = this.terminalQuery.getStore();
+        const entryClosing = this.lease?.active ? this.lease.closing : undefined;
+        const terminalConnect = entryClosing &&
+            terminal?.closing === entryClosing &&
+            !terminal.connected &&
+            terminal.context === __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").captureCommitContext(entryClosing.scope.lease);
+        if (entryClosing && !terminalConnect) {
+            await entryClosing.ready;
+            throw entryClosing.reason.cause;
+        }
+        if (terminalConnect)
+            terminal.connected = true;
+        const entryWindow = entryScope?.noMutation && entryScope.phase !== 'committed' && entryScope.phase !== 'settled'
+            ? entryScope
+            : undefined;
+        const startup = this.startupQuery.getStore();
+        if (entryScope && !entryScope.noMutation) {
+            if (!startup || startup.connected)
+                entryScope.issuedBeforeCapture = true;
+            else
+                startup.connected = true;
+        }
+        const entryTicket = this.noMutationQuery.getStore();
+        const originalConnect = entryTicket !== undefined && !entryTicket.connected;
+        let entryRefusal;
+        if (entryWindow) {
+            entryRefusal = __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_validateNoMutationDispatch).call(this, entryWindow, entryTicket, entryTicket?.sql ?? '');
+            if (entryTicket)
+                entryTicket.connected = true;
+            if (!originalConnect)
+                entryRefusal ??= __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_nativeDispatchRefusal).call(this, entryWindow, new Error('SQLite query ticket cannot lend its native connection'));
+        }
+        const connection = (await super.connect());
+        const commitScope = this.nativeCommitContext.getStore();
+        const activeScope = this.guardedCommit;
+        const window = entryWindow ??
+            (activeScope?.noMutation && activeScope.phase !== 'committed' && activeScope.phase !== 'settled'
+                ? activeScope
+                : undefined);
+        const connectionScope = entryScope ?? activeScope;
+        const scope = commitScope ?? window ?? connectionScope;
+        const closing = scope?.lease.closing ?? (this.lease?.active ? this.lease.closing : undefined);
+        if (closing && (!terminalConnect || terminal.closing !== closing)) {
+            await closing.ready;
+            throw closing.reason.cause;
+        }
+        if (!scope)
+            return connection;
+        const ticket = this.noMutationQuery.getStore();
+        if (window)
+            entryRefusal ??= __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_validateNoMutationDispatch).call(this, window, ticket, ticket?.sql ?? '');
+        const context = commitScope || window || terminalConnect ? __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").captureCommitContext(scope.lease) : undefined;
+        const callbackContext = window ? node_async_hooks_1.AsyncLocalStorage.snapshot() : undefined;
+        return new Proxy(connection, {
+            get: (target, property) => {
+                if (property === 'all' || ((window || connectionScope) && property === 'run')) {
+                    return (...args) => {
+                        const [query, parameters] = args;
+                        const last = args[args.length - 1];
+                        const callback = typeof last === 'function' ? last : undefined;
+                        if (!window && __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_finalValidationActive).call(this, scope)) {
+                            const refusal = __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_nativeDispatchRefusal).call(this, scope, new Error('SQLite saved facade lacks its original final-validation ticket'));
+                            if (!callback)
+                                throw refusal;
+                            callback.call(target, refusal);
+                            return target;
+                        }
+                        const closing = scope.lease.closing;
+                        if (!window && closing) {
+                            if (!terminalConnect ||
+                                terminal.closing !== closing ||
+                                !scope.lease.active ||
+                                scope !== this.guardedCommit ||
+                                !terminal.context.active ||
+                                property !== 'all' ||
+                                terminal.sql !== query ||
+                                (!terminal.retry &&
+                                    (terminal !== this.terminalQuery.getStore() ||
+                                        terminal.dispatched ||
+                                        terminal.context !== __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").captureCommitContext(scope.lease)))) {
+                                const refusal = new SqliteCommitGuardRefusedError(closing.reason?.cause);
+                                if (!callback)
+                                    throw refusal;
+                                callback.call(target, refusal);
+                                return target;
+                            }
+                            terminal.dispatched = true;
+                            terminal.retry = false;
+                        }
+                        if (window) {
+                            const refusal = entryRefusal ?? __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_validateNoMutationDispatch).call(this, window, ticket, query);
+                            if (refusal ||
+                                !originalConnect ||
+                                (__classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_finalValidationActive).call(this, window) && !__classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").isCurrent(context)) ||
+                                entryScope !== window ||
+                                entryTicket !== ticket ||
+                                !ticket?.active ||
+                                ticket.scope !== window ||
+                                ticket.sql !== query ||
+                                !window.noMutation.pending.has(ticket) ||
+                                (ticket.dispatched && !ticket.retry) ||
+                                (ticket.nativeMethod !== undefined && ticket.nativeMethod !== property) ||
+                                (isSqliteTransactionControl(query) && !ticket.control)) {
+                                callback.call(target, refusal ??
+                                    __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_nativeDispatchRefusal).call(this, window, new Error('SQLite native dispatch lacks its original single-use ticket')));
+                                return target;
+                            }
+                            ticket.nativeMethod ??= property;
+                            ticket.dispatched = true;
+                            ticket.retry = false;
+                            if (query !== 'COMMIT' || !commitScope)
+                                return __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_submitNative).call(this, window, ticket, property, query, parameters, callback, callbackContext, context);
+                        }
+                        if (property !== 'all' ||
+                            query !== 'COMMIT' ||
+                            !commitScope ||
+                            (scope.guards.length === 0 && !scope.observed && !scope.noMutation)) {
+                            const original = window ? (window.noMutation[property] ?? target[property]) : target[property];
+                            if (!window && closing && query === 'ROLLBACK')
+                                return target.all(query, parameters, function (error, rows) {
+                                    if (error?.toString().includes('SQLITE_BUSY:'))
+                                        terminal.retry = true;
+                                    callback.call(this, error, rows);
+                                });
+                            return original.apply(window?.noMutation.native ?? target, args);
+                        }
+                        if (scope.guards.length === 0 && !scope.noMutation) {
+                            scope.outcome = 'unknown';
+                            return target.all(query, parameters, function (error, rows) {
+                                if (!error)
+                                    scope.outcome = 'committed';
+                                callback.call(this, error, rows);
+                            });
+                        }
+                        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_dispatchGuardedCommit).call(this, scope, context, target, query, parameters, callback);
+                        return target;
+                    };
+                }
+                const value = Reflect.get(target, property);
+                return typeof value === 'function'
+                    ? (...args) => {
+                        if (__classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_finalValidationActive).call(this, scope))
+                            throw __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_nativeDispatchRefusal).call(this, scope, new Error('Unsupported SQLite final-validation facade call'));
+                        return Reflect.apply(value, target, args);
+                    }
+                    : value;
+            },
+        });
+    }
+    async release() {
+        if (__classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").isClosed) {
+            this.isTransactionActive = false;
+            this.transactionDepth = 0;
+            await super.release();
+            return;
+        }
+        while (this.operationDepth === 0 && this.isTransactionActive)
+            await this.rollbackTransaction();
+        await super.release();
+        this.releaseIfSettled();
+    }
+    releaseIfSettled() {
+        if (this.lease?.closing)
+            __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_settleCommitScope).call(this);
+        if (this.lease &&
+            this.operationDepth === 0 &&
+            (!this.lease?.closing || !__classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").hasContexts(this.lease)) &&
+            !this.isTransactionActive &&
+            !this.guardedCommit?.noMutation?.inFlight &&
+            !this.guardedCommit?.noMutation?.queue.length &&
+            !this.guardedCommit?.noMutation?.pending.size)
+            leaseReleases.get(this.lease)();
+    }
+}
+_CoordinatedSqliteQueryRunner_coordinator = new WeakMap(), _CoordinatedSqliteQueryRunner_instances = new WeakSet(), _CoordinatedSqliteQueryRunner_managedLifecycle = function _CoordinatedSqliteQueryRunner_managedLifecycle(args, original) {
+    const lifecycle = {
+        context: __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").captureCommitContext(this.lease),
+        state: 'new',
+    };
+    const claim = async (operation, isolation) => {
+        const before = lifecycle.state;
+        if (operation === 'start'
+            ? before !== 'new'
+            : operation === 'commit'
+                ? before !== 'body'
+                : !['start-failed', 'body', 'commit-failed'].includes(before))
+            throw new Error('SQLite managed lifecycle was already claimed');
+        lifecycle.state = operation === 'start' ? 'body' : operation === 'commit' ? 'committing' : 'rolling-back';
+        try {
+            if (operation === 'start')
+                await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_startManagedTransaction).call(this, isolation, lifecycle);
+            else if (operation === 'commit')
+                await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_commitManagedTransaction).call(this, lifecycle);
+            else
+                await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_rollbackManagedTransaction).call(this, lifecycle);
+            if (operation !== 'start')
+                lifecycle.state = operation === 'commit' ? 'commit-returned' : 'terminal';
+        }
+        catch (cause) {
+            lifecycle.state =
+                operation === 'rollback' ? 'terminal' : operation === 'commit' ? 'commit-failed' : 'start-failed';
+            throw cause;
+        }
+    };
+    const released = () => this.isReleased, manager = () => this.manager;
+    const view = Object.freeze({
+        get isReleased() {
+            return released();
+        },
+        get manager() {
+            return manager();
+        },
+        startTransaction: (isolation) => claim('start', isolation),
+        commitTransaction: () => claim('commit'),
+        rollbackTransaction: () => claim('rollback'),
+    });
+    return Reflect.apply(original, Object.freeze({ queryRunner: view, connection: this.connection }), args);
+}, _CoordinatedSqliteQueryRunner_checkNoMutationPins = function _CoordinatedSqliteQueryRunner_checkNoMutationPins(evidence) {
+    try {
+        if (evidence.current() === true)
+            return true;
+    }
+    catch (cause) {
+        evidence.anomaly ??= { cause };
+    }
+    evidence.anomaly ??= { cause: new Error('Original SQLite no-mutation identity expired') };
+    return false;
+}, _CoordinatedSqliteQueryRunner_recordNoMutationAttempt = function _CoordinatedSqliteQueryRunner_recordNoMutationAttempt(sql) {
+    const scope = this.guardedCommit, evidence = scope?.noMutation;
+    if (!evidence || scope.phase === 'committed' || scope.phase === 'settled')
+        return undefined;
+    const permit = this.noMutationControl;
+    this.noMutationControl = undefined;
+    const control = permit?.scope === scope && permit.sql === sql;
+    const reservation = evidence.reservation === sql;
+    evidence.reservation = undefined;
+    if (evidence.attempts === noMutationCounterLimit || evidence.mutations === noMutationCounterLimit)
+        evidence.anomaly ??= { cause: new Error('SQLite query witness exhausted') };
+    else {
+        evidence.attempts++;
+        if ((!control || !permit.outer) && !reservation && !evidence.read(sql))
+            evidence.mutations++;
+    }
+    const refusal = __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_finalValidationRefusal).call(this, scope, sql, control && permit.outer);
+    if (refusal)
+        throw refusal;
+    if (!__classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_finalValidationActive).call(this, scope))
+        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_checkNoMutationPins).call(this, evidence);
+    if (isSqliteTransactionControl(sql) && !control) {
+        const cause = new Error('SQLite transaction control requires its original internal invocation');
+        evidence.anomaly ??= { cause };
+        throw new SqliteCommitGuardRefusedError(cause);
+    }
+    const ticket = {
+        scope,
+        sql,
+        control,
+        outer: control && permit.outer,
+        cleanup: control && permit.outer && sql === 'ROLLBACK',
+        active: true,
+        connected: false,
+        dispatched: false,
+        retry: false,
+    };
+    evidence.pending.add(ticket);
+    return ticket;
+}, _CoordinatedSqliteQueryRunner_retainQueryRefusal = function _CoordinatedSqliteQueryRunner_retainQueryRefusal(scope, cause) {
+    if (scope?.noMutation &&
+        scope === this.guardedCommit &&
+        scope.phase !== 'committed' &&
+        scope.phase !== 'settled' &&
+        !scope.noMutation.terminal) {
+        scope.childFailure ??= { cause };
+    }
+}, _CoordinatedSqliteQueryRunner_nativeDispatchRefusal = function _CoordinatedSqliteQueryRunner_nativeDispatchRefusal(scope, cause) {
+    scope.noMutation.anomaly ??= { cause };
+    const refusal = new SqliteCommitGuardRefusedError(cause);
+    __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_retainQueryRefusal).call(this, scope, refusal);
+    return refusal;
+}, _CoordinatedSqliteQueryRunner_finalValidationActive = function _CoordinatedSqliteQueryRunner_finalValidationActive(scope) {
+    return scope?.noMutation?.finalValidation && scope.phase !== 'committed' && scope.phase !== 'settled';
+}, _CoordinatedSqliteQueryRunner_finalValidationRefusal = function _CoordinatedSqliteQueryRunner_finalValidationRefusal(scope, sql, outer = false) {
+    if (!__classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_finalValidationActive).call(this, scope))
+        return;
+    if (outer && (sql === 'ROLLBACK' || sql === 'COMMIT'))
+        return;
+    const evidence = scope.noMutation;
+    if (!evidence.read(sql) ||
+        !__classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_checkNoMutationPins).call(this, evidence) ||
+        evidence.anomaly ||
+        scope.childFailure ||
+        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").managedPrimary() ||
+        evidence.decision === 'refused' ||
+        evidence.terminal ||
+        scope.lease.closing ||
+        scope.phase !== 'open')
+        return __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_nativeDispatchRefusal).call(this, scope, scope.childFailure
+            ? scope.childFailure.cause
+            : evidence.anomaly
+                ? evidence.anomaly.cause
+                : new Error('SQLite final validation admits only original closed-grammar reads'));
+}, _CoordinatedSqliteQueryRunner_assertFinalControlOrigin = function _CoordinatedSqliteQueryRunner_assertFinalControlOrigin(operation, lifecycle) {
+    const scope = this.guardedCommit;
+    const ownerCheck = scope !== undefined && this.noMutationOwnerCheck.getStore() === scope;
+    if (scope?.noMutation && !lifecycle && scope.phase !== 'committed' && scope.phase !== 'settled')
+        scope.noMutation.ownerControlAttempted = true;
+    if (!__classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_finalValidationActive).call(this, scope))
+        return;
+    let original = false;
+    try {
+        original =
+            !ownerCheck &&
+                operation !== 'start' &&
+                ((lifecycle?.scope === scope &&
+                    lifecycle.context === scope.managedOwner &&
+                    lifecycle.state === (operation === 'commit' ? 'committing' : 'rolling-back')) ||
+                    (operation === 'rollback' && !scope.managedOwner)) &&
+                (this.transactionDepth === 1 || operation === 'rollback') &&
+                scope.lease === this.lease &&
+                scope.lease.active &&
+                (!scope.managedOwner || (lifecycle?.context === scope.noMutation.owner && lifecycle.context.active));
+    }
+    catch {
+    }
+    if (!original) {
+        if (operation === 'start')
+            __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").markFailedStart();
+        throw __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_nativeDispatchRefusal).call(this, scope, new Error('SQLite final validation control requires its original outer origin'));
+    }
+}, _CoordinatedSqliteQueryRunner_validateNoMutationDispatch = function _CoordinatedSqliteQueryRunner_validateNoMutationDispatch(scope, ticket, sql) {
+    const evidence = scope.noMutation;
+    if (!evidence || scope.phase === 'committed' || scope.phase === 'settled')
+        return;
+    if (!__classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_finalValidationActive).call(this, scope))
+        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_checkNoMutationPins).call(this, evidence);
+    if (!ticket || !ticket.active || ticket.scope !== scope || ticket.sql !== sql || !evidence.pending.has(ticket))
+        return __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_nativeDispatchRefusal).call(this, scope, new Error('SQLite native dispatch lacks its original query ticket'));
+    return __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_finalValidationRefusal).call(this, scope, sql, ticket.outer);
+}, _CoordinatedSqliteQueryRunner_blockedQuery = function _CoordinatedSqliteQueryRunner_blockedQuery(ticket) {
+    const evidence = ticket.scope.noMutation;
+    return new Promise((_resolve, reject) => {
+        const finish = () => reject(new SqliteCommitGuardRefusedError(ticket.scope.childFailure ? ticket.scope.childFailure.cause : evidence.terminal?.logical?.cause));
+        if (evidence.terminal && !evidence.terminal.logical)
+            blockedRefusals.get(evidence).push(finish);
+        else
+            finish();
+    });
+}, _CoordinatedSqliteQueryRunner_beginFullAbort = function _CoordinatedSqliteQueryRunner_beginFullAbort(scope, trigger) {
+    if (!scope ||
+        scope !== this.guardedCommit ||
+        !scope.lease.active ||
+        (!scope.guards.length && !scope.noMutation) ||
+        scope.phase === 'committed')
+        return;
+    const lease = scope.lease;
+    if (lease.closing)
+        return lease.closing;
+    let resolveReason;
+    const ready = new Promise((resolve) => {
+        resolveReason = resolve;
+    });
+    const terminal = scope.noMutation?.terminal;
+    let reason = __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").managedPrimary() ?? scope.childFailure ?? terminal?.logical;
+    if (!reason && !terminal)
+        reason = trigger;
+    if (!reason && !terminal) {
+        const cause = new Error('Queued nested SQLite transaction was refused because its owning transaction is closing');
+        cause.name = 'SqliteNestedTransactionAbortedError';
+        reason = { cause };
+    }
+    const closing = { scope, reason, ready };
+    abortResolvers.set(closing, resolveReason);
+    lease.closing = closing;
+    __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").refuseQueued(lease);
+    if (reason)
+        resolveReason();
+    return closing;
+}, _CoordinatedSqliteQueryRunner_captureQueryFailure = function _CoordinatedSqliteQueryRunner_captureQueryFailure(ticket, cause) {
+    const scope = ticket.scope, evidence = scope.noMutation;
+    if (evidence.terminal?.origin === ticket && !evidence.terminal.logical) {
+        evidence.terminal.logical = { cause };
+        const closing = scope.lease.closing;
+        if (closing?.scope === scope && !closing.reason) {
+            closing.reason = { cause };
+            abortResolvers.get(closing)();
+        }
+        scope.childFailure ??= { cause };
+        for (const finish of blockedRefusals.get(evidence).splice(0))
+            finish();
+        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_pumpNative).call(this, scope);
+    }
+    else if (!evidence.terminal)
+        this.captureChildFailureRecorder(scope.lease)?.(cause);
+}, _CoordinatedSqliteQueryRunner_latchNativeFailure = function _CoordinatedSqliteQueryRunner_latchNativeFailure(ticket, cause) {
+    ticket.scope.noMutation.terminal ??= { nativeCause: cause, origin: ticket };
+    __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_beginFullAbort).call(this, ticket.scope);
+}, _CoordinatedSqliteQueryRunner_pumpNative = function _CoordinatedSqliteQueryRunner_pumpNative(scope) {
+    const evidence = scope.noMutation;
+    if (evidence.inFlight || (evidence.terminal && !evidence.terminal.logical))
+        return;
+    const envelope = evidence.queue.shift();
+    if (!envelope)
+        return;
+    nativeActions.get(envelope).context(() => __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_dispatchQueued).call(this, scope, envelope));
+}, _CoordinatedSqliteQueryRunner_dispatchQueued = function _CoordinatedSqliteQueryRunner_dispatchQueued(scope, envelope) {
+    const evidence = scope.noMutation;
+    const ticket = envelope.ticket;
+    const actions = nativeActions.get(envelope);
+    let physical = false;
+    try {
+        physical = evidence.physical();
+    }
+    catch (cause) {
+        evidence.anomaly ??= { cause };
+    }
+    if ((!ticket.cleanup && evidence.terminal) ||
+        !ticket.active ||
+        !evidence.pending.has(ticket) ||
+        ticket.scope !== this.guardedCommit ||
+        !scope.lease.active ||
+        !envelope.context.active ||
+        envelope.context.lease !== scope.lease ||
+        !physical) {
+        actions.refuse(new SqliteCommitGuardRefusedError(scope.childFailure?.cause));
+        queueMicrotask(() => __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_pumpNative).call(this, scope));
+        return;
+    }
+    const mismatch = ticket.sql !== envelope.query ||
+        ticket.nativeMethod !== envelope.property ||
+        !ticket.connected ||
+        !ticket.dispatched ||
+        envelope.query === 'COMMIT' ||
+        (isSqliteTransactionControl(envelope.query) && !ticket.control);
+    const refusal = mismatch
+        ? __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_nativeDispatchRefusal).call(this, scope, scope.childFailure
+            ? scope.childFailure.cause
+            : evidence.anomaly
+                ? evidence.anomaly.cause
+                : new Error('SQLite queued native SQL lacks its exact original ticket'))
+        : __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_finalValidationActive).call(this, scope)
+            ? __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_validateNoMutationDispatch).call(this, scope, ticket, envelope.query)
+            : undefined;
+    if (refusal || (__classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_finalValidationActive).call(this, scope) && !evidence.physical())) {
+        actions.refuse(refusal ?? __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_nativeDispatchRefusal).call(this, scope, new Error('SQLite final physical identity expired')));
+        queueMicrotask(() => __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_pumpNative).call(this, scope));
+        return;
+    }
+    evidence.inFlight = envelope;
+    actions.submit();
+}, _CoordinatedSqliteQueryRunner_submitNative = function _CoordinatedSqliteQueryRunner_submitNative(scope, ticket, property, query, parameters, callback, callbackContext, context) {
+    const evidence = scope.noMutation, native = evidence.native;
+    const original = evidence[property];
+    let finished = false;
+    const deliver = (receiver, args, nativeCompletion = true) => {
+        if (finished)
+            return;
+        finished = true;
+        const error = args[0];
+        if (error?.toString().includes('SQLITE_BUSY:'))
+            ticket.retry = true;
+        else if (error && nativeCompletion && !ticket.cleanup)
+            __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_latchNativeFailure).call(this, ticket, error);
+        try {
+            callbackContext(() => Reflect.apply(callback, receiver, args));
+        }
+        finally {
+            if (evidence.inFlight === envelope)
+                evidence.inFlight = undefined;
+            queueMicrotask(() => __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_pumpNative).call(this, scope));
+        }
+    };
+    const envelope = Object.freeze({ ticket, context, query, property });
+    nativeActions.set(envelope, {
+        context: callbackContext,
+        refuse: (cause) => deliver(native, [cause], false),
+        submit: () => {
+            try {
+                original.call(native, query, parameters, function (...args) {
+                    deliver(this, args);
+                });
+            }
+            catch (cause) {
+                if (finished)
+                    throw cause;
+                finished = true;
+                __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_latchNativeFailure).call(this, ticket, cause);
+                if (evidence.inFlight === envelope)
+                    evidence.inFlight = undefined;
+                queryDispatchFailures.get(ticket)(cause);
+            }
+        },
+    });
+    evidence.queue.push(envelope);
+    __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_pumpNative).call(this, scope);
+    return native;
+}, _CoordinatedSqliteQueryRunner_noMutationTransactionControl = async function _CoordinatedSqliteQueryRunner_noMutationTransactionControl(operation, isolation, lifecycle) {
+    const originalOuter = operation !== 'start' && this.transactionDepth === 1;
+    if (operation === 'start') {
+        if (this.driver.transactionSupport === 'none')
+            throw new typeorm_1.TypeORMError(`Transactions aren't supported by ${this.connection.driver.options.type}.`);
+        if (this.isTransactionActive && this.driver.transactionSupport === 'simple')
+            throw new typeorm_1.TransactionAlreadyStartedError();
+        if (isolation && isolation !== 'READ UNCOMMITTED' && isolation !== 'SERIALIZABLE')
+            throw new typeorm_1.TypeORMError('SQLite only supports SERIALIZABLE and READ UNCOMMITTED isolation');
+        this.isTransactionActive = true;
+        try {
+            await this.broadcaster.broadcast('BeforeTransactionStart');
+        }
+        catch (error) {
+            this.isTransactionActive = false;
+            throw error;
+        }
+    }
+    else {
+        if (!this.isTransactionActive)
+            throw new typeorm_1.TransactionNotStartedError();
+        await this.broadcaster.broadcast(operation === 'commit' ? 'BeforeTransactionCommit' : 'BeforeTransactionRollback');
+    }
+    __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_assertFinalControlOrigin).call(this, operation, lifecycle);
+    const terminalRollback = operation === 'rollback' &&
+        (this.guardedCommit.noMutation?.terminal !== undefined || __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_finalValidationActive).call(this, this.guardedCommit));
+    const abortNested = terminalRollback && this.transactionDepth > 1;
+    const outer = operation !== 'start' && (originalOuter || terminalRollback);
+    const sql = operation === 'start'
+        ? `SAVEPOINT typeorm_${this.transactionDepth}`
+        : outer
+            ? operation === 'commit'
+                ? 'COMMIT'
+                : 'ROLLBACK'
+            : `${operation === 'commit' ? 'RELEASE' : 'ROLLBACK TO'} SAVEPOINT typeorm_${this.transactionDepth - 1}`;
+    if (outer && this.lease.closing) {
+        if (operation === 'rollback')
+            await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").drainOwned(this.lease);
+        this.terminalControlPermit = {
+            scope: this.lease.closing.scope,
+            context: __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").captureCommitContext(this.lease),
+            sql,
+        };
+    }
+    this.noMutationControl = { scope: this.guardedCommit, sql, outer };
+    try {
+        await this.query(sql);
+    }
+    finally {
+        this.noMutationControl = undefined;
+        this.terminalControlPermit = undefined;
+    }
+    if (outer)
+        this.isTransactionActive = false;
+    this.transactionDepth = terminalRollback ? 0 : this.transactionDepth + (operation === 'start' ? 1 : -1);
+    try {
+        await this.broadcaster.broadcast(operation === 'start'
+            ? 'AfterTransactionStart'
+            : operation === 'commit'
+                ? 'AfterTransactionCommit'
+                : 'AfterTransactionRollback');
+    }
+    finally {
+        if (abortNested && this.lease?.active)
+            this.lease.aborted = new Error('Nested SQLite terminal failure aborted the owning transaction scope');
+    }
+}, _CoordinatedSqliteQueryRunner_startManagedTransaction = async function _CoordinatedSqliteQueryRunner_startManagedTransaction(isolationLevel, lifecycle) {
+    __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_assertFinalControlOrigin).call(this, 'start', lifecycle);
+    if (this.lease?.active && this.lease.closing) {
+        await this.lease.closing.ready;
+        throw this.lease.closing.reason.cause;
+    }
+    __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").assertAvailable();
+    if (this.writeAdmission) {
+        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").markFailedStart();
+        return __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").track(() => Promise.reject(new Error('SQLite write admission forbids reentrant transaction start before BEGIN acknowledgement')));
+    }
+    if (!this.lease?.active)
+        this.lease = await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").acquire(this);
+    const previousDepth = this.transactionDepth;
+    const writeIntent = this.writeIntentRequested && previousDepth === 0;
+    this.writeIntentRequested = false;
+    const outerScope = previousDepth === 0 ? { lease: this.lease, guards: [], phase: 'starting', outcome: 'pending' } : undefined;
+    if (outerScope) {
+        this.guardedCommit = outerScope;
+        if (lifecycle) {
+            lifecycle.scope = outerScope;
+            outerScope.managedOwner = lifecycle.context;
+        }
+    }
+    try {
+        await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_withTransactionControl).call(this, () => writeIntent
+            ? __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_startWithWriteIntent).call(this)
+            : this.guardedCommit?.noMutation && previousDepth > 0
+                ? __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_noMutationTransactionControl).call(this, 'start', isolationLevel, lifecycle)
+                : __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_startOriginalTransaction).call(this, isolationLevel));
+        if (outerScope)
+            outerScope.phase = 'open';
+    }
+    catch (error) {
+        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").recordManagedFailure(error);
+        if (previousDepth === 0) {
+            if (outerScope)
+                outerScope.phase = 'rolling_back';
+            await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_recoverTransaction).call(this);
+        }
+        else {
+            this.isTransactionActive = true;
+            if (this.transactionDepth > previousDepth)
+                await this.rollbackTransaction();
+            this.transactionDepth = previousDepth;
+            __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").markFailedStart();
+        }
+        throw error;
+    }
+    finally {
+        if (writeIntent)
+            this.writeAdmission = undefined;
+        if (outerScope)
+            __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_settleCommitScope).call(this);
+        this.releaseIfSettled();
+    }
+}, _CoordinatedSqliteQueryRunner_startOriginalTransaction = async function _CoordinatedSqliteQueryRunner_startOriginalTransaction(isolation) {
+    if (this.transactionDepth !== 0)
+        return Reflect.apply(Reflect.get(SqliteQueryRunner_1.SqliteQueryRunner.prototype, 'startTransaction'), this, [isolation]);
+    if (this.driver.transactionSupport === 'none')
+        throw new typeorm_1.TypeORMError(`Transactions aren't supported by ${this.connection.driver.options.type}.`);
+    if (this.isTransactionActive && this.driver.transactionSupport === 'simple')
+        throw new typeorm_1.TransactionAlreadyStartedError();
+    if (isolation && isolation !== 'READ UNCOMMITTED' && isolation !== 'SERIALIZABLE')
+        throw new typeorm_1.TypeORMError('SQLite only supports SERIALIZABLE and READ UNCOMMITTED isolation');
+    this.isTransactionActive = true;
+    try {
+        await this.broadcaster.broadcast('BeforeTransactionStart');
+    }
+    catch (cause) {
+        this.isTransactionActive = false;
+        throw cause;
+    }
+    if (isolation) {
+        this.startupPermit = `PRAGMA read_uncommitted = ${isolation === 'READ UNCOMMITTED' ? 'true' : 'false'}`;
+        await this.query(this.startupPermit);
+    }
+    this.startupPermit = 'BEGIN TRANSACTION';
+    await this.query(this.startupPermit);
+    this.transactionDepth += 1;
+    await this.broadcaster.broadcast('AfterTransactionStart');
+}, _CoordinatedSqliteQueryRunner_startWithWriteIntent = async function _CoordinatedSqliteQueryRunner_startWithWriteIntent() {
+    this.writeAdmission = 'pending';
+    this.isTransactionActive = true;
+    try {
+        await this.broadcaster.broadcast('BeforeTransactionStart');
+        this.writeAdmission = 'armed';
+        this.startupPermit = 'BEGIN IMMEDIATE TRANSACTION';
+        await this.query('BEGIN IMMEDIATE TRANSACTION');
+    }
+    finally {
+        this.writeAdmission = undefined;
+    }
+    this.transactionDepth += 1;
+    await this.broadcaster.broadcast('AfterTransactionStart');
+}, _CoordinatedSqliteQueryRunner_commitManagedTransaction = async function _CoordinatedSqliteQueryRunner_commitManagedTransaction(lifecycle) {
+    __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_assertFinalControlOrigin).call(this, 'commit', lifecycle);
+    try {
+        await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").drainCurrent();
+        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_assertFinalControlOrigin).call(this, 'commit', lifecycle);
+        await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_withTransactionControl).call(this, () => this.guardedCommit?.noMutation || (this.lease?.active && this.lease.closing)
+            ? __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_noMutationTransactionControl).call(this, 'commit', undefined, lifecycle)
+            : Reflect.apply(Reflect.get(SqliteQueryRunner_1.SqliteQueryRunner.prototype, 'commitTransaction'), this, []));
+    }
+    catch (cause) {
+        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").recordManagedFailure(cause);
+        throw cause;
+    }
+    finally {
+        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_settleCommitScope).call(this);
+        this.releaseIfSettled();
+    }
+}, _CoordinatedSqliteQueryRunner_rollbackManagedTransaction = async function _CoordinatedSqliteQueryRunner_rollbackManagedTransaction(lifecycle) {
+    if (lifecycle && __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").consumeFailedStart())
+        return;
+    __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_assertFinalControlOrigin).call(this, 'rollback', lifecycle);
+    const scope = this.guardedCommit;
+    if (lifecycle?.scope === scope &&
+        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_finalValidationActive).call(this, scope) &&
+        !this.isTransactionActive &&
+        this.transactionDepth > 0) {
+        let physical = false;
+        try {
+            physical = scope.noMutation.physical();
+        }
+        catch {
+        }
+        if (!physical) {
+            scope.outcome = 'unknown';
+            const cause = new Error('SQLite original managed rollback physical identity expired');
+            __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").poison(cause);
+            throw cause;
+        }
+        this.isTransactionActive = true;
+    }
+    const full = this.transactionDepth === 1 || scope?.noMutation?.terminal !== undefined || __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_finalValidationActive).call(this, scope);
+    if (full)
+        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_beginFullAbort).call(this, scope);
+    if (scope && full)
+        scope.phase = 'rolling_back';
+    try {
+        await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").drainCurrent(false);
+        await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_withTransactionControl).call(this, async () => {
+            if (this.lease?.active && this.lease.closing)
+                await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").drainOwned(this.lease);
+            await (scope?.noMutation || (this.lease?.active && this.lease.closing)
+                ? __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_noMutationTransactionControl).call(this, 'rollback', undefined, lifecycle)
+                : Reflect.apply(Reflect.get(SqliteQueryRunner_1.SqliteQueryRunner.prototype, 'rollbackTransaction'), this, []));
+            if (this.lease?.active && this.lease.closing)
+                await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").drainOwned(this.lease);
+        });
+    }
+    catch (error) {
+        if (this.lease?.active && this.isTransactionActive)
+            await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_recoverTransaction).call(this, { cause: error });
+        throw error;
+    }
+    finally {
+        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_settleCommitScope).call(this);
+        this.releaseIfSettled();
+    }
+}, _CoordinatedSqliteQueryRunner_dispatchGuardedCommit = function _CoordinatedSqliteQueryRunner_dispatchGuardedCommit(scope, context, connection, query, parameters, callback) {
+    const ticket = this.noMutationQuery.getStore();
+    const latchFailure = (cause) => __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_latchNativeFailure).call(this, ticket, cause);
+    const callbackContext = node_async_hooks_1.AsyncLocalStorage.snapshot();
+    let delivered = false;
+    const deliver = function (error, rows) {
+        if (delivered)
+            return;
+        delivered = true;
+        if (ticket) {
+            if (error?.toString().includes('SQLITE_BUSY:'))
+                ticket.retry = true;
+            else if (error && scope.outcome === 'unknown')
+                latchFailure(error);
+        }
+        callbackContext(() => {
+            callback.call(this, error, rows);
+        });
+    };
+    void __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f")
+        .drainCommitChildren(context, () => {
+        let submitted = false;
+        try {
+            if (scope !== this.guardedCommit ||
+                !scope.lease.active ||
+                this.transactionDepth !== 1 ||
+                (scope.phase !== 'open' && scope.phase !== 'sealed')) {
+                throw new Error('SQLite outer COMMIT scope expired');
+            }
+            if (scope.lease.closing)
+                throw new SqliteCommitGuardRefusedError(scope.childFailure ? scope.childFailure.cause : scope.lease.closing.reason?.cause);
+            if (scope.noMutation?.inFlight || scope.noMutation?.queue.length || scope.noMutation?.terminal)
+                throw new SqliteCommitGuardRefusedError(scope.childFailure?.cause);
+            scope.phase = 'sealed';
+            if (scope.childFailure)
+                throw new SqliteCommitGuardRefusedError(scope.childFailure.cause);
+            for (const guard of scope.guards) {
+                if (guard() !== true)
+                    throw new SqliteCommitGuardRefusedError();
+            }
+            if (scope.childFailure)
+                throw new SqliteCommitGuardRefusedError(scope.childFailure.cause);
+            const witness = scope.noMutation;
+            if (witness &&
+                (query !== 'COMMIT' ||
+                    ticket?.scope !== scope ||
+                    ticket.sql !== query ||
+                    !ticket.control ||
+                    !ticket.outer ||
+                    !ticket.connected ||
+                    !ticket.dispatched ||
+                    ticket.nativeMethod !== 'all' ||
+                    !witness.pending.has(ticket) ||
+                    witness.native !== connection ||
+                    context.lease !== scope.lease ||
+                    !context.active))
+                throw __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_nativeDispatchRefusal).call(this, scope, scope.childFailure
+                    ? scope.childFailure.cause
+                    : witness.anomaly
+                        ? witness.anomaly.cause
+                        : new Error('SQLite COMMIT lacks its original terminal ticket'));
+            if (witness?.finalValidation) {
+                __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_checkNoMutationPins).call(this, witness);
+                if (witness.decision !== 'applied' ||
+                    witness.anomaly ||
+                    scope.childFailure ||
+                    __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").managedPrimary() ||
+                    witness.inFlight ||
+                    witness.queue.length ||
+                    witness.terminal ||
+                    __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").hasOutstanding(context) ||
+                    [...witness.pending].some((pending) => pending !== ticket))
+                    throw new SqliteCommitGuardRefusedError(scope.childFailure ? scope.childFailure.cause : witness.anomaly?.cause);
+            }
+            if (witness && witness.decision !== 'applied') {
+                __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_checkNoMutationPins).call(this, witness);
+                if (witness.decision !== 'unchanged' ||
+                    witness.anomaly ||
+                    witness.mutations !== 0n ||
+                    [...witness.pending].some((ticket) => !ticket.control))
+                    throw new SqliteCommitGuardRefusedError(witness.anomaly?.cause);
+            }
+            scope.phase = 'submitted';
+            scope.outcome = 'unknown';
+            submitted = true;
+            (scope.noMutation?.all ?? connection.all).call(connection, query, parameters, function (error, rows) {
+                if (!error) {
+                    scope.phase = 'committed';
+                    scope.outcome = 'committed';
+                }
+                else if (error.toString().includes('SQLITE_BUSY:')) {
+                    scope.phase = 'sealed';
+                }
+                else {
+                    scope.outcome = 'unknown';
+                }
+                deliver.call(this, error, rows);
+            });
+        }
+        catch (error) {
+            if (delivered)
+                return;
+            if (submitted) {
+                scope.outcome = 'unknown';
+                if (ticket) {
+                    __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_latchNativeFailure).call(this, ticket, error);
+                    queryDispatchFailures.get(ticket)(error);
+                    return;
+                }
+                deliver.call(connection, error instanceof Error ? error : new Error('Native COMMIT dispatch threw', { cause: error }));
+            }
+            else {
+                __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_refuseCommit).call(this, scope, connection, deliver, error);
+            }
+        }
+    })
+        .catch((error) => __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_refuseCommit).call(this, scope, connection, deliver, scope.childFailure ? scope.childFailure.cause : error));
+}, _CoordinatedSqliteQueryRunner_refuseCommit = function _CoordinatedSqliteQueryRunner_refuseCommit(scope, connection, callback, cause) {
+    scope.phase = 'sealed';
+    scope.outcome = 'refused';
+    callback.call(connection, cause instanceof SqliteCommitGuardRefusedError ? cause : new SqliteCommitGuardRefusedError(cause));
+}, _CoordinatedSqliteQueryRunner_settleCommitScope = function _CoordinatedSqliteQueryRunner_settleCommitScope() {
+    const scope = this.guardedCommit;
+    if (!scope ||
+        (scope.lease.closing && __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").hasContexts(scope.lease)) ||
+        this.isTransactionActive ||
+        this.transactionDepth !== 0 ||
+        scope.noMutation?.inFlight ||
+        scope.noMutation?.queue.length ||
+        scope.noMutation?.pending.size)
+        return;
+    if (scope.outcome === 'pending')
+        scope.outcome = 'rolled_back';
+    scope.phase = 'settled';
+    scope.childFailure = undefined;
+    this.guardedCommit = undefined;
+}, _CoordinatedSqliteQueryRunner_withTransactionControl = function _CoordinatedSqliteQueryRunner_withTransactionControl(operation) {
+    return __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").run(this.lease, async () => {
+        this.transactionControlDepth++;
+        try {
+            await operation();
+        }
+        finally {
+            this.transactionControlDepth--;
+        }
+    });
+}, _CoordinatedSqliteQueryRunner_recoverTransaction = async function _CoordinatedSqliteQueryRunner_recoverTransaction(trigger) {
+    const closing = __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_beginFullAbort).call(this, this.guardedCommit, trigger);
+    if (closing)
+        return __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_withTransactionControl).call(this, () => __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_recoverOwnedTransaction).call(this, closing));
+    return __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_instances, "m", _CoordinatedSqliteQueryRunner_recoverOwnedTransaction).call(this);
+}, _CoordinatedSqliteQueryRunner_recoverOwnedTransaction = async function _CoordinatedSqliteQueryRunner_recoverOwnedTransaction(closing) {
+    const hadTransaction = this.transactionDepth > 0;
+    const abortedNestedTransaction = this.transactionDepth > 1;
+    try {
+        if (closing)
+            await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").drainOwned(closing.scope.lease);
+        await new Promise((resolve, reject) => {
+            const connection = this.driver.databaseConnection;
+            connection.run('ROLLBACK', (error) => {
+                if (!error || /no transaction is active/i.test(error.message))
+                    resolve();
+                else
+                    reject(error);
+            });
+        });
+    }
+    catch (error) {
+        if (this.guardedCommit?.outcome === 'pending')
+            this.guardedCommit.outcome = 'unknown';
+        __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").poison(error);
+    }
+    finally {
+        this.isTransactionActive = false;
+        this.transactionDepth = 0;
+    }
+    if (hadTransaction) {
+        try {
+            await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").run(this.lease, () => this.broadcaster.broadcast('AfterTransactionRollback'));
+        }
+        catch {
+        }
+    }
+    if (closing)
+        await __classPrivateFieldGet(this, _CoordinatedSqliteQueryRunner_coordinator, "f").drainOwned(closing.scope.lease);
+    if (abortedNestedTransaction && this.lease?.active) {
+        this.lease.aborted = new Error('Nested SQLite transaction recovery aborted the owning transaction scope');
+    }
+};
+function registerSqliteCommitGuard(manager, guard) {
+    if (!(manager.queryRunner instanceof CoordinatedSqliteQueryRunner)) {
+        throw new Error('SQLite COMMIT guards require a coordinated scoped manager');
+    }
+    return manager.queryRunner.registerCommitGuard(manager, guard);
+}
+function captureSqliteNoMutationWindow(manager, ownerCurrent) {
+    if (!(manager.queryRunner instanceof CoordinatedSqliteQueryRunner))
+        throw new Error('SQLite no-mutation window requires its coordinated scoped manager');
+    return manager.queryRunner.captureNoMutationWindow(manager, ownerCurrent);
+}
+function observeSqliteOuterOutcome(manager) {
+    if (!(manager.queryRunner instanceof CoordinatedSqliteQueryRunner)) {
+        throw new Error('Native outcome observation requires a coordinated scoped manager');
+    }
+    return manager.queryRunner.observeOuterOutcome(manager);
+}
+function hasCurrentSqliteConnectionLease(dataSource) {
+    return coordinators.get(dataSource)?.currentRunner !== undefined;
+}
+function isSqliteTransactionActive(dataSource) {
+    return coordinators.get(dataSource)?.isTransactionActive ?? dataSource.createQueryRunner().isTransactionActive;
+}
+function outsideSqliteTransaction(dataSource, operation) {
+    const coordinator = coordinators.get(dataSource);
+    return coordinator ? coordinator.detach(operation) : operation();
+}
+//# sourceMappingURL=sqlite-data-source.js.map