no-mistakes 0.80.0 → 0.82.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "no-mistakes",
-  "version": "0.80.0",
+  "version": "0.82.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.80.0",
-    "no-mistakes-linux-arm64-gnu": "0.80.0",
-    "no-mistakes-linux-x64-gnu": "0.80.0",
-    "no-mistakes-win32-x64-msvc": "0.80.0"
+    "no-mistakes-darwin-arm64": "0.82.0",
+    "no-mistakes-linux-arm64-gnu": "0.82.0",
+    "no-mistakes-linux-x64-gnu": "0.82.0",
+    "no-mistakes-win32-x64-msvc": "0.82.0"
   }
 }

package/postgres-expression-types.d.ts

@@ -17,8 +17,46 @@ export type PostgresSqlExpressionRoot =
   | { kind: "parenthesized"; expression: PostgresSqlExpressionRoot }
   | { kind: "cast"; dataType: string; expression: PostgresSqlExpressionRoot }
   | { kind: "literal"; sql: string }
+  | { kind: "binary"; operator: string }
+  | { kind: "unary"; operator: string; expression: PostgresSqlExpressionRoot }
+  | { kind: "case" | "subquery" | "other" };
+export type PostgresSqlExpressionChildRole =
+  | "argument"
+  | "binaryLeft"
+  | "binaryRight"
+  | "caseOperand"
+  | "caseWhenCondition"
+  | "caseWhenResult"
+  | "caseElse"
+  | "castOperand"
+  | "filterPredicate"
+  | "parenthesizedExpression"
+  | "unaryOperand"
+  | "other";
+export type PostgresSqlExpressionChildRoot =
+  | { kind: "columnReference"; name: PostgresSqlName }
+  | {
+      kind: "functionCall";
+      name: PostgresSqlName;
+      argumentsComplete: boolean;
+      syntax: PostgresSqlFunctionSyntax;
+      modifiers: string[];
+    }
+  | { kind: "parenthesized" }
+  | { kind: "cast"; castKind: string; dataType: string }
+  | { kind: "literal"; sql: string }
   | { kind: "binary" | "unary"; operator: string }
   | { kind: "case" | "subquery" | "other" };
