vouchington-tooling 0.35.0 → 0.36.1

package/dist/post-publication-inventory/readers/public-boundary-dataflow.d.mts

@@ -0,0 +1,3 @@
+type Node = import('./source-ast.mts').UnknownNode;
+export declare function constrainingUseReachesConsumer(hasCall: Node, ancestors: Node[], ast: Node): boolean;
+export {};

package/dist/post-publication-inventory/readers/public-boundary-dataflow.mjs

@@ -0,0 +1,61 @@
+import { derivedBindingIsConsumed } from "./public-boundary-consumed.mjs";
+import { isFunctionLike, isNode, propertyName } from "./source-ast.mjs";
+import { containsNode } from "./public-boundary-ast.mjs";
+export function constrainingUseReachesConsumer(hasCall, ancestors, ast) {
+    let crossedCallback = false;
+    for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+        const ancestor = ancestors[index];
+        if (isFunctionLike(ancestor)) {
+            if (crossedCallback)
+                return false;
+            crossedCallback = true;
+            continue;
+        }
+        if (ancestor.type === 'ReturnStatement')
+            return true;
+        if (ancestor.type !== 'CallExpression' || !isNode(ancestor.callee))
+            continue;
+        const callName = ancestor.callee.type === 'Identifier'
+            ? propertyName(ancestor.callee)
+            : ancestor.callee.type === 'MemberExpression' && isNode(ancestor.callee.property)
+                ? propertyName(ancestor.callee.property)
+                : null;
+        if (callName === 'assert')
+            return true;
+        if (!['filter', 'flatMap', 'map'].includes(callName ?? '')) {
+            if (crossedCallback)
+                return false;
+            continue;
+        }
+        if (!hasCallDeterminesCallbackResult(hasCall, ancestors.slice(index + 1)))
+            return false;
+        return derivedCallReachesConsumer(ancestors.slice(0, index), ast);
+    }
+    return false;
+}
+function hasCallDeterminesCallbackResult(hasCall, descendants) {
+    const callback = descendants.find(isFunctionLike);
+    if (!callback || !isNode(callback.body))
+        return false;
+    if (callback.body.type !== 'BlockStatement')
+        return containsNode(callback.body, hasCall);
+    return descendants.some((descendant) => descendant.type === 'ReturnStatement');
+}
+function derivedCallReachesConsumer(ancestors, ast) {
+    for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+        const ancestor = ancestors[index];
+        if (ancestor.type === 'ReturnStatement')
+            return true;
+        if (ancestor.type === 'AssignmentExpression' && isNode(ancestor.left)) {
+            if (ancestor.left.type === 'MemberExpression')
+                return true;
+            const name = propertyName(ancestor.left);
+            return name ? derivedBindingIsConsumed(ast, name, ancestor.range[1]) : false;
+        }
+        if (ancestor.type === 'VariableDeclarator' && isNode(ancestor.id)) {
+            const name = propertyName(ancestor.id);
+            return name ? derivedBindingIsConsumed(ast, name, ancestor.range[1]) : false;
+        }
+    }
+    return false;
+}

package/dist/post-publication-inventory/readers/public-boundary-then.d.mts

@@ -0,0 +1,9 @@
+type Node = import('./source-ast.mts').UnknownNode;
+type BoundaryBinding = {
+    declaredAt: number;
+    declaration: Node;
+    name: string;
+};
+export declare function isShadowedAtUse(binding: BoundaryBinding, ancestors: Node[]): boolean;
+export declare function isThenBoundaryParameter(receiver: string, ancestors: Node[], imported: Set<string>): boolean;
+export {};

package/dist/post-publication-inventory/readers/public-boundary-then.mjs

