vouchington-tooling 0.38.1 → 0.40.0

package/README.md

@@ -512,6 +512,18 @@ the dedicated process group to exit after the direct child closes so descendants
 `isProcessGroupAlive` and `waitForProcessGroupExit` are also available when callers need the same
 process-group probe and bounded-drain semantics outside a browser session.
 
+### Generated arbiter input
+
+The `pg-schema-snapshot` export also provides `projectGeneratedArbiterInput(conflict)` for
+`PostgresSqlConflict` facts from `no-mistakes@0.83.0` or newer. It projects normalized key and
+partial-predicate column identities, ordered assignment columns, direct non-EXCLUDED references,
+and assignment indirection. Named constraints and unresolved expression keys have undefined
+`keyColumns`; missing or incomplete expression coverage sets `complete` to false. Callers must
+reject incomplete projections and retain their own snapshot-dependent replay verdict. The adapter
+loads no optional parser peer at runtime and implements no replay-safety policy. Its public
+`GeneratedArbiterConflict` contract is structural, so importing snapshot declarations does not
+require the optional peer either.
+
 ### Contract schema type queries
 
 `getExportedTypeFacts` and `getCallRowTypeFacts` use an existing TypeScript `Program` from the
@@ -686,6 +698,16 @@ reexports, and literal dynamic/require loads. Missing or incomplete facts for a
 throw; external specifiers resolve to `null`. The default file inventory limit is 10,000
 files and can be reduced with `maxFiles`.
 
+## Static schema-allowlist pairs
+
+`extractStaticStringPairs(source)` from `pg-schema-snapshot` collects the first two string literals
+of every array expression in ESTree field traversal order, including arrays with extra elements.
+Conditional alternatives precede consequents, preserving the existing parser walker. It
+preserves duplicates and decoded string values. It does not evaluate imports, exported constants,
+spreads, or templates, and malformed source throws. Schema-allowlist consumers retain their own
+file selection, key filtering, deduplication, snapshot comparison, and diagnostics. Parsing is
+source-only and does not build a TypeScript compiler program or execute the source.
+
 ## SQL view declarations
 
 `vouchington-tooling/sql-ast` exports `extractViewDeclarations(sql)` and the
@@ -698,14 +720,17 @@ lifecycle decisions.
 
 ## SQL index shapes
 
-`vouchington-tooling/sql-ast` exports `extractIndexShapes(sql)`. Await `initSqlAst()` before
-calling it. It returns `{ idxname, table, shapeKey }` for each named top-level `CREATE INDEX`.
-Consumers can group identical `shapeKey` values to find differently named index definitions
-with the same projected physical shape. The key normalizes effective sort and null ordering and
-removes parser locations from expressions and predicates. Invalid SQL throws. Anonymous indexes
-and indexes inside `DO` blocks are omitted. The projection does not model operator classes,
-collations, or `INCLUDE` columns, so callers using those features must extend it before relying
-on shape collisions.
+`vouchington-tooling/sql-ast` exports asynchronous `extractIndexShapes(sql)`. Await its result;
+it lazily loads the optional `no-mistakes` peer and requires version 0.81.0 or newer when
+called with nonblank SQL. Other SQL exports do not require this peer. It does not need
+`initSqlAst()`. It returns
+`{ idxname, table, shapeKey }` for each named top-level `CREATE INDEX`. Consumers can group
+identical keys to detect collisions. Keys use upstream structural identity, including effective
+sort/null ordering, quoted relation identity, expressions, predicates, operator classes, and
+`INCLUDE` columns. Key serialization is opaque and must not be persisted across versions.
+Any parse diagnostic rejects the whole input. Anonymous indexes and indexes inside `DO` blocks
+are omitted. Consumer call sites must change from synchronous calls to `await` when adopting
+this release.
 
 ## Publication writer inventory facts
 

package/dist/pg-schema-snapshot/generated-arbiter-facts.d.mts

