@pikku/core 0.12.72 → 0.12.77

package/src/wirings/workflow/graph/graph-node.ts

@@ -4,82 +4,11 @@ import type {
   RefValue,
 } from './workflow-graph.types.js'
 
-/**
- * Standard RPC handler interface (matches generated FlattenedRPCMap entries)
- */
 export interface RPCHandler<I = any, O = any> {
   input: I
   output: O
 }
 
-/**
- * Compute output types for all nodes based on their func (RPC name)
- */
-export type NodeOutputMap<
-  Nodes extends Record<string, { func: string }>,
-  RPCMap extends Record<string, RPCHandler>,
-> = {
-  [K in keyof Nodes]: Nodes[K]['func'] extends keyof RPCMap
-    ? RPCMap[Nodes[K]['func']]['output']
-    : unknown
-}
-
-/**
- * Node definition with RPC name reference
- */
-export interface GraphNodeDef<
-  RPCMap extends Record<string, RPCHandler>,
-  NodeIds extends string = string,
-  NodeOutputs extends Record<string, any> = Record<string, any>,
-> {
-  /** RPC function name (must be a key in RPCMap) */
-  func: keyof RPCMap & string
-  /** Input mapping - reference outputs from other nodes with autocomplete */
-  input?: (
-    ref: <N extends keyof NodeOutputs & string>(
-      nodeId: N,
-      path: keyof NodeOutputs[N] & string
-    ) => RefValue
-  ) => Record<string, unknown>
-  /** Next node(s) to execute */
-  next?: NextConfig<NodeIds>
-  /** Error handling - node(s) to execute on error */
-  onError?: NodeIds | NodeIds[]
-  /** Maximum retry attempts allowed (excludes the initial attempt) */
-  retries?: number
-  /** Delay between retries — milliseconds, duration string, or 'exponential' */
-  retryDelay?: string | number
-}
-
-/**
- * Helper to create a type-safe graph definition with RPC autocomplete.
- * Pass node IDs as first type parameter for type-safe next/ref/output key completion.
- *
- * @example
- * ```typescript
- * // Import the typed graph from generated types
- * import { pikkuWorkflowGraph } from './.pikku/workflow/pikku-workflow-types.gen.js'
- *
- * export const myGraph = pikkuWorkflowGraph({
- *   name: 'myWorkflow',
- *   nodes: {
- *     entry: 'createUserProfile',  // autocompletes RPC names
- *     sendWelcome: 'sendEmail',
- *   },
- *   config: {
- *     entry: { next: 'sendWelcome' },
- *     sendWelcome: {
- *       input: (ref) => ({
- *         to: ref('entry', 'email'),  // 'entry' and 'email' both autocomplete
- *       }),
- *     },
- *   },
- * })
- * ```
- */
-/**
- * Type to compute output types for all nodes based on their func mapping
- */
 type ComputeNodeOutputs<
   FuncMap extends Record<string, string>,
   RPCMap extends Record<string, RPCHandler>,
@@ -89,9 +18,6 @@ type ComputeNodeOutputs<
     : unknown
 }
 
-/**
- * Type to compute input types for all nodes based on their func mapping
- */
 type ComputeNodeInputs<
   FuncMap extends Record<string, string>,
   RPCMap extends Record<string, RPCHandler>,
@@ -101,15 +27,8 @@ type ComputeNodeInputs<
     : unknown
 }
 
-/**
- * Typed ref value - carries the type of the referenced field as a phantom type.
- * At runtime this is just RefValue, but TypeScript tracks the type T.
- */
 export type TypedRef<T> = RefValue & { __phantomType?: T }
 
-/**
- * Map input type fields to allow TypedRef of matching type as an alternative
- */
 type InputWithRefs<T> = {
   [K in keyof T]: T[K] | TypedRef<T[K]>
 }