@@ -0,0 +1,31 @@
+import { isFunctionLike, isNode, propertyName } from "./source-ast.mjs";
+import { canonicalCallNames } from "./source-helpers.mjs";
+export function isShadowedAtUse(binding, ancestors) {
+    return ancestors.some((ancestor) => {
+        if (!isFunctionLike(ancestor) || !Array.isArray(ancestor.params))
+            return false;
+        if (binding.declaration.range[0] >= ancestor.range[0] &&
+            binding.declaration.range[1] <= ancestor.range[1]) {
+            return false;
+        }
+        return ancestor.params.some((param) => isNode(param) && propertyName(param) === binding.name);
+    });
+}
+export function isThenBoundaryParameter(receiver, ancestors, imported) {
+    return ancestors.some((ancestor) => {
+        if (!isFunctionLike(ancestor) || !Array.isArray(ancestor.params))
+            return false;
+        if (!ancestor.params.some((param) => isNode(param) && propertyName(param) === receiver))
+            return false;
+        const parent = ancestors[ancestors.indexOf(ancestor) - 1];
+        if (!parent || parent.type !== 'CallExpression' || !isNode(parent.callee))
+            return false;
+        if (parent.callee.type !== 'MemberExpression' ||
+            !isNode(parent.callee.object) ||
+            !isNode(parent.callee.property) ||
+            propertyName(parent.callee.property) !== 'then') {
+            return false;
+        }
+        return canonicalCallNames(parent.callee.object, imported).length > 0;
+    });
+}

package/dist/post-publication-inventory/readers/public-boundary.d.mts

@@ -0,0 +1,3 @@
+import type { ReaderSourceAnalysisOptions } from './source-options.mts';
+/** Proves that public IDs constrain a collection or guard before it can be emitted. */
+export declare function sourceFiltersWithPublicBoundary(content: string, symbols: string[], options: ReaderSourceAnalysisOptions): boolean;

package/dist/post-publication-inventory/readers/public-boundary.mjs

@@ -0,0 +1,71 @@
+import { isShadowedAtUse, isThenBoundaryParameter } from "./public-boundary-then.mjs";
+import { isNode, parseSource, propertyName, walk } from "./source-ast.mjs";
+import { importedCanonicalBindings } from "./source-helpers.mjs";
+import { isSetHasCall, walkWithAncestors } from "./public-boundary-ast.mjs";
+import { constrainingUseReachesConsumer } from "./public-boundary-dataflow.mjs";
+/** Proves that public IDs constrain a collection or guard before it can be emitted. */
+export function sourceFiltersWithPublicBoundary(content, symbols, options) {
+    const ast = parseSource(content).ast;
+    const imported = importedCanonicalBindings(ast, symbols, options);
+    if (imported.size === 0)
+        return false;
+    const bindings = [];
+    walk(ast, (node) => {
+        if (node.type !== 'VariableDeclarator' || !isNode(node.id) || !isNode(node.init))
+            return;
+        const name = propertyName(node.id);
+        if (!name || !isDirectCanonicalBoundaryCall(node.init, imported))
+            return;
+        bindings.push({ declaredAt: node.range[1], declaration: node, name });
+    });
+    let constrained = false;
+    walkWithAncestors(ast, [], (node, ancestors) => {
+        if (constrained)
+            return;
+        if (node.type === 'ReturnStatement' && isNode(node.argument)) {
+            if (isDirectCanonicalBoundaryCall(node.argument, imported)) {
+                constrained = true;
+                return;
+            }
+            const returned = propertyName(node.argument);
+            if (returned &&
+                bindings.some((binding) => binding.name === returned &&
+                    node.range[0] > binding.declaredAt &&
+                    !isShadowedAtUse(binding, ancestors))) {
+                constrained = true;
+            }
+            return;
+        }
+        if (!isSetHasCall(node) ||
+            !hasCandidateIdArgument(node, options) ||
+            !constrainingUseReachesConsumer(node, ancestors, ast)) {
+            return;
+        }
+        const receiver = propertyName(node.callee.object);
+        if (receiver &&
+            bindings.some((binding) => binding.name === receiver &&
+                node.range[0] > binding.declaredAt &&
+                !isShadowedAtUse(binding, ancestors))) {
+            constrained = true;
+            return;
+        }
+        if (receiver && isThenBoundaryParameter(receiver, ancestors, imported))
+            constrained = true;
+    });
+    return constrained;
+}
+function isDirectCanonicalBoundaryCall(node, imported) {
+    const expression = node.type === 'AwaitExpression' && isNode(node.argument) ? node.argument : node;
+    return (expression.type === 'CallExpression' &&
+        isNode(expression.callee) &&
+        expression.callee.type === 'Identifier' &&
+        imported.has(expression.callee.name));
+}
+function hasCandidateIdArgument(node, options) {
+    if (!Array.isArray(node.arguments) || !isNode(node.arguments[0]))
+        return false;
+    const argument = node.arguments[0];
+    return (argument.type === 'MemberExpression' &&
+        isNode(argument.property) &&
+        propertyName(argument.property) === options.candidateIdProperty);
+}

