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

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

@@ -0,0 +1,131 @@
+/**
+ * Defines runtime context carried across action attempts.
+ *
+ * @since 0.1.0
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type { CacheEnvironment } from "./CacheEnvironment.ts";
+/**
+ * Context reference carrying the complete environment folded into reusable
+ * action keys.
+ *
+ * A composition either provides a complete {@link CacheEnvironment} or leaves
+ * it absent. When absent, the engine scopes action keys to the current run
+ * instead of presenting incomplete environment data as reusable identity.
+ *
+ * @category idempotency
+ * @since 0.1.0
+ */
+export declare const CurrentCacheEnvironment: Context.Reference<{
+    readonly layers: readonly string[];
+    readonly capabilities: {
+        readonly [x: string]: readonly string[];
+    };
+} | undefined>;
+/**
+ * Declares the complete cache environment of a composition as a layer.
+ *
+ * **When to use**
+ *
+ * Use this only when the composition can identify every semantic runtime
+ * layer and its complete capability set. Otherwise leave the context absent.
+ *
+ * @category idempotency
+ * @since 0.1.0
+ */
+export declare const layerCacheEnvironment: (environment: CacheEnvironment) => Layer.Layer<never>;
+/**
+ * The ordinal slots a retry sequence shares across its attempts, keyed by
+ * allocation scope.
+ *
+ * `Action.retry` cannot allocate ordinals itself — allocation is scoped by
+ * action identity and only the engine knows which action is being
+ * dispatched (issue #73) — so it provides an empty map the engine fills per
+ * scope on the first attempt and reads back on every later one. The map is
+ * scope-keyed rather than a single value because one retry block may
+ * dispatch several distinct actions; a shared unkeyed slot handed the
+ * first action's ordinal to every later one, silently skipping their own
+ * name-scoped counters and aliasing a later independent dispatch onto an
+ * in-block key (issue #84).
+ *
+ * Each scope pins a *sequence* of ordinals rather than a single value
+ * (issue #100): one retry block may dispatch the same declaration several
+ * times, and a single-valued slot handed the first dispatch's ordinal to
+ * every later one, so the second dispatch silently replayed the first's
+ * recorded outcome. `cursors` counts the dispatches of each scope within the
+ * current attempt — `Action.retry` resets it at every attempt boundary —
+ * so the n-th same-scope dispatch of every attempt reuses the n-th pinned
+ * ordinal.
+ *
+ * @category attempts
+ * @since 0.1.0
+ */
+export interface OrdinalSlot {
+    readonly values: Map<string, Array<number>>;
+    readonly cursors: Map<string, number>;
+}
+/**
+ * Context reference carrying the ordinal slot of the enclosing
+ * `Action.retry` sequence, when present.
+ *
+ * @category attempts
+ * @since 0.1.0
+ */
+export declare const CurrentOrdinal: Context.Reference<OrdinalSlot | undefined>;
+/**
+ * Context reference containing the current action retry attempt, defaulting
+ * to `1`.
+ *
+ * @category attempts
+ * @since 0.1.0
+ */
+export declare const CurrentAttempt: Context.Reference<number>;
+/**
+ * Context reference carrying the persisted key of the dispatch an
+ * implementation is currently running under, when the runtime supplies one.
+ *
+ * **When to use**
+ *
+ * Use it in an action implementation that has to name durable state of its
+ * own — `Sleep` names a `DurableClock` — so the name it derives belongs to
+ * THIS dispatch. The key is the identity the engine already allocated for the
+ * dispatch: its attempt rows, its recorded outcome, and its cache row are
+ * addressed by it, so it is stable across every replay of one node and
+ * distinct between two identical calls of the same declaration. Deriving from
+ * it is therefore the only way an implementation gets both properties without
+ * allocating a second identity beside the engine's.
+ *
+ * **Gotchas**
+ *
+ * A runtime that has not adopted the seam leaves the reference absent rather
+ * than substituting a placeholder, because a placeholder would silently alias
+ * every dispatch of one declaration onto one name. An implementation that
+ * needs durable identity refuses instead.
+ *
+ * @category idempotency
+ * @since 0.1.0
+ */
+export declare const CurrentInvocationKey: Context.Reference<string | undefined>;
+/**
+ * Context reference carrying the heartbeat of the attempt currently running,
+ * which the runtime installs for an action declared with
+ * `heartbeatTimeoutMs`. Outside such an attempt it does nothing.
+ *
+ * @category attempts
+ * @since 1.0.0
+ */
+export declare const CurrentHeartbeat: Context.Reference<Effect.Effect<void, never, never>>;
+/**
+ * Reports that the running action attempt is still making progress.
+ *
+ * An action declared with `heartbeatTimeoutMs` fails its attempt with
+ * `AttemptTimedOut` when that long passes without a heartbeat; each call
+ * restarts the gap. In any other action it is a no-op.
+ *
+ * @category attempts
+ * @since 1.0.0
+ */
+export declare const heartbeat: Effect.Effect<void>;
+//# sourceMappingURL=Context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Context.d.ts","sourceRoot":"","sources":["../../../src/Action/Context.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAE7D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB;;;;;cAGnC,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,GAChC,aAAa,gBAAgB,KAC5B,KAAK,CAAC,KAAK,CAAC,KAAK,CAAwD,CAAA;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAA;IAC3C,QAAQ,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACtC;AAED;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,4CAG1B,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,2BAG1B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,oBAAoB,uCAGhC,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,sDAG5B,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAGxC,CAAA"}