@@ -0,0 +1,49 @@
+/** Minimal structural facts; public declarations do not require the optional SQL parser peer. */
+export type GeneratedArbiterName = {
+    parts: readonly {
+        identity: string;
+    }[];
+};
+type GeneratedArbiterRoot = {
+    kind: 'columnReference';
+    name: GeneratedArbiterName;
+} | {
+    kind: 'parenthesized';
+    expression: GeneratedArbiterRoot;
+} | {
+    kind: 'functionCall' | 'cast' | 'nullTest' | 'distinctness' | 'parameter' | 'typedLiteral' | 'literal' | 'binary' | 'unary' | 'case' | 'subquery' | 'other';
+};
+export type GeneratedArbiterExpression = {
+    columns: readonly GeneratedArbiterName[];
+    root: GeneratedArbiterRoot;
+    childrenComplete?: boolean;
+};
+export type GeneratedArbiterConflict = {
+    target: {
+        kind: 'columns';
+        columns: readonly {
+            identity: string;
+        }[];
+    } | {
+        kind: 'expressions';
+        expressions: readonly GeneratedArbiterExpression[];
+    } | {
+        kind: 'constraint' | 'omitted';
+    };
+    predicate: GeneratedArbiterExpression | null;
+    action: {
+        kind: 'doNothing';
+    } | {
+        kind: 'doUpdate';
+        assignments: readonly {
+            columns: readonly GeneratedArbiterName[];
+            expression: GeneratedArbiterExpression;
+            complete: boolean;
+            target?: {
+                subscripts: readonly unknown[];
+                indirection?: readonly unknown[];
+            };
+        }[];
+    };
+};
+export {};

package/dist/pg-schema-snapshot/generated-arbiter-facts.mjs

@@ -0,0 +1 @@
+export {};

package/dist/pg-schema-snapshot/generated-arbiter-input.d.mts

@@ -0,0 +1,21 @@
+import type { GeneratedArbiterConflict } from './generated-arbiter-facts.mts';
+export type GeneratedArbiterAssignmentInput = {
+    columns: readonly string[];
+    /** A direct column reference, excluding the two-part EXCLUDED namespace. */
+    referencedColumn: string | undefined;
+    hasIndirection: boolean;
+    complete: boolean;
+};
+export type GeneratedArbiterInput = {
+    action: 'doNothing' | 'doUpdate';
+    /** Undefined for named constraints, omitted keys, or unresolved expression keys. */
+    keyColumns: ReadonlySet<string> | undefined;
+    predicateColumns: ReadonlySet<string>;
+    assignments: readonly GeneratedArbiterAssignmentInput[];
+    /** False means callers must reject rather than infer replay safety from partial facts. */
+    complete: boolean;
+};
+/** Projects released SQL facts for a snapshot-dependent generated-column replay verdict.
+ * This reports syntax and identities only; callers own protection and safety policy.
+ */
+export declare function projectGeneratedArbiterInput(conflict: GeneratedArbiterConflict): GeneratedArbiterInput;

package/dist/pg-schema-snapshot/generated-arbiter-input.mjs

@@ -0,0 +1,73 @@
+/** Projects released SQL facts for a snapshot-dependent generated-column replay verdict.
+ * This reports syntax and identities only; callers own protection and safety policy.
+ */
+export function projectGeneratedArbiterInput(conflict) {
+    let complete = true;
+    const predicateColumns = new Set();
+    if (conflict.predicate) {
+        complete = expressionComplete(conflict.predicate);
+        collectColumns(conflict.predicate, predicateColumns);
+    }
+    let keyColumns;
+    if (conflict.target.kind === 'columns' && conflict.target.columns.length > 0) {
+        keyColumns = new Set(conflict.target.columns.map((column) => column.identity));
+    }
+    else if (conflict.target.kind === 'expressions') {
+        const columns = new Set();
+        let resolved = conflict.target.expressions.length > 0;
+        for (const expression of conflict.target.expressions) {
+            const references = new Set();
+            collectColumns(expression, references);
+            const represented = expressionComplete(expression);
+            complete &&= represented;
+            if (!represented || references.size !== 1)
+                resolved = false;
+            for (const column of references)
+                columns.add(column);
+        }
+        if (resolved)
+            keyColumns = columns;
+    }
+    const assignments = conflict.action.kind === 'doUpdate'
+        ? conflict.action.assignments.map((assignment) => {
+            const columns = assignment.columns.map(lastIdentity);
+            const represented = assignment.complete &&
+                columns.every((column) => column !== undefined) &&
+                expressionComplete(assignment.expression);
+            complete &&= represented;
+            let root = assignment.expression.root;
+            while (root.kind === 'parenthesized')
+                root = root.expression;
+            return {
+                columns: columns.filter((column) => column !== undefined),
+                referencedColumn: root.kind === 'columnReference' && !isExcluded(root.name)
+                    ? lastIdentity(root.name)
+                    : undefined,
+                hasIndirection: Boolean(assignment.target &&
+                    (assignment.target.subscripts.length > 0 ||
+                        (assignment.target.indirection?.length ?? 0) > 0)),
+                complete: represented,
+            };
+        })
+        : [];
+    return { action: conflict.action.kind, keyColumns, predicateColumns, assignments, complete };
+}
+function lastIdentity(name) {
+    return name.parts.at(-1)?.identity;
+}
+function isExcluded(name) {
+    return name.parts.length === 2 && name.parts[0]?.identity === 'excluded';
+}
+function collectColumns(expression, columns) {
+    for (const name of expression.columns) {
+        const column = lastIdentity(name);
+        if (!isExcluded(name) && column !== undefined)
+            columns.add(column);
+    }
+}
+function expressionComplete(expression) {
+    // Older optional peers do not carry completeness; do not silently admit their partial facts.
+    return ('childrenComplete' in expression &&
+        expression.childrenComplete === true &&
+        expression.columns.every((name) => lastIdentity(name) !== undefined));
+}

