@ontrails/warden 1.0.0-beta.12 → 1.0.0-beta.13

package/src/rules/{service-exists.ts → provision-exists.ts}

@@ -1,6 +1,6 @@
 import {
-  collectNamedServiceIds,
-  collectServiceDefinitionIds,
+  collectNamedProvisionIds,
+  collectProvisionDefinitionIds,
   extractFirstStringArg,
   findConfigProperty,
   findTrailDefinitions,
@@ -18,18 +18,18 @@ import type {
   WardenDiagnostic,
 } from './types.js';
 
-const isServiceCall = (node: AstNode): boolean =>
+const isProvisionCall = (node: AstNode): boolean =>
   node.type === 'CallExpression' &&
   identifierName((node as unknown as { callee?: AstNode }).callee) ===
-    'service';
+    'provision';
 
-const getServiceElements = (config: AstNode): readonly AstNode[] => {
-  const servicesProp = findConfigProperty(config, 'services');
-  if (!servicesProp) {
+const getProvisionElements = (config: AstNode): readonly AstNode[] => {
+  const provisionsProp = findConfigProperty(config, 'provisions');
+  if (!provisionsProp) {
     return [];
   }
 
-  const arrayNode = servicesProp.value;
+  const arrayNode = provisionsProp.value;
   if (!arrayNode || (arrayNode as AstNode).type !== 'ArrayExpression') {
     return [];
   }
@@ -40,93 +40,93 @@ const getServiceElements = (config: AstNode): readonly AstNode[] => {
   return elements ?? [];
 };
 
-const extractDeclaredServiceId = (
+const extractDeclaredProvisionId = (
   element: AstNode,
-  serviceIdsByName: ReadonlyMap<string, string>
+  provisionIdsByName: ReadonlyMap<string, string>
 ): string | null => {
   if (element.type === 'Identifier') {
     const name = identifierName(element);
-    return name ? (serviceIdsByName.get(name) ?? null) : null;
+    return name ? (provisionIdsByName.get(name) ?? null) : null;
   }
 
   if (isStringLiteral(element)) {
     return getStringValue(element);
   }
 
-  return isServiceCall(element) ? extractFirstStringArg(element) : null;
+  return isProvisionCall(element) ? extractFirstStringArg(element) : null;
 };
 
-const extractDeclaredServiceIds = (
+const extractDeclaredProvisionIds = (
   config: AstNode,
-  serviceIdsByName: ReadonlyMap<string, string>
+  provisionIdsByName: ReadonlyMap<string, string>
 ): readonly string[] => [
   ...new Set(
-    getServiceElements(config).flatMap((element) => {
-      const id = extractDeclaredServiceId(element, serviceIdsByName);
+    getProvisionElements(config).flatMap((element) => {
+      const id = extractDeclaredProvisionId(element, provisionIdsByName);
       return id ? [id] : [];
     })
   ),
 ];
 
-const buildMissingServiceDiagnostic = (
+const buildMissingProvisionDiagnostic = (
   trailId: string,
-  serviceId: string,
+  provisionId: string,
   filePath: string,
   line: number
 ): WardenDiagnostic => ({
   filePath,
   line,
-  message: `Trail "${trailId}" declares service "${serviceId}" which is not defined in the project.`,
-  rule: 'service-exists',
+  message: `Trail "${trailId}" declares provision "${provisionId}" which is not defined in the project.`,
+  rule: 'provision-exists',
   severity: 'error',
 });
 
-const reportMissingServices = (
+const reportMissingProvisions = (
   def: { id: string; config: AstNode; start: number },
   sourceCode: string,
-  serviceIdsByName: ReadonlyMap<string, string>,
+  provisionIdsByName: ReadonlyMap<string, string>,
   filePath: string,
-  knownServiceIds: ReadonlySet<string>,
+  knownProvisionIds: ReadonlySet<string>,
   diagnostics: WardenDiagnostic[]
 ): void => {
   const line = offsetToLine(sourceCode, def.start);
-  for (const serviceId of extractDeclaredServiceIds(
+  for (const provisionId of extractDeclaredProvisionIds(
     def.config,
-    serviceIdsByName
+    provisionIdsByName
   )) {
-    if (!knownServiceIds.has(serviceId)) {
+    if (!knownProvisionIds.has(provisionId)) {
       diagnostics.push(
-        buildMissingServiceDiagnostic(def.id, serviceId, filePath, line)
+        buildMissingProvisionDiagnostic(def.id, provisionId, filePath, line)
       );
     }
   }
 };
 
-const buildServiceDiagnostics = (
+const buildProvisionDiagnostics = (
   ast: AstNode,
   sourceCode: string,
   filePath: string,
-  knownServiceIds: ReadonlySet<string>
+  knownProvisionIds: ReadonlySet<string>
 ): readonly WardenDiagnostic[] => {
   const diagnostics: WardenDiagnostic[] = [];
-  const serviceIdsByName = collectNamedServiceIds(ast);
+  const provisionIdsByName = collectNamedProvisionIds(ast);
   for (const def of findTrailDefinitions(ast)) {
-    reportMissingServices(
+    reportMissingProvisions(
       def,
       sourceCode,
-      serviceIdsByName,
+      provisionIdsByName,
       filePath,
-      knownServiceIds,
+      knownProvisionIds,
       diagnostics
     );
   }
   return diagnostics;
 };
 
-const checkServicesExist = (
+const checkProvisionsExist = (
   sourceCode: string,
   filePath: string,
-  knownServiceIds: ReadonlySet<string>
+  knownProvisionIds: ReadonlySet<string>
 ): readonly WardenDiagnostic[] => {
   if (isTestFile(filePath)) {
     return [];
@@ -137,22 +137,27 @@ const checkServicesExist = (
     return [];
   }
 
-  return buildServiceDiagnostics(ast, sourceCode, filePath, knownServiceIds);
+  return buildProvisionDiagnostics(
+    ast,
+    sourceCode,
+    filePath,
+    knownProvisionIds
+  );
 };
 
 /**
- * Checks that all declared services resolve to known service definitions.
+ * Checks that all declared provisions resolve to known provision definitions.
  */
-export const serviceExists: ProjectAwareWardenRule = {
+export const provisionExists: ProjectAwareWardenRule = {
   check(sourceCode: string, filePath: string): readonly WardenDiagnostic[] {
     const ast = parse(filePath, sourceCode);
     if (!ast) {
       return [];
     }
-    return checkServicesExist(
+    return checkProvisionsExist(
       sourceCode,
       filePath,
-      collectServiceDefinitionIds(ast)
+      collectProvisionDefinitionIds(ast)
     );
   },
   checkWithContext(
@@ -161,17 +166,17 @@ export const serviceExists: ProjectAwareWardenRule = {
     context: ProjectContext
   ): readonly WardenDiagnostic[] {
     const ast = parse(filePath, sourceCode);
-    const localServiceIds = ast
-      ? collectServiceDefinitionIds(ast)
+    const localProvisionIds = ast
+      ? collectProvisionDefinitionIds(ast)
       : new Set<string>();
-    return checkServicesExist(
+    return checkProvisionsExist(
       sourceCode,
       filePath,
-      context.knownServiceIds ?? localServiceIds
+      context.knownProvisionIds ?? localProvisionIds
     );
   },
   description:
-    'Ensure every service declared on a trail resolves to a known service definition.',
-  name: 'service-exists',
+    'Ensure every provision declared on a trail resolves to a known provision definition.',
+  name: 'provision-exists',
   severity: 'error',
 };

package/src/rules/specs.ts

@@ -18,7 +18,7 @@ export interface ObjectProperty extends ParsedEntry {
 
 export interface TrailLikeSpec {
   readonly id: string;
-  readonly kind: 'event' | 'trail';
+  readonly kind: 'signal' | 'trail';
   readonly line: number;
   readonly properties: ReadonlyMap<string, ObjectProperty>;
   readonly specText: string;
@@ -214,7 +214,7 @@ const resolveSpecId = (
 
 const buildTrailLikeSpec = (
   sourceCode: string,
-  kind: 'event' | 'trail',
+  kind: 'signal' | 'trail',
   specArg: SplitEntry,
   specStart: number,
   id: string,
@@ -276,7 +276,7 @@ const resolveTrailLikeSpec = (
 
 const parseTrailLikeMatch = (
   sourceCode: string,
-  kind: 'event' | 'trail',
+  kind: 'signal' | 'trail',
   callStart: number
 ): TrailLikeSpec | null => {
   const resolved = resolveTrailLikeSpec(sourceCode, callStart);
@@ -352,7 +352,7 @@ export const findTrailLikeSpecs = (
       continue;
     }
 
-    const kind = match[1] === 'event' ? 'event' : 'trail';
+    const kind = match[1] === 'signal' ? 'signal' : 'trail';
     const spec = parseTrailLikeMatch(sourceCode, kind, callStart);
     if (spec !== null) {
       specs.push(spec);

package/src/rules/types.ts

@@ -45,8 +45,8 @@ export interface WardenRule {
 export interface ProjectContext {
   /** All known trail IDs in the project */
   readonly knownTrailIds: ReadonlySet<string>;
-  /** All known service IDs in the project */
-  readonly knownServiceIds?: ReadonlySet<string>;
+  /** All known provision IDs in the project */
+  readonly knownProvisionIds?: ReadonlySet<string>;
   /** All trail IDs referenced as detour targets across the project */
   readonly detourTargetTrailIds?: ReadonlySet<string>;
 }

package/src/trails/{context-no-surface-types.trail.ts → context-no-trailhead-types.trail.ts}

@@ -1,7 +1,7 @@
-import { contextNoSurfaceTypes } from '../rules/context-no-surface-types.js';
+import { contextNoTrailheadTypes } from '../rules/context-no-trailhead-types.js';
 import { wrapRule } from './wrap-rule.js';
 
-export const contextNoSurfaceTypesTrail = wrapRule({
+export const contextNoTrailheadTypesTrail = wrapRule({
   examples: [
     {
       expected: { diagnostics: [] },
@@ -9,13 +9,13 @@ export const contextNoSurfaceTypesTrail = wrapRule({
         filePath: 'clean.ts',
         sourceCode: `import { trail, Result } from "@ontrails/core";
 trail("entity.show", {
-  run: async (input, ctx) => {
+  blaze: async (input, ctx) => {
     return Result.ok({ name: "test" });
   }
 })`,
       },
-      name: 'Clean trail without surface imports',
+      name: 'Clean trail without trailhead imports',
     },
   ],
-  rule: contextNoSurfaceTypes,
+  rule: contextNoTrailheadTypes,
 });

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

@@ -0,0 +1,22 @@
+import { crossDeclarations } from '../rules/cross-declarations.js';
+import { wrapRule } from './wrap-rule.js';
+
+export const crossDeclarationsTrail = wrapRule({
+  examples: [
+    {
+      expected: { diagnostics: [] },
+      input: {
+        filePath: 'clean.ts',
+        sourceCode: `trail("entity.onboard", {
+  crosses: ["entity.create"],
+  blaze: async (input, ctx) => {
+    const result = await ctx.cross("entity.create", input);
+    return Result.ok(result);
+  }
+})`,
+      },
+      name: 'Matched crossing declarations and calls',
+    },
+  ],
+  rule: crossDeclarations,
+});

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

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

package/src/trails/index.ts

@@ -1,5 +1,5 @@
-export { contextNoSurfaceTypesTrail } from './context-no-surface-types.trail.js';
-export { followDeclarationsTrail } from './follow-declarations.trail.js';
+export { contextNoTrailheadTypesTrail } from './context-no-trailhead-types.trail.js';
+export { crossDeclarationsTrail } from './cross-declarations.trail.js';
 export { implementationReturnsResultTrail } from './implementation-returns-result.trail.js';
 export { noDirectImplInRouteTrail } from './no-direct-impl-in-route.trail.js';
 export { noDirectImplementationCallTrail } from './no-direct-implementation-call.trail.js';
@@ -7,8 +7,8 @@ export { noSyncResultAssumptionTrail } from './no-sync-result-assumption.trail.j
 export { noThrowInDetourTargetTrail } from './no-throw-in-detour-target.trail.js';
 export { noThrowInImplementationTrail } from './no-throw-in-implementation.trail.js';
 export { preferSchemaInferenceTrail } from './prefer-schema-inference.trail.js';
-export { serviceDeclarationsTrail } from './service-declarations.trail.js';
-export { serviceExistsTrail } from './service-exists.trail.js';
+export { provisionDeclarationsTrail } from './provision-declarations.trail.js';
+export { provisionExistsTrail } from './provision-exists.trail.js';
 export { validDescribeRefsTrail } from './valid-describe-refs.trail.js';
 export { validDetourRefsTrail } from './valid-detour-refs.trail.js';
 

package/src/trails/no-direct-impl-in-route.trail.ts

@@ -8,14 +8,14 @@ export const noDirectImplInRouteTrail = wrapRule({
       input: {
         filePath: 'clean.ts',
         sourceCode: `trail("entity.onboard", {
-  follow: ["entity.create"],
-  run: async (input, ctx) => {
-    const result = await ctx.follow("entity.create", input);
+  crosses: ["entity.create"],
+  blaze: async (input, ctx) => {
+    const result = await ctx.cross("entity.create", input);
     return Result.ok(result);
   }
 })`,
       },
-      name: 'Trail with follow using ctx.follow()',
+      name: 'Trail with crossings using ctx.cross()',
     },
   ],
   rule: noDirectImplInRoute,

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

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

package/src/trails/no-sync-result-assumption.trail.ts

@@ -7,12 +7,12 @@ export const noSyncResultAssumptionTrail = wrapRule({
       expected: { diagnostics: [] },
       input: {
         filePath: 'clean.ts',
-        sourceCode: `const result = await myTrail.run(input, ctx);
+        sourceCode: `const result = await myTrail.blaze(input, ctx);
 if (result.isOk()) {
   console.log(result.value);
 }`,
       },
-      name: 'Properly awaited .run() call',
+      name: 'Properly awaited .blaze() call',
     },
   ],
   rule: noSyncResultAssumption,

package/src/trails/no-throw-in-detour-target.trail.ts

@@ -8,7 +8,7 @@ export const noThrowInDetourTargetTrail = wrapRule({
       input: {
         filePath: 'clean.ts',
         sourceCode: `trail("entity.fallback", {
-  run: async (input, ctx) => {
+  blaze: async (input, ctx) => {
     return Result.ok({ recovered: true });
   }
 })`,

package/src/trails/no-throw-in-implementation.trail.ts

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

package/src/trails/prefer-schema-inference.trail.ts

@@ -9,7 +9,7 @@ export const preferSchemaInferenceTrail = wrapRule({
         filePath: 'clean.ts',
         sourceCode: `trail("entity.show", {
   input: z.object({ name: z.string() }),
-  run: async (input, ctx) => {
+  blaze: async (input, ctx) => {
     return Result.ok({ name: input.name });
   }
 })`,

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

@@ -0,0 +1,25 @@
+import { provisionDeclarations } from '../rules/provision-declarations.js';
+import { wrapRule } from './wrap-rule.js';
+
+export const provisionDeclarationsTrail = wrapRule({
+  examples: [
+    {
+      expected: { diagnostics: [] },
+      input: {
+        filePath: 'clean.ts',
+        sourceCode: `const db = provision("db.main", {
+  create: () => Result.ok({ source: "factory" }),
+});
+
+trail("entity.show", {
+  provisions: [db],
+  blaze: async (_input, ctx) => {
+    return Result.ok(db.from(ctx));
+  }
+})`,
+      },
+      name: 'Matched provision declarations and usage',
+    },
+  ],
+  rule: provisionDeclarations,
+});

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

@@ -0,0 +1,27 @@
+import { provisionExists } from '../rules/provision-exists.js';
+import { wrapRule } from './wrap-rule.js';
+
+export const provisionExistsTrail = wrapRule({
+  examples: [
+    {
+      expected: { diagnostics: [] },
+      input: {
+        filePath: 'clean.ts',
+        knownProvisionIds: ['db.main'],
+        knownTrailIds: ['entity.show'],
+        sourceCode: `const db = provision("db.main", {
+  create: () => Result.ok({ source: "factory" }),
+});
+
+trail("entity.show", {
+  provisions: [db],
+  blaze: async (_input, ctx) => {
+    return Result.ok(db.from(ctx));
+  }
+})`,
+      },
+      name: 'Declared provisions resolve to known project provisions',
+    },
+  ],
+  rule: provisionExists,
+});

package/src/trails/run.ts

@@ -4,14 +4,14 @@
  * Returns a flat array of diagnostics from every rule.
  */
 
-import { dispatch } from '@ontrails/core';
+import { run } from '@ontrails/core';
 
 import type { WardenDiagnostic } from '../rules/types.js';
 import type { RuleOutput } from './schema.js';
 import { wardenTopo } from './topo.js';
 
 /**
- * Dispatch all warden rule trails for a given file and collect diagnostics.
+ * Run all warden rule trails for a given file and collect diagnostics.
  *
  * Each rule trail runs independently. Errors from individual trails are
  * silently skipped so that one broken rule does not block the rest.
@@ -20,7 +20,7 @@ export const runWardenTrails = async (
   filePath: string,
   sourceCode: string,
   options?: {
-    readonly knownServiceIds?: readonly string[];
+    readonly knownProvisionIds?: readonly string[];
     readonly knownTrailIds?: readonly string[];
   }
 ): Promise<readonly WardenDiagnostic[]> => {
@@ -28,11 +28,11 @@ export const runWardenTrails = async (
 
   for (const id of wardenTopo.ids()) {
     const input =
-      options?.knownTrailIds || options?.knownServiceIds
+      options?.knownTrailIds || options?.knownProvisionIds
         ? {
             filePath,
-            ...(options?.knownServiceIds
-              ? { knownServiceIds: options.knownServiceIds }
+            ...(options?.knownProvisionIds
+              ? { knownProvisionIds: options.knownProvisionIds }
               : {}),
             ...(options?.knownTrailIds
               ? { knownTrailIds: options.knownTrailIds }
@@ -40,7 +40,7 @@ export const runWardenTrails = async (
             sourceCode,
           }
         : { filePath, sourceCode };
-    const result = await dispatch(wardenTopo, id, input);
+    const result = await run(wardenTopo, id, input);
     if (result.isOk()) {
       const { diagnostics } = result.value as RuleOutput;
       for (const d of diagnostics) {

package/src/trails/schema.ts

@@ -30,10 +30,10 @@ export const ruleInput = z.object({
  * files.
  */
 export const projectAwareRuleInput = ruleInput.extend({
-  knownServiceIds: z
+  knownProvisionIds: z
     .array(z.string())
     .optional()
-    .describe('Service IDs known across the project'),
+    .describe('Provision IDs known across the project'),
   knownTrailIds: z
     .array(z.string())
     .optional()

package/src/trails/valid-detour-refs.trail.ts

@@ -9,12 +9,12 @@ export const validDetourRefsTrail = wrapRule({
         filePath: 'clean.ts',
         knownTrailIds: ['entity.fallback', 'entity.show'],
         sourceCode: `trail("entity.fallback", {
-  run: async (input, ctx) => Result.ok(data)
+  blaze: async (input, ctx) => Result.ok(data)
 })
 
 trail("entity.show", {
   detours: [{ target: "entity.fallback" }],
-  run: async (input, ctx) => Result.ok(data)
+  blaze: async (input, ctx) => Result.ok(data)
 })`,
       },
       name: 'Valid detour target reference',

package/src/trails/wrap-rule.ts

@@ -49,19 +49,10 @@ export function wrapRule(
   if (isProjectAware) {
     const projectAwareRule = rule as ProjectAwareWardenRule;
     return trail(`warden.rule.${rule.name}`, {
-      description: rule.description,
-      examples: examples as Trail<
-        ProjectAwareRuleInput,
-        RuleOutput
-      >['examples'],
-      input: projectAwareRuleInput,
-      intent: 'read',
-      metadata: { category: 'governance', severity: rule.severity },
-      output: ruleOutput,
-      run: (input: ProjectAwareRuleInput) => {
+      blaze: (input: ProjectAwareRuleInput) => {
         const context = {
-          knownServiceIds: input.knownServiceIds
-            ? new Set(input.knownServiceIds)
+          knownProvisionIds: input.knownProvisionIds
+            ? new Set(input.knownProvisionIds)
             : undefined,
           knownTrailIds: input.knownTrailIds
             ? new Set(input.knownTrailIds)
@@ -74,19 +65,28 @@ export function wrapRule(
         );
         return Result.ok({ diagnostics: [...diagnostics] });
       },
+      description: rule.description,
+      examples: examples as Trail<
+        ProjectAwareRuleInput,
+        RuleOutput
+      >['examples'],
+      input: projectAwareRuleInput,
+      intent: 'read',
+      meta: { category: 'governance', severity: rule.severity },
+      output: ruleOutput,
     });
   }
 
   return trail(`warden.rule.${rule.name}`, {
+    blaze: (input: RuleInput) => {
+      const diagnostics = rule.check(input.sourceCode, input.filePath);
+      return Result.ok({ diagnostics: [...diagnostics] });
+    },
     description: rule.description,
     examples: examples as Trail<RuleInput, RuleOutput>['examples'],
     input: ruleInput,
     intent: 'read',
-    metadata: { category: 'governance', severity: rule.severity },
+    meta: { category: 'governance', severity: rule.severity },
     output: ruleOutput,
-    run: (input: RuleInput) => {
-      const diagnostics = rule.check(input.sourceCode, input.filePath);
-      return Result.ok({ diagnostics: [...diagnostics] });
-    },
   });
 }

package/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/cli.ts","./src/drift.ts","./src/formatters.ts","./src/index.ts","./src/rules/ast.ts","./src/rules/context-no-surface-types.ts","./src/rules/follow-declarations.ts","./src/rules/implementation-returns-result.ts","./src/rules/index.ts","./src/rules/no-direct-impl-in-route.ts","./src/rules/no-direct-implementation-call.ts","./src/rules/no-sync-result-assumption.ts","./src/rules/no-throw-in-detour-target.ts","./src/rules/no-throw-in-implementation.ts","./src/rules/prefer-schema-inference.ts","./src/rules/scan.ts","./src/rules/service-declarations.ts","./src/rules/service-exists.ts","./src/rules/specs.ts","./src/rules/structure.ts","./src/rules/types.ts","./src/rules/valid-describe-refs.ts","./src/rules/valid-detour-refs.ts","./src/trails/context-no-surface-types.trail.ts","./src/trails/follow-declarations.trail.ts","./src/trails/implementation-returns-result.trail.ts","./src/trails/index.ts","./src/trails/no-direct-impl-in-route.trail.ts","./src/trails/no-direct-implementation-call.trail.ts","./src/trails/no-sync-result-assumption.trail.ts","./src/trails/no-throw-in-detour-target.trail.ts","./src/trails/no-throw-in-implementation.trail.ts","./src/trails/prefer-schema-inference.trail.ts","./src/trails/run.ts","./src/trails/schema.ts","./src/trails/service-declarations.trail.ts","./src/trails/service-exists.trail.ts","./src/trails/topo.ts","./src/trails/valid-describe-refs.trail.ts","./src/trails/valid-detour-refs.trail.ts","./src/trails/wrap-rule.ts"],"version":"5.9.3"}
+{"root":["./src/cli.ts","./src/drift.ts","./src/formatters.ts","./src/index.ts","./src/rules/ast.ts","./src/rules/context-no-trailhead-types.ts","./src/rules/cross-declarations.ts","./src/rules/implementation-returns-result.ts","./src/rules/index.ts","./src/rules/no-direct-impl-in-route.ts","./src/rules/no-direct-implementation-call.ts","./src/rules/no-sync-result-assumption.ts","./src/rules/no-throw-in-detour-target.ts","./src/rules/no-throw-in-implementation.ts","./src/rules/prefer-schema-inference.ts","./src/rules/provision-declarations.ts","./src/rules/provision-exists.ts","./src/rules/scan.ts","./src/rules/specs.ts","./src/rules/structure.ts","./src/rules/types.ts","./src/rules/valid-describe-refs.ts","./src/rules/valid-detour-refs.ts","./src/trails/context-no-trailhead-types.trail.ts","./src/trails/cross-declarations.trail.ts","./src/trails/implementation-returns-result.trail.ts","./src/trails/index.ts","./src/trails/no-direct-impl-in-route.trail.ts","./src/trails/no-direct-implementation-call.trail.ts","./src/trails/no-sync-result-assumption.trail.ts","./src/trails/no-throw-in-detour-target.trail.ts","./src/trails/no-throw-in-implementation.trail.ts","./src/trails/prefer-schema-inference.trail.ts","./src/trails/provision-declarations.trail.ts","./src/trails/provision-exists.trail.ts","./src/trails/run.ts","./src/trails/schema.ts","./src/trails/topo.ts","./src/trails/valid-describe-refs.trail.ts","./src/trails/valid-detour-refs.trail.ts","./src/trails/wrap-rule.ts"],"version":"5.9.3"}