package/dist/esm/Action/Context.js

@@ -0,0 +1,99 @@
+// Deep reviewed and polished by a human on 2026-08-10.
+/**
+ * Defines runtime context carried across action attempts.
+ *
+ * @since 0.1.0
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+/**
+ * Context reference carrying the complete environment folded into reusable
+ * action keys.
+ *
+ * A composition either provides a complete {@link CacheEnvironment} or leaves
+ * it absent. When absent, the engine scopes action keys to the current run
+ * instead of presenting incomplete environment data as reusable identity.
+ *
+ * @category idempotency
+ * @since 0.1.0
+ */
+export const CurrentCacheEnvironment = Context.Reference("@smthrs/flow/Action/CurrentCacheEnvironment", { defaultValue: () => undefined });
+/**
+ * Declares the complete cache environment of a composition as a layer.
+ *
+ * **When to use**
+ *
+ * Use this only when the composition can identify every semantic runtime
+ * layer and its complete capability set. Otherwise leave the context absent.
+ *
+ * @category idempotency
+ * @since 0.1.0
+ */
+export const layerCacheEnvironment = (environment) => Layer.succeed(CurrentCacheEnvironment)(environment);
+/**
+ * Context reference carrying the ordinal slot of the enclosing
+ * `Action.retry` sequence, when present.
+ *
+ * @category attempts
+ * @since 0.1.0
+ */
+export const CurrentOrdinal = Context.Reference("@smthrs/flow/Action/CurrentOrdinal", { defaultValue: () => undefined });
+/**
+ * Context reference containing the current action retry attempt, defaulting
+ * to `1`.
+ *
+ * @category attempts
+ * @since 0.1.0
+ */
+export const CurrentAttempt = Context.Reference("@smthrs/flow/Action/CurrentAttempt", { defaultValue: () => 1 });
+/**
+ * Context reference carrying the persisted key of the dispatch an
+ * implementation is currently running under, when the runtime supplies one.
+ *
+ * **When to use**
+ *
+ * Use it in an action implementation that has to name durable state of its
+ * own — `Sleep` names a `DurableClock` — so the name it derives belongs to
+ * THIS dispatch. The key is the identity the engine already allocated for the
+ * dispatch: its attempt rows, its recorded outcome, and its cache row are
+ * addressed by it, so it is stable across every replay of one node and
+ * distinct between two identical calls of the same declaration. Deriving from
+ * it is therefore the only way an implementation gets both properties without
+ * allocating a second identity beside the engine's.
+ *
+ * **Gotchas**
+ *
+ * A runtime that has not adopted the seam leaves the reference absent rather
+ * than substituting a placeholder, because a placeholder would silently alias
+ * every dispatch of one declaration onto one name. An implementation that
+ * needs durable identity refuses instead.
+ *
+ * @category idempotency
+ * @since 0.1.0
+ */
+export const CurrentInvocationKey = Context.Reference("@smthrs/flow/Action/CurrentInvocationKey", { defaultValue: () => undefined });
+/**
+ * Context reference carrying the heartbeat of the attempt currently running,
+ * which the runtime installs for an action declared with
+ * `heartbeatTimeoutMs`. Outside such an attempt it does nothing.
+ *
+ * @category attempts
+ * @since 1.0.0
+ */
+export const CurrentHeartbeat = Context.Reference("@smthrs/flow/Action/CurrentHeartbeat", { defaultValue: () => Effect.void });
+/**
+ * Reports that the running action attempt is still making progress.
+ *
+ * An action declared with `heartbeatTimeoutMs` fails its attempt with
+ * `AttemptTimedOut` when that long passes without a heartbeat; each call
+ * restarts the gap. In any other action it is a no-op.
+ *
+ * @category attempts
+ * @since 1.0.0
+ */
+export const heartbeat = Effect.gen(function* () {
+    const beat = yield* CurrentHeartbeat;
+    yield* beat;
+});
+//# sourceMappingURL=Context.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Context.js","sourceRoot":"","sources":["../../../src/Action/Context.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD;;;;GAIG;AAEH,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAGrC;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,OAAO,CAAC,SAAS,CACtD,6CAA6C,EAC7C,EAAE,YAAY,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE,CAClC,CAAA;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CACnC,WAA6B,EACT,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,uBAAuB,CAAC,CAAC,WAAW,CAAC,CAAA;AAiC5E;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,OAAO,CAAC,SAAS,CAC7C,oCAAoC,EACpC,EAAE,YAAY,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE,CAClC,CAAA;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,OAAO,CAAC,SAAS,CAC7C,oCAAoC,EACpC,EAAE,YAAY,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAC1B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,OAAO,CAAC,SAAS,CACnD,0CAA0C,EAC1C,EAAE,YAAY,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE,CAClC,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,OAAO,CAAC,SAAS,CAC/C,sCAAsC,EACtC,EAAE,YAAY,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,CACpC,CAAA;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,SAAS,GAAwB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAChE,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,gBAAgB,CAAA;IACpC,KAAK,CAAC,CAAC,IAAI,CAAA;AACb,CAAC,CAAC,CAAA","sourcesContent":["// Deep reviewed and polished by a human on 2026-08-10.\n\n/**\n * Defines runtime context carried across action attempts.\n *\n * @since 0.1.0\n */\n\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\nimport type { CacheEnvironment } from \"./CacheEnvironment.ts\"\n\n/**\n * Context reference carrying the complete environment folded into reusable\n * action keys.\n *\n * A composition either provides a complete {@link CacheEnvironment} or leaves\n * it absent. When absent, the engine scopes action keys to the current run\n * instead of presenting incomplete environment data as reusable identity.\n *\n * @category idempotency\n * @since 0.1.0\n */\nexport const CurrentCacheEnvironment = Context.Reference<CacheEnvironment | undefined>(\n  \"@smthrs/flow/Action/CurrentCacheEnvironment\",\n  { defaultValue: () => undefined }\n)\n\n/**\n * Declares the complete cache environment of a composition as a layer.\n *\n * **When to use**\n *\n * Use this only when the composition can identify every semantic runtime\n * layer and its complete capability set. Otherwise leave the context absent.\n *\n * @category idempotency\n * @since 0.1.0\n */\nexport const layerCacheEnvironment = (\n  environment: CacheEnvironment\n): Layer.Layer<never> => Layer.succeed(CurrentCacheEnvironment)(environment)\n\n/**\n * The ordinal slots a retry sequence shares across its attempts, keyed by\n * allocation scope.\n *\n * `Action.retry` cannot allocate ordinals itself — allocation is scoped by\n * action identity and only the engine knows which action is being\n * dispatched (issue #73) — so it provides an empty map the engine fills per\n * scope on the first attempt and reads back on every later one. The map is\n * scope-keyed rather than a single value because one retry block may\n * dispatch several distinct actions; a shared unkeyed slot handed the\n * first action's ordinal to every later one, silently skipping their own\n * name-scoped counters and aliasing a later independent dispatch onto an\n * in-block key (issue #84).\n *\n * Each scope pins a *sequence* of ordinals rather than a single value\n * (issue #100): one retry block may dispatch the same declaration several\n * times, and a single-valued slot handed the first dispatch's ordinal to\n * every later one, so the second dispatch silently replayed the first's\n * recorded outcome. `cursors` counts the dispatches of each scope within the\n * current attempt — `Action.retry` resets it at every attempt boundary —\n * so the n-th same-scope dispatch of every attempt reuses the n-th pinned\n * ordinal.\n *\n * @category attempts\n * @since 0.1.0\n */\nexport interface OrdinalSlot {\n  readonly values: Map<string, Array<number>>\n  readonly cursors: Map<string, number>\n}\n\n/**\n * Context reference carrying the ordinal slot of the enclosing\n * `Action.retry` sequence, when present.\n *\n * @category attempts\n * @since 0.1.0\n */\nexport const CurrentOrdinal = Context.Reference<OrdinalSlot | undefined>(\n  \"@smthrs/flow/Action/CurrentOrdinal\",\n  { defaultValue: () => undefined }\n)\n\n/**\n * Context reference containing the current action retry attempt, defaulting\n * to `1`.\n *\n * @category attempts\n * @since 0.1.0\n */\nexport const CurrentAttempt = Context.Reference<number>(\n  \"@smthrs/flow/Action/CurrentAttempt\",\n  { defaultValue: () => 1 }\n)\n\n/**\n * Context reference carrying the persisted key of the dispatch an\n * implementation is currently running under, when the runtime supplies one.\n *\n * **When to use**\n *\n * Use it in an action implementation that has to name durable state of its\n * own — `Sleep` names a `DurableClock` — so the name it derives belongs to\n * THIS dispatch. The key is the identity the engine already allocated for the\n * dispatch: its attempt rows, its recorded outcome, and its cache row are\n * addressed by it, so it is stable across every replay of one node and\n * distinct between two identical calls of the same declaration. Deriving from\n * it is therefore the only way an implementation gets both properties without\n * allocating a second identity beside the engine's.\n *\n * **Gotchas**\n *\n * A runtime that has not adopted the seam leaves the reference absent rather\n * than substituting a placeholder, because a placeholder would silently alias\n * every dispatch of one declaration onto one name. An implementation that\n * needs durable identity refuses instead.\n *\n * @category idempotency\n * @since 0.1.0\n */\nexport const CurrentInvocationKey = Context.Reference<string | undefined>(\n  \"@smthrs/flow/Action/CurrentInvocationKey\",\n  { defaultValue: () => undefined }\n)\n\n/**\n * Context reference carrying the heartbeat of the attempt currently running,\n * which the runtime installs for an action declared with\n * `heartbeatTimeoutMs`. Outside such an attempt it does nothing.\n *\n * @category attempts\n * @since 1.0.0\n */\nexport const CurrentHeartbeat = Context.Reference<Effect.Effect<void>>(\n  \"@smthrs/flow/Action/CurrentHeartbeat\",\n  { defaultValue: () => Effect.void }\n)\n\n/**\n * Reports that the running action attempt is still making progress.\n *\n * An action declared with `heartbeatTimeoutMs` fails its attempt with\n * `AttemptTimedOut` when that long passes without a heartbeat; each call\n * restarts the gap. In any other action it is a no-op.\n *\n * @category attempts\n * @since 1.0.0\n */\nexport const heartbeat: Effect.Effect<void> = Effect.gen(function*() {\n  const beat = yield* CurrentHeartbeat\n  yield* beat\n})\n"]}

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

