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

package/package.json

@@ -32,8 +32,8 @@
     "uuid": "^13.0.0",
     "web-streams-polyfill": "^4.1.0",
     "zod": "^3.22.4",
-    "@auto-engineer/narrative": "1.138.0",
-    "@auto-engineer/message-bus": "1.138.0"
+    "@auto-engineer/narrative": "1.140.0",
+    "@auto-engineer/message-bus": "1.140.0"
   },
   "publishConfig": {
     "access": "public"
@@ -44,9 +44,9 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "tsx": "^4.19.2",
-    "@auto-engineer/cli": "1.138.0"
+    "@auto-engineer/cli": "1.140.0"
   },
-  "version": "1.138.0",
+  "version": "1.140.0",
   "scripts": {
     "generate:server": "tsx src/cli/index.ts",
     "build": "tsc && tsx ../../scripts/fix-esm-imports.ts && rm -rf dist/src/codegen/templates && mkdir -p dist/src/codegen && cp -r src/codegen/templates dist/src/codegen/templates && cp src/server.ts dist/src && cp -r src/utils dist/src && cp -r src/domain dist/src",

package/src/codegen/extract/data-sink.ts

@@ -1,6 +1,6 @@
-import type { Slice } from '@auto-engineer/narrative';
+import type { Moment } from '@auto-engineer/narrative';
 import type { CommandRef, ErrorRef } from '../types';
-import { extractGwtSpecsFromSlice, type GwtResult } from './step-converter';
+import { extractGwtSpecsFromMoment, type GwtResult } from './step-converter';
 
 function resolveStreamId(stream: string, exampleData: Record<string, unknown>): string {
   return stream.replace(/\$\{([^}]+)\}/g, (_, key: string) => String(exampleData?.[key] ?? 'unknown'));
@@ -20,7 +20,7 @@ function extractExampleDataFromCommand(firstSpec: GwtResult): Record<string, unk
   return firstExample?.exampleData ?? {};
 }
 
