@auto-engineer/narrative 0.13.0 → 0.13.1

package/src/narrative-context.ts

@@ -1,24 +1,20 @@
 import createDebug from 'debug';
 import type { DataSinkItem, DataSourceItem, DataItem, DataSink, DataSource } from './types';
 import type { GivenTypeInfo } from './loader/ts-utils';
-import { Narrative, Slice, Example, CommandSlice, QuerySlice, ExperienceSlice } from './index';
+import { Narrative, Slice, CommandSlice, QuerySlice, ExperienceSlice } from './index';
 import type { ClientSpecNode } from './schema';
+import type { z } from 'zod';
+import type { StepSchema, ExampleSchema, SpecSchema, RuleSchema } from './schema';
 
-function normalizeContext(context?: Partial<Record<string, string>>): Record<string, string> | undefined {
-  if (!context) return undefined;
-
-  const filtered: Record<string, string> = {};
-  for (const [key, value] of Object.entries(context)) {
-    if (value !== undefined) {
-      filtered[key] = value;
-    }
-  }
-
-  return Object.keys(filtered).length > 0 ? filtered : undefined;
-}
+type Step = z.infer<typeof StepSchema>;
+type Example = z.infer<typeof ExampleSchema>;
+type Spec = z.infer<typeof SpecSchema>;
+type Rule = z.infer<typeof RuleSchema>;
 
 const debug = createDebug('auto:narrative:context:given-types');
 
