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

package/src/rules/incomplete-crud.ts

@@ -1,9 +1,12 @@
 import { crudOperations } from '@ontrails/store';
 
+import { collectNamedEntityIds } from './source/entities.js';
 import {
-  collectNamedContourIds,
   collectNamedStoreTableIds,
   deriveStoreTableId,
+  isNamedCall,
+} from './source/stores.js';
+import {
   getNodeArguments,
   getNodeElements,
   getNodeId,
@@ -14,13 +17,12 @@ import {
   getNodeSpecifiers,
   getStringValue,
   identifierName,
-  isNamedCall,
   isStringLiteral,
   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 type {
   ProjectAwareWardenRule,
@@ -30,10 +32,10 @@ import type {
 
 const CRUD_OPERATION_SET = new Set<string>(crudOperations);
 
-/** Sentinel entity id prefix for contours imported from another module. */
-const IMPORTED_CONTOUR_PREFIX = 'imported:';
-const IMPORTED_CONTOUR_SOURCE_SEPARATOR = '#';
-const CONTOUR_BINDING_SUFFIX = 'Contour';
+/** Sentinel entity id prefix for entities imported from another module. */
+const IMPORTED_ENTITY_PREFIX = 'imported:';
+const IMPORTED_ENTITY_SOURCE_SEPARATOR = '#';
+const ENTITY_BINDING_SUFFIX = 'Entity';
 
 interface CrudCoverage {
   readonly entityId: string;
@@ -103,8 +105,8 @@ const collectImportDeclarationAliases = (
   }
 };
 
-const extractInlineContourId = (node: AstNode | undefined): string | null => {
-  if (!isNamedCall(node, 'contour')) {
+const extractInlineEntityId = (node: AstNode | undefined): string | null => {
+  if (!isNamedCall(node, 'entity')) {
     return null;
   }
 
@@ -127,18 +129,18 @@ const collectImportAliasResolutions = (
   return aliases;
 };
 
-const buildImportedContourId = (source: string, importedName: string): string =>
-  `${IMPORTED_CONTOUR_PREFIX}${source}${IMPORTED_CONTOUR_SOURCE_SEPARATOR}${importedName}`;
+const buildImportedEntityId = (source: string, importedName: string): string =>
+  `${IMPORTED_ENTITY_PREFIX}${source}${IMPORTED_ENTITY_SOURCE_SEPARATOR}${importedName}`;
 
-const parseImportedContourId = (
+const parseImportedEntityId = (
   entityId: string
 ): { readonly bindingName: string; readonly source?: string } | null => {
-  if (!entityId.startsWith(IMPORTED_CONTOUR_PREFIX)) {
+  if (!entityId.startsWith(IMPORTED_ENTITY_PREFIX)) {
     return null;
   }
 
-  const remainder = entityId.slice(IMPORTED_CONTOUR_PREFIX.length);
-  const separator = remainder.lastIndexOf(IMPORTED_CONTOUR_SOURCE_SEPARATOR);
+  const remainder = entityId.slice(IMPORTED_ENTITY_PREFIX.length);
+  const separator = remainder.lastIndexOf(IMPORTED_ENTITY_SOURCE_SEPARATOR);
   if (separator === -1) {
     return { bindingName: remainder };
   }
@@ -150,38 +152,38 @@ const parseImportedContourId = (
 };
 
 /**
- * Resolve an identifier reference (bound contour or imported alias) to a
+ * Resolve an identifier reference (bound entity or imported alias) to a
  * stable entity id. Imported identifiers return a `pending-resolution`
  * sentinel so coverage is still tracked instead of silently dropped.
  */
-const resolveContourIdentifier = (
+const resolveEntityIdentifier = (
   name: string,
-  namedContourIds: ReadonlyMap<string, string>,
+  namedEntityIds: ReadonlyMap<string, string>,
   importAliases: ReadonlyMap<string, ImportAliasResolution>
 ): string | null => {
-  const local = namedContourIds.get(name);
+  const local = namedEntityIds.get(name);
   if (local) {
     return local;
   }
 
   const imported = importAliases.get(name);
   if (imported) {
-    return buildImportedContourId(imported.source, imported.importedName);
+    return buildImportedEntityId(imported.source, imported.importedName);
   }
 
   return null;
 };
 
-const stripContourBindingSuffix = (entityId: string): string =>
-  entityId.endsWith(CONTOUR_BINDING_SUFFIX)
-    ? entityId.slice(0, -CONTOUR_BINDING_SUFFIX.length)
+const stripEntityBindingSuffix = (entityId: string): string =>
+  entityId.endsWith(ENTITY_BINDING_SUFFIX)
+    ? entityId.slice(0, -ENTITY_BINDING_SUFFIX.length)
     : entityId;
 
 const normalizeProjectEntityId = (
   entityId: string,
   projectEntityIds: ReadonlySet<string>
 ): string => {
-  const imported = parseImportedContourId(entityId);
+  const imported = parseImportedEntityId(entityId);
   if (!imported) {
     return entityId;
   }
@@ -190,11 +192,11 @@ const normalizeProjectEntityId = (
   if (projectEntityIds.has(localId)) {
     return localId;
   }
-  const strippedId = stripContourBindingSuffix(localId);
+  const strippedId = stripEntityBindingSuffix(localId);
   if (
     strippedId !== localId &&
     (projectEntityIds.has(strippedId) ||
-      projectEntityIds.has(`${IMPORTED_CONTOUR_PREFIX}${strippedId}`))
+      projectEntityIds.has(`${IMPORTED_ENTITY_PREFIX}${strippedId}`))
   ) {
     return strippedId;
   }
@@ -218,19 +220,19 @@ const normalizeProjectCoverage = (
 };
 
 /**
- * Resolve a `deriveTrail` contour argument to a stable entity id.
+ * Resolve a `deriveTrail` entity argument to a stable entity id.
  *
  * Resolution order:
- *   1. Inline `contour('name', …)` call — use the authored name.
- *   2. Local identifier bound to `contour('name', …)` via `namedContourIds`.
+ *   1. Inline `entity('name', …)` call — use the authored name.
+ *   2. Local identifier bound to `entity('name', …)` via `namedEntityIds`.
  *   3. Identifier imported from another module — mark as a pending
  *      `imported:<local>` coverage observation so the rule still tracks the
  *      entity across the file instead of silently dropping it. The prefix is
  *      stripped from diagnostic output for readability.
  */
-const resolveContourId = (
+const resolveEntityId = (
   node: AstNode | undefined,
-  namedContourIds: ReadonlyMap<string, string>,
+  namedEntityIds: ReadonlyMap<string, string>,
   importAliases: ReadonlyMap<string, ImportAliasResolution>
 ): string | null => {
   if (!node) {
@@ -240,11 +242,11 @@ const resolveContourId = (
   if (node.type === 'Identifier') {
     const name = identifierName(node);
     return name
-      ? resolveContourIdentifier(name, namedContourIds, importAliases)
+      ? resolveEntityIdentifier(name, namedEntityIds, importAliases)
       : null;
   }
 
-  return extractInlineContourId(node);
+  return extractInlineEntityId(node);
 };
 
 const ensureCoverage = (
@@ -277,16 +279,16 @@ const extractCrudOperation = (node: AstNode | undefined): string | null => {
 
 const extractDerivedCrudEntry = (
   node: AstNode,
-  namedContourIds: ReadonlyMap<string, string>,
+  namedEntityIds: ReadonlyMap<string, string>,
   importAliases: ReadonlyMap<string, ImportAliasResolution>
 ): { readonly entityId: string; readonly operation: string } | null => {
   if (!isNamedCall(node, 'deriveTrail')) {
     return null;
   }
 
-  const [contourArg, operationArg] = getNodeArguments(node);
+  const [entityArg, operationArg] = getNodeArguments(node);
   const operation = extractCrudOperation(operationArg);
-  const entityId = resolveContourId(contourArg, namedContourIds, importAliases);
+  const entityId = resolveEntityId(entityArg, namedEntityIds, importAliases);
   return operation && entityId ? { entityId, operation } : null;
 };
 
@@ -295,11 +297,11 @@ const collectDerivedCrudCoverage = (
   sourceCode: string
 ): ReadonlyMap<string, CrudCoverage> => {
   const coverageByEntityId = new Map<string, CrudCoverage>();
-  const namedContourIds = collectNamedContourIds(ast);
+  const namedEntityIds = collectNamedEntityIds(ast);
   const importAliases = collectImportAliasResolutions(ast);
 
   walk(ast, (node) => {
-    const entry = extractDerivedCrudEntry(node, namedContourIds, importAliases);
+    const entry = extractDerivedCrudEntry(node, namedEntityIds, importAliases);
     if (!entry) {
       return;
     }
@@ -504,7 +506,7 @@ const collectIncompleteEntities = (
 };
 
 const formatEntityLabel = (entityId: string): string => {
-  const imported = parseImportedContourId(entityId);
+  const imported = parseImportedEntityId(entityId);
   return imported
     ? `${imported.bindingName} (imported, pending-resolution)`
     : entityId;

package/src/rules/index.ts

@@ -1,7 +1,8 @@
 import { activationOrphan } from './activation-orphan.js';
+import { capturedKernel } from './captured-kernel.js';
 import { cliCommandRouteCoherence } from './cli-command-route-coherence.js';
 import { circularRefs } from './circular-refs.js';
-import { contourExists } from './contour-exists.js';
+import { entityExists } from './entity-exists.js';
 import { contextNoSurfaceTypes } from './context-no-surface-types.js';
 import { composesDeclarations } from './composes-declarations.js';
 import { deadInternalTrail } from './dead-internal-trail.js';
@@ -58,7 +59,7 @@ import { surfaceTrailheadCoherence } from './surface-trailhead-coherence.js';
 import { trailForkCoaching } from './trail-fork-coaching.js';
 import { trailheadOverrideDivergence } from './trailhead-override-divergence.js';
 import {
-  forkWithoutPreservedBlaze,
+  forkWithoutPreservedImplementation,
   markerSchemaUnsupported,
   versionPinnedCompose,
 } from './trail-versioning-source.js';
@@ -139,10 +140,11 @@ export {
 export type { BuiltinWardenRuleName } from './metadata.js';
 
 export { activationOrphan } from './activation-orphan.js';
+export { capturedKernel } from './captured-kernel.js';
 export { cliCommandRouteCoherence } from './cli-command-route-coherence.js';
 export { noThrowInImplementation } from './no-throw-in-implementation.js';
 export { circularRefs } from './circular-refs.js';
-export { contourExists } from './contour-exists.js';
+export { entityExists } from './entity-exists.js';
 export { contextNoSurfaceTypes } from './context-no-surface-types.js';
 export { composesDeclarations } from './composes-declarations.js';
 export { deadInternalTrail } from './dead-internal-trail.js';
@@ -197,7 +199,7 @@ export { surfaceTrailheadCoherence } from './surface-trailhead-coherence.js';
 export { trailForkCoaching } from './trail-fork-coaching.js';
 export { trailheadOverrideDivergence } from './trailhead-override-divergence.js';
 export {
-  forkWithoutPreservedBlaze,
+  forkWithoutPreservedImplementation,
   markerSchemaUnsupported,
   versionPinnedCompose,
 } from './trail-versioning-source.js';
@@ -219,8 +221,9 @@ export const wardenRules: ReadonlyMap<string, WardenRule> = new Map<
   WardenRule
 >([
   [noThrowInImplementation.name, noThrowInImplementation],
+  [capturedKernel.name, capturedKernel],
   [circularRefs.name, circularRefs],
-  [contourExists.name, contourExists],
+  [entityExists.name, entityExists],
   [contextNoSurfaceTypes.name, contextNoSurfaceTypes],
   [composesDeclarations.name, composesDeclarations],
   [deadInternalTrail.name, deadInternalTrail],
@@ -270,7 +273,7 @@ export const wardenRules: ReadonlyMap<string, WardenRule> = new Map<
   [unreachableDetourShadowing.name, unreachableDetourShadowing],
   [wardenExportSymmetry.name, wardenExportSymmetry],
   [wardenRulesUseAst.name, wardenRulesUseAst],
-  [forkWithoutPreservedBlaze.name, forkWithoutPreservedBlaze],
+  [forkWithoutPreservedImplementation.name, forkWithoutPreservedImplementation],
   [markerSchemaUnsupported.name, markerSchemaUnsupported],
   [versionPinnedCompose.name, versionPinnedCompose],
 ]);

package/src/rules/intent-propagation.ts

@@ -3,11 +3,9 @@ import {
   collectNamedTrailIds,
   collectTrailIntentsById,
   extractDefinitionComposeTargetIds,
-  findTrailDefinitions,
-  offsetToLine,
-  parse,
-} from './ast.js';
-import type { AstNode } from './ast.js';
+} from './source/composition.js';
+import { findTrailDefinitions, offsetToLine, parse } from '@ontrails/source';
+import type { AstNode } from '@ontrails/source';
 import { isTestFile } from './scan.js';
 import type {
   ProjectAwareWardenRule,

package/src/rules/layer-field-name-drift.ts

@@ -8,8 +8,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 = 'layer-field-name-drift';

package/src/rules/library-projection-coherence.ts

@@ -1,8 +1,8 @@
-import { deriveTopoGraph } from '@ontrails/topographer';
+import { deriveTopoGraph } from '@ontrails/topography';
 import type {
   TopoGraph,
   TopoGraphLibraryProjection,
-} from '@ontrails/topographer';
+} from '@ontrails/topography';
 
 import type { TopoAwareWardenRule, WardenDiagnostic } from './types.js';
 

package/src/rules/metadata.ts

@@ -69,6 +69,7 @@ const depthByTier = {
 
 const concernByRuleName: Partial<Record<string, WardenRuleConcern>> = {
   'activation-orphan': 'signals',
+  'captured-kernel': 'general',
   'cli-command-route-coherence': 'meta',
   'composes-declarations': 'composition',
   'context-no-surface-types': 'composition',
@@ -81,7 +82,7 @@ const concernByRuleName: Partial<Record<string, WardenRuleConcern>> = {
   'duplicate-public-contract': 'meta',
   'error-mapping-completeness': 'results',
   'fires-declarations': 'signals',
-  'fork-without-preserved-blaze': 'lifecycle',
+  'fork-without-preserved-implementation': 'lifecycle',
   'governed-symbol-residue': 'lifecycle',
   'implementation-returns-result': 'results',
   'intent-propagation': 'composition',
@@ -157,9 +158,30 @@ const builtinWardenRuleMetadataInput = {
       'Signal activation consumers reference sources with producer declarations.',
     tier: 'topo-aware',
   },
+  'captured-kernel': {
+    guidance: {
+      relatedRules: [
+        'duplicate-exported-symbol',
+        'public-internal-deep-imports',
+        'resolved-import-boundary',
+      ],
+      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.',
+    },
+    invariant:
+      'Public subpath exports that re-export internal kernels receive ownership review after multiple production packages consume them.',
+    lifecycle: { state: 'durable' },
+    scope: 'advisory',
+    tier: 'project-static',
+  },
   'circular-refs': {
     ...durableExternal,
-    invariant: 'Contour reference graphs must be acyclic.',
+    invariant: 'Entity reference graphs must be acyclic.',
     tier: 'project-static',
   },
   'cli-command-route-coherence': {
@@ -189,11 +211,6 @@ const builtinWardenRuleMetadataInput = {
     invariant: 'Trail logic stays surface-agnostic.',
     tier: 'source-static',
   },
-  'contour-exists': {
-    ...durableExternal,
-    invariant: 'Declared contour references resolve to known contours.',
-    tier: 'project-static',
-  },
   'dead-internal-trail': {
     ...durableExternal,
     invariant: 'Internal trails should be reachable through declared composes.',
@@ -263,6 +280,11 @@ const builtinWardenRuleMetadataInput = {
       'Public surface trails should not expose duplicate normalized contract facts.',
     tier: 'topo-aware',
   },
+  'entity-exists': {
+    ...durableExternal,
+    invariant: 'Declared entity references resolve to known entities.',
+    tier: 'project-static',
+  },
   'error-mapping-completeness': {
     ...durableExtension,
     invariant: 'Registered surface error mappers cover every error category.',
@@ -286,9 +308,9 @@ const builtinWardenRuleMetadataInput = {
     invariant: 'Declared fires stay aligned with signal firing usage.',
     tier: 'source-static',
   },
-  'fork-without-preserved-blaze': {
+  'fork-without-preserved-implementation': {
     ...durableExternal,
-    invariant: 'Fork version entries preserve their historical blaze.',
+    invariant: 'Fork version entries preserve their historical implementation.',
     tier: 'source-static',
   },
   'governed-symbol-residue': {
@@ -300,7 +322,7 @@ const builtinWardenRuleMetadataInput = {
   },
   'implementation-returns-result': {
     ...durableExternal,
-    invariant: 'Blazes return Result values.',
+    invariant: 'Implementations return Result values.',
     tier: 'source-static',
   },
   'incomplete-accessor-for-standard-op': {
@@ -368,7 +390,7 @@ const builtinWardenRuleMetadataInput = {
   'no-destructured-compose': {
     ...durableExternal,
     invariant:
-      'Trail blazes compose through ctx.compose() directly instead of destructuring compose from the context.',
+      'Trail implementations compose through ctx.compose() directly instead of destructuring compose from the context.',
     tier: 'source-static',
   },
   'no-dev-permit-in-source': {
@@ -447,12 +469,12 @@ const builtinWardenRuleMetadataInput = {
       relatedRules: ['implementation-returns-result', 'no-native-error-result'],
       steps: [
         'Return Result.err() with the most specific TrailsError subclass available.',
-        'Use detours for recoverable runtime strategies instead of throwing inside the blaze.',
+        'Use detours for recoverable runtime strategies instead of throwing inside the implementation.',
       ],
       summary:
-        'Convert thrown failures in blazes into explicit Result.err() outcomes.',
+        'Convert thrown failures in implementations into explicit Result.err() outcomes.',
     },
-    invariant: 'Blazes return Result.err() instead of throwing.',
+    invariant: 'Implementations return Result.err() instead of throwing.',
     tier: 'source-static',
   },
   'no-top-level-surface': {
@@ -564,7 +586,7 @@ const builtinWardenRuleMetadataInput = {
   },
   'reference-exists': {
     ...durableExternal,
-    invariant: 'Reference declarations resolve to known contours.',
+    invariant: 'Reference declarations resolve to known entities.',
     tier: 'project-static',
   },
   'resolved-import-boundary': {

package/src/rules/missing-reconcile.ts

@@ -2,10 +2,9 @@ import {
   collectCrudTableIds,
   collectReconcileTableIds,
   findStoreTableDefinitions,
-  offsetToLine,
-  parse,
-} from './ast.js';
-import type { AstNode } from './ast.js';
+} from './source/stores.js';
+import { offsetToLine, parse } from '@ontrails/source';
+import type { AstNode } from '@ontrails/source';
 import { isTestFile } from './scan.js';
 import type {
   ProjectAwareWardenRule,

package/src/rules/missing-visibility.ts

@@ -1,4 +1,5 @@
-import { collectComposeTargetTrailIds, parse } from './ast.js';
+import { collectComposeTargetTrailIds } from './source/composition.js';
+import { parse } from '@ontrails/source';
 import { isTestFile } from './scan.js';
 import {
   findTrailLikeSpecs,

package/src/rules/no-destructured-compose.ts

@@ -1,5 +1,5 @@
 import {
-  findBlazeBodies,
+  findImplementationBodies,
   findTrailDefinitions,
   getNodeComputed,
   getNodeId,
@@ -16,15 +16,15 @@ import {
   offsetToLine,
   parse,
   walkWithScopes,
-} from './ast.js';
+} from '@ontrails/source';
+import type { AstNode } from '@ontrails/source';
 import { isFrameworkInternalFile, isTestFile } from './scan.js';
-import type { AstNode } from './ast.js';
 import type { WardenDiagnostic, WardenRule } from './types.js';
 
 const RULE_NAME = 'no-destructured-compose';
 
 const diagnosticMessage = (trailId: string): string =>
-  `Trail "${trailId}" destructures compose from the blaze context. Use ctx.compose(...) directly so composition stays visible and Warden can recognize composed Result values.`;
+  `Trail "${trailId}" destructures compose from the implementation context. Use ctx.compose(...) directly so composition stays visible and Warden can recognize composed Result values.`;
 
 const propertyKeyName = (property: AstNode): string | null => {
   if (getNodeComputed(property) === true) {
@@ -60,8 +60,8 @@ const findComposeBinding = (pattern: AstNode | undefined): AstNode | null => {
   return null;
 };
 
-const blazeParams = (blaze: AstNode): readonly AstNode[] =>
-  getNodeParams(blaze) ?? [];
+const implementationParams = (implementation: AstNode): readonly AstNode[] =>
+  getNodeParams(implementation) ?? [];
 
 const destructuredComposeFromVariableDeclarator = (
   node: AstNode,
@@ -104,13 +104,13 @@ const checkBodyDestructuring = (
   sourceCode: string,
   filePath: string,
   trailId: string,
-  blaze: AstNode,
+  implementation: AstNode,
   contextName: string
 ): WardenDiagnostic[] => {
   const diagnostics: WardenDiagnostic[] = [];
 
   walkWithScopes(
-    blaze,
+    implementation,
     (node, scopes) => {
       if (isShadowed(contextName, scopes)) {
         return;
@@ -155,8 +155,10 @@ export const noDestructuredCompose: WardenRule = {
         continue;
       }
 
-      for (const blaze of findBlazeBodies(definition.config)) {
-        const params = blazeParams(blaze);
+      for (const implementation of findImplementationBodies(
+        definition.config
+      )) {
+        const params = implementationParams(implementation);
         const [, contextParam] = params;
         const paramComposeBinding = findComposeBinding(contextParam);
 
@@ -177,7 +179,7 @@ export const noDestructuredCompose: WardenRule = {
               sourceCode,
               filePath,
               definition.id,
-              blaze,
+              implementation,
               contextName
             )
           );
@@ -188,7 +190,7 @@ export const noDestructuredCompose: WardenRule = {
     return diagnostics;
   },
   description:
-    'Coach trail blazes to compose with ctx.compose(...) directly instead of destructuring compose from the context.',
+    'Coach trail implementations to compose with ctx.compose(...) directly instead of destructuring compose from the context.',
   name: RULE_NAME,
   severity: 'warn',
 };

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

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

package/src/rules/no-legacy-cli-alias-export.ts

@@ -40,8 +40,8 @@ import {
   isStringLiteral,
   offsetToLine,
   parse,
-} from './ast.js';
-import type { AstNode } from './ast.js';
+} from '@ontrails/source';
+import type { AstNode } from '@ontrails/source';
 import type { WardenDiagnostic, WardenFix, WardenRule } from './types.js';
 
 const RULE_NAME = 'no-legacy-cli-alias-export';

package/src/rules/no-native-error-result.ts

@@ -7,9 +7,9 @@ import {
   offsetToLine,
   parse,
   walk,
-} from './ast.js';
+} from '@ontrails/source';
+import type { AstNode } from '@ontrails/source';
 import { isFrameworkInternalFile } from './scan.js';
-import type { AstNode } from './ast.js';
 import type { WardenDiagnostic, WardenRule } from './types.js';
 
 const RULE_NAME = 'no-native-error-result';