package/dist/post-publication-inventory/readers/public-view-ast.d.mts

@@ -0,0 +1,6 @@
+import type { ReaderPublicViewOptions } from './public-view-options.mts';
+export declare function nestedSelectStatements(value: unknown): Record<string, unknown>[];
+export declare function containsEligibilitySourceEquality(values: unknown[], aliases: {
+    eligibility: Set<string>;
+    sourceRows: Set<string>;
+}, options: ReaderPublicViewOptions): boolean;

package/dist/post-publication-inventory/readers/public-view-ast.mjs

@@ -0,0 +1,67 @@
+import { isRecord } from "../../sql-ast/unknown-record.mjs";
+export function nestedSelectStatements(value) {
+    const selects = [];
+    function collect(node) {
+        if (Array.isArray(node)) {
+            for (const item of node)
+                collect(item);
+            return;
+        }
+        if (!isRecord(node))
+            return;
+        if (isRecord(node.SelectStmt)) {
+            selects.push(node.SelectStmt);
+            return;
+        }
+        for (const child of Object.values(node))
+            collect(child);
+    }
+    collect(value);
+    return selects;
+}
+export function containsEligibilitySourceEquality(values, aliases, options) {
+    function collect(value) {
+        if (Array.isArray(value))
+            return value.some(collect);
+        if (!isRecord(value))
+            return false;
+        if (isRecord(value.BoolExpr) &&
+            (value.BoolExpr.boolop === 'OR_EXPR' || value.BoolExpr.boolop === 'NOT_EXPR')) {
+            return false;
+        }
+        if (isRecord(value.A_Expr) && value.A_Expr.kind === 'AEXPR_OP' && isEquals(value.A_Expr)) {
+            const left = columnReference(value.A_Expr.lexpr);
+            const right = columnReference(value.A_Expr.rexpr);
+            if ((isEligibilityId(left, aliases.eligibility, options) &&
+                isSourceId(right, aliases.sourceRows, options)) ||
+                (isEligibilityId(right, aliases.eligibility, options) &&
+                    isSourceId(left, aliases.sourceRows, options))) {
+                return true;
+            }
+        }
+        if (isRecord(value.A_Expr) || isRecord(value.BooleanTest) || isRecord(value.CaseExpr)) {
+            return false;
+        }
+        return Object.values(value).some(collect);
+    }
+    return values.some(collect);
+}
+function isEquals(expression) {
+    return (Array.isArray(expression.name) &&
+        expression.name.some((value) => isRecord(value.String) && value.String.sval === '='));
+}
+function columnReference(value) {
+    if (!isRecord(value) || !isRecord(value.ColumnRef) || !Array.isArray(value.ColumnRef.fields)) {
+        return null;
+    }
+    const fields = value.ColumnRef.fields.flatMap((field) => isRecord(field.String) && typeof field.String.sval === 'string' ? [field.String.sval] : []);
+    if (fields.length !== 2)
+        return null;
+    return { alias: fields[0], column: fields[1] };
+}
+function isEligibilityId(value, aliases, options) {
+    return value !== null && value.column === options.eligibilityIdColumn && aliases.has(value.alias);
+}
+function isSourceId(value, aliases, options) {
+    return value !== null && value.column === options.sourceIdColumn && aliases.has(value.alias);
+}

