@fairfox/polly 0.1.3 → 0.1.5

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

@@ -0,0 +1,2089 @@
+#!/usr/bin/env bun
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// vendor/verify/src/codegen/tla.ts
+var exports_tla = {};
+__export(exports_tla, {
+  generateTLA: () => generateTLA,
+  TLAGenerator: () => TLAGenerator
+});
+
+class TLAGenerator {
+  lines = [];
+  indent = 0;
+  generate(config, analysis) {
+    this.lines = [];
+    this.indent = 0;
+    const spec = this.generateSpec(config, analysis);
+    const cfg = this.generateConfig(config, analysis);
+    return { spec, cfg };
+  }
+  generateSpec(config, analysis) {
+    this.lines = [];
+    this.indent = 0;
+    this.addHeader();
+    this.addExtends();
+    this.addConstants(config, analysis);
+    this.addMessageTypes(config, analysis);
+    this.addStateType(config, analysis);
+    this.addVariables();
+    this.addInit(config, analysis);
+    this.addActions(config, analysis);
+    this.addRouteWithHandlers(config, analysis);
+    this.addNext(config, analysis);
+    this.addSpec();
+    this.addInvariants(config, analysis);
+    return this.lines.join(`
+`);
+  }
+  generateConfig(config, analysis) {
+    const lines = [];
+    lines.push("SPECIFICATION UserSpec");
+    lines.push("");
+    lines.push("\\* Constants");
+    lines.push("CONSTANTS");
+    lines.push("  Contexts = {background, content, popup}");
+    lines.push(`  MaxMessages = ${config.messages.maxInFlight || 3}`);
+    lines.push(`  MaxTabId = ${config.messages.maxTabs || 1}`);
+    lines.push("  TimeoutLimit = 3");
+    for (const [field, fieldConfig] of Object.entries(config.state)) {
+      if (typeof fieldConfig === "object" && fieldConfig !== null) {
+        if ("maxLength" in fieldConfig && fieldConfig.maxLength !== null) {
+          const constName = this.fieldToConstName(field);
+          lines.push(`  ${constName}_MaxLength = ${fieldConfig.maxLength}`);
+        }
+        if ("max" in fieldConfig && fieldConfig.max !== null) {
+          const constName = this.fieldToConstName(field);
+          lines.push(`  ${constName}_Max = ${fieldConfig.max}`);
+        }
+        if ("maxSize" in fieldConfig && fieldConfig.maxSize !== null) {
+          const constName = this.fieldToConstName(field);
+          lines.push(`  ${constName}_MaxSize = ${fieldConfig.maxSize}`);
+        }
+      }
+    }
+    lines.push("");
+    lines.push("\\* Invariants to check");
+    lines.push("INVARIANTS");
+    lines.push("  TypeOK");
+    lines.push("  NoRoutingLoops");
+    lines.push("  UserStateTypeInvariant");
+    lines.push("");
+    lines.push("\\* State constraint");
+    lines.push("CONSTRAINT");
+    lines.push("  StateConstraint");
+    return lines.join(`
+`);
+  }
+  addHeader() {
+    this.line("------------------------- MODULE UserApp -------------------------");
+    this.line("(*");
+    this.line("  Auto-generated TLA+ specification for web extension");
+    this.line("  ");
+    this.line("  Generated from:");
+    this.line("    - TypeScript type definitions");
+    this.line("    - Verification configuration");
+    this.line("  ");
+    this.line("  This spec extends MessageRouter with:");
+    this.line("    - Application-specific state types");
+    this.line("    - Message type definitions");
+    this.line("    - State transition actions");
+    this.line("*)");
+    this.line("");
+  }
+  addExtends() {
+    this.line("EXTENDS MessageRouter");
+    this.line("");
+  }
+  addConstants(config, analysis) {
+    const hasCustomConstants = Object.entries(config.state).some(([field, fieldConfig]) => {
+      if (typeof fieldConfig !== "object" || fieldConfig === null)
+        return false;
+      return "maxLength" in fieldConfig && fieldConfig.maxLength !== null || "max" in fieldConfig && fieldConfig.max !== null || "maxSize" in fieldConfig && fieldConfig.maxSize !== null;
+    });
+    if (!hasCustomConstants) {
+      return;
+    }
+    this.line("\\* Application-specific constants");
+    this.line("CONSTANTS");
+    this.indent++;
+    let first = true;
+    for (const [field, fieldConfig] of Object.entries(config.state)) {
+      if (typeof fieldConfig === "object" && fieldConfig !== null) {
+        const constName = this.fieldToConstName(field);
+        if ("maxLength" in fieldConfig && fieldConfig.maxLength !== null) {
+          this.line(`${first ? "" : ","}${constName}_MaxLength  \\* Max length for ${field}`);
+          first = false;
+        }
+        if ("max" in fieldConfig && fieldConfig.max !== null) {
+          this.line(`${first ? "" : ","}${constName}_Max       \\* Max value for ${field}`);
+          first = false;
+        }
+        if ("maxSize" in fieldConfig && fieldConfig.maxSize !== null) {
+          this.line(`${first ? "" : ","}${constName}_MaxSize   \\* Max size for ${field}`);
+          first = false;
+        }
+      }
+    }
+    this.indent--;
+    this.line("");
+  }
+  addStateType(config, analysis) {
+    this.line("\\* Generic value type for sequences and maps");
+    this.line("\\* Bounded to allow model checking");
+    this.line('Value == {"v1", "v2", "v3"}');
+    this.line("");
+    this.line("\\* Generic key type for maps");
+    this.line("\\* Bounded to allow model checking");
+    this.line('Keys == {"k1", "k2", "k3"}');
+    this.line("");
+    this.line("\\* Application state type definition");
+    this.line("State == [");
+    this.indent++;
+    const stateFields = [];
+    for (const [fieldPath, fieldConfig] of Object.entries(config.state)) {
+      if (typeof fieldConfig !== "object" || fieldConfig === null)
+        continue;
+      const fieldName = this.sanitizeFieldName(fieldPath);
+      const tlaType = this.fieldConfigToTLAType(fieldPath, fieldConfig, config);
+      stateFields.push(`${fieldName}: ${tlaType}`);
+    }
+    for (let i = 0;i < stateFields.length; i++) {
+      const field = stateFields[i];
+      const suffix = i < stateFields.length - 1 ? "," : "";
+      this.line(`${field}${suffix}`);
+    }
+    this.indent--;
+    this.line("]");
+    this.line("");
+  }
+  addMessageTypes(config, analysis) {
+    if (analysis.messageTypes.length === 0) {
+      return;
+    }
+    this.line("\\* Message types from application");
+    const messageTypeSet = analysis.messageTypes.map((t) => `"${t}"`).join(", ");
+    this.line(`UserMessageTypes == {${messageTypeSet}}`);
+    this.line("");
+  }
+  addVariables() {
+    this.line("\\* Application state per context");
+    this.line("VARIABLE contextStates");
+    this.line("");
+    this.line("\\* All variables (extending MessageRouter vars)");
+    this.line("allVars == <<ports, messages, pendingRequests, delivered, routingDepth, time, contextStates>>");
+    this.line("");
+  }
+  addInit(config, analysis) {
+    this.line("\\* Initial application state");
+    this.line("InitialState == [");
+    this.indent++;
+    const fields = [];
+    for (const [fieldPath, fieldConfig] of Object.entries(config.state)) {
+      if (typeof fieldConfig !== "object" || fieldConfig === null)
+        continue;
+      const fieldName = this.sanitizeFieldName(fieldPath);
+      const initialValue = this.getInitialValue(fieldConfig);
+      fields.push(`${fieldName} |-> ${initialValue}`);
+    }
+    for (let i = 0;i < fields.length; i++) {
+      const field = fields[i];
+      const suffix = i < fields.length - 1 ? "," : "";
+      this.line(`${field}${suffix}`);
+    }
+    this.indent--;
+    this.line("]");
+    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.indent--;
+    this.line("");
+  }
+  addActions(config, analysis) {
+    this.line("\\* =============================================================================");
+    this.line("\\* Application-specific actions");
+    this.line("\\* =============================================================================");
+    this.line("");
+    if (analysis.handlers.length === 0) {
+      this.line("\\* No message handlers found in codebase");
+      this.line("\\* State remains unchanged for all messages");
+      this.line("StateTransition(ctx, msgType) ==");
+      this.indent++;
+      this.line("UNCHANGED contextStates");
+      this.indent--;
+      this.line("");
+      return;
+    }
+    this.line("\\* State transitions extracted from message handlers");
+    this.line("");
+    const handlersByType = new Map;
+    for (const handler of analysis.handlers) {
+      if (!handlersByType.has(handler.messageType)) {
+        handlersByType.set(handler.messageType, []);
+      }
+      handlersByType.get(handler.messageType).push(handler);
+    }
+    for (const [messageType, handlers] of handlersByType.entries()) {
+      this.generateHandlerAction(messageType, handlers, config);
+    }
+    this.line("\\* Main state transition action");
+    this.line("StateTransition(ctx, msgType) ==");
+    this.indent++;
+    const messageTypes = Array.from(handlersByType.keys());
+    for (let i = 0;i < messageTypes.length; i++) {
+      const msgType = messageTypes[i];
+      const actionName = this.messageTypeToActionName(msgType);
+      if (i === 0) {
+        this.line(`IF msgType = "${msgType}" THEN ${actionName}(ctx)`);
+      } else if (i === messageTypes.length - 1) {
+        this.line(`ELSE IF msgType = "${msgType}" THEN ${actionName}(ctx)`);
+        this.line("ELSE UNCHANGED contextStates  \\* Unknown message type");
+      } else {
+        this.line(`ELSE IF msgType = "${msgType}" THEN ${actionName}(ctx)`);
+      }
+    }
+    this.indent--;
+    this.line("");
+  }
+  generateHandlerAction(messageType, handlers, config) {
+    const actionName = this.messageTypeToActionName(messageType);
+    this.line(`\\* Handler for ${messageType}`);
+    this.line(`${actionName}(ctx) ==`);
+    this.indent++;
+    const allPreconditions = handlers.flatMap((h) => h.preconditions);
+    const allAssignments = handlers.flatMap((h) => h.assignments);
+    const allPostconditions = handlers.flatMap((h) => h.postconditions);
+    if (allPreconditions.length > 0) {
+      for (const precondition of allPreconditions) {
+        const tlaExpr = this.tsExpressionToTLA(precondition.expression);
+        const comment = precondition.message ? ` \\* ${precondition.message}` : "";
+        this.line(`/\\ ${tlaExpr}${comment}`);
+      }
+    }
+    const validAssignments = allAssignments.filter((a) => {
+      if (a.value === null) {
+        const fieldConfig = config.state[a.field];
+        if (fieldConfig && typeof fieldConfig === "object" && "values" in fieldConfig && fieldConfig.values) {
+          return true;
+        }
+        return false;
+      }
+      return true;
+    }).map((a) => {
+      if (a.value === null) {
+        const fieldConfig = config.state[a.field];
+        if (fieldConfig && typeof fieldConfig === "object" && "values" in fieldConfig && fieldConfig.values) {
+          const nullValue = fieldConfig.values[fieldConfig.values.length - 1];
+          return { ...a, value: nullValue };
+        }
+      }
+      return a;
+    });
+    if (validAssignments.length === 0) {
+      if (allPreconditions.length === 0) {
+        this.line("\\* No state changes in handler");
+      }
+      this.line("/\\ UNCHANGED contextStates");
+    } else {
+      this.line("/\\ contextStates' = [contextStates EXCEPT");
+      this.indent++;
+      for (let i = 0;i < validAssignments.length; i++) {
+        const assignment = validAssignments[i];
+        const fieldName = this.sanitizeFieldName(assignment.field);
+        const value = this.assignmentValueToTLA(assignment.value);
+        const suffix = i < validAssignments.length - 1 ? "," : "";
+        this.line(`![ctx].${fieldName} = ${value}${suffix}`);
+      }
+      this.indent--;
+      this.line("]");
+    }
+    if (allPostconditions.length > 0) {
+      for (const postcondition of allPostconditions) {
+        const tlaExpr = this.tsExpressionToTLA(postcondition.expression, true);
+        const comment = postcondition.message ? ` \\* ${postcondition.message}` : "";
+        this.line(`/\\ ${tlaExpr}${comment}`);
+      }
+    }
+    this.indent--;
+    this.line("");
+  }
+  tsExpressionToTLA(expr, isPrimed = false) {
+    let tla = expr;
+    const statePrefix = isPrimed ? "contextStates'[ctx]" : "contextStates[ctx]";
+    tla = tla.replace(/state\.([a-zA-Z_][a-zA-Z0-9_.]*)/g, (match, path2) => {
+      return `${statePrefix}.${this.sanitizeFieldName(path2)}`;
+    });
+    tla = tla.replace(/payload\.([a-zA-Z_][a-zA-Z0-9_.]*)/g, (match, path2) => {
+      return `payload.${this.sanitizeFieldName(path2)}`;
+    });
+    tla = tla.replace(/===/g, "=");
+    tla = tla.replace(/!==/g, "#");
+    tla = tla.replace(/!=/g, "#");
+    tla = tla.replace(/==/g, "=");
+    tla = tla.replace(/&&/g, "/\\");
+    tla = tla.replace(/\|\|/g, "\\/");
+    tla = tla.replace(/!([^=])/g, "~$1");
+    tla = tla.replace(/!$/g, "~");
+    tla = tla.replace(/\btrue\b/g, "TRUE");
+    tla = tla.replace(/\bfalse\b/g, "FALSE");
+    tla = tla.replace(/\bnull\b/g, "NULL");
+    tla = tla.replace(/</g, "<");
+    tla = tla.replace(/>/g, ">");
+    tla = tla.replace(/<=/g, "<=");
+    tla = tla.replace(/>=/g, ">=");
+    return tla;
+  }
+  messageTypeToActionName(messageType) {
+    return "Handle" + messageType.split("_").map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+  }
+  assignmentValueToTLA(value) {
+    if (typeof value === "boolean") {
+      return value ? "TRUE" : "FALSE";
+    }
+    if (typeof value === "number") {
+      return String(value);
+    }
+    if (value === null) {
+      return "NULL";
+    }
+    if (typeof value === "string") {
+      return `"${value}"`;
+    }
+    return "NULL";
+  }
+  addRouteWithHandlers(config, analysis) {
+    this.line("\\* =============================================================================");
+    this.line("\\* Message Routing with State Transitions");
+    this.line("\\* =============================================================================");
+    this.line("");
+    if (analysis.handlers.length === 0) {
+      return;
+    }
+    this.line("\\* Route a message and invoke its handler");
+    this.line("UserRouteMessage(msgIndex) ==");
+    this.indent++;
+    this.line("/\\ msgIndex \\in 1..Len(messages)");
+    this.line("/\\ LET msg == messages[msgIndex]");
+    this.line('   IN /\\ msg.status = "pending"');
+    this.line("      /\\ routingDepth' = routingDepth + 1");
+    this.line("      /\\ routingDepth < 5");
+    this.line("      /\\ \\E target \\in msg.targets :");
+    this.line('            /\\ IF target \\in Contexts /\\ ports[target] = "connected"');
+    this.line("               THEN \\* Successful delivery - route AND invoke handler");
+    this.line(`                    /\\ messages' = [messages EXCEPT ![msgIndex].status = "delivered"]`);
+    this.line("                    /\\ delivered' = delivered \\union {msg.id}");
+    this.line("                    /\\ pendingRequests' = [id \\in DOMAIN pendingRequests \\ {msg.id} |->");
+    this.line("                                           pendingRequests[id]]");
+    this.line("                    /\\ time' = time + 1");
+    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 ports");
+    this.indent--;
+    this.line("");
+  }
+  addNext(config, analysis) {
+    this.line("\\* Next state relation (extends MessageRouter)");
+    this.line("UserNext ==");
+    this.indent++;
+    if (analysis.handlers.length > 0) {
+      this.line("\\/ \\E c \\in Contexts : ConnectPort(c) /\\ UNCHANGED contextStates");
+      this.line("\\/ \\E c \\in Contexts : DisconnectPort(c) /\\ UNCHANGED contextStates");
+      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.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");
+    } else {
+      this.line("\\/ Next /\\ UNCHANGED contextStates");
+    }
+    this.indent--;
+    this.line("");
+  }
+  addSpec() {
+    this.line("\\* Specification");
+    this.line("UserSpec == UserInit /\\ [][UserNext]_allVars /\\ WF_allVars(UserNext)");
+    this.line("");
+  }
+  addInvariants(config, analysis) {
+    this.line("\\* =============================================================================");
+    this.line("\\* Application Invariants");
+    this.line("\\* =============================================================================");
+    this.line("");
+    this.line("\\* TypeOK and NoRoutingLoops are inherited from MessageRouter");
+    this.line("");
+    this.line("\\* Application state type invariant");
+    this.line("UserStateTypeInvariant ==");
+    this.indent++;
+    this.line("\\A ctx \\in Contexts :");
+    this.indent++;
+    this.line("contextStates[ctx] \\in State");
+    this.indent--;
+    this.indent--;
+    this.line("");
+    this.line("\\* State constraint to bound state space");
+    this.line("StateConstraint ==");
+    this.indent++;
+    this.line("Len(messages) <= MaxMessages");
+    this.indent--;
+    this.line("");
+    this.line("=============================================================================");
+  }
+  fieldConfigToTLAType(fieldPath, fieldConfig, config) {
+    if ("type" in fieldConfig) {
+      if (fieldConfig.type === "boolean") {
+        return "BOOLEAN";
+      }
+      if (fieldConfig.type === "enum" && fieldConfig.values) {
+        const values = fieldConfig.values.map((v) => `"${v}"`).join(", ");
+        return `{${values}}`;
+      }
+    }
+    if ("maxLength" in fieldConfig) {
+      const constName = this.fieldToConstName(fieldPath);
+      return `Seq(Value)`;
+    }
+    if ("min" in fieldConfig && "max" in fieldConfig) {
+      const constName = this.fieldToConstName(fieldPath);
+      const min = fieldConfig.min || 0;
+      const max = fieldConfig.max || 100;
+      return `${min}..${max}`;
+    }
+    if ("values" in fieldConfig) {
+      if (fieldConfig.values && Array.isArray(fieldConfig.values)) {
+        const values = fieldConfig.values.map((v) => `"${v}"`).join(", ");
+        return `{${values}}`;
+      }
+      if (fieldConfig.abstract) {
+        return "STRING";
+      }
+      return "STRING";
+    }
+    if ("maxSize" in fieldConfig) {
+      return "[Keys -> Value]";
+    }
+    return "Value";
+  }
+  getInitialValue(fieldConfig) {
+    if ("type" in fieldConfig) {
+      if (fieldConfig.type === "boolean") {
+        return "FALSE";
+      }
+      if (fieldConfig.type === "enum" && fieldConfig.values && fieldConfig.values.length > 0) {
+        return `"${fieldConfig.values[0]}"`;
+      }
+    }
+    if ("maxLength" in fieldConfig) {
+      return "<<>>";
+    }
+    if ("min" in fieldConfig) {
+      return String(fieldConfig.min || 0);
+    }
+    if ("values" in fieldConfig && fieldConfig.values && fieldConfig.values.length > 0) {
+      return `"${fieldConfig.values[0]}"`;
+    }
+    if ("maxSize" in fieldConfig) {
+      return '[k \\in Keys |-> "v1"]';
+    }
+    return "0";
+  }
+  fieldToConstName(fieldPath) {
+    return fieldPath.replace(/\./g, "_").toUpperCase();
+  }
+  sanitizeFieldName(fieldPath) {
+    return fieldPath.replace(/\./g, "_");
+  }
+  line(content) {
+    if (content === "") {
+      this.lines.push("");
+    } else {
+      const indentation = "  ".repeat(this.indent);
+      this.lines.push(indentation + content);
+    }
+  }
+}
+function generateTLA(config, analysis) {
+  const generator = new TLAGenerator;
+  return generator.generate(config, analysis);
+}
+
+// vendor/verify/src/runner/docker.ts
+var exports_docker = {};
+__export(exports_docker, {
+  DockerRunner: () => DockerRunner
+});
+import { spawn } from "node:child_process";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
+class DockerRunner {
+  containerName = "web-ext-tla-verify";
+  async isDockerAvailable() {
+    try {
+      const result = await this.runCommand("docker", ["--version"]);
+      return result.exitCode === 0;
+    } catch {
+      return false;
+    }
+  }
+  async hasImage() {
+    try {
+      const result = await this.runCommand("docker", ["images", "-q", "talex5/tla"]);
+      return result.stdout.trim().length > 0;
+    } catch {
+      return false;
+    }
+  }
+  async pullImage(onProgress) {
+    await this.runCommandStreaming("docker", ["pull", "talex5/tla:latest"], onProgress);
+  }
+  async runTLC(specPath, options) {
+    if (!fs2.existsSync(specPath)) {
+      throw new Error(`Spec file not found: ${specPath}`);
+    }
+    const specDir = path2.dirname(specPath);
+    const specName = path2.basename(specPath, ".tla");
+    const cfgPath = path2.join(specDir, `${specName}.cfg`);
+    if (!fs2.existsSync(cfgPath)) {
+      throw new Error(`Config file not found: ${cfgPath}`);
+    }
+    const args = [
+      "run",
+      "--rm",
+      "-v",
+      `${specDir}:/specs`,
+      "talex5/tla",
+      "sh",
+      "-c",
+      `cd /specs && tlc -workers ${options?.workers || 1} ${specName}.tla`
+    ];
+    const result = await this.runCommand("docker", args, {
+      timeout: options?.timeout || 60000
+    });
+    return this.parseTLCOutput(result);
+  }
+  parseTLCOutput(result) {
+    const output = result.stdout + result.stderr;
+    const violationMatch = output.match(/Error: Invariant (.*?) is violated/);
+    if (violationMatch) {
+      return {
+        success: false,
+        violation: {
+          type: "invariant",
+          name: violationMatch[1],
+          trace: this.extractTrace(output)
+        },
+        output
+      };
+    }
+    if (result.exitCode !== 0 || output.includes("Error:")) {
+      return {
+        success: false,
+        error: this.extractError(output),
+        output
+      };
+    }
+    const statesMatch = output.match(/(\d+) states generated/);
+    const distinctMatch = output.match(/(\d+) distinct states/);
+    return {
+      success: true,
+      stats: {
+        statesGenerated: statesMatch ? Number.parseInt(statesMatch[1]) : 0,
+        distinctStates: distinctMatch ? Number.parseInt(distinctMatch[1]) : 0
+      },
+      output
+    };
+  }
+  extractTrace(output) {
+    const lines = output.split(`
+`);
+    const trace = [];
+    let inTrace = false;
+    for (const line of lines) {
+      if (line.includes("State ") && line.includes(":")) {
+        inTrace = true;
+        trace.push(line);
+      } else if (inTrace) {
+        if (line.trim() === "" || line.startsWith("Error:")) {
+          break;
+        }
+        trace.push(line);
+      }
+    }
+    return trace;
+  }
+  extractError(output) {
+    const errorMatch = output.match(/Error: (.*?)(?:\n|$)/);
+    if (errorMatch) {
+      return errorMatch[1];
+    }
+    if (output.includes("Parse Error")) {
+      return "TLA+ syntax error in specification";
+    }
+    if (output.includes("Semantic Error")) {
+      return "Semantic error in specification";
+    }
+    return "Unknown error occurred during model checking";
+  }
+  runCommand(command, args, options) {
+    return new Promise((resolve2, reject) => {
+      const proc = spawn(command, args);
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      const timeout = options?.timeout ? setTimeout(() => {
+        proc.kill();
+        reject(new Error(`Command timed out after ${options.timeout}ms`));
+      }, options.timeout) : null;
+      proc.on("close", (exitCode) => {
+        if (timeout)
+          clearTimeout(timeout);
+        resolve2({
+          exitCode: exitCode || 0,
+          stdout,
+          stderr
+        });
+      });
+      proc.on("error", (error) => {
+        if (timeout)
+          clearTimeout(timeout);
+        reject(error);
+      });
+    });
+  }
+  runCommandStreaming(command, args, onOutput) {
+    return new Promise((resolve2, reject) => {
+      const proc = spawn(command, args);
+      proc.stdout.on("data", (data) => {
+        if (onOutput) {
+          const lines = data.toString().split(`
+`);
+          for (const line of lines) {
+            if (line.trim()) {
+              onOutput(line.trim());
+            }
+          }
+        }
+      });
+      proc.stderr.on("data", (data) => {
+        if (onOutput) {
+          const lines = data.toString().split(`
+`);
+          for (const line of lines) {
+            if (line.trim()) {
+              onOutput(line.trim());
+            }
+          }
+        }
+      });
+      proc.on("close", (exitCode) => {
+        if (exitCode === 0) {
+          resolve2();
+        } else {
+          reject(new Error(`Command failed with exit code ${exitCode}`));
+        }
+      });
+      proc.on("error", reject);
+    });
+  }
+}
+var init_docker = () => {};
+
+// vendor/verify/src/cli.ts
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+
+// vendor/analysis/src/extract/types.ts
+import { Project as Project2 } from "ts-morph";
+
+// vendor/analysis/src/extract/handlers.ts
+import { Project, SyntaxKind, Node } from "ts-morph";
+
+class HandlerExtractor {
+  project;
+  constructor(tsConfigPath) {
+    this.project = new Project({
+      tsConfigFilePath: tsConfigPath
+    });
+  }
+  extractHandlers() {
+    const handlers = [];
+    const messageTypes = new Set;
+    const sourceFiles = this.project.getSourceFiles();
+    for (const sourceFile of sourceFiles) {
+      const fileHandlers = this.extractFromFile(sourceFile);
+      handlers.push(...fileHandlers);
+      for (const handler of fileHandlers) {
+        messageTypes.add(handler.messageType);
+      }
+    }
+    return {
+      handlers,
+      messageTypes
+    };
+  }
+  extractFromFile(sourceFile) {
+    const handlers = [];
+    const filePath = sourceFile.getFilePath();
+    const context = this.inferContext(filePath);
+    sourceFile.forEachDescendant((node) => {
+      if (Node.isCallExpression(node)) {
+        const expression = node.getExpression();
+        if (Node.isPropertyAccessExpression(expression)) {
+          const methodName = expression.getName();
+          if (methodName === "on") {
+            const handler = this.extractHandler(node, context, filePath);
+            if (handler) {
+              handlers.push(handler);
+            }
+          }
+        }
+      }
+    });
+    return handlers;
+  }
+  extractHandler(callExpr, context, filePath) {
+    const args = callExpr.getArguments();
+    if (args.length < 2) {
+      return null;
+    }
+    const messageTypeArg = args[0];
+    let messageType = null;
+    if (Node.isStringLiteral(messageTypeArg)) {
+      messageType = messageTypeArg.getLiteralValue();
+    } else if (Node.isTemplateExpression(messageTypeArg)) {
+      messageType = messageTypeArg.getText().replace(/[`'"]/g, "");
+    }
+    if (!messageType) {
+      return null;
+    }
+    const handlerArg = args[1];
+    const assignments = [];
+    const preconditions = [];
+    const postconditions = [];
+    if (Node.isArrowFunction(handlerArg) || Node.isFunctionExpression(handlerArg)) {
+      this.extractAssignments(handlerArg, assignments);
+      this.extractVerificationConditions(handlerArg, preconditions, postconditions);
+    }
+    const line = callExpr.getStartLineNumber();
+    return {
+      messageType,
+      node: context,
+      assignments,
+      preconditions,
+      postconditions,
+      location: {
+        file: filePath,
+        line
+      }
+    };
+  }
+  extractAssignments(funcNode, assignments) {
+    funcNode.forEachDescendant((node) => {
+      if (Node.isBinaryExpression(node)) {
+        const operator = node.getOperatorToken().getText();
+        if (operator === "=") {
+          const left = node.getLeft();
+          const right = node.getRight();
+          if (Node.isPropertyAccessExpression(left)) {
+            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
+                });
+              }
+            }
+          }
+        }
+      }
+    });
+  }
+  extractVerificationConditions(funcNode, preconditions, postconditions) {
+    const body = funcNode.getBody();
+    const statements = Node.isBlock(body) ? body.getStatements() : [body];
+    statements.forEach((statement, index) => {
+      if (Node.isExpressionStatement(statement)) {
+        const expr = statement.getExpression();
+        if (Node.isCallExpression(expr)) {
+          const callee = expr.getExpression();
+          if (Node.isIdentifier(callee)) {
+            const functionName = callee.getText();
+            if (functionName === "requires") {
+              const condition = this.extractCondition(expr);
+              if (condition) {
+                preconditions.push(condition);
+              }
+            } else if (functionName === "ensures") {
+              const condition = this.extractCondition(expr);
+              if (condition) {
+                postconditions.push(condition);
+              }
+            }
+          }
+        }
+      }
+    });
+  }
+  extractCondition(callExpr) {
+    const args = callExpr.getArguments();
+    if (args.length === 0) {
+      return null;
+    }
+    const conditionArg = args[0];
+    const expression = conditionArg.getText();
+    let message;
+    if (args.length >= 2 && Node.isStringLiteral(args[1])) {
+      message = args[1].getLiteralValue();
+    }
+    const line = callExpr.getStartLineNumber();
+    const column = callExpr.getStartLinePos();
+    return {
+      expression,
+      message,
+      location: {
+        line,
+        column
+      }
+    };
+  }
+  getPropertyPath(node) {
+    const parts = [];
+    let current = node;
+    while (Node.isPropertyAccessExpression(current)) {
+      parts.unshift(current.getName());
+      current = current.getExpression();
+    }
+    if (Node.isIdentifier(current)) {
+      parts.unshift(current.getText());
+    }
+    return parts.join(".");
+  }
+  extractValue(node) {
+    if (Node.isStringLiteral(node)) {
+      return node.getLiteralValue();
+    }
+    if (Node.isNumericLiteral(node)) {
+      return node.getLiteralValue();
+    }
+    if (node.getKind() === SyntaxKind.TrueKeyword) {
+      return true;
+    }
+    if (node.getKind() === SyntaxKind.FalseKeyword) {
+      return false;
+    }
+    if (node.getKind() === SyntaxKind.NullKeyword) {
+      return null;
+    }
+    return;
+  }
+  inferContext(filePath) {
+    const path = filePath.toLowerCase();
+    if (path.includes("/background/") || path.includes("\\background\\")) {
+      return "background";
+    }
+    if (path.includes("/content/") || path.includes("\\content\\")) {
+      return "content";
+    }
+    if (path.includes("/popup/") || path.includes("\\popup\\")) {
+      return "popup";
+    }
+    if (path.includes("/devtools/") || path.includes("\\devtools\\")) {
+      return "devtools";
+    }
+    if (path.includes("/options/") || path.includes("\\options\\")) {
+      return "options";
+    }
+    if (path.includes("/offscreen/") || path.includes("\\offscreen\\")) {
+      return "offscreen";
+    }
+    return "unknown";
+  }
+}
+
+// vendor/analysis/src/extract/types.ts
+class TypeExtractor {
+  project;
+  constructor(tsConfigPath) {
+    this.project = new Project2({
+      tsConfigFilePath: tsConfigPath
+    });
+  }
+  async analyzeCodebase(stateFilePath) {
+    const stateType = stateFilePath ? this.extractStateType(stateFilePath) : this.findStateType();
+    const messageTypes = this.findMessageTypes();
+    const fields = stateType ? this.analyzeFields(stateType) : [];
+    const configFilePath = this.project.getCompilerOptions().configFilePath;
+    const tsConfigPath = typeof configFilePath === "string" ? configFilePath : "tsconfig.json";
+    const handlerExtractor = new HandlerExtractor(tsConfigPath);
+    const handlerAnalysis = handlerExtractor.extractHandlers();
+    return {
+      stateType,
+      messageTypes: Array.from(new Set([...messageTypes, ...handlerAnalysis.messageTypes])),
+      fields,
+      handlers: handlerAnalysis.handlers
+    };
+  }
+  extractStateType(filePath) {
+    const sourceFile = this.project.getSourceFile(filePath);
+    if (!sourceFile) {
+      return null;
+    }
+    const typeAlias = sourceFile.getTypeAlias("AppState") || sourceFile.getTypeAlias("State") || sourceFile.getTypeAliases()[0];
+    if (!typeAlias) {
+      return null;
+    }
+    const type = typeAlias.getType();
+    return this.convertType(type, typeAlias.getName());
+  }
+  findStateType() {
+    const stateFiles = this.project.getSourceFiles("**/state*.ts");
+    for (const file of stateFiles) {
+      const typeAlias = file.getTypeAlias("AppState") || file.getTypeAlias("State");
+      if (typeAlias) {
+        const type = typeAlias.getType();
+        return this.convertType(type, typeAlias.getName());
+      }
+    }
+    return null;
+  }
+  findMessageTypes() {
+    const messageTypes = [];
+    const messageFiles = this.project.getSourceFiles("**/message*.ts");
+    for (const file of messageFiles) {
+      for (const typeAlias of file.getTypeAliases()) {
+        const type = typeAlias.getType();
+        if (type.isUnion()) {
+          for (const unionType of type.getUnionTypes()) {
+            if (unionType.isObject()) {
+              const typeProperty = unionType.getProperty("type");
+              if (typeProperty) {
+                const typeType = typeProperty.getTypeAtLocation(file);
+                if (typeType.isStringLiteral()) {
+                  messageTypes.push(typeType.getLiteralValue());
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    return [...new Set(messageTypes)];
+  }
+  convertType(type, name) {
+    const nullable = type.isNullable();
+    if (type.isBoolean() || type.isBooleanLiteral()) {
+      return { name, kind: "boolean", nullable };
+    }
+    if (type.isUnion()) {
+      const unionTypes = type.getUnionTypes();
+      const allStringLiterals = unionTypes.every((t) => t.isStringLiteral());
+      if (allStringLiterals) {
+        const enumValues = unionTypes.map((t) => t.getLiteralValue());
+        return {
+          name,
+          kind: "enum",
+          nullable,
+          enumValues
+        };
+      }
+      const nonNullTypes = unionTypes.filter((t) => !t.isNull() && !t.isUndefined());
+      if (nonNullTypes.length === 1) {
+        const baseType = this.convertType(nonNullTypes[0], name);
+        return {
+          ...baseType,
+          nullable: true
+        };
+      }
+      return {
+        name,
+        kind: "union",
+        nullable,
+        unionTypes: unionTypes.map((t, i) => this.convertType(t, `${name}_${i}`))
+      };
+    }
+    if (type.isString() || type.isStringLiteral()) {
+      return { name, kind: "string", nullable };
+    }
+    if (type.isNumber() || type.isNumberLiteral()) {
+      return { name, kind: "number", nullable };
+    }
+    if (type.isArray()) {
+      const elementType = type.getArrayElementType();
+      return {
+        name,
+        kind: "array",
+        nullable,
+        elementType: elementType ? this.convertType(elementType, `${name}_element`) : { name: "unknown", kind: "unknown", nullable: false }
+      };
+    }
+    const symbol = type.getSymbol();
+    if (symbol) {
+      const symbolName = symbol.getName();
+      if (symbolName === "Map") {
+        const typeArgs = type.getTypeArguments();
+        return {
+          name,
+          kind: "map",
+          nullable,
+          valueType: typeArgs && typeArgs[1] ? this.convertType(typeArgs[1], `${name}_value`) : undefined
+        };
+      }
+      if (symbolName === "Set") {
+        const typeArgs = type.getTypeArguments();
+        return {
+          name,
+          kind: "set",
+          nullable,
+          elementType: typeArgs && typeArgs[0] ? this.convertType(typeArgs[0], `${name}_element`) : undefined
+        };
+      }
+    }
+    if (type.isObject()) {
+      const properties = {};
+      for (const prop of type.getProperties()) {
+        const propName = prop.getName();
+        const propType = prop.getTypeAtLocation(this.project.getSourceFiles()[0]);
+        properties[propName] = this.convertType(propType, propName);
+      }
+      return {
+        name,
+        kind: "object",
+        nullable,
+        properties
+      };
+    }
+    if (type.isNull()) {
+      return { name, kind: "null", nullable: true };
+    }
+    return { name, kind: "unknown", nullable };
+  }
+  analyzeFields(stateType, prefix = "") {
+    const fields = [];
+    if (stateType.kind === "object" && stateType.properties) {
+      for (const [key, propType] of Object.entries(stateType.properties)) {
+        const path = prefix ? `${prefix}.${key}` : key;
+        if (propType.kind === "object") {
+          fields.push(...this.analyzeFields(propType, path));
+        } else {
+          const analysis = this.analyzeField(path, propType);
+          fields.push(analysis);
+        }
+      }
+    }
+    return fields;
+  }
+  analyzeField(path, type) {
+    const analysis = {
+      path,
+      type,
+      confidence: "low",
+      evidence: [],
+      suggestions: [],
+      bounds: {}
+    };
+    if (type.kind === "boolean") {
+      analysis.confidence = "high";
+      analysis.evidence.push("Boolean type - auto-configured");
+      return analysis;
+    }
+    if (type.kind === "enum" && type.enumValues) {
+      analysis.confidence = "high";
+      analysis.evidence.push(`Enum with ${type.enumValues.length} values`);
+      analysis.bounds.values = type.enumValues;
+      return analysis;
+    }
+    if (type.kind === "array") {
+      analysis.confidence = "low";
+      analysis.suggestions.push("Choose maxLength: 5 (fast), 10 (balanced), or 20 (thorough)");
+      analysis.bounds.maxLength = undefined;
+      const foundBound = this.findArrayBound(path);
+      if (foundBound) {
+        analysis.confidence = "medium";
+        analysis.evidence.push(`Found array check: ${foundBound.evidence}`);
+        analysis.bounds.maxLength = foundBound.value;
+      }
+      return analysis;
+    }
+    if (type.kind === "number") {
+      analysis.confidence = "low";
+      analysis.suggestions.push("Provide min and max values based on your application logic");
+      analysis.bounds.min = undefined;
+      analysis.bounds.max = undefined;
+      const foundBound = this.findNumberBound(path);
+      if (foundBound) {
+        analysis.confidence = "high";
+        analysis.evidence.push(`Found comparison: ${foundBound.evidence}`);
+        analysis.bounds = { ...analysis.bounds, ...foundBound.bounds };
+      }
+      return analysis;
+    }
+    if (type.kind === "string") {
+      analysis.confidence = "low";
+      analysis.suggestions.push('Provide 2-3 example values: ["value1", "value2", "value3"]', "Or use { abstract: true } for symbolic verification");
+      analysis.bounds.values = undefined;
+      return analysis;
+    }
+    if (type.kind === "map" || type.kind === "set") {
+      analysis.confidence = "low";
+      analysis.suggestions.push("Provide maxSize (recommended: 3-5)");
+      analysis.bounds.maxSize = undefined;
+      return analysis;
+    }
+    return analysis;
+  }
+  findArrayBound(path) {
+    return null;
+  }
+  findNumberBound(path) {
+    return null;
+  }
+}
+async function analyzeCodebase(options) {
+  const extractor = new TypeExtractor(options.tsConfigPath);
+  return extractor.analyzeCodebase(options.stateFilePath);
+}
+
+// vendor/verify/src/codegen/config.ts
+class ConfigGenerator {
+  lines = [];
+  indent = 0;
+  generate(analysis) {
+    this.lines = [];
+    this.indent = 0;
+    this.addHeader();
+    this.addImports();
+    this.addExport();
+    this.addStateConfig(analysis.fields);
+    this.addMessagesConfig();
+    this.addBehaviorConfig();
+    this.closeExport();
+    return this.lines.join(`
+`);
+  }
+  addHeader() {
+    this.line("// ═══════════════════════════════════════════════════════════════");
+    this.line("// Verification Configuration");
+    this.line("// ═══════════════════════════════════════════════════════════════");
+    this.line("//");
+    this.line("// This file configures TLA+ verification for your extension.");
+    this.line("// Some values are auto-configured, others need your input.");
+    this.line("//");
+    this.line("// Look for:");
+    this.line("//   • /* CONFIGURE */ - Replace with your value");
+    this.line("//   • /* REVIEW */ - Check the auto-generated value");
+    this.line("//   • null - Must be replaced with a concrete value");
+    this.line("//");
+    this.line("// Run 'bun verify' to check for incomplete configuration.");
+    this.line("// Run 'bun verify --setup' for interactive help.");
+    this.line("//");
+    this.line("");
+  }
+  addImports() {
+    this.line("import { defineVerification } from '@fairfox/polly/verify'");
+    this.line("");
+  }
+  addExport() {
+    this.line("export default defineVerification({");
+    this.indent++;
+  }
+  closeExport() {
+    this.indent--;
+    this.line("})");
+  }
+  addStateConfig(fields) {
+    this.line("state: {");
+    this.indent++;
+    for (let i = 0;i < fields.length; i++) {
+      const field = fields[i];
+      if (i > 0) {
+        this.line("");
+      }
+      this.addFieldConfig(field);
+    }
+    this.indent--;
+    this.line("},");
+    this.line("");
+  }
+  addFieldConfig(field) {
+    this.addFieldComment(field);
+    const config = this.generateFieldConfig(field);
+    this.line(`"${field.path}": ${config},`);
+  }
+  addFieldComment(field) {
+    const separator = "─".repeat(60);
+    this.line(`// ${separator}`);
+    this.line(`// ${field.path}: ${this.formatTypeName(field.type)}`);
+    this.line(`// ${separator}`);
+    if (field.confidence === "high") {
+      this.line("// ✓ Auto-configured from code analysis");
+      if (field.evidence.length > 0) {
+        for (const evidence of field.evidence) {
+          this.line(`//   ${evidence}`);
+        }
+      }
+      this.line("//");
+      return;
+    }
+    if (field.confidence === "medium") {
+      this.line("// ⚠️  Please review this auto-generated value");
+      if (field.evidence.length > 0) {
+        for (const evidence of field.evidence) {
+          this.line(`//   Found: ${evidence}`);
+        }
+      }
+      this.line("//");
+      this.line("// REVIEW: Adjust if needed");
+      this.line("//");
+      return;
+    }
+    this.line("// ⚠️  Manual configuration required");
+    this.line("//");
+    this.addTypeGuidance(field);
+    if (field.suggestions.length > 0) {
+      this.line("//");
+      for (const suggestion of field.suggestions) {
+        this.line(`// ${suggestion}`);
+      }
+    }
+    this.line("//");
+    this.line("// CONFIGURE: Fill in the value below");
+    this.line("//");
+  }
+  addTypeGuidance(field) {
+    switch (field.type.kind) {
+      case "array":
+        this.line("// This array has no bounds in your code. Choose a maximum");
+        this.line("// length for verification. Tradeoffs:");
+        this.line("//   • Small (3-5): Fast, catches basic bugs");
+        this.line("//   • Medium (10-15): Balanced, catches most bugs");
+        this.line("//   • Large (20+): Thorough, much slower");
+        break;
+      case "string":
+        this.line("// Strings need concrete values for precise verification.");
+        this.line("// Provide 2-3 representative values from your app.");
+        if (field.type.nullable) {
+          this.line("//");
+          this.line("// Note: This field is nullable (can be null)");
+        }
+        this.line("//");
+        this.line("// Examples:");
+        this.line('//   ["user_abc123", "user_xyz789", "guest_000"]');
+        this.line('//   ["active", "inactive", "pending"]');
+        this.line("//");
+        this.line("// Alternative: Use abstract verification (less precise, faster)");
+        this.line("//   { abstract: true }");
+        break;
+      case "number":
+        this.line("// Numbers need a range. Choose min and max values based on");
+        this.line("// realistic bounds in your application.");
+        if (field.type.nullable) {
+          this.line("//");
+          this.line("// Note: This field is nullable (can be null)");
+        }
+        this.line("//");
+        this.line("// Examples:");
+        this.line("//   { min: 0, max: 100 }  // Counter");
+        this.line("//   { min: 0, max: 999999 }  // Timestamp");
+        break;
+      case "map":
+      case "set":
+        this.line(`// ${field.type.kind} needs a maximum size. How many entries`);
+        this.line("// do you need to model to catch bugs?");
+        this.line("//");
+        this.line("// Recommended: 3-5 for most cases");
+        break;
+      case "object":
+        this.line("// Complex nested object. Configure each field separately.");
+        break;
+      default:
+        this.line(`// ${field.type.kind} type requires configuration.`);
+    }
+  }
+  generateFieldConfig(field) {
+    switch (field.type.kind) {
+      case "boolean":
+        return "{ type: 'boolean' }";
+      case "enum":
+        if (field.type.enumValues) {
+          const values = field.type.enumValues.map((v) => `"${v}"`).join(", ");
+          return `{ type: "enum", values: [${values}] }`;
+        }
+        return "{ type: 'enum', values: /* CONFIGURE */ null }";
+      case "array":
+        if (field.bounds?.maxLength !== undefined && field.bounds.maxLength !== null) {
+          if (field.confidence === "medium") {
+            return `{ maxLength: /* REVIEW */ ${field.bounds.maxLength} }`;
+          }
+          return `{ maxLength: ${field.bounds.maxLength} }`;
+        }
+        return "{ maxLength: /* CONFIGURE */ null }";
+      case "number":
+        if (field.bounds?.min !== undefined && field.bounds?.max !== undefined) {
+          const minStr = field.bounds.min !== null ? field.bounds.min : "/* CONFIGURE */";
+          const maxStr = field.bounds.max !== null ? field.bounds.max : "/* CONFIGURE */";
+          if (field.confidence === "high") {
+            return `{ min: ${minStr}, max: ${maxStr} }`;
+          }
+          return `{ min: /* REVIEW */ ${minStr}, max: /* REVIEW */ ${maxStr} }`;
+        }
+        return "{ min: /* CONFIGURE */ null, max: /* CONFIGURE */ null }";
+      case "string":
+        return "{ values: /* CONFIGURE */ null }";
+      case "map":
+      case "set":
+        return "{ maxSize: /* CONFIGURE */ null }";
+      default:
+        return "{ /* CONFIGURE */ }";
+    }
+  }
+  addMessagesConfig() {
+    this.line("messages: {");
+    this.indent++;
+    this.line("// Maximum messages in flight simultaneously across all contexts.");
+    this.line("// Higher = more realistic concurrency, but exponentially slower.");
+    this.line("//");
+    this.line("// Recommended values:");
+    this.line("//   • 2-3: Fast verification (< 10 seconds)");
+    this.line("//   • 4-6: Balanced (10-60 seconds)");
+    this.line("//   • 8+: Thorough but slow (minutes)");
+    this.line("//");
+    this.line("// WARNING: State space grows exponentially! Start small.");
+    this.line("maxInFlight: 3,");
+    this.line("");
+    this.line("// Maximum tab IDs to model (content scripts are per-tab).");
+    this.line("//");
+    this.line("// Recommended:");
+    this.line("//   • 0-1: Most extensions (single tab or tab-agnostic)");
+    this.line("//   • 2-3: Multi-tab coordination");
+    this.line("//");
+    this.line("// Start with 0 or 1 for faster verification.");
+    this.line("maxTabs: 1,");
+    this.indent--;
+    this.line("},");
+    this.line("");
+  }
+  addBehaviorConfig() {
+    this.line("// Verification behavior");
+    this.line("// ─────────────────────");
+    this.line("//");
+    this.line("// onBuild: What to do during development builds");
+    this.line("//   • 'warn' - Show warnings but don't fail (recommended)");
+    this.line("//   • 'error' - Fail the build on violations");
+    this.line("//   • 'off' - Skip verification");
+    this.line("//");
+    this.line("onBuild: 'warn',");
+    this.line("");
+    this.line("// onRelease: What to do during production builds");
+    this.line("//   • 'error' - Fail the build on violations (recommended)");
+    this.line("//   • 'warn' - Show warnings but don't fail");
+    this.line("//   • 'off' - Skip verification");
+    this.line("//");
+    this.line("onRelease: 'error',");
+  }
+  formatTypeName(type) {
+    let typeName;
+    switch (type.kind) {
+      case "boolean":
+        typeName = "boolean";
+        break;
+      case "string":
+        typeName = "string";
+        break;
+      case "number":
+        typeName = "number";
+        break;
+      case "enum":
+        if (type.enumValues) {
+          typeName = type.enumValues.map((v) => `"${v}"`).join(" | ");
+        } else {
+          typeName = "enum";
+        }
+        break;
+      case "array":
+        if (type.elementType) {
+          typeName = `${this.formatTypeName(type.elementType)}[]`;
+        } else {
+          typeName = "array";
+        }
+        break;
+      case "object":
+        typeName = "object";
+        break;
+      case "map":
+        typeName = "Map";
+        break;
+      case "set":
+        typeName = "Set";
+        break;
+      case "null":
+        typeName = "null";
+        break;
+      default:
+        typeName = "unknown";
+    }
+    if (type.nullable && type.kind !== "null") {
+      typeName += " | null";
+    }
+    return typeName;
+  }
+  line(content) {
+    if (content === "") {
+      this.lines.push("");
+    } else {
+      const indentation = "  ".repeat(this.indent);
+      this.lines.push(indentation + content);
+    }
+  }
+}
+function generateConfig(analysis) {
+  const generator = new ConfigGenerator;
+  return generator.generate(analysis);
+}
+
+// vendor/verify/src/config/parser.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+class ConfigValidator {
+  issues = [];
+  validate(configPath) {
+    this.issues = [];
+    if (!fs.existsSync(configPath)) {
+      this.issues.push({
+        type: "incomplete",
+        severity: "error",
+        message: "Configuration file does not exist",
+        suggestion: "Run 'bun verify --setup' to generate configuration"
+      });
+      return {
+        valid: false,
+        issues: this.issues
+      };
+    }
+    const configSource = fs.readFileSync(configPath, "utf-8");
+    this.checkConfigureMarkers(configSource);
+    this.checkReviewMarkers(configSource);
+    try {
+      const config = this.loadConfig(configPath);
+      this.validateConfig(config);
+    } catch (error) {
+      this.issues.push({
+        type: "invalid_value",
+        severity: "error",
+        message: `Failed to load configuration: ${error instanceof Error ? error.message : String(error)}`,
+        suggestion: "Check for syntax errors in the configuration file"
+      });
+    }
+    const hasErrors = this.issues.some((i) => i.severity === "error");
+    return {
+      valid: !hasErrors,
+      issues: this.issues
+    };
+  }
+  checkConfigureMarkers(source) {
+    const configureRegex = /\/\*\s*CONFIGURE\s*\*\//g;
+    const matches = [...source.matchAll(configureRegex)];
+    if (matches.length > 0) {
+      const lines = source.split(`
+`);
+      const locations = [];
+      for (const match of matches) {
+        const position = match.index;
+        const lineNumber = source.substring(0, position).split(`
+`).length;
+        const line = lines[lineNumber - 1];
+        const fieldMatch = line.match(/"([^"]+)":\s*{/);
+        const fieldName = fieldMatch ? fieldMatch[1] : "unknown";
+        locations.push({
+          line: lineNumber,
+          column: match.index - source.lastIndexOf(`
+`, position),
+          context: fieldName
+        });
+      }
+      this.issues.push({
+        type: "incomplete",
+        severity: "error",
+        message: `Found ${matches.length} incomplete configuration marker(s)`,
+        suggestion: "Replace all /* CONFIGURE */ markers with actual values"
+      });
+      for (const loc of locations) {
+        this.issues.push({
+          type: "incomplete",
+          severity: "error",
+          field: loc.context,
+          location: { line: loc.line, column: loc.column },
+          message: `Incomplete configuration at line ${loc.line}`,
+          suggestion: `Fill in value for "${loc.context}"`
+        });
+      }
+    }
+  }
+  checkReviewMarkers(source) {
+    const reviewRegex = /\/\*\s*REVIEW\s*\*\//g;
+    const matches = [...source.matchAll(reviewRegex)];
+    if (matches.length > 0) {
+      this.issues.push({
+        type: "incomplete",
+        severity: "warning",
+        message: `Found ${matches.length} value(s) that should be reviewed`,
+        suggestion: "Review auto-generated values marked with /* REVIEW */"
+      });
+    }
+  }
+  loadConfig(configPath) {
+    delete __require.cache[__require.resolve(path.resolve(configPath))];
+    const module = __require(path.resolve(configPath));
+    return module.default || module;
+  }
+  validateConfig(config) {
+    this.findNullPlaceholders(config.state, "state");
+    this.findNullPlaceholders(config.messages, "messages");
+    this.validateBounds(config);
+  }
+  findNullPlaceholders(obj, path2) {
+    if (obj === null || obj === undefined) {
+      this.issues.push({
+        type: "null_placeholder",
+        severity: "error",
+        field: path2,
+        message: `Configuration incomplete: ${path2}`,
+        suggestion: "Replace null with a concrete value"
+      });
+      return;
+    }
+    if (typeof obj !== "object") {
+      return;
+    }
+    for (const [key, value] of Object.entries(obj)) {
+      const fullPath = `${path2}.${key}`;
+      if (value === null) {
+        this.issues.push({
+          type: "null_placeholder",
+          severity: "error",
+          field: fullPath,
+          message: `Configuration incomplete: ${fullPath}`,
+          suggestion: "Replace null with a concrete value"
+        });
+      } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        this.findNullPlaceholders(value, fullPath);
+      }
+    }
+  }
+  validateBounds(config) {
+    if (config.messages.maxInFlight !== null) {
+      if (config.messages.maxInFlight < 1) {
+        this.issues.push({
+          type: "invalid_value",
+          severity: "error",
+          field: "messages.maxInFlight",
+          message: "maxInFlight must be at least 1",
+          suggestion: "Use a value between 4-10 for most cases"
+        });
+      }
+      if (config.messages.maxInFlight > 20) {
+        this.issues.push({
+          type: "unrealistic_bound",
+          severity: "warning",
+          field: "messages.maxInFlight",
+          message: "Very high maxInFlight (>20) will slow verification significantly",
+          suggestion: "Use 4-10 for development, up to 20 for thorough verification"
+        });
+      }
+    }
+    if (config.messages.maxTabs !== null) {
+      if (config.messages.maxTabs < 1) {
+        this.issues.push({
+          type: "invalid_value",
+          severity: "error",
+          field: "messages.maxTabs",
+          message: "maxTabs must be at least 1",
+          suggestion: "Use 2-3 for most cases"
+        });
+      }
+      if (config.messages.maxTabs > 10) {
+        this.issues.push({
+          type: "unrealistic_bound",
+          severity: "warning",
+          field: "messages.maxTabs",
+          message: "Very high maxTabs (>10) will slow verification significantly",
+          suggestion: "Use 2-3 for most cases"
+        });
+      }
+    }
+    for (const [fieldName, fieldConfig] of Object.entries(config.state)) {
+      if (typeof fieldConfig !== "object" || fieldConfig === null) {
+        continue;
+      }
+      if ("maxLength" in fieldConfig) {
+        const maxLength = fieldConfig.maxLength;
+        if (maxLength !== null) {
+          if (maxLength < 0) {
+            this.issues.push({
+              type: "invalid_value",
+              severity: "error",
+              field: `state.${fieldName}.maxLength`,
+              message: "maxLength cannot be negative",
+              suggestion: "Use a positive number"
+            });
+          }
+          if (maxLength > 50) {
+            this.issues.push({
+              type: "unrealistic_bound",
+              severity: "warning",
+              field: `state.${fieldName}.maxLength`,
+              message: `Very large maxLength (${maxLength}) will slow verification`,
+              suggestion: "Use 10-20 for most cases"
+            });
+          }
+        }
+      }
+      if ("min" in fieldConfig && "max" in fieldConfig) {
+        const min = fieldConfig.min;
+        const max = fieldConfig.max;
+        if (min !== null && max !== null && min > max) {
+          this.issues.push({
+            type: "invalid_value",
+            severity: "error",
+            field: `state.${fieldName}`,
+            message: `Invalid range: min (${min}) > max (${max})`,
+            suggestion: "Ensure min is less than or equal to max"
+          });
+        }
+        if (min !== null && max !== null && max - min > 1000) {
+          this.issues.push({
+            type: "unrealistic_bound",
+            severity: "warning",
+            field: `state.${fieldName}`,
+            message: `Very large number range (${max - min}) will slow verification`,
+            suggestion: "Use smaller ranges when possible"
+          });
+        }
+      }
+      if ("maxSize" in fieldConfig) {
+        const maxSize = fieldConfig.maxSize;
+        if (maxSize !== null) {
+          if (maxSize < 0) {
+            this.issues.push({
+              type: "invalid_value",
+              severity: "error",
+              field: `state.${fieldName}.maxSize`,
+              message: "maxSize cannot be negative",
+              suggestion: "Use a positive number"
+            });
+          }
+          if (maxSize > 20) {
+            this.issues.push({
+              type: "unrealistic_bound",
+              severity: "warning",
+              field: `state.${fieldName}.maxSize`,
+              message: `Very large maxSize (${maxSize}) will slow verification`,
+              suggestion: "Use 3-5 for most cases"
+            });
+          }
+        }
+      }
+    }
+  }
+}
+function validateConfig(configPath) {
+  const validator = new ConfigValidator;
+  return validator.validate(configPath);
+}
+
+// vendor/verify/src/cli.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  gray: "\x1B[90m"
+};
+function color(text, colorCode) {
+  return `${colorCode}${text}${COLORS.reset}`;
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  switch (command) {
+    case "--setup":
+    case "setup":
+      await setupCommand();
+      break;
+    case "--validate":
+    case "validate":
+      await validateCommand();
+      break;
+    case "--help":
+    case "help":
+      showHelp();
+      break;
+    default:
+      await verifyCommand();
+  }
+}
+async function setupCommand() {
+  console.log(color(`
+\uD83D\uDD0D Analyzing codebase...
+`, COLORS.blue));
+  try {
+    const tsConfigPath = findTsConfig();
+    if (!tsConfigPath) {
+      console.error(color("❌ Could not find tsconfig.json", COLORS.red));
+      console.error("   Run this command from your project root");
+      process.exit(1);
+    }
+    console.log(color(`   Using: ${tsConfigPath}`, COLORS.gray));
+    const analysis = await analyzeCodebase({
+      tsConfigPath,
+      stateFilePath: findStateFile()
+    });
+    if (!analysis.stateType) {
+      console.log(color(`
+⚠️  Could not find state type definition`, COLORS.yellow));
+      console.log("   Expected to find a type named 'AppState' or 'State'");
+      console.log("   in a file matching **/state*.ts");
+      console.log();
+      console.log("   You can still generate a config template:");
+      console.log("   It will be empty and you'll need to fill it in manually.");
+      console.log();
+    } else {
+      console.log(color(`✓ Found state type with ${analysis.fields.length} field(s)`, COLORS.green));
+    }
+    console.log(color(`✓ Found ${analysis.messageTypes.length} message type(s)`, COLORS.green));
+    if (analysis.fields.length > 0) {
+      console.log(color(`
+\uD83D\uDCCA Configuration Summary:
+`, COLORS.blue));
+      const table = [
+        ["Field", "Type", "Status"],
+        ["─".repeat(30), "─".repeat(20), "─".repeat(20)]
+      ];
+      for (const field of analysis.fields) {
+        const status = field.confidence === "high" ? color("✓ Auto-configured", COLORS.green) : field.confidence === "medium" ? color("⚠ Review needed", COLORS.yellow) : color("⚠ Manual config", COLORS.red);
+        table.push([field.path, field.type.kind, status]);
+      }
+      for (const row of table) {
+        console.log(`   ${row[0].padEnd(32)} ${row[1].padEnd(22)} ${row[2]}`);
+      }
+    }
+    const configContent = generateConfig(analysis);
+    const configPath = path3.join(process.cwd(), "specs", "verification.config.ts");
+    const configDir = path3.dirname(configPath);
+    if (!fs3.existsSync(configDir)) {
+      fs3.mkdirSync(configDir, { recursive: true });
+    }
+    fs3.writeFileSync(configPath, configContent, "utf-8");
+    console.log(color(`
+✅ Configuration generated!
+`, COLORS.green));
+    console.log(`   File: ${color(configPath, COLORS.blue)}`);
+    console.log();
+    console.log(color("\uD83D\uDCDD Next steps:", COLORS.blue));
+    console.log();
+    console.log("   1. Review the generated configuration file");
+    console.log("   2. Fill in values marked with /* CONFIGURE */");
+    console.log("   3. Run 'bun verify' to check your configuration");
+    console.log();
+    console.log(color("\uD83D\uDCA1 Tip:", COLORS.gray));
+    console.log(color("   Look for comments explaining what each field needs.", COLORS.gray));
+    console.log();
+  } catch (error) {
+    console.error(color(`
+❌ Setup failed:`, COLORS.red));
+    console.error(`   ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+async function validateCommand() {
+  const configPath = path3.join(process.cwd(), "specs", "verification.config.ts");
+  console.log(color(`
+\uD83D\uDD0D Validating configuration...
+`, COLORS.blue));
+  const result = validateConfig(configPath);
+  if (result.valid) {
+    console.log(color(`✅ Configuration is complete and valid!
+`, COLORS.green));
+    console.log("   You can now run 'bun verify' to start verification.");
+    console.log();
+    return;
+  }
+  const errors = result.issues.filter((i) => i.severity === "error");
+  const warnings = result.issues.filter((i) => i.severity === "warning");
+  if (errors.length > 0) {
+    console.log(color(`❌ Found ${errors.length} error(s):
+`, COLORS.red));
+    for (const error of errors) {
+      console.log(color(`   • ${error.message}`, COLORS.red));
+      if (error.field) {
+        console.log(color(`     Field: ${error.field}`, COLORS.gray));
+      }
+      if (error.location) {
+        console.log(color(`     Location: line ${error.location.line}`, COLORS.gray));
+      }
+      console.log(color(`     → ${error.suggestion}`, COLORS.yellow));
+      console.log();
+    }
+  }
+  if (warnings.length > 0) {
+    console.log(color(`⚠️  Found ${warnings.length} warning(s):
+`, COLORS.yellow));
+    for (const warning of warnings) {
+      console.log(color(`   • ${warning.message}`, COLORS.yellow));
+      if (warning.field) {
+        console.log(color(`     Field: ${warning.field}`, COLORS.gray));
+      }
+      console.log(color(`     → ${warning.suggestion}`, COLORS.gray));
+      console.log();
+    }
+  }
+  console.log(color(`Configuration incomplete. Please fix the errors above.
+`, COLORS.red));
+  process.exit(1);
+}
+async function verifyCommand() {
+  const configPath = path3.join(process.cwd(), "specs", "verification.config.ts");
+  console.log(color(`
+\uD83D\uDD0D Running verification...
+`, COLORS.blue));
+  const validation = validateConfig(configPath);
+  if (!validation.valid) {
+    const errors = validation.issues.filter((i) => i.severity === "error");
+    console.log(color(`❌ Configuration incomplete (${errors.length} error(s))
+`, COLORS.red));
+    for (const error of errors.slice(0, 3)) {
+      console.log(color(`   • ${error.message}`, COLORS.red));
+      if (error.field) {
+        console.log(color(`     Field: ${error.field}`, COLORS.gray));
+      }
+      console.log();
+    }
+    if (errors.length > 3) {
+      console.log(color(`   ... and ${errors.length - 3} more error(s)`, COLORS.gray));
+      console.log();
+    }
+    console.log("   Run 'bun verify --validate' to see all issues");
+    console.log("   Run 'bun verify --setup' to regenerate configuration");
+    console.log();
+    process.exit(1);
+  }
+  console.log(color("✓ Configuration valid", COLORS.green));
+  console.log();
+  try {
+    await runFullVerification(configPath);
+  } catch (error) {
+    console.error(color(`
+❌ Verification failed:`, COLORS.red));
+    console.error(`   ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+async function runFullVerification(configPath) {
+  const { generateTLA: generateTLA2 } = await Promise.resolve().then(() => exports_tla);
+  const { DockerRunner: DockerRunner2 } = await Promise.resolve().then(() => (init_docker(), exports_docker));
+  delete __require.cache[__require.resolve(path3.resolve(configPath))];
+  const configModule = __require(path3.resolve(configPath));
+  const config = configModule.default || configModule;
+  console.log(color("\uD83D\uDCCA Analyzing codebase...", COLORS.blue));
+  const tsConfigPath = findTsConfig();
+  if (!tsConfigPath) {
+    throw new Error("Could not find tsconfig.json");
+  }
+  const analysis = await analyzeCodebase({
+    tsConfigPath,
+    stateFilePath: findStateFile()
+  });
+  console.log(color("✓ Analysis complete", COLORS.green));
+  console.log();
+  console.log(color("\uD83D\uDCDD Generating TLA+ specification...", COLORS.blue));
+  const { spec, cfg } = generateTLA2(config, analysis);
+  const specDir = path3.join(process.cwd(), "specs", "tla", "generated");
+  if (!fs3.existsSync(specDir)) {
+    fs3.mkdirSync(specDir, { recursive: true });
+  }
+  const specPath = path3.join(specDir, "UserApp.tla");
+  const cfgPath = path3.join(specDir, "UserApp.cfg");
+  fs3.writeFileSync(specPath, spec);
+  fs3.writeFileSync(cfgPath, cfg);
+  const baseSpecPath = path3.join(process.cwd(), "specs", "tla", "MessageRouter.tla");
+  if (fs3.existsSync(baseSpecPath)) {
+    const destSpecPath = path3.join(specDir, "MessageRouter.tla");
+    fs3.copyFileSync(baseSpecPath, destSpecPath);
+  } else {
+    console.log(color("⚠️  Warning: MessageRouter.tla not found, verification may fail", COLORS.yellow));
+  }
+  console.log(color("✓ Specification generated", COLORS.green));
+  console.log(color(`   ${specPath}`, COLORS.gray));
+  console.log();
+  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.");
+  }
+  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));
+    });
+  }
+  console.log(color("✓ Docker ready", COLORS.green));
+  console.log();
+  console.log(color("⚙️  Running TLC model checker...", COLORS.blue));
+  console.log(color("   This may take a minute...", COLORS.gray));
+  console.log();
+  const result = await docker.runTLC(specPath, {
+    workers: 2,
+    timeout: 120000
+  });
+  if (result.success) {
+    console.log(color(`✅ Verification passed!
+`, COLORS.green));
+    console.log(color("Statistics:", COLORS.blue));
+    console.log(color(`   States explored: ${result.stats?.statesGenerated || 0}`, COLORS.gray));
+    console.log(color(`   Distinct states: ${result.stats?.distinctStates || 0}`, COLORS.gray));
+    console.log();
+  } else {
+    console.log(color(`❌ Verification failed!
+`, COLORS.red));
+    if (result.violation) {
+      console.log(color(`Invariant violated: ${result.violation.name}
+`, COLORS.red));
+      console.log(color("Trace to violation:", COLORS.yellow));
+      for (const line of result.violation.trace.slice(0, 20)) {
+        console.log(color(`  ${line}`, COLORS.gray));
+      }
+      if (result.violation.trace.length > 20) {
+        console.log(color(`  ... (${result.violation.trace.length - 20} more lines)`, COLORS.gray));
+      }
+    } else if (result.error) {
+      console.log(color(`Error: ${result.error}`, COLORS.red));
+    }
+    console.log();
+    console.log(color("Full output saved to:", COLORS.gray));
+    console.log(color(`  ${path3.join(specDir, "tlc-output.log")}`, COLORS.gray));
+    fs3.writeFileSync(path3.join(specDir, "tlc-output.log"), result.output);
+    process.exit(1);
+  }
+}
+function showHelp() {
+  console.log(`
+${color("bun verify", COLORS.blue)} - Formal verification for web extensions
+
+${color("Commands:", COLORS.blue)}
+
+  ${color("bun verify", COLORS.green)}
+    Run verification (validates config, generates specs, runs TLC)
+
+  ${color("bun verify --setup", COLORS.green)}
+    Analyze codebase and generate configuration file
+
+  ${color("bun verify --validate", COLORS.green)}
+    Validate existing configuration without running verification
+
+  ${color("bun verify --help", COLORS.green)}
+    Show this help message
+
+${color("Getting Started:", COLORS.blue)}
+
+  1. Run ${color("bun verify --setup", COLORS.green)} to generate configuration
+  2. Review ${color("specs/verification.config.ts", COLORS.blue)} and fill in marked fields
+  3. Run ${color("bun verify --validate", COLORS.green)} to check your configuration
+  4. Run ${color("bun verify", COLORS.green)} to start verification
+
+${color("Configuration Help:", COLORS.blue)}
+
+  The generated config file uses special markers:
+
+    ${color("/* CONFIGURE */", COLORS.yellow)}  - Replace with your value
+    ${color("/* REVIEW */", COLORS.yellow)}     - Check auto-generated value
+    ${color("null", COLORS.yellow)}             - Must be replaced with concrete value
+
+${color("Learn More:", COLORS.blue)}
+
+  Documentation: https://github.com/fairfox/web-ext
+  TLA+ Resources: https://learntla.com
+`);
+}
+function findTsConfig() {
+  const locations = [
+    path3.join(process.cwd(), "tsconfig.json"),
+    path3.join(process.cwd(), "packages", "web-ext", "tsconfig.json")
+  ];
+  for (const loc of locations) {
+    if (fs3.existsSync(loc)) {
+      return loc;
+    }
+  }
+  return null;
+}
+function findStateFile() {
+  const locations = [
+    path3.join(process.cwd(), "types", "state.ts"),
+    path3.join(process.cwd(), "src", "types", "state.ts"),
+    path3.join(process.cwd(), "packages", "web-ext", "src", "shared", "state", "app-state.ts")
+  ];
+  for (const loc of locations) {
+    if (fs3.existsSync(loc)) {
+      return loc;
+    }
+  }
+  return;
+}
+main().catch((error) => {
+  console.error(color(`
+❌ Fatal error:`, COLORS.red));
+  console.error(`   ${error instanceof Error ? error.message : String(error)}`);
+  if (error instanceof Error && error.stack) {
+    console.error(color(`
+Stack trace:`, COLORS.gray));
+    console.error(color(error.stack, COLORS.gray));
+  }
+  process.exit(1);
+});
+
+//# debugId=10F00303D4610C9D64756E2164756E21