+export interface PostgresSqlExpressionChild {
+  role: PostgresSqlExpressionChildRole;
+  index: number | null;
+  argumentName?: PostgresSqlIdentifier;
+  sql: string;
+  span: PostgresSqlSpan | null;
+  root: PostgresSqlExpressionChildRoot;
+  children: PostgresSqlExpressionChild[];
+  childrenComplete: boolean;
+}
 /** Bare CURRENT_TIMESTAMP is a value function; CURRENT_TIMESTAMP(3) uses call syntax. */
 export type PostgresSqlFunctionSyntax = "call" | "value";
 export interface PostgresSqlCallArgument {

package/postgres-insert-types.d.ts

@@ -12,12 +12,44 @@ export interface PostgresSqlInsert {
   alias: PostgresSqlIdentifier | null;
   columns: PostgresSqlName[];
   columnsOmitted: boolean;
+  columnSources: PostgresSqlInsertColumnSources;
   source: PostgresSqlInsertSource;
   onConflict: PostgresSqlConflict | null;
   span: PostgresSqlSpan | null;
+  /** Syntax completeness is independent of provenance and does not imply replay safety. */
   complete: boolean;
   diagnostics: PostgresSqlDiagnostic[];
 }
+export type PostgresSqlInsertColumnSources =
+  | { kind: "mapped"; columns: PostgresSqlInsertColumnSource[]; complete: boolean }
+  | {
+      kind: "unsupported";
+      reason: PostgresSqlInsertColumnSourcesReason;
+      branchPath?: number[];
+      rowIndex?: number;
+      expectedColumns?: number;
+      sourceColumns?: number;
+    };
+export type PostgresSqlInsertColumnSourcesReason =
+  | "columnsOmitted"
+  | "defaultValues"
+  | "unsupportedSource"
+  | "wildcardProjection"
+  | "aliasExpansion"
+  | "setOperationByName"
+  | "nestingLimit"
+  | "sourceArityMismatch"
+  | "duplicateTargetColumn"
+  | "emptySource"
+  | "cteSourceDelegated";
+export interface PostgresSqlInsertColumnSource {
+  columnIndex: number;
+  column: PostgresSqlName;
+  sources: PostgresSqlInsertSourceExpression[];
+}
+export type PostgresSqlInsertSourceExpression =
+  | { kind: "values"; branchPath: number[]; rowIndex: number; expression: PostgresSqlExpression }
+  | { kind: "select"; branchPath: number[]; expression: PostgresSqlExpression };
 export type PostgresSqlInsertSource =
   | { kind: "values"; rows: PostgresSqlExpression[][]; span: PostgresSqlSpan | null }
   | { kind: "select"; query: PostgresSqlQuery; span: PostgresSqlSpan | null }
@@ -32,7 +64,12 @@ export interface PostgresSqlConflict {
 export type PostgresSqlConflictTarget =
   | { kind: "omitted" }
   | { kind: "columns"; columns: PostgresSqlIdentifier[] }
-  | { kind: "constraint"; name: PostgresSqlName };
+  | { kind: "constraint"; name: PostgresSqlName }
+  | {
+      kind: "expressions";
+      expressions: PostgresSqlExpression[];
+      operatorClasses?: (PostgresSqlArbiterOperatorClass | null)[];
+    };
 export type PostgresSqlConflictAction =
   | { kind: "doNothing" }
   | {
@@ -40,11 +77,29 @@ export type PostgresSqlConflictAction =
       assignments: PostgresSqlInsertAssignment[];
       predicate: PostgresSqlExpression | null;
     };
+/** Ordered index expressions retain source spans; catalog resolution is not implied. */
+export interface PostgresSqlAssignmentTarget {
+  base: PostgresSqlExpression;
+  subscripts: PostgresSqlExpression[];
+  indirection?: PostgresSqlAssignmentStep[];
+  span: PostgresSqlSpan | null;
+}
+export interface PostgresSqlArbiterOperatorClass {
+  name: PostgresSqlName;
+  parameters?: PostgresSqlArbiterParameter[];
+  span: PostgresSqlSpan | null;
+}
+export type PostgresSqlAssignmentStep =
+  | { kind: "subscript"; expression: PostgresSqlExpression; span: PostgresSqlSpan | null }
+  | { kind: "field"; name: PostgresSqlIdentifier; span: PostgresSqlSpan | null };
 export interface PostgresSqlInsertAssignment {
   columns: PostgresSqlName[];
+  target?: PostgresSqlAssignmentTarget;
   expression: PostgresSqlExpression;
+  /** Conservative syntactic lineage; derived and unresolved do not imply missing syntax. */
   provenance: PostgresSqlInsertProvenance;
   span: PostgresSqlSpan | null;
+  /** Whether the assignment syntax is fully represented, independently of provenance. */
   complete: boolean;
 }
 export type PostgresSqlInsertProvenance =
@@ -52,4 +107,10 @@ export type PostgresSqlInsertProvenance =
   | "excludedColumn"
   | "literal"
   | "placeholder"
+  | "derived"
   | "unresolved";
+
+export interface PostgresSqlArbiterParameter {
+  name: PostgresSqlIdentifier;
+  value: PostgresSqlExpression;
+}

package/postgres-procedural-types.d.ts

@@ -26,4 +26,16 @@ export interface PostgresSqlConditionalBranch {
 }
 
 /** Original body source slices retain this enclosing literal encoding. */
-export type PostgresSqlBodyEncoding = "dollarQuoted" | "singleQuoted";
+export type PostgresSqlBodyEncoding = "dollarQuoted" | "singleQuoted" | "escapedString";
+
+/** Wrapper literalSpan uses enclosing source coordinates. All child spans and
+ * diagnostics use decodedSql coordinates, including nested expression spans.
+ * Source occurrences never imply that SQL executes. */
+export interface PostgresSqlLiteralExecute {
+  literalSpan: PostgresSqlSpan;
+  bodyEncoding: PostgresSqlBodyEncoding;
+  decodedSql: string;
+  statements: PostgresSqlStatement[];
+  diagnostics: PostgresSqlDiagnostic[];
+  complete: boolean;
+}

package/postgres-source-types.d.ts

@@ -6,7 +6,10 @@ 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";
-import type { PostgresSqlExpressionRoot } from "./postgres-expression-types";
+import type {
+  PostgresSqlExpressionChild,
+  PostgresSqlExpressionRoot,
+} from "./postgres-expression-types";
 export type * from "./postgres-expression-types";
 import type { PostgresSqlQuery } from "./postgres-query-types";
 export type * from "./postgres-query-types";
@@ -15,6 +18,7 @@ export type * from "./postgres-drop-types";
 import type {
   PostgresSqlConditionalBranch,
   PostgresSqlProceduralBlock,
+  PostgresSqlLiteralExecute,
 } from "./postgres-procedural-types";
 export type * from "./postgres-procedural-types";
 /** Pure SQL source input. No repository, database, or filesystem options are needed. */
@@ -57,6 +61,8 @@ export interface PostgresSqlExpression {
   columns: PostgresSqlName[];
   functions: PostgresSqlFunctionReference[];
   root: PostgresSqlExpressionRoot;
+  children: PostgresSqlExpressionChild[];
+  childrenComplete: boolean;
 }
 export interface PostgresSqlType {
   sql: string;
@@ -96,6 +102,8 @@ export interface PostgresSqlConstraint {
   onUpdate: string | null;
   characteristics: string | null;
   sql: string;
+  /** UTF-8 source range; null when no proven token boundary is available. */
+  span: PostgresSqlSpan | null;
 }
 export type PostgresSqlAlterOperation =
   | { kind: "addColumn"; column: PostgresSqlColumn }
@@ -119,6 +127,7 @@ export interface PostgresSqlIndexKey {
 export interface PostgresSqlIndex {
   name: PostgresSqlName | null;
   table: PostgresSqlName;
+  only: boolean;
   method: string;
   unique: boolean;
   nullsDistinct: boolean;
@@ -178,6 +187,7 @@ export type PostgresSqlStatementKind =
   | { kind: "createTrigger"; trigger: PostgresSqlTrigger }
   | { kind: "createFunction"; function: PostgresSqlFunction }
   | { kind: "drop"; drop: PostgresSqlDrop }
+  | { kind: "literalExecute"; execute: PostgresSqlLiteralExecute }
   | { kind: "doBlock"; block: PostgresSqlProceduralBlock }
   | { kind: "conditional"; branches: PostgresSqlConditionalBranch[] }
   | { kind: "other" };