@ontrails/warden 1.0.0-beta.2 → 1.0.0-beta.4

package/src/__tests__/prefer-schema-inference.test.ts

@@ -10,7 +10,7 @@ trail("entity.show", {
   fields: {
     firstName: { label: "First Name" },
   },
-  implementation: (input) => Result.ok(input),
+  run: (input) => Result.ok(input),
 })`;
 
     const diagnostics = preferSchemaInference.check(code, 'src/entity.ts');
@@ -31,7 +31,7 @@ trail("entity.paint", {
       options: [{ value: "red" }, { value: "green" }],
     },
   },
-  implementation: (input) => Result.ok(input),
+  run: (input) => Result.ok(input),
 })`;
 
     const diagnostics = preferSchemaInference.check(code, 'src/entity.ts');
@@ -56,7 +56,7 @@ trail("entity.paint", {
     },
     displayName: { label: "Public name" },
   },
-  implementation: (input) => Result.ok(input),
+  run: (input) => Result.ok(input),
 })`;
 
     const diagnostics = preferSchemaInference.check(code, 'src/entity.ts');
@@ -74,7 +74,7 @@ trail("entity.show", {
       message: "Who should we greet?",
     },
   },
-  implementation: (input) => Result.ok(input),
+  run: (input) => Result.ok(input),
 })`;
 
     const diagnostics = preferSchemaInference.check(code, 'src/entity.ts');

package/src/__tests__/rules.test.ts

