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

package/dist/esm/Flow/Result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Result.js","sourceRoot":"","sources":["../../../src/Flow/Result.ts"],"names":[],"mappings":"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","sourcesContent":["// Deep reviewed and polished by a human on 2026-08-10.\n\n/**\n * Serializable completion and suspension states returned by flow executions.\n *\n * @since 0.1.0\n */\n\nimport { CapabilityPattern } from \"@smthrs/capability/Capability\"\nimport * as Data from \"effect/Data\"\nimport * as Effect from \"effect/Effect\"\nimport type * as Exit from \"effect/Exit\"\nimport * as Schema from \"effect/Schema\"\nimport * as SchemaIssue from \"effect/SchemaIssue\"\nimport * as SchemaParser from \"effect/SchemaParser\"\nimport * as Transformation from \"effect/SchemaTransformation\"\nimport type { ExitEncoded } from \"effect/unstable/rpc/RpcMessage\"\n\nconst ResultTypeId = \"@smthrs/flow/Flow/Result\"\n\n/**\n * Returns `true` when a value is a flow `Result`.\n *\n * @category results\n * @since 0.1.0\n */\nexport const isResult = <A = unknown, E = unknown>(\n  u: unknown\n): u is Result<A, E> => {\n  if (u !== Object(u)) return false\n  const marker = Object.getOwnPropertyDescriptor(u, ResultTypeId)\n  if (marker === undefined || !(\"value\" in marker) || marker.value !== ResultTypeId) return false\n  const tag = Object.getOwnPropertyDescriptor(u, \"_tag\")\n  return tag !== undefined && \"value\" in tag &&\n    (tag.value === \"Complete\" || tag.value === \"Suspended\" || tag.value === \"Handoff\")\n}\n\n/**\n * Result of a flow execution: a completed exit, a suspended flow state, or a\n * handoff to the next round of a trampoline lineage.\n *\n * @category results\n * @since 0.1.0\n */\nexport type Result<A, E> = Complete<A, E> | Suspended | Handoff\n\n/**\n * Encoded representation of a flow `Result`.\n *\n * @category results\n * @since 0.1.0\n */\nexport type ResultEncoded<A, E> =\n  | CompleteEncoded<A, E>\n  | typeof Suspended.Encoded\n  | typeof Handoff.Encoded\n\n/**\n * Encoded representation of a completed flow result containing an encoded\n * `Exit`.\n *\n * @category results\n * @since 0.1.0\n */\nexport interface CompleteEncoded<A, E> {\n  readonly _tag: \"Complete\"\n  readonly exit: ExitEncoded<A, E>\n}\n\n/**\n * Schema constructor for `Complete` flow results using the supplied\n * success and error schemas.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport interface CompleteSchema<\n  Success extends Schema.Constraint,\n  Error extends Schema.Constraint\n> extends\n  Schema.declareConstructor<\n    Complete<Success[\"Type\"], Error[\"Type\"]>,\n    Complete<Success[\"Encoded\"], Error[\"Encoded\"]>,\n    readonly [Schema.Exit<Success, Error, Schema.Defect>]\n  >\n{\n  readonly success: Success\n  readonly error: Error\n}\n\n/**\n * Represents a completed flow execution with its success or failure `Exit`.\n *\n * @category results\n * @since 0.1.0\n */\nexport class Complete<A, E> extends Data.TaggedClass(\"Complete\")<{\n  readonly exit: Exit.Exit<A, E>\n}> {\n  /**\n   * Marks this value as a flow result for runtime guards.\n   *\n   * @since 0.1.0\n   */\n  readonly [ResultTypeId] = ResultTypeId\n\n  /**\n   * Builds the schema for completed flow results from success and error schemas.\n   *\n   * @since 0.1.0\n   */\n  static Schema<Success extends Schema.Constraint, Error extends Schema.Constraint>(options: {\n    readonly success: Success\n    readonly error: Error\n  }): CompleteSchema<Success, Error> {\n    // The declaration stays inline because it closes over this constructor's schemas.\n    const schema = Schema.declareConstructor<\n      Complete<Success[\"Type\"], Error[\"Type\"]>,\n      Complete<Success[\"Encoded\"], Error[\"Encoded\"]>\n    >()(\n      [Schema.Exit(options.success, options.error, Schema.Defect())],\n      ([exit]) => (input, ast, options) => {\n        if (!(isResult(input) && input._tag === \"Complete\")) {\n          return Effect.fail(new SchemaIssue.InvalidType(ast, input, options))\n        }\n        return Effect.mapBothEager(\n          SchemaParser.decodeEffect(exit)(input.exit, options),\n          {\n            onSuccess: (exit) => new Complete({ exit }),\n            onFailure: (issue) =>\n              new SchemaIssue.Composite(\n                ast,\n                [\n                  new SchemaIssue.Pointer([\"exit\"], issue)\n                ],\n                input,\n                options\n              )\n          }\n        )\n      },\n      {\n        expected: \"Flow.Complete\",\n        toCodecJson: ([exit]) =>\n          Schema.link<Complete<Success[\"Encoded\"], Error[\"Encoded\"]>>()(\n            Schema.Struct({\n              _tag: Schema.tag(\"Complete\"),\n              exit\n            }),\n            Transformation.transform({\n              decode: (encoded) => new Complete({ exit: encoded.exit }),\n              encode: (result) => (({\n                _tag: \"Complete\",\n                exit: result.exit\n              }) as const)\n            })\n          )\n      }\n    )\n    return Schema.make(schema.ast, {\n      success: options.success,\n      error: options.error\n    })\n  }\n}\n\n/**\n * Represents a suspended flow execution, optionally carrying the cause that\n * triggered suspension.\n *\n * @category results\n * @since 0.1.0\n */\nexport class Suspended extends Schema.Class<Suspended>(\n  \"@smthrs/flow/Flow/Suspended\"\n)({\n  _tag: Schema.tag(\"Suspended\"),\n  cause: Schema.optional(Schema.Cause(Schema.Never, Schema.Defect()))\n}) {\n  /**\n   * Marks this value as a flow result for runtime guards.\n   *\n   * @since 0.1.0\n   */\n  readonly [ResultTypeId] = ResultTypeId\n}\n\n/**\n * The deadline a trampoline lineage's rounds share: the journaled first start\n * of its originating round and the bound in milliseconds, so every round\n * expires at `startedAtMs + deadlineMs`.\n *\n * @category results\n * @since 1.0.0\n */\nexport const LineageDeadline = Schema.Struct({\n  startedAtMs: Schema.Number,\n  deadlineMs: Schema.Number\n})\n\n/**\n * The deadline a trampoline lineage's rounds share.\n *\n * @category results\n * @since 1.0.0\n */\nexport type LineageDeadline = typeof LineageDeadline.Type\n\n/**\n * Represents a flow round that ended by handing off to the next round of its\n * trampoline lineage.\n *\n * A round settles this way when its body's root value is a `to` invocation\n * (`docs/concepts/trampoline-rounds.md`): the round produced no answer of\n * its own, it produced the NEXT flow to run. `flow` is the target's tag, so the\n * value survives the journal and the run row unchanged.\n *\n * DECIDED: `payload` is the target's payload in\n * ENCODED form. The target's `to` method accepts its ordinary constructor\n * shape so authoring stays aligned with `call` and `execute`; the body\n * interpreter resolves planned references and encodes the invocation through\n * the target declaration before constructing `Handoff`. The receiving round\n * decodes those bytes through the same schema.\n *\n * It is a third settlement rather than a `Complete` carrying a magic value\n * because the engine has to tell \"this run answered\" from \"this run continues\n * elsewhere\" without decoding against a success schema the handoff never\n * satisfies.\n *\n * @category results\n * @since 0.1.0\n */\nexport class Handoff extends Schema.Class<Handoff>(\n  \"@smthrs/flow/Flow/Handoff\"\n)({\n  _tag: Schema.tag(\"Handoff\"),\n  flow: Schema.NonEmptyString,\n  capabilityCeilings: Schema.optionalKey(Schema.Array(Schema.Array(CapabilityPattern))),\n  payload: Schema.Unknown,\n  /**\n   * The lineage deadline the next round runs under, stamped by the round\n   * that handed off when its lineage is bounded (`Deadline.bound`).\n   */\n  deadline: Schema.optionalKey(LineageDeadline)\n}) {\n  /**\n   * Marks this value as a flow result for runtime guards.\n   *\n   * @since 0.1.0\n   */\n  readonly [ResultTypeId] = ResultTypeId\n}\n\n/**\n * Creates a schema for flow results using the supplied success and error\n * schemas.\n *\n * @category results\n * @since 0.1.0\n */\nexport const Result = <\n  Success extends Schema.Constraint,\n  Error extends Schema.Constraint\n>(options: {\n  readonly success: Success\n  readonly error: Error\n}) => Schema.Union([Complete.Schema(options), Suspended, Handoff])\n\nconst AnyOrVoid = Schema.Union([Schema.Any, Schema.Void])\n\n/**\n * Schema for encoded flow results with generic success and error payloads.\n *\n * @category results\n * @since 0.1.0\n */\nexport const ResultEncoded: Schema.Codec<ResultEncoded<any, any>> = Schema.toEncoded(\n  Schema.toCodecJson(\n    Result({\n      success: AnyOrVoid,\n      error: AnyOrVoid\n    })\n  )\n) as any\n"]}

