@entifix/workflow 0.0.0-stage → 0.12.1

package/dist/interpreter/slip-workflow.js

@@ -0,0 +1,316 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { Slip, slipSteps } from '@entifix/business/flow';
+import { decodeProblem, Failure, isFailure, JsonBody, problemOf, Timeout } from '@entifix/core';
+import { BulkheadTag, CircuitBreakerTag, flowEvent, On, OutboxTag, ParticipantClientTag } from '@entifix/transactions';
+import { Context, Effect, Exit, Metric, Schedule, Schema, SchemaTransformation } from 'effect';
+import { Activity, DurableClock, DurableDeferred, Workflow } from 'effect/workflow';
+import { flowStates, FlowStatusStoreTag } from '../status/flow-status-store.js';
+/**
+ * A failure as an Activity journals it: the problem body on the way in, the
+ * failure its code names on the way out, so a resumed flow sees the typed
+ * refusal a participant sent rather than a cast.
+ */ export const JournaledFailure = Schema.Unknown.pipe(Schema.decodeTo(Schema.declare((value)=>isFailure(value)), SchemaTransformation.transform({
+    decode: (body)=>decodeProblem(body),
+    encode: (failure)=>problemOf(failure)
+})));
+/**
+ * How a flow ended, as the workflow's own result: every step ran, or a
+ * refusal before the commit point was undone, or an undoing itself failed and
+ * the flow stopped where it was — which a person has to look at.
+ */ export const FlowOutcome = Schema.Literals([
+    'completed',
+    'compensated',
+    'failed'
+]);
+/** A durable wait that outlived its timeout before its signal came. */ export class FlowWaitTimedOut extends Failure.timeout()('FlowWaitTimedOut', 'flowWaitTimedOut', {
+    step: Schema.String
+}, {
+    message: ({ step })=>`the wait at '${step}' timed out`
+}) {
+}
+export const DEFAULT_FLOW_DIALS = {
+    attemptTimeoutMs: 10000,
+    stepTimeoutMs: 60000,
+    concurrency: 4
+};
+/**
+ * The interpreter's options, provided to the workflow it is registered with —
+ * the payload is the slip; the catalog and dials are the deployment's.
+ */ export class InterpreterOptionsTag extends Context.Service()('@entifix/workflow/InterpreterOptions') {
+}
+/**
+ * The one workflow every flow runs as: its payload is the pinned slip and the
+ * idempotency key that started it
+ * ([ADR 0016](../../../../../docs/adr/0016-a-flow-engine-port-and-a-durable-workflow-adapter.md)).
+ * The execution id derives from the key, so the same key is the same flow.
+ *
+ * A flow suspended past its commit point is resumed on the retry schedule:
+ * a participant that comes back gets the step again, idempotently.
+ */ export const SlipWorkflow = Workflow.make('entifix/slip', {
+    payload: {
+        key: Schema.String,
+        slip: Slip
+    },
+    idempotencyKey: (payload)=>payload.key,
+    success: FlowOutcome,
+    // Its failure is what suspends it past the commit point; it is never the
+    // flow's result.
+    error: JournaledFailure,
+    // Doubling from a second, never more than a minute apart.
+    suspendedRetrySchedule: Schedule.min([
+        Schedule.exponential('1 second'),
+        Schedule.spaced('1 minute')
+    ])
+});
+/** The durable wait a `wait` step parks on, addressed by the step's name. */ export const waitFor = (step)=>DurableDeferred.make(`wait:${step}`, {
+        success: Schema.Unknown
+    });
+const segmentOf = (step)=>step.segment === undefined ? undefined : [
+        step.segment.vendor,
+        step.segment.paymentMethod
+    ].filter(Boolean).join('/');
+/**
+ * A stage's steps as the groups that run at once: one group per segment when
+ * every step names one — a basket's vendors, joined before the shared pivot —
+ * and otherwise one group, in order.
+ */ const groupsOf = (steps)=>{
+    if (steps.some((step)=>segmentOf(step) === undefined)) return [
+        [
+            ...steps
+        ]
+    ];
+    const groups = new Map();
+    for (const step of steps){
+        var _groups_get;
+        const key = segmentOf(step);
+        groups.set(key, [
+            ...(_groups_get = groups.get(key)) != null ? _groups_get : [],
+            step
+        ]);
+    }
+    return [
+        ...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 options = yield* InterpreterOptionsTag;
+        const dials = _extends({}, DEFAULT_FLOW_DIALS, options.dials);
+        const { catalog } = options;
+        const steps = slipSteps(slip);
+        const ordinalOf = (step)=>steps.indexOf(step) + 1;
+        const commitPoint = steps.findIndex((step)=>{
+            var _catalog_get;
+            return ((_catalog_get = catalog.get(step.ref)) == null ? void 0 : _catalog_get.kind) === 'pivot';
+        });
+        const outputs = {};
+        const done = [];
+        const record = (name, patch)=>Activity.make({
+                name,
+                execute: Effect.flatMap(FlowStatusStoreTag, (store)=>store.update(slip.flowId, patch)).pipe(Effect.andThen(Metric.update(Metric.withAttributes(flowStates, {
+                    state: patch.state,
+                    source: options.source
+                }), 1)), Effect.orDie)
+            });
+        const announce = (name, step, ordinal, failure)=>Activity.make({
+                name: `announce:${name}:${step}`,
+                execute: Effect.flatMap(OutboxTag, (outbox)=>{
+                    var _slip_audience;
+                    return outbox.enqueue(flowEvent({
+                        name,
+                        source: options.source,
+                        at: new Date().toISOString(),
+                        step: `${name}:${step}`,
+                        ordinal,
+                        audience: [
+                            {
+                                kind: 'flow',
+                                id: slip.flowId
+                            },
+                            ...(_slip_audience = slip.audience) != null ? _slip_audience : []
+                        ],
+                        data: _extends({
+                            flowId: slip.flowId,
+                            definition: slip.recipe,
+                            slipVersion: slip.slipVersion,
+                            step
+                        }, failure === undefined ? {} : {
+                            failure: {
+                                code: failure.code,
+                                category: failure.category
+                            }
+                        })
+                    }));
+                }).pipe(Effect.orDie)
+            });
+        /** One call, bounded, under the participant's breaker, bulkhead and budget. */ const guarded = (step, attempt)=>Effect.gen(function*() {
+                var _step_participant;
+                const key = (_step_participant = step.participant) != null ? _step_participant : 'participant';
+                const bounds = _extends({}, dials, options.dialsFor == null ? void 0 : options.dialsFor.call(options, key));
+                const breaker = yield* CircuitBreakerTag;
+                const bulkhead = yield* BulkheadTag;
+                const timedOut = ()=>Effect.fail(new Timeout({
+                        dependency: key
+                    }));
+                return yield* breaker.guard(key)(bulkhead.withPermit(key)(attempt.pipe(Effect.timeoutOrElse({
+                    duration: bounds.attemptTimeoutMs,
+                    orElse: timedOut
+                })))).pipe(On(Failure.isFamily('technical')).retry({
+                    key: {
+                        dependency: key
+                    },
+                    idempotent: true
+                }), Effect.timeoutOrElse({
+                    duration: bounds.stepTimeoutMs,
+                    orElse: timedOut
+                }));
+            });
+        const call = (step, kind)=>Activity.make({
+                name: `${step.step}:${kind}`,
+                // Whatever the participant answered, as JSON — `undefined` included,
+                // which a journal cannot otherwise hold.
+                success: JsonBody,
+                error: JournaledFailure,
+                execute: Effect.flatMap(ParticipantClientTag, (participant)=>guarded(step, participant.call({
+                        step,
+                        kind,
+                        idempotencyKey: kind === 'action' ? `${slip.flowId}:${step.step}` : `${slip.flowId}:${step.step}:compensation`,
+                        outputs
+                    })))
+            });
+        const wait = (step)=>Effect.gen(function*() {
+                var _step_parameters, _step_parameters1;
+                const correlation = (_step_parameters = step.parameters) == null ? void 0 : _step_parameters['correlation'];
+                yield* record(`status:${step.step}:waiting`, _extends({
+                    state: 'waiting',
+                    step: step.step,
+                    waitingFor: step.step
+                }, typeof correlation === 'string' ? {
+                    correlation
+                } : {}));
+                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
+                // racing again.
+                outputs[step.step] = typeof timeoutMs === 'number' ? yield* DurableDeferred.raceAll({
+                    name: `race:${step.step}`,
+                    success: Schema.Unknown,
+                    error: FlowWaitTimedOut,
+                    effects: [
+                        signalled,
+                        DurableClock.sleep({
+                            name: `timeout:${step.step}`,
+                            duration: timeoutMs
+                        }).pipe(Effect.andThen(Effect.fail(new FlowWaitTimedOut({
+                            step: step.step
+                        }))))
+                    ]
+                }) : yield* signalled;
+                yield* record(`status:${step.step}:resumed`, {
+                    state: 'running',
+                    step: step.step
+                });
+            });
+        /** One step, its failure tagged with where it happened. */ const run = (step)=>Effect.gen(function*() {
+                var _catalog_get, _catalog_get1;
+                if (((_catalog_get = catalog.get(step.ref)) == null ? void 0 : _catalog_get.kind) === 'wait') return yield* wait(step).pipe(Effect.mapError((failure)=>({
+                        step,
+                        failure
+                    })));
+                yield* record(`status:${step.step}:running`, {
+                    state: 'running',
+                    step: step.step
+                });
+                outputs[step.step] = yield* call(step, 'action').pipe(Effect.mapError((failure)=>({
+                        step,
+                        failure
+                    })));
+                if (((_catalog_get1 = catalog.get(step.ref)) == null ? void 0 : _catalog_get1.kind) === 'compensatable') done.push(step);
+            });
+        yield* announce('flow.started', 'started', 0);
+        for (const stage of slip.stages){
+            const exits = yield* Effect.forEach(groupsOf(stage.steps), (group)=>Effect.exit(Effect.forEach(group, run, {
+                    discard: true
+                })), {
+                concurrency: dials.concurrency
+            });
+            // The earliest step that failed decides; a group's failure is its own.
+            const [first] = exits.flatMap((exit)=>Exit.isFailure(exit) ? exit.cause.reasons.flatMap((reason)=>// A durable race fails with its losers' interruptions beside
+                    // the failure that won, so the failure is looked for.
+                    reason._tag === 'Fail' ? [
+                        reason.error
+                    ] : []) : []).sort((a, b)=>ordinalOf(a.step) - ordinalOf(b.step));
+            if (first === undefined) continue;
+            const { step, failure } = first;
+            if (commitPoint === -1 || steps.indexOf(step) <= commitPoint) {
+                for (const undone of [
+                    ...done
+                ].reverse()){
+                    const undoing = yield* Effect.exit(call(undone, 'compensation'));
+                    if (Exit.isFailure(undoing)) {
+                        yield* record(`status:${undone.step}:failed`, {
+                            state: 'failed',
+                            step: undone.step
+                        });
+                        yield* announce('flow.failed', undone.step, ordinalOf(undone), failure);
+                        return 'failed';
+                    }
+                }
+                yield* record(`status:${step.step}:compensated`, {
+                    state: 'compensated',
+                    step: step.step
+                });
+                yield* announce('flow.failed', step.step, ordinalOf(step), failure);
+                return 'compensated';
+            }
+            yield* record(`status:${step.step}:suspended`, {
+                state: 'suspended',
+                step: step.step
+            });
+            yield* announce('flow.suspended', step.step, ordinalOf(step), failure);
+            return yield* Effect.fail(failure).pipe(Effect.provideService(Workflow.SuspendOnFailure, true));
+        }
+        yield* record('status:completed', {
+            state: 'completed'
+        });
+        yield* announce('flow.completed', 'completed', steps.length + 1);
+        return 'completed';
+    });
+/**
+ * One interpreter per grammar version a slip can be written in. A flow runs
+ * to its end under the grammar it started with, so a change to how steps are
+ * walked — their order, their Activity names — is a new entry here, never an
+ * edit to an existing one; the journal replay holds every entry to its
+ * recorded command sequence.
+ */ const INTERPRETERS = {
+    1: interpretV1
+};
+/** 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);
+/** The interpreter registered with the workflow engine, with its options. */ export const SlipWorkflowLayer = (options)=>SlipWorkflow.toLayer((payload)=>interpretSlip(payload.slip).pipe(Effect.provideService(InterpreterOptionsTag, options)));
+
+//# sourceMappingURL=slip-workflow.js.map

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

