@auto-engineer/narrative 0.20.0 → 0.21.0

package/dist/src/getNarratives.specs.js

@@ -1,11 +1,10 @@
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { InMemoryFileStore } from '@auto-engineer/file-store';
-import { NodeFileStore } from '@auto-engineer/file-store/node';
 import { beforeEach, describe, expect, it } from 'vitest';
-import { getNarratives } from './getNarratives.js';
-import { modelToNarrative } from './index.js';
 import { modelSchema } from './schema.js';
+import { modelToNarrative } from './index.js';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import { InMemoryFileStore, NodeFileStore } from '@auto-engineer/file-store';
+import { getNarratives } from './getNarratives.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const pattern = /\.(narrative)\.(ts)$/;
@@ -47,56 +46,42 @@ describe('getNarratives', (_mode) => {
             expect(createItemSlice.stream).toBe('item-${id}');
             if (createItemSlice.type === 'command') {
                 expect(createItemSlice.client.specs).toBeDefined();
-                expect(Array.isArray(createItemSlice.client.specs)).toBe(true);
-                expect(createItemSlice.client.specs).toHaveLength(1);
-                expect(createItemSlice.client.specs[0].type).toBe('describe');
-                expect(createItemSlice.client.specs[0].title).toBe('A form that allows users to add items');
-                if (createItemSlice.client.specs[0].type === 'describe') {
-                    expect(createItemSlice.client.specs[0].children).toHaveLength(1);
-                }
+                expect(createItemSlice.client.specs?.name).toBe('A form that allows users to add items');
+                expect(createItemSlice.client.specs?.rules).toHaveLength(1);
                 expect(createItemSlice.server.specs).toBeDefined();
-                expect(Array.isArray(createItemSlice.server.specs)).toBe(true);
-                expect(createItemSlice.server.specs).toHaveLength(1);
-                const spec = createItemSlice.server.specs[0];
-                expect(spec.feature).toBeDefined();
+                const spec = createItemSlice.server.specs;
+                expect(spec.name).toBeDefined();
                 expect(spec.rules).toHaveLength(1);
                 const rule = spec.rules[0];
-                expect(rule.name).toBeDefined();
+                expect(rule.description).toBeDefined();
                 expect(rule.examples).toHaveLength(1);
                 const example = rule.examples[0];
-                expect(example.steps).toBeDefined();
-                expect(example.steps.length).toBeGreaterThanOrEqual(2);
-                const whenStep = example.steps.find((s) => s.keyword === 'When');
-                const thenStep = example.steps.find((s) => s.keyword === 'Then');
-                expect(whenStep).toBeDefined();
-                expect(thenStep).toBeDefined();
-                if (whenStep && 'text' in whenStep) {
-                    expect(whenStep.text).toBe('CreateItem');
-                    expect(whenStep.docString).toMatchObject({
+                expect(typeof example.when === 'object' && !Array.isArray(example.when)).toBe(true);
+                if (typeof example.when === 'object' && !Array.isArray(example.when)) {
+                    if ('commandRef' in example.when) {
+                        expect(example.when.commandRef).toBe('CreateItem');
+                    }
+                    expect(example.when.exampleData).toMatchObject({
                         itemId: 'item_123',
                         description: 'A new item',
                     });
                 }
-                if (thenStep && 'text' in thenStep) {
-                    expect(thenStep.text).toBe('ItemCreated');
-                    expect(thenStep.docString).toMatchObject({
+                expect(example.then).toHaveLength(1);
+                expect(example.then[0]).toMatchObject({
+                    eventRef: 'ItemCreated',
+                    exampleData: {
                         id: 'item_123',
                         description: 'A new item',
                         addedAt: new Date('2024-01-15T10:00:00.000Z'),
-                    });
-                }
+                    },
+                });
             }
             const viewItemSlice = items.slices[1];
             expect(viewItemSlice.type).toBe('query');
             expect(viewItemSlice.name).toBe('view items');
             expect(viewItemSlice.client.specs).toBeDefined();
-            expect(Array.isArray(viewItemSlice.client.specs)).toBe(true);
-            expect(viewItemSlice.client.specs).toHaveLength(1);
-            expect(viewItemSlice.client.specs[0].type).toBe('describe');
-            expect(viewItemSlice.client.specs[0].title).toBe('view Items Screen');
-            if (viewItemSlice.client.specs[0].type === 'describe') {
-                expect(viewItemSlice.client.specs[0].children).toHaveLength(3);
-            }
+            expect(viewItemSlice.client.specs?.name).toBe('view Items Screen');
+            expect(viewItemSlice.client.specs?.rules).toHaveLength(3);
             expect(viewItemSlice.request).toBeDefined();
             expect(viewItemSlice.request).toMatch(/query items\(\$itemId: String!\) {\s+items\(itemId: \$itemId\) {\s+id\s+description\s+}/);
             const data = viewItemSlice?.server?.data;
@@ -106,7 +91,7 @@ describe('getNarratives', (_mode) => {
             expect(data[0].target).toMatchObject({ type: 'State', name: 'items' });
             expect(data[0].origin).toMatchObject({ name: 'ItemsProjection', type: 'projection' });
             const specs = viewItemSlice?.server?.specs;
-            if (specs == null || specs.length === 0 || specs[0].feature === '')
+            if (specs == null || specs.name === '')
                 throw new Error('No specs found in view items slice');
             expect(specs).toBeDefined();
         }
@@ -118,40 +103,31 @@ describe('getNarratives', (_mode) => {
             expect(submitOrderSlice.stream).toBe('order-${orderId}');
             if (submitOrderSlice.type === 'command') {
                 expect(submitOrderSlice.client.specs).toBeDefined();
-                expect(Array.isArray(submitOrderSlice.client.specs)).toBe(true);
-                expect(submitOrderSlice.client.specs).toHaveLength(1);
-                expect(submitOrderSlice.client.specs[0].type).toBe('describe');
-                expect(submitOrderSlice.client.specs[0].title).toBe('Order submission form');
-                if (submitOrderSlice.client.specs[0].type === 'describe') {
-                    expect(submitOrderSlice.client.specs[0].children).toHaveLength(2);
-                }
+                expect(submitOrderSlice.client.specs?.name).toBe('Order submission form');
+                expect(submitOrderSlice.client.specs?.rules).toHaveLength(2);
                 expect(submitOrderSlice.server.specs).toBeDefined();
-                expect(Array.isArray(submitOrderSlice.server.specs)).toBe(true);
-                expect(submitOrderSlice.server.specs).toHaveLength(1);
-                const spec = submitOrderSlice.server.specs[0];
+                const spec = submitOrderSlice.server.specs;
                 expect(spec.rules).toHaveLength(1);
                 const rule = spec.rules[0];
                 expect(rule.examples).toHaveLength(1);
                 const example = rule.examples[0];
-                expect(example.steps).toBeDefined();
-                expect(example.steps.length).toBeGreaterThanOrEqual(2);
-                const whenStep = example.steps.find((s) => s.keyword === 'When');
-                const thenStep = example.steps.find((s) => s.keyword === 'Then');
-                expect(whenStep).toBeDefined();
-                expect(thenStep).toBeDefined();
-                if (whenStep && 'text' in whenStep) {
-                    expect(whenStep.text).toBe('PlaceOrder');
-                    expect(whenStep.docString).toMatchObject({ productId: 'product_789', quantity: 3 });
+                expect(typeof example.when === 'object' && !Array.isArray(example.when)).toBe(true);
+                if (typeof example.when === 'object' && !Array.isArray(example.when)) {
+                    if ('commandRef' in example.when) {
+                        expect(example.when.commandRef).toBe('PlaceOrder');
+                    }
+                    expect(example.when.exampleData).toMatchObject({ productId: 'product_789', quantity: 3 });
                 }
-                if (thenStep && 'text' in thenStep) {
-                    expect(thenStep.text).toBe('OrderPlaced');
-                    expect(thenStep.docString).toMatchObject({
+                expect(example.then).toHaveLength(1);
+                expect(example.then[0]).toMatchObject({
+                    eventRef: 'OrderPlaced',
+                    exampleData: {
                         orderId: 'order_001',
                         productId: 'product_789',
                         quantity: 3,
                         placedAt: new Date('2024-01-20T10:00:00.000Z'),
-                    });
-                }
+                    },
+                });
             }
         }
         const messages = schemas.messages;
@@ -205,15 +181,16 @@ describe('getNarratives', (_mode) => {
             if (slice.type === 'react') {
                 expect(slice.server).toBeDefined();
                 expect(slice.server.specs).toBeDefined();
-                expect(Array.isArray(slice.server.specs)).toBe(true);
-                expect(slice.server.specs.length).toBeGreaterThanOrEqual(1);
-                const spec = slice.server.specs[0];
+                expect(typeof slice.server.specs === 'object' && !Array.isArray(slice.server.specs)).toBe(true);
+                const spec = slice.server.specs;
                 expect(spec.rules).toBeDefined();
                 expect(Array.isArray(spec.rules)).toBe(true);
                 spec.rules.forEach((rule) => {
                     rule.examples.forEach((example) => {
-                        expect(example.steps).toBeDefined();
-                        expect(Array.isArray(example.steps)).toBe(true);
+                        expect(example.when).toBeDefined();
+                        expect(Array.isArray(example.when)).toBe(true);
+                        expect(example.then).toBeDefined();
+                        expect(Array.isArray(example.then)).toBe(true);
                     });
                 });
             }
@@ -266,10 +243,10 @@ describe('getNarratives', (_mode) => {
         const commandSlice = testFlowWithIds.slices.find((s) => s.name === 'Create test item');
         if (commandSlice?.type !== 'command')
             return;
-        expect(commandSlice.server.specs[0].rules).toHaveLength(2);
-        const rule1 = commandSlice.server.specs[0].rules.find((r) => r.name === 'Valid test items should be created successfully');
+        expect(commandSlice.server.specs.rules).toHaveLength(2);
+        const rule1 = commandSlice.server.specs.rules.find((r) => r.description === 'Valid test items should be created successfully');
         expect(rule1?.id).toBe('RULE-001');
-        const rule2 = commandSlice.server.specs[0].rules.find((r) => r.name === 'Invalid test items should be rejected');
+        const rule2 = commandSlice.server.specs.rules.find((r) => r.description === 'Invalid test items should be rejected');
         expect(rule2?.id).toBe('RULE-002');
     });
     it('should have ids for query slice rules', async () => {
@@ -281,8 +258,8 @@ describe('getNarratives', (_mode) => {
         const querySlice = testFlowWithIds.slices.find((s) => s.name === 'Get test items');
         if (querySlice?.type !== 'query')
             return;
-        expect(querySlice.server.specs[0].rules).toHaveLength(1);
-        const rule3 = querySlice.server.specs[0].rules.find((r) => r.name === 'Items should be retrievable after creation');
+        expect(querySlice.server.specs.rules).toHaveLength(1);
+        const rule3 = querySlice.server.specs.rules.find((r) => r.description === 'Items should be retrievable after creation');
         expect(rule3?.id).toBe('RULE-003');
     });
     it('should have ids for react slice rules', async () => {
@@ -294,8 +271,8 @@ describe('getNarratives', (_mode) => {
         const reactSlice = testFlowWithIds.slices.find((s) => s.name === 'React to test event');
         if (reactSlice?.type !== 'react')
             return;
-        expect(reactSlice.server.specs[0].rules).toHaveLength(1);
-        const rule4 = reactSlice.server.specs[0].rules.find((r) => r.name === 'System should react to test item creation');
+        expect(reactSlice.server.specs.rules).toHaveLength(1);
+        const rule4 = reactSlice.server.specs.rules.find((r) => r.description === 'System should react to test item creation');
         expect(rule4?.id).toBe('RULE-004');
     });
     it('should handle when examples correctly', async () => {
@@ -311,10 +288,14 @@ describe('getNarratives', (_mode) => {
             const submitSlice = questionnaireFlow.slices.find((s) => s.name === 'submits the questionnaire');
             expect(submitSlice?.type).toBe('command');
             if (submitSlice?.type === 'command') {
-                const example = submitSlice.server?.specs?.[0]?.rules[0]?.examples[0];
-                const whenStep = example?.steps?.find((s) => s.keyword === 'When');
-                if (whenStep && 'text' in whenStep) {
-                    expect(whenStep.text).toBe('SubmitQuestionnaire');
+                const example = submitSlice.server?.specs?.rules[0]?.examples[0];
+                if (example !== null &&
+                    example !== undefined &&
+                    typeof example.when === 'object' &&
+                    example.when !== null &&
+                    !Array.isArray(example.when) &&
+                    'commandRef' in example.when) {
+                    expect(example.when.commandRef).toBe('SubmitQuestionnaire');
                 }
             }
         }
@@ -332,13 +313,13 @@ describe('getNarratives', (_mode) => {
     it('should handle experience slice with client specs', async () => {
         const memoryVfs = new InMemoryFileStore();
         const flowWithExperienceContent = `
-import { flow, experience, it, specs } from '@auto-engineer/narrative';
+import { flow, experience, should, specs } from '@auto-engineer/narrative';
 
 flow('Test Experience Flow', () => {
-  experience('Homepage', 'H1a4Bn6Cy').client(() => {
+  experience('Homepage', 'AUTO-H1a4Bn6Cy').client(() => {
     specs(() => {
-      it('show a hero section with a welcome message');
-      it('allow user to start the questionnaire');
+      should('show a hero section with a welcome message');
+      should('allow user to start the questionnaire');
     });
   });
 });
@@ -355,24 +336,26 @@ flow('Test Experience Flow', () => {
             if (homepageSlice?.type === 'experience') {
                 expect(homepageSlice.client).toBeDefined();
                 expect(homepageSlice.client.specs).toBeDefined();
-                expect(Array.isArray(homepageSlice.client.specs)).toBe(true);
-                expect(homepageSlice.client.specs).toHaveLength(2);
-                expect(homepageSlice.client.specs[0].type).toBe('it');
-                expect(homepageSlice.client.specs[0].title).toBe('show a hero section with a welcome message');
-                expect(homepageSlice.client.specs[1].type).toBe('it');
-                expect(homepageSlice.client.specs[1].title).toBe('allow user to start the questionnaire');
+                expect(homepageSlice.client.specs?.rules).toBeDefined();
+                expect(homepageSlice.client.specs?.rules).toHaveLength(2);
+                const rules = homepageSlice.client.specs?.rules;
+                if (rules && Array.isArray(rules)) {
+                    expect(rules).toHaveLength(2);
+                    expect(rules[0]).toBe('show a hero section with a welcome message');
+                    expect(rules[1]).toBe('allow user to start the questionnaire');
+                }
             }
         }
     });
     it('simulates browser execution with transpiled CommonJS code', async () => {
         const memoryVfs = new InMemoryFileStore();
         const flowContent = `
-import { flow, experience, it, specs } from '@auto-engineer/narrative';
+import { flow, experience, should, specs } from '@auto-engineer/narrative';
 
 flow('Browser Test Flow', () => {
   experience('HomePage').client(() => {
     specs(() => {
-      it('render correctly');
+      should('render correctly');
     });
   });
 });
@@ -392,10 +375,8 @@ flow('Browser Test Flow', () => {
         if (slice.type === 'experience') {
             expect(slice.client).toBeDefined();
             expect(slice.client.specs).toBeDefined();
-            expect(Array.isArray(slice.client.specs)).toBe(true);
-            expect(slice.client.specs).toHaveLength(1);
-            expect(slice.client.specs[0].type).toBe('it');
-            expect(slice.client.specs[0].title).toBe('render correctly');
+            expect(slice.client.specs?.rules).toHaveLength(1);
+            expect(slice.client.specs?.rules?.[0]).toBe('render correctly');
         }
     });
     it('handles experience slice with ES module interop correctly', async () => {
@@ -405,8 +386,8 @@ flow('Browser Test Flow', () => {
         const flowContent = `
 import { flow, experience } from '@auto-engineer/narrative';
 
-flow('Questionnaires', 'Q9m2Kp4Lx', () => {
-  experience('Homepage', 'H1a4Bn6Cy').client(() => {});
+flow('Questionnaires', 'AUTO-Q9m2Kp4Lx', () => {
+  experience('Homepage', 'AUTO-H1a4Bn6Cy').client(() => {});
 });
       `;
         await memoryVfs.write('/browser/questionnaires.narrative.ts', new TextEncoder().encode(flowContent));
@@ -541,7 +522,7 @@ flow('questionnaires-test', () => {
         expect(querySlice?.type).toBe('query');
         if (querySlice?.type !== 'query')
             return;
-        const example = querySlice.server.specs[0].rules[0]?.examples[0];
+        const example = querySlice.server.specs.rules[0]?.examples[0];
         expect(example).toBeDefined();
         if (example !== null && example !== undefined) {
             validateMixedGivenTypes(example);
@@ -580,7 +561,7 @@ flow('questionnaires-test', () => {
         const model = await createQuestionnaireBugTestModel();
         validateQuestionnaireBugFix(model);
     });
-    it('should convert all given events to eventRef', async () => {
+    it('should convert all given events to eventRef', async function () {
         const memoryVfs = new InMemoryFileStore();
         const todoSummaryFlowContent = `
 import { flow, query, specs, rule, example, type Event, type State } from '@auto-engineer/narrative';
@@ -680,37 +661,39 @@ flow('Todo List', () => {
         expect(summarySlice?.type).toBe('query');
         if (summarySlice?.type !== 'query')
             return;
-        const example = summarySlice.server.specs[0].rules[0]?.examples[0];
+        const example = summarySlice.server.specs.rules[0]?.examples[0];
         expect(example).toBeDefined();
-        expect(example.steps).toBeDefined();
-        expect(Array.isArray(example.steps)).toBe(true);
-        const givenAndSteps = example.steps.filter((s) => s.keyword === 'Given' || s.keyword === 'And');
-        expect(givenAndSteps).toHaveLength(5);
-        validateGivenItemsHaveEventRef(givenAndSteps);
-        validateTodoEventRefs(givenAndSteps);
+        expect(example.given).toBeDefined();
+        expect(Array.isArray(example.given)).toBe(true);
+        expect(example.given).toHaveLength(5);
+        if (!example.given) {
+            throw new Error('expected example.given to be defined');
+        }
+        validateGivenItemsHaveEventRef(example.given);
+        validateTodoEventRefs(example.given);
         validateTodoMessages(model);
     });
 });
-function validateGivenItemsHaveEventRef(givenSteps) {
-    for (let i = 0; i < givenSteps.length; i++) {
-        const step = givenSteps[i];
-        if (typeof step === 'object' && step !== null) {
-            expect(step.keyword === 'Given' || step.keyword === 'And').toBe(true);
-            expect('text' in step).toBe(true);
+function validateGivenItemsHaveEventRef(given) {
+    for (let i = 0; i < given.length; i++) {
+        const givenItem = given[i];
+        if (typeof givenItem === 'object' && givenItem !== null) {
+            expect('eventRef' in givenItem).toBe(true);
+            expect('stateRef' in givenItem).toBe(false);
         }
     }
 }
-function expectStepText(step, expectedType) {
-    if (step !== null && step !== undefined && typeof step === 'object' && 'text' in step) {
-        expect(step.text).toBe(expectedType);
+function expectEventRef(item, expectedType) {
+    if (item !== null && item !== undefined && typeof item === 'object' && 'eventRef' in item) {
+        expect(item.eventRef).toBe(expectedType);
     }
 }
-function validateTodoEventRefs(givenSteps) {
-    expectStepText(givenSteps[0], 'TodoAdded');
-    expectStepText(givenSteps[1], 'TodoAdded');
-    expectStepText(givenSteps[2], 'TodoAdded');
-    expectStepText(givenSteps[3], 'TodoMarkedInProgress');
-    expectStepText(givenSteps[4], 'TodoMarkedComplete');
+function validateTodoEventRefs(given) {
+    expectEventRef(given[0], 'TodoAdded');
+    expectEventRef(given[1], 'TodoAdded');
+    expectEventRef(given[2], 'TodoAdded');
+    expectEventRef(given[3], 'TodoMarkedInProgress');
+    expectEventRef(given[4], 'TodoMarkedComplete');
 }
 function validateTodoMessages(model) {
     const todoAddedEvent = model.messages.find((m) => m.name === 'TodoAdded');
@@ -730,10 +713,14 @@ function validateSubmitQuestionnaireCommand(questionnaireFlow) {
     const submitSlice = questionnaireFlow.slices.find((s) => s.name === 'submits questionnaire');
     expect(submitSlice?.type).toBe('command');
     if (submitSlice?.type === 'command') {
-        const example = submitSlice.server?.specs?.[0]?.rules[0]?.examples[0];
-        const whenStep = example?.steps?.find((s) => s.keyword === 'When');
-        if (whenStep && 'text' in whenStep) {
-            expect(whenStep.text).toBe('SubmitQuestionnaire');
+        const example = submitSlice.server?.specs?.rules[0]?.examples[0];
+        if (example !== null &&
+            example !== undefined &&
+            typeof example.when === 'object' &&
+            example.when !== null &&
+            !Array.isArray(example.when) &&
+            'commandRef' in example.when) {
+            expect(example.when.commandRef).toBe('SubmitQuestionnaire');
         }
     }
 }
@@ -744,11 +731,15 @@ function validateQuestionAnsweredEvent(model) {
 function validateGivenSectionEventRefs(questionnaireFlow) {
     const viewsSlice = questionnaireFlow.slices.find((s) => s.name === 'views progress');
     if (viewsSlice?.type === 'query') {
-        const example = viewsSlice.server?.specs?.[0]?.rules[0]?.examples[0];
-        if (example?.steps !== undefined && Array.isArray(example.steps)) {
-            const givenStep = example.steps.find((s) => s.keyword === 'Given');
-            if (givenStep && 'text' in givenStep) {
-                expect(givenStep.text).toBe('QuestionAnswered');
+        const example = viewsSlice.server?.specs?.rules[0]?.examples[0];
+        if (example?.given && Array.isArray(example.given) && example.given.length > 0) {
+            const givenItem = example.given[0];
+            if (typeof givenItem === 'object' && givenItem !== null) {
+                expect('eventRef' in givenItem).toBe(true);
+                expect('stateRef' in givenItem).toBe(false);
+                if ('eventRef' in givenItem) {
+                    expect(givenItem.eventRef).toBe('QuestionAnswered');
+                }
             }
         }
     }
@@ -760,43 +751,45 @@ function validateCurrentQuestionIdType(model) {
     expect(currentQuestionIdField?.type).toBe('string | null');
 }
 function validateMixedGivenTypes(example) {
-    expect(example.name).toBe('system with 2 items reaches max of 2');
-    expect(example.steps).toBeDefined();
-    expect(Array.isArray(example.steps)).toBe(true);
-    const givenSteps = example.steps.filter((s) => s.keyword === 'Given' || s.keyword === 'And');
-    expect(givenSteps).toHaveLength(4);
-    const firstGiven = givenSteps[0];
-    expect('text' in firstGiven).toBe(true);
-    if ('text' in firstGiven) {
-        expect(firstGiven.text).toBe('ConfigState');
+    expect(example.description).toBe('system with 2 items reaches max of 2');
+    expect(example.given).toBeDefined();
+    expect(Array.isArray(example.given)).toBe(true);
+    if (!example.given)
+        return;
+    expect(example.given).toHaveLength(4);
+    const firstGiven = example.given[0];
+    expect('stateRef' in firstGiven).toBe(true);
+    expect('eventRef' in firstGiven).toBe(false);
+    if ('stateRef' in firstGiven) {
+        expect(firstGiven.stateRef).toBe('ConfigState');
     }
-    const secondGiven = givenSteps[1];
-    expect('text' in secondGiven).toBe(true);
-    if ('text' in secondGiven) {
-        expect(secondGiven.text).toBe('SystemInitialized');
+    const secondGiven = example.given[1];
+    expect('eventRef' in secondGiven).toBe(true);
+    if ('eventRef' in secondGiven) {
+        expect(secondGiven.eventRef).toBe('SystemInitialized');
     }
-    const thirdGiven = givenSteps[2];
-    expect('text' in thirdGiven).toBe(true);
-    if ('text' in thirdGiven) {
-        expect(thirdGiven.text).toBe('ItemAdded');
+    const thirdGiven = example.given[2];
+    expect('eventRef' in thirdGiven).toBe(true);
+    if ('eventRef' in thirdGiven) {
+        expect(thirdGiven.eventRef).toBe('ItemAdded');
     }
-    const fourthGiven = givenSteps[3];
-    expect('text' in fourthGiven).toBe(true);
-    if ('text' in fourthGiven) {
-        expect(fourthGiven.text).toBe('ItemAdded');
+    const fourthGiven = example.given[3];
+    expect('eventRef' in fourthGiven).toBe(true);
+    if ('eventRef' in fourthGiven) {
+        expect(fourthGiven.eventRef).toBe('ItemAdded');
     }
 }
 function validateEmptyWhenClause(example) {
-    const whenStep = example.steps.find((s) => s.keyword === 'When');
-    expect(whenStep).toBeUndefined();
+    expect(example.when).toBeUndefined();
 }
 function validateThenClause(example) {
-    const thenSteps = example.steps.filter((s) => s.keyword === 'Then');
-    expect(thenSteps).toHaveLength(1);
-    const thenOutcome = thenSteps[0];
-    expect('text' in thenOutcome).toBe(true);
-    if ('text' in thenOutcome) {
-        expect(thenOutcome.text).toBe('SystemStatus');
+    expect(example.then).toBeDefined();
+    expect(Array.isArray(example.then)).toBe(true);
+    expect(example.then).toHaveLength(1);
+    const thenOutcome = example.then[0];
+    expect('stateRef' in thenOutcome).toBe(true);
+    if ('stateRef' in thenOutcome) {
+        expect(thenOutcome.stateRef).toBe('SystemStatus');
     }
 }
 function validateMixedGivenTypeMessages(model) {
@@ -827,8 +820,7 @@ import {
   query,
   experience,
   flow,
-  describe,
-  it,
+  should,
   specs,
   rule,
   example,
@@ -876,11 +868,11 @@ type SubmitQuestionnaire = Command<
   }
 >;
 
-flow('Questionnaires', 'Q9m2Kp4Lx', () => {
-  command('sends the questionnaire link', 'S2b5Cp7Dz')
+flow('Questionnaires', 'AUTO-Q9m2Kp4Lx', () => {
+  command('sends the questionnaire link', 'AUTO-S2b5Cp7Dz')
     .server(() => {
       specs(() => {
-        rule('questionnaire link is sent to participant', 'r0A1Bo8X', () => {
+        rule('questionnaire link is sent to participant', 'AUTO-r0A1Bo8X', () => {
           example('sends the questionnaire link successfully')
             .when<SendQuestionnaireLink>({
               questionnaireId: 'q-001',
@@ -904,16 +896,16 @@ flow('Questionnaires', 'Q9m2Kp4Lx', () => {
       }
     \`)
     .client(() => {
-      describe('Questionnaire Link', () => {
-        it('display a confirmation message when the link is sent');
-        it('handle errors when the link cannot be sent');
+      specs('Questionnaire Link', () => {
+        should('display a confirmation message when the link is sent');
+        should('handle errors when the link cannot be sent');
       });
     });
 
-  command('submits the questionnaire', 'T5k9Jw3V')
+  command('submits the questionnaire', 'AUTO-T5k9Jw3V')
     .server(() => {
       specs(() => {
-        rule('questionnaire allowed to be submitted when all questions are answered', 'r4H0Lx4U', () => {
+        rule('questionnaire allowed to be submitted when all questions are answered', 'AUTO-r4H0Lx4U', () => {
           example('submits the questionnaire successfully')
             .when<SubmitQuestionnaire>({
               questionnaireId: 'q-001',
@@ -936,8 +928,8 @@ flow('Questionnaires', 'Q9m2Kp4Lx', () => {
       }
     \`)
     .client(() => {
-      describe('Submission Confirmation', () => {
-        it('display a confirmation message upon successful submission');
+      specs('Submission Confirmation', () => {
+        should('display a confirmation message upon successful submission');
       });
     });
 });`;
@@ -967,34 +959,32 @@ function getSubmitSlice(questionnaireFlow) {
     return submitSlice;
 }
 function getSubmitExample(submitSlice) {
-    const rule = submitSlice.server?.specs?.[0]?.rules[0];
+    const rule = submitSlice.server?.specs?.rules[0];
     expect(rule).toBeDefined();
     expect(rule?.examples).toHaveLength(1);
     const example = rule?.examples[0];
-    expect(example?.name).toBe('submits the questionnaire successfully');
+    expect(example?.description).toBe('submits the questionnaire successfully');
     return example;
 }
 function validateSubmitCommandRef(example) {
     const ex = example;
-    expect(ex?.steps).toBeDefined();
-    const whenStep = ex?.steps?.find((s) => s.keyword === 'When');
-    if (whenStep && 'text' in whenStep) {
-        expect(whenStep.text).toBe('SubmitQuestionnaire');
-        expect(whenStep.text).not.toBe('SendQuestionnaireLink');
+    expect(ex?.when).toBeDefined();
+    if (typeof ex?.when === 'object' && ex.when !== null && !Array.isArray(ex.when) && 'commandRef' in ex.when) {
+        expect(ex.when.commandRef).toBe('SubmitQuestionnaire');
+        expect(ex.when.commandRef).not.toBe('SendQuestionnaireLink');
     }
     else {
-        throw new Error('Expected steps to have a When step with text property');
+        throw new Error('Expected when to have commandRef property');
     }
 }
 function validateLinkSliceCommandRef(questionnaireFlow) {
     const linkSlice = questionnaireFlow.slices.find((s) => s.name === 'sends the questionnaire link');
     expect(linkSlice?.type).toBe('command');
     if (linkSlice?.type === 'command') {
-        const linkExample = linkSlice.server?.specs?.[0]?.rules[0]?.examples[0];
+        const linkExample = linkSlice.server?.specs?.rules[0]?.examples[0];
         const ex = linkExample;
-        const whenStep = ex?.steps?.find((s) => s.keyword === 'When');
-        if (whenStep && 'text' in whenStep) {
-            expect(whenStep.text).toBe('SendQuestionnaireLink');
+        if (typeof ex?.when === 'object' && ex.when !== null && !Array.isArray(ex.when) && 'commandRef' in ex.when) {
+            expect(ex.when.commandRef).toBe('SendQuestionnaireLink');
         }
     }
 }
@@ -1020,19 +1010,17 @@ function getServerSpecsFromSlice(submitSlice) {
     const slice = submitSlice;
     const serverSpecs = slice.server?.specs;
     expect(serverSpecs).toBeDefined();
-    expect(Array.isArray(serverSpecs)).toBe(true);
-    expect(serverSpecs).toHaveLength(1);
-    const firstSpec = serverSpecs[0];
-    expect(firstSpec?.rules).toBeDefined();
-    expect(firstSpec?.rules).toHaveLength(1);
-    return firstSpec;
+    const specs = serverSpecs;
+    expect(specs?.rules).toBeDefined();
+    expect(specs?.rules).toHaveLength(1);
+    return serverSpecs;
 }
 function getFirstRuleFromSpecs(serverSpecs) {
     const specs = serverSpecs;
     const rule = specs?.rules?.[0];
     expect(rule).toBeDefined();
     const r = rule;
-    expect(r?.name).toBe('questionnaire allowed to be submitted when all questions are answered');
+    expect(r?.description).toBe('questionnaire allowed to be submitted when all questions are answered');
     expect(r?.examples).toBeDefined();
     expect(r?.examples).toHaveLength(1);
     return rule;
@@ -1042,35 +1030,34 @@ function getFirstExampleFromRule(rule) {
     const example = r?.examples?.[0];
     expect(example).toBeDefined();
     const ex = example;
-    expect(ex?.name).toBe('submits the questionnaire successfully');
+    expect(ex?.description).toBe('submits the questionnaire successfully');
     return example;
 }
 function validateExampleCommandRef(example) {
     const ex = example;
-    expect(ex?.steps).toBeDefined();
-    const whenStep = ex?.steps?.find((s) => s.keyword === 'When');
-    expect(whenStep).toBeDefined();
-    if (whenStep && 'text' in whenStep) {
-        expect(whenStep.text).toBe('SubmitQuestionnaire');
-        expect(whenStep.text).not.toBe('SendQuestionnaireLink');
-        expect(whenStep.docString).toEqual({
+    expect(ex?.when).toBeDefined();
+    if (typeof ex?.when === 'object' && ex.when !== null && !Array.isArray(ex.when) && 'commandRef' in ex.when) {
+        expect(ex.when.commandRef).toBe('SubmitQuestionnaire');
+        expect(ex.when.commandRef).not.toBe('SendQuestionnaireLink');
+        expect(ex.when.exampleData).toEqual({
             questionnaireId: 'q-001',
             participantId: 'participant-abc',
         });
     }
     else {
-        throw new Error('Expected when step to have text property');
+        throw new Error('Expected when to have commandRef property');
     }
 }
 function validateThenEvents(example) {
     const ex = example;
-    expect(ex?.steps).toBeDefined();
-    const thenSteps = ex?.steps?.filter((s) => s.keyword === 'Then');
-    expect(thenSteps).toHaveLength(1);
-    const thenStep = thenSteps?.[0];
-    if (thenStep && 'text' in thenStep) {
-        expect(thenStep.text).toBe('QuestionnaireSubmitted');
-        expect(thenStep.docString).toEqual({
+    expect(ex?.then).toBeDefined();
+    expect(Array.isArray(ex?.then)).toBe(true);
+    expect(ex?.then).toHaveLength(1);
+    const thenEvent = ex?.then?.[0];
+    if (thenEvent !== null && thenEvent !== undefined && 'eventRef' in thenEvent) {
+        const event = thenEvent;
+        expect(event.eventRef).toBe('QuestionnaireSubmitted');
+        expect(event.exampleData).toEqual({
             questionnaireId: 'q-001',
             participantId: 'participant-abc',
             submittedAt: new Date('2030-01-01T09:00:00.000Z'),