@ontrails/warden 1.0.0-beta.39 → 1.0.0-beta.41

package/src/rules/valid-describe-refs.ts

@@ -6,8 +6,8 @@ import {
   offsetToLine,
   parse,
   walk,
-} from './ast.js';
-import type { AstNode } from './ast.js';
+} from '@ontrails/source';
+import type { AstNode } from '@ontrails/source';
 import { isTestFile } from './scan.js';
 import { collectTrailIds } from './specs.js';
 import type {

package/src/rules/warden-export-symmetry.ts

@@ -21,8 +21,8 @@ import {
   getNodeDeclaration,
   getNodeDeclarations,
   getNodeElements,
-  getNodeExportKind,
   getNodeExported,
+  getNodeExportKind,
   getNodeId,
   getNodeKey,
   getNodeLeft,
@@ -35,8 +35,8 @@ import {
   offsetToLine,
   parse,
   walk,
-} from './ast.js';
-import type { AstNode } from './ast.js';
+} from '@ontrails/source';
+import type { AstNode } from '@ontrails/source';
 import { registeredRuleNames } from './registry-names.js';
 import type { WardenDiagnostic, WardenRule } from './types.js';
 

package/src/rules/warden-rules-use-ast.ts

@@ -1,6 +1,6 @@
 /**
  * Self-governance rule: warden rules must inspect the AST via the helpers in
- * `./ast.ts` rather than regex-scanning raw source text. Raw-text scans
+ * `../source/*` helpers rather than regex-scanning raw source text. Raw-text scans
  * produce false positives on string literals, template payloads, and
  * docstrings — see TRL-335 and ADR-0036.
  *
@@ -16,13 +16,12 @@
  *    bug as scanning with one — see TRL-345.
  * 4. `rawNodeFieldCastSite` — asserting AST nodes through
  *    `as unknown as { field?: ... }` where a typed accessor exists on
- *    `./ast.ts`.
+ *    `../source/*`.
  *
  * This rule is path-anchored to this package's own `src/rules/` directory so
  * it never fires against a consumer repo that happens to share the same
- * folder layout. `ast.ts` itself is excluded because it IS the raw-text
- * interface to the parser; `types.ts`, `index.ts`, `registry-names.ts`, and
- * anything under `__tests__` are also excluded.
+ * folder layout. Support modules such as `types.ts`, `index.ts`,
+ * `registry-names.ts`, and anything under `__tests__` are excluded.
  */
 import { basename as pathBasename, dirname, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -54,8 +53,8 @@ import {
   offsetToLine,
   parse,
   walk,
-} from './ast.js';
-import type { AstNode } from './ast.js';
+} from '@ontrails/source';
+import type { AstNode } from '@ontrails/source';
 import type { WardenDiagnostic, WardenRule } from './types.js';
 
 const RULE_NAME = 'warden-rules-use-ast';
@@ -109,12 +108,10 @@ const SELF_RULES_DIRS: ReadonlySet<string> = new Set(
 
 /**
  * Stems of files in `src/rules/` (and their bundled `dist/rules/` twins) that
- * are NOT themselves warden rules and therefore must not be checked. `ast` is
- * the raw-text interface to the parser and legitimately touches source text;
- * the others are support modules without a `check()` function.
+ * are not themselves Warden rules and therefore must not be checked. These
+ * are support modules without a `check()` function.
  */
 const EXCLUDED_STEMS: readonly string[] = [
-  'ast',
   'index',
   'registry-names',
   'scan',
@@ -125,9 +122,7 @@ const EXCLUDED_STEMS: readonly string[] = [
 
 /**
  * Both `.ts` (source layout) and `.js` (dist layout) basenames must be
- * excluded so the rule stays silent when pointed at a bundled tree. The
- * dist-layout `ast.js` contains the same raw-text parser entry point as
- * `ast.ts` and would false-positive if scanned.
+ * excluded so the rule stays silent when pointed at a bundled tree.
  */
 const EXCLUDED_BASENAMES: ReadonlySet<string> = new Set(
   EXCLUDED_STEMS.flatMap((stem) => [`${stem}.ts`, `${stem}.js`])
@@ -374,7 +369,7 @@ const regexConstructionSite = (node: AstNode): RegexConstructionSite | null => {
 };
 
 const DIAGNOSTIC_ADVICE =
-  'Warden rules must inspect the AST via packages/warden/src/rules/ast.ts helpers, not regex-scan raw source text. ' +
+  'Warden rules must inspect source code via @ontrails/source helpers, not regex-scan raw source text. ' +
   'Use findStringLiterals, findTrailDefinitions, findConfigProperty, or a similar AST walker. ' +
   'Raw-text scanning produces false positives on string literals, template payloads, and docstrings — see TRL-335, ADR-0036.';
 
@@ -514,7 +509,7 @@ const detectRawNodeFieldCast = (node: AstNode): DetectedSite | null => {
   const fields = entries.map(([field, accessor]) => `${field} -> ${accessor}`);
   return {
     identifier: expression,
-    message: `${RULE_NAME}: raw AST node-field cast should use typed helpers from ./ast.js (${fields.join(', ')}). Raw node-field casts drift from the curated @ontrails/warden/ast guard surface.`,
+    message: `${RULE_NAME}: raw AST node-field cast should use typed helpers from the shared source helpers (${fields.join(', ')}). Raw node-field casts drift from the shared source helper surface.`,
     severity: 'warn',
     start: node.start,
   };
@@ -1108,7 +1103,7 @@ export const wardenRulesUseAst: WardenRule = {
     return analyze(sourceCode, filePath, ast);
   },
   description:
-    'Enforces that warden rules inspect the AST via packages/warden/src/rules/ast.ts helpers rather than regex-scanning raw source text or hand-casting node fields.',
+    'Enforces that warden rules inspect source code via @ontrails/source helpers rather than regex-scanning raw source text or hand-casting node fields.',
   name: RULE_NAME,
   severity: 'error',
 };

package/src/trails/activation-orphan.trail.ts

@@ -9,7 +9,7 @@ const orphanSignal = signal('invoice.paid', {
 });
 
 const orphanConsumer = trail('invoice.audit', {
-  blaze: () => Result.ok({ ok: true }),
+  implementation: () => Result.ok({ ok: true }),
   input: z.object({ invoiceId: z.string() }),
   on: [orphanSignal],
   output: z.object({ ok: z.boolean() }),
@@ -21,24 +21,24 @@ const producedSignal = signal('invoice.created', {
 });
 
 const producerTrail = trail('invoice.create', {
-  blaze: async (_input, ctx) => {
+  fires: [producedSignal],
+  implementation: async (_input, ctx) => {
     await ctx.fire?.(producedSignal, { invoiceId: 'inv_1' });
     return Result.ok({ invoiceId: 'inv_1' });
   },
-  fires: [producedSignal],
   input: z.object({}),
   output: z.object({ invoiceId: z.string() }),
 });
 
 const producedConsumer = trail('invoice.index', {
-  blaze: () => Result.ok({ ok: true }),
+  implementation: () => Result.ok({ ok: true }),
   input: z.object({ invoiceId: z.string() }),
   on: [producedSignal],
   output: z.object({ ok: z.boolean() }),
 });
 
 const scheduledConsumer = trail('invoice.reconcile', {
-  blaze: () => Result.ok({ ok: true }),
+  implementation: () => Result.ok({ ok: true }),
   input: z.object({}),
   on: [schedule('schedule.invoice.reconcile', { cron: '0 * * * *' })],
   output: z.object({ ok: z.boolean() }),

package/src/trails/captured-kernel.trail.ts

@@ -0,0 +1,108 @@
+import { capturedKernel } from '../rules/captured-kernel.js';
+import { wrapRule } from './wrap-rule.js';
+
+export const capturedKernelTrail = wrapRule({
+  examples: [
+    {
+      expected: {
+        diagnostics: [
+          {
+            filePath: 'packages/core/src/kernel.ts',
+            guidance: {
+              steps: [
+                'Review whether the public subpath should become an owned package surface, move back behind the package root, or be split into a better-owned package.',
+                'If the imported capability is reusable source-code machinery, serves at least two independently owned toolchain capabilities, exposes one genuinely shared contract, and owns no verdict, migration plan, graph query, or surface rendering, consider relocating it to @ontrails/source.',
+                'Otherwise, preserve the current owner or choose another doctrinal owner.',
+              ],
+              summary:
+                'Review ownership before an internal re-exported kernel hardens into a public package seam.',
+            },
+            line: 1,
+            message:
+              '@ontrails/core export target "@ontrails/core/kernel" re-exports internal target "./internal/kernel.js" and is consumed by external production packages @ontrails/cli, @ontrails/store. Review ownership of the exported subpath and its captured kernel before it becomes a durable public seam.',
+            rule: 'captured-kernel',
+            severity: 'warn',
+          },
+        ],
+      },
+      input: {
+        filePath: 'packages/core/src/kernel.ts',
+        importResolutionsByFile: {
+          'packages/cli/src/index.ts': [
+            {
+              crossesPackageBoundary: true,
+              importSource: '@ontrails/core/kernel',
+              importerPath: 'packages/cli/src/index.ts',
+              isInternalTarget: false,
+              line: 1,
+              packageName: '@ontrails/core',
+              packageRoot: 'packages/core',
+              resolvedPath: 'packages/core/src/kernel.ts',
+              usesPublicExport: true,
+            },
+          ],
+          'packages/core/src/kernel.ts': [
+            {
+              crossesPackageBoundary: false,
+              importSource: './internal/kernel.js',
+              importerPath: 'packages/core/src/kernel.ts',
+              isInternalTarget: true,
+              line: 1,
+              packageName: '@ontrails/core',
+              packageRoot: 'packages/core',
+              resolvedPath: 'packages/core/src/internal/kernel.ts',
+              usesPublicExport: false,
+            },
+          ],
+          'packages/store/src/index.ts': [
+            {
+              crossesPackageBoundary: true,
+              importSource: '@ontrails/core/kernel',
+              importerPath: 'packages/store/src/index.ts',
+              isInternalTarget: false,
+              line: 1,
+              packageName: '@ontrails/core',
+              packageRoot: 'packages/core',
+              resolvedPath: 'packages/core/src/kernel.ts',
+              usesPublicExport: true,
+            },
+          ],
+        },
+        knownTrailIds: [],
+        publicWorkspaces: {
+          '@ontrails/cli': {
+            exportTargets: {
+              '@ontrails/cli': 'packages/cli/src/index.ts',
+            },
+            hasExports: true,
+            name: '@ontrails/cli',
+            packageJsonPath: 'packages/cli/package.json',
+            rootDir: 'packages/cli',
+          },
+          '@ontrails/core': {
+            exportTargets: {
+              '@ontrails/core': 'packages/core/src/index.ts',
+              '@ontrails/core/kernel': 'packages/core/src/kernel.ts',
+            },
+            hasExports: true,
+            name: '@ontrails/core',
+            packageJsonPath: 'packages/core/package.json',
+            rootDir: 'packages/core',
+          },
+          '@ontrails/store': {
+            exportTargets: {
+              '@ontrails/store': 'packages/store/src/index.ts',
+            },
+            hasExports: true,
+            name: '@ontrails/store',
+            packageJsonPath: 'packages/store/package.json',
+            rootDir: 'packages/store',
+          },
+        },
+        sourceCode: "export { kernel } from './internal/kernel.js';\n",
+      },
+      name: 'Flags captured kernels consumed by multiple production packages',
+    },
+  ],
+  rule: capturedKernel,
+});

package/src/trails/circular-refs.trail.ts

@@ -6,23 +6,23 @@ export const circularRefsTrail = wrapRule({
     {
       expected: { diagnostics: [] },
       input: {
-        contourReferencesByName: {
+        entityReferencesByName: {
           gist: ['user'],
           user: [],
         },
-        filePath: 'contours.ts',
-        knownContourIds: ['gist', 'user'],
+        filePath: 'entities.ts',
+        knownEntityIds: ['gist', 'user'],
         knownTrailIds: [],
-        sourceCode: `const user = contour("user", {
+        sourceCode: `const user = entity("user", {
   id: z.string().uuid(),
 }, { identity: "id" });
 
-const gist = contour("gist", {
+const gist = entity("gist", {
   id: z.string().uuid(),
   ownerId: user.id(),
 }, { identity: "id" });`,
       },
-      name: 'Acyclic contour references stay clean',
+      name: 'Acyclic entity references stay clean',
     },
   ],
   rule: circularRefs,

package/src/trails/cli-command-route-coherence.trail.ts

@@ -5,16 +5,16 @@ import { cliCommandRouteCoherence } from '../rules/cli-command-route-coherence.j
 import { wrapTopoRule } from './wrap-rule.js';
 
 const searchTrail = trail('wayfind.search', {
-  blaze: () => Result.ok([]),
   cli: {
     aliases: ['find'],
   },
+  implementation: () => Result.ok([]),
   input: z.object({ query: z.string() }),
   output: z.array(z.string()),
 });
 
 const collidingTrail = trail('wayfind.find', {
-  blaze: () => Result.ok([]),
+  implementation: () => Result.ok([]),
   input: z.object({ query: z.string() }),
   output: z.array(z.string()),
 });

package/src/trails/composes-declarations.trail.ts

@@ -9,7 +9,7 @@ export const composesDeclarationsTrail = wrapRule({
         filePath: 'clean.ts',
         sourceCode: `trail("entity.onboard", {
   composes: ["entity.create"],
-  blaze: async (input, ctx) => {
+  implementation: async (input, ctx) => {
     const result = await ctx.compose("entity.create", input);
     return Result.ok(result);
   }

package/src/trails/context-no-surface-types.trail.ts

@@ -9,7 +9,7 @@ export const contextNoSurfaceTypesTrail = wrapRule({
         filePath: 'clean.ts',
         sourceCode: `import { trail, Result } from "@ontrails/core";
 trail("entity.show", {
-  blaze: async (input, ctx) => {
+  implementation: async (input, ctx) => {
     return Result.ok({ name: "test" });
   }
 })`,

package/src/trails/dead-internal-trail.trail.ts

@@ -11,12 +11,12 @@ export const deadInternalTrailTrail = wrapRule({
         knownTrailIds: ['entity.public', 'entity.sync'],
         sourceCode: `trail('entity.public', {
   composes: ['entity.sync'],
-  blaze: async (_input, ctx) => ctx.compose('entity.sync', {}),
+  implementation: async (_input, ctx) => ctx.compose('entity.sync', {}),
 });
 
 trail('entity.sync', {
   visibility: 'internal',
-  blaze: async () => Result.ok({}),
+  implementation: async () => Result.ok({}),
 });`,
       },
       name: 'Internal trails stay clean when another trail composes them',

package/src/trails/dead-public-trail.trail.ts

@@ -20,7 +20,7 @@ export const deadPublicTrailTrail = wrapRule({
         filePath: 'packages/regrade/src/downstream/report.ts',
         knownTrailIds: ['regrade.downstream.report', 'regrade'],
         sourceCode: `export const regradeReportTrail = trail('regrade.downstream.report', {
-  blaze: async () => Result.ok({}),
+  implementation: async () => Result.ok({}),
 });`,
         topoTrailIds: ['regrade'],
       },

package/src/trails/deprecation-without-guidance.trail.ts

@@ -1,5 +1,5 @@
 import { topo } from '@ontrails/core';
-import { deriveTopoGraph } from '@ontrails/topographer';
+import { deriveTopoGraph } from '@ontrails/topography';
 
 import { deprecationWithoutGuidance } from '../rules/trail-versioning-topo.js';
 import { wrapTopoRule } from './wrap-rule.js';

package/src/trails/duplicate-public-contract.trail.ts

@@ -8,13 +8,13 @@ const sharedInput = z.object({ target: z.string() });
 const sharedOutput = z.object({ ok: z.boolean() });
 
 const canonicalTrail = trail('survey.diff', {
-  blaze: () => Result.ok({ ok: true }),
+  implementation: () => Result.ok({ ok: true }),
   input: sharedInput,
   output: sharedOutput,
 });
 
 const duplicateTrail = trail('diff', {
-  blaze: () => Result.ok({ ok: true }),
+  implementation: () => Result.ok({ ok: true }),
   input: sharedInput,
   output: sharedOutput,
 });
@@ -28,7 +28,7 @@ export const duplicatePublicContractTrail = wrapTopoRule({
             filePath: '<topo>',
             line: 1,
             message:
-              'Likely duplicate public trail contracts "diff", "survey.diff" share the same input, output, intent, permits, resources, contours, composes, signals, and detours. Keep one contract with aliases/input mappings, compose a distinct wrapper, or document why these public contracts are separate.',
+              'Likely duplicate public trail contracts "diff", "survey.diff" share the same input, output, intent, permits, resources, entities, composes, signals, and detours. Keep one contract with aliases/input mappings, compose a distinct wrapper, or document why these public contracts are separate.',
             rule: 'duplicate-public-contract',
             severity: 'warn',
           },

package/src/trails/entity-exists.trail.ts

@@ -0,0 +1,21 @@
+import { entityExists } from '../rules/entity-exists.js';
+import { wrapRule } from './wrap-rule.js';
+
+export const entityExistsTrail = wrapRule({
+  examples: [
+    {
+      expected: { diagnostics: [] },
+      input: {
+        filePath: 'entity.ts',
+        knownEntityIds: ['user'],
+        knownTrailIds: ['user.create'],
+        sourceCode: `trail("user.create", {
+  entities: [user],
+  implementation: async (input, ctx) => Result.ok({ ok: true }),
+})`,
+      },
+      name: 'Declared entities resolve to known project entities',
+    },
+  ],
+  rule: entityExists,
+});

package/src/trails/example-valid.trail.ts

@@ -6,8 +6,8 @@ export const exampleValidTrail = wrapRule({
     {
       expected: { diagnostics: [] },
       input: {
-        filePath: 'contours.ts',
-        sourceCode: `const user = contour("user", {
+        filePath: 'entities.ts',
+        sourceCode: `const user = entity("user", {
   id: z.string().uuid(),
   name: z.string(),
 }, {
@@ -18,7 +18,7 @@ export const exampleValidTrail = wrapRule({
   identity: "id",
 });`,
       },
-      name: 'Contour examples validate against their schema',
+      name: 'Entity examples validate against their schema',
     },
   ],
   rule: exampleValid,

package/src/trails/fires-declarations.trail.ts

@@ -10,7 +10,7 @@ export const firesDeclarationsTrail = wrapRule({
         sourceCode: `const entityCreated = signal("entity.created", { payload: z.object({}) });
 trail("entity.onboard", {
   fires: [entityCreated],
-  blaze: async (input, ctx) => {
+  implementation: async (input, ctx) => {
     await ctx.fire(entityCreated, { id: input.id });
     return Result.ok({});
   }

package/src/trails/{fork-without-preserved-blaze.trail.ts → fork-without-preserved-implementation.trail.ts}

@@ -1,7 +1,7 @@
-import { forkWithoutPreservedBlaze } from '../rules/trail-versioning-source.js';
+import { forkWithoutPreservedImplementation } from '../rules/trail-versioning-source.js';
 import { wrapRule } from './wrap-rule.js';
 
-export const forkWithoutPreservedBlazeTrail = wrapRule({
+export const forkWithoutPreservedImplementationTrail = wrapRule({
   examples: [
     {
       expected: { diagnostics: [] },
@@ -20,12 +20,12 @@ trail('versioned.clean', {
       },
     },
   },
-  blaze: async () => Result.ok({ message: 'ok' }),
+  implementation: async () => Result.ok({ message: 'ok' }),
 });
 `,
       },
       name: 'Revision entries use transpose',
     },
   ],
-  rule: forkWithoutPreservedBlaze,
+  rule: forkWithoutPreservedImplementation,
 });

package/src/trails/implementation-returns-result.trail.ts

@@ -8,7 +8,7 @@ export const implementationReturnsResultTrail = wrapRule({
       input: {
         filePath: 'clean.ts',
         sourceCode: `trail("entity.show", {
-  blaze: async (input, ctx) => {
+  implementation: async (input, ctx) => {
     return Result.ok({ name: "test" });
   }
 })`,

package/src/trails/incomplete-accessor-for-standard-op.trail.ts

@@ -9,10 +9,10 @@ type Connection = Readonly<Record<string, Accessor>>;
 
 const noop = (): undefined => undefined;
 
-const buildResource = (id: string, contourName: string, accessor: Accessor) =>
+const buildResource = (id: string, entityName: string, accessor: Accessor) =>
   resource<Connection>(id, {
-    create: () => Result.ok({ [contourName]: accessor }),
-    mock: () => ({ [contourName]: accessor }),
+    create: () => Result.ok({ [entityName]: accessor }),
+    mock: () => ({ [entityName]: accessor }),
   });
 
 const buildCrudTrail = (
@@ -20,7 +20,7 @@ const buildCrudTrail = (
   resourceValue: ReturnType<typeof buildResource>
 ) =>
   trail(trailId, {
-    blaze: () => Result.ok({ ok: true }),
+    implementation: () => Result.ok({ ok: true }),
     input: z.object({}),
     output: z.object({ ok: z.boolean() }),
     pattern: 'crud',

package/src/trails/index.ts

@@ -1,7 +1,8 @@
 export { activationOrphanTrail } from './activation-orphan.trail.js';
+export { capturedKernelTrail } from './captured-kernel.trail.js';
 export { cliCommandRouteCoherenceTrail } from './cli-command-route-coherence.trail.js';
 export { circularRefsTrail } from './circular-refs.trail.js';
-export { contourExistsTrail } from './contour-exists.trail.js';
+export { entityExistsTrail } from './entity-exists.trail.js';
 export { contextNoSurfaceTypesTrail } from './context-no-surface-types.trail.js';
 export { composesDeclarationsTrail } from './composes-declarations.trail.js';
 export { deadInternalTrailTrail } from './dead-internal-trail.trail.js';
@@ -14,7 +15,7 @@ export { duplicateExportedSymbolTrail } from './duplicate-exported-symbol.trail.
 export { errorMappingCompletenessTrail } from './error-mapping-completeness.trail.js';
 export { exampleValidTrail } from './example-valid.trail.js';
 export { firesDeclarationsTrail } from './fires-declarations.trail.js';
-export { forkWithoutPreservedBlazeTrail } from './fork-without-preserved-blaze.trail.js';
+export { forkWithoutPreservedImplementationTrail } from './fork-without-preserved-implementation.trail.js';
 export { governedSymbolResidueTrail } from './governed-symbol-residue.trail.js';
 export { implementationReturnsResultTrail } from './implementation-returns-result.trail.js';
 export { incompleteAccessorForStandardOpTrail } from './incomplete-accessor-for-standard-op.trail.js';

package/src/trails/intent-propagation.trail.ts

@@ -11,12 +11,12 @@ export const intentPropagationTrail = wrapRule({
         sourceCode: `trail('entity.read', {
   intent: 'read',
   composes: ['entity.lookup'],
-  blaze: async (_input, ctx) => ctx.compose('entity.lookup', {}),
+  implementation: async (_input, ctx) => ctx.compose('entity.lookup', {}),
 });
 
 trail('entity.lookup', {
   intent: 'read',
-  blaze: async () => Result.ok({}),
+  implementation: async () => Result.ok({}),
 });`,
         trailIntentsById: {
           'entity.lookup': 'read',

package/src/trails/library-projection-coherence.trail.ts

@@ -7,13 +7,13 @@ import { wrapTopoRule } from './wrap-rule.js';
 const output = z.object({ ok: z.boolean() });
 
 const dotted = trail('widget.ping', {
-  blaze: () => Result.ok({ ok: true }),
+  implementation: () => Result.ok({ ok: true }),
   input: z.object({}),
   output,
 });
 
 const kebab = trail('widget-ping', {
-  blaze: () => Result.ok({ ok: true }),
+  implementation: () => Result.ok({ ok: true }),
   input: z.object({}),
   output,
 });

package/src/trails/marker-schema-unsupported.trail.ts

@@ -12,7 +12,7 @@ trail('versioned.schema', {
   version: 2,
   input: z.object({ name: z.string() }),
   output: z.object({ message: z.string() }),
-  blaze: async () => Result.ok({ message: 'ok' }),
+  implementation: async () => Result.ok({ message: 'ok' }),
 });
 `,
       },

package/src/trails/missing-visibility.trail.ts

@@ -12,7 +12,7 @@ export const missingVisibilityTrail = wrapRule({
         sourceCode: `trail('entity.resolve', {
   visibility: 'internal',
   composeInput: z.object({ forkedFrom: z.string() }),
-  blaze: async () => Result.ok({}),
+  implementation: async () => Result.ok({}),
 });`,
       },
       name: 'Composition-only trails stay quiet when already internal',

package/src/trails/no-destructured-compose.trail.ts

@@ -9,10 +9,10 @@ export const noDestructuredComposeTrail = wrapRule({
         filePath: 'clean.ts',
         sourceCode: `trail("entity.onboard", {
   composes: ["entity.create"],
-  blaze: async (input, ctx) => ctx.compose("entity.create", input),
+  implementation: async (input, ctx) => ctx.compose("entity.create", input),
 });`,
       },
-      name: 'Clean blaze using ctx.compose directly',
+      name: 'Clean implementation using ctx.compose directly',
     },
     {
       expected: {
@@ -21,7 +21,7 @@ export const noDestructuredComposeTrail = wrapRule({
             filePath: 'destructured.ts',
             line: 4,
             message:
-              'Trail "entity.onboard" destructures compose from the blaze context. Use ctx.compose(...) directly so composition stays visible and Warden can recognize composed Result values.',
+              'Trail "entity.onboard" destructures compose from the implementation context. Use ctx.compose(...) directly so composition stays visible and Warden can recognize composed Result values.',
             rule: 'no-destructured-compose',
             severity: 'warn',
           },
@@ -31,13 +31,13 @@ export const noDestructuredComposeTrail = wrapRule({
         filePath: 'destructured.ts',
         sourceCode: `trail("entity.onboard", {
   composes: ["entity.create"],
-  blaze: async (input, ctx) => {
+  implementation: async (input, ctx) => {
     const { compose } = ctx;
     return compose("entity.create", input);
   },
 });`,
       },
-      name: 'Warns when compose is destructured from the blaze context',
+      name: 'Warns when compose is destructured from the implementation context',
     },
   ],
   rule: noDestructuredCompose,

package/src/trails/no-direct-implementation-call.trail.ts

@@ -9,7 +9,7 @@ export const noDirectImplementationCallTrail = wrapRule({
         filePath: 'clean.ts',
         sourceCode: `const data = await ctx.compose("entity.show", { id: "1" });`,
       },
-      name: 'Clean code using ctx.compose instead of .blaze()',
+      name: 'Clean code using ctx.compose instead of .implementation()',
     },
   ],
   rule: noDirectImplementationCall,

package/src/trails/no-redundant-result-error-wrap.trail.ts

@@ -10,7 +10,7 @@ export const noRedundantResultErrorWrapTrail = wrapRule({
         sourceCode: `import { Result, trail } from "@ontrails/core";
 
 trail("entity.load", {
-  blaze: async (input, ctx) => {
+  implementation: async (input, ctx) => {
     const loaded = await ctx.compose("entity.fetch", input);
     if (loaded.isErr()) {
       return loaded;
@@ -39,7 +39,7 @@ trail("entity.load", {
         sourceCode: `import { Result, trail } from "@ontrails/core";
 
 trail("entity.load", {
-  blaze: async (input, ctx) => {
+  implementation: async (input, ctx) => {
     const loaded = await ctx.compose("entity.fetch", input);
     if (loaded.isErr()) {
       return Result.err(loaded.error);