@@ -0,0 +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  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';\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.\n */\nexport const FlowOutcome = Schema.Literals([\n  'completed',\n  'compensated',\n  'failed',\n]);\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 outputs: Record<string, unknown> = {};\n    const done: SlipStep[] = [];\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              outputs,\n            }),\n          ),\n        ),\n      });\n\n    const wait = (step: SlipStep) =>\n      Effect.gen(function* () {\n        const correlation = step.parameters?.['correlation'];\n        yield* record(`status:${step.step}:waiting`, {\n          state: 'waiting',\n          step: step.step,\n          waitingFor: step.step,\n          ...(typeof correlation === 'string' ? { correlation } : {}),\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        outputs[step.step] =\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                      Effect.fail(new FlowWaitTimedOut({ step: step.step })),\n                    ),\n                  ),\n                ],\n              })\n            : yield* signalled;\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        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        outputs[step.step] = yield* call(step, 'action').pipe(\n          Effect.mapError((failure): StepFailed => ({ step, failure })),\n        );\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            ? exit.cause.reasons.flatMap(reason =>\n                // A durable race fails with its losers' interruptions beside\n                // the failure that won, so the failure is looked for.\n                reason._tag === 'Fail' ? [reason.error] : [],\n              )\n            : [],\n        )\n        .sort((a, b) => ordinalOf(a.step) - ordinalOf(b.step));\n      if (first === undefined) continue;\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","Context","Effect","Exit","Metric","Schedule","Schema","SchemaTransformation","Activity","DurableClock","DurableDeferred","Workflow","flowStates","FlowStatusStoreTag","JournaledFailure","Unknown","pipe","decodeTo","declare","value","transform","decode","body","encode","failure","FlowOutcome","Literals","FlowWaitTimedOut","timeout","step","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","undefined","vendor","paymentMethod","filter","Boolean","join","groupsOf","steps","some","groups","Map","set","get","values","interpretV1","gen","options","dials","catalog","ordinalOf","indexOf","commitPoint","findIndex","ref","kind","outputs","done","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","wait","correlation","parameters","waitingFor","signalled","await","timeoutMs","raceAll","effects","sleep","run","mapError","push","stage","stages","exits","forEach","group","exit","discard","first","cause","reasons","reason","_tag","sort","a","b","undone","reverse","undoing","provideService","SuspendOnFailure","length","INTERPRETERS","interpretedSlipVersions","Object","keys","map","Number","interpretSlip","SlipWorkflowLayer","toLayer"],"mappings":"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"}

