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

package/dist/esm/DurableDeferred.js

@@ -0,0 +1,357 @@
+// Deep reviewed and polished by a human on 2026-08-10.
+/**
+ * Defines named wait points for durable flow executions.
+ *
+ * A `DurableDeferred` has a stable name and schemas for the value that will be
+ * recorded later. Flows can await it, suspend when no result exists yet, and
+ * resume after its result is recorded. Tokens identify the flow name,
+ * execution id, and deferred name so external code can complete the correct
+ * wait point later.
+ *
+ * @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 Base64Url from "effect/encoding/Base64Url";
+import * as Exit from "effect/Exit";
+import * as Filter from "effect/Filter";
+import { dual } from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as SchemaGetter from "effect/SchemaGetter";
+import { CurrentAttempt } from "./Action/Context.js";
+import * as Flow from "./Flow/index.js";
+import { FlowInstance } from "./FlowRuntime/FlowInstance.js";
+import { FlowRuntime } from "./FlowRuntime/FlowRuntime.js";
+const TypeId = "@smthrs/flow/DurableDeferred";
+// Queues, human tasks and clocks mint a deferred per item, attempt or sleep.
+// Effect caches compiled parsers by AST identity, so the exit schema is shared
+// per (success, error) pair rather than rebuilt for every deferred.
+const exitSchemaCache = new WeakMap();
+const exitSchemaFor = (success, error) => {
+    let byError = exitSchemaCache.get(success);
+    if (byError === undefined) {
+        byError = new WeakMap();
+        exitSchemaCache.set(success, byError);
+    }
+    let cached = byError.get(error);
+    if (cached === undefined) {
+        cached = Schema.Exit(Schema.toCodecJson(success), Schema.toCodecJson(error), Schema.toCodecJson(Schema.Defect()));
+        byError.set(error, cached);
+    }
+    return cached;
+};
+/**
+ * Creates a named durable deferred with optional success and error schemas for
+ * persisted completion.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export const make = (name, options) => {
+    const successSchema = options?.success ?? Schema.Void;
+    const errorSchema = options?.error ?? Schema.Never;
+    return {
+        [TypeId]: TypeId,
+        name,
+        successSchema,
+        errorSchema,
+        exitSchema: exitSchemaFor(successSchema, errorSchema),
+        withActionAttempt: Effect.gen(function* () {
+            const attempt = yield* CurrentAttempt;
+            return make(`${name}/${attempt}`, {
+                success: successSchema,
+                error: errorSchema
+            });
+        })
+    };
+};
+const await_ = 
+// Untraced because deferred polling participates in the flow scheduler hot path.
+Effect.fnUntraced(function* (self) {
+    const engine = yield* FlowRuntime;
+    const instance = yield* FlowInstance;
+    const exit = yield* Flow.wrapActionResult(engine.deferredResult(self), Option.isNone);
+    if (Option.isNone(exit)) {
+        return yield* Flow.suspend(instance);
+    }
+    const value = exit.value;
+    // A recorded interruption is a durable *outcome*, not a request to
+    // suspend: mark the instance interrupted before re-raising so
+    // `Flow.intoResult` classifies the interrupt-only cause as a `Complete`
+    // failure. Without this the driver mistakes the cause for an external
+    // suspension interrupt, aborts without a terminal transition, and the
+    // run spins in the suspended-retry loop forever.
+    if (Exit.isFailure(value) && Cause.hasInterruptsOnly(value.cause)) {
+        instance.interrupted = true;
+    }
+    return yield* value;
+});
+export { 
+/**
+ * Waits for the durable deferred, suspending the current flow when no
+ * persisted completion is available.
+ *
+ * @category combinators
+ * @since 0.1.0
+ */
+await_ as await };
+/**
+ * Runs an effect and records its exit into the durable deferred, resuming
+ * flows that are waiting on that deferred.
+ *
+ * @category combinators
+ * @since 0.1.0
+ */
+export const into = dual(2, (effect, self) => Effect.contextWith((context) => {
+    const engine = Context.get(context, FlowRuntime);
+    const instance = Context.get(context, FlowInstance);
+    // Keep the original instance: action regions identify their ancestors
+    // by reference, and suspension metadata belongs to the enclosing flow.
+    return Effect.onExit(effect, 
+    // Untraced because completion encoding is called for each deferred result.
+    Effect.fnUntraced(function* (exit) {
+        if (Exit.isFailure(exit)) {
+            const [interrupts, reasons] = Arr.partition(exit.cause.reasons, Filter.fromPredicate(Cause.isInterruptReason));
+            const hasInterruptsOnly = interrupts.length === exit.cause.reasons.length;
+            if (hasInterruptsOnly) {
+                // An interrupt-only exit is never a result: the effect was
+                // suspended, preempted, or interrupted, so record nothing.
+                // Recording here would durably persist the empty non-interrupt
+                // partition, and first-writer-wins would replay that empty
+                // cause forever instead of the real completion.
+                return;
+            }
+            else if (interrupts.length > 0) {
+                exit = Exit.failCause(Cause.fromReasons(reasons));
+            }
+        }
+        yield* engine.deferredDone(self, {
+            flowName: instance.flow._tag,
+            executionId: instance.executionId,
+            deferredName: self.name,
+            exit
+        });
+    }));
+}));
+/**
+ * Runs effects as a durable race, returning a previously persisted result when
+ * present or completing a named deferred with the first success. The race
+ * fails only when every effect fails.
+ *
+ * @category racing
+ * @since 0.1.0
+ */
+export const raceAll = (options) => {
+    const deferred = make(`raceAll/${options.name}`, {
+        success: options.success,
+        error: options.error
+    });
+    return Effect.gen(function* () {
+        const engine = yield* FlowRuntime;
+        const exit = yield* engine.deferredResult(deferred);
+        if (Option.isSome(exit)) {
+            return yield* exit.value;
+        }
+        return yield* into(Effect.raceAll(options.effects), deferred);
+    });
+};
+/**
+ * Runtime brand identifier for durable deferred tokens.
+ *
+ * @category type IDs
+ * @since 0.1.0
+ */
+export const TokenTypeId = "@smthrs/flow/DurableDeferred/Token";
+/**
+ * Schema for branded durable deferred tokens.
+ *
+ * @category token
+ * @since 0.1.0
+ */
+export const Token = Schema.String.pipe(Schema.brand(TokenTypeId));
+/**
+ * A completion token could not be decoded into its durable address.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export class TokenInvalid extends Schema.TaggedError()("@smthrs/flow/DurableDeferred/TokenInvalid", {
+    code: Schema.Literals(["malformed_token", "deferred_mismatch"]).pipe(Schema.withConstructorDefault(Effect.succeed("malformed_token"))),
+    message: Schema.String
+}) {
+}
+/**
+ * Schema for a decoded durable deferred token containing the flow
+ * name, execution ID, and deferred name.
+ *
+ * @category token
+ * @since 0.1.0
+ */
+export class TokenParsed extends Schema.Class("@smthrs/flow/DurableDeferred/TokenParsed")({
+    flowName: Schema.String,
+    executionId: Schema.String,
+    deferredName: Schema.String
+}) {
+    /**
+     * Encodes the parsed flow, execution, and deferred names back into a token.
+     *
+     * @since 0.1.0
+     */
+    get asToken() {
+        return Base64Url.encode(JSON.stringify([this.flowName, this.executionId, this.deferredName]));
+    }
+    /**
+     * Schema for decoding and encoding durable deferred tokens as strings.
+     *
+     * @since 0.1.0
+     */
+    static FromString = Schema.String.pipe(Schema.decodeTo(Schema.fromJsonString(Schema.Tuple([Schema.String, Schema.String, Schema.String])), {
+        decode: SchemaGetter.decodeBase64UrlString(),
+        encode: SchemaGetter.encodeBase64Url()
+    }), Schema.decodeTo(TokenParsed, {
+        decode: SchemaGetter.transform(([flowName, executionId, deferredName]) => new TokenParsed({
+            flowName,
+            executionId,
+            deferredName
+        })),
+        encode: SchemaGetter.transform((parsed) => [
+            parsed.flowName,
+            parsed.executionId,
+            parsed.deferredName
+        ])
+    }));
+    /**
+     * Decodes a durable deferred token string into its parsed components.
+     *
+     * @since 0.1.0
+     */
+    static fromString = Schema.decodeSync(TokenParsed.FromString);
+    /**
+     * Encodes parsed durable deferred token components into a token string.
+     *
+     * @since 0.1.0
+     */
+    static encode = Schema.encodeSync(TokenParsed.FromString);
+    /**
+     * Parses an untrusted token into its durable address with a typed,
+     * bounded diagnostic on failure.
+     *
+     * @category token
+     * @since 1.0.0
+     */
+    static parse = (token) => Effect.mapError(Schema.decodeEffect(TokenParsed.FromString)(token), (issue) => new TokenInvalid({
+        message: `The supplied token "${tokenExcerpt(token)}" is not a durable deferred token: ${issue.message}`
+    }));
+}
+const maxTokenExcerptChars = 64;
+/** Renders a bounded excerpt of untrusted token content for a diagnostic. */
+const tokenExcerpt = (token) => token.length <= maxTokenExcerptChars
+    ? token
+    : `${token.slice(0, maxTokenExcerptChars)} [${token.length - maxTokenExcerptChars} characters dropped]`;
+/**
+ * Creates a token for a durable deferred using the current flow instance's
+ * flow name and execution ID.
+ *
+ * @category token
+ * @since 0.1.0
+ */
+export const token = 
+// Untraced because token allocation is on the durable-deferred hot path.
+Effect.fnUntraced(function* (self) {
+    const instance = yield* FlowInstance;
+    return tokenFromExecutionId(self, instance);
+});
+/**
+ * Creates a durable deferred token from an explicit flow, execution ID,
+ * and deferred name.
+ *
+ * @category token
+ * @since 0.1.0
+ */
+export const tokenFromExecutionId = dual(2, (self, options) => new TokenParsed({
+    flowName: options.flow._tag,
+    executionId: options.executionId,
+    deferredName: self.name
+}).asToken);
+/**
+ * Creates a durable deferred token by deriving the flow execution ID from
+ * the supplied flow payload.
+ *
+ * The payload identifies a previously started execution only when the flow
+ * declares `idempotencyKey` or the host installs the opt-in `derived`
+ * execution-id source. Otherwise the default `fresh` source mints a new
+ * execution ID on every call, so the token addresses no earlier run. To
+ * complete an existing execution without stable identity, keep its execution
+ * ID and use {@link tokenFromExecutionId}.
+ *
+ * @category token
+ * @since 0.1.0
+ */
+export const tokenFromPayload = dual(2, (self, options) => Effect.map(options.flow.executionId(options.payload), (executionId) => tokenFromExecutionId(self, {
+    flow: options.flow,
+    executionId
+})));
+/**
+ * Completes the durable deferred identified by a token with the supplied exit,
+ * encoding the result through the deferred schemas.
+ *
+ * The token is not a credential (see {@link Token}): authorize the caller
+ * before completing a wait on its behalf.
+ *
+ * @category combinators
+ * @since 0.1.0
+ */
+export const done = dual(2, 
+// Untraced because awaiting a deferred re-enters the scheduler recursively.
+Effect.fnUntraced(function* (self, options) {
+    const token = yield* TokenParsed.parse(options.token);
+    if (token.deferredName !== self.name) {
+        return yield* Effect.fail(new TokenInvalid({
+            code: "deferred_mismatch",
+            message: `The token addresses deferred "${tokenExcerpt(token.deferredName)}", but it was submitted through ` +
+                `deferred "${self.name}".`
+        }));
+    }
+    const engine = yield* FlowRuntime;
+    yield* engine.deferredDone(self, {
+        flowName: token.flowName,
+        executionId: token.executionId,
+        deferredName: token.deferredName,
+        exit: options.exit
+    });
+}));
+/**
+ * Completes the durable deferred identified by a token with a successful
+ * value.
+ *
+ * @category combinators
+ * @since 0.1.0
+ */
+export const succeed = dual(2, (self, options) => done(self, {
+    token: options.token,
+    exit: Exit.succeed(options.value)
+}));
+/**
+ * Completes the durable deferred identified by a token with a typed failure.
+ *
+ * @category combinators
+ * @since 0.1.0
+ */
+export const fail = dual(2, (self, options) => done(self, {
+    token: options.token,
+    exit: Exit.fail(options.error)
+}));
+/**
+ * Completes the durable deferred identified by a token with a failure cause.
+ *
+ * @category combinators
+ * @since 0.1.0
+ */
+export const failCause = dual(2, (self, options) => done(self, {
+    token: options.token,
+    exit: Exit.failCause(options.cause)
+}));
+//# sourceMappingURL=DurableDeferred.js.map