package/dist/pg-schema-snapshot/index.d.mts

@@ -1,12 +1,16 @@
+export type { GeneratedArbiterConflict } from './generated-arbiter-facts.mts';
+export { projectGeneratedArbiterInput } from './generated-arbiter-input.mts';
+export type { GeneratedArbiterInput, GeneratedArbiterAssignmentInput, } from './generated-arbiter-input.mts';
 export { buildSchemaSnapshot, buildTableSnapshots } from './build-snapshot.mts';
 export { readColumns, readConstraints, readEnums, readExtensions, readFunctions, readIndexes, readPolicies, readSchemaCatalog, readTables, readTriggers, readViews, } from './catalog-queries.mts';
 export type { CatalogColumnRow, CatalogConstraintRow, CatalogEnumValueRow, CatalogExtensionRow, CatalogFunctionRow, CatalogIndexRow, CatalogPolicyRow, CatalogTableRow, CatalogTriggerRow, CatalogViewRow, SchemaCatalog, } from './catalog-queries.mts';
 export { generateSchemaSnapshot, stableStringify, writeSchemaSnapshot } from './generate.mts';
 export { detectRenamedIndexes, indexShapeKey } from './index-rename-detect.mts';
 export type { RenamedIndex, SchemaIndexRenameSnapshot } from './index-rename-detect.mts';
-export { createPostgresReplayContext } from './replay-context.mts';
+export { createPostgresReplayContext, createPostgresReplayContextFromSchema, } from './replay-context.mts';
 export type { GeneratedColumnReferences, PostgresReplayContext } from './replay-context.mts';
 export { renderSchemaMarkdown } from './render-markdown.mts';
 export type { SchemaMarkdownFiles } from './render-markdown.mts';
 export { renderTableDocument } from './render-tables.mts';
 export type { CatalogQuery, PartitionPolicy, SchemaColumnSnapshot, SchemaEnumSnapshot, SchemaExtensionSnapshot, SchemaForeignKeySnapshot, SchemaFunctionSnapshot, SchemaGrowthMaps, SchemaIndexKeySnapshot, SchemaIndexSnapshot, SchemaKeyConstraintSnapshot, SchemaPhysicalPartitionSnapshot, SchemaPolicySnapshot, SchemaSnapshot, SchemaTableSnapshot, SchemaViewSnapshot, } from './types.mts';
+export { extractStaticStringPairs } from './static-string-pairs.mts';

package/dist/pg-schema-snapshot/index.mjs

@@ -1,7 +1,9 @@
+export { projectGeneratedArbiterInput } from "./generated-arbiter-input.mjs";
 export { buildSchemaSnapshot, buildTableSnapshots } from "./build-snapshot.mjs";
 export { readColumns, readConstraints, readEnums, readExtensions, readFunctions, readIndexes, readPolicies, readSchemaCatalog, readTables, readTriggers, readViews, } from "./catalog-queries.mjs";
 export { generateSchemaSnapshot, stableStringify, writeSchemaSnapshot } from "./generate.mjs";
 export { detectRenamedIndexes, indexShapeKey } from "./index-rename-detect.mjs";
-export { createPostgresReplayContext } from "./replay-context.mjs";
+export { createPostgresReplayContext, createPostgresReplayContextFromSchema, } from "./replay-context.mjs";
 export { renderSchemaMarkdown } from "./render-markdown.mjs";
 export { renderTableDocument } from "./render-tables.mjs";
+export { extractStaticStringPairs } from "./static-string-pairs.mjs";

package/dist/pg-schema-snapshot/replay-context.d.mts

@@ -11,6 +11,8 @@ export type PostgresReplayContext = {
     /** Memoized per table; unknown tables return undefined and empty dependency sets return an empty map. */
     generatedDependenciesForTable(table: string): ReadonlyMap<string, ReadonlySet<string>> | undefined;
 };