+type MajorKeyword = 'Given' | 'When' | 'Then';
+
 interface NarrativeContext {
   narrative: Narrative;
   currentSliceIndex: number | null;
@@ -27,13 +23,16 @@ interface NarrativeContext {
   currentRuleIndex: number | null;
   currentExampleIndex: number | null;
   clientSpecStack: ClientSpecNode[];
+  lastMajorKeyword: MajorKeyword | null;
 }
 
 let context: NarrativeContext | null = null;
 let givenTypesByFile: Map<string, GivenTypeInfo[]> = new Map();
 let whenTypesByFile: Map<string, GivenTypeInfo[]> = new Map();
+let thenTypesByFile: Map<string, GivenTypeInfo[]> = new Map();
 const givenCallCounters: Map<string, number> = new Map();
 const whenCallCounters: Map<string, number> = new Map();
+const thenCallCounters: Map<string, number> = new Map();
 
 export function setGivenTypesByFile(types: Map<string, GivenTypeInfo[]>): void {
   const whenTypes = types.get('__whenTypes') as Map<string, GivenTypeInfo[]> | undefined;
@@ -42,9 +41,16 @@ export function setGivenTypesByFile(types: Map<string, GivenTypeInfo[]>): void {
     types.delete('__whenTypes');
   }
 
+  const thenTypes = types.get('__thenTypes') as Map<string, GivenTypeInfo[]> | undefined;
+  if (thenTypes) {
+    thenTypesByFile = thenTypes;
+    types.delete('__thenTypes');
+  }
+
   givenTypesByFile = types;
   givenCallCounters.clear();
   whenCallCounters.clear();
+  thenCallCounters.clear();
 }
 
 export function startNarrative(name: string, id?: string): Narrative {
@@ -52,6 +58,7 @@ export function startNarrative(name: string, id?: string): Narrative {
   if (sourceFile !== null && sourceFile !== undefined && sourceFile !== '') {
     givenCallCounters.set(sourceFile, 0);
     whenCallCounters.set(sourceFile, 0);
+    thenCallCounters.set(sourceFile, 0);
   }
 
   const narrative: Narrative = {
@@ -68,6 +75,7 @@ export function startNarrative(name: string, id?: string): Narrative {
     currentRuleIndex: null,
     currentExampleIndex: null,
     clientSpecStack: [],
+    lastMajorKeyword: null,
   };
   return narrative;
 }
@@ -91,15 +99,20 @@ export function addSlice(slice: Slice): void {
   context.currentSliceIndex = context.narrative.slices.length - 1;
 }
 
-function getServerSpecs(
-  slice: Slice,
-): { name: string; rules: { id?: string; description: string; examples: Example[] }[] } | undefined {
+function getServerSpecs(slice: Slice): Spec[] | undefined {
   if ('server' in slice) {
     return slice.server?.specs;
   }
   return undefined;
 }
 
+function getCurrentSpec(slice: Slice): Spec | undefined {
+  if (!context || context.currentSpecIndex === null) return undefined;
+  const specs = getServerSpecs(slice);
+  if (!specs) return undefined;
+  return specs[context.currentSpecIndex];
+}
+
 function getCurrentExample(slice: Slice): Example | undefined {
   if (
     !context ||
@@ -110,11 +123,10 @@ function getCurrentExample(slice: Slice): Example | undefined {
     return undefined;
   }
 
-  const spec = getServerSpecs(slice);
+  const spec = getCurrentSpec(slice);
   if (!spec) return undefined;
 
-  const objectRules = spec.rules as { id?: string; description: string; examples: Example[] }[];
-  return objectRules[context.currentRuleIndex]?.examples[context.currentExampleIndex];
+  return spec.rules[context.currentRuleIndex]?.examples[context.currentExampleIndex];
 }
 
 export function startClientBlock(slice: Slice): void {
@@ -153,19 +165,19 @@ export function startServerBlock(slice: Slice, description: string = ''): void {
   if (slice.type === 'command') {
     slice.server = {
       description,
-      specs: { name: '', rules: [] },
+      specs: [],
       data: undefined,
     };
   } else if (slice.type === 'query') {
     slice.server = {
       description,
-      specs: { name: '', rules: [] },
+      specs: [],
       data: undefined,
     };
   } else if (slice.type === 'react') {
     slice.server = {
       description: description || undefined,
-      specs: { name: '', rules: [] },
+      specs: [],
       data: undefined,
     };
   }
@@ -179,23 +191,25 @@ export function endServerBlock(): void {
   }
 }
 
-function initializeServerSpecs(slice: Slice, description: string): void {
+function addServerSpec(slice: Slice, feature: string): void {
   if ('server' in slice && slice.server != null) {
-    slice.server.specs = {
-      name: description,
+    const newSpec: Spec = {
+      type: 'gherkin',
+      feature,
       rules: [],
     };
-    if (context) context.currentSpecIndex = 0;
+    slice.server.specs.push(newSpec);
+    if (context) context.currentSpecIndex = slice.server.specs.length - 1;
   }
 }
 
-export function pushSpec(description: string): void {
+export function pushSpec(feature: string): void {
   if (!context || !context.currentSpecTarget) throw new Error('No active spec target');
   const slice = getCurrentSlice();
   if (!slice) throw new Error('No active slice');
 
   if (context.currentSpecTarget === 'server') {
-    initializeServerSpecs(slice, description);
+    addServerSpec(slice, feature);
   }
 }
 
@@ -293,193 +307,107 @@ function stripTypeDiscriminator(items: DataItem[]): (DataSink | DataSource)[] {
   });
 }
 
-export function recordRule(description: string, id?: string): void {
+export function recordRule(name: string, id?: string): void {
   if (!context || context.currentSpecIndex === null) throw new Error('No active spec context');
   const slice = getCurrentSlice();
   if (!slice) throw new Error('No active slice');
 
-  const spec = getServerSpecs(slice);
+  const spec = getCurrentSpec(slice);
   if (!spec) throw new Error('No active specs for current slice');
 
-  const objectRules = spec.rules as { id?: string; description: string; examples: Example[] }[];
-  objectRules.push({
+  const newRule: Rule = {
     id,
-    description,
+    name,
     examples: [],
-  });
-  context.currentRuleIndex = objectRules.length - 1;
+  };
+  spec.rules.push(newRule);
+  context.currentRuleIndex = spec.rules.length - 1;
 }
 
-export function recordExample(description: string): void {
+export function recordExample(name: string, id?: string): void {
   if (!context || context.currentSpecIndex === null || context.currentRuleIndex === null) {
     throw new Error('No active rule context');
   }
   const slice = getCurrentSlice();
   if (!slice) throw new Error('No active slice');
 
-  const spec = getServerSpecs(slice);
+  const spec = getCurrentSpec(slice);
   if (!spec) throw new Error('No active specs for current slice');
 
-  const objectRules = spec.rules as { id?: string; description: string; examples: Example[] }[];
-  const rule = objectRules[context.currentRuleIndex];
-  rule.examples.push({
-    description,
-    then: [],
-  });
-  context.currentExampleIndex = rule.examples.length - 1;
-}
-
-function processItemWithASTMatch(
-  item: unknown,
-  matchingType: import('./loader/ts-utils').GivenTypeInfo,
-  contextParam?: Record<string, string>,
-): { [key: string]: unknown; exampleData: unknown; context?: Record<string, string> } {
-  const refType = getRefTypeFromClassification(matchingType.classification);
-  return {
-    [refType]: matchingType.typeName,
-    exampleData: ensureMessageFormat(item).data,
-    ...(contextParam && { context: contextParam }),
+  const rule = spec.rules[context.currentRuleIndex];
+  const newExample: Example = {
+    id,
+    name,
+    steps: [],
   };
+  rule.examples.push(newExample);
+  context.currentExampleIndex = rule.examples.length - 1;
+  context.lastMajorKeyword = null;
 }
 
-function processGivenItems(
-  data: unknown[],
-  contextParam?: Record<string, string>,
-): Array<{ [key: string]: unknown; exampleData: unknown; context?: Record<string, string> }> {
-  const sourceFile = context?.narrative.sourceFile;
+type StepKeyword = 'Given' | 'When' | 'Then' | 'And';
+type ErrorType = 'IllegalStateError' | 'ValidationError' | 'NotFoundError';
 
-  return data.map((item) => {
-    if (sourceFile !== null && sourceFile !== undefined && sourceFile !== '') {
-      const currentCount = givenCallCounters.get(sourceFile) ?? 0;
-      givenCallCounters.set(sourceFile, currentCount + 1);
-
-      // Look up AST-extracted type info by ordinal position
-      const givenTypes = givenTypesByFile.get(sourceFile) || [];
-      const matchingType = givenTypes[currentCount];
-
-      if (matchingType !== null && matchingType !== undefined) {
-        debug('AST match for %s at ordinal %d: %s', sourceFile, currentCount, matchingType.typeName);
-        return processItemWithASTMatch(item, matchingType, contextParam);
-      } else {
-        debug('No AST match for %s at ordinal %d, item: %o', sourceFile, currentCount, item);
-      }
-    }
-    // Fallback: emit explicit InferredType for downstream processing
-    return {
-      eventRef: 'InferredType',
-      exampleData: ensureMessageFormat(item).data,
-      ...(contextParam && { context: contextParam }),
-    };
-  });
+function isValidSourceFile(sourceFile: string | null | undefined): sourceFile is string {
+  return sourceFile !== null && sourceFile !== undefined && sourceFile !== '';
 }
 
-export function recordGivenData(data: unknown[], contextParam?: Partial<Record<string, string>>): void {
-  if (
-    !context ||
-    context.currentSpecIndex === null ||
-    context.currentRuleIndex === null ||
-    context.currentExampleIndex === null
-  ) {
-    throw new Error('No active example context');
-  }
-  const slice = getCurrentSlice();
-  if (!slice) throw new Error('No active slice');
-
-  const example = getCurrentExample(slice);
-  if (!example) throw new Error('No active example for current slice');
-
-  const items = processGivenItems(data, normalizeContext(contextParam));
-  example.given = items as typeof example.given;
+function isValidMatchingType(
+  matchingType: import('./loader/ts-utils').GivenTypeInfo | undefined,
+): matchingType is import('./loader/ts-utils').GivenTypeInfo {
+  return matchingType !== null && matchingType !== undefined && matchingType.typeName !== '';
 }
 
-export function recordAndGivenData(data: unknown[], contextParam?: Partial<Record<string, string>>): void {
-  if (
-    !context ||
-    context.currentSpecIndex === null ||
-    context.currentRuleIndex === null ||
-    context.currentExampleIndex === null
-  ) {
-    throw new Error('No active example context');
-  }
-  const slice = getCurrentSlice();
-  if (!slice) throw new Error('No active slice');
-
-  const example = getCurrentExample(slice);
-  if (!example) throw new Error('No active example for current slice');
-
-  const items = processGivenItems(data, normalizeContext(contextParam));
-
-  if (example.given && Array.isArray(example.given)) {
-    example.given.push(...(items as NonNullable<typeof example.given>));
-  } else {
-    example.given = items as NonNullable<typeof example.given>;
+function resolveEffectiveKeyword(keyword: StepKeyword): MajorKeyword {
+  if (keyword !== 'And') {
+    return keyword;
   }
+  return context?.lastMajorKeyword ?? 'Given';
 }
 
-function updateExampleWhen(
-  example: Example,
-  data: unknown,
-  sliceType: string,
-  contextParam?: Record<string, string>,
-): void {
-  const ordinal = incrementWhenCounter();
-
-  if (typeof data === 'object' && data !== null && Object.keys(data).length === 0) {
-    if (sliceType === 'query') {
-      example.when = { eventRef: '', exampleData: {} };
-    } else {
-      example.when = { commandRef: '', exampleData: {} };
-    }
-    return;
-  }
+function getTypesByFileForKeyword(keyword: MajorKeyword): Map<string, GivenTypeInfo[]> {
+  if (keyword === 'Given') return givenTypesByFile;
+  if (keyword === 'When') return whenTypesByFile;
+  return thenTypesByFile;
+}
 
-  if (sliceType === 'react' || (sliceType === 'query' && Array.isArray(data))) {
-    // For react slices and query slices with array input, when is an array of events
-    const eventsArray = Array.isArray(data) ? data : [data];
-    example.when = eventsArray.map((item) => convertToEventExample(item, contextParam));
-  } else {
-    example.when = convertToCommandOrEventExample(data, contextParam, ordinal);
-  }
+function getCountersForKeyword(keyword: MajorKeyword): Map<string, number> {
+  if (keyword === 'Given') return givenCallCounters;
+  if (keyword === 'When') return whenCallCounters;
+  return thenCallCounters;
 }
 
-export function recordWhenData(data: unknown, contextParam?: Partial<Record<string, string>>): void {
-  if (
-    !context ||
-    context.currentSpecIndex === null ||
-    context.currentRuleIndex === null ||
-    context.currentExampleIndex === null
-  ) {
-    throw new Error('No active example context');
+function getTypeNameFromAST(effectiveKeyword: MajorKeyword): string | null {
+  const sourceFile = context?.narrative.sourceFile;
+  if (!isValidSourceFile(sourceFile)) {
+    return null;
   }
-  const slice = getCurrentSlice();
-  if (!slice) throw new Error('No active slice');
 
-  const example = getCurrentExample(slice);
-  if (!example) throw new Error('No active example for current slice');
+  const typesByFile = getTypesByFileForKeyword(effectiveKeyword);
+  const counters = getCountersForKeyword(effectiveKeyword);
 
-  updateExampleWhen(example, data, slice.type, normalizeContext(contextParam));
-}
+  const currentCount = counters.get(sourceFile) ?? 0;
+  counters.set(sourceFile, currentCount + 1);
 
-export function recordThenData(data: unknown[], contextParam?: Record<string, string>): void {
-  if (
-    !context ||
-    context.currentSpecIndex === null ||
-    context.currentRuleIndex === null ||
-    context.currentExampleIndex === null
-  ) {
-    throw new Error('No active example context');
-  }
-  const slice = getCurrentSlice();
-  if (!slice) throw new Error('No active slice');
+  const types = typesByFile.get(sourceFile) || [];
+  const matchingType = types[currentCount];
 
-  const example = getCurrentExample(slice);
-  if (!example) throw new Error('No active example for current slice');
+  if (isValidMatchingType(matchingType)) {
+    debug(
+      'AST match for %s keyword %s at ordinal %d: %s',
+      sourceFile,
+      effectiveKeyword,
+      currentCount,
+      matchingType.typeName,
+    );
+    return matchingType.typeName;
+  }
 
-  const outcomes = data.map((item) => convertToOutcomeExample(item, slice.type, normalizeContext(contextParam)));
-  example.then = outcomes as typeof example.then;
+  debug('No AST match for %s keyword %s at ordinal %d', sourceFile, effectiveKeyword, currentCount);
+  return null;
 }
 
-export function recordAndThenData(data: unknown[], contextParam?: Partial<Record<string, string>>): void {
+function getActiveExampleContext(): { example: Example } {
   if (
     !context ||
     context.currentSpecIndex === null ||
@@ -490,220 +418,45 @@ export function recordAndThenData(data: unknown[], contextParam?: Partial<Record
   }
   const slice = getCurrentSlice();
   if (!slice) throw new Error('No active slice');
-
   const example = getCurrentExample(slice);
   if (!example) throw new Error('No active example for current slice');
-
-  const outcomes = data.map((item) => convertToOutcomeExample(item, slice.type, normalizeContext(contextParam)));
-  example.then.push(...(outcomes as typeof example.then));
+  return { example };
 }
 
-function convertToEventExample(
-  item: unknown,
-  contextParam?: Record<string, string>,
-): { eventRef: string; exampleData: Record<string, unknown>; context?: Record<string, string> } {
-  const message = ensureMessageFormat(item);
-  return {
-    eventRef: message.type,
-    exampleData: message.data,
-    ...(contextParam && { context: contextParam }),
-  };
-}
-
-function getRefTypeFromClassification(classification: string): string {
-  if (classification === 'event') return 'eventRef';
-  if (classification === 'command') return 'commandRef';
-  return 'stateRef';
-}
-
-function isValidSourceFile(sourceFile: string | null | undefined): sourceFile is string {
-  return sourceFile !== null && sourceFile !== undefined && sourceFile !== '';
-}
-
-function isValidMatchingType(
-  matchingType: import('./loader/ts-utils').GivenTypeInfo | undefined,
-): matchingType is import('./loader/ts-utils').GivenTypeInfo {
-  return matchingType !== null && matchingType !== undefined && matchingType.typeName !== '';
-}
-
-function incrementWhenCounter(): number {
-  const sourceFile = context?.narrative.sourceFile;
+export function recordStep(keyword: StepKeyword, text: string, data: unknown): void {
+  const { example } = getActiveExampleContext();
+  const effectiveKeyword = resolveEffectiveKeyword(keyword);
 
-  if (!isValidSourceFile(sourceFile)) {
-    return -1;
+  if (keyword !== 'And') {
+    context!.lastMajorKeyword = keyword as MajorKeyword;
   }
 
-  const currentCount = whenCallCounters.get(sourceFile) ?? 0;
-  whenCallCounters.set(sourceFile, currentCount + 1);
-
-  debug('[when-counter] incremented counter for %s to %d', sourceFile, currentCount + 1);
+  const shouldInferType = text === 'InferredType';
+  const typeName = shouldInferType ? (getTypeNameFromAST(effectiveKeyword) ?? 'InferredType') : text;
 
-  return currentCount;
-}
-
-function tryGetWhenTypeFromAST(
-  item: unknown,
-  ordinal: number,
-): { commandRef: string; exampleData: Record<string, unknown> } | null {
-  const sourceFile = context?.narrative.sourceFile;
+  const docString = typeof data === 'object' && data !== null ? (data as Record<string, unknown>) : undefined;
 
-  debug('[when-ast] tryGetWhenTypeFromAST called, sourceFile=%s, ordinal=%d', sourceFile, ordinal);
-  debug('[when-ast] whenTypesByFile has %d files', whenTypesByFile.size);
-  debug('[when-ast] whenTypesByFile keys: %o', [...whenTypesByFile.keys()]);
-
-  if (!isValidSourceFile(sourceFile)) {
-    debug('[when-ast] sourceFile is null/undefined/empty, returning null');
-    return null;
-  }
-
-  const whenTypes = whenTypesByFile.get(sourceFile) || [];
-  debug('[when-ast] sourceFile=%s, ordinal=%d, whenTypes.length=%d', sourceFile, ordinal, whenTypes.length);
-  if (whenTypes.length > 0) {
-    debug(
-      '[when-ast] available types: %o',
-      whenTypes.map((t) => ({ typeName: t.typeName, classification: t.classification })),
-    );
-  }
-
-  const matchingType = whenTypes[ordinal];
-
-  if (!isValidMatchingType(matchingType)) {
-    debug('[when-ast] No valid AST match for when at %s ordinal %d, falling back', sourceFile, ordinal);
-    return null;
-  }
-
-  const refType = getRefTypeFromClassification(matchingType.classification);
-  debug(
-    '[when-ast] ✅ AST match for when at %s ordinal %d: %s -> %s',
-    sourceFile,
-    ordinal,
-    matchingType.typeName,
-    refType,
-  );
-
-  return {
-    [refType]: matchingType.typeName,
-    exampleData: ensureMessageFormat(item).data,
-  } as { commandRef: string; exampleData: Record<string, unknown> };
-}
-
-function convertToCommandOrEventExample(
-  item: unknown,
-  contextParam?: Record<string, string>,
-  ordinal?: number,
-):
-  | { commandRef: string; exampleData: Record<string, unknown> }
-  | { eventRef: string; exampleData: Record<string, unknown> }[] {
-  if (ordinal !== undefined && ordinal >= 0) {
-    const astResult = tryGetWhenTypeFromAST(item, ordinal);
-    if (astResult) return astResult;
-  }
-
-  // Fallback to the original logic
-  const message = ensureMessageFormat(item);
-  return {
-    commandRef: message.type,
-    exampleData: message.data,
-    ...(contextParam && { context: contextParam }),
-  };
-}
-
-function convertToOutcomeExample(
-  item: unknown,
-  sliceType: string,
-  contextParam?: Record<string, string>,
-):
-  | { eventRef: string; exampleData: Record<string, unknown>; context?: Record<string, string> }
-  | { stateRef: string; exampleData: Record<string, unknown>; context?: Record<string, string> }
-  | { commandRef: string; exampleData: Record<string, unknown>; context?: Record<string, string> }
-  | { errorType: 'IllegalStateError' | 'ValidationError' | 'NotFoundError'; message?: string } {
-  const message = ensureMessageFormat(item);
-
-  // Check if it's an error
-  if (message.type === 'Error' || 'errorType' in message.data) {
-    return {
-      errorType:
-        (message.data.errorType as 'IllegalStateError' | 'ValidationError' | 'NotFoundError') || 'IllegalStateError',
-      message: message.data.message as string | undefined,
-    };
-  }
-
-  if (sliceType === 'command') {
-    return {
-      eventRef: message.type,
-      exampleData: message.data,
-    };
-  } else if (sliceType === 'query') {
-    return {
-      stateRef: message.type,
-      exampleData: message.data,
-    };
-  } else if (sliceType === 'react') {
-    return {
-      commandRef: message.type,
-      exampleData: message.data,
-    };
-  }
-
-  return {
-    eventRef: message.type,
-    exampleData: message.data,
-    ...(contextParam && { context: contextParam }),
+  const step: Step = {
+    keyword,
+    text: typeName,
+    ...(docString !== undefined && Object.keys(docString).length > 0 ? { docString } : {}),
   };
-}
-
-function ensureMessageFormat(item: unknown): { type: string; data: Record<string, unknown> } {
-  if (typeof item !== 'object' || item === null) {
-    throw new Error('Invalid message format');
-  }
-  const obj = item as Record<string, unknown>;
-
-  if ('type' in obj && typeof obj.type === 'string') {
-    return parseMessageObject(obj);
-  }
 
-  // Handle enhanced DSL format - pure data objects without type field
-  // The type will be inferred during schema processing from the TypeScript types
-  return {
-    type: 'InferredType', // Placeholder - will be resolved during schema generation
-    data: obj,
-  };
+  example.steps.push(step);
 }
 
-function parseMessageObject(obj: Record<string, unknown>): { type: string; data: Record<string, unknown> } {
-  // Handle direct type/data structure
-  if (hasValidDataProperty(obj)) {
-    return { type: obj.type as string, data: obj.data as Record<string, unknown> };
-  }
-
-  // Handle builder format with __messageCategory
-  if ('__messageCategory' in obj) {
-    return parseBuilderFormat(obj);
-  }
-
-  // Handle legacy format where properties are at top level
-  return parseLegacyFormat(obj);
-}
+export function recordErrorStep(errorType: ErrorType, message?: string): void {
+  const { example } = getActiveExampleContext();
 
-function hasValidDataProperty(obj: Record<string, unknown>): boolean {
-  return 'data' in obj && typeof obj.data === 'object' && obj.data !== null;
-}
+  context!.lastMajorKeyword = 'Then';
 
-function parseBuilderFormat(obj: Record<string, unknown>): { type: string; data: Record<string, unknown> } {
-  const data =
-    'data' in obj
-      ? (obj.data as Record<string, unknown>)
-      : Object.fromEntries(Object.entries(obj).filter(([key]) => key !== 'type' && key !== '__messageCategory'));
-  return {
-    type: obj.type as string,
-    data,
+  const step: Step = {
+    keyword: 'Then',
+    error: {
+      type: errorType,
+      ...(message !== undefined ? { message } : {}),
+    },
   };
-}
 
-function parseLegacyFormat(obj: Record<string, unknown>): { type: string; data: Record<string, unknown> } {
-  const data = Object.fromEntries(Object.entries(obj).filter(([key]) => key !== 'type'));
-  return {
-    type: obj.type as string,
-    data,
-  };
+  example.steps.push(step);
 }