package/dist/postgres/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The flow engine's durable half over the host's SQL database: the cluster
+ * workflow engine's journal, a status store beside it, and a single runner.
+ * Postgres dialect. A deployment of several runners adds
+ * `@entifix/workflow/socket-runner`.
+ */
+export * from './single-runner.js';
+export * from './sql-flow-status-store.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/postgres/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/postgres/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC"}

package/dist/postgres/index.js

@@ -0,0 +1,9 @@
+/**
+ * The flow engine's durable half over the host's SQL database: the cluster
+ * workflow engine's journal, a status store beside it, and a single runner.
+ * Postgres dialect. A deployment of several runners adds
+ * `@entifix/workflow/socket-runner`.
+ */ export * from './single-runner.js';
+export * from './sql-flow-status-store.js';
+
+//# sourceMappingURL=index.js.map

package/dist/postgres/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/postgres/index.ts"],"sourcesContent":["/**\n * The flow engine's durable half over the host's SQL database: the cluster\n * workflow engine's journal, a status store beside it, and a single runner.\n * Postgres dialect. A deployment of several runners adds\n * `@entifix/workflow/socket-runner`.\n */\nexport * from './single-runner.js';\nexport * from './sql-flow-status-store.js';\n"],"names":[],"mappings":"AAAA;;;;;CAKC,GACD,cAAc,qBAAqB;AACnC,cAAc,6BAA6B"}