+/** Collects generated-expression facts with the optional SQL peer, once per snapshot. */
+export declare function createPostgresReplayContextFromSchema(schema: SchemaSnapshot): Promise<PostgresReplayContext>;
 /**
  * Projects injected schema snapshot data and parser-derived generated-expression references for
  * replay checks. The caller owns snapshot loading and SQL parsing. Every STORED generated column

package/dist/pg-schema-snapshot/replay-context.mjs

@@ -1,3 +1,38 @@
+import { loadPostgresParser } from "../sql-ast/no-mistakes-peer.mjs";
+/** Collects generated-expression facts with the optional SQL peer, once per snapshot. */
+export async function createPostgresReplayContextFromSchema(schema) {
+    const definitions = Object.entries(schema.tables).flatMap(([table, snapshotTable]) => Object.entries(snapshotTable.columns).flatMap(([column, definition]) => definition.generated === 'stored' && definition.generatedExpression !== null
+        ? [{ table, column, expression: definition.generatedExpression }]
+        : []));
+    if (definitions.length === 0) {
+        return createPostgresReplayContext({ schema, generatedColumnReferences: [] });
+    }
+    const { parsePostgresSql } = await loadPostgresParser('createPostgresReplayContextFromSchema');
+    const parsed = await parsePostgresSql(definitions.map(({ table, column, expression }) => ({
+        sql: `SELECT (${expression})`,
+        fileName: `schema-snapshot:${table}.${column}`,
+    })));
+    const generatedColumnReferences = definitions.map(({ table, column }, index) => {
+        const facts = parsed[index];
+        const statement = facts?.statements[0];
+        if (!facts ||
+            facts.diagnostics.length > 0 ||
+            facts.statements.length !== 1 ||
+            statement?.kind !== 'select' ||
+            !statement.query.complete ||
+            statement.query.unsupported.length > 0) {
+            throw new Error(`Unable to collect generated-column references for ${table}.${column}`);
+        }
+        return {
+            table,
+            column,
+            sourceColumns: [
+                ...new Set(statement.query.columns.map((reference) => reference.name.parts.at(-1).identity)),
+            ],
+        };
+    });
+    return createPostgresReplayContext({ schema, generatedColumnReferences });
+}
 /**
  * Projects injected schema snapshot data and parser-derived generated-expression references for
  * replay checks. The caller owns snapshot loading and SQL parsing. Every STORED generated column

package/dist/pg-schema-snapshot/static-string-pairs.d.mts

@@ -0,0 +1,8 @@
+/**
+ * Collects the first two string literals of every source array in ESTree field traversal order.
+ * Order follows the existing parser walker, including conditional alternatives before consequents.
+ * Arrays may contain further elements. This does not evaluate constants, imports, or spreads;
+ * repeated pairs remain repeated so callers can apply their own selection and deduplication.
+ * Invalid source throws through the source-only parser.
+ */
+export declare function extractStaticStringPairs(source: string): readonly (readonly [string, string])[];

package/dist/pg-schema-snapshot/static-string-pairs.mjs

@@ -0,0 +1,26 @@
+import { isNode, parseSource, walk } from "../post-publication-inventory/readers/source-ast.mjs";
+/**
+ * Collects the first two string literals of every source array in ESTree field traversal order.
+ * Order follows the existing parser walker, including conditional alternatives before consequents.
+ * Arrays may contain further elements. This does not evaluate constants, imports, or spreads;
+ * repeated pairs remain repeated so callers can apply their own selection and deduplication.
+ * Invalid source throws through the source-only parser.
+ */
+export function extractStaticStringPairs(source) {
+    const pairs = [];
+    const { ast } = parseSource(source);
+    walk(ast, (node) => {
+        if (node.type !== 'ArrayExpression' || !Array.isArray(node.elements))
+            return;
+        const [first, second] = node.elements;
+        if (isNode(first) &&
+            isNode(second) &&
+            first.type === 'Literal' &&
+            second.type === 'Literal' &&
+            typeof first.value === 'string' &&
+            typeof second.value === 'string') {
+            pairs.push([first.value, second.value]);
+        }
+    });
+    return pairs;
+}

package/dist/sql-ast/index-shapes.d.mts