@@ -0,0 +1,20 @@
+/**
+ * Defines the `DuplicateImplementation` action failure.
+ *
+ * @since 0.1.0
+ */
+import * as Schema from "effect/Schema";
+declare const DuplicateImplementation_base: Schema.Class<DuplicateImplementation, Schema.TaggedStruct<"@smthrs/flow/Action/DuplicateImplementation", {
+    readonly name: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Two implementations competed for one action tag without an explicit override.
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class DuplicateImplementation extends DuplicateImplementation_base {
+    /** @since 1.0.0 */
+    get message(): string;
+}
+export {};
+//# sourceMappingURL=DuplicateImplementation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DuplicateImplementation.d.ts","sourceRoot":"","sources":["../../../src/Action/DuplicateImplementation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;;;;AAEvC;;;;GAIG;AACH,qBAAa,uBAAwB,SAAQ,4BAG5C;IAGC,mBAAmB;IACnB,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF"}

package/dist/esm/Action/DuplicateImplementation.js

@@ -0,0 +1,20 @@
+/**
+ * Defines the `DuplicateImplementation` action failure.
+ *
+ * @since 0.1.0
+ */
+import * as Schema from "effect/Schema";
+/**
+ * Two implementations competed for one action tag without an explicit override.
+ * @category errors
+ * @since 0.1.0
+ */
+export class DuplicateImplementation extends Schema.TaggedError()("@smthrs/flow/Action/DuplicateImplementation", { name: Schema.String }) {
+    // The `name` field shadows `Error.name`, so without a message a recorded
+    // defect reads only as the bare action tag.
+    /** @since 1.0.0 */
+    get message() {
+        return `Action "${this.name}" already has an implementation in this registry; provide its layer once, or pass override: true to replace it`;
+    }
+}
+//# sourceMappingURL=DuplicateImplementation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DuplicateImplementation.js","sourceRoot":"","sources":["../../../src/Action/DuplicateImplementation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;GAIG;AACH,MAAM,OAAO,uBAAwB,SAAQ,MAAM,CAAC,WAAW,EAA2B,CACxF,6CAA6C,EAC7C,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,CACxB;IACC,yEAAyE;IACzE,4CAA4C;IAC5C,mBAAmB;IACnB,IAAa,OAAO;QAClB,OAAO,WAAW,IAAI,CAAC,IAAI,gHAAgH,CAAA;IAC7I,CAAC;CACF","sourcesContent":["/**\n * Defines the `DuplicateImplementation` action failure.\n *\n * @since 0.1.0\n */\n\nimport * as Schema from \"effect/Schema\"\n\n/**\n * Two implementations competed for one action tag without an explicit override.\n * @category errors\n * @since 0.1.0\n */\nexport class DuplicateImplementation extends Schema.TaggedError<DuplicateImplementation>()(\n  \"@smthrs/flow/Action/DuplicateImplementation\",\n  { name: Schema.String }\n) {\n  // The `name` field shadows `Error.name`, so without a message a recorded\n  // defect reads only as the bare action tag.\n  /** @since 1.0.0 */\n  override get message(): string {\n    return `Action \"${this.name}\" already has an implementation in this registry; provide its layer once, or pass override: true to replace it`\n  }\n}\n"]}

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

@@ -0,0 +1,59 @@
+import * as Schema from "effect/Schema";
+/**
+ * Schema for the filesystem boundary of an action.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const FileBoundary: Schema.Struct<{
+    /**
+     * Exact files already measured, or globs to expand while preparing.
+     *
+     * Workspace-relative in both forms: a measured {@link FileInput} path is
+     * checked like every pattern, because the engine measures reads inside the
+     * workspace sandbox and would refuse an absolute or upward path only at
+     * prepare time.
+     */
+    readonly readSet: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly path: Schema.NonEmptyString;
+        readonly digest: Schema.NonEmptyString;
+    }>, Schema.TaggedStruct<"Glob", {
+        readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+        readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    }>]>>;
+    /** Files or patterns the action is allowed to write. */
+    readonly writeSet: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+        readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+        readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    }>, Schema.TaggedStruct<"TreeArtifact", {
+        readonly path: Schema.NonEmptyString;
+    }>]>>;
+    /**
+     * Files the action is allowed to DELETE.
+     *
+     * A declared write that is absent when the action finishes is a defect —
+     * Bazel's `SkyframeActionExecutor.checkOutputs` reports "output was not
+     * created" and fails the action — because recording the absence as valid
+     * evidence caches the claim "this file should not exist", which a later
+     * replay then acts on by deleting the path. Deletion stays a feature here,
+     * but only when it was declared, and a declared removal is what makes an
+     * absent path legitimate rather than a crash mid-execution.
+     *
+     * Optional with an empty default, so boundaries persisted before it keep
+     * decoding. Disjoint from {@link writeSet}: a path cannot be both promised
+     * and disclaimed. Workspace-relative like every other declared path —
+     * replay acts on a removal by deleting it, so an absolute or upward
+     * spelling would hand evidence an eraser aimed outside the workspace.
+     */
+    readonly removes: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    /** Whether undeclared access is rejected immediately or validated later. */
+    readonly boundaryMode: Schema.Literals<readonly ["hard", "expected"]>;
+}>;
+/**
+ * The filesystem boundary of an action.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type FileBoundary = typeof FileBoundary.Type;
+//# sourceMappingURL=FileBoundary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileBoundary.d.ts","sourceRoot":"","sources":["../../../src/Action/FileBoundary.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAIvC;;;;;GAKG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;;OAOG;;;;;;;;IAEH,wDAAwD;;;;;;;IAExD;;;;;;;;;;;;;;;;OAgBG;;IAEH,4EAA4E;;EAa7E,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA"}

package/dist/esm/Action/FileBoundary.js

@@ -0,0 +1,60 @@
+// Deep reviewed and polished by a human on 2026-08-10.
+/**
+ * An action's declaration of which files it reads and which it may write.
+ *
+ * The declaration is what makes a step hermetic enough to cache: the read set
+ * is the dependency edge set folded into the step key, and the write set is
+ * what the host measures the execution against afterwards. `boundaryMode`
+ * decides what happens when the two disagree — a hard boundary refuses the
+ * result, an expected one records the deviation and carries on.
+ *
+ * @since 0.1.0
+ */
+import * as FileSet from "@smthrs/plan/FileSet";
+import * as Schema from "effect/Schema";
+import { BoundaryMode } from "./BoundaryMode.js";
+import { FileInput } from "./FileInput.js";
+/**
+ * Schema for the filesystem boundary of an action.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const FileBoundary = Schema.Struct({
+    /**
+     * Exact files already measured, or globs to expand while preparing.
+     *
+     * Workspace-relative in both forms: a measured {@link FileInput} path is
+     * checked like every pattern, because the engine measures reads inside the
+     * workspace sandbox and would refuse an absolute or upward path only at
+     * prepare time.
+     */
+    readSet: Schema.Array(Schema.Union([FileInput, FileSet.Glob])),
+    /** Files or patterns the action is allowed to write. */
+    writeSet: Schema.Array(FileSet.Entry),
+    /**
+     * Files the action is allowed to DELETE.
+     *
+     * A declared write that is absent when the action finishes is a defect —
+     * Bazel's `SkyframeActionExecutor.checkOutputs` reports "output was not
+     * created" and fails the action — because recording the absence as valid
+     * evidence caches the claim "this file should not exist", which a later
+     * replay then acts on by deleting the path. Deletion stays a feature here,
+     * but only when it was declared, and a declared removal is what makes an
+     * absent path legitimate rather than a crash mid-execution.
+     *
+     * Optional with an empty default, so boundaries persisted before it keep
+     * decoding. Disjoint from {@link writeSet}: a path cannot be both promised
+     * and disclaimed. Workspace-relative like every other declared path —
+     * replay acts on a removal by deleting it, so an absolute or upward
+     * spelling would hand evidence an eraser aimed outside the workspace.
+     */
+    removes: Schema.optional(Schema.Array(FileSet.Pattern)),
+    /** Whether undeclared access is rejected immediately or validated later. */
+    boundaryMode: BoundaryMode
+}).check(Schema.makeFilter((boundary) => {
+    const both = (boundary.removes ?? []).filter((path) => boundary.writeSet.some((entry) => FileSet.overlaps(entry, path)));
+    return both.length === 0 ||
+        `a path cannot be both written and removed: ${both.join(", ")}`;
+}, { title: "disjointWritesAndRemoves" }));
+//# sourceMappingURL=FileBoundary.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileBoundary.js","sourceRoot":"","sources":["../../../src/Action/FileBoundary.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,OAAO,MAAM,sBAAsB,CAAA;AAC/C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC;IACxC;;;;;;;OAOG;IACH,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;IAC9D,wDAAwD;IACxD,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;IACrC;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IACvD,4EAA4E;IAC5E,YAAY,EAAE,YAAY;CAC3B,CAAC,CAAC,KAAK,CACN,MAAM,CAAC,UAAU,CACf,CAAC,QAAQ,EAAE,EAAE;IACX,MAAM,IAAI,GAAG,CAAC,QAAQ,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CACpD,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CACjE,CAAA;IACD,OAAO,IAAI,CAAC,MAAM,KAAK,CAAC;QACtB,8CAA8C,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAA;AACnE,CAAC,EACD,EAAE,KAAK,EAAE,0BAA0B,EAAE,CACtC,CACF,CAAA","sourcesContent":["// Deep reviewed and polished by a human on 2026-08-10.\n\n/**\n * An action's declaration of which files it reads and which it may write.\n *\n * The declaration is what makes a step hermetic enough to cache: the read set\n * is the dependency edge set folded into the step key, and the write set is\n * what the host measures the execution against afterwards. `boundaryMode`\n * decides what happens when the two disagree — a hard boundary refuses the\n * result, an expected one records the deviation and carries on.\n *\n * @since 0.1.0\n */\n\nimport * as FileSet from \"@smthrs/plan/FileSet\"\nimport * as Schema from \"effect/Schema\"\nimport { BoundaryMode } from \"./BoundaryMode.ts\"\nimport { FileInput } from \"./FileInput.ts\"\n\n/**\n * Schema for the filesystem boundary of an action.\n *\n * @category models\n * @since 0.1.0\n */\nexport const FileBoundary = Schema.Struct({\n  /**\n   * Exact files already measured, or globs to expand while preparing.\n   *\n   * Workspace-relative in both forms: a measured {@link FileInput} path is\n   * checked like every pattern, because the engine measures reads inside the\n   * workspace sandbox and would refuse an absolute or upward path only at\n   * prepare time.\n   */\n  readSet: Schema.Array(Schema.Union([FileInput, FileSet.Glob])),\n  /** Files or patterns the action is allowed to write. */\n  writeSet: Schema.Array(FileSet.Entry),\n  /**\n   * Files the action is allowed to DELETE.\n   *\n   * A declared write that is absent when the action finishes is a defect —\n   * Bazel's `SkyframeActionExecutor.checkOutputs` reports \"output was not\n   * created\" and fails the action — because recording the absence as valid\n   * evidence caches the claim \"this file should not exist\", which a later\n   * replay then acts on by deleting the path. Deletion stays a feature here,\n   * but only when it was declared, and a declared removal is what makes an\n   * absent path legitimate rather than a crash mid-execution.\n   *\n   * Optional with an empty default, so boundaries persisted before it keep\n   * decoding. Disjoint from {@link writeSet}: a path cannot be both promised\n   * and disclaimed. Workspace-relative like every other declared path —\n   * replay acts on a removal by deleting it, so an absolute or upward\n   * spelling would hand evidence an eraser aimed outside the workspace.\n   */\n  removes: Schema.optional(Schema.Array(FileSet.Pattern)),\n  /** Whether undeclared access is rejected immediately or validated later. */\n  boundaryMode: BoundaryMode\n}).check(\n  Schema.makeFilter(\n    (boundary) => {\n      const both = (boundary.removes ?? []).filter((path) =>\n        boundary.writeSet.some((entry) => FileSet.overlaps(entry, path))\n      )\n      return both.length === 0 ||\n        `a path cannot be both written and removed: ${both.join(\", \")}`\n    },\n    { title: \"disjointWritesAndRemoves\" }\n  )\n)\n\n/**\n * The filesystem boundary of an action.\n *\n * @category models\n * @since 0.1.0\n */\nexport type FileBoundary = typeof FileBoundary.Type\n"]}

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

