@ontrails/warden 1.0.0-beta.0 → 1.0.0-beta.10

package/dist/trails/wrap-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap-rule.d.ts","sourceRoot":"","sources":["../../src/trails/wrap-rule.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C,OAAO,KAAK,EAAE,sBAAsB,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE5E,OAAO,KAAK,EAAE,qBAAqB,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEhF,UAAU,eAAe;IACvB,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC,UAAU,CAAC,CAAC;CAC7D;AAED,UAAU,2BAA2B;IACnC,sDAAsD;IACtD,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IACtC,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,qBAAqB,EAAE,UAAU,CAAC,CAAC,UAAU,CAAC,CAAC;CACzE;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,2BAA2B,GACnC,KAAK,CAAC,qBAAqB,EAAE,UAAU,CAAC,CAAC;AAC5C,wBAAgB,QAAQ,CACtB,OAAO,EAAE,eAAe,GACvB,KAAK,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC"}

package/dist/trails/wrap-rule.js

@@ -0,0 +1,43 @@
+/**
+ * Factory that wraps a WardenRule as a trail.
+ *
+ * Keeps each rule trail file minimal — just the import + examples.
+ */
+import { trail, Result } from '@ontrails/core';
+import { projectAwareRuleInput, ruleInput, ruleOutput } from './schema.js';
+export function wrapRule(options) {
+    const { rule, examples } = options;
+    const isProjectAware = 'checkWithContext' in rule;
+    if (isProjectAware) {
+        const projectAwareRule = rule;
+        return trail(`warden.rule.${rule.name}`, {
+            description: rule.description,
+            examples: examples,
+            input: projectAwareRuleInput,
+            intent: 'read',
+            metadata: { category: 'governance', severity: rule.severity },
+            output: ruleOutput,
+            run: (input) => {
+                const diagnostics = projectAwareRule.checkWithContext(input.sourceCode, input.filePath, {
+                    knownTrailIds: input.knownTrailIds
+                        ? new Set(input.knownTrailIds)
+                        : new Set(),
+                });
+                return Result.ok({ diagnostics: [...diagnostics] });
+            },
+        });
+    }
+    return trail(`warden.rule.${rule.name}`, {
+        description: rule.description,
+        examples: examples,
+        input: ruleInput,
+        intent: 'read',
+        metadata: { category: 'governance', severity: rule.severity },
+        output: ruleOutput,
+        run: (input) => {
+            const diagnostics = rule.check(input.sourceCode, input.filePath);
+            return Result.ok({ diagnostics: [...diagnostics] });
+        },
+    });
+}
+//# sourceMappingURL=wrap-rule.js.map