@@ -1,34 +1,11 @@
 /**
- * Extracts a canonical "shape key" for every top-level CREATE INDEX statement in the given SQL,
- * for detecting index definitions that build the same physical index under different names.
- *
- * The key is built from normalized `IndexStmt` AST fields (table, uniqueness, access method, each
- * indexed column/expression with its *effective* sort order and null ordering, and the predicate
- * with position-dependent `location` fields stripped) rather than from raw source text. This
- * canonicalizes cosmetic syntax variance that leaves the physical index unchanged:
- * - implicit vs. explicit `ASC` (`SORTBY_DEFAULT` is normalized to `SORTBY_ASC`, PostgreSQL's
- *   actual default for btree ordering);
- * - implicit vs. explicit `NULLS FIRST`/`NULLS LAST` (PostgreSQL's real default depends on sort
- *   direction — `NULLS LAST` for ascending, `NULLS FIRST` for descending — so
- *   `SORTBY_NULLS_DEFAULT` is resolved against the effective ordering rather than compared as-is);
- * - redundant parentheses in a predicate or expression (parentheses are pure grouping and leave no
- *   trace in the parsed AST once `location` offsets — which shift under added parens even though
- *   the tree shape is unchanged — are stripped before comparison).
- *
- * Operator classes, collations, and INCLUDE columns are intentionally NOT modeled; callers whose
- * generators use them must extend the projection before using this collision policy for those SQL.
- *
- * @libpg-query/parser has no deparse/SQL-regeneration function, so this hashes a normalized JSON
- * projection of the relevant AST subtrees instead of reconstructing SQL text.
- *
- * DO $$ ... END $$; blocks are opaque to the top-level parser — they appear as a single DoStmt,
- * not individual IndexStmt nodes — so nested CREATE INDEX statements are not covered.
- *
- * Unparseable SQL throws rather than returning an empty shape list.
- * Requires initSqlAst() to have resolved before the first call.
+ * Returns collision keys for named top-level CREATE INDEX statements using released SQL facts.
+ * Effective ordering, expressions, predicates, operator classes, and INCLUDE columns participate
+ * in the upstream structural identity. DO blocks remain opaque to this top-level projection.
+ * Any parse diagnostic rejects the complete input instead of returning partial collision facts.
  */
-export declare function extractIndexShapes(sql: string): {
+export declare function extractIndexShapes(sql: string): Promise<{
     idxname: string;
     table: string;
     shapeKey: string;
-}[];
+}[]>;

package/dist/sql-ast/index-shapes.mjs

@@ -1,85 +1,28 @@
-import { parseSql } from "./parser.mjs";
+import { loadPostgresParser } from "./no-mistakes-peer.mjs";
 /**
- * Extracts a canonical "shape key" for every top-level CREATE INDEX statement in the given SQL,
- * for detecting index definitions that build the same physical index under different names.
- *
- * The key is built from normalized `IndexStmt` AST fields (table, uniqueness, access method, each
- * indexed column/expression with its *effective* sort order and null ordering, and the predicate
- * with position-dependent `location` fields stripped) rather than from raw source text. This
- * canonicalizes cosmetic syntax variance that leaves the physical index unchanged:
- * - implicit vs. explicit `ASC` (`SORTBY_DEFAULT` is normalized to `SORTBY_ASC`, PostgreSQL's
- *   actual default for btree ordering);
- * - implicit vs. explicit `NULLS FIRST`/`NULLS LAST` (PostgreSQL's real default depends on sort
- *   direction — `NULLS LAST` for ascending, `NULLS FIRST` for descending — so
- *   `SORTBY_NULLS_DEFAULT` is resolved against the effective ordering rather than compared as-is);
- * - redundant parentheses in a predicate or expression (parentheses are pure grouping and leave no
- *   trace in the parsed AST once `location` offsets — which shift under added parens even though
- *   the tree shape is unchanged — are stripped before comparison).
- *
- * Operator classes, collations, and INCLUDE columns are intentionally NOT modeled; callers whose
- * generators use them must extend the projection before using this collision policy for those SQL.
- *
- * @libpg-query/parser has no deparse/SQL-regeneration function, so this hashes a normalized JSON
- * projection of the relevant AST subtrees instead of reconstructing SQL text.
- *
- * DO $$ ... END $$; blocks are opaque to the top-level parser — they appear as a single DoStmt,
- * not individual IndexStmt nodes — so nested CREATE INDEX statements are not covered.
- *
- * Unparseable SQL throws rather than returning an empty shape list.
- * Requires initSqlAst() to have resolved before the first call.
+ * Returns collision keys for named top-level CREATE INDEX statements using released SQL facts.
+ * Effective ordering, expressions, predicates, operator classes, and INCLUDE columns participate
+ * in the upstream structural identity. DO blocks remain opaque to this top-level projection.
+ * Any parse diagnostic rejects the complete input instead of returning partial collision facts.
  */
