@fairfox/polly 0.67.0 → 0.70.0

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

@@ -798,6 +798,8 @@ var init_tla = __esm(() => {
     tabSymmetryEnabled = false;
     tabCount = 0;
     moduleName = "UserApp";
+    currentConfig;
+    meshSignalDocs = new Map;
     constructor(options) {
       this.options = options;
     }
@@ -811,6 +813,19 @@ var init_tla = __esm(() => {
       if (moduleName) {
         this.moduleName = moduleName;
       }
+      this.currentConfig = config;
+      this.meshSignalDocs.clear();
+      if (this.hasMeshConfig(config)) {
+        const declaredDocs = new Set(Object.keys(config.mesh ?? {}));
+        const sigs = analysis.meshOrPeerSignals;
+        if (sigs) {
+          for (const s of sigs) {
+            if (declaredDocs.has(s.key)) {
+              this.meshSignalDocs.set(s.variableName, s.key);
+            }
+          }
+        }
+      }
       this.validateInputs(config, analysis);
       this.extractInvariantsIfEnabled();
       this.generateTemporalPropertiesIfEnabled(analysis);
@@ -963,7 +978,7 @@ var init_tla = __esm(() => {
       this.addMessageTypes(config, analysis);
       this.addTabSymmetry(config);
       this.addStateType(config, analysis);
-      this.addVariables();
+      this.addVariables(config);
       if (this.temporalProperties.length > 0) {
         this.addDeliveredTracking();
       }
@@ -1181,6 +1196,74 @@ var init_tla = __esm(() => {
       this.indent--;
       this.line("]");
       this.line("");
+      this.addMeshTypes(config);
+    }
+    addMeshTypes(config) {
+      const mesh = config.mesh;
+      if (!mesh || Object.keys(mesh).length === 0)
+        return;
+      const docIds = Object.keys(mesh).sort();
+      this.line("\\* polly#117: declared $meshState documents");
+      this.line(`MeshDocs == {${docIds.map((d) => `"${d}"`).join(", ")}}`);
+      this.line("");
+      for (const docId of docIds) {
+        const fields = mesh[docId];
+        if (!fields)
+          continue;
+        const fieldLines = [];
+        for (const [fieldName, fieldConfig] of Object.entries(fields)) {
+          const tlaType = this.fieldConfigToTLAType(`${docId}_${fieldName}`, fieldConfig, config);
+          fieldLines.push(`${this.sanitizeFieldName(fieldName)}: ${tlaType}`);
+        }
+        this.line(`\\* Document type for ${docId}`);
+        this.line(`MeshDoc_${this.sanitizeFieldName(docId)} == [${fieldLines.join(", ")}]`);
+        this.line("");
+      }
+      this.line("\\* Initial mesh-document values (one record per declared docId)");
+      this.line("InitialMesh == [");
+      this.indent++;
+      const initLines = [];
+      for (const docId of docIds) {
+        const fields = mesh[docId];
+        if (!fields)
+          continue;
+        const inner = [];
+        for (const [fieldName, fieldConfig] of Object.entries(fields)) {
+          const initVal = this.fieldConfigInitialValue(`${docId}_${fieldName}`, fieldConfig, config);
+          inner.push(`${this.sanitizeFieldName(fieldName)} |-> ${initVal}`);
+        }
+        initLines.push(`"${docId}" |-> [${inner.join(", ")}]`);
+      }
+      initLines.forEach((line, i) => {
+        this.line(line + (i < initLines.length - 1 ? "," : ""));
+      });
+      this.indent--;
+      this.line("]");
+      this.line("");
+    }
+    fieldConfigInitialValue(_path, fieldConfig, _config) {
+      const fc = fieldConfig;
+      if (fc["type"] === "boolean")
+        return "FALSE";
+      if (fc["type"] === "number") {
+        const min = typeof fc["min"] === "number" ? fc["min"] : 0;
+        return String(min);
+      }
+      if (fc["type"] === "enum" && Array.isArray(fc["values"]) && fc["values"].length > 0) {
+        return `"${String(fc["values"][0])}"`;
+      }
+      if (fc["type"] === "string") {
+        return typeof fc["initial"] === "string" ? `"${fc["initial"]}"` : '""';
+      }
+      if (fc["type"] === "array") {
+        return "<<>>";
+      }
+      if (Array.isArray(fc.values)) {
+        const values = fc.values;
+        if (values.length > 0)
+          return `"${values[0]}"`;
+      }
+      return '"v1"';
     }
     defineValueTypes() {
       this.line("\\* Generic value type for sequences and maps");
@@ -1402,18 +1485,40 @@ var init_tla = __esm(() => {
         console.log(`[INFO] [TLAGenerator] Tab symmetry enabled: ${this.tabCount} tabs as model values`);
       }
     }
-    addVariables() {
+    addVariables(config) {
+      const hasMesh = this.hasMeshConfig(config);
       this.line("\\* Application state per context");
       this.line("VARIABLE contextStates");
       this.line("");
+      if (hasMesh) {
+        this.line("\\* polly#117: per-context mesh document replicas. Each context");
+        this.line("\\* carries an independent record per declared $meshState document.");
+        this.line("\\* The PropagateMeshOp action diffuses values between contexts to");
+        this.line("\\* model Automerge sync, and predicate references to mesh-tagged");
+        this.line("\\* signals route through this variable instead of contextStates.");
+        this.line("VARIABLE meshState");
+        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, payload>>");
+      const allVarsList = hasMesh ? "ports, messages, pendingRequests, delivered, routingDepth, time, contextStates, meshState, payload" : "ports, messages, pendingRequests, delivered, routingDepth, time, contextStates, payload";
+      this.line(`allVars == <<${allVarsList}>>`);
       this.line("");
     }
+    hasMeshConfig(config) {
+      const c = config ?? this.currentConfig;
+      return !!c?.mesh && Object.keys(c.mesh).length > 0;
+    }
+    userStateVars(config) {
+      return this.hasMeshConfig(config) ? ["contextStates", "meshState"] : ["contextStates"];
+    }
+    unchangedUserStates(config, andOthers = []) {
+      const all = [...andOthers, ...this.userStateVars(config)];
+      return all.length === 1 ? `UNCHANGED ${all[0]}` : `UNCHANGED <<${all.join(", ")}>>`;
+    }
     addInit(config, _analysis) {
       this.deriveParamDomains(config, _analysis);
       this.line("\\* Initial application state");
@@ -1434,6 +1539,9 @@ var init_tla = __esm(() => {
       this.indent++;
       this.line("/\\ Init  \\* MessageRouter's init");
       this.line("/\\ contextStates = [c \\in Contexts |-> InitialState]");
+      if (this.hasMeshConfig(config)) {
+        this.line("/\\ meshState = [c \\in Contexts |-> InitialMesh]");
+      }
       this.line("/\\ payload \\in PayloadType  \\* Non-deterministic initial payload");
       this.indent--;
       this.line("");
@@ -1629,7 +1737,7 @@ var init_tla = __esm(() => {
       this.line("\\* State remains unchanged for all messages");
       this.line("StateTransition(ctx, msgType) ==");
       this.indent++;
-      this.line("UNCHANGED contextStates");
+      this.line(this.unchangedUserStates());
       this.indent--;
       this.line("");
     }
@@ -1638,7 +1746,7 @@ var init_tla = __esm(() => {
       this.line("\\* State remains unchanged for all messages");
       this.line("StateTransition(ctx, msgType) ==");
       this.indent++;
-      this.line("UNCHANGED contextStates");
+      this.line(this.unchangedUserStates());
       this.indent--;
       this.line("");
     }
@@ -1741,7 +1849,7 @@ var init_tla = __esm(() => {
     recordPostconditionProperty(messageType, actionName, postconditions) {
       if (postconditions.length === 0)
         return;
-      const predicateClauses = postconditions.map((pc) => this.tsExpressionToTLA(pc.expression, true)).filter((p) => p && p.length > 0).map((p) => p.replace(/\[ctx\]/g, "[target]"));
+      const predicateClauses = postconditions.map((pc) => this.tsExpressionToTLA(pc.expression, true)).filter((p) => p && p.length > 0).map((p) => p.replace(/\[ctx\]/g, "[target]").replace(/\{ctx\}/g, "{target}"));
       if (predicateClauses.length === 0)
         return;
       const conjunction = predicateClauses.length === 1 ? predicateClauses[0] : predicateClauses.map((c) => `             /\\ ${c}`).join(`
@@ -1782,7 +1890,23 @@ var init_tla = __esm(() => {
         onBuild: "warn",
         onRelease: "warn"
       };
-      return this.flattenStateConfig(fakeConfig).has(sanitized);
+      if (this.flattenStateConfig(fakeConfig).has(sanitized))
+        return true;
+      return this.isMeshAssignmentModeled(field);
+    }
+    isMeshAssignmentModeled(field) {
+      const meshHit = this.classifyAssignmentAsMesh(field);
+      if (!meshHit)
+        return false;
+      const mesh = this.currentConfig?.mesh;
+      if (!mesh)
+        return false;
+      const docConfig = mesh[meshHit.docId];
+      if (!docConfig)
+        return false;
+      if (meshHit.innerField === "")
+        return true;
+      return Object.hasOwn(docConfig, meshHit.innerField);
     }
     shouldIncludeAssignment(assignment, state) {
       if (assignment.value !== null)
@@ -1817,7 +1941,7 @@ var init_tla = __esm(() => {
         if (preconditions.length === 0) {
           this.line("\\* No state changes in handler");
         }
-        this.line("/\\ UNCHANGED contextStates");
+        this.line(`/\\ ${this.unchangedUserStates()}`);
         return true;
       }
       const ndetAssignments = [];
@@ -1830,15 +1954,67 @@ var init_tla = __esm(() => {
         }
       }
       if (ndetAssignments.length === 0) {
-        const exceptClauses = detAssignments.map((a) => {
+        const partition = this.partitionAssignments(detAssignments);
+        this.emitDeterministicAssignmentPartitions(partition);
+        return false;
+      }
+      this.emitNDETStateUpdates(ndetAssignments, detAssignments);
+      return false;
+    }
+    partitionAssignments(assignments) {
+      const local = [];
+      const mesh = new Map;
+      for (const a of assignments) {
+        const meshHit = this.classifyAssignmentAsMesh(a.field);
+        if (meshHit) {
+          const list = mesh.get(meshHit.docId) ?? [];
+          list.push({ inner: meshHit.innerField, value: a.value });
+          mesh.set(meshHit.docId, list);
+        } else {
+          local.push(a);
+        }
+      }
+      return { local, mesh };
+    }
+    classifyAssignmentAsMesh(field) {
+      for (const [signalName, docId] of this.meshSignalDocs.entries()) {
+        if (field === signalName) {
+          return { docId, innerField: "" };
+        }
+        const prefix = `${signalName}_`;
+        if (field.startsWith(prefix)) {
+          return { docId, innerField: field.substring(prefix.length) };
+        }
+      }
+      return null;
+    }
+    emitDeterministicAssignmentPartitions(partition) {
+      const { local, mesh } = partition;
+      if (local.length > 0) {
+        const exceptClauses = local.map((a) => {
           const tlaValue = this.assignmentValueToTLA(a.value);
           return `![ctx].${this.sanitizeFieldName(a.field)} = ${tlaValue}`;
         });
         this.line(`/\\ contextStates' = [contextStates EXCEPT ${exceptClauses.join(", ")}]`);
-        return false;
+      } else if (mesh.size > 0) {
+        this.line("/\\ UNCHANGED contextStates");
+      }
+      if (mesh.size > 0) {
+        const clauses = [];
+        for (const [docId, writes] of mesh.entries()) {
+          for (const w of writes) {
+            const tlaValue = this.assignmentValueToTLA(w.value);
+            if (w.inner === "") {
+              clauses.push(`![ctx]["${docId}"] = ${tlaValue}`);
+            } else {
+              clauses.push(`![ctx]["${docId}"].${this.sanitizeFieldName(w.inner)} = ${tlaValue}`);
+            }
+          }
+        }
+        this.line(`/\\ meshState' = [meshState EXCEPT ${clauses.join(", ")}]`);
+      } else if (this.hasMeshConfig() && local.length > 0) {
+        this.line("/\\ UNCHANGED meshState");
       }
-      this.emitNDETStateUpdates(ndetAssignments, detAssignments);
-      return false;
     }
     emitNDETStateUpdates(ndetAssignments, detAssignments) {
       const detExceptClauses = detAssignments.map((a) => {
@@ -1869,10 +2045,56 @@ var init_tla = __esm(() => {
         this.indent--;
       }
     }
+    tryExtractPeerScopedPredicate(expr) {
+      if (typeof expr !== "string")
+        return null;
+      const trimmed = expr.trim();
+      const match = trimmed.match(/^(forAllPeers|somePeer)\s*\(\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*=>\s*([\s\S]+)\)\s*$/);
+      if (!match)
+        return null;
+      const fn = match[1];
+      const binder = match[2];
+      const innerBody = match[3];
+      if (!fn || !binder || innerBody === undefined)
+        return null;
+      return {
+        binder,
+        innerBody: innerBody.trim(),
+        kind: fn === "forAllPeers" ? "forall" : "exists"
+      };
+    }
     tsExpressionToTLA(expr, isPrimed = false) {
       if (!expr || typeof expr !== "string") {
         return expr || "";
       }
+      const scoped = this.tryExtractPeerScopedPredicate(expr);
+      if (scoped) {
+        const binder = scoped.binder;
+        const peerPrefix = isPrimed ? `contextStates'[${binder}]` : `contextStates[${binder}]`;
+        let body = scoped.innerBody;
+        const binderRe1 = new RegExp(`\\b${binder}\\.([a-zA-Z_][a-zA-Z0-9_]*)\\.value\\.([a-zA-Z_][a-zA-Z0-9_.]*)`, "g");
+        body = body.replace(binderRe1, (_m, sig, path3) => {
+          const meshDoc = this.meshSignalDocs.get(sig);
+          if (meshDoc !== undefined) {
+            const meshPeerPrefix = isPrimed ? `meshState'[${binder}]["${meshDoc}"]` : `meshState[${binder}]["${meshDoc}"]`;
+            const field = this.sanitizeFieldName(String(path3).replace(/\./g, "_"));
+            return `${meshPeerPrefix}.${field}`;
+          }
+          const flat = this.sanitizeFieldName(`${sig}_${String(path3).replace(/\./g, "_")}`);
+          return `${peerPrefix}.${flat}`;
+        });
+        const binderRe2 = new RegExp(`\\b${binder}\\.([a-zA-Z_][a-zA-Z0-9_]*)\\.value\\b(?!\\.)`, "g");
+        body = body.replace(binderRe2, (_m, sig) => {
+          const meshDoc = this.meshSignalDocs.get(sig);
+          if (meshDoc !== undefined) {
+            return isPrimed ? `meshState'[${binder}]["${meshDoc}"]` : `meshState[${binder}]["${meshDoc}"]`;
+          }
+          return `${peerPrefix}.${sig}`;
+        });
+        const innerTLA = this.tsExpressionToTLA(body, isPrimed);
+        const quantifier = scoped.kind === "forall" ? "\\A" : "\\E";
+        return `${quantifier} ${binder} \\in Contexts \\ {ctx} : (${innerTLA})`;
+      }
       let tla = expr;
       const statePrefix = isPrimed ? "contextStates'[ctx]" : "contextStates[ctx]";
       tla = this.translateComplexExpressions(tla, statePrefix);
@@ -1889,10 +2111,20 @@ var init_tla = __esm(() => {
       }
       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) => {
+        const meshDoc = this.meshSignalDocs.get(stateName);
+        if (meshDoc !== undefined) {
+          const meshPrefix = isPrimed ? `meshState'[ctx]["${meshDoc}"]` : `meshState[ctx]["${meshDoc}"]`;
+          const field = this.sanitizeFieldName(String(path3).replace(/\./g, "_"));
+          return `${meshPrefix}.${field}`;
+        }
         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) => {
+        const meshDoc = this.meshSignalDocs.get(stateName);
+        if (meshDoc !== undefined) {
+          return isPrimed ? `meshState'[ctx]["${meshDoc}"]` : `meshState[ctx]["${meshDoc}"]`;
+        }
         return `${statePrefix}.${stateName}`;
       });
       tla = tla.replace(/state\.([a-zA-Z_][a-zA-Z0-9_.]*)/g, (_match, path3) => {
@@ -2353,28 +2585,48 @@ var init_tla = __esm(() => {
       this.line("                    /\\ pendingRequests' = [id \\in DOMAIN pendingRequests \\ {msg.id} |->");
       this.line("                                           pendingRequests[id]]");
       this.line("                    /\\ time' = time + 1");
-      this.line("                    /\\ UNCHANGED <<delivered, contextStates, payload>>");
+      this.line(`                    /\\ ${this.unchangedUserStates(undefined, ["delivered", "payload"])}`);
       this.line("      /\\ UNCHANGED ports");
       this.indent--;
       this.line("");
     }
+    addPropagateMeshOp() {
+      if (!this.hasMeshConfig())
+        return;
+      this.line("\\* polly#117: propagate a mesh-document value from one context to another.");
+      this.line("\\* Models Automerge sync: src and dst must currently disagree on docId, and");
+      this.line("\\* the action copies src's value into dst's record. All other state is fixed.");
+      this.line("PropagateMeshOp(src, dst, docId) ==");
+      this.indent++;
+      this.line("/\\ src # dst");
+      this.line("/\\ meshState[src][docId] # meshState[dst][docId]");
+      this.line("/\\ meshState' = [meshState EXCEPT ![dst][docId] = meshState[src][docId]]");
+      this.line("/\\ UNCHANGED <<ports, messages, pendingRequests, delivered, routingDepth, time, contextStates, payload>>");
+      this.indent--;
+      this.line("");
+    }
     addNext(_config, analysis) {
+      this.addPropagateMeshOp();
       this.line("\\* Next state relation (extends MessageRouter)");
       this.line("UserNext ==");
       this.indent++;
       const hasValidHandlers = analysis.handlers.some((h) => this.isValidTLAIdentifier(h.messageType));
       if (hasValidHandlers) {
-        this.line("\\/ \\E c \\in Contexts : ConnectPort(c) /\\ UNCHANGED <<contextStates, payload>>");
-        this.line("\\/ \\E c \\in Contexts : DisconnectPort(c) /\\ UNCHANGED <<contextStates, payload>>");
+        const userPayload = this.unchangedUserStates(undefined, ["payload"]);
+        this.line(`\\/ \\E c \\in Contexts : ConnectPort(c) /\\ ${userPayload}`);
+        this.line(`\\/ \\E c \\in Contexts : DisconnectPort(c) /\\ ${userPayload}`);
         this.line("\\/ \\E src \\in Contexts : \\E targetSet \\in (SUBSET Contexts \\ {{}}) : \\E tab \\in Tabs : \\E msgType \\in UserMessageTypes :");
         this.indent++;
-        this.line("SendMessage(src, targetSet, tab, msgType) /\\ UNCHANGED <<contextStates, payload>>");
+        this.line(`SendMessage(src, targetSet, tab, msgType) /\\ ${userPayload}`);
         this.indent--;
         this.line("\\/ \\E i \\in 1..Len(messages) : UserRouteMessage(i)");
-        this.line("\\/ CompleteRouting /\\ UNCHANGED <<contextStates, payload>>");
-        this.line("\\/ \\E i \\in 1..Len(messages) : TimeoutMessage(i) /\\ UNCHANGED <<contextStates, payload>>");
+        this.line(`\\/ CompleteRouting /\\ ${userPayload}`);
+        this.line(`\\/ \\E i \\in 1..Len(messages) : TimeoutMessage(i) /\\ ${userPayload}`);
+        if (this.hasMeshConfig()) {
+          this.line("\\/ \\E src, dst \\in Contexts : \\E docId \\in MeshDocs : PropagateMeshOp(src, dst, docId)");
+        }
       } else {
-        this.line("\\/ Next /\\ UNCHANGED <<contextStates, payload>>");
+        this.line(`\\/ Next /\\ ${this.unchangedUserStates(undefined, ["payload"])}`);
       }
       this.indent--;
       this.line("");
@@ -2957,7 +3209,7 @@ class DockerRunner {
     });
   }
 }
-var __dirname = "/Users/AJT/projects/polly/tools/verify/src/runner";
+var __dirname = "/Users/AJT/projects/polly/packages/polly/tools/verify/src/runner";
 var init_docker = () => {};
 
 // tools/verify/src/cli.ts
@@ -4629,6 +4881,7 @@ class HandlerExtractor {
     const stateConstraints = [];
     const globalStateConstraints = [];
     const verifiedStates = [];
+    const meshOrPeerSignals = [];
     const resources = [];
     this.warnings = [];
     const allSourceFiles = this.project.getSourceFiles();
@@ -4659,6 +4912,12 @@ class HandlerExtractor {
         }
       }
     }
+    for (const filePath of this.analyzedFiles) {
+      const sourceFile = this.project.getSourceFile(filePath);
+      if (!sourceFile)
+        continue;
+      meshOrPeerSignals.push(...this.extractMeshOrPeerSignalsFromFile(sourceFile));
+    }
     this.debugLogExtractionResults(handlers.length, invalidMessageTypes.size);
     this.debugLogAnalysisStats(allSourceFiles.length, entryPoints.length);
     return {
@@ -4667,10 +4926,45 @@ class HandlerExtractor {
       stateConstraints,
       globalStateConstraints,
       verifiedStates,
+      meshOrPeerSignals,
       resources,
       warnings: this.warnings
     };
   }
+  extractMeshOrPeerSignalsFromFile(sourceFile) {
+    const out = [];
+    const filePath = sourceFile.getFilePath();
+    sourceFile.forEachDescendant((node) => {
+      const info = this.recognizeMeshOrPeerStateCall(node, filePath);
+      if (info)
+        out.push(info);
+    });
+    return out;
+  }
+  recognizeMeshOrPeerStateCall(node, filePath) {
+    if (!Node2.isCallExpression(node))
+      return null;
+    const expression = node.getExpression();
+    if (!Node2.isIdentifier(expression))
+      return null;
+    const funcName = expression.getText();
+    const kind = funcName === "$meshState" ? "mesh" : funcName === "$peerState" ? "peer" : null;
+    if (!kind)
+      return null;
+    const args = node.getArguments();
+    const keyArg = args[0];
+    if (!keyArg || !Node2.isStringLiteral(keyArg))
+      return null;
+    const key = keyArg.getLiteralValue();
+    const variableName = this.getVariableNameFromParent(node) || key;
+    return {
+      kind,
+      key,
+      variableName,
+      filePath,
+      line: node.getStartLineNumber()
+    };
+  }
   analyzeFileAndImports(sourceFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates, resources) {
     const filePath = sourceFile.getFilePath();
     if (this.analyzedFiles.has(filePath)) {
@@ -6790,6 +7084,7 @@ class TypeExtractor {
       stateConstraints: handlerAnalysis.stateConstraints,
       globalStateConstraints: handlerAnalysis.globalStateConstraints,
       verifiedStates: handlerAnalysis.verifiedStates,
+      meshOrPeerSignals: handlerAnalysis.meshOrPeerSignals,
       resources: handlerAnalysis.resources
     };
   }
@@ -7197,7 +7492,7 @@ async function analyzeCodebase(options) {
   return extractor.analyzeCodebase(options.stateFilePath);
 }
 // tools/verify/src/cli.ts
-var __dirname = "/Users/AJT/projects/polly/tools/verify/src";
+var __dirname = "/Users/AJT/projects/polly/packages/polly/tools/verify/src";
 var COLORS = {
   reset: "\x1B[0m",
   red: "\x1B[31m",
@@ -7449,6 +7744,49 @@ function displayExpressionWarnings(result) {
     console.log();
   }
 }
+function displayMeshOrPeerSignalWarnings(analysis) {
+  const signals = analysis.meshOrPeerSignals ?? [];
+  if (signals.length === 0)
+    return;
+  const findings = [];
+  for (const handler of analysis.handlers) {
+    const scanConditions = (conditions, kind) => {
+      for (const cond of conditions) {
+        for (const sig of signals) {
+          const pattern = new RegExp(`\\b${sig.variableName}\\.value\\b`);
+          if (pattern.test(cond.expression)) {
+            findings.push({
+              handler: handler.messageType,
+              kind,
+              expression: cond.expression,
+              signalName: sig.variableName,
+              signalKind: sig.kind,
+              location: {
+                file: handler.location.file,
+                line: cond.location?.line ?? handler.location.line
+              }
+            });
+          }
+        }
+      }
+    };
+    scanConditions(handler.preconditions, "precondition");
+    scanConditions(handler.postconditions, "postcondition");
+  }
+  if (findings.length === 0)
+    return;
+  console.log(color(`
+⚠️  ${findings.length} predicate(s) reference a $meshState/$peerState signal (polly#117):`, COLORS.yellow));
+  console.log(color("   The verifier currently treats these the same as $sharedState — single-context local state.", COLORS.gray));
+  console.log(color(`   Cross-peer semantics are NOT verified. A green run does not prove the claim across peers.
+`, COLORS.gray));
+  for (const f of findings) {
+    console.log(color(`   ⚠  ${f.handler} ${f.kind}: ${f.signalName} is $${f.signalKind}State, not single-context`, COLORS.yellow));
+    console.log(color(`      ${f.expression}`, COLORS.gray));
+    console.log(color(`      at ${f.location.file}:${f.location.line}`, COLORS.gray));
+    console.log();
+  }
+}
 async function verifyCommand() {
   const configPath = path4.join(process.cwd(), "specs", "verification.config.ts");
   console.log(color(`
@@ -7517,6 +7855,7 @@ async function runFullVerification(configPath) {
   if (exprValidation.warnings.length > 0) {
     displayExpressionWarnings(exprValidation);
   }
+  displayMeshOrPeerSignalWarnings(typedAnalysis);
   if (typedConfig.subsystems && Object.keys(typedConfig.subsystems).length > 0) {
     await runSubsystemVerification(typedConfig, typedAnalysis);
     return;
@@ -7917,4 +8256,4 @@ main().catch((error) => {
   process.exit(1);
 });
 
-//# debugId=E1FA1E90DBF1B2F664756E2164756E21
+//# debugId=E07763C4D9F04C6264756E2164756E21