package/dist/esm/DurableDeferred.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DurableDeferred.js","sourceRoot":"","sources":["../../src/DurableDeferred.ts"],"names":[],"mappings":"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","sourcesContent":["// Deep reviewed and polished by a human on 2026-08-10.\n\n/**\n * Defines named wait points for durable flow executions.\n *\n * A `DurableDeferred` has a stable name and schemas for the value that will be\n * recorded later. Flows can await it, suspend when no result exists yet, and\n * resume after its result is recorded. Tokens identify the flow name,\n * execution id, and deferred name so external code can complete the correct\n * wait point later.\n *\n * @since 0.1.0\n */\n\nimport * as Arr from \"effect/Array\"\nimport type { NonEmptyReadonlyArray } from \"effect/Array\"\nimport type * as Brand from \"effect/Brand\"\nimport * as Cause from \"effect/Cause\"\nimport * as Context from \"effect/Context\"\nimport type * as Crypto from \"effect/Crypto\"\nimport * as Effect from \"effect/Effect\"\nimport * as Base64Url from \"effect/encoding/Base64Url\"\nimport * as Exit from \"effect/Exit\"\nimport * as Filter from \"effect/Filter\"\nimport { dual } from \"effect/Function\"\nimport * as Option from \"effect/Option\"\nimport * as Schema from \"effect/Schema\"\nimport * as SchemaGetter from \"effect/SchemaGetter\"\nimport { CurrentAttempt } from \"./Action/Context.ts\"\nimport * as Flow from \"./Flow/index.ts\"\nimport { FlowInstance } from \"./FlowRuntime/FlowInstance.ts\"\nimport { FlowRuntime } from \"./FlowRuntime/FlowRuntime.ts\"\n\nconst TypeId = \"@smthrs/flow/DurableDeferred\"\n\n/**\n * Named durable deferred value whose completion is persisted by the flow\n * engine and encoded with success and error schemas.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface DurableDeferred<\n  Success extends Schema.Constraint,\n  Error extends Schema.Constraint = Schema.Never\n> {\n  readonly [TypeId]: typeof TypeId\n  readonly name: string\n  readonly successSchema: Success\n  readonly errorSchema: Error\n  readonly exitSchema: Schema.Exit<Schema.Top, Schema.Top, Schema.Top>\n  readonly withActionAttempt: Effect.Effect<DurableDeferred<Success, Error>>\n}\n\n/**\n * Type-erased durable deferred shape for APIs that only need the deferred\n * identity and name.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Any {\n  readonly [TypeId]: typeof TypeId\n  readonly name: string\n}\n\n/**\n * Type-erased durable deferred shape that also exposes success, error, and\n * exit schemas.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface AnyWithProps {\n  readonly [TypeId]: typeof TypeId\n  readonly name: string\n  readonly successSchema: Schema.Top\n  readonly errorSchema: Schema.Top\n  readonly exitSchema: Schema.Exit<any, any, any>\n}\n\n// Queues, human tasks and clocks mint a deferred per item, attempt or sleep.\n// Effect caches compiled parsers by AST identity, so the exit schema is shared\n// per (success, error) pair rather than rebuilt for every deferred.\nconst exitSchemaCache = new WeakMap<object, WeakMap<object, Schema.Exit<any, any, any>>>()\n\nconst exitSchemaFor = (success: Schema.Constraint, error: Schema.Constraint): Schema.Exit<any, any, any> => {\n  let byError = exitSchemaCache.get(success)\n  if (byError === undefined) {\n    byError = new WeakMap()\n    exitSchemaCache.set(success, byError)\n  }\n  let cached = byError.get(error)\n  if (cached === undefined) {\n    cached = Schema.Exit(\n      Schema.toCodecJson(success),\n      Schema.toCodecJson(error),\n      Schema.toCodecJson(Schema.Defect())\n    )\n    byError.set(error, cached)\n  }\n  return cached\n}\n\n/**\n * Creates a named durable deferred with optional success and error schemas for\n * persisted completion.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = <\n  Success extends Schema.Constraint = Schema.Void,\n  Error extends Schema.Constraint = Schema.Never\n>(\n  name: string,\n  options?: {\n    readonly success?: Success | undefined\n    readonly error?: Error | undefined\n  }\n): DurableDeferred<Success, Error> => {\n  const successSchema = options?.success ?? (Schema.Void as any as Success)\n  const errorSchema = options?.error ?? (Schema.Never as any as Error)\n  return {\n    [TypeId]: TypeId as typeof TypeId,\n    name,\n    successSchema,\n    errorSchema,\n    exitSchema: exitSchemaFor(successSchema, errorSchema) as any,\n    withActionAttempt: Effect.gen(function*() {\n      const attempt = yield* CurrentAttempt\n      return make(`${name}/${attempt}`, {\n        success: successSchema,\n        error: errorSchema\n      })\n    })\n  }\n}\n\nconst await_: <Success extends Schema.Constraint, Error extends Schema.Constraint>(\n  self: DurableDeferred<Success, Error>\n) => Effect.Effect<\n  Success[\"Type\"],\n  Error[\"Type\"],\n  | FlowRuntime\n  | FlowInstance\n  | Success[\"DecodingServices\"]\n  | Error[\"DecodingServices\"]\n> =\n  // Untraced because deferred polling participates in the flow scheduler hot path.\n  Effect.fnUntraced(function*<\n    Success extends Schema.Constraint,\n    Error extends Schema.Constraint\n  >(self: DurableDeferred<Success, Error>) {\n    const engine = yield* FlowRuntime\n    const instance = yield* FlowInstance\n    const exit = yield* Flow.wrapActionResult(\n      engine.deferredResult(self),\n      Option.isNone\n    )\n    if (Option.isNone(exit)) {\n      return yield* Flow.suspend(instance)\n    }\n    const value = exit.value as Exit.Exit<any, any>\n    // A recorded interruption is a durable *outcome*, not a request to\n    // suspend: mark the instance interrupted before re-raising so\n    // `Flow.intoResult` classifies the interrupt-only cause as a `Complete`\n    // failure. Without this the driver mistakes the cause for an external\n    // suspension interrupt, aborts without a terminal transition, and the\n    // run spins in the suspended-retry loop forever.\n    if (Exit.isFailure(value) && Cause.hasInterruptsOnly(value.cause)) {\n      instance.interrupted = true\n    }\n    return yield* value\n  })\n\nexport {\n  /**\n   * Waits for the durable deferred, suspending the current flow when no\n   * persisted completion is available.\n   *\n   * @category combinators\n   * @since 0.1.0\n   */\n  await_ as await\n}\n\n/**\n * Runs an effect and records its exit into the durable deferred, resuming\n * flows that are waiting on that deferred.\n *\n * @category combinators\n * @since 0.1.0\n */\nexport const into: {\n  <Success extends Schema.Constraint, Error extends Schema.Constraint>(\n    self: DurableDeferred<Success, Error>\n  ): <R>(\n    effect: Effect.Effect<Success[\"Type\"], Error[\"Type\"], R>\n  ) => Effect.Effect<\n    Success[\"Type\"],\n    Error[\"Type\"],\n    | R\n    | FlowRuntime\n    | FlowInstance\n    | Success[\"DecodingServices\"]\n    | Success[\"EncodingServices\"]\n    | Error[\"DecodingServices\"]\n    | Error[\"EncodingServices\"]\n  >\n  <Success extends Schema.Constraint, Error extends Schema.Constraint, R>(\n    effect: Effect.Effect<Success[\"Type\"], Error[\"Type\"], R>,\n    self: DurableDeferred<Success, Error>\n  ): Effect.Effect<\n    Success[\"Type\"],\n    Error[\"Type\"],\n    | R\n    | FlowRuntime\n    | FlowInstance\n    | Success[\"DecodingServices\"]\n    | Success[\"EncodingServices\"]\n    | Error[\"DecodingServices\"]\n    | Error[\"EncodingServices\"]\n  >\n} = dual(\n  2,\n  <Success extends Schema.Constraint, Error extends Schema.Constraint, R>(\n    effect: Effect.Effect<Success[\"Type\"], Error[\"Type\"], R>,\n    self: DurableDeferred<Success, Error>\n  ): Effect.Effect<\n    Success[\"Type\"],\n    Error[\"Type\"],\n    | R\n    | FlowRuntime\n    | FlowInstance\n    | Success[\"DecodingServices\"]\n    | Success[\"EncodingServices\"]\n    | Error[\"DecodingServices\"]\n    | Error[\"EncodingServices\"]\n  > =>\n    Effect.contextWith(\n      (context: Context.Context<FlowRuntime | FlowInstance>) => {\n        const engine = Context.get(context, FlowRuntime)\n        const instance = Context.get(context, FlowInstance)\n        // Keep the original instance: action regions identify their ancestors\n        // by reference, and suspension metadata belongs to the enclosing flow.\n        return Effect.onExit(\n          effect,\n          // Untraced because completion encoding is called for each deferred result.\n          Effect.fnUntraced(function*(exit) {\n            if (Exit.isFailure(exit)) {\n              const [interrupts, reasons] = Arr.partition(\n                exit.cause.reasons,\n                Filter.fromPredicate(Cause.isInterruptReason)\n              )\n              const hasInterruptsOnly = interrupts.length === exit.cause.reasons.length\n              if (hasInterruptsOnly) {\n                // An interrupt-only exit is never a result: the effect was\n                // suspended, preempted, or interrupted, so record nothing.\n                // Recording here would durably persist the empty non-interrupt\n                // partition, and first-writer-wins would replay that empty\n                // cause forever instead of the real completion.\n                return\n              } else if (interrupts.length > 0) {\n                exit = Exit.failCause(Cause.fromReasons(reasons))\n              }\n            }\n            yield* engine.deferredDone(self, {\n              flowName: instance.flow._tag,\n              executionId: instance.executionId,\n              deferredName: self.name,\n              exit\n            })\n          })\n        )\n      }\n    )\n)\n\n/**\n * Runs effects as a durable race, returning a previously persisted result when\n * present or completing a named deferred with the first success. The race\n * fails only when every effect fails.\n *\n * @category racing\n * @since 0.1.0\n */\nexport const raceAll = <\n  const Effects extends NonEmptyReadonlyArray<Effect.Effect<any, any, any>>,\n  Success extends Schema.Schema<Effect.Success<Effects[number]>>,\n  Error extends Schema.Schema<Effect.Error<Effects[number]>>\n>(options: {\n  name: string\n  success: Success\n  error: Error\n  effects: Effects\n}): Effect.Effect<\n  Effect.Success<Effects[number]>,\n  Effect.Error<Effects[number]>,\n  | Effect.Services<Effects[number]>\n  | Success[\"DecodingServices\"]\n  | Success[\"EncodingServices\"]\n  | Error[\"DecodingServices\"]\n  | Error[\"EncodingServices\"]\n  | FlowRuntime\n  | FlowInstance\n> => {\n  const deferred = make<any, any>(`raceAll/${options.name}`, {\n    success: options.success,\n    error: options.error\n  })\n  return Effect.gen(function*() {\n    const engine = yield* FlowRuntime\n    const exit = yield* engine.deferredResult(deferred)\n    if (Option.isSome(exit)) {\n      return yield* exit.value\n    }\n    return yield* into(\n      Effect.raceAll(options.effects),\n      deferred\n    )\n  })\n}\n\n/**\n * Runtime brand identifier for durable deferred tokens.\n *\n * @category type IDs\n * @since 0.1.0\n */\nexport const TokenTypeId = \"@smthrs/flow/DurableDeferred/Token\"\n\n/**\n * Type-level brand identifier for `Token` values.\n *\n * @category type IDs\n * @since 0.1.0\n */\nexport type TokenTypeId = typeof TokenTypeId\n\n/**\n * Branded string token identifying a durable deferred for a flow\n * execution.\n *\n * A token is an address, not a credential. It is unsigned base64url JSON of\n * the flow name, execution id, and deferred name, and `tokenFromExecutionId`\n * and `tokenFromPayload` rebuild it from those values alone. Anyone who can\n * call `done`, `succeed`, `fail`, `failCause`, or `HumanTask.answer` against\n * the run's `FlowRuntime` can complete an open wait whose address they know or\n * derive. A host that exposes completion to other parties must authorize the\n * caller before it calls one of them.\n *\n * @category token\n * @since 0.1.0\n */\nexport type Token = Brand.Branded<string, TokenTypeId>\n\n/**\n * Schema for branded durable deferred tokens.\n *\n * @category token\n * @since 0.1.0\n */\nexport const Token: Schema.brand<Schema.String, TokenTypeId> = Schema.String.pipe(Schema.brand(TokenTypeId))\n\n/**\n * A completion token could not be decoded into its durable address.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class TokenInvalid extends Schema.TaggedError<TokenInvalid>()(\"@smthrs/flow/DurableDeferred/TokenInvalid\", {\n  code: Schema.Literals([\"malformed_token\", \"deferred_mismatch\"]).pipe(\n    Schema.withConstructorDefault(Effect.succeed(\"malformed_token\"))\n  ),\n  message: Schema.String\n}) {}\n\n/**\n * Schema for a decoded durable deferred token containing the flow\n * name, execution ID, and deferred name.\n *\n * @category token\n * @since 0.1.0\n */\nexport class TokenParsed extends Schema.Class<TokenParsed>(\n  \"@smthrs/flow/DurableDeferred/TokenParsed\"\n)({\n  flowName: Schema.String,\n  executionId: Schema.String,\n  deferredName: Schema.String\n}) {\n  /**\n   * Encodes the parsed flow, execution, and deferred names back into a token.\n   *\n   * @since 0.1.0\n   */\n  get asToken(): Token {\n    return Base64Url.encode(\n      JSON.stringify([this.flowName, this.executionId, this.deferredName])\n    ) as Token\n  }\n\n  /**\n   * Schema for decoding and encoding durable deferred tokens as strings.\n   *\n   * @since 0.1.0\n   */\n  static readonly FromString = Schema.String.pipe(\n    Schema.decodeTo(\n      Schema.fromJsonString(\n        Schema.Tuple([Schema.String, Schema.String, Schema.String])\n      ),\n      {\n        decode: SchemaGetter.decodeBase64UrlString(),\n        encode: SchemaGetter.encodeBase64Url()\n      }\n    ),\n    Schema.decodeTo(TokenParsed, {\n      decode: SchemaGetter.transform(\n        ([flowName, executionId, deferredName]) =>\n          new TokenParsed({\n            flowName,\n            executionId,\n            deferredName\n          })\n      ),\n      encode: SchemaGetter.transform(\n        (parsed) =>\n          [\n            parsed.flowName,\n            parsed.executionId,\n            parsed.deferredName\n          ] as const\n      )\n    })\n  )\n\n  /**\n   * Decodes a durable deferred token string into its parsed components.\n   *\n   * @since 0.1.0\n   */\n  static readonly fromString = Schema.decodeSync(TokenParsed.FromString)\n\n  /**\n   * Encodes parsed durable deferred token components into a token string.\n   *\n   * @since 0.1.0\n   */\n  static readonly encode = Schema.encodeSync(TokenParsed.FromString)\n\n  /**\n   * Parses an untrusted token into its durable address with a typed,\n   * bounded diagnostic on failure.\n   *\n   * @category token\n   * @since 1.0.0\n   */\n  static readonly parse = (token: string): Effect.Effect<TokenParsed, TokenInvalid> =>\n    Effect.mapError(\n      Schema.decodeEffect(TokenParsed.FromString)(token),\n      (issue) =>\n        new TokenInvalid({\n          message: `The supplied token \"${tokenExcerpt(token)}\" is not a durable deferred token: ${issue.message}`\n        })\n    )\n}\n\nconst maxTokenExcerptChars = 64\n\n/** Renders a bounded excerpt of untrusted token content for a diagnostic. */\nconst tokenExcerpt = (token: string): string =>\n  token.length <= maxTokenExcerptChars\n    ? token\n    : `${token.slice(0, maxTokenExcerptChars)} [${token.length - maxTokenExcerptChars} characters dropped]`\n\n/**\n * Creates a token for a durable deferred using the current flow instance's\n * flow name and execution ID.\n *\n * @category token\n * @since 0.1.0\n */\nexport const token: <Success extends Schema.Constraint, Error extends Schema.Constraint>(\n  self: DurableDeferred<Success, Error>\n) => Effect.Effect<Token, never, FlowInstance> =\n  // Untraced because token allocation is on the durable-deferred hot path.\n  Effect.fnUntraced(\n    function*<Success extends Schema.Constraint, Error extends Schema.Constraint>(\n      self: DurableDeferred<Success, Error>\n    ) {\n      const instance = yield* FlowInstance\n      return tokenFromExecutionId(self, instance)\n    }\n  )\n\n/**\n * Creates a durable deferred token from an explicit flow, execution ID,\n * and deferred name.\n *\n * @category token\n * @since 0.1.0\n */\nexport const tokenFromExecutionId: {\n  (options: {\n    readonly flow: Flow.Any\n    readonly executionId: string\n  }): <Success extends Schema.Constraint, Error extends Schema.Constraint>(\n    self: DurableDeferred<Success, Error>\n  ) => Token\n  <Success extends Schema.Constraint, Error extends Schema.Constraint>(\n    self: DurableDeferred<Success, Error>,\n    options: { readonly flow: Flow.Any; readonly executionId: string }\n  ): Token\n} = dual(\n  2,\n  <Success extends Schema.Constraint, Error extends Schema.Constraint>(\n    self: DurableDeferred<Success, Error>,\n    options: {\n      readonly flow: Flow.Any\n      readonly executionId: string\n    }\n  ): Token =>\n    new TokenParsed({\n      flowName: options.flow._tag,\n      executionId: options.executionId,\n      deferredName: self.name\n    }).asToken\n)\n\n/**\n * Creates a durable deferred token by deriving the flow execution ID from\n * the supplied flow payload.\n *\n * The payload identifies a previously started execution only when the flow\n * declares `idempotencyKey` or the host installs the opt-in `derived`\n * execution-id source. Otherwise the default `fresh` source mints a new\n * execution ID on every call, so the token addresses no earlier run. To\n * complete an existing execution without stable identity, keep its execution\n * ID and use {@link tokenFromExecutionId}.\n *\n * @category token\n * @since 0.1.0\n */\nexport const tokenFromPayload: {\n  <W extends Flow.Any>(options: {\n    readonly flow: W\n    readonly payload: Flow.PayloadSchema<W>[\"~type.make.in\"]\n  }): <Success extends Schema.Constraint, Error extends Schema.Constraint>(\n    self: DurableDeferred<Success, Error>\n  ) => Effect.Effect<Token, never, Crypto.Crypto | Flow.PayloadSchema<W>[\"EncodingServices\"]>\n  <\n    Success extends Schema.Constraint,\n    Error extends Schema.Constraint,\n    W extends Flow.Any\n  >(\n    self: DurableDeferred<Success, Error>,\n    options: {\n      readonly flow: W\n      readonly payload: Flow.PayloadSchema<W>[\"~type.make.in\"]\n    }\n  ): Effect.Effect<Token, never, Crypto.Crypto | Flow.PayloadSchema<W>[\"EncodingServices\"]>\n} = dual(\n  2,\n  <\n    Success extends Schema.Constraint,\n    Error extends Schema.Constraint,\n    W extends Flow.Any\n  >(\n    self: DurableDeferred<Success, Error>,\n    options: {\n      readonly flow: W\n      readonly payload: Flow.PayloadSchema<W>[\"~type.make.in\"]\n    }\n  ): Effect.Effect<Token, never, Crypto.Crypto | Flow.PayloadSchema<W>[\"EncodingServices\"]> =>\n    Effect.map(options.flow.executionId(options.payload), (executionId) =>\n      tokenFromExecutionId(self, {\n        flow: options.flow,\n        executionId\n      }))\n)\n\n/**\n * Completes the durable deferred identified by a token with the supplied exit,\n * encoding the result through the deferred schemas.\n *\n * The token is not a credential (see {@link Token}): authorize the caller\n * before completing a wait on its behalf.\n *\n * @category combinators\n * @since 0.1.0\n */\nexport const done: {\n  <Success extends Schema.Constraint, Error extends Schema.Constraint>(options: {\n    readonly token: Token\n    readonly exit: Exit.Exit<Success[\"Type\"], Error[\"Type\"]>\n  }): (\n    self: DurableDeferred<Success, Error>\n  ) => Effect.Effect<\n    void,\n    TokenInvalid,\n    FlowRuntime | Success[\"EncodingServices\"] | Error[\"EncodingServices\"]\n  >\n  <Success extends Schema.Constraint, Error extends Schema.Constraint>(\n    self: DurableDeferred<Success, Error>,\n    options: {\n      readonly token: Token\n      readonly exit: Exit.Exit<Success[\"Type\"], Error[\"Type\"]>\n    }\n  ): Effect.Effect<\n    void,\n    TokenInvalid,\n    FlowRuntime | Success[\"EncodingServices\"] | Error[\"EncodingServices\"]\n  >\n} = dual(\n  2,\n  // Untraced because awaiting a deferred re-enters the scheduler recursively.\n  Effect.fnUntraced(function*<\n    Success extends Schema.Constraint,\n    Error extends Schema.Constraint\n  >(\n    self: DurableDeferred<Success, Error>,\n    options: {\n      readonly token: Token\n      readonly exit: Exit.Exit<Success[\"Type\"], Error[\"Type\"]>\n    }\n  ) {\n    const token = yield* TokenParsed.parse(options.token)\n    if (token.deferredName !== self.name) {\n      return yield* Effect.fail(\n        new TokenInvalid({\n          code: \"deferred_mismatch\",\n          message: `The token addresses deferred \"${tokenExcerpt(token.deferredName)}\", but it was submitted through ` +\n            `deferred \"${self.name}\".`\n        })\n      )\n    }\n    const engine = yield* FlowRuntime\n    yield* engine.deferredDone(self, {\n      flowName: token.flowName,\n      executionId: token.executionId,\n      deferredName: token.deferredName,\n      exit: options.exit\n    })\n  })\n)\n\n/**\n * Completes the durable deferred identified by a token with a successful\n * value.\n *\n * @category combinators\n * @since 0.1.0\n */\nexport const succeed: {\n  <Success extends Schema.Constraint, Error extends Schema.Constraint>(options: {\n    readonly token: Token\n    readonly value: Success[\"Type\"]\n  }): (\n    self: DurableDeferred<Success, Error>\n  ) => Effect.Effect<void, TokenInvalid, FlowRuntime | Success[\"EncodingServices\"]>\n  <Success extends Schema.Constraint, Error extends Schema.Constraint>(\n    self: DurableDeferred<Success, Error>,\n    options: {\n      readonly token: Token\n      readonly value: Success[\"Type\"]\n    }\n  ): Effect.Effect<void, TokenInvalid, FlowRuntime | Success[\"EncodingServices\"]>\n} = dual(\n  2,\n  <Success extends Schema.Constraint, Error extends Schema.Constraint>(\n    self: DurableDeferred<Success, Error>,\n    options: {\n      readonly token: Token\n      readonly value: Success[\"Type\"]\n    }\n  ): Effect.Effect<void, TokenInvalid, FlowRuntime | Success[\"EncodingServices\"]> =>\n    done(self, {\n      token: options.token,\n      exit: Exit.succeed(options.value)\n    })\n)\n\n/**\n * Completes the durable deferred identified by a token with a typed failure.\n *\n * @category combinators\n * @since 0.1.0\n */\nexport const fail: {\n  <Success extends Schema.Constraint, Error extends Schema.Constraint>(options: {\n    readonly token: Token\n    readonly error: Error[\"Type\"]\n  }): (\n    self: DurableDeferred<Success, Error>\n  ) => Effect.Effect<void, TokenInvalid, FlowRuntime | Error[\"EncodingServices\"]>\n  <Success extends Schema.Constraint, Error extends Schema.Constraint>(\n    self: DurableDeferred<Success, Error>,\n    options: {\n      readonly token: Token\n      readonly error: Error[\"Type\"]\n    }\n  ): Effect.Effect<void, TokenInvalid, FlowRuntime | Error[\"EncodingServices\"]>\n} = dual(\n  2,\n  <Success extends Schema.Constraint, Error extends Schema.Constraint>(\n    self: DurableDeferred<Success, Error>,\n    options: {\n      readonly token: Token\n      readonly error: Error[\"Type\"]\n    }\n  ): Effect.Effect<void, TokenInvalid, FlowRuntime | Error[\"EncodingServices\"]> =>\n    done(self, {\n      token: options.token,\n      exit: Exit.fail(options.error)\n    })\n)\n\n/**\n * Completes the durable deferred identified by a token with a failure cause.\n *\n * @category combinators\n * @since 0.1.0\n */\nexport const failCause: {\n  <Success extends Schema.Constraint, Error extends Schema.Constraint>(options: {\n    readonly token: Token\n    readonly cause: Cause.Cause<Error[\"Type\"]>\n  }): (\n    self: DurableDeferred<Success, Error>\n  ) => Effect.Effect<void, TokenInvalid, FlowRuntime | Error[\"EncodingServices\"]>\n  <Success extends Schema.Constraint, Error extends Schema.Constraint>(\n    self: DurableDeferred<Success, Error>,\n    options: {\n      readonly token: Token\n      readonly cause: Cause.Cause<Error[\"Type\"]>\n    }\n  ): Effect.Effect<void, TokenInvalid, FlowRuntime | Error[\"EncodingServices\"]>\n} = dual(\n  2,\n  <Success extends Schema.Constraint, Error extends Schema.Constraint>(\n    self: DurableDeferred<Success, Error>,\n    options: {\n      readonly token: Token\n      readonly cause: Cause.Cause<Error[\"Type\"]>\n    }\n  ): Effect.Effect<void, TokenInvalid, FlowRuntime | Error[\"EncodingServices\"]> =>\n    done(self, {\n      token: options.token,\n      exit: Exit.failCause(options.cause)\n    })\n)\n"]}