package/dist/esm/Flow/Runtime.d.ts

@@ -0,0 +1,98 @@
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Scope from "effect/Scope";
+import { FlowInstance } from "../FlowRuntime/FlowInstance.ts";
+import { type Result } from "./Result.ts";
+/**
+ * Runs an effect as a flow execution and converts its outcome into a
+ * `Result`, handling suspension, defect capture, interruption, and flow
+ * scope finalization.
+ *
+ * @category results
+ * @since 0.1.0
+ */
+export declare const intoResult: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Result<A, E>, never, Exclude<R, Scope.Scope> | FlowInstance>;
+/**
+ * Wraps an action-like effect so flow suspension waits for currently
+ * running actions to finish or suspend.
+ *
+ * The wait is for *siblings*. An action that suspends holds work its siblings
+ * have not journaled yet, so the flow must not park out from under them; an
+ * enclosing region holds no such work, because everything it is doing is this
+ * region. Waiting for one is a deadlock, and it was a real one: a harness cell
+ * call is an action, the `wait` flow it dispatches awaits a `DurableClock`
+ * under the run's own instance, and the round that should have parked instead
+ * blocked forever inside an uninterruptible finalizer — not cancellable, not
+ * resumable, and invisible in the journal past the `clock-scheduled` record.
+ *
+ * @category results
+ * @since 0.1.0
+ */
+export declare const wrapActionResult: <A, E, R>(effect: Effect.Effect<A, E, R>, isSuspend: (value: A) => boolean) => Effect.Effect<A, E, R | FlowInstance>;
+/**
+ * Accesses the current round's flow scope. Suspension keeps it open;
+ * completion or handoff closes it.
+ *
+ * @category resource management
+ * @since 0.1.0
+ */
+export declare const scope: Effect.Effect<Scope.Scope, never, FlowInstance>;
+/**
+ * Provides the current round's flow scope to the given effect. Suspension keeps
+ * the scope open; completion or handoff closes it.
+ *
+ * @category resource management
+ * @since 0.1.0
+ */
+export declare const provideScope: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Scope.Scope> | FlowInstance>;
+/**
+ * Adds an exit finalizer to the current flow scope, preserving the
+ * services available when the finalizer is registered.
+ *
+ * @category resource management
+ * @since 0.1.0
+ */
+export declare const addFinalizer: <R>(f: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void, never, R>) => Effect.Effect<void, never, FlowInstance | R>;
+/**
+ * Runs an effect and registers how to undo its successful result if the
+ * current round later exits unsuccessfully.
+ *
+ * **When to use**
+ *
+ * Use when a top-level flow operation changes something that must be undone if
+ * a later operation causes the same round to fail or be interrupted.
+ *
+ * **Details**
+ *
+ * The effect runs first. If it fails, no rollback is registered. If it
+ * succeeds, its value is captured in a round-scope finalizer. The finalizer does
+ * nothing when the round succeeds; when the round exits unsuccessfully
+ * it calls `rollback(value, cause)`. Suspension keeps that scope open.
+ *
+ * A handoff completes the round successfully and discards its `withRollback` registrations.
+ * A later round's failure cannot invoke those rollbacks. The engine does not
+ * provide lineage-scoped compensation.
+ *
+ * **Gotchas**
+ *
+ * This applies only to effects run directly inside the flow execution. It does
+ * not attach rollback behavior to nested actions. The rollback's typed error
+ * channel is `never`; handle expected rollback failures inside the callback.
+ *
+ * @category resource management
+ * @since 0.1.0
+ */
+export declare const withRollback: {
+    <A, R2>(rollback: (value: A, cause: Cause.Cause<unknown>) => Effect.Effect<void, never, R2>): <E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | R2 | FlowInstance | Scope.Scope>;
+    <A, E, R, R2>(effect: Effect.Effect<A, E, R>, rollback: (value: A, cause: Cause.Cause<unknown>) => Effect.Effect<void, never, R2>): Effect.Effect<A, E, R | R2 | FlowInstance | Scope.Scope>;
+};
+/**
+ * Marks a flow instance as suspended and interrupts the current fiber to
+ * stop execution until it is resumed.
+ *
+ * @category results
+ * @since 0.1.0
+ */
+export declare const suspend: (instance: FlowInstance["Service"]) => Effect.Effect<never>;
+//# sourceMappingURL=Runtime.d.ts.map