@@ -126,7 +45,6 @@ export function createGraph<RPCMap extends Record<string, RPCHandler>>() {
   > => {
     type NodeIds = Extract<keyof FuncMap, string>
 
-    // If no nodes provided, return just the funcMap converted to graph nodes
     if (!nodesOrBuilder) {
       const result: Record<string, GraphNodeConfig<string>> = {}
       for (const [nodeId, rpcName] of Object.entries(funcMap)) {
@@ -159,9 +77,6 @@ export function createGraph<RPCMap extends Record<string, RPCHandler>>() {
   }
 }
 
-/**
- * Type helper for node configuration map
- */
 type GraphNodeConfigMap<
   FuncMap extends Record<string, string>,
   RPCMap extends Record<string, RPCHandler>,
@@ -180,57 +95,6 @@ type GraphNodeConfigMap<
     onError?: Extract<keyof FuncMap, string> | Extract<keyof FuncMap, string>[]
     retries?: number
     retryDelay?: string | number
-    /** Free-text node documentation. Non-semantic — excluded from graphHash. */
     notes?: string
   }
 }
-
-/**
- * Untyped graph for use without RPC map.
- * Pass node IDs as type parameter for type-safe next/ref, or omit for untyped usage.
- *
- * @example
- * ```typescript
- * // Typed usage - next and ref are type-checked
- * graph<'entry' | 'sendWelcome'>({
- *   entry: { func: 'createUserProfile', next: 'sendWelcome' },
- *   sendWelcome: { func: 'sendEmail', input: (ref) => ({ to: ref('entry', 'email') }) },
- * })
- *
- * // Untyped usage - no type checking on next/ref
- * graph({
- *   entry: { func: 'createUserProfile', next: 'sendWelcome' },
- *   sendWelcome: { func: 'sendEmail' },
- * })
- * ```
- */
-export function graph<NodeIds extends string = string>(
-  nodes: Record<
-    NodeIds,
-    {
-      func: string
-      next?: NextConfig<NodeIds>
-      input?: (
-        ref: (nodeId: NodeIds, path: string) => RefValue
-      ) => Record<string, unknown>
-      onError?: NodeIds | NodeIds[]
-      retries?: number
-      retryDelay?: string | number
-    }
-  >
-): Record<NodeIds, GraphNodeConfig<NodeIds>> {
-  const result: Record<string, GraphNodeConfig<string>> = {}
-
-  for (const [nodeId, def] of Object.entries(nodes) as [string, any][]) {
-    result[nodeId] = {
-      func: def.func,
-      input: def.input as any,
-      next: def.next,
-      onError: def.onError,
-      retries: def.retries,
-      retryDelay: def.retryDelay,
-    }
-  }
-
-  return result as Record<NodeIds, GraphNodeConfig<NodeIds>>
-}

package/src/wirings/workflow/graph/graph-runner.test.ts

@@ -258,8 +258,6 @@ describe('graph-runner bugs', () => {
       },
     } as any)
 
