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

package/src/Fault.ts

@@ -0,0 +1,279 @@
+/**
+ * One typed fault for every failure, and the one response table that reads it.
+ *
+ * Each owner of an error union registers its codes here with a class, so a
+ * failure crosses every seam as `{ class, tag }` rather than as prose. The
+ * control plane stamps it on a failed run, the gateway carries it to the
+ * worker, and every surface reads the same record.
+ *
+ * @since 1.0.0
+ */
+
+import * as Clock from "effect/Clock"
+import * as Effect from "effect/Effect"
+import * as Result from "effect/Result"
+import * as Schema from "effect/Schema"
+import type { HumanAnswerInvalid, HumanTaskFailed } from "./HumanTask.ts"
+import * as RetryPolicy from "./RetryPolicy.ts"
+
+/**
+ * Whose problem a failure is. The first five are the wire registry; `factory`
+ * (the factory's own work failed and a replan may fix it) and `policy` (a cap
+ * stopped it) are the factory's.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export const Class = Schema.Literals(["user", "wait", "infra", "dependency", "bug", "factory", "policy"])
+
+/**
+ * The decoded form of {@link Class}.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Class = typeof Class.Type
+
+/**
+ * What happens next. `very_hard` is a ladder state the worker reaches, not a class.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export const Response = Schema.Literals(["retry", "backup", "park", "replan", "very_hard", "help", "close", "stop"])
+
+/**
+ * The decoded form of {@link Response}.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Response = typeof Response.Type
+
+/**
+ * The record stamped on a failed run. `tag` is `<_tag>/<code>`, or `<_tag>`
+ * for an error without a code.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export const Fault = Schema.Struct({ class: Class, tag: Schema.String })
+
+/**
+ * The decoded form of {@link Fault}.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Fault = typeof Fault.Type
+
+/**
+ * One class per code of an owner's union. `satisfies Rows<Code>` at the owner
+ * makes a new code without a class a compile error.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Rows<Code extends string> = Readonly<Record<Code, Class>>
+
+interface Row {
+  readonly table: Class | Readonly<Record<string, Class>>
+  readonly field: string
+}
+
+/*
+ * One registry per process, not per module instance: a process that loads
+ * both the ESM and the CommonJS build still reads every owner's rows.
+ */
+const rows: Map<string, Row> = ((globalThis as { [key: symbol]: Map<string, Row> | undefined })[
+  Symbol.for("@smthrs/flow/Fault/rows")
+] ??= new Map())
+
+const same = (left: Row, right: Row): boolean =>
+  left.field === right.field && JSON.stringify(left.table) === JSON.stringify(right.table)
+
+/** Reads a property without running a throwing getter or proxy trap into the caller. */
+const read = (value: object, key: string): unknown => {
+  try {
+    return (value as Record<string, unknown>)[key]
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Registers an owner's error tag: one class for the whole tag, or one per
+ * value of its `field` (`code` unless the union names it otherwise). A value
+ * the table does not name is `bug`. Registering a tag again with the same
+ * rows is a no-op (a module loaded twice); with different rows it throws,
+ * because two owners disagreeing about one tag is a defect.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export const register = <Code extends string>(tag: string, table: Class | Rows<Code>, field = "code"): void => {
+  const row: Row = { table, field }
+  const existing = rows.get(tag)
+  if (existing !== undefined && !same(existing, row)) {
+    throw new Error(`Fault: ${tag} is already registered with different rows`)
+  }
+  rows.set(tag, row)
+}
+
+const classOf = (row: Row, code: string | undefined): Class =>
+  typeof row.table === "string" ? row.table : code !== undefined && Object.hasOwn(row.table, code)
+    ? row.table[code]!
+    : "bug"
+
+/**
+ * Every tag registered so far. The sweep test reads it.
+ *
+ * @category getters
+ * @since 1.0.0
+ */
+export const registered = (): ReadonlySet<string> => new Set(rows.keys())
+
+/**
+ * The fault of a failure. Walks `cause` and answers the innermost registered
+ * tag, because a wrapper names where a failure surfaced and its cause names
+ * why: a harness `model_failed` over a model `quota_exceeded` is a wait. A
+ * failure no owner registered is a `bug`.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export const of = (error: unknown): Fault => {
+  let found: Fault = { class: "bug", tag: "unregistered" }
+  let current: unknown = error
+  const seen = new Set<unknown>()
+  for (let depth = 0; depth < 16 && typeof current === "object" && current !== null && !seen.has(current); depth++) {
+    seen.add(current)
+    const tag = RetryPolicy.errorTag(current)
+    const row = tag === undefined ? undefined : rows.get(tag)
+    if (row !== undefined) {
+      const value = read(current, row.field)
+      const code = typeof value === "string" ? value : undefined
+      found = { class: classOf(row, code), tag: code === undefined ? tag! : `${tag}/${code}` }
+    }
+    current = read(current, "cause")
+  }
+  return found
+}
+
+/**
+ * Retries typed infrastructure failures of an effect the caller can safely repeat.
+ * Preserves its error channel when the bounded transient policy expires.
+ * Defects and interruption propagate without retry.
+ *
+ * @category combinators
+ * @since 1.0.0
+ */
+export const retryTransient = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+  Effect.gen(function*() {
+    const start = yield* Clock.currentTimeMillis
+    let attempt = 1
+    while (true) {
+      const result = yield* Effect.result(effect)
+      if (Result.isSuccess(result)) return result.success
+      if (of(result.failure).class !== "infra") return yield* Effect.fail(result.failure)
+      const decision = yield* RetryPolicy.decideEffect(RetryPolicy.transient, {
+        attempt,
+        error: result.failure,
+        elapsedMs: (yield* Clock.currentTimeMillis) - start
+      })
+      if (decision._tag === "GiveUp") return yield* Effect.fail(result.failure)
+      yield* Effect.sleep(decision.delayMs)
+      attempt++
+    }
+  })
+
+/**
+ * What the responder knows when it picks a response.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface State {
+  /** The action attempt that just failed. */
+  readonly attempt: number
+  /** Seats not tried in this frame and not cooling. */
+  readonly seatsLeft: number
+  /** Quota parks left before the run stops (`QuotaPolicy.defaultMaxParks` less those spent). */
+  readonly parksLeft: number
+  /** Replans spent: the worker's attempt minus one. */
+  readonly replans: number
+  /** Whether the item already had its very-hard continuation. */
+  readonly veryHard: boolean
+}
+
+/**
+ * The one ladder. A new class does not compile until it has a row.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export const respond = (fault: Fault, state: State): Response =>
+  ({
+    wait: state.seatsLeft > 0 ? "backup" : state.parksLeft > 0 ? "park" : "stop",
+    dependency: state.seatsLeft > 0 ? "backup" : state.attempt < 3 ? "retry" : "stop",
+    infra: state.attempt < 3 ? "retry" : "park",
+    factory: state.replans < 2 ? "replan" : !state.veryHard ? "very_hard" : "help",
+    user: fault.tag === "coding/Error/declined" ? "close" : "help",
+    policy: "stop",
+    bug: "stop"
+  } as const satisfies Record<Class, Response>)[fault.class]
+
+register("@smthrs/flow/InfraInterrupt", "infra")
+register("@smthrs/flow/InfraInterruptRetriesExhausted", "infra")
+register(
+  "@smthrs/flow/HumanTaskFailed",
+  {
+    rejected: "user",
+    timeout: "factory",
+    request_invalid: "bug"
+  } satisfies Rows<HumanTaskFailed["code"]>
+)
+register(
+  "@smthrs/flow/HumanAnswerInvalid",
+  {
+    answer_invalid: "user",
+    answer_not_open: "user"
+  } satisfies Rows<HumanAnswerInvalid["code"]>
+)
+// A spent polling or retry budget is the thing polled not answering in time.
+register("@smthrs/flow/PollExhausted", "dependency")
+register("@smthrs/flow/RetryAttemptsExhausted", "dependency")
+register("@smthrs/flow/RetryPolicyExpired", "dependency")
+// An attempt that outlives its bound is the thing it waited on not answering in time.
+register("@smthrs/flow/AttemptTimedOut", "dependency")
+// Invariant refusals: the program, not the person or the platform, is wrong.
+for (
+  const tag of [
+    "MaxRoundsExceeded",
+    "IrreversibleRetryRequiresIdempotencyKey",
+    "WaitForRequestInvalid",
+    "SleepRequestInvalid",
+    "DurableDeferred/TokenInvalid",
+    "ExecutionIdRequired",
+    "FlowCycleDetected",
+    "CancelRequestFailed",
+    "Action/DuplicateImplementation",
+    "ConcurrentKeylessDispatch",
+    "FlowExecutionNotFound",
+    "ImplementationVersionMismatch",
+    "UncanonicalIdempotencyKey",
+    "InterpreterError"
+  ]
+) register(`@smthrs/flow/${tag}`, "bug")
+
+// Lower host seams do not depend on flow authoring. Register their stable wire
+// tags here so classification does not introduce an upward package dependency.
+register("@smthrs/kernel/Unreachable", "infra")
+register("@smthrs/sandbox/RemoteChildProcessSpawner/ProviderError", {
+  unavailable: "infra",
+  timeout: "infra",
+  spawn_error: "bug",
+  not_found: "bug",
+  aborted: "bug",
+  unknown: "bug"
+})

package/src/Flow/Annotations.ts

@@ -0,0 +1,151 @@
+// Deep reviewed and polished by a human on 2026-08-10.
+
+/**
+ * Execution policies attached to flow definitions through Effect context.
+ *
+ * @since 0.1.0
+ */
+
+import * as PlanEffects from "@smthrs/plan/Effects"
+import * as PlanPlacement from "@smthrs/plan/Placement"
+import * as Plan from "@smthrs/plan/Plan"
+import * as Context from "effect/Context"
+import { constFalse, constTrue } from "effect/Function"
+
+/**
+ * Declared filesystem effects: the plan node effect contract itself.
+ *
+ * This is `@smthrs/plan`'s `Plan.NodeEffects`, not a copy of it. The two were
+ * field-for-field identical structs in two packages, which meant a change to
+ * one silently stopped `Plan.compile` decoding what this package wrote.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export const Effects = Plan.NodeEffects
+
+/**
+ * The value form of {@link Effects}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Effects = Plan.NodeEffects
+
+/**
+ * A directive naming where a node runs, carried unchanged until planning.
+ *
+ * This is `@smthrs/plan`'s `Placement.Placement`, the one typed model. It was
+ * `Schema.Unknown` here while `@smthrs/core` held a four-variant enum of the
+ * same thing, which made every crossing a cast.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type PlacementDirective = PlanPlacement.Placement
+
+/**
+ * Capability ceiling. An omitted annotation inherits; an explicit empty array denies.
+ * The reference default remains an empty metadata projection for catalog readers;
+ * execution distinguishes an absent annotation from an explicitly stored one.
+ *
+ * @category annotations
+ * @since 0.1.0
+ */
+export const Capabilities = Context.Reference<ReadonlyArray<string>>(
+  "@smthrs/flow/Flow/Capabilities",
+  { defaultValue: () => [] }
+)
+
+/**
+ * Required annotation key for a flow's declared filesystem effects.
+ *
+ * @category annotations
+ * @since 0.1.0
+ */
+export const EffectsDeclaration = Context.Service<Effects>("@smthrs/flow/Flow/EffectsDeclaration")
+
+/**
+ * The effect AUTHORITY a flow declares: the ceiling every step spliced beneath
+ * it must stay inside.
+ *
+ * This is the one envelope model, `@smthrs/plan/Effects`, which `@smthrs/core`
+ * re-exports and `@smthrs/patterns` intersects against. It answers a different
+ * question from {@link EffectsDeclaration}: that one says which FILES a node
+ * touches, so a plan can order writers and a sandbox can enforce a boundary at
+ * run time, while this one says how much a flow is ALLOWED to touch, so
+ * {@link module:Graph.build} can refuse a composition that claims more than its
+ * caller granted.
+ *
+ * `Flow.make`'s `effects` option writes it, which is what makes it readable by
+ * a catalog that projects a declaration without importing this module.
+ *
+ * @category annotations
+ * @since 0.1.0
+ */
+export const EffectEnvelope = PlanEffects.Envelope
+
+/**
+ * Required annotation key for a flow's schema-encodable placement directive.
+ *
+ * @category annotations
+ * @since 0.1.0
+ */
+export const Placement = PlanPlacement.Annotation
+
+/**
+ * Captures defects for a flow and includes them in the result of the flow or its actions.
+ *
+ * **Details**
+ *
+ * By default, this annotation is set to `true`, meaning defects are captured.
+ *
+ * @category annotations
+ * @since 0.1.0
+ */
+export const CaptureDefects = Context.Reference<boolean>(
+  "@smthrs/flow/Flow/CaptureDefects",
+  {
+    defaultValue: constTrue
+  }
+)
+
+/**
+ * Whether a catalog may offer this flow to a model, defaulting to yes.
+ *
+ * It answers a different question from {@link Capabilities}: that one says how
+ * much a flow is allowed to touch, this one says whether a model is shown the
+ * flow at all. A flow whose actions only one host implements is discoverable
+ * everywhere its file is, and teaching it to an agent running somewhere else
+ * offers a call that has no implementation to reach.
+ *
+ * `Flow.make`'s `modelInvocable` option writes it, which is what makes it
+ * readable by a catalog that projects a declaration from source text without
+ * importing this module, exactly as `capabilities` and `effects` are.
+ *
+ * @category annotations
+ * @since 0.1.0
+ */
+export const ModelInvocable = Context.Reference<boolean>(
+  "@smthrs/flow/Flow/ModelInvocable",
+  {
+    defaultValue: constTrue
+  }
+)
+
+/**
+ * Marks a flow to suspend when it encounters any error.
+ *
+ * **Details**
+ *
+ * The suspended execution can later be resumed with the flow's `resume` method, for example `MyFlow.resume(executionId)`.
+ *
+ * @category annotations
+ * @since 0.1.0
+ */
+export const SuspendOnFailure = Context.Reference<boolean>(
+  "@smthrs/flow/Flow/SuspendOnFailure",
+  {
+    defaultValue: constFalse
+  }
+)

package/src/Flow/CapabilityCeiling.ts

@@ -0,0 +1,37 @@
+/** Declared capability ceilings shared by planning and execution.
+ * @since 1.0.0
+ */
+
+import * as Capability from "@smthrs/capability/Capability"
+import * as CapabilitySet from "@smthrs/capability/CapabilitySet"
+import * as Context from "effect/Context"
+import * as Option from "effect/Option"
+import { Capabilities } from "./Annotations.ts"
+
+/** Returns only explicitly declared ceilings; omission inherits.
+ * @category accessors
+ * @since 1.0.0
+ */
+export const capabilityCeilings = (annotations: Context.Context<never>): ReadonlyArray<ReadonlyArray<string>> =>
+  annotations.mapUnsafe.has(Capabilities.key) ? [Context.get(annotations, Capabilities)] : []
+
+/** Parses declaration patterns into ceiling groups. Invalid patterns are dropped, so they deny.
+ * @category constructors
+ * @since 1.0.0
+ */
+export const parseCapabilityCeilings = (
+  groups: ReadonlyArray<ReadonlyArray<string>>
+): ReadonlyArray<ReadonlyArray<Capability.CapabilityPattern>> =>
+  groups.map((group) =>
+    group.flatMap((text) => {
+      const parsed = Capability.parsePattern(text)
+      return Option.isSome(parsed) ? [parsed.value] : []
+    })
+  )
+
+/** Applies declaration patterns as an exact conjunction. Invalid patterns deny.
+ * @category combinators
+ * @since 1.0.0
+ */
+export const attenuateCapabilities = (groups: ReadonlyArray<ReadonlyArray<string>>) =>
+  CapabilitySet.attenuateGroups(parseCapabilityCeilings(groups))

package/src/Flow/DeadlineExceeded.ts

@@ -0,0 +1,40 @@
+/**
+ * Defect recorded when an execution runs past its flow's declared deadline.
+ *
+ * @since 1.0.0
+ */
+
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+import * as Fault from "../Fault.ts"
+
+/**
+ * An execution was still unsettled when its flow's `deadline` elapsed.
+ *
+ * The deadline counts from the execution's first start, which the engine
+ * journals, so a resume after a restart honors the original deadline rather
+ * than starting a new one. Expiry is terminal: the execution settles with this
+ * defect whether it was running or parked, and its attached children are
+ * cancelled with it. It is not a typed `execute` failure.
+ *
+ * `startedAtMs` is the journaled start and `deadlineMs` the declared bound, so
+ * `startedAtMs + deadlineMs` is when the execution expired.
+ *
+ * @category errors
+ * @since 1.0.0
+ */
+export class DeadlineExceeded extends Schema.TaggedError<DeadlineExceeded>()(
+  "@smthrs/flow/DeadlineExceeded",
+  {
+    code: Schema.Literal("deadline_exceeded").pipe(
+      Schema.withConstructorDefault(Effect.succeed("deadline_exceeded"))
+    ),
+    flowName: Schema.String,
+    executionId: Schema.String,
+    deadlineMs: Schema.Number,
+    startedAtMs: Schema.Number,
+    message: Schema.String
+  }
+) {}
+
+Fault.register("@smthrs/flow/DeadlineExceeded", "policy")

package/src/Flow/ExecutionIdRequired.ts

@@ -0,0 +1,36 @@
+// Deep reviewed and polished by a human on 2026-08-10.
+
+/**
+ * Failure raised when a flow execution has no explicit or derived identity.
+ *
+ * @since 0.1.0
+ */
+
+import * as Effect from "effect/Effect"
+import * as Schema from "effect/Schema"
+
+/**
+ * A flow execution has no selected identity.
+ *
+ * The opt-in `derived` execution-id source raises this when the payload
+ * cannot be canonicalized, for example a non-finite number, a lone surrogate,
+ * or a cycle. It dies with it before starting a run, so this is a defect and
+ * not a typed failure a body catches. The default `fresh` source instead
+ * mints a cryptographic UUID for every unkeyed invocation.
+ *
+ * A served resume raises it too: `FlowProxyServer` dies with it when the
+ * `ExecutionIdScope` configured on a layer returns `undefined` for a resume
+ * request, because the client value is not a fallback there.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export class ExecutionIdRequired extends Schema.TaggedError<ExecutionIdRequired>()(
+  "@smthrs/flow/ExecutionIdRequired",
+  {
+    code: Schema.Literal("execution_id_required").pipe(
+      Schema.withConstructorDefault(Effect.succeed("execution_id_required"))
+    ),
+    flowName: Schema.String
+  }
+) {}

package/src/Flow/ExecutionIds.ts

@@ -0,0 +1,133 @@
+/**
+ * The ambient source of execution identity, for a flow executed without one.
+ *
+ * Identity has three sources, in this order: the `executionId` the caller
+ * named, the `idempotencyKey` the flow declared, and — when neither exists —
+ * the source in this module. The first two are decisions an author made at the
+ * call site or the declaration site; the third is a decision the *host* makes
+ * once, for every flow it drives, which is why it is a context reference and
+ * not another option on `execute`.
+ *
+ * The default mints a fresh cryptographic UUID for every unkeyed invocation.
+ * Equal payloads are independent requests. To reattach after a crash, retain
+ * the returned execution id, declare an idempotency key, or explicitly install
+ * the `derived` source. Changing this default does not rewrite stored ids.
+ *
+ * @since 0.1.0
+ */
+
+import { Sha256 } from "@smthrs/crypto"
+import { DerivedKey } from "@smthrs/keys"
+import * as Context from "effect/Context"
+import * as Crypto from "effect/Crypto"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Schema from "effect/Schema"
+import { ExecutionIdRequired } from "./ExecutionIdRequired.ts"
+import type { Any } from "./Flow.ts"
+
+/**
+ * Mints the execution id of an invocation that named none.
+ *
+ * It is consulted only after the two explicit sources are absent, and it runs
+ * before the runtime is read, so a source that cannot name the invocation
+ * fails the execution rather than starting one under a guessed identity.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface ExecutionIdSource {
+  readonly mint: <W extends Any>(
+    flow: W,
+    payload: unknown
+  ) => Effect.Effect<string, never, Crypto.Crypto | W["payloadSchema"]["EncodingServices"]>
+}
+
+/**
+ * The canonical key of an invocation: the flow's own payload codec, then RFC
+ * 8785, then SHA-256.
+ *
+ * Encoding first is what makes the key agree with the durable driver, which
+ * compares the ENCODED payload when it decides whether an existing run row is
+ * the same invocation. A payload with no canonical form — a non-finite number,
+ * a lone surrogate, a cycle — has no derivable identity at all, so it fails
+ * here instead of hashing something approximate.
+ *
+ * @private
+ */
+const canonicalKey = <W extends Any>(
+  flow: W,
+  payload: unknown
+): Effect.Effect<string, ExecutionIdRequired, Crypto.Crypto | W["payloadSchema"]["EncodingServices"]> =>
+  (Schema.encodeEffect(Schema.toCodecJson(flow.payloadSchema))(payload) as Effect.Effect<
+    unknown,
+    unknown,
+    W["payloadSchema"]["EncodingServices"]
+  >).pipe(
+    Effect.flatMap((encoded) => Schema.decodeUnknownEffect(DerivedKey)(encoded)),
+    Effect.mapError(() => new ExecutionIdRequired({ flowName: flow._tag }))
+  )
+
+/**
+ * An opt-in deterministic source over the flow tag and the payload's
+ * canonical form.
+ *
+ * Same tag and same encoded payload derive the same id, which is exactly the
+ * pair the durable driver already treats as one invocation, so a re-drive of a
+ * crashed program re-attaches to the run it left behind instead of opening a
+ * second one.
+ *
+ * The tag and canonical payload key are JSON-tuple framed before hashing.
+ * Their strings are used exactly as given and encoded as UTF-8, with no Unicode
+ * normalization. This preimage encoding freezes at rc.0.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export const derived: ExecutionIdSource = {
+  mint: (flow, payload) =>
+    canonicalKey(flow, payload).pipe(
+      // The JSON tuple prevents delimiter splicing. This exact framing freezes at rc.0.
+      Effect.flatMap((key) => Effect.orDie(Schema.decodeUnknownEffect(Sha256)(JSON.stringify([flow._tag, key])))),
+      Effect.orDie
+    )
+}
+
+/**
+ * Mints independent execution ids for unkeyed requests using host cryptography.
+ * @category constructors
+ * @since 0.1.0
+ */
+export const fresh: ExecutionIdSource = {
+  mint: () => Effect.flatMap(Crypto.Crypto, (crypto) => Effect.orDie(crypto.randomUUIDv4))
+}
+
+/**
+ * Context reference carrying the host's execution-id source, defaulting to
+ * {@link fresh}.
+ *
+ * @category idempotency
+ * @since 0.1.0
+ */
+export const CurrentExecutionIds = Context.Reference<ExecutionIdSource>(
+  "@smthrs/flow/Flow/CurrentExecutionIds",
+  {
+    defaultValue: () => fresh
+  }
+)
+
+/**
+ * Declares the host's execution-id source as a layer.
+ *
+ * **When to use**
+ *
+ * Install `derived` when equal payloads deliberately identify the same work,
+ * or provide a host-specific identity source. Explicit caller execution ids
+ * and declared idempotency keys take precedence over this source.
+ *
+ * @category idempotency
+ * @since 0.1.0
+ */
+export const layerExecutionIds = (
+  source: ExecutionIdSource
+): Layer.Layer<never> => Layer.succeed(CurrentExecutionIds)(source)