@@ -0,0 +1,28 @@
+import * as Schema from "effect/Schema";
+/**
+ * Schema for an input file path paired with its measured content digest.
+ *
+ * The path is workspace-relative like every other declared path in a
+ * {@link FileBoundary}: the engine measures reads through the workspace
+ * sandbox, which refuses absolute and upward spellings, so a boundary that
+ * admitted them here would only be refused later, at prepare or replay.
+ * Checking here keeps the boundary this package admits the boundary the
+ * engine accepts.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const FileInput: Schema.Struct<{
+    /** Workspace-relative path of the input file. */
+    readonly path: Schema.NonEmptyString;
+    /** Non-empty digest observed for the file contents. */
+    readonly digest: Schema.NonEmptyString;
+}>;
+/**
+ * An input file path paired with its measured content digest.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type FileInput = typeof FileInput.Type;
+//# sourceMappingURL=FileInput.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileInput.d.ts","sourceRoot":"","sources":["../../../src/Action/FileInput.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS;IACpB,iDAAiD;;IAEjD,uDAAuD;;EAEvD,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA"}

package/dist/esm/Action/FileInput.js

@@ -0,0 +1,32 @@
+// Deep reviewed and polished by a human on 2026-08-10.
+/**
+ * A file path paired with the digest measured for its contents.
+ *
+ * Paths alone cannot key a step — the same path holds different bytes on
+ * different days — so every declared read carries the digest observed for it,
+ * and a later run compares digests rather than mtimes.
+ *
+ * @since 0.1.0
+ */
+import * as FileSet from "@smthrs/plan/FileSet";
+import * as Schema from "effect/Schema";
+/**
+ * Schema for an input file path paired with its measured content digest.
+ *
+ * The path is workspace-relative like every other declared path in a
+ * {@link FileBoundary}: the engine measures reads through the workspace
+ * sandbox, which refuses absolute and upward spellings, so a boundary that
+ * admitted them here would only be refused later, at prepare or replay.
+ * Checking here keeps the boundary this package admits the boundary the
+ * engine accepts.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const FileInput = Schema.Struct({
+    /** Workspace-relative path of the input file. */
+    path: FileSet.Pattern,
+    /** Non-empty digest observed for the file contents. */
+    digest: Schema.NonEmptyString
+});
+//# sourceMappingURL=FileInput.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileInput.js","sourceRoot":"","sources":["../../../src/Action/FileInput.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD;;;;;;;;GAQG;AAEH,OAAO,KAAK,OAAO,MAAM,sBAAsB,CAAA;AAC/C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC;IACrC,iDAAiD;IACjD,IAAI,EAAE,OAAO,CAAC,OAAO;IACrB,uDAAuD;IACvD,MAAM,EAAE,MAAM,CAAC,cAAc;CAC9B,CAAC,CAAA","sourcesContent":["// Deep reviewed and polished by a human on 2026-08-10.\n\n/**\n * A file path paired with the digest measured for its contents.\n *\n * Paths alone cannot key a step — the same path holds different bytes on\n * different days — so every declared read carries the digest observed for it,\n * and a later run compares digests rather than mtimes.\n *\n * @since 0.1.0\n */\n\nimport * as FileSet from \"@smthrs/plan/FileSet\"\nimport * as Schema from \"effect/Schema\"\n\n/**\n * Schema for an input file path paired with its measured content digest.\n *\n * The path is workspace-relative like every other declared path in a\n * {@link FileBoundary}: the engine measures reads through the workspace\n * sandbox, which refuses absolute and upward spellings, so a boundary that\n * admitted them here would only be refused later, at prepare or replay.\n * Checking here keeps the boundary this package admits the boundary the\n * engine accepts.\n *\n * @category models\n * @since 0.1.0\n */\nexport const FileInput = Schema.Struct({\n  /** Workspace-relative path of the input file. */\n  path: FileSet.Pattern,\n  /** Non-empty digest observed for the file contents. */\n  digest: Schema.NonEmptyString\n})\n\n/**\n * An input file path paired with its measured content digest.\n *\n * @category models\n * @since 0.1.0\n */\nexport type FileInput = typeof FileInput.Type\n"]}

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