package/dist/esm/Flow/Runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Runtime.d.ts","sourceRoot":"","sources":["../../../src/Flow/Runtime.ts"],"names":[],"mappings":"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"}

package/dist/esm/Flow/Runtime.js

@@ -0,0 +1,231 @@
+// Deep reviewed and polished by a human on 2026-08-10.
+/**
+ * Runtime helpers for flow completion, suspension, scopes, and rollback.
+ *
+ * @since 0.1.0
+ */
+import * as Arr from "effect/Array";
+import * as Cause from "effect/Cause";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as Filter from "effect/Filter";
+import { dual, identity } from "effect/Function";
+import * as Scope from "effect/Scope";
+import { FlowInstance } from "../FlowRuntime/FlowInstance.js";
+import { CaptureDefects, SuspendOnFailure } from "./Annotations.js";
+import { Complete, isResult, Suspended } from "./Result.js";
+/**
+ * Runs an effect as a flow execution and converts its outcome into a
+ * `Result`, handling suspension, defect capture, interruption, and flow
+ * scope finalization.
+ *
+ * @category results
+ * @since 0.1.0
+ */
+export const intoResult = (effect) => Effect.contextWith((context) => {
+    const instance = Context.get(context, FlowInstance);
+    const captureDefects = Context.get(instance.flow.annotations, CaptureDefects);
+    const suspendOnFailure = Context.get(instance.flow.annotations, SuspendOnFailure);
+    return effect.pipe(
+    // so we can use external interruption to suspend the flow
+    Effect.forkChild({ startImmediately: true }), Effect.flatMap((fiber) => Effect.onInterrupt(Fiber.join(fiber), () => Fiber.interrupt(fiber))), Effect.interruptible, suspendOnFailure
+        ? Effect.catchCause((cause) => {
+            instance.suspended = true;
+            if (!Cause.hasInterruptsOnly(cause)) {
+                instance.cause = Cause.die(Cause.squash(cause));
+            }
+            return Effect.interrupt;
+        })
+        : identity, Effect.scoped, Effect.matchCauseEffect({
+        // A body that handed off produced no answer of its own, so the slot
+        // the handoff was recorded in wins over the value the handler returned
+        // (`docs/concepts/trampoline-rounds.md`).
+        onSuccess: (value) => Effect.succeed(instance.handoff ?? new Complete({ exit: Exit.succeed(value) })),
+        onFailure: (cause) => {
+            const [reasons, interrupts] = Arr.partition(cause.reasons, Filter.fromPredicate(Cause.isInterruptReason));
+            const hasInterruptsOnly = interrupts.length === cause.reasons.length;
+            const filtered = reasons.length === 0 ? cause : Cause.fromReasons(reasons);
+            return instance.suspended && hasInterruptsOnly
+                ? Effect.succeed(new Suspended({ cause: instance.cause }))
+                : (!instance.interrupted && hasInterruptsOnly) ||
+                    (!captureDefects && Cause.hasDies(cause))
+                    ? Effect.failCause(filtered)
+                    : Effect.succeed(new Complete({ exit: Exit.failCause(filtered) }));
+        }
+    }), (eff) => Effect.onExitPrimitive(eff, (exit) => {
+        if (Exit.isFailure(exit)) {
+            return Scope.close(instance.scope, exit);
+        }
+        else if (exit.value._tag === "Complete") {
+            return Scope.close(instance.scope, exit.value.exit);
+        }
+        else if (exit.value._tag === "Handoff") {
+            // A handoff ends this round for good — the next round is a separate
+            // execution with its own instance and its own scope — so the round's
+            // scope closes here exactly as a completion closes it. A suspension
+            // is the only settlement that keeps the scope open.
+            return Scope.close(instance.scope, Exit.void);
+        }
+        return Effect.void;
+    }, true), Effect.uninterruptible);
+});
+/**
+ * The action regions open on the current fiber's dynamic call stack.
+ *
+ * `actionState.count` says how many regions are open on an instance; it does
+ * not say which of them the current region is nested inside. That difference is
+ * the whole of {@link wrapActionResult}'s liveness: a region that suspends
+ * waits for the *other* open regions to settle, and an enclosing region can
+ * never settle before the region inside it returns. Carrying the enclosing
+ * instances in the context is what lets a suspension tell a sibling — which
+ * will settle — from an ancestor, which is waiting on the very fiber that is
+ * waiting on it.
+ *
+ * It is a context reference rather than a fiber-local counter because the chain
+ * crosses fibers: {@link intoResult} forks the body, and an engine gives every
+ * action dispatch a fiber of its own. Context propagates to forked children;
+ * a per-fiber counter would restart at each fork and read every ancestor as a
+ * sibling again.
+ */
+const EnclosingActions = Context.Reference("@smthrs/flow/Flow/EnclosingActions", { defaultValue: () => [] });
+/**
+ * Wraps an action-like effect so flow suspension waits for currently
+ * running actions to finish or suspend.
+ *
+ * The wait is for *siblings*. An action that suspends holds work its siblings
+ * have not journaled yet, so the flow must not park out from under them; an
+ * enclosing region holds no such work, because everything it is doing is this
+ * region. Waiting for one is a deadlock, and it was a real one: a harness cell
+ * call is an action, the `wait` flow it dispatches awaits a `DurableClock`
+ * under the run's own instance, and the round that should have parked instead
+ * blocked forever inside an uninterruptible finalizer — not cancellable, not
+ * resumable, and invisible in the journal past the `clock-scheduled` record.
+ *
+ * @category results
+ * @since 0.1.0
+ */
+export const wrapActionResult = (effect, isSuspend) => Effect.contextWith((context) => {
+    const instance = Context.get(context, FlowInstance);
+    const enclosing = Context.getUnsafe(context, EnclosingActions);
+    // How many of the regions counted on this instance are this one's own
+    // ancestors, and so how many of them will still be open once every sibling
+    // has settled.
+    let ancestors = 0;
+    for (const open of enclosing)
+        if (open === instance)
+            ancestors++;
+    const state = instance.actionState;
+    if (state.count === 0)
+        state.latch.closeUnsafe();
+    state.count++;
+    return Effect.onExit(Effect.provideService(effect, EnclosingActions, [...enclosing, instance]), (exit) => {
+        state.count--;
+        const isSuspended = Exit.isSuccess(exit) && isSuspend(exit.value);
+        if (Exit.isSuccess(exit) &&
+            isResult(exit.value) &&
+            exit.value._tag === "Suspended" &&
+            exit.value.cause) {
+            instance.cause = instance.cause
+                ? Cause.combine(instance.cause, exit.value.cause)
+                : exit.value.cause;
+        }
+        if (state.count === 0)
+            return state.latch.open;
+        // Every decrement can satisfy a waiter whose threshold is not zero, so
+        // the waiters are released to re-test their own. `release` wakes them
+        // without opening the latch, so the ones still short of their threshold
+        // park again on the next turn of the loop.
+        return isSuspended
+            ? Effect.andThen(state.latch.release, waitForSiblings(instance, ancestors))
+            : Effect.asVoid(state.latch.release);
+    });
+});
+// Untraced because this latch loop is a flow scheduler hot path.
+const waitForSiblings = Effect.fnUntraced(function* (instance, ancestors) {
+    const state = instance.actionState;
+    while (true) {
+        if (state.count > ancestors) {
+            yield* state.latch.await;
+            yield* Effect.yieldNow;
+            continue;
+        }
+        yield* Effect.yieldNow;
+        if (state.count <= ancestors)
+            return;
+    }
+});
+/**
+ * Accesses the current round's flow scope. Suspension keeps it open;
+ * completion or handoff closes it.
+ *
+ * @category resource management
+ * @since 0.1.0
+ */
+export const scope = Effect.map(FlowInstance, (instance) => instance.scope);
+/**
+ * Provides the current round's flow scope to the given effect. Suspension keeps
+ * the scope open; completion or handoff closes it.
+ *
+ * @category resource management
+ * @since 0.1.0
+ */
+export const provideScope = (effect) => Effect.flatMap(scope, (scope) => Scope.provide(effect, scope));
+/**
+ * Adds an exit finalizer to the current flow scope, preserving the
+ * services available when the finalizer is registered.
+ *
+ * @category resource management
+ * @since 0.1.0
+ */
+export const addFinalizer = 
+// Untraced because suspension recursively re-enters flow execution.
+Effect.fnUntraced(function* (f) {
+    const instance = yield* FlowInstance;
+    const services = yield* Effect.context();
+    yield* Scope.addFinalizerExit(instance.scope, (exit) => Effect.provideContext(f(exit), services));
+});
+/**
+ * Runs an effect and registers how to undo its successful result if the
+ * current round later exits unsuccessfully.
+ *
+ * **When to use**
+ *
+ * Use when a top-level flow operation changes something that must be undone if
+ * a later operation causes the same round to fail or be interrupted.
+ *
+ * **Details**
+ *
+ * The effect runs first. If it fails, no rollback is registered. If it
+ * succeeds, its value is captured in a round-scope finalizer. The finalizer does
+ * nothing when the round succeeds; when the round exits unsuccessfully
+ * it calls `rollback(value, cause)`. Suspension keeps that scope open.
+ *
+ * A handoff completes the round successfully and discards its `withRollback` registrations.
+ * A later round's failure cannot invoke those rollbacks. The engine does not
+ * provide lineage-scoped compensation.
+ *
+ * **Gotchas**
+ *
+ * This applies only to effects run directly inside the flow execution. It does
+ * not attach rollback behavior to nested actions. The rollback's typed error
+ * channel is `never`; handle expected rollback failures inside the callback.
+ *
+ * @category resource management
+ * @since 0.1.0
+ */
+export const withRollback = dual(2, (effect, rollback) => Effect.uninterruptibleMask((restore) => Effect.tap(restore(effect), (value) => addFinalizer((exit) => Exit.isSuccess(exit) ? Effect.void : rollback(value, exit.cause)))));
+/**
+ * Marks a flow instance as suspended and interrupts the current fiber to
+ * stop execution until it is resumed.
+ *
+ * @category results
+ * @since 0.1.0
+ */
+export const suspend = (instance) => Effect.interruptible(Effect.callback(() => {
+    instance.suspended = true;
+    const fiber = Fiber.getCurrent();
+    fiber.interruptUnsafe(fiber.id);
+}));
+//# sourceMappingURL=Runtime.js.map

