@smthrs/flow 0.0.0-stage → 1.0.0-rc.4

package/src/Action/Implementations.ts

@@ -0,0 +1,149 @@
+/**
+ * The table a driver resolves a declared action's implementation through.
+ *
+ * `docs/concepts/flows-and-actions.md` splits an Action in two: a
+ * declaration that is pure data and travels everywhere, and an implementation
+ * attached separately as a layer, on the hosts that can run it. A body names
+ * the declaration — `Increment.call({ path })` records a node and executes
+ * nothing — so whatever later drives that node has to find the implementation
+ * by name, from context, at execution time. That is this service: `toLayer`
+ * files the implementation here when the table is present, and a driver asks
+ * for it by the tag the node carries.
+ *
+ * "When the table is present" means present while the implementation layer
+ * ITSELF is built, so ONE table goes under the implementations AND under
+ * whatever drives them:
+ *
+ * ```ts
+ * Layer.mergeAll(Read.toLayer(read), Write.toLayer(write), Interpreter.layer(Pipeline)).pipe(
+ *   Layer.provideMerge(Action.layerImplementations)
+ * )
+ * ```
+ *
+ * Filing is a build-time effect, not a declared output, so the type checker
+ * cannot catch a composition that builds one table for the implementations and
+ * a second for the driver. That composition files into the first and reads the
+ * second, and the driver refuses the call at run time naming the action.
+ *
+ * The table is deliberately not part of `FlowRuntime`. The runtime port is what
+ * a flow, an action, or a durable wait is EXECUTED against, and an
+ * implementation table is not an execution capability: it is authoring data,
+ * assembled by the same layers that assemble the declarations, and every
+ * runtime implementation can serve one identically.
+ *
+ * @since 0.1.0
+ */
+
+import * as Context from "effect/Context"
+import type * as Crypto from "effect/Crypto"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import type { Scope } from "effect/Scope"
+import type { FlowInstance } from "../FlowRuntime/FlowInstance.ts"
+import type { FlowRuntime } from "../FlowRuntime/FlowRuntime.ts"
+import { DuplicateImplementation } from "./DuplicateImplementation.ts"
+
+/**
+ * One declared action's implementation, as a driver consumes it: a name to
+ * resolve it by, and the durable action a payload produces.
+ *
+ * `action` returns the same `Action.make` value `toLayer` registers with
+ * the runtime, so a node driven through it takes the ordinary action path —
+ * invocation key, attempt journal, tier, retry policy — rather than a second
+ * execution mechanism that would have to keep up with the first.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Implementation {
+  readonly name: string
+  /** Semantic version attested by the implementation registration. */
+  readonly implementationVersion?: string | undefined
+  readonly action: (
+    payload: unknown
+  ) => Effect.Effect<unknown, unknown, Crypto.Crypto | FlowRuntime | FlowInstance>
+}
+
+/**
+ * Service holding the declared action implementations a composition wired
+ * up, keyed by action tag.
+ *
+ * **When to use**
+ *
+ * Use when driving a flow body, whose action calls name declarations rather
+ * than carry code. A composition that only drives behavior registered directly
+ * with the runtime never needs it, which is why `Action.toLayer` files an
+ * implementation here when the service is present and skips it otherwise.
+ *
+ * @category services
+ * @since 0.1.0
+ */
+export class Implementations extends Context.Service<
+  Implementations,
+  {
+    /**
+     * Files an implementation under its action tag for the lifetime of the
+     * registering scope. A conflicting registration dies unless `override: true` explicitly replaces the
+     * earlier one, and closing the registering scope exposes the newest
+     * registration whose scope is still open. Which of two merged layers is later is not a guarantee Effect
+     * makes, so a substitution replaces the implementation layer in the
+     * composition rather than stacking a second one on top of it — and a
+     * NESTED provision that reaches this same table through layer
+     * memoization shadows the enclosing entry only while it lives, instead
+     * of leaking its replacement into the enclosing composition.
+     */
+    readonly add: (
+      implementation: Implementation,
+      options?: { readonly override?: boolean }
+    ) => Effect.Effect<void, never, Scope>
+
+    /**
+     * The implementation registered for an action tag, if a layer supplied
+     * one.
+     */
+    readonly get: (name: string) => Effect.Effect<Option.Option<Implementation>>
+  }
+>()("@smthrs/flow/Action/Implementations") {}
+
+/**
+ * Layer providing an implementation table scoped to the composition that
+ * builds it.
+ *
+ * The table is mutable and lives for the layer's lifetime, exactly like the
+ * flow registry a runtime keeps: registration happens while layers are built,
+ * and every lookup happens later, when a run drives a node. Because filing is
+ * a build-time effect, provide this UNDER the implementation layers — see the
+ * wiring at the top of this module — rather than merging it beside them.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export const layerImplementations: Layer.Layer<Implementations> = Layer.effect(Implementations)(
+  Effect.sync(() => {
+    const registered = new Map<string, Array<{ readonly implementation: Implementation }>>()
+    return Implementations.of({
+      add: (implementation, options) =>
+        Effect.suspend(() => {
+          const entries = registered.get(implementation.name) ?? []
+          if (entries.length > 0 && options?.override !== true && entries.at(-1)?.implementation !== implementation) {
+            return Effect.die(new DuplicateImplementation({ name: implementation.name }))
+          }
+          // Ownership belongs to this registration, not the implementation
+          // object: two scopes may file the very same implementation. Sibling
+          // scopes can close in either order, so a captured predecessor is not
+          // proof that its resources are still alive when an override closes.
+          const entry = { implementation }
+          entries.push(entry)
+          registered.set(implementation.name, entries)
+          return Effect.addFinalizer(() =>
+            Effect.sync(() => {
+              entries.splice(entries.indexOf(entry), 1)
+              if (entries.length === 0) registered.delete(implementation.name)
+            })
+          )
+        }),
+      get: (name) => Effect.sync(() => Option.fromNullishOr(registered.get(name)?.at(-1)?.implementation))
+    })
+  })
+)

package/src/Action/InfraInterrupt.ts

@@ -0,0 +1,30 @@
+/**
+ * Defines the `InfraInterrupt` action failure.
+ *
+ * The `_tag` string was settled under `@smthrs/flow/` for 1.0.0-rc.0. The RC
+ * makes no compatibility promise to 0.x journals, and the tag freezes when
+ * the RC ships.
+ *
+ * @since 0.1.0
+ */
+
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+
+/**
+ * Marker an action implementation or adapter raises for an infrastructure
+ * event it wants the action's `interruptRetryPolicy` to retry. Shipped engines
+ * do not synthesize it from ordinary fiber interruption.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export class InfraInterrupt extends Schema.TaggedError<InfraInterrupt>()(
+  "@smthrs/flow/InfraInterrupt",
+  {
+    code: Schema.Literal("infra_interrupt").pipe(
+      Schema.withConstructorDefault(Effect.succeed("infra_interrupt"))
+    ),
+    reason: Schema.optional(Schema.Unknown)
+  }
+) {}

package/src/Action/InfraInterruptRetriesExhausted.ts

@@ -0,0 +1,37 @@
+/**
+ * Defines the `InfraInterruptRetriesExhausted` action failure.
+ *
+ * The `_tag` string was settled under `@smthrs/flow/` for 1.0.0-rc.0. The RC
+ * makes no compatibility promise to 0.x journals, and the tag freezes when
+ * the RC ships.
+ *
+ * @since 0.1.0
+ */
+
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+import { InfraInterrupt } from "./InfraInterrupt.ts"
+
+/**
+ * An action spent its infrastructure-interrupt retry policy without reaching
+ * an ordinary success or failure.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export class InfraInterruptRetriesExhausted extends Schema.TaggedError<InfraInterruptRetriesExhausted>()(
+  "@smthrs/flow/InfraInterruptRetriesExhausted",
+  {
+    code: Schema.Literal("infra_interrupt_retries_exhausted").pipe(
+      Schema.withConstructorDefault(Effect.succeed("infra_interrupt_retries_exhausted"))
+    ),
+    actionName: Schema.String,
+    attempts: Schema.Number,
+    interrupt: InfraInterrupt,
+    /**
+     * The sentence an operator reads out of a rendered cause. The typed fields
+     * beside it are what a log pipeline keys on.
+     */
+    message: Schema.String
+  }
+) {}