package/dist/esm/DurableQueue.d.ts

@@ -0,0 +1,160 @@
+import type * as Crypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as PersistedQueue from "effect/persistence/PersistedQueue";
+import * as Schedule from "effect/Schedule";
+import * as Schema from "effect/Schema";
+import * as DurableDeferred from "./DurableDeferred.ts";
+import { type FlowInstance, type FlowRuntime } from "./FlowRuntime/index.ts";
+/**
+ * Type-level identifier used to recognize `DurableQueue` values.
+ *
+ * @category type IDs
+ * @since 0.1.0
+ */
+export type TypeId = "@smthrs/flow/DurableQueue";
+/**
+ * Runtime identifier attached to `DurableQueue` values.
+ *
+ * @category type IDs
+ * @since 0.1.0
+ */
+export declare const TypeId: TypeId;
+/**
+ * Durable flow queue definition containing a payload schema, idempotency
+ * key, and deferred used to await worker results.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface DurableQueue<Payload extends Schema.Top, Success extends Schema.Top = Schema.Void, Error extends Schema.Top = Schema.Never> {
+    readonly [TypeId]: TypeId;
+    readonly name: string;
+    readonly payloadSchema: Payload;
+    readonly idempotencyKey: (payload: Payload["Type"]) => string;
+    readonly deferred: DurableDeferred.DurableDeferred<Success, Error>;
+}
+/**
+ * Creates a `DurableQueue` that waits for persisted items to finish processing
+ * using a `DurableDeferred`.
+ *
+ * **Example** (Defining a durable queue with workers)
+ *
+ * ```ts
+ * import { Action, DurableQueue, Flow, Interpreter } from "@smthrs/flow"
+ * import { Effect, Layer, Schema } from "effect"
+ *
+ * // Define a DurableQueue that can be used to derive workers and offer items for
+ * // processing.
+ * const ApiQueue = DurableQueue.make({
+ *   name: "ApiQueue",
+ *   payload: {
+ *     id: Schema.String
+ *   },
+ *   success: Schema.Void,
+ *   error: Schema.Never,
+ *   idempotencyKey(payload) {
+ *     return payload.id
+ *   }
+ * })
+ *
+ * // Offering an item is work, so it is a declared Action: the declaration is
+ * // pure data, and the implementation attaches separately.
+ * const Offer = Action.make("MyFlow/offer", {
+ *   payload: {
+ *     id: Schema.String
+ *   }
+ * })
+ *
+ * const OfferLive = Offer.toLayer(
+ *   Effect.fnUntraced(function*({ id }) {
+ *     // Add an item to the DurableQueue defined above.
+ *     //
+ *     // When the worker has finished processing the item, the flow will
+ *     // resume.
+ *     //
+ *     yield* DurableQueue.process(ApiQueue, { id })
+ *
+ *     yield* Effect.log("Flow succeeded!")
+ *   })
+ * )
+ *
+ * // The flow is the composite, and its body names the step it is made of.
+ * const MyFlow = Flow.make("MyFlow", {
+ *   payload: {
+ *     id: Schema.String
+ *   },
+ *   idempotencyKey: ({ id }) => id,
+ *   body: (payload) => Offer.call(payload)
+ * })
+ *
+ * const MyFlowLayer = Layer.mergeAll(OfferLive, Interpreter.layer(MyFlow)).pipe(
+ *   Layer.provideMerge(Action.layerImplementations)
+ * )
+ *
+ * // Define a worker layer that can process items from the DurableQueue.
+ * const ApiWorker = DurableQueue.worker(
+ *   ApiQueue,
+ *   Effect.fnUntraced(function*({ id }) {
+ *     yield* Effect.log(`Worker processing API call with id: ${id}`)
+ *   }),
+ *   { concurrency: 5 } // Process up to 5 items concurrently
+ * )
+ * ```
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: <Payload extends Schema.Top | Schema.Struct.Fields, Success extends Schema.Top = Schema.Void, Error extends Schema.Top = Schema.Never>(options: {
+    readonly name: string;
+    readonly payload: Payload;
+    readonly idempotencyKey: (payload: Payload extends Schema.Struct.Fields ? Schema.Struct.Type<Payload> : Payload["Type"]) => string;
+    readonly success?: Success | undefined;
+    readonly error?: Error | undefined;
+}) => DurableQueue<Payload extends Schema.Struct.Fields ? Schema.Struct<Payload> : Payload, Success, Error>;
+/**
+ * Adds an item to the queue and waits for a worker to process it.
+ *
+ * `retrySchedule` controls retries when the persisted offer fails. The default
+ * is unbounded, with exponential delays capped at one minute, so a transient
+ * store outage does not lose the item. A caller-supplied schedule may exhaust;
+ * its final offer failure becomes a defect to keep the public error channel
+ * reserved for the worker's declared error.
+ *
+ * Payload construction also becomes a defect when `fields` does not satisfy
+ * the queue's payload schema. The public error channel is the worker result,
+ * not malformed caller input.
+ *
+ * @category processing
+ * @since 0.1.0
+ */
+export declare const process: <Payload extends Schema.Top, Success extends Schema.Top, Error extends Schema.Top>(self: DurableQueue<Payload, Success, Error>, payload: Payload["~type.make.in"], options?: {
+    readonly retrySchedule?: Schedule.Schedule<any, PersistedQueue.PersistedQueueError> | undefined;
+}) => Effect.Effect<Success["Type"], Error["Type"], FlowRuntime | FlowInstance | Crypto.Crypto | PersistedQueue.PersistedQueueFactory | Payload["EncodingServices"] | Payload["DecodingServices"] | Success["DecodingServices"] | Error["DecodingServices"]>;
+/**
+ * Create a worker effect that processes items from the durable queue.
+ *
+ * `concurrency` defaults to one and must be a positive safe integer. It is
+ * checked before the persisted queue is opened. `maxAttempts` defaults to ten
+ * and is passed to the persisted queue. Completion-write failures can rerun the
+ * handler; side effects must be idempotent. Exhaustion leaves the flow waiting.
+ *
+ * @throws A `RangeError` when `concurrency` is not a positive safe integer.
+ * @category worker
+ * @since 0.1.0
+ */
+export declare const makeWorker: <Payload extends Schema.Top, Success extends Schema.Top, Error extends Schema.Top, R>(self: DurableQueue<Payload, Success, Error>, f: (payload: Payload["Type"]) => Effect.Effect<Success["Type"], Error["Type"], R>, options?: {
+    readonly concurrency?: number | undefined;
+    readonly maxAttempts?: number | undefined;
+} | undefined) => Effect.Effect<never, never, FlowRuntime | PersistedQueue.PersistedQueueFactory | R | Payload["EncodingServices"] | Payload["DecodingServices"] | Success["EncodingServices"] | Error["EncodingServices"]>;
+/**
+ * Create a layer that runs workers for the durable queue.
+ *
+ * @category worker
+ * @since 0.1.0
+ */
+export declare const worker: <Payload extends Schema.Top, Success extends Schema.Top, Error extends Schema.Top, R>(self: DurableQueue<Payload, Success, Error>, f: (payload: Payload["Type"]) => Effect.Effect<Success["Type"], Error["Type"], R>, options?: {
+    readonly concurrency?: number | undefined;
+    readonly maxAttempts?: number | undefined;
+} | undefined) => Layer.Layer<never, never, FlowRuntime | PersistedQueue.PersistedQueueFactory | R | Payload["EncodingServices"] | Payload["DecodingServices"] | Success["EncodingServices"] | Error["EncodingServices"]>;
+//# sourceMappingURL=DurableQueue.d.ts.map

package/dist/esm/DurableQueue.d.ts.map

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