package/dist/esm/Flow/Runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Runtime.js","sourceRoot":"","sources":["../../../src/Flow/Runtime.ts"],"names":[],"mappings":"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","sourcesContent":["// Deep reviewed and polished by a human on 2026-08-10.\n\n/**\n * Runtime helpers for flow completion, suspension, scopes, and rollback.\n *\n * @since 0.1.0\n */\n\nimport * as Arr from \"effect/Array\"\nimport * as Cause from \"effect/Cause\"\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Exit from \"effect/Exit\"\nimport * as Fiber from \"effect/Fiber\"\nimport * as Filter from \"effect/Filter\"\nimport { dual, identity } from \"effect/Function\"\nimport * as Scope from \"effect/Scope\"\nimport { FlowInstance } from \"../FlowRuntime/FlowInstance.ts\"\nimport { CaptureDefects, SuspendOnFailure } from \"./Annotations.ts\"\nimport { Complete, isResult, type Result, Suspended } from \"./Result.ts\"\n\n/**\n * Runs an effect as a flow execution and converts its outcome into a\n * `Result`, handling suspension, defect capture, interruption, and flow\n * scope finalization.\n *\n * @category results\n * @since 0.1.0\n */\nexport const intoResult = <A, E, R>(\n  effect: Effect.Effect<A, E, R>\n): Effect.Effect<\n  Result<A, E>,\n  never,\n  Exclude<R, Scope.Scope> | FlowInstance\n> =>\n  Effect.contextWith((context: Context.Context<FlowInstance>) => {\n    const instance = Context.get(context, FlowInstance)\n    const captureDefects = Context.get(instance.flow.annotations, CaptureDefects)\n    const suspendOnFailure = Context.get(instance.flow.annotations, SuspendOnFailure)\n    return effect.pipe(\n      // so we can use external interruption to suspend the flow\n      Effect.forkChild({ startImmediately: true }),\n      Effect.flatMap((fiber) => Effect.onInterrupt(Fiber.join(fiber), () => Fiber.interrupt(fiber))),\n      Effect.interruptible,\n      suspendOnFailure\n        ? Effect.catchCause((cause) => {\n          instance.suspended = true\n          if (!Cause.hasInterruptsOnly(cause)) {\n            instance.cause = Cause.die(Cause.squash(cause))\n          }\n          return Effect.interrupt\n        })\n        : identity,\n      Effect.scoped,\n      Effect.matchCauseEffect({\n        // A body that handed off produced no answer of its own, so the slot\n        // the handoff was recorded in wins over the value the handler returned\n        // (`docs/concepts/trampoline-rounds.md`).\n        onSuccess: (value) =>\n          Effect.succeed(\n            instance.handoff ?? new Complete({ exit: Exit.succeed(value) })\n          ),\n        onFailure: (cause): Effect.Effect<Result<A, E>> => {\n          const [reasons, interrupts] = Arr.partition(\n            cause.reasons,\n            Filter.fromPredicate(Cause.isInterruptReason)\n          )\n          const hasInterruptsOnly = interrupts.length === cause.reasons.length\n          const filtered = reasons.length === 0 ? cause : Cause.fromReasons(reasons)\n          return instance.suspended && hasInterruptsOnly\n            ? Effect.succeed(new Suspended({ cause: instance.cause }))\n            : (!instance.interrupted && hasInterruptsOnly) ||\n                (!captureDefects && Cause.hasDies(cause))\n            ? Effect.failCause(filtered as Cause.Cause<never>)\n            : Effect.succeed(new Complete({ exit: Exit.failCause(filtered) }))\n        }\n      }),\n      (eff) =>\n        Effect.onExitPrimitive(eff, (exit) => {\n          if (Exit.isFailure(exit)) {\n            return Scope.close(instance.scope, exit)\n          } else if (exit.value._tag === \"Complete\") {\n            return Scope.close(instance.scope, exit.value.exit)\n          } else if (exit.value._tag === \"Handoff\") {\n            // A handoff ends this round for good — the next round is a separate\n            // execution with its own instance and its own scope — so the round's\n            // scope closes here exactly as a completion closes it. A suspension\n            // is the only settlement that keeps the scope open.\n            return Scope.close(instance.scope, Exit.void)\n          }\n          return Effect.void\n        }, true),\n      Effect.uninterruptible\n    )\n  })\n\n/**\n * The action regions open on the current fiber's dynamic call stack.\n *\n * `actionState.count` says how many regions are open on an instance; it does\n * not say which of them the current region is nested inside. That difference is\n * the whole of {@link wrapActionResult}'s liveness: a region that suspends\n * waits for the *other* open regions to settle, and an enclosing region can\n * never settle before the region inside it returns. Carrying the enclosing\n * instances in the context is what lets a suspension tell a sibling — which\n * will settle — from an ancestor, which is waiting on the very fiber that is\n * waiting on it.\n *\n * It is a context reference rather than a fiber-local counter because the chain\n * crosses fibers: {@link intoResult} forks the body, and an engine gives every\n * action dispatch a fiber of its own. Context propagates to forked children;\n * a per-fiber counter would restart at each fork and read every ancestor as a\n * sibling again.\n */\nconst EnclosingActions = Context.Reference<ReadonlyArray<FlowInstance[\"Service\"]>>(\n  \"@smthrs/flow/Flow/EnclosingActions\",\n  { defaultValue: () => [] }\n)\n\n/**\n * Wraps an action-like effect so flow suspension waits for currently\n * running actions to finish or suspend.\n *\n * The wait is for *siblings*. An action that suspends holds work its siblings\n * have not journaled yet, so the flow must not park out from under them; an\n * enclosing region holds no such work, because everything it is doing is this\n * region. Waiting for one is a deadlock, and it was a real one: a harness cell\n * call is an action, the `wait` flow it dispatches awaits a `DurableClock`\n * under the run's own instance, and the round that should have parked instead\n * blocked forever inside an uninterruptible finalizer — not cancellable, not\n * resumable, and invisible in the journal past the `clock-scheduled` record.\n *\n * @category results\n * @since 0.1.0\n */\nexport const wrapActionResult = <A, E, R>(\n  effect: Effect.Effect<A, E, R>,\n  isSuspend: (value: A) => boolean\n): Effect.Effect<A, E, R | FlowInstance> =>\n  Effect.contextWith((context: Context.Context<FlowInstance>) => {\n    const instance = Context.get(context, FlowInstance)\n    const enclosing = Context.getUnsafe(context, EnclosingActions)\n    // How many of the regions counted on this instance are this one's own\n    // ancestors, and so how many of them will still be open once every sibling\n    // has settled.\n    let ancestors = 0\n    for (const open of enclosing) if (open === instance) ancestors++\n    const state = instance.actionState\n    if (state.count === 0) state.latch.closeUnsafe()\n    state.count++\n    return Effect.onExit(\n      Effect.provideService(effect, EnclosingActions, [...enclosing, instance]),\n      (exit) => {\n        state.count--\n        const isSuspended = Exit.isSuccess(exit) && isSuspend(exit.value)\n        if (\n          Exit.isSuccess(exit) &&\n          isResult(exit.value) &&\n          exit.value._tag === \"Suspended\" &&\n          exit.value.cause\n        ) {\n          instance.cause = instance.cause\n            ? Cause.combine(instance.cause, exit.value.cause)\n            : exit.value.cause\n        }\n        if (state.count === 0) return state.latch.open\n        // Every decrement can satisfy a waiter whose threshold is not zero, so\n        // the waiters are released to re-test their own. `release` wakes them\n        // without opening the latch, so the ones still short of their threshold\n        // park again on the next turn of the loop.\n        return isSuspended\n          ? Effect.andThen(state.latch.release, waitForSiblings(instance, ancestors))\n          : Effect.asVoid(state.latch.release)\n      }\n    )\n  })\n\n// Untraced because this latch loop is a flow scheduler hot path.\nconst waitForSiblings = Effect.fnUntraced(function*(\n  instance: FlowInstance[\"Service\"],\n  ancestors: number\n) {\n  const state = instance.actionState\n  while (true) {\n    if (state.count > ancestors) {\n      yield* state.latch.await\n      yield* Effect.yieldNow\n      continue\n    }\n    yield* Effect.yieldNow\n    if (state.count <= ancestors) return\n  }\n})\n\n/**\n * Accesses the current round's flow scope. Suspension keeps it open;\n * completion or handoff closes it.\n *\n * @category resource management\n * @since 0.1.0\n */\nexport const scope: Effect.Effect<\n  Scope.Scope,\n  never,\n  FlowInstance\n> = Effect.map(\n  FlowInstance,\n  (instance) => instance.scope as Scope.Scope\n)\n\n/**\n * Provides the current round's flow scope to the given effect. Suspension keeps\n * the scope open; completion or handoff closes it.\n *\n * @category resource management\n * @since 0.1.0\n */\nexport const provideScope = <A, E, R>(\n  effect: Effect.Effect<A, E, R>\n): Effect.Effect<A, E, Exclude<R, Scope.Scope> | FlowInstance> =>\n  Effect.flatMap(scope, (scope) => Scope.provide(effect, scope))\n\n/**\n * Adds an exit finalizer to the current flow scope, preserving the\n * services available when the finalizer is registered.\n *\n * @category resource management\n * @since 0.1.0\n */\nexport const addFinalizer: <R>(\n  f: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void, never, R>\n) => Effect.Effect<\n  void,\n  never,\n  FlowInstance | R\n> =\n  // Untraced because suspension recursively re-enters flow execution.\n  Effect.fnUntraced(function*<R>(\n    f: (exit: Exit.Exit<unknown, unknown>) => Effect.Effect<void, never, R>\n  ) {\n    const instance = yield* FlowInstance\n    const services = yield* Effect.context<R>()\n    yield* Scope.addFinalizerExit(instance.scope, (exit) => Effect.provideContext(f(exit), services))\n  })\n\n/**\n * Runs an effect and registers how to undo its successful result if the\n * current round later exits unsuccessfully.\n *\n * **When to use**\n *\n * Use when a top-level flow operation changes something that must be undone if\n * a later operation causes the same round to fail or be interrupted.\n *\n * **Details**\n *\n * The effect runs first. If it fails, no rollback is registered. If it\n * succeeds, its value is captured in a round-scope finalizer. The finalizer does\n * nothing when the round succeeds; when the round exits unsuccessfully\n * it calls `rollback(value, cause)`. Suspension keeps that scope open.\n *\n * A handoff completes the round successfully and discards its `withRollback` registrations.\n * A later round's failure cannot invoke those rollbacks. The engine does not\n * provide lineage-scoped compensation.\n *\n * **Gotchas**\n *\n * This applies only to effects run directly inside the flow execution. It does\n * not attach rollback behavior to nested actions. The rollback's typed error\n * channel is `never`; handle expected rollback failures inside the callback.\n *\n * @category resource management\n * @since 0.1.0\n */\nexport const withRollback: {\n  <A, R2>(\n    rollback: (value: A, cause: Cause.Cause<unknown>) => Effect.Effect<void, never, R2>\n  ): <E, R>(\n    effect: Effect.Effect<A, E, R>\n  ) => Effect.Effect<A, E, R | R2 | FlowInstance | Scope.Scope>\n  <A, E, R, R2>(\n    effect: Effect.Effect<A, E, R>,\n    rollback: (value: A, cause: Cause.Cause<unknown>) => Effect.Effect<void, never, R2>\n  ): Effect.Effect<A, E, R | R2 | FlowInstance | Scope.Scope>\n} = dual(2, <A, E, R, R2>(\n  effect: Effect.Effect<A, E, R>,\n  rollback: (value: A, cause: Cause.Cause<unknown>) => Effect.Effect<void, never, R2>\n): Effect.Effect<A, E, R | R2 | FlowInstance | Scope.Scope> =>\n  Effect.uninterruptibleMask((restore) =>\n    Effect.tap(\n      restore(effect),\n      (value) => addFinalizer((exit) => Exit.isSuccess(exit) ? Effect.void : rollback(value, exit.cause))\n    )\n  ))\n\n/**\n * Marks a flow instance as suspended and interrupts the current fiber to\n * stop execution until it is resumed.\n *\n * @category results\n * @since 0.1.0\n */\nexport const suspend = (instance: FlowInstance[\"Service\"]): Effect.Effect<never> =>\n  Effect.interruptible(Effect.callback<never>(() => {\n    instance.suspended = true\n    const fiber = Fiber.getCurrent()!\n    fiber.interruptUnsafe(fiber.id)\n  }))\n"]}

