@fairfox/polly 0.12.3 → 0.13.0

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

@@ -49,7 +49,13 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // tools/verify/src/primitives/index.ts
-function $constraints(_stateField, _constraints) {}
+function $constraints(stateField, constraints, options) {
+  if (options?.runtime) {
+    import("../../../src/shared/lib/constraints.js").then(({ registerConstraints }) => {
+      registerConstraints(stateField, constraints);
+    }).catch(() => {});
+  }
+}
 
 // tools/verify/src/config.ts
 function defineVerification(config) {
@@ -77,4 +83,4 @@ export {
   $constraints
 };
 
-//# debugId=06CC0A95E020BF9F64756E2164756E21
+//# debugId=B7658306F59988EF64756E2164756E21

package/dist/tools/verify/src/config.js.map

@@ -2,10 +2,10 @@
   "version": 3,
   "sources": ["../tools/verify/src/primitives/index.ts", "../tools/verify/src/config.ts"],
   "sourcesContent": [
-    "// Verification primitives for formal verification\n// These are runtime no-ops but extracted during verification\n\n/**\n * Assert a precondition that must be true when the handler executes.\n *\n * In production: No-op (compiled away)\n * In verification: Translated to TLA+ assertion\n *\n * @example\n * messageBus.on(\"USER_LOGIN\", (payload) => {\n *   requires(state.user.loggedIn === false, \"User must not be logged in\")\n *   state.user.loggedIn = true\n * })\n */\nexport function requires(condition: boolean, message?: string): void {\n  // Runtime no-op - only used during verification\n  // Condition and message are checked during static analysis only\n  void condition;\n  void message;\n}\n\n/**\n * Assert a postcondition that must be true after the handler completes.\n *\n * In production: No-op (compiled away)\n * In verification: Translated to TLA+ assertion\n *\n * @example\n * messageBus.on(\"USER_LOGIN\", (payload) => {\n *   state.user.loggedIn = true\n *   ensures(state.user.loggedIn === true, \"User must be logged in\")\n * })\n */\nexport function ensures(condition: boolean, message?: string): void {\n  // Runtime no-op - only used during verification\n  // Condition and message are checked during static analysis only\n  void condition;\n  void message;\n}\n\n/**\n * Define a global invariant that must always hold.\n *\n * In production: No-op (compiled away)\n * In verification: Translated to TLA+ invariant\n *\n * @example\n * invariant(\"UserIdConsistent\", () =>\n *   state.user.loggedIn === false || state.user.id !== null\n * )\n */\nexport function invariant(_name: string, condition: () => boolean): void {\n  // Runtime no-op - only used during verification\n  // Name and condition are checked during static analysis only\n  void condition;\n}\n\n/**\n * Assert that a value is within a valid range.\n *\n * @example\n * requires(inRange(todoCount, 0, 100), \"Todo count must be 0-100\")\n */\nexport function inRange(value: number, min: number, max: number): boolean {\n  return value >= min && value <= max;\n}\n\n/**\n * Assert that a value is one of the allowed values.\n *\n * @example\n * requires(oneOf(state.user.role, [\"admin\", \"user\"]), \"Role must be admin or user\")\n */\nexport function oneOf<T>(value: T, allowed: T[]): boolean {\n  return allowed.includes(value);\n}\n\n/**\n * Assert that an array has a specific length constraint.\n *\n * @example\n * requires(hasLength(state.todos, { max: 10 }), \"Too many todos\")\n */\nexport function hasLength(array: unknown[], constraint: { min?: number; max?: number }): boolean {\n  if (constraint.min !== undefined && array.length < constraint.min) return false;\n  if (constraint.max !== undefined && array.length > constraint.max) return false;\n  return true;\n}\n\n/**\n * Declare state-level constraints for verification.\n * Maps message types to preconditions on state fields.\n *\n * The parser automatically wires these constraints to handlers.\n *\n * @example\n * const state = { loggedIn: false };\n *\n * $constraints(\"loggedIn\", {\n *   USER_LOGOUT: { requires: \"loggedIn === true\", message: \"Must be logged in\" },\n *   BOOKMARK_ADD: { requires: \"loggedIn === true\", message: \"Must be logged in\" },\n * });\n */\nexport function $constraints(\n  _stateField: string,\n  _constraints: Record<\n    string,\n    {\n      requires?: string;\n      ensures?: string;\n      message?: string;\n    }\n  >\n): void {\n  // Runtime no-op - only used during verification\n  // Parser extracts these and wires them to TLA+ handlers\n}\n\n// Re-export for convenience\nexport const verify = {\n  requires,\n  ensures,\n  invariant,\n  inRange,\n  oneOf,\n  hasLength,\n  $constraints,\n};\n",
+    "// Verification primitives for formal verification\n// These are runtime no-ops but extracted during verification\n\n/**\n * Assert a precondition that must be true when the handler executes.\n *\n * In production: No-op (compiled away)\n * In verification: Translated to TLA+ assertion\n *\n * @example\n * messageBus.on(\"USER_LOGIN\", (payload) => {\n *   requires(state.user.loggedIn === false, \"User must not be logged in\")\n *   state.user.loggedIn = true\n * })\n */\nexport function requires(condition: boolean, message?: string): void {\n  // Runtime no-op - only used during verification\n  // Condition and message are checked during static analysis only\n  void condition;\n  void message;\n}\n\n/**\n * Assert a postcondition that must be true after the handler completes.\n *\n * In production: No-op (compiled away)\n * In verification: Translated to TLA+ assertion\n *\n * @example\n * messageBus.on(\"USER_LOGIN\", (payload) => {\n *   state.user.loggedIn = true\n *   ensures(state.user.loggedIn === true, \"User must be logged in\")\n * })\n */\nexport function ensures(condition: boolean, message?: string): void {\n  // Runtime no-op - only used during verification\n  // Condition and message are checked during static analysis only\n  void condition;\n  void message;\n}\n\n/**\n * Define a global invariant that must always hold.\n *\n * In production: No-op (compiled away)\n * In verification: Translated to TLA+ invariant\n *\n * @example\n * invariant(\"UserIdConsistent\", () =>\n *   state.user.loggedIn === false || state.user.id !== null\n * )\n */\nexport function invariant(_name: string, condition: () => boolean): void {\n  // Runtime no-op - only used during verification\n  // Name and condition are checked during static analysis only\n  void condition;\n}\n\n/**\n * Assert that a value is within a valid range.\n *\n * @example\n * requires(inRange(todoCount, 0, 100), \"Todo count must be 0-100\")\n */\nexport function inRange(value: number, min: number, max: number): boolean {\n  return value >= min && value <= max;\n}\n\n/**\n * Assert that a value is one of the allowed values.\n *\n * @example\n * requires(oneOf(state.user.role, [\"admin\", \"user\"]), \"Role must be admin or user\")\n */\nexport function oneOf<T>(value: T, allowed: T[]): boolean {\n  return allowed.includes(value);\n}\n\n/**\n * Assert that an array has a specific length constraint.\n *\n * @example\n * requires(hasLength(state.todos, { max: 10 }), \"Too many todos\")\n */\nexport function hasLength(array: unknown[], constraint: { min?: number; max?: number }): boolean {\n  if (constraint.min !== undefined && array.length < constraint.min) return false;\n  if (constraint.max !== undefined && array.length > constraint.max) return false;\n  return true;\n}\n\n/**\n * Declare state-level constraints for verification and optional runtime checking.\n * Maps message types to preconditions on state fields.\n *\n * The parser automatically wires these constraints to handlers during verification.\n * Optionally, constraints can be enforced at runtime by passing `{ runtime: true }`.\n *\n * @example\n * // Verification only (TLA+ generation)\n * const state = { loggedIn: false };\n *\n * $constraints(\"loggedIn\", {\n *   USER_LOGOUT: { requires: \"state.loggedIn === true\", message: \"Must be logged in\" },\n *   BOOKMARK_ADD: { requires: \"state.loggedIn === true\", message: \"Must be logged in\" },\n * });\n *\n * @example\n * // Runtime enforcement (function predicates)\n * $constraints(\"loggedIn\", {\n *   USER_LOGOUT: {\n *     requires: (state) => state.loggedIn === true,\n *     message: \"Must be logged in to logout\"\n *   },\n * }, { runtime: true });\n */\nexport function $constraints(\n  stateField: string,\n  constraints: Record<\n    string,\n    {\n      requires?: string | ((state: unknown) => boolean);\n      ensures?: string | ((state: unknown) => boolean);\n      message?: string;\n    }\n  >,\n  options?: { runtime?: boolean }\n): void {\n  // Register constraints for runtime checking if enabled\n  if (options?.runtime) {\n    // Import dynamically to avoid circular dependencies\n    // This is safe because it only happens at runtime, not during static analysis\n    // @ts-expect-error - Dynamic import path resolves correctly at runtime\n    import(\"../../../src/shared/lib/constraints.js\")\n      .then(({ registerConstraints }) => {\n        registerConstraints(stateField, constraints);\n      })\n      .catch(() => {\n        // Silently ignore - constraints module may not be available during static analysis\n      });\n  }\n\n  // For verification: Still a no-op at runtime\n  // Parser extracts these and wires them to TLA+ handlers\n}\n\n// Re-export for convenience\nexport const verify = {\n  requires,\n  ensures,\n  invariant,\n  inRange,\n  oneOf,\n  hasLength,\n  $constraints,\n};\n",
     "// ═══════════════════════════════════════════════════════════════\n// Configuration Helper for @fairfox/polly/verify\n// ═══════════════════════════════════════════════════════════════\n//\n// Lightweight entry point for user configuration files.\n// Does NOT include heavy dependencies (ts-morph, analysis, etc.)\n// which are only needed by the CLI tool.\n\n// ─────────────────────────────────────────────────────────────────\n// Configuration Types (inlined to avoid heavy dependencies)\n// ─────────────────────────────────────────────────────────────────\n\n// Legacy verification configuration\ninterface LegacyVerificationConfig {\n  state: Record<string, unknown>;\n  messages: {\n    // Basic bounds\n    maxInFlight?: number;\n    maxTabs?: number;\n    maxClients?: number;\n    maxRenderers?: number;\n    maxWorkers?: number;\n    maxContexts?: number;\n\n    // Tier 1 Optimizations (no precision loss)\n    include?: string[]; // Only verify these message types\n    exclude?: string[]; // Exclude these message types (mutually exclusive with include)\n    symmetry?: string[][]; // Groups of symmetric message types [[type1, type2], [type3, type4]]\n    perMessageBounds?: Record<string, number>; // Different maxInFlight per message type\n  };\n  onBuild?: \"warn\" | \"error\" | \"off\";\n  onRelease?: \"warn\" | \"error\" | \"off\";\n\n  // Verification engine options\n  verification?: {\n    timeout?: number; // Timeout in seconds (0 = no timeout)\n    workers?: number; // Number of TLC workers\n  };\n\n  // Tier 2 Optimizations (controlled approximations)\n  tier2?: {\n    // Temporal constraints: ordering requirements between messages\n    temporalConstraints?: Array<{\n      before: string; // Message type that must occur first\n      after: string; // Message type that must occur after\n      description?: string; // Human-readable description\n    }>;\n\n    // Bounded exploration: limit depth for specific scenarios\n    boundedExploration?: {\n      maxDepth?: number; // Maximum state depth to explore\n      criticalPaths?: string[][]; // Sequences of message types that must be fully explored\n    };\n  };\n}\n\n// Adapter-based configuration (for future use)\ninterface AdapterVerificationConfig {\n  adapter: unknown; // Adapter interface not exported to avoid heavy deps\n  state: Record<string, unknown>;\n  bounds?: {\n    maxInFlight?: number;\n    [key: string]: unknown;\n  };\n  onBuild?: \"warn\" | \"error\" | \"off\";\n}\n\n// Union type for both config formats\ntype UnifiedVerificationConfig = LegacyVerificationConfig | AdapterVerificationConfig;\n\n/**\n * Define verification configuration with type checking\n *\n * Used in generated verification.config.ts files.\n *\n * @example\n * ```typescript\n * import { defineVerification } from '@fairfox/polly/verify'\n *\n * export default defineVerification({\n *   state: {\n *     \"user.role\": { type: \"enum\", values: [\"admin\", \"user\", \"guest\"] },\n *   },\n *   messages: {\n *     maxInFlight: 6,\n *     maxTabs: 2,\n *   },\n * })\n * ```\n */\nexport function defineVerification<T extends UnifiedVerificationConfig>(config: T): T {\n  // Validate configuration structure\n  if (\"adapter\" in config) {\n    // New adapter-based format\n    if (!config.adapter) {\n      throw new Error(\"Configuration must include an adapter\");\n    }\n    if (!config.state) {\n      throw new Error(\"Configuration must include state bounds\");\n    }\n  } else if (\"messages\" in config) {\n    // Legacy format\n    if (!config.state) {\n      throw new Error(\"Configuration must include state bounds\");\n    }\n    if (!config.messages) {\n      throw new Error(\"Legacy configuration must include messages bounds\");\n    }\n  } else {\n    throw new Error(\n      \"Invalid configuration format. Must include either 'adapter' (new format) or 'messages' (legacy format)\"\n    );\n  }\n\n  return config;\n}\n\n// Re-export $constraints from primitives for user code\nexport { $constraints } from \"./primitives/index.js\";\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwGO,SAAS,YAAY,CAC1B,aACA,cAQM;;;ACxBD,SAAS,kBAAuD,CAAC,QAAc;AAAA,EAEpF,IAAI,aAAa,QAAQ;AAAA,IAEvB,IAAI,CAAC,OAAO,SAAS;AAAA,MACnB,MAAM,IAAI,MAAM,uCAAuC;AAAA,IACzD;AAAA,IACA,IAAI,CAAC,OAAO,OAAO;AAAA,MACjB,MAAM,IAAI,MAAM,yCAAyC;AAAA,IAC3D;AAAA,EACF,EAAO,SAAI,cAAc,QAAQ;AAAA,IAE/B,IAAI,CAAC,OAAO,OAAO;AAAA,MACjB,MAAM,IAAI,MAAM,yCAAyC;AAAA,IAC3D;AAAA,IACA,IAAI,CAAC,OAAO,UAAU;AAAA,MACpB,MAAM,IAAI,MAAM,mDAAmD;AAAA,IACrE;AAAA,EACF,EAAO;AAAA,IACL,MAAM,IAAI,MACR,wGACF;AAAA;AAAA,EAGF,OAAO;AAAA;",
-  "debugId": "06CC0A95E020BF9F64756E2164756E21",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmHO,SAAS,YAAY,CAC1B,YACA,aAQA,SACM;AAAA,EAEN,IAAI,SAAS,SAAS;AAAA,IAIb,iDACJ,KAAK,GAAG,0BAA0B;AAAA,MACjC,oBAAoB,YAAY,WAAW;AAAA,KAC5C,EACA,MAAM,MAAM,EAEZ;AAAA,EACL;AAAA;;;ACjDK,SAAS,kBAAuD,CAAC,QAAc;AAAA,EAEpF,IAAI,aAAa,QAAQ;AAAA,IAEvB,IAAI,CAAC,OAAO,SAAS;AAAA,MACnB,MAAM,IAAI,MAAM,uCAAuC;AAAA,IACzD;AAAA,IACA,IAAI,CAAC,OAAO,OAAO;AAAA,MACjB,MAAM,IAAI,MAAM,yCAAyC;AAAA,IAC3D;AAAA,EACF,EAAO,SAAI,cAAc,QAAQ;AAAA,IAE/B,IAAI,CAAC,OAAO,OAAO;AAAA,MACjB,MAAM,IAAI,MAAM,yCAAyC;AAAA,IAC3D;AAAA,IACA,IAAI,CAAC,OAAO,UAAU;AAAA,MACpB,MAAM,IAAI,MAAM,mDAAmD;AAAA,IACrE;AAAA,EACF,EAAO;AAAA,IACL,MAAM,IAAI,MACR,wGACF;AAAA;AAAA,EAGF,OAAO;AAAA;",
+  "debugId": "B7658306F59988EF64756E2164756E21",
   "names": []
 }

package/dist/tools/verify/src/primitives/index.d.ts

@@ -61,24 +61,37 @@ export declare function hasLength(array: unknown[], constraint: {
     max?: number;
 }): boolean;
 /**
- * Declare state-level constraints for verification.
+ * Declare state-level constraints for verification and optional runtime checking.
  * Maps message types to preconditions on state fields.
  *
- * The parser automatically wires these constraints to handlers.
+ * The parser automatically wires these constraints to handlers during verification.
+ * Optionally, constraints can be enforced at runtime by passing `{ runtime: true }`.
  *
  * @example
+ * // Verification only (TLA+ generation)
  * const state = { loggedIn: false };
  *
  * $constraints("loggedIn", {
- *   USER_LOGOUT: { requires: "loggedIn === true", message: "Must be logged in" },
- *   BOOKMARK_ADD: { requires: "loggedIn === true", message: "Must be logged in" },
+ *   USER_LOGOUT: { requires: "state.loggedIn === true", message: "Must be logged in" },
+ *   BOOKMARK_ADD: { requires: "state.loggedIn === true", message: "Must be logged in" },
  * });
+ *
+ * @example
+ * // Runtime enforcement (function predicates)
+ * $constraints("loggedIn", {
+ *   USER_LOGOUT: {
+ *     requires: (state) => state.loggedIn === true,
+ *     message: "Must be logged in to logout"
+ *   },
+ * }, { runtime: true });
  */
-export declare function $constraints(_stateField: string, _constraints: Record<string, {
-    requires?: string;
-    ensures?: string;
+export declare function $constraints(stateField: string, constraints: Record<string, {
+    requires?: string | ((state: unknown) => boolean);
+    ensures?: string | ((state: unknown) => boolean);
     message?: string;
-}>): void;
+}>, options?: {
+    runtime?: boolean;
+}): void;
 export declare const verify: {
     requires: typeof requires;
     ensures: typeof ensures;

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

@@ -1794,17 +1794,25 @@ class HandlerExtractor {
     const assignments = [];
     const preconditions = [];
     const postconditions = [];
+    let actualHandler = null;
     if (Node4.isArrowFunction(handlerArg) || Node4.isFunctionExpression(handlerArg)) {
-      this.extractAssignments(handlerArg, assignments);
-      this.extractVerificationConditions(handlerArg, preconditions, postconditions);
-      this.checkAsyncMutations(handlerArg, messageType);
+      actualHandler = handlerArg;
+    } else if (Node4.isIdentifier(handlerArg)) {
+      actualHandler = this.resolveFunctionReference(handlerArg);
+    }
+    if (actualHandler) {
+      this.extractAssignments(actualHandler, assignments);
+      this.extractVerificationConditions(actualHandler, preconditions, postconditions);
+      if (Node4.isArrowFunction(actualHandler) || Node4.isFunctionExpression(actualHandler)) {
+        this.checkAsyncMutations(actualHandler, messageType);
+      }
     }
     const line = callExpr.getStartLineNumber();
     const sourceFile = callExpr.getSourceFile();
     const handlerName = `${messageType}_handler`;
     let relationships;
-    if (Node4.isArrowFunction(handlerArg) || Node4.isFunctionExpression(handlerArg)) {
-      const detectedRelationships = this.relationshipExtractor.extractFromHandler(handlerArg, sourceFile, handlerName);
+    if (actualHandler) {
+      const detectedRelationships = this.relationshipExtractor.extractFromHandler(actualHandler, sourceFile, handlerName);
       if (detectedRelationships.length > 0) {
         relationships = detectedRelationships;
       }
@@ -1830,6 +1838,9 @@ class HandlerExtractor {
       if (Node4.isCallExpression(node)) {
         this.extractArrayMutationAssignment(node, assignments);
       }
+      if (Node4.isPostfixUnaryExpression(node) || Node4.isPrefixUnaryExpression(node)) {
+        this.extractUnaryExpressionAssignment(node, assignments);
+      }
     });
   }
   extractBinaryExpressionAssignment(node, assignments) {
@@ -1905,6 +1916,36 @@ class HandlerExtractor {
       }
     }
   }
+  getUnaryOperatorText(operator) {
+    if (typeof operator === "number") {
+      if (operator === SyntaxKind.PlusPlusToken)
+        return "++";
+      if (operator === SyntaxKind.MinusMinusToken)
+        return "--";
+      return null;
+    }
+    if (operator && typeof operator === "object" && "getText" in operator) {
+      return operator.getText();
+    }
+    return null;
+  }
+  extractUnaryExpressionAssignment(node, assignments) {
+    if (!Node4.isPostfixUnaryExpression(node) && !Node4.isPrefixUnaryExpression(node))
+      return;
+    const operator = node.getOperatorToken();
+    const operatorText = this.getUnaryOperatorText(operator);
+    if (operatorText !== "++" && operatorText !== "--")
+      return;
+    const operand = node.getOperand();
+    if (!Node4.isPropertyAccessExpression(operand))
+      return;
+    const fieldPath = this.getPropertyPath(operand);
+    if (fieldPath.startsWith("state.")) {
+      const field = fieldPath.substring(6);
+      const value = operatorText === "++" ? "@ + 1" : "@ - 1";
+      assignments.push({ field, value });
+    }
+  }
   extractArrayMutationAssignment(node, assignments) {
     if (!Node4.isCallExpression(node))
       return;
@@ -1984,7 +2025,7 @@ class HandlerExtractor {
   }
   extractVerificationConditions(funcNode, preconditions, postconditions) {
     const body = funcNode.getBody();
-    const statements = Node4.isBlock(body) ? body.getStatements() : [body];
+    const statements = Node4.isBlock(body) ? body.getStatements() : body ? [body] : [];
     for (const statement of statements) {
       this.processStatementForConditions(statement, preconditions, postconditions);
     }
@@ -2104,10 +2145,14 @@ class HandlerExtractor {
     const handlers = [];
     try {
       const initializer = varDecl.getInitializer();
-      if (!this.isHandlerMapInitializer(initializer, varDecl)) {
+      if (!initializer) {
         return handlers;
       }
-      const properties = initializer.getProperties();
+      const objectLiteral = this.getHandlerMapObject(initializer, varDecl);
+      if (!objectLiteral) {
+        return handlers;
+      }
+      const properties = objectLiteral.getProperties();
       for (const prop of properties) {
         const handler = this.extractHandlerFromProperty(prop, context, filePath);
         if (handler) {
@@ -2117,12 +2162,16 @@ class HandlerExtractor {
     } catch (_error) {}
     return handlers;
   }
-  isHandlerMapInitializer(initializer, varDecl) {
-    if (!initializer || !Node4.isObjectLiteralExpression(initializer)) {
-      return false;
+  getHandlerMapObject(initializer, varDecl) {
+    if (Node4.isObjectLiteralExpression(initializer)) {
+      if (this.isHandlerMapName(varDecl.getName())) {
+        return initializer;
+      }
     }
-    const varName = varDecl.getName().toLowerCase();
-    return /(handler|listener|callback|event)s?/.test(varName);
+    return null;
+  }
+  isHandlerMapName(varName) {
+    return /(handler|listener|callback|event)s?/.test(varName.toLowerCase());
   }
   extractHandlerFromProperty(prop, context, filePath) {
     if (!Node4.isPropertyAssignment(prop)) {
@@ -2133,13 +2182,29 @@ class HandlerExtractor {
     if (!messageType) {
       return null;
     }
+    const value = prop.getInitializer();
+    const assignments = [];
+    const preconditions = [];
+    const postconditions = [];
+    if (value) {
+      if (Node4.isArrowFunction(value) || Node4.isFunctionExpression(value)) {
+        this.extractAssignments(value, assignments);
+        this.extractVerificationConditions(value, preconditions, postconditions);
+      } else if (Node4.isIdentifier(value)) {
+        const referencedFunction = this.resolveFunctionReference(value);
+        if (referencedFunction) {
+          this.extractAssignments(referencedFunction, assignments);
+          this.extractVerificationConditions(referencedFunction, preconditions, postconditions);
+        }
+      }
+    }
     const line = prop.getStartLineNumber();
     return {
       messageType,
       node: context,
-      assignments: [],
-      preconditions: [],
-      postconditions: [],
+      assignments,
+      preconditions,
+      postconditions,
       location: { file: filePath, line }
     };
   }
@@ -2152,6 +2217,26 @@ class HandlerExtractor {
     }
     return null;
   }
+  resolveFunctionReference(identifier) {
+    if (!Node4.isIdentifier(identifier)) {
+      return null;
+    }
+    try {
+      const definitions = identifier.getDefinitionNodes();
+      for (const def of definitions) {
+        if (Node4.isFunctionDeclaration(def)) {
+          return def;
+        }
+        if (Node4.isVariableDeclaration(def)) {
+          const initializer = def.getInitializer();
+          if (initializer && (Node4.isArrowFunction(initializer) || Node4.isFunctionExpression(initializer))) {
+            return initializer;
+          }
+        }
+      }
+    } catch (_error) {}
+    return null;
+  }
   extractTypeGuardHandlers(ifNode, context, filePath) {
     const handlers = [];
     try {
@@ -4934,4 +5019,4 @@ main().catch((_error) => {
   process.exit(1);
 });
 
-//# debugId=17D3ACE789AF647764756E2164756E21
+//# debugId=29B7FAEF737837BA64756E2164756E21