-function extractExampleDataFromSpecs(slice: Slice, gwtSpecs: GwtResult[]): Record<string, unknown> {
+function extractExampleDataFromSpecs(slice: Moment, gwtSpecs: GwtResult[]): Record<string, unknown> {
   if (gwtSpecs.length === 0) {
     return {};
   }
@@ -72,12 +72,12 @@ export function extractStreamIdFields(pattern: string): string[] {
   return fields;
 }
 
-export function getStreamFromSink(slice: Slice): { streamPattern?: string; streamId?: string } {
+export function getStreamFromSink(slice: Moment): { streamPattern?: string; streamId?: string } {
   if (!('server' in slice)) return {};
   if (slice.server?.data?.items == null || !Array.isArray(slice.server.data.items)) {
     return {};
   }
-  const gwtSpecs = extractGwtSpecsFromSlice(slice);
+  const gwtSpecs = extractGwtSpecsFromMoment(slice);
   const exampleData = extractExampleDataFromSpecs(slice, gwtSpecs);
   const serverData = slice.server.data.items;
 

package/src/codegen/extract/events.ts

@@ -6,35 +6,35 @@ function createEventMessage(
   eventRef: string | undefined,
   source: 'given' | 'then' | 'when',
   allMessages: MessageDefinition[],
-  currentSliceName?: string,
-  currentFlowName?: string,
+  currentMomentName?: string,
+  currentSceneName?: string,
 ): Message | undefined {
   if (eventRef == null) return undefined;
   const fields = extractFieldsFromMessage(eventRef, 'event', allMessages);
   const messageDef = allMessages.find((m) => m.type === 'event' && m.name === eventRef);
-  const metadata = messageDef?.metadata as { sourceFlowName?: string; sourceSliceName?: string } | undefined;
-  const sourceFlowName = metadata?.sourceFlowName ?? currentFlowName;
-  const sourceSliceName = metadata?.sourceSliceName ?? currentSliceName;
+  const metadata = messageDef?.metadata as { sourceSceneName?: string; sourceMomentName?: string } | undefined;
+  const sourceSceneName = metadata?.sourceSceneName ?? currentSceneName;
+  const sourceMomentName = metadata?.sourceMomentName ?? currentMomentName;
 
   return {
     type: eventRef,
     fields,
     source,
-    sourceFlowName,
-    sourceSliceName,
+    sourceSceneName,
+    sourceMomentName,
   };
 }
 
 export function extractEventsFromThen(
   thenItems: Array<EventRef | ErrorRef>,
   allMessages: MessageDefinition[],
-  currentSliceName?: string,
-  currentFlowName?: string,
+  currentMomentName?: string,
+  currentSceneName?: string,
 ): Message[] {
   return thenItems
     .map((then): Message | undefined => {
       if (!('eventRef' in then)) return undefined;
-      return createEventMessage(then.eventRef, 'then', allMessages, currentSliceName, currentFlowName);
+      return createEventMessage(then.eventRef, 'then', allMessages, currentMomentName, currentSceneName);
     })
     .filter((event): event is Message => event !== undefined);
 }
@@ -42,25 +42,25 @@ export function extractEventsFromThen(
 export function extractEventsFromGiven(
   givenEvents: EventRef[] | undefined,
   allMessages: MessageDefinition[],
-  currentSliceName?: string,
-  currentFlowName?: string,
+  currentMomentName?: string,
+  currentSceneName?: string,
 ): Message[] {
   if (!givenEvents) return [];
 
   return givenEvents
-    .map((given) => createEventMessage(given.eventRef, 'given', allMessages, currentSliceName, currentFlowName))
+    .map((given) => createEventMessage(given.eventRef, 'given', allMessages, currentMomentName, currentSceneName))
     .filter((event): event is Message => event !== undefined);
 }
 
 export function extractEventsFromWhen(
   gwtSpecs: ReactGwtSpec[],
   allMessages: MessageDefinition[],
-  currentSliceName?: string,
+  currentMomentName?: string,
 ): Message[] {
   return gwtSpecs.flatMap((gwt) => {
     if (!Array.isArray(gwt.when)) {
       return [];
     }
-    return gwt.when.flatMap((eventExample) => extractEventsFromGiven([eventExample], allMessages, currentSliceName));
+    return gwt.when.flatMap((eventExample) => extractEventsFromGiven([eventExample], allMessages, currentMomentName));
   });
 }

package/src/codegen/extract/gwt.ts

@@ -1,13 +1,13 @@
-import type { Slice } from '@auto-engineer/narrative';
+import type { Moment } from '@auto-engineer/narrative';
 import type { CommandRef, EventRef, GwtCondition } from '../types';
-import { extractGwtSpecsFromSlice, type GwtConditionWithRule, type QueryActionRef } from './step-converter';
+import { extractGwtSpecsFromMoment, type GwtConditionWithRule, type QueryActionRef } from './step-converter';
 
-export function buildCommandGwtMapping(slice: Slice): Record<string, (GwtCondition & { failingFields?: string[] })[]> {
+export function buildCommandGwtMapping(slice: Moment): Record<string, (GwtCondition & { failingFields?: string[] })[]> {
   if (slice.type !== 'command') {
     return {};
   }
 
-  const gwtSpecs = extractGwtSpecsFromSlice(slice);
+  const gwtSpecs = extractGwtSpecsFromMoment(slice);
   const mapping = buildCommandMapping(gwtSpecs);
   return enhanceMapping(mapping);
 }

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

@@ -7,48 +7,48 @@ describe('groupEventImports', () => {
     const events: Message[] = [{ type: 'OrderCreated', fields: [], source: 'then' }];
 
     const result = groupEventImports({
-      currentSliceName: 'create order',
-      currentFlowName: 'order management',
+      currentMomentName: 'create order',
+      currentSceneName: 'order management',
       events,
     });
 
     expect(result).toEqual([{ importPath: './events', eventTypes: ['OrderCreated'] }]);
   });
 
-  it('groups cross-slice same-flow events as ../other-slice/events', () => {
+  it('groups cross-slice same-scene events as ../other-slice/events', () => {
     const events: Message[] = [
       {
         type: 'OrderCreated',
         fields: [],
         source: 'when',
-        sourceFlowName: 'order management',
-        sourceSliceName: 'create order',
+        sourceSceneName: 'order management',
+        sourceMomentName: 'create order',
       },
     ];
 
     const result = groupEventImports({
-      currentSliceName: 'notify customer',
-      currentFlowName: 'order management',
+      currentMomentName: 'notify customer',
+      currentSceneName: 'order management',
       events,
     });
 
     expect(result).toEqual([{ importPath: '../create-order/events', eventTypes: ['OrderCreated'] }]);
   });
 
-  it('groups cross-flow events as ../../other-flow/other-slice/events', () => {
+  it('groups cross-scene events as ../../other-scene/other-slice/events', () => {
     const events: Message[] = [
       {
         type: 'WorkoutCreated',
         fields: [],
         source: 'when',
-        sourceFlowName: 'gym workout creation',
-        sourceSliceName: 'create workout',
+        sourceSceneName: 'gym workout creation',
+        sourceMomentName: 'create workout',
       },
     ];
 
     const result = groupEventImports({
-      currentSliceName: 'view workout progress',
-      currentFlowName: 'gym workout completion',
+      currentMomentName: 'view workout progress',
+      currentSceneName: 'gym workout completion',
       events,
     });
 
@@ -60,27 +60,27 @@ describe('groupEventImports', () => {
     ]);
   });
 
-  it('handles mixed same-flow and cross-flow events', () => {
+  it('handles mixed same-scene and cross-scene events', () => {
     const events: Message[] = [
       {
         type: 'WorkoutCompleted',
         fields: [],
         source: 'when',
-        sourceFlowName: 'gym workout completion',
-        sourceSliceName: 'complete workout',
+        sourceSceneName: 'gym workout completion',
+        sourceMomentName: 'complete workout',
       },
       {
         type: 'WorkoutCreated',
         fields: [],
         source: 'when',
-        sourceFlowName: 'gym workout creation',
-        sourceSliceName: 'create workout',
+        sourceSceneName: 'gym workout creation',
+        sourceMomentName: 'create workout',
       },
     ];
 
     const result = groupEventImports({
-      currentSliceName: 'view workout progress',
-      currentFlowName: 'gym workout completion',
+      currentMomentName: 'view workout progress',
+      currentSceneName: 'gym workout completion',
       events,
     });
 

package/src/codegen/extract/imports.ts

@@ -6,9 +6,9 @@ export interface ImportGroup {
   eventTypes: string[];
 }
 
-export interface CrossSliceImportContext {
-  currentSliceName: string;
-  currentFlowName: string;
+export interface CrossMomentImportContext {
+  currentMomentName: string;
+  currentSceneName: string;
   events: Message[];
 }
 
@@ -17,24 +17,24 @@ export interface CrossSliceImportContext {
  * Events from the current slice are imported from './events',
  * while cross-slice events are imported from '../other-slice/events'.
  */
-export function groupEventImports(context: CrossSliceImportContext): ImportGroup[] {
-  const { currentSliceName, currentFlowName, events } = context;
+export function groupEventImports(context: CrossMomentImportContext): ImportGroup[] {
+  const { currentMomentName, currentSceneName, events } = context;
   const importGroups = new Map<string, string[]>();
 
   for (const event of events) {
     if (!event.type) continue;
     let importPath: string;
-    const isFromCurrentSlice =
-      event.source === 'then' || event.sourceSliceName === currentSliceName || event.sourceSliceName == null;
+    const isFromCurrentMoment =
+      event.source === 'then' || event.sourceMomentName === currentMomentName || event.sourceMomentName == null;
 
-    if (isFromCurrentSlice) {
+    if (isFromCurrentMoment) {
       importPath = './events';
     } else {
-      const sourceFlowName = event.sourceFlowName;
-      const isCrossFlow = sourceFlowName != null && sourceFlowName !== currentFlowName;
-      const sliceSegment = toKebabCase(event.sourceSliceName ?? currentSliceName);
-      importPath = isCrossFlow
-        ? `../../${toKebabCase(sourceFlowName)}/${sliceSegment}/events`
+      const sourceSceneName = event.sourceSceneName;
+      const isCrossScene = sourceSceneName != null && sourceSceneName !== currentSceneName;
+      const sliceSegment = toKebabCase(event.sourceMomentName ?? currentMomentName);
+      importPath = isCrossScene
+        ? `../../${toKebabCase(sourceSceneName)}/${sliceSegment}/events`
         : `../${sliceSegment}/events`;
     }
     if (!importGroups.has(importPath)) {

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

@@ -1,11 +1,11 @@
-import type { Slice } from '@auto-engineer/narrative';
+import type { Moment } from '@auto-engineer/narrative';
 import { describe, expect, it } from 'vitest';
 import type { MessageDefinition } from '../types';
 import { extractMessagesFromSpecs } from './messages';
 
 describe('extractMessagesFromSpecs (react slice)', () => {
   it('should extract given events and states, filtering phantom refs', () => {
-    const slice: Slice = {
+    const slice: Moment = {
       type: 'react',
       name: 'adjust inventory on payment',
       server: {
@@ -88,8 +88,8 @@ describe('extractMessagesFromSpecs (react slice)', () => {
           { name: 'orderId', tsType: 'string', required: true },
         ],
         source: 'given',
-        sourceFlowName: undefined,
-        sourceSliceName: 'adjust inventory on payment',
+        sourceSceneName: undefined,
+        sourceMomentName: 'adjust inventory on payment',
       },
     ]);
 
@@ -108,7 +108,7 @@ describe('extractMessagesFromSpecs (react slice)', () => {
   });
 
   it('should extract commands from normalized react when-command pattern', () => {
-    const slice: Slice = {
+    const slice: Moment = {
       type: 'react',
       name: 'update workout progress',
       server: {
@@ -174,8 +174,8 @@ describe('extractMessagesFromSpecs (react slice)', () => {
         type: 'GymSessionLogged',
         fields: [{ name: 'sessionId', tsType: 'string', required: true }],
         source: 'given',
-        sourceFlowName: undefined,
-        sourceSliceName: 'update workout progress',
+        sourceSceneName: undefined,
+        sourceMomentName: 'update workout progress',
       },
     ]);
 
@@ -191,7 +191,7 @@ describe('extractMessagesFromSpecs (react slice)', () => {
 
 describe('extractMessagesFromSpecs (command slice)', () => {
   it('should create state-as-event with source then for Given-step state refs', () => {
-    const slice: Slice = {
+    const slice: Moment = {
       type: 'command',
       name: 'book barber appointment',
       server: {
@@ -269,7 +269,7 @@ describe('extractMessagesFromSpecs (command slice)', () => {
           { name: 'appointments', tsType: 'object[]', required: true },
         ],
         source: 'then',
-        sourceSliceName: 'book barber appointment',
+        sourceMomentName: 'book barber appointment',
       },
       {
         type: 'BarberAppointmentBooked',
@@ -278,14 +278,14 @@ describe('extractMessagesFromSpecs (command slice)', () => {
           { name: 'barberId', tsType: 'string', required: true },
         ],
         source: 'then',
-        sourceFlowName: undefined,
-        sourceSliceName: 'book barber appointment',
+        sourceSceneName: undefined,
+        sourceMomentName: 'book barber appointment',
       },
     ]);
   });
 
   it('should still extract Given-step event refs with source given', () => {
-    const slice: Slice = {
+    const slice: Moment = {
       type: 'command',
       name: 'update order',
       server: {
@@ -357,8 +357,8 @@ describe('extractMessagesFromSpecs (command slice)', () => {
         type: 'OrderPlaced',
         fields: [{ name: 'orderId', tsType: 'string', required: true }],
         source: 'given',
-        sourceFlowName: undefined,
-        sourceSliceName: 'update order',
+        sourceSceneName: undefined,
+        sourceMomentName: 'update order',
       },
       {
         type: 'OrderUpdated',
@@ -367,8 +367,8 @@ describe('extractMessagesFromSpecs (command slice)', () => {
           { name: 'status', tsType: 'string', required: true },
         ],
         source: 'then',
-        sourceFlowName: undefined,
-        sourceSliceName: 'update order',
+        sourceSceneName: undefined,
+        sourceMomentName: 'update order',
       },
     ]);
   });
@@ -376,7 +376,7 @@ describe('extractMessagesFromSpecs (command slice)', () => {
 
 describe('extractMessagesFromSpecs (query slice)', () => {
   it('should not include non-event When steps in the events list', () => {
-    const slice: Slice = {
+    const slice: Moment = {
       type: 'query',
       name: 'views workout details',
       server: {
@@ -461,8 +461,8 @@ describe('extractMessagesFromSpecs (query slice)', () => {
           { name: 'exercise', tsType: 'string', required: true },
         ],
         source: 'given',
-        sourceFlowName: undefined,
-        sourceSliceName: undefined,
+        sourceSceneName: undefined,
+        sourceMomentName: undefined,
       },
     ]);
 
@@ -472,7 +472,7 @@ describe('extractMessagesFromSpecs (query slice)', () => {
 
 describe('extractMessagesFromSpecs (react slice with data target events)', () => {
   it('should extract data target events with source then', () => {
-    const slice: Slice = {
+    const slice: Moment = {
       type: 'react',
       name: 'notify barber of new booking',
       server: {
@@ -551,7 +551,7 @@ describe('extractMessagesFromSpecs (react slice with data target events)', () =>
             { name: 'notifiedAt', tsType: 'Date', required: true },
           ],
           source: 'then',
-          sourceSliceName: 'notify barber of new booking',
+          sourceMomentName: 'notify barber of new booking',
         },
       ]),
     );
@@ -560,7 +560,7 @@ describe('extractMessagesFromSpecs (react slice with data target events)', () =>
 
 describe('extractMessagesFromSpecs (command slice with data target events)', () => {
   it('should extract data.items Event not in GWT Then', () => {
-    const slice: Slice = {
+    const slice: Moment = {
       type: 'command',
       name: 'submit workout log',
       server: {
@@ -644,15 +644,15 @@ describe('extractMessagesFromSpecs (command slice with data target events)', ()
         type: 'WorkoutLogged',
         fields: [{ name: 'workoutId', tsType: 'string', required: true }],
         source: 'then',
-        sourceFlowName: undefined,
-        sourceSliceName: 'submit workout log',
+        sourceSceneName: undefined,
+        sourceMomentName: 'submit workout log',
       },
       {
         type: 'WorkoutLogRejected',
         fields: [{ name: 'workoutId', tsType: 'string', required: true }],
         source: 'then',
-        sourceFlowName: undefined,
-        sourceSliceName: 'submit workout log',
+        sourceSceneName: undefined,
+        sourceMomentName: 'submit workout log',
       },
       {
         type: 'PointsEarned',
@@ -661,13 +661,13 @@ describe('extractMessagesFromSpecs (command slice with data target events)', ()
           { name: 'points', tsType: 'number', required: true },
         ],
         source: 'then',
-        sourceSliceName: 'submit workout log',
+        sourceMomentName: 'submit workout log',
       },
     ]);
   });
 
   it('should deduplicate events present in both GWT Then and data.items', () => {
-    const slice: Slice = {
+    const slice: Moment = {
       type: 'command',
       name: 'place order',
       server: {
@@ -723,8 +723,8 @@ describe('extractMessagesFromSpecs (command slice with data target events)', ()
         type: 'OrderPlaced',
         fields: [{ name: 'orderId', tsType: 'string', required: true }],
         source: 'then',
-        sourceFlowName: undefined,
-        sourceSliceName: 'place order',
+        sourceSceneName: undefined,
+        sourceMomentName: 'place order',
       },
     ]);
   });

package/src/codegen/extract/messages.ts

@@ -1,4 +1,4 @@
-import type { Slice } from '@auto-engineer/narrative';
+import type { Moment } from '@auto-engineer/narrative';
 import createDebug from 'debug';
 import type { CommandRef, EventRef, Message, MessageDefinition } from '../types';
 import { extractCommandsFromGwt, extractCommandsFromThen } from './commands';
@@ -52,7 +52,7 @@ function deduplicateMessages<T extends Message>(messages: T[]): T[] {
   return result;
 }
 
-function extractDataTargetEvents(slice: Slice, allMessages: MessageDefinition[]): Message[] {
+function extractDataTargetEvents(slice: Moment, allMessages: MessageDefinition[]): Message[] {
   const events: Message[] = [];
   if ('server' in slice && slice.server?.data?.items) {
     for (const item of slice.server.data.items) {
@@ -61,7 +61,7 @@ function extractDataTargetEvents(slice: Slice, allMessages: MessageDefinition[])
           type: item.target.name,
           fields: extractFieldsFromMessage(item.target.name, 'event', allMessages),
           source: 'then' as const,
-          sourceSliceName: slice.name,
+          sourceMomentName: slice.name,
         });
       }
     }
@@ -69,11 +69,11 @@ function extractDataTargetEvents(slice: Slice, allMessages: MessageDefinition[])
   return events;
 }
 
-function extractMessagesForCommand(slice: Slice, allMessages: MessageDefinition[]): ExtractedMessages {
+function extractMessagesForCommand(slice: Moment, allMessages: MessageDefinition[]): ExtractedMessages {
   debugCommand('Extracting messages for command slice: %s', slice.name);
 
   if (slice.type !== 'command') {
-    debugCommand('  Slice type is not command, returning empty');
+    debugCommand('  Moment type is not command, returning empty');
     return EMPTY_EXTRACTED_MESSAGES;
   }
 
@@ -98,7 +98,7 @@ function extractMessagesForCommand(slice: Slice, allMessages: MessageDefinition[
       type: ref.eventRef,
       fields: extractFieldsFromMessage(ref.eventRef, 'state', allMessages),
       source: 'then' as const,
-      sourceSliceName: slice.name,
+      sourceMomentName: slice.name,
     }));
   debugCommand('  State-as-events from Given: %d', stateAsEvents.length);
 
@@ -129,11 +129,11 @@ function extractMessagesForCommand(slice: Slice, allMessages: MessageDefinition[
   return result;
 }
 
-function extractMessagesForQuery(slice: Slice, allMessages: MessageDefinition[]): ExtractedMessages {
+function extractMessagesForQuery(slice: Moment, allMessages: MessageDefinition[]): ExtractedMessages {
   debugQuery('Extracting messages for query slice: %s', slice.name);
 
   if (slice.type !== 'query') {
-    debugQuery('  Slice type is not query, returning empty');
+    debugQuery('  Moment type is not query, returning empty');
     return EMPTY_EXTRACTED_MESSAGES;
   }
 
@@ -157,14 +157,14 @@ function extractMessagesForQuery(slice: Slice, allMessages: MessageDefinition[])
       .map((eventExample) => {
         const fields = extractFieldsFromMessage(eventExample.eventRef, 'event', allMessages);
         const messageDef = allMessages.find((m) => m.type === 'event' && m.name === eventExample.eventRef);
-        const metadata = messageDef?.metadata as { sourceFlowName?: string; sourceSliceName?: string } | undefined;
+        const metadata = messageDef?.metadata as { sourceSceneName?: string; sourceMomentName?: string } | undefined;
 
         return {
           type: eventExample.eventRef,
           fields,
           source: 'when',
-          sourceFlowName: metadata?.sourceFlowName,
-          sourceSliceName: metadata?.sourceSliceName,
+          sourceSceneName: metadata?.sourceSceneName,
+          sourceMomentName: metadata?.sourceMomentName,
         };
       });
 
@@ -188,11 +188,11 @@ function extractMessagesForQuery(slice: Slice, allMessages: MessageDefinition[])
   return result;
 }
 
-function extractMessagesForReact(slice: Slice, allMessages: MessageDefinition[]): ExtractedMessages {
+function extractMessagesForReact(slice: Moment, allMessages: MessageDefinition[]): ExtractedMessages {
   debugReact('Extracting messages for react slice: %s', slice.name);
 
   if (slice.type !== 'react') {
-    debugReact('  Slice type is not react, returning empty');
+    debugReact('  Moment type is not react, returning empty');
     return EMPTY_EXTRACTED_MESSAGES;
   }
 
@@ -254,7 +254,7 @@ function extractMessagesForReact(slice: Slice, allMessages: MessageDefinition[])
   return result;
 }
 
-export function extractMessagesFromSpecs(slice: Slice, allMessages: MessageDefinition[]): ExtractedMessages {
+export function extractMessagesFromSpecs(slice: Moment, allMessages: MessageDefinition[]): ExtractedMessages {
   debug('Extracting messages from slice: %s (type: %s)', slice.name, slice.type);
   debug('  Total message definitions available: %d', allMessages.length);
 
@@ -271,8 +271,8 @@ export function extractMessagesFromSpecs(slice: Slice, allMessages: MessageDefin
       result = extractMessagesForReact(slice, allMessages);
       break;
     default: {
-      const unknownSlice = slice as Slice;
-      debug('  Unknown slice type: %s, returning empty', unknownSlice.type);
+      const unknownMoment = slice as Moment;
+      debug('  Unknown slice type: %s, returning empty', unknownMoment.type);
       result = EMPTY_EXTRACTED_MESSAGES;
     }
   }