package/dist/postgres/single-runner.d.ts

@@ -0,0 +1,9 @@
+import { Layer } from 'effect';
+import type { InterpreterOptions } from '../interpreter/slip-workflow.js';
+/**
+ * The flow engine on one runner in this process, its journal and its status
+ * in the host's SQL database — for a deployment of one replica, and for specs.
+ * Needs the host's `SqlClient` and `Crypto` and a participant client.
+ */
+export declare const SingleRunnerFlowEngineLayer: (options: InterpreterOptions) => Layer.Layer<import("@entifix/transactions").FlowEngineTag, import("@entifix/core").StoreFailure | import("effect/Config").ConfigError, import("@entifix/transactions").OutboxTag | import("@entifix/transactions").BulkheadTag | import("@entifix/transactions").CircuitBreakerTag | import("@entifix/transactions").ParticipantClientTag | import("@entifix/transactions").RetryBudgetTag | import("effect/sql/SqlClient").SqlClient | import("effect/Crypto").Crypto>;
+//# sourceMappingURL=single-runner.d.ts.map

package/dist/postgres/single-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-runner.d.ts","sourceRoot":"","sources":["../../src/postgres/single-runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAI/B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAG1E;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,GAAI,SAAS,kBAAkB,4cAQpE,CAAC"}

package/dist/postgres/single-runner.js

@@ -0,0 +1,13 @@
+import { Layer } from 'effect';
+import { ClusterWorkflowEngine, SingleRunner } from 'effect/cluster';
+import { FlowEngineLayer } from '../engine/make-flow-engine.js';
+import { SqlFlowStatusStoreLayer } from './sql-flow-status-store.js';
+/**
+ * The flow engine on one runner in this process, its journal and its status
+ * in the host's SQL database — for a deployment of one replica, and for specs.
+ * Needs the host's `SqlClient` and `Crypto` and a participant client.
+ */ export const SingleRunnerFlowEngineLayer = (options)=>FlowEngineLayer(options).pipe(Layer.provide(SqlFlowStatusStoreLayer), Layer.provide(ClusterWorkflowEngine.layer.pipe(Layer.provide(SingleRunner.layer({
+        runnerStorage: 'sql'
+    })))));
+
+//# sourceMappingURL=single-runner.js.map

