no-mistakes 0.78.1 → 0.79.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "no-mistakes",
-  "version": "0.78.1",
+  "version": "0.79.0",
   "description": "Deterministic impact maps, test plans, Playwright coverage, and repository checks for coding agents",
   "license": "MIT",
   "repository": {
@@ -45,9 +45,9 @@
     "access": "public"
   },
   "optionalDependencies": {
-    "no-mistakes-darwin-arm64": "0.78.1",
-    "no-mistakes-linux-arm64-gnu": "0.78.1",
-    "no-mistakes-linux-x64-gnu": "0.78.1",
-    "no-mistakes-win32-x64-msvc": "0.78.1"
+    "no-mistakes-darwin-arm64": "0.79.0",
+    "no-mistakes-linux-arm64-gnu": "0.79.0",
+    "no-mistakes-linux-x64-gnu": "0.79.0",
+    "no-mistakes-win32-x64-msvc": "0.79.0"
   }
 }

package/postgres-metadata-types.d.ts

@@ -0,0 +1,18 @@
+import type { PostgresSqlName } from "./postgres-source-types";
+import type { PostgresSqlFunctionArgument } from "./postgres-function-types";
+
+export interface PostgresSqlComment {
+  objectType: string;
+  name: PostgresSqlName;
+  /** null means no signature was written; [] preserves an explicit (). */
+  arguments: PostgresSqlFunctionArgument[] | null;
+  comment: string | null;
+}
+export interface PostgresSqlAlterIndex {
+  name: PostgresSqlName;
+  ifExists: boolean;
+  operation: PostgresSqlAlterIndexOperation;
+}
+export type PostgresSqlAlterIndexOperation =
+  | { kind: "attachPartition"; partition: PostgresSqlName }
+  | { kind: "rename"; name: PostgresSqlName };

package/postgres-procedural-types.d.ts

@@ -4,7 +4,11 @@ import type {
   PostgresSqlSpan,
   PostgresSqlStatement,
 } from "./postgres-source-types";