@@ -14,7 +14,7 @@ describe('no-throw-in-implementation', () => {
   test('flags throw inside implementation body', () => {
     const code = `
 trail("entity.show", {
-  implementation: async (input, ctx) => {
+  run: async (input, ctx) => {
     throw new Error("boom");
   }
 })`;
@@ -27,7 +27,7 @@ trail("entity.show", {
   test('allows Result.err() in implementation', () => {
     const code = `
 trail("entity.show", {
-  implementation: async (input, ctx) => {
+  run: async (input, ctx) => {
     return Result.err(new NotFoundError("not found"));
   }
 })`;
@@ -42,7 +42,7 @@ function helper() {
 }
 
 trail("entity.show", {
-  implementation: async (input, ctx) => {
+  run: async (input, ctx) => {
     return Result.ok(data);
   }
 })`;
@@ -59,7 +59,7 @@ describe('context-no-surface-types', () => {
     const code = `
 import { Request, Response } from "express";
 trail("entity.show", {
-  implementation: async (input, ctx) => {
+  run: async (input, ctx) => {
     return Result.ok(data);
   }
 })`;
@@ -73,7 +73,7 @@ trail("entity.show", {
     const code = `
 import type { McpSession } from "@modelcontextprotocol/sdk";
 trail("entity.show", {
-  implementation: async (input, ctx) => {
+  run: async (input, ctx) => {
     return Result.ok(data);
   }
 })`;
@@ -85,7 +85,7 @@ trail("entity.show", {
     const code = `
 import { trail, Result } from "@ontrails/core";
 trail("entity.show", {
-  implementation: async (input, ctx) => {
+  run: async (input, ctx) => {
     return Result.ok(data);
   }
 })`;
@@ -110,7 +110,7 @@ describe('valid-detour-refs', () => {
     const code = `
 trail("entity.show", {
   detours: [{ target: "entity.edit" }],
-  implementation: async (input, ctx) => Result.ok(data)
+  run: async (input, ctx) => Result.ok(data)
 })`;
     const diagnostics = validDetourRefs.check(code, TEST_FILE);
     expect(diagnostics.length).toBe(1);
@@ -120,12 +120,12 @@ trail("entity.show", {
   test('passes when detour target exists', () => {
     const code = `
 trail("entity.edit", {
-  implementation: async (input, ctx) => Result.ok(data)
+  run: async (input, ctx) => Result.ok(data)
 })
 
 trail("entity.show", {
   detours: [{ target: "entity.edit" }],
-  implementation: async (input, ctx) => Result.ok(data)
+  run: async (input, ctx) => Result.ok(data)
 })`;
     const diagnostics = validDetourRefs.check(code, TEST_FILE);
     expect(diagnostics.length).toBe(0);
@@ -135,7 +135,7 @@ trail("entity.show", {
     const code = `
 trail("entity.show", {
   detours: [{ target: "entity.edit" }],
-  implementation: async (input, ctx) => Result.ok(data)
+  run: async (input, ctx) => Result.ok(data)
 })`;
     const context = { knownTrailIds: new Set(['entity.show', 'entity.edit']) };
     const diagnostics = validDetourRefs.checkWithContext(
@@ -145,18 +145,45 @@ trail("entity.show", {
     );
     expect(diagnostics.length).toBe(0);
   });
+
+  test('flags detour target in trail with follow that does not exist', () => {
+    const code = `
+trail("entity.onboard", {
+  detours: [{ target: "entity.missing" }],
+  follow: ["entity.create"],
+  run: async (input, ctx) => Result.ok(data)
+})`;
+    const diagnostics = validDetourRefs.check(code, TEST_FILE);
+    expect(diagnostics.length).toBe(1);
+    expect(diagnostics[0]?.message).toContain('entity.missing');
+  });
+
+  test('passes when trail with follow detour target exists', () => {
+    const code = `
+trail("entity.fallback", {
+  run: async (input, ctx) => Result.ok(data)
+})
+
+trail("entity.onboard", {
+  detours: [{ target: "entity.fallback" }],
+  follow: ["entity.create"],
+  run: async (input, ctx) => Result.ok(data)
+})`;
+    const diagnostics = validDetourRefs.check(code, TEST_FILE);
+    expect(diagnostics.length).toBe(0);
+  });
 });
 
 // ---------------------------------------------------------------------------
 // no-direct-impl-in-route
 // ---------------------------------------------------------------------------
 describe('no-direct-impl-in-route', () => {
-  test('warns on direct .implementation() call in route', () => {
+  test('warns on direct .run() call in trail with follow', () => {
     const code = `
-hike("entity.onboard", {
-  follows: ["entity.create"],
-  implementation: async (input, ctx) => {
-    const result = await entityCreate.implementation(data);
+trail("entity.onboard", {
+  follow: ["entity.create"],
+  run: async (input, ctx) => {
+    const result = await entityCreate.run(data);
     return Result.ok(result);
   }
 })`;
@@ -168,9 +195,9 @@ hike("entity.onboard", {
 
   test('allows ctx.follow() calls', () => {
     const code = `
-hike("entity.onboard", {
-  follows: ["entity.create"],
-  implementation: async (input, ctx) => {
+trail("entity.onboard", {
+  follow: ["entity.create"],
+  run: async (input, ctx) => {
     const result = await ctx.follow("entity.create", data);
     return Result.ok(result);
   }
@@ -179,9 +206,21 @@ hike("entity.onboard", {
     expect(diagnostics.length).toBe(0);
   });
 
-  test('ignores files without hike() calls', () => {
+  test('ignores trails without follow', () => {
+    const code = `
+trail("entity.show", {
+  run: async (input, ctx) => {
+    const result = await someTrail.run(data);
+    return Result.ok(result);
+  }
+})`;
+    const diagnostics = noDirectImplInRoute.check(code, TEST_FILE);
+    expect(diagnostics.length).toBe(0);
+  });
+
+  test('ignores files without trail() calls', () => {
     const code = `
-const result = await someTrail.implementation(data);`;
+const result = await someTrail.run(data);`;
     const diagnostics = noDirectImplInRoute.check(code, TEST_FILE);
     expect(diagnostics.length).toBe(0);
   });

package/src/__tests__/valid-describe-refs.test.ts

@@ -9,7 +9,7 @@ trail("entity.show", {
   input: z.object({
     query: z.string().describe("Search query. @see entity.search"),
   }),
-  implementation: (input) => Result.ok(input),
+  run: (input) => Result.ok(input),
 })`;
 
     const diagnostics = validDescribeRefs.check(code, 'src/entity.ts');
@@ -23,14 +23,14 @@ trail("entity.show", {
     const code = `
 trail("entity.search", {
   input: z.object({ query: z.string() }),
-  implementation: (input) => Result.ok(input),
+  run: (input) => Result.ok(input),
 })
 
 trail("entity.show", {
   input: z.object({
     query: z.string().describe("Search query. @see entity.search"),
   }),
-  implementation: (input) => Result.ok(input),
+  run: (input) => Result.ok(input),
 })`;
 
     const diagnostics = validDescribeRefs.check(code, 'src/entity.ts');
@@ -44,7 +44,7 @@ trail("entity.show", {
   input: z.object({
     query: z.string().describe("Search query. @see entity.search"),
   }),
-  implementation: (input) => Result.ok(input),
+  run: (input) => Result.ok(input),
 })`;
 
     const diagnostics = validDescribeRefs.checkWithContext(

package/src/cli.ts

@@ -152,10 +152,7 @@ const loadSourceFiles = async (
 };
 
 const buildProjectContextFromTopo = (appTopo: Topo): ProjectContext => {
-  const knownTrailIds = new Set<string>([
-    ...appTopo.trails.keys(),
-    ...appTopo.hikes.keys(),
-  ]);
+  const knownTrailIds = new Set<string>(appTopo.trails.keys());
 
   const detourTargetTrailIds = new Set<string>();
   for (const t of appTopo.trails.values()) {

package/src/rules/ast.ts

@@ -74,15 +74,11 @@ export const offsetToLine = (sourceCode: string, offset: number): number => {
   return line;
 };
 
-/** Find all `implementation:` property values in an AST. */
-export const findImplementationBodies = (ast: AstNode): AstNode[] => {
+/** Find all `run:` property values in an AST. */
+export const findRunBodies = (ast: AstNode): AstNode[] => {
   const bodies: AstNode[] = [];
   walk(ast, (node) => {
-    if (
-      node.type === 'Property' &&
-      node.key?.name === 'implementation' &&
-      node.value
-    ) {
+    if (node.type === 'Property' && node.key?.name === 'run' && node.value) {
       bodies.push(node.value);
     }
   });
@@ -92,20 +88,20 @@ export const findImplementationBodies = (ast: AstNode): AstNode[] => {
 export interface TrailDefinition {
   /** Trail ID string, e.g. "entity.show" */
   readonly id: string;
-  /** "trail" or "hike" */
+  /** "trail" or "event" */
   readonly kind: string;
-  /** The config object argument (second arg to trail/hike call) */
+  /** The config object argument (second arg to trail() call) */
   readonly config: AstNode;
   /** Start offset of the call expression */
   readonly start: number;
 }
 
 /**
- * Find all `trail("id", { ... })` and `hike("id", { ... })` call sites.
+ * Find all `trail("id", { ... })` and `event("id", { ... })` call sites.
  *
  * Returns the trail ID, kind, and config object node for each definition.
  */
-const TRAIL_CALLEE_NAMES = new Set(['trail', 'hike']);
+const TRAIL_CALLEE_NAMES = new Set(['trail', 'event']);
 
 const getTrailCalleeName = (node: AstNode): string | null => {
   if (node.type !== 'CallExpression') {
@@ -157,8 +153,8 @@ const extractTrailDefinition = (node: AstNode): TrailDefinition | null => {
   };
 };
 
-/** Check if a node is a call to `.implementation()` on some object. */
-export const isImplementationCall = (node: AstNode): boolean => {
+/** Check if a node is a call to `.run()` on some object. */
+export const isRunCall = (node: AstNode): boolean => {
   if (node.type !== 'CallExpression') {
     return false;
   }
@@ -175,7 +171,7 @@ export const isImplementationCall = (node: AstNode): boolean => {
   const prop = (callee as unknown as { property?: AstNode }).property;
   return (
     prop?.type === 'Identifier' &&
-    (prop as unknown as { name: string }).name === 'implementation'
+    (prop as unknown as { name: string }).name === 'run'
   );
 };
 

package/src/rules/context-no-surface-types.ts

@@ -123,7 +123,7 @@ const classifyImport = (
  */
 export const contextNoSurfaceTypes: WardenRule = {
   check(sourceCode: string, filePath: string): readonly WardenDiagnostic[] {
-    if (!/\b(?:trail|hike)\s*\(/.test(sourceCode)) {
+    if (!/\btrail\s*\(/.test(sourceCode)) {
       return [];
     }
 

package/src/rules/implementation-returns-result.ts

@@ -1,13 +1,13 @@
 /**
  * Finds implementations that return raw values instead of `Result`.
  *
- * Uses AST parsing to find `implementation:` bodies and check that
+ * Uses AST parsing to find `run:` bodies and check that
  * every return statement returns Result.ok(), Result.err(), ctx.follow(),
  * or a tracked Result-typed variable.
  */
 
 import {
-  findImplementationBodies,
+  findRunBodies,
   findTrailDefinitions,
   offsetToLine,
   parse,
@@ -63,7 +63,7 @@ const isResultMemberCall = (callee: AstNode): boolean => {
   if (objName === 'ctx' && propName === 'follow') {
     return true;
   }
-  return propName === 'implementation';
+  return propName === 'run';
 };
 
 // ---------------------------------------------------------------------------
@@ -158,6 +158,63 @@ const trackResultVariable = (node: AstNode, resultVars: Set<string>): void => {
   }
 };
 
+// ---------------------------------------------------------------------------
+// Shallow walk (stops at nested function boundaries)
+// ---------------------------------------------------------------------------
+
+const FUNCTION_BOUNDARY_TYPES = new Set([
+  'ArrowFunctionExpression',
+  'FunctionExpression',
+  'FunctionDeclaration',
+]);
+
+/** Check if a value is a function-boundary AST node that should not be recursed into. */
+const isFunctionBoundary = (val: unknown): boolean =>
+  !!val &&
+  typeof val === 'object' &&
+  FUNCTION_BOUNDARY_TYPES.has((val as AstNode).type);
+
+/** Recurse into a single AST property value, skipping function boundaries. */
+const visitValue = (
+  val: unknown,
+  visit: (node: AstNode) => void,
+  recurse: (node: unknown, visit: (node: AstNode) => void) => void
+): void => {
+  if (Array.isArray(val)) {
+    for (const item of val) {
+      if (!isFunctionBoundary(item)) {
+        recurse(item, visit);
+      }
+    }
+  } else if (
+    val &&
+    typeof val === 'object' &&
+    (val as AstNode).type &&
+    !isFunctionBoundary(val)
+  ) {
+    recurse(val, visit);
+  }
+};
+
+/**
+ * Walk an AST node tree without recursing into nested function bodies.
+ *
+ * This ensures that return statements inside `.map()`, `.filter()`, `.then()`
+ * callbacks etc. are not mistakenly checked as implementation-level returns.
+ */
+const walkShallow = (node: unknown, visit: (node: AstNode) => void): void => {
+  if (!node || typeof node !== 'object') {
+    return;
+  }
+  const n = node as AstNode;
+  if (n.type) {
+    visit(n);
+  }
+  for (const val of Object.values(n)) {
+    visitValue(val, visit, walkShallow);
+  }
+};
+
 // ---------------------------------------------------------------------------
 // Return statement checking
 // ---------------------------------------------------------------------------
@@ -173,7 +230,7 @@ const checkReturnStatements = (
 ): void => {
   const resultVars = new Set<string>();
 
-  walk(blockBody, (node) => {
+  walkShallow(blockBody, (node) => {
     if (node.type === 'VariableDeclarator') {
       trackResultVariable(node, resultVars);
     }
@@ -304,8 +361,8 @@ const checkAllDefinitions = (
   const helperNames = collectResultHelperNames(ast, sourceCode);
 
   for (const def of findTrailDefinitions(ast)) {
-    const info = { id: def.id, label: def.kind === 'hike' ? 'Hike' : 'Trail' };
-    for (const implValue of findImplementationBodies(def.config as AstNode)) {
+    const info = { id: def.id, label: 'Trail' };
+    for (const implValue of findRunBodies(def.config as AstNode)) {
       checkImplementation(
         implValue,
         info,

package/src/rules/index.ts

@@ -29,14 +29,7 @@ export { noThrowInDetourTarget } from './no-throw-in-detour-target.js';
 export { preferSchemaInference } from './prefer-schema-inference.js';
 export { validDescribeRefs } from './valid-describe-refs.js';
 
-/**
- * All built-in warden rules, keyed by rule name.
- *
- * Rules that duplicate validateTopo checks (follows-trails-exist,
- * no-recursive-follows, event-origins-exist, examples-match-schema,
- * require-output-schema) and follows-matches-calls (now covered by
- * testExamples follows coverage) have been removed.
- */
+/** All built-in warden rules, keyed by rule name. */
 export const wardenRules: ReadonlyMap<string, WardenRule> = new Map<
   string,
   WardenRule

package/src/rules/no-direct-impl-in-route.ts

@@ -1,14 +1,15 @@
 /**
- * Detects hike implementations that call `.implementation()` directly.
+ * Detects trail implementations with `follow` that call `.run()` directly.
  *
- * Uses AST parsing to find hike definition bodies and check for
- * `.implementation()` call expressions.
+ * Uses AST parsing to find trail definitions that declare `follow` and check for
+ * `.run()` call expressions in their bodies.
  */
 
 import {
-  findImplementationBodies,
+  findConfigProperty,
+  findRunBodies,
   findTrailDefinitions,
-  isImplementationCall,
+  isRunCall,
   offsetToLine,
   parse,
   walk,
@@ -22,20 +23,20 @@ interface AstNode {
   readonly [key: string]: unknown;
 }
 
-const findImplCallsInHike = (
+const findImplCallsInTrailWithFollow = (
   def: { readonly config: AstNode },
   filePath: string,
   sourceCode: string,
   diagnostics: WardenDiagnostic[]
 ): void => {
-  for (const body of findImplementationBodies(def.config as AstNode)) {
+  for (const body of findRunBodies(def.config as AstNode)) {
     walk(body, (node) => {
-      if (isImplementationCall(node as AstNode)) {
+      if (isRunCall(node as AstNode)) {
         diagnostics.push({
           filePath,
           line: offsetToLine(sourceCode, node.start),
           message:
-            'Use ctx.follow("trailId", input) instead of direct .implementation() calls. ctx.follow() validates input and propagates tracing.',
+            'Use ctx.follow("trailId", input) instead of direct .run() calls. ctx.follow() validates input and propagates tracing.',
           rule: 'no-direct-impl-in-route',
           severity: 'warn',
         });
@@ -44,12 +45,15 @@ const findImplCallsInHike = (
   }
 };
 
+const hasFollowProperty = (config: AstNode): boolean =>
+  findConfigProperty(config as AstNode, 'follow') !== null;
+
 /**
- * Detects routes that call another trail's `.implementation()` directly.
+ * Detects trails with `follow` that call another trail's `.run()` directly.
  */
 export const noDirectImplInRoute: WardenRule = {
   check(sourceCode: string, filePath: string): readonly WardenDiagnostic[] {
-    if (!/\bhike\s*\(/.test(sourceCode)) {
+    if (!/\btrail\s*\(/.test(sourceCode)) {
       return [];
     }
 
@@ -59,18 +63,18 @@ export const noDirectImplInRoute: WardenRule = {
     }
 
     const diagnostics: WardenDiagnostic[] = [];
-    const hikeDefs = findTrailDefinitions(ast as AstNode).filter(
-      (d) => d.kind === 'hike'
+    const followDefs = findTrailDefinitions(ast as AstNode).filter((d) =>
+      hasFollowProperty(d.config as AstNode)
     );
 
-    for (const def of hikeDefs) {
-      findImplCallsInHike(def, filePath, sourceCode, diagnostics);
+    for (const def of followDefs) {
+      findImplCallsInTrailWithFollow(def, filePath, sourceCode, diagnostics);
     }
 
     return diagnostics;
   },
   description:
-    'Prefer ctx.follow() over direct .implementation() calls in route bodies.',
+    'Prefer ctx.follow() over direct .run() calls in trail bodies with follow.',
   name: 'no-direct-impl-in-route',
 
   severity: 'warn',

package/src/rules/no-direct-implementation-call.ts

@@ -1,16 +1,16 @@
 /**
- * Flags direct `.implementation()` calls in application code.
+ * Flags direct `.run()` calls in application code.
  *
- * Uses AST parsing to find `.implementation()` call expressions,
+ * Uses AST parsing to find `.run()` call expressions,
  * ignoring occurrences in strings and comments.
  */
 
-import { isImplementationCall, offsetToLine, parse, walk } from './ast.js';
+import { isRunCall, offsetToLine, parse, walk } from './ast.js';
 import { isFrameworkInternalFile, isTestFile } from './scan.js';
 import type { WardenDiagnostic, WardenRule } from './types.js';
 
 /**
- * Flags direct `.implementation()` calls in application code.
+ * Flags direct `.run()` calls in application code.
  */
 export const noDirectImplementationCall: WardenRule = {
   check(sourceCode: string, filePath: string): readonly WardenDiagnostic[] {
@@ -26,12 +26,12 @@ export const noDirectImplementationCall: WardenRule = {
     const diagnostics: WardenDiagnostic[] = [];
 
     walk(ast, (node) => {
-      if (isImplementationCall(node)) {
+      if (isRunCall(node)) {
         diagnostics.push({
           filePath,
           line: offsetToLine(sourceCode, node.start),
           message:
-            'Use ctx.follow("trailId", input) instead of direct .implementation() calls. Direct implementation access bypasses validation, tracing, and layers.',
+            'Use ctx.follow("trailId", input) instead of direct .run() calls. Direct implementation access bypasses validation, tracing, and layers.',
           rule: 'no-direct-implementation-call',
           severity: 'warn',
         });
@@ -41,7 +41,7 @@ export const noDirectImplementationCall: WardenRule = {
     return diagnostics;
   },
   description:
-    'Disallow direct .implementation() calls in application code. Use ctx.follow() instead.',
+    'Disallow direct .run() calls in application code. Use ctx.follow() instead.',
   name: 'no-direct-implementation-call',
   severity: 'warn',
 };

package/src/rules/no-sync-result-assumption.ts

@@ -7,10 +7,10 @@ import {
 
 const RESULT_ACCESS_PATTERN =
   /\.(?:isOk|isErr|match|map)\s*\(|\.(?:value|error)\b/;
-const IMPLEMENTATION_CALL_PATTERN = /\.implementation\s*\(/;
+const IMPLEMENTATION_CALL_PATTERN = /\.run\s*\(/;
 
 const isAwaitedImplementationCall = (line: string): boolean => {
-  const callIndex = line.indexOf('.implementation(');
+  const callIndex = line.indexOf('.run(');
   if (callIndex === -1) {
     return false;
   }
@@ -39,7 +39,7 @@ interface PendingCall {
 }
 
 const MISSING_AWAIT_MESSAGE =
-  'Missing await: .implementation() returns Promise<Result> after normalization. Use `const result = await trail.implementation(input, ctx)`.';
+  'Missing await: .run() returns Promise<Result> after normalization. Use `const result = await trail.run(input, ctx)`.';
 
 const createMissingAwaitDiagnostic = (
   filePath: string,
@@ -140,7 +140,7 @@ const scanSourceCode = (
 };
 
 /**
- * Flags code that assumes `.implementation()` returns a synchronous result.
+ * Flags code that assumes `.run()` returns a synchronous result.
  */
 export const noSyncResultAssumption: WardenRule = {
   check(sourceCode: string, filePath: string): readonly WardenDiagnostic[] {
@@ -150,7 +150,7 @@ export const noSyncResultAssumption: WardenRule = {
     return scanSourceCode(stripQuotedContent(sourceCode), filePath);
   },
   description:
-    'Disallow treating .implementation() as synchronous after normalization. Always await the returned Promise<Result>.',
+    'Disallow treating .run() as synchronous after normalization. Always await the returned Promise<Result>.',
   name: 'no-sync-result-assumption',
   severity: 'error',
 };

package/src/rules/no-throw-in-detour-target.ts

@@ -6,7 +6,7 @@
  */
 
 import {
-  findImplementationBodies,
+  findRunBodies,
   findTrailDefinitions,
   offsetToLine,
   parse,
@@ -66,7 +66,7 @@ const findThrowsInTargetedTrails = (
       continue;
     }
 
-    for (const body of findImplementationBodies(def.config as AstNode)) {
+    for (const body of findRunBodies(def.config as AstNode)) {
       walk(body, (node) => {
         if (node.type === 'ThrowStatement') {
           diagnostics.push({

package/src/rules/no-throw-in-implementation.ts

@@ -1,11 +1,11 @@
 /**
- * Finds `throw` statements inside `implementation:` function bodies.
+ * Finds `throw` statements inside `run:` function bodies.
  *
  * Uses AST parsing for accurate detection — no false positives from
  * throw in comments, strings, or nested non-implementation functions.
  */
 
-import { findImplementationBodies, offsetToLine, parse, walk } from './ast.js';
+import { findRunBodies, offsetToLine, parse, walk } from './ast.js';
 import type { WardenDiagnostic, WardenRule } from './types.js';
 
 export const noThrowInImplementation: WardenRule = {
@@ -17,7 +17,7 @@ export const noThrowInImplementation: WardenRule = {
 
     const diagnostics: WardenDiagnostic[] = [];
 
-    for (const body of findImplementationBodies(ast)) {
+    for (const body of findRunBodies(ast)) {
       walk(body, (node) => {
         if (node.type === 'ThrowStatement') {
           diagnostics.push({