@fairfox/polly 0.15.1 → 0.15.4

package/dist/tools/verify/src/config.d.ts

@@ -61,4 +61,4 @@ type UnifiedVerificationConfig = LegacyVerificationConfig | AdapterVerificationC
  * ```
  */
 export declare function defineVerification<T extends UnifiedVerificationConfig>(config: T): T;
-export { $constraints } from "./primitives/index.js";
+export { $constraints, ensures, hasLength, inRange, oneOf, requires } from "./primitives/index.js";

package/dist/tools/verify/src/config.js

@@ -49,6 +49,21 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // tools/verify/src/primitives/index.ts
+function requires(condition, message) {}
+function ensures(condition, message) {}
+function inRange(value, min, max) {
+  return value >= min && value <= max;
+}
+function oneOf(value, allowed) {
+  return allowed.includes(value);
+}
+function hasLength(array, constraint) {
+  if (constraint.min !== undefined && array.length < constraint.min)
+    return false;
+  if (constraint.max !== undefined && array.length > constraint.max)
+    return false;
+  return true;
+}
 function $constraints(stateField, constraints, options) {
   if (options?.runtime) {
     import("../../../src/shared/lib/constraints.js").then(({ registerConstraints }) => {
@@ -79,8 +94,13 @@ function defineVerification(config) {
   return config;
 }
 export {
+  requires,
+  oneOf,
+  inRange,
+  hasLength,
+  ensures,
   defineVerification,
   $constraints
 };
 
-//# debugId=B7658306F59988EF64756E2164756E21
+//# debugId=477FC1CD67CF195864756E2164756E21

package/dist/tools/verify/src/config.js.map

@@ -3,9 +3,9 @@
   "sources": ["../tools/verify/src/primitives/index.ts", "../tools/verify/src/config.ts"],
   "sourcesContent": [
     "// Verification primitives for formal verification\n// These are runtime no-ops but extracted during verification\n\n/**\n * Assert a precondition that must be true when the handler executes.\n *\n * In production: No-op (compiled away)\n * In verification: Translated to TLA+ assertion\n *\n * @example\n * messageBus.on(\"USER_LOGIN\", (payload) => {\n *   requires(state.user.loggedIn === false, \"User must not be logged in\")\n *   state.user.loggedIn = true\n * })\n */\nexport function requires(condition: boolean, message?: string): void {\n  // Runtime no-op - only used during verification\n  // Condition and message are checked during static analysis only\n  void condition;\n  void message;\n}\n\n/**\n * Assert a postcondition that must be true after the handler completes.\n *\n * In production: No-op (compiled away)\n * In verification: Translated to TLA+ assertion\n *\n * @example\n * messageBus.on(\"USER_LOGIN\", (payload) => {\n *   state.user.loggedIn = true\n *   ensures(state.user.loggedIn === true, \"User must be logged in\")\n * })\n */\nexport function ensures(condition: boolean, message?: string): void {\n  // Runtime no-op - only used during verification\n  // Condition and message are checked during static analysis only\n  void condition;\n  void message;\n}\n\n/**\n * Define a global invariant that must always hold.\n *\n * In production: No-op (compiled away)\n * In verification: Translated to TLA+ invariant\n *\n * @example\n * invariant(\"UserIdConsistent\", () =>\n *   state.user.loggedIn === false || state.user.id !== null\n * )\n */\nexport function invariant(_name: string, condition: () => boolean): void {\n  // Runtime no-op - only used during verification\n  // Name and condition are checked during static analysis only\n  void condition;\n}\n\n/**\n * Assert that a value is within a valid range.\n *\n * @example\n * requires(inRange(todoCount, 0, 100), \"Todo count must be 0-100\")\n */\nexport function inRange(value: number, min: number, max: number): boolean {\n  return value >= min && value <= max;\n}\n\n/**\n * Assert that a value is one of the allowed values.\n *\n * @example\n * requires(oneOf(state.user.role, [\"admin\", \"user\"]), \"Role must be admin or user\")\n */\nexport function oneOf<T>(value: T, allowed: T[]): boolean {\n  return allowed.includes(value);\n}\n\n/**\n * Assert that an array has a specific length constraint.\n *\n * @example\n * requires(hasLength(state.todos, { max: 10 }), \"Too many todos\")\n */\nexport function hasLength(array: unknown[], constraint: { min?: number; max?: number }): boolean {\n  if (constraint.min !== undefined && array.length < constraint.min) return false;\n  if (constraint.max !== undefined && array.length > constraint.max) return false;\n  return true;\n}\n\n/**\n * Declare state-level constraints for verification and optional runtime checking.\n * Maps message types to preconditions on state fields.\n *\n * The parser automatically wires these constraints to handlers during verification.\n * Optionally, constraints can be enforced at runtime by passing `{ runtime: true }`.\n *\n * @example\n * // Verification only (TLA+ generation)\n * const state = { loggedIn: false };\n *\n * $constraints(\"loggedIn\", {\n *   USER_LOGOUT: { requires: \"state.loggedIn === true\", message: \"Must be logged in\" },\n *   BOOKMARK_ADD: { requires: \"state.loggedIn === true\", message: \"Must be logged in\" },\n * });\n *\n * @example\n * // Runtime enforcement (function predicates)\n * $constraints(\"loggedIn\", {\n *   USER_LOGOUT: {\n *     requires: (state) => state.loggedIn === true,\n *     message: \"Must be logged in to logout\"\n *   },\n * }, { runtime: true });\n */\nexport function $constraints(\n  stateField: string,\n  constraints: Record<\n    string,\n    {\n      requires?: string | ((state: unknown) => boolean);\n      ensures?: string | ((state: unknown) => boolean);\n      message?: string;\n    }\n  >,\n  options?: { runtime?: boolean }\n): void {\n  // Register constraints for runtime checking if enabled\n  if (options?.runtime) {\n    // Import dynamically to avoid circular dependencies\n    // This is safe because it only happens at runtime, not during static analysis\n    // @ts-expect-error - Dynamic import path resolves correctly at runtime\n    import(\"../../../src/shared/lib/constraints.js\")\n      .then(({ registerConstraints }) => {\n        registerConstraints(stateField, constraints);\n      })\n      .catch(() => {\n        // Silently ignore - constraints module may not be available during static analysis\n      });\n  }\n\n  // For verification: Still a no-op at runtime\n  // Parser extracts these and wires them to TLA+ handlers\n}\n\n// Re-export for convenience\nexport const verify = {\n  requires,\n  ensures,\n  invariant,\n  inRange,\n  oneOf,\n  hasLength,\n  $constraints,\n};\n",
-    "// ═══════════════════════════════════════════════════════════════\n// Configuration Helper for @fairfox/polly/verify\n// ═══════════════════════════════════════════════════════════════\n//\n// Lightweight entry point for user configuration files.\n// Does NOT include heavy dependencies (ts-morph, analysis, etc.)\n// which are only needed by the CLI tool.\n\n// ─────────────────────────────────────────────────────────────────\n// Configuration Types (inlined to avoid heavy dependencies)\n// ─────────────────────────────────────────────────────────────────\n\n// Legacy verification configuration\ninterface LegacyVerificationConfig {\n  state: Record<string, unknown>;\n  messages: {\n    // Basic bounds\n    maxInFlight?: number;\n    maxTabs?: number;\n    maxClients?: number;\n    maxRenderers?: number;\n    maxWorkers?: number;\n    maxContexts?: number;\n\n    // Tier 1 Optimizations (no precision loss)\n    include?: string[]; // Only verify these message types\n    exclude?: string[]; // Exclude these message types (mutually exclusive with include)\n    symmetry?: string[][]; // Groups of symmetric message types [[type1, type2], [type3, type4]]\n    perMessageBounds?: Record<string, number>; // Different maxInFlight per message type\n  };\n  onBuild?: \"warn\" | \"error\" | \"off\";\n  onRelease?: \"warn\" | \"error\" | \"off\";\n\n  // Verification engine options\n  verification?: {\n    timeout?: number; // Timeout in seconds (0 = no timeout)\n    workers?: number; // Number of TLC workers\n  };\n\n  // Tier 2 Optimizations (controlled approximations)\n  tier2?: {\n    // Temporal constraints: ordering requirements between messages\n    temporalConstraints?: Array<{\n      before: string; // Message type that must occur first\n      after: string; // Message type that must occur after\n      description?: string; // Human-readable description\n    }>;\n\n    // Bounded exploration: limit depth for specific scenarios\n    boundedExploration?: {\n      maxDepth?: number; // Maximum state depth to explore\n      criticalPaths?: string[][]; // Sequences of message types that must be fully explored\n    };\n  };\n}\n\n// Adapter-based configuration (for future use)\ninterface AdapterVerificationConfig {\n  adapter: unknown; // Adapter interface not exported to avoid heavy deps\n  state: Record<string, unknown>;\n  bounds?: {\n    maxInFlight?: number;\n    [key: string]: unknown;\n  };\n  onBuild?: \"warn\" | \"error\" | \"off\";\n}\n\n// Union type for both config formats\ntype UnifiedVerificationConfig = LegacyVerificationConfig | AdapterVerificationConfig;\n\n/**\n * Define verification configuration with type checking\n *\n * Used in generated verification.config.ts files.\n *\n * @example\n * ```typescript\n * import { defineVerification } from '@fairfox/polly/verify'\n *\n * export default defineVerification({\n *   state: {\n *     \"user.role\": { type: \"enum\", values: [\"admin\", \"user\", \"guest\"] },\n *   },\n *   messages: {\n *     maxInFlight: 6,\n *     maxTabs: 2,\n *   },\n * })\n * ```\n */\nexport function defineVerification<T extends UnifiedVerificationConfig>(config: T): T {\n  // Validate configuration structure\n  if (\"adapter\" in config) {\n    // New adapter-based format\n    if (!config.adapter) {\n      throw new Error(\"Configuration must include an adapter\");\n    }\n    if (!config.state) {\n      throw new Error(\"Configuration must include state bounds\");\n    }\n  } else if (\"messages\" in config) {\n    // Legacy format\n    if (!config.state) {\n      throw new Error(\"Configuration must include state bounds\");\n    }\n    if (!config.messages) {\n      throw new Error(\"Legacy configuration must include messages bounds\");\n    }\n  } else {\n    throw new Error(\n      \"Invalid configuration format. Must include either 'adapter' (new format) or 'messages' (legacy format)\"\n    );\n  }\n\n  return config;\n}\n\n// Re-export $constraints from primitives for user code\nexport { $constraints } from \"./primitives/index.js\";\n"
+    "// ═══════════════════════════════════════════════════════════════\n// Configuration Helper for @fairfox/polly/verify\n// ═══════════════════════════════════════════════════════════════\n//\n// Lightweight entry point for user configuration files.\n// Does NOT include heavy dependencies (ts-morph, analysis, etc.)\n// which are only needed by the CLI tool.\n\n// ─────────────────────────────────────────────────────────────────\n// Configuration Types (inlined to avoid heavy dependencies)\n// ─────────────────────────────────────────────────────────────────\n\n// Legacy verification configuration\ninterface LegacyVerificationConfig {\n  state: Record<string, unknown>;\n  messages: {\n    // Basic bounds\n    maxInFlight?: number;\n    maxTabs?: number;\n    maxClients?: number;\n    maxRenderers?: number;\n    maxWorkers?: number;\n    maxContexts?: number;\n\n    // Tier 1 Optimizations (no precision loss)\n    include?: string[]; // Only verify these message types\n    exclude?: string[]; // Exclude these message types (mutually exclusive with include)\n    symmetry?: string[][]; // Groups of symmetric message types [[type1, type2], [type3, type4]]\n    perMessageBounds?: Record<string, number>; // Different maxInFlight per message type\n  };\n  onBuild?: \"warn\" | \"error\" | \"off\";\n  onRelease?: \"warn\" | \"error\" | \"off\";\n\n  // Verification engine options\n  verification?: {\n    timeout?: number; // Timeout in seconds (0 = no timeout)\n    workers?: number; // Number of TLC workers\n  };\n\n  // Tier 2 Optimizations (controlled approximations)\n  tier2?: {\n    // Temporal constraints: ordering requirements between messages\n    temporalConstraints?: Array<{\n      before: string; // Message type that must occur first\n      after: string; // Message type that must occur after\n      description?: string; // Human-readable description\n    }>;\n\n    // Bounded exploration: limit depth for specific scenarios\n    boundedExploration?: {\n      maxDepth?: number; // Maximum state depth to explore\n      criticalPaths?: string[][]; // Sequences of message types that must be fully explored\n    };\n  };\n}\n\n// Adapter-based configuration (for future use)\ninterface AdapterVerificationConfig {\n  adapter: unknown; // Adapter interface not exported to avoid heavy deps\n  state: Record<string, unknown>;\n  bounds?: {\n    maxInFlight?: number;\n    [key: string]: unknown;\n  };\n  onBuild?: \"warn\" | \"error\" | \"off\";\n}\n\n// Union type for both config formats\ntype UnifiedVerificationConfig = LegacyVerificationConfig | AdapterVerificationConfig;\n\n/**\n * Define verification configuration with type checking\n *\n * Used in generated verification.config.ts files.\n *\n * @example\n * ```typescript\n * import { defineVerification } from '@fairfox/polly/verify'\n *\n * export default defineVerification({\n *   state: {\n *     \"user.role\": { type: \"enum\", values: [\"admin\", \"user\", \"guest\"] },\n *   },\n *   messages: {\n *     maxInFlight: 6,\n *     maxTabs: 2,\n *   },\n * })\n * ```\n */\nexport function defineVerification<T extends UnifiedVerificationConfig>(config: T): T {\n  // Validate configuration structure\n  if (\"adapter\" in config) {\n    // New adapter-based format\n    if (!config.adapter) {\n      throw new Error(\"Configuration must include an adapter\");\n    }\n    if (!config.state) {\n      throw new Error(\"Configuration must include state bounds\");\n    }\n  } else if (\"messages\" in config) {\n    // Legacy format\n    if (!config.state) {\n      throw new Error(\"Configuration must include state bounds\");\n    }\n    if (!config.messages) {\n      throw new Error(\"Legacy configuration must include messages bounds\");\n    }\n  } else {\n    throw new Error(\n      \"Invalid configuration format. Must include either 'adapter' (new format) or 'messages' (legacy format)\"\n    );\n  }\n\n  return config;\n}\n\n// Re-export verification primitives for user code\nexport { $constraints, ensures, hasLength, inRange, oneOf, requires } from \"./primitives/index.js\";\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmHO,SAAS,YAAY,CAC1B,YACA,aAQA,SACM;AAAA,EAEN,IAAI,SAAS,SAAS;AAAA,IAIb,iDACJ,KAAK,GAAG,0BAA0B;AAAA,MACjC,oBAAoB,YAAY,WAAW;AAAA,KAC5C,EACA,MAAM,MAAM,EAEZ;AAAA,EACL;AAAA;;;ACjDK,SAAS,kBAAuD,CAAC,QAAc;AAAA,EAEpF,IAAI,aAAa,QAAQ;AAAA,IAEvB,IAAI,CAAC,OAAO,SAAS;AAAA,MACnB,MAAM,IAAI,MAAM,uCAAuC;AAAA,IACzD;AAAA,IACA,IAAI,CAAC,OAAO,OAAO;AAAA,MACjB,MAAM,IAAI,MAAM,yCAAyC;AAAA,IAC3D;AAAA,EACF,EAAO,SAAI,cAAc,QAAQ;AAAA,IAE/B,IAAI,CAAC,OAAO,OAAO;AAAA,MACjB,MAAM,IAAI,MAAM,yCAAyC;AAAA,IAC3D;AAAA,IACA,IAAI,CAAC,OAAO,UAAU;AAAA,MACpB,MAAM,IAAI,MAAM,mDAAmD;AAAA,IACrE;AAAA,EACF,EAAO;AAAA,IACL,MAAM,IAAI,MACR,wGACF;AAAA;AAAA,EAGF,OAAO;AAAA;",
-  "debugId": "B7658306F59988EF64756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeO,SAAS,QAAQ,CAAC,WAAoB,SAAwB;AAmB9D,SAAS,OAAO,CAAC,WAAoB,SAAwB;AA8B7D,SAAS,OAAO,CAAC,OAAe,KAAa,KAAsB;AAAA,EACxE,OAAO,SAAS,OAAO,SAAS;AAAA;AAS3B,SAAS,KAAQ,CAAC,OAAU,SAAuB;AAAA,EACxD,OAAO,QAAQ,SAAS,KAAK;AAAA;AASxB,SAAS,SAAS,CAAC,OAAkB,YAAqD;AAAA,EAC/F,IAAI,WAAW,QAAQ,aAAa,MAAM,SAAS,WAAW;AAAA,IAAK,OAAO;AAAA,EAC1E,IAAI,WAAW,QAAQ,aAAa,MAAM,SAAS,WAAW;AAAA,IAAK,OAAO;AAAA,EAC1E,OAAO;AAAA;AA4BF,SAAS,YAAY,CAC1B,YACA,aAQA,SACM;AAAA,EAEN,IAAI,SAAS,SAAS;AAAA,IAIb,iDACJ,KAAK,GAAG,0BAA0B;AAAA,MACjC,oBAAoB,YAAY,WAAW;AAAA,KAC5C,EACA,MAAM,MAAM,EAEZ;AAAA,EACL;AAAA;;;ACjDK,SAAS,kBAAuD,CAAC,QAAc;AAAA,EAEpF,IAAI,aAAa,QAAQ;AAAA,IAEvB,IAAI,CAAC,OAAO,SAAS;AAAA,MACnB,MAAM,IAAI,MAAM,uCAAuC;AAAA,IACzD;AAAA,IACA,IAAI,CAAC,OAAO,OAAO;AAAA,MACjB,MAAM,IAAI,MAAM,yCAAyC;AAAA,IAC3D;AAAA,EACF,EAAO,SAAI,cAAc,QAAQ;AAAA,IAE/B,IAAI,CAAC,OAAO,OAAO;AAAA,MACjB,MAAM,IAAI,MAAM,yCAAyC;AAAA,IAC3D;AAAA,IACA,IAAI,CAAC,OAAO,UAAU;AAAA,MACpB,MAAM,IAAI,MAAM,mDAAmD;AAAA,IACrE;AAAA,EACF,EAAO;AAAA,IACL,MAAM,IAAI,MACR,wGACF;AAAA;AAAA,EAGF,OAAO;AAAA;",
+  "debugId": "477FC1CD67CF195864756E2164756E21",
   "names": []
 }

package/dist/tools/visualize/src/cli.js

@@ -1598,6 +1598,7 @@ class HandlerExtractor {
   relationshipExtractor;
   analyzedFiles;
   packageRoot;
+  warnings;
   constructor(tsConfigPath) {
     this.project = new Project3({
       tsConfigFilePath: tsConfigPath
@@ -1605,8 +1606,27 @@ class HandlerExtractor {
     this.typeGuardCache = new WeakMap;
     this.relationshipExtractor = new RelationshipExtractor;
     this.analyzedFiles = new Set;
+    this.warnings = [];
     this.packageRoot = this.findPackageRoot(tsConfigPath);
   }
+  warnUnsupportedPattern(pattern, location, suggestion) {
+    const exists = this.warnings.some((w) => w.pattern === pattern && w.location === location);
+    if (!exists) {
+      this.warnings.push({
+        type: "unsupported_pattern",
+        pattern,
+        location,
+        suggestion
+      });
+    }
+  }
+  getNodeLocation(node) {
+    const sourceFile = node.getSourceFile();
+    const lineAndCol = sourceFile.getLineAndColumnAtPos(node.getStart());
+    const filePath = sourceFile.getFilePath();
+    const relativePath = filePath.startsWith(this.packageRoot) ? filePath.substring(this.packageRoot.length + 1) : filePath;
+    return `${relativePath}:${lineAndCol.line}`;
+  }
   findPackageRoot(tsConfigPath) {
     let dir = tsConfigPath.substring(0, tsConfigPath.lastIndexOf("/"));
     while (dir.length > 1) {
@@ -1630,6 +1650,7 @@ class HandlerExtractor {
     const invalidMessageTypes = new Set;
     const stateConstraints = [];
     const verifiedStates = [];
+    this.warnings = [];
     const allSourceFiles = this.project.getSourceFiles();
     const entryPoints = allSourceFiles.filter((f) => this.isWithinPackage(f.getFilePath()));
     this.debugLogSourceFiles(allSourceFiles, entryPoints);
@@ -1664,7 +1685,8 @@ class HandlerExtractor {
       handlers,
       messageTypes,
       stateConstraints,
-      verifiedStates
+      verifiedStates,
+      warnings: this.warnings
     };
   }
   analyzeFileAndImports(sourceFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, verifiedStates) {
@@ -1894,46 +1916,364 @@ class HandlerExtractor {
     if (!Node4.isPropertyAccessExpression(left))
       return;
     const fieldPath = this.getPropertyPath(left);
-    if (fieldPath.startsWith("state.")) {
-      const field = fieldPath.substring(6);
-      const value = this.extractValue(right);
-      if (value !== undefined) {
-        assignments.push({ field, value });
-      }
+    if (this.tryExtractStateFieldPattern(fieldPath, right, assignments))
       return;
-    }
-    const valueMatch = fieldPath.match(/\.value\.(.+)$/);
-    if (valueMatch?.[1]) {
-      const field = valueMatch[1];
-      const value = this.extractValue(right);
-      if (value !== undefined) {
-        assignments.push({ field, value });
-      }
+    if (this.tryExtractSignalNestedFieldPattern(fieldPath, right, assignments))
+      return;
+    if (this.tryExtractSignalObjectPattern(fieldPath, right, assignments))
+      return;
+    if (this.tryExtractSignalArrayPattern(fieldPath, right, assignments))
+      return;
+    if (this.tryExtractSignalMethodPattern(fieldPath, right, assignments))
+      return;
+    if (this.tryExtractSetConstructorPattern(fieldPath, right, assignments))
       return;
+    this.tryExtractMapConstructorPattern(fieldPath, right, assignments);
+  }
+  tryExtractStateFieldPattern(fieldPath, right, assignments) {
+    if (!fieldPath.startsWith("state."))
+      return false;
+    const field = fieldPath.substring(6);
+    const value = this.extractValue(right);
+    if (value !== undefined) {
+      assignments.push({ field, value });
     }
-    if (fieldPath.endsWith(".value") && Node4.isObjectLiteralExpression(right)) {
-      this.extractObjectLiteralAssignments(right, assignments);
+    return true;
+  }
+  tryExtractSignalNestedFieldPattern(fieldPath, right, assignments) {
+    const valueFieldMatch = fieldPath.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\.value\.(.+)$/);
+    if (!valueFieldMatch?.[1] || !valueFieldMatch?.[2])
+      return false;
+    const signalName = valueFieldMatch[1];
+    const fieldName = valueFieldMatch[2];
+    const value = this.extractValue(right);
+    if (value !== undefined) {
+      assignments.push({ field: `${signalName}_${fieldName}`, value });
     }
+    return true;
   }
-  extractObjectLiteralAssignments(objectLiteral, assignments) {
-    if (!Node4.isObjectLiteralExpression(objectLiteral))
+  tryExtractSignalObjectPattern(fieldPath, right, assignments) {
+    if (!fieldPath.endsWith(".value") || !Node4.isObjectLiteralExpression(right))
+      return false;
+    const signalName = fieldPath.slice(0, -6);
+    if (this.isSpreadUpdatePattern(right, fieldPath)) {
+      this.extractSpreadUpdateAssignments(right, assignments, signalName);
+    } else {
+      this.extractObjectLiteralAssignments(right, assignments, signalName);
+    }
+    return true;
+  }
+  isSpreadUpdatePattern(objectLiteral, fieldPath) {
+    const properties = objectLiteral.getProperties();
+    if (properties.length === 0)
+      return false;
+    const firstProp = properties[0];
+    if (!firstProp || !Node4.isSpreadAssignment(firstProp))
+      return false;
+    const spreadExpr = firstProp.getExpression();
+    if (!spreadExpr)
+      return false;
+    return this.getPropertyPath(spreadExpr) === fieldPath;
+  }
+  tryExtractSignalArrayPattern(fieldPath, right, assignments) {
+    if (!fieldPath.endsWith(".value") || !Node4.isArrayLiteralExpression(right))
+      return false;
+    const signalName = fieldPath.slice(0, -6);
+    const arrayAssignment = this.extractArraySpreadOperation(right, fieldPath, signalName);
+    if (arrayAssignment) {
+      assignments.push(arrayAssignment);
+    }
+    return true;
+  }
+  tryExtractSignalMethodPattern(fieldPath, right, assignments) {
+    if (!fieldPath.endsWith(".value") || !Node4.isCallExpression(right))
+      return false;
+    const signalName = fieldPath.slice(0, -6);
+    this.checkForMutatingCollectionMethods(right);
+    const methodAssignment = this.extractArrayMethodOperation(right, fieldPath, signalName);
+    if (methodAssignment) {
+      assignments.push(methodAssignment);
+    }
+    return true;
+  }
+  checkForMutatingCollectionMethods(callExpr) {
+    const expression = callExpr.getExpression();
+    if (!Node4.isPropertyAccessExpression(expression))
       return;
-    for (const prop of objectLiteral.getProperties()) {
-      if (Node4.isPropertyAssignment(prop)) {
-        const name = prop.getName();
-        const initializer = prop.getInitializer();
-        if (!name || !initializer)
-          continue;
-        const value = this.extractValue(initializer);
-        if (value !== undefined) {
-          assignments.push({ field: name, value });
+    const methodName = expression.getName();
+    const sourceExpr = expression.getExpression();
+    const setMethods = ["add", "delete", "clear"];
+    if (setMethods.includes(methodName)) {
+      const sourceText = sourceExpr.getText();
+      if (sourceText.includes("Set") || this.looksLikeSetOrMap(sourceExpr, "Set")) {
+        this.warnUnsupportedPattern(`set.${methodName}()`, this.getNodeLocation(callExpr), `Set.${methodName}() mutates in place. Use: new Set([...set, item]) for add, new Set([...set].filter(...)) for delete.`);
+      }
+    }
+    const mapMethods = ["set", "delete", "clear"];
+    if (mapMethods.includes(methodName)) {
+      const sourceText = sourceExpr.getText();
+      if (sourceText.includes("Map") || this.looksLikeSetOrMap(sourceExpr, "Map")) {
+        this.warnUnsupportedPattern(`map.${methodName}()`, this.getNodeLocation(callExpr), `Map.${methodName}() mutates in place. Use: new Map([...map, [key, value]]) for set, new Map([...map].filter(...)) for delete.`);
+      }
+    }
+  }
+  looksLikeSetOrMap(expr, collectionType) {
+    const text = expr.getText().toLowerCase();
+    return text.includes(collectionType.toLowerCase());
+  }
+  tryExtractSetConstructorPattern(fieldPath, right, assignments) {
+    if (!fieldPath.endsWith(".value") || !Node4.isNewExpression(right))
+      return false;
+    const constructorExpr = right.getExpression();
+    if (!Node4.isIdentifier(constructorExpr) || constructorExpr.getText() !== "Set")
+      return false;
+    const signalName = fieldPath.slice(0, -6);
+    const setAssignment = this.extractSetOperation(right, fieldPath, signalName);
+    if (setAssignment) {
+      assignments.push(setAssignment);
+    }
+    return true;
+  }
+  tryExtractMapConstructorPattern(fieldPath, right, assignments) {
+    if (!fieldPath.endsWith(".value") || !Node4.isNewExpression(right))
+      return false;
+    const constructorExpr = right.getExpression();
+    if (!Node4.isIdentifier(constructorExpr) || constructorExpr.getText() !== "Map")
+      return false;
+    const signalName = fieldPath.slice(0, -6);
+    const mapAssignment = this.extractMapOperation(right, fieldPath, signalName);
+    if (mapAssignment) {
+      assignments.push(mapAssignment);
+    }
+    return true;
+  }
+  extractSetOperation(newExpr, fieldPath, signalName) {
+    const args = newExpr.getArguments();
+    if (args.length === 0) {
+      return { field: signalName, value: "{}" };
+    }
+    const firstArg = args[0];
+    if (!firstArg)
+      return null;
+    if (Node4.isArrayLiteralExpression(firstArg)) {
+      return this.extractSetArrayOperation(firstArg, fieldPath, signalName);
+    }
+    if (Node4.isCallExpression(firstArg)) {
+      return this.extractSetMethodChainOperation(firstArg, fieldPath, signalName);
+    }
+    return null;
+  }
+  extractSetArrayOperation(arrayLiteral, fieldPath, signalName) {
+    const elements = arrayLiteral.getElements();
+    if (elements.length < 1)
+      return null;
+    const firstElement = elements[0];
+    const lastElement = elements[elements.length - 1];
+    if (firstElement && Node4.isSpreadElement(firstElement)) {
+      const spreadExpr = firstElement.getExpression();
+      if (spreadExpr && this.getPropertyPath(spreadExpr) === fieldPath) {
+        return { field: signalName, value: "@ \\union {payload}" };
+      }
+    }
+    if (lastElement && Node4.isSpreadElement(lastElement)) {
+      const spreadExpr = lastElement.getExpression();
+      if (spreadExpr && this.getPropertyPath(spreadExpr) === fieldPath) {
+        return { field: signalName, value: "{payload} \\union @" };
+      }
+    }
+    return null;
+  }
+  extractSetMethodChainOperation(callExpr, fieldPath, signalName) {
+    const expression = callExpr.getExpression();
+    if (!Node4.isPropertyAccessExpression(expression))
+      return null;
+    const methodName = expression.getName();
+    const sourceExpr = expression.getExpression();
+    if (methodName === "filter" && Node4.isArrayLiteralExpression(sourceExpr)) {
+      const elements = sourceExpr.getElements();
+      if (elements.length === 1) {
+        const spreadEl = elements[0];
+        if (spreadEl && Node4.isSpreadElement(spreadEl)) {
+          const spreadExpr = spreadEl.getExpression();
+          if (spreadExpr && this.getPropertyPath(spreadExpr) === fieldPath) {
+            return { field: signalName, value: "@ \\ {payload}" };
+          }
         }
       }
-      if (Node4.isShorthandPropertyAssignment(prop)) {
-        const name = prop.getName();
-        assignments.push({ field: name, value: "@" });
+    }
+    return null;
+  }
+  extractMapOperation(newExpr, fieldPath, signalName) {
+    const args = newExpr.getArguments();
+    if (args.length === 0) {
+      return { field: signalName, value: "<<>>" };
+    }
+    const firstArg = args[0];
+    if (!firstArg)
+      return null;
+    if (Node4.isArrayLiteralExpression(firstArg)) {
+      return this.extractMapArrayOperation(firstArg, fieldPath, signalName);
+    }
+    if (Node4.isCallExpression(firstArg)) {
+      return this.extractMapMethodChainOperation(firstArg, fieldPath, signalName);
+    }
+    return null;
+  }
+  extractMapArrayOperation(arrayLiteral, fieldPath, signalName) {
+    const elements = arrayLiteral.getElements();
+    if (elements.length < 1)
+      return null;
+    const firstElement = elements[0];
+    if (firstElement && Node4.isSpreadElement(firstElement)) {
+      const spreadExpr = firstElement.getExpression();
+      if (spreadExpr && this.getPropertyPath(spreadExpr) === fieldPath) {
+        return { field: signalName, value: "[@ EXCEPT ![payload.key] = payload.value]" };
+      }
+    }
+    return null;
+  }
+  extractMapMethodChainOperation(callExpr, fieldPath, signalName) {
+    const expression = callExpr.getExpression();
+    if (!Node4.isPropertyAccessExpression(expression))
+      return null;
+    const methodName = expression.getName();
+    const sourceExpr = expression.getExpression();
+    if (methodName === "filter" && Node4.isArrayLiteralExpression(sourceExpr)) {
+      const elements = sourceExpr.getElements();
+      if (elements.length === 1) {
+        const spreadEl = elements[0];
+        if (spreadEl && Node4.isSpreadElement(spreadEl)) {
+          const spreadExpr = spreadEl.getExpression();
+          if (spreadExpr && this.getPropertyPath(spreadExpr) === fieldPath) {
+            return { field: signalName, value: "[k \\in DOMAIN @ \\ {payload.key} |-> @[k]]" };
+          }
+        }
       }
     }
+    return null;
+  }
+  extractArrayMethodOperation(callExpr, fieldPath, signalName) {
+    const expression = callExpr.getExpression();
+    if (!Node4.isPropertyAccessExpression(expression))
+      return null;
+    const methodName = expression.getName();
+    const sourceExpr = expression.getExpression();
+    const sourcePath = this.getPropertyPath(sourceExpr);
+    if (sourcePath !== fieldPath)
+      return null;
+    switch (methodName) {
+      case "filter":
+        return { field: signalName, value: "SelectSeq(@, LAMBDA t: TRUE)" };
+      case "map":
+        return { field: signalName, value: "[i \\in DOMAIN @ |-> @[i]]" };
+      case "slice":
+        return { field: signalName, value: "SubSeq(@, 1, Len(@))" };
+      case "concat":
+        return { field: signalName, value: "@ \\o <<payload>>" };
+      case "reverse":
+        return { field: signalName, value: "[i \\in DOMAIN @ |-> @[Len(@) - i + 1]]" };
+      default:
+        this.warnUnsupportedArrayMethod(methodName, callExpr);
+        return null;
+    }
+  }
+  warnUnsupportedArrayMethod(methodName, node) {
+    const mutatingMethods = [
+      "push",
+      "pop",
+      "shift",
+      "unshift",
+      "splice",
+      "sort",
+      "fill",
+      "copyWithin"
+    ];
+    const queryMethods = [
+      "find",
+      "findIndex",
+      "reduce",
+      "reduceRight",
+      "some",
+      "every",
+      "includes",
+      "indexOf",
+      "lastIndexOf"
+    ];
+    const otherMethods = ["flat", "flatMap", "join", "toString", "toLocaleString"];
+    if (mutatingMethods.includes(methodName)) {
+      this.warnUnsupportedPattern(`array.${methodName}()`, this.getNodeLocation(node), `'${methodName}' mutates in place. Use spread syntax: [...arr, item] for append, arr.filter() for removal.`);
+    } else if (queryMethods.includes(methodName)) {
+      this.warnUnsupportedPattern(`array.${methodName}()`, this.getNodeLocation(node), `'${methodName}' returns a single value, not a new array. State assignment won't be extracted.`);
+    } else if (otherMethods.includes(methodName)) {
+      this.warnUnsupportedPattern(`array.${methodName}()`, this.getNodeLocation(node), `'${methodName}' is not supported for state extraction. Consider using map/filter instead.`);
+    }
+  }
+  extractSpreadUpdateAssignments(objectLiteral, assignments, signalName) {
+    for (const prop of objectLiteral.getProperties()) {
+      if (Node4.isSpreadAssignment(prop))
+        continue;
+      this.extractPropertyAssignment(prop, assignments, signalName);
+    }
+  }
+  extractArraySpreadOperation(arrayLiteral, fieldPath, signalName) {
+    const elements = arrayLiteral.getElements();
+    if (elements.length < 1)
+      return null;
+    return this.tryExtractAppendOperation(elements, fieldPath, signalName) ?? this.tryExtractPrependOperation(elements, fieldPath, signalName);
+  }
+  tryExtractAppendOperation(elements, fieldPath, signalName) {
+    const firstElement = elements[0];
+    if (!firstElement || !Node4.isSpreadElement(firstElement))
+      return null;
+    const spreadExpr = firstElement.getExpression();
+    if (!spreadExpr || this.getPropertyPath(spreadExpr) !== fieldPath)
+      return null;
+    if (elements.length === 2) {
+      return { field: signalName, value: "Append(@, payload)" };
+    }
+    const placeholders = Array(elements.length - 1).fill("payload").join(", ");
+    return { field: signalName, value: `@ \\o <<${placeholders}>>` };
+  }
+  tryExtractPrependOperation(elements, fieldPath, signalName) {
+    if (elements.length < 2)
+      return null;
+    const lastElement = elements[elements.length - 1];
+    if (!lastElement || !Node4.isSpreadElement(lastElement))
+      return null;
+    const spreadExpr = lastElement.getExpression();
+    if (!spreadExpr || this.getPropertyPath(spreadExpr) !== fieldPath)
+      return null;
+    if (elements.length === 2) {
+      return { field: signalName, value: "<<payload>> \\o @" };
+    }
+    const placeholders = Array(elements.length - 1).fill("payload").join(", ");
+    return { field: signalName, value: `<<${placeholders}>> \\o @` };
+  }
+  extractObjectLiteralAssignments(objectLiteral, assignments, signalName) {
+    if (!Node4.isObjectLiteralExpression(objectLiteral))
+      return;
+    for (const prop of objectLiteral.getProperties()) {
+      this.extractPropertyAssignment(prop, assignments, signalName);
+    }
+  }
+  extractPropertyAssignment(prop, assignments, signalName) {
+    if (Node4.isPropertyAssignment(prop)) {
+      const name = prop.getName();
+      const initializer = prop.getInitializer();
+      if (!name || !initializer)
+        return;
+      const value = this.extractValue(initializer);
+      if (value === undefined)
+        return;
+      const field = signalName ? `${signalName}_${name}` : name;
+      assignments.push({ field, value });
+      return;
+    }
+    if (Node4.isShorthandPropertyAssignment(prop)) {
+      const name = prop.getName();
+      const field = signalName ? `${signalName}_${name}` : name;
+      assignments.push({ field, value: "@" });
+    }
   }
   extractElementAccessAssignment(left, right, assignments) {
     if (!Node4.isElementAccessExpression(left))
@@ -2946,15 +3286,15 @@ class HandlerExtractor {
         if (path2 === `${varName}.value`) {
           const right = node.getRight();
           if (Node4.isObjectLiteralExpression(right)) {
-            this.extractObjectLiteralAssignments(right, mutations);
+            this.extractObjectLiteralAssignments(right, mutations, varName);
           }
           break;
         }
         const fieldPrefix = `${varName}.value.`;
         if (path2.startsWith(fieldPrefix)) {
-          const field = path2.substring(fieldPrefix.length);
+          const fieldName = path2.substring(fieldPrefix.length);
           const value = this.extractValue(node.getRight());
-          mutations.push({ field, value: value ?? "@" });
+          mutations.push({ field: `${varName}_${fieldName}`, value: value ?? "@" });
           break;
         }
       }
@@ -5285,4 +5625,4 @@ main().catch((_error) => {
   process.exit(1);
 });
 
-//# debugId=AD2A9496CB1D22A064756E2164756E21
+//# debugId=3513B8B8E90D943B64756E2164756E21