package/src/Action/IrreversibleRetryRequiresIdempotencyKey.ts

@@ -0,0 +1,32 @@
+/**
+ * Defines the `IrreversibleRetryRequiresIdempotencyKey` action failure.
+ *
+ * The `_tag` string was settled under `@smthrs/flow/` for 1.0.0-rc.0. The RC
+ * makes no compatibility promise to 0.x journals, and the tag freezes when
+ * the RC ships.
+ *
+ * @since 0.1.0
+ */
+
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+
+/**
+ * An irreversible action attempted a retry without declaring an
+ * idempotency key.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export class IrreversibleRetryRequiresIdempotencyKey
+  extends Schema.TaggedError<IrreversibleRetryRequiresIdempotencyKey>()(
+    "@smthrs/flow/IrreversibleRetryRequiresIdempotencyKey",
+    {
+      code: Schema.Literal("irreversible_retry_requires_idempotency_key").pipe(
+        Schema.withConstructorDefault(Effect.succeed("irreversible_retry_requires_idempotency_key"))
+      ),
+      actionName: Schema.String,
+      attempt: Schema.Number
+    }
+  )
+{}

package/src/Action/StepIdentity.ts

@@ -0,0 +1,219 @@
+// Deep reviewed and polished by a human on 2026-08-10.
+
+/**
+ * Derives allocation scopes and run-local invocation keys.
+ *
+ * Ordinal step identity has four components: the kind of durable operation
+ * (an action dispatch or an internal engine operation), the stable
+ * declaration identity (the action name, or a fixed internal label), an
+ * optional explicit idempotency component — a caller-declared string or
+ * object — and an optional structural dispatch site. Every ordinal counter
+ * in the engine is keyed by the scope this module derives, and the scope is
+ * also folded into the persisted key as `parentScope`, so two dispatches with
+ * distinct declarations or structural sites can never swap ordinals under a
+ * permuted fiber interleaving (issues #73, #85, #98, #101).
+ *
+ * The derivation is injective: distinct `(kind, name, idempotency, site)`
+ * inputs always produce distinct scopes. The name and site are
+ * length-prefixed so their contents cannot splice across component
+ * separators, and both idempotency forms are canonicalized to a fixed-width
+ * digest under distinct tags so a string can never alias the object identity
+ * whose digest it happens to spell.
+ *
+ * Governing contract: `docs/concepts/execution-identity.md`.
+ *
+ * @since 0.1.0
+ */
+
+import { Sha256 } from "@smthrs/crypto"
+import { DerivedKey, type StoredKey } from "@smthrs/keys"
+import * as Context from "effect/Context"
+import type * as Crypto from "effect/Crypto"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import * as Schema from "effect/Schema"
+
+/**
+ * Validates the engine-owned coordinates of a run-local invocation.
+ *
+ * @private
+ * @since 0.1.0
+ */
+const Invocation = Schema.Struct({
+  runId: Schema.NonEmptyString,
+  parentScope: Schema.optionalKey(Schema.NonEmptyString),
+  ordinal: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+  tier: Schema.Literals(["compensable", "irreversible", "unsealed"])
+})
+
+/**
+ * The interpreter graph site currently dispatching an action.
+ *
+ * A site is a replay-stable structural address of an `ActionCall` node. It is
+ * never derived from fiber arrival order and is never a diagnostic label. It
+ * is durable key material: changing it deliberately changes ordinal scopes
+ * and invocation keys. Handler-driven dispatches leave the service absent.
+ *
+ * @since 0.1.0
+ * @category services
+ */
+export class DispatchSite extends Context.Service<DispatchSite, string>()(
+  "@smthrs/flow/Action/DispatchSite"
+) {}
+
+/**
+ * What one dispatch tells the node that drove it.
+ *
+ * `outcome` is the fact the walk above cannot see on its own: whether the
+ * dispatch ran its body or was served from a durable record. `stepKeyDigest`
+ * is the identity the rest of the engine addresses that dispatch by — the
+ * digest `flows.engine.attempt-started` carries and `flows_attempts` is keyed
+ * on — and `attempt` is the durable attempt it ran as. Both are optional
+ * because a runtime that keeps no attempt rows has neither, and a node with
+ * no digest says so rather than inventing one.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface DispatchOutcome {
+  readonly outcome: "executed" | "replayed"
+  readonly stepKeyDigest?: string | undefined
+  readonly attempt?: number | undefined
+}
+
+/**
+ * Where the dispatches of one interpreter node report what happened to them.
+ *
+ * An engine knows facts the walk above it cannot see: whether a dispatch ran
+ * its body or was served from a durable record, which step key it ran under,
+ * and which durable attempt it was. Without the first a node that replayed
+ * every one of its dispatches is indistinguishable from one that did the work
+ * again. Without the other two a node's evidence cannot be joined to the
+ * attempt records the engine wrote, because an attempt record carries a step
+ * key digest and no node id while a node record carried no digest at all. The
+ * interpreter installs one of these per node and reads the report back when
+ * the node settles.
+ *
+ * Absent by default. A dispatch outside an interpreted graph — a handler
+ * calling an action directly — reports to nobody, and reporting stays a
+ * side channel rather than a change to what `actionExecute` returns.
+ *
+ * @since 1.0.0
+ * @category services
+ */
+export class DispatchReport extends Context.Service<DispatchReport, {
+  readonly dispatched: (dispatch: DispatchOutcome) => Effect.Effect<void>
+}>()("@smthrs/flow/Action/DispatchReport") {}
+
+/**
+ * Reports one dispatch to the node that drove it, when a node drove it.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export const reportDispatch = (dispatch: DispatchOutcome): Effect.Effect<void> =>
+  Effect.flatMap(
+    Effect.serviceOption(DispatchReport),
+    (report) => Option.isNone(report) ? Effect.void : report.value.dispatched(dispatch)
+  )
+
+/**
+ * The declaration material an allocation scope is derived from.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface AllocationIdentity {
+  /**
+   * `"action"` for user-declared action dispatches, `"internal"` for
+   * engine-owned durable operations (queue offers, deferred tokens). The two
+   * kinds own disjoint counter namespaces.
+   */
+  readonly kind: "action" | "internal"
+  /**
+   * The stable declaration identity: an action's declared name, or a fixed
+   * label for an internal operation family. Diagnostic names must not be
+   * passed here unless they are part of identity.
+   */
+  readonly name: string
+  /**
+   * The explicit idempotency component. A declared string and a declared
+   * cache key input both refine the scope — two concurrent invocations of
+   * one name with distinguishable inputs each own their own counter, so a
+   * replay that reverses fiber-arrival order can never hand one invocation
+   * the other's recorded outcome. Absent, invocations of one name share a
+   * counter and remain allocation-ordered — indistinguishable declarations
+   * have no material to order them by.
+   */
+  readonly idempotency?: string | Schema.JsonObject | undefined
+  /**
+   * The replay-stable structural address of the interpreter graph node that
+   * drives this dispatch. Absent for handler-driven dispatches, preserving
+   * their existing allocation scopes byte for byte.
+   */
+  readonly site?: string | undefined
+}
+
+/**
+ * Derives the ordinal allocation scope of a durable operation.
+ *
+ * The scope keys the operation's ordinal counter and is folded into its
+ * persisted invocation key as `parentScope`, so identity is stable
+ * under any interleaving of distinct declarations.
+ *
+ * Injectivity: the name is length-prefixed (`<kind>/<length>:<name>`), so a
+ * name containing `/s:` or `/c:` material cannot collide with a keyed form
+ * of a shorter name, and the idempotency component is a fixed-shape tagged
+ * digest appended after the name. Both idempotency forms canonicalize under
+ * distinct one-character tags so a string can never alias the object identity
+ * whose digest it happens to spell. A present site is appended as
+ * `/g:<length>:<site>`; its length prefix prevents site contents from
+ * aliasing another component or splicing across a future suffix. An absent
+ * site appends nothing, preserving the prior encoding exactly.
+ *
+ * The object form is caller-owned material, so it can carry values canonical
+ * serialization rejects (`Date`, `undefined`, class instances, `Redacted`);
+ * the failure surfaces as the typed `SchemaError` (issue #151), never
+ * as a thrown defect. The string and absent forms
+ * are total — the first overload keeps their error channel `never`.
+ *
+ * @since 0.1.0
+ * @category derivations
+ */
+export const allocationScope = (
+  identity: AllocationIdentity
+): Effect.Effect<string, Schema.SchemaError, Crypto.Crypto> =>
+  Effect.gen(function*() {
+    let scope = `${identity.kind}/${identity.name.length}:${identity.name}`
+    if (typeof identity.idempotency === "string") {
+      const digest = yield* Schema.decodeUnknownEffect(Sha256)(identity.idempotency)
+      scope = `${scope}/s:${digest}`
+    } else if (identity.idempotency !== undefined) {
+      const key = yield* Schema.decodeUnknownEffect(DerivedKey)({ kind: "declaration", input: identity.idempotency })
+      scope = `${scope}/c:${key}`
+    }
+    if (identity.site === undefined) return scope
+    return `${scope}/g:${identity.site.length}:${identity.site}`
+  })
+
+/**
+ * Derives an invocation key from engine-generated input.
+ *
+ * The input is engine-generated by construction — a finite counter
+ * ordinal, a literal tier, and plain string scopes — so canonical
+ * serialization cannot reject it. A failure here is an engine defect, and it
+ * surfaces as the typed `SchemaError` itself (issue #151) rather than
+ * being discarded through `Result.getOrThrow`.
+ *
+ * @since 0.1.0
+ * @category derivations
+ */
+export const invocationKey = (input: {
+  readonly runId: string
+  readonly parentScope?: string | undefined
+  readonly ordinal: number
+  readonly tier: "unsealed" | "compensable" | "irreversible"
+}): Effect.Effect<StoredKey, Schema.SchemaError, Crypto.Crypto> =>
+  Schema.decodeUnknownEffect(Invocation)(input).pipe(
+    Effect.flatMap((validated) => Schema.decodeUnknownEffect(DerivedKey)({ kind: "invocation", ...validated }))
+  )

