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

package/dist/esm/Action/Implementations.d.ts

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

package/dist/esm/Action/Implementations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Implementations.d.ts","sourceRoot":"","sources":["../../../src/Action/Implementations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAA;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAGhE;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,oEAAoE;IACpE,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACnD,QAAQ,CAAC,MAAM,EAAE,CACf,OAAO,EAAE,OAAO,KACb,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,GAAG,WAAW,GAAG,YAAY,CAAC,CAAA;CACjF;;IAmBG;;;;;;;;;;OAUG;kBACW,CACZ,cAAc,EAAE,cAAc,EAC9B,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,KACtC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC;IAEtC;;;OAGG;kBACW,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;;AArChF;;;;;;;;;;;;;GAaG;AACH,qBAAa,eAAgB,SAAQ,oBAyBK;CAAG;AAE7C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,KAAK,CAAC,eAAe,CA2B7D,CAAA"}

package/dist/esm/Action/Implementations.js

@@ -0,0 +1,94 @@
+/**
+ * The table a driver resolves a declared action's implementation through.
+ *
+ * `docs/concepts/flows-and-actions.md` splits an Action in two: a
+ * declaration that is pure data and travels everywhere, and an implementation
+ * attached separately as a layer, on the hosts that can run it. A body names
+ * the declaration — `Increment.call({ path })` records a node and executes
+ * nothing — so whatever later drives that node has to find the implementation
+ * by name, from context, at execution time. That is this service: `toLayer`
+ * files the implementation here when the table is present, and a driver asks
+ * for it by the tag the node carries.
+ *
+ * "When the table is present" means present while the implementation layer
+ * ITSELF is built, so ONE table goes under the implementations AND under
+ * whatever drives them:
+ *
+ * ```ts
+ * Layer.mergeAll(Read.toLayer(read), Write.toLayer(write), Interpreter.layer(Pipeline)).pipe(
+ *   Layer.provideMerge(Action.layerImplementations)
+ * )
+ * ```
+ *
+ * Filing is a build-time effect, not a declared output, so the type checker
+ * cannot catch a composition that builds one table for the implementations and
+ * a second for the driver. That composition files into the first and reads the
+ * second, and the driver refuses the call at run time naming the action.
+ *
+ * The table is deliberately not part of `FlowRuntime`. The runtime port is what
+ * a flow, an action, or a durable wait is EXECUTED against, and an
+ * implementation table is not an execution capability: it is authoring data,
+ * assembled by the same layers that assemble the declarations, and every
+ * runtime implementation can serve one identically.
+ *
+ * @since 0.1.0
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { DuplicateImplementation } from "./DuplicateImplementation.js";
+/**
+ * Service holding the declared action implementations a composition wired
+ * up, keyed by action tag.
+ *
+ * **When to use**
+ *
+ * Use when driving a flow body, whose action calls name declarations rather
+ * than carry code. A composition that only drives behavior registered directly
+ * with the runtime never needs it, which is why `Action.toLayer` files an
+ * implementation here when the service is present and skips it otherwise.
+ *
+ * @category services
+ * @since 0.1.0
+ */
+export class Implementations extends Context.Service()("@smthrs/flow/Action/Implementations") {
+}
+/**
+ * Layer providing an implementation table scoped to the composition that
+ * builds it.
+ *
+ * The table is mutable and lives for the layer's lifetime, exactly like the
+ * flow registry a runtime keeps: registration happens while layers are built,
+ * and every lookup happens later, when a run drives a node. Because filing is
+ * a build-time effect, provide this UNDER the implementation layers — see the
+ * wiring at the top of this module — rather than merging it beside them.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export const layerImplementations = Layer.effect(Implementations)(Effect.sync(() => {
+    const registered = new Map();
+    return Implementations.of({
+        add: (implementation, options) => Effect.suspend(() => {
+            const entries = registered.get(implementation.name) ?? [];
+            if (entries.length > 0 && options?.override !== true && entries.at(-1)?.implementation !== implementation) {
+                return Effect.die(new DuplicateImplementation({ name: implementation.name }));
+            }
+            // Ownership belongs to this registration, not the implementation
+            // object: two scopes may file the very same implementation. Sibling
+            // scopes can close in either order, so a captured predecessor is not
+            // proof that its resources are still alive when an override closes.
+            const entry = { implementation };
+            entries.push(entry);
+            registered.set(implementation.name, entries);
+            return Effect.addFinalizer(() => Effect.sync(() => {
+                entries.splice(entries.indexOf(entry), 1);
+                if (entries.length === 0)
+                    registered.delete(implementation.name);
+            }));
+        }),
+        get: (name) => Effect.sync(() => Option.fromNullishOr(registered.get(name)?.at(-1)?.implementation))
+    });
+}));
+//# sourceMappingURL=Implementations.js.map

package/dist/esm/Action/Implementations.js.map

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

package/dist/esm/Action/InfraInterrupt.d.ts

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

package/dist/esm/Action/InfraInterrupt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InfraInterrupt.d.ts","sourceRoot":"","sources":["../../../src/Action/InfraInterrupt.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;;;;;AAEvC;;;;;;;GAOG;AACH,qBAAa,cAAe,SAAQ,mBAQnC;CAAG"}

package/dist/esm/Action/InfraInterrupt.js

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

package/dist/esm/Action/InfraInterrupt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InfraInterrupt.js","sourceRoot":"","sources":["../../../src/Action/InfraInterrupt.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;;;GAOG;AACH,MAAM,OAAO,cAAe,SAAQ,MAAM,CAAC,WAAW,EAAkB,CACtE,6BAA6B,EAC7B;IACE,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,IAAI,CAC1C,MAAM,CAAC,sBAAsB,CAAC,MAAM,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAC,CACjE;IACD,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC;CACxC,CACF;CAAG","sourcesContent":["/**\n * Defines the `InfraInterrupt` action failure.\n *\n * The `_tag` string was settled under `@smthrs/flow/` for 1.0.0-rc.0. The RC\n * makes no compatibility promise to 0.x journals, and the tag freezes when\n * the RC ships.\n *\n * @since 0.1.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\n\n/**\n * Marker an action implementation or adapter raises for an infrastructure\n * event it wants the action's `interruptRetryPolicy` to retry. Shipped engines\n * do not synthesize it from ordinary fiber interruption.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class InfraInterrupt extends Schema.TaggedError<InfraInterrupt>()(\n  \"@smthrs/flow/InfraInterrupt\",\n  {\n    code: Schema.Literal(\"infra_interrupt\").pipe(\n      Schema.withConstructorDefault(Effect.succeed(\"infra_interrupt\"))\n    ),\n    reason: Schema.optional(Schema.Unknown)\n  }\n) {}\n"]}

package/dist/esm/Action/InfraInterruptRetriesExhausted.d.ts

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

package/dist/esm/Action/InfraInterruptRetriesExhausted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InfraInterruptRetriesExhausted.d.ts","sourceRoot":"","sources":["../../../src/Action/InfraInterruptRetriesExhausted.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;;;;;;IAkBhD;;;OAGG;;;AAnBP;;;;;;GAMG;AACH,qBAAa,8BAA+B,SAAQ,mCAenD;CAAG"}

package/dist/esm/Action/InfraInterruptRetriesExhausted.js

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

package/dist/esm/Action/InfraInterruptRetriesExhausted.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InfraInterruptRetriesExhausted.js","sourceRoot":"","sources":["../../../src/Action/InfraInterruptRetriesExhausted.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAEpD;;;;;;GAMG;AACH,MAAM,OAAO,8BAA+B,SAAQ,MAAM,CAAC,WAAW,EAAkC,CACtG,6CAA6C,EAC7C;IACE,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,mCAAmC,CAAC,CAAC,IAAI,CAC5D,MAAM,CAAC,sBAAsB,CAAC,MAAM,CAAC,OAAO,CAAC,mCAAmC,CAAC,CAAC,CACnF;IACD,UAAU,EAAE,MAAM,CAAC,MAAM;IACzB,QAAQ,EAAE,MAAM,CAAC,MAAM;IACvB,SAAS,EAAE,cAAc;IACzB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC,MAAM;CACvB,CACF;CAAG","sourcesContent":["/**\n * Defines the `InfraInterruptRetriesExhausted` action failure.\n *\n * The `_tag` string was settled under `@smthrs/flow/` for 1.0.0-rc.0. The RC\n * makes no compatibility promise to 0.x journals, and the tag freezes when\n * the RC ships.\n *\n * @since 0.1.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\nimport { InfraInterrupt } from \"./InfraInterrupt.ts\"\n\n/**\n * An action spent its infrastructure-interrupt retry policy without reaching\n * an ordinary success or failure.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class InfraInterruptRetriesExhausted extends Schema.TaggedError<InfraInterruptRetriesExhausted>()(\n  \"@smthrs/flow/InfraInterruptRetriesExhausted\",\n  {\n    code: Schema.Literal(\"infra_interrupt_retries_exhausted\").pipe(\n      Schema.withConstructorDefault(Effect.succeed(\"infra_interrupt_retries_exhausted\"))\n    ),\n    actionName: Schema.String,\n    attempts: Schema.Number,\n    interrupt: InfraInterrupt,\n    /**\n     * The sentence an operator reads out of a rendered cause. The typed fields\n     * beside it are what a log pipeline keys on.\n     */\n    message: Schema.String\n  }\n) {}\n"]}