package/dist/postgres/single-runner.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/postgres/single-runner.ts"],"sourcesContent":["import { Layer } from 'effect';\nimport { ClusterWorkflowEngine, SingleRunner } from 'effect/cluster';\n\nimport { FlowEngineLayer } from '../engine/make-flow-engine.js';\nimport type { InterpreterOptions } from '../interpreter/slip-workflow.js';\nimport { SqlFlowStatusStoreLayer } from './sql-flow-status-store.js';\n\n/**\n * The flow engine on one runner in this process, its journal and its status\n * in the host's SQL database — for a deployment of one replica, and for specs.\n * Needs the host's `SqlClient` and `Crypto` and a participant client.\n */\nexport const SingleRunnerFlowEngineLayer = (options: InterpreterOptions) =>\n  FlowEngineLayer(options).pipe(\n    Layer.provide(SqlFlowStatusStoreLayer),\n    Layer.provide(\n      ClusterWorkflowEngine.layer.pipe(\n        Layer.provide(SingleRunner.layer({ runnerStorage: 'sql' })),\n      ),\n    ),\n  );\n"],"names":["Layer","ClusterWorkflowEngine","SingleRunner","FlowEngineLayer","SqlFlowStatusStoreLayer","SingleRunnerFlowEngineLayer","options","pipe","provide","layer","runnerStorage"],"mappings":"AAAA,SAASA,KAAK,QAAQ,SAAS;AAC/B,SAASC,qBAAqB,EAAEC,YAAY,QAAQ,iBAAiB;AAErE,SAASC,eAAe,QAAQ,gCAAgC;AAEhE,SAASC,uBAAuB,QAAQ,6BAA6B;AAErE;;;;CAIC,GACD,OAAO,MAAMC,8BAA8B,CAACC,UAC1CH,gBAAgBG,SAASC,IAAI,CAC3BP,MAAMQ,OAAO,CAACJ,0BACdJ,MAAMQ,OAAO,CACXP,sBAAsBQ,KAAK,CAACF,IAAI,CAC9BP,MAAMQ,OAAO,CAACN,aAAaO,KAAK,CAAC;QAAEC,eAAe;IAAM,OAG5D"}

package/dist/postgres/sql-flow-status-store.d.ts

@@ -0,0 +1,14 @@
+import { Effect, Layer } from 'effect';
+import { SqlClient } from 'effect/sql';
+import { type FlowStatusStore, FlowStatusStoreTag } from '../status/flow-status-store.js';
+/** Creates the flow status table if it is missing. Idempotent. */
+export declare const ensureFlowStatusTable: (sql: SqlClient.SqlClient) => Effect.Effect<void, import("@entifix/core").StoreFailure, never>;
+/**
+ * The flow status store over SQL, beside the workflow engine's own tables. A
+ * registration inserts under the key or answers the flow already there, in one
+ * statement and a read.
+ */
+export declare const makeSqlFlowStatusStore: (sql: SqlClient.SqlClient) => FlowStatusStore;
+/** The SQL status store, its table ensured as the layer builds. */
+export declare const SqlFlowStatusStoreLayer: Layer.Layer<FlowStatusStoreTag, import("@entifix/core").StoreFailure, SqlClient.SqlClient>;
+//# sourceMappingURL=sql-flow-status-store.d.ts.map

package/dist/postgres/sql-flow-status-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-flow-status-store.d.ts","sourceRoot":"","sources":["../../src/postgres/sql-flow-status-store.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAU,MAAM,QAAQ,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,OAAO,EAEL,KAAK,eAAe,EACpB,kBAAkB,EACnB,MAAM,gCAAgC,CAAC;AAwBxC,kEAAkE;AAClE,eAAO,MAAM,qBAAqB,GAAI,KAAK,SAAS,CAAC,SAAS,qEAUZ,CAAC;AAEnD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GACjC,KAAK,SAAS,CAAC,SAAS,KACvB,eA2CD,CAAC;AAEH,mEAAmE;AACnE,eAAO,MAAM,uBAAuB,4FAOnC,CAAC"}

package/dist/postgres/sql-flow-status-store.js

@@ -0,0 +1,68 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { translateSqlError } from '@entifix/sql';
+import { Effect, Layer, Option } from 'effect';
+import { SqlClient } from 'effect/sql';
+import { FlowStatusStoreTag } from '../status/flow-status-store.js';
+const recordOf = (row)=>_extends({
+        flowId: row.flow_id,
+        executionId: row.execution_id,
+        state: row.state
+    }, row.step === null ? {} : {
+        step: row.step
+    }, row.waiting_for === null ? {} : {
+        waitingFor: row.waiting_for
+    }, row.correlation === null ? {} : {
+        correlation: row.correlation
+    });
+const fault = (error)=>translateSqlError(error);
+/** Creates the flow status table if it is missing. Idempotent. */ export const ensureFlowStatusTable = (sql)=>sql`
+    CREATE TABLE IF NOT EXISTS entifix_flow_status (
+      flow_id text PRIMARY KEY,
+      idempotency_key text NOT NULL UNIQUE,
+      execution_id text NOT NULL,
+      state text NOT NULL,
+      step text,
+      waiting_for text,
+      correlation text
+    )`.pipe(Effect.asVoid, Effect.mapError(fault));
+/**
+ * The flow status store over SQL, beside the workflow engine's own tables. A
+ * registration inserts under the key or answers the flow already there, in one
+ * statement and a read.
+ */ export const makeSqlFlowStatusStore = (sql)=>({
+        register: (key, record)=>Effect.gen(function*() {
+                const [inserted] = yield* sql`
+        INSERT INTO entifix_flow_status
+          (flow_id, idempotency_key, execution_id, state)
+        VALUES (${record.flowId}, ${key}, ${record.executionId}, ${record.state})
+        ON CONFLICT DO NOTHING
+        RETURNING *`;
+                if (inserted !== undefined) return recordOf(inserted);
+                const [existing] = yield* sql`
+        SELECT * FROM entifix_flow_status
+        WHERE idempotency_key = ${key} OR flow_id = ${record.flowId}`;
+                // Gone between the two statements cannot happen: nothing deletes a flow.
+                return recordOf(existing);
+            }).pipe(Effect.mapError(fault)),
+        find: (flowId)=>sql`
+      SELECT * FROM entifix_flow_status WHERE flow_id = ${flowId}`.pipe(Effect.map(([row])=>row === undefined ? Option.none() : Option.some(recordOf(row))), Effect.mapError(fault)),
+        findByCorrelation: (correlation)=>sql`
+      SELECT * FROM entifix_flow_status
+      WHERE correlation = ${correlation}`.pipe(Effect.map(([row])=>row === undefined ? Option.none() : Option.some(recordOf(row))), Effect.mapError(fault)),
+        update: (flowId, patch)=>{
+            var _patch_step, _patch_waitingFor, _patch_correlation;
+            return sql`
+      UPDATE entifix_flow_status
+      SET state = ${patch.state}, step = ${(_patch_step = patch.step) != null ? _patch_step : null},
+          waiting_for = ${(_patch_waitingFor = patch.waitingFor) != null ? _patch_waitingFor : null},
+          correlation = ${(_patch_correlation = patch.correlation) != null ? _patch_correlation : null}
+      WHERE flow_id = ${flowId}`.pipe(Effect.asVoid, Effect.mapError(fault));
+        }
+    });
+/** The SQL status store, its table ensured as the layer builds. */ export const SqlFlowStatusStoreLayer = Layer.effect(FlowStatusStoreTag, Effect.gen(function*() {
+    const sql = yield* SqlClient.SqlClient;
+    yield* ensureFlowStatusTable(sql);
+    return makeSqlFlowStatusStore(sql);
+}));
+
+//# sourceMappingURL=sql-flow-status-store.js.map

