@fairfox/polly 0.8.0 → 0.9.1

package/dist/tools/verify/specs/verification.config.ts

@@ -39,6 +39,10 @@ export const verificationConfig = defineVerification({
     //
     // Start with 0 or 1 for faster verification.
     maxTabs: 1,
+
+    // TEST: Message filtering (Issue #14)
+    // Only verify these specific message types
+    include: ["test_message_1", "test_message_2", "test_message_3"],
   },
 
   // Verification behavior

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

@@ -775,6 +775,13 @@ class TLAGenerator {
     if (analysis.messageTypes.length === 0) {
       return;
     }
+    if (process.env["POLLY_DEBUG"]) {
+      console.log("[DEBUG] [TLAGenerator] Full config keys:", Object.keys(config));
+      console.log("[DEBUG] [TLAGenerator] config.messages:", JSON.stringify(config.messages, null, 2));
+      console.log("[DEBUG] [TLAGenerator] config.messages.include:", config.messages.include);
+      console.log("[DEBUG] [TLAGenerator] config.messages.exclude:", config.messages.exclude);
+      console.log("[DEBUG] [TLAGenerator] analysis.messageTypes:", analysis.messageTypes);
+    }
     let validMessageTypes = [];
     const invalidMessageTypes = [];
     for (const msgType of analysis.messageTypes) {
@@ -790,18 +797,46 @@ class TLAGenerator {
         console.log(`[WARN]   - "${invalid}" (not a valid TLA+ identifier)`);
       }
     }
+    if (process.env["POLLY_DEBUG"]) {
+      console.log(`[DEBUG] [TLAGenerator] Valid message types before filtering (${validMessageTypes.length}):`, validMessageTypes);
+    }
     const originalCount = validMessageTypes.length;
     const filteredOut = [];
+    if (process.env["POLLY_DEBUG"]) {
+      console.log("[DEBUG] [TLAGenerator] Checking filter conditions:");
+      console.log("[DEBUG]   - config.messages.include exists:", !!config.messages.include);
+      console.log("[DEBUG]   - config.messages.include.length:", config.messages.include?.length ?? "N/A");
+      console.log("[DEBUG]   - First condition result:", !!(config.messages.include && config.messages.include.length > 0));
+    }
     if (config.messages.include && config.messages.include.length > 0) {
+      if (process.env["POLLY_DEBUG"]) {
+        console.log("[DEBUG] [TLAGenerator] Entering include mode filtering");
+      }
       const included = new Set(config.messages.include);
       const beforeFilter = validMessageTypes;
       validMessageTypes = validMessageTypes.filter((msg) => included.has(msg));
       filteredOut.push(...beforeFilter.filter((msg) => !included.has(msg)));
+      if (process.env["POLLY_DEBUG"]) {
+        console.log("[DEBUG] [TLAGenerator] After include filtering:");
+        console.log("[DEBUG]   - validMessageTypes:", validMessageTypes);
+        console.log("[DEBUG]   - filteredOut:", filteredOut);
+      }
     } else if (config.messages.exclude && config.messages.exclude.length > 0) {
+      if (process.env["POLLY_DEBUG"]) {
+        console.log("[DEBUG] [TLAGenerator] Entering exclude mode filtering");
+      }
       const excluded = new Set(config.messages.exclude);
       const beforeFilter = validMessageTypes;
       validMessageTypes = validMessageTypes.filter((msg) => !excluded.has(msg));
       filteredOut.push(...beforeFilter.filter((msg) => excluded.has(msg)));
+      if (process.env["POLLY_DEBUG"]) {
+        console.log("[DEBUG] [TLAGenerator] After exclude filtering:");
+        console.log("[DEBUG]   - validMessageTypes:", validMessageTypes);
+        console.log("[DEBUG]   - filteredOut:", filteredOut);
+      }
+    } else if (process.env["POLLY_DEBUG"]) {
+      console.log("[DEBUG] [TLAGenerator] No include/exclude filtering applied");
+      console.log("[DEBUG]   - Reason: Neither include nor exclude conditions met");
     }
     if (filteredOut.length > 0) {
       const filterMode = config.messages.include ? "include" : "exclude";
@@ -809,6 +844,8 @@ class TLAGenerator {
       if (process.env["POLLY_DEBUG"]) {
         console.log(`[INFO]   Filtered out: ${filteredOut.join(", ")}`);
       }
+    } else if (config.messages.include || config.messages.exclude) {
+      console.log("[WARN] [TLAGenerator] Message filters configured but no types were filtered");
     }
     if (validMessageTypes.length === 0) {
       return;
@@ -1759,22 +1796,32 @@ import * as path3 from "node:path";
 class DockerRunner {
   async isDockerAvailable() {
     try {
-      const result = await this.runCommand("docker", ["--version"]);
+      const result = await this.runCommand("docker", ["info"], {
+        timeout: 5000
+      });
       return result.exitCode === 0;
-    } catch {
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("timed out")) {
+        throw error;
+      }
       return false;
     }
   }
   async hasImage() {
     try {
-      const result = await this.runCommand("docker", ["images", "-q", "talex5/tla"]);
+      const result = await this.runCommand("docker", ["images", "-q", "talex5/tla"], {
+        timeout: 1e4
+      });
       return result.stdout.trim().length > 0;
-    } catch {
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("timed out")) {
+        throw error;
+      }
       return false;
     }
   }
   async pullImage(onProgress) {
-    await this.runCommandStreaming("docker", ["pull", "talex5/tla:latest"], onProgress);
+    await this.runCommandStreaming("docker", ["pull", "talex5/tla:latest"], onProgress, 300000);
   }
   async runTLC(specPath, options) {
     if (!fs3.existsSync(specPath)) {
@@ -1896,9 +1943,13 @@ class DockerRunner {
       });
     });
   }
-  runCommandStreaming(command, args, onOutput) {
+  runCommandStreaming(command, args, onOutput, timeout) {
     return new Promise((resolve2, reject) => {
       const proc = spawn(command, args);
+      const timeoutHandle = timeout && timeout > 0 ? setTimeout(() => {
+        proc.kill();
+        reject(new Error(`Command timed out after ${Math.floor(timeout / 1000)}s. Docker may be unresponsive.`));
+      }, timeout) : null;
       proc.stdout.on("data", (data) => {
         if (onOutput) {
           const lines = data.toString().split(`
@@ -1922,13 +1973,19 @@ class DockerRunner {
         }
       });
       proc.on("close", (exitCode) => {
+        if (timeoutHandle)
+          clearTimeout(timeoutHandle);
         if (exitCode === 0) {
           resolve2();
         } else {
           reject(new Error(`Command failed with exit code ${exitCode}`));
         }
       });
-      proc.on("error", reject);
+      proc.on("error", (error) => {
+        if (timeoutHandle)
+          clearTimeout(timeoutHandle);
+        reject(error);
+      });
     });
   }
 }
@@ -2251,6 +2308,28 @@ class ConfigGenerator {
         this.line("maxContexts: 3,");
         break;
     }
+    this.line("");
+    this.line("// ─────────────────────────────────────────────────────────");
+    this.line("// Tier 1 Optimizations (no precision loss) - OPTIONAL");
+    this.line("// ─────────────────────────────────────────────────────────");
+    this.line("// Uncomment and configure to reduce state space:");
+    this.line("//");
+    this.line("// 1. Filter messages (use include OR exclude, not both):");
+    this.line("//    include: ['authenticate', 'query', 'command', 'result'],");
+    this.line("//    exclude: ['load', 'unload', 'resize', 'scroll', 'click'],");
+    this.line("//");
+    this.line("// 2. Symmetry reduction (group equivalent message types):");
+    this.line("//    symmetry: [");
+    this.line("//      ['query_user', 'query_post'],     // All query types");
+    this.line("//      ['create', 'update', 'delete'],   // CRUD operations");
+    this.line("//    ],");
+    this.line("//");
+    this.line("// 3. Per-message bounds (different maxInFlight per type):");
+    this.line("//    perMessageBounds: {");
+    this.line("//      'authenticate': 1,  // Sequential only");
+    this.line("//      'query': 5,         // Allow concurrency");
+    this.line("//      'command': 2,");
+    this.line("//    },");
     this.indent--;
     this.line("},");
     this.line("");
@@ -2288,6 +2367,31 @@ class ConfigGenerator {
     this.line("//   }");
     this.line("//");
     this.line("// preset: 'balanced',");
+    this.line("");
+    this.line("// ─────────────────────────────────────────────────────────");
+    this.line("// Tier 2 Optimizations (controlled approximations) - ADVANCED");
+    this.line("// ─────────────────────────────────────────────────────────");
+    this.line("// Use with caution - these reduce precision for performance.");
+    this.line("// Only use if verification is too slow even with Tier 1 optimizations.");
+    this.line("//");
+    this.line("// tier2: {");
+    this.line("//   // Temporal constraints: specify known ordering requirements");
+    this.line("//   temporalConstraints: [");
+    this.line("//     {");
+    this.line("//       before: 'LOGIN',");
+    this.line("//       after: 'LOGOUT',");
+    this.line("//       description: 'User must login before logout'");
+    this.line("//     },");
+    this.line("//   ],");
+    this.line("//");
+    this.line("//   // Bounded exploration: limit state depth");
+    this.line("//   boundedExploration: {");
+    this.line("//     maxDepth: 20,  // Stop exploring after 20 actions");
+    this.line("//     // criticalPaths: [  // Ensure these sequences are fully explored");
+    this.line("//     //   ['LOGIN', 'QUERY', 'LOGOUT'],");
+    this.line("//     // ],");
+    this.line("//   },");
+    this.line("// },");
   }
   formatTypeName(type) {
     let typeName;
@@ -2464,6 +2568,13 @@ class ConfigValidator {
     this.findNullPlaceholders(config.state, "state");
     this.findNullPlaceholders(config.messages, "messages");
     this.validateBounds(config);
+    this.validateTier1Optimizations(config.messages);
+    if (config.verification) {
+      this.validateVerificationOptions(config.verification);
+    }
+    if (config.tier2) {
+      this.validateTier2Optimizations(config.tier2);
+    }
   }
   findNullPlaceholders(obj, path2) {
     if (obj === null || obj === undefined) {
@@ -2624,6 +2735,142 @@ class ConfigValidator {
       });
     }
   }
+  validateTier1Optimizations(messages) {
+    if (messages.include && messages.exclude) {
+      this.issues.push({
+        type: "invalid_value",
+        severity: "error",
+        field: "messages",
+        message: "Cannot use both 'include' and 'exclude' filters",
+        suggestion: "Use either 'include' OR 'exclude', not both"
+      });
+    }
+    if (messages.symmetry) {
+      for (let i = 0;i < messages.symmetry.length; i++) {
+        const group = messages.symmetry[i];
+        if (group.length < 2) {
+          this.issues.push({
+            type: "invalid_value",
+            severity: "warning",
+            field: `messages.symmetry[${i}]`,
+            message: "Symmetry group must have at least 2 message types",
+            suggestion: "Remove single-element symmetry groups"
+          });
+        }
+      }
+    }
+    if (messages.perMessageBounds) {
+      for (const [msgType, bound] of Object.entries(messages.perMessageBounds)) {
+        if (bound < 1) {
+          this.issues.push({
+            type: "invalid_value",
+            severity: "error",
+            field: `messages.perMessageBounds.${msgType}`,
+            message: `Per-message bound must be at least 1`,
+            suggestion: "Use a positive number"
+          });
+        }
+        if (bound > 20) {
+          this.issues.push({
+            type: "unrealistic_bound",
+            severity: "warning",
+            field: `messages.perMessageBounds.${msgType}`,
+            message: `Per-message bound ${bound} is outside recommended range (1-20)`,
+            suggestion: "Consider adjusting bound to a more realistic value"
+          });
+        }
+      }
+    }
+  }
+  validateVerificationOptions(verification) {
+    if (verification.timeout !== undefined) {
+      if (verification.timeout < 0) {
+        this.issues.push({
+          type: "invalid_value",
+          severity: "error",
+          field: "verification.timeout",
+          message: "Timeout cannot be negative",
+          suggestion: "Use 0 for no timeout, or positive number for timeout in seconds"
+        });
+      }
+      if (verification.timeout > 3600) {
+        this.issues.push({
+          type: "unrealistic_bound",
+          severity: "warning",
+          field: "verification.timeout",
+          message: "Timeout over 1 hour (3600s) is very long",
+          suggestion: "Consider reducing timeout or using 0 for no limit"
+        });
+      }
+    }
+    if (verification.workers !== undefined) {
+      if (verification.workers < 1) {
+        this.issues.push({
+          type: "invalid_value",
+          severity: "error",
+          field: "verification.workers",
+          message: "Workers must be at least 1",
+          suggestion: "Use 1 or more workers"
+        });
+      }
+      if (verification.workers > 16) {
+        this.issues.push({
+          type: "unrealistic_bound",
+          severity: "warning",
+          field: "verification.workers",
+          message: "More than 16 workers may not improve performance",
+          suggestion: "Typical range is 1-8 workers"
+        });
+      }
+    }
+  }
+  validateTier2Optimizations(tier2) {
+    if (tier2.temporalConstraints) {
+      for (let i = 0;i < tier2.temporalConstraints.length; i++) {
+        const constraint = tier2.temporalConstraints[i];
+        if (!constraint.before || !constraint.after) {
+          this.issues.push({
+            type: "invalid_value",
+            severity: "error",
+            field: `tier2.temporalConstraints[${i}]`,
+            message: "Temporal constraint must have 'before' and 'after' fields",
+            suggestion: "Specify both message types for ordering constraint"
+          });
+        }
+        if (constraint.before === constraint.after) {
+          this.issues.push({
+            type: "invalid_value",
+            severity: "error",
+            field: `tier2.temporalConstraints[${i}]`,
+            message: "Temporal constraint cannot have same message type for 'before' and 'after'",
+            suggestion: "Use different message types"
+          });
+        }
+      }
+    }
+    if (tier2.boundedExploration) {
+      if (tier2.boundedExploration.maxDepth !== undefined) {
+        if (tier2.boundedExploration.maxDepth < 1) {
+          this.issues.push({
+            type: "invalid_value",
+            severity: "error",
+            field: "tier2.boundedExploration.maxDepth",
+            message: "maxDepth must be at least 1",
+            suggestion: "Use positive integer for depth limit"
+          });
+        }
+        if (tier2.boundedExploration.maxDepth > 100) {
+          this.issues.push({
+            type: "unrealistic_bound",
+            severity: "warning",
+            field: "tier2.boundedExploration.maxDepth",
+            message: "maxDepth > 100 may not be useful",
+            suggestion: "Typical range is 10-50"
+          });
+        }
+      }
+    }
+  }
 }
 function validateConfig(configPath) {
   const validator = new ConfigValidator;
@@ -4656,14 +4903,50 @@ async function setupDocker() {
   const { DockerRunner: DockerRunner2 } = await Promise.resolve().then(() => (init_docker(), exports_docker));
   console.log(color("\uD83D\uDC33 Checking Docker...", COLORS.blue));
   const docker = new DockerRunner2;
-  if (!await docker.isDockerAvailable()) {
-    throw new Error("Docker is not available. Please install Docker and try again.");
+  try {
+    if (!await docker.isDockerAvailable()) {
+      console.log();
+      console.log(color("❌ Docker is not available", COLORS.red));
+      console.log();
+      console.log("Please ensure Docker is installed and running:");
+      console.log(color("  • Install Docker Desktop: https://www.docker.com/products/docker-desktop", COLORS.gray));
+      console.log(color("  • Make sure Docker Desktop is running", COLORS.gray));
+      console.log();
+      throw new Error("Docker is not available");
+    }
+  } catch (error) {
+    console.log();
+    if (error instanceof Error && error.message.includes("timed out")) {
+      console.log(color("❌ Docker is unresponsive", COLORS.red));
+      console.log();
+      console.log("Docker appears to be installed but is not responding.");
+      console.log("Try restarting Docker:");
+      console.log(color("  • Quit Docker Desktop completely", COLORS.gray));
+      console.log(color("  • Restart Docker Desktop", COLORS.gray));
+      console.log(color("  • Wait for Docker to fully start (check the menu bar icon)", COLORS.gray));
+      console.log();
+    } else if (error instanceof Error && error.message !== "Docker is not available") {
+      console.log(color(`❌ Error checking Docker: ${error.message}`, COLORS.red));
+      console.log();
+    }
+    throw error;
   }
-  if (!await docker.hasImage()) {
-    console.log(color("   Pulling TLA+ image (this may take a moment)...", COLORS.gray));
-    await docker.pullImage((line) => {
-      console.log(color(`   ${line}`, COLORS.gray));
-    });
+  try {
+    if (!await docker.hasImage()) {
+      console.log(color("   Pulling TLA+ image (this may take a moment)...", COLORS.gray));
+      await docker.pullImage((line) => {
+        console.log(color(`   ${line}`, COLORS.gray));
+      });
+    }
+  } catch (error) {
+    console.log();
+    if (error instanceof Error && error.message.includes("timed out")) {
+      console.log(color("❌ Docker is unresponsive while checking for TLA+ image", COLORS.red));
+      console.log();
+      console.log("Docker is not responding. Try restarting Docker Desktop.");
+      console.log();
+    }
+    throw error;
   }
   console.log(color("✓ Docker ready", COLORS.green));
   console.log();
@@ -4769,4 +5052,4 @@ main().catch((error) => {
   process.exit(1);
 });
 
-//# debugId=84A67D24A43D09B664756E2164756E21
+//# debugId=E4DF49968E3D4FDC64756E2164756E21