package/dist/esm/Flow/TypeId.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Runtime identity shared by flow interfaces and constructors.
+ *
+ * @private
+ * @since 0.1.0
+ */
+export declare const TypeId = "@smthrs/flow/Flow";
+//# sourceMappingURL=TypeId.d.ts.map

package/dist/esm/Flow/TypeId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeId.d.ts","sourceRoot":"","sources":["../../../src/Flow/TypeId.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,MAAM,sBAAsB,CAAA"}

package/dist/esm/Flow/TypeId.js

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

package/dist/esm/Flow/TypeId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeId.js","sourceRoot":"","sources":["../../../src/Flow/TypeId.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,mBAAmB,CAAA","sourcesContent":["// Deep reviewed and polished by a human on 2026-08-10.\n\n/**\n * Runtime identity shared by flow interfaces and constructors.\n *\n * @private\n * @since 0.1.0\n */\nexport const TypeId = \"@smthrs/flow/Flow\"\n"]}

package/dist/esm/Flow/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Typed durable flow definitions, results, and runtime helpers.
+ *
+ * @since 0.1.0
+ */
+export * from "./Annotations.ts";
+export * from "./CapabilityCeiling.ts";
+export * from "./DeadlineExceeded.ts";
+export * from "./ExecutionIdRequired.ts";
+export * from "./ExecutionIds.ts";
+export * from "./Flow.ts";
+export * from "./make.ts";
+export * from "./MaxRoundsExceeded.ts";
+export * from "./Outcome.ts";
+export * from "./Result.ts";
+export * from "./Runtime.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/Flow/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/Flow/index.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH,cAAc,kBAAkB,CAAA;AAChC,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA;AACzB,cAAc,wBAAwB,CAAA;AACtC,cAAc,cAAc,CAAA;AAC5B,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA"}