package/dist/postgres/sql-flow-status-store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/postgres/sql-flow-status-store.ts"],"sourcesContent":["import { translateSqlError } from '@entifix/sql';\nimport type { FlowState } from '@entifix/transactions';\nimport { Effect, Layer, Option } from 'effect';\nimport { SqlClient } from 'effect/sql';\n\nimport {\n  type FlowRecord,\n  type FlowStatusStore,\n  FlowStatusStoreTag,\n} from '../status/flow-status-store.js';\n\n// A type alias, not an interface: a row must be assignable to the record a\n// driver hands back, and an interface has no index signature.\ntype FlowStatusRow = {\n  readonly flow_id: string;\n  readonly execution_id: string;\n  readonly state: FlowState;\n  readonly step: string | null;\n  readonly waiting_for: string | null;\n  readonly correlation: string | null;\n};\n\nconst recordOf = (row: FlowStatusRow): FlowRecord => ({\n  flowId: row.flow_id,\n  executionId: row.execution_id,\n  state: row.state,\n  ...(row.step === null ? {} : { step: row.step }),\n  ...(row.waiting_for === null ? {} : { waitingFor: row.waiting_for }),\n  ...(row.correlation === null ? {} : { correlation: row.correlation }),\n});\n\nconst fault = (error: unknown) => translateSqlError(error);\n\n/** Creates the flow status table if it is missing. Idempotent. */\nexport const ensureFlowStatusTable = (sql: SqlClient.SqlClient) =>\n  sql`\n    CREATE TABLE IF NOT EXISTS entifix_flow_status (\n      flow_id text PRIMARY KEY,\n      idempotency_key text NOT NULL UNIQUE,\n      execution_id text NOT NULL,\n      state text NOT NULL,\n      step text,\n      waiting_for text,\n      correlation text\n    )`.pipe(Effect.asVoid, Effect.mapError(fault));\n\n/**\n * The flow status store over SQL, beside the workflow engine's own tables. A\n * registration inserts under the key or answers the flow already there, in one\n * statement and a read.\n */\nexport const makeSqlFlowStatusStore = (\n  sql: SqlClient.SqlClient,\n): FlowStatusStore => ({\n  register: (key, record) =>\n    Effect.gen(function* () {\n      const [inserted] = yield* sql<FlowStatusRow>`\n        INSERT INTO entifix_flow_status\n          (flow_id, idempotency_key, execution_id, state)\n        VALUES (${record.flowId}, ${key}, ${record.executionId}, ${record.state})\n        ON CONFLICT DO NOTHING\n        RETURNING *`;\n      if (inserted !== undefined) return recordOf(inserted);\n      const [existing] = yield* sql<FlowStatusRow>`\n        SELECT * FROM entifix_flow_status\n        WHERE idempotency_key = ${key} OR flow_id = ${record.flowId}`;\n      // Gone between the two statements cannot happen: nothing deletes a flow.\n      return recordOf(existing as FlowStatusRow);\n    }).pipe(Effect.mapError(fault)),\n\n  find: flowId =>\n    sql<FlowStatusRow>`\n      SELECT * FROM entifix_flow_status WHERE flow_id = ${flowId}`.pipe(\n      Effect.map(([row]) =>\n        row === undefined ? Option.none() : Option.some(recordOf(row)),\n      ),\n      Effect.mapError(fault),\n    ),\n\n  findByCorrelation: correlation =>\n    sql<FlowStatusRow>`\n      SELECT * FROM entifix_flow_status\n      WHERE correlation = ${correlation}`.pipe(\n      Effect.map(([row]) =>\n        row === undefined ? Option.none() : Option.some(recordOf(row)),\n      ),\n      Effect.mapError(fault),\n    ),\n\n  update: (flowId, patch) =>\n    sql`\n      UPDATE entifix_flow_status\n      SET state = ${patch.state}, step = ${patch.step ?? null},\n          waiting_for = ${patch.waitingFor ?? null},\n          correlation = ${patch.correlation ?? null}\n      WHERE flow_id = ${flowId}`.pipe(Effect.asVoid, Effect.mapError(fault)),\n});\n\n/** The SQL status store, its table ensured as the layer builds. */\nexport const SqlFlowStatusStoreLayer = Layer.effect(\n  FlowStatusStoreTag,\n  Effect.gen(function* () {\n    const sql = yield* SqlClient.SqlClient;\n    yield* ensureFlowStatusTable(sql);\n    return makeSqlFlowStatusStore(sql);\n  }),\n);\n"],"names":["translateSqlError","Effect","Layer","Option","SqlClient","FlowStatusStoreTag","recordOf","row","flowId","flow_id","executionId","execution_id","state","step","waiting_for","waitingFor","correlation","fault","error","ensureFlowStatusTable","sql","pipe","asVoid","mapError","makeSqlFlowStatusStore","register","key","record","gen","inserted","undefined","existing","find","map","none","some","findByCorrelation","update","patch","SqlFlowStatusStoreLayer","effect"],"mappings":"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"}

