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

package/src/__tests__/{follows.test.ts → crosses.test.ts}

@@ -1,16 +1,17 @@
 import { describe } from 'bun:test';
 
 import type { AnyTrail, TrailContext } from '@ontrails/core';
-import { InternalError, Result, service, trail } from '@ontrails/core';
+import { InternalError, Result, provision, trail } from '@ontrails/core';
 import { z } from 'zod';
 
-import { testFollows } from '../follows.js';
+import { testCrosses } from '../crosses.js';
 
 // ---------------------------------------------------------------------------
-// Test trails (followed by composition trail)
+// Test trails (trails with crossings)
 // ---------------------------------------------------------------------------
 
 const addTrail = trail('entity.add', {
+  blaze: (input: { name: string }) => Result.ok({ id: '1', name: input.name }),
   description: 'Add an entity',
   examples: [
     { input: { name: 'Alpha' }, name: 'success' },
@@ -23,15 +24,14 @@ const addTrail = trail('entity.add', {
   ],
   input: z.object({ name: z.string() }),
   output: z.object({ id: z.string(), name: z.string() }),
-  run: (input: { name: string }) => Result.ok({ id: '1', name: input.name }),
 });
 
 const relateTrail = trail('entity.relate', {
+  blaze: (input: { from: string; to: string }) =>
+    Result.ok({ from: input.from, to: input.to }),
   description: 'Relate two entities',
   input: z.object({ from: z.string(), to: z.string() }),
   output: z.object({ from: z.string(), to: z.string() }),
-  run: (input: { from: string; to: string }) =>
-    Result.ok({ from: input.from, to: input.to }),
 });
 
 // ---------------------------------------------------------------------------
@@ -39,17 +39,14 @@ const relateTrail = trail('entity.relate', {
 // ---------------------------------------------------------------------------
 
 const onboardTrail = trail('entity.onboard', {
-  follow: ['entity.add', 'entity.relate'],
-  input: z.object({ name: z.string(), relatedTo: z.string() }),
-  output: z.object({ name: z.string(), relatedTo: z.string() }),
-  run: async (
+  blaze: async (
     input: { name: string; relatedTo: string },
     ctx: TrailContext
   ) => {
-    if (!ctx.follow) {
-      return Result.err(new Error('follow not available'));
+    if (!ctx.cross) {
+      return Result.err(new Error('cross not available'));
     }
-    const addResult = await ctx.follow<{ id: string; name: string }>(
+    const addResult = await ctx.cross<{ id: string; name: string }>(
       'entity.add',
       { name: input.name }
     );
@@ -57,7 +54,7 @@ const onboardTrail = trail('entity.onboard', {
       return Result.err(addResult.error);
     }
 
-    const relateResult = await ctx.follow<{ from: string; to: string }>(
+    const relateResult = await ctx.cross<{ from: string; to: string }>(
       'entity.relate',
       { from: addResult.value.name, to: input.relatedTo }
     );
@@ -70,6 +67,9 @@ const onboardTrail = trail('entity.onboard', {
       relatedTo: relateResult.value.to,
     });
   },
+  crosses: ['entity.add', 'entity.relate'],
+  input: z.object({ name: z.string(), relatedTo: z.string() }),
+  output: z.object({ name: z.string(), relatedTo: z.string() }),
 });
 
 const trailsMap = new Map<string, AnyTrail>([
@@ -83,9 +83,9 @@ const trailsMap = new Map<string, AnyTrail>([
 
 const opts = { trails: trailsMap };
 
-describe('testFollows: expectOk', () => {
+describe('testCrosses: expectOk', () => {
   // eslint-disable-next-line jest/require-hook
-  testFollows(
+  testCrosses(
     onboardTrail,
     [
       {
@@ -98,14 +98,14 @@ describe('testFollows: expectOk', () => {
   );
 });
 
-describe('testFollows: expectFollowed', () => {
+describe('testCrosses: expectCrossed', () => {
   // eslint-disable-next-line jest/require-hook
-  testFollows(
+  testCrosses(
     onboardTrail,
     [
       {
-        description: 'follows add then relate in order',
-        expectFollowed: ['entity.add', 'entity.relate'],
+        description: 'crosses add then relate in order',
+        expectCrossed: ['entity.add', 'entity.relate'],
         expectOk: true,
         input: { name: 'Alpha', relatedTo: 'Beta' },
       },
@@ -114,14 +114,14 @@ describe('testFollows: expectFollowed', () => {
   );
 });
 
-describe('testFollows: expectFollowedCount', () => {
+describe('testCrosses: expectCrossedCount', () => {
   // eslint-disable-next-line jest/require-hook
-  testFollows(
+  testCrosses(
     onboardTrail,
     [
       {
-        description: 'each trail followed exactly once',
-        expectFollowedCount: { 'entity.add': 1, 'entity.relate': 1 },
+        description: 'each trail crossed exactly once',
+        expectCrossedCount: { 'entity.add': 1, 'entity.relate': 1 },
         expectOk: true,
         input: { name: 'Alpha', relatedTo: 'Beta' },
       },
@@ -130,9 +130,9 @@ describe('testFollows: expectFollowedCount', () => {
   );
 });
 
-describe('testFollows: injectFromExample', () => {
+describe('testCrosses: injectFromExample', () => {
   // eslint-disable-next-line jest/require-hook
-  testFollows(
+  testCrosses(
     onboardTrail,
     [
       {
@@ -147,9 +147,9 @@ describe('testFollows: injectFromExample', () => {
   );
 });
 
-describe('testFollows: expectValue', () => {
+describe('testCrosses: expectValue', () => {
   // eslint-disable-next-line jest/require-hook
-  testFollows(
+  testCrosses(
     onboardTrail,
     [
       {
@@ -163,51 +163,48 @@ describe('testFollows: expectValue', () => {
 });
 
 // ---------------------------------------------------------------------------
-// Nested follow chain: A → B → C
+// Nested cross chain: A → B → C
 // ---------------------------------------------------------------------------
 
 const leafTrail = trail('step.leaf', {
+  blaze: (input: { value: string }) => Result.ok({ leaf: input.value }),
   description: 'Leaf trail in a nested chain',
   input: z.object({ value: z.string() }),
   output: z.object({ leaf: z.string() }),
-  run: (input: { value: string }) => Result.ok({ leaf: input.value }),
 });
 
 const middleTrail = trail('step.middle', {
-  description: 'Middle trail that follows the leaf',
-  follow: ['step.leaf'],
-  input: z.object({ value: z.string() }),
-  output: z.object({ middle: z.string() }),
-  run: async (input: { value: string }, ctx: TrailContext) => {
-    if (!ctx.follow) {
-      return Result.err(new Error('follow not available'));
+  blaze: async (input: { value: string }, ctx: TrailContext) => {
+    if (!ctx.cross) {
+      return Result.err(new Error('cross not available'));
     }
-    const leafResult = await ctx.follow<{ leaf: string }>('step.leaf', input);
+    const leafResult = await ctx.cross<{ leaf: string }>('step.leaf', input);
     if (leafResult.isErr()) {
       return leafResult;
     }
     return Result.ok({ middle: leafResult.value.leaf });
   },
+  crosses: ['step.leaf'],
+  description: 'Middle trail that crosses the leaf',
+  input: z.object({ value: z.string() }),
+  output: z.object({ middle: z.string() }),
 });
 
 const nestedRootTrail = trail('step.root', {
-  description: 'Root trail that follows the middle trail',
-  follow: ['step.middle'],
-  input: z.object({ value: z.string() }),
-  output: z.object({ root: z.string() }),
-  run: async (input: { value: string }, ctx: TrailContext) => {
-    if (!ctx.follow) {
-      return Result.err(new Error('follow not available'));
+  blaze: async (input: { value: string }, ctx: TrailContext) => {
+    if (!ctx.cross) {
+      return Result.err(new Error('cross not available'));
     }
-    const midResult = await ctx.follow<{ middle: string }>(
-      'step.middle',
-      input
-    );
+    const midResult = await ctx.cross<{ middle: string }>('step.middle', input);
     if (midResult.isErr()) {
       return midResult;
     }
     return Result.ok({ root: midResult.value.middle });
   },
+  crosses: ['step.middle'],
+  description: 'Root trail that crosses the middle trail',
+  input: z.object({ value: z.string() }),
+  output: z.object({ root: z.string() }),
 });
 
 const nestedTrailsMap = new Map<string, AnyTrail>([
@@ -215,13 +212,13 @@ const nestedTrailsMap = new Map<string, AnyTrail>([
   ['step.middle', middleTrail],
 ]);
 
-describe('testFollows: nested follow chain (A → B → C)', () => {
+describe('testCrosses: nested cross chain (A → B → C)', () => {
   // eslint-disable-next-line jest/require-hook
-  testFollows(
+  testCrosses(
     nestedRootTrail,
     [
       {
-        description: 'nested ctx.follow works through A → B → C',
+        description: 'nested ctx.cross works through A → B → C',
         expectOk: true,
         expectValue: { root: 'hello' },
         input: { value: 'hello' },
@@ -231,31 +228,27 @@ describe('testFollows: nested follow chain (A → B → C)', () => {
   );
 });
 
-const mockDbService = service('db.mock.follows', {
+const mockDbProvision = provision('db.mock.crosses', {
   create: () => Result.ok({ source: 'factory' }),
   mock: () => ({ source: 'mock' }),
 });
 
-const serviceLeafTrail = trail('service.leaf', {
-  description: 'Leaf trail that reads from a service',
+const provisionLeafTrail = trail('provision.leaf', {
+  blaze: (_input, ctx) =>
+    Result.ok({ childSource: mockDbProvision.from(ctx).source }),
+  description: 'Leaf trail that reads from a provision',
   input: z.object({}),
   output: z.object({ childSource: z.string() }),
-  run: (_input, ctx) =>
-    Result.ok({ childSource: mockDbService.from(ctx).source }),
-  services: [mockDbService],
+  provisions: [mockDbProvision],
 });
 
-const serviceRootTrail = trail('service.root', {
-  description: 'Root trail that reads from a service and follows a child trail',
-  follow: ['service.leaf'],
-  input: z.object({}),
-  output: z.object({ childSource: z.string(), rootSource: z.string() }),
-  run: async (_input, ctx: TrailContext) => {
-    if (!ctx.follow) {
-      return Result.err(new Error('follow not available'));
+const provisionRootTrail = trail('provision.root', {
+  blaze: async (_input, ctx: TrailContext) => {
+    if (!ctx.cross) {
+      return Result.err(new Error('cross not available'));
     }
-    const childResult = await ctx.follow<{ childSource: string }>(
-      'service.leaf',
+    const childResult = await ctx.cross<{ childSource: string }>(
+      'provision.leaf',
       {}
     );
     if (childResult.isErr()) {
@@ -264,46 +257,46 @@ const serviceRootTrail = trail('service.root', {
 
     return Result.ok({
       childSource: childResult.value.childSource,
-      rootSource: mockDbService.from(ctx).source,
+      rootSource: mockDbProvision.from(ctx).source,
     });
   },
-  services: [mockDbService],
+  crosses: ['provision.leaf'],
+  description:
+    'Root trail that reads from a provision and crosses a child trail',
+  input: z.object({}),
+  output: z.object({ childSource: z.string(), rootSource: z.string() }),
+  provisions: [mockDbProvision],
 });
 
-const serviceTrailsMap = new Map<string, AnyTrail>([
-  ['service.leaf', serviceLeafTrail],
+const provisionTrailsMap = new Map<string, AnyTrail>([
+  ['provision.leaf', provisionLeafTrail],
 ]);
 
-const statefulMockDbService = service('db.mock.follows.stateful', {
+const statefulMockDbProvision = provision('db.mock.crosses.stateful', {
   create: () => Result.ok({ count: 0 }),
   mock: () => ({ count: 0 }),
 });
 
-const statefulServiceLeafTrail = trail('service.stateful.leaf', {
-  description: 'Leaf trail that observes the current mock service state',
+const statefulProvisionLeafTrail = trail('provision.stateful.leaf', {
+  blaze: (_input, ctx) =>
+    Result.ok({ childCount: statefulMockDbProvision.from(ctx).count }),
+  description: 'Leaf trail that observes the current mock provision state',
   input: z.object({}),
   output: z.object({ childCount: z.number() }),
-  run: (_input, ctx) =>
-    Result.ok({ childCount: statefulMockDbService.from(ctx).count }),
-  services: [statefulMockDbService],
+  provisions: [statefulMockDbProvision],
 });
 
-const statefulServiceRootTrail = trail('service.stateful.root', {
-  description:
-    'Root trail that mutates a mocked service and follows a child trail',
-  follow: ['service.stateful.leaf'],
-  input: z.object({}),
-  output: z.object({ childCount: z.number(), rootCount: z.number() }),
-  run: async (_input, ctx: TrailContext) => {
-    if (!ctx.follow) {
-      return Result.err(new Error('follow not available'));
+const statefulProvisionRootTrail = trail('provision.stateful.root', {
+  blaze: async (_input, ctx: TrailContext) => {
+    if (!ctx.cross) {
+      return Result.err(new Error('cross not available'));
     }
 
-    const statefulService = statefulMockDbService.from(ctx);
-    statefulService.count += 1;
+    const statefulProvision = statefulMockDbProvision.from(ctx);
+    statefulProvision.count += 1;
 
-    const childResult = await ctx.follow<{ childCount: number }>(
-      'service.stateful.leaf',
+    const childResult = await ctx.cross<{ childCount: number }>(
+      'provision.stateful.leaf',
       {}
     );
     if (childResult.isErr()) {
@@ -312,45 +305,46 @@ const statefulServiceRootTrail = trail('service.stateful.root', {
 
     return Result.ok({
       childCount: childResult.value.childCount,
-      rootCount: statefulService.count,
+      rootCount: statefulProvision.count,
     });
   },
-  services: [statefulMockDbService],
+  crosses: ['provision.stateful.leaf'],
+  description:
+    'Root trail that mutates a mocked provision and crosses a child trail',
+  input: z.object({}),
+  output: z.object({ childCount: z.number(), rootCount: z.number() }),
+  provisions: [statefulMockDbProvision],
 });
 
-const statefulServiceTrailsMap = new Map<string, AnyTrail>([
-  ['service.stateful.leaf', statefulServiceLeafTrail],
+const statefulProvisionTrailsMap = new Map<string, AnyTrail>([
+  ['provision.stateful.leaf', statefulProvisionLeafTrail],
 ]);
 
-const scenarioStateService = service('db.mock.scenarios', {
+const scenarioStateProvision = provision('db.mock.scenarios', {
   create: () => Result.ok({ count: 0 }),
   mock: () => ({ count: 0 }),
 });
 
-const scenarioLeafTrail = trail('service.scenario.leaf', {
+const scenarioLeafTrail = trail('provision.scenario.leaf', {
+  blaze: (_input, ctx) =>
+    Result.ok({ count: scenarioStateProvision.from(ctx).count }),
   description: 'Leaf trail that reads mutable scenario state',
   input: z.object({}),
   output: z.object({ count: z.number() }),
-  run: (_input, ctx) =>
-    Result.ok({ count: scenarioStateService.from(ctx).count }),
-  services: [scenarioStateService],
+  provisions: [scenarioStateProvision],
 });
 
-const scenarioRootTrail = trail('service.scenario.root', {
-  description: 'Root trail that mutates scenario state and follows a leaf',
-  follow: ['service.scenario.leaf'],
-  input: z.object({}),
-  output: z.object({ count: z.number() }),
-  run: async (_input, ctx: TrailContext) => {
-    if (!ctx.follow) {
-      return Result.err(new Error('follow not available'));
+const scenarioRootTrail = trail('provision.scenario.root', {
+  blaze: async (_input, ctx: TrailContext) => {
+    if (!ctx.cross) {
+      return Result.err(new Error('cross not available'));
     }
 
-    const state = scenarioStateService.from(ctx);
+    const state = scenarioStateProvision.from(ctx);
     state.count += 1;
 
-    const leafResult = await ctx.follow<{ count: number }>(
-      'service.scenario.leaf',
+    const leafResult = await ctx.cross<{ count: number }>(
+      'provision.scenario.leaf',
       {}
     );
     if (leafResult.isErr()) {
@@ -359,34 +353,32 @@ const scenarioRootTrail = trail('service.scenario.root', {
 
     return Result.ok({ count: leafResult.value.count });
   },
-  services: [scenarioStateService],
+  crosses: ['provision.scenario.leaf'],
+  description: 'Root trail that mutates scenario state and crosses a leaf',
+  input: z.object({}),
+  output: z.object({ count: z.number() }),
+  provisions: [scenarioStateProvision],
 });
 
-const scenarioTrailsMap = new Map<string, AnyTrail>([
-  ['service.scenario.leaf', scenarioLeafTrail],
+const scenarioProvisionTrailsMap = new Map<string, AnyTrail>([
+  ['provision.scenario.leaf', scenarioLeafTrail],
 ]);
 
-const transformedFollowLeafTrail = trail('follow.transformed.leaf', {
-  description: 'Leaf trail in a transformed follow chain',
+const transformedCrossLeafTrail = trail('cross.transformed.leaf', {
+  blaze: (input: { value: number }) => Result.ok({ value: input.value }),
+  description: 'Leaf trail in a transformed cross chain',
   input: z.object({ value: z.number() }),
   output: z.object({ value: z.number() }),
-  run: (input: { value: number }) => Result.ok({ value: input.value }),
 });
 
-const transformedFollowRootTrail = trail('follow.transformed.root', {
-  description: 'Root trail that transforms input once before following',
-  follow: ['follow.transformed.leaf'],
-  input: z
-    .object({ value: z.string() })
-    .transform(({ value }) => ({ value: Number(value) + 1 })),
-  output: z.object({ root: z.number() }),
-  run: async (input: { value: number }, ctx: TrailContext) => {
-    if (!ctx.follow) {
-      return Result.err(new Error('follow not available'));
+const transformedCrossRootTrail = trail('cross.transformed.root', {
+  blaze: async (input: { value: number }, ctx: TrailContext) => {
+    if (!ctx.cross) {
+      return Result.err(new Error('cross not available'));
     }
 
-    const leafResult = await ctx.follow<{ value: number }>(
-      'follow.transformed.leaf',
+    const leafResult = await ctx.cross<{ value: number }>(
+      'cross.transformed.leaf',
       { value: input.value }
     );
     if (leafResult.isErr()) {
@@ -395,38 +387,40 @@ const transformedFollowRootTrail = trail('follow.transformed.root', {
 
     return Result.ok({ root: leafResult.value.value });
   },
+  crosses: ['cross.transformed.leaf'],
+  description: 'Root trail that transforms input once before crossing',
+  input: z
+    .object({ value: z.string() })
+    .transform(({ value }) => ({ value: Number(value) + 1 })),
+  output: z.object({ root: z.number() }),
 });
 
-const transformedFollowTrailsMap = new Map<string, AnyTrail>([
-  ['follow.transformed.leaf', transformedFollowLeafTrail],
+const transformedCrossTrailsMap = new Map<string, AnyTrail>([
+  ['cross.transformed.leaf', transformedCrossLeafTrail],
 ]);
 
-const undeclaredFollowService = service('db.undeclared.follows', {
+const undeclaredCrossProvision = provision('db.undeclared.crosses', {
   create: () => Result.ok({ source: 'factory' }),
   mock: () => ({ source: 'mock' }),
 });
 
-const undeclaredServiceLeafTrail = trail('service.undeclared.leaf', {
-  description: 'Leaf trail that declares the shared service',
+const undeclaredProvisionLeafTrail = trail('provision.undeclared.leaf', {
+  blaze: (_input, ctx) =>
+    Result.ok({ childSource: undeclaredCrossProvision.from(ctx).source }),
+  description: 'Leaf trail that declares the shared provision',
   input: z.object({}),
   output: z.object({ childSource: z.string() }),
-  run: (_input, ctx) =>
-    Result.ok({ childSource: undeclaredFollowService.from(ctx).source }),
-  services: [undeclaredFollowService],
+  provisions: [undeclaredCrossProvision],
 });
 
-const undeclaredServiceRootTrail = trail('service.undeclared.root', {
-  description: 'Root trail that uses a service without declaring it',
-  follow: ['service.undeclared.leaf'],
-  input: z.object({}),
-  output: z.object({ childSource: z.string(), rootSource: z.string() }),
-  run: async (_input, ctx: TrailContext) => {
-    if (!ctx.follow) {
-      return Result.err(new Error('follow not available'));
+const undeclaredProvisionRootTrail = trail('provision.undeclared.root', {
+  blaze: async (_input, ctx: TrailContext) => {
+    if (!ctx.cross) {
+      return Result.err(new Error('cross not available'));
     }
 
-    const childResult = await ctx.follow<{ childSource: string }>(
-      'service.undeclared.leaf',
+    const childResult = await ctx.cross<{ childSource: string }>(
+      'provision.undeclared.leaf',
       {}
     );
     if (childResult.isErr()) {
@@ -435,92 +429,96 @@ const undeclaredServiceRootTrail = trail('service.undeclared.root', {
 
     return Result.ok({
       childSource: childResult.value.childSource,
-      rootSource: undeclaredFollowService.from(ctx).source,
+      rootSource: undeclaredCrossProvision.from(ctx).source,
     });
   },
+  crosses: ['provision.undeclared.leaf'],
+  description: 'Root trail that uses a provision without declaring it',
+  input: z.object({}),
+  output: z.object({ childSource: z.string(), rootSource: z.string() }),
 });
 
-const undeclaredServiceTrailsMap = new Map<string, AnyTrail>([
-  ['service.undeclared.leaf', undeclaredServiceLeafTrail],
+const undeclaredProvisionTrailsMap = new Map<string, AnyTrail>([
+  ['provision.undeclared.leaf', undeclaredProvisionLeafTrail],
 ]);
 
-const unrelatedFollowService = service('db.unrelated.follows', {
+const unrelatedCrossProvision = provision('db.unrelated.crosses', {
   create: () => Result.ok({ source: 'factory' }),
   mock: () => {
     throw new Error('unrelated mock should not be resolved');
   },
 });
 
-const unrelatedServiceTrail = trail('service.unrelated', {
+const unrelatedProvisionTrail = trail('provision.unrelated', {
+  blaze: (_input, ctx) =>
+    Result.ok({ source: unrelatedCrossProvision.from(ctx).source }),
   description: 'Trail that should not be traversed or mocked',
   input: z.object({}),
   output: z.object({ source: z.string() }),
-  run: (_input, ctx) =>
-    Result.ok({ source: unrelatedFollowService.from(ctx).source }),
-  services: [unrelatedFollowService],
+  provisions: [unrelatedCrossProvision],
 });
 
-const unrelatedServiceTrailsMap = new Map<string, AnyTrail>([
-  ['service.unrelated', unrelatedServiceTrail],
+const unrelatedProvisionTrailsMap = new Map<string, AnyTrail>([
+  ['provision.unrelated', unrelatedProvisionTrail],
 ]);
 
-describe('testFollows service mocks', () => {
+describe('testCrosses provision mocks', () => {
   // eslint-disable-next-line jest/require-hook
-  testFollows(
-    serviceRootTrail,
+  testCrosses(
+    provisionRootTrail,
     [
       {
-        description: 'propagates auto-resolved service mocks through follow',
+        description: 'propagates auto-resolved provision mocks through cross',
         expectValue: { childSource: 'mock', rootSource: 'mock' },
         input: {},
       },
     ],
-    { trails: serviceTrailsMap }
+    { trails: provisionTrailsMap }
   );
 });
 
-describe('testFollows service mocks are fresh per scenario', () => {
+describe('testCrosses provision mocks are fresh per scenario', () => {
   // eslint-disable-next-line jest/require-hook
-  testFollows(
+  testCrosses(
     scenarioRootTrail,
     [
       {
-        description: 'first scenario sees a fresh mutable service',
+        description: 'first scenario sees a fresh mutable provision',
         expectValue: { count: 1 },
         input: {},
       },
       {
-        description: 'second scenario also sees a fresh mutable service',
+        description: 'second scenario also sees a fresh mutable provision',
         expectValue: { count: 1 },
         input: {},
       },
     ],
-    { trails: scenarioTrailsMap }
+    { trails: scenarioProvisionTrailsMap }
   );
 });
 
-describe('testFollows explicit service overrides', () => {
+describe('testCrosses explicit provision overrides', () => {
   // eslint-disable-next-line jest/require-hook
-  testFollows(
-    serviceRootTrail,
+  testCrosses(
+    provisionRootTrail,
     [
       {
-        description: 'propagates explicit service overrides through follow',
+        description: 'propagates explicit provision overrides through cross',
         expectValue: { childSource: 'override', rootSource: 'override' },
         input: {},
       },
     ],
     {
-      services: { 'db.mock.follows': { source: 'override' } },
-      trails: serviceTrailsMap,
+      provisions: { 'db.mock.crosses': { source: 'override' } },
+      trails: provisionTrailsMap,
     }
   );
 });
 
-describe('testFollows raw transformed input', () => {
+describe('testCrosses raw transformed input', () => {
   // eslint-disable-next-line jest/require-hook
-  testFollows(
-    transformedFollowRootTrail,
+  testCrosses(
+    transformedCrossRootTrail,
     [
       {
         description: 'raw scenario input is only transformed once',
@@ -528,62 +526,62 @@ describe('testFollows raw transformed input', () => {
         input: { value: '1' },
       },
     ],
-    { trails: transformedFollowTrailsMap }
+    { trails: transformedCrossTrailsMap }
   );
 });
 
-describe('testFollows service declarations', () => {
+describe('testCrosses provision declarations', () => {
   // eslint-disable-next-line jest/require-hook
-  testFollows(
-    undeclaredServiceRootTrail,
+  testCrosses(
+    undeclaredProvisionRootTrail,
     [
       {
-        description: 'fails when the root trail omits a required service',
+        description: 'fails when the root trail omits a required provision',
         expectErr: InternalError,
-        expectErrMessage: undeclaredFollowService.id,
+        expectErrMessage: undeclaredCrossProvision.id,
         input: {},
       },
     ],
-    { trails: undeclaredServiceTrailsMap }
+    { trails: undeclaredProvisionTrailsMap }
   );
 });
 
-describe('testFollows only resolves mocks for trails under test', () => {
+describe('testCrosses only resolves mocks for trails under test', () => {
   // eslint-disable-next-line jest/require-hook
-  testFollows(
-    serviceRootTrail,
+  testCrosses(
+    provisionRootTrail,
     [
       {
-        description: 'unrelated service mocks are not resolved',
+        description: 'unrelated provision mocks are not resolved',
         expectValue: { childSource: 'mock', rootSource: 'mock' },
         input: {},
       },
     ],
     {
       trails: new Map<string, AnyTrail>([
-        ...serviceTrailsMap.entries(),
-        ...unrelatedServiceTrailsMap.entries(),
+        ...provisionTrailsMap.entries(),
+        ...unrelatedProvisionTrailsMap.entries(),
       ]),
     }
   );
 });
 
-describe('testFollows fresh service mocks per scenario', () => {
+describe('testCrosses fresh provision mocks per scenario', () => {
   // eslint-disable-next-line jest/require-hook
-  testFollows(
-    statefulServiceRootTrail,
+  testCrosses(
+    statefulProvisionRootTrail,
     [
       {
-        description: 'first scenario gets a fresh service mock',
+        description: 'first scenario gets a fresh provision mock',
         expectValue: { childCount: 1, rootCount: 1 },
         input: {},
       },
       {
-        description: 'second scenario also gets a fresh service mock',
+        description: 'second scenario also gets a fresh provision mock',
         expectValue: { childCount: 1, rootCount: 1 },
         input: {},
       },
     ],
-    { trails: statefulServiceTrailsMap }
+    { trails: statefulProvisionTrailsMap }
   );
 });