package/src/Action/TreeArtifact.ts

@@ -0,0 +1,8 @@
+/**
+ * Directory outputs captured and replayed as tree artifacts.
+ *
+ * @since 0.1.0
+ */
+
+export { TreeArtifact } from "@smthrs/plan/FileSet"
+export type { TreeArtifact as Type } from "@smthrs/plan/FileSet"

package/src/Action/TypeId.ts

@@ -0,0 +1,9 @@
+// Deep reviewed and polished by a human on 2026-08-10.
+
+/**
+ * Runtime identity shared by action interfaces and constructors.
+ *
+ * @private
+ * @since 0.1.0
+ */
+export const TypeId = "@smthrs/flow/Action"

package/src/Action/UncanonicalIdempotencyKey.ts

@@ -0,0 +1,36 @@
+/**
+ * Defines the `UncanonicalIdempotencyKey` action failure.
+ *
+ * The `_tag` string was settled under `@smthrs/flow/` for 1.0.0-rc.0. The RC
+ * makes no compatibility promise to 0.x journals, and the tag freezes when
+ * the RC ships.
+ *
+ * @since 0.1.0
+ */
+
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+
+/**
+ * A caller-declared object-form `idempotencyKey` carried material canonical
+ * serialization rejects. The declaration can be fixed, and the error is
+ * non-retryable: the same declaration
+ * derives the same rejection on every attempt, so the body never runs.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export class UncanonicalIdempotencyKey extends Schema.TaggedError<UncanonicalIdempotencyKey>()(
+  "@smthrs/flow/UncanonicalIdempotencyKey",
+  {
+    code: Schema.Literal("uncanonical_idempotency_key").pipe(
+      Schema.withConstructorDefault(Effect.succeed("uncanonical_idempotency_key"))
+    ),
+    actionName: Schema.String,
+    /** Stable reason identifying an RFC 8785 canonicalization failure. */
+    reason: Schema.String,
+    /** The path of the offending value inside the declared identity. */
+    path: Schema.String,
+    message: Schema.String
+  }
+) {}