package/dist/post-publication-inventory/readers/public-view-options.d.mts

@@ -0,0 +1,8 @@
+import type { ReaderSqlTemplateOptions } from './sql-template.mts';
+export interface ReaderPublicViewOptions {
+    readonly sql: ReaderSqlTemplateOptions;
+    readonly sourceRelation: string;
+    readonly eligibilityRelation: string;
+    readonly sourceIdColumn: string;
+    readonly eligibilityIdColumn: string;
+}

package/dist/post-publication-inventory/readers/public-view-protection.d.mts

@@ -0,0 +1,2 @@
+import type { ReaderPublicViewOptions } from './public-view-options.mts';
+export declare function selectProtectsSourceRows(select: Record<string, unknown>, options: ReaderPublicViewOptions): boolean;

package/dist/post-publication-inventory/readers/public-view-protection.mjs

@@ -0,0 +1,83 @@
+import { isRecord } from "../../sql-ast/unknown-record.mjs";
+import { containsEligibilitySourceEquality } from "./public-view-ast.mjs";
+export function selectProtectsSourceRows(select, options) {
+    const aliases = collectSelectAliases(select.fromClause, options);
+    return (aliases.sourceRows.size === 0 ||
+        (aliases.eligibility.size > 0 &&
+            (containsEligibilitySourceEquality([select.whereClause], aliases, options) ||
+                filteringJoinContainsEligibilityEquality(select.fromClause, aliases, options))) ||
+        correlatedEligibilitySubqueryComposes(select, aliases.sourceRows, options));
+}
+function correlatedEligibilitySubqueryComposes(select, outerSourceAliases, options) {
+    function containsPositiveEligibilityExists(value) {
+        if (Array.isArray(value))
+            return value.some(containsPositiveEligibilityExists);
+        if (!isRecord(value))
+            return false;
+        if (isRecord(value.BoolExpr) &&
+            (value.BoolExpr.boolop === 'OR_EXPR' || value.BoolExpr.boolop === 'NOT_EXPR')) {
+            return false;
+        }
+        if (isRecord(value.A_Expr) || isRecord(value.BooleanTest) || isRecord(value.CaseExpr)) {
+            return false;
+        }
+        if (isRecord(value.SubLink) &&
+            value.SubLink.subLinkType === 'EXISTS_SUBLINK' &&
+            isRecord(value.SubLink.subselect) &&
+            isRecord(value.SubLink.subselect.SelectStmt)) {
+            const nested = value.SubLink.subselect.SelectStmt;
+            const nestedAliases = collectSelectAliases(nested.fromClause, options);
+            return (nestedAliases.eligibility.size > 0 &&
+                containsEligibilitySourceEquality([nested.fromClause, nested.whereClause], {
+                    eligibility: nestedAliases.eligibility,
+                    sourceRows: outerSourceAliases,
+                }, options));
+        }
+        return Object.values(value).some(containsPositiveEligibilityExists);
+    }
+    return containsPositiveEligibilityExists(select.whereClause);
+}
+function filteringJoinContainsEligibilityEquality(value, aliases, options) {
+    if (Array.isArray(value)) {
+        return value.some((item) => filteringJoinContainsEligibilityEquality(item, aliases, options));
+    }
+    if (isRecord(value.JoinExpr)) {
+        if (value.JoinExpr.jointype === 'JOIN_INNER' &&
+            containsEligibilitySourceEquality([value.JoinExpr.quals], aliases, options)) {
+            return true;
+        }
+        return (filteringJoinContainsEligibilityEquality(value.JoinExpr.larg, aliases, options) ||
+            filteringJoinContainsEligibilityEquality(value.JoinExpr.rarg, aliases, options));
+    }
+    return false;
+}
+function collectSelectAliases(value, options) {
+    const aliases = { eligibility: new Set(), sourceRows: new Set() };
+    function collect(fromClause) {
+        if (Array.isArray(fromClause)) {
+            for (const item of fromClause)
+                collect(item);
+            return;
+        }
+        if (!isRecord(fromClause))
+            return;
+        if (isRecord(fromClause.RangeVar)) {
+            const range = fromClause.RangeVar;
+            const relationName = range.relname;
+            const alias = isRecord(range.alias) && typeof range.alias.aliasname === 'string'
+                ? range.alias.aliasname
+                : relationName;
+            if (relationName === options.eligibilityRelation)
+                aliases.eligibility.add(alias);
+            if (relationName === options.sourceRelation)
+                aliases.sourceRows.add(alias);
+            return;
+        }
+        if (isRecord(fromClause.JoinExpr)) {
+            collect(fromClause.JoinExpr.larg);
+            collect(fromClause.JoinExpr.rarg);
+        }
+    }
+    collect(value);
+    return aliases;
+}

