@fairfox/polly 0.18.0 → 0.20.0

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

@@ -429,13 +429,22 @@ async function generateSubsystemTLA(_subsystemName, subsystem, config, analysis)
       temporalConstraints: filteredConfig.tier2.temporalConstraints.filter((tc) => handlerNames.has(tc.before) && handlerNames.has(tc.after))
     };
   }
+  const subsystemFieldPatterns = subsystem.state.map((field) => {
+    const dotIdx = field.indexOf(".");
+    if (dotIdx >= 0) {
+      return `${field.substring(0, dotIdx)}.value.${field.substring(dotIdx + 1)}`;
+    }
+    return `${field}.value`;
+  });
+  const filteredGlobalStateConstraints = (analysis.globalStateConstraints ?? []).filter((constraint) => subsystemFieldPatterns.some((pattern) => constraint.expression.includes(pattern)));
   const filteredAnalysis = {
     ...analysis,
     messageTypes: analysis.messageTypes.filter((mt) => handlerNames.has(mt)),
-    handlers: analysis.handlers.filter((h) => handlerNames.has(h.messageType))
+    handlers: analysis.handlers.filter((h) => handlerNames.has(h.messageType)),
+    globalStateConstraints: filteredGlobalStateConstraints
   };
   const generator = new TLAGenerator;
