@lix-js/sdk 0.5.0 → 0.6.0-preview.0

package/dist/engine/preprocessor/steps/rewrite-vtable-selects.js

@@ -1,2305 +0,0 @@
-import {} from "../sql-parser/nodes.js";
-import { internalQueryBuilder } from "../../internal-query-builder.js";
-import { getColumnName, getColumnQualifier, getIdentifierValue, isSelectAllForTable, normalizeIdentifierValue, objectNameMatches, } from "../sql-parser/ast-helpers.js";
-import { visitSelectStatement, } from "../sql-parser/visitor.js";
-import { normalizeSegmentedStatement } from "../sql-parser/parse.js";
-import { cacheTableNameToSchemaKey, schemaKeyToCacheTableName, } from "../../../state/cache/create-schema-cache-table.js";
-export const INTERNAL_STATE_VTABLE = "lix_internal_state_vtable";
-const DEFAULT_ALIAS_KEY = normalizeIdentifierValue(INTERNAL_STATE_VTABLE);
-const ORIGINAL_TABLE_KEY = DEFAULT_ALIAS_KEY;
-const HIDDEN_SEGMENT_COLUMNS = ["_pk"];
-const HIDDEN_SEGMENT_COLUMN_SET = new Set(HIDDEN_SEGMENT_COLUMNS);
-const SNAPSHOT_JSON_ENTITY_PATHS = new Set(["$.id", "$.entity_id"]);
-// Guarded until we can reliably map JSON paths to concrete entity identifiers.
-const SNAPSHOT_ENTITY_FILTER_PUSH_ENABLED = false;
-/**
- * Rewrites internal state vtable references into inline union subqueries.
- *
- * @example
- * ```ts
- * const rewritten = rewriteVtableSelects({
- *   node: statement,
- *   getCacheTables,
- *   hasOpenTransaction,
- * });
- * ```
- */
-export const rewriteVtableSelects = (context) => {
-    let anyChanges = false;
-    const rewrittenStatements = context.statements.map((statement) => {
-        const rewritten = rewriteSegmentedStatement(statement, context);
-        if (rewritten !== statement) {
-            anyChanges = true;
-        }
-        return rewritten;
-    });
-    return anyChanges ? rewrittenStatements : context.statements;
-};
-function rewriteSegmentedStatement(statement, context) {
-    let changed = false;
-    const segments = statement.segments.map((segment) => {
-        if (segment.node_kind === "select_statement") {
-            const rewritten = rewriteSelectStatement(segment, context);
-            if (rewritten !== segment) {
-                changed = true;
-            }
-            return rewritten;
-        }
-        if (segment.node_kind === "compound_select") {
-            const rewritten = rewriteCompoundSelect(segment, context);
-            if (rewritten !== segment) {
-                changed = true;
-            }
-            return rewritten;
-        }
-        return segment;
-    });
-    if (!changed) {
-        return statement;
-    }
-    return normalizeSegmentedStatement({
-        ...statement,
-        segments,
-    });
-}
-function rewriteSelectStatement(select, context, pushdownSchemaKeys = [], pushdownPruneInheritance = false, pushdownPruneTransactions = false, pushdownFileIds = [], pushdownEntityIds = [], pushdownVersionIds = [], pushdownSnapshotFilters = []) {
-    const parameters = context.parameters ?? [];
-    const ctePredicateMap = collectCtePredicateMap(select, parameters, pushdownSchemaKeys, pushdownPruneInheritance, pushdownPruneTransactions, pushdownFileIds, pushdownEntityIds, pushdownVersionIds, pushdownSnapshotFilters);
-    const selectWithRewrittenCtes = rewriteSelectWithClause(select, context, ctePredicateMap, pushdownSchemaKeys, pushdownPruneInheritance, pushdownPruneTransactions, pushdownFileIds, pushdownEntityIds, pushdownVersionIds, pushdownSnapshotFilters);
-    const fallbackAliasNames = collectRelationAliasNames(selectWithRewrittenCtes);
-    const fallbackSchemaSummary = collectSchemaKeyPredicates(selectWithRewrittenCtes.where_clause, fallbackAliasNames, parameters);
-    const fallbackSchemaKeys = mergeStringLiterals(pushdownSchemaKeys, fallbackSchemaSummary.literals);
-    const fallbackFileSummary = collectFileIdPredicates(selectWithRewrittenCtes.where_clause, fallbackAliasNames, parameters);
-    const fallbackFileIds = mergeStringLiterals(pushdownFileIds, fallbackFileSummary.literals);
-    const fallbackEntitySummary = collectEntityIdPredicates(selectWithRewrittenCtes.where_clause, fallbackAliasNames, parameters);
-    const fallbackEntityIds = mergeStringLiterals(pushdownEntityIds, fallbackEntitySummary.literals);
-    const fallbackVersionSummary = collectVersionIdPredicates(selectWithRewrittenCtes.where_clause, fallbackAliasNames, parameters);
-    const fallbackVersionIds = mergeStringLiterals(pushdownVersionIds, fallbackVersionSummary.literals);
-    const fallbackSnapshotSummary = collectSnapshotJsonPredicates(selectWithRewrittenCtes.where_clause, fallbackAliasNames, parameters);
-    const fallbackSnapshotFilters = mergeSnapshotFilters(pushdownSnapshotFilters, fallbackSnapshotSummary);
-    const fallbackPruneInheritance = pushdownPruneInheritance ||
-        shouldPruneInheritance(selectWithRewrittenCtes.where_clause, fallbackAliasNames, parameters);
-    const fallbackPruneTransactions = pushdownPruneTransactions ||
-        shouldPruneTransactionSegment(selectWithRewrittenCtes.where_clause, fallbackAliasNames, parameters);
-    const subqueryPredicateMap = collectSubqueryPredicateMap(selectWithRewrittenCtes, parameters, pushdownSchemaKeys, pushdownPruneInheritance, pushdownPruneTransactions, pushdownFileIds, pushdownEntityIds, pushdownVersionIds, pushdownSnapshotFilters);
-    const withRewrittenSubqueries = visitSelectStatement(selectWithRewrittenCtes, {
-        subquery(node, visitContext) {
-            const parentKind = visitContext.parent?.node_kind;
-            const aliasValue = getIdentifierValue(node.alias);
-            const normalizedAlias = aliasValue
-                ? normalizeIdentifierValue(aliasValue)
-                : DEFAULT_ALIAS_KEY;
-            const predicateMetadata = parentKind === "from_clause" || parentKind === "join_clause"
-                ? subqueryPredicateMap.get(normalizedAlias)
-                : undefined;
-            const nextSchemaKeys = predicateMetadata?.schemaKeys ?? fallbackSchemaKeys;
-            const nextPrune = predicateMetadata?.pruneInheritance ?? fallbackPruneInheritance;
-            const nextPruneTransactions = predicateMetadata?.pruneTransactionSegment ??
-                fallbackPruneTransactions;
-            const nextFileIds = predicateMetadata?.fileIds ?? fallbackFileIds;
-            const nextEntityIds = predicateMetadata?.entityIds ?? fallbackEntityIds;
-            const nextVersionIds = predicateMetadata?.versionIds ?? fallbackVersionIds;
-            const nextSnapshotFilters = predicateMetadata?.snapshotFilters ?? fallbackSnapshotFilters;
-            const rewrittenStatement = node.statement.node_kind === "compound_select"
-                ? rewriteCompoundSelect(node.statement, context, nextSchemaKeys, nextPrune, nextPruneTransactions, nextFileIds, nextEntityIds, nextVersionIds, nextSnapshotFilters)
-                : rewriteSelectStatement(node.statement, context, nextSchemaKeys, nextPrune, nextPruneTransactions, nextFileIds, nextEntityIds, nextVersionIds, nextSnapshotFilters);
-            if (rewrittenStatement !== node.statement) {
-                return {
-                    ...node,
-                    statement: rewrittenStatement,
-                };
-            }
-            return node;
-        },
-    });
-    const references = collectInternalStateReferences(withRewrittenSubqueries);
-    if (references.length === 0) {
-        return withRewrittenSubqueries;
-    }
-    const aliasList = references
-        .map((reference) => reference.alias)
-        .filter((alias) => alias !== null);
-    const tableNamesForTrace = new Set([
-        DEFAULT_ALIAS_KEY,
-        ORIGINAL_TABLE_KEY,
-        ...references
-            .map((reference) => reference.normalizedAlias)
-            .filter((alias) => alias !== null),
-    ]);
-    const schemaSummary = collectSchemaKeyPredicates(withRewrittenSubqueries.where_clause, tableNamesForTrace, parameters);
-    const mergedSchemaKeys = mergeStringLiterals(pushdownSchemaKeys, schemaSummary.literals);
-    const schemaSummaryForTrace = {
-        count: schemaSummary.count,
-        literals: mergedSchemaKeys,
-    };
-    const projectionKind = determineProjectionKind(withRewrittenSubqueries.projection, tableNamesForTrace);
-    const selectedColumnsSummaryForTrace = collectSelectedColumns(withRewrittenSubqueries, tableNamesForTrace);
-    const metadata = buildInlineMetadata(withRewrittenSubqueries, references, parameters, pushdownSchemaKeys, pushdownPruneInheritance, pushdownPruneTransactions, pushdownFileIds, pushdownEntityIds, pushdownVersionIds, pushdownSnapshotFilters);
-    const rewritten = visitSelectStatement(withRewrittenSubqueries, createInlineVisitor(metadata, context));
-    if (context.trace) {
-        const entry = buildTraceEntry({
-            aliasList,
-            projectionKind,
-            schemaSummary: schemaSummaryForTrace,
-            selectedColumns: selectedColumnsSummaryForTrace.selectedColumns,
-        });
-        context.trace.push(entry);
-    }
-    return rewritten;
-}
-function rewriteCompoundSelect(compound, context, pushdownSchemaKeys = [], pushdownPruneInheritance = false, pushdownPruneTransactions = false, pushdownFileIds = [], pushdownEntityIds = [], pushdownVersionIds = [], pushdownSnapshotFilters = []) {
-    const rewrittenWithClause = compound.with_clause
-        ? rewriteWithClauseNode(compound.with_clause, context, new Map(), pushdownSchemaKeys, pushdownPruneInheritance, pushdownPruneTransactions, pushdownFileIds, pushdownEntityIds, pushdownVersionIds, pushdownSnapshotFilters)
-        : null;
-    let changed = false;
-    const first = rewriteSelectStatement(compound.first, context, pushdownSchemaKeys, pushdownPruneInheritance, pushdownPruneTransactions, pushdownFileIds, pushdownEntityIds, pushdownVersionIds, pushdownSnapshotFilters);
-    if (first !== compound.first) {
-        changed = true;
-    }
-    const branches = compound.compounds.map((branch) => {
-        const rewritten = rewriteSelectStatement(branch.select, context, pushdownSchemaKeys, pushdownPruneInheritance, pushdownPruneTransactions, pushdownFileIds, pushdownEntityIds, pushdownVersionIds, pushdownSnapshotFilters);
-        if (rewritten !== branch.select) {
-            changed = true;
-            return {
-                ...branch,
-                select: rewritten,
-            };
-        }
-        return branch;
-    });
-    if (!changed) {
-        return rewrittenWithClause === compound.with_clause
-            ? compound
-            : {
-                ...compound,
-                with_clause: rewrittenWithClause,
-            };
-    }
-    return {
-        ...compound,
-        first,
-        compounds: branches,
-        with_clause: rewrittenWithClause ?? compound.with_clause,
-    };
-}
-function collectInternalStateReferences(select) {
-    const references = [];
-    for (const clause of select.from_clauses) {
-        const relation = clause.relation;
-        if (relation.node_kind === "table_reference") {
-            if (isInternalStateTable(relation)) {
-                references.push({
-                    relation,
-                    alias: getIdentifierValue(relation.alias),
-                    normalizedAlias: normalizeAlias(relation.alias),
-                });
-            }
-        }
-        for (const join of clause.joins) {
-            const joinRelation = join.relation;
-            if (joinRelation.node_kind === "table_reference" &&
-                isInternalStateTable(joinRelation)) {
-                references.push({
-                    relation: joinRelation,
-                    alias: getIdentifierValue(joinRelation.alias),
-                    normalizedAlias: normalizeAlias(joinRelation.alias),
-                });
-            }
-        }
-    }
-    return references;
-}
-function isInternalStateTable(table) {
-    return objectNameMatches(table.name, INTERNAL_STATE_VTABLE);
-}
-function normalizeAlias(alias) {
-    const value = getIdentifierValue(alias);
-    return value ? normalizeIdentifierValue(value) : null;
-}
-function collectSubqueryPredicateMap(select, parameters, pushdownSchemaKeys, pushdownPruneInheritance, pushdownPruneTransactions, pushdownFileIds, pushdownEntityIds, pushdownVersionIds, pushdownSnapshotFilters) {
-    const map = new Map();
-    const register = (relation, joinFilter) => {
-        if (relation.node_kind !== "subquery") {
-            return;
-        }
-        const aliasValue = getIdentifierValue(relation.alias);
-        if (!aliasValue) {
-            return;
-        }
-        const normalizedAlias = normalizeIdentifierValue(aliasValue);
-        const tableNames = new Set([
-            normalizedAlias,
-            DEFAULT_ALIAS_KEY,
-            ORIGINAL_TABLE_KEY,
-        ]);
-        const whereSummary = collectSchemaKeyPredicates(select.where_clause, tableNames, parameters);
-        const joinSummary = collectSchemaKeyPredicatesFromExpression(joinFilter, tableNames, parameters, false);
-        const localKeys = mergeStringLiterals(whereSummary.literals, joinSummary.literals);
-        const fileWhereSummary = collectFileIdPredicates(select.where_clause, tableNames, parameters);
-        const fileJoinSummary = collectFileIdPredicatesFromExpression(joinFilter, tableNames, parameters, false);
-        const localFileIds = mergeStringLiterals(fileWhereSummary.literals, fileJoinSummary.literals);
-        const entityWhereSummary = collectEntityIdPredicates(select.where_clause, tableNames, parameters);
-        const entityJoinSummary = collectEntityIdPredicatesFromExpression(joinFilter, tableNames, parameters, false);
-        const localEntityIds = mergeStringLiterals(entityWhereSummary.literals, entityJoinSummary.literals);
-        const snapshotWhereSummary = collectSnapshotJsonPredicates(select.where_clause, tableNames, parameters);
-        const snapshotJoinSummary = collectSnapshotJsonPredicatesFromExpression(joinFilter, tableNames, parameters, false);
-        const localSnapshotFilters = mergeSnapshotFilters(snapshotWhereSummary, snapshotJoinSummary);
-        const versionWhereSummary = collectVersionIdPredicates(select.where_clause, tableNames, parameters);
-        const versionJoinSummary = collectVersionIdPredicatesFromExpression(joinFilter, tableNames, parameters, false);
-        const localVersionIds = mergeStringLiterals(versionWhereSummary.literals, versionJoinSummary.literals);
-        const existing = map.get(normalizedAlias);
-        const merged = mergeStringLiterals(existing?.schemaKeys ?? [], pushdownSchemaKeys, localKeys);
-        const mergedFileIds = mergeStringLiterals(existing?.fileIds ?? [], pushdownFileIds, localFileIds);
-        const mergedEntityIds = mergeStringLiterals(existing?.entityIds ?? [], pushdownEntityIds, localEntityIds);
-        const mergedSnapshotFilters = mergeSnapshotFilters(existing?.snapshotFilters ?? [], pushdownSnapshotFilters, localSnapshotFilters);
-        const mergedVersionIds = mergeStringLiterals(existing?.versionIds ?? [], pushdownVersionIds, localVersionIds);
-        const pruneFromWhere = requiresNullPredicateForColumn(select.where_clause, tableNames, parameters, true);
-        const pruneFromJoin = requiresNullPredicateForColumn(joinFilter, tableNames, parameters, false);
-        const combinedPrune = (existing?.pruneInheritance ?? false) ||
-            pushdownPruneInheritance ||
-            pruneFromWhere ||
-            pruneFromJoin;
-        const pruneTxnFromWhere = excludesColumnLiteralFromExpression(select.where_clause, tableNames, parameters, "source_tag", "T", true);
-        const pruneTxnFromJoin = excludesColumnLiteralFromExpression(joinFilter, tableNames, parameters, "source_tag", "T", false);
-        const combinedTxnPrune = (existing?.pruneTransactionSegment ?? false) ||
-            pushdownPruneTransactions ||
-            pruneTxnFromWhere ||
-            pruneTxnFromJoin;
-        const finalFileIds = shouldPushFileFilter(merged, mergedFileIds)
-            ? mergedFileIds
-            : [];
-        const finalEntityIds = shouldPushEntityFilter(merged, mergedEntityIds)
-            ? mergedEntityIds
-            : [];
-        const finalSnapshotFilters = shouldPushSnapshotFilters(merged, mergedSnapshotFilters)
-            ? mergedSnapshotFilters
-            : [];
-        if (merged.length > 0 ||
-            finalFileIds.length > 0 ||
-            finalEntityIds.length > 0 ||
-            finalSnapshotFilters.length > 0 ||
-            mergedVersionIds.length > 0 ||
-            combinedPrune ||
-            combinedTxnPrune) {
-            map.set(normalizedAlias, {
-                schemaKeys: merged,
-                fileIds: finalFileIds,
-                entityIds: finalEntityIds,
-                snapshotFilters: finalSnapshotFilters,
-                versionIds: mergedVersionIds,
-                pruneInheritance: combinedPrune,
-                pruneTransactionSegment: combinedTxnPrune,
-            });
-        }
-    };
-    for (const clause of select.from_clauses) {
-        register(clause.relation, null);
-        for (const join of clause.joins) {
-            register(join.relation, join.on_expression);
-        }
-    }
-    return map;
-}
-function collectRelationAliasNames(select) {
-    const aliases = new Set([DEFAULT_ALIAS_KEY, ORIGINAL_TABLE_KEY]);
-    const addAlias = (alias) => {
-        const value = getIdentifierValue(alias);
-        if (value) {
-            aliases.add(normalizeIdentifierValue(value));
-        }
-    };
-    for (const clause of select.from_clauses) {
-        addAlias(extractRelationAlias(clause.relation));
-        for (const join of clause.joins) {
-            addAlias(extractRelationAlias(join.relation));
-        }
-    }
-    return aliases;
-}
-function extractRelationAlias(relation) {
-    if ("alias" in relation) {
-        const alias = relation.alias;
-        return alias ?? null;
-    }
-    return null;
-}
-function collectCtePredicateMap(select, parameters, pushdownSchemaKeys, pushdownPruneInheritance, pushdownPruneTransactions, pushdownFileIds, pushdownEntityIds, pushdownVersionIds, pushdownSnapshotFilters) {
-    const withClause = select.with_clause;
-    if (!withClause || withClause.ctes.length === 0) {
-        return new Map();
-    }
-    const cteNames = new Set(withClause.ctes
-        .map((cte) => normalizeIdentifierValue(cte.name.value))
-        .filter((name) => !!name));
-    if (cteNames.size === 0) {
-        return new Map();
-    }
-    const map = new Map();
-    const register = (table, joinFilter) => {
-        const normalizedName = normalizeObjectName(table.name);
-        if (!normalizedName || !cteNames.has(normalizedName)) {
-            return;
-        }
-        const aliasValue = getIdentifierValue(table.alias);
-        const tableNames = new Set([
-            normalizedName,
-            DEFAULT_ALIAS_KEY,
-            ORIGINAL_TABLE_KEY,
-        ]);
-        if (aliasValue) {
-            tableNames.add(normalizeIdentifierValue(aliasValue));
-        }
-        const whereSummary = collectSchemaKeyPredicates(select.where_clause, tableNames, parameters);
-        const joinSummary = collectSchemaKeyPredicatesFromExpression(joinFilter, tableNames, parameters, false);
-        const localKeys = mergeStringLiterals(whereSummary.literals, joinSummary.literals);
-        const fileWhereSummary = collectFileIdPredicates(select.where_clause, tableNames, parameters);
-        const fileJoinSummary = collectFileIdPredicatesFromExpression(joinFilter, tableNames, parameters, false);
-        const localFileIds = mergeStringLiterals(fileWhereSummary.literals, fileJoinSummary.literals);
-        const entityWhereSummary = collectEntityIdPredicates(select.where_clause, tableNames, parameters);
-        const entityJoinSummary = collectEntityIdPredicatesFromExpression(joinFilter, tableNames, parameters, false);
-        const localEntityIds = mergeStringLiterals(entityWhereSummary.literals, entityJoinSummary.literals);
-        const snapshotWhereSummary = collectSnapshotJsonPredicates(select.where_clause, tableNames, parameters);
-        const snapshotJoinSummary = collectSnapshotJsonPredicatesFromExpression(joinFilter, tableNames, parameters, false);
-        const localSnapshotFilters = mergeSnapshotFilters(snapshotWhereSummary, snapshotJoinSummary);
-        const versionWhereSummary = collectVersionIdPredicates(select.where_clause, tableNames, parameters);
-        const versionJoinSummary = collectVersionIdPredicatesFromExpression(joinFilter, tableNames, parameters, false);
-        const localVersionIds = mergeStringLiterals(versionWhereSummary.literals, versionJoinSummary.literals);
-        const existing = map.get(normalizedName);
-        const mergedSchemaKeys = mergeStringLiterals(existing?.schemaKeys ?? [], pushdownSchemaKeys, localKeys);
-        const mergedFileIds = mergeStringLiterals(existing?.fileIds ?? [], pushdownFileIds, localFileIds);
-        const mergedEntityIds = mergeStringLiterals(existing?.entityIds ?? [], pushdownEntityIds, localEntityIds);
-        const mergedSnapshotFilters = mergeSnapshotFilters(existing?.snapshotFilters ?? [], pushdownSnapshotFilters, localSnapshotFilters);
-        const mergedVersionIds = mergeStringLiterals(existing?.versionIds ?? [], pushdownVersionIds, localVersionIds);
-        const pruneFromWhere = requiresNullPredicateForColumn(select.where_clause, tableNames, parameters, true);
-        const pruneFromJoin = requiresNullPredicateForColumn(joinFilter, tableNames, parameters, false);
-        const combinedPrune = (existing?.pruneInheritance ?? false) ||
-            pushdownPruneInheritance ||
-            pruneFromWhere ||
-            pruneFromJoin;
-        const pruneTxnFromWhere = excludesColumnLiteralFromExpression(select.where_clause, tableNames, parameters, "source_tag", "T", true);
-        const pruneTxnFromJoin = excludesColumnLiteralFromExpression(joinFilter, tableNames, parameters, "source_tag", "T", false);
-        const combinedTxnPrune = (existing?.pruneTransactionSegment ?? false) ||
-            pushdownPruneTransactions ||
-            pruneTxnFromWhere ||
-            pruneTxnFromJoin;
-        const finalFileIds = shouldPushFileFilter(mergedSchemaKeys, mergedFileIds)
-            ? mergedFileIds
-            : [];
-        const finalEntityIds = shouldPushEntityFilter(mergedSchemaKeys, mergedEntityIds)
-            ? mergedEntityIds
-            : [];
-        const finalSnapshotFilters = shouldPushSnapshotFilters(mergedSchemaKeys, mergedSnapshotFilters)
-            ? mergedSnapshotFilters
-            : [];
-        const entry = {
-            schemaKeys: mergedSchemaKeys,
-            fileIds: finalFileIds,
-            entityIds: finalEntityIds,
-            snapshotFilters: finalSnapshotFilters,
-            versionIds: mergedVersionIds,
-            pruneInheritance: combinedPrune,
-            pruneTransactionSegment: combinedTxnPrune,
-        };
-        map.set(normalizedName, entry);
-    };
-    for (const clause of select.from_clauses) {
-        if (clause.relation.node_kind === "table_reference") {
-            register(clause.relation, null);
-        }
-        for (const join of clause.joins) {
-            if (join.relation.node_kind === "table_reference") {
-                register(join.relation, join.on_expression);
-            }
-        }
-    }
-    return map;
-}
-function rewriteSelectWithClause(select, context, predicateMap, pushdownSchemaKeys, pushdownPruneInheritance, pushdownPruneTransactions, pushdownFileIds, pushdownEntityIds, pushdownVersionIds, pushdownSnapshotFilters) {
-    if (!select.with_clause) {
-        return select;
-    }
-    const rewritten = rewriteWithClauseNode(select.with_clause, context, predicateMap, pushdownSchemaKeys, pushdownPruneInheritance, pushdownPruneTransactions, pushdownFileIds, pushdownEntityIds, pushdownVersionIds, pushdownSnapshotFilters);
-    if (rewritten === select.with_clause) {
-        return select;
-    }
-    return {
-        ...select,
-        with_clause: rewritten,
-    };
-}
-function rewriteWithClauseNode(withClause, context, predicateMap, pushdownSchemaKeys, pushdownPruneInheritance, pushdownPruneTransactions, pushdownFileIds, pushdownEntityIds, pushdownVersionIds, pushdownSnapshotFilters) {
-    let changed = false;
-    const rewrittenCtes = withClause.ctes.map((cte) => {
-        const cteName = normalizeIdentifierValue(cte.name.value);
-        const metadata = cteName ? predicateMap.get(cteName) : undefined;
-        const nextSchemaKeys = metadata?.schemaKeys ?? pushdownSchemaKeys;
-        const nextPrune = metadata?.pruneInheritance ?? pushdownPruneInheritance;
-        const nextPruneTransactions = metadata?.pruneTransactionSegment ?? pushdownPruneTransactions;
-        const nextFileIds = metadata?.fileIds ?? pushdownFileIds;
-        const nextEntityIds = metadata?.entityIds ?? pushdownEntityIds;
-        const nextVersionIds = metadata?.versionIds ?? pushdownVersionIds;
-        const nextSnapshotFilters = metadata?.snapshotFilters ?? pushdownSnapshotFilters;
-        const statement = cte.statement.node_kind === "compound_select"
-            ? rewriteCompoundSelect(cte.statement, context, nextSchemaKeys, nextPrune, nextPruneTransactions, nextFileIds, nextEntityIds, nextVersionIds, nextSnapshotFilters)
-            : rewriteSelectStatement(cte.statement, context, nextSchemaKeys, nextPrune, nextPruneTransactions, nextFileIds, nextEntityIds, nextVersionIds, nextSnapshotFilters);
-        if (statement !== cte.statement) {
-            changed = true;
-            return {
-                ...cte,
-                statement,
-            };
-        }
-        return cte;
-    });
-    if (!changed) {
-        return withClause;
-    }
-    return {
-        ...withClause,
-        ctes: rewrittenCtes,
-    };
-}
-function buildInlineMetadata(select, references, parameters, pushdownSchemaKeys, pushdownPruneInheritance, pushdownPruneTransactions, pushdownFileIds, pushdownEntityIds, pushdownVersionIds, pushdownSnapshotFilters) {
-    const metadata = new Map();
-    for (const reference of references) {
-        const aliasKey = reference.normalizedAlias ?? DEFAULT_ALIAS_KEY;
-        if (metadata.has(aliasKey)) {
-            continue;
-        }
-        const tableNames = new Set([
-            aliasKey,
-            DEFAULT_ALIAS_KEY,
-            ORIGINAL_TABLE_KEY,
-        ]);
-        const summary = collectSchemaKeyPredicates(select.where_clause, tableNames, parameters);
-        const schemaKeys = mergeStringLiterals(pushdownSchemaKeys, summary.literals);
-        const fileSummary = collectFileIdPredicates(select.where_clause, tableNames, parameters);
-        const mergedFileIds = mergeStringLiterals(pushdownFileIds, fileSummary.literals);
-        const entitySummary = collectEntityIdPredicates(select.where_clause, tableNames, parameters);
-        const mergedEntityIds = mergeStringLiterals(pushdownEntityIds, entitySummary.literals);
-        const versionSummary = collectVersionIdPredicates(select.where_clause, tableNames, parameters);
-        const mergedVersionIds = mergeStringLiterals(pushdownVersionIds, versionSummary.literals);
-        const snapshotSummary = collectSnapshotJsonPredicates(select.where_clause, tableNames, parameters);
-        const mergedSnapshotFilters = mergeSnapshotFilters(pushdownSnapshotFilters, snapshotSummary);
-        const fileIds = shouldPushFileFilter(schemaKeys, mergedFileIds)
-            ? mergedFileIds
-            : [];
-        const entityIds = shouldPushEntityFilter(schemaKeys, mergedEntityIds)
-            ? mergedEntityIds
-            : [];
-        const columnSummary = collectSelectedColumns(select, tableNames);
-        const snapshotFilters = shouldPushSnapshotFilters(schemaKeys, mergedSnapshotFilters)
-            ? mergedSnapshotFilters
-            : [];
-        const pruneInheritance = pushdownPruneInheritance ||
-            shouldPruneInheritance(select.where_clause, tableNames, parameters);
-        const pruneTransactionSegment = pushdownPruneTransactions ||
-            shouldPruneTransactionSegment(select.where_clause, tableNames, parameters);
-        metadata.set(aliasKey, {
-            schemaKeys,
-            fileIds,
-            entityIds,
-            snapshotFilters,
-            versionIds: mergedVersionIds,
-            selectedColumns: columnSummary.selectedColumns,
-            hiddenColumns: new Set(columnSummary.requestedHiddenColumns),
-            supportColumns: new Set(columnSummary.supportColumns),
-            pruneInheritance,
-            pruneTransactionSegment,
-        });
-    }
-    return metadata;
-}
-function shouldPruneInheritance(whereClause, tableNames, parameters) {
-    return requiresNullPredicateForColumn(whereClause, tableNames, parameters, true);
-}
-function shouldPruneTransactionSegment(whereClause, tableNames, parameters) {
-    return excludesColumnLiteralFromExpression(whereClause, tableNames, parameters, "source_tag", "T", true);
-}
-function requiresNullPredicateForColumn(expression, tableNames, parameters, allowUnqualified) {
-    if (!expression) {
-        return false;
-    }
-    const context = {
-        tableNames,
-        parameters,
-        allowUnqualified,
-    };
-    return expressionRequiresNullForColumn(expression, "inherited_from_version_id", context);
-}
-function excludesColumnLiteralFromExpression(expression, tableNames, parameters, columnName, literal, allowUnqualified) {
-    if (!expression) {
-        return false;
-    }
-    const context = {
-        tableNames,
-        parameters,
-        allowUnqualified,
-    };
-    return expressionExcludesColumnLiteral(expression, columnName, literal, context);
-}
-function expressionExcludesColumnLiteral(expression, columnName, literal, context) {
-    if ("sql_text" in expression) {
-        return false;
-    }
-    switch (expression.node_kind) {
-        case "grouped_expression":
-            return expressionExcludesColumnLiteral(expression.expression, columnName, literal, context);
-        case "binary_expression":
-            if (expression.operator === "and") {
-                return (expressionExcludesColumnLiteral(expression.left, columnName, literal, context) ||
-                    expressionExcludesColumnLiteral(expression.right, columnName, literal, context));
-            }
-            if (expression.operator === "or") {
-                return (expressionExcludesColumnLiteral(expression.left, columnName, literal, context) &&
-                    expressionExcludesColumnLiteral(expression.right, columnName, literal, context));
-            }
-            return (columnComparisonExcludes(expression, expression.left, expression.right, columnName, literal, context) ||
-                columnComparisonExcludes(expression, expression.right, expression.left, columnName, literal, context));
-        case "in_list_expression": {
-            if (!isColumnReference(expression.operand, context, columnName)) {
-                return false;
-            }
-            const values = expression.items
-                .map((item) => extractStringLiteral(item, context))
-                .filter((value) => typeof value === "string");
-            if (values.length === 0) {
-                return false;
-            }
-            if (expression.negated) {
-                return values.includes(literal);
-            }
-            return !values.includes(literal);
-        }
-        default:
-            return false;
-    }
-}
-function columnComparisonExcludes(expression, columnSide, valueSide, columnName, literal, context) {
-    if (!isColumnReference(columnSide, context, columnName)) {
-        return false;
-    }
-    const value = extractStringLiteral(valueSide, context);
-    if (typeof value !== "string") {
-        return false;
-    }
-    switch (expression.operator) {
-        case "=":
-        case "is":
-            return value !== literal;
-        case "!=":
-        case "<>":
-        case "is_not":
-            return value === literal;
-        default:
-            return false;
-    }
-}
-function extractStringLiteral(expression, context) {
-    const node = unwrapExpression(expression);
-    if ("sql_text" in node) {
-        return null;
-    }
-    if (node.node_kind === "literal") {
-        return typeof node.value === "string" ? node.value : null;
-    }
-    if (node.node_kind === "parameter") {
-        return resolveParameterSchemaLiteral(node, context.parameters);
-    }
-    return null;
-}
-function createInlineVisitor(metadata, context) {
-    return {
-        table_reference(node) {
-            if (!isInternalStateTable(node)) {
-                return;
-            }
-            const aliasValue = getIdentifierValue(node.alias);
-            const aliasKey = aliasValue
-                ? normalizeIdentifierValue(aliasValue)
-                : DEFAULT_ALIAS_KEY;
-            const metadataEntry = metadata.get(aliasKey);
-            if (!metadataEntry) {
-                return;
-            }
-            const aliasForSql = aliasValue ??
-                getIdentifierValue(node.name.parts.at(-1) ?? null) ??
-                INTERNAL_STATE_VTABLE;
-            const inlineSql = buildVtableSelectRewrite({
-                schemaKeys: metadataEntry.schemaKeys,
-                fileIds: metadataEntry.fileIds,
-                entityIds: metadataEntry.entityIds,
-                snapshotFilters: metadataEntry.snapshotFilters,
-                versionIds: metadataEntry.versionIds,
-                cacheTables: context.getCacheTables(),
-                selectedColumns: metadataEntry.selectedColumns,
-                hiddenColumns: metadataEntry.hiddenColumns,
-                supportColumns: metadataEntry.supportColumns,
-                hasOpenTransaction: context.hasOpenTransaction(),
-                pruneInheritance: metadataEntry.pruneInheritance,
-                pruneTransactionSegment: metadataEntry.pruneTransactionSegment,
-                versionInheritance: context.getVersionInheritance
-                    ? context.getVersionInheritance()
-                    : undefined,
-            }).trimEnd();
-            const fragment = {
-                node_kind: "raw_fragment",
-                sql_text: `${inlineSql} AS ${quoteIdentifier(aliasForSql)}`,
-            };
-            return fragment;
-        },
-    };
-}
-function collectSchemaKeyPredicates(whereClause, tableNames, parameters, allowUnqualified = true) {
-    return collectColumnPredicates(whereClause, tableNames, parameters, "schema_key", allowUnqualified);
-}
-function collectSchemaKeyPredicatesFromExpression(expression, tableNames, parameters, allowUnqualified) {
-    return collectColumnPredicatesFromExpression(expression, tableNames, parameters, "schema_key", allowUnqualified);
-}
-function collectFileIdPredicates(whereClause, tableNames, parameters, allowUnqualified = true) {
-    return collectColumnPredicates(whereClause, tableNames, parameters, "file_id", allowUnqualified);
-}
-function collectFileIdPredicatesFromExpression(expression, tableNames, parameters, allowUnqualified) {
-    return collectColumnPredicatesFromExpression(expression, tableNames, parameters, "file_id", allowUnqualified);
-}
-function collectEntityIdPredicates(whereClause, tableNames, parameters, allowUnqualified = true) {
-    return collectColumnPredicates(whereClause, tableNames, parameters, "entity_id", allowUnqualified);
-}
-function collectEntityIdPredicatesFromExpression(expression, tableNames, parameters, allowUnqualified) {
-    return collectColumnPredicatesFromExpression(expression, tableNames, parameters, "entity_id", allowUnqualified);
-}
-function collectVersionIdPredicates(whereClause, tableNames, parameters, allowUnqualified = true) {
-    return collectColumnPredicates(whereClause, tableNames, parameters, "version_id", allowUnqualified);
-}
-function collectVersionIdPredicatesFromExpression(expression, tableNames, parameters, allowUnqualified) {
-    return collectColumnPredicatesFromExpression(expression, tableNames, parameters, "version_id", allowUnqualified);
-}
-function collectSnapshotJsonPredicates(whereClause, tableNames, parameters, allowUnqualified = true) {
-    if (!whereClause) {
-        return [];
-    }
-    const context = {
-        tableNames,
-        parameters,
-        allowUnqualified,
-    };
-    const summary = new Map();
-    collectSnapshotPredicatesFromExpression(whereClause, context, summary);
-    return snapshotSummaryToPredicates(summary);
-}
-function collectSnapshotJsonPredicatesFromExpression(expression, tableNames, parameters, allowUnqualified) {
-    if (!expression) {
-        return [];
-    }
-    const context = {
-        tableNames,
-        parameters,
-        allowUnqualified,
-    };
-    const summary = new Map();
-    collectSnapshotPredicatesFromExpression(expression, context, summary);
-    return snapshotSummaryToPredicates(summary);
-}
-function collectSnapshotPredicatesFromExpression(expression, context, summary) {
-    if ("sql_text" in expression) {
-        return;
-    }
-    switch (expression.node_kind) {
-        case "grouped_expression":
-            collectSnapshotPredicatesFromExpression(expression.expression, context, summary);
-            return;
-        case "binary_expression": {
-            if (isLogicalOperator(expression.operator)) {
-                collectSnapshotPredicatesFromExpression(expression.left, context, summary);
-                collectSnapshotPredicatesFromExpression(expression.right, context, summary);
-                return;
-            }
-            if (!isEqualityOperator(expression.operator)) {
-                return;
-            }
-            const leftPath = extractSnapshotJsonPath(expression.left, context);
-            if (leftPath) {
-                incrementSnapshotSummaryWithOperand(summary, leftPath, expression.right, context);
-            }
-            const rightPath = extractSnapshotJsonPath(expression.right, context);
-            if (rightPath) {
-                incrementSnapshotSummaryWithOperand(summary, rightPath, expression.left, context);
-            }
-            return;
-        }
-        case "in_list_expression": {
-            if (expression.negated) {
-                return;
-            }
-            const path = extractSnapshotJsonPath(expression.operand, context);
-            if (!path) {
-                return;
-            }
-            for (const item of expression.items) {
-                incrementSnapshotSummaryWithOperand(summary, path, item, context);
-            }
-            return;
-        }
-        case "unary_expression":
-            collectSnapshotPredicatesFromExpression(expression.operand, context, summary);
-            return;
-        default:
-            return;
-    }
-}
-function incrementSnapshotSummaryWithOperand(summary, path, operand, context) {
-    const value = extractStringLiteral(operand, context);
-    if (typeof value !== "string") {
-        return;
-    }
-    const existing = summary.get(path) ?? new Set();
-    existing.add(value);
-    summary.set(path, existing);
-}
-function snapshotSummaryToPredicates(summary) {
-    return Array.from(summary.entries()).map(([path, values]) => ({
-        path,
-        values: Array.from(values),
-    }));
-}
-function extractSnapshotJsonPath(expression, context) {
-    const node = unwrapExpression(expression);
-    if ("sql_text" in node) {
-        return null;
-    }
-    switch (node.node_kind) {
-        case "grouped_expression":
-            return extractSnapshotJsonPath(node.expression, context);
-        case "function_call": {
-            const functionName = node.name.value.toLowerCase();
-            if (functionName !== "json_extract") {
-                return null;
-            }
-            const [targetArg, pathArg] = node.arguments;
-            if (!targetArg ||
-                !pathArg ||
-                targetArg.node_kind === "all_columns" ||
-                pathArg.node_kind === "all_columns") {
-                return null;
-            }
-            const referencedColumn = resolveReferencedColumn(targetArg, context);
-            if (referencedColumn !== "snapshot_content") {
-                return null;
-            }
-            return extractLiteralString(pathArg, context.parameters);
-        }
-        default:
-            return null;
-    }
-}
-function collectColumnPredicates(whereClause, tableNames, parameters, columnName, allowUnqualified = true) {
-    if (!whereClause) {
-        return { count: 0, literals: [] };
-    }
-    const context = {
-        tableNames,
-        parameters,
-        allowUnqualified,
-    };
-    return visitExpression(whereClause, context, columnName);
-}
-function collectColumnPredicatesFromExpression(expression, tableNames, parameters, columnName, allowUnqualified) {
-    if (!expression) {
-        return { count: 0, literals: [] };
-    }
-    const context = {
-        tableNames,
-        parameters,
-        allowUnqualified,
-    };
-    return visitExpression(expression, context, columnName);
-}
-function expressionRequiresNullForColumn(expression, columnName, context) {
-    if ("sql_text" in expression) {
-        return false;
-    }
-    switch (expression.node_kind) {
-        case "grouped_expression":
-            return expressionRequiresNullForColumn(expression.expression, columnName, context);
-        case "binary_expression":
-            if (expression.operator === "and") {
-                return (expressionRequiresNullForColumn(expression.left, columnName, context) ||
-                    expressionRequiresNullForColumn(expression.right, columnName, context));
-            }
-            if (expression.operator === "or") {
-                return (expressionRequiresNullForColumn(expression.left, columnName, context) &&
-                    expressionRequiresNullForColumn(expression.right, columnName, context));
-            }
-            if (expression.operator === "is") {
-                const leftMatches = isColumnReference(expression.left, context, columnName);
-                const rightMatches = isColumnReference(expression.right, context, columnName);
-                if ((leftMatches &&
-                    isNullLiteralExpression(expression.right, context.parameters)) ||
-                    (rightMatches &&
-                        isNullLiteralExpression(expression.left, context.parameters))) {
-                    return true;
-                }
-            }
-            return false;
-        default:
-            return false;
-    }
-}
-function visitExpression(expression, context, columnName) {
-    if ("sql_text" in expression) {
-        return { count: 0, literals: [] };
-    }
-    switch (expression.node_kind) {
-        case "grouped_expression":
-            return visitExpression(expression.expression, context, columnName);
-        case "binary_expression":
-            return visitBinaryExpression(expression, context, columnName);
-        case "unary_expression":
-            return visitExpression(expression.operand, context, columnName);
-        case "in_list_expression":
-            return visitInListExpression(expression, context, columnName);
-        case "between_expression":
-            return visitBetweenExpression(expression, context, columnName);
-        case "column_reference":
-        case "literal":
-        case "parameter":
-        default:
-            return { count: 0, literals: [] };
-    }
-}
-function visitBinaryExpression(expression, context, columnName) {
-    if (isLogicalOperator(expression.operator)) {
-        return mergeSummaries(visitExpression(expression.left, context, columnName), visitExpression(expression.right, context, columnName));
-    }
-    if (!isEqualityOperator(expression.operator)) {
-        return { count: 0, literals: [] };
-    }
-    let summary = {
-        count: 0,
-        literals: [],
-    };
-    const leftMatches = isColumnReference(expression.left, context, columnName);
-    const rightMatches = isColumnReference(expression.right, context, columnName);
-    if (leftMatches) {
-        summary = incrementSummaryWithOperand(summary, expression.right, context);
-    }
-    if (rightMatches) {
-        summary = incrementSummaryWithOperand(summary, expression.left, context);
-    }
-    return summary;
-}
-function visitInListExpression(expression, context, columnName) {
-    if (!isColumnReference(expression.operand, context, columnName)) {
-        return { count: 0, literals: [] };
-    }
-    let summary = {
-        count: 1,
-        literals: [],
-    };
-    for (const item of expression.items) {
-        summary = incrementSummaryWithOperand(summary, item, context);
-    }
-    return summary;
-}
-function visitBetweenExpression(expression, context, columnName) {
-    if (!isColumnReference(expression.operand, context, columnName)) {
-        return { count: 0, literals: [] };
-    }
-    let summary = {
-        count: 1,
-        literals: [],
-    };
-    summary = incrementSummaryWithOperand(summary, expression.start, context);
-    summary = incrementSummaryWithOperand(summary, expression.end, context);
-    return summary;
-}
-function incrementSummaryWithOperand(summary, operand, context) {
-    const next = { ...summary };
-    const node = unwrapExpression(operand);
-    switch (node.node_kind) {
-        case "literal":
-            if (typeof node.value === "string") {
-                next.literals.push(node.value);
-            }
-            break;
-        case "parameter": {
-            const resolved = resolveParameterSchemaLiteral(node, context.parameters);
-            if (typeof resolved === "string") {
-                next.literals.push(resolved);
-            }
-            break;
-        }
-        default:
-            break;
-    }
-    next.count += 1;
-    return next;
-}
-function isNullLiteralExpression(expression, parameters) {
-    const node = unwrapExpression(expression);
-    if ("sql_text" in node) {
-        return false;
-    }
-    if (node.node_kind === "literal") {
-        return node.value === null;
-    }
-    if (node.node_kind === "parameter") {
-        return resolveParameterValue(node, parameters) === null;
-    }
-    return false;
-}
-function resolveParameterSchemaLiteral(parameter, parameters) {
-    const value = resolveParameterValue(parameter, parameters);
-    return typeof value === "string" ? value : null;
-}
-function resolveParameterValue(parameter, parameters) {
-    const index = parameter.position;
-    if (typeof index === "number" && index >= 0 && index < parameters.length) {
-        return parameters[index];
-    }
-    return undefined;
-}
-function unwrapExpression(expression) {
-    if ("sql_text" in expression) {
-        return expression;
-    }
-    if (expression.node_kind === "grouped_expression") {
-        return unwrapExpression(expression.expression);
-    }
-    return expression;
-}
-function isColumnReference(expression, context, expectedColumn) {
-    const column = resolveReferencedColumn(expression, context);
-    return column === expectedColumn;
-}
-function resolveReferencedColumn(expression, context) {
-    if ("sql_text" in expression) {
-        return null;
-    }
-    switch (expression.node_kind) {
-        case "column_reference": {
-            const qualifier = getColumnQualifier(expression);
-            const columnName = getColumnName(expression);
-            if (qualifier && context.tableNames.has(qualifier)) {
-                return columnName;
-            }
-            if (!qualifier && context.allowUnqualified) {
-                return columnName;
-            }
-            return null;
-        }
-        case "grouped_expression":
-            return resolveReferencedColumn(expression.expression, context);
-        case "function_call":
-            return resolveColumnFromFunctionCall(expression, context);
-        default:
-            return null;
-    }
-}
-function resolveColumnFromFunctionCall(expression, context) {
-    const functionName = expression.name.value.toLowerCase();
-    if (functionName !== "json_extract") {
-        return null;
-    }
-    const [target, pathArg] = expression.arguments;
-    if (!target ||
-        !pathArg ||
-        target.node_kind === "all_columns" ||
-        pathArg.node_kind === "all_columns") {
-        return null;
-    }
-    const targetExpr = target;
-    const referencedColumn = resolveReferencedColumn(targetExpr, context);
-    if (referencedColumn !== "snapshot_content") {
-        return null;
-    }
-    if (!SNAPSHOT_ENTITY_FILTER_PUSH_ENABLED) {
-        return null;
-    }
-    const pathExpression = pathArg;
-    const literalPath = extractLiteralString(pathExpression, context.parameters);
-    if (!literalPath) {
-        return null;
-    }
-    return mapSnapshotJsonColumnFromPath(literalPath);
-}
-function extractLiteralString(expression, parameters) {
-    const node = unwrapExpression(expression);
-    if ("sql_text" in node) {
-        return null;
-    }
-    if (node.node_kind === "literal" && typeof node.value === "string") {
-        return node.value;
-    }
-    if (node.node_kind === "parameter") {
-        const value = resolveParameterValue(node, parameters);
-        return typeof value === "string" ? value : null;
-    }
-    return null;
-}
-/**
- * Maps recognized json_extract paths to their corresponding physical columns.
- *
- * @param path - JSON path literal extracted from a json_extract() call.
- * @returns The name of the backing column or null when the path is unsupported.
- *
- * @example
- * ```ts
- * mapSnapshotJsonColumnFromPath("$.id");
- * // => "entity_id"
- * ```
- */
-function mapSnapshotJsonColumnFromPath(path) {
-    const trimmed = path.trim();
-    const candidates = new Set([trimmed]);
-    const unquoted = trimmed.replace(/\."([^"]+)"(?=\.|$)/g, (_, segment) => `.${segment}`);
-    candidates.add(unquoted);
-    for (const candidate of candidates) {
-        if (SNAPSHOT_JSON_ENTITY_PATHS.has(candidate)) {
-            return "entity_id";
-        }
-    }
-    return null;
-}
-function isLogicalOperator(operator) {
-    return operator === "and" || operator === "or";
-}
-function isEqualityOperator(operator) {
-    return operator === "=" || operator === "is";
-}
-function mergeSummaries(...summaries) {
-    return summaries.reduce((accumulator, current) => {
-        accumulator.count += current.count;
-        accumulator.literals.push(...current.literals);
-        return accumulator;
-    }, { count: 0, literals: [] });
-}
-function mergeStringLiterals(...lists) {
-    const seen = new Set();
-    const merged = [];
-    for (const list of lists) {
-        for (const item of list) {
-            if (typeof item !== "string") {
-                continue;
-            }
-            if (!seen.has(item)) {
-                seen.add(item);
-                merged.push(item);
-            }
-        }
-    }
-    return merged;
-}
-function mergeSnapshotFilters(...lists) {
-    const merged = new Map();
-    for (const list of lists) {
-        if (!list) {
-            continue;
-        }
-        for (const entry of list) {
-            if (!entry || typeof entry.path !== "string") {
-                continue;
-            }
-            const valueSet = merged.get(entry.path) ?? new Set();
-            for (const value of entry.values ?? []) {
-                if (typeof value === "string") {
-                    valueSet.add(value);
-                }
-            }
-            if (valueSet.size > 0) {
-                merged.set(entry.path, valueSet);
-            }
-        }
-    }
-    return Array.from(merged.entries()).map(([path, values]) => ({
-        path,
-        values: Array.from(values),
-    }));
-}
-function collectSelectedColumns(select, tableNames) {
-    const hiddenSelections = new Set();
-    const supportColumns = new Set();
-    if (select.projection.length === 0) {
-        return {
-            selectedColumns: null,
-            requestedHiddenColumns: hiddenSelections,
-            supportColumns,
-        };
-    }
-    const order = [];
-    const entries = new Map();
-    let hasUnresolvedProjection = false;
-    let selectsAll = false;
-    for (const item of select.projection) {
-        if (isSelectAllForTable(item, tableNames)) {
-            selectsAll = true;
-            continue;
-        }
-        if (item.node_kind !== "select_expression") {
-            hasUnresolvedProjection = true;
-            continue;
-        }
-        const columnName = extractColumnFromExpression(item.expression, tableNames);
-        if (!columnName) {
-            hasUnresolvedProjection = true;
-            continue;
-        }
-        if (HIDDEN_SEGMENT_COLUMN_SET.has(columnName)) {
-            hiddenSelections.add(columnName);
-        }
-        const alias = getIdentifierValue(item.alias);
-        if (!entries.has(columnName)) {
-            order.push(columnName);
-            entries.set(columnName, {
-                column: columnName,
-                alias: alias ?? null,
-            });
-        }
-        else if (alias) {
-            const existing = entries.get(columnName);
-            if (existing.alias === null) {
-                entries.set(columnName, {
-                    column: columnName,
-                    alias,
-                });
-            }
-        }
-    }
-    const referenced = collectReferencedColumnSummary(select, tableNames);
-    if (referenced.hasUnknownReferences) {
-        hasUnresolvedProjection = true;
-    }
-    for (const column of referenced.columns) {
-        if (HIDDEN_SEGMENT_COLUMN_SET.has(column)) {
-            hiddenSelections.add(column);
-        }
-        if (!entries.has(column)) {
-            supportColumns.add(column);
-        }
-    }
-    if (hasUnresolvedProjection || selectsAll) {
-        return {
-            selectedColumns: null,
-            requestedHiddenColumns: hiddenSelections,
-            supportColumns,
-        };
-    }
-    return {
-        selectedColumns: order.map((column) => entries.get(column)),
-        requestedHiddenColumns: hiddenSelections,
-        supportColumns,
-    };
-}
-function collectReferencedColumnSummary(select, tableNames) {
-    const columns = new Set();
-    let hasUnknownReferences = false;
-    const visit = (expression) => {
-        if (hasUnknownReferences || !expression) {
-            return;
-        }
-        if ("sql_text" in expression) {
-            hasUnknownReferences = true;
-            return;
-        }
-        switch (expression.node_kind) {
-            case "column_reference": {
-                const qualifier = getColumnQualifier(expression);
-                if (qualifier && !tableNames.has(qualifier)) {
-                    return;
-                }
-                const columnName = getColumnName(expression);
-                if (columnName) {
-                    columns.add(columnName);
-                }
-                return;
-            }
-            case "binary_expression":
-                visit(expression.left);
-                visit(expression.right);
-                return;
-            case "unary_expression":
-                visit(expression.operand);
-                return;
-            case "grouped_expression":
-                visit(expression.expression);
-                return;
-            case "function_call":
-                for (const argument of expression.arguments) {
-                    if (argument.node_kind === "all_columns") {
-                        continue;
-                    }
-                    visit(argument);
-                }
-                return;
-            case "in_list_expression":
-                visit(expression.operand);
-                for (const item of expression.items) {
-                    visit(item);
-                }
-                return;
-            case "between_expression":
-                visit(expression.operand);
-                visit(expression.start);
-                visit(expression.end);
-                return;
-            case "subquery_expression":
-                hasUnknownReferences = true;
-                return;
-            case "literal":
-            case "parameter":
-                return;
-            default:
-                return;
-        }
-    };
-    visit(select.where_clause);
-    for (const clause of select.from_clauses) {
-        for (const join of clause.joins) {
-            visit(join.on_expression);
-        }
-    }
-    for (const order of select.order_by) {
-        visit(order.expression);
-    }
-    return { columns, hasUnknownReferences };
-}
-function extractColumnFromExpression(expression, tableNames) {
-    if ("sql_text" in expression) {
-        return null;
-    }
-    switch (expression.node_kind) {
-        case "column_reference": {
-            const qualifier = getColumnQualifier(expression);
-            if (qualifier && !tableNames.has(qualifier)) {
-                return null;
-            }
-            return getColumnName(expression);
-        }
-        case "grouped_expression":
-            return extractColumnFromExpression(expression.expression, tableNames);
-        case "function_call":
-            return extractColumnFromFunctionCall(expression, tableNames);
-        default:
-            return null;
-    }
-}
-function extractColumnFromFunctionCall(expression, tableNames) {
-    let referencedColumn = null;
-    for (const argument of expression.arguments) {
-        if (argument.node_kind === "all_columns") {
-            return null;
-        }
-        const extracted = extractColumnFromExpression(argument, tableNames);
-        if (extracted) {
-            if (referencedColumn && referencedColumn !== extracted) {
-                return null;
-            }
-            referencedColumn = extracted;
-            continue;
-        }
-        if (!isLiteralOrParameter(argument)) {
-            return null;
-        }
-    }
-    return referencedColumn;
-}
-function isLiteralOrParameter(expression) {
-    if ("sql_text" in expression) {
-        return false;
-    }
-    switch (expression.node_kind) {
-        case "literal":
-        case "parameter":
-            return true;
-        case "grouped_expression":
-            return isLiteralOrParameter(expression.expression);
-        default:
-            return false;
-    }
-}
-function determineProjectionKind(projection, tableNames) {
-    for (const item of projection) {
-        if (isSelectAllForTable(item, tableNames)) {
-            return "selectAll";
-        }
-    }
-    return "partial";
-}
-function buildTraceEntry(args) {
-    const { aliasList, schemaSummary, projectionKind, selectedColumns } = args;
-    const referenceCount = aliasList.length === 0 ? 1 : aliasList.length;
-    return {
-        step: "rewrite_vtable_selects",
-        payload: {
-            reference_count: referenceCount,
-            aliases: aliasList,
-            projection: projectionKind,
-            schema_key_predicates: schemaSummary.count,
-            schema_key_literals: schemaSummary.literals,
-            selected_columns: selectedColumns
-                ? selectedColumns.map((entry) => entry.column)
-                : null,
-        },
-    };
-}
-function buildVtableSelectRewrite(options) {
-    const schemaFilterList = options.schemaKeys ?? [];
-    const requestedVersionIds = Array.from(new Set(options.versionIds ?? []));
-    const wantedVersionsCteName = requestedVersionIds.length > 0 ? "wanted_versions" : null;
-    const { candidateColumns, rankedColumns } = buildProjectionColumnSet(options.selectedColumns, options.hiddenColumns, options.supportColumns);
-    candidateColumns.add("priority");
-    rankedColumns.add("priority");
-    const inheritancePlan = determineInheritancePlan({
-        requestedVersionIds: options.versionIds,
-        versionInheritance: options.versionInheritance,
-        forcedPrune: options.pruneInheritance,
-    });
-    const schemaFilter = buildSchemaFilter(schemaFilterList);
-    const fileFilter = options.fileIds && options.fileIds.length > 0
-        ? buildFileFilter(options.fileIds)
-        : null;
-    const entityFilter = options.entityIds && options.entityIds.length > 0
-        ? buildEntityFilter(options.entityIds)
-        : null;
-    const snapshotFilter = buildSnapshotContentFilter(options.snapshotFilters);
-    const txnFilter = combineFilters(schemaFilter, fileFilter, entityFilter, snapshotFilter);
-    const inheritedFilter = combineFilters(schemaFilter, fileFilter, entityFilter, snapshotFilter);
-    const buildVersionJoin = (alias, joinAlias) => buildWantedVersionJoinClause(wantedVersionsCteName, alias, joinAlias);
-    const txnVersionJoin = buildVersionJoin("txn", "wv_txn");
-    const untrackedVersionJoin = buildVersionJoin("unt", "wv_unt");
-    const cacheVersionJoin = buildVersionJoin("cache", "wv_cache");
-    const inheritanceVersionJoin = buildVersionJoin("vi", "wv_vi");
-    const parentVersionJoin = buildVersionJoin("vi", "wv_parent");
-    const needsWriterJoin = candidateColumns.has("writer_key");
-    if (needsWriterJoin) {
-        candidateColumns.add("inherited_from_version_id");
-        rankedColumns.add("inherited_from_version_id");
-    }
-    const needsChangeJoin = candidateColumns.has("metadata");
-    const projectionSql = buildRewriteProjectionSql(options.selectedColumns, {
-        supportColumns: options.supportColumns,
-        needsWriterJoin,
-        candidateColumns,
-    });
-    const cacheSource = buildCacheSource(schemaFilterList, options.cacheTables, candidateColumns);
-    const rankingOrder = [
-        "c.priority",
-        "c.created_at DESC",
-        "c.file_id",
-        "c.schema_key",
-        "c.entity_id",
-        "c.version_id",
-        "c.change_id",
-    ];
-    const segments = [];
-    if (options.hasOpenTransaction !== false &&
-        !options.pruneTransactionSegment) {
-        segments.push(buildTransactionSegment(txnFilter, candidateColumns, txnVersionJoin));
-    }
-    segments.push(buildUntrackedSegment(txnFilter, candidateColumns, untrackedVersionJoin));
-    const cacheSegment = buildCacheSegment(cacheSource, txnFilter, candidateColumns, cacheVersionJoin);
-    if (cacheSegment) {
-        segments.push(cacheSegment);
-    }
-    const shouldPruneInheritance = inheritancePlan.mode === "pruned";
-    let inheritanceJoinSource = "version_inheritance vi";
-    let parentJoinSource = "version_parent vi";
-    if (inheritancePlan.mode === "inline") {
-        inheritanceJoinSource = buildInlineInheritanceSource(inheritancePlan.versionAncestorPairs);
-        parentJoinSource = buildInlineParentSource(inheritancePlan.parentPairs);
-    }
-    let allSegments = segments;
-    if (!shouldPruneInheritance) {
-        const inheritedSegments = [];
-        if (cacheSegment) {
-            const inheritedCache = buildInheritedCacheSegment(cacheSource, inheritedFilter, candidateColumns, inheritanceJoinSource, inheritanceVersionJoin);
-            if (inheritedCache) {
-                inheritedSegments.push(inheritedCache);
-            }
-        }
-        inheritedSegments.push(buildInheritedUntrackedSegment(inheritedFilter, candidateColumns, inheritanceJoinSource, inheritanceVersionJoin));
-        if (options.hasOpenTransaction !== false) {
-            inheritedSegments.push(buildInheritedTransactionSegment(inheritedFilter, candidateColumns, parentJoinSource, parentVersionJoin));
-        }
-        allSegments = segments.concat(inheritedSegments);
-    }
-    const candidates = allSegments.join(`\n\n    UNION ALL\n\n`);
-    const writerJoinSql = needsWriterJoin
-        ? `
-LEFT JOIN lix_internal_state_writer ws_dst ON
-  ws_dst.file_id = w.file_id AND
-  ws_dst.entity_id = w.entity_id AND
-  ws_dst.schema_key = w.schema_key AND
-  ws_dst.version_id = w.version_id
-LEFT JOIN lix_internal_state_writer ws_src ON
-  ws_src.file_id = w.file_id AND
-  ws_src.entity_id = w.entity_id AND
-  ws_src.schema_key = w.schema_key AND
-  ws_src.version_id = w.inherited_from_version_id`
-        : "";
-    const changeJoinSql = needsChangeJoin
-        ? `
-LEFT JOIN lix_internal_change chc ON chc.id = w.change_id`
-        : "";
-    const transactionJoinSql = options.hasOpenTransaction !== false
-        ? `
-LEFT JOIN lix_internal_transaction_state itx ON itx.id = w.change_id`
-        : "";
-    const rankedSql = buildRankedSegment({
-        projectionColumns: rankedColumns,
-        rankingOrder,
-        candidatesSql: candidates,
-    });
-    const withClauses = [];
-    if (wantedVersionsCteName) {
-        withClauses.push(buildWantedVersionsCte(wantedVersionsCteName, requestedVersionIds));
-    }
-    if (inheritancePlan.mode === "recursive") {
-        withClauses.push(buildVersionDescriptorCte());
-        withClauses.push(buildVersionInheritanceCte(wantedVersionsCteName));
-        withClauses.push(buildVersionParentCte(wantedVersionsCteName));
-    }
-    const withPrefix = withClauses.length > 0
-        ? `WITH
-${withClauses.map((clause) => indent(clause, 2)).join(",\n")}
-`
-        : "";
-    const body = `${withPrefix}SELECT
-${indent(projectionSql, 2)}
-FROM (
-${indent(rankedSql, 2)}
-) AS w
-${writerJoinSql}
-${changeJoinSql}
-${transactionJoinSql}
-WHERE w.rn = 1`;
-    return `(\n${body}\n)\n`;
-}
-function buildRewriteProjectionSql(selectedColumns, options) {
-    const builder = internalQueryBuilder;
-    const baseQuery = builder.selectFrom(`${INTERNAL_STATE_VTABLE} as w`);
-    const supportEntries = selectedColumns === null
-        ? []
-        : Array.from(options.supportColumns)
-            .filter((column) => !selectedColumns.some((entry) => entry.column === column) &&
-            !INTERNAL_ONLY_COLUMN_SET.has(column))
-            .map((column) => ({
-            column,
-            alias: null,
-        }));
-    const combinedEntries = selectedColumns === null ? null : [...selectedColumns, ...supportEntries];
-    const query = combinedEntries === null || combinedEntries.length === 0
-        ? undefined
-        : baseQuery.select((eb) => combinedEntries.map((entry) => {
-            if (options.needsWriterJoin && entry.column === "writer_key") {
-                return eb.fn
-                    .coalesce(eb.ref("ws_dst.writer_key"), eb.ref("ws_src.writer_key"), eb.ref("w.writer_key"))
-                    .as(entry.column);
-            }
-            return eb.ref(`w.${entry.column}`).as(entry.column);
-        }));
-    if (!query) {
-        const defaultColumns = buildDefaultProjectionColumns(options.candidateColumns);
-        return defaultColumns
-            .map((column) => options.needsWriterJoin && column === "writer_key"
-            ? `COALESCE(ws_dst.writer_key, ws_src.writer_key, w.writer_key) AS ${quoteIdentifier(column)}`
-            : `w.${quoteIdentifier(column)} AS ${quoteIdentifier(column)}`)
-            .join(",\n");
-    }
-    const { sql } = query.compile();
-    const match = sql.match(/^select\s+(?<projection>[\s\S]+?)\s+from\s+/i);
-    return match?.groups?.projection?.trim() ?? sql;
-}
-function buildDefaultProjectionColumns(candidateColumns) {
-    const ordered = PROJECTION_COLUMN_ORDER.filter((column) => !INTERNAL_ONLY_COLUMN_SET.has(column) && candidateColumns.has(column));
-    const additional = Array.from(candidateColumns).filter((column) => !INTERNAL_ONLY_COLUMN_SET.has(column) && !ordered.includes(column));
-    return ordered.concat(additional.sort());
-}
-function buildProjectionColumnSet(selectedColumns, hiddenColumns, supportColumns) {
-    const requestedHiddenColumns = new Set(hiddenColumns);
-    const seedColumns = selectedColumns === null
-        ? ALL_SEGMENT_COLUMNS
-        : Array.from(BASE_SEGMENT_COLUMNS);
-    const candidateColumns = new Set();
-    const rankedColumns = new Set();
-    for (const column of seedColumns) {
-        if (HIDDEN_SEGMENT_COLUMN_SET.has(column) &&
-            !requestedHiddenColumns.has(column)) {
-            continue;
-        }
-        candidateColumns.add(column);
-        rankedColumns.add(column);
-    }
-    if (selectedColumns && selectedColumns.length > 0) {
-        for (const entry of selectedColumns) {
-            candidateColumns.add(entry.column);
-            rankedColumns.add(entry.column);
-        }
-    }
-    for (const column of supportColumns) {
-        candidateColumns.add(column);
-        rankedColumns.add(column);
-    }
-    for (const hiddenColumn of requestedHiddenColumns) {
-        candidateColumns.add(hiddenColumn);
-        rankedColumns.add(hiddenColumn);
-    }
-    for (const hiddenColumn of HIDDEN_SEGMENT_COLUMN_SET) {
-        if (!requestedHiddenColumns.has(hiddenColumn)) {
-            candidateColumns.delete(hiddenColumn);
-            rankedColumns.delete(hiddenColumn);
-        }
-    }
-    // Internal rewrites rely on snapshot_content for JSON decoding and cache filtering.
-    candidateColumns.add("snapshot_content");
-    rankedColumns.add("snapshot_content");
-    return { candidateColumns, rankedColumns };
-}
-const NEWLINE = "\n";
-const ALL_SEGMENT_COLUMNS = [
-    "_pk",
-    "source_tag",
-    "entity_id",
-    "schema_key",
-    "file_id",
-    "plugin_key",
-    "snapshot_content",
-    "schema_version",
-    "version_id",
-    "created_at",
-    "updated_at",
-    "inherited_from_version_id",
-    "change_id",
-    "untracked",
-    "commit_id",
-    "metadata",
-    "writer_key",
-    "priority",
-];
-const BASE_SEGMENT_COLUMNS = new Set([
-    "entity_id",
-    "schema_key",
-    "file_id",
-    "version_id",
-    "created_at",
-    "change_id",
-    "priority",
-]);
-const CACHE_COLUMNS = [
-    "entity_id",
-    "schema_key",
-    "file_id",
-    "plugin_key",
-    "snapshot_content",
-    "schema_version",
-    "version_id",
-    "created_at",
-    "updated_at",
-    "inherited_from_version_id",
-    "change_id",
-    "commit_id",
-    "is_tombstone",
-];
-const PROJECTION_COLUMN_ORDER = ALL_SEGMENT_COLUMNS.filter((column) => column !== "priority");
-const INTERNAL_ONLY_COLUMN_SET = new Set(["priority", "rn"]);
-function buildTransactionSegment(segmentFilter, projectionColumns, versionJoinClause) {
-    const rewrittenFilter = rewriteFilterForAlias(segmentFilter, "txn");
-    const filterClause = rewrittenFilter ? `WHERE ${rewrittenFilter}` : "";
-    const columns = [
-        [
-            "_pk",
-            `'T' || '~' || lix_encode_pk_part(txn.file_id) || '~' || lix_encode_pk_part(txn.entity_id) || '~' || lix_encode_pk_part(txn.version_id) AS _pk`,
-        ],
-        ["source_tag", "'T' AS source_tag"],
-        ["entity_id", "txn.entity_id AS entity_id"],
-        ["schema_key", "txn.schema_key AS schema_key"],
-        ["file_id", "txn.file_id AS file_id"],
-        ["plugin_key", "txn.plugin_key AS plugin_key"],
-        ["snapshot_content", "json(txn.snapshot_content) AS snapshot_content"],
-        ["schema_version", "txn.schema_version AS schema_version"],
-        ["version_id", "txn.version_id AS version_id"],
-        ["created_at", "txn.created_at AS created_at"],
-        ["updated_at", "txn.created_at AS updated_at"],
-        ["inherited_from_version_id", "NULL AS inherited_from_version_id"],
-        ["change_id", "txn.id AS change_id"],
-        ["untracked", "txn.untracked AS untracked"],
-        ["commit_id", "'pending' AS commit_id"],
-        ["metadata", "json(txn.metadata) AS metadata"],
-        ["writer_key", "txn.writer_key AS writer_key"],
-        ["priority", "1 AS priority"],
-    ];
-    const columnSql = columns
-        .filter(([column]) => projectionColumns.has(column))
-        .map(([, sql]) => sql)
-        .join(",\n");
-    const joinClause = versionJoinClause ? `\n\t\t${versionJoinClause}` : "";
-    return stripIndent(`
-		SELECT
-${indent(columnSql, 4)}
-		FROM lix_internal_transaction_state txn${joinClause}
-		${filterClause}
-	`).trimEnd();
-}
-function buildUntrackedSegment(segmentFilter, projectionColumns, versionJoinClause) {
-    const rewrittenFilter = rewriteFilterForAlias(segmentFilter, "unt");
-    const columns = [
-        [
-            "_pk",
-            `'U' || '~' || lix_encode_pk_part(unt.file_id) || '~' || lix_encode_pk_part(unt.entity_id) || '~' || lix_encode_pk_part(unt.version_id) AS _pk`,
-        ],
-        ["source_tag", "'U' AS source_tag"],
-        ["entity_id", "unt.entity_id AS entity_id"],
-        ["schema_key", "unt.schema_key AS schema_key"],
-        ["file_id", "unt.file_id AS file_id"],
-        ["plugin_key", "unt.plugin_key AS plugin_key"],
-        ["snapshot_content", "json(unt.snapshot_content) AS snapshot_content"],
-        ["schema_version", "unt.schema_version AS schema_version"],
-        ["version_id", "unt.version_id AS version_id"],
-        ["created_at", "unt.created_at AS created_at"],
-        ["updated_at", "unt.updated_at AS updated_at"],
-        ["inherited_from_version_id", "NULL AS inherited_from_version_id"],
-        ["change_id", "'untracked' AS change_id"],
-        ["untracked", "1 AS untracked"],
-        ["commit_id", "'untracked' AS commit_id"],
-        ["metadata", "NULL AS metadata"],
-        ["writer_key", "NULL AS writer_key"],
-        ["priority", "2 AS priority"],
-    ];
-    const columnSql = columns
-        .filter(([column]) => projectionColumns.has(column))
-        .map(([, sql]) => sql)
-        .join(",\n");
-    const joinClause = versionJoinClause ? `\n\t\t${versionJoinClause}` : "";
-    return stripIndent(`
-		SELECT
-${indent(columnSql, 4)}
-		FROM lix_internal_state_all_untracked unt${joinClause}
-		${rewrittenFilter ? `WHERE ${rewrittenFilter}` : ""}
-	`).trimEnd();
-}
-function buildCacheSegment(cacheSource, segmentFilter, projectionColumns, versionJoinClause) {
-    if (!cacheSource) {
-        return null;
-    }
-    const rewrittenFilter = rewriteFilterForAlias(segmentFilter, "cache");
-    const sourceKeyword = cacheSource.trim().toLowerCase();
-    const sourceSql = sourceKeyword.startsWith("select")
-        ? `(${cacheSource})`
-        : cacheSource;
-    const columns = [
-        [
-            "_pk",
-            `'C' || '~' || lix_encode_pk_part(cache.file_id) || '~' || lix_encode_pk_part(cache.entity_id) || '~' || lix_encode_pk_part(cache.version_id) AS _pk`,
-        ],
-        ["source_tag", "'C' AS source_tag"],
-        ["entity_id", "cache.entity_id AS entity_id"],
-        ["schema_key", "cache.schema_key AS schema_key"],
-        ["file_id", "cache.file_id AS file_id"],
-        ["plugin_key", "cache.plugin_key AS plugin_key"],
-        ["snapshot_content", "json(cache.snapshot_content) AS snapshot_content"],
-        ["schema_version", "cache.schema_version AS schema_version"],
-        ["version_id", "cache.version_id AS version_id"],
-        ["created_at", "cache.created_at AS created_at"],
-        ["updated_at", "cache.updated_at AS updated_at"],
-        [
-            "inherited_from_version_id",
-            "cache.inherited_from_version_id AS inherited_from_version_id",
-        ],
-        ["change_id", "cache.change_id AS change_id"],
-        ["untracked", "0 AS untracked"],
-        ["commit_id", "cache.commit_id AS commit_id"],
-        ["metadata", "NULL AS metadata"],
-        ["writer_key", "NULL AS writer_key"],
-        ["priority", "3 AS priority"],
-    ];
-    const columnSql = columns
-        .filter(([column]) => projectionColumns.has(column))
-        .map(([, sql]) => sql)
-        .join(",\n");
-    const whereClause = rewrittenFilter ? `\n\t\tWHERE ${rewrittenFilter}` : "";
-    const joinClause = versionJoinClause ? `\n\t\t${versionJoinClause}` : "";
-    return stripIndent(`
-		SELECT
-${indent(columnSql, 4)}
-		FROM ${sourceSql} cache${joinClause}${whereClause}
-	`).trimEnd();
-}
-/**
- * Builds the base CTE extracting version descriptors for inheritance lookups.
- *
- * @returns SQL fragment for the version descriptor base CTE.
- *
- * @example
- * ```ts
- * const sql = buildVersionDescriptorCte();
- * ```
- */
-function buildVersionDescriptorCte() {
-    return stripIndent(`
-	version_descriptor_base AS (
-	  SELECT
-	    json_extract(desc.snapshot_content, '$.id') AS version_id,
-	    json_extract(desc.snapshot_content, '$.inherits_from_version_id') AS inherits_from_version_id
-	  FROM "lix_internal_state_cache_v1_lix_version_descriptor" desc
-	  WHERE desc.is_tombstone = 0
-	    AND desc.snapshot_content IS NOT NULL
-	)`).trim();
-}
-/**
- * Builds the recursive CTE that unfolds the full inheritance chain.
- *
- * @param seedCteName - Optional wanted version CTE that limits recursion seeds.
- * @returns SQL fragment for the version inheritance CTE.
- *
- * @example
- * ```ts
- * const sql = buildVersionInheritanceCte("wanted_versions");
- * ```
- */
-function buildVersionInheritanceCte(seedCteName) {
-    const seedJoin = seedCteName
-        ? `
-	  JOIN ${seedCteName} wv ON wv.version_id = vdb.version_id`
-        : "";
-    return stripIndent(`
-	version_inheritance(version_id, ancestor_version_id) AS (
-	  SELECT
-	    vdb.version_id,
-	    vdb.inherits_from_version_id
-	  FROM version_descriptor_base vdb${seedJoin}
-	  WHERE vdb.inherits_from_version_id IS NOT NULL
-
-	  UNION ALL
-
-	  SELECT
-	    vi.version_id,
-	    vdb.inherits_from_version_id
-	  FROM version_inheritance vi
-	  JOIN version_descriptor_base vdb ON vdb.version_id = vi.ancestor_version_id
-	  WHERE vdb.inherits_from_version_id IS NOT NULL
-	)`).trim();
-}
-/**
- * Builds the CTE mapping each version to its direct parent version.
- *
- * @param seedCteName - Optional wanted version CTE limiting descriptors.
- * @returns SQL fragment for the version parent CTE.
- *
- * @example
- * ```ts
- * const sql = buildVersionParentCte("wanted_versions");
- * ```
- */
-function buildVersionParentCte(seedCteName) {
-    const seedJoin = seedCteName
-        ? `
-	  JOIN ${seedCteName} wv ON wv.version_id = vdb.version_id`
-        : "";
-    return stripIndent(`
-	version_parent AS (
-	  SELECT
-	    vdb.version_id,
-	    vdb.inherits_from_version_id AS parent_version_id
-	  FROM version_descriptor_base vdb${seedJoin}
-	  WHERE vdb.inherits_from_version_id IS NOT NULL
-	)`).trim();
-}
-/**
- * Builds a CTE enumerating the requested versions for join-based filters.
- *
- * @param cteName - The identifier assigned to the CTE.
- * @param versionIds - Ordered list of version identifiers to include.
- * @returns SQL fragment for the wanted versions CTE.
- *
- * @example
- * ```ts
- * const sql = buildWantedVersionsCte("wanted_versions", ["v1", "v2"]);
- * ```
- */
-function buildWantedVersionsCte(cteName, versionIds) {
-    const selects = versionIds
-        .map((versionId) => `SELECT '${escapeSqlLiteral(versionId)}' AS version_id`)
-        .join("\nUNION ALL\n");
-    return stripIndent(`
-${cteName} AS (
-${indent(selects, 2)}
-)`).trim();
-}
-/**
- * Builds the inherited cache candidate segment that maps ancestor versions onto
- * the target schema version.
- *
- * @param cacheSource - The SQL producing the cache rows.
- * @param segmentFilter - Optional predicate scoped to the cache alias.
- * @param projectionColumns - Columns required for the projection.
- * @param versionJoinClause - SQL equi-join tying descendants to wanted versions.
- * @returns SQL fragment or null when no cache source exists.
- *
- * @example
- * ```ts
- * const sql = buildInheritedCacheSegment(
- *   '"cache_table"',
- *   "txn.schema_key = 'demo'",
- *   new Set(),
- *   "version_inheritance vi",
- *   "JOIN wanted_versions wv ON wv.version_id = vi.version_id"
- * );
- * ```
- */
-function buildInheritedCacheSegment(cacheSource, segmentFilter, projectionColumns, inheritanceJoin, versionJoinClause) {
-    if (!cacheSource) {
-        return null;
-    }
-    const rewrittenFilter = rewriteFilterForAlias(segmentFilter, "cache");
-    const sourceKeyword = cacheSource.trim().toLowerCase();
-    const sourceSql = sourceKeyword.startsWith("select")
-        ? `(${cacheSource})`
-        : cacheSource;
-    const columns = [
-        [
-            "_pk",
-            `'CI' || '~' || lix_encode_pk_part(cache.file_id) || '~' || lix_encode_pk_part(cache.entity_id) || '~' || lix_encode_pk_part(vi.version_id) AS _pk`,
-        ],
-        ["source_tag", "'CI' AS source_tag"],
-        ["entity_id", "cache.entity_id AS entity_id"],
-        ["schema_key", "cache.schema_key AS schema_key"],
-        ["file_id", "cache.file_id AS file_id"],
-        ["plugin_key", "cache.plugin_key AS plugin_key"],
-        ["snapshot_content", "json(cache.snapshot_content) AS snapshot_content"],
-        ["schema_version", "cache.schema_version AS schema_version"],
-        ["version_id", "vi.version_id AS version_id"],
-        ["created_at", "cache.created_at AS created_at"],
-        ["updated_at", "cache.updated_at AS updated_at"],
-        [
-            "inherited_from_version_id",
-            "cache.version_id AS inherited_from_version_id",
-        ],
-        ["change_id", "cache.change_id AS change_id"],
-        ["untracked", "0 AS untracked"],
-        ["commit_id", "cache.commit_id AS commit_id"],
-        ["metadata", "NULL AS metadata"],
-        ["writer_key", "NULL AS writer_key"],
-        ["priority", "4 AS priority"],
-    ];
-    const columnSql = columns
-        .filter(([column]) => projectionColumns.has(column))
-        .map(([, sql]) => sql)
-        .join(",\n");
-    const joinClause = versionJoinClause ? `\n\t\t${versionJoinClause}` : "";
-    return stripIndent(`
-		SELECT
-${indent(columnSql, 4)}
-		FROM ${inheritanceJoin}${joinClause}
-		JOIN ${sourceSql} cache ON cache.version_id = vi.ancestor_version_id
-		WHERE cache.is_tombstone = 0
-		  AND cache.snapshot_content IS NOT NULL${rewrittenFilter ? ` AND ${rewrittenFilter}` : ""}
-	`).trimEnd();
-}
-/**
- * Builds the inherited segment sourcing data from `lix_internal_state_all_untracked`.
- *
- * @param segmentFilter - Optional predicate scoped to the untracked alias.
- * @param projectionColumns - Columns required for the projection.
- * @param versionJoinClause - SQL equi-join tying descendants to wanted versions.
- * @returns SQL fragment selecting inherited untracked rows.
- *
- * @example
- * ```ts
- * const sql = buildInheritedUntrackedSegment(
- *   null,
- *   new Set(["entity_id"]),
- *   "version_inheritance vi",
- *   "JOIN wanted_versions wv ON wv.version_id = vi.version_id"
- * );
- * ```
- */
-function buildInheritedUntrackedSegment(segmentFilter, projectionColumns, inheritanceJoin, versionJoinClause) {
-    const rewrittenFilter = rewriteFilterForAlias(segmentFilter, "unt");
-    const columns = [
-        [
-            "_pk",
-            `'UI' || '~' || lix_encode_pk_part(unt.file_id) || '~' || lix_encode_pk_part(unt.entity_id) || '~' || lix_encode_pk_part(vi.version_id) AS _pk`,
-        ],
-        ["source_tag", "'UI' AS source_tag"],
-        ["entity_id", "unt.entity_id AS entity_id"],
-        ["schema_key", "unt.schema_key AS schema_key"],
-        ["file_id", "unt.file_id AS file_id"],
-        ["plugin_key", "unt.plugin_key AS plugin_key"],
-        ["snapshot_content", "json(unt.snapshot_content) AS snapshot_content"],
-        ["schema_version", "unt.schema_version AS schema_version"],
-        ["version_id", "vi.version_id AS version_id"],
-        ["created_at", "unt.created_at AS created_at"],
-        ["updated_at", "unt.updated_at AS updated_at"],
-        [
-            "inherited_from_version_id",
-            "unt.version_id AS inherited_from_version_id",
-        ],
-        ["change_id", "'untracked' AS change_id"],
-        ["untracked", "1 AS untracked"],
-        ["commit_id", "'untracked' AS commit_id"],
-        ["metadata", "NULL AS metadata"],
-        ["writer_key", "NULL AS writer_key"],
-        ["priority", "5 AS priority"],
-    ];
-    const columnSql = columns
-        .filter(([column]) => projectionColumns.has(column))
-        .map(([, sql]) => sql)
-        .join(",\n");
-    const joinClause = versionJoinClause ? `\n\t\t${versionJoinClause}` : "";
-    return stripIndent(`
-		SELECT
-${indent(columnSql, 4)}
-		FROM ${inheritanceJoin}${joinClause}
-		JOIN lix_internal_state_all_untracked unt ON unt.version_id = vi.ancestor_version_id
-		WHERE unt.is_tombstone = 0
-		  AND unt.snapshot_content IS NOT NULL${rewrittenFilter ? ` AND ${rewrittenFilter}` : ""}
-	`).trimEnd();
-}
-/**
- * Builds the inherited segment that projects transaction rows onto descendant
- * versions.
- *
- * @param segmentFilter - Optional predicate scoped to the transaction alias.
- * @param projectionColumns - Columns required for the projection.
- * @param versionJoinClause - SQL equi-join tying descendants to wanted versions.
- * @returns SQL fragment selecting inherited transaction rows.
- *
- * @example
- * ```ts
- * const sql = buildInheritedTransactionSegment(
- *   "txn.schema_key = 'demo'",
- *   new Set(["change_id"]),
- *   "version_parent vi",
- *   "JOIN wanted_versions wv ON wv.version_id = vi.version_id"
- * );
- * ```
- */
-function buildInheritedTransactionSegment(segmentFilter, projectionColumns, parentJoinSource, versionJoinClause) {
-    const columns = [
-        [
-            "_pk",
-            `'TI' || '~' || lix_encode_pk_part(txn.file_id) || '~' || lix_encode_pk_part(txn.entity_id) || '~' || lix_encode_pk_part(vi.version_id) AS _pk`,
-        ],
-        ["source_tag", "'TI' AS source_tag"],
-        ["entity_id", "txn.entity_id AS entity_id"],
-        ["schema_key", "txn.schema_key AS schema_key"],
-        ["file_id", "txn.file_id AS file_id"],
-        ["plugin_key", "txn.plugin_key AS plugin_key"],
-        ["snapshot_content", "json(txn.snapshot_content) AS snapshot_content"],
-        ["schema_version", "txn.schema_version AS schema_version"],
-        ["version_id", "vi.version_id AS version_id"],
-        ["created_at", "txn.created_at AS created_at"],
-        ["updated_at", "txn.created_at AS updated_at"],
-        [
-            "inherited_from_version_id",
-            "vi.parent_version_id AS inherited_from_version_id",
-        ],
-        ["change_id", "txn.id AS change_id"],
-        ["untracked", "txn.untracked AS untracked"],
-        ["commit_id", "'pending' AS commit_id"],
-        ["metadata", "json(txn.metadata) AS metadata"],
-        ["writer_key", "txn.writer_key AS writer_key"],
-        ["priority", "6 AS priority"],
-    ];
-    const columnSql = columns
-        .filter(([column]) => projectionColumns.has(column))
-        .map(([, sql]) => sql)
-        .join(",\n");
-    const rewrittenFilter = rewriteFilterForAlias(segmentFilter, "txn");
-    const joinClause = versionJoinClause ? `\n\t\t${versionJoinClause}` : "";
-    return stripIndent(`
-		SELECT
-${indent(columnSql, 4)}
-		FROM ${parentJoinSource}${joinClause}
-		JOIN lix_internal_transaction_state txn ON txn.version_id = vi.parent_version_id
-		WHERE vi.parent_version_id IS NOT NULL
-		  AND txn.snapshot_content IS NOT NULL${rewrittenFilter ? ` AND ${rewrittenFilter}` : ""}
-	`).trimEnd();
-}
-function buildRankedSegment(options) {
-    const columns = ALL_SEGMENT_COLUMNS.filter((column) => options.projectionColumns.has(column)).map((column) => `c.${column} AS ${column}`);
-    const orderClause = options.rankingOrder.join(", ");
-    const selectEntries = [
-        ...columns,
-        `ROW_NUMBER() OVER (
-        PARTITION BY c.file_id, c.schema_key, c.entity_id, c.version_id
-        ORDER BY ${orderClause}
-      ) AS rn`,
-    ];
-    return stripIndent(`
-		SELECT
-${indent(selectEntries.join(",\n"), 4)}
-		FROM (
-${indent(options.candidatesSql, 6)}
-		) AS c
-	`).trimEnd();
-}
-function buildSchemaFilter(schemaKeys) {
-    if (!schemaKeys || schemaKeys.length === 0) {
-        return null;
-    }
-    const values = schemaKeys.map((key) => `'${key}'`).join(", ");
-    return `txn.schema_key IN (${values})`;
-}
-function buildFileFilter(fileIds) {
-    if (!fileIds || fileIds.length === 0) {
-        return null;
-    }
-    const values = fileIds
-        .map((fileId) => `'${escapeSqlLiteral(fileId)}'`)
-        .join(", ");
-    return `txn.file_id IN (${values})`;
-}
-function buildEntityFilter(entityIds) {
-    if (!entityIds || entityIds.length === 0) {
-        return null;
-    }
-    const values = entityIds
-        .map((entityId) => `'${escapeSqlLiteral(entityId)}'`)
-        .join(", ");
-    return `txn.entity_id IN (${values})`;
-}
-function buildSnapshotContentFilter(filters) {
-    if (!filters || filters.length === 0) {
-        return null;
-    }
-    const clauses = filters
-        .map((filter) => buildSnapshotPredicateClause(filter))
-        .filter((clause) => typeof clause === "string");
-    if (clauses.length === 0) {
-        return null;
-    }
-    return clauses.map((clause) => `(${clause})`).join(" AND ");
-}
-function buildSnapshotPredicateClause(filter) {
-    const uniqueValues = Array.from(new Set(filter.values));
-    if (uniqueValues.length === 0) {
-        return null;
-    }
-    const pathLiteral = `'${escapeSqlLiteral(filter.path)}'`;
-    if (uniqueValues.length === 1) {
-        const value = escapeSqlLiteral(uniqueValues[0]);
-        return `json_extract(txn.snapshot_content, ${pathLiteral}) = '${value}'`;
-    }
-    const valueList = uniqueValues
-        .map((value) => `'${escapeSqlLiteral(value)}'`)
-        .join(", ");
-    return `json_extract(txn.snapshot_content, ${pathLiteral}) IN (${valueList})`;
-}
-/**
- * Builds an equi-join clause tying a table alias to the wanted versions CTE.
- *
- * @param cteName - Name of the wanted versions CTE.
- * @param targetAlias - Table alias exposing a `version_id` column.
- * @param joinAlias - Alias assigned to the join for readability.
- * @returns SQL JOIN clause or an empty string when no CTE is provided.
- *
- * @example
- * ```ts
- * const joinSql = buildWantedVersionJoinClause("wanted_versions", "txn", "wv_txn");
- * ```
- */
-function buildWantedVersionJoinClause(cteName, targetAlias, joinAlias) {
-    if (!cteName) {
-        return "";
-    }
-    return `JOIN ${cteName} ${joinAlias} ON ${joinAlias}.version_id = ${targetAlias}.version_id`;
-}
-function buildCacheSource(schemaKeys, cacheTables, projectionColumns) {
-    const requiredColumns = new Set(projectionColumns);
-    // Always keep structural columns that power tombstone filtering and ranking.
-    requiredColumns.add("snapshot_content");
-    requiredColumns.add("is_tombstone");
-    requiredColumns.add("file_id");
-    requiredColumns.add("entity_id");
-    requiredColumns.add("schema_key");
-    requiredColumns.add("version_id");
-    requiredColumns.add("change_id");
-    requiredColumns.add("created_at");
-    const uniqueKeys = schemaKeys && schemaKeys.length > 0
-        ? Array.from(new Set(schemaKeys))
-        : Array.from(cacheTables.keys());
-    const seenTables = new Set();
-    const entries = uniqueKeys
-        .map((key) => {
-        const lookupKeys = new Set([key]);
-        const sanitizedKey = cacheTableNameToSchemaKey(schemaKeyToCacheTableName(key));
-        if (sanitizedKey !== key) {
-            lookupKeys.add(sanitizedKey);
-        }
-        for (const lookupKey of lookupKeys) {
-            const tableName = cacheTables.get(lookupKey);
-            if (typeof tableName === "string" &&
-                tableName.length > 0 &&
-                !seenTables.has(tableName)) {
-                seenTables.add(tableName);
-                return {
-                    tableName,
-                    sql: buildPhysicalCacheSelect(tableName, requiredColumns),
-                };
-            }
-        }
-        return null;
-    })
-        .filter((value) => value !== null);
-    if (entries.length === 0) {
-        return null;
-    }
-    if (entries.length === 1) {
-        return quoteIdentifier(entries[0].tableName);
-    }
-    return entries.map((entry) => entry.sql).join(`\nUNION ALL\n`);
-}
-function buildPhysicalCacheSelect(tableName, requiredColumns) {
-    const projection = CACHE_COLUMNS.filter((column) => requiredColumns.has(column))
-        .map((column) => quoteIdentifier(column))
-        .join(",\n    ");
-    return `SELECT
-    ${projection}
-  FROM ${quoteIdentifier(tableName)}`;
-}
-/**
- * Resolves the cache table name for the provided schema key, falling back to its sanitized form.
- *
- * @example
- * ```ts
- * resolveCacheTableName(new Map([["delete_cache_schema", "cache_table"]]), "delete_cache_schema");
- * // "cache_table"
- * ```
- */
-function stripIndent(value) {
-    const trimmed = value.replace(/^\n+/, "").replace(/\n+$/, "");
-    const lines = trimmed.split(NEWLINE);
-    const indents = lines
-        .filter((line) => line.trim().length > 0)
-        .map((line) => line.match(/^\s*/)?.[0]?.length ?? 0);
-    const minIndent = indents.length > 0 ? Math.min(...indents) : 0;
-    return lines.map((line) => line.slice(minIndent)).join(NEWLINE);
-}
-function indent(value, spaces) {
-    const pad = " ".repeat(spaces);
-    return value
-        .split(NEWLINE)
-        .map((line) => (line.length > 0 ? pad + line : line))
-        .join(NEWLINE);
-}
-function quoteIdentifier(identifier) {
-    return `"${identifier.replace(/"/g, '""')}"`;
-}
-function shouldPushFileFilter(schemaKeys, fileIds) {
-    if (!schemaKeys || schemaKeys.length === 0)
-        return false;
-    if (!fileIds || fileIds.length === 0)
-        return false;
-    return schemaKeys.every((key) => typeof key === "string" && !key.startsWith("lix_"));
-}
-function shouldPushEntityFilter(schemaKeys, entityIds) {
-    if (!schemaKeys || schemaKeys.length === 0)
-        return false;
-    if (!entityIds || entityIds.length === 0)
-        return false;
-    return schemaKeys.every((key) => typeof key === "string" && !key.startsWith("lix_"));
-}
-function shouldPushSnapshotFilters(schemaKeys, filters) {
-    if (!schemaKeys || schemaKeys.length === 0)
-        return false;
-    if (!filters || filters.length === 0)
-        return false;
-    return schemaKeys.every((key) => typeof key === "string" && !key.startsWith("lix_"));
-}
-function combineFilters(...filters) {
-    const active = filters.filter((filter) => typeof filter === "string" && filter.length > 0);
-    if (active.length === 0) {
-        return null;
-    }
-    if (active.length === 1) {
-        return active[0];
-    }
-    return active.map((filter) => `(${filter})`).join(" AND ");
-}
-function rewriteFilterForAlias(filter, alias) {
-    if (!filter) {
-        return null;
-    }
-    return filter.replace(/txn\./g, `${alias}.`);
-}
-function normalizeObjectName(objectName) {
-    if (objectName.parts.length === 0) {
-        return null;
-    }
-    const last = objectName.parts[objectName.parts.length - 1];
-    return normalizeIdentifierValue(last.value);
-}
-function escapeSqlLiteral(value) {
-    return value.replace(/'/g, "''");
-}
-function determineInheritancePlan(args) {
-    const requested = Array.from(new Set(args.requestedVersionIds ?? []));
-    if (args.forcedPrune) {
-        return { mode: "pruned" };
-    }
-    if (requested.length === 0) {
-        return args.versionInheritance ? { mode: "recursive" } : { mode: "pruned" };
-    }
-    if (!args.versionInheritance || args.versionInheritance.size === 0) {
-        return { mode: "pruned" };
-    }
-    const ancestorPairs = [];
-    const parentPairs = [];
-    const ancestorSeen = new Set();
-    const parentSeen = new Set();
-    for (const versionId of requested) {
-        let current = versionId;
-        const chainVisited = new Set([current]);
-        while (true) {
-            const node = args.versionInheritance.get(current);
-            if (!node) {
-                return {
-                    mode: "recursive",
-                };
-            }
-            const parentId = node.inheritsFromVersionId;
-            if (!parentId) {
-                break;
-            }
-            if (chainVisited.has(parentId)) {
-                return {
-                    mode: "recursive",
-                };
-            }
-            chainVisited.add(parentId);
-            const ancestorKey = `${versionId}::${parentId}`;
-            if (!ancestorSeen.has(ancestorKey)) {
-                ancestorSeen.add(ancestorKey);
-                ancestorPairs.push({ versionId, ancestorId: parentId });
-            }
-            const parentKey = `${current}::${parentId}`;
-            if (!parentSeen.has(parentKey)) {
-                parentSeen.add(parentKey);
-                parentPairs.push({ versionId: current, parentId });
-            }
-            current = parentId;
-        }
-    }
-    if (ancestorPairs.length === 0) {
-        return { mode: "pruned" };
-    }
-    return {
-        mode: "inline",
-        versionAncestorPairs: ancestorPairs,
-        parentPairs,
-    };
-}
-function buildInlineInheritanceSource(pairs) {
-    return buildInlineValueSource(pairs.map(({ versionId, ancestorId }) => [versionId, ancestorId]), ["version_id", "ancestor_version_id"]);
-}
-function buildInlineParentSource(pairs) {
-    return buildInlineValueSource(pairs.map(({ versionId, parentId }) => [versionId, parentId]), ["version_id", "parent_version_id"]);
-}
-function buildInlineValueSource(rows, columns) {
-    const selects = rows
-        .map(([left, right]) => `SELECT '${escapeSqlLiteral(left)}' AS ${columns[0]}, '${escapeSqlLiteral(right)}' AS ${columns[1]}`)
-        .join("\nUNION ALL\n");
-    return `(\n${selects}\n) AS vi`;
-}
-//# sourceMappingURL=rewrite-vtable-selects.js.map