@auto-engineer/server-generator-apollo-emmett 1.138.0 → 1.140.0

package/src/codegen/extract/projection.specs.ts

@@ -1,4 +1,4 @@
-import type { Narrative } from '@auto-engineer/narrative';
+import type { Scene } from '@auto-engineer/narrative';
 import { describe, expect, it } from 'vitest';
 import type { Message } from '../types';
 import { buildEventIdFieldMap } from './projection';
@@ -10,10 +10,10 @@ describe('buildEventIdFieldMap', () => {
       { type: 'ExerciseLogged', fields: [] },
     ];
 
-    const flows: Narrative[] = [
+    const scenes: Scene[] = [
       {
-        name: 'workout-flow',
-        slices: [
+        name: 'workout-scene',
+        moments: [
           {
             type: 'command',
             name: 'create-workout',
@@ -76,13 +76,13 @@ describe('buildEventIdFieldMap', () => {
       },
     ];
 
-    const findEventSourceFn = (_fls: Narrative[], eventType: string) => {
-      if (eventType === 'WorkoutCreated') return { flowName: 'workout-flow', sliceName: 'create-workout' };
-      if (eventType === 'ExerciseLogged') return { flowName: 'workout-flow', sliceName: 'log-exercises' };
+    const findEventSourceFn = (_fls: Scene[], eventType: string) => {
+      if (eventType === 'WorkoutCreated') return { sceneName: 'workout-scene', momentName: 'create-workout' };
+      if (eventType === 'ExerciseLogged') return { sceneName: 'workout-scene', momentName: 'log-exercises' };
       return null;
     };
 
-    const result = buildEventIdFieldMap(events, flows, findEventSourceFn);
+    const result = buildEventIdFieldMap(events, scenes, findEventSourceFn);
     expect(result).toEqual(
       new Map([
         ['WorkoutCreated', 'id'],
@@ -97,10 +97,10 @@ describe('buildEventIdFieldMap', () => {
       { type: 'WorkoutUpdated', fields: [] },
     ];
 
-    const flows: Narrative[] = [
+    const scenes: Scene[] = [
       {
-        name: 'workout-flow',
-        slices: [
+        name: 'workout-scene',
+        moments: [
           {
             type: 'command',
             name: 'manage-workout',
@@ -141,12 +141,12 @@ describe('buildEventIdFieldMap', () => {
       },
     ];
 
-    const findEventSourceFn = (_fls: Narrative[], _eventType: string) => ({
-      flowName: 'workout-flow',
-      sliceName: 'manage-workout',
+    const findEventSourceFn = (_fls: Scene[], _eventType: string) => ({
+      sceneName: 'workout-scene',
+      momentName: 'manage-workout',
     });
 
-    const result = buildEventIdFieldMap(events, flows, findEventSourceFn);
+    const result = buildEventIdFieldMap(events, scenes, findEventSourceFn);
     expect(result).toEqual(
       new Map([
         ['WorkoutCreated', 'id'],
@@ -157,20 +157,20 @@ describe('buildEventIdFieldMap', () => {
 
   it('returns undefined when no producing slice is found', () => {
     const events: Message[] = [{ type: 'UnknownEvent', fields: [] }];
-    const flows: Narrative[] = [];
+    const scenes: Scene[] = [];
     const findEventSourceFn = () => null;
 
-    const result = buildEventIdFieldMap(events, flows, findEventSourceFn);
+    const result = buildEventIdFieldMap(events, scenes, findEventSourceFn);
     expect(result).toEqual(undefined);
   });
 
   it('skips events from slices with composite keys', () => {
     const events: Message[] = [{ type: 'UserJoined', fields: [] }];
 
-    const flows: Narrative[] = [
+    const scenes: Scene[] = [
       {
-        name: 'flow',
-        slices: [
+        name: 'scene',
+        moments: [
           {
             type: 'command',
             name: 'join',
@@ -204,9 +204,9 @@ describe('buildEventIdFieldMap', () => {
       },
     ];
 
-    const findEventSourceFn = () => ({ flowName: 'flow', sliceName: 'join' });
+    const findEventSourceFn = () => ({ sceneName: 'scene', momentName: 'join' });
 
-    const result = buildEventIdFieldMap(events, flows, findEventSourceFn);
+    const result = buildEventIdFieldMap(events, scenes, findEventSourceFn);
     expect(result).toEqual(undefined);
   });
 });

package/src/codegen/extract/projection.ts

@@ -1,4 +1,4 @@
-import type { Narrative, Slice } from '@auto-engineer/narrative';
+import type { Moment, Scene } from '@auto-engineer/narrative';
 import type { Message } from '../types';
 import { extractStreamIdFields } from './data-sink';
 
@@ -26,7 +26,7 @@ function isProjectionOrigin(origin: unknown): origin is ProjectionOrigin {
   return obj.type === 'projection';
 }
 
-function extractProjectionField<K extends keyof ProjectionOrigin>(slice: Slice, fieldName: K): string | undefined {
+function extractProjectionField<K extends keyof ProjectionOrigin>(slice: Moment, fieldName: K): string | undefined {
   if (!('server' in slice)) return undefined;
   const dataSource = slice.server?.data?.items?.[0];
   if (!hasOrigin(dataSource)) return undefined;
@@ -42,7 +42,7 @@ function extractProjectionField<K extends keyof ProjectionOrigin>(slice: Slice,
   return undefined;
 }
 
-export function extractProjectionIdField(slice: Slice): string | string[] | undefined {
+export function extractProjectionIdField(slice: Moment): string | string[] | undefined {
   if (!('server' in slice)) return undefined;
   const dataSource = slice.server?.data?.items?.[0];
   if (!hasOrigin(dataSource)) return undefined;
@@ -56,20 +56,20 @@ export function extractProjectionIdField(slice: Slice): string | string[] | unde
   return undefined;
 }
 
-export function extractProjectionName(slice: Slice): string | undefined {
+export function extractProjectionName(slice: Moment): string | undefined {
   return extractProjectionField(slice, 'name');
 }
 
 export function buildEventIdFieldMap(
   events: Message[],
-  flows: Narrative[],
-  findEventSourceFn: (flows: Narrative[], eventType: string) => { flowName: string; sliceName: string } | null,
+  scenes: Scene[],
+  findEventSourceFn: (scenes: Scene[], eventType: string) => { sceneName: string; momentName: string } | null,
 ): Map<string, string> | undefined {
   const map = new Map<string, string>();
   for (const event of events) {
-    const source = findEventSourceFn(flows, event.type);
+    const source = findEventSourceFn(scenes, event.type);
     if (!source) continue;
-    const slice = flows.find((f) => f.name === source.flowName)?.slices.find((s) => s.name === source.sliceName);
+    const slice = scenes.find((f) => f.name === source.sceneName)?.moments.find((s) => s.name === source.momentName);
     if (!slice || typeof slice.stream !== 'string') continue;
     const fields = extractStreamIdFields(slice.stream);
     if (fields.length === 1) {
@@ -79,7 +79,7 @@ export function buildEventIdFieldMap(
   return map.size > 0 ? map : undefined;
 }
 
-export function extractProjectionSingleton(slice: Slice): boolean {
+export function extractProjectionSingleton(slice: Moment): boolean {
   if (!('server' in slice)) return false;
   const dataSource = slice.server?.data?.items?.[0];
   if (!hasOrigin(dataSource)) return false;

package/src/codegen/extract/query.ts

@@ -1,4 +1,4 @@
-import type { MappingEntry, Slice } from '@auto-engineer/narrative';
+import type { MappingEntry, Moment } from '@auto-engineer/narrative';
 import type { EventRef, StateRef } from '../types';
 import { extractGwtFromSpecs, isQueryAction, type QueryActionRef } from './step-converter';
 
@@ -16,7 +16,7 @@ export interface QueryGwtCondition {
   then: Array<StateRef>;
 }
 
-export function buildQueryGwtMapping(slice: Slice): QueryGwtCondition[] {
+export function buildQueryGwtMapping(slice: Moment): QueryGwtCondition[] {
   if (slice.type !== 'query') return [];
 
   const specs = slice.server?.specs;

package/src/codegen/extract/slice-normalizer.specs.ts

@@ -1,18 +1,18 @@
-import type { Slice, Spec } from '@auto-engineer/narrative';
+import type { Moment, Spec } from '@auto-engineer/narrative';
 import { describe, expect, it } from 'vitest';
 import type { MessageDefinition } from '../types';
-import { normalizeSliceForTemplate } from './slice-normalizer';
+import { normalizeMomentForTemplate } from './slice-normalizer';
 
-function createReactSlice(specs: Spec[]): Slice {
+function createReactMoment(specs: Spec[]): Moment {
   return {
     type: 'react',
     name: 'NotifyUpcomingWorkout',
     client: { specs: [] },
     server: { description: '', specs },
-  } as unknown as Slice;
+  } as unknown as Moment;
 }
 
-describe('slice-normalizer', () => {
+describe('moment-normalizer', () => {
   describe('normalizeReactPatternB — typical pattern preserves command in then', () => {
     it('should move trigger event to when and place original command in then', () => {
       const specs: Spec[] = [
@@ -76,8 +76,8 @@ describe('slice-normalizer', () => {
         },
       ];
 
-      const slice = createReactSlice(specs);
-      const result = normalizeSliceForTemplate(slice, allMessages);
+      const slice = createReactMoment(specs);
+      const result = normalizeMomentForTemplate(slice, allMessages);
       const normalizedSpecs = result.server?.specs;
       const example = normalizedSpecs?.rules[0].examples[0];
 
@@ -136,8 +136,8 @@ describe('slice-normalizer', () => {
         },
       ];
 
-      const slice = createReactSlice(specs);
-      const result = normalizeSliceForTemplate(slice, allMessages);
+      const slice = createReactMoment(specs);
+      const result = normalizeMomentForTemplate(slice, allMessages);
       const example = result.server?.specs?.rules[0].examples[0];
 
       expect(example?.then).toEqual([{ commandRef: 'NotifyAchievementOpportunity', exampleData: { memberId: 'm1' } }]);
@@ -166,8 +166,8 @@ describe('slice-normalizer', () => {
         },
       ];
 
-      const slice = createReactSlice(specs);
-      const result = normalizeSliceForTemplate(slice, allMessages);
+      const slice = createReactMoment(specs);
+      const result = normalizeMomentForTemplate(slice, allMessages);
       const example = result.server?.specs?.rules[0].examples[0];
 
       expect(example?.then).toEqual([{ commandRef: 'NotifyAchievementOpportunity', exampleData: { memberId: 'm1' } }]);

package/src/codegen/extract/slice-normalizer.ts

@@ -1,4 +1,4 @@
-import type { Slice, Spec } from '@auto-engineer/narrative';
+import type { Moment, Spec } from '@auto-engineer/narrative';
 import type { MessageDefinition } from '../types';
 import {
   type CommandRef,
@@ -6,9 +6,9 @@ import {
   type EventRef,
   extractGwtFromSpecs,
   type GwtConditionWithRule,
-  getSliceType,
+  getMomentType,
+  type MomentType,
   type QueryActionRef,
-  type SliceType,
   type StateRef,
 } from './step-converter';
 
@@ -96,12 +96,12 @@ function filterReactThenToCommands(rules: NormalizedRule[], allMessages: Message
 
 function normalizeSpecsForTemplate(
   specs: Spec[],
-  sliceType: SliceType,
+  momentType: MomentType,
   allMessages?: MessageDefinition[],
 ): NormalizedSpecs | null {
   if (specs.length === 0) return null;
 
-  const gwtResults = extractGwtFromSpecs(specs, sliceType);
+  const gwtResults = extractGwtFromSpecs(specs, momentType);
   const groupedByRule = groupGwtByRule(gwtResults);
 
   const featureName = specs[0]?.feature ?? '';
@@ -111,7 +111,7 @@ function normalizeSpecsForTemplate(
     examples: gwts.map(gwtToNormalizedExample),
   }));
 
-  if (sliceType === 'react' && allMessages) {
+  if (momentType === 'react' && allMessages) {
     normalizeReactPatternB(rules, allMessages);
     filterReactThenToCommands(rules, allMessages);
   }
@@ -122,21 +122,21 @@ function normalizeSpecsForTemplate(
   };
 }
 
-type SliceWithServer = Slice & { server?: { specs?: Spec[] } };
-type NormalizedSlice<T extends SliceWithServer> = Omit<T, 'server'> & {
+type MomentWithServer = Moment & { server?: { specs?: Spec[] } };
+type NormalizedMoment<T extends MomentWithServer> = Omit<T, 'server'> & {
   server?: Omit<T['server'], 'specs'> & { specs?: NormalizedSpecs | null };
 };
 
-export function normalizeSliceForTemplate<T extends SliceWithServer>(
+export function normalizeMomentForTemplate<T extends MomentWithServer>(
   slice: T,
   allMessages?: MessageDefinition[],
-): NormalizedSlice<T> {
+): NormalizedMoment<T> {
   if (!('server' in slice) || !slice.server?.specs) {
-    return slice as NormalizedSlice<T>;
+    return slice as NormalizedMoment<T>;
   }
 
-  const sliceType = getSliceType(slice);
-  const normalizedSpecs = normalizeSpecsForTemplate(slice.server.specs, sliceType, allMessages);
+  const momentType = getMomentType(slice);
+  const normalizedSpecs = normalizeSpecsForTemplate(slice.server.specs, momentType, allMessages);
 
   return {
     ...slice,
@@ -144,5 +144,5 @@ export function normalizeSliceForTemplate<T extends SliceWithServer>(
       ...slice.server,
       specs: normalizedSpecs,
     },
-  } as NormalizedSlice<T>;
+  } as NormalizedMoment<T>;
 }

package/src/codegen/extract/states.ts

@@ -1,4 +1,4 @@
-import type { Slice } from '@auto-engineer/narrative';
+import type { Moment } from '@auto-engineer/narrative';
 import type { EventRef, Message, MessageDefinition } from '../types';
 import { extractFieldsFromMessage } from './fields';
 
@@ -16,7 +16,7 @@ function createStateMessage(stateName: string, allMessages: MessageDefinition[])
   };
 }
 
-function hasServerData(slice: Slice): slice is Slice & { server: { data: { items: unknown[] } } } {
+function hasServerData(slice: Moment): slice is Moment & { server: { data: { items: unknown[] } } } {
   return (
     'server' in slice &&
     Boolean(slice.server) &&
@@ -33,7 +33,7 @@ export function extractStatesFromGiven(givenRefs: EventRef[], allMessages: Messa
     .map((ref) => createStateMessage(ref.eventRef, allMessages));
 }
 
-export function extractStatesFromTarget(slice: Slice, allMessages: MessageDefinition[]): Message[] {
+export function extractStatesFromTarget(slice: Moment, allMessages: MessageDefinition[]): Message[] {
   if (!hasServerData(slice)) {
     return [];
   }
@@ -46,7 +46,7 @@ export function extractStatesFromTarget(slice: Slice, allMessages: MessageDefini
   return uniqueTargets.map((name) => createStateMessage(name, allMessages));
 }
 
-export function extractStatesFromData(slice: Slice, allMessages: MessageDefinition[]): Message[] {
+export function extractStatesFromData(slice: Moment, allMessages: MessageDefinition[]): Message[] {
   if (!hasServerData(slice)) {
     return [];
   }

package/src/codegen/extract/step-converter.specs.ts

@@ -1,17 +1,17 @@
-import type { Example, Slice } from '@auto-engineer/narrative';
+import type { Example, Moment } from '@auto-engineer/narrative';
 import { describe, expect, it } from 'vitest';
 import { isQueryAction, stepsToGwt } from './step-converter';
 
 describe('step-converter', () => {
   describe('stepsToGwt with query slices', () => {
-    const createQuerySlice = (request?: string): Slice =>
+    const createQueryMoment = (request?: string): Moment =>
       ({
         type: 'query',
         name: 'View Workout Plan',
         request,
         client: { specs: [] },
         server: { description: '', specs: [] },
-      }) as unknown as Slice;
+      }) as unknown as Moment;
 
     const createExample = (
       steps: Array<{ keyword: string; text: string; docString?: Record<string, unknown> }>,
@@ -27,7 +27,7 @@ describe('step-converter', () => {
 
     describe('Pattern 2: Query Action', () => {
       it('should produce QueryActionRef when When matches query name from request', () => {
-        const slice = createQuerySlice('query ViewWorkoutPlan($workoutId: ID!) { workoutPlan { id } }');
+        const slice = createQueryMoment('query ViewWorkoutPlan($workoutId: ID!) { workoutPlan { id } }');
         const example = createExample([
           { keyword: 'Given', text: 'WorkoutPlanCreated', docString: { workoutId: 'wrk_123' } },
           { keyword: 'When', text: 'ViewWorkoutPlan', docString: { workoutId: 'wrk_123' } },
@@ -44,7 +44,7 @@ describe('step-converter', () => {
       });
 
       it('should produce QueryActionRef when When matches query name case-insensitively', () => {
-        const slice = createQuerySlice('query viewWorkoutHistory { history { id } }');
+        const slice = createQueryMoment('query viewWorkoutHistory { history { id } }');
         const example = createExample([
           { keyword: 'Given', text: 'WorkoutPlanCreated', docString: { workoutId: 'wrk_123' } },
           { keyword: 'When', text: 'ViewWorkoutHistory', docString: { userId: 'user_456' } },
@@ -61,7 +61,7 @@ describe('step-converter', () => {
       });
 
       it('should produce EventRef[] when no request field is provided', () => {
-        const slice = createQuerySlice(); // No request = cannot detect query action
+        const slice = createQueryMoment(); // No request = cannot detect query action
         const example = createExample([
           { keyword: 'Given', text: 'UserCreated', docString: { userId: 'user_123' } },
           { keyword: 'When', text: 'GetUserProfile', docString: { userId: 'user_123' } },
@@ -78,7 +78,7 @@ describe('step-converter', () => {
 
     describe('Pattern 1: Event-based', () => {
       it('should produce EventRef[] when When contains event names', () => {
-        const slice = createQuerySlice('query ViewWorkoutPlan { workoutPlan { id } }');
+        const slice = createQueryMoment('query ViewWorkoutPlan { workoutPlan { id } }');
         const example = createExample([
           { keyword: 'Given', text: 'WorkoutPlanCreated', docString: { workoutId: 'wrk_123' } },
           { keyword: 'When', text: 'WorkoutPlanUpdated', docString: { workoutId: 'wrk_123', name: 'Updated Plan' } },
@@ -96,7 +96,7 @@ describe('step-converter', () => {
       });
 
       it('should produce EventRef[] when When does not match query action patterns', () => {
-        const slice = createQuerySlice();
+        const slice = createQueryMoment();
         const example = createExample([
           { keyword: 'Given', text: 'OrderCreated', docString: { orderId: 'ord_123' } },
           { keyword: 'When', text: 'OrderShipped', docString: { orderId: 'ord_123' } },
@@ -110,7 +110,7 @@ describe('step-converter', () => {
       });
 
       it('should produce EventRef[] for multiple When events', () => {
-        const slice = createQuerySlice();
+        const slice = createQueryMoment();
         const example = createExample([
           { keyword: 'Given', text: 'AccountCreated', docString: { accountId: 'acc_123' } },
           { keyword: 'When', text: 'DepositMade', docString: { amount: 100 } },

package/src/codegen/extract/step-converter.ts

@@ -1,22 +1,22 @@
-import type { Example, Slice, Spec } from '@auto-engineer/narrative';
+import type { Example, Moment, Spec } from '@auto-engineer/narrative';
 import {
   type CommandRef,
   detectQueryAction,
   type ErrorRef,
   type EventRef,
-  getSliceType,
+  getMomentType,
   isQueryAction,
   isStepWithDocString,
   isStepWithError,
   type MajorKeyword,
+  type MomentType,
   type QueryActionRef,
   resolveMajorKeyword,
-  type SliceType,
   type StateRef,
 } from './step-types';
 
-export type { CommandRef, EventRef, StateRef, ErrorRef, SliceType, QueryActionRef };
-export { getSliceType, isQueryAction };
+export type { CommandRef, EventRef, StateRef, ErrorRef, MomentType, QueryActionRef };
+export { getMomentType, isQueryAction };
 
 export interface GwtResult {
   given: EventRef[];
@@ -63,10 +63,10 @@ function parseSteps(example: Example): ParsedSteps {
   return { given, whenItems, thenItems, thenErrors };
 }
 
-function buildGwtResult(sliceType: SliceType, parsed: ParsedSteps, description: string, slice?: Slice): GwtResult {
+function buildGwtResult(momentType: MomentType, parsed: ParsedSteps, description: string, slice?: Moment): GwtResult {
   const { given, whenItems, thenItems, thenErrors } = parsed;
 
-  if (sliceType === 'command') {
+  if (momentType === 'command') {
     return {
       given,
       when: { commandRef: whenItems[0]?.text ?? '', exampleData: whenItems[0]?.exampleData ?? {} },
@@ -75,7 +75,7 @@ function buildGwtResult(sliceType: SliceType, parsed: ParsedSteps, description:
     };
   }
 
-  if (sliceType === 'react') {
+  if (momentType === 'react') {
     return {
       given,
       when: whenItems.map((w) => ({ eventRef: w.text, exampleData: w.exampleData })),
@@ -84,7 +84,7 @@ function buildGwtResult(sliceType: SliceType, parsed: ParsedSteps, description:
     };
   }
 
-  if (sliceType === 'query' && slice && whenItems.length > 0) {
+  if (momentType === 'query' && slice && whenItems.length > 0) {
     const firstWhenText = whenItems[0]?.text ?? '';
     if (detectQueryAction(firstWhenText, slice)) {
       return {
@@ -105,22 +105,22 @@ function buildGwtResult(sliceType: SliceType, parsed: ParsedSteps, description:
   };
 }
 
-export function stepsToGwt(example: Example, sliceType: SliceType, slice?: Slice): GwtResult {
+export function stepsToGwt(example: Example, momentType: MomentType, slice?: Moment): GwtResult {
   const parsed = parseSteps(example);
-  return buildGwtResult(sliceType, parsed, example.name, slice);
+  return buildGwtResult(momentType, parsed, example.name, slice);
 }
 
 export interface GwtConditionWithRule extends GwtResult {
   ruleDescription: string;
 }
 
-export function extractGwtFromSpecs(specs: Spec[], sliceType: SliceType, slice?: Slice): GwtConditionWithRule[] {
+export function extractGwtFromSpecs(specs: Spec[], momentType: MomentType, slice?: Moment): GwtConditionWithRule[] {
   const results: GwtConditionWithRule[] = [];
 
   for (const spec of specs) {
     for (const rule of spec.rules) {
       for (const example of rule.examples) {
-        const gwt = stepsToGwt(example, sliceType, slice);
+        const gwt = stepsToGwt(example, momentType, slice);
         results.push({
           ...gwt,
           ruleDescription: rule.name,
@@ -132,9 +132,9 @@ export function extractGwtFromSpecs(specs: Spec[], sliceType: SliceType, slice?:
   return results;
 }
 
-export function extractGwtSpecsFromSlice(slice: Slice): GwtConditionWithRule[] {
+export function extractGwtSpecsFromMoment(slice: Moment): GwtConditionWithRule[] {
   if (!('server' in slice)) return [];
   const specs = slice.server?.specs;
   if (!Array.isArray(specs) || specs.length === 0) return [];
-  return extractGwtFromSpecs(specs, getSliceType(slice), slice);
+  return extractGwtFromSpecs(specs, getMomentType(slice), slice);
 }

package/src/codegen/extract/step-types.specs.ts

@@ -1,4 +1,4 @@
-import type { Slice } from '@auto-engineer/narrative';
+import type { Moment } from '@auto-engineer/narrative';
 import { describe, expect, it } from 'vitest';
 import { detectQueryAction, extractQueryNameFromRequest, isQueryAction, type QueryActionRef } from './step-types';
 
@@ -79,55 +79,55 @@ describe('step-types', () => {
   });
 
   describe('detectQueryAction', () => {
-    const createQuerySlice = (request?: string): Slice =>
+    const createQueryMoment = (request?: string): Moment =>
       ({
         type: 'query',
         name: 'View Workout Plan',
         request,
         client: { specs: [] },
         server: { description: '', specs: [] },
-      }) as unknown as Slice;
+      }) as unknown as Moment;
 
-    const createCommandSlice = (): Slice =>
+    const createCommandMoment = (): Moment =>
       ({
         type: 'command',
         name: 'Create Workout',
         client: { specs: [] },
         server: { description: '', specs: [] },
-      }) as unknown as Slice;
+      }) as unknown as Moment;
 
     it('should return true when whenText exactly matches query name from request', () => {
-      const slice = createQuerySlice('query ViewWorkoutPlan($id: ID!) { workoutPlan { id } }');
+      const slice = createQueryMoment('query ViewWorkoutPlan($id: ID!) { workoutPlan { id } }');
       expect(detectQueryAction('ViewWorkoutPlan', slice)).toBe(true);
     });
 
     it('should return true when whenText matches query name case-insensitively', () => {
-      const slice = createQuerySlice('query viewWorkoutPlan { workoutPlan { id } }');
+      const slice = createQueryMoment('query viewWorkoutPlan { workoutPlan { id } }');
       expect(detectQueryAction('ViewWorkoutPlan', slice)).toBe(true);
     });
 
     it('should return false for command slices', () => {
-      const slice = createCommandSlice();
+      const slice = createCommandMoment();
       expect(detectQueryAction('ViewWorkoutPlan', slice)).toBe(false);
     });
 
     it('should return false when no request field is provided', () => {
-      const slice = createQuerySlice(); // No request
+      const slice = createQueryMoment(); // No request
       expect(detectQueryAction('ViewWorkoutPlan', slice)).toBe(false);
     });
 
     it('should return false for event names that do not match query name', () => {
-      const slice = createQuerySlice('query ViewWorkoutPlan { workoutPlan { id } }');
+      const slice = createQueryMoment('query ViewWorkoutPlan { workoutPlan { id } }');
       expect(detectQueryAction('WorkoutPlanCreated', slice)).toBe(false);
     });
 
     it('should return false for empty whenText', () => {
-      const slice = createQuerySlice('query ViewWorkoutPlan { workoutPlan { id } }');
+      const slice = createQueryMoment('query ViewWorkoutPlan { workoutPlan { id } }');
       expect(detectQueryAction('', slice)).toBe(false);
     });
 
     it('should return false when request contains mutation instead of query', () => {
-      const slice = createQuerySlice('mutation CreateWorkout { createWorkout { id } }');
+      const slice = createQueryMoment('mutation CreateWorkout { createWorkout { id } }');
       expect(detectQueryAction('CreateWorkout', slice)).toBe(false);
     });
   });

package/src/codegen/extract/step-types.ts

@@ -1,4 +1,4 @@
-import type { Slice, Step, StepWithDocStringSchema, StepWithErrorSchema } from '@auto-engineer/narrative';
+import type { Moment, Step, StepWithDocStringSchema, StepWithErrorSchema } from '@auto-engineer/narrative';
 import {
   detectQueryAction as detectQueryActionFromNarrative,
   extractQueryNameFromRequest,
@@ -13,9 +13,9 @@ export type MajorKeyword = Exclude<StepKeyword, 'And'>;
 
 export type ErrorType = StepWithError['error']['type'];
 
-export type SliceType = Extract<Slice['type'], 'command' | 'query' | 'react'>;
+export type MomentType = Extract<Moment['type'], 'command' | 'query' | 'react'>;
 
-export function getSliceType(slice: Slice): SliceType {
+export function getMomentType(slice: Moment): MomentType {
   if (slice.type === 'command' || slice.type === 'query' || slice.type === 'react') {
     return slice.type;
   }
@@ -74,6 +74,6 @@ export { extractQueryNameFromRequest };
  * Detects if the "When" text in a query slice represents a query action (query name)
  * rather than an event name. Delegates to the narrative package implementation.
  */
-export function detectQueryAction(whenText: string, slice: Slice): boolean {
+export function detectQueryAction(whenText: string, slice: Moment): boolean {
   return detectQueryActionFromNarrative(whenText, slice);
 }