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

package/src/commands/generate-server.ts

@@ -3,7 +3,7 @@ import * as path from 'node:path';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { type Command, defineCommandHandler, type Event } from '@auto-engineer/message-bus';
-import type { Model, Narrative, Slice } from '@auto-engineer/narrative';
+import type { Model, Moment, Scene } from '@auto-engineer/narrative';
 import createDebug from 'debug';
 
 import fs from 'fs-extra';
@@ -25,7 +25,7 @@ const debugScaffold = createDebug('auto:server-generator-apollo-emmett:scaffold'
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-type SliceDelta = {
+type MomentDelta = {
   type: 'added' | 'removed' | 'changed';
   previous?: Record<string, unknown>;
   current?: Record<string, unknown>;
@@ -37,7 +37,7 @@ export type ChangeSet = {
   changed: string[];
   sharedTypesChanged: boolean;
   allAffected: string[];
-  deltas: Record<string, SliceDelta>;
+  deltas: Record<string, MomentDelta>;
 };
 
 export type GenerationState = {
@@ -81,29 +81,29 @@ export type ServerGenerationFailedEvent = Event<
     destination: string;
     error: string;
     model: Model;
-    flowName?: string;
-    sliceName?: string;
-    sliceType?: string;
+    sceneName?: string;
+    momentName?: string;
+    momentType?: string;
   }
 >;
 
-export type SliceGeneratedEvent = Event<
-  'SliceGenerated',
+export type MomentGeneratedEvent = Event<
+  'MomentGenerated',
   {
-    flowName: string;
-    sliceName: string;
-    sliceType: string;
+    sceneName: string;
+    momentName: string;
+    momentType: string;
     schemaPath: string;
-    slicePath: string;
+    momentPath: string;
   }
 >;
 
-export type SliceGenerationFailedEvent = Event<
-  'SliceGenerationFailed',
+export type MomentGenerationFailedEvent = Event<
+  'MomentGenerationFailed',
   {
-    flowName: string;
-    sliceName: string;
-    sliceType: string;
+    sceneName: string;
+    momentName: string;
+    momentType: string;
     error: string;
     model: Model;
   }
@@ -112,8 +112,8 @@ export type SliceGenerationFailedEvent = Event<
 export type GenerateServerEvents =
   | ServerGeneratedEvent
   | ServerGenerationFailedEvent
-  | SliceGeneratedEvent
-  | SliceGenerationFailedEvent;
+  | MomentGeneratedEvent
+  | MomentGenerationFailedEvent;
 
 export const commandHandler = defineCommandHandler({
   name: 'GenerateServer',
@@ -125,8 +125,8 @@ export const commandHandler = defineCommandHandler({
   events: [
     { name: 'ServerGenerated', displayName: 'Back End Built' },
     { name: 'ServerGenerationFailed', displayName: 'Back End Build Failed' },
-    { name: 'SliceGenerated', displayName: 'Slice Generated' },
-    { name: 'SliceGenerationFailed', displayName: 'Slice Generation Failed' },
+    { name: 'MomentGenerated', displayName: 'Moment Generated' },
+    { name: 'MomentGenerationFailed', displayName: 'Moment Generation Failed' },
   ],
   fields: {
     model: {
@@ -202,23 +202,24 @@ async function cleanStaleCompiledFiles(serverDir: string): Promise<void> {
 async function generateAndWriteScaffold(
   spec: Model,
   serverDir: string,
-  affectedSliceIds?: Set<string>,
+  affectedMomentIds?: Set<string>,
 ): Promise<{ duplicateCommands: DuplicateCommandInfo[]; fieldIssues: FieldIssue[] }> {
-  const domainFlowsPath = join(serverDir, 'src', 'domain', 'flows');
+  const domainNarrativesPath = join(serverDir, 'src', 'domain', 'narratives');
   debugScaffold('Generating scaffold file plans');
-  debugScaffold('  Domain flows path: %s', domainFlowsPath);
-  debugScaffold('  Number of flows: %d', spec.narratives?.length || 0);
+  debugScaffold('  Domain scenes path: %s', domainNarrativesPath);
+  debugScaffold('  Number of scenes: %d', spec.scenes?.length || 0);
 
   const {
     plans: filePlans,
     duplicateCommands,
     fieldIssues,
   } = await generateScaffoldFilePlans(
-    spec.narratives,
+    spec.scenes,
     spec.messages,
     spec.integrations,
-    domainFlowsPath,
-    affectedSliceIds,
+    domainNarrativesPath,
+    affectedMomentIds,
+    spec.narratives,
   );
 
   debugScaffold('Generated %d file plans', filePlans.length);
@@ -254,7 +255,7 @@ async function copyAllFiles(serverDir: string): Promise<void> {
 }
 
 export async function writeHealthResolver(serverDir: string): Promise<void> {
-  const healthDir = path.join(serverDir, 'src', 'domain', 'flows', 'health');
+  const healthDir = path.join(serverDir, 'src', 'domain', 'narratives', 'health');
   const resolverPath = path.join(healthDir, 'query.resolver.ts');
   await fs.ensureDir(healthDir);
   await writeFile(
@@ -311,9 +312,9 @@ function stripAnsiCodes(text: string): string {
 export function createServerFailureEvent(command: GenerateServerCommand, error: unknown): ServerGenerationFailedEvent {
   debug('Server generation failed with error: %O', error);
 
-  let flowName: string | undefined;
-  let sliceName: string | undefined;
-  let sliceType: string | undefined;
+  let sceneName: string | undefined;
+  let momentName: string | undefined;
+  let momentType: string | undefined;
   let templateFile: string | undefined;
   let errorMessage: string;
 
@@ -321,9 +322,9 @@ export function createServerFailureEvent(command: GenerateServerCommand, error:
     let current: unknown = error;
     while (current instanceof Error) {
       if (current instanceof ScaffoldError) {
-        flowName = current.flowName;
-        sliceName = current.sliceName;
-        sliceType = current.sliceType;
+        sceneName = current.sceneName;
+        momentName = current.momentName;
+        momentType = current.momentType;
       }
       if (current instanceof TemplateRenderError) {
         templateFile = current.templateFile;
@@ -345,9 +346,9 @@ export function createServerFailureEvent(command: GenerateServerCommand, error:
       destination: command.data.destination,
       error: errorMessage,
       model: command.data.model,
-      flowName,
-      sliceName,
-      sliceType,
+      sceneName,
+      momentName,
+      momentType,
     },
     timestamp: new Date(),
     requestId: command.requestId,
@@ -363,19 +364,21 @@ function findRootCause(error: Error): Error {
   return current;
 }
 
-export function createSliceGeneratedEvent(
-  flow: Narrative,
-  slice: Slice,
+export function createMomentGeneratedEvent(
+  scene: Scene,
+  slice: Moment,
   command: GenerateServerCommand,
-): SliceGeneratedEvent {
+  sceneDirName?: string,
+): MomentGeneratedEvent {
+  const dirName = sceneDirName ?? toKebabCase(scene.name);
   return {
-    type: 'SliceGenerated',
+    type: 'MomentGenerated',
     data: {
-      flowName: flow.name,
-      sliceName: slice.name,
-      sliceType: slice.type,
+      sceneName: scene.name,
+      momentName: slice.name,
+      momentType: slice.type,
       schemaPath: deriveModelPath(command.data.destination),
-      slicePath: ensureDirPath('./server/src/domain/flows', toKebabCase(flow.name), toKebabCase(slice.name)),
+      momentPath: ensureDirPath('./server/src/domain/narratives', dirName, toKebabCase(slice.name)),
     },
     timestamp: new Date(),
     requestId: command.requestId,
@@ -383,15 +386,30 @@ export function createSliceGeneratedEvent(
   };
 }
 
-export function emitSliceGenerationFailedForDuplicates(
+function buildSceneToNarrativeMap(narratives: Model['narratives']): Map<string, string> {
+  const map = new Map<string, string>();
+  for (const narrative of narratives) {
+    for (const sceneId of narrative.sceneIds) {
+      map.set(sceneId, narrative.name);
+    }
+  }
+  return map;
+}
+
+function getSceneDirName(scene: Scene, sceneToNarrative: Map<string, string>): string {
+  const narrativeName = scene.id ? sceneToNarrative.get(scene.id) : undefined;
+  return narrativeName ? `${toKebabCase(narrativeName)}_${toKebabCase(scene.name)}` : toKebabCase(scene.name);
+}
+
+export function emitMomentGenerationFailedForDuplicates(
   duplicateCommands: DuplicateCommandInfo[],
   spec: Model,
   command: GenerateServerCommand,
   events: GenerateServerEvents[],
 ): void {
   for (const dup of duplicateCommands) {
-    for (const flow of spec.narratives) {
-      for (const slice of flow.slices) {
+    for (const scene of spec.scenes) {
+      for (const slice of scene.moments) {
         if (slice.type !== 'command') continue;
         const gwtSpecs = slice.server?.specs;
         if (!Array.isArray(gwtSpecs)) continue;
@@ -400,14 +418,14 @@ export function emitSliceGenerationFailedForDuplicates(
             rule.examples?.some((ex) => ex.steps?.some((step) => step.keyword === 'When' && step.text === dup.command)),
           ),
         );
-        if (hasCommand && (flow.name !== dup.existingFlow || slice.name !== dup.existingSlice)) {
-          const event: SliceGenerationFailedEvent = {
-            type: 'SliceGenerationFailed',
+        if (hasCommand && (scene.name !== dup.existingScene || slice.name !== dup.existingMoment)) {
+          const event: MomentGenerationFailedEvent = {
+            type: 'MomentGenerationFailed',
             data: {
-              flowName: flow.name,
-              sliceName: slice.name,
-              sliceType: slice.type,
-              error: `Duplicate command handler: '${dup.command}' is already registered in ${dup.existingFlow}/${dup.existingSlice}`,
+              sceneName: scene.name,
+              momentName: slice.name,
+              momentType: slice.type,
+              error: `Duplicate command handler: '${dup.command}' is already registered in ${dup.existingScene}/${dup.existingMoment}`,
               model: spec,
             },
             timestamp: new Date(),
@@ -415,7 +433,7 @@ export function emitSliceGenerationFailedForDuplicates(
             correlationId: command.correlationId,
           };
           events.push(event);
-          debug('SliceGenerationFailed: %s.%s - duplicate command %s', flow.name, slice.name, dup.command);
+          debug('MomentGenerationFailed: %s.%s - duplicate command %s', scene.name, slice.name, dup.command);
         }
       }
     }
@@ -423,15 +441,15 @@ export function emitSliceGenerationFailedForDuplicates(
 }
 
 // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: nested iteration over model structure is inherent to the task
-export function emitSliceGenerationFailedForFieldIssues(
+export function emitMomentGenerationFailedForFieldIssues(
   fieldIssues: FieldIssue[],
   spec: Model,
   command: GenerateServerCommand,
   events: GenerateServerEvents[],
 ): void {
   for (const issue of fieldIssues) {
-    for (const flow of spec.narratives) {
-      for (const slice of flow.slices) {
+    for (const scene of spec.scenes) {
+      for (const slice of scene.moments) {
         if (slice.type === 'experience') continue;
 
         const gwtSpecs = slice.server?.specs;
@@ -454,11 +472,11 @@ export function emitSliceGenerationFailedForFieldIssues(
 
         if (usesMessageViaGwt || usesMessageViaData) {
           events.push({
-            type: 'SliceGenerationFailed',
+            type: 'MomentGenerationFailed',
             data: {
-              flowName: flow.name,
-              sliceName: slice.name,
-              sliceType: slice.type,
+              sceneName: scene.name,
+              momentName: slice.name,
+              momentType: slice.type,
               error: issue.error,
               model: spec,
             },
@@ -473,29 +491,31 @@ export function emitSliceGenerationFailedForFieldIssues(
 }
 
 // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: nested iteration over model structure is inherent to the task
-export function emitSliceGeneratedForAll(
+export function emitMomentGeneratedForAll(
   spec: Model,
   command: GenerateServerCommand,
   events: GenerateServerEvents[],
   duplicateCommands: DuplicateCommandInfo[] = [],
   fieldIssues: FieldIssue[] = [],
 ): void {
-  if (Array.isArray(spec.narratives) && spec.narratives.length > 0) {
-    for (const flow of spec.narratives) {
-      if (Array.isArray(flow.slices) && flow.slices.length > 0) {
-        for (const slice of flow.slices) {
+  const sceneToNarrative = buildSceneToNarrativeMap(spec.narratives);
+  if (Array.isArray(spec.scenes) && spec.scenes.length > 0) {
+    for (const scene of spec.scenes) {
+      const sceneDirName = getSceneDirName(scene, sceneToNarrative);
+      if (Array.isArray(scene.moments) && scene.moments.length > 0) {
+        for (const slice of scene.moments) {
           if (slice.type === 'experience') continue;
-          events.push(createSliceGeneratedEvent(flow, slice, command));
-          debug('SliceGenerated: %s.%s', flow.name, slice.name);
+          events.push(createMomentGeneratedEvent(scene, slice, command, sceneDirName));
+          debug('MomentGenerated: %s.%s', scene.name, slice.name);
         }
       }
     }
   }
-  emitSliceGenerationFailedForDuplicates(duplicateCommands, spec, command, events);
-  emitSliceGenerationFailedForFieldIssues(fieldIssues, spec, command, events);
+  emitMomentGenerationFailedForDuplicates(duplicateCommands, spec, command, events);
+  emitMomentGenerationFailedForFieldIssues(fieldIssues, spec, command, events);
 }
 
-export function emitSliceGeneratedForAffected(
+export function emitMomentGeneratedForAffected(
   spec: Model,
   affectedIds: Set<string>,
   command: GenerateServerCommand,
@@ -503,18 +523,20 @@ export function emitSliceGeneratedForAffected(
   duplicateCommands: DuplicateCommandInfo[] = [],
   fieldIssues: FieldIssue[] = [],
 ): void {
-  for (const flow of spec.narratives) {
-    for (const slice of flow.slices) {
+  const sceneToNarrative = buildSceneToNarrativeMap(spec.narratives);
+  for (const scene of spec.scenes) {
+    const sceneDirName = getSceneDirName(scene, sceneToNarrative);
+    for (const slice of scene.moments) {
       if (slice.type === 'experience') continue;
-      const sliceId = `${toKebabCase(flow.name)}/${toKebabCase(slice.name)}`;
+      const sliceId = `${sceneDirName}/${toKebabCase(slice.name)}`;
       if (affectedIds.has(sliceId)) {
-        events.push(createSliceGeneratedEvent(flow, slice, command));
-        debug('SliceGenerated (incremental): %s.%s', flow.name, slice.name);
+        events.push(createMomentGeneratedEvent(scene, slice, command, sceneDirName));
+        debug('MomentGenerated (incremental): %s.%s', scene.name, slice.name);
       }
     }
   }
-  emitSliceGenerationFailedForDuplicates(duplicateCommands, spec, command, events);
-  emitSliceGenerationFailedForFieldIssues(fieldIssues, spec, command, events);
+  emitMomentGenerationFailedForDuplicates(duplicateCommands, spec, command, events);
+  emitMomentGenerationFailedForFieldIssues(fieldIssues, spec, command, events);
 }
 
 export async function handleGenerateServerCommandInternal(
@@ -547,25 +569,25 @@ export async function handleGenerateServerCommandInternal(
       await cleanServerDir(serverDir);
       await copyAllFiles(serverDir);
       const { duplicateCommands, fieldIssues } = await generateAndWriteScaffold(spec, serverDir);
-      emitSliceGeneratedForAll(spec, command, events, duplicateCommands, fieldIssues);
+      emitMomentGeneratedForAll(spec, command, events, duplicateCommands, fieldIssues);
       await writeConfigurationFiles(serverDir);
     } else if (changeSet.allAffected.length === 0 && changeSet.removed.length === 0) {
       debug('No changes detected, skipping scaffold generation');
-      emitSliceGeneratedForAll(spec, command, events);
+      emitMomentGeneratedForAll(spec, command, events);
     } else {
       debug('Incremental generation mode');
 
       for (const sliceId of changeSet.removed) {
-        const [flowDir, sliceDir] = sliceId.split('/');
-        await fs.remove(join(serverDir, 'src/domain/flows', flowDir, sliceDir));
-        debug('Removed slice directory: %s/%s', flowDir, sliceDir);
+        const [sceneDir, momentDir] = sliceId.split('/');
+        await fs.remove(join(serverDir, 'src/domain/narratives', sceneDir, momentDir));
+        debug('Removed slice directory: %s/%s', sceneDir, momentDir);
       }
 
       await copyAllFiles(serverDir);
 
       const affectedIds = new Set(changeSet.allAffected);
       const { duplicateCommands, fieldIssues } = await generateAndWriteScaffold(spec, serverDir, affectedIds);
-      emitSliceGeneratedForAffected(spec, affectedIds, command, events, duplicateCommands, fieldIssues);
+      emitMomentGeneratedForAffected(spec, affectedIds, command, events, duplicateCommands, fieldIssues);
       await writeConfigurationFiles(serverDir);
     }
 

package/src/commands/initialize-server.specs.ts

@@ -41,7 +41,7 @@ describe('handleInitializeServerInternal', () => {
       'src/utils/loadResolvers.ts',
       'src/domain/shared/types.ts',
       'src/domain/shared/index.ts',
-      'src/domain/flows/health/query.resolver.ts',
+      'src/domain/narratives/health/query.resolver.ts',
     ];
 
     for (const file of expectedFiles) {
@@ -79,7 +79,7 @@ describe('handleInitializeServerInternal', () => {
     await handleInitializeServerInternal(command);
 
     const content = await readFile(
-      join(tempDir, 'server', 'src', 'domain', 'flows', 'health', 'query.resolver.ts'),
+      join(tempDir, 'server', 'src', 'domain', 'narratives', 'health', 'query.resolver.ts'),
       'utf8',
     );
     expect(content).toContain('HealthResolver');
@@ -111,14 +111,14 @@ describe('handleInitializeServerInternal', () => {
     const sentinel = 'CUSTOM_CONTENT_SHOULD_NOT_BE_OVERWRITTEN';
     await fs.writeFile(join(serverDir, 'src', 'server.ts'), sentinel);
     await fs.writeFile(join(serverDir, 'src', 'domain', 'shared', 'types.ts'), sentinel);
-    await fs.writeFile(join(serverDir, 'src', 'domain', 'flows', 'health', 'query.resolver.ts'), sentinel);
+    await fs.writeFile(join(serverDir, 'src', 'domain', 'narratives', 'health', 'query.resolver.ts'), sentinel);
     await fs.writeFile(join(serverDir, 'vitest.config.ts'), sentinel);
 
     await handleInitializeServerInternal(command);
 
     expect(await readFile(join(serverDir, 'src', 'server.ts'), 'utf8')).toBe(sentinel);
     expect(await readFile(join(serverDir, 'src', 'domain', 'shared', 'types.ts'), 'utf8')).toBe(sentinel);
-    expect(await readFile(join(serverDir, 'src', 'domain', 'flows', 'health', 'query.resolver.ts'), 'utf8')).toBe(
+    expect(await readFile(join(serverDir, 'src', 'domain', 'narratives', 'health', 'query.resolver.ts'), 'utf8')).toBe(
       sentinel,
     );
     expect(await readFile(join(serverDir, 'vitest.config.ts'), 'utf8')).toBe(sentinel);

package/src/commands/initialize-server.ts

@@ -242,7 +242,7 @@ async function start() {
     schema: { autoMigration: 'CreateOrUpdate' },
   });
 
-  const resolvers = await loadResolvers('src/domain/flows/**/*.resolver.{ts,js}');
+  const resolvers = await loadResolvers('src/domain/narratives/**/*.resolver.{ts,js}');
   type ResolverClass = new (...args: unknown[]) => unknown;
   const schema = await buildSchema({
     resolvers: resolvers as unknown as [ResolverClass, ...ResolverClass[]],
@@ -367,7 +367,10 @@ export async function handleInitializeServerInternal(
     await writeIfMissing(join(serverDir, 'src', 'utils', 'index.ts'), UTILS_INDEX_TS);
     await writeIfMissing(join(serverDir, 'src', 'domain', 'shared', 'types.ts'), TYPES_TS);
     await writeIfMissing(join(serverDir, 'src', 'domain', 'shared', 'index.ts'), SHARED_INDEX_TS);
-    await writeIfMissing(join(serverDir, 'src', 'domain', 'flows', 'health', 'query.resolver.ts'), HEALTH_RESOLVER_TS);
+    await writeIfMissing(
+      join(serverDir, 'src', 'domain', 'narratives', 'health', 'query.resolver.ts'),
+      HEALTH_RESOLVER_TS,
+    );
 
     return {
       type: 'ServerInitialized',

package/src/domain/flows/shared/types.ts

@@ -0,0 +1,15 @@
+import 'reflect-metadata';
+import type { CommandSender, EventStore, InMemoryDatabase } from '@event-driven-io/emmett';
+
+export interface ReactorContext {
+  eventStore: EventStore;
+  commandSender: CommandSender;
+  database: InMemoryDatabase;
+  [key: string]: unknown;
+}
+
+export interface GraphQLContext {
+  eventStore: EventStore;
+  messageBus: CommandSender;
+  database: InMemoryDatabase;
+}

package/src/domain/narratives/shared/types.ts

@@ -0,0 +1,15 @@
+import 'reflect-metadata';
+import type { CommandSender, EventStore, InMemoryDatabase } from '@event-driven-io/emmett';
+
+export interface ReactorContext {
+  eventStore: EventStore;
+  commandSender: CommandSender;
+  database: InMemoryDatabase;
+  [key: string]: unknown;
+}
+
+export interface GraphQLContext {
+  eventStore: EventStore;
+  messageBus: CommandSender;
+  database: InMemoryDatabase;
+}

package/src/index.ts

@@ -5,9 +5,9 @@ export const COMMANDS = [generateServerHandler, initializeServerHandler];
 export type {
   GenerateServerCommand,
   GenerateServerEvents,
+  MomentGeneratedEvent,
   ServerGeneratedEvent,
   ServerGenerationFailedEvent,
-  SliceGeneratedEvent,
 } from './commands/generate-server';
 export type {
   InitializeServerCommand,

package/src/server.ts

@@ -7,8 +7,8 @@ import { buildSchema } from 'type-graphql';
 import { loadProjections, loadRegisterFiles, loadResolvers } from './utils';
 
 async function start() {
-  const loadedProjections = await loadProjections('src/domain/flows/**/projection.{ts,js}');
-  const registrations = await loadRegisterFiles('src/domain/flows/**/register.{ts,js}');
+  const loadedProjections = await loadProjections('src/domain/narratives/**/projection.{ts,js}');
+  const registrations = await loadRegisterFiles('src/domain/narratives/**/register.{ts,js}');
 
   const messageBus = getInMemoryMessageBus();
   const database = getInMemoryDatabase();
@@ -63,7 +63,7 @@ async function start() {
   };
   process.on('SIGINT', () => void shutdown());
   process.on('SIGTERM', () => void shutdown());
-  const resolvers = await loadResolvers('src/domain/flows/**/*.resolver.{ts,js}');
+  const resolvers = await loadResolvers('src/domain/narratives/**/*.resolver.{ts,js}');
   type ResolverClass = new (...args: unknown[]) => unknown;
   const schema = await buildSchema({
     resolvers: resolvers as unknown as [ResolverClass, ...ResolverClass[]],

package/src/utils/loadRegisterFiles.ts

@@ -2,11 +2,11 @@ import path from 'node:path';
 import type { CommandProcessor, EventStore } from '@event-driven-io/emmett';
 import fg from 'fast-glob';
 
-export interface SliceRegistration {
+export interface MomentRegistration {
   register: (messageBus: CommandProcessor, eventStore: EventStore) => Promise<unknown> | undefined;
 }
 
-export async function loadRegisterFiles(source: string): Promise<SliceRegistration[]> {
+export async function loadRegisterFiles(source: string): Promise<MomentRegistration[]> {
   const files = await fg(source, { absolute: true });
 
   const modules = await Promise.all(
@@ -18,9 +18,9 @@ export async function loadRegisterFiles(source: string): Promise<SliceRegistrati
           typeof mod === 'object' &&
           mod !== null &&
           'register' in mod &&
-          typeof (mod as SliceRegistration).register === 'function'
+          typeof (mod as MomentRegistration).register === 'function'
         ) {
-          return mod as SliceRegistration;
+          return mod as MomentRegistration;
         }
 
         console.warn('⚠️ Skipping invalid register.ts at', file);
@@ -32,7 +32,7 @@ export async function loadRegisterFiles(source: string): Promise<SliceRegistrati
     }),
   );
 
-  return modules.filter((m): m is SliceRegistration => m !== null);
+  return modules.filter((m): m is MomentRegistration => m !== null);
 }
 
 function pathToFileUrl(filePath: string): URL {

package/src/utils/loadResolvers.ts

@@ -28,7 +28,7 @@ export async function loadResolvers(source: string): Promise<Resolver[]> {
   }
 
   if (allResolvers.length === 0) {
-    throw new Error('❌ No resolvers found for any slices.');
+    throw new Error('❌ No resolvers found for any moments.');
   }
   return allResolvers;
 }