package/dist/esm/Action/IrreversibleRetryRequiresIdempotencyKey.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Defines the `IrreversibleRetryRequiresIdempotencyKey` action failure.
+ *
+ * The `_tag` string was settled under `@smthrs/flow/` for 1.0.0-rc.0. The RC
+ * makes no compatibility promise to 0.x journals, and the tag freezes when
+ * the RC ships.
+ *
+ * @since 0.1.0
+ */
+import * as Schema from "effect/Schema";
+declare const IrreversibleRetryRequiresIdempotencyKey_base: Schema.Class<IrreversibleRetryRequiresIdempotencyKey, Schema.TaggedStruct<"@smthrs/flow/IrreversibleRetryRequiresIdempotencyKey", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"irreversible_retry_requires_idempotency_key">>;
+    readonly actionName: Schema.String;
+    readonly attempt: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * An irreversible action attempted a retry without declaring an
+ * idempotency key.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class IrreversibleRetryRequiresIdempotencyKey extends IrreversibleRetryRequiresIdempotencyKey_base {
+}
+export {};
+//# sourceMappingURL=IrreversibleRetryRequiresIdempotencyKey.d.ts.map

package/dist/esm/Action/IrreversibleRetryRequiresIdempotencyKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IrreversibleRetryRequiresIdempotencyKey.d.ts","sourceRoot":"","sources":["../../../src/Action/IrreversibleRetryRequiresIdempotencyKey.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;;;;;;AAEvC;;;;;;GAMG;AACH,qBAAa,uCACX,SAAQ,4CASP;CACD"}