-    // start → a, where a loops back through b once, then exits to c:
-    //   start → a --retry--> b → a --done--> c
     const meta: WorkflowRuntimeMeta = {
       name: 'testCyclicGraph',
       pikkuFuncId: 'testCyclicGraph',
@@ -274,11 +272,16 @@ describe('graph-runner bugs', () => {
       },
     }
 
-    const runId = await ws.createRun('testCyclicGraph', {}, false, 'cyclic-hash', {
-      type: 'test',
-    })
+    const runId = await ws.createRun(
+      'testCyclicGraph',
+      {},
+      false,
+      'cyclic-hash',
+      {
+        type: 'test',
+      }
+    )
 
-    // Succeed a queued step (taking an optional branch), then advance the graph.
     const advance = async (stepName: string, branch?: string) => {
       const step = await ws.getStepState(runId, stepName)
       await ws.setStepRunning(step.stepId)
@@ -287,15 +290,13 @@ describe('graph-runner bugs', () => {
       await continueGraph(ws, runId, 'testCyclicGraph', meta)
     }
 
-    await continueGraph(ws, runId, 'testCyclicGraph', meta) // fire entry
+    await continueGraph(ws, runId, 'testCyclicGraph', meta)
     await advance('start')
-    await advance('a', 'retry') // a → b (b reaches a, but first visit ⇒ bare 'b')
-    await advance('b') // b → a revisit ⇒ a#1
-    await advance('a#1', 'done') // a#1 → c (forward edge, terminal)
+    await advance('a', 'retry')
+    await advance('b')
+    await advance('a#1', 'done')
     await advance('c')
 
-    // Each step records the predecessor it was reached from; the cyclic
-    // revisit is a fresh ordinal instance (a#1) with its own provenance.
     assert.deepEqual(queued, [
       { stepName: 'start', fromStepName: undefined },
       { stepName: 'a', fromStepName: 'start' },
@@ -307,7 +308,6 @@ describe('graph-runner bugs', () => {
     const run = await ws.getRun(runId)
     assert.equal(run?.status, 'completed')
 
-    // Reconstruct the walked path purely from the fromStepName chain.
     const instances = await ws.getStepInstances(runId)
     const from = new Map(instances.map((i) => [i.stepName, i.fromStepName]))
     const path: string[] = []
@@ -419,7 +419,6 @@ describe('graph-runner bugs', () => {
   test('inline graph revisits a cyclic node and records the walked path via fromStepName', async () => {
     const ws = new InMemoryWorkflowService()
 
-    // attempt loops back to itself via `again` until it converges to `done`.
     const mockRpcService = {
       rpcWithWire: async (rpcName: string, _data: any, wire: any) => {
         if (rpcName === 'cyclicBegin') return { attempts: 3 }
@@ -464,7 +463,6 @@ describe('graph-runner bugs', () => {
     const run = await ws.getRun(runId)
     assert.equal(run?.status, 'completed')
 
-    // The self-cycle produced three ordinal instances of `attempt`.
     const instances = await ws.getStepInstances(runId)
     const names = instances.map((i) => i.stepName).sort()
     assert.ok(
@@ -474,8 +472,6 @@ describe('graph-runner bugs', () => {
       `expected attempt/attempt#1/attempt#2, got ${JSON.stringify(names)}`
     )
 
-    // Walk the fromStepName chain back from the terminal node — inline now
-    // records provenance identical to the queued path.
     const from = new Map(instances.map((i) => [i.stepName, i.fromStepName]))
     const path: string[] = []
     let cursor: string | undefined = 'finish'
@@ -483,7 +479,13 @@ describe('graph-runner bugs', () => {
       path.unshift(cursor)
       cursor = from.get(cursor) ?? undefined
     }
-    assert.deepEqual(path, ['begin', 'attempt', 'attempt#1', 'attempt#2', 'finish'])
+    assert.deepEqual(path, [
+      'begin',
+      'attempt',
+      'attempt#1',
+      'attempt#2',
+      'finish',
+    ])
 
     delete metaState['testInlineCyclic']
   })
@@ -647,7 +649,6 @@ describe('graph-runner bugs', () => {
       },
     }
 
-    // Set up queue service to verify nothing is queued
     let queued = false
     pikkuState(null, 'package', 'singletonServices', {
       queueService: {

package/src/wirings/workflow/graph/graph-runner.ts

@@ -29,7 +29,6 @@ function buildTemplateRegex(nodeId: string): RegExp | null {
   return new RegExp(`^${escaped}$`)
 }
 
-/** Strip a trailing revisit ordinal (`node#2` → `node`); leaves other names as-is. */
 function stripInstanceOrdinal(name: string): string {
   const hash = name.lastIndexOf('#')
   if (hash <= 0) return name
@@ -48,7 +47,6 @@ function remapStepNamesToNodeIds(
   }
   return stepNames.map((name) => {
     if (nodes[name]) return name
-    // Revisit instance (`node#N`) maps to its logical node.
     const base = stripInstanceOrdinal(name)
     if (base !== name && nodes[base]) return base
     const matches: string[] = []
@@ -69,8 +67,6 @@ function remapStepNamesToNodeIds(
 
 const ENTRY_FROM = '__entry__'
 
-/** Whether `target` can reach `source` over `next` edges — i.e. an edge
- *  source→target closes a cycle (a back-edge), vs a plain forward edge. */
 function closesCycle(
   source: string,
   target: string,
@@ -88,15 +84,6 @@ function closesCycle(
   return false
 }
 
-/**
- * Decide which next steps to fire this tick. Two kinds of edge:
- *  - forward edge → node-once: fire the target only if it has no instance yet,
- *    so converging edges (joins) collapse to a single run (unchanged behavior).
- *  - back-edge (target can reach the source, closing a cycle) → revisit: fire a
- *    fresh ordinal instance (`target#1`, …), edge-once on `from → target` so it
- *    doesn't re-fire every tick. Cycles terminate when branch routing stops
- *    looping back; a node always records the predecessor it was reached from.
- */
 function planGraphTransitions(
   nodes: Record<string, any>,
   instances: Array<{ stepName: string; status: string; fromStepName?: string }>,
@@ -122,7 +109,6 @@ function planGraphTransitions(
   const completed = instances.filter((i) => i.status === 'succeeded')
   const completedLogical = new Set(completed.map((i) => toLogical(i.stepName)))
 
-  // Available edges: entry edges + each completed instance's resolved `next`.
   const edges: Array<{
     from?: string
     fromKey: string
@@ -140,7 +126,12 @@ function planGraphTransitions(
       node.next,
       branchByStep[inst.stepName]
     )) {
-      edges.push({ from: inst.stepName, fromKey: inst.stepName, fromLogical, target })
+      edges.push({
+        from: inst.stepName,
+        fromKey: inst.stepName,
+        fromLogical,
+        target,
+      })
     }
   }
 
@@ -158,7 +149,6 @@ function planGraphTransitions(
     const isBackEdge =
       edge.fromLogical !== undefined &&
       closesCycle(edge.fromLogical, target, nodes)
-    // Forward edge into an already-started node = a join; node-once.
     if (!isBackEdge && visits > 0) {
       consumed.add(edgeKey)
       continue
@@ -457,8 +447,6 @@ async function queueGraphNode(
   nodeConfig?: { retries?: number; retryDelay?: string | number },
   fromStepName?: string
 ): Promise<void> {
-  // Default to the workflow-wide retry policy when the node sets none, so the
-  // persisted step retries match the queue `attempts` (see resolveStepJobOptions).
   const stepOptions = {
     retries: nodeConfig?.retries ?? DEFAULT_STEP_RETRIES,
     retryDelay: nodeConfig?.retryDelay,
@@ -500,8 +488,6 @@ export async function continueGraph(
     failedNodeIds: rawFailed,
     branchKeys: branchByStep,
   } = await workflowService.getCompletedGraphState(runId)
-  // Validate step/branch names map to unambiguous nodes (planning keys
-  // physically; these calls only surface ambiguous template configs).
   remapStepNamesToNodeIds(rawCompleted, nodes, graphName)
   remapBranchKeys(branchByStep, nodes, graphName)
   const failedNodeIds = remapStepNamesToNodeIds(rawFailed, nodes, graphName)
@@ -531,15 +517,12 @@ export async function continueGraph(
   )
 
   if (plan.toFire.length === 0) {
-    // Nothing left to fire and nothing running/blocked → the run is done.
     if (!plan.hasInFlight && !plan.blockedWaiting) {
       await workflowService.updateRunStatus(runId, 'completed')
     }
     return
   }
 
-  // The same run read a few lines up: nothing between here and there writes it,
-  // and `input` is fixed at creation anyway.
   const triggerInput = currentRun?.input
 
   for (const fire of plan.toFire) {
@@ -569,13 +552,6 @@ export async function continueGraph(
   }
 }
 
-/**
- * Invoke a graph node's RPC with the graph + workflow wires, capturing any
- * branch the node selects and persisting it. Shared by the queued
- * (executeGraphStep) and inline (executeGraphNodeInline) executors so both build
- * the wire and record the branch identically — only their child-workflow and
- * onError handling differs around this call.
- */
 async function invokeGraphNodeRpc(
   workflowService: PikkuWorkflowService,
   rpcService: any,
@@ -752,9 +728,6 @@ async function executeGraphNodeInline(
 
   const rpcName = node.rpcName
 
-  // Persist under the physical instance key (node, node#1 … for revisits) and
-  // record the predecessor — same as the queued path (queueGraphNode), so an
-  // inline graph run stores identical step rows + provenance.
   const stepState = await workflowService.insertStepState(
     runId,
     instanceKey,
@@ -864,19 +837,12 @@ async function continueGraphInline(
   triggerInput: any,
   entryNodeIds: string[]
 ): Promise<void> {
-  // Drive the run to completion in-process using the SAME planner as the queued
-  // path (continueGraph): each loop plans the next wave of transitions, executes
-  // them inline (vs queueGraphNode dispatch), then re-plans. Sharing the planner
-  // gives the inline path joins, cycle revisits and fromStepName provenance
-  // identical to the queue — instead of a second, weaker traversal.
   while (true) {
     const {
       failedNodeIds: rawFailed,
       branchKeys: branchByStep,
       completedNodeIds: rawCompleted,
     } = await workflowService.getCompletedGraphState(runId)
-    // Validate step/branch names map to unambiguous nodes (planning keys
-    // physically; these calls only surface ambiguous template configs).
     remapStepNamesToNodeIds(rawCompleted, nodes, graphName)
     remapBranchKeys(branchByStep, nodes, graphName)
     const failedNodeIds = remapStepNamesToNodeIds(rawFailed, nodes, graphName)
@@ -942,7 +908,6 @@ async function continueGraphInline(
         )
       })
     )
-    // Nothing executable fired (e.g. nodes without an rpcName) → can't progress.
     if (executed === 0) return
   }
 }

package/src/wirings/workflow/graph/wire-workflow-graph.ts

@@ -8,10 +8,6 @@ export interface PikkuWorkflowGraphConfig<
   tags?: string[]
   nodes: FuncMap
   config?: T
-  /**
-   * Graph-level free-text notes (e.g. imported sticky notes). Non-semantic:
-   * excluded from the graph topology hash.
-   */
   notes?: string[]
 }
 

package/src/wirings/workflow/graph/workflow-graph.types.ts

@@ -1,113 +1,55 @@
-/**
- * Ref value - internal representation after input callback is evaluated
- */
 export interface RefValue {
   __isRef: true
   nodeId: string
   path?: string
 }
 
-/**
- * Helper to create a ref value
- */
 export const createRef = (nodeId: string, path?: string): RefValue => ({
   __isRef: true,
   nodeId,
   path,
 })
 
-/**
- * Check if a value is a ref
- */
 export const isRef = (value: unknown): value is RefValue =>
   typeof value === 'object' &&
   value !== null &&
   '__isRef' in value &&
   (value as RefValue).__isRef === true
 
-/**
- * Input reference for fetching step results
- */
 export interface InputRef {
   nodeId: string
   path?: string
 }
 
-/**
- * Ref function type - provides type-safe references to other nodes' outputs
- * The actual typing is done at the pikkuWorkflowGraph level
- */
 export type RefFn<NodeIds extends string = string> = (
   nodeId: NodeIds,
   path?: string
 ) => RefValue
 
-/**
- * Next node configuration - fully serializable
- * - string: single next node
- * - string[]: parallel execution (all run concurrently)
- * - Record<string, string | string[]>: branching (function calls graph.branch('key'))
- */
 export type NextConfig<NodeIds extends string = string> =
   | NodeIds
   | NodeIds[]
   | Record<string, NodeIds | NodeIds[]>
 
-/**
- * Graph node configuration - references functions by RPC name
- */
 export interface GraphNodeConfig<NodeIds extends string = string> {
-  /** RPC function name */
   func: string
-  /** Input mapping callback - receives ref function, returns input object */
   input?: (ref: RefFn<NodeIds>) => Record<string, unknown>
-  /** Next nodes - string, array, or record for branching */
   next?: NextConfig<NodeIds>
-  /** Error routing - node(s) to execute on error */
   onError?: NodeIds | NodeIds[]
-  /** Maximum retry attempts allowed (excludes the initial attempt) */
   retries?: number
-  /** Delay between retries — milliseconds, duration string, or 'exponential' */
   retryDelay?: string | number
-  /**
-   * Free-text documentation for this node. Non-semantic: excluded from the
-   * graph topology hash, so editing a note never marks the workflow as changed.
-   */
   notes?: string
 }
 
-/**
- * Graph wire context - available to functions running in a workflow graph
- */
 export interface PikkuGraphWire {
-  /** Workflow run ID */
   runId: string
-  /** Graph name */
   graphName: string
-  /** Current node ID */
   nodeId: string
-  /**
-   * Select which branch to take for Record-based next config.
-   * Must be called if the node has a Record `next` configuration.
-   * @param key - The branch key to take (must match a key in the next Record)
-   */
   branch: (key: string) => void
-  /**
-   * Set a state variable value.
-   * @param name - Variable name
-   * @param value - Value to store
-   */
   setState: (name: string, value: unknown) => Promise<void>
-  /**
-   * Get the entire state object.
-   * @returns The state object with all variables
-   */
   getState: () => Promise<Record<string, unknown>>
 }
 
-/**
- * Internal mutable state for graph wire (used by runner to capture branch)
- */
 export interface GraphWireState {
   branchKey?: string
 }

package/src/wirings/workflow/index.ts

@@ -1,6 +1,3 @@
-/**
- * Workflow module exports
- */
 export {
   PikkuWorkflowService,
   WorkflowCancelledException,
@@ -18,7 +15,6 @@ export type {
 } from './pikku-workflow-service.js'
 export { deriveInvocationId, uuidv5 } from './workflow-invocation-id.js'
 
-// Time-travel: reconstruct run state at any point from durable history
 export {
   buildRunTimeline,
   reconstructStateAt,
@@ -32,11 +28,9 @@ export type {
   RunPhase,
 } from './run-timeline.js'
 
-// Internal registration functions (used by generated code)
 export { addWorkflow } from './dsl/workflow-runner.js'
 export { addFeature, resolveFeatureScenarios } from './feature.js'
 
-// Graph helpers (template, pikkuWorkflowGraph)
 export { template, type TemplateString } from './graph/template.js'
 export {
   pikkuWorkflowGraph,
@@ -44,7 +38,6 @@ export {
   type PikkuWorkflowGraphResult,
 } from './graph/wire-workflow-graph.js'
 
-// Queue worker functions (registered by codegen, executed at runtime)
 export {
   pikkuWorkflowWorkerFunc,
   pikkuWorkflowOrchestratorFunc,
@@ -56,7 +49,6 @@ export type {
   PikkuWorkflowSleeperInput,
 } from './workflow-queue-workers.js'
 
-// Re-export all types from workflow.types
 export type {
   WorkflowService,
   WorkflowQueueOptions,
@@ -84,12 +76,8 @@ export type {
   WorkflowsMeta,
   WorkflowRuntimeMeta,
   WorkflowsRuntimeMeta,
-  WorkflowStepInput,
-  WorkflowOrchestratorInput,
-  WorkflowSleeperInput,
 } from './workflow.types.js'
 
-// Re-export DSL types
 export type {
   WorkflowStepOptions,
   WorkflowWireDoRPC,
@@ -127,48 +115,33 @@ export type {
   PikkuScenarioWire,
 } from './workflow.types.js'
 
-/* ------------------------------------------------------------------ *
- * Scenarios — writing a step
- *
- * What a step file imports. Everything here is reached from inside a
- * `pikkuScenarioStep` body.
- * ------------------------------------------------------------------ */
-
-// The step's own wire, and the shape of what it was given
 export type {
   ScenarioStepPhase,
+  ScenarioStepKind,
   ScenarioStepOptions,
   PikkuScenarioStepWire,
   ScenarioEnvironment,
+  ScenarioSurface,
+  ScenarioSurfaceResolution,
 } from './scenario-step.types.js'
+export { SCENARIO_SURFACES } from './scenario-step.types.js'
+
+// Which of a step's bindings run: one for an action, every witness for a `then`
+export { resolveScenarioSurfaces, witnessesAgree } from './scenario-surface.js'
 
-// Narrows the optional halves of the step wire, with a message that says what to do
 export { requireActor, requireScenarioEnv } from './scenario-step-guards.js'
 
-// Waits for the target to catch up, without every step writing the loop again
 export { pollUntil, type PollOptions } from './scenario-poll.js'
 
-// Persists cookies across a step's requests, the way a browser would
 export { createCookieJar } from './scenario-cookie-jar.js'
 export type { ScenarioCookieJar } from './scenario-cookie-jar.js'
 
-// What the transport answered — an actor's `invokeRaw`, or a route reached
-// directly — and the one way to POST JSON at a route and keep its status
 export type {
   ScenarioHttpResponse,
   ScenarioJsonRequest,
-} from '../../services/scenario-actors-service.js'
-export {
-  readScenarioHttpResponse,
-  postScenarioJson,
-} from '../../services/scenario-actors-service.js'
-
-/* ------------------------------------------------------------------ *
- * Scenarios — driving a browser
- *
- * How a step names an element, and what a driver package
- * (`@pikku/playwright`, or another) implements.
- * ------------------------------------------------------------------ */
+} from '../../services/personas-service.js'
+// The readers themselves live on `@pikku/core/persona`; workflow is a production
+// wiring and must not pull scenario runtime in behind it.
 
 export type {
   PikkuBrowserWire,
@@ -177,11 +150,4 @@ export type {
   ScenarioBrowserFailure,
 } from './scenario-step.types.js'
 
-/* ------------------------------------------------------------------ *
- * Scenarios — reporting a run
- *
- * Used by the CLI reporter and the console, so the two render the same
- * sentence for the same step. A step body needs none of it.
- * ------------------------------------------------------------------ */
-
 export { composeStepProse, renderStepTemplate } from './scenario-prose.js'