@auto-engineer/server-generator-apollo-emmett 1.104.0 → 1.105.0

package/ketchup-plan.md

@@ -6,6 +6,8 @@
 
 ## DONE
 
+- [x] Burst 24: Fix handle.ts multi-command stream pattern
+- [x] Burst 23: Fix decide default case + add discriminated union narrowing guidance (a24a654f)
 - [x] Burst 22: Add null-document guidance to projection template (0d1d2007)
 - [x] Burst 21: Add discriminated union guidance to evolve template (7abc038c)
 - [x] Burst 20: Fill missing inline object fields with type defaults (b39bfd1b)

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.104.0",
-    "@auto-engineer/message-bus": "1.104.0"
+    "@auto-engineer/narrative": "1.105.0",
+    "@auto-engineer/message-bus": "1.105.0"
   },
   "publishConfig": {
     "access": "public"
@@ -44,9 +44,9 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "tsx": "^4.19.2",
-    "@auto-engineer/cli": "1.104.0"
+    "@auto-engineer/cli": "1.105.0"
   },
-  "version": "1.104.0",
+  "version": "1.105.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/formatTsValue.specs.ts

@@ -22,6 +22,18 @@ describe('formatTsValue', () => {
     it('returns null for null value', () => {
       expect(formatTsValue(null, 'string')).toBe('null');
     });
+
+    it('returns 0 for non-numeric string with number type', () => {
+      expect(formatTsValue('null', 'number')).toBe('0');
+    });
+
+    it('returns 0 for empty string with number type', () => {
+      expect(formatTsValue('', 'number')).toBe('0');
+    });
+
+    it('returns 0 for boolean with number type', () => {
+      expect(formatTsValue(true, 'number')).toBe('0');
+    });
   });
 
   describe('simple arrays', () => {

package/src/codegen/formatTsValueSimple.specs.ts

@@ -27,7 +27,7 @@ describe('formatTsValueSimple', () => {
   });
 
   it('should return number string for string value when tsType is number', () => {
-    expect(formatTsValueSimple('5.00', 'number')).toBe('5.00');
+    expect(formatTsValueSimple('5.00', 'number')).toBe('5');
   });
 
   it('should return number string for number value when tsType is number', () => {

package/src/codegen/scaffoldErrors.specs.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest';
+import { ScaffoldError, TemplateRenderError } from './scaffoldFromSchema';
+
+describe('TemplateRenderError', () => {
+  it('captures template file and chains cause', () => {
+    const original = new TypeError('Cannot read properties of undefined');
+    const error = new TemplateRenderError('decide.ts.ejs', original);
+
+    expect(error).toEqual(
+      expect.objectContaining({
+        name: 'TemplateRenderError',
+        message: 'Template render failed: decide.ts.ejs',
+        templateFile: 'decide.ts.ejs',
+        cause: original,
+      }),
+    );
+    expect(error).toBeInstanceOf(Error);
+    expect(error).toBeInstanceOf(TemplateRenderError);
+  });
+});
+
+describe('ScaffoldError', () => {
+  it('captures flow/slice/type and chains cause', () => {
+    const templateError = new TemplateRenderError('evolve.ts.ejs', new Error('bad data'));
+    const error = new ScaffoldError('Checkout', 'PlaceOrder', 'command', templateError);
+
+    expect(error).toEqual(
+      expect.objectContaining({
+        name: 'ScaffoldError',
+        message: 'Scaffold failed for Checkout/PlaceOrder (command)',
+        flowName: 'Checkout',
+        sliceName: 'PlaceOrder',
+        sliceType: 'command',
+        cause: templateError,
+      }),
+    );
+    expect(error).toBeInstanceOf(Error);
+    expect(error).toBeInstanceOf(ScaffoldError);
+  });
+});

package/src/codegen/scaffoldFromSchema.ts

@@ -47,6 +47,30 @@ import { normalizeSliceForTemplate } from './extract/slice-normalizer';
 import { extractGwtSpecsFromSlice, type GwtResult } from './extract/step-converter';
 import type { GwtCondition, Message, MessageDefinition } from './types';
 
+export class TemplateRenderError extends Error {
+  readonly templateFile: string;
+
+  constructor(templateFile: string, cause: unknown) {
+    super(`Template render failed: ${templateFile}`, { cause });
+    this.name = 'TemplateRenderError';
+    this.templateFile = templateFile;
+  }
+}
+
+export class ScaffoldError extends Error {
+  readonly flowName: string;
+  readonly sliceName: string;
+  readonly sliceType: string;
+
+  constructor(flowName: string, sliceName: string, sliceType: string, cause: unknown) {
+    super(`Scaffold failed for ${flowName}/${sliceName} (${sliceType})`, { cause });
+    this.name = 'ScaffoldError';
+    this.flowName = flowName;
+    this.sliceName = sliceName;
+    this.sliceType = sliceType;
+  }
+}
+
 const defaultFilesByType: Record<string, string[]> = {
   command: [
     'commands.ts.ejs',
@@ -419,7 +443,14 @@ export function formatTsValueSimple(value: unknown, tsType: string): string {
     return JSON.stringify(typeof value === 'string' ? value : String(value));
   }
   if (tsType === 'number') {
-    return String(value);
+    if (typeof value === 'number') return String(value);
+    if (typeof value === 'string') {
+      const s = value.trim();
+      if (s === '') return '0';
+      const num = Number(s);
+      return Number.isNaN(num) ? '0' : String(num);
+    }
+    return '0';
   }
   if (tsType === 'boolean') {
     return value === true || value === 'true' ? 'true' : 'false';
@@ -520,23 +551,27 @@ async function generateFileForTemplate(
   debugFiles('  Template path: %s', templatePath);
   debugFiles('  Output path: %s', outputPath);
 
-  const contents = await renderTemplate(templatePath, templateData, unionToEnumName);
-  debugFiles('  Rendered content size: %d bytes', contents.length);
-
-  debugFiles('  Formatting with Prettier...');
-  const formattedContents = await prettier.format(contents, {
-    parser: 'typescript',
-    filepath: outputPath,
-    singleQuote: true,
-    trailingComma: 'all',
-    printWidth: 120,
-    tabWidth: 2,
-  });
-  debugFiles('  Formatted content size: %d bytes', formattedContents.length);
-
-  const plan = { outputPath, contents: formattedContents };
-  debugFiles('  File plan created for: %s', fileName);
-  return plan;
+  try {
+    const contents = await renderTemplate(templatePath, templateData, unionToEnumName);
+    debugFiles('  Rendered content size: %d bytes', contents.length);
+
+    debugFiles('  Formatting with Prettier...');
+    const formattedContents = await prettier.format(contents, {
+      parser: 'typescript',
+      filepath: outputPath,
+      singleQuote: true,
+      trailingComma: 'all',
+      printWidth: 120,
+      tabWidth: 2,
+    });
+    debugFiles('  Formatted content size: %d bytes', formattedContents.length);
+
+    const plan = { outputPath, contents: formattedContents };
+    debugFiles('  File plan created for: %s', fileName);
+    return plan;
+  } catch (error) {
+    throw new TemplateRenderError(templateFile, error);
+  }
 }
 
 export function resolveReferencedMessageTypes(
@@ -918,19 +953,23 @@ export async function generateScaffoldFilePlans(
       debugFlow('  Processing slice: %s (type: %s)', slice.name, slice.type);
       const sliceDir = ensureDirPath(flowDir, toKebabCase(slice.name));
       debugFlow('    Slice directory: %s', sliceDir);
-      const { plans, duplicateCommands } = await generateFilesForSlice(
-        slice,
-        flow,
-        sliceDir,
-        sanitizedMessages,
-        flows,
-        unionToEnumName,
-        integrations,
-        registeredCommands,
-      );
-      debugFlow('    Generated %d plans for slice', plans.length);
-      allPlans.push(...plans);
-      allDuplicateCommands.push(...duplicateCommands);
+      try {
+        const { plans, duplicateCommands } = await generateFilesForSlice(
+          slice,
+          flow,
+          sliceDir,
+          sanitizedMessages,
+          flows,
+          unionToEnumName,
+          integrations,
+          registeredCommands,
+        );
+        debugFlow('    Generated %d plans for slice', plans.length);
+        allPlans.push(...plans);
+        allDuplicateCommands.push(...duplicateCommands);
+      } catch (error) {
+        throw new ScaffoldError(flow.name, slice.name, slice.type, error);
+      }
     }
     debugFlow('  Completed flow: %s', flow.name);
   }

package/src/codegen/templates/command/decide.specs.ts

@@ -97,6 +97,9 @@ describe('decide.ts.ejs', () => {
       * You should:
       * - Validate the command input fields
       * - Inspect the current domain \`_state\` to determine if the command is allowed
+      * - If State is a discriminated union, NEVER use \`as any\` to bypass type checking.
+      *   Narrow with the discriminant: \`if (_state.status !== 'active') throw new IllegalStateError('...');\`
+      *   After narrowing, access variant fields directly — TypeScript infers the correct type.
       * - If invalid, throw one of the following domain errors: \`IllegalStateError\`
       *   ⚠️ Error constructors: IllegalStateError takes a string message
       * - If valid, return one or more events with the correct structure
@@ -117,7 +120,7 @@ describe('decide.ts.ejs', () => {
             throw new IllegalStateError('Not yet implemented: ' + command.type);
           }
           default:
-            throw new IllegalStateError(\`Unexpected command type: \${String(command.type)}\`);
+            throw new IllegalStateError('Unexpected command type');
         }
       };
       "
@@ -232,6 +235,9 @@ describe('decide.ts.ejs', () => {
       * You should:
       * - Validate the command input fields
       * - Inspect the current domain \`_state\` to determine if the command is allowed
+      * - If State is a discriminated union, NEVER use \`as any\` to bypass type checking.
+      *   Narrow with the discriminant: \`if (_state.status !== 'active') throw new IllegalStateError('...');\`
+      *   After narrowing, access variant fields directly — TypeScript infers the correct type.
       * - If invalid, throw one of the following domain errors: \`IllegalStateError\`
       *   ⚠️ Error constructors: IllegalStateError takes a string message
       * - If valid, return one or more events with the correct structure
@@ -258,7 +264,7 @@ describe('decide.ts.ejs', () => {
             throw new IllegalStateError('Not yet implemented: ' + command.type);
           }
           default:
-            throw new IllegalStateError(\`Unexpected command type: \${String(command.type)}\`);
+            throw new IllegalStateError('Unexpected command type');
         }
       };
       "
@@ -393,6 +399,9 @@ describe('decide.ts.ejs', () => {
       * You should:
       * - Validate the command input fields
       * - Inspect the current domain \`_state\` to determine if the command is allowed
+      * - If State is a discriminated union, NEVER use \`as any\` to bypass type checking.
+      *   Narrow with the discriminant: \`if (_state.status !== 'active') throw new IllegalStateError('...');\`
+      *   After narrowing, access variant fields directly — TypeScript infers the correct type.
       * - If invalid, throw one of the following domain errors: \`IllegalStateError\`, \`ValidationError\`
       *   ⚠️ Error constructors: IllegalStateError takes a string message, ValidationError takes a string message
       * - If valid, return one or more events with the correct structure
@@ -417,7 +426,7 @@ describe('decide.ts.ejs', () => {
             throw new IllegalStateError('Not yet implemented: ' + command.type);
           }
           default:
-            throw new IllegalStateError(\`Unexpected command type: \${String(command.type)}\`);
+            throw new IllegalStateError('Unexpected command type');
         }
       };
       "
@@ -592,6 +601,9 @@ describe('decide.ts.ejs', () => {
       * You should:
       * - Validate the command input fields
       * - Inspect the current domain \`_state\` to determine if the command is allowed
+      * - If State is a discriminated union, NEVER use \`as any\` to bypass type checking.
+      *   Narrow with the discriminant: \`if (_state.status !== 'active') throw new IllegalStateError('...');\`
+      *   After narrowing, access variant fields directly — TypeScript infers the correct type.
           * - Use \`products\` (integration result) to enrich or filter the output
       * - If invalid, throw one of the following domain errors: \`IllegalStateError\`
       *   ⚠️ Error constructors: IllegalStateError takes a string message
@@ -627,7 +639,7 @@ describe('decide.ts.ejs', () => {
             throw new IllegalStateError('Not yet implemented: ' + command.type);
           }
           default:
-            throw new IllegalStateError(\`Unexpected command type: \${String(command.type)}\`);
+            throw new IllegalStateError('Unexpected command type');
         }
       };
       "

package/src/codegen/templates/command/decide.ts.ejs

@@ -61,6 +61,9 @@ case '<%= command %>': {
 * You should:
 * - Validate the command input fields
 * - Inspect the current domain `_state` to determine if the command is allowed
+* - If State is a discriminated union, NEVER use `as any` to bypass type checking.
+*   Narrow with the discriminant: `if (_state.status !== 'active') throw new IllegalStateError('...');`
+*   After narrowing, access variant fields directly — TypeScript infers the correct type.
 <% if (integrationReturnType) { -%>
     * - Use `<%= camelCase(integrationReturnType) %>` (integration result) to enrich or filter the output
 <% } -%>
@@ -132,6 +135,6 @@ throw new IllegalStateError('Not yet implemented: ' + command.type);
 }
 <% } -%>
 default:
-throw new IllegalStateError(`Unexpected command type: ${String(command.type)}`);
+throw new IllegalStateError('Unexpected command type');
 }
 };

package/src/codegen/templates/command/evolve.specs.ts

@@ -87,27 +87,28 @@ describe('evolve.ts.ejs', () => {
       /**
        * ## IMPLEMENTATION INSTRUCTIONS ##
        *
-       * This function defines how the domain state evolves in response to events.
+       * Evolve domain state in response to events.
+       * Only track fields needed for future decisions in decide.ts.
        *
-       * Guidelines:
-       * - Apply only the **minimal** necessary changes for future decisions in \`decide.ts\`.
-       * - Ignore any event fields not required for decision-making logic.
-       * - If the event doesn’t change decision-relevant state, return the existing \`state\`.
-       * - Prefer immutability: always return a **new state object**.
-       * - Avoid spreading all of \`event.data\` unless all fields are relevant.
-       * - If State is a discriminated union (e.g., NotInitialized | Initialized),
-       *   always include the discriminant field (e.g., \`status\`) in return values.
-       *   Do NOT spread \`...state\` and add variant-specific fields — construct a complete object:
-       *   \`return { status: 'initialized', field: event.data.field };\`
+       * RULES:
+       * - Return a new object literal for state transitions.
+       *   For no-op (event doesn’t affect state), return the existing \`state\`.
+       * - If State is a discriminated union (check state.ts), EVERY return
+       *   MUST include the discriminant field as a string literal.
+       *   Example: \`return { status: ‘active’, field: event.data.field };\`
+       * - NEVER spread ...event.data or ...state — list each field explicitly.
+       *
+       * VERIFY before finalizing:
+       *   [ ] Every return (except \`return state;\`) matches a variant from state.ts
+       *   [ ] Every return includes the discriminant field
+       *   [ ] No spread operators in return statements
        */
 
       export const evolve = (state: State, event: ListingCreated): State => {
         switch (event.type) {
           case 'ListingCreated': {
-            // TODO: Update state based on ListingCreated
-            return {
-              ...state,
-            };
+            // TODO: Return { status: 'variant', field1: ..., field2: ... } matching state.ts.
+            return state;
           }
           default:
             return state;

package/src/codegen/templates/command/evolve.ts.ejs

@@ -7,18 +7,21 @@
     /**
     * ## IMPLEMENTATION INSTRUCTIONS ##
     *
-    * This function defines how the domain state evolves in response to events.
+    * Evolve domain state in response to events.
+    * Only track fields needed for future decisions in decide.ts.
     *
-    * Guidelines:
-    * - Apply only the **minimal** necessary changes for future decisions in `decide.ts`.
-    * - Ignore any event fields not required for decision-making logic.
-    * - If the event doesn’t change decision-relevant state, return the existing `state`.
-    * - Prefer immutability: always return a **new state object**.
-    * - Avoid spreading all of `event.data` unless all fields are relevant.
-    * - If State is a discriminated union (e.g., NotInitialized | Initialized),
-    *   always include the discriminant field (e.g., `status`) in return values.
-    *   Do NOT spread `...state` and add variant-specific fields — construct a complete object:
-    *   `return { status: 'initialized', field: event.data.field };`
+    * RULES:
+    * - Return a new object literal for state transitions.
+    *   For no-op (event doesn’t affect state), return the existing `state`.
+    * - If State is a discriminated union (check state.ts), EVERY return
+    *   MUST include the discriminant field as a string literal.
+    *   Example: `return { status: ‘active’, field: event.data.field };`
+    * - NEVER spread ...event.data or ...state — list each field explicitly.
+    *
+    * VERIFY before finalizing:
+    *   [ ] Every return (except `return state;`) matches a variant from state.ts
+    *   [ ] Every return includes the discriminant field
+    *   [ ] No spread operators in return statements
     */
 
     export const evolve = (
@@ -28,10 +31,8 @@
     switch (event.type) {
     <% events.forEach(event => { -%>
         case '<%= event.type %>': {
-        // TODO: Update state based on <%= event.type %>
-        return {
-        ...state
-        };
+        // TODO: Return { status: 'variant', field1: ..., field2: ... } matching state.ts.
+        return state;
         }
     <% }); -%>
     default:

package/src/codegen/templates/command/handle.specs.ts

@@ -331,4 +331,150 @@ describe('generateScaffoldFilePlans', () => {
       "
     `);
   });
+  it('should generate stream guard when not all commands share stream pattern fields', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'Member tracks workouts',
+          slices: [
+            {
+              type: 'command',
+              name: 'Track workouts',
+              stream: 'workouts-${memberId}',
+              client: {
+                specs: [],
+              },
+              server: {
+                description: 'test',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Track workouts',
+                    rules: [
+                      {
+                        name: 'Should log workout',
+                        examples: [
+                          {
+                            name: 'Member logs a workout',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'LogWorkout',
+                                docString: { memberId: 'm1', exercise: 'squat' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'WorkoutLogged',
+                                docString: { memberId: 'm1', exercise: 'squat' },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                      {
+                        name: 'Should calculate points',
+                        examples: [
+                          {
+                            name: 'Points are calculated',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'CalculatePoints',
+                                docString: { season: 'winter' },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'PointsCalculated',
+                                docString: { season: 'winter', points: 10 },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+                data: {
+                  items: [
+                    {
+                      target: { type: 'Event', name: 'WorkoutLogged' },
+                      destination: {
+                        type: 'stream',
+                        pattern: 'workouts-${memberId}',
+                      },
+                    },
+                  ],
+                },
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'LogWorkout',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'exercise', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'command',
+          name: 'CalculatePoints',
+          fields: [{ name: 'season', type: 'string', required: true }],
+        },
+        {
+          type: 'event',
+          name: 'WorkoutLogged',
+          source: 'internal',
+          fields: [
+            { name: 'memberId', type: 'string', required: true },
+            { name: 'exercise', type: 'string', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'PointsCalculated',
+          source: 'internal',
+          fields: [
+            { name: 'season', type: 'string', required: true },
+            { name: 'points', type: 'number', required: true },
+          ],
+        },
+      ],
+    };
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const handleFile = plans.find((p) => p.outputPath.endsWith('handle.ts'));
+
+    expect(handleFile?.contents).toMatchInlineSnapshot(`
+      "import { CommandHandler, type EventStore, type MessageHandlerResult } from '@event-driven-io/emmett';
+      import { evolve } from './evolve';
+      import { initialState } from './state';
+      import { decide } from './decide';
+      import type { LogWorkout, CalculatePoints } from './commands';
+
+      const handler = CommandHandler({
+        evolve,
+        initialState,
+      });
+
+      export const handle = async (
+        eventStore: EventStore,
+        command: LogWorkout | CalculatePoints,
+      ): Promise<MessageHandlerResult> => {
+        const commandData = command.data;
+        if (!('memberId' in commandData)) {
+          throw new Error('Cannot determine stream: "memberId" not in command data');
+        }
+        const streamId = \`workouts-\${commandData.memberId}\`;
+
+        await handler(eventStore, streamId, (state) => decide(command, state));
+        return undefined;
+      };
+      "
+    `);
+  });
 });

package/src/codegen/templates/command/handle.ts.ejs

@@ -53,6 +53,16 @@ const integrationCalls = integrationData.map((d, i) => {
 
 const resultVarName = integrationCalls.find(call => !!call.varName)?.varName;
 const needsReturnValue = typeof resultVarName === 'string';
+
+const streamVars = [];
+const streamPatternStr = stream?.pattern ?? '';
+const svRegex = /\$\{([^}]+)\}/g;
+let svMatch;
+while ((svMatch = svRegex.exec(streamPatternStr)) !== null) {
+    streamVars.push(svMatch[1]);
+}
+const allCmdFieldSets = commands.map(c => new Set((c.fields ?? []).map(f => f.name)));
+const needsStreamGuard = streamVars.length > 0 && !allCmdFieldSets.every(fs => streamVars.every(v => fs.has(v)));
 %>
 
 <% integrationSideEffectImports.forEach((importSource) => { %>
@@ -86,7 +96,17 @@ eventStore: EventStore,
 command: <%= commands.map(c => pascalCase(c.type)).join(' | ') %>
 ): Promise<MessageHandlerResult> => {
     <% if (stream?.pattern?.includes('${')) { -%>
-        const streamId = `<%= stream.pattern.replace(/\$\{([^}]+)\}/g, (_, key) => `\${command.data.${key}}`) %>`;
+        <% if (needsStreamGuard) { -%>
+            const commandData = command.data;
+            <% for (const v of streamVars) { -%>
+                if (!('<%= v %>' in commandData)) {
+                    throw new Error('Cannot determine stream: "<%= v %>" not in command data');
+                }
+            <% } -%>
+            const streamId = `<%= stream.pattern.replace(/\$\{([^}]+)\}/g, (_, key) => `\${commandData.${key}}`) %>`;
+        <% } else { -%>
+            const streamId = `<%= stream.pattern.replace(/\$\{([^}]+)\}/g, (_, key) => `\${command.data.${key}}`) %>`;
+        <% } -%>
     <% } else { -%>
         const streamId = '<%= stream?.pattern ?? 'unknown-stream' %>';
     <% } -%>

package/src/codegen/templates/query/projection.specs.ts

@@ -562,8 +562,11 @@ describe('projection.ts.ejs', () => {
       // SINGLETON AGGREGATION PATTERN
       // This projection maintains a single document that aggregates data from multiple entities.
       // Use internal state to track individual entity information for accurate calculations.
+
+      type EntityData = TodoAdded['data'];
+
       interface InternalTodoSummary extends TodoSummary {
-        _entities?: Record<string, { status?: string; [key: string]: unknown }>;
+        _entities?: Record<string, EntityData>;
       }
 
       type AllEvents = TodoAdded;

package/src/codegen/templates/query/projection.ts.ejs

@@ -45,8 +45,14 @@ import { <%= stateEnums.join(', ') %> } from '../../../shared';
 // SINGLETON AGGREGATION PATTERN
 // This projection maintains a single document that aggregates data from multiple entities.
 // Use internal state to track individual entity information for accurate calculations.
+<% if (events.length === 1) { %>
+type EntityData = <%= pascalCase(events[0].type) %>['data'];
+<% } else { %>
+type EntityData = Partial<<%= events.map(e => pascalCase(e.type) + "['data']").join(' & ') %>>;
+<% } %>
+
 interface Internal<%= pascalCase(targetName || 'State') %> extends <%= pascalCase(targetName || 'State') %> {
-  _entities?: Record<string, { status?: string; [key: string]: unknown }>;
+  _entities?: Record<string, EntityData>;
 }
 <% } %>
 type AllEvents = <%= allEventTypes %>;