@fairfox/polly 0.15.1 → 0.15.4

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

@@ -569,6 +569,7 @@ class TLAGenerator {
   addBasicConstants(lines, config) {
     lines.push("  Contexts = {background, content, popup}");
     lines.push(`  MaxMessages = ${config.messages.maxInFlight || 3}`);
+    lines.push("  NULL = NULL");
     if (config.messages.perMessageBounds) {
       for (const [msgType, bound] of Object.entries(config.messages.perMessageBounds)) {
         const constName = `MaxMessages_${msgType}`;
@@ -682,21 +683,17 @@ class TLAGenerator {
   addConstants(config) {
     const hasStateConstants = this.hasCustomConstants(config.state);
     const hasPerMessageBounds = config.messages.perMessageBounds && Object.keys(config.messages.perMessageBounds).length > 0;
-    if (!hasStateConstants && !hasPerMessageBounds) {
-      return;
-    }
     this.line("\\* Application-specific constants");
     this.line("CONSTANTS");
     this.indent++;
+    this.line("NULL");
     if (hasStateConstants) {
-      this.generateConstantDeclarations(config.state);
+      this.generateConstantDeclarations(config.state, false);
     }
     if (hasPerMessageBounds) {
-      let first = !hasStateConstants;
       for (const [msgType, _bound] of Object.entries(config.messages.perMessageBounds)) {
         const constName = `MaxMessages_${msgType}`;
-        this.line(`${first ? "" : ","}${constName}`);
-        first = false;
+        this.line(`,${constName}`);
       }
     }
     this.indent--;
@@ -709,8 +706,8 @@ class TLAGenerator {
       return "maxLength" in fieldConfig && fieldConfig.maxLength !== null || "max" in fieldConfig && fieldConfig.max !== null || "maxSize" in fieldConfig && fieldConfig.maxSize !== null;
     });
   }
-  generateConstantDeclarations(state) {
-    let first = true;
+  generateConstantDeclarations(state, firstConstant = true) {
+    let first = firstConstant;
     for (const [field, fieldConfig] of Object.entries(state)) {
       if (typeof fieldConfig !== "object" || fieldConfig === null)
         continue;
@@ -747,12 +744,12 @@ class TLAGenerator {
   }
   defineValueTypes() {
     this.line("\\* Generic value type for sequences and maps");
-    this.line("\\* Bounded to allow model checking");
-    this.line('Value == {"v1", "v2", "v3"}');
+    this.line("\\* Bounded to 2 values to reduce state space (2^n vs 3^n)");
+    this.line('Value == {"v1", "v2"}');
     this.line("");
     this.line("\\* Generic key type for maps");
     this.line("\\* Bounded to allow model checking");
-    this.line('Keys == {"k1", "k2", "k3"}');
+    this.line('Keys == {"k1", "k2"}');
     this.line("");
   }
   collectStateFields(config, _analysis) {
@@ -791,7 +788,7 @@ class TLAGenerator {
     }
   }
   hasTypeIndicators(fieldConfig) {
-    return "type" in fieldConfig || "values" in fieldConfig || "maxLength" in fieldConfig || "min" in fieldConfig || "max" in fieldConfig || "maxSize" in fieldConfig;
+    return "type" in fieldConfig || "values" in fieldConfig || "maxLength" in fieldConfig || "min" in fieldConfig || "max" in fieldConfig || "maxSize" in fieldConfig || "abstract" in fieldConfig;
   }
   writeStateFields(fields) {
     if (fields.length === 0) {
@@ -936,8 +933,12 @@ class TLAGenerator {
     this.line("\\* Application state per context");
     this.line("VARIABLE contextStates");
     this.line("");
+    this.line("\\* Message payload (abstract model - non-deterministically chosen)");
+    this.line("\\* In verification, we model payload fields as potentially any valid value");
+    this.line("VARIABLE payload");
+    this.line("");
     this.line("\\* All variables (extending MessageRouter vars)");
-    this.line("allVars == <<ports, messages, pendingRequests, delivered, routingDepth, time, contextStates>>");
+    this.line("allVars == <<ports, messages, pendingRequests, delivered, routingDepth, time, contextStates, payload>>");
     this.line("");
   }
   addInit(config, _analysis) {
@@ -949,11 +950,16 @@ class TLAGenerator {
     this.indent--;
     this.line("]");
     this.line("");
+    this.line("\\* Payload modeled with essential fields only (id, text, userId)");
+    this.line("\\* Other fields (name, role, filter) use same Value type at runtime");
+    this.line("PayloadType == [id: Value, text: Value, userId: Value]");
+    this.line("");
     this.line("\\* Initial state (extends MessageRouter)");
     this.line("UserInit ==");
     this.indent++;
     this.line("/\\ Init  \\* MessageRouter's init");
     this.line("/\\ contextStates = [c \\in Contexts |-> InitialState]");
+    this.line("/\\ payload \\in PayloadType  \\* Non-deterministic initial payload");
     this.indent--;
     this.line("");
   }
@@ -1131,8 +1137,10 @@ class TLAGenerator {
     }
     this.emitPreconditions(allPreconditions);
     const validAssignments = this.processAssignments(allAssignments, config.state);
-    this.emitStateUpdates(validAssignments, allPreconditions);
-    this.emitPostconditions(allPostconditions);
+    const usedUnchanged = this.emitStateUpdates(validAssignments, allPreconditions);
+    if (!usedUnchanged) {
+      this.emitPostconditions(allPostconditions);
+    }
     this.indent--;
     this.line("");
   }
@@ -1170,19 +1178,19 @@ class TLAGenerator {
     return assignment;
   }
   emitStateUpdates(validAssignments, preconditions) {
-    if (validAssignments.length === 0) {
-      if (preconditions.length === 0) {
-        this.line("\\* No state changes in handler");
-      }
-      this.line("/\\ UNCHANGED contextStates");
-      return;
+    if (validAssignments.length > 0) {
+      const exceptClauses = validAssignments.map((a) => {
+        const tlaValue = this.assignmentValueToTLA(a.value);
+        return `![ctx].${this.sanitizeFieldName(a.field)} = ${tlaValue}`;
+      });
+      this.line(`/\\ contextStates' = [contextStates EXCEPT ${exceptClauses.join(", ")}]`);
+      return false;
+    }
+    if (preconditions.length === 0) {
+      this.line("\\* No state changes in handler");
     }
-    const assignments = validAssignments.filter((a) => a && a.value !== undefined).map((assignment) => {
-      const fieldName = this.sanitizeFieldName(assignment.field);
-      const value = this.assignmentValueToTLA(assignment.value);
-      return `![ctx].${fieldName} = ${value}`;
-    }).join(", ");
-    this.line(`/\\ contextStates' = [contextStates EXCEPT ${assignments}]`);
+    this.line("/\\ UNCHANGED contextStates");
+    return true;
   }
   tsExpressionToTLA(expr, isPrimed = false) {
     if (!expr || typeof expr !== "string") {
@@ -1203,8 +1211,12 @@ class TLAGenerator {
       return expr;
     }
     tla = tla.replace(/'([^']+)'/g, '"$1"');
-    tla = tla.replace(/([a-zA-Z_][a-zA-Z0-9_]*)\.value\.([a-zA-Z_][a-zA-Z0-9_.]*)/g, (_match, _stateName, path3) => {
-      return `${statePrefix}.${this.sanitizeFieldName(path3)}`;
+    tla = tla.replace(/([a-zA-Z_][a-zA-Z0-9_]*)\.value\.([a-zA-Z_][a-zA-Z0-9_.]*)/g, (_match, stateName, path3) => {
+      const fullPath = `${stateName}_${path3.replace(/\./g, "_")}`;
+      return `${statePrefix}.${this.sanitizeFieldName(fullPath)}`;
+    });
+    tla = tla.replace(/([a-zA-Z_][a-zA-Z0-9_]*)\.value\b(?!\.)/g, (_match, stateName) => {
+      return `${statePrefix}.${stateName}`;
     });
     tla = tla.replace(/state\.([a-zA-Z_][a-zA-Z0-9_.]*)/g, (_match, path3) => {
       return `${statePrefix}.${this.sanitizeFieldName(path3)}`;
@@ -1227,13 +1239,99 @@ class TLAGenerator {
     tla = tla.replace(/>/g, ">");
     tla = tla.replace(/<=/g, "<=");
     tla = tla.replace(/>=/g, ">=");
+    tla = this.convertFunctionParamsToPayload(tla);
     return tla;
   }
+  convertFunctionParamsToPayload(tla) {
+    const tlaKeywords = new Set([
+      "TRUE",
+      "FALSE",
+      "NULL",
+      "IF",
+      "THEN",
+      "ELSE",
+      "LET",
+      "IN",
+      "CASE",
+      "OTHER",
+      "CHOOSE",
+      "EXCEPT",
+      "DOMAIN",
+      "SUBSET",
+      "UNION",
+      "UNCHANGED",
+      "Len",
+      "Cardinality",
+      "SubSeq",
+      "Append",
+      "Head",
+      "Tail",
+      "Seq",
+      "ctx",
+      "payload",
+      "msg",
+      "state",
+      "contextStates"
+    ]);
+    const quantifiedVars = new Set;
+    const quantifierPattern = /\\[EA]\s+(\w+)\s+\\in|CHOOSE\s+(\w+)\s+\\in/g;
+    for (const qMatch of tla.matchAll(quantifierPattern)) {
+      if (qMatch[1])
+        quantifiedVars.add(qMatch[1]);
+      if (qMatch[2])
+        quantifiedVars.add(qMatch[2]);
+    }
+    const stringRanges = [];
+    const stringPattern = /"[^"]*"/g;
+    for (const sMatch of tla.matchAll(stringPattern)) {
+      stringRanges.push({ start: sMatch.index, end: sMatch.index + sMatch[0].length });
+    }
+    const isInsideString = (offset) => {
+      return stringRanges.some((range) => offset >= range.start && offset < range.end);
+    };
+    const result = tla.replace(/([=#<>]\s*)([a-z][a-zA-Z0-9_]*)(\s*[/#\\)<>,]|\s*$)/g, (match, prefix, ident, suffix, offset) => {
+      if (isInsideString(offset + prefix.length))
+        return match;
+      if (tlaKeywords.has(ident))
+        return match;
+      if (quantifiedVars.has(ident))
+        return match;
+      if (ident === ident.toUpperCase() && ident.length > 1)
+        return match;
+      if (["in", "of", "or", "and", "not"].includes(ident.toLowerCase()))
+        return match;
+      return `${prefix}payload.${ident}${suffix}`;
+    });
+    return result;
+  }
   translateArrayOperations(expr, _statePrefix) {
     if (!expr || typeof expr !== "string") {
       return expr || "";
     }
     let result = expr;
+    result = result.replace(/hasLength\(([^,]+),\s*\{\s*(?:min:\s*(\d+))?\s*,?\s*(?:max:\s*(\d+))?\s*\}\)/g, (_match, arrayRef, minVal, maxVal) => {
+      const constraints = [];
+      const arr = arrayRef.trim();
+      if (minVal !== undefined) {
+        constraints.push(`Len(${arr}) >= ${minVal}`);
+      }
+      if (maxVal !== undefined) {
+        constraints.push(`Len(${arr}) <= ${maxVal}`);
+      }
+      if (constraints.length === 0) {
+        return "TRUE";
+      }
+      return constraints.join(" /\\ ");
+    });
+    result = result.replace(/inRange\(([^,]+),\s*(\d+),\s*(\d+)\)/g, (_match, valueRef, minVal, maxVal) => {
+      const val = valueRef.trim();
+      return `${val} >= ${minVal} /\\ ${val} <= ${maxVal}`;
+    });
+    result = result.replace(/oneOf\(([^,]+),\s*\[([^\]]+)\]\)/g, (_match, valueRef, valuesStr) => {
+      const val = valueRef.trim();
+      const values = valuesStr.split(",").map((v) => v.trim());
+      return `${val} \\in {${values.join(", ")}}`;
+    });
     result = result.replace(/(\w+(?:\.\w+)*)\.length\b/g, (_match, arrayRef) => {
       if (arrayRef.startsWith("state.")) {
         return `Len(${arrayRef})`;
@@ -1523,13 +1621,14 @@ class TLAGenerator {
     this.line("                    /\\ pendingRequests' = [id \\in DOMAIN pendingRequests \\ {msg.id} |->");
     this.line("                                           pendingRequests[id]]");
     this.line("                    /\\ time' = time + 1");
+    this.line("                    /\\ \\E p \\in PayloadType : payload' = p  \\* Non-deterministic payload");
     this.line("                    /\\ StateTransition(target, msg.msgType)");
     this.line("               ELSE \\* Port not connected - message fails");
     this.line(`                    /\\ messages' = [messages EXCEPT ![msgIndex].status = "failed"]`);
     this.line("                    /\\ pendingRequests' = [id \\in DOMAIN pendingRequests \\ {msg.id} |->");
     this.line("                                           pendingRequests[id]]");
     this.line("                    /\\ time' = time + 1");
-    this.line("                    /\\ UNCHANGED <<delivered, contextStates>>");
+    this.line("                    /\\ UNCHANGED <<delivered, contextStates, payload>>");
     this.line("      /\\ UNCHANGED ports");
     this.indent--;
     this.line("");
@@ -1540,17 +1639,17 @@ class TLAGenerator {
     this.indent++;
     const hasValidHandlers = analysis.handlers.some((h) => this.isValidTLAIdentifier(h.messageType));
     if (hasValidHandlers) {
-      this.line("\\/ \\E c \\in Contexts : ConnectPort(c) /\\ UNCHANGED contextStates");
-      this.line("\\/ \\E c \\in Contexts : DisconnectPort(c) /\\ UNCHANGED contextStates");
+      this.line("\\/ \\E c \\in Contexts : ConnectPort(c) /\\ UNCHANGED <<contextStates, payload>>");
+      this.line("\\/ \\E c \\in Contexts : DisconnectPort(c) /\\ UNCHANGED <<contextStates, payload>>");
       this.line("\\/ \\E src \\in Contexts : \\E targetSet \\in (SUBSET Contexts \\ {{}}) : \\E tab \\in 0..MaxTabId : \\E msgType \\in UserMessageTypes :");
       this.indent++;
-      this.line("SendMessage(src, targetSet, tab, msgType) /\\ UNCHANGED contextStates");
+      this.line("SendMessage(src, targetSet, tab, msgType) /\\ UNCHANGED <<contextStates, payload>>");
       this.indent--;
       this.line("\\/ \\E i \\in 1..Len(messages) : UserRouteMessage(i)");
-      this.line("\\/ CompleteRouting /\\ UNCHANGED contextStates");
-      this.line("\\/ \\E i \\in 1..Len(messages) : TimeoutMessage(i) /\\ UNCHANGED contextStates");
+      this.line("\\/ CompleteRouting /\\ UNCHANGED <<contextStates, payload>>");
+      this.line("\\/ \\E i \\in 1..Len(messages) : TimeoutMessage(i) /\\ UNCHANGED <<contextStates, payload>>");
     } else {
-      this.line("\\/ Next /\\ UNCHANGED contextStates");
+      this.line("\\/ Next /\\ UNCHANGED <<contextStates, payload>>");
     }
     this.indent--;
     this.line("");
@@ -1667,9 +1766,15 @@ class TLAGenerator {
     this.line("=============================================================================");
   }
   fieldConfigToTLAType(_fieldPath, fieldConfig, _config) {
-    const typeResult = this.tryBooleanType(fieldConfig) || this.tryEnumType(fieldConfig) || this.tryArrayType(fieldConfig) || this.tryNumberType(fieldConfig) || this.tryStringType(fieldConfig) || this.tryMapType(fieldConfig);
+    const typeResult = this.tryAbstractType(fieldConfig) || this.tryBooleanType(fieldConfig) || this.tryEnumType(fieldConfig) || this.tryArrayType(fieldConfig) || this.tryNumberType(fieldConfig) || this.tryStringType(fieldConfig) || this.tryMapType(fieldConfig);
     return typeResult || "Value";
   }
+  tryAbstractType(fieldConfig) {
+    if ("abstract" in fieldConfig && fieldConfig.abstract === true) {
+      return "Value";
+    }
+    return null;
+  }
   tryBooleanType(fieldConfig) {
     if ("type" in fieldConfig && fieldConfig.type === "boolean") {
       return "BOOLEAN";
@@ -1824,6 +1929,9 @@ class TLAGenerator {
     }
   }
   getInitialValue(fieldConfig) {
+    if ("abstract" in fieldConfig && fieldConfig.abstract === true) {
+      return '"v1"';
+    }
     if (Array.isArray(fieldConfig)) {
       if (fieldConfig.length > 0 && typeof fieldConfig[0] === "boolean") {
         return fieldConfig[0] ? "TRUE" : "FALSE";
@@ -3392,6 +3500,7 @@ class HandlerExtractor {
   relationshipExtractor;
   analyzedFiles;
   packageRoot;
+  warnings;
   constructor(tsConfigPath) {
     this.project = new Project({
       tsConfigFilePath: tsConfigPath
@@ -3399,8 +3508,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) {
@@ -3424,6 +3552,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);
@@ -3458,7 +3587,8 @@ class HandlerExtractor {
       handlers,
       messageTypes,
       stateConstraints,
-      verifiedStates
+      verifiedStates,
+      warnings: this.warnings
     };
   }
   analyzeFileAndImports(sourceFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, verifiedStates) {
@@ -3688,46 +3818,364 @@ class HandlerExtractor {
     if (!Node2.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") && Node2.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 (!Node2.isObjectLiteralExpression(objectLiteral))
+  tryExtractSignalObjectPattern(fieldPath, right, assignments) {
+    if (!fieldPath.endsWith(".value") || !Node2.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 || !Node2.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") || !Node2.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") || !Node2.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 (!Node2.isPropertyAccessExpression(expression))
       return;
-    for (const prop of objectLiteral.getProperties()) {
-      if (Node2.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") || !Node2.isNewExpression(right))
+      return false;
+    const constructorExpr = right.getExpression();
+    if (!Node2.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") || !Node2.isNewExpression(right))
+      return false;
+    const constructorExpr = right.getExpression();
+    if (!Node2.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 (Node2.isArrayLiteralExpression(firstArg)) {
+      return this.extractSetArrayOperation(firstArg, fieldPath, signalName);
+    }
+    if (Node2.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 && Node2.isSpreadElement(firstElement)) {
+      const spreadExpr = firstElement.getExpression();
+      if (spreadExpr && this.getPropertyPath(spreadExpr) === fieldPath) {
+        return { field: signalName, value: "@ \\union {payload}" };
+      }
+    }
+    if (lastElement && Node2.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 (!Node2.isPropertyAccessExpression(expression))
+      return null;
+    const methodName = expression.getName();
+    const sourceExpr = expression.getExpression();
+    if (methodName === "filter" && Node2.isArrayLiteralExpression(sourceExpr)) {
+      const elements = sourceExpr.getElements();
+      if (elements.length === 1) {
+        const spreadEl = elements[0];
+        if (spreadEl && Node2.isSpreadElement(spreadEl)) {
+          const spreadExpr = spreadEl.getExpression();
+          if (spreadExpr && this.getPropertyPath(spreadExpr) === fieldPath) {
+            return { field: signalName, value: "@ \\ {payload}" };
+          }
         }
       }
-      if (Node2.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 (Node2.isArrayLiteralExpression(firstArg)) {
+      return this.extractMapArrayOperation(firstArg, fieldPath, signalName);
+    }
+    if (Node2.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 && Node2.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 (!Node2.isPropertyAccessExpression(expression))
+      return null;
+    const methodName = expression.getName();
+    const sourceExpr = expression.getExpression();
+    if (methodName === "filter" && Node2.isArrayLiteralExpression(sourceExpr)) {
+      const elements = sourceExpr.getElements();
+      if (elements.length === 1) {
+        const spreadEl = elements[0];
+        if (spreadEl && Node2.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 (!Node2.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 (Node2.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 || !Node2.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 || !Node2.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 (!Node2.isObjectLiteralExpression(objectLiteral))
+      return;
+    for (const prop of objectLiteral.getProperties()) {
+      this.extractPropertyAssignment(prop, assignments, signalName);
+    }
+  }
+  extractPropertyAssignment(prop, assignments, signalName) {
+    if (Node2.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 (Node2.isShorthandPropertyAssignment(prop)) {
+      const name = prop.getName();
+      const field = signalName ? `${signalName}_${name}` : name;
+      assignments.push({ field, value: "@" });
+    }
   }
   extractElementAccessAssignment(left, right, assignments) {
     if (!Node2.isElementAccessExpression(left))
@@ -4740,15 +5188,15 @@ class HandlerExtractor {
         if (path2 === `${varName}.value`) {
           const right = node.getRight();
           if (Node2.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;
         }
       }
@@ -5663,4 +6111,4 @@ main().catch((error) => {
   process.exit(1);
 });
 
-//# debugId=102A9867273619A364756E2164756E21
+//# debugId=143C5A4485F127EB64756E2164756E21