package/dist/trails/wrap-rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap-rule.js","sourceRoot":"","sources":["../../src/trails/wrap-rule.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAI/C,OAAO,EAAE,qBAAqB,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AA4B3E,MAAM,UAAU,QAAQ,CACtB,OAAsD;IAEtD,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,OAAO,CAAC;IACnC,MAAM,cAAc,GAAG,kBAAkB,IAAI,IAAI,CAAC;IAElD,IAAI,cAAc,EAAE,CAAC;QACnB,MAAM,gBAAgB,GAAG,IAA8B,CAAC;QACxD,OAAO,KAAK,CAAC,eAAe,IAAI,CAAC,IAAI,EAAE,EAAE;YACvC,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,QAAQ,EAAE,QAGG;YACb,KAAK,EAAE,qBAAqB;YAC5B,MAAM,EAAE,MAAM;YACd,QAAQ,EAAE,EAAE,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE;YAC7D,MAAM,EAAE,UAAU;YAClB,GAAG,EAAE,CAAC,KAA4B,EAAE,EAAE;gBACpC,MAAM,WAAW,GAAG,gBAAgB,CAAC,gBAAgB,CACnD,KAAK,CAAC,UAAU,EAChB,KAAK,CAAC,QAAQ,EACd;oBACE,aAAa,EAAE,KAAK,CAAC,aAAa;wBAChC,CAAC,CAAC,IAAI,GAAG,CAAC,KAAK,CAAC,aAAa,CAAC;wBAC9B,CAAC,CAAC,IAAI,GAAG,EAAU;iBACtB,CACF,CAAC;gBACF,OAAO,MAAM,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC;YACtD,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAED,OAAO,KAAK,CAAC,eAAe,IAAI,CAAC,IAAI,EAAE,EAAE;QACvC,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,QAAQ,EAAE,QAAoD;QAC9D,KAAK,EAAE,SAAS;QAChB,MAAM,EAAE,MAAM;QACd,QAAQ,EAAE,EAAE,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE;QAC7D,MAAM,EAAE,UAAU;QAClB,GAAG,EAAE,CAAC,KAAgB,EAAE,EAAE;YACxB,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;YACjE,OAAO,MAAM,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC;QACtD,CAAC;KACF,CAAC,CAAC;AACL,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ontrails/warden",
-  "version": "1.0.0-beta.0",
+  "version": "1.0.0-beta.10",
   "type": "module",
   "exports": {
     ".": "./src/index.ts",
@@ -14,12 +14,13 @@
     "clean": "rm -rf dist *.tsbuildinfo"
   },
   "devDependencies": {
+    "@ontrails/testing": "^1.0.0-beta.8",
     "@oxc-project/types": "^0.122.0",
     "oxc-parser": "^0.121.0",
-    "zod": "catalog:"
+    "zod": "^4.3.5"
   },
   "peerDependencies": {
-    "@ontrails/core": "workspace:*",
-    "@ontrails/schema": "workspace:*"
+    "@ontrails/core": "^1.0.0-beta.8",
+    "@ontrails/schema": "^1.0.0-beta.8"
   }
 }

package/src/__tests__/cli.test.ts