package/dist/post-publication-inventory/readers/public-view.d.mts

@@ -0,0 +1,2 @@
+import type { ReaderPublicViewOptions } from './public-view-options.mts';
+export declare function composesPublicEligibilityView(content: string, options: ReaderPublicViewOptions): boolean;

package/dist/post-publication-inventory/readers/public-view.mjs

@@ -0,0 +1,117 @@
+import { parseSql } from "../../sql-ast/parser.mjs";
+import { isRecord } from "../../sql-ast/unknown-record.mjs";
+import { extractStaticSqlTemplateQuasis } from "./sql-source.mjs";
+import { nestedSelectStatements } from "./public-view-ast.mjs";
+import { selectProtectsSourceRows } from "./public-view-protection.mjs";
+export function composesPublicEligibilityView(content, options) {
+    try {
+        let foundSourceReader = false;
+        for (const sql of extractStaticSqlTemplateQuasis(content, options.sql)) {
+            try {
+                const tree = parseSql(sql);
+                const readsSource = selectTreeReadsRelation(tree, options.sourceRelation);
+                const readsEligibility = selectTreeReadsRelation(tree, options.eligibilityRelation);
+                if (!readsSource && !readsEligibility)
+                    continue;
+                foundSourceReader = true;
+                if (readsSource && !selectTreeComposesPublicEligibility(tree, options))
+                    return false;
+            }
+            catch {
+                // A fragment appended to a larger SQLStatement is not independently parseable.
+            }
+        }
+        return foundSourceReader;
+    }
+    catch {
+        return false;
+    }
+}
+function selectTreeReadsRelation(tree, relation) {
+    return tree.stmts.some((statement) => containsRangeVar(statement, relation));
+}
+function containsRangeVar(value, relation) {
+    if (Array.isArray(value))
+        return value.some((item) => containsRangeVar(item, relation));
+    if (!isRecord(value))
+        return false;
+    if (isRecord(value.RangeVar) && value.RangeVar.relname === relation)
+        return true;
+    return Object.values(value).some((item) => containsRangeVar(item, relation));
+}
+function selectTreeComposesPublicEligibility(tree, options) {
+    const selects = tree.stmts.flatMap((statement) => 'SelectStmt' in statement.stmt
+        ? [statement.stmt.SelectStmt]
+        : []);
+    return (selects.length > 0 &&
+        selects.every((select) => selectScopesComposePublicEligibility(select, options)));
+}
+function selectScopesComposePublicEligibility(select, options, inheritedCtes = new Map(), visitingCtes = new Set()) {
+    const ctes = new Map([...inheritedCtes, ...collectCteSelects(select.withClause)]);
+    if (!selectProtectsSourceRows(select, options))
+        return false;
+    const nestedSelects = nestedSelectStatements([
+        select.fromClause,
+        select.targetList,
+        select.whereClause,
+        select.havingClause,
+        select.groupClause,
+        select.distinctClause,
+        select.sortClause,
+        select.limitOffset,
+        select.limitCount,
+        select.windowClause,
+        select.valuesLists,
+    ]);
+    for (const branch of [select.larg, select.rarg]) {
+        if (isRecord(branch))
+            nestedSelects.push(branch);
+    }
+    if (nestedSelects.some((nested) => !selectScopesComposePublicEligibility(nested, options, ctes, visitingCtes))) {
+        return false;
+    }
+    function cteScopesCompose(name) {
+        if (visitingCtes.has(name))
+            return false;
+        const cte = ctes.get(name);
+        if (!cte)
+            return true;
+        const nextVisiting = new Set(visitingCtes).add(name);
+        return selectScopesComposePublicEligibility(cte, options, ctes, nextVisiting);
+    }
+    return selectRangeRelationNames(select.fromClause).every(cteScopesCompose);
+}
+function collectCteSelects(withClause) {
+    const ctes = new Map();
+    if (!isRecord(withClause) || !Array.isArray(withClause.ctes))
+        return ctes;
+    for (const cte of withClause.ctes) {
+        const expression = cte.CommonTableExpr;
+        if (isRecord(expression.ctequery.SelectStmt)) {
+            ctes.set(expression.ctename, expression.ctequery.SelectStmt);
+        }
+    }
+    return ctes;
+}
+function selectRangeRelationNames(value) {
+    const names = new Set();
+    function collect(fromClause) {
+        if (Array.isArray(fromClause)) {
+            for (const item of fromClause)
+                collect(item);
+            return;
+        }
+        if (!isRecord(fromClause))
+            return;
+        if (isRecord(fromClause.RangeVar) && typeof fromClause.RangeVar.relname === 'string') {
+            names.add(fromClause.RangeVar.relname);
+            return;
+        }
+        if (isRecord(fromClause.JoinExpr)) {
+            collect(fromClause.JoinExpr.larg);
+            collect(fromClause.JoinExpr.rarg);
+        }
+    }
+    collect(value);
+    return [...names];
+}