package/dist/socket-runner/index.d.ts

@@ -0,0 +1,2 @@
+export * from './socket-runner.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/socket-runner/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/socket-runner/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/socket-runner/index.js

@@ -0,0 +1,3 @@
+export * from './socket-runner.js';
+
+//# sourceMappingURL=index.js.map

package/dist/socket-runner/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/socket-runner/index.ts"],"sourcesContent":["export * from './socket-runner.js';\n"],"names":[],"mappings":"AAAA,cAAc,qBAAqB"}

package/dist/socket-runner/socket-runner.d.ts

@@ -0,0 +1,24 @@
+import { Layer } from 'effect';
+import { type ShardingConfig } from 'effect/cluster';
+import type { InterpreterOptions } from '../interpreter/slip-workflow.js';
+export interface SocketRunnerOptions {
+    /** Where the other runners reach this one, and where it listens. */
+    readonly host: string;
+    readonly port: number;
+    /**
+     * How quickly the runner notices a dead peer and takes its shards over —
+     * the lock expiry, the assignment refresh, the storage polls. The cluster
+     * defaults are tuned for a fleet that rarely loses a runner; a host may
+     * shorten them, and the chaos suite does.
+     */
+    readonly sharding?: Partial<Omit<ShardingConfig.ShardingConfig['Service'], 'runnerAddress'>>;
+}
+/**
+ * The flow engine as one runner among several
+ * ([ADR 0016](../../../../../docs/adr/0016-a-flow-engine-port-and-a-durable-workflow-adapter.md)):
+ * runners register in the shared SQL database, shards are spread between
+ * them, and a runner that dies has its flows resumed by another. Every
+ * replica runs this with its own port.
+ */
+export declare const SocketRunnerFlowEngineLayer: (options: InterpreterOptions, runner: SocketRunnerOptions) => Layer.Layer<import("@entifix/transactions").FlowEngineTag, import("@entifix/core").StoreFailure | import("effect/Config").ConfigError | import("effect/socket/SocketServer").SocketServerError, import("@entifix/transactions").OutboxTag | import("@entifix/transactions").BulkheadTag | import("@entifix/transactions").CircuitBreakerTag | import("@entifix/transactions").ParticipantClientTag | import("@entifix/transactions").RetryBudgetTag | import("effect/sql/SqlClient").SqlClient>;
+//# sourceMappingURL=socket-runner.d.ts.map

package/dist/socket-runner/socket-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket-runner.d.ts","sourceRoot":"","sources":["../../src/socket-runner/socket-runner.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAU,MAAM,QAAQ,CAAC;AACvC,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAG1E,MAAM,WAAW,mBAAmB;IAClC,oEAAoE;IACpE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CACzB,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,SAAS,CAAC,EAAE,eAAe,CAAC,CAChE,CAAC;CACH;AAED;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,GACtC,SAAS,kBAAkB,EAC3B,QAAQ,mBAAmB,oeAmB1B,CAAC"}

package/dist/socket-runner/socket-runner.js