@@ -21,7 +21,7 @@ describe('runWarden', () => {
       writeFileSync(
         join(dir, 'bad.ts'),
         `trail("entity.show", {
-  implementation: async (input, ctx) => {
+  run: async (input, ctx) => {
     throw new Error("boom");
   }
 })`
@@ -41,7 +41,7 @@ describe('runWarden', () => {
       writeFileSync(
         join(dir, 'good.ts'),
         `trail("entity.show", {
-  implementation: async (input, ctx) => {
+  run: async (input, ctx) => {
     return Result.ok(data);
   }
 })`
@@ -72,7 +72,7 @@ describe('runWarden', () => {
       // Even with bad code, driftOnly should produce 0 diagnostics
       writeFileSync(
         join(dir, 'bad.ts'),
-        `trail("x", { implementation: async () => { throw new Error("x"); } })`
+        `trail("x", { run: async () => { throw new Error("x"); } })`
       );
       const report = await runWarden({ driftOnly: true, rootDir: dir });
       expect(report.diagnostics.length).toBe(0);
@@ -89,7 +89,7 @@ describe('runWarden', () => {
         join(dir, 'show.ts'),
         `trail("entity.show", {
   detours: { NotFoundError: ["entity.search"] },
-  implementation: async (input, ctx) => {
+  run: async (input, ctx) => {
     return Result.ok(data);
   }
 })`
@@ -97,7 +97,7 @@ describe('runWarden', () => {
       writeFileSync(
         join(dir, 'search.ts'),
         `trail("entity.search", {
-  implementation: async (input, ctx) => {
+  run: async (input, ctx) => {
     return Result.ok(data);
   }
 })`
@@ -121,7 +121,7 @@ describe('runWarden', () => {
         join(dir, 'show.ts'),
         `trail("entity.show", {
   detours: { NotFoundError: ["entity.search"] },
-  implementation: async (input, ctx) => {
+  run: async (input, ctx) => {
     return Result.ok(data);
   }
 })`
@@ -129,7 +129,7 @@ describe('runWarden', () => {
       writeFileSync(
         join(dir, 'search.ts'),
         `trail("entity.search", {
-  implementation: async (input, ctx) => {
+  run: async (input, ctx) => {
     throw new Error("boom");
   }
 })`

package/src/__tests__/drift.test.ts

@@ -11,9 +11,9 @@ import { checkDrift } from '../drift.js';
 
 const makeTopo = () => {
   const t = trail('test.hello', {
-    implementation: () => Result.ok({ greeting: 'hi' }),
     input: z.object({ name: z.string() }),
     output: z.object({ greeting: z.string() }),
+    run: () => Result.ok({ greeting: 'hi' }),
   });
   return topo('test-app', { t });
 };

package/src/__tests__/follow-declarations.test.ts

@@ -0,0 +1,303 @@
+import { describe, expect, test } from 'bun:test';
+
+import { followDeclarations } from '../rules/follow-declarations.js';
+
+const TEST_FILE = 'test.ts';
+
+describe('follow-declarations', () => {
+  describe('clean cases', () => {
+    test('declared and called match exactly', () => {
+      const code = `
+import { trail, Result } from '@ontrails/core';
+const t = trail('onboard', {
+  follow: ['entity.add', 'search'],
+  input: z.object({ name: z.string() }),
+  run: async (input, ctx) => {
+    await ctx.follow('entity.add', { name: input.name });
+    await ctx.follow('search', { query: input.name });
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = followDeclarations.check(code, TEST_FILE);
+
+      expect(diagnostics.length).toBe(0);
+    });
+
+    test('no follow declaration and no ctx.follow() calls', () => {
+      const code = `
+trail('simple', {
+  input: z.object({ name: z.string() }),
+  run: async (input, ctx) => {
+    return Result.ok({ greeting: 'hello ' + input.name });
+  },
+});
+`;
+
+      const diagnostics = followDeclarations.check(code, TEST_FILE);
+
+      expect(diagnostics.length).toBe(0);
+    });
+  });
+
+  describe('error cases', () => {
+    test('called but not declared produces error', () => {
+      const code = `
+trail('onboard', {
+  input: z.object({ name: z.string() }),
+  run: async (input, ctx) => {
+    await ctx.follow('entity.add', { name: input.name });
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = followDeclarations.check(code, TEST_FILE);
+
+      expect(diagnostics.length).toBe(1);
+      expect(diagnostics[0]?.severity).toBe('error');
+      expect(diagnostics[0]?.rule).toBe('follow-declarations');
+      expect(diagnostics[0]?.message).toContain("ctx.follow('entity.add')");
+      expect(diagnostics[0]?.message).toContain('not declared in follow');
+    });
+  });
+
+  describe('warn cases', () => {
+    test('declared but not called produces warning', () => {
+      const code = `
+trail('onboard', {
+  follow: ['entity.add', 'search'],
+  run: async (input, ctx) => {
+    await ctx.follow('entity.add', { name: input.name });
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = followDeclarations.check(code, TEST_FILE);
+
+      expect(diagnostics.length).toBe(1);
+      expect(diagnostics[0]?.severity).toBe('warn');
+      expect(diagnostics[0]?.rule).toBe('follow-declarations');
+      expect(diagnostics[0]?.message).toContain("'search' declared in follow");
+      expect(diagnostics[0]?.message).toContain('never called');
+    });
+  });
+
+  describe('single-object overload', () => {
+    test('recognizes trail({ id, follow, run }) form', () => {
+      const code = `
+trail({
+  id: 'onboard',
+  follow: ['entity.add'],
+  input: z.object({ name: z.string() }),
+  run: async (input, ctx) => {
+    await ctx.follow('entity.add', { name: input.name });
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = followDeclarations.check(code, TEST_FILE);
+
+      expect(diagnostics.length).toBe(0);
+    });
+
+    test('detects undeclared follows in single-object form', () => {
+      const code = `
+trail({
+  id: 'onboard',
+  input: z.object({ name: z.string() }),
+  run: async (input, ctx) => {
+    await ctx.follow('entity.add', { name: input.name });
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = followDeclarations.check(code, TEST_FILE);
+
+      expect(diagnostics.length).toBe(1);
+      expect(diagnostics[0]?.severity).toBe('error');
+      expect(diagnostics[0]?.message).toContain("'entity.add'");
+    });
+  });
+
+  describe('context parameter naming', () => {
+    test('recognizes context.follow() when second param is named context', () => {
+      const code = `
+trail('onboard', {
+  follow: ['entity.add'],
+  input: z.object({ name: z.string() }),
+  run: async (input, context) => {
+    await context.follow('entity.add', { name: input.name });
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = followDeclarations.check(code, TEST_FILE);
+
+      expect(diagnostics.length).toBe(0);
+    });
+
+    test('detects undeclared context.follow() calls', () => {
+      const code = `
+trail('onboard', {
+  input: z.object({ name: z.string() }),
+  run: async (input, context) => {
+    await context.follow('entity.add', { name: input.name });
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = followDeclarations.check(code, TEST_FILE);
+
+      expect(diagnostics.length).toBe(1);
+      expect(diagnostics[0]?.severity).toBe('error');
+    });
+
+    test('recognizes destructured follow() calls', () => {
+      const code = `
+trail('onboard', {
+  follow: ['entity.add'],
+  input: z.object({ name: z.string() }),
+  run: async (input, ctx) => {
+    const { follow } = ctx;
+    await follow('entity.add', { name: input.name });
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = followDeclarations.check(code, TEST_FILE);
+
+      expect(diagnostics.length).toBe(0);
+    });
+  });
+
+  describe('nested run false positives', () => {
+    test('metadata.run does not trigger false positives', () => {
+      const code = `
+trail('onboard', {
+  follow: ['entity.add'],
+  input: z.object({ name: z.string() }),
+  metadata: { run: async () => ctx.follow('phantom') },
+  run: async (input, ctx) => {
+    await ctx.follow('entity.add', { name: input.name });
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = followDeclarations.check(code, TEST_FILE);
+
+      expect(diagnostics.length).toBe(0);
+    });
+  });
+
+  describe('identifier resolution in follow arrays', () => {
+    test('resolves const identifiers in follow array', () => {
+      const code = `
+const ENTITY_ADD = 'entity.add';
+trail('onboard', {
+  follow: [ENTITY_ADD],
+  input: z.object({ name: z.string() }),
+  run: async (input, ctx) => {
+    await ctx.follow('entity.add', { name: input.name });
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = followDeclarations.check(code, TEST_FILE);
+
+      expect(diagnostics.length).toBe(0);
+    });
+
+    test('reports error when resolved identifier does not match called follow', () => {
+      const code = `
+const ENTITY_ADD = 'entity.add';
+trail('onboard', {
+  follow: [ENTITY_ADD],
+  input: z.object({ name: z.string() }),
+  run: async (input, ctx) => {
+    await ctx.follow('search', { name: input.name });
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = followDeclarations.check(code, TEST_FILE);
+
+      // 'search' called but not declared, 'entity.add' declared but not called
+      expect(diagnostics.length).toBe(2);
+    });
+  });
+
+  describe('edge cases', () => {
+    test('dynamic follow IDs are skipped', () => {
+      const code = `
+trail('dispatch', {
+  follow: ['entity.add'],
+  run: async (input, ctx) => {
+    const trailId = input.target;
+    await ctx.follow(trailId, input);
+    await ctx.follow('entity.add', input);
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = followDeclarations.check(code, TEST_FILE);
+
+      expect(diagnostics.length).toBe(0);
+    });
+
+    test('multiple trails in one file are validated independently', () => {
+      const code = `
+trail('alpha', {
+  follow: ['shared'],
+  run: async (input, ctx) => {
+    await ctx.follow('shared', input);
+    return Result.ok({});
+  },
+});
+
+trail('beta', {
+  run: async (input, ctx) => {
+    await ctx.follow('undeclared', input);
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = followDeclarations.check(code, TEST_FILE);
+
+      expect(diagnostics.length).toBe(1);
+      expect(diagnostics[0]?.message).toContain('Trail "beta"');
+      expect(diagnostics[0]?.message).toContain("'undeclared'");
+      expect(diagnostics[0]?.severity).toBe('error');
+    });
+
+    test('skips test files', () => {
+      const code = `
+trail('onboard', {
+  run: async (input, ctx) => {
+    await ctx.follow('entity.add', input);
+    return Result.ok({});
+  },
+});
+`;
+
+      const diagnostics = followDeclarations.check(
+        code,
+        'src/__tests__/trails.test.ts'
+      );
+
+      expect(diagnostics.length).toBe(0);
+    });
+  });
+});

package/src/__tests__/implementation-returns-result.test.ts

@@ -8,7 +8,7 @@ describe('implementation-returns-result', () => {
   test('flags raw object return in trail implementation', () => {
     const code = `
 trail("entity.show", {
-  implementation: async (input, ctx) => {
+  run: async (input, ctx) => {
     return { name: "foo" };
   }
 })`;
@@ -22,15 +22,16 @@ trail("entity.show", {
 
   test('allows Result.ok() and returning ctx.follow() results', () => {
     const code = `
-hike("entity.onboard", {
-  implementation: async (input, ctx) => {
+trail("entity.onboard", {
+  follow: ["entity.create"],
+  run: async (input, ctx) => {
     const result = await ctx.follow("entity.create", input);
     return result;
   }
 })
 
 trail("entity.create", {
-  implementation: async (input, ctx) => Result.ok({ id: "123" })
+  run: async (input, ctx) => Result.ok({ id: "123" })
 })`;
 
     const diagnostics = implementationReturnsResult.check(code, TEST_FILE);
@@ -41,7 +42,7 @@ trail("entity.create", {
   test('flags concise raw implementation bodies', () => {
     const code = `
 trail("entity.create", {
-  implementation: async (input, ctx) => ({ id: "123" })
+  run: async (input, ctx) => ({ id: "123" })
 })`;
 
     const diagnostics = implementationReturnsResult.check(code, TEST_FILE);
@@ -50,6 +51,59 @@ trail("entity.create", {
     expect(diagnostics[0]?.message).toContain('entity.create');
   });
 
+  test('ignores return statements inside nested callbacks like .map()', () => {
+    const code = `
+trail("entity.list", {
+  run: async (input, ctx) => {
+    const items = ["a", "b", "c"];
+    const mapped = items.map((item) => {
+      return { name: item };
+    });
+    const filtered = items.filter((item) => {
+      return item !== "b";
+    });
+    return Result.ok(mapped);
+  }
+})`;
+
+    const diagnostics = implementationReturnsResult.check(code, TEST_FILE);
+
+    expect(diagnostics.length).toBe(0);
+  });
+
+  test('ignores return statements inside .then() callbacks', () => {
+    const code = `
+trail("entity.fetch", {
+  run: async (input, ctx) => {
+    const data = await somePromise.then((res) => {
+      return res.json();
+    });
+    return Result.ok(data);
+  }
+})`;
+
+    const diagnostics = implementationReturnsResult.check(code, TEST_FILE);
+
+    expect(diagnostics.length).toBe(0);
+  });
+
+  test('still flags raw returns at the implementation level', () => {
+    const code = `
+trail("entity.list", {
+  run: async (input, ctx) => {
+    const items = ["a", "b"].map((item) => {
+      return { name: item };
+    });
+    return items;
+  }
+})`;
+
+    const diagnostics = implementationReturnsResult.check(code, TEST_FILE);
+
+    expect(diagnostics.length).toBe(1);
+    expect(diagnostics[0]?.message).toContain('entity.list');
+  });
+
   test('allows returning explicitly Result-typed local helpers', () => {
     const code = `
 const buildDetail = (trailId: string): Result<object, Error> =>
@@ -59,7 +113,7 @@ const buildDiff = async (): Promise<Result<object, Error>> =>
   Result.ok({ breaking: [] });
 
 trail("survey", {
-  implementation: async (input, ctx) => {
+  run: async (input, ctx) => {
     if (input.diff) {
       return await buildDiff();
     }

package/src/__tests__/no-direct-implementation-call.test.ts

@@ -8,11 +8,11 @@ describe('no-direct-implementation-call', () => {
 import { trail, Result } from "@ontrails/core";
 
 const entityShow = trail("entity.show", {
-  implementation: async (input, ctx) => Result.ok({ id: input.id }),
+  run: async (input, ctx) => Result.ok({ id: input.id }),
 });
 
 async function run() {
-  const result = await entityShow.implementation({ id: "1" }, ctx);
+  const result = await entityShow.run({ id: "1" }, ctx);
   return result;
 }`;
 
@@ -26,9 +26,9 @@ async function run() {
 
   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", input);
     return Result.ok(result);
   },
@@ -43,7 +43,7 @@ hike("entity.onboard", {
   test('ignores test files', () => {
     const code = `
 async function run() {
-  return await entityShow.implementation({ id: "1" }, ctx);
+  return await entityShow.run({ id: "1" }, ctx);
 }`;
 
     const diagnostics = noDirectImplementationCall.check(
@@ -57,7 +57,7 @@ async function run() {
   test('ignores framework internals that intentionally call implementations', () => {
     const code = `
 export async function run() {
-  return await entityShow.implementation({ id: "1" }, ctx);
+  return await entityShow.run({ id: "1" }, ctx);
 }`;
 
     const diagnostics = noDirectImplementationCall.check(
@@ -70,7 +70,7 @@ export async function run() {
 
   test('ignores implementation references inside template strings', () => {
     const code = `
-const generated = \`const result = await entityShow.implementation({ id: "1" }, ctx);\`;
+const generated = \`const result = await entityShow.run({ id: "1" }, ctx);\`;
 `;
 
     const diagnostics = noDirectImplementationCall.check(

package/src/__tests__/no-sync-result-assumption.test.ts

@@ -6,7 +6,7 @@ describe('no-sync-result-assumption', () => {
   test('flags direct result access on implementation calls', () => {
     const code = `
 async function run() {
-  const isOk = entityShow.implementation({ id: "1" }, ctx).isOk();
+  const isOk = entityShow.run({ id: "1" }, ctx).isOk();
   return isOk;
 }`;
 
@@ -20,7 +20,7 @@ async function run() {
 
   test('flags a stored implementation result that is used synchronously', () => {
     const code = `
-const result = entityShow.implementation({ id: "1" }, ctx);
+const result = entityShow.run({ id: "1" }, ctx);
 
 if (result.isOk()) {
   console.log("ok");
@@ -35,7 +35,7 @@ if (result.isOk()) {
   test('allows awaited implementation calls before result access', () => {
     const code = `
 async function run() {
-  const result = await entityShow.implementation({ id: "1" }, ctx);
+  const result = await entityShow.run({ id: "1" }, ctx);
   return result.isOk();
 }`;
 
@@ -47,7 +47,7 @@ async function run() {
   test('allows awaited implementation calls when the property access is chained', () => {
     const code = `
 async function run() {
-  return (await entityShow.implementation({ id: "1" }, ctx)).isOk();
+  return (await entityShow.run({ id: "1" }, ctx)).isOk();
 }`;
 
     const diagnostics = noSyncResultAssumption.check(code, 'src/app.ts');
@@ -57,7 +57,7 @@ async function run() {
 
   test('ignores test files', () => {
     const code = `
-const result = entityShow.implementation({ id: "1" }, ctx);
+const result = entityShow.run({ id: "1" }, ctx);
 result.isOk();
 `;
 
@@ -71,7 +71,7 @@ result.isOk();
 
   test('ignores framework internals that intentionally call implementations', () => {
     const code = `
-const result = entityShow.implementation({ id: "1" }, ctx);
+const result = entityShow.run({ id: "1" }, ctx);
 result.isOk();
 `;