@@ -0,0 +1,16 @@
+/**
+ * Named reusable filesystem declaration groups.
+ *
+ * @since 0.1.0
+ */
+import { Filegroup } from "@smthrs/plan/FileSet";
+export { Filegroup };
+export type { Filegroup as Type } from "@smthrs/plan/FileSet";
+/**
+ * Creates a named filegroup.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: (name: string, entries: ReadonlyArray<import("@smthrs/plan/FileSet").Entry>) => Filegroup;
+//# sourceMappingURL=Filegroup.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Filegroup.d.ts","sourceRoot":"","sources":["../../../src/Action/Filegroup.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAiB,MAAM,sBAAsB,CAAA;AAC/D,OAAO,EAAE,SAAS,EAAE,CAAA;AACpB,YAAY,EAAE,SAAS,IAAI,IAAI,EAAE,MAAM,sBAAsB,CAAA;AAC7D;;;;;GAKG;AACH,eAAO,MAAM,IAAI,2FAAgB,CAAA"}

package/dist/esm/Action/Filegroup.js

@@ -0,0 +1,15 @@
+/**
+ * Named reusable filesystem declaration groups.
+ *
+ * @since 0.1.0
+ */
+import { Filegroup, makeFilegroup } from "@smthrs/plan/FileSet";
+export { Filegroup };
+/**
+ * Creates a named filegroup.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export const make = makeFilegroup;
+//# sourceMappingURL=Filegroup.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Filegroup.js","sourceRoot":"","sources":["../../../src/Action/Filegroup.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAC/D,OAAO,EAAE,SAAS,EAAE,CAAA;AAEpB;;;;;GAKG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,aAAa,CAAA","sourcesContent":["/**\n * Named reusable filesystem declaration groups.\n *\n * @since 0.1.0\n */\n\nimport { Filegroup, makeFilegroup } from \"@smthrs/plan/FileSet\"\nexport { Filegroup }\nexport type { Filegroup as Type } from \"@smthrs/plan/FileSet\"\n/**\n * Creates a named filegroup.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = makeFilegroup\n"]}

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

