@auto-engineer/narrative 0.21.0 → 0.21.2

package/dist/src/model-to-narrative.specs.js

@@ -1,2378 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import schema from './samples/seasonal-assistant.schema.json.js';
-import { modelToNarrative } from './transformers/model-to-narrative/index.js';
-describe('modelToNarrative', () => {
-    it('should create a full flow DSL from a model', async () => {
-        const code = await modelToNarrative(schema);
-        expect(code).toEqual(`import {
-  command,
-  data,
-  example,
-  gql,
-  narrative,
-  query,
-  react,
-  rule,
-  should,
-  sink,
-  source,
-  specs,
-} from '@auto-engineer/narrative';
-import type { Command, Event, State } from '@auto-engineer/narrative';
-import { AI, ProductCatalog } from '../server/src/integrations.js';
-import type { Products } from '../server/src/integrations.js';
-type EnterShoppingCriteria = Command<
-  'EnterShoppingCriteria',
-  {
-    sessionId: string;
-    criteria: string;
-  }
->;
-type ShoppingCriteriaEntered = Event<
-  'ShoppingCriteriaEntered',
-  {
-    sessionId: string;
-    criteria: string;
-  }
->;
-type SuggestShoppingItems = Command<
-  'SuggestShoppingItems',
-  {
-    sessionId: string;
-    prompt: string;
-  }
->;
-type ShoppingItemsSuggested = Event<
-  'ShoppingItemsSuggested',
-  {
-    sessionId: string;
-    suggestedItems: {
-      productId: string;
-      name: string;
-      quantity: number;
-      reason: string;
-    }[];
-  }
->;
-type SuggestedItems = State<
-  'SuggestedItems',
-  {
-    sessionId: string;
-    items: {
-      productId: string;
-      name: string;
-      quantity: number;
-      reason: string;
-    }[];
-  }
->;
-type AddItemsToCart = Command<
-  'AddItemsToCart',
-  {
-    sessionId: string;
-    items: {
-      productId: string;
-      quantity: number;
-    }[];
-  }
->;
-type ItemsAddedToCart = Event<
-  'ItemsAddedToCart',
-  {
-    sessionId: string;
-    items: {
-      productId: string;
-      quantity: number;
-    }[];
-  }
->;
-narrative('Seasonal Assistant', () => {
-  command('enters shopping criteria into assistant')
-    .client(() => {
-      specs('Assistant Chat Interface', () => {
-        should('allow shopper to describe their shopping needs in natural language');
-        should('provide a text input for entering criteria');
-        should('show examples of what to include (age, interests, budget)');
-        should('show a button to submit the criteria');
-        should('generate a persisted session id for a visit');
-        should('show the header on top of the page');
-      });
-    })
-    .request(
-      gql(\`mutation EnterShoppingCriteria($input: EnterShoppingCriteriaInput!) {
-  enterShoppingCriteria(input: $input) {
-    success
-    error {
-      type
-      message
-    }
-  }
-}\`),
-    )
-    .server(() => {
-      data([sink().event('ShoppingCriteriaEntered').toStream('shopping-session-\${sessionId}')]);
-      specs('When shopper submits criteria, a shopping session is started', () => {
-        rule('Valid criteria should start a shopping session', () => {
-          example('User submits shopping criteria for children')
-            .when<EnterShoppingCriteria>({
-              sessionId: 'shopper-123',
-              criteria:
-                'I need back-to-school items for my 7-year-old daughter who loves soccer and crafts, and my 12-year-old son who is into computers and Magic the Gathering.',
-            })
-            .then<ShoppingCriteriaEntered>({
-              sessionId: 'shopper-123',
-              criteria:
-                'I need back-to-school items for my 7-year-old daughter who loves soccer and crafts, and my 12-year-old son who is into computers and Magic the Gathering.',
-            });
-        });
-      });
-    });
-  react('creates a chat session').server(() => {
-    specs('When shopping criteria are entered, request wishlist creation', () => {
-      rule('Shopping criteria should trigger item suggestion', () => {
-        example('Criteria entered triggers wishlist creation')
-          .when<ShoppingCriteriaEntered>({
-            sessionId: 'session-abc',
-            criteria:
-              'I need back-to-school items for my 7-year-old daughter who loves soccer and crafts, and my 12-year-old son who is into computers and Magic the Gathering.',
-          })
-          .then<SuggestShoppingItems>({
-            sessionId: 'session-abc',
-            prompt:
-              'I need back-to-school items for my 7-year-old daughter who loves soccer and crafts, and my 12-year-old son who is into computers and Magic the Gathering.',
-          });
-      });
-    });
-  });
-  command('selects items relevant to the shopping criteria').server(() => {
-    data([
-      sink()
-        .command('SuggestShoppingItems')
-        .toIntegration(AI, 'DoChat', 'command')
-        .withState(source().state('Products').fromIntegration(ProductCatalog))
-        .additionalInstructions(
-          'add the following to the DoChat: schemaName: Products, systemPrompt: use the PRODUCT_CATALOGUE_PRODUCTS MCP tool to get product data',
-        ),
-      sink().event('ShoppingItemsSuggested').toStream('shopping-session-\${sessionId}'),
-    ]);
-    specs('When chat is triggered, AI suggests items based on product catalog', () => {
-      rule('AI should suggest relevant items from available products', () => {
-        example('Product catalog with matching items generates suggestions')
-          .given<Products>({
-            products: [
-              {
-                productId: 'prod-soccer-ball',
-                name: 'Super Soccer Ball',
-                category: 'Sports',
-                price: 10,
-                tags: ['soccer', 'sports'],
-                imageUrl: 'https://example.com/soccer-ball.jpg',
-              },
-              {
-                productId: 'prod-craft-kit',
-                name: 'Deluxe Craft Kit',
-                category: 'Arts & Crafts',
-                price: 25,
-                tags: ['crafts', 'art', 'creative'],
-                imageUrl: 'https://example.com/craft-kit.jpg',
-              },
-              {
-                productId: 'prod-laptop-bag',
-                name: 'Tech Laptop Backpack',
-                category: 'School Supplies',
-                price: 45,
-                tags: ['computers', 'tech', 'school'],
-                imageUrl: 'https://example.com/laptop-bag.jpg',
-              },
-              {
-                productId: 'prod-mtg-starter',
-                name: 'Magic the Gathering Starter Set',
-                category: 'Games',
-                price: 30,
-                tags: ['magic', 'tcg', 'games'],
-                imageUrl: 'https://example.com/mtg-starter.jpg',
-              },
-            ],
-          })
-          .when<SuggestShoppingItems>({
-            sessionId: 'session-abc',
-            prompt:
-              'I need back-to-school items for my 7-year-old daughter who loves soccer and crafts, and my 12-year-old son who is into computers and Magic the Gathering.',
-          })
-          .then<ShoppingItemsSuggested>({
-            sessionId: 'session-abc',
-            suggestedItems: [
-              {
-                productId: 'prod-soccer-ball',
-                name: 'Super Soccer Ball',
-                quantity: 1,
-                reason: 'Perfect for your daughter who loves soccer',
-              },
-              {
-                productId: 'prod-craft-kit',
-                name: 'Deluxe Craft Kit',
-                quantity: 1,
-                reason: 'Great for creative activities and crafts',
-              },
-              {
-                productId: 'prod-laptop-bag',
-                name: 'Tech Laptop Backpack',
-                quantity: 1,
-                reason: "Essential for your son's school computer needs",
-              },
-              {
-                productId: 'prod-mtg-starter',
-                name: 'Magic the Gathering Starter Set',
-                quantity: 1,
-                reason: 'Ideal starter set for Magic the Gathering enthusiasts',
-              },
-            ],
-          });
-      });
-    });
-  });
-  query('views suggested items')
-    .client(() => {
-      specs('Suggested Items Screen', () => {
-        should('display all suggested items with names and reasons');
-        should('show quantity selectors for each item');
-        should('have an "Add to Cart" button for selected items');
-        should('allow removing items from the suggestions');
-      });
-    })
-    .request(
-      gql(\`query GetSuggestedItems($sessionId: ID!) {
-  suggestedItems(sessionId: $sessionId) {
-    items {
-      productId
-      name
-      quantity
-      reason
-    }
-  }
-}\`),
-    )
-    .server(() => {
-      data([source().state('SuggestedItems').fromProjection('SuggestedItemsProjection', 'sessionId')]);
-      specs('Suggested items are available for viewing', () => {
-        rule('Items should be available for viewing after suggestion', () => {
-          example('Item becomes available after AI suggestion event')
-            .when<ShoppingItemsSuggested>({
-              sessionId: 'session-abc',
-              suggestedItems: [
-                {
-                  productId: 'prod-soccer-ball',
-                  name: 'Super Soccer Ball',
-                  quantity: 1,
-                  reason: 'Perfect for your daughter who loves soccer',
-                },
-                {
-                  productId: 'prod-craft-kit',
-                  name: 'Deluxe Craft Kit',
-                  quantity: 1,
-                  reason: 'Great for creative activities and crafts',
-                },
-                {
-                  productId: 'prod-laptop-bag',
-                  name: 'Tech Laptop Backpack',
-                  quantity: 1,
-                  reason: "Essential for your son's school computer needs",
-                },
-                {
-                  productId: 'prod-mtg-starter',
-                  name: 'Magic the Gathering Starter Set',
-                  quantity: 1,
-                  reason: 'Ideal starter set for Magic the Gathering enthusiasts',
-                },
-              ],
-            })
-            .then<SuggestedItems>({
-              sessionId: 'session-abc',
-              items: [
-                {
-                  productId: 'prod-soccer-ball',
-                  name: 'Super Soccer Ball',
-                  quantity: 1,
-                  reason: 'Perfect for your daughter who loves soccer',
-                },
-                {
-                  productId: 'prod-craft-kit',
-                  name: 'Deluxe Craft Kit',
-                  quantity: 1,
-                  reason: 'Great for creative activities and crafts',
-                },
-                {
-                  productId: 'prod-laptop-bag',
-                  name: 'Tech Laptop Backpack',
-                  quantity: 1,
-                  reason: "Essential for your son's school computer needs",
-                },
-                {
-                  productId: 'prod-mtg-starter',
-                  name: 'Magic the Gathering Starter Set',
-                  quantity: 1,
-                  reason: 'Ideal starter set for Magic the Gathering enthusiasts',
-                },
-              ],
-            });
-        });
-      });
-    });
-  command('accepts items and adds to their cart')
-    .client(() => {
-      specs('Suggested Items Screen', () => {
-        should('allow selecting specific items to add');
-        should('update quantities before adding to cart');
-        should('provide feedback when items are added');
-      });
-    })
-    .server(() => {
-      data([sink().event('ItemsAddedToCart').toStream('shopping-session-\${sessionId}')]);
-      specs('When shopper accepts items, they are added to cart', () => {
-        rule('Accepted items should be added to the shopping cart', () => {
-          example('User selects all suggested items for cart')
-            .when<AddItemsToCart>({
-              sessionId: 'session-abc',
-              items: [
-                { productId: 'prod-soccer-ball', quantity: 1 },
-                { productId: 'prod-craft-kit', quantity: 1 },
-                { productId: 'prod-laptop-bag', quantity: 1 },
-                { productId: 'prod-mtg-starter', quantity: 1 },
-              ],
-            })
-            .then<ItemsAddedToCart>({
-              sessionId: 'session-abc',
-              items: [
-                { productId: 'prod-soccer-ball', quantity: 1 },
-                { productId: 'prod-craft-kit', quantity: 1 },
-                { productId: 'prod-laptop-bag', quantity: 1 },
-                { productId: 'prod-mtg-starter', quantity: 1 },
-              ],
-            });
-        });
-      });
-    });
-});
-`);
-    });
-    it('should handle experience slices in model to flow conversion', async () => {
-        const experienceModel = {
-            variant: 'specs',
-            narratives: [
-                {
-                    name: 'Test Experience Flow',
-                    id: 'TEST-001',
-                    slices: [
-                        {
-                            name: 'Homepage',
-                            id: 'EXP-001',
-                            type: 'experience',
-                            client: {
-                                specs: {
-                                    name: '',
-                                    rules: ['show a hero section with a welcome message', 'allow user to start the questionnaire'],
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-            messages: [],
-            integrations: [],
-        };
-        const code = await modelToNarrative(experienceModel);
-        expect(code).toEqual(`import { experience, narrative, should, specs } from '@auto-engineer/narrative';
-narrative('Test Experience Flow', 'TEST-001', () => {
-  experience('Homepage', 'EXP-001').client(() => {
-    specs(() => {
-      should('show a hero section with a welcome message');
-      should('allow user to start the questionnaire');
-    });
-  });
-});
-`);
-    });
-    it('should handle flows and slices without IDs', async () => {
-        const modelWithoutIds = {
-            variant: 'specs',
-            narratives: [
-                {
-                    name: 'Test Flow without IDs',
-                    // id: undefined - no ID
-                    slices: [
-                        {
-                            name: 'Homepage',
-                            // id: undefined - no ID
-                            type: 'experience',
-                            client: {
-                                specs: {
-                                    name: 'Homepage specs',
-                                    rules: ['show welcome message', 'display navigation'],
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-            messages: [],
-            integrations: [],
-        };
-        const code = await modelToNarrative(modelWithoutIds);
-        expect(code).toEqual(`import { experience, narrative, should, specs } from '@auto-engineer/narrative';
-narrative('Test Flow without IDs', () => {
-  experience('Homepage').client(() => {
-    specs('Homepage specs', () => {
-      should('show welcome message');
-      should('display navigation');
-    });
-  });
-});
-`);
-    });
-    it('should include flow and slice IDs in generated code', async () => {
-        const modelWithIds = {
-            variant: 'specs',
-            narratives: [
-                {
-                    name: 'Test Flow with IDs',
-                    id: 'FLOW-123',
-                    slices: [
-                        {
-                            name: 'Homepage',
-                            id: 'SLICE-ABC',
-                            type: 'experience',
-                            client: {
-                                specs: {
-                                    name: 'Homepage specs',
-                                    rules: ['show welcome message', 'display navigation'],
-                                },
-                            },
-                        },
-                        {
-                            name: 'view products',
-                            id: 'SLICE-XYZ',
-                            type: 'query',
-                            client: {
-                                description: 'Product query client',
-                                specs: {
-                                    name: 'Product list specs',
-                                    rules: ['display all products', 'allow filtering'],
-                                },
-                            },
-                            server: {
-                                description: 'Product query server',
-                                specs: {
-                                    name: 'Product data specs',
-                                    rules: [],
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-            messages: [],
-            integrations: [],
-        };
-        const code = await modelToNarrative(modelWithIds);
-        expect(code).toEqual(`import { experience, narrative, query, should, specs } from '@auto-engineer/narrative';
-narrative('Test Flow with IDs', 'FLOW-123', () => {
-  experience('Homepage', 'SLICE-ABC').client(() => {
-    specs('Homepage specs', () => {
-      should('show welcome message');
-      should('display navigation');
-    });
-  });
-  query('view products', 'SLICE-XYZ')
-    .client(() => {
-      specs('Product list specs', () => {
-        should('display all products');
-        should('allow filtering');
-      });
-    })
-    .server(() => {
-      specs('Product data specs', () => {});
-    });
-});
-`);
-    });
-    it('should include rule IDs in server specs when present', async () => {
-        const modelWithRuleIds = {
-            variant: 'specs',
-            narratives: [
-                {
-                    name: 'Test Flow with Rule IDs',
-                    id: 'FLOW-456',
-                    slices: [
-                        {
-                            name: 'process command',
-                            id: 'SLICE-789',
-                            type: 'command',
-                            client: {
-                                description: 'Command processing client',
-                            },
-                            server: {
-                                description: 'Command processing server',
-                                specs: {
-                                    name: 'Command Processing',
-                                    rules: [
-                                        {
-                                            id: 'RULE-ABC',
-                                            description: 'Valid commands should be processed',
-                                            examples: [
-                                                {
-                                                    description: 'User submits valid command',
-                                                    when: {
-                                                        commandRef: 'ProcessCommand',
-                                                        exampleData: { id: 'cmd-123', action: 'create' },
-                                                    },
-                                                    then: [
-                                                        {
-                                                            eventRef: 'CommandProcessed',
-                                                            exampleData: { id: 'cmd-123', status: 'success' },
-                                                        },
-                                                    ],
-                                                },
-                                            ],
-                                        },
-                                    ],
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-            messages: [
-                {
-                    type: 'command',
-                    name: 'ProcessCommand',
-                    fields: [
-                        { name: 'id', type: 'string', required: true },
-                        { name: 'action', type: 'string', required: true },
-                    ],
-                    metadata: { version: 1 },
-                },
-                {
-                    type: 'event',
-                    name: 'CommandProcessed',
-                    fields: [
-                        { name: 'id', type: 'string', required: true },
-                        { name: 'status', type: 'string', required: true },
-                    ],
-                    source: 'external',
-                    metadata: { version: 1 },
-                },
-            ],
-            integrations: [],
-        };
-        const code = await modelToNarrative(modelWithRuleIds);
-        expect(code).toEqual(`import { command, example, narrative, rule, specs } from '@auto-engineer/narrative';
-import type { Command, Event } from '@auto-engineer/narrative';
-type ProcessCommand = Command<
-  'ProcessCommand',
-  {
-    id: string;
-    action: string;
-  }
->;
-type CommandProcessed = Event<
-  'CommandProcessed',
-  {
-    id: string;
-    status: string;
-  }
->;
-narrative('Test Flow with Rule IDs', 'FLOW-456', () => {
-  command('process command', 'SLICE-789').server(() => {
-    specs('Command Processing', () => {
-      rule('Valid commands should be processed', 'RULE-ABC', () => {
-        example('User submits valid command')
-          .when<ProcessCommand>({ id: 'cmd-123', action: 'create' })
-          .then<CommandProcessed>({ id: 'cmd-123', status: 'success' });
-      });
-    });
-  });
-});
-`);
-    });
-    it('should correctly resolve Date types in messages', async () => {
-        const modelWithDateTypes = {
-            variant: 'specs',
-            narratives: [
-                {
-                    name: 'Questionnaire Flow',
-                    id: 'QUEST-001',
-                    slices: [],
-                },
-            ],
-            messages: [
-                {
-                    type: 'event',
-                    name: 'QuestionnaireLinkSent',
-                    fields: [
-                        { name: 'questionnaireId', type: 'string', required: true },
-                        { name: 'participantId', type: 'string', required: true },
-                        { name: 'link', type: 'string', required: true },
-                        { name: 'sentAt', type: 'Date', required: true },
-                    ],
-                    source: 'external',
-                    metadata: { version: 1 },
-                },
-                {
-                    type: 'event',
-                    name: 'QuestionAnswered',
-                    fields: [
-                        { name: 'questionnaireId', type: 'string', required: true },
-                        { name: 'participantId', type: 'string', required: true },
-                        { name: 'questionId', type: 'string', required: true },
-                        { name: 'answer', type: 'unknown', required: true },
-                        { name: 'savedAt', type: 'Date', required: true },
-                    ],
-                    source: 'external',
-                    metadata: { version: 1 },
-                },
-            ],
-            integrations: [],
-        };
-        const code = await modelToNarrative(modelWithDateTypes);
-        expect(code).toEqual(`import { narrative } from '@auto-engineer/narrative';
-import type { Event } from '@auto-engineer/narrative';
-type QuestionnaireLinkSent = Event<
-  'QuestionnaireLinkSent',
-  {
-    questionnaireId: string;
-    participantId: string;
-    link: string;
-    sentAt: Date;
-  }
->;
-type QuestionAnswered = Event<
-  'QuestionAnswered',
-  {
-    questionnaireId: string;
-    participantId: string;
-    questionId: string;
-    answer: unknown;
-    savedAt: Date;
-  }
->;
-narrative('Questionnaire Flow', 'QUEST-001', () => {});
-`);
-    });
-    it('should generate browser-compatible imports without mixing values and types', async () => {
-        const questionnairesModel = {
-            variant: 'specs',
-            narratives: [
-                {
-                    name: 'Questionnaires',
-                    id: 'AUTO-Q9m2Kp4Lx',
-                    slices: [
-                        {
-                            name: 'Homepage',
-                            id: 'AUTO-H1a4Bn6Cy',
-                            type: 'experience',
-                            client: {
-                                specs: {
-                                    name: '',
-                                    rules: ['show a hero section with a welcome message', 'allow user to start the questionnaire'],
-                                },
-                            },
-                        },
-                        {
-                            name: 'views the questionnaire',
-                            id: 'AUTO-V7n8Rq5M',
-                            type: 'query',
-                            client: {
-                                description: '',
-                                specs: {
-                                    name: 'Questionnaire Progress',
-                                    rules: [
-                                        'focus on the current question based on the progress state',
-                                        'display the list of answered questions',
-                                        'display the list of remaining questions',
-                                        'show a progress indicator that is always visible as the user scrolls',
-                                    ],
-                                },
-                            },
-                            request: 'query QuestionnaireProgress($participantId: ID!) {\n  questionnaireProgress(participantId: $participantId) {\n    questionnaireId\n    participantId\n    currentQuestionId\n    remainingQuestions\n    status\n    answers {\n      questionId\n      value\n    }\n  }\n}',
-                            server: {
-                                description: '',
-                                data: [
-                                    {
-                                        target: {
-                                            type: 'State',
-                                            name: 'QuestionnaireProgress',
-                                        },
-                                        origin: {
-                                            type: 'projection',
-                                            name: 'Questionnaires',
-                                            idField: 'questionnaire-participantId',
-                                        },
-                                    },
-                                ],
-                                specs: {
-                                    name: '',
-                                    rules: [
-                                        {
-                                            id: 'AUTO-r1A3Bp9W',
-                                            description: 'questionnaires show current progress',
-                                            examples: [
-                                                {
-                                                    description: 'a question has already been answered',
-                                                    given: [
-                                                        {
-                                                            eventRef: 'QuestionnaireLinkSent',
-                                                            exampleData: {
-                                                                questionnaireId: 'q-001',
-                                                                participantId: 'participant-abc',
-                                                                link: 'https://app.example.com/q/q-001?participant=participant-abc',
-                                                                sentAt: new Date('2030-01-01T09:00:00.000Z'),
-                                                            },
-                                                        },
-                                                    ],
-                                                    when: {
-                                                        exampleData: {
-                                                            questionnaireId: 'q-001',
-                                                            participantId: 'participant-abc',
-                                                            questionId: 'q1',
-                                                            answer: 'Yes',
-                                                            savedAt: new Date('2030-01-01T09:05:00.000Z'),
-                                                        },
-                                                        eventRef: 'QuestionAnswered',
-                                                    },
-                                                    then: [
-                                                        {
-                                                            stateRef: 'QuestionnaireProgress',
-                                                            exampleData: {
-                                                                questionnaireId: 'q-001',
-                                                                participantId: 'participant-abc',
-                                                                status: 'in_progress',
-                                                                currentQuestionId: 'q2',
-                                                                remainingQuestions: ['q2', 'q3'],
-                                                                answers: [
-                                                                    {
-                                                                        questionId: 'q1',
-                                                                        value: 'Yes',
-                                                                    },
-                                                                ],
-                                                            },
-                                                        },
-                                                    ],
-                                                },
-                                            ],
-                                        },
-                                    ],
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-            messages: [
-                {
-                    type: 'event',
-                    name: 'QuestionnaireLinkSent',
-                    fields: [
-                        {
-                            name: 'questionnaireId',
-                            type: 'string',
-                            required: true,
-                        },
-                        {
-                            name: 'participantId',
-                            type: 'string',
-                            required: true,
-                        },
-                        {
-                            name: 'link',
-                            type: 'string',
-                            required: true,
-                        },
-                        {
-                            name: 'sentAt',
-                            type: 'Date',
-                            required: true,
-                        },
-                    ],
-                    source: 'internal',
-                    metadata: {
-                        version: 1,
-                    },
-                },
-                {
-                    type: 'event',
-                    name: 'QuestionAnswered',
-                    fields: [
-                        {
-                            name: 'questionnaireId',
-                            type: 'string',
-                            required: true,
-                        },
-                        {
-                            name: 'participantId',
-                            type: 'string',
-                            required: true,
-                        },
-                        {
-                            name: 'questionId',
-                            type: 'string',
-                            required: true,
-                        },
-                        {
-                            name: 'answer',
-                            type: 'unknown',
-                            required: true,
-                        },
-                        {
-                            name: 'savedAt',
-                            type: 'Date',
-                            required: true,
-                        },
-                    ],
-                    source: 'internal',
-                    metadata: {
-                        version: 1,
-                    },
-                },
-                {
-                    type: 'state',
-                    name: 'QuestionnaireProgress',
-                    fields: [
-                        {
-                            name: 'questionnaireId',
-                            type: 'string',
-                            required: true,
-                        },
-                        {
-                            name: 'participantId',
-                            type: 'string',
-                            required: true,
-                        },
-                        {
-                            name: 'status',
-                            type: '"in_progress" | "ready_to_submit" | "submitted"',
-                            required: true,
-                        },
-                        {
-                            name: 'currentQuestionId',
-                            type: 'string | null',
-                            required: true,
-                        },
-                        {
-                            name: 'remainingQuestions',
-                            type: 'Array<string>',
-                            required: true,
-                        },
-                        {
-                            name: 'answers',
-                            type: 'Array<{ questionId: string; value: unknown }>',
-                            required: true,
-                        },
-                    ],
-                    metadata: {
-                        version: 1,
-                    },
-                },
-            ],
-            integrations: [],
-        };
-        const code = await modelToNarrative(questionnairesModel);
-        expect(code).toEqual(`import {
-  data,
-  example,
-  experience,
-  gql,
-  narrative,
-  query,
-  rule,
-  should,
-  source,
-  specs,
-} from '@auto-engineer/narrative';
-import type { Event, State } from '@auto-engineer/narrative';
-type QuestionnaireLinkSent = Event<
-  'QuestionnaireLinkSent',
-  {
-    questionnaireId: string;
-    participantId: string;
-    link: string;
-    sentAt: Date;
-  }
->;
-type QuestionAnswered = Event<
-  'QuestionAnswered',
-  {
-    questionnaireId: string;
-    participantId: string;
-    questionId: string;
-    answer: unknown;
-    savedAt: Date;
-  }
->;
-type QuestionnaireProgress = State<
-  'QuestionnaireProgress',
-  {
-    questionnaireId: string;
-    participantId: string;
-    status: 'in_progress' | 'ready_to_submit' | 'submitted';
-    currentQuestionId: string | null;
-    remainingQuestions: string[];
-    answers: {
-      questionId: string;
-      value: unknown;
-    }[];
-  }
->;
-narrative('Questionnaires', 'AUTO-Q9m2Kp4Lx', () => {
-  experience('Homepage', 'AUTO-H1a4Bn6Cy').client(() => {
-    specs(() => {
-      should('show a hero section with a welcome message');
-      should('allow user to start the questionnaire');
-    });
-  });
-  query('views the questionnaire', 'AUTO-V7n8Rq5M')
-    .client(() => {
-      specs('Questionnaire Progress', () => {
-        should('focus on the current question based on the progress state');
-        should('display the list of answered questions');
-        should('display the list of remaining questions');
-        should('show a progress indicator that is always visible as the user scrolls');
-      });
-    })
-    .request(
-      gql(\`query QuestionnaireProgress($participantId: ID!) {
-  questionnaireProgress(participantId: $participantId) {
-    questionnaireId
-    participantId
-    currentQuestionId
-    remainingQuestions
-    status
-    answers {
-      questionId
-      value
-    }
-  }
-}\`),
-    )
-    .server(() => {
-      data([source().state('QuestionnaireProgress').fromProjection('Questionnaires', 'questionnaire-participantId')]);
-      specs(() => {
-        rule('questionnaires show current progress', 'AUTO-r1A3Bp9W', () => {
-          example('a question has already been answered')
-            .given<QuestionnaireLinkSent>({
-              questionnaireId: 'q-001',
-              participantId: 'participant-abc',
-              link: 'https://app.example.com/q/q-001?participant=participant-abc',
-              sentAt: new Date('2030-01-01T09:00:00.000Z'),
-            })
-            .when<QuestionAnswered>({
-              questionnaireId: 'q-001',
-              participantId: 'participant-abc',
-              questionId: 'q1',
-              answer: 'Yes',
-              savedAt: new Date('2030-01-01T09:05:00.000Z'),
-            })
-            .then<QuestionnaireProgress>({
-              questionnaireId: 'q-001',
-              participantId: 'participant-abc',
-              status: 'in_progress',
-              currentQuestionId: 'q2',
-              remainingQuestions: ['q2', 'q3'],
-              answers: [{ questionId: 'q1', value: 'Yes' }],
-            });
-        });
-      });
-    });
-});
-`);
-    });
-    it('should consolidate duplicate rules with multiple examples into single rule blocks', async () => {
-        const modelWithDuplicateRules = {
-            variant: 'specs',
-            narratives: [
-                {
-                    name: 'Test Flow',
-                    id: 'TEST-FLOW',
-                    slices: [
-                        {
-                            name: 'test slice',
-                            id: 'TEST-SLICE',
-                            type: 'query',
-                            client: {
-                                description: 'Test client for duplicate rules',
-                            },
-                            server: {
-                                description: 'Test server for duplicate rules',
-                                specs: {
-                                    name: 'Test Rules',
-                                    rules: [
-                                        {
-                                            id: 'AUTO-r1A3Bp9W',
-                                            description: 'questionnaires show current progress',
-                                            examples: [
-                                                {
-                                                    description: 'a question has already been answered',
-                                                    given: [
-                                                        {
-                                                            eventRef: 'QuestionnaireLinkSent',
-                                                            exampleData: {
-                                                                questionnaireId: 'q-001',
-                                                                participantId: 'participant-abc',
-                                                            },
-                                                        },
-                                                    ],
-                                                    when: {
-                                                        eventRef: 'QuestionAnswered',
-                                                        exampleData: {
-                                                            questionnaireId: 'q-001',
-                                                            questionId: 'q1',
-                                                            answer: 'Yes',
-                                                        },
-                                                    },
-                                                    then: [
-                                                        {
-                                                            stateRef: 'QuestionnaireProgress',
-                                                            exampleData: {
-                                                                questionnaireId: 'q-001',
-                                                                status: 'in_progress',
-                                                            },
-                                                        },
-                                                    ],
-                                                },
-                                                {
-                                                    description: 'no questions have been answered yet',
-                                                    given: [
-                                                        {
-                                                            eventRef: 'QuestionnaireLinkSent',
-                                                            exampleData: {
-                                                                questionnaireId: 'q-001',
-                                                                participantId: 'participant-abc',
-                                                            },
-                                                        },
-                                                    ],
-                                                    when: {
-                                                        eventRef: 'QuestionnaireLinkSent',
-                                                        exampleData: {},
-                                                    },
-                                                    then: [
-                                                        {
-                                                            stateRef: 'QuestionnaireProgress',
-                                                            exampleData: {
-                                                                questionnaireId: 'q-001',
-                                                                status: 'in_progress',
-                                                            },
-                                                        },
-                                                    ],
-                                                },
-                                            ],
-                                        },
-                                    ],
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-            messages: [
-                {
-                    type: 'event',
-                    name: 'QuestionnaireLinkSent',
-                    fields: [
-                        { name: 'questionnaireId', type: 'string', required: true },
-                        { name: 'participantId', type: 'string', required: true },
-                    ],
-                    source: 'internal',
-                    metadata: { version: 1 },
-                },
-                {
-                    type: 'event',
-                    name: 'QuestionAnswered',
-                    fields: [
-                        { name: 'questionnaireId', type: 'string', required: true },
-                        { name: 'questionId', type: 'string', required: true },
-                        { name: 'answer', type: 'unknown', required: true },
-                    ],
-                    source: 'internal',
-                    metadata: { version: 1 },
-                },
-                {
-                    type: 'state',
-                    name: 'QuestionnaireProgress',
-                    fields: [
-                        { name: 'questionnaireId', type: 'string', required: true },
-                        { name: 'status', type: 'string', required: true },
-                    ],
-                    metadata: { version: 1 },
-                },
-            ],
-            integrations: [],
-        };
-        const code = await modelToNarrative(modelWithDuplicateRules);
-        expect(code).toEqual(`import { example, narrative, query, rule, specs } from '@auto-engineer/narrative';
-import type { Event, State } from '@auto-engineer/narrative';
-type QuestionnaireLinkSent = Event<
-  'QuestionnaireLinkSent',
-  {
-    questionnaireId: string;
-    participantId: string;
-  }
->;
-type QuestionAnswered = Event<
-  'QuestionAnswered',
-  {
-    questionnaireId: string;
-    questionId: string;
-    answer: unknown;
-  }
->;
-type QuestionnaireProgress = State<
-  'QuestionnaireProgress',
-  {
-    questionnaireId: string;
-    status: string;
-  }
->;
-narrative('Test Flow', 'TEST-FLOW', () => {
-  query('test slice', 'TEST-SLICE').server(() => {
-    specs('Test Rules', () => {
-      rule('questionnaires show current progress', 'AUTO-r1A3Bp9W', () => {
-        example('a question has already been answered')
-          .given<QuestionnaireLinkSent>({ questionnaireId: 'q-001', participantId: 'participant-abc' })
-          .when<QuestionAnswered>({ questionnaireId: 'q-001', questionId: 'q1', answer: 'Yes' })
-          .then<QuestionnaireProgress>({ questionnaireId: 'q-001', status: 'in_progress' });
-        example('no questions have been answered yet')
-          .given<QuestionnaireLinkSent>({ questionnaireId: 'q-001', participantId: 'participant-abc' })
-          .when<QuestionnaireLinkSent>({})
-          .then<QuestionnaireProgress>({ questionnaireId: 'q-001', status: 'in_progress' });
-      });
-    });
-  });
-});
-`);
-    });
-    it('should chain multiple given examples with .and() syntax', async () => {
-        const modelWithMultiGiven = {
-            variant: 'specs',
-            narratives: [
-                {
-                    name: 'Multi Given Flow',
-                    id: 'MULTI-GIVEN',
-                    slices: [
-                        {
-                            name: 'multi given slice',
-                            id: 'MULTI-SLICE',
-                            type: 'query',
-                            client: {
-                                description: 'Multi given client',
-                            },
-                            server: {
-                                description: 'Multi given server rules',
-                                specs: {
-                                    name: 'Multi Given Rules',
-                                    rules: [
-                                        {
-                                            id: 'AUTO-MultiGiven',
-                                            description: 'all questions have been answered',
-                                            examples: [
-                                                {
-                                                    description: 'questionnaire with multiple events',
-                                                    given: [
-                                                        {
-                                                            stateRef: 'QuestionnaireConfig',
-                                                            exampleData: {
-                                                                questionnaireId: 'q-001',
-                                                                numberOfQuestions: 3,
-                                                            },
-                                                        },
-                                                        {
-                                                            eventRef: 'QuestionnaireLinkSent',
-                                                            exampleData: {
-                                                                questionnaireId: 'q-001',
-                                                                participantId: 'participant-abc',
-                                                                link: 'https://example.com/q/q-001',
-                                                                sentAt: new Date('2030-01-01T09:00:00.000Z'),
-                                                            },
-                                                        },
-                                                        {
-                                                            eventRef: 'QuestionAnswered',
-                                                            exampleData: {
-                                                                questionnaireId: 'q-001',
-                                                                participantId: 'participant-abc',
-                                                                questionId: 'q1',
-                                                                answer: 'Yes',
-                                                                savedAt: new Date('2030-01-01T09:05:00.000Z'),
-                                                            },
-                                                        },
-                                                        {
-                                                            eventRef: 'QuestionAnswered',
-                                                            exampleData: {
-                                                                questionnaireId: 'q-001',
-                                                                participantId: 'participant-abc',
-                                                                questionId: 'q2',
-                                                                answer: 'No',
-                                                                savedAt: new Date('2030-01-01T09:10:00.000Z'),
-                                                            },
-                                                        },
-                                                    ],
-                                                    when: {
-                                                        eventRef: 'QuestionAnswered',
-                                                        exampleData: {
-                                                            questionnaireId: 'q-001',
-                                                            participantId: 'participant-abc',
-                                                            questionId: 'q3',
-                                                            answer: 'Maybe',
-                                                            savedAt: new Date('2030-01-01T09:15:00.000Z'),
-                                                        },
-                                                    },
-                                                    then: [
-                                                        {
-                                                            stateRef: 'QuestionnaireProgress',
-                                                            exampleData: {
-                                                                questionnaireId: 'q-001',
-                                                                participantId: 'participant-abc',
-                                                                status: 'ready_to_submit',
-                                                                currentQuestionId: null,
-                                                                remainingQuestions: [],
-                                                                answers: [
-                                                                    { questionId: 'q1', value: 'Yes' },
-                                                                    { questionId: 'q2', value: 'No' },
-                                                                ],
-                                                            },
-                                                        },
-                                                    ],
-                                                },
-                                            ],
-                                        },
-                                    ],
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-            messages: [
-                {
-                    type: 'state',
-                    name: 'QuestionnaireConfig',
-                    fields: [
-                        { name: 'questionnaireId', type: 'string', required: true },
-                        { name: 'numberOfQuestions', type: 'number', required: true },
-                    ],
-                    metadata: { version: 1 },
-                },
-                {
-                    type: 'event',
-                    name: 'QuestionnaireLinkSent',
-                    fields: [
-                        { name: 'questionnaireId', type: 'string', required: true },
-                        { name: 'participantId', type: 'string', required: true },
-                        { name: 'link', type: 'string', required: true },
-                        { name: 'sentAt', type: 'Date', required: true },
-                    ],
-                    source: 'internal',
-                    metadata: { version: 1 },
-                },
-                {
-                    type: 'event',
-                    name: 'QuestionAnswered',
-                    fields: [
-                        { name: 'questionnaireId', type: 'string', required: true },
-                        { name: 'participantId', type: 'string', required: true },
-                        { name: 'questionId', type: 'string', required: true },
-                        { name: 'answer', type: 'unknown', required: true },
-                        { name: 'savedAt', type: 'Date', required: true },
-                    ],
-                    source: 'internal',
-                    metadata: { version: 1 },
-                },
-                {
-                    type: 'state',
-                    name: 'QuestionnaireProgress',
-                    fields: [
-                        { name: 'questionnaireId', type: 'string', required: true },
-                        { name: 'participantId', type: 'string', required: true },
-                        { name: 'status', type: '"in_progress" | "ready_to_submit" | "submitted"', required: true },
-                        { name: 'currentQuestionId', type: 'string | null', required: true },
-                        { name: 'remainingQuestions', type: 'Array<string>', required: true },
-                        { name: 'answers', type: 'Array<{ questionId: string; value: unknown }>', required: true },
-                    ],
-                    metadata: { version: 1 },
-                },
-            ],
-            integrations: [],
-        };
-        const code = await modelToNarrative(modelWithMultiGiven);
-        expect(code).toEqual(`import { example, narrative, query, rule, specs } from '@auto-engineer/narrative';
-import type { Event, State } from '@auto-engineer/narrative';
-type QuestionnaireConfig = State<
-  'QuestionnaireConfig',
-  {
-    questionnaireId: string;
-    numberOfQuestions: number;
-  }
->;
-type QuestionnaireLinkSent = Event<
-  'QuestionnaireLinkSent',
-  {
-    questionnaireId: string;
-    participantId: string;
-    link: string;
-    sentAt: Date;
-  }
->;
-type QuestionAnswered = Event<
-  'QuestionAnswered',
-  {
-    questionnaireId: string;
-    participantId: string;
-    questionId: string;
-    answer: unknown;
-    savedAt: Date;
-  }
->;
-type QuestionnaireProgress = State<
-  'QuestionnaireProgress',
-  {
-    questionnaireId: string;
-    participantId: string;
-    status: 'in_progress' | 'ready_to_submit' | 'submitted';
-    currentQuestionId: string | null;
-    remainingQuestions: string[];
-    answers: {
-      questionId: string;
-      value: unknown;
-    }[];
-  }
->;
-narrative('Multi Given Flow', 'MULTI-GIVEN', () => {
-  query('multi given slice', 'MULTI-SLICE').server(() => {
-    specs('Multi Given Rules', () => {
-      rule('all questions have been answered', 'AUTO-MultiGiven', () => {
-        example('questionnaire with multiple events')
-          .given<QuestionnaireConfig>({ questionnaireId: 'q-001', numberOfQuestions: 3 })
-          .and<QuestionnaireLinkSent>({
-            questionnaireId: 'q-001',
-            participantId: 'participant-abc',
-            link: 'https://example.com/q/q-001',
-            sentAt: new Date('2030-01-01T09:00:00.000Z'),
-          })
-          .and<QuestionAnswered>({
-            questionnaireId: 'q-001',
-            participantId: 'participant-abc',
-            questionId: 'q1',
-            answer: 'Yes',
-            savedAt: new Date('2030-01-01T09:05:00.000Z'),
-          })
-          .and<QuestionAnswered>({
-            questionnaireId: 'q-001',
-            participantId: 'participant-abc',
-            questionId: 'q2',
-            answer: 'No',
-            savedAt: new Date('2030-01-01T09:10:00.000Z'),
-          })
-          .when<QuestionAnswered>({
-            questionnaireId: 'q-001',
-            participantId: 'participant-abc',
-            questionId: 'q3',
-            answer: 'Maybe',
-            savedAt: new Date('2030-01-01T09:15:00.000Z'),
-          })
-          .then<QuestionnaireProgress>({
-            questionnaireId: 'q-001',
-            participantId: 'participant-abc',
-            status: 'ready_to_submit',
-            currentQuestionId: null,
-            remainingQuestions: [],
-            answers: [
-              { questionId: 'q1', value: 'Yes' },
-              { questionId: 'q2', value: 'No' },
-            ],
-          });
-      });
-    });
-  });
-});
-`);
-    });
-    it('should generate types for states referenced in data origins', async () => {
-        const modelWithReferencedStates = {
-            variant: 'specs',
-            narratives: [
-                {
-                    name: 'Referenced States Flow',
-                    id: 'REF-STATES',
-                    slices: [
-                        {
-                            name: 'query with database states',
-                            id: 'REF-SLICE',
-                            type: 'query',
-                            client: {
-                                description: 'Client for referenced states',
-                            },
-                            server: {
-                                description: 'Server for referenced states',
-                                data: [
-                                    {
-                                        target: {
-                                            type: 'State',
-                                            name: 'QuestionnaireProgress',
-                                        },
-                                        origin: {
-                                            type: 'projection',
-                                            name: 'QuestionnaireProjection',
-                                            idField: 'participantId',
-                                        },
-                                    },
-                                    {
-                                        target: {
-                                            type: 'State',
-                                            name: 'QuestionnaireConfig',
-                                        },
-                                        origin: {
-                                            type: 'database',
-                                            collection: 'ConfigStore',
-                                            query: { questionnaireId: '$questionnaireId' },
-                                        },
-                                    },
-                                ],
-                                specs: {
-                                    name: 'Database State Rules',
-                                    rules: [
-                                        {
-                                            id: 'AUTO-RefState',
-                                            description: 'questionnaire config is available when referenced',
-                                            examples: [
-                                                {
-                                                    description: 'config from database is accessible',
-                                                    given: [
-                                                        {
-                                                            stateRef: 'QuestionnaireConfig',
-                                                            exampleData: {
-                                                                questionnaireId: 'q-001',
-                                                                numberOfQuestions: 5,
-                                                                title: 'Customer Satisfaction Survey',
-                                                            },
-                                                        },
-                                                    ],
-                                                    when: {
-                                                        eventRef: 'QuestionnaireProgress',
-                                                        exampleData: {},
-                                                    },
-                                                    then: [
-                                                        {
-                                                            stateRef: 'QuestionnaireProgress',
-                                                            exampleData: {
-                                                                questionnaireId: 'q-001',
-                                                                participantId: 'participant-abc',
-                                                                status: 'in_progress',
-                                                                totalQuestions: 5,
-                                                            },
-                                                        },
-                                                    ],
-                                                },
-                                            ],
-                                        },
-                                    ],
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-            messages: [
-                {
-                    type: 'state',
-                    name: 'QuestionnaireProgress',
-                    fields: [
-                        { name: 'questionnaireId', type: 'string', required: true },
-                        { name: 'participantId', type: 'string', required: true },
-                        { name: 'status', type: 'string', required: true },
-                        { name: 'totalQuestions', type: 'number', required: true },
-                    ],
-                    metadata: { version: 1 },
-                },
-                {
-                    type: 'state',
-                    name: 'QuestionnaireConfig',
-                    fields: [
-                        { name: 'questionnaireId', type: 'string', required: true },
-                        { name: 'numberOfQuestions', type: 'number', required: true },
-                        { name: 'title', type: 'string', required: true },
-                    ],
-                    metadata: { version: 1 },
-                },
-            ],
-            integrations: [],
-        };
-        const code = await modelToNarrative(modelWithReferencedStates);
-        expect(code)
-            .toEqual(`import { data, example, narrative, query, rule, source, specs } from '@auto-engineer/narrative';
-import type { State } from '@auto-engineer/narrative';
-type QuestionnaireProgress = State<
-  'QuestionnaireProgress',
-  {
-    questionnaireId: string;
-    participantId: string;
-    status: string;
-    totalQuestions: number;
-  }
->;
-type QuestionnaireConfig = State<
-  'QuestionnaireConfig',
-  {
-    questionnaireId: string;
-    numberOfQuestions: number;
-    title: string;
-  }
->;
-narrative('Referenced States Flow', 'REF-STATES', () => {
-  query('query with database states', 'REF-SLICE').server(() => {
-    data([
-      source().state('QuestionnaireProgress').fromProjection('QuestionnaireProjection', 'participantId'),
-      source().state('QuestionnaireConfig').fromDatabase('ConfigStore', { questionnaireId: '$questionnaireId' }),
-    ]);
-    specs('Database State Rules', () => {
-      rule('questionnaire config is available when referenced', 'AUTO-RefState', () => {
-        example('config from database is accessible')
-          .given<QuestionnaireConfig>({
-            questionnaireId: 'q-001',
-            numberOfQuestions: 5,
-            title: 'Customer Satisfaction Survey',
-          })
-          .when<QuestionnaireProgress>({})
-          .then<QuestionnaireProgress>({
-            questionnaireId: 'q-001',
-            participantId: 'participant-abc',
-            status: 'in_progress',
-            totalQuestions: 5,
-          });
-      });
-    });
-  });
-});
-`);
-    });
-    it('should generate new Date() constructors for Date fields', async () => {
-        const modelWithDateFields = {
-            variant: 'specs',
-            narratives: [
-                {
-                    name: 'Date Handling Flow',
-                    id: 'DATE-FLOW',
-                    slices: [
-                        {
-                            name: 'date handling slice',
-                            id: 'DATE-SLICE',
-                            type: 'query',
-                            client: {
-                                description: 'Date client',
-                            },
-                            server: {
-                                description: 'Date server with Date fields',
-                                specs: {
-                                    name: 'Date Field Rules',
-                                    rules: [
-                                        {
-                                            id: 'AUTO-DateRule',
-                                            description: 'handles Date fields correctly',
-                                            examples: [
-                                                {
-                                                    description: 'event with Date fields',
-                                                    given: [
-                                                        {
-                                                            eventRef: 'TimestampedEvent',
-                                                            exampleData: {
-                                                                id: 'event-123',
-                                                                sentAt: new Date('2030-01-01T09:00:00.000Z'),
-                                                                savedAt: new Date('2030-01-01T09:05:00.000Z'),
-                                                                attemptedAt: '2030-01-01T09:10:00.000Z',
-                                                                submittedAt: '2030-01-01T09:15:00.000Z',
-                                                            },
-                                                        },
-                                                    ],
-                                                    when: {
-                                                        eventRef: 'ProcessEvent',
-                                                        exampleData: {
-                                                            processedAt: '2030-01-01T10:00:00.000Z',
-                                                        },
-                                                    },
-                                                    then: [
-                                                        {
-                                                            stateRef: 'ProcessState',
-                                                            exampleData: {
-                                                                id: 'state-123',
-                                                                completedAt: '2030-01-01T11:00:00.000Z',
-                                                                status: 'completed',
-                                                            },
-                                                        },
-                                                    ],
-                                                },
-                                            ],
-                                        },
-                                    ],
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-            messages: [
-                {
-                    type: 'event',
-                    name: 'TimestampedEvent',
-                    fields: [
-                        { name: 'id', type: 'string', required: true },
-                        { name: 'sentAt', type: 'Date', required: true },
-                        { name: 'savedAt', type: 'Date', required: true },
-                        { name: 'attemptedAt', type: 'Date', required: true },
-                        { name: 'submittedAt', type: 'Date', required: true },
-                    ],
-                    source: 'internal',
-                    metadata: { version: 1 },
-                },
-                {
-                    type: 'event',
-                    name: 'ProcessEvent',
-                    fields: [{ name: 'processedAt', type: 'Date', required: true }],
-                    source: 'internal',
-                    metadata: { version: 1 },
-                },
-                {
-                    type: 'state',
-                    name: 'ProcessState',
-                    fields: [
-                        { name: 'id', type: 'string', required: true },
-                        { name: 'completedAt', type: 'Date', required: true },
-                        { name: 'status', type: 'string', required: true },
-                    ],
-                    metadata: { version: 1 },
-                },
-            ],
-            integrations: [],
-        };
-        const code = await modelToNarrative(modelWithDateFields);
-        expect(code).toEqual(`import { example, narrative, query, rule, specs } from '@auto-engineer/narrative';
-import type { Event, State } from '@auto-engineer/narrative';
-type TimestampedEvent = Event<
-  'TimestampedEvent',
-  {
-    id: string;
-    sentAt: Date;
-    savedAt: Date;
-    attemptedAt: Date;
-    submittedAt: Date;
-  }
->;
-type ProcessEvent = Event<
-  'ProcessEvent',
-  {
-    processedAt: Date;
-  }
->;
-type ProcessState = State<
-  'ProcessState',
-  {
-    id: string;
-    completedAt: Date;
-    status: string;
-  }
->;
-narrative('Date Handling Flow', 'DATE-FLOW', () => {
-  query('date handling slice', 'DATE-SLICE').server(() => {
-    specs('Date Field Rules', () => {
-      rule('handles Date fields correctly', 'AUTO-DateRule', () => {
-        example('event with Date fields')
-          .given<TimestampedEvent>({
-            id: 'event-123',
-            sentAt: new Date('2030-01-01T09:00:00.000Z'),
-            savedAt: new Date('2030-01-01T09:05:00.000Z'),
-            attemptedAt: new Date('2030-01-01T09:10:00.000Z'),
-            submittedAt: new Date('2030-01-01T09:15:00.000Z'),
-          })
-          .when<ProcessEvent>({ processedAt: new Date('2030-01-01T10:00:00.000Z') })
-          .then<ProcessState>({
-            id: 'state-123',
-            completedAt: new Date('2030-01-01T11:00:00.000Z'),
-            status: 'completed',
-          });
-      });
-    });
-  });
-});
-`);
-    });
-    it('should generate multiple flows when multiple flows have the same sourceFile', async () => {
-        const modelWithMultipleFlowsSameSource = {
-            variant: 'specs',
-            narratives: [
-                {
-                    name: 'Home Screen',
-                    sourceFile: '/path/to/homepage.narrative.ts',
-                    slices: [
-                        {
-                            name: 'Active Surveys Summary',
-                            id: 'AUTO-aifPcU3hw',
-                            type: 'experience',
-                            client: {
-                                specs: {
-                                    name: '',
-                                    rules: ['show active surveys summary'],
-                                },
-                            },
-                        },
-                    ],
-                },
-                {
-                    name: 'Create Survey',
-                    sourceFile: '/path/to/homepage.narrative.ts',
-                    slices: [
-                        {
-                            name: 'Create Survey Form',
-                            id: 'AUTO-MPviTMrQC',
-                            type: 'experience',
-                            client: {
-                                specs: {
-                                    name: '',
-                                    rules: ['allow entering survey title'],
-                                },
-                            },
-                        },
-                    ],
-                },
-                {
-                    name: 'Response Analytics',
-                    sourceFile: '/path/to/homepage.narrative.ts',
-                    slices: [
-                        {
-                            name: 'Response Rate Charts',
-                            id: 'AUTO-eME978Euk',
-                            type: 'experience',
-                            client: {
-                                specs: {
-                                    name: '',
-                                    rules: ['show daily response rate charts'],
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-            messages: [],
-            integrations: [],
-        };
-        const code = await modelToNarrative(modelWithMultipleFlowsSameSource);
-        expect(code).toEqual(`import { experience, narrative, should, specs } from '@auto-engineer/narrative';
-narrative('Home Screen', () => {
-  experience('Active Surveys Summary', 'AUTO-aifPcU3hw').client(() => {
-    specs(() => {
-      should('show active surveys summary');
-    });
-  });
-});
-narrative('Create Survey', () => {
-  experience('Create Survey Form', 'AUTO-MPviTMrQC').client(() => {
-    specs(() => {
-      should('allow entering survey title');
-    });
-  });
-});
-narrative('Response Analytics', () => {
-  experience('Response Rate Charts', 'AUTO-eME978Euk').client(() => {
-    specs(() => {
-      should('show daily response rate charts');
-    });
-  });
-});
-`);
-    });
-    it('should omit .when({}) when given has multiple items and when is empty', async () => {
-        const modelWithEmptyWhen = {
-            variant: 'specs',
-            narratives: [
-                {
-                    name: 'Todo List Summary',
-                    id: 'TODO-001',
-                    slices: [
-                        {
-                            name: 'views completion summary',
-                            id: 'SUMMARY-001',
-                            type: 'query',
-                            client: {
-                                description: 'Summary view client',
-                            },
-                            server: {
-                                description: 'Summary calculation server',
-                                specs: {
-                                    name: 'Summary Statistics',
-                                    rules: [
-                                        {
-                                            id: 'RULE-SUMMARY',
-                                            description: 'summary shows overall todo list statistics',
-                                            examples: [
-                                                {
-                                                    description: 'calculates summary from multiple todos',
-                                                    given: [
-                                                        {
-                                                            eventRef: 'TodoAdded',
-                                                            exampleData: {
-                                                                todoId: 'todo-001',
-                                                                description: 'Buy groceries',
-                                                                status: 'pending',
-                                                                addedAt: new Date('2030-01-01T09:00:00.000Z'),
-                                                            },
-                                                        },
-                                                        {
-                                                            eventRef: 'TodoAdded',
-                                                            exampleData: {
-                                                                todoId: 'todo-002',
-                                                                description: 'Write report',
-                                                                status: 'pending',
-                                                                addedAt: new Date('2030-01-01T09:10:00.000Z'),
-                                                            },
-                                                        },
-                                                        {
-                                                            eventRef: 'TodoMarkedInProgress',
-                                                            exampleData: {
-                                                                todoId: 'todo-001',
-                                                                markedAt: new Date('2030-01-01T10:00:00.000Z'),
-                                                            },
-                                                        },
-                                                        {
-                                                            eventRef: 'TodoMarkedComplete',
-                                                            exampleData: {
-                                                                todoId: 'todo-002',
-                                                                completedAt: new Date('2030-01-01T11:00:00.000Z'),
-                                                            },
-                                                        },
-                                                    ],
-                                                    when: {
-                                                        eventRef: '',
-                                                        exampleData: {},
-                                                    },
-                                                    then: [
-                                                        {
-                                                            stateRef: 'TodoListSummary',
-                                                            exampleData: {
-                                                                summaryId: 'main-summary',
-                                                                totalTodos: 2,
-                                                                pendingCount: 0,
-                                                                inProgressCount: 1,
-                                                                completedCount: 1,
-                                                                completionPercentage: 50,
-                                                            },
-                                                        },
-                                                    ],
-                                                },
-                                            ],
-                                        },
-                                    ],
-                                },
-                            },
-                        },
-                    ],
-                },
-            ],
-            messages: [
-                {
-                    type: 'event',
-                    name: 'TodoAdded',
-                    fields: [
-                        { name: 'todoId', type: 'string', required: true },
-                        { name: 'description', type: 'string', required: true },
-                        { name: 'status', type: 'string', required: true },
-                        { name: 'addedAt', type: 'Date', required: true },
-                    ],
-                    source: 'internal',
-                    metadata: { version: 1 },
-                },
-                {
-                    type: 'event',
-                    name: 'TodoMarkedInProgress',
-                    fields: [
-                        { name: 'todoId', type: 'string', required: true },
-                        { name: 'markedAt', type: 'Date', required: true },
-                    ],
-                    source: 'internal',
-                    metadata: { version: 1 },
-                },
-                {
-                    type: 'event',
-                    name: 'TodoMarkedComplete',
-                    fields: [
-                        { name: 'todoId', type: 'string', required: true },
-                        { name: 'completedAt', type: 'Date', required: true },
-                    ],
-                    source: 'internal',
-                    metadata: { version: 1 },
-                },
-                {
-                    type: 'state',
-                    name: 'TodoListSummary',
-                    fields: [
-                        { name: 'summaryId', type: 'string', required: true },
-                        { name: 'totalTodos', type: 'number', required: true },
-                        { name: 'pendingCount', type: 'number', required: true },
-                        { name: 'inProgressCount', type: 'number', required: true },
-                        { name: 'completedCount', type: 'number', required: true },
-                        { name: 'completionPercentage', type: 'number', required: true },
-                    ],
-                    metadata: { version: 1 },
-                },
-            ],
-            integrations: [],
-        };
-        const code = await modelToNarrative(modelWithEmptyWhen);
-        expect(code).toEqual(`import { example, narrative, query, rule, specs } from '@auto-engineer/narrative';
-import type { Event, State } from '@auto-engineer/narrative';
-type TodoAdded = Event<
-  'TodoAdded',
-  {
-    todoId: string;
-    description: string;
-    status: string;
-    addedAt: Date;
-  }
->;
-type TodoMarkedInProgress = Event<
-  'TodoMarkedInProgress',
-  {
-    todoId: string;
-    markedAt: Date;
-  }
->;
-type TodoMarkedComplete = Event<
-  'TodoMarkedComplete',
-  {
-    todoId: string;
-    completedAt: Date;
-  }
->;
-type TodoListSummary = State<
-  'TodoListSummary',
-  {
-    summaryId: string;
-    totalTodos: number;
-    pendingCount: number;
-    inProgressCount: number;
-    completedCount: number;
-    completionPercentage: number;
-  }
->;
-narrative('Todo List Summary', 'TODO-001', () => {
-  query('views completion summary', 'SUMMARY-001').server(() => {
-    specs('Summary Statistics', () => {
-      rule('summary shows overall todo list statistics', 'RULE-SUMMARY', () => {
-        example('calculates summary from multiple todos')
-          .given<TodoAdded>({
-            todoId: 'todo-001',
-            description: 'Buy groceries',
-            status: 'pending',
-            addedAt: new Date('2030-01-01T09:00:00.000Z'),
-          })
-          .and<TodoAdded>({
-            todoId: 'todo-002',
-            description: 'Write report',
-            status: 'pending',
-            addedAt: new Date('2030-01-01T09:10:00.000Z'),
-          })
-          .and<TodoMarkedInProgress>({ todoId: 'todo-001', markedAt: new Date('2030-01-01T10:00:00.000Z') })
-          .and<TodoMarkedComplete>({ todoId: 'todo-002', completedAt: new Date('2030-01-01T11:00:00.000Z') })
-          .then<TodoListSummary>({
-            summaryId: 'main-summary',
-            totalTodos: 2,
-            pendingCount: 0,
-            inProgressCount: 1,
-            completedCount: 1,
-            completionPercentage: 50,
-          });
-      });
-    });
-  });
-});
-`);
-        expect(code).not.toContain('.when({})');
-        expect(code).not.toContain('.when<');
-    });
-    describe('projection DSL generation', () => {
-        it('should generate fromSingletonProjection for singleton projections', async () => {
-            const modelWithSingletonProjection = {
-                variant: 'specs',
-                narratives: [
-                    {
-                        name: 'Todo Summary Flow',
-                        id: 'TODO-SUMMARY',
-                        slices: [
-                            {
-                                name: 'views todo summary',
-                                id: 'SUMMARY-SLICE',
-                                type: 'query',
-                                client: {
-                                    description: 'Summary client',
-                                },
-                                server: {
-                                    description: 'Summary server',
-                                    data: [
-                                        {
-                                            target: {
-                                                type: 'State',
-                                                name: 'TodoListSummary',
-                                            },
-                                            origin: {
-                                                type: 'projection',
-                                                name: 'TodoSummary',
-                                                singleton: true,
-                                            },
-                                        },
-                                    ],
-                                    specs: {
-                                        name: 'Summary Rules',
-                                        rules: [],
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                ],
-                messages: [
-                    {
-                        type: 'state',
-                        name: 'TodoListSummary',
-                        fields: [
-                            { name: 'summaryId', type: 'string', required: true },
-                            { name: 'totalTodos', type: 'number', required: true },
-                        ],
-                        metadata: { version: 1 },
-                    },
-                ],
-                integrations: [],
-            };
-            const code = await modelToNarrative(modelWithSingletonProjection);
-            expect(code).toEqual(`import { data, narrative, query, source, specs } from '@auto-engineer/narrative';
-import type { State } from '@auto-engineer/narrative';
-type TodoListSummary = State<
-  'TodoListSummary',
-  {
-    summaryId: string;
-    totalTodos: number;
-  }
->;
-narrative('Todo Summary Flow', 'TODO-SUMMARY', () => {
-  query('views todo summary', 'SUMMARY-SLICE').server(() => {
-    data([source().state('TodoListSummary').fromSingletonProjection('TodoSummary')]);
-    specs('Summary Rules', () => {});
-  });
-});
-`);
-        });
-        it('should generate fromProjection with single idField for regular projections', async () => {
-            const modelWithRegularProjection = {
-                variant: 'specs',
-                narratives: [
-                    {
-                        name: 'Todo Flow',
-                        id: 'TODO-FLOW',
-                        slices: [
-                            {
-                                name: 'views todo',
-                                id: 'TODO-SLICE',
-                                type: 'query',
-                                client: {
-                                    description: 'Todo client',
-                                },
-                                server: {
-                                    description: 'Todo server',
-                                    data: [
-                                        {
-                                            target: {
-                                                type: 'State',
-                                                name: 'TodoState',
-                                            },
-                                            origin: {
-                                                type: 'projection',
-                                                name: 'Todos',
-                                                idField: 'todoId',
-                                            },
-                                        },
-                                    ],
-                                    specs: {
-                                        name: 'Todo Rules',
-                                        rules: [],
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                ],
-                messages: [
-                    {
-                        type: 'state',
-                        name: 'TodoState',
-                        fields: [
-                            { name: 'todoId', type: 'string', required: true },
-                            { name: 'description', type: 'string', required: true },
-                        ],
-                        metadata: { version: 1 },
-                    },
-                ],
-                integrations: [],
-            };
-            const code = await modelToNarrative(modelWithRegularProjection);
-            expect(code).toEqual(`import { data, narrative, query, source, specs } from '@auto-engineer/narrative';
-import type { State } from '@auto-engineer/narrative';
-type TodoState = State<
-  'TodoState',
-  {
-    todoId: string;
-    description: string;
-  }
->;
-narrative('Todo Flow', 'TODO-FLOW', () => {
-  query('views todo', 'TODO-SLICE').server(() => {
-    data([source().state('TodoState').fromProjection('Todos', 'todoId')]);
-    specs('Todo Rules', () => {});
-  });
-});
-`);
-        });
-        it('should generate fromCompositeProjection with array idField for composite key projections', async () => {
-            const modelWithCompositeProjection = {
-                variant: 'specs',
-                narratives: [
-                    {
-                        name: 'User Project Flow',
-                        id: 'USER-PROJECT-FLOW',
-                        slices: [
-                            {
-                                name: 'views user project',
-                                id: 'USER-PROJECT-SLICE',
-                                type: 'query',
-                                client: {
-                                    description: 'User project client',
-                                },
-                                server: {
-                                    description: 'User project server',
-                                    data: [
-                                        {
-                                            target: {
-                                                type: 'State',
-                                                name: 'UserProjectState',
-                                            },
-                                            origin: {
-                                                type: 'projection',
-                                                name: 'UserProjects',
-                                                idField: ['userId', 'projectId'],
-                                            },
-                                        },
-                                    ],
-                                    specs: {
-                                        name: 'User Project Rules',
-                                        rules: [],
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                ],
-                messages: [
-                    {
-                        type: 'state',
-                        name: 'UserProjectState',
-                        fields: [
-                            { name: 'userId', type: 'string', required: true },
-                            { name: 'projectId', type: 'string', required: true },
-                            { name: 'role', type: 'string', required: true },
-                        ],
-                        metadata: { version: 1 },
-                    },
-                ],
-                integrations: [],
-            };
-            const code = await modelToNarrative(modelWithCompositeProjection);
-            expect(code).toEqual(`import { data, narrative, query, source, specs } from '@auto-engineer/narrative';
-import type { State } from '@auto-engineer/narrative';
-type UserProjectState = State<
-  'UserProjectState',
-  {
-    userId: string;
-    projectId: string;
-    role: string;
-  }
->;
-narrative('User Project Flow', 'USER-PROJECT-FLOW', () => {
-  query('views user project', 'USER-PROJECT-SLICE').server(() => {
-    data([source().state('UserProjectState').fromCompositeProjection('UserProjects', ['userId', 'projectId'])]);
-    specs('User Project Rules', () => {});
-  });
-});
-`);
-        });
-        it('should generate all three projection types in a single narrative', async () => {
-            const modelWithAllProjectionTypes = {
-                variant: 'specs',
-                narratives: [
-                    {
-                        name: 'All Projection Types',
-                        id: 'ALL-PROJ',
-                        slices: [
-                            {
-                                name: 'views summary',
-                                id: 'SUMMARY-SLICE',
-                                type: 'query',
-                                client: {
-                                    description: 'Summary client',
-                                },
-                                server: {
-                                    description: 'Summary server',
-                                    data: [
-                                        {
-                                            target: {
-                                                type: 'State',
-                                                name: 'TodoListSummary',
-                                            },
-                                            origin: {
-                                                type: 'projection',
-                                                name: 'TodoSummary',
-                                                singleton: true,
-                                            },
-                                        },
-                                    ],
-                                    specs: {
-                                        name: 'Summary Rules',
-                                        rules: [],
-                                    },
-                                },
-                            },
-                            {
-                                name: 'views todo',
-                                id: 'TODO-SLICE',
-                                type: 'query',
-                                client: {
-                                    description: 'Todo client',
-                                },
-                                server: {
-                                    description: 'Todo server',
-                                    data: [
-                                        {
-                                            target: {
-                                                type: 'State',
-                                                name: 'TodoState',
-                                            },
-                                            origin: {
-                                                type: 'projection',
-                                                name: 'Todos',
-                                                idField: 'todoId',
-                                            },
-                                        },
-                                    ],
-                                    specs: {
-                                        name: 'Todo Rules',
-                                        rules: [],
-                                    },
-                                },
-                            },
-                            {
-                                name: 'views user project todos',
-                                id: 'USER-PROJECT-SLICE',
-                                type: 'query',
-                                client: {
-                                    description: 'User project client',
-                                },
-                                server: {
-                                    description: 'User project server',
-                                    data: [
-                                        {
-                                            target: {
-                                                type: 'State',
-                                                name: 'UserProjectTodos',
-                                            },
-                                            origin: {
-                                                type: 'projection',
-                                                name: 'UserProjectTodos',
-                                                idField: ['userId', 'projectId'],
-                                            },
-                                        },
-                                    ],
-                                    specs: {
-                                        name: 'User Project Rules',
-                                        rules: [],
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                ],
-                messages: [
-                    {
-                        type: 'state',
-                        name: 'TodoListSummary',
-                        fields: [
-                            { name: 'summaryId', type: 'string', required: true },
-                            { name: 'totalTodos', type: 'number', required: true },
-                        ],
-                        metadata: { version: 1 },
-                    },
-                    {
-                        type: 'state',
-                        name: 'TodoState',
-                        fields: [
-                            { name: 'todoId', type: 'string', required: true },
-                            { name: 'description', type: 'string', required: true },
-                        ],
-                        metadata: { version: 1 },
-                    },
-                    {
-                        type: 'state',
-                        name: 'UserProjectTodos',
-                        fields: [
-                            { name: 'userId', type: 'string', required: true },
-                            { name: 'projectId', type: 'string', required: true },
-                            { name: 'todos', type: 'Array<string>', required: true },
-                        ],
-                        metadata: { version: 1 },
-                    },
-                ],
-                integrations: [],
-            };
-            const code = await modelToNarrative(modelWithAllProjectionTypes);
-            expect(code).toEqual(`import { data, narrative, query, source, specs } from '@auto-engineer/narrative';
-import type { State } from '@auto-engineer/narrative';
-type TodoListSummary = State<
-  'TodoListSummary',
-  {
-    summaryId: string;
-    totalTodos: number;
-  }
->;
-type TodoState = State<
-  'TodoState',
-  {
-    todoId: string;
-    description: string;
-  }
->;
-type UserProjectTodos = State<
-  'UserProjectTodos',
-  {
-    userId: string;
-    projectId: string;
-    todos: string[];
-  }
->;
-narrative('All Projection Types', 'ALL-PROJ', () => {
-  query('views summary', 'SUMMARY-SLICE').server(() => {
-    data([source().state('TodoListSummary').fromSingletonProjection('TodoSummary')]);
-    specs('Summary Rules', () => {});
-  });
-  query('views todo', 'TODO-SLICE').server(() => {
-    data([source().state('TodoState').fromProjection('Todos', 'todoId')]);
-    specs('Todo Rules', () => {});
-  });
-  query('views user project todos', 'USER-PROJECT-SLICE').server(() => {
-    data([source().state('UserProjectTodos').fromCompositeProjection('UserProjectTodos', ['userId', 'projectId'])]);
-    specs('User Project Rules', () => {});
-  });
-});
-`);
-        });
-    });
-});
-//# sourceMappingURL=model-to-narrative.specs.js.map