@@ -0,0 +1,20 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { NodeClusterSocket } from '@effect/platform-node';
+import { Layer, Option } from 'effect';
+import { ClusterWorkflowEngine, RunnerAddress } from 'effect/cluster';
+import { FlowEngineLayer } from '../engine/make-flow-engine.js';
+import { SqlFlowStatusStoreLayer } from '../postgres/sql-flow-status-store.js';
+/**
+ * The flow engine as one runner among several
+ * ([ADR 0016](../../../../../docs/adr/0016-a-flow-engine-port-and-a-durable-workflow-adapter.md)):
+ * runners register in the shared SQL database, shards are spread between
+ * them, and a runner that dies has its flows resumed by another. Every
+ * replica runs this with its own port.
+ */ export const SocketRunnerFlowEngineLayer = (options, runner)=>FlowEngineLayer(options).pipe(Layer.provide(SqlFlowStatusStoreLayer), Layer.provide(ClusterWorkflowEngine.layer.pipe(Layer.provide(NodeClusterSocket.layer({
+        storage: 'sql',
+        shardingConfig: _extends({}, runner.sharding, {
+            runnerAddress: Option.some(RunnerAddress.make(runner.host, runner.port))
+        })
+    })))));
+
+//# sourceMappingURL=socket-runner.js.map

package/dist/socket-runner/socket-runner.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/socket-runner/socket-runner.ts"],"sourcesContent":["import { NodeClusterSocket } from '@effect/platform-node';\nimport { Layer, Option } from 'effect';\nimport {\n  ClusterWorkflowEngine,\n  RunnerAddress,\n  type ShardingConfig,\n} from 'effect/cluster';\n\nimport { FlowEngineLayer } from '../engine/make-flow-engine.js';\nimport type { InterpreterOptions } from '../interpreter/slip-workflow.js';\nimport { SqlFlowStatusStoreLayer } from '../postgres/sql-flow-status-store.js';\n\nexport interface SocketRunnerOptions {\n  /** Where the other runners reach this one, and where it listens. */\n  readonly host: string;\n  readonly port: number;\n  /**\n   * How quickly the runner notices a dead peer and takes its shards over —\n   * the lock expiry, the assignment refresh, the storage polls. The cluster\n   * defaults are tuned for a fleet that rarely loses a runner; a host may\n   * shorten them, and the chaos suite does.\n   */\n  readonly sharding?: Partial<\n    Omit<ShardingConfig.ShardingConfig['Service'], 'runnerAddress'>\n  >;\n}\n\n/**\n * The flow engine as one runner among several\n * ([ADR 0016](../../../../../docs/adr/0016-a-flow-engine-port-and-a-durable-workflow-adapter.md)):\n * runners register in the shared SQL database, shards are spread between\n * them, and a runner that dies has its flows resumed by another. Every\n * replica runs this with its own port.\n */\nexport const SocketRunnerFlowEngineLayer = (\n  options: InterpreterOptions,\n  runner: SocketRunnerOptions,\n) =>\n  FlowEngineLayer(options).pipe(\n    Layer.provide(SqlFlowStatusStoreLayer),\n    Layer.provide(\n      ClusterWorkflowEngine.layer.pipe(\n        Layer.provide(\n          NodeClusterSocket.layer({\n            storage: 'sql',\n            shardingConfig: {\n              ...runner.sharding,\n              runnerAddress: Option.some(\n                RunnerAddress.make(runner.host, runner.port),\n              ),\n            },\n          }),\n        ),\n      ),\n    ),\n  );\n"],"names":["NodeClusterSocket","Layer","Option","ClusterWorkflowEngine","RunnerAddress","FlowEngineLayer","SqlFlowStatusStoreLayer","SocketRunnerFlowEngineLayer","options","runner","pipe","provide","layer","storage","shardingConfig","sharding","runnerAddress","some","make","host","port"],"mappings":";AAAA,SAASA,iBAAiB,QAAQ,wBAAwB;AAC1D,SAASC,KAAK,EAAEC,MAAM,QAAQ,SAAS;AACvC,SACEC,qBAAqB,EACrBC,aAAa,QAER,iBAAiB;AAExB,SAASC,eAAe,QAAQ,gCAAgC;AAEhE,SAASC,uBAAuB,QAAQ,uCAAuC;AAiB/E;;;;;;CAMC,GACD,OAAO,MAAMC,8BAA8B,CACzCC,SACAC,SAEAJ,gBAAgBG,SAASE,IAAI,CAC3BT,MAAMU,OAAO,CAACL,0BACdL,MAAMU,OAAO,CACXR,sBAAsBS,KAAK,CAACF,IAAI,CAC9BT,MAAMU,OAAO,CACXX,kBAAkBY,KAAK,CAAC;QACtBC,SAAS;QACTC,gBAAgB,aACXL,OAAOM,QAAQ;YAClBC,eAAed,OAAOe,IAAI,CACxBb,cAAcc,IAAI,CAACT,OAAOU,IAAI,EAAEV,OAAOW,IAAI;;IAGjD,OAIN"}