package/src/Action/idempotencyKey.ts

@@ -0,0 +1,67 @@
+// Deep reviewed and polished by a human on 2026-08-10.
+
+/**
+ * Derives run-local keys for internal durable operations.
+ *
+ * @since 0.1.0
+ */
+
+import type * as Crypto from "effect/Crypto"
+import * as Effect from "effect/Effect"
+import { FlowInstance } from "../FlowRuntime/FlowInstance.ts"
+import { CurrentAttempt } from "./Context.ts"
+import * as StepIdentity from "./StepIdentity.ts"
+
+/**
+ * Computes a run-local invocation key for an internal durable operation.
+ *
+ * The caller name separates durable declarations that share a parent scope.
+ *
+ * @category idempotency
+ * @since 0.1.0
+ */
+export const idempotencyKey: (
+  name: string,
+  options?: {
+    readonly includeAttempt?: boolean | undefined
+    readonly parentScope?: string | undefined
+  } | undefined
+) => Effect.Effect<string, never, FlowInstance | Crypto.Crypto> =
+  // Untraced because action-key allocation is on every action attempt.
+  Effect.fnUntraced(function*(name: string, options?: {
+    readonly includeAttempt?: boolean | undefined
+    readonly parentScope?: string | undefined
+  }) {
+    const instance = yield* FlowInstance
+    const attempt = yield* CurrentAttempt
+    // Internal durable operations are scoped by the caller's declaration name
+    // and declared `parentScope` through the canonical `StepIdentity` derivation (issue
+    // #98): a run-global counter numbered concurrent offers in fiber-arrival
+    // order, so a replay with a permuted interleaving handed one payload's
+    // ordinal to another and its await watched a deferred nothing resolves.
+    // With the counter scoped per declared parent, each scope numbers its
+    // own allocations deterministically; only allocations *within* one
+    // scope remain arrival-ordered — they carry no input that orders them
+    // by.
+    const parentScope = options?.parentScope !== undefined
+      ? options.parentScope
+      : options?.includeAttempt
+      ? `attempt:${attempt}`
+      : undefined
+    // String (or absent) idempotency input keeps the derivation total
+    // (issue #151): schema decoding preserves typed identity failures while
+    // injected cryptography keeps key construction platform-independent.
+    const scope = yield* StepIdentity.allocationScope({
+      kind: "internal",
+      name,
+      idempotency: parentScope
+    }).pipe(Effect.orDie)
+    const ordinal = instance.actionState.nextOrdinal(scope)
+    const identityScope = JSON.stringify([name, parentScope ?? null])
+    return yield* StepIdentity.invocationKey({
+      runId: instance.executionId,
+      ordinal,
+      tier: "unsealed",
+      parentScope: identityScope
+    }).pipe(Effect.orDie)
+  })