@@ -0,0 +1,8 @@
+/**
+ * Bazel-style workspace-relative file glob declarations.
+ *
+ * @since 0.1.0
+ */
+export { Glob, matchesGlob, matchesPattern, Pattern } from "@smthrs/plan/FileSet";
+export type { Glob as Type } from "@smthrs/plan/FileSet";
+//# sourceMappingURL=Glob.d.ts.map

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

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

package/dist/esm/Action/Glob.js

@@ -0,0 +1,7 @@
+/**
+ * Bazel-style workspace-relative file glob declarations.
+ *
+ * @since 0.1.0
+ */
+export { Glob, matchesGlob, matchesPattern, Pattern } from "@smthrs/plan/FileSet";
+//# sourceMappingURL=Glob.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Glob.js","sourceRoot":"","sources":["../../../src/Action/Glob.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA","sourcesContent":["/**\n * Bazel-style workspace-relative file glob declarations.\n *\n * @since 0.1.0\n */\n\nexport { Glob, matchesGlob, matchesPattern, Pattern } from \"@smthrs/plan/FileSet\"\nexport type { Glob as Type } from \"@smthrs/plan/FileSet\"\n"]}

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

@@ -0,0 +1,26 @@
+/**
+ * Defines the `ImplementationVersionMismatch` 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 ImplementationVersionMismatch_base: Schema.Class<ImplementationVersionMismatch, Schema.TaggedStruct<"@smthrs/flow/ImplementationVersionMismatch", {
+    readonly actionName: Schema.String;
+    readonly declaredVersion: Schema.NullOr<Schema.String>;
+    readonly registeredVersion: Schema.NullOr<Schema.String>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A handler registration does not attest the declaration's implementation version.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class ImplementationVersionMismatch extends ImplementationVersionMismatch_base {
+}
+export {};
+//# sourceMappingURL=ImplementationVersionMismatch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ImplementationVersionMismatch.d.ts","sourceRoot":"","sources":["../../../src/Action/ImplementationVersionMismatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;;;;;;;AAEvC;;;;;GAKG;AACH,qBAAa,6BAA8B,SAAQ,kCAQlD;CAAG"}

package/dist/esm/Action/ImplementationVersionMismatch.js

@@ -0,0 +1,24 @@
+/**
+ * Defines the `ImplementationVersionMismatch` 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";
+/**
+ * A handler registration does not attest the declaration's implementation version.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export class ImplementationVersionMismatch extends Schema.TaggedError()("@smthrs/flow/ImplementationVersionMismatch", {
+    actionName: Schema.String,
+    declaredVersion: Schema.NullOr(Schema.String),
+    registeredVersion: Schema.NullOr(Schema.String),
+    message: Schema.String
+}) {
+}
+//# sourceMappingURL=ImplementationVersionMismatch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ImplementationVersionMismatch.js","sourceRoot":"","sources":["../../../src/Action/ImplementationVersionMismatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;GAKG;AACH,MAAM,OAAO,6BAA8B,SAAQ,MAAM,CAAC,WAAW,EAAiC,CACpG,4CAA4C,EAC5C;IACE,UAAU,EAAE,MAAM,CAAC,MAAM;IACzB,eAAe,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;IAC7C,iBAAiB,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;IAC/C,OAAO,EAAE,MAAM,CAAC,MAAM;CACvB,CACF;CAAG","sourcesContent":["/**\n * Defines the `ImplementationVersionMismatch` 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 Schema from \"effect/Schema\"\n\n/**\n * A handler registration does not attest the declaration's implementation version.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class ImplementationVersionMismatch extends Schema.TaggedError<ImplementationVersionMismatch>()(\n  \"@smthrs/flow/ImplementationVersionMismatch\",\n  {\n    actionName: Schema.String,\n    declaredVersion: Schema.NullOr(Schema.String),\n    registeredVersion: Schema.NullOr(Schema.String),\n    message: Schema.String\n  }\n) {}\n"]}