@auto-engineer/narrative 0.13.0 → 0.13.2

package/src/transformers/model-to-narrative/generators/gwt.ts

@@ -35,188 +35,215 @@ export type GWTBlock = {
   >;
 };
 
-function buildThenItems(
+function buildStandaloneGivenStatements(
   ts: typeof import('typescript'),
   f: tsNS.NodeFactory,
   g: GWTBlock,
   messages?: Array<{ type: string; name: string; fields: Array<{ name: string; type: string; required: boolean }> }>,
-): tsNS.Expression[] {
-  return g.then.map((t) => {
-    const item = t as Record<string, unknown>;
-
-    // Handle event references: just return the data (type handled by generic parameter)
-    if ('eventRef' in item) {
-      const e = t as { eventRef: string; exampleData: Record<string, unknown> };
-      const typeInfo = messages ? getFieldTypeInfo(messages, e.eventRef) : undefined;
-      return jsonToExpr(ts, f, e.exampleData, typeInfo);
-    }
-
-    // Handle command references: just return the data (type handled by generic parameter)
-    if ('commandRef' in item) {
-      const c = t as { commandRef: string; exampleData: Record<string, unknown> };
-      const typeInfo = messages ? getFieldTypeInfo(messages, c.commandRef) : undefined;
-      return jsonToExpr(ts, f, c.exampleData, typeInfo);
-    }
-
-    // Handle state references: just return the data (type handled by generic parameter)
-    if ('stateRef' in item) {
-      const s = t as { stateRef: string; exampleData: Record<string, unknown> };
-      const typeInfo = messages ? getFieldTypeInfo(messages, s.stateRef) : undefined;
-      return jsonToExpr(ts, f, s.exampleData, typeInfo);
-    }
-
-    // Handle error objects: { errorType: 'ValidationError', message: '...' }
-    if ('errorType' in item) {
-      const err = t as { errorType: 'IllegalStateError' | 'ValidationError' | 'NotFoundError'; message?: string };
-      return f.createObjectLiteralExpression(
-        [
-          f.createPropertyAssignment('errorType', f.createStringLiteral(err.errorType)),
-          ...(err.message !== null && err.message !== undefined
-            ? [f.createPropertyAssignment('message', f.createStringLiteral(err.message))]
-            : []),
-        ],
-        false,
-      );
-    }
-
-    return f.createNull();
-  });
-}
+): tsNS.Statement[] {
+  const statements: tsNS.Statement[] = [];
 
-function getDescriptions(
-  g: GWTBlock & { description?: string; ruleDescription?: string; exampleDescription?: string },
-) {
-  const ruleDesc =
-    g.ruleDescription !== null && g.ruleDescription !== undefined && g.ruleDescription !== ''
-      ? g.ruleDescription
-      : 'Generated rule description';
-
-  const exampleDesc =
-    g.exampleDescription !== null && g.exampleDescription !== undefined && g.exampleDescription !== ''
-      ? g.exampleDescription
-      : g.description !== null && g.description !== undefined && g.description !== ''
-        ? g.description
-        : 'Generated example description';
-
-  return { ruleDesc, exampleDesc };
-}
-
-function addGivenToChain(
-  ts: typeof import('typescript'),
-  f: tsNS.NodeFactory,
-  exampleChain: tsNS.Expression,
-  g: GWTBlock,
-  messages?: Array<{ type: string; name: string; fields: Array<{ name: string; type: string; required: boolean }> }>,
-): tsNS.Expression {
   if (hasGivenEvents(g) && g.given !== null && g.given !== undefined && g.given.length > 0) {
-    // Start with the first given
     const firstGiven = g.given[0];
     const firstTypeInfo = messages ? getFieldTypeInfo(messages, firstGiven.eventRef) : undefined;
-    let currentChain = f.createCallExpression(
-      f.createPropertyAccessExpression(exampleChain, 'given'),
-      [f.createTypeReferenceNode(firstGiven.eventRef, undefined)],
-      [jsonToExpr(ts, f, firstGiven.exampleData, firstTypeInfo)],
+    statements.push(
+      f.createExpressionStatement(
+        f.createCallExpression(
+          f.createIdentifier('given'),
+          [f.createTypeReferenceNode(firstGiven.eventRef, undefined)],
+          [jsonToExpr(ts, f, firstGiven.exampleData, firstTypeInfo)],
+        ),
+      ),
     );
 
-    // Chain additional givens with .and()
     for (let i = 1; i < g.given.length; i++) {
       const givenEvent = g.given[i];
       const typeInfo = messages ? getFieldTypeInfo(messages, givenEvent.eventRef) : undefined;
-      currentChain = f.createCallExpression(
-        f.createPropertyAccessExpression(currentChain, 'and'),
-        [f.createTypeReferenceNode(givenEvent.eventRef, undefined)],
-        [jsonToExpr(ts, f, givenEvent.exampleData, typeInfo)],
+      statements.push(
+        f.createExpressionStatement(
+          f.createCallExpression(
+            f.createIdentifier('and'),
+            [f.createTypeReferenceNode(givenEvent.eventRef, undefined)],
+            [jsonToExpr(ts, f, givenEvent.exampleData, typeInfo)],
+          ),
+        ),
       );
     }
-
-    return currentChain;
   }
-  return exampleChain;
+
+  return statements;
 }
 
-function addCommandWhenToChain(
+function createWhenCallExpression(
   ts: typeof import('typescript'),
   f: tsNS.NodeFactory,
-  exampleChain: tsNS.Expression,
-  when: { commandRef: string; exampleData: Record<string, unknown> },
+  typeRef: string,
+  exampleData: Record<string, unknown>,
   messages?: Array<{ type: string; name: string; fields: Array<{ name: string; type: string; required: boolean }> }>,
-): tsNS.Expression {
-  const typeInfo = messages ? getFieldTypeInfo(messages, when.commandRef) : undefined;
-  return f.createCallExpression(
-    f.createPropertyAccessExpression(exampleChain, 'when'),
-    when.commandRef ? [f.createTypeReferenceNode(when.commandRef, undefined)] : undefined,
-    [jsonToExpr(ts, f, when.exampleData, typeInfo)],
+): tsNS.Statement {
+  const typeInfo = messages !== undefined ? getFieldTypeInfo(messages, typeRef) : undefined;
+  return f.createExpressionStatement(
+    f.createCallExpression(
+      f.createIdentifier('when'),
+      typeRef !== '' ? [f.createTypeReferenceNode(typeRef, undefined)] : undefined,
+      [jsonToExpr(ts, f, exampleData, typeInfo)],
+    ),
   );
 }
 
-function addEventWhenToChain(
+function buildCommandWhenStatement(
   ts: typeof import('typescript'),
   f: tsNS.NodeFactory,
-  exampleChain: tsNS.Expression,
-  firstEvent: { eventRef: string; exampleData: Record<string, unknown> },
+  when: { commandRef: string; exampleData: Record<string, unknown> },
   messages?: Array<{ type: string; name: string; fields: Array<{ name: string; type: string; required: boolean }> }>,
-): tsNS.Expression {
-  const typeInfo = messages ? getFieldTypeInfo(messages, firstEvent.eventRef) : undefined;
-  return f.createCallExpression(
-    f.createPropertyAccessExpression(exampleChain, 'when'),
-    firstEvent.eventRef ? [f.createTypeReferenceNode(firstEvent.eventRef, undefined)] : undefined,
-    [jsonToExpr(ts, f, firstEvent.exampleData, typeInfo)],
-  );
+): tsNS.Statement {
+  return createWhenCallExpression(ts, f, when.commandRef, when.exampleData, messages);
 }
 
-function isEmptyEventWhen(when: { eventRef: string; exampleData: Record<string, unknown> }): boolean {
-  return (!when.eventRef || when.eventRef === '') && Object.keys(when.exampleData).length === 0;
+function buildEventWhenStatement(
+  ts: typeof import('typescript'),
+  f: tsNS.NodeFactory,
+  event: { eventRef: string; exampleData: Record<string, unknown> },
+  messages?: Array<{ type: string; name: string; fields: Array<{ name: string; type: string; required: boolean }> }>,
+): tsNS.Statement {
+  return createWhenCallExpression(ts, f, event.eventRef, event.exampleData, messages);
 }
 
-function isEmptyCommandWhen(when: { commandRef: string; exampleData: Record<string, unknown> }): boolean {
-  return (!when.commandRef || when.commandRef === '') && Object.keys(when.exampleData).length === 0;
+function isQueryWithSingleEvent(
+  sliceKind: string,
+  when: GWTBlock['when'],
+): when is { eventRef: string; exampleData: Record<string, unknown> } {
+  return sliceKind === 'query' && when !== undefined && !Array.isArray(when) && 'eventRef' in when;
 }
 
-function isEmptyWhen(whenData: GWTBlock['when']): boolean {
-  if (!whenData) return true;
-  if (Array.isArray(whenData) && whenData.length === 0) return true;
-  if (typeof whenData === 'object' && 'eventRef' in whenData) {
-    return isEmptyEventWhen(whenData as { eventRef: string; exampleData: Record<string, unknown> });
-  }
-  if (typeof whenData === 'object' && 'commandRef' in whenData) {
-    return isEmptyCommandWhen(whenData as { commandRef: string; exampleData: Record<string, unknown> });
-  }
-  return false;
+function isReactOrQueryWithEvents(sliceKind: string): boolean {
+  return sliceKind === 'react' || sliceKind === 'query';
 }
 
-function processWhenForSliceKind(
+function buildStandaloneWhenStatement(
   ts: typeof import('typescript'),
   f: tsNS.NodeFactory,
-  exampleChain: tsNS.Expression,
-  when: GWTBlock['when'],
+  g: GWTBlock,
   sliceKind: 'command' | 'react' | 'query' | 'experience',
   messages?: Array<{ type: string; name: string; fields: Array<{ name: string; type: string; required: boolean }> }>,
-): tsNS.Expression {
+): tsNS.Statement | null {
+  if (isEmptyWhen(g.when)) {
+    return null;
+  }
+
+  const when = g.when;
   if (sliceKind === 'command' && isWhenCommand(when)) {
-    return addCommandWhenToChain(ts, f, exampleChain, when, messages);
+    return buildCommandWhenStatement(ts, f, when, messages);
   }
-  if ((sliceKind === 'react' || sliceKind === 'query') && isWhenEvents(when)) {
-    return addEventWhenToChain(ts, f, exampleChain, when[0], messages);
+  if (isReactOrQueryWithEvents(sliceKind) && isWhenEvents(when) && when.length > 0) {
+    return buildEventWhenStatement(ts, f, when[0], messages);
   }
-  if (sliceKind === 'query' && when && !Array.isArray(when) && 'eventRef' in when) {
-    const whenEvent = when as { eventRef: string; exampleData: Record<string, unknown> };
-    return addEventWhenToChain(ts, f, exampleChain, whenEvent, messages);
+  if (isQueryWithSingleEvent(sliceKind, when)) {
+    return buildEventWhenStatement(ts, f, when, messages);
   }
-  return exampleChain;
+  return null;
 }
 
-function addWhenToChain(
+function buildStandaloneThenStatement(
   ts: typeof import('typescript'),
   f: tsNS.NodeFactory,
-  exampleChain: tsNS.Expression,
   g: GWTBlock,
-  sliceKind: 'command' | 'react' | 'query' | 'experience',
   messages?: Array<{ type: string; name: string; fields: Array<{ name: string; type: string; required: boolean }> }>,
+): tsNS.Statement {
+  const firstThenItem = g.then[0];
+  const thenTypeRef = getThenTypeRef(firstThenItem);
+  const typeInfo = messages && thenTypeRef ? getFieldTypeInfo(messages, thenTypeRef) : undefined;
+  const thenArg = buildThenItem(ts, f, firstThenItem, typeInfo);
+  const thenTypeParams = thenTypeRef ? [f.createTypeReferenceNode(thenTypeRef, undefined)] : undefined;
+
+  return f.createExpressionStatement(f.createCallExpression(f.createIdentifier('then'), thenTypeParams, [thenArg]));
+}
+
+function buildThenItem(
+  ts: typeof import('typescript'),
+  f: tsNS.NodeFactory,
+  t: GWTBlock['then'][0],
+  typeInfo?: FieldTypeInfo,
 ): tsNS.Expression {
-  if (isEmptyWhen(g.when)) {
-    return exampleChain;
+  const item = t as Record<string, unknown>;
+
+  if ('eventRef' in item) {
+    const e = t as { eventRef: string; exampleData: Record<string, unknown> };
+    return jsonToExpr(ts, f, e.exampleData, typeInfo);
   }
-  return processWhenForSliceKind(ts, f, exampleChain, g.when, sliceKind, messages);
+
+  if ('commandRef' in item) {
+    const c = t as { commandRef: string; exampleData: Record<string, unknown> };
+    return jsonToExpr(ts, f, c.exampleData, typeInfo);
+  }
+
+  if ('stateRef' in item) {
+    const s = t as { stateRef: string; exampleData: Record<string, unknown> };
+    return jsonToExpr(ts, f, s.exampleData, typeInfo);
+  }
+
+  if ('errorType' in item) {
+    const err = t as { errorType: 'IllegalStateError' | 'ValidationError' | 'NotFoundError'; message?: string };
+    return f.createObjectLiteralExpression(
+      [
+        f.createPropertyAssignment('errorType', f.createStringLiteral(err.errorType)),
+        ...(err.message !== null && err.message !== undefined
+          ? [f.createPropertyAssignment('message', f.createStringLiteral(err.message))]
+          : []),
+      ],
+      false,
+    );
+  }
+
+  return f.createNull();
+}
+
+function getDescriptions(
+  g: GWTBlock & { description?: string; ruleDescription?: string; exampleDescription?: string },
+) {
+  const ruleDesc =
+    g.ruleDescription !== null && g.ruleDescription !== undefined && g.ruleDescription !== ''
+      ? g.ruleDescription
+      : 'Generated rule description';
+
+  const exampleDesc =
+    g.exampleDescription !== null && g.exampleDescription !== undefined && g.exampleDescription !== ''
+      ? g.exampleDescription
+      : g.description !== null && g.description !== undefined && g.description !== ''
+        ? g.description
+        : 'Generated example description';
+
+  return { ruleDesc, exampleDesc };
+}
+
+function isEmptyEventWhen(when: { eventRef: string; exampleData: Record<string, unknown> }): boolean {
+  return Object.keys(when.exampleData).length === 0;
+}
+
+function isEmptyCommandWhen(when: { commandRef: string; exampleData: Record<string, unknown> }): boolean {
+  return (!when.commandRef || when.commandRef === '') && Object.keys(when.exampleData).length === 0;
+}
+
+function isEmptyWhen(whenData: GWTBlock['when']): boolean {
+  if (!whenData) return true;
+  if (Array.isArray(whenData)) {
+    if (whenData.length === 0) return true;
+    const firstItem = whenData[0];
+    if ('eventRef' in firstItem) {
+      return isEmptyEventWhen(firstItem as { eventRef: string; exampleData: Record<string, unknown> });
+    }
+    if ('commandRef' in firstItem) {
+      return isEmptyCommandWhen(firstItem as { commandRef: string; exampleData: Record<string, unknown> });
+    }
+    return false;
+  }
+  if (typeof whenData === 'object' && 'eventRef' in whenData) {
+    return isEmptyEventWhen(whenData as { eventRef: string; exampleData: Record<string, unknown> });
+  }
+  if (typeof whenData === 'object' && 'commandRef' in whenData) {
+    return isEmptyCommandWhen(whenData as { commandRef: string; exampleData: Record<string, unknown> });
+  }
+  return false;
 }
 
 function getThenTypeRef(firstThenItem: GWTBlock['then'][0]): string {
@@ -230,50 +257,37 @@ function getThenTypeRef(firstThenItem: GWTBlock['then'][0]): string {
   return '';
 }
 
-function addThenToChain(
-  ts: typeof import('typescript'),
-  f: tsNS.NodeFactory,
-  exampleChain: tsNS.Expression,
-  g: GWTBlock,
-  messages?: Array<{ type: string; name: string; fields: Array<{ name: string; type: string; required: boolean }> }>,
-): tsNS.Expression {
-  const thenItems = buildThenItems(ts, f, g, messages);
-  const firstThenItem = g.then[0];
-  const thenTypeRef = getThenTypeRef(firstThenItem);
-
-  // Always use single object format for .then()
-  const thenArg = thenItems[0];
-  const thenTypeParams = thenTypeRef ? [f.createTypeReferenceNode(thenTypeRef, undefined)] : undefined;
-
-  return f.createCallExpression(f.createPropertyAccessExpression(exampleChain, 'then'), thenTypeParams, [thenArg]);
-}
-
 export function buildGwtSpecBlock(
   ts: typeof import('typescript'),
   f: tsNS.NodeFactory,
   g: GWTBlock & { description?: string; ruleDescription?: string; exampleDescription?: string; ruleId?: string },
   sliceKind: 'command' | 'react' | 'query' | 'experience',
+  messages?: Array<{ type: string; name: string; fields: Array<{ name: string; type: string; required: boolean }> }>,
 ): tsNS.Statement {
   const { ruleDesc, exampleDesc } = getDescriptions(g);
 
-  // Build the example chain: example('desc').given().when().then()
-  let exampleChain: tsNS.Expression = f.createCallExpression(f.createIdentifier('example'), undefined, [
+  const bodyStatements: tsNS.Statement[] = [];
+  bodyStatements.push(...buildStandaloneGivenStatements(ts, f, g, messages));
+  const whenStmt = buildStandaloneWhenStatement(ts, f, g, sliceKind, messages);
+  if (whenStmt) {
+    bodyStatements.push(whenStmt);
+  }
+  bodyStatements.push(buildStandaloneThenStatement(ts, f, g, messages));
+
+  const exampleCall = f.createCallExpression(f.createIdentifier('example'), undefined, [
     f.createStringLiteral(exampleDesc),
+    f.createArrowFunction(
+      undefined,
+      undefined,
+      [],
+      undefined,
+      f.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+      f.createBlock(bodyStatements, true),
+    ),
   ]);
 
-  // Add .given() if present
-  exampleChain = addGivenToChain(ts, f, exampleChain, g);
-
-  // Add .when()
-  exampleChain = addWhenToChain(ts, f, exampleChain, g, sliceKind);
-
-  // Add .then()
-  exampleChain = addThenToChain(ts, f, exampleChain, g);
-
-  // Create the rule() call containing the example
   const ruleArgs: tsNS.Expression[] = [f.createStringLiteral(ruleDesc)];
 
-  // Add rule ID if provided
   if (g.ruleId !== null && g.ruleId !== undefined) {
     ruleArgs.push(f.createStringLiteral(g.ruleId));
   }
@@ -285,7 +299,7 @@ export function buildGwtSpecBlock(
       [],
       undefined,
       f.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
-      f.createBlock([f.createExpressionStatement(exampleChain)], true),
+      f.createBlock([f.createExpressionStatement(exampleCall)], true),
     ),
   );
 
@@ -323,33 +337,36 @@ export function buildConsolidatedGwtSpecBlock(
   sliceKind: 'command' | 'react' | 'query' | 'experience',
   messages?: Array<{ type: string; name: string; fields: Array<{ name: string; type: string; required: boolean }> }>,
 ): tsNS.Statement {
-  // Build example chains for each GWT block
   const exampleStatements: tsNS.Statement[] = [];
 
   for (const g of gwtBlocks) {
     const { exampleDesc } = getDescriptions(g);
 
-    // Build the example chain: example('desc').given().when().then()
-    let exampleChain: tsNS.Expression = f.createCallExpression(f.createIdentifier('example'), undefined, [
+    const bodyStatements: tsNS.Statement[] = [];
+    bodyStatements.push(...buildStandaloneGivenStatements(ts, f, g, messages));
+    const whenStmt = buildStandaloneWhenStatement(ts, f, g, sliceKind, messages);
+    if (whenStmt) {
+      bodyStatements.push(whenStmt);
+    }
+    bodyStatements.push(buildStandaloneThenStatement(ts, f, g, messages));
+
+    const exampleCall = f.createCallExpression(f.createIdentifier('example'), undefined, [
       f.createStringLiteral(exampleDesc),
+      f.createArrowFunction(
+        undefined,
+        undefined,
+        [],
+        undefined,
+        f.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+        f.createBlock(bodyStatements, true),
+      ),
     ]);
 
-    // Add .given() if present
-    exampleChain = addGivenToChain(ts, f, exampleChain, g, messages);
-
-    // Add .when()
-    exampleChain = addWhenToChain(ts, f, exampleChain, g, sliceKind, messages);
-
-    // Add .then()
-    exampleChain = addThenToChain(ts, f, exampleChain, g, messages);
-
-    exampleStatements.push(f.createExpressionStatement(exampleChain));
+    exampleStatements.push(f.createExpressionStatement(exampleCall));
   }
 
-  // Create the rule() call containing all examples
   const ruleArgs: tsNS.Expression[] = [f.createStringLiteral(rule.description)];
 
-  // Add rule ID if provided
   if (rule.id !== null && rule.id !== undefined) {
     ruleArgs.push(f.createStringLiteral(rule.id));
   }

package/src/transformers/model-to-narrative/generators/imports.ts

@@ -1,20 +1,24 @@
 type BuildImportsOpts = { flowImport: string; integrationImport: string };
 
 export const ALL_FLOW_FUNCTION_NAMES = [
+  'and',
   'command',
-  'query',
-  'react',
-  'experience',
-  'narrative',
+  'data',
   'describe',
-  'it',
-  'specs',
-  'rule',
   'example',
+  'experience',
+  'given',
   'gql',
-  'source',
-  'data',
+  'it',
+  'narrative',
+  'query',
+  'react',
+  'rule',
   'sink',
+  'source',
+  'specs',
+  'then',
+  'when',
 ] as const;
 
 export function buildImports(

package/src/transformers/narrative-to-model/index.ts

@@ -136,39 +136,100 @@ function getServerSpecs(slice: Slice) {
   return undefined;
 }
 
+interface StepWithDocString {
+  keyword: 'Given' | 'When' | 'Then' | 'And';
+  text: string;
+  docString?: Record<string, unknown>;
+}
+
+interface StepWithError {
+  keyword: 'Then';
+  error: { type: string; message?: string };
+}
+
+type Step = StepWithDocString | StepWithError;
+
+function isStepWithError(step: Step): step is StepWithError {
+  return 'error' in step;
+}
+
+function processSteps(
+  steps: Step[],
+  slice: Slice,
+  resolveTypeAndInfo: TypeResolver,
+  messages: Map<string, Message>,
+  exampleShapeHints: ExampleShapeHints,
+): void {
+  let effectiveKeyword: 'Given' | 'When' | 'Then' = 'Given';
+
+  for (const step of steps) {
+    if (isStepWithError(step)) {
+      continue;
+    }
+
+    const keyword = step.keyword;
+    if (keyword !== 'And') {
+      effectiveKeyword = keyword;
+    }
+
+    const refItem = {
+      eventRef: step.text,
+      commandRef: step.text,
+      stateRef: step.text,
+      exampleData: step.docString,
+    };
+
+    if (effectiveKeyword === 'Given') {
+      processGiven([refItem], resolveTypeAndInfo, messages, exampleShapeHints);
+    } else if (effectiveKeyword === 'When') {
+      processWhen([refItem], slice, resolveTypeAndInfo, messages, exampleShapeHints);
+    } else if (effectiveKeyword === 'Then') {
+      processThen([refItem], resolveTypeAndInfo, messages, exampleShapeHints);
+    }
+  }
+}
+
+interface SpecWithRules {
+  rules: Array<{ examples: Array<{ steps?: Step[] }> }>;
+}
+
+function isSpecWithRules(spec: unknown): spec is SpecWithRules {
+  return (
+    typeof spec === 'object' && spec !== null && 'rules' in spec && Array.isArray((spec as { rules: unknown[] }).rules)
+  );
+}
+
+function processRuleExamples(
+  rule: { examples: Array<{ steps?: Step[] }> },
+  slice: Slice,
+  resolveTypeAndInfo: TypeResolver,
+  messages: Map<string, Message>,
+  exampleShapeHints: ExampleShapeHints,
+): void {
+  if (!Array.isArray(rule.examples)) return;
+  for (const example of rule.examples) {
+    if (Array.isArray(example.steps)) {
+      processSteps(example.steps, slice, resolveTypeAndInfo, messages, exampleShapeHints);
+    }
+  }
+}
+
 function processSliceSpecs(
   slice: Slice,
   resolveTypeAndInfo: TypeResolver,
   messages: Map<string, Message>,
   exampleShapeHints: ExampleShapeHints,
 ): void {
-  const serverSpec = getServerSpecs(slice);
-
-  if (serverSpec !== undefined && Array.isArray(serverSpec.rules)) {
-    serverSpec.rules.forEach((rule: unknown) => {
-      if (
-        typeof rule === 'object' &&
-        rule !== null &&
-        'examples' in rule &&
-        Array.isArray((rule as { examples: unknown[] }).examples)
-      ) {
-        const ruleObj = rule as { examples: { given?: unknown; when?: unknown; then?: unknown }[] };
-        ruleObj.examples.forEach((example) => {
-          if (example.given !== undefined && example.given !== null) {
-            const givenArray = Array.isArray(example.given) ? example.given : [example.given];
-            processGiven(givenArray, resolveTypeAndInfo, messages, exampleShapeHints);
-          }
-          if (example.when !== undefined && example.when !== null) {
-            const whenArray = Array.isArray(example.when) ? example.when : [example.when];
-            processWhen(whenArray, slice, resolveTypeAndInfo, messages, exampleShapeHints);
-          }
-          if (example.then !== undefined && example.then !== null) {
-            const thenArray = Array.isArray(example.then) ? example.then : [example.then];
-            processThen(thenArray, resolveTypeAndInfo, messages, exampleShapeHints);
-          }
-        });
+  const serverSpecs = getServerSpecs(slice);
+
+  if (serverSpecs === undefined || !Array.isArray(serverSpecs)) return;
+
+  for (const spec of serverSpecs) {
+    if (isSpecWithRules(spec)) {
+      for (const rule of spec.rules) {
+        processRuleExamples(rule, slice, resolveTypeAndInfo, messages, exampleShapeHints);
       }
-    });
+    }
   }
 }