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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Action/Implementations.ts"],
+  "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 \u2014 `Increment.call({ path })` records a node and executes\n * nothing \u2014 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 \u2014\n * invocation key, attempt journal, tier, retry policy \u2014 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 \u2014 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 \u2014 see the\n * wiring at the top of this module \u2014 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"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoCA,cAAyB;AAEzB,aAAwB;AACxB,YAAuB;AACvB,aAAwB;AAIxB,qCAAwC;AAqCjC,MAAM,wBAAwB,QAAQ,QAyB3C,EAAE,qCAAqC,EAAE;AAAC;AAerC,MAAM,uBAAqD,MAAM,OAAO,eAAe;AAAA,EAC5F,OAAO,KAAK,MAAM;AAChB,UAAM,aAAa,oBAAI,IAAgE;AACvF,WAAO,gBAAgB,GAAG;AAAA,MACxB,KAAK,CAAC,gBAAgB,YACpB,OAAO,QAAQ,MAAM;AACnB,cAAM,UAAU,WAAW,IAAI,eAAe,IAAI,KAAK,CAAC;AACxD,YAAI,QAAQ,SAAS,KAAK,SAAS,aAAa,QAAQ,QAAQ,GAAG,EAAE,GAAG,mBAAmB,gBAAgB;AACzG,iBAAO,OAAO,IAAI,IAAI,uDAAwB,EAAE,MAAM,eAAe,KAAK,CAAC,CAAC;AAAA,QAC9E;AAKA,cAAM,QAAQ,EAAE,eAAe;AAC/B,gBAAQ,KAAK,KAAK;AAClB,mBAAW,IAAI,eAAe,MAAM,OAAO;AAC3C,eAAO,OAAO;AAAA,UAAa,MACzB,OAAO,KAAK,MAAM;AAChB,oBAAQ,OAAO,QAAQ,QAAQ,KAAK,GAAG,CAAC;AACxC,gBAAI,QAAQ,WAAW,EAAG,YAAW,OAAO,eAAe,IAAI;AAAA,UACjE,CAAC;AAAA,QACH;AAAA,MACF,CAAC;AAAA,MACH,KAAK,CAAC,SAAS,OAAO,KAAK,MAAM,OAAO,cAAc,WAAW,IAAI,IAAI,GAAG,GAAG,EAAE,GAAG,cAAc,CAAC;AAAA,IACrG,CAAC;AAAA,EACH,CAAC;AACH;",
+  "names": []
+}

package/dist/cjs/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/cjs/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/cjs/Action/InfraInterrupt.js

@@ -0,0 +1,46 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var InfraInterrupt_exports = {};
+__export(InfraInterrupt_exports, {
+  InfraInterrupt: () => InfraInterrupt
+});
+module.exports = __toCommonJS(InfraInterrupt_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+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/cjs/Action/InfraInterrupt.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Action/InfraInterrupt.ts"],
+  "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"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,aAAwB;AACxB,aAAwB;AAUjB,MAAM,uBAAuB,OAAO,YAA4B;AAAA,EACrE;AAAA,EACA;AAAA,IACE,MAAM,OAAO,QAAQ,iBAAiB,EAAE;AAAA,MACtC,OAAO,uBAAuB,OAAO,QAAQ,iBAAiB,CAAC;AAAA,IACjE;AAAA,IACA,QAAQ,OAAO,SAAS,OAAO,OAAO;AAAA,EACxC;AACF,EAAE;AAAC;",
+  "names": []
+}

package/dist/cjs/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/cjs/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/cjs/Action/InfraInterruptRetriesExhausted.js

@@ -0,0 +1,54 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var InfraInterruptRetriesExhausted_exports = {};
+__export(InfraInterruptRetriesExhausted_exports, {
+  InfraInterruptRetriesExhausted: () => InfraInterruptRetriesExhausted
+});
+module.exports = __toCommonJS(InfraInterruptRetriesExhausted_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var import_InfraInterrupt = require("./InfraInterrupt.js");
+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: import_InfraInterrupt.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/cjs/Action/InfraInterruptRetriesExhausted.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Action/InfraInterruptRetriesExhausted.ts"],
+  "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"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,aAAwB;AACxB,aAAwB;AACxB,4BAA+B;AASxB,MAAM,uCAAuC,OAAO,YAA4C;AAAA,EACrG;AAAA,EACA;AAAA,IACE,MAAM,OAAO,QAAQ,mCAAmC,EAAE;AAAA,MACxD,OAAO,uBAAuB,OAAO,QAAQ,mCAAmC,CAAC;AAAA,IACnF;AAAA,IACA,YAAY,OAAO;AAAA,IACnB,UAAU,OAAO;AAAA,IACjB,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA,IAKX,SAAS,OAAO;AAAA,EAClB;AACF,EAAE;AAAC;",
+  "names": []
+}

package/dist/cjs/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/cjs/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/cjs/Action/IrreversibleRetryRequiresIdempotencyKey.js