package/dist/esm/Flow/index.js

@@ -0,0 +1,18 @@
+// Deep reviewed and polished by a human on 2026-08-10.
+/**
+ * Typed durable flow definitions, results, and runtime helpers.
+ *
+ * @since 0.1.0
+ */
+export * from "./Annotations.js";
+export * from "./CapabilityCeiling.js";
+export * from "./DeadlineExceeded.js";
+export * from "./ExecutionIdRequired.js";
+export * from "./ExecutionIds.js";
+export * from "./Flow.js";
+export * from "./make.js";
+export * from "./MaxRoundsExceeded.js";
+export * from "./Outcome.js";
+export * from "./Result.js";
+export * from "./Runtime.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/Flow/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/Flow/index.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD;;;;GAIG;AAEH,cAAc,kBAAkB,CAAA;AAChC,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,cAAc,WAAW,CAAA;AACzB,cAAc,WAAW,CAAA;AACzB,cAAc,wBAAwB,CAAA;AACtC,cAAc,cAAc,CAAA;AAC5B,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA","sourcesContent":["// Deep reviewed and polished by a human on 2026-08-10.\n\n/**\n * Typed durable flow definitions, results, and runtime helpers.\n *\n * @since 0.1.0\n */\n\nexport * from \"./Annotations.ts\"\nexport * from \"./CapabilityCeiling.ts\"\nexport * from \"./DeadlineExceeded.ts\"\nexport * from \"./ExecutionIdRequired.ts\"\nexport * from \"./ExecutionIds.ts\"\nexport * from \"./Flow.ts\"\nexport * from \"./make.ts\"\nexport * from \"./MaxRoundsExceeded.ts\"\nexport * from \"./Outcome.ts\"\nexport * from \"./Result.ts\"\nexport * from \"./Runtime.ts\"\n"]}