-export function extractIndexShapes(sql) {
+export async function extractIndexShapes(sql) {
     if (!sql.trim())
         return [];
-    const result = parseSql(sql);
-    const shapes = [];
-    for (const stmt of result.stmts ?? []) {
-        const node = stmt.stmt;
-        if (!node || !('IndexStmt' in node))
-            continue;
-        const indexStmt = node.IndexStmt;
-        const idxname = indexStmt.idxname;
-        if (!idxname)
-            continue;
-        const table = indexStmt.relation?.relname ?? '';
-        const canonical = {
-            table,
-            unique: Boolean(indexStmt.unique),
-            accessMethod: indexStmt.accessMethod ?? 'btree',
-            indexParams: (indexStmt.indexParams ?? []).map(normalizeIndexParam),
-            whereClause: indexStmt.whereClause ? stripLocations(indexStmt.whereClause) : null,
-        };
-        shapes.push({ idxname, table, shapeKey: JSON.stringify(canonical) });
+    const { parsePostgresSql } = await loadPostgresParser('extractIndexShapes');
+    const facts = await parsePostgresSql({ sql });
+    if (facts.diagnostics.length > 0) {
+        throw new Error(`SQL syntax error: ${facts.diagnostics.map(({ message }) => message).join('; ')}`);
     }
-    return shapes;
-}
-function normalizeIndexParam(param) {
-    if (!('IndexElem' in param))
-        return stripLocations(param);
-    const elem = param.IndexElem;
-    const ordering = elem.ordering === undefined || elem.ordering === 'SORTBY_DEFAULT' ? 'SORTBY_ASC' : elem.ordering;
-    const nullsOrdering = elem.nulls_ordering === undefined || elem.nulls_ordering === 'SORTBY_NULLS_DEFAULT'
-        ? ordering === 'SORTBY_DESC'
-            ? 'SORTBY_NULLS_FIRST'
-            : 'SORTBY_NULLS_LAST'
-        : elem.nulls_ordering;
-    return {
-        key: elem.name ?? stripLocations(elem.expr),
-        ordering,
-        nullsOrdering,
-    };
-}
-function stripLocations(value) {
-    if (Array.isArray(value))
-        return value.map(stripLocations);
-    if (value && typeof value === 'object') {
-        const out = {};
-        for (const [key, val] of Object.entries(value)) {
-            if (key === 'location')
-                continue;
-            out[key] = stripLocations(val);
-        }
-        return out;
-    }
-    return value;
+    return facts.statements.flatMap((statement) => {
+        if (statement.kind !== 'createIndex' || !statement.index.name)
+            return [];
+        const { index } = statement;
+        return [
+            {
+                idxname: index.name.parts.at(-1).value,
+                table: index.table.parts.at(-1).value,
+                shapeKey: index.structuralIdentity,
+            },
+        ];
+    });
 }

package/dist/sql-ast/no-mistakes-peer.d.mts

@@ -0,0 +1,86 @@
+export declare function loadPostgresParser(caller: string): Promise<{
+    default: typeof import("no-mistakes");
+    analyzeTypeScriptModules(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TypeScriptModulesOptions>): Promise<import("no-mistakes").TypeScriptModulesReport>;
+    parsePostgresSql(source: import("no-mistakes").PostgresSqlSource): Promise<import("no-mistakes").PostgresSqlFacts>;
+    parsePostgresSql(sources: import("no-mistakes").PostgresSqlSource[]): Promise<import("no-mistakes").PostgresSqlFacts[]>;
+    dependencies(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TraversePathsOptions>): Promise<import("no-mistakes").ImportClosureResult>;
+    dependencies(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TraverseGraphOptions>): Promise<import("no-mistakes").DependencyResult>;
+    dependents(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TraverseOptions>): Promise<import("no-mistakes").DependencyResult>;
+    related(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TraverseOptions>): Promise<import("no-mistakes").DependencyResult>;
+    analyzeProject(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").AnalyzeProjectOptions>): Promise<import("no-mistakes").AnalyzeProjectResult>;
+    writePlanningImpactArtifacts(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").WritePlanningImpactArtifactsOptions>): Promise<import("no-mistakes").PlanningImpactArtifacts>;
+    symbols(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").SymbolsSignatureImpactOptions>): Promise<import("no-mistakes").SignatureImpactResult>;
+    symbols(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").SymbolsListOptions>): Promise<import("no-mistakes").SymbolsResult>;
+    symbols(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").SymbolsOptions>): Promise<import("no-mistakes").SymbolsResult | import("no-mistakes").SignatureImpactResult>;
+    importUsages(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ImportUsagesOptions>): Promise<import("no-mistakes").ImportUsagesResult>;
+    importers(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ImportersOptions>): Promise<import("no-mistakes").ImportersResult>;
+    exportsOf(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ExportsOfOptions>): Promise<import("no-mistakes").ExportsOfResult>;
+    deadExports(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").DeadExportsOptions>): Promise<import("no-mistakes").DeadExportsResult>;
+    callSites(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").CallSitesOptions>): Promise<import("no-mistakes").CallSitesResult>;
+    resolveCheck(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ResolveCheckOptions>): Promise<import("no-mistakes").ResolveCheckResult>;
+    resolveCheck(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ResolveCheckFilesOptions>): Promise<import("no-mistakes").ResolveCheckBatchResult>;
+    fetches(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").FetchesOptions>): Promise<import("no-mistakes").FetchReport>;
+    flow(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").FlowOptions>): Promise<import("no-mistakes").FlowReport>;
+    check(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").CheckOptions>): Promise<import("no-mistakes").CheckReport>;
+    resolveConfig(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").ResolvedConfig>;
+    validateMermaidMarkdown(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").MermaidValidationOptions>): Promise<import("no-mistakes").MermaidValidationResult>;
+    testsPlan(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsPlanOptions>): Promise<import("no-mistakes").TestPlan>;
+    testsImpact(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsImpactOptions>): Promise<import("no-mistakes").TestPlan>;
+    testsTargets(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsTargetsOptions>): Promise<import("no-mistakes").TestsTargetsReport>;
+    testsWhy(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsWhyOptions>): Promise<Record<string, import("no-mistakes").WhyStep[]>>;
+    testsComment(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsPlanDocumentOptions>): Promise<string>;
+    testsGraph(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsPlanDocumentOptions>): Promise<import("no-mistakes").TestGraph>;
+    testsGraphMermaid(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").TestsPlanDocumentOptions>): Promise<string>;
+    playwrightCheck(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").PlaywrightOptions>): Promise<unknown>;
+    playwrightEdges(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").PlaywrightOptions>): Promise<unknown>;
+    playwrightRelated(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").PlaywrightRelatedOptions>): Promise<unknown>;
+    playwrightTests(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").PlaywrightOptions>): Promise<unknown>;
+    queues(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").QueueReport>;
+    queueEdges(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").QueueEdge[]>;
+    queueRelated(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").QueueEdge[]>;
+    queueCheck(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").QueueCheckFinding[]>;
+    serverRoutes(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").ServerRoutesReport>;
+    serverRouteList(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<unknown[]>;
+    serverRouteEdges(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").GraphEdge[]>;
+    serverRouteRelated(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").GraphEdge[]>;
+    serverContracts(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").ServerContractsReport>;
+    reactAnalyze(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").ReactComponentFacts[]>;
+    reactCheck(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions>): Promise<import("no-mistakes").ReactViolation[]>;
+    reactUsages(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ProjectOptions & {
+        target: string;
+    }>): Promise<import("no-mistakes").ReactUsagesReport>;
+    generatePostgresCatalog(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").PostgresCatalogOptions & {
+        coverage: "ordering";
+    }>): Promise<import("no-mistakes").PostgresOrderingCatalog>;
+    generatePostgresCatalog(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").PostgresCatalogOptions & {
+        coverage?: "complete";
+    }>): Promise<import("no-mistakes").PostgresCompleteCatalog>;
+    generatePostgresCatalog(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").PostgresCatalogOptions>): Promise<import("no-mistakes").PostgresCatalog>;
+    lockfileDiff(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").LockfileDiffOptions>): Promise<import("no-mistakes").LockfileDiffEntry[]>;
+    ciImpact(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").CiImpactOptions>): Promise<import("no-mistakes").CiImpactReport>;
+    ciEnv(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").CiEnvOptions>): Promise<import("no-mistakes").CiEnvReport>;
+    ciTopology(options?: import("no-mistakes").WithInvocationOptions<import("no-mistakes").CiTopologyOptions>): Promise<import("no-mistakes").WorkflowTopology>;
+    ciTopologyImpact(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").CiTopologyImpactOptions>): Promise<import("no-mistakes").CiTopologyImpactReport>;
+    createWorkflowTopologyIndex(topology: import("no-mistakes").WorkflowTopology): import("no-mistakes").WorkflowTopologyIndex;
+    impactedChecks(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").ImpactedChecksOptions>): Promise<import("no-mistakes").ImpactedChecksReport>;
+    dataPw(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").DataPwOptions>): Promise<import("no-mistakes").DataPwReport>;
+    effects(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").EffectsOptions>): Promise<import("no-mistakes").EffectsReport>;
+    rscCallers(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").RscCallersOptions>): Promise<import("no-mistakes").RscCallersReport>;
+    registryExtension(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").RegistryExtensionOptions>): Promise<import("no-mistakes").RegistryExtensionReport>;
+    infraResourceRefs(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").InfraOptions & {
+        address: string;
+    }>): Promise<import("no-mistakes").ResourceRefRow[]>;
+    infraOutputs(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").InfraOptions & {
+        moduleDir: string;
+    }>): Promise<import("no-mistakes").ModuleOutputsResult>;
+    infraTestFor(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").InfraOptions & {
+        tfFile: string;
+    }>): Promise<import("no-mistakes").TestForRow[]>;
+    swiftImporters(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").SwiftOptions & {
+        file: string;
+    }>): Promise<import("no-mistakes").SwiftImporterRow[]>;
+    swiftTestTargets(options: import("no-mistakes").WithInvocationOptions<import("no-mistakes").SwiftOptions & {
+        file: string;
+    }>): Promise<import("no-mistakes").SwiftTestTargetRow[]>;
+    version(): Promise<string>;
+}>;

package/dist/sql-ast/no-mistakes-peer.mjs

@@ -0,0 +1,13 @@
+import { readFile } from 'node:fs/promises';
+export async function loadPostgresParser(caller) {
+    const entry = import.meta.resolve('no-mistakes');
+    const metadata = JSON.parse(await readFile(new URL('package.json', entry), 'utf8'));
+    const version = /^(\d+)\.(\d+)\.(\d+)(-[\w.-]+)?(?:\+[\w.-]+)?$/.exec(metadata.version);
+    const major = Number(version?.[1]);
+    const minor = Number(version?.[2]);
+    const patch = Number(version?.[3]);
+    if (!version || (major === 0 && (minor < 81 || (minor === 81 && patch === 0 && version[4])))) {
+        throw new Error(`${caller} requires no-mistakes >=0.81.0`);
+    }
+    return import('no-mistakes');
+}

package/docs/postgres-replay-context.md

@@ -1,5 +1,11 @@
 # PostgreSQL replay context
 
+`await createPostgresReplayContextFromSchema(schema)` collects STORED generated-expression
+references using the optional `no-mistakes >=0.81.0` SQL peer, then returns the memoized replay context.
+It rejects malformed expressions, additional statements, and unsupported queries instead of
+treating missing facts as an empty dependency set. Snapshots without STORED expressions do not
+load the peer. An incompatible peer is rejected before loading its parser. Snapshot loading and INSERT policy remain the caller's responsibility.
+
 `createPostgresReplayContext` projects a caller-owned schema snapshot and generated-column
 reference facts into the two lookups used by replay checks. It does not load snapshots, parse SQL,
 or decide INSERT policy.
@@ -7,7 +13,7 @@ or decide INSERT policy.
 The caller supplies one `{ table, column, sourceColumns }` fact for each snapshot column whose
 `generated` value is `stored` and whose `generatedExpression` is present. Build `sourceColumns` from
 the parser's typed expression column references, retaining each reference's final identifier
-component. Supply an empty array for a valid expression with no column references. Missing facts
+identity (unquoted names fold to lowercase; quoted names preserve case). Supply an empty array for a valid expression with no column references. Missing facts
 throw when that table's dependencies are requested, so parser failures cannot silently become an
 empty dependency set.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vouchington-tooling",
-  "version": "0.38.1",
+  "version": "0.40.0",
   "description": "Vouchington CLI and extractable tooling libraries.",
   "homepage": "https://github.com/vouchington/vouchington-tooling/tree/main/packages/vouchington-tooling#readme",
   "bugs": {
@@ -380,14 +380,14 @@
     "@modelcontextprotocol/sdk": "1.31.0",
     "@types/picomatch": "^4.0.3",
     "@types/spdx-expression-parse": "4.0.0",
-    "agent-blackboard": "^0.6.0",
-    "no-mistakes": "0.78.0",
+    "agent-blackboard": "^0.6.1",
+    "no-mistakes": "0.83.0",
     "smol-toml": "1.9.0",
     "typescript5": "npm:typescript@5.9.3"
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": "^1.31.0",
-    "agent-blackboard": "^0.6.0",
+    "agent-blackboard": "^0.6.1",
     "no-mistakes": "*",
     "typescript": ">=5",
     "vitest": ">=5"