package/src/Action/index.ts

@@ -0,0 +1,31 @@
+// Deep reviewed and polished by a human on 2026-08-10.
+
+/**
+ * Durable actions, identity, boundaries, retries, and runtime context.
+ *
+ * @since 0.1.0
+ */
+
+export * from "./Action.ts"
+export * from "./AttemptTimedOut.ts"
+export * from "./BoundaryMode.ts"
+export * from "./CacheEnvironment.ts"
+export * from "./ConcurrentKeylessDispatch.ts"
+export * from "./Context.ts"
+export * from "./DuplicateImplementation.ts"
+export * from "./FileBoundary.ts"
+export * as Filegroup from "./Filegroup.ts"
+export * from "./FileInput.ts"
+export * as Glob from "./Glob.ts"
+export * from "./idempotencyKey.ts"
+export * from "./Implementations.ts"
+export * from "./ImplementationVersionMismatch.ts"
+export * from "./InfraInterrupt.ts"
+export * from "./InfraInterruptRetriesExhausted.ts"
+export * from "./IrreversibleRetryRequiresIdempotencyKey.ts"
+export * from "./make.ts"
+export * from "./raceAll.ts"
+export * from "./retry.ts"
+export * from "./StepIdentity.ts"
+export * as TreeArtifact from "./TreeArtifact.ts"
+export * from "./UncanonicalIdempotencyKey.ts"