@auto-engineer/server-generator-apollo-emmett 1.110.4 → 1.110.5

package/dist/src/codegen/templates/query/query.resolver.specs.ts

@@ -114,9 +114,9 @@ describe('query.resolver.ts.ejs', () => {
           return model.find((item) => {
             if (location !== undefined && item.location !== location) return false;
 
-            // TODO: 'maxPrice' has no matching field on the state type — implement custom filter logic.
+            // NOTE: 'maxPrice' has no matching field on the state type — add custom filter logic if needed.
 
-            // TODO: 'minGuests' has no matching field on the state type — implement custom filter logic.
+            // NOTE: 'minGuests' has no matching field on the state type — add custom filter logic if needed.
 
             return true;
           });
@@ -935,7 +935,7 @@ describe('query.resolver.ts.ejs', () => {
           // If this query should return a single item, switch to findOne().
 
           return model.find((item) => {
-            // TODO: 'pantryId' has no matching field on the state type — implement custom filter logic.
+            // NOTE: 'pantryId' has no matching field on the state type — add custom filter logic if needed.
 
             return true;
           });
@@ -1177,7 +1177,7 @@ describe('query.resolver.ts.ejs', () => {
           // If this query should return a single item, switch to findOne().
 
           return model.find((item) => {
-            // TODO: 'pantryId' has no matching field on the state type — implement custom filter logic.
+            // NOTE: 'pantryId' has no matching field on the state type — add custom filter logic if needed.
 
             return true;
           });

package/dist/src/codegen/templates/query/query.resolver.ts.ejs

@@ -170,7 +170,7 @@ return model.find((<%= hasArgs ? 'item' : '_item' %>) => {
             if (stateFieldNames.has(arg.name)) { %>
     if (<%= arg.name %> !== undefined && item.<%= arg.name %> !== <%= arg.name %>) return false;
 <%          } else { %>
-    // TODO: '<%= arg.name %>' has no matching field on the state type — implement custom filter logic.
+    // NOTE: '<%= arg.name %>' has no matching field on the state type — add custom filter logic if needed.
 <%          }
         }
 } %>

package/dist/src/codegen/templates/react/react.specs.ts

@@ -256,6 +256,13 @@ describe('handle.ts.ejs (react slice)', () => {
              *   NEVER hardcode values copied from test assertions.
              *
              * Preserve all import paths above — they are generated from the model.
+             *
+             * CONSTRAINTS:
+             * - NEVER use \`as SomeType\` type assertions. Use typed variable declarations.
+             * - Only reference event.data fields listed in the "Event fields:" comment below. Check the type before accessing any field.
+             * - Do NOT modify the inMemoryReactor configuration, connectionOptions, import statements, or commandSender.send() call structure. Only fill in data fields marked TODO.
+             * - When event.data contains nested arrays/objects (e.g., exercises[].sets[]), iterate them to compute values. Do NOT cast arrays/objects to primitive types.
+             *
              * Add business logic (validation, conditional sends) as needed.
              */
 

package/dist/src/codegen/templates/react/react.ts.ejs

@@ -60,6 +60,13 @@ const willHaveAggregateStream = states.some(state =>
 <% if (willHaveAggregateStream) { -%>
     * Do NOT modify or remove aggregateStream calls — they load required state.
 <% } -%>
+    *
+    * CONSTRAINTS:
+    * - NEVER use `as SomeType` type assertions. Use typed variable declarations.
+    * - Only reference event.data fields listed in the "Event fields:" comment below. Check the type before accessing any field.
+    * - Do NOT modify the inMemoryReactor configuration, connectionOptions, import statements, or commandSender.send() call structure. Only fill in data fields marked TODO.
+    * - When event.data contains nested arrays/objects (e.g., exercises[].sets[]), iterate them to compute values. Do NOT cast arrays/objects to primitive types.
+    *
     * Add business logic (validation, conditional sends) as needed.
     */
 <%

package/dist/src/codegen/templates/react/register.specs.ts

@@ -246,6 +246,12 @@ describe('register.ts.ejs (react slice)', () => {
            *   evolve: (s: Record<string, unknown>, e: { type: string; data: Record<string, unknown> }) => ...
            * - NEVER hardcode values copied from test assertions.
            * - Preserve all import paths above — they are generated from the model.
+           *
+           * CONSTRAINTS:
+           * - NEVER use \`as SomeType\` type assertions. Use typed variable declarations.
+           * - Only reference fields that exist on the event type (BookingRequested). Check the import above.
+           * - Do NOT modify the messageBus.subscribe() call, function signature, or import statements.
+           * - When event.data contains nested arrays/objects, iterate them. Do NOT cast to primitive types.
            */
 
           // await messageBus.send({

package/dist/src/codegen/templates/react/register.ts.ejs

@@ -38,6 +38,12 @@ async (event: <%= pascalCase(eventType) %>) => {
 *   evolve: (s: Record<string, unknown>, e: { type: string; data: Record<string, unknown> }) => ...
 * - NEVER hardcode values copied from test assertions.
 * - Preserve all import paths above — they are generated from the model.
+*
+* CONSTRAINTS:
+* - NEVER use `as SomeType` type assertions. Use typed variable declarations.
+* - Only reference fields that exist on the event type (<%= pascalCase(eventType) %>). Check the import above.
+* - Do NOT modify the messageBus.subscribe() call, function signature, or import statements.
+* - When event.data contains nested arrays/objects, iterate them. Do NOT cast to primitive types.
 */
 
 // await messageBus.send({

package/ketchup-plan.md

@@ -4,6 +4,11 @@
 
 (none)
 
+## DONE (Round 3)
+
+- [x] Burst 26: Add fart-model test for query-arg-differs-from-projection case
+- [x] Burst 25: Exclude query arg fields from projection spec expected state (6da49a58)
+
 ## DONE
 
 - [x] Burst 24: Fix handle.ts multi-command stream pattern

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.110.4",
-    "@auto-engineer/message-bus": "1.110.4"
+    "@auto-engineer/narrative": "1.110.5",
+    "@auto-engineer/message-bus": "1.110.5"
   },
   "publishConfig": {
     "access": "public"
@@ -44,9 +44,9 @@
     "typescript": "^5.8.3",
     "vitest": "^3.2.4",
     "tsx": "^4.19.2",
-    "@auto-engineer/cli": "1.110.4"
+    "@auto-engineer/cli": "1.110.5"
   },
-  "version": "1.110.4",
+  "version": "1.110.5",
   "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/templates/command/decide.specs.ts

@@ -97,13 +97,14 @@ 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('...');\`
+      * - NEVER use \`as SomeType\` type assertions — not \`as any\`, not \`as EventType\`, no casts at all. Use typed variable declarations.
+      * - If State is a discriminated union, 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
       *
+      * - Only destructure/reference command.data fields that exist in the command type (imported from ./commands). Do NOT access fields not declared in the type, even if example data includes them.
       * ⚠️ Only read from inputs — never mutate them. \`evolve.ts\` handles state updates.
 
       * Business rules:
@@ -235,13 +236,14 @@ 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('...');\`
+      * - NEVER use \`as SomeType\` type assertions — not \`as any\`, not \`as EventType\`, no casts at all. Use typed variable declarations.
+      * - If State is a discriminated union, 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
       *
+      * - Only destructure/reference command.data fields that exist in the command type (imported from ./commands). Do NOT access fields not declared in the type, even if example data includes them.
       * ⚠️ Only read from inputs — never mutate them. \`evolve.ts\` handles state updates.
 
       * Business rules:
@@ -399,13 +401,14 @@ 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('...');\`
+      * - NEVER use \`as SomeType\` type assertions — not \`as any\`, not \`as EventType\`, no casts at all. Use typed variable declarations.
+      * - If State is a discriminated union, 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
       *
+      * - Only destructure/reference command.data fields that exist in the command type (imported from ./commands). Do NOT access fields not declared in the type, even if example data includes them.
       * ⚠️ Only read from inputs — never mutate them. \`evolve.ts\` handles state updates.
 
       * Business rules:
@@ -601,14 +604,15 @@ 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('...');\`
+      * - NEVER use \`as SomeType\` type assertions — not \`as any\`, not \`as EventType\`, no casts at all. Use typed variable declarations.
+      * - If State is a discriminated union, 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
       * - If valid, return one or more events with the correct structure
       *
+      * - Only destructure/reference command.data fields that exist in the command type (imported from ./commands). Do NOT access fields not declared in the type, even if example data includes them.
       * ⚠️ Only read from inputs — never mutate them. \`evolve.ts\` handles state updates.
           *
           * Integration result shape (Products):

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

@@ -145,8 +145,13 @@ describe('<%= ruleDescription %>', () => {
     ])
       .when({
         type: '<%= example.commandRef %>',
-        data: <%- formatDataObject(example.exampleData, schema) %>,
 <%  const commandFieldNames = new Set(schema?.fields?.map(f => f.name) || []);
+    const filteredCmdData = Object.fromEntries(
+      Object.entries(example.exampleData || {}).filter(([key]) => commandFieldNames.has(key))
+    );
+-%>
+        data: <%- formatDataObject(filteredCmdData, schema) %>,
+<%
     const { date: derivedDate, fields: derivedDateFieldNames } = findDerivedDateInfo(eventResults, commandFieldNames, gwt.given);
     const keepFieldNames = buildKeepFieldNames(eventResults, commandFieldNames, derivedDateFieldNames, gwt.given);
 -%>

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

@@ -61,8 +61,8 @@ 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('...');`
+* - NEVER use `as SomeType` type assertions — not `as any`, not `as EventType`, no casts at all. Use typed variable declarations.
+* - If State is a discriminated union, 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
@@ -71,6 +71,7 @@ case '<%= command %>': {
 *   ⚠️ Error constructors: IllegalStateError takes a string message<% if (usedErrors.includes('ValidationError')) { %>, ValidationError takes a string message<% } %><% if (usedErrors.includes('NotFoundError')) { %>, NotFoundError takes { id, type, message? }<% } %>
 * - If valid, return one or more events with the correct structure
 *
+* - Only destructure/reference command.data fields that exist in the command type (imported from ./commands). Do NOT access fields not declared in the type, even if example data includes them.
 * ⚠️ Only read from inputs — never mutate them. `evolve.ts` handles state updates.
 <% if (integrationReturnFields.length > 0) { -%>
     *

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

@@ -102,6 +102,11 @@ describe('evolve.ts.ejs', () => {
        *   [ ] Every return (except \`return state;\`) matches a variant from state.ts
        *   [ ] Every return includes the discriminant field
        *   [ ] No spread operators in return statements
+       *
+       * CONSTRAINTS:
+       * - NEVER use \`as SomeType\` type assertions. Return properly typed object literals.
+       * - Only reference event.data fields that exist on the event type (check imports above).
+       * - Only return fields that exist in the State type (check state.ts). Do NOT invent new fields.
        */
 
       export const evolve = (state: State, event: ListingCreated): State => {

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

@@ -22,6 +22,11 @@
     *   [ ] Every return (except `return state;`) matches a variant from state.ts
     *   [ ] Every return includes the discriminant field
     *   [ ] No spread operators in return statements
+    *
+    * CONSTRAINTS:
+    * - NEVER use `as SomeType` type assertions. Return properly typed object literals.
+    * - Only reference event.data fields that exist on the event type (check imports above).
+    * - Only return fields that exist in the State type (check state.ts). Do NOT invent new fields.
     */
 
     export const evolve = (

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

@@ -1202,8 +1202,7 @@ describe('projection.specs.ts.ejs', () => {
                 .collection<WorkoutHistory>('WorkoutHistoryProjection')
                 .findOne((doc) => doc.memberId === 'mem_001');
 
-              const expected: WorkoutHistory = {
-                memberId: 'mem_001',
+              const expected = {
                 totalCalories: 250,
               };
 
@@ -1214,6 +1213,224 @@ describe('projection.specs.ts.ejs', () => {
     `);
   });
 
+  it('should exclude query arg fields that differ from projection-computed values', async () => {
+    const spec: SpecsSchema = {
+      variant: 'specs',
+      narratives: [
+        {
+          name: 'fart-flow',
+          slices: [
+            {
+              type: 'command',
+              name: 'log-fart',
+              stream: 'farts-${userId}',
+              client: { specs: [] },
+              server: {
+                description: '',
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'Log fart command',
+                    rules: [
+                      {
+                        name: 'Should record farts',
+                        examples: [
+                          {
+                            name: 'User logs fart',
+                            steps: [
+                              {
+                                keyword: 'When',
+                                text: 'LogFart',
+                                docString: { userId: 'usr_123', intensity: 7 },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'FartLogged',
+                                docString: { userId: 'usr_123', fartId: 'fart_456', intensity: 7 },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+            {
+              type: 'query',
+              name: 'view-fart-history',
+              stream: 'farts',
+              request:
+                'query GetFartHistory($userId: ID!, $minIntensity: Int) { fartHistory(userId: $userId, minIntensity: $minIntensity) { farts { fartId intensity } } }',
+              client: { specs: [] },
+              server: {
+                description: '',
+                data: {
+                  items: [
+                    {
+                      target: { type: 'State', name: 'FartHistory' },
+                      origin: { type: 'projection', name: 'FartHistoryProjection', idField: 'userId' },
+                    },
+                  ],
+                },
+                specs: [
+                  {
+                    type: 'gherkin',
+                    feature: 'View fart history query',
+                    rules: [
+                      {
+                        name: 'Fart history projection',
+                        examples: [
+                          {
+                            name: 'Shows farts after logging',
+                            steps: [
+                              {
+                                keyword: 'Given',
+                                text: 'FartLogged',
+                                docString: { userId: 'usr_123', fartId: 'fart_456', intensity: 7 },
+                              },
+                              {
+                                keyword: 'Given',
+                                text: 'FartLogged',
+                                docString: { userId: 'usr_123', fartId: 'fart_789', intensity: 9 },
+                              },
+                              {
+                                keyword: 'When',
+                                text: 'GetFartHistory',
+                                docString: { userId: 'usr_123', minIntensity: 6 },
+                              },
+                              {
+                                keyword: 'Then',
+                                text: 'FartHistory',
+                                docString: {
+                                  userId: 'usr_123',
+                                  farts: [
+                                    { fartId: 'fart_456', intensity: 7 },
+                                    { fartId: 'fart_789', intensity: 9 },
+                                  ],
+                                  minIntensity: 6,
+                                },
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          ],
+        },
+      ],
+      messages: [
+        {
+          type: 'command',
+          name: 'LogFart',
+          fields: [
+            { name: 'userId', type: 'string', required: true },
+            { name: 'intensity', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'event',
+          name: 'FartLogged',
+          source: 'internal',
+          fields: [
+            { name: 'userId', type: 'string', required: true },
+            { name: 'fartId', type: 'string', required: true },
+            { name: 'intensity', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'query',
+          name: 'GetFartHistory',
+          fields: [
+            { name: 'userId', type: 'string', required: true },
+            { name: 'minIntensity', type: 'number', required: true },
+          ],
+        },
+        {
+          type: 'state',
+          name: 'FartHistory',
+          fields: [
+            { name: 'userId', type: 'string', required: true },
+            { name: 'farts', type: 'Array<{ fartId: string; intensity: number }>', required: true },
+            { name: 'minIntensity', type: 'number', required: true },
+          ],
+        },
+      ],
+    } as SpecsSchema;
+
+    const { plans } = await generateScaffoldFilePlans(spec.narratives, spec.messages, undefined, 'src/domain/flows');
+    const specFile = plans.find((p) => p.outputPath.endsWith('view-fart-history/projection.specs.ts'));
+
+    expect(specFile?.contents).toMatchInlineSnapshot(`
+      "import { describe, it, beforeEach, expect } from 'vitest';
+      import { InMemoryProjectionSpec } from '@event-driven-io/emmett';
+      import { projection } from './projection';
+      import type { FartLogged } from '../log-fart/events';
+      import { FartHistory } from './state';
+
+      type ProjectionEvent = FartLogged;
+
+      describe('Fart history projection', () => {
+        let given: InMemoryProjectionSpec<ProjectionEvent>;
+
+        beforeEach(() => {
+          given = InMemoryProjectionSpec.for({ projection });
+        });
+
+        it('Shows farts after logging', () =>
+          given([
+            {
+              type: 'FartLogged',
+              data: {
+                userId: 'usr_123',
+                fartId: 'fart_456',
+                intensity: 7,
+              },
+              metadata: {
+                streamName: 'farts',
+                streamPosition: 1n,
+                globalPosition: 1n,
+              },
+            },
+            {
+              type: 'FartLogged',
+              data: {
+                userId: 'usr_123',
+                fartId: 'fart_789',
+                intensity: 9,
+              },
+              metadata: {
+                streamName: 'farts',
+                streamPosition: 1n,
+                globalPosition: 1n,
+              },
+            },
+          ])
+            .when([])
+            .then(async (state) => {
+              const document = await state.database
+                .collection<FartHistory>('FartHistoryProjection')
+                .findOne((doc) => doc.userId === 'usr_123');
+
+              const expected = {
+                farts: [
+                  { fartId: 'fart_456', intensity: 7 },
+                  { fartId: 'fart_789', intensity: 9 },
+                ],
+              };
+
+              expect(document).toMatchObject(expected);
+            }));
+      });
+      "
+    `);
+  });
+
   it('should serialize inline objects and arrays with Date sub-fields correctly', async () => {
     const spec: SpecsSchema = {
       variant: 'specs',
@@ -1572,6 +1789,11 @@ describe('projection.specs.ts.ejs', () => {
       * NEVER hardcode constant values — every output field must trace to an input.
       * Preserve all import paths above — they are generated from the model.
       * ⚠️ \`document\` may be null (first event for this entity). Guard before accessing properties.
+      *
+      * CONSTRAINTS:
+      * - NEVER use \`as SomeType\` type assertions. Declare typed variables instead: \`const x: Type = value;\`
+      * - Only reference event.data fields listed in the "Event fields:" line below.
+      * - Do NOT modify anything outside this case block: imports, type parameters, canHandle, collectionName, and getDocumentId are auto-generated.
       *
           * Implement how this event updates the projection.
           *
@@ -1584,11 +1806,12 @@ describe('projection.specs.ts.ejs', () => {
           *      internalField: SomeType;
           *    }
           *
-          * 2. Cast document parameter to extended type:
+          * 2. Assign document to extended type:
           *    const current: InternalWorkoutHistory = document ?? { ...defaults };
           *
-          * 3. Cast return values to extended type:
-          *    return { ...allFields, internalField } as InternalWorkoutHistory;
+          * 3. Return via typed variable (preserves internal state for next event):
+          *    const result: InternalWorkoutHistory = { ...allFields, internalField };
+          *    return result;
           *
           * This keeps internal state separate from the public GraphQL schema.
 

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

@@ -244,6 +244,11 @@ describe('projection.ts.ejs', () => {
       * NEVER hardcode constant values — every output field must trace to an input.
       * Preserve all import paths above — they are generated from the model.
       * ⚠️ \`document\` may be null (first event for this entity). Guard before accessing properties.
+      *
+      * CONSTRAINTS:
+      * - NEVER use \`as SomeType\` type assertions. Declare typed variables instead: \`const x: Type = value;\`
+      * - Only reference event.data fields listed in the "Event fields:" line below.
+      * - Do NOT modify anything outside this case block: imports, type parameters, canHandle, collectionName, and getDocumentId are auto-generated.
       *
           * Implement how this event updates the projection.
           *
@@ -256,11 +261,12 @@ describe('projection.ts.ejs', () => {
           *      internalField: SomeType;
           *    }
           *
-          * 2. Cast document parameter to extended type:
+          * 2. Assign document to extended type:
           *    const current: InternalAvailableListings = document ?? { ...defaults };
           *
-          * 3. Cast return values to extended type:
-          *    return { ...allFields, internalField } as InternalAvailableListings;
+          * 3. Return via typed variable (preserves internal state for next event):
+          *    const result: InternalAvailableListings = { ...allFields, internalField };
+          *    return result;
           *
           * This keeps internal state separate from the public GraphQL schema.
 
@@ -284,6 +290,11 @@ describe('projection.ts.ejs', () => {
       * NEVER hardcode constant values — every output field must trace to an input.
       * Preserve all import paths above — they are generated from the model.
       * ⚠️ \`document\` may be null (first event for this entity). Guard before accessing properties.
+      *
+      * CONSTRAINTS:
+      * - NEVER use \`as SomeType\` type assertions. Declare typed variables instead: \`const x: Type = value;\`
+      * - Only reference event.data fields listed in the "Event fields:" line below.
+      * - Do NOT modify anything outside this case block: imports, type parameters, canHandle, collectionName, and getDocumentId are auto-generated.
       *
           * This event might indicate removal of a AvailableListings.
           *
@@ -588,6 +599,11 @@ describe('projection.ts.ejs', () => {
       * NEVER hardcode constant values — every output field must trace to an input.
       * Preserve all import paths above — they are generated from the model.
       * ⚠️ \`document\` may be null (first event for this entity). Guard before accessing properties.
+      *
+      * CONSTRAINTS:
+      * - NEVER use \`as SomeType\` type assertions. Declare typed variables instead: \`const x: Type = value;\`
+      * - Only reference event.data fields listed in the "Event fields:" line below.
+      * - Do NOT modify anything outside this case block: imports, type parameters, canHandle, collectionName, and getDocumentId are auto-generated.
       *
           * **SINGLETON AGGREGATION PATTERN**
           *
@@ -810,6 +826,11 @@ describe('projection.ts.ejs', () => {
       * NEVER hardcode constant values — every output field must trace to an input.
       * Preserve all import paths above — they are generated from the model.
       * ⚠️ \`document\` may be null (first event for this entity). Guard before accessing properties.
+      *
+      * CONSTRAINTS:
+      * - NEVER use \`as SomeType\` type assertions. Declare typed variables instead: \`const x: Type = value;\`
+      * - Only reference event.data fields listed in the "Event fields:" line below.
+      * - Do NOT modify anything outside this case block: imports, type parameters, canHandle, collectionName, and getDocumentId are auto-generated.
       *
           * **COMPOSITE KEY PROJECTION**
           *

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

@@ -277,13 +277,23 @@ if (isCompositeKey) {
 }
 %>
 
-        const expected: <%= TargetType %> = {
-<% const stateKeys = Object.keys(expectedState.exampleData || {});
+<%
+   const stateKeys = Object.keys(expectedState.exampleData || {});
+   const queryArgs = isQueryActionTest
+     ? (testCase.when?.args
+       || (Array.isArray(testCase.when) && testCase.when[0]?.exampleData)
+       || {})
+     : {};
+   const queryArgKeys = new Set(Object.keys(queryArgs));
+   const assertionKeys = stateKeys.filter(k => !queryArgKeys.has(k));
    const stateMessage = messages.find(m => m.name === targetName);
-   for (let i = 0; i < stateKeys.length; i++) {
-     const key = stateKeys[i];
+   const isPartial = assertionKeys.length < stateKeys.length;
+-%>
+        const expected<%= isPartial ? '' : `: ${TargetType}` %> = {
+<% for (let i = 0; i < assertionKeys.length; i++) {
+     const key = assertionKeys[i];
      const value = expectedState.exampleData[key];
-     const isLast = i === stateKeys.length - 1;
+     const isLast = i === assertionKeys.length - 1;
      const field = stateMessage?.fields?.find(f => f.name === key);
      const tsType = field?.tsType || field?.type || 'string';
      const formattedValue = formatSpecValue(value, tsType);