-  return await generator.generate(filteredConfig, filteredAnalysis);
+  return await generator.generate(filteredConfig, filteredAnalysis, `UserApp_${_subsystemName}`);
 }
 var TLAValidationError, TLAGenerator;
 var init_tla = __esm(() => {
@@ -458,6 +467,7 @@ var init_tla = __esm(() => {
     resolvedActionNames = new Map;
     tabSymmetryEnabled = false;
     tabCount = 0;
+    moduleName = "UserApp";
     constructor(options) {
       this.options = options;
     }
@@ -467,7 +477,10 @@ var init_tla = __esm(() => {
       }
       return /^[a-zA-Z][a-zA-Z0-9_]*$/.test(s);
     }
-    async generate(config, analysis) {
+    async generate(config, analysis, moduleName) {
+      if (moduleName) {
+        this.moduleName = moduleName;
+      }
       this.validateInputs(config, analysis);
       this.extractInvariantsIfEnabled();
       this.generateTemporalPropertiesIfEnabled(analysis);
@@ -757,7 +770,7 @@ var init_tla = __esm(() => {
       }
     }
     addHeader() {
-      this.line("------------------------- MODULE UserApp -------------------------");
+      this.line(`------------------------- MODULE ${this.moduleName} -------------------------`);
       this.line("(*");
       this.line("  Auto-generated TLA+ specification for web extension");
       this.line("  ");
@@ -1349,32 +1362,86 @@ var init_tla = __esm(() => {
       if (assignment.value !== null)
         return true;
       const fieldConfig = state[assignment.field];
-      return !!(fieldConfig && typeof fieldConfig === "object" && ("values" in fieldConfig) && fieldConfig.values);
+      if (!fieldConfig || typeof fieldConfig !== "object")
+        return false;
+      if ("abstract" in fieldConfig && fieldConfig.abstract)
+        return true;
+      if ("nullable" in fieldConfig && fieldConfig.nullable)
+        return true;
+      return !!(("values" in fieldConfig) && fieldConfig.values);
     }
     mapNullAssignment(assignment, state) {
       if (assignment.value !== null)
         return assignment;
       const fieldConfig = state[assignment.field];
-      if (fieldConfig && typeof fieldConfig === "object" && "values" in fieldConfig && fieldConfig.values) {
+      if (!fieldConfig || typeof fieldConfig !== "object")
+        return assignment;
+      if ("abstract" in fieldConfig && fieldConfig.abstract)
+        return assignment;
+      if ("nullable" in fieldConfig && fieldConfig.nullable)
+        return assignment;
+      if ("values" in fieldConfig && fieldConfig.values) {
         const nullValue = fieldConfig.values[fieldConfig.values.length - 1];
         return { ...assignment, value: nullValue };
       }
       return assignment;
     }
     emitStateUpdates(validAssignments, preconditions) {
-      if (validAssignments.length > 0) {
-        const exceptClauses = validAssignments.map((a) => {
+      if (validAssignments.length === 0) {
+        if (preconditions.length === 0) {
+          this.line("\\* No state changes in handler");
+        }
+        this.line("/\\ UNCHANGED contextStates");
+        return true;
+      }
+      const ndetAssignments = [];
+      const detAssignments = [];
+      for (const a of validAssignments) {
+        if (typeof a.value === "string" && a.value.startsWith("NDET:")) {
+          ndetAssignments.push({ field: a.field, value: a.value });
+        } else {
+          detAssignments.push(a);
+        }
+      }
+      if (ndetAssignments.length === 0) {
+        const exceptClauses = detAssignments.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");
+      this.emitNDETStateUpdates(ndetAssignments, detAssignments);
+      return false;
+    }
+    emitNDETStateUpdates(ndetAssignments, detAssignments) {
+      const detExceptClauses = detAssignments.map((a) => {
+        const tlaValue = this.assignmentValueToTLA(a.value);
+        return `![ctx].${this.sanitizeFieldName(a.field)} = ${tlaValue}`;
+      });
+      const ndetExceptClauses = [];
+      const quantifierOpeners = [];
+      for (const a of ndetAssignments) {
+        const fieldName = this.sanitizeFieldName(a.field);
+        const fieldRef = `contextStates[ctx].${fieldName}`;
+        if (a.value === "NDET:FILTER") {
+          quantifierOpeners.push(`/\\ \\E newLen_${fieldName} \\in 0..Len(${fieldRef}) :`);
+          ndetExceptClauses.push(`![ctx].${fieldName} = SubSeq(@, 1, newLen_${fieldName})`);
+        } else if (a.value === "NDET:MAP") {
+          quantifierOpeners.push(`/\\ \\E mapIdx_${fieldName} \\in 1..Len(${fieldRef}) :`);
+          quantifierOpeners.push(`\\E mapVal_${fieldName} \\in Value :`);
+          ndetExceptClauses.push(`![ctx].${fieldName} = [@ EXCEPT ![mapIdx_${fieldName}] = mapVal_${fieldName}]`);
+        }
+      }
+      for (const opener of quantifierOpeners) {
+        this.line(opener);
+        this.indent++;
+      }
+      const allExceptClauses = [...detExceptClauses, ...ndetExceptClauses];
+      this.line(`/\\ contextStates' = [contextStates EXCEPT ${allExceptClauses.join(", ")}]`);
+      for (const _opener of quantifierOpeners) {
+        this.indent--;
       }
-      this.line("/\\ UNCHANGED contextStates");
-      return true;
     }
     tsExpressionToTLA(expr, isPrimed = false) {
       if (!expr || typeof expr !== "string") {
@@ -1787,6 +1854,9 @@ var init_tla = __esm(() => {
         return "NULL";
       }
       if (typeof value === "string") {
+        if (value.startsWith("NDET:")) {
+          throw new Error(`NDET marker "${value}" reached assignmentValueToTLA — should have been partitioned in emitStateUpdates`);
+        }
         if (value.startsWith("param:")) {
           const paramName = value.substring(6);
           return `payload.${this.sanitizeFieldName(paramName)}`;
@@ -2011,6 +2081,9 @@ var init_tla = __esm(() => {
     }
     tryAbstractType(fieldConfig) {
       if ("abstract" in fieldConfig && fieldConfig.abstract === true) {
+        if ("nullable" in fieldConfig && fieldConfig.nullable === true) {
+          return "Value \\union {NULL}";
+        }
         return "Value";
       }
       return null;
@@ -2178,6 +2251,9 @@ var init_tla = __esm(() => {
     }
     getInitialValue(fieldConfig) {
       if ("abstract" in fieldConfig && fieldConfig.abstract === true) {
+        if ("nullable" in fieldConfig && fieldConfig.nullable === true) {
+          return "NULL";
+        }
         return '"v1"';
       }
       if (Array.isArray(fieldConfig)) {
@@ -2869,7 +2945,7 @@ class ConfigGenerator {
     this.addHeader();
     this.addImports();
     this.addExport();
-    this.addStateConfig(analysis.fields);
+    this.addStateConfig(analysis.fields, analysis.resources);
     this.addMessagesConfig();
     this.addBehaviorConfig();
     this.closeExport();
@@ -2935,7 +3011,7 @@ class ConfigGenerator {
     this.indent--;
     this.line("})");
   }
-  addStateConfig(fields) {
+  addStateConfig(fields, resources) {
     this.line("state: {");
     this.indent++;
     for (let i = 0;i < fields.length; i++) {
@@ -2947,6 +3023,18 @@ class ConfigGenerator {
       }
       this.addFieldConfig(field);
     }
+    if (resources && resources.length > 0) {
+      if (fields.length > 0) {
+        this.line("");
+      }
+      this.line("// ─── $resource async lifecycle fields (auto-generated) ───");
+      for (const resource of resources) {
+        this.line("");
+        this.line(`// ${resource.name}: fetch lifecycle status`);
+        this.line(`"${resource.name}_status": { type: "enum", values: ["idle", "loading", "success", "error"] },`);
+        this.line(`"${resource.name}_error": { type: "boolean" },`);
+      }
+    }
     this.indent--;
     this.line("},");
     this.line("");
@@ -4277,12 +4365,13 @@ class HandlerExtractor {
     const stateConstraints = [];
     const globalStateConstraints = [];
     const verifiedStates = [];
+    const resources = [];
     this.warnings = [];
     const allSourceFiles = this.project.getSourceFiles();
     const entryPoints = allSourceFiles.filter((f) => this.isWithinPackage(f.getFilePath()));
     this.debugLogSourceFiles(allSourceFiles, entryPoints);
     for (const entryPoint of entryPoints) {
-      this.analyzeFileAndImports(entryPoint, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates);
+      this.analyzeFileAndImports(entryPoint, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates, resources);
     }
     if (verifiedStates.length > 0) {
       if (process.env["POLLY_DEBUG"]) {
@@ -4314,10 +4403,11 @@ class HandlerExtractor {
       stateConstraints,
       globalStateConstraints,
       verifiedStates,
+      resources,
       warnings: this.warnings
     };
   }
-  analyzeFileAndImports(sourceFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates) {
+  analyzeFileAndImports(sourceFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates, resources) {
     const filePath = sourceFile.getFilePath();
     if (this.analyzedFiles.has(filePath)) {
       return;
@@ -4335,6 +4425,20 @@ class HandlerExtractor {
     globalStateConstraints.push(...fileGlobalConstraints);
     const fileVerifiedStates = this.extractVerifiedStatesFromFile(sourceFile);
     verifiedStates.push(...fileVerifiedStates);
+    const fileResources = this.extractResourcesFromFile(sourceFile, filePath);
+    for (const resource of fileResources) {
+      resources.push(resource);
+      const context = this.inferContext(filePath);
+      const syntheticHandlers = this.createResourceHandlers(resource, context);
+      for (const handler of syntheticHandlers) {
+        handlers.push(handler);
+        if (this.isValidTLAIdentifier(handler.messageType)) {
+          messageTypes.add(handler.messageType);
+        } else {
+          invalidMessageTypes.add(handler.messageType);
+        }
+      }
+    }
     const importDeclarations = sourceFile.getImportDeclarations();
     for (const importDecl of importDeclarations) {
       const importedFile = importDecl.getModuleSpecifierSourceFile();
@@ -4346,7 +4450,7 @@ class HandlerExtractor {
           }
           continue;
         }
-        this.analyzeFileAndImports(importedFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates);
+        this.analyzeFileAndImports(importedFile, handlers, messageTypes, invalidMessageTypes, stateConstraints, globalStateConstraints, verifiedStates, resources);
       } else if (process.env["POLLY_DEBUG"]) {
         const specifier = importDecl.getModuleSpecifierValue();
         if (!specifier.startsWith("node:") && !this.isNodeModuleImport(specifier)) {
@@ -4705,7 +4809,9 @@ class HandlerExtractor {
       return;
     if (this.tryExtractSetConstructorPattern(fieldPath, right, assignments))
       return;
-    this.tryExtractMapConstructorPattern(fieldPath, right, assignments);
+    if (this.tryExtractMapConstructorPattern(fieldPath, right, assignments))
+      return;
+    this.tryExtractSignalDirectValuePattern(fieldPath, right, assignments);
   }
   tryExtractStateFieldPattern(fieldPath, right, assignments) {
     if (!fieldPath.startsWith("state."))
@@ -4824,6 +4930,25 @@ class HandlerExtractor {
     }
     return true;
   }
+  tryExtractSignalDirectValuePattern(fieldPath, right, assignments) {
+    if (!fieldPath.endsWith(".value"))
+      return false;
+    const signalName = fieldPath.slice(0, -6);
+    const literalValue = this.extractValue(right);
+    if (literalValue !== undefined) {
+      assignments.push({ field: signalName, value: literalValue });
+      return true;
+    }
+    if (Node2.isPropertyAccessExpression(right)) {
+      const rightPath = this.getPropertyPath(right);
+      const parts = rightPath.split(".");
+      if (parts.length === 2 && parts[0] !== undefined && parts[1] !== undefined && this.currentFunctionParams.includes(parts[0])) {
+        assignments.push({ field: signalName, value: `param:${parts[1]}` });
+        return true;
+      }
+    }
+    return false;
+  }
   extractSetOperation(newExpr, fieldPath, signalName) {
     const args = newExpr.getArguments();
     if (args.length === 0) {
@@ -4940,11 +5065,11 @@ class HandlerExtractor {
       return null;
     switch (methodName) {
       case "filter":
-        return { field: signalName, value: "SelectSeq(@, LAMBDA t: TRUE)" };
+        return { field: signalName, value: "NDET:FILTER" };
       case "map":
-        return { field: signalName, value: "[i \\in DOMAIN @ |-> @[i]]" };
+        return { field: signalName, value: "NDET:MAP" };
       case "slice":
-        return { field: signalName, value: "SubSeq(@, 1, Len(@))" };
+        return { field: signalName, value: "NDET:FILTER" };
       case "concat":
         return { field: signalName, value: "@ \\o <<payload>>" };
       case "reverse":
@@ -6215,6 +6340,125 @@ class HandlerExtractor {
     }
     return name || funcName;
   }
+  extractResourcesFromFile(sourceFile, filePath) {
+    const resources = [];
+    sourceFile.forEachDescendant((node) => {
+      if (!Node2.isCallExpression(node))
+        return;
+      const resource = this.extractResourcePattern(node, filePath);
+      if (resource) {
+        resources.push(resource);
+      }
+    });
+    return resources;
+  }
+  extractResourcePattern(node, filePath) {
+    const expression = node.getExpression();
+    if (!Node2.isIdentifier(expression))
+      return null;
+    if (expression.getText() !== "$resource")
+      return null;
+    const args = node.getArguments();
+    if (args.length < 2)
+      return null;
+    const nameArg = args[0];
+    if (!nameArg || !Node2.isStringLiteral(nameArg))
+      return null;
+    const name = nameArg.getLiteralValue();
+    const optionsArg = args[1];
+    if (!optionsArg || !Node2.isObjectLiteralExpression(optionsArg))
+      return null;
+    const sourceSignals = this.extractResourceSourceReads(optionsArg);
+    const variableName = this.getVariableNameFromParent(node) || name;
+    if (process.env["POLLY_DEBUG"]) {
+      console.log(`[DEBUG] Found $resource: ${variableName} (name: "${name}") with source signals: [${sourceSignals.join(", ")}]`);
+    }
+    return {
+      name,
+      variableName,
+      filePath,
+      line: node.getStartLineNumber(),
+      sourceSignals
+    };
+  }
+  extractResourceSourceReads(optionsObj) {
+    const signals = [];
+    const sourceProp = optionsObj.getProperty("source");
+    if (!sourceProp || !Node2.isPropertyAssignment(sourceProp))
+      return signals;
+    const sourceInit = sourceProp.getInitializer();
+    if (!sourceInit)
+      return signals;
+    sourceInit.forEachDescendant((node) => {
+      if (!Node2.isPropertyAccessExpression(node))
+        return;
+      const text = node.getText();
+      const match = text.match(/^(\w+)\.value(?:\.(\w+))?$/);
+      if (match) {
+        const signalName = match[1];
+        const fieldName = match[2];
+        if (fieldName) {
+          signals.push(`${signalName}_${fieldName}`);
+        } else {
+          signals.push(signalName);
+        }
+      }
+    });
+    return signals;
+  }
+  createResourceHandlers(resource, context) {
+    const { name, filePath, line } = resource;
+    const location = { file: filePath, line };
+    const fetchStart = {
+      messageType: `${name}_FetchStart`,
+      node: context,
+      assignments: [
+        { field: `${name}_status`, value: "loading" },
+        { field: `${name}_error`, value: false }
+      ],
+      preconditions: [
+        {
+          expression: `${name}_status !== "loading"`,
+          location: { line, column: 0 }
+        }
+      ],
+      postconditions: [],
+      location
+    };
+    const fetchSuccess = {
+      messageType: `${name}_FetchSuccess`,
+      node: context,
+      assignments: [
+        { field: `${name}_status`, value: "success" },
+        { field: `${name}_error`, value: false }
+      ],
+      preconditions: [
+        {
+          expression: `${name}_status === "loading"`,
+          location: { line, column: 0 }
+        }
+      ],
+      postconditions: [],
+      location
+    };
+    const fetchError = {
+      messageType: `${name}_FetchError`,
+      node: context,
+      assignments: [
+        { field: `${name}_status`, value: "error" },
+        { field: `${name}_error`, value: true }
+      ],
+      preconditions: [
+        {
+          expression: `${name}_status === "loading"`,
+          location: { line, column: 0 }
+        }
+      ],
+      postconditions: [],
+      location
+    };
+    return [fetchStart, fetchSuccess, fetchError];
+  }
 }
 
 // tools/analysis/src/extract/types.ts
@@ -6248,7 +6492,9 @@ class TypeExtractor {
       fields,
       handlers: completeHandlers,
       stateConstraints: handlerAnalysis.stateConstraints,
-      globalStateConstraints: handlerAnalysis.globalStateConstraints
+      globalStateConstraints: handlerAnalysis.globalStateConstraints,
+      verifiedStates: handlerAnalysis.verifiedStates,
+      resources: handlerAnalysis.resources
     };
   }
   extractHandlerAnalysis() {
@@ -7343,4 +7589,4 @@ main().catch((error) => {
   process.exit(1);
 });
 
-//# debugId=7EE824400DEB8F7564756E2164756E21
+//# debugId=AA5557533E02826364756E2164756E21