no-mistakes 0.84.1 → 0.85.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "no-mistakes",
-  "version": "0.84.1",
+  "version": "0.85.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.84.1",
-    "no-mistakes-linux-arm64-gnu": "0.84.1",
-    "no-mistakes-linux-x64-gnu": "0.84.1",
-    "no-mistakes-win32-x64-msvc": "0.84.1"
+    "no-mistakes-darwin-arm64": "0.85.0",
+    "no-mistakes-linux-arm64-gnu": "0.85.0",
+    "no-mistakes-linux-x64-gnu": "0.85.0",
+    "no-mistakes-win32-x64-msvc": "0.85.0"
   }
 }

package/postgres-insert-types.d.ts

@@ -6,6 +6,7 @@ import type {
   PostgresSqlSpan,
 } from "./postgres-source-types";
 import type { PostgresSqlQuery } from "./postgres-query-types";
+import type { PostgresSqlReturningItem } from "./postgres-query-statement-types";
 /** Syntactic facts only: complete does not establish replay safety. */
 export interface PostgresSqlInsert {
   table: PostgresSqlName | null;
@@ -15,6 +16,8 @@ export interface PostgresSqlInsert {
   columnSources: PostgresSqlInsertColumnSources;
   source: PostgresSqlInsertSource;
   onConflict: PostgresSqlConflict | null;
+  /** Empty when the statement has no RETURNING clause. */
+  returning: PostgresSqlReturningItem[];
   span: PostgresSqlSpan | null;
   /** Syntax completeness is independent of provenance and does not imply replay safety. */
   complete: boolean;

package/postgres-procedural-types.d.ts

@@ -14,10 +14,35 @@ export interface PostgresSqlProceduralBlock {
   bodyEncoding: PostgresSqlBodyEncoding;
   bodySpan: PostgresSqlSpan;
   statements: PostgresSqlStatement[];
+  /** Classified source occurrences in source order. Visibility is not execution. */
+  occurrences: PostgresSqlProceduralOccurrence[];
   diagnostics: PostgresSqlDiagnostic[];
   complete: boolean;
 }
 
+/** Closed classification for one procedural source occurrence. */
+export type PostgresSqlProceduralOccurrenceKind =
+  | "utility"
+  | "controlFlow"
+  | "dml"
+  | "dynamicExecute"
+  | "unknown";
+
+/** One statically visible occurrence and the occurrences it contains.
+ * `utility` is a non-DML command such as CREATE TYPE.
+ * `controlFlow` is IF, LOOP, RAISE, or another recognized procedural form.
+ * `dml` means INSERT, UPDATE, DELETE, or MERGE text is present; it does not run.
+ * `dynamicExecute` is EXECUTE of a non-literal command, including format and
+ * concatenation that is not wholly literal. `unknown` fails closed.
+ * Nested occurrences stay in source order. Spans use original source coordinates.
+ * Quoted strings and comments are not keywords.
+ */
+export interface PostgresSqlProceduralOccurrence {
+  kind: PostgresSqlProceduralOccurrenceKind;
+  span: PostgresSqlSpan;
+  occurrences: PostgresSqlProceduralOccurrence[];
+}
+
 /** Branch DDL describes source occurrences, never guaranteed execution. */
 export interface PostgresSqlConditionalBranch {
   condition: PostgresSqlExpression | null;
@@ -39,7 +64,8 @@ export interface PostgresSqlLiteralExecute {
   literalSpan: PostgresSqlSpan;
   bodyEncoding: PostgresSqlExecuteEncoding;
   decodedSql: string;
-  /** Ordered source expressions, with enclosing source spans and no runtime evaluation. */
+  /** Ordered source expressions, with enclosing source spans and no runtime evaluation.
+   * A present span's source bytes equal `sql`, including call parentheses. */
   using: PostgresSqlExpression[];
   statements: PostgresSqlStatement[];
   diagnostics: PostgresSqlDiagnostic[];

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

@@ -5,7 +5,7 @@ import type {
   PostgresSqlName,
   PostgresSqlSpan,
 } from "./postgres-source-types";
-import type { PostgresSqlConflict } from "./postgres-insert-types";
+import type { PostgresSqlConflict, PostgresSqlInsertColumnSources } from "./postgres-insert-types";
 import type { PostgresSqlQueryUnsupported } from "./postgres-query-types";
 
 /** Syntactic modifying bodies in source order, not PostgreSQL execution order.
@@ -37,6 +37,8 @@ export interface PostgresSqlCteInsert {
   alias: PostgresSqlIdentifier | null;
   columns: PostgresSqlName[];
   columnsOmitted: boolean;
+  /** Omitted for non-RETURNING CTE inserts. RETURNING keeps direct column lineage. */
+  columnSources?: PostgresSqlInsertColumnSources;
   source: PostgresSqlCteInsertSource;
   onConflict: PostgresSqlConflict | null;
   diagnostics: PostgresSqlDiagnostic[];

package/postgres-query-types.d.ts

@@ -105,7 +105,21 @@ export interface PostgresSqlQueryEquality {
 export interface PostgresSqlQueryExists {
   scopeId: number;
   subqueryScopeId: number;
+  /** The EXISTS node's own flag. Wrapping `NOT` is not folded into this value. */
   negated: boolean;
+  /**
+   * NOT operators that apply to this EXISTS: each wrapping `NOT` (parentheses
+   * are transparent) plus one when `negated` is true.
+   */
+  notDepth: number;
+  /**
+   * `notDepth % 2 === 1` when this EXISTS is not under a boolean test, CASE,
+   * or other wrapper. `null` when `context.underBooleanTest`,
+   * `context.underCase`, or `context.underOther` is set: those wrappers can
+   * invert or hide polarity, and this field does not guess. Always present.
+   * Distinct from `negated` and from `context.underNot`.
+   */
+  effectiveNegated: boolean | null;
   context: PostgresSqlPredicateContext;
   correlated: boolean;
   correlations: PostgresSqlQueryColumn[];

package/postgres-source-types.d.ts

@@ -57,8 +57,10 @@ export interface PostgresSqlFunctionReference {
   span: PostgresSqlSpan | null;
 }
 export interface PostgresSqlExpression {
+  /** Rendered SQL. A present `span` covers these exact source bytes when they occur verbatim. */
   sql: string;
   identity: string;
+  /** End-exclusive span in this fact's source coordinates. */
   span: PostgresSqlSpan | null;
   columns: PostgresSqlName[];
   functions: PostgresSqlFunctionReference[];