footprintjs 10.0.1 → 10.2.0

package/dist/esm/lib/engine/narrative/formatting/sentences.js

@@ -47,4 +47,130 @@ export function errorSentence(ctx) {
 export function validationSentence(details) {
     return ` Validation issues: ${details}.`;
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Whether the narrative tells an attempt (P1b). A STAGE series of ONE attempt — a stage run on the attempt runner
+ * only because of a `timeoutMs` or the run's deadline — that succeeded or paused says nothing the stage's own line
+ * does not, so it is not told (its record is still on the tree and the hook). Every other attempt is — every call
+ * and every observed attempt too (P2): the stage's own line never mentions them.
+ */
+export function isAttemptTold(record) {
+    return record.kind !== 'stage' || record.of !== 1 || (record.outcome !== 'ok' && record.outcome !== 'paused');
+}
+/**
+ * One attempt of a retried stage, as one sentence (10.1): its outcome and duration, the cause of a failure
+ * (`category: message`, the category left out when it is `unknown`), and the decision — the wait before a retry,
+ * or why the series stopped. The error is the record's SERVED message, so a redacted error reads redacted here.
+ * Under a run deadline the decision also says the time left (P1b).
+ *
+ *   Attempt 1 of 3 at Fetch rate failed in 812ms (rate-limited: 429), retrying in 4s.
+ *   Attempt 3 of 3 at Fetch rate succeeded in 31ms.
+ *   Attempt 1 of 4 at Charge card failed in 120ms (permanent: card declined); stopped: retryOn declined.
+ *   Attempt 2 of 3 at Fetch rate timed out after 40s, retrying in 2s (70s left).
+ *   Attempt 2 of 4 at Charge card timed out after 20s; stopped: no time left (300ms left, next wait 2s).
+ */
+export function attemptSentence(stageName, record) {
+    if (record.kind === 'call')
+        return callSentence(record);
+    if (record.kind === 'observed')
+        return observedSentence(record);
+    const ceiling = record.of !== undefined ? ` of ${record.of}` : '';
+    return `Attempt ${record.attempt}${ceiling} at ${stageName} ${attemptOutcome(record)}${effectClause(record)}${attemptDecision(record)}.`;
+}
+/**
+ * One attempt of a call a stage made (`scope.$call`, P2), by its target — a single call (`attempts: 1`) says only
+ * how it went, since "attempt 1 of 1" and "no attempts left" add nothing:
+ *
+ *   Call inventory.lookup succeeded in 12ms.
+ *   Call stripe.quotes.create, attempt 1 of 3, failed in 812ms (rate-limited: 429), retrying in 4s.
+ */
+function callSentence(record) {
+    const target = record.target ?? 'call';
+    if (record.of === 1) {
+        const decision = record.reason === 'exhausted' ? '' : attemptDecision(record);
+        return `Call ${target} ${attemptOutcome(record)}${effectClause(record)}${decision}.`;
+    }
+    const ceiling = record.of !== undefined ? ` of ${record.of}` : '';
+    return `Call ${target}, attempt ${record.attempt}${ceiling}, ${attemptOutcome(record)}${effectClause(record)}${attemptDecision(record)}.`;
+}
+/**
+ * One attempt an outside system ran on its own, as its adapter reported it (`observed()`, P2). No decision clause:
+ * the system decided what followed, not the library.
+ *
+ *   Observed: the stripe SDK made attempt 2 of 3, failed in 600ms (server: busy).
+ */
+function observedSentence(record) {
+    const who = record.source === undefined || record.source === 'sdk'
+        ? `the ${record.target ?? 'outside'} SDK`
+        : `${record.target ?? 'outside'} (${record.source})`;
+    const ceiling = record.of !== undefined ? ` of ${record.of}` : '';
+    return `Observed: ${who} made attempt ${record.attempt}${ceiling}, ${attemptOutcome(record)}.`;
+}
+function attemptOutcome(record) {
+    const took = formatDuration(record.durationMs);
+    switch (record.outcome) {
+        case 'ok':
+            return `succeeded in ${took}`;
+        case 'timeout':
+            return `timed out after ${took}`;
+        case 'paused':
+            return `paused after ${took}`;
+        case 'aborted':
+            return `was aborted after ${took}${record.error ? ` (${record.error.message})` : ''}`;
+        default:
+            return `failed in ${took}${attemptCause(record)}`;
+    }
+}
+/**
+ * A touching attempt whose effect is unknown says so (P3) — the outcome alone ("failed", "timed out") would read as
+ * "nothing happened", and nothing may be retried blindly on that reading. `applied` and `none` add nothing the
+ * outcome does not say. Absent on a target that touches nothing (byte identity).
+ *
+ *   Attempt 2 of 2 at Charge card timed out after 20s, effect on stripe unknown; stopped: no attempts left.
+ */
+function effectClause(record) {
+    return record.effect === 'unknown' && record.system !== undefined ? `, effect on ${record.system} unknown` : '';
+}
+function attemptCause(record) {
+    if (!record.error)
+        return '';
+    const category = record.category && record.category !== 'unknown' ? `${record.category}: ` : '';
+    return ` (${category}${record.error.message})`;
+}
+function attemptDecision(record) {
+    if (record.next === 'retry') {
+        const left = record.timeLeftMs !== undefined ? ` (${formatDuration(Math.max(0, record.timeLeftMs))} left)` : '';
+        return (record.delayMs ? `, retrying in ${formatDuration(record.delayMs)}` : ', retrying immediately') + left;
+    }
+    if (record.next === 'done')
+        return '';
+    switch (record.reason) {
+        case 'exhausted':
+            return '; stopped: no attempts left';
+        case 'declined':
+            // A throwing predicate is "do not retry" too — but it is a broken predicate, not a verdict.
+            return record.retryOnThrew ? '; stopped: retryOn threw' : '; stopped: retryOn declined';
+        case 'no-time-left': {
+            const facts = [
+                ...(record.timeLeftMs !== undefined ? [`${formatDuration(Math.max(0, record.timeLeftMs))} left`] : []),
+                ...(record.delayMs !== undefined ? [`next wait ${formatDuration(record.delayMs)}`] : []),
+            ];
+            return `; stopped: no time left${facts.length > 0 ? ` (${facts.join(', ')})` : ''}`;
+        }
+        case 'aborted':
+            // An attempt that threw the abort's own reason already says it ("was aborted"); an attempt that failed on
+            // its own while the run aborted says its failure, then why the series stopped.
+            return record.outcome === 'aborted' ? '' : '; stopped: the run was aborted';
+        case 'paused':
+            // The outcome already says it.
+            return '';
+        default:
+            return `; stopped: ${record.reason}`;
+    }
+}
+/** A duration as the narrative says it: whole milliseconds under a second, seconds (one decimal at most) above. */
+export function formatDuration(ms) {
+    if (ms < 1_000)
+        return `${Math.round(ms)}ms`;
+    return `${Number((ms / 1_000).toFixed(1))}s`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sentences.js","sourceRoot":"","sources":["../../../../../../src/lib/engine/narrative/formatting/sentences.ts"],"names":[],"mappings":"AAaA,MAAM,UAAU,iBAAiB,CAAC,GAA0D;IAC1F,OAAO,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,cAAc,GAAG,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC,wBAAwB,GAAG,CAAC,SAAS,GAAG,CAAC;AACvG,CAAC;AAED,qFAAqF;AACrF,MAAM,UAAU,gBAAgB,CAAC,GAAwE;IACvG,MAAM,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC;IAC9B,IAAI,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,SAAS,EAAE,CAAC;QACrC,OAAO,MAAM,GAAG,CAAC,WAAW,KAAK,GAAG,CAAC,SAAS,iBAAiB,UAAU,GAAG,CAAC;IAC/E,CAAC;IACD,IAAI,GAAG,CAAC,WAAW;QAAE,OAAO,MAAM,GAAG,CAAC,WAAW,cAAc,UAAU,GAAG,CAAC;IAC7E,IAAI,GAAG,CAAC,SAAS;QAAE,OAAO,wBAAwB,GAAG,CAAC,SAAS,2BAA2B,UAAU,GAAG,CAAC;IACxG,OAAO,+CAA+C,UAAU,GAAG,CAAC;AACtE,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,GAAsB;IACjD,MAAM,KAAK,GAAG,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACtC,OAAO,gBAAgB,GAAG,CAAC,QAAQ,CAAC,MAAM,oBAAoB,KAAK,GAAG,CAAC;AACzE,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,GAAsB;IACjD,OAAO,GAAG,CAAC,WAAW;QACpB,CAAC,CAAC,WAAW,GAAG,CAAC,SAAS,KAAK,GAAG,CAAC,WAAW,SAAS;QACvD,CAAC,CAAC,WAAW,GAAG,CAAC,SAAS,YAAY,GAAG,CAAC,MAAM,GAAG,CAAC;AACxD,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,GAAuB;IACnD,OAAO,wBAAwB,GAAG,CAAC,SAAS,GAAG,CAAC;AAClD,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,GAA0C;IACtE,OAAO,uBAAuB,GAAG,CAAC,SAAS,GAAG,CAAC;AACjD,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,GAAoD;IACjF,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC;IACnD,OAAO,wBAAwB,GAAG,CAAC,SAAS,GAAG,MAAM,EAAE,CAAC;AAC1D,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,MAAkC;IAClE,OAAO,MAAM;SACV,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QACb,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;QACrE,OAAO,GAAG,IAAI,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC;IACrC,CAAC,CAAC;SACD,IAAI,CAAC,IAAI,CAAC,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,GAAsD;IAClF,OAAO,wBAAwB,GAAG,CAAC,SAAS,KAAK,GAAG,CAAC,OAAO,GAAG,CAAC;AAClE,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,kBAAkB,CAAC,OAAe;IAChD,OAAO,uBAAuB,OAAO,GAAG,CAAC;AAC3C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,MAAqB;IACjD,OAAO,MAAM,CAAC,IAAI,KAAK,OAAO,IAAI,MAAM,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,KAAK,IAAI,IAAI,MAAM,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC;AAChH,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,eAAe,CAAC,SAAiB,EAAE,MAAqB;IACtE,IAAI,MAAM,CAAC,IAAI,KAAK,MAAM;QAAE,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC;IACxD,IAAI,MAAM,CAAC,IAAI,KAAK,UAAU;QAAE,OAAO,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAChE,MAAM,OAAO,GAAG,MAAM,CAAC,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAClE,OAAO,WAAW,MAAM,CAAC,OAAO,GAAG,OAAO,OAAO,SAAS,IAAI,cAAc,CAAC,MAAM,CAAC,GAAG,YAAY,CACjG,MAAM,CACP,GAAG,eAAe,CAAC,MAAM,CAAC,GAAG,CAAC;AACjC,CAAC;AAED;;;;;;GAMG;AACH,SAAS,YAAY,CAAC,MAAqB;IACzC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC;IACvC,IAAI,MAAM,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC;QACpB,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,KAAK,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;QAC9E,OAAO,QAAQ,MAAM,IAAI,cAAc,CAAC,MAAM,CAAC,GAAG,YAAY,CAAC,MAAM,CAAC,GAAG,QAAQ,GAAG,CAAC;IACvF,CAAC;IACD,MAAM,OAAO,GAAG,MAAM,CAAC,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAClE,OAAO,QAAQ,MAAM,aAAa,MAAM,CAAC,OAAO,GAAG,OAAO,KAAK,cAAc,CAAC,MAAM,CAAC,GAAG,YAAY,CAClG,MAAM,CACP,GAAG,eAAe,CAAC,MAAM,CAAC,GAAG,CAAC;AACjC,CAAC;AAED;;;;;GAKG;AACH,SAAS,gBAAgB,CAAC,MAAqB;IAC7C,MAAM,GAAG,GACP,MAAM,CAAC,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,KAAK,KAAK;QACpD,CAAC,CAAC,OAAO,MAAM,CAAC,MAAM,IAAI,SAAS,MAAM;QACzC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,IAAI,SAAS,KAAK,MAAM,CAAC,MAAM,GAAG,CAAC;IACzD,MAAM,OAAO,GAAG,MAAM,CAAC,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAClE,OAAO,aAAa,GAAG,iBAAiB,MAAM,CAAC,OAAO,GAAG,OAAO,KAAK,cAAc,CAAC,MAAM,CAAC,GAAG,CAAC;AACjG,CAAC;AAED,SAAS,cAAc,CAAC,MAAqB;IAC3C,MAAM,IAAI,GAAG,cAAc,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IAC/C,QAAQ,MAAM,CAAC,OAAO,EAAE,CAAC;QACvB,KAAK,IAAI;YACP,OAAO,gBAAgB,IAAI,EAAE,CAAC;QAChC,KAAK,SAAS;YACZ,OAAO,mBAAmB,IAAI,EAAE,CAAC;QACnC,KAAK,QAAQ;YACX,OAAO,gBAAgB,IAAI,EAAE,CAAC;QAChC,KAAK,SAAS;YACZ,OAAO,qBAAqB,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;QACxF;YACE,OAAO,aAAa,IAAI,GAAG,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;IACtD,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAS,YAAY,CAAC,MAAqB;IACzC,OAAO,MAAM,CAAC,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,eAAe,MAAM,CAAC,MAAM,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC;AAClH,CAAC;AAED,SAAS,YAAY,CAAC,MAAqB;IACzC,IAAI,CAAC,MAAM,CAAC,KAAK;QAAE,OAAO,EAAE,CAAC;IAC7B,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;IAChG,OAAO,KAAK,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC;AACjD,CAAC;AAED,SAAS,eAAe,CAAC,MAAqB;IAC5C,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC5B,MAAM,IAAI,GAAG,MAAM,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;QAChH,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,iBAAiB,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,wBAAwB,CAAC,GAAG,IAAI,CAAC;IAChH,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,KAAK,MAAM;QAAE,OAAO,EAAE,CAAC;IACtC,QAAQ,MAAM,CAAC,MAAM,EAAE,CAAC;QACtB,KAAK,WAAW;YACd,OAAO,6BAA6B,CAAC;QACvC,KAAK,UAAU;YACb,4FAA4F;YAC5F,OAAO,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,0BAA0B,CAAC,CAAC,CAAC,6BAA6B,CAAC;QAC1F,KAAK,cAAc,CAAC,CAAC,CAAC;YACpB,MAAM,KAAK,GAAG;gBACZ,GAAG,CAAC,MAAM,CAAC,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;gBACtG,GAAG,CAAC,MAAM,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,aAAa,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;aACzF,CAAC;YACF,OAAO,0BAA0B,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;QACtF,CAAC;QACD,KAAK,SAAS;YACZ,0GAA0G;YAC1G,+EAA+E;YAC/E,OAAO,MAAM,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gCAAgC,CAAC;QAC9E,KAAK,QAAQ;YACX,+BAA+B;YAC/B,OAAO,EAAE,CAAC;QACZ;YACE,OAAO,cAAc,MAAM,CAAC,MAAM,EAAE,CAAC;IACzC,CAAC;AACH,CAAC;AAED,mHAAmH;AACnH,MAAM,UAAU,cAAc,CAAC,EAAU;IACvC,IAAI,EAAE,GAAG,KAAK;QAAE,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC;IAC7C,OAAO,GAAG,MAAM,CAAC,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;AAC/C,CAAC","sourcesContent":["/** Shared English sentence bodies, with no event capture or recorder state. */\nimport type { AttemptRecord } from '../../../attempt/types.js';\nimport type { ValidationIssue } from '../../../schema/errors.js';\nimport type {\n  BreakRenderContext,\n  DecisionRenderContext,\n  ErrorRenderContext,\n  ForkRenderContext,\n  LoopRenderContext,\n  StageRenderContext,\n} from '../narrativeTypes.js';\nimport type { FlowResumeEvent } from '../types.js';\n\nexport function nextStageSentence(ctx: Pick<StageRenderContext, 'stageName' | 'description'>): string {\n  return ctx.description ? `Next step: ${ctx.description}.` : `Next, it moved on to ${ctx.stageName}.`;\n}\n\n/** Evidence takes precedence at the Combined recorder; this is only its fallback. */\nexport function decisionSentence(ctx: Pick<DecisionRenderContext, 'chosen' | 'description' | 'rationale'>): string {\n  const branchName = ctx.chosen;\n  if (ctx.description && ctx.rationale) {\n    return `It ${ctx.description}: ${ctx.rationale}, so it chose ${branchName}.`;\n  }\n  if (ctx.description) return `It ${ctx.description} and chose ${branchName}.`;\n  if (ctx.rationale) return `A decision was made: ${ctx.rationale}, so the path taken was ${branchName}.`;\n  return `A decision was made, and the path taken was ${branchName}.`;\n}\n\nexport function forkSentence(ctx: ForkRenderContext): string {\n  const names = ctx.children.join(', ');\n  return `Forking into ${ctx.children.length} parallel paths: ${names}.`;\n}\n\nexport function loopSentence(ctx: LoopRenderContext): string {\n  return ctx.description\n    ? `On pass ${ctx.iteration}: ${ctx.description} again.`\n    : `On pass ${ctx.iteration} through ${ctx.target}.`;\n}\n\nexport function breakSentence(ctx: BreakRenderContext): string {\n  return `Execution stopped at ${ctx.stageName}.`;\n}\n\nexport function pauseSentence(ctx: Pick<BreakRenderContext, 'stageName'>): string {\n  return `Execution paused at ${ctx.stageName}.`;\n}\n\nexport function resumeSentence(ctx: Pick<FlowResumeEvent, 'stageName' | 'hasInput'>): string {\n  const suffix = ctx.hasInput ? ' with input.' : '.';\n  return `Execution resumed at ${ctx.stageName}${suffix}`;\n}\n\nexport function validationDetails(issues: readonly ValidationIssue[]): string {\n  return issues\n    .map((issue) => {\n      const path = issue.path.length > 0 ? issue.path.join('.') : '(root)';\n      return `${path}: ${issue.message}`;\n    })\n    .join('; ');\n}\n\nexport function errorSentence(ctx: Pick<ErrorRenderContext, 'stageName' | 'message'>): string {\n  return `An error occurred at ${ctx.stageName}: ${ctx.message}.`;\n}\n\n/** Callers retain their distinct rules for whether to display empty details. */\nexport function validationSentence(details: string): string {\n  return ` Validation issues: ${details}.`;\n}\n\n/**\n * Whether the narrative tells an attempt (P1b). A STAGE series of ONE attempt — a stage run on the attempt runner\n * only because of a `timeoutMs` or the run's deadline — that succeeded or paused says nothing the stage's own line\n * does not, so it is not told (its record is still on the tree and the hook). Every other attempt is — every call\n * and every observed attempt too (P2): the stage's own line never mentions them.\n */\nexport function isAttemptTold(record: AttemptRecord): boolean {\n  return record.kind !== 'stage' || record.of !== 1 || (record.outcome !== 'ok' && record.outcome !== 'paused');\n}\n\n/**\n * One attempt of a retried stage, as one sentence (10.1): its outcome and duration, the cause of a failure\n * (`category: message`, the category left out when it is `unknown`), and the decision — the wait before a retry,\n * or why the series stopped. The error is the record's SERVED message, so a redacted error reads redacted here.\n * Under a run deadline the decision also says the time left (P1b).\n *\n *   Attempt 1 of 3 at Fetch rate failed in 812ms (rate-limited: 429), retrying in 4s.\n *   Attempt 3 of 3 at Fetch rate succeeded in 31ms.\n *   Attempt 1 of 4 at Charge card failed in 120ms (permanent: card declined); stopped: retryOn declined.\n *   Attempt 2 of 3 at Fetch rate timed out after 40s, retrying in 2s (70s left).\n *   Attempt 2 of 4 at Charge card timed out after 20s; stopped: no time left (300ms left, next wait 2s).\n */\nexport function attemptSentence(stageName: string, record: AttemptRecord): string {\n  if (record.kind === 'call') return callSentence(record);\n  if (record.kind === 'observed') return observedSentence(record);\n  const ceiling = record.of !== undefined ? ` of ${record.of}` : '';\n  return `Attempt ${record.attempt}${ceiling} at ${stageName} ${attemptOutcome(record)}${effectClause(\n    record,\n  )}${attemptDecision(record)}.`;\n}\n\n/**\n * One attempt of a call a stage made (`scope.$call`, P2), by its target — a single call (`attempts: 1`) says only\n * how it went, since \"attempt 1 of 1\" and \"no attempts left\" add nothing:\n *\n *   Call inventory.lookup succeeded in 12ms.\n *   Call stripe.quotes.create, attempt 1 of 3, failed in 812ms (rate-limited: 429), retrying in 4s.\n */\nfunction callSentence(record: AttemptRecord): string {\n  const target = record.target ?? 'call';\n  if (record.of === 1) {\n    const decision = record.reason === 'exhausted' ? '' : attemptDecision(record);\n    return `Call ${target} ${attemptOutcome(record)}${effectClause(record)}${decision}.`;\n  }\n  const ceiling = record.of !== undefined ? ` of ${record.of}` : '';\n  return `Call ${target}, attempt ${record.attempt}${ceiling}, ${attemptOutcome(record)}${effectClause(\n    record,\n  )}${attemptDecision(record)}.`;\n}\n\n/**\n * One attempt an outside system ran on its own, as its adapter reported it (`observed()`, P2). No decision clause:\n * the system decided what followed, not the library.\n *\n *   Observed: the stripe SDK made attempt 2 of 3, failed in 600ms (server: busy).\n */\nfunction observedSentence(record: AttemptRecord): string {\n  const who =\n    record.source === undefined || record.source === 'sdk'\n      ? `the ${record.target ?? 'outside'} SDK`\n      : `${record.target ?? 'outside'} (${record.source})`;\n  const ceiling = record.of !== undefined ? ` of ${record.of}` : '';\n  return `Observed: ${who} made attempt ${record.attempt}${ceiling}, ${attemptOutcome(record)}.`;\n}\n\nfunction attemptOutcome(record: AttemptRecord): string {\n  const took = formatDuration(record.durationMs);\n  switch (record.outcome) {\n    case 'ok':\n      return `succeeded in ${took}`;\n    case 'timeout':\n      return `timed out after ${took}`;\n    case 'paused':\n      return `paused after ${took}`;\n    case 'aborted':\n      return `was aborted after ${took}${record.error ? ` (${record.error.message})` : ''}`;\n    default:\n      return `failed in ${took}${attemptCause(record)}`;\n  }\n}\n\n/**\n * A touching attempt whose effect is unknown says so (P3) — the outcome alone (\"failed\", \"timed out\") would read as\n * \"nothing happened\", and nothing may be retried blindly on that reading. `applied` and `none` add nothing the\n * outcome does not say. Absent on a target that touches nothing (byte identity).\n *\n *   Attempt 2 of 2 at Charge card timed out after 20s, effect on stripe unknown; stopped: no attempts left.\n */\nfunction effectClause(record: AttemptRecord): string {\n  return record.effect === 'unknown' && record.system !== undefined ? `, effect on ${record.system} unknown` : '';\n}\n\nfunction attemptCause(record: AttemptRecord): string {\n  if (!record.error) return '';\n  const category = record.category && record.category !== 'unknown' ? `${record.category}: ` : '';\n  return ` (${category}${record.error.message})`;\n}\n\nfunction attemptDecision(record: AttemptRecord): string {\n  if (record.next === 'retry') {\n    const left = record.timeLeftMs !== undefined ? ` (${formatDuration(Math.max(0, record.timeLeftMs))} left)` : '';\n    return (record.delayMs ? `, retrying in ${formatDuration(record.delayMs)}` : ', retrying immediately') + left;\n  }\n  if (record.next === 'done') return '';\n  switch (record.reason) {\n    case 'exhausted':\n      return '; stopped: no attempts left';\n    case 'declined':\n      // A throwing predicate is \"do not retry\" too — but it is a broken predicate, not a verdict.\n      return record.retryOnThrew ? '; stopped: retryOn threw' : '; stopped: retryOn declined';\n    case 'no-time-left': {\n      const facts = [\n        ...(record.timeLeftMs !== undefined ? [`${formatDuration(Math.max(0, record.timeLeftMs))} left`] : []),\n        ...(record.delayMs !== undefined ? [`next wait ${formatDuration(record.delayMs)}`] : []),\n      ];\n      return `; stopped: no time left${facts.length > 0 ? ` (${facts.join(', ')})` : ''}`;\n    }\n    case 'aborted':\n      // An attempt that threw the abort's own reason already says it (\"was aborted\"); an attempt that failed on\n      // its own while the run aborted says its failure, then why the series stopped.\n      return record.outcome === 'aborted' ? '' : '; stopped: the run was aborted';\n    case 'paused':\n      // The outcome already says it.\n      return '';\n    default:\n      return `; stopped: ${record.reason}`;\n  }\n}\n\n/** A duration as the narrative says it: whole milliseconds under a second, seconds (one decimal at most) above. */\nexport function formatDuration(ms: number): string {\n  if (ms < 1_000) return `${Math.round(ms)}ms`;\n  return `${Number((ms / 1_000).toFixed(1))}s`;\n}\n"]}

package/dist/esm/lib/engine/narrative/index.d.ts

@@ -1,11 +1,11 @@
 export type { CombinedNarrativeRecorderOptions } from './CombinedNarrativeRecorder.js';
 export { CombinedNarrativeRecorder } from './CombinedNarrativeRecorder.js';
-export type { BreakRenderContext, CombinedNarrativeEntry, CombinedNarrativeOptions, DecisionRenderContext, EmitRenderContext, ErrorRenderContext, ForkRenderContext, LoopRenderContext, NarrativeFormatter, OpRenderContext, SelectedRenderContext, StageRenderContext, SubflowRenderContext, } from './narrativeTypes.js';
+export type { AttemptRenderContext, BreakRenderContext, CombinedNarrativeEntry, CombinedNarrativeOptions, DecisionRenderContext, EmitRenderContext, ErrorRenderContext, ForkRenderContext, LoopRenderContext, NarrativeFormatter, OpRenderContext, SelectedRenderContext, StageRenderContext, SubflowRenderContext, } from './narrativeTypes.js';
 export { NullControlFlowNarrativeGenerator } from './NullControlFlowNarrativeGenerator.js';
 export type { IControlFlowNarrative } from './types.js';
 export { FlowRecorderDispatcher } from './FlowRecorderDispatcher.js';
 export { NarrativeFlowRecorder } from './NarrativeFlowRecorder.js';
-export type { FlowBreakEvent, FlowDecisionEvent, FlowErrorEvent, FlowForkEvent, FlowLoopEvent, FlowNextEvent, FlowRecorder, FlowRunEvent, FlowRunFailedEvent, FlowSelectedEvent, FlowStageEvent, FlowSubflowEvent, } from './types.js';
+export type { FlowAttemptEvent, FlowBreakEvent, FlowDecisionEvent, FlowErrorEvent, FlowForkEvent, FlowLoopEvent, FlowNextEvent, FlowRecorder, FlowRunEvent, FlowRunFailedEvent, FlowSelectedEvent, FlowStageEvent, FlowSubflowEvent, } from './types.js';
 export { AdaptiveNarrativeFlowRecorder } from './recorders/AdaptiveNarrativeFlowRecorder.js';
 export { MilestoneNarrativeFlowRecorder } from './recorders/MilestoneNarrativeFlowRecorder.js';
 export { ProgressiveNarrativeFlowRecorder } from './recorders/ProgressiveNarrativeFlowRecorder.js';

package/dist/esm/lib/engine/narrative/index.js

@@ -11,4 +11,4 @@ export { RLENarrativeFlowRecorder } from './recorders/RLENarrativeFlowRecorder.j
 export { SeparateNarrativeFlowRecorder } from './recorders/SeparateNarrativeFlowRecorder.js';
 export { SilentNarrativeFlowRecorder } from './recorders/SilentNarrativeFlowRecorder.js';
 export { WindowedNarrativeFlowRecorder } from './recorders/WindowedNarrativeFlowRecorder.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/engine/narrative/narrativeTypes.d.ts

@@ -5,12 +5,19 @@
  * The CombinedNarrativeBuilder class was removed in v1.0.
  * Use CombinedNarrativeRecorder (auto-attached by setEnableNarrative()) instead.
  */
+import type { AttemptRecord } from '../../attempt/types.js';
 export interface CombinedNarrativeEntry {
     type: 'stage' | 'step' | 'condition' | 'fork' | 'selector' | 'subflow' | 'loop' | 'break' | 'error' | 'pause' | 'resume' | 'emit'
-    /** A failed attempt at a stage with a declared retry policy, which was
-     *  retried. Rendered as a depth-1 sub-item of its stage, IN ORDER between
-     *  the attempts' reads and writes. */
-     | 'retry';
+    /** A failed attempt that was retried — rendered by 9.15–10.0 only. Since
+     *  10.1 the built-in narrative renders one `'attempt'` line per attempt
+     *  instead; the member stays so a narrative stored by an earlier release
+     *  still type-checks. */
+     | 'retry'
+    /** One attempt of a stage with a declared retry policy (10.1): its outcome,
+     *  duration, cause and decision. A depth-1 sub-item of its stage, IN ORDER
+     *  between the attempts' reads and writes; for a stage that failed, the
+     *  lines follow its `'error'` entry. */
+     | 'attempt';
     text: string;
     depth: number;
     stageName?: string;
@@ -108,21 +115,14 @@ export interface ErrorRenderContext {
     validationIssues?: string;
 }
 /**
- * Context passed to `NarrativeFormatter.renderRetry` — one failed attempt at a
- * stage with a declared retry policy, which the engine then retried. Fires only
- * for attempts followed by another attempt; the final failure goes to
- * `renderError`.
+ * Context passed to `NarrativeFormatter.renderAttempt` — one attempt of a stage
+ * with a declared retry policy (10.1), whatever its outcome.
  */
-export interface RetryRenderContext {
+export interface AttemptRenderContext {
+    /** The stage the attempt ran. */
     stageName: string;
-    /** Which attempt just failed, 1-based. */
-    attempt: number;
-    /** Total attempts the policy allows, including the first. */
-    maxAttempts: number;
-    /** Milliseconds waited before the next attempt. `0` = immediate. */
-    delayMs: number;
-    /** The failed attempt's error message. */
-    message: string;
+    /** The attempt: outcome, duration, category, the served error, and the retry-or-stop decision. */
+    record: AttemptRecord;
 }
 /**
  * Context passed to `NarrativeFormatter.renderEmit` — fires for every
@@ -193,11 +193,17 @@ export interface NarrativeFormatter {
     renderBreak?(ctx: BreakRenderContext): string;
     renderError?(ctx: ErrorRenderContext): string;
     /**
-     * Format a retried attempt into a narrative line. Rendered as a depth-1
-     * sub-item of its stage, positioned between the attempts' reads and writes
-     * so the narrative reads in the order things actually happened.
+     * Format one attempt of a retried stage (10.1) into a narrative line — a
+     * depth-1 sub-item of its stage, between the attempts' reads and writes (for
+     * a stage that failed for good, beneath its error line). It replaces the
+     * 9.15–10.0 `renderRetry`, which is removed: this line says "retrying" too.
+     *
+     *   - `string`    → use as the narrative line
+     *   - `null`      → deliberately exclude this entry
+     *   - `undefined` → fall back to the library's default sentence
+     *                   (`Attempt 2 of 3 at Fetch failed in 12ms (…), retrying in 1s.`)
      */
-    renderRetry?(ctx: RetryRenderContext): string;
+    renderAttempt?(ctx: AttemptRenderContext): string | null | undefined;
     /**
      * Format a consumer-emitted event (from `scope.$emit(name, payload)`)
      * into a narrative line.

package/dist/esm/lib/engine/narrative/narrativeTypes.js

@@ -6,4 +6,4 @@
  * Use CombinedNarrativeRecorder (auto-attached by setEnableNarrative()) instead.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"narrativeTypes.js","sourceRoot":"","sources":["../../../../../src/lib/engine/narrative/narrativeTypes.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG","sourcesContent":["/**\n * narrativeTypes — Shared type definitions for the narrative recorder system.\n *\n * Previously: CombinedNarrativeBuilder.ts (file renamed in post-release cleanup).\n * The CombinedNarrativeBuilder class was removed in v1.0.\n * Use CombinedNarrativeRecorder (auto-attached by setEnableNarrative()) instead.\n */\n\n// ---------------------------------------------------------------------------\n// Types (kept — used by CombinedNarrativeRecorder, FlowChartExecutor, etc.)\n// ---------------------------------------------------------------------------\n\nexport interface CombinedNarrativeEntry {\n  type:\n    | 'stage'\n    | 'step'\n    | 'condition'\n    | 'fork'\n    | 'selector'\n    | 'subflow'\n    | 'loop'\n    | 'break'\n    | 'error'\n    | 'pause'\n    | 'resume'\n    | 'emit'\n    /** A failed attempt at a stage with a declared retry policy, which was\n     *  retried. Rendered as a depth-1 sub-item of its stage, IN ORDER between\n     *  the attempts' reads and writes. */\n    | 'retry';\n  text: string;\n  depth: number;\n  stageName?: string;\n  /** Stable stage identifier from the builder (matches spec node id). Use for UI sync. */\n  stageId?: string;\n  /** Unique per-execution-step identifier. Format: [subflowPath/]stageId#executionIndex.\n   *  Links narrative entries to recorder Map entries for O(1) time-travel lookup.\n   *  Undefined only when TraversalContext is absent from the source event. */\n  runtimeStageId?: string;\n  stepNumber?: number;\n  /** Subflow ID when this entry was generated inside a subflow. Undefined for root-level. */\n  subflowId?: string;\n  /** Direction for subflow entries: 'entry' when entering, 'exit' when leaving.\n   *  Only present on entries with type === 'subflow'. Use this instead of text scanning. */\n  direction?: 'entry' | 'exit';\n  /** Scope key that was read or written. Only present on 'step' entries.\n   *  Use this for structured data extraction (e.g., grounding analysis)\n   *  instead of matching on rendered text strings. */\n  key?: string;\n  /** Raw value from the scope event — available for programmatic access and custom formatting.\n   *  Only present on 'step' entries (read/write ops). This is a live reference, not a clone.\n   *  When using ScopeFacade, redacted keys will have value '[REDACTED]' (sanitized upstream\n   *  by ScopeFacade before dispatching events — the recorder does not enforce redaction). */\n  rawValue?: unknown;\n}\n\nexport interface CombinedNarrativeOptions {\n  includeStepNumbers?: boolean;\n  includeValues?: boolean;\n  indent?: string;\n}\n\n// ---------------------------------------------------------------------------\n// NarrativeFormatter — Pluggable formatting for CombinedNarrativeRecorder\n// ---------------------------------------------------------------------------\n\n/** Context passed to renderStage. */\nexport interface StageRenderContext {\n  stageName: string;\n  stageNumber: number;\n  isFirst: boolean;\n  description?: string;\n  /** Loop iteration number (1-based). Present when this stage is visited via loopTo(). */\n  loopIteration?: number;\n  /** True for the stage a resume re-entered: its arrival was already told by the resume entry. */\n  resumed?: boolean;\n}\n\n/** Context passed to renderOp. Return null to exclude the entry. */\nexport interface OpRenderContext {\n  type: 'read' | 'write';\n  key: string;\n  rawValue: unknown;\n  valueSummary: string;\n  operation?: 'set' | 'update' | 'delete';\n  stepNumber: number;\n}\n\n/** Context passed to renderDecision. */\nexport interface DecisionRenderContext {\n  decider: string;\n  chosen: string;\n  description?: string;\n  rationale?: string;\n  /** Raw evidence from decide()/select() — available for custom rendering. */\n  evidence?: unknown;\n}\n\n/** Context passed to renderFork. */\nexport interface ForkRenderContext {\n  children: string[];\n}\n\n/** Context passed to renderSubflow. */\nexport interface SubflowRenderContext {\n  name: string;\n  direction: 'entry' | 'exit';\n  description?: string;\n  /** Mapped input values sent into the subflow. Present on entry. */\n  mappedInput?: Record<string, unknown>;\n  /** Subflow shared state at exit. Present on exit. */\n  outputState?: Record<string, unknown>;\n}\n\n/** Context passed to renderLoop. */\nexport interface LoopRenderContext {\n  target: string;\n  iteration: number;\n  description?: string;\n}\n\n/** Context passed to renderBreak. */\nexport interface BreakRenderContext {\n  stageName: string;\n}\n\n/** Context passed to renderSelected. */\nexport interface SelectedRenderContext {\n  selected: string[];\n  total: number;\n  /** Raw evidence from select() — available for custom rendering. */\n  evidence?: unknown;\n}\n\n/** Context passed to renderError. */\nexport interface ErrorRenderContext {\n  stageName: string;\n  message: string;\n  validationIssues?: string;\n}\n\n/**\n * Context passed to `NarrativeFormatter.renderRetry` — one failed attempt at a\n * stage with a declared retry policy, which the engine then retried. Fires only\n * for attempts followed by another attempt; the final failure goes to\n * `renderError`.\n */\nexport interface RetryRenderContext {\n  stageName: string;\n  /** Which attempt just failed, 1-based. */\n  attempt: number;\n  /** Total attempts the policy allows, including the first. */\n  maxAttempts: number;\n  /** Milliseconds waited before the next attempt. `0` = immediate. */\n  delayMs: number;\n  /** The failed attempt's error message. */\n  message: string;\n}\n\n/**\n * Context passed to `NarrativeFormatter.renderEmit` — fires for every\n * consumer-emitted event (`scope.$emit(name, payload)`). Carries the full\n * `EmitEvent` shape so formatters can render name + payload with full\n * context.\n */\nexport interface EmitRenderContext {\n  name: string;\n  payload: unknown;\n  stageName: string;\n  runtimeStageId: string;\n  subflowPath: readonly string[];\n  pipelineId: string;\n  timestamp: number;\n  /** Summary string — the library's default truncated payload preview. */\n  payloadSummary: string;\n}\n\n/**\n * Pluggable formatter for narrative output. Turns structured event context\n * objects into the text lines that make up the narrative array.\n *\n * ## Why \"Formatter\", not \"Renderer\"\n *\n * In web terminology \"renderer\" usually means \"turn data into a visible UI\"\n * (pixels, DOM, HTML). This interface does something smaller: it converts\n * event context into a text string. That is more accurately called a\n * *formatter*.\n *\n * ## Behaviour\n *\n * Each method is optional — unimplemented methods fall back to the default\n * English formatter. Return `null` from `renderOp` to exclude that entry\n * from the narrative entirely.\n *\n * @example\n * ```typescript\n * const rec = narrative({\n *   renderer: {\n *     renderOp(ctx) {\n *       if (ctx.key.startsWith('_internal')) return null; // filter out internal keys\n *       return `${ctx.type === 'read' ? 'Read' : 'Wrote'} ${ctx.key}: ${ctx.valueSummary}`;\n *     },\n *   },\n * });\n * ```\n */\nexport interface NarrativeFormatter {\n  renderStage?(ctx: StageRenderContext): string;\n  /**\n   * Format an op (scope read/write, or subflow-input key) into a narrative line.\n   *\n   *   - `string`    → use as the narrative line\n   *   - `null`      → deliberately exclude this entry from the narrative\n   *   - `undefined` → this formatter does not handle this op; fall back to\n   *                   the library's default template\n   *\n   * The `undefined` return lets a domain-aware formatter handle only the\n   * keys it knows about and leave the rest to the library default — without\n   * having to re-implement the whole default inline.\n   */\n  renderOp?(ctx: OpRenderContext): string | null | undefined;\n  renderDecision?(ctx: DecisionRenderContext): string;\n  renderFork?(ctx: ForkRenderContext): string;\n  renderSelected?(ctx: SelectedRenderContext): string;\n  renderSubflow?(ctx: SubflowRenderContext): string;\n  renderLoop?(ctx: LoopRenderContext): string;\n  renderBreak?(ctx: BreakRenderContext): string;\n  renderError?(ctx: ErrorRenderContext): string;\n  /**\n   * Format a retried attempt into a narrative line. Rendered as a depth-1\n   * sub-item of its stage, positioned between the attempts' reads and writes\n   * so the narrative reads in the order things actually happened.\n   */\n  renderRetry?(ctx: RetryRenderContext): string;\n  /**\n   * Format a consumer-emitted event (from `scope.$emit(name, payload)`)\n   * into a narrative line.\n   *\n   *   - `string`    → use as the narrative line\n   *   - `null`      → deliberately exclude this entry\n   *   - `undefined` → this formatter does not handle this emit; fall back\n   *                   to the library's default template\n   *\n   * Typical pattern: switch on `ctx.name` (or a prefix of it) and return a\n   * domain-specific text line for the event types you care about; return\n   * `undefined` for everything else so the default template handles it.\n   */\n  renderEmit?(ctx: EmitRenderContext): string | null | undefined;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"narrativeTypes.js","sourceRoot":"","sources":["../../../../../src/lib/engine/narrative/narrativeTypes.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG","sourcesContent":["/**\n * narrativeTypes — Shared type definitions for the narrative recorder system.\n *\n * Previously: CombinedNarrativeBuilder.ts (file renamed in post-release cleanup).\n * The CombinedNarrativeBuilder class was removed in v1.0.\n * Use CombinedNarrativeRecorder (auto-attached by setEnableNarrative()) instead.\n */\n\nimport type { AttemptRecord } from '../../attempt/types.js';\n\n// ---------------------------------------------------------------------------\n// Types (kept — used by CombinedNarrativeRecorder, FlowChartExecutor, etc.)\n// ---------------------------------------------------------------------------\n\nexport interface CombinedNarrativeEntry {\n  type:\n    | 'stage'\n    | 'step'\n    | 'condition'\n    | 'fork'\n    | 'selector'\n    | 'subflow'\n    | 'loop'\n    | 'break'\n    | 'error'\n    | 'pause'\n    | 'resume'\n    | 'emit'\n    /** A failed attempt that was retried — rendered by 9.15–10.0 only. Since\n     *  10.1 the built-in narrative renders one `'attempt'` line per attempt\n     *  instead; the member stays so a narrative stored by an earlier release\n     *  still type-checks. */\n    | 'retry'\n    /** One attempt of a stage with a declared retry policy (10.1): its outcome,\n     *  duration, cause and decision. A depth-1 sub-item of its stage, IN ORDER\n     *  between the attempts' reads and writes; for a stage that failed, the\n     *  lines follow its `'error'` entry. */\n    | 'attempt';\n  text: string;\n  depth: number;\n  stageName?: string;\n  /** Stable stage identifier from the builder (matches spec node id). Use for UI sync. */\n  stageId?: string;\n  /** Unique per-execution-step identifier. Format: [subflowPath/]stageId#executionIndex.\n   *  Links narrative entries to recorder Map entries for O(1) time-travel lookup.\n   *  Undefined only when TraversalContext is absent from the source event. */\n  runtimeStageId?: string;\n  stepNumber?: number;\n  /** Subflow ID when this entry was generated inside a subflow. Undefined for root-level. */\n  subflowId?: string;\n  /** Direction for subflow entries: 'entry' when entering, 'exit' when leaving.\n   *  Only present on entries with type === 'subflow'. Use this instead of text scanning. */\n  direction?: 'entry' | 'exit';\n  /** Scope key that was read or written. Only present on 'step' entries.\n   *  Use this for structured data extraction (e.g., grounding analysis)\n   *  instead of matching on rendered text strings. */\n  key?: string;\n  /** Raw value from the scope event — available for programmatic access and custom formatting.\n   *  Only present on 'step' entries (read/write ops). This is a live reference, not a clone.\n   *  When using ScopeFacade, redacted keys will have value '[REDACTED]' (sanitized upstream\n   *  by ScopeFacade before dispatching events — the recorder does not enforce redaction). */\n  rawValue?: unknown;\n}\n\nexport interface CombinedNarrativeOptions {\n  includeStepNumbers?: boolean;\n  includeValues?: boolean;\n  indent?: string;\n}\n\n// ---------------------------------------------------------------------------\n// NarrativeFormatter — Pluggable formatting for CombinedNarrativeRecorder\n// ---------------------------------------------------------------------------\n\n/** Context passed to renderStage. */\nexport interface StageRenderContext {\n  stageName: string;\n  stageNumber: number;\n  isFirst: boolean;\n  description?: string;\n  /** Loop iteration number (1-based). Present when this stage is visited via loopTo(). */\n  loopIteration?: number;\n  /** True for the stage a resume re-entered: its arrival was already told by the resume entry. */\n  resumed?: boolean;\n}\n\n/** Context passed to renderOp. Return null to exclude the entry. */\nexport interface OpRenderContext {\n  type: 'read' | 'write';\n  key: string;\n  rawValue: unknown;\n  valueSummary: string;\n  operation?: 'set' | 'update' | 'delete';\n  stepNumber: number;\n}\n\n/** Context passed to renderDecision. */\nexport interface DecisionRenderContext {\n  decider: string;\n  chosen: string;\n  description?: string;\n  rationale?: string;\n  /** Raw evidence from decide()/select() — available for custom rendering. */\n  evidence?: unknown;\n}\n\n/** Context passed to renderFork. */\nexport interface ForkRenderContext {\n  children: string[];\n}\n\n/** Context passed to renderSubflow. */\nexport interface SubflowRenderContext {\n  name: string;\n  direction: 'entry' | 'exit';\n  description?: string;\n  /** Mapped input values sent into the subflow. Present on entry. */\n  mappedInput?: Record<string, unknown>;\n  /** Subflow shared state at exit. Present on exit. */\n  outputState?: Record<string, unknown>;\n}\n\n/** Context passed to renderLoop. */\nexport interface LoopRenderContext {\n  target: string;\n  iteration: number;\n  description?: string;\n}\n\n/** Context passed to renderBreak. */\nexport interface BreakRenderContext {\n  stageName: string;\n}\n\n/** Context passed to renderSelected. */\nexport interface SelectedRenderContext {\n  selected: string[];\n  total: number;\n  /** Raw evidence from select() — available for custom rendering. */\n  evidence?: unknown;\n}\n\n/** Context passed to renderError. */\nexport interface ErrorRenderContext {\n  stageName: string;\n  message: string;\n  validationIssues?: string;\n}\n\n/**\n * Context passed to `NarrativeFormatter.renderAttempt` — one attempt of a stage\n * with a declared retry policy (10.1), whatever its outcome.\n */\nexport interface AttemptRenderContext {\n  /** The stage the attempt ran. */\n  stageName: string;\n  /** The attempt: outcome, duration, category, the served error, and the retry-or-stop decision. */\n  record: AttemptRecord;\n}\n\n/**\n * Context passed to `NarrativeFormatter.renderEmit` — fires for every\n * consumer-emitted event (`scope.$emit(name, payload)`). Carries the full\n * `EmitEvent` shape so formatters can render name + payload with full\n * context.\n */\nexport interface EmitRenderContext {\n  name: string;\n  payload: unknown;\n  stageName: string;\n  runtimeStageId: string;\n  subflowPath: readonly string[];\n  pipelineId: string;\n  timestamp: number;\n  /** Summary string — the library's default truncated payload preview. */\n  payloadSummary: string;\n}\n\n/**\n * Pluggable formatter for narrative output. Turns structured event context\n * objects into the text lines that make up the narrative array.\n *\n * ## Why \"Formatter\", not \"Renderer\"\n *\n * In web terminology \"renderer\" usually means \"turn data into a visible UI\"\n * (pixels, DOM, HTML). This interface does something smaller: it converts\n * event context into a text string. That is more accurately called a\n * *formatter*.\n *\n * ## Behaviour\n *\n * Each method is optional — unimplemented methods fall back to the default\n * English formatter. Return `null` from `renderOp` to exclude that entry\n * from the narrative entirely.\n *\n * @example\n * ```typescript\n * const rec = narrative({\n *   renderer: {\n *     renderOp(ctx) {\n *       if (ctx.key.startsWith('_internal')) return null; // filter out internal keys\n *       return `${ctx.type === 'read' ? 'Read' : 'Wrote'} ${ctx.key}: ${ctx.valueSummary}`;\n *     },\n *   },\n * });\n * ```\n */\nexport interface NarrativeFormatter {\n  renderStage?(ctx: StageRenderContext): string;\n  /**\n   * Format an op (scope read/write, or subflow-input key) into a narrative line.\n   *\n   *   - `string`    → use as the narrative line\n   *   - `null`      → deliberately exclude this entry from the narrative\n   *   - `undefined` → this formatter does not handle this op; fall back to\n   *                   the library's default template\n   *\n   * The `undefined` return lets a domain-aware formatter handle only the\n   * keys it knows about and leave the rest to the library default — without\n   * having to re-implement the whole default inline.\n   */\n  renderOp?(ctx: OpRenderContext): string | null | undefined;\n  renderDecision?(ctx: DecisionRenderContext): string;\n  renderFork?(ctx: ForkRenderContext): string;\n  renderSelected?(ctx: SelectedRenderContext): string;\n  renderSubflow?(ctx: SubflowRenderContext): string;\n  renderLoop?(ctx: LoopRenderContext): string;\n  renderBreak?(ctx: BreakRenderContext): string;\n  renderError?(ctx: ErrorRenderContext): string;\n  /**\n   * Format one attempt of a retried stage (10.1) into a narrative line — a\n   * depth-1 sub-item of its stage, between the attempts' reads and writes (for\n   * a stage that failed for good, beneath its error line). It replaces the\n   * 9.15–10.0 `renderRetry`, which is removed: this line says \"retrying\" too.\n   *\n   *   - `string`    → use as the narrative line\n   *   - `null`      → deliberately exclude this entry\n   *   - `undefined` → fall back to the library's default sentence\n   *                   (`Attempt 2 of 3 at Fetch failed in 12ms (…), retrying in 1s.`)\n   */\n  renderAttempt?(ctx: AttemptRenderContext): string | null | undefined;\n  /**\n   * Format a consumer-emitted event (from `scope.$emit(name, payload)`)\n   * into a narrative line.\n   *\n   *   - `string`    → use as the narrative line\n   *   - `null`      → deliberately exclude this entry\n   *   - `undefined` → this formatter does not handle this emit; fall back\n   *                   to the library's default template\n   *\n   * Typical pattern: switch on `ctx.name` (or a prefix of it) and return a\n   * domain-specific text line for the event types you care about; return\n   * `undefined` for everything else so the default template handles it.\n   */\n  renderEmit?(ctx: EmitRenderContext): string | null | undefined;\n}\n"]}

package/dist/esm/lib/engine/narrative/recorders/ManifestFlowRecorder.d.ts

@@ -9,6 +9,14 @@
  * The manifest reflects only subflows that were actually entered during
  * execution — unvisited branches are not included.
  *
+ * Attempts (10.1): a stage whose retry series retried, gave up or timed out gets a row —
+ * `{ stageId, stageName, runtimeStageId, attempts: AttemptSummary }` — on the
+ * entry of the subflow it ran in (`ManifestEntry.attempts`). The manifest has
+ * no entry for the top-level chart, so a top-level stage's row (or one whose
+ * subflow entry this recorder never saw) is served by `getRootAttempts()` and
+ * rides the snapshot bundle's `meta.rootAttempts` (absent when empty — the
+ * bundle's `data` keeps its shape).
+ *
  * @example
  * ```typescript
  * const manifest = new ManifestFlowRecorder();
@@ -22,7 +30,18 @@
  * const spec = manifest.getSpec('sf-credit-check');
  * ```
  */
-import type { FlowRecorder, FlowSubflowEvent, FlowSubflowRegisteredEvent } from '../types.js';
+import type { AttemptSummary } from '../../../attempt/types.js';
+import type { FlowAttemptEvent, FlowRecorder, FlowSubflowEvent, FlowSubflowRegisteredEvent } from '../types.js';
+/** One stage execution whose retry series retried, gave up or timed out, at a glance. */
+export interface ManifestAttemptRow {
+    /** Stable stage id (path-prefixed inside a subflow). */
+    stageId: string;
+    stageName: string;
+    /** The execution — the series' `runtimeStageId`. */
+    runtimeStageId: string;
+    /** The series at a glance — equal to the stage's `StageSnapshot.attemptSummary`. */
+    attempts: AttemptSummary;
+}
 /** A single entry in the subflow manifest tree. */
 export interface ManifestEntry {
     /** Subflow identifier — use for on-demand spec lookup. */
@@ -33,6 +52,8 @@ export interface ManifestEntry {
     description?: string;
     /** Nested subflows entered within this subflow. */
     children: ManifestEntry[];
+    /** Stages run directly in this subflow whose series retried, gave up or timed out — absent when none did. */
+    attempts?: ManifestAttemptRow[];
 }
 export declare class ManifestFlowRecorder implements FlowRecorder {
     readonly id: string;
@@ -42,12 +63,31 @@ export declare class ManifestFlowRecorder implements FlowRecorder {
     private roots;
     /** Full specs stored from dynamic registration events. */
     private specs;
+    /**
+     * Open entries by subflowId — where a stage's row lands. Not the stack: parallel subflow siblings exit out of
+     * stack order, so the entry a row belongs to may no longer be on it.
+     */
+    private openEntries;
+    /** Rows of top-level stages — the manifest has no entry for the top-level chart. */
+    private rootAttempts;
+    /** Per-series tallies of the series that retried, gave up or timed out. */
+    private readonly attemptBook;
     constructor(id?: string);
     onSubflowEntry(event: FlowSubflowEvent): void;
-    onSubflowExit(_event: FlowSubflowEvent): void;
+    onSubflowExit(event: FlowSubflowEvent): void;
+    /**
+     * A series' row lands once, when it ends, on the open entry of the subflow the stage ran in; a top-level
+     * stage's (or one whose entry this recorder never saw) on the root rows.
+     */
+    onAttempt(event: FlowAttemptEvent): void;
     onSubflowRegistered(event: FlowSubflowRegisteredEvent): void;
     /** Returns the manifest tree — lightweight, suitable for snapshot inclusion. */
     getManifest(): ManifestEntry[];
+    /**
+     * Rows of top-level stages whose series retried, gave up or timed out, in the order the series ended — plus any row of a
+     * subflow stage whose entry this recorder never saw (its path-prefixed `stageId` says where it ran).
+     */
+    getRootAttempts(): ManifestAttemptRow[];
     /**
      * Returns the full spec for a dynamically-registered subflow.
      * Only populated for subflows auto-registered at runtime (via StageNode
@@ -59,6 +99,9 @@ export declare class ManifestFlowRecorder implements FlowRecorder {
     /** Returns all stored spec IDs. */
     getSpecIds(): string[];
     toSnapshot(): {
+        meta?: {
+            rootAttempts: ManifestAttemptRow[];
+        } | undefined;
         name: string;
         description: string;
         preferredOperation: "translate";

package/dist/esm/lib/engine/narrative/recorders/ManifestFlowRecorder.js

@@ -9,6 +9,14 @@
  * The manifest reflects only subflows that were actually entered during
  * execution — unvisited branches are not included.
  *
+ * Attempts (10.1): a stage whose retry series retried, gave up or timed out gets a row —
+ * `{ stageId, stageName, runtimeStageId, attempts: AttemptSummary }` — on the
+ * entry of the subflow it ran in (`ManifestEntry.attempts`). The manifest has
+ * no entry for the top-level chart, so a top-level stage's row (or one whose
+ * subflow entry this recorder never saw) is served by `getRootAttempts()` and
+ * rides the snapshot bundle's `meta.rootAttempts` (absent when empty — the
+ * bundle's `data` keeps its shape).
+ *
  * @example
  * ```typescript
  * const manifest = new ManifestFlowRecorder();
@@ -22,6 +30,7 @@
  * const spec = manifest.getSpec('sf-credit-check');
  * ```
  */
+import { AttemptSeriesBook, subflowOfAttempt } from '../../../recorder/attemptSeries.js';
 export class ManifestFlowRecorder {
     id;
     /** Stack tracks nesting depth — current subflow is top of stack. */
@@ -30,6 +39,15 @@ export class ManifestFlowRecorder {
     roots = [];
     /** Full specs stored from dynamic registration events. */
     specs = new Map();
+    /**
+     * Open entries by subflowId — where a stage's row lands. Not the stack: parallel subflow siblings exit out of
+     * stack order, so the entry a row belongs to may no longer be on it.
+     */
+    openEntries = new Map();
+    /** Rows of top-level stages — the manifest has no entry for the top-level chart. */
+    rootAttempts = [];
+    /** Per-series tallies of the series that retried, gave up or timed out. */
+    attemptBook = new AttemptSeriesBook();
     constructor(id) {
         this.id = id ?? 'manifest';
     }
@@ -41,8 +59,10 @@ export class ManifestFlowRecorder {
             children: [],
         };
         this.stack.push(entry);
+        this.openEntries.set(entry.subflowId, entry);
     }
-    onSubflowExit(_event) {
+    onSubflowExit(event) {
+        this.openEntries.delete(event.subflowId ?? event.name);
         const completed = this.stack.pop();
         if (!completed)
             return;
@@ -54,6 +74,28 @@ export class ManifestFlowRecorder {
             this.roots.push(completed);
         }
     }
+    /**
+     * A series' row lands once, when it ends, on the open entry of the subflow the stage ran in; a top-level
+     * stage's (or one whose entry this recorder never saw) on the root rows.
+     */
+    onAttempt(event) {
+        const summary = this.attemptBook.add(event.record)?.summary;
+        if (!summary)
+            return;
+        const row = {
+            stageId: event.stageId,
+            stageName: event.stageName,
+            runtimeStageId: event.record.series,
+            attempts: summary,
+        };
+        const owner = this.openEntries.get(subflowOfAttempt(event) ?? '');
+        // A row whose subflow entry this recorder never saw (attached mid-run) is kept with the top-level rows — its
+        // path-prefixed `stageId` still says where it ran — never dropped.
+        if (owner)
+            (owner.attempts ??= []).push(row);
+        else
+            this.rootAttempts.push(row);
+    }
     onSubflowRegistered(event) {
         if (event.specStructure && !this.specs.has(event.subflowId)) {
             this.specs.set(event.subflowId, event.specStructure);
@@ -63,6 +105,13 @@ export class ManifestFlowRecorder {
     getManifest() {
         return [...this.roots];
     }
+    /**
+     * Rows of top-level stages whose series retried, gave up or timed out, in the order the series ended — plus any row of a
+     * subflow stage whose entry this recorder never saw (its path-prefixed `stageId` says where it ran).
+     */
+    getRootAttempts() {
+        return [...this.rootAttempts];
+    }
     /**
      * Returns the full spec for a dynamically-registered subflow.
      * Only populated for subflows auto-registered at runtime (via StageNode
@@ -83,6 +132,7 @@ export class ManifestFlowRecorder {
             description: 'Translator (FlowRecorder) — subflow catalog built during traversal',
             preferredOperation: 'translate',
             data: this.getManifest(),
+            ...(this.rootAttempts.length > 0 && { meta: { rootAttempts: this.getRootAttempts() } }),
         };
     }
     /** Clears state for reuse. */
@@ -90,6 +140,9 @@ export class ManifestFlowRecorder {
         this.stack = [];
         this.roots = [];
         this.specs.clear();
+        this.openEntries = new Map();
+        this.rootAttempts = [];
+        this.attemptBook.clear();
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ManifestFlowRecorder.js","sourceRoot":"","sources":["../../../../../../src/lib/engine/narrative/recorders/ManifestFlowRecorder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ManifestFlowRecorder — Builds a lightweight subflow manifest during traversal.\n *\n * Collects subflow metadata (ID, name, description) as a side effect of\n * observing traversal events. Produces a tree structure suitable for LLM\n * navigation: lightweight enough to include in snapshots, with on-demand\n * access to full specs via getSpec().\n *\n * The manifest reflects only subflows that were actually entered during\n * execution — unvisited branches are not included.\n *\n * Attempts (10.1): a stage whose retry series retried, gave up or timed out gets a row —\n * `{ stageId, stageName, runtimeStageId, attempts: AttemptSummary }` — on the\n * entry of the subflow it ran in (`ManifestEntry.attempts`). The manifest has\n * no entry for the top-level chart, so a top-level stage's row (or one whose\n * subflow entry this recorder never saw) is served by `getRootAttempts()` and\n * rides the snapshot bundle's `meta.rootAttempts` (absent when empty — the\n * bundle's `data` keeps its shape).\n *\n * @example\n * ```typescript\n * const manifest = new ManifestFlowRecorder();\n * executor.attachFlowRecorder(manifest);\n * await executor.run({ input: data });\n *\n * // Lightweight tree of subflow IDs + descriptions\n * const tree = manifest.getManifest();\n *\n * // Full spec for a specific subflow (if available)\n * const spec = manifest.getSpec('sf-credit-check');\n * ```\n */\n\nimport type { AttemptSummary } from '../../../attempt/types.js';\nimport { AttemptSeriesBook, subflowOfAttempt } from '../../../recorder/attemptSeries.js';\nimport type { FlowAttemptEvent, FlowRecorder, FlowSubflowEvent, FlowSubflowRegisteredEvent } from '../types.js';\n\n/** One stage execution whose retry series retried, gave up or timed out, at a glance. */\nexport interface ManifestAttemptRow {\n  /** Stable stage id (path-prefixed inside a subflow). */\n  stageId: string;\n  stageName: string;\n  /** The execution — the series' `runtimeStageId`. */\n  runtimeStageId: string;\n  /** The series at a glance — equal to the stage's `StageSnapshot.attemptSummary`. */\n  attempts: AttemptSummary;\n}\n\n/** A single entry in the subflow manifest tree. */\nexport interface ManifestEntry {\n  /** Subflow identifier — use for on-demand spec lookup. */\n  subflowId: string;\n  /** Human-readable name. */\n  name: string;\n  /** Build-time description of what this subflow does. */\n  description?: string;\n  /** Nested subflows entered within this subflow. */\n  children: ManifestEntry[];\n  /** Stages run directly in this subflow whose series retried, gave up or timed out — absent when none did. */\n  attempts?: ManifestAttemptRow[];\n}\n\nexport class ManifestFlowRecorder implements FlowRecorder {\n  readonly id: string;\n\n  /** Stack tracks nesting depth — current subflow is top of stack. */\n  private stack: ManifestEntry[] = [];\n  /** Root-level subflows (not nested inside another subflow). */\n  private roots: ManifestEntry[] = [];\n  /** Full specs stored from dynamic registration events. */\n  private specs = new Map<string, unknown>();\n  /**\n   * Open entries by subflowId — where a stage's row lands. Not the stack: parallel subflow siblings exit out of\n   * stack order, so the entry a row belongs to may no longer be on it.\n   */\n  private openEntries = new Map<string, ManifestEntry>();\n  /** Rows of top-level stages — the manifest has no entry for the top-level chart. */\n  private rootAttempts: ManifestAttemptRow[] = [];\n  /** Per-series tallies of the series that retried, gave up or timed out. */\n  private readonly attemptBook = new AttemptSeriesBook();\n\n  constructor(id?: string) {\n    this.id = id ?? 'manifest';\n  }\n\n  onSubflowEntry(event: FlowSubflowEvent): void {\n    const entry: ManifestEntry = {\n      subflowId: event.subflowId ?? event.name,\n      name: event.name,\n      description: event.description,\n      children: [],\n    };\n    this.stack.push(entry);\n    this.openEntries.set(entry.subflowId, entry);\n  }\n\n  onSubflowExit(event: FlowSubflowEvent): void {\n    this.openEntries.delete(event.subflowId ?? event.name);\n    const completed = this.stack.pop();\n    if (!completed) return;\n\n    const parent = this.stack[this.stack.length - 1];\n    if (parent) {\n      parent.children.push(completed);\n    } else {\n      this.roots.push(completed);\n    }\n  }\n\n  /**\n   * A series' row lands once, when it ends, on the open entry of the subflow the stage ran in; a top-level\n   * stage's (or one whose entry this recorder never saw) on the root rows.\n   */\n  onAttempt(event: FlowAttemptEvent): void {\n    const summary = this.attemptBook.add(event.record)?.summary;\n    if (!summary) return;\n    const row: ManifestAttemptRow = {\n      stageId: event.stageId,\n      stageName: event.stageName,\n      runtimeStageId: event.record.series,\n      attempts: summary,\n    };\n    const owner = this.openEntries.get(subflowOfAttempt(event) ?? '');\n    // A row whose subflow entry this recorder never saw (attached mid-run) is kept with the top-level rows — its\n    // path-prefixed `stageId` still says where it ran — never dropped.\n    if (owner) (owner.attempts ??= []).push(row);\n    else this.rootAttempts.push(row);\n  }\n\n  onSubflowRegistered(event: FlowSubflowRegisteredEvent): void {\n    if (event.specStructure && !this.specs.has(event.subflowId)) {\n      this.specs.set(event.subflowId, event.specStructure);\n    }\n  }\n\n  /** Returns the manifest tree — lightweight, suitable for snapshot inclusion. */\n  getManifest(): ManifestEntry[] {\n    return [...this.roots];\n  }\n\n  /**\n   * Rows of top-level stages whose series retried, gave up or timed out, in the order the series ended — plus any row of a\n   * subflow stage whose entry this recorder never saw (its path-prefixed `stageId` says where it ran).\n   */\n  getRootAttempts(): ManifestAttemptRow[] {\n    return [...this.rootAttempts];\n  }\n\n  /**\n   * Returns the full spec for a dynamically-registered subflow.\n   * Only populated for subflows auto-registered at runtime (via StageNode\n   * return with subflowDef). Statically-configured subflows are not included\n   * even if they appear in getManifest(). Use FlowChart.buildTimeStructure\n   * to access statically-defined subflow specs.\n   */\n  getSpec(subflowId: string): unknown | undefined {\n    return this.specs.get(subflowId);\n  }\n\n  /** Returns all stored spec IDs. */\n  getSpecIds(): string[] {\n    return Array.from(this.specs.keys());\n  }\n\n  toSnapshot() {\n    return {\n      name: 'Manifest',\n      description: 'Translator (FlowRecorder) — subflow catalog built during traversal',\n      preferredOperation: 'translate' as const,\n      data: this.getManifest(),\n      ...(this.rootAttempts.length > 0 && { meta: { rootAttempts: this.getRootAttempts() } }),\n    };\n  }\n\n  /** Clears state for reuse. */\n  clear(): void {\n    this.stack = [];\n    this.roots = [];\n    this.specs.clear();\n    this.openEntries = new Map();\n    this.rootAttempts = [];\n    this.attemptBook.clear();\n  }\n}\n"]}

package/dist/esm/lib/engine/narrative/recorders/index.d.ts

@@ -1,5 +1,5 @@
 export { AdaptiveNarrativeFlowRecorder } from './AdaptiveNarrativeFlowRecorder.js';
-export type { ManifestEntry } from './ManifestFlowRecorder.js';
+export type { ManifestAttemptRow, ManifestEntry } from './ManifestFlowRecorder.js';
 export { ManifestFlowRecorder } from './ManifestFlowRecorder.js';
 export { MilestoneNarrativeFlowRecorder } from './MilestoneNarrativeFlowRecorder.js';
 export { ProgressiveNarrativeFlowRecorder } from './ProgressiveNarrativeFlowRecorder.js';