package/dist/post-publication-inventory/readers/source-ast.d.mts

@@ -0,0 +1,30 @@
+export interface UnknownNode {
+    type?: string;
+    range: [number, number];
+    loc?: {
+        start: {
+            line: number;
+        };
+        end: {
+            line: number;
+        };
+    };
+    [key: string]: unknown;
+}
+/**
+ * The root AST node returned by parseSource(): the ESTree Program plus the comments/tokens arrays
+ * `@typescript-eslint/parser` attaches alongside it.
+ */
+type ParsedAst = UnknownNode & {
+    comments?: UnknownNode[];
+    tokens?: UnknownNode[] | undefined;
+};
+interface ParseResult {
+    ast: ParsedAst;
+}
+export declare function parseSource(code: string): ParseResult;
+export declare function isNode(value: unknown): value is UnknownNode;
+export declare function walk(node: UnknownNode | undefined, visit: (node: UnknownNode) => void): void;
+export declare function propertyName(node: UnknownNode | undefined): string | null;
+export declare function isFunctionLike(node: UnknownNode): boolean;
+export {};

package/dist/post-publication-inventory/readers/source-ast.mjs

@@ -0,0 +1,52 @@
+import { parseForESLint } from '@typescript-eslint/parser';
+export function parseSource(code) {
+    const result = parseForESLint(code, {
+        comment: true,
+        ecmaVersion: 'latest',
+        loc: true,
+        range: true,
+        sourceType: 'module',
+    });
+    // @typescript-eslint/parser force-enables `tokens: true` regardless of the options above
+    // (parser.js hardcodes it), and every token duplicates a slice of the source string
+    // (node-utils.js builds each token via `ast.text.slice(start, end)`) — roughly half of a parsed
+    // AST's retained size. Nothing in this repo reads `ast.tokens`; drop the reference immediately
+    // after parsing (explicit `undefined`, not `delete`, so the field stays traceable in the type)
+    // so streaming source-analysis callers do not retain the redundant token array.
+    result.ast.tokens = undefined;
+    return result;
+}
+export function isNode(value) {
+    return (typeof value === 'object' && value !== null && typeof value.type === 'string');
+}
+export function walk(node, visit) {
+    if (!node)
+        return;
+    visit(node);
+    for (const [key, value] of Object.entries(node)) {
+        if (key === 'parent' || key === 'loc' || key === 'range')
+            continue;
+        if (Array.isArray(value)) {
+            for (const child of value)
+                if (isNode(child))
+                    walk(child, visit);
+        }
+        else if (isNode(value)) {
+            walk(value, visit);
+        }
+    }
+}
+export function propertyName(node) {
+    if (!node)
+        return null;
+    if (node.type === 'Identifier')
+        return node.name;
+    if (node.type === 'Literal')
+        return typeof node.value === 'string' ? node.value : null;
+    return null;
+}
+export function isFunctionLike(node) {
+    return (node.type === 'FunctionDeclaration' ||
+        node.type === 'FunctionExpression' ||
+        node.type === 'ArrowFunctionExpression');
+}