package/dist/esm/Flow/internal.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Private flow construction shared by declarations and action registration.
+ *
+ * @since 1.0.0
+ * @private
+ */
+import * as Node from "@smthrs/plan/Node";
+import * as Context from "effect/Context";
+import type * as Duration from "effect/Duration";
+import * as Schema from "effect/Schema";
+import type * as RetryPolicy from "../RetryPolicy.ts";
+import type { Any, AnyStructSchema, BodySuccess, DeclarationMetadata, Flow } from "./Flow.ts";
+/**
+ * Builds the private prototype from normalized declaration data.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const makeProto: <const Tag extends string, Payload extends AnyStructSchema, Success extends Schema.Top, Error extends Schema.Top, Requires>(options: DeclarationMetadata & {
+    readonly _tag: Tag;
+    readonly description?: string | undefined;
+    readonly payloadSchema: Payload;
+    readonly successSchema: Success;
+    readonly errorSchema: Error;
+    readonly annotations: Context.Context<never>;
+    readonly body: (payload: Payload["Type"]) => Node.Node<BodySuccess<Success["Type"]>, Error["Type"], Requires>;
+    readonly prompt?: ((payload: Payload["Type"]) => string) | undefined;
+    readonly action?: Any["action"] | undefined;
+    readonly idempotencyKey?: ((payload: Payload["Type"]) => string) | undefined;
+    readonly suspendedRetryPolicy?: RetryPolicy.RetryPolicy | undefined;
+    readonly maxRounds?: number | undefined;
+    readonly deadline?: Duration.Duration | undefined;
+}) => Flow<Tag, Payload, Success, Error, Requires>;
+//# sourceMappingURL=internal.d.ts.map

package/dist/esm/Flow/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../../../src/Flow/internal.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,IAAI,MAAM,mBAAmB,CAAA;AAEzC,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AAEzC,OAAO,KAAK,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAEhD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC,OAAO,KAAK,KAAK,WAAW,MAAM,mBAAmB,CAAA;AAErD,OAAO,KAAK,EAAE,GAAG,EAAE,eAAe,EAAgB,WAAW,EAAE,mBAAmB,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAuL3G;;;;;GAKG;AACH,eAAO,MAAM,SAAS,GACpB,KAAK,CAAC,GAAG,SAAS,MAAM,EACxB,OAAO,SAAS,eAAe,EAC/B,OAAO,SAAS,MAAM,CAAC,GAAG,EAC1B,KAAK,SAAS,MAAM,CAAC,GAAG,EACxB,QAAQ,EAER,SAAS,mBAAmB,GAAG;IAC7B,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAA;IAClB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACzC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAA;IAC/B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAA;IAC/B,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAA;IAC3B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC5C,QAAQ,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,CAAA;IAC7G,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC,GAAG,SAAS,CAAA;IACpE,QAAQ,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAA;IAC3C,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC,GAAG,SAAS,CAAA;IAC5E,QAAQ,CAAC,oBAAoB,CAAC,EAAE,WAAW,CAAC,WAAW,GAAG,SAAS,CAAA;IACnE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACvC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,QAAQ,GAAG,SAAS,CAAA;CAClD,KACA,IAAI,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,CAK7C,CAAA"}