package/dist/esm/Action/IrreversibleRetryRequiresIdempotencyKey.js

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

package/dist/esm/Action/IrreversibleRetryRequiresIdempotencyKey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IrreversibleRetryRequiresIdempotencyKey.js","sourceRoot":"","sources":["../../../src/Action/IrreversibleRetryRequiresIdempotencyKey.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;;GAMG;AACH,MAAM,OAAO,uCACX,SAAQ,MAAM,CAAC,WAAW,EAA2C,CACnE,sDAAsD,EACtD;IACE,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,6CAA6C,CAAC,CAAC,IAAI,CACtE,MAAM,CAAC,sBAAsB,CAAC,MAAM,CAAC,OAAO,CAAC,6CAA6C,CAAC,CAAC,CAC7F;IACD,UAAU,EAAE,MAAM,CAAC,MAAM;IACzB,OAAO,EAAE,MAAM,CAAC,MAAM;CACvB,CACF;CACD","sourcesContent":["/**\n * Defines the `IrreversibleRetryRequiresIdempotencyKey` action failure.\n *\n * The `_tag` string was settled under `@smthrs/flow/` for 1.0.0-rc.0. The RC\n * makes no compatibility promise to 0.x journals, and the tag freezes when\n * the RC ships.\n *\n * @since 0.1.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\n\n/**\n * An irreversible action attempted a retry without declaring an\n * idempotency key.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class IrreversibleRetryRequiresIdempotencyKey\n  extends Schema.TaggedError<IrreversibleRetryRequiresIdempotencyKey>()(\n    \"@smthrs/flow/IrreversibleRetryRequiresIdempotencyKey\",\n    {\n      code: Schema.Literal(\"irreversible_retry_requires_idempotency_key\").pipe(\n        Schema.withConstructorDefault(Effect.succeed(\"irreversible_retry_requires_idempotency_key\"))\n      ),\n      actionName: Schema.String,\n      attempt: Schema.Number\n    }\n  )\n{}\n"]}

package/dist/esm/Action/StepIdentity.d.ts

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

package/dist/esm/Action/StepIdentity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StepIdentity.d.ts","sourceRoot":"","sources":["../../../src/Action/StepIdentity.ts"],"names":[],"mappings":"AA4BA,OAAO,EAAc,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AACzD,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;;AAevC;;;;;;;;;;GAUG;AACH,qBAAa,YAAa,SAAQ,iBAEjC;CAAG;AAEJ;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,UAAU,GAAG,UAAU,CAAA;IACzC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACtC;;yBAuBsB,CAAC,QAAQ,EAAE,eAAe,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;;AArBzE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,cAAe,SAAQ,mBAEM;CAAG;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU,eAAe,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAI1E,CAAA;AAEH;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAA;IACpC;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB;;;;;;;;OAQG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,UAAU,GAAG,SAAS,CAAA;IAC7D;;;;OAIG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,eAAe,GAC1B,UAAU,kBAAkB,KAC3B,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,CAYtD,CAAA;AAEJ;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACzC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,aAAa,GAAG,cAAc,CAAA;CAC3D,KAAG,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,CAG3D,CAAA"}