-/** Nested facts are procedural source occurrences, never guaranteed execution. */
+/** Nested facts are procedural source occurrences, never guaranteed execution.
+ * Supported nested ALTER TABLE constraints use the same typed operations as
+ * top-level statements. Their spans retain original global source coordinates.
+ * Inspect diagnostics even when safely attributed statements are present.
+ */
 export interface PostgresSqlProceduralBlock {
   language: string;
   bodyEncoding: PostgresSqlBodyEncoding;

package/postgres-query-statement-types.d.ts

@@ -0,0 +1,86 @@
+import type {
+  PostgresSqlDiagnostic,
+  PostgresSqlExpression,
+  PostgresSqlIdentifier,
+  PostgresSqlName,
+  PostgresSqlSpan,
+} from "./postgres-source-types";
+import type { PostgresSqlConflict } from "./postgres-insert-types";
+import type { PostgresSqlQueryUnsupported } from "./postgres-query-types";
+
+/** Syntactic modifying bodies in source order, not PostgreSQL execution order.
+ * IDs reference the containing PostgresSqlQuery report, including nested CTEs.
+ * cteId is null for a modifying query body outside a CTE definition.
+ */
+export interface PostgresSqlQueryStatementProvenance {
+  ordinal: number;
+  cteId: number | null;
+  queryScopeId: number;
+  parentScopeId: number | null;
+  /** Exact original source slice. Empty only when span is unavailable/incomplete. */
+  sql: string;
+  span: PostgresSqlSpan | null;
+  returning: PostgresSqlReturningItem[];
+  complete: boolean;
+  unsupported: PostgresSqlQueryUnsupported[];
+}
+export type PostgresSqlQueryStatementKind =
+  | { kind: "insert"; insert: PostgresSqlCteInsert }
+  | { kind: "update"; update: PostgresSqlCteUpdate }
+  | { kind: "delete"; delete: PostgresSqlCteDelete }
+  | { kind: "merge"; merge: PostgresSqlCteMerge }
+  | { kind: "unsupported"; reason: string };
+export type PostgresSqlQueryStatement = PostgresSqlQueryStatementProvenance &
+  PostgresSqlQueryStatementKind;
+export interface PostgresSqlCteInsert {
+  table: PostgresSqlName | null;
+  alias: PostgresSqlIdentifier | null;
+  columns: PostgresSqlName[];
+  columnsOmitted: boolean;
+  source: PostgresSqlCteInsertSource;
+  onConflict: PostgresSqlConflict | null;
+  diagnostics: PostgresSqlDiagnostic[];
+}
+export type PostgresSqlCteInsertSource =
+  | { kind: "values"; rows: PostgresSqlExpression[][]; span: PostgresSqlSpan | null }
+  | { kind: "select"; queryScopeId: number; span: PostgresSqlSpan | null }
+  | { kind: "defaultValues" }
+  | { kind: "unsupported"; reason: string };
+export interface PostgresSqlCteUpdate {
+  targetRelationIds: number[];
+  fromRelationIds: number[];
+  assignments: PostgresSqlDmlAssignment[];
+  predicate: PostgresSqlExpression | null;
+}
+export interface PostgresSqlCteDelete {
+  targetRelationIds: number[];
+  usingRelationIds: number[];
+  predicate: PostgresSqlExpression | null;
+}
+export interface PostgresSqlCteMerge {
+  targetRelationIds: number[];
+  sourceRelationIds: number[];
+  predicate: PostgresSqlExpression;
+  clauses: PostgresSqlMergeClause[];
+}
+export interface PostgresSqlDmlAssignment {
+  columns: PostgresSqlName[];
+  expression: PostgresSqlExpression;
+  span: PostgresSqlSpan | null;
+}
+export interface PostgresSqlMergeClause {
+  matchKind: string;
+  predicate: PostgresSqlExpression | null;
+  span: PostgresSqlSpan | null;
+  action: PostgresSqlMergeAction;
+}
+export type PostgresSqlMergeAction =
+  | { kind: "insert"; columns: PostgresSqlName[]; rows: PostgresSqlExpression[][] }
+  | { kind: "update"; assignments: PostgresSqlDmlAssignment[] }
+  | { kind: "delete" }
+  | { kind: "doNothing" }
+  | { kind: "unsupported"; reason: string };
+export type PostgresSqlReturningItem =
+  | { kind: "expression"; expression: PostgresSqlExpression; alias: PostgresSqlIdentifier | null }
+  | { kind: "wildcard"; qualifier: PostgresSqlName | null; span: PostgresSqlSpan | null }
+  | { kind: "unsupported"; reason: string; span: PostgresSqlSpan | null };

package/postgres-query-types.d.ts

@@ -1,3 +1,5 @@
+import type { PostgresSqlQueryStatement } from "./postgres-query-statement-types";
+export type * from "./postgres-query-statement-types";
 import type {
   PostgresSqlIdentifier,
   PostgresSqlName,
@@ -12,6 +14,8 @@ export interface PostgresSqlQuery {
   equalities: PostgresSqlQueryEquality[];
   exists: PostgresSqlQueryExists[];
   ctes: PostgresSqlQueryCte[];
+  /** Data-modifying query bodies in original source order; SELECT CTEs are excluded. */
+  nestedStatements: PostgresSqlQueryStatement[];
   unsupported: PostgresSqlQueryUnsupported[];
   complete: boolean;
 }

package/postgres-source-types.d.ts

@@ -1,4 +1,6 @@
 import type { PostgresSqlFunction } from "./postgres-function-types";
+import type { PostgresSqlComment, PostgresSqlAlterIndex } from "./postgres-metadata-types";
+export type * from "./postgres-metadata-types";
 export type * from "./postgres-function-types";
 import type { PostgresSqlInsert } from "./postgres-insert-types";
 export type * from "./postgres-insert-types";
@@ -156,6 +158,8 @@ export interface PostgresSqlTrigger {
   characteristics: string | null;
 }
 export type PostgresSqlStatementKind =
+  | { kind: "comment"; comment: PostgresSqlComment }
+  | { kind: "alterIndex"; index: PostgresSqlAlterIndex }
   | { kind: "insert"; insert: PostgresSqlInsert }
   | { kind: "select"; query: PostgresSqlQuery }
   | {