@entifix/workflow 0.16.0 → 0.17.0

package/dist/interpreter/slip-workflow.d.ts

@@ -65,7 +65,7 @@ export declare class InterpreterOptionsTag extends InterpreterOptionsTag_base {
 export declare const SlipWorkflow: Workflow.Workflow<"entifix/slip", Schema.Struct<{
     key: Schema.String;
     slip: Schema.Struct<{
-        readonly slipVersion: Schema.Literal<1>;
+        readonly slipVersion: Schema.Literals<readonly [1, 2]>;
         readonly flowId: Schema.String;
         readonly recipe: Schema.String;
         readonly requiresCommitPoint: Schema.optionalKey<Schema.Boolean>;

package/dist/interpreter/slip-workflow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slip-workflow.d.ts","sourceRoot":"","sources":["../../src/interpreter/slip-workflow.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EACpB,IAAI,EAGL,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAEL,KAAK,cAAc,EAMpB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,WAAW,EACX,iBAAiB,EAIjB,SAAS,EACT,oBAAoB,EACrB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,KAAK,EACL,OAAO,EACP,MAAM,EAIN,MAAM,EAEP,MAAM,QAAQ,CAAC;AAChB,OAAO,EAGL,eAAe,EACf,QAAQ,EACT,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAGL,kBAAkB,EACnB,MAAM,gCAAgC,CAAC;AAGxC;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,KAAK,CAAC,cAAc,EAAE,OAAO,CAShE,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,WAAW,8EAKtB,CAAC;;;;AAqCH,uEAAuE;AACvE,qBAAa,gBAAiB,SAAQ,qBAKrC;CAAG;AAEJ,6EAA6E;AAC7E,MAAM,WAAW,SAAS;IACxB,6BAA6B;IAC7B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,0DAA0D;IAC1D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,yCAAyC;IACzC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,eAAO,MAAM,kBAAkB,EAAE,SAIhC,CAAC;AAEF,oFAAoF;AACpF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,wDAAwD;IACxD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAClB,WAAW,EAAE,MAAM,KAChB,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC,GAAG,SAAS,CAAC;CAC1D;;AAED;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,0BAGA;CAAG;AAE9C;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+LAYvB,CAAC;AAEH,6EAA6E;AAC7E,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,kEAC+B,CAAC;AA+WpE,4EAA4E;AAC5E,eAAO,MAAM,uBAAuB,EAAE,SAAS,MAAM,EACd,CAAC;AAExC,eAAO,MAAM,aAAa,GAAI,MAAM,IAAI,waACF,CAAC;AAEvC,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB,GAAI,SAAS,kBAAkB,mPAK1D,CAAC"}
+{"version":3,"file":"slip-workflow.d.ts","sourceRoot":"","sources":["../../src/interpreter/slip-workflow.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EACpB,IAAI,EAGL,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAEL,KAAK,cAAc,EAMpB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,WAAW,EACX,iBAAiB,EAIjB,SAAS,EACT,oBAAoB,EACrB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,KAAK,EACL,OAAO,EACP,MAAM,EAIN,MAAM,EAEP,MAAM,QAAQ,CAAC;AAChB,OAAO,EAGL,eAAe,EACf,QAAQ,EACT,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAGL,kBAAkB,EACnB,MAAM,gCAAgC,CAAC;AAGxC;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,KAAK,CAAC,cAAc,EAAE,OAAO,CAShE,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,WAAW,8EAKtB,CAAC;;;;AAqCH,uEAAuE;AACvE,qBAAa,gBAAiB,SAAQ,qBAKrC;CAAG;AAEJ,6EAA6E;AAC7E,MAAM,WAAW,SAAS;IACxB,6BAA6B;IAC7B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,0DAA0D;IAC1D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,yCAAyC;IACzC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,eAAO,MAAM,kBAAkB,EAAE,SAIhC,CAAC;AAEF,oFAAoF;AACpF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,wDAAwD;IACxD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAClB,WAAW,EAAE,MAAM,KAChB,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC,GAAG,SAAS,CAAC;CAC1D;;AAED;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,0BAGA;CAAG;AAE9C;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+LAYvB,CAAC;AAEH,6EAA6E;AAC7E,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,kEAC+B,CAAC;AA+XpE,4EAA4E;AAC5E,eAAO,MAAM,uBAAuB,EAAE,SAAS,MAAM,EACd,CAAC;AAExC,eAAO,MAAM,aAAa,GAAI,MAAM,IAAI,waACF,CAAC;AAEvC,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB,GAAI,SAAS,kBAAkB,mPAK1D,CAAC"}

package/dist/interpreter/slip-workflow.js

@@ -114,32 +114,7 @@ const segmentOf = (step)=>step.segment === undefined ? undefined : [
         ...groups.values()
     ];
 };
-/**
- * Interprets a pinned slip of grammar version 1
- * ([ADR 0016](../../../../../docs/adr/0016-a-flow-engine-port-and-a-durable-workflow-adapter.md)):
- * each step is an Activity named after it and keyed `<flowId>:<step>`, so a
- * resumed flow replays what already ran and calls a participant at most once
- * per step. Inside the Activity the call runs under the participant's
- * breaker and bulkhead and the retry budget, each attempt bounded and the
- * step as a whole bounded; nothing retries outside it.
- *
- * - Before and at the commit point, a failure — a breaker already open
- *   included, which fails fast — compensates what succeeded, in reverse, and
- *   the flow ends `compensated`.
- * - After it, a failure suspends the flow at that step: the money is taken,
- *   so the flow rolls forward when the participant comes back, never back.
- * - A `wait` step parks the flow on a durable deferred its signal completes,
- *   raced with a durable clock when it names `timeoutMs`; it may name a
- *   `correlation`, so a sender that knows the order rather than the flow can
- *   complete it.
- * - The segments of a stage run at once, bounded, and join before the next.
- *
- * Every transition is announced as a `flow.*` event through the outbox, by an
- * Activity, so it is written once whatever replays. Compensation is explicit
- * rather than a workflow finalizer, so the record says `compensated` only
- * after the last undoing has run — and an undoing that fails stops the flow
- * `failed` at that step instead of pretending.
- */ const interpretV1 = (slip)=>Effect.gen(function*() {
+const walkSlip = (slip, grammar)=>Effect.gen(function*() {
         const options = yield* InterpreterOptionsTag;
         const dials = _extends({}, DEFAULT_FLOW_DIALS, options.dials);
         const { catalog } = options;
@@ -241,6 +216,11 @@ const segmentOf = (step)=>step.segment === undefined ? undefined : [
                 } : {}, accepts === undefined ? {} : {
                     accepts
                 }));
+                // Past the commit point the caller's write has landed, and the wait is
+                // for someone else — a courier, a person — so the flow says so and a
+                // browser holding the write pending can let it go. Before it, nothing
+                // has landed, and the flow stays silent.
+                if (grammar.announcesCommittedWaits && commitPoint !== -1 && steps.indexOf(step) > commitPoint) yield* announce('flow.waiting', step.step, ordinalOf(step));
                 const signalled = DurableDeferred.await(waitFor(step.step));
                 const timeoutMs = (_step_parameters1 = step.parameters) == null ? void 0 : _step_parameters1['timeoutMs'];
                 // A durable race, so a replay answers the branch that won rather than
@@ -363,7 +343,12 @@ const segmentOf = (step)=>step.segment === undefined ? undefined : [
  * edit to an existing one; the journal replay holds every entry to its
  * recorded command sequence.
  */ const INTERPRETERS = {
-    1: interpretV1
+    1: (slip)=>walkSlip(slip, {
+            announcesCommittedWaits: false
+        }),
+    2: (slip)=>walkSlip(slip, {
+            announcesCommittedWaits: true
+        })
 };
 /** Every `slipVersion` the interpreter walks — each must have a journal. */ export const interpretedSlipVersions = Object.keys(INTERPRETERS).map(Number);
 export const interpretSlip = (slip)=>INTERPRETERS[slip.slipVersion](slip);

package/dist/interpreter/slip-workflow.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/interpreter/slip-workflow.ts"],"sourcesContent":["import {\n  type FragmentCatalog,\n  Slip,\n  type SlipStep,\n  slipSteps,\n} from '@entifix/business/flow';\nimport {\n  decodeProblem,\n  type EntifixFailure,\n  Failure,\n  isFailure,\n  JsonBody,\n  problemOf,\n  Timeout,\n} from '@entifix/core';\nimport {\n  BulkheadTag,\n  CircuitBreakerTag,\n  flowEvent,\n  type FlowEventName,\n  On,\n  OutboxTag,\n  ParticipantClientTag,\n} from '@entifix/transactions';\nimport {\n  Cause,\n  Context,\n  Effect,\n  Exit,\n  Metric,\n  Schedule,\n  Schema,\n  SchemaTransformation,\n} from 'effect';\nimport {\n  Activity,\n  DurableClock,\n  DurableDeferred,\n  Workflow,\n} from 'effect/workflow';\n\nimport {\n  type FlowRecordPatch,\n  flowStates,\n  FlowStatusStoreTag,\n} from '../status/flow-status-store.js';\nimport { makeBindings } from './bindings.js';\n\n/**\n * A failure as an Activity journals it: the problem body on the way in, the\n * failure its code names on the way out, so a resumed flow sees the typed\n * refusal a participant sent rather than a cast.\n */\nexport const JournaledFailure: Schema.Codec<EntifixFailure, unknown> =\n  Schema.Unknown.pipe(\n    Schema.decodeTo(\n      Schema.declare((value): value is EntifixFailure => isFailure(value)),\n      SchemaTransformation.transform({\n        decode: body => decodeProblem(body),\n        encode: failure => problemOf(failure),\n      }),\n    ),\n  );\n\n/**\n * How a flow ended, as the workflow's own result: every step ran, or a\n * refusal before the commit point was undone, or an undoing itself failed and\n * the flow stopped where it was — which a person has to look at — or a wait\n * that strands on its timeout ran out, which a person has to look at too.\n */\nexport const FlowOutcome = Schema.Literals([\n  'completed',\n  'compensated',\n  'failed',\n  'stranded',\n]);\n\n/**\n * What a wait does when its `timeoutMs` runs out, from its `onTimeout`\n * parameter: answer as if signalled with an outcome a later guard branches\n * on, strand the flow for an operator, or — named neither — fail as any step\n * does, which past the commit point suspends it.\n */\ntype OnTimeout =\n  | { readonly kind: 'outcome'; readonly outcome: string }\n  | { readonly kind: 'strand' }\n  | { readonly kind: 'fail' };\n\nconst onTimeoutOf = (step: SlipStep): OnTimeout => {\n  const named = step.parameters?.['onTimeout'];\n  if (named === 'strand') return { kind: 'strand' };\n  const outcome =\n    typeof named === 'object' && named !== null\n      ? (named as { readonly outcome?: unknown }).outcome\n      : undefined;\n  return typeof outcome === 'string'\n    ? { kind: 'outcome', outcome }\n    : { kind: 'fail' };\n};\n\n/** The outcome a wait was answered with: its signal's `outcome`, when a string. */\nconst outcomeOf = (answer: unknown): string | undefined => {\n  const named =\n    typeof answer === 'object' && answer !== null\n      ? (answer as { readonly outcome?: unknown }).outcome\n      : undefined;\n  return typeof named === 'string' ? named : undefined;\n};\n\n/** The race's answer when a wait that strands on its timeout ran out. */\nconst STRANDED = Symbol.for('@entifix/workflow/stranded');\n\n/** A durable wait that outlived its timeout before its signal came. */\nexport class FlowWaitTimedOut extends Failure.timeout<FlowWaitTimedOut>()(\n  'FlowWaitTimedOut',\n  'flowWaitTimedOut',\n  { step: Schema.String },\n  { message: ({ step }) => `the wait at '${step}' timed out` },\n) {}\n\n/** How long a flow gives each participant call, and each step as a whole. */\nexport interface FlowDials {\n  /** One attempt at a call. */\n  readonly attemptTimeoutMs: number;\n  /** Every attempt at a step together, retries included. */\n  readonly stepTimeoutMs: number;\n  /** Segments of one stage run at once. */\n  readonly concurrency: number;\n}\n\nexport const DEFAULT_FLOW_DIALS: FlowDials = {\n  attemptTimeoutMs: 10_000,\n  stepTimeoutMs: 60_000,\n  concurrency: 4,\n};\n\n/** What the interpreter runs a slip with: the catalog, who announces, the dials. */\nexport interface InterpreterOptions {\n  readonly catalog: FragmentCatalog;\n  /** The slice the `flow.*` events are announced from. */\n  readonly source: string;\n  readonly dials?: Partial<FlowDials>;\n  /**\n   * One participant's own attempt and step bounds, over `dials` — the same\n   * shape the breaker's `dialsFor` and the bulkhead's `permitsFor` take, so a\n   * participant's dials are one row set however many guards read them.\n   */\n  readonly dialsFor?: (\n    participant: string,\n  ) => Partial<Omit<FlowDials, 'concurrency'>> | undefined;\n}\n\n/**\n * The interpreter's options, provided to the workflow it is registered with —\n * the payload is the slip; the catalog and dials are the deployment's.\n */\nexport class InterpreterOptionsTag extends Context.Service<\n  InterpreterOptionsTag,\n  InterpreterOptions\n>()('@entifix/workflow/InterpreterOptions') {}\n\n/**\n * The one workflow every flow runs as: its payload is the pinned slip and the\n * idempotency key that started it\n * ([ADR 0016](../../../../../docs/adr/0016-a-flow-engine-port-and-a-durable-workflow-adapter.md)).\n * The execution id derives from the key, so the same key is the same flow.\n *\n * A flow suspended past its commit point is resumed on the retry schedule:\n * a participant that comes back gets the step again, idempotently.\n */\nexport const SlipWorkflow = Workflow.make('entifix/slip', {\n  payload: { key: Schema.String, slip: Slip },\n  idempotencyKey: payload => payload.key,\n  success: FlowOutcome,\n  // Its failure is what suspends it past the commit point; it is never the\n  // flow's result.\n  error: JournaledFailure,\n  // Doubling from a second, never more than a minute apart.\n  suspendedRetrySchedule: Schedule.min([\n    Schedule.exponential('1 second'),\n    Schedule.spaced('1 minute'),\n  ]),\n});\n\n/** The durable wait a `wait` step parks on, addressed by the step's name. */\nexport const waitFor = (step: string) =>\n  DurableDeferred.make(`wait:${step}`, { success: Schema.Unknown });\n\n/** A step's failure, with the step it happened at. */\ninterface StepFailed {\n  readonly step: SlipStep;\n  readonly failure: EntifixFailure;\n}\n\nconst segmentOf = (step: SlipStep) =>\n  step.segment === undefined\n    ? undefined\n    : [step.segment.vendor, step.segment.paymentMethod]\n        .filter(Boolean)\n        .join('/');\n\n/**\n * A stage's steps as the groups that run at once: one group per segment when\n * every step names one — a basket's vendors, joined before the shared pivot —\n * and otherwise one group, in order.\n */\nconst groupsOf = (steps: readonly SlipStep[]): readonly SlipStep[][] => {\n  if (steps.some(step => segmentOf(step) === undefined)) return [[...steps]];\n  const groups = new Map<string, SlipStep[]>();\n  for (const step of steps) {\n    const key = segmentOf(step) as string;\n    groups.set(key, [...(groups.get(key) ?? []), step]);\n  }\n  return [...groups.values()];\n};\n\n/**\n * Interprets a pinned slip of grammar version 1\n * ([ADR 0016](../../../../../docs/adr/0016-a-flow-engine-port-and-a-durable-workflow-adapter.md)):\n * each step is an Activity named after it and keyed `<flowId>:<step>`, so a\n * resumed flow replays what already ran and calls a participant at most once\n * per step. Inside the Activity the call runs under the participant's\n * breaker and bulkhead and the retry budget, each attempt bounded and the\n * step as a whole bounded; nothing retries outside it.\n *\n * - Before and at the commit point, a failure — a breaker already open\n *   included, which fails fast — compensates what succeeded, in reverse, and\n *   the flow ends `compensated`.\n * - After it, a failure suspends the flow at that step: the money is taken,\n *   so the flow rolls forward when the participant comes back, never back.\n * - A `wait` step parks the flow on a durable deferred its signal completes,\n *   raced with a durable clock when it names `timeoutMs`; it may name a\n *   `correlation`, so a sender that knows the order rather than the flow can\n *   complete it.\n * - The segments of a stage run at once, bounded, and join before the next.\n *\n * Every transition is announced as a `flow.*` event through the outbox, by an\n * Activity, so it is written once whatever replays. Compensation is explicit\n * rather than a workflow finalizer, so the record says `compensated` only\n * after the last undoing has run — and an undoing that fails stops the flow\n * `failed` at that step instead of pretending.\n */\nconst interpretV1 = (slip: Slip) =>\n  Effect.gen(function* () {\n    const options = yield* InterpreterOptionsTag;\n    const dials = { ...DEFAULT_FLOW_DIALS, ...options.dials };\n    const { catalog } = options;\n    const steps = slipSteps(slip);\n    const ordinalOf = (step: SlipStep) => steps.indexOf(step) + 1;\n    const commitPoint = steps.findIndex(\n      step => catalog.get(step.ref)?.kind === 'pivot',\n    );\n    const bindings = makeBindings();\n    const done: SlipStep[] = [];\n    /** What each wait was answered with, by step name — what a guard reads. */\n    const answered = new Map<string, string | undefined>();\n    /** Steps a guard passed over; a step guarded on one of them is skipped too. */\n    const skipped = new Set<string>();\n    /** The wait whose timeout stranded the flow, once one has. */\n    let stranded: SlipStep | undefined;\n\n    const record = (name: string, patch: FlowRecordPatch) =>\n      Activity.make({\n        name,\n        execute: Effect.flatMap(FlowStatusStoreTag, store =>\n          store.update(slip.flowId, patch),\n        ).pipe(\n          Effect.andThen(\n            Metric.update(\n              Metric.withAttributes(flowStates, {\n                state: patch.state,\n                source: options.source,\n              }),\n              1,\n            ),\n          ),\n          Effect.orDie,\n        ),\n      });\n\n    const announce = (\n      name: FlowEventName,\n      step: string,\n      ordinal: number,\n      failure?: EntifixFailure,\n    ) =>\n      Activity.make({\n        name: `announce:${name}:${step}`,\n        execute: Effect.flatMap(OutboxTag, outbox =>\n          outbox.enqueue(\n            flowEvent({\n              name,\n              source: options.source,\n              at: new Date().toISOString(),\n              step: `${name}:${step}`,\n              ordinal,\n              audience: [\n                { kind: 'flow', id: slip.flowId },\n                ...(slip.audience ?? []),\n              ],\n              data: {\n                flowId: slip.flowId,\n                definition: slip.recipe,\n                slipVersion: slip.slipVersion,\n                step,\n                ...(failure === undefined\n                  ? {}\n                  : {\n                      failure: {\n                        code: failure.code,\n                        category: failure.category,\n                      },\n                    }),\n              },\n            }),\n          ),\n        ).pipe(Effect.orDie),\n      });\n\n    /** One call, bounded, under the participant's breaker, bulkhead and budget. */\n    const guarded = (\n      step: SlipStep,\n      attempt: Effect.Effect<unknown, EntifixFailure>,\n    ) =>\n      Effect.gen(function* () {\n        const key = step.participant ?? 'participant';\n        const bounds = { ...dials, ...options.dialsFor?.(key) };\n        const breaker = yield* CircuitBreakerTag;\n        const bulkhead = yield* BulkheadTag;\n        const timedOut = () => Effect.fail(new Timeout({ dependency: key }));\n        return yield* breaker\n          .guard(key)(\n            bulkhead.withPermit(key)(\n              attempt.pipe(\n                Effect.timeoutOrElse({\n                  duration: bounds.attemptTimeoutMs,\n                  orElse: timedOut,\n                }),\n              ),\n            ),\n          )\n          .pipe(\n            On(Failure.isFamily('technical')).retry({\n              key: { dependency: key },\n              idempotent: true,\n            }),\n            Effect.timeoutOrElse({\n              duration: bounds.stepTimeoutMs,\n              orElse: timedOut,\n            }),\n          );\n      });\n\n    const call = (step: SlipStep, kind: 'action' | 'compensation') =>\n      Activity.make({\n        name: `${step.step}:${kind}`,\n        // Whatever the participant answered, as JSON — `undefined` included,\n        // which a journal cannot otherwise hold.\n        success: JsonBody,\n        error: JournaledFailure,\n        execute: Effect.flatMap(ParticipantClientTag, participant =>\n          guarded(\n            step,\n            participant.call({\n              step,\n              kind,\n              idempotencyKey:\n                kind === 'action'\n                  ? `${slip.flowId}:${step.step}`\n                  : `${slip.flowId}:${step.step}:compensation`,\n              inputs: bindings.inputsFor(step, catalog.get(step.ref), kind),\n            }),\n          ),\n        ),\n      });\n\n    const wait = (step: SlipStep) =>\n      Effect.gen(function* () {\n        const correlation = step.parameters?.['correlation'];\n        const accepts = catalog.get(step.ref)?.outcomes;\n        const onTimeout = onTimeoutOf(step);\n        yield* record(`status:${step.step}:waiting`, {\n          state: 'waiting',\n          step: step.step,\n          waitingFor: step.step,\n          ...(typeof correlation === 'string' ? { correlation } : {}),\n          ...(accepts === undefined ? {} : { accepts }),\n        });\n        const signalled = DurableDeferred.await(waitFor(step.step));\n        const timeoutMs = step.parameters?.['timeoutMs'];\n        // A durable race, so a replay answers the branch that won rather than\n        // racing again.\n        const answer =\n          typeof timeoutMs === 'number'\n            ? yield* DurableDeferred.raceAll({\n                name: `race:${step.step}`,\n                success: Schema.Unknown,\n                error: FlowWaitTimedOut,\n                effects: [\n                  signalled,\n                  DurableClock.sleep({\n                    name: `timeout:${step.step}`,\n                    duration: timeoutMs,\n                  }).pipe(\n                    Effect.andThen(\n                      // An outcome answers as a signal would; a strand and a\n                      // plain failure both fail the race, and are told apart\n                      // below — so the journaled race is the same either way.\n                      onTimeout.kind === 'outcome'\n                        ? Effect.succeed<unknown>({\n                            outcome: onTimeout.outcome,\n                          })\n                        : Effect.fail(\n                            new FlowWaitTimedOut({ step: step.step }),\n                          ),\n                    ),\n                  ),\n                ],\n              }).pipe(\n                Effect.catchTag('FlowWaitTimedOut', timedOut =>\n                  onTimeout.kind === 'strand'\n                    ? Effect.succeed<unknown>(STRANDED)\n                    : Effect.fail(timedOut),\n                ),\n              )\n            : yield* signalled;\n        if (answer === STRANDED) {\n          stranded = step;\n          return;\n        }\n        answered.set(step.step, outcomeOf(answer));\n        bindings.record(step, catalog.get(step.ref), answer);\n        yield* record(`status:${step.step}:resumed`, {\n          state: 'running',\n          step: step.step,\n        });\n      });\n\n    /** One step, its failure tagged with where it happened. */\n    const run = (step: SlipStep) =>\n      Effect.gen(function* () {\n        // A stranded flow runs nothing more, in any group of the stage.\n        if (stranded !== undefined) return;\n        if (step.guard !== undefined) {\n          const { wait: guardedOn, outcomes } = step.guard;\n          const outcome = answered.get(guardedOn);\n          if (\n            skipped.has(guardedOn) ||\n            outcome === undefined ||\n            !outcomes.includes(outcome)\n          ) {\n            skipped.add(step.step);\n            return;\n          }\n        }\n        if (catalog.get(step.ref)?.kind === 'wait')\n          return yield* wait(step).pipe(\n            Effect.mapError((failure): StepFailed => ({ step, failure })),\n          );\n        yield* record(`status:${step.step}:running`, {\n          state: 'running',\n          step: step.step,\n        });\n        const answer = yield* call(step, 'action').pipe(\n          Effect.mapError((failure): StepFailed => ({ step, failure })),\n        );\n        bindings.record(step, catalog.get(step.ref), answer);\n        if (catalog.get(step.ref)?.kind === 'compensatable') done.push(step);\n      });\n\n    yield* announce('flow.started', 'started', 0);\n\n    for (const stage of slip.stages) {\n      const exits = yield* Effect.forEach(\n        groupsOf(stage.steps),\n        group => Effect.exit(Effect.forEach(group, run, { discard: true })),\n        { concurrency: dials.concurrency },\n      );\n      // The earliest step that failed decides; a group's failure is its own.\n      const [first] = exits\n        .flatMap(exit =>\n          Exit.isFailure(exit)\n            ? // A durable race fails with its losers' interruptions beside\n              // the failure that won, so the failure is looked for.\n              exit.cause.reasons\n                .filter(Cause.isFailReason)\n                .map(reason => reason.error)\n            : [],\n        )\n        .sort((a, b) => ordinalOf(a.step) - ordinalOf(b.step));\n      if (first === undefined) {\n        if (stranded === undefined) continue;\n        yield* record(`status:${stranded.step}:stranded`, {\n          state: 'stranded',\n          step: stranded.step,\n        });\n        yield* announce('flow.stranded', stranded.step, ordinalOf(stranded));\n        return 'stranded' as const;\n      }\n\n      const { step, failure } = first;\n      if (commitPoint === -1 || steps.indexOf(step) <= commitPoint) {\n        for (const undone of [...done].reverse()) {\n          const undoing = yield* Effect.exit(call(undone, 'compensation'));\n          if (Exit.isFailure(undoing)) {\n            yield* record(`status:${undone.step}:failed`, {\n              state: 'failed',\n              step: undone.step,\n            });\n            yield* announce(\n              'flow.failed',\n              undone.step,\n              ordinalOf(undone),\n              failure,\n            );\n            return 'failed' as const;\n          }\n        }\n        yield* record(`status:${step.step}:compensated`, {\n          state: 'compensated',\n          step: step.step,\n        });\n        yield* announce('flow.failed', step.step, ordinalOf(step), failure);\n        return 'compensated' as const;\n      }\n\n      yield* record(`status:${step.step}:suspended`, {\n        state: 'suspended',\n        step: step.step,\n      });\n      yield* announce('flow.suspended', step.step, ordinalOf(step), failure);\n      return yield* Effect.fail(failure).pipe(\n        Effect.provideService(Workflow.SuspendOnFailure, true),\n      );\n    }\n\n    yield* record('status:completed', { state: 'completed' });\n    yield* announce('flow.completed', 'completed', steps.length + 1);\n    return 'completed' as const;\n  });\n\n/**\n * One interpreter per grammar version a slip can be written in. A flow runs\n * to its end under the grammar it started with, so a change to how steps are\n * walked — their order, their Activity names — is a new entry here, never an\n * edit to an existing one; the journal replay holds every entry to its\n * recorded command sequence.\n */\nconst INTERPRETERS = { 1: interpretV1 } as const satisfies Record<\n  Slip['slipVersion'],\n  (slip: Slip) => unknown\n>;\n\n/** Every `slipVersion` the interpreter walks — each must have a journal. */\nexport const interpretedSlipVersions: readonly number[] =\n  Object.keys(INTERPRETERS).map(Number);\n\nexport const interpretSlip = (slip: Slip) =>\n  INTERPRETERS[slip.slipVersion](slip);\n\n/** The interpreter registered with the workflow engine, with its options. */\nexport const SlipWorkflowLayer = (options: InterpreterOptions) =>\n  SlipWorkflow.toLayer(payload =>\n    interpretSlip(payload.slip).pipe(\n      Effect.provideService(InterpreterOptionsTag, options),\n    ),\n  );\n"],"names":["Slip","slipSteps","decodeProblem","Failure","isFailure","JsonBody","problemOf","Timeout","BulkheadTag","CircuitBreakerTag","flowEvent","On","OutboxTag","ParticipantClientTag","Cause","Context","Effect","Exit","Metric","Schedule","Schema","SchemaTransformation","Activity","DurableClock","DurableDeferred","Workflow","flowStates","FlowStatusStoreTag","makeBindings","JournaledFailure","Unknown","pipe","decodeTo","declare","value","transform","decode","body","encode","failure","FlowOutcome","Literals","onTimeoutOf","step","named","parameters","kind","outcome","undefined","outcomeOf","answer","STRANDED","Symbol","for","FlowWaitTimedOut","timeout","String","message","DEFAULT_FLOW_DIALS","attemptTimeoutMs","stepTimeoutMs","concurrency","InterpreterOptionsTag","Service","SlipWorkflow","make","payload","key","slip","idempotencyKey","success","error","suspendedRetrySchedule","min","exponential","spaced","waitFor","segmentOf","segment","vendor","paymentMethod","filter","Boolean","join","groupsOf","steps","some","groups","Map","set","get","values","interpretV1","gen","options","dials","catalog","ordinalOf","indexOf","commitPoint","findIndex","ref","bindings","done","answered","skipped","Set","stranded","record","name","patch","execute","flatMap","store","update","flowId","andThen","withAttributes","state","source","orDie","announce","ordinal","outbox","enqueue","at","Date","toISOString","audience","id","data","definition","recipe","slipVersion","code","category","guarded","attempt","participant","bounds","dialsFor","breaker","bulkhead","timedOut","fail","dependency","guard","withPermit","timeoutOrElse","duration","orElse","isFamily","retry","idempotent","call","inputs","inputsFor","wait","correlation","accepts","outcomes","onTimeout","waitingFor","signalled","await","timeoutMs","raceAll","effects","sleep","succeed","catchTag","run","guardedOn","has","includes","add","mapError","push","stage","stages","exits","forEach","group","exit","discard","first","cause","reasons","isFailReason","map","reason","sort","a","b","undone","reverse","undoing","provideService","SuspendOnFailure","length","INTERPRETERS","interpretedSlipVersions","Object","keys","Number","interpretSlip","SlipWorkflowLayer","toLayer"],"mappings":"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"}
+{"version":3,"sources":["../../src/interpreter/slip-workflow.ts"],"sourcesContent":["import {\n  type FragmentCatalog,\n  Slip,\n  type SlipStep,\n  slipSteps,\n} from '@entifix/business/flow';\nimport {\n  decodeProblem,\n  type EntifixFailure,\n  Failure,\n  isFailure,\n  JsonBody,\n  problemOf,\n  Timeout,\n} from '@entifix/core';\nimport {\n  BulkheadTag,\n  CircuitBreakerTag,\n  flowEvent,\n  type FlowEventName,\n  On,\n  OutboxTag,\n  ParticipantClientTag,\n} from '@entifix/transactions';\nimport {\n  Cause,\n  Context,\n  Effect,\n  Exit,\n  Metric,\n  Schedule,\n  Schema,\n  SchemaTransformation,\n} from 'effect';\nimport {\n  Activity,\n  DurableClock,\n  DurableDeferred,\n  Workflow,\n} from 'effect/workflow';\n\nimport {\n  type FlowRecordPatch,\n  flowStates,\n  FlowStatusStoreTag,\n} from '../status/flow-status-store.js';\nimport { makeBindings } from './bindings.js';\n\n/**\n * A failure as an Activity journals it: the problem body on the way in, the\n * failure its code names on the way out, so a resumed flow sees the typed\n * refusal a participant sent rather than a cast.\n */\nexport const JournaledFailure: Schema.Codec<EntifixFailure, unknown> =\n  Schema.Unknown.pipe(\n    Schema.decodeTo(\n      Schema.declare((value): value is EntifixFailure => isFailure(value)),\n      SchemaTransformation.transform({\n        decode: body => decodeProblem(body),\n        encode: failure => problemOf(failure),\n      }),\n    ),\n  );\n\n/**\n * How a flow ended, as the workflow's own result: every step ran, or a\n * refusal before the commit point was undone, or an undoing itself failed and\n * the flow stopped where it was — which a person has to look at — or a wait\n * that strands on its timeout ran out, which a person has to look at too.\n */\nexport const FlowOutcome = Schema.Literals([\n  'completed',\n  'compensated',\n  'failed',\n  'stranded',\n]);\n\n/**\n * What a wait does when its `timeoutMs` runs out, from its `onTimeout`\n * parameter: answer as if signalled with an outcome a later guard branches\n * on, strand the flow for an operator, or — named neither — fail as any step\n * does, which past the commit point suspends it.\n */\ntype OnTimeout =\n  | { readonly kind: 'outcome'; readonly outcome: string }\n  | { readonly kind: 'strand' }\n  | { readonly kind: 'fail' };\n\nconst onTimeoutOf = (step: SlipStep): OnTimeout => {\n  const named = step.parameters?.['onTimeout'];\n  if (named === 'strand') return { kind: 'strand' };\n  const outcome =\n    typeof named === 'object' && named !== null\n      ? (named as { readonly outcome?: unknown }).outcome\n      : undefined;\n  return typeof outcome === 'string'\n    ? { kind: 'outcome', outcome }\n    : { kind: 'fail' };\n};\n\n/** The outcome a wait was answered with: its signal's `outcome`, when a string. */\nconst outcomeOf = (answer: unknown): string | undefined => {\n  const named =\n    typeof answer === 'object' && answer !== null\n      ? (answer as { readonly outcome?: unknown }).outcome\n      : undefined;\n  return typeof named === 'string' ? named : undefined;\n};\n\n/** The race's answer when a wait that strands on its timeout ran out. */\nconst STRANDED = Symbol.for('@entifix/workflow/stranded');\n\n/** A durable wait that outlived its timeout before its signal came. */\nexport class FlowWaitTimedOut extends Failure.timeout<FlowWaitTimedOut>()(\n  'FlowWaitTimedOut',\n  'flowWaitTimedOut',\n  { step: Schema.String },\n  { message: ({ step }) => `the wait at '${step}' timed out` },\n) {}\n\n/** How long a flow gives each participant call, and each step as a whole. */\nexport interface FlowDials {\n  /** One attempt at a call. */\n  readonly attemptTimeoutMs: number;\n  /** Every attempt at a step together, retries included. */\n  readonly stepTimeoutMs: number;\n  /** Segments of one stage run at once. */\n  readonly concurrency: number;\n}\n\nexport const DEFAULT_FLOW_DIALS: FlowDials = {\n  attemptTimeoutMs: 10_000,\n  stepTimeoutMs: 60_000,\n  concurrency: 4,\n};\n\n/** What the interpreter runs a slip with: the catalog, who announces, the dials. */\nexport interface InterpreterOptions {\n  readonly catalog: FragmentCatalog;\n  /** The slice the `flow.*` events are announced from. */\n  readonly source: string;\n  readonly dials?: Partial<FlowDials>;\n  /**\n   * One participant's own attempt and step bounds, over `dials` — the same\n   * shape the breaker's `dialsFor` and the bulkhead's `permitsFor` take, so a\n   * participant's dials are one row set however many guards read them.\n   */\n  readonly dialsFor?: (\n    participant: string,\n  ) => Partial<Omit<FlowDials, 'concurrency'>> | undefined;\n}\n\n/**\n * The interpreter's options, provided to the workflow it is registered with —\n * the payload is the slip; the catalog and dials are the deployment's.\n */\nexport class InterpreterOptionsTag extends Context.Service<\n  InterpreterOptionsTag,\n  InterpreterOptions\n>()('@entifix/workflow/InterpreterOptions') {}\n\n/**\n * The one workflow every flow runs as: its payload is the pinned slip and the\n * idempotency key that started it\n * ([ADR 0016](../../../../../docs/adr/0016-a-flow-engine-port-and-a-durable-workflow-adapter.md)).\n * The execution id derives from the key, so the same key is the same flow.\n *\n * A flow suspended past its commit point is resumed on the retry schedule:\n * a participant that comes back gets the step again, idempotently.\n */\nexport const SlipWorkflow = Workflow.make('entifix/slip', {\n  payload: { key: Schema.String, slip: Slip },\n  idempotencyKey: payload => payload.key,\n  success: FlowOutcome,\n  // Its failure is what suspends it past the commit point; it is never the\n  // flow's result.\n  error: JournaledFailure,\n  // Doubling from a second, never more than a minute apart.\n  suspendedRetrySchedule: Schedule.min([\n    Schedule.exponential('1 second'),\n    Schedule.spaced('1 minute'),\n  ]),\n});\n\n/** The durable wait a `wait` step parks on, addressed by the step's name. */\nexport const waitFor = (step: string) =>\n  DurableDeferred.make(`wait:${step}`, { success: Schema.Unknown });\n\n/** A step's failure, with the step it happened at. */\ninterface StepFailed {\n  readonly step: SlipStep;\n  readonly failure: EntifixFailure;\n}\n\nconst segmentOf = (step: SlipStep) =>\n  step.segment === undefined\n    ? undefined\n    : [step.segment.vendor, step.segment.paymentMethod]\n        .filter(Boolean)\n        .join('/');\n\n/**\n * A stage's steps as the groups that run at once: one group per segment when\n * every step names one — a basket's vendors, joined before the shared pivot —\n * and otherwise one group, in order.\n */\nconst groupsOf = (steps: readonly SlipStep[]): readonly SlipStep[][] => {\n  if (steps.some(step => segmentOf(step) === undefined)) return [[...steps]];\n  const groups = new Map<string, SlipStep[]>();\n  for (const step of steps) {\n    const key = segmentOf(step) as string;\n    groups.set(key, [...(groups.get(key) ?? []), step]);\n  }\n  return [...groups.values()];\n};\n\n/**\n * Interprets a pinned slip of grammar version 1\n * ([ADR 0016](../../../../../docs/adr/0016-a-flow-engine-port-and-a-durable-workflow-adapter.md)):\n * each step is an Activity named after it and keyed `<flowId>:<step>`, so a\n * resumed flow replays what already ran and calls a participant at most once\n * per step. Inside the Activity the call runs under the participant's\n * breaker and bulkhead and the retry budget, each attempt bounded and the\n * step as a whole bounded; nothing retries outside it.\n *\n * - Before and at the commit point, a failure — a breaker already open\n *   included, which fails fast — compensates what succeeded, in reverse, and\n *   the flow ends `compensated`.\n * - After it, a failure suspends the flow at that step: the money is taken,\n *   so the flow rolls forward when the participant comes back, never back.\n * - A `wait` step parks the flow on a durable deferred its signal completes,\n *   raced with a durable clock when it names `timeoutMs`; it may name a\n *   `correlation`, so a sender that knows the order rather than the flow can\n *   complete it.\n * - The segments of a stage run at once, bounded, and join before the next.\n *\n * Every transition is announced as a `flow.*` event through the outbox, by an\n * Activity, so it is written once whatever replays. Compensation is explicit\n * rather than a workflow finalizer, so the record says `compensated` only\n * after the last undoing has run — and an undoing that fails stops the flow\n * `failed` at that step instead of pretending.\n */\n/** What differs between grammar versions as the walk is interpreted. */\ninterface Grammar {\n  /** Whether a wait past the commit point announces `flow.waiting` (v2). */\n  readonly announcesCommittedWaits: boolean;\n}\n\nconst walkSlip = (slip: Slip, grammar: Grammar) =>\n  Effect.gen(function* () {\n    const options = yield* InterpreterOptionsTag;\n    const dials = { ...DEFAULT_FLOW_DIALS, ...options.dials };\n    const { catalog } = options;\n    const steps = slipSteps(slip);\n    const ordinalOf = (step: SlipStep) => steps.indexOf(step) + 1;\n    const commitPoint = steps.findIndex(\n      step => catalog.get(step.ref)?.kind === 'pivot',\n    );\n    const bindings = makeBindings();\n    const done: SlipStep[] = [];\n    /** What each wait was answered with, by step name — what a guard reads. */\n    const answered = new Map<string, string | undefined>();\n    /** Steps a guard passed over; a step guarded on one of them is skipped too. */\n    const skipped = new Set<string>();\n    /** The wait whose timeout stranded the flow, once one has. */\n    let stranded: SlipStep | undefined;\n\n    const record = (name: string, patch: FlowRecordPatch) =>\n      Activity.make({\n        name,\n        execute: Effect.flatMap(FlowStatusStoreTag, store =>\n          store.update(slip.flowId, patch),\n        ).pipe(\n          Effect.andThen(\n            Metric.update(\n              Metric.withAttributes(flowStates, {\n                state: patch.state,\n                source: options.source,\n              }),\n              1,\n            ),\n          ),\n          Effect.orDie,\n        ),\n      });\n\n    const announce = (\n      name: FlowEventName,\n      step: string,\n      ordinal: number,\n      failure?: EntifixFailure,\n    ) =>\n      Activity.make({\n        name: `announce:${name}:${step}`,\n        execute: Effect.flatMap(OutboxTag, outbox =>\n          outbox.enqueue(\n            flowEvent({\n              name,\n              source: options.source,\n              at: new Date().toISOString(),\n              step: `${name}:${step}`,\n              ordinal,\n              audience: [\n                { kind: 'flow', id: slip.flowId },\n                ...(slip.audience ?? []),\n              ],\n              data: {\n                flowId: slip.flowId,\n                definition: slip.recipe,\n                slipVersion: slip.slipVersion,\n                step,\n                ...(failure === undefined\n                  ? {}\n                  : {\n                      failure: {\n                        code: failure.code,\n                        category: failure.category,\n                      },\n                    }),\n              },\n            }),\n          ),\n        ).pipe(Effect.orDie),\n      });\n\n    /** One call, bounded, under the participant's breaker, bulkhead and budget. */\n    const guarded = (\n      step: SlipStep,\n      attempt: Effect.Effect<unknown, EntifixFailure>,\n    ) =>\n      Effect.gen(function* () {\n        const key = step.participant ?? 'participant';\n        const bounds = { ...dials, ...options.dialsFor?.(key) };\n        const breaker = yield* CircuitBreakerTag;\n        const bulkhead = yield* BulkheadTag;\n        const timedOut = () => Effect.fail(new Timeout({ dependency: key }));\n        return yield* breaker\n          .guard(key)(\n            bulkhead.withPermit(key)(\n              attempt.pipe(\n                Effect.timeoutOrElse({\n                  duration: bounds.attemptTimeoutMs,\n                  orElse: timedOut,\n                }),\n              ),\n            ),\n          )\n          .pipe(\n            On(Failure.isFamily('technical')).retry({\n              key: { dependency: key },\n              idempotent: true,\n            }),\n            Effect.timeoutOrElse({\n              duration: bounds.stepTimeoutMs,\n              orElse: timedOut,\n            }),\n          );\n      });\n\n    const call = (step: SlipStep, kind: 'action' | 'compensation') =>\n      Activity.make({\n        name: `${step.step}:${kind}`,\n        // Whatever the participant answered, as JSON — `undefined` included,\n        // which a journal cannot otherwise hold.\n        success: JsonBody,\n        error: JournaledFailure,\n        execute: Effect.flatMap(ParticipantClientTag, participant =>\n          guarded(\n            step,\n            participant.call({\n              step,\n              kind,\n              idempotencyKey:\n                kind === 'action'\n                  ? `${slip.flowId}:${step.step}`\n                  : `${slip.flowId}:${step.step}:compensation`,\n              inputs: bindings.inputsFor(step, catalog.get(step.ref), kind),\n            }),\n          ),\n        ),\n      });\n\n    const wait = (step: SlipStep) =>\n      Effect.gen(function* () {\n        const correlation = step.parameters?.['correlation'];\n        const accepts = catalog.get(step.ref)?.outcomes;\n        const onTimeout = onTimeoutOf(step);\n        yield* record(`status:${step.step}:waiting`, {\n          state: 'waiting',\n          step: step.step,\n          waitingFor: step.step,\n          ...(typeof correlation === 'string' ? { correlation } : {}),\n          ...(accepts === undefined ? {} : { accepts }),\n        });\n        // Past the commit point the caller's write has landed, and the wait is\n        // for someone else — a courier, a person — so the flow says so and a\n        // browser holding the write pending can let it go. Before it, nothing\n        // has landed, and the flow stays silent.\n        if (\n          grammar.announcesCommittedWaits &&\n          commitPoint !== -1 &&\n          steps.indexOf(step) > commitPoint\n        )\n          yield* announce('flow.waiting', step.step, ordinalOf(step));\n        const signalled = DurableDeferred.await(waitFor(step.step));\n        const timeoutMs = step.parameters?.['timeoutMs'];\n        // A durable race, so a replay answers the branch that won rather than\n        // racing again.\n        const answer =\n          typeof timeoutMs === 'number'\n            ? yield* DurableDeferred.raceAll({\n                name: `race:${step.step}`,\n                success: Schema.Unknown,\n                error: FlowWaitTimedOut,\n                effects: [\n                  signalled,\n                  DurableClock.sleep({\n                    name: `timeout:${step.step}`,\n                    duration: timeoutMs,\n                  }).pipe(\n                    Effect.andThen(\n                      // An outcome answers as a signal would; a strand and a\n                      // plain failure both fail the race, and are told apart\n                      // below — so the journaled race is the same either way.\n                      onTimeout.kind === 'outcome'\n                        ? Effect.succeed<unknown>({\n                            outcome: onTimeout.outcome,\n                          })\n                        : Effect.fail(\n                            new FlowWaitTimedOut({ step: step.step }),\n                          ),\n                    ),\n                  ),\n                ],\n              }).pipe(\n                Effect.catchTag('FlowWaitTimedOut', timedOut =>\n                  onTimeout.kind === 'strand'\n                    ? Effect.succeed<unknown>(STRANDED)\n                    : Effect.fail(timedOut),\n                ),\n              )\n            : yield* signalled;\n        if (answer === STRANDED) {\n          stranded = step;\n          return;\n        }\n        answered.set(step.step, outcomeOf(answer));\n        bindings.record(step, catalog.get(step.ref), answer);\n        yield* record(`status:${step.step}:resumed`, {\n          state: 'running',\n          step: step.step,\n        });\n      });\n\n    /** One step, its failure tagged with where it happened. */\n    const run = (step: SlipStep) =>\n      Effect.gen(function* () {\n        // A stranded flow runs nothing more, in any group of the stage.\n        if (stranded !== undefined) return;\n        if (step.guard !== undefined) {\n          const { wait: guardedOn, outcomes } = step.guard;\n          const outcome = answered.get(guardedOn);\n          if (\n            skipped.has(guardedOn) ||\n            outcome === undefined ||\n            !outcomes.includes(outcome)\n          ) {\n            skipped.add(step.step);\n            return;\n          }\n        }\n        if (catalog.get(step.ref)?.kind === 'wait')\n          return yield* wait(step).pipe(\n            Effect.mapError((failure): StepFailed => ({ step, failure })),\n          );\n        yield* record(`status:${step.step}:running`, {\n          state: 'running',\n          step: step.step,\n        });\n        const answer = yield* call(step, 'action').pipe(\n          Effect.mapError((failure): StepFailed => ({ step, failure })),\n        );\n        bindings.record(step, catalog.get(step.ref), answer);\n        if (catalog.get(step.ref)?.kind === 'compensatable') done.push(step);\n      });\n\n    yield* announce('flow.started', 'started', 0);\n\n    for (const stage of slip.stages) {\n      const exits = yield* Effect.forEach(\n        groupsOf(stage.steps),\n        group => Effect.exit(Effect.forEach(group, run, { discard: true })),\n        { concurrency: dials.concurrency },\n      );\n      // The earliest step that failed decides; a group's failure is its own.\n      const [first] = exits\n        .flatMap(exit =>\n          Exit.isFailure(exit)\n            ? // A durable race fails with its losers' interruptions beside\n              // the failure that won, so the failure is looked for.\n              exit.cause.reasons\n                .filter(Cause.isFailReason)\n                .map(reason => reason.error)\n            : [],\n        )\n        .sort((a, b) => ordinalOf(a.step) - ordinalOf(b.step));\n      if (first === undefined) {\n        if (stranded === undefined) continue;\n        yield* record(`status:${stranded.step}:stranded`, {\n          state: 'stranded',\n          step: stranded.step,\n        });\n        yield* announce('flow.stranded', stranded.step, ordinalOf(stranded));\n        return 'stranded' as const;\n      }\n\n      const { step, failure } = first;\n      if (commitPoint === -1 || steps.indexOf(step) <= commitPoint) {\n        for (const undone of [...done].reverse()) {\n          const undoing = yield* Effect.exit(call(undone, 'compensation'));\n          if (Exit.isFailure(undoing)) {\n            yield* record(`status:${undone.step}:failed`, {\n              state: 'failed',\n              step: undone.step,\n            });\n            yield* announce(\n              'flow.failed',\n              undone.step,\n              ordinalOf(undone),\n              failure,\n            );\n            return 'failed' as const;\n          }\n        }\n        yield* record(`status:${step.step}:compensated`, {\n          state: 'compensated',\n          step: step.step,\n        });\n        yield* announce('flow.failed', step.step, ordinalOf(step), failure);\n        return 'compensated' as const;\n      }\n\n      yield* record(`status:${step.step}:suspended`, {\n        state: 'suspended',\n        step: step.step,\n      });\n      yield* announce('flow.suspended', step.step, ordinalOf(step), failure);\n      return yield* Effect.fail(failure).pipe(\n        Effect.provideService(Workflow.SuspendOnFailure, true),\n      );\n    }\n\n    yield* record('status:completed', { state: 'completed' });\n    yield* announce('flow.completed', 'completed', steps.length + 1);\n    return 'completed' as const;\n  });\n\n/**\n * One interpreter per grammar version a slip can be written in. A flow runs\n * to its end under the grammar it started with, so a change to how steps are\n * walked — their order, their Activity names — is a new entry here, never an\n * edit to an existing one; the journal replay holds every entry to its\n * recorded command sequence.\n */\nconst INTERPRETERS = {\n  1: (slip: Slip) => walkSlip(slip, { announcesCommittedWaits: false }),\n  2: (slip: Slip) => walkSlip(slip, { announcesCommittedWaits: true }),\n} as const satisfies Record<Slip['slipVersion'], (slip: Slip) => unknown>;\n\n/** Every `slipVersion` the interpreter walks — each must have a journal. */\nexport const interpretedSlipVersions: readonly number[] =\n  Object.keys(INTERPRETERS).map(Number);\n\nexport const interpretSlip = (slip: Slip) =>\n  INTERPRETERS[slip.slipVersion](slip);\n\n/** The interpreter registered with the workflow engine, with its options. */\nexport const SlipWorkflowLayer = (options: InterpreterOptions) =>\n  SlipWorkflow.toLayer(payload =>\n    interpretSlip(payload.slip).pipe(\n      Effect.provideService(InterpreterOptionsTag, options),\n    ),\n  );\n"],"names":["Slip","slipSteps","decodeProblem","Failure","isFailure","JsonBody","problemOf","Timeout","BulkheadTag","CircuitBreakerTag","flowEvent","On","OutboxTag","ParticipantClientTag","Cause","Context","Effect","Exit","Metric","Schedule","Schema","SchemaTransformation","Activity","DurableClock","DurableDeferred","Workflow","flowStates","FlowStatusStoreTag","makeBindings","JournaledFailure","Unknown","pipe","decodeTo","declare","value","transform","decode","body","encode","failure","FlowOutcome","Literals","onTimeoutOf","step","named","parameters","kind","outcome","undefined","outcomeOf","answer","STRANDED","Symbol","for","FlowWaitTimedOut","timeout","String","message","DEFAULT_FLOW_DIALS","attemptTimeoutMs","stepTimeoutMs","concurrency","InterpreterOptionsTag","Service","SlipWorkflow","make","payload","key","slip","idempotencyKey","success","error","suspendedRetrySchedule","min","exponential","spaced","waitFor","segmentOf","segment","vendor","paymentMethod","filter","Boolean","join","groupsOf","steps","some","groups","Map","set","get","values","walkSlip","grammar","gen","options","dials","catalog","ordinalOf","indexOf","commitPoint","findIndex","ref","bindings","done","answered","skipped","Set","stranded","record","name","patch","execute","flatMap","store","update","flowId","andThen","withAttributes","state","source","orDie","announce","ordinal","outbox","enqueue","at","Date","toISOString","audience","id","data","definition","recipe","slipVersion","code","category","guarded","attempt","participant","bounds","dialsFor","breaker","bulkhead","timedOut","fail","dependency","guard","withPermit","timeoutOrElse","duration","orElse","isFamily","retry","idempotent","call","inputs","inputsFor","wait","correlation","accepts","outcomes","onTimeout","waitingFor","announcesCommittedWaits","signalled","await","timeoutMs","raceAll","effects","sleep","succeed","catchTag","run","guardedOn","has","includes","add","mapError","push","stage","stages","exits","forEach","group","exit","discard","first","cause","reasons","isFailReason","map","reason","sort","a","b","undone","reverse","undoing","provideService","SuspendOnFailure","length","INTERPRETERS","interpretedSlipVersions","Object","keys","Number","interpretSlip","SlipWorkflowLayer","toLayer"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@entifix/workflow",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Durable flows: the slip interpreter on Effect Workflow, behind the flow engine port, with Postgres storage and socket runners.",
   "license": "MIT",
   "repository": {
@@ -89,16 +89,16 @@
   },
   "dependencies": {
     "@swc/helpers": "0.5.23",
-    "@entifix/core": "0.16.0",
-    "@entifix/business": "0.16.0",
-    "@entifix/sql": "0.16.0",
-    "@entifix/transactions": "0.16.0"
+    "@entifix/business": "0.17.0",
+    "@entifix/core": "0.17.0",
+    "@entifix/sql": "0.17.0",
+    "@entifix/transactions": "0.17.0"
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.7",
     "@effect/sql-pg": "4.0.7",
     "effect": "4.0.7",
-    "@entifix/testing-unit": "0.16.0"
+    "@entifix/testing-unit": "0.17.0"
   },
   "peerDependencies": {
     "@effect/platform-node": "^4.0.7",