vouchington-tooling 0.39.0 → 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

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,3 +1,6 @@
+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';
@@ -10,3 +13,4 @@ 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,3 +1,4 @@
+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";
@@ -5,3 +6,4 @@ export { detectRenamedIndexes, indexShapeKey } from "./index-rename-detect.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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vouchington-tooling",
-  "version": "0.39.0",
+  "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": {
@@ -381,7 +381,7 @@
     "@types/picomatch": "^4.0.3",
     "@types/spdx-expression-parse": "4.0.0",
     "agent-blackboard": "^0.6.1",
-    "no-mistakes": "0.81.0",
+    "no-mistakes": "0.83.0",
     "smol-toml": "1.9.0",
     "typescript5": "npm:typescript@5.9.3"
   },