package/dist/post-publication-inventory/readers/source-executors.d.mts

@@ -0,0 +1,4 @@
+import type { ReaderSourceAnalysisOptions } from './source-options.mts';
+type Node = import('./source-ast.mts').UnknownNode;
+export declare function terminalSqlExecutorBindings(ast: Node, options: ReaderSourceAnalysisOptions): Set<string>;
+export {};

package/dist/post-publication-inventory/readers/source-executors.mjs

@@ -0,0 +1,38 @@
+import { isNode, propertyName, walk } from "./source-ast.mjs";
+export function terminalSqlExecutorBindings(ast, options) {
+    const bindings = new Set();
+    walk(ast, (node) => {
+        if (node.type !== 'ImportDeclaration' ||
+            !isNode(node.source) ||
+            node.source.type !== 'Literal' ||
+            typeof node.source.value !== 'string' ||
+            !options.sql.executorImports.has(node.source.value) ||
+            !Array.isArray(node.specifiers)) {
+            return;
+        }
+        for (const specifier of node.specifiers) {
+            if (!isNode(specifier) || specifier.type !== 'ImportSpecifier')
+                continue;
+            const importedName = propertyName(specifier.imported);
+            const localName = propertyName(specifier.local);
+            if (importedName &&
+                localName &&
+                options.sql.executorImports.get(String(node.source.value))?.has(importedName)) {
+                bindings.add(localName);
+            }
+        }
+    });
+    walk(ast, (node) => {
+        if (node.type !== 'VariableDeclarator' || !isNode(node.id) || !isNode(node.init))
+            return;
+        const binding = propertyName(node.id);
+        if (!binding || node.init.type !== 'ConditionalExpression')
+            return;
+        const consequent = propertyName(node.init.consequent);
+        const alternate = propertyName(node.init.alternate);
+        if ((consequent && bindings.has(consequent)) || (alternate && bindings.has(alternate))) {
+            bindings.add(binding);
+        }
+    });
+    return bindings;
+}

package/dist/post-publication-inventory/readers/source-helpers.d.mts

@@ -0,0 +1,16 @@
+import type { ReaderSourceAnalysisOptions } from './source-options.mts';
+import { terminalSqlExecutorBindings } from './source-executors.mts';
+export { terminalSqlExecutorBindings };
+type Node = import('./source-ast.mts').UnknownNode;
+export declare function addComposedNames(composed: Set<string>, names: string[]): void;
+export declare function addBindingComposition(composed: Set<string>, declaration: {
+    declaredAt: number;
+    names: string[];
+} | undefined, reassigned: boolean): void;
+export declare function canonicalCallNames(node: Node | undefined, imported: Set<string>): string[];
+export declare function isAppendCall(node: Node, options: ReaderSourceAnalysisOptions): boolean;
+export declare function isPushCall(node: Node): boolean;
+export declare function appendReceiverName(node: Node): string | null;
+export declare function isSqlStatementInitializer(node: Node | undefined, options: ReaderSourceAnalysisOptions): boolean;
+export declare function importedCanonicalBindings(ast: Node, symbols: string[], options: ReaderSourceAnalysisOptions): Set<string>;
+export declare function isTerminalSqlCall(node: Node, bindings: Set<string>): boolean;