@@ -0,0 +1,47 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var IrreversibleRetryRequiresIdempotencyKey_exports = {};
+__export(IrreversibleRetryRequiresIdempotencyKey_exports, {
+  IrreversibleRetryRequiresIdempotencyKey: () => IrreversibleRetryRequiresIdempotencyKey
+});
+module.exports = __toCommonJS(IrreversibleRetryRequiresIdempotencyKey_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+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/cjs/Action/IrreversibleRetryRequiresIdempotencyKey.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Action/IrreversibleRetryRequiresIdempotencyKey.ts"],
+  "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"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,aAAwB;AACxB,aAAwB;AASjB,MAAM,gDACH,OAAO,YAAqD;AAAA,EAClE;AAAA,EACA;AAAA,IACE,MAAM,OAAO,QAAQ,6CAA6C,EAAE;AAAA,MAClE,OAAO,uBAAuB,OAAO,QAAQ,6CAA6C,CAAC;AAAA,IAC7F;AAAA,IACA,YAAY,OAAO;AAAA,IACnB,SAAS,OAAO;AAAA,EAClB;AACF,EACF;AAAC;",
+  "names": []
+}

package/dist/cjs/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/cjs/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"}

package/dist/cjs/Action/StepIdentity.js

@@ -0,0 +1,75 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var StepIdentity_exports = {};
+__export(StepIdentity_exports, {
+  DispatchReport: () => DispatchReport,
+  DispatchSite: () => DispatchSite,
+  allocationScope: () => allocationScope,
+  invocationKey: () => invocationKey,
+  reportDispatch: () => reportDispatch
+});
+module.exports = __toCommonJS(StepIdentity_exports);
+var import_crypto = require("@smthrs/crypto");
+var import_keys = require("@smthrs/keys");
+var Context = __toESM(require("effect/Context"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+const Invocation = Schema.Struct({
+  runId: Schema.NonEmptyString,
+  parentScope: Schema.optionalKey(Schema.NonEmptyString),
+  ordinal: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+  tier: Schema.Literals(["compensable", "irreversible", "unsealed"])
+});
+class DispatchSite extends Context.Service()(
+  "@smthrs/flow/Action/DispatchSite"
+) {
+}
+class DispatchReport extends Context.Service()("@smthrs/flow/Action/DispatchReport") {
+}
+const reportDispatch = (dispatch) => Effect.flatMap(
+  Effect.serviceOption(DispatchReport),
+  (report) => Option.isNone(report) ? Effect.void : report.value.dispatched(dispatch)
+);
+const allocationScope = (identity) => Effect.gen(function* () {
+  let scope = `${identity.kind}/${identity.name.length}:${identity.name}`;
+  if (typeof identity.idempotency === "string") {
+    const digest = yield* Schema.decodeUnknownEffect(import_crypto.Sha256)(identity.idempotency);
+    scope = `${scope}/s:${digest}`;
+  } else if (identity.idempotency !== void 0) {
+    const key = yield* Schema.decodeUnknownEffect(import_keys.DerivedKey)({ kind: "declaration", input: identity.idempotency });
+    scope = `${scope}/c:${key}`;
+  }
+  if (identity.site === void 0) return scope;
+  return `${scope}/g:${identity.site.length}:${identity.site}`;
+});
+const invocationKey = (input) => Schema.decodeUnknownEffect(Invocation)(input).pipe(
+  Effect.flatMap((validated) => Schema.decodeUnknownEffect(import_keys.DerivedKey)({ kind: "invocation", ...validated }))
+);
+//# sourceMappingURL=StepIdentity.js.map

package/dist/cjs/Action/StepIdentity.js.map

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

package/dist/cjs/Action/TreeArtifact.d.ts

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

package/dist/cjs/Action/TreeArtifact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeArtifact.d.ts","sourceRoot":"","sources":["../../../src/Action/TreeArtifact.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACnD,YAAY,EAAE,YAAY,IAAI,IAAI,EAAE,MAAM,sBAAsB,CAAA"}

package/dist/cjs/Action/TreeArtifact.js

@@ -0,0 +1,25 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TreeArtifact_exports = {};
+__export(TreeArtifact_exports, {
+  TreeArtifact: () => import_FileSet.TreeArtifact
+});
+module.exports = __toCommonJS(TreeArtifact_exports);
+var import_FileSet = require("@smthrs/plan/FileSet");
+//# sourceMappingURL=TreeArtifact.js.map

package/dist/cjs/Action/TreeArtifact.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Action/TreeArtifact.ts"],
+  "sourcesContent": ["/**\n * Directory outputs captured and replayed as tree artifacts.\n *\n * @since 0.1.0\n */\n\nexport { TreeArtifact } from \"@smthrs/plan/FileSet\"\nexport type { TreeArtifact as Type } from \"@smthrs/plan/FileSet\"\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAA6B;",
+  "names": []
+}

package/dist/cjs/Action/TypeId.d.ts

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

package/dist/cjs/Action/TypeId.d.ts.map

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