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

package/dist/esm/Action/CacheEnvironment.js

@@ -0,0 +1,130 @@
+// Deep reviewed and polished by a human on 2026-08-10.
+/**
+ * The environment description folded into every cross-run cache key.
+ *
+ * A cached result is only reusable on a host that would have produced the same
+ * bytes, so the key has to name the environment as well as the inputs — the
+ * platform, the toolchain, and the capability groups in force. Bazel's action
+ * key does the same thing for the same reason.
+ *
+ * It is a *complete* value on purpose: an environment a composition cannot
+ * fully describe is one whose cache hits cannot be justified, and the engine
+ * executes rather than guessing at the missing part.
+ *
+ * @since 0.1.0
+ */
+import * as PlanCachePolicy from "@smthrs/plan/CachePolicy";
+import * as Schema from "effect/Schema";
+/**
+ * Validates named capability groups.
+ *
+ * @private
+ * @since 0.1.0
+ */
+const Capabilities = Schema.Record(Schema.String, Schema.Array(Schema.NonEmptyString)).check(Schema.makeFilter((capabilities) => Object.keys(capabilities).every((name) => name.length > 0) || "Capability names must not be empty"));
+/**
+ * Schema for the complete runtime environment included in cache keys.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const CacheEnvironment = Schema.Struct({
+    /** Ordered semantic runtime layers, including versions and configuration. */
+    layers: Schema.Array(Schema.NonEmptyString),
+    /** Complete effective capability groups. */
+    capabilities: Capabilities
+});
+/**
+ * How far a recorded sealed result may travel.
+ *
+ * `shared` is the content-addressed default: the key names the inputs and the
+ * environment, so any run on any host that would have produced the same bytes
+ * may reuse the row. `run` and `flow` narrow that on purpose — a step whose
+ * result is only meaningful inside one execution, or inside one flow, folds
+ * that identity into its key so a sibling never reads it.
+ *
+ * This is `@smthrs/plan`'s `CachePolicy.CacheScope`, the one scope vocabulary
+ * `@smthrs/patterns` also declares its policy with.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export const CacheScope = PlanCachePolicy.CacheScope;
+/**
+ * The caller's declaration about the decay and the reach of a sealed action's
+ * recorded result.
+ *
+ * `ttlMs` bounds the age of a row the engine may serve: past it the dispatch
+ * executes again and journals `cache-expired`, so the refusal is durable
+ * evidence a replay reads rather than a fresh clock reading. `scope` decides
+ * what the key names besides the inputs.
+ *
+ * This is `@smthrs/plan`'s `CachePolicy.CachePolicy`, the one policy schema.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export const CachePolicy = PlanCachePolicy.CachePolicy;
+/**
+ * Annotation key carrying a declaration's {@link CachePolicy}.
+ *
+ * It is an annotation, not a field on the action, for the same reason
+ * placement and effects are: the policy is data that travels with the
+ * declaration and is read by whoever executes it, and adding it changes no
+ * existing call site.
+ *
+ * It is `@smthrs/plan`'s `CachePolicy.CachePolicyAnnotation` itself, the same
+ * object `@smthrs/patterns` annotates a flow with, identified by
+ * `"@smthrs/flow/Action/CachePolicy"`.
+ *
+ * @category annotations
+ * @since 0.1.0
+ */
+export const CachePolicyAnnotation = PlanCachePolicy.CachePolicyAnnotation;
+/**
+ * Reads the cache policy an annotation bag carries, or `undefined` when it
+ * carries none.
+ *
+ * @category getters
+ * @since 0.1.0
+ */
+export const cachePolicyOf = PlanCachePolicy.cachePolicyOf;
+/**
+ * Declares a cache policy on an action.
+ *
+ * This is the form the engine honors today: `@smthrs/engine-store` reads
+ * {@link CachePolicyAnnotation} off the dispatched action, bounds the age of
+ * the row it may serve by `ttlMs`, and narrows the address that row is stored
+ * under from `scope`. `@smthrs/patterns`' `WithCache` declares the same policy
+ * over a `@smthrs/core` flow under the same annotation key, for the
+ * declaration surface, so a policy written by either is read by the engine.
+ *
+ * The action is not mutated. `annotate` returns a new declaration carrying the
+ * policy, which is what a plan captures.
+ *
+ * It is `@smthrs/plan`'s `CachePolicy.annotate` under this package's name for
+ * it.
+ *
+ * @example
+ * ```ts
+ * import { Action } from "@smthrs/flow"
+ * import * as CacheEnvironment from "@smthrs/flow/CacheEnvironment"
+ * import * as Effect from "effect/Effect"
+ * import * as Schema from "effect/Schema"
+ *
+ * const compile = CacheEnvironment.withCache(
+ *   Action.make({
+ *     name: "build/compile",
+ *     success: Schema.String,
+ *     tier: "sealed",
+ *     execute: Effect.succeed("dist/server.js")
+ *   }),
+ *   { ttlMs: 60_000, scope: "shared" }
+ * )
+ * ```
+ *
+ * @category combinators
+ * @since 0.1.0
+ */
+export const withCache = PlanCachePolicy.annotate;
+//# sourceMappingURL=CacheEnvironment.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CacheEnvironment.js","sourceRoot":"","sources":["../../../src/Action/CacheEnvironment.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,eAAe,MAAM,0BAA0B,CAAA;AAC3D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;GAKG;AACH,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,KAAK,CAC1F,MAAM,CAAC,UAAU,CAAC,CAAC,YAAY,EAAE,EAAE,CACjC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,oCAAoC,CACnG,CACF,CAAA;AAaD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,CAAC;IAC5C,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,cAAc,CAAC;IAC3C,4CAA4C;IAC5C,YAAY,EAAE,YAAY;CAC3B,CAAC,CAAA;AAEF;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,eAAe,CAAC,UAAU,CAAA;AAUpD;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,eAAe,CAAC,WAAW,CAAA;AAWtD;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,eAAe,CAAC,qBAAqB,CAAA;AAE1E;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,eAAe,CAAC,aAAa,CAAA;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,eAAe,CAAC,QAAQ,CAAA","sourcesContent":["// Deep reviewed and polished by a human on 2026-08-10.\n\n/**\n * The environment description folded into every cross-run cache key.\n *\n * A cached result is only reusable on a host that would have produced the same\n * bytes, so the key has to name the environment as well as the inputs — the\n * platform, the toolchain, and the capability groups in force. Bazel's action\n * key does the same thing for the same reason.\n *\n * It is a *complete* value on purpose: an environment a composition cannot\n * fully describe is one whose cache hits cannot be justified, and the engine\n * executes rather than guessing at the missing part.\n *\n * @since 0.1.0\n */\n\nimport * as PlanCachePolicy from \"@smthrs/plan/CachePolicy\"\nimport * as Schema from \"effect/Schema\"\n\n/**\n * Validates named capability groups.\n *\n * @private\n * @since 0.1.0\n */\nconst Capabilities = Schema.Record(Schema.String, Schema.Array(Schema.NonEmptyString)).check(\n  Schema.makeFilter((capabilities) =>\n    Object.keys(capabilities).every((name) => name.length > 0) || \"Capability names must not be empty\"\n  )\n)\n\n/**\n * Complete runtime environment included in every cross-run cache key.\n *\n * If a composition cannot provide this complete value, the engine executes\n * normally but does not derive a cross-run cache key.\n *\n * @category models\n * @since 0.1.0\n */\nexport type CacheEnvironment = typeof CacheEnvironment.Type\n\n/**\n * Schema for the complete runtime environment included in cache keys.\n *\n * @category models\n * @since 0.1.0\n */\nexport const CacheEnvironment = Schema.Struct({\n  /** Ordered semantic runtime layers, including versions and configuration. */\n  layers: Schema.Array(Schema.NonEmptyString),\n  /** Complete effective capability groups. */\n  capabilities: Capabilities\n})\n\n/**\n * How far a recorded sealed result may travel.\n *\n * `shared` is the content-addressed default: the key names the inputs and the\n * environment, so any run on any host that would have produced the same bytes\n * may reuse the row. `run` and `flow` narrow that on purpose — a step whose\n * result is only meaningful inside one execution, or inside one flow, folds\n * that identity into its key so a sibling never reads it.\n *\n * This is `@smthrs/plan`'s `CachePolicy.CacheScope`, the one scope vocabulary\n * `@smthrs/patterns` also declares its policy with.\n *\n * @category models\n * @since 0.1.0\n */\nexport const CacheScope = PlanCachePolicy.CacheScope\n\n/**\n * How far a recorded sealed result may travel.\n *\n * @category models\n * @since 0.1.0\n */\nexport type CacheScope = PlanCachePolicy.CacheScope\n\n/**\n * The caller's declaration about the decay and the reach of a sealed action's\n * recorded result.\n *\n * `ttlMs` bounds the age of a row the engine may serve: past it the dispatch\n * executes again and journals `cache-expired`, so the refusal is durable\n * evidence a replay reads rather than a fresh clock reading. `scope` decides\n * what the key names besides the inputs.\n *\n * This is `@smthrs/plan`'s `CachePolicy.CachePolicy`, the one policy schema.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const CachePolicy = PlanCachePolicy.CachePolicy\n\n/**\n * The caller's declaration about the decay and the reach of a sealed action's\n * recorded result.\n *\n * @category models\n * @since 0.1.0\n */\nexport type CachePolicy = PlanCachePolicy.CachePolicy\n\n/**\n * Annotation key carrying a declaration's {@link CachePolicy}.\n *\n * It is an annotation, not a field on the action, for the same reason\n * placement and effects are: the policy is data that travels with the\n * declaration and is read by whoever executes it, and adding it changes no\n * existing call site.\n *\n * It is `@smthrs/plan`'s `CachePolicy.CachePolicyAnnotation` itself, the same\n * object `@smthrs/patterns` annotates a flow with, identified by\n * `\"@smthrs/flow/Action/CachePolicy\"`.\n *\n * @category annotations\n * @since 0.1.0\n */\nexport const CachePolicyAnnotation = PlanCachePolicy.CachePolicyAnnotation\n\n/**\n * Reads the cache policy an annotation bag carries, or `undefined` when it\n * carries none.\n *\n * @category getters\n * @since 0.1.0\n */\nexport const cachePolicyOf = PlanCachePolicy.cachePolicyOf\n\n/**\n * Declares a cache policy on an action.\n *\n * This is the form the engine honors today: `@smthrs/engine-store` reads\n * {@link CachePolicyAnnotation} off the dispatched action, bounds the age of\n * the row it may serve by `ttlMs`, and narrows the address that row is stored\n * under from `scope`. `@smthrs/patterns`' `WithCache` declares the same policy\n * over a `@smthrs/core` flow under the same annotation key, for the\n * declaration surface, so a policy written by either is read by the engine.\n *\n * The action is not mutated. `annotate` returns a new declaration carrying the\n * policy, which is what a plan captures.\n *\n * It is `@smthrs/plan`'s `CachePolicy.annotate` under this package's name for\n * it.\n *\n * @example\n * ```ts\n * import { Action } from \"@smthrs/flow\"\n * import * as CacheEnvironment from \"@smthrs/flow/CacheEnvironment\"\n * import * as Effect from \"effect/Effect\"\n * import * as Schema from \"effect/Schema\"\n *\n * const compile = CacheEnvironment.withCache(\n *   Action.make({\n *     name: \"build/compile\",\n *     success: Schema.String,\n *     tier: \"sealed\",\n *     execute: Effect.succeed(\"dist/server.js\")\n *   }),\n *   { ttlMs: 60_000, scope: \"shared\" }\n * )\n * ```\n *\n * @category combinators\n * @since 0.1.0\n */\nexport const withCache = PlanCachePolicy.annotate\n"]}

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

@@ -0,0 +1,34 @@
+/**
+ * Defines the `ConcurrentKeylessDispatch` 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 ConcurrentKeylessDispatch_base: Schema.Class<ConcurrentKeylessDispatch, Schema.TaggedStruct<"@smthrs/flow/ConcurrentKeylessDispatch", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"concurrent_keyless_dispatch">>;
+    readonly actionName: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Two ordinal-keyed invocations of one allocation scope were in flight
+ * concurrently, either keyless invocations of one declaration or same-key
+ * invocations at a non-sealed tier (issue #130), so their ordinals, and with
+ * them their step keys, attempt rows, and recorded outcomes, would be
+ * assigned by fiber arrival order. A crash-resume that replays the fibers in
+ * the opposite order would silently hand one invocation the other's recorded
+ * outcome (issue #111); Temporal fails such replays with a nondeterminism
+ * error, and the engine refuses the hazard up front instead of detecting it
+ * after the corruption. Declare an `idempotencyKey` *distinguishing* the
+ * invocations to dispatch them concurrently; a sealed action with a key
+ * takes a pure cache key and is exempt.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class ConcurrentKeylessDispatch extends ConcurrentKeylessDispatch_base {
+}
+export {};
+//# sourceMappingURL=ConcurrentKeylessDispatch.d.ts.map

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

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

package/dist/esm/Action/ConcurrentKeylessDispatch.js

@@ -0,0 +1,33 @@
+/**
+ * Defines the `ConcurrentKeylessDispatch` action failure.
+ *
+ * The `_tag` string was settled under `@smthrs/flow/` for 1.0.0-rc.0. The RC
+ * makes no compatibility promise to 0.x journals, and the tag freezes when
+ * the RC ships.
+ *
+ * @since 0.1.0
+ */
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+/**
+ * Two ordinal-keyed invocations of one allocation scope were in flight
+ * concurrently, either keyless invocations of one declaration or same-key
+ * invocations at a non-sealed tier (issue #130), so their ordinals, and with
+ * them their step keys, attempt rows, and recorded outcomes, would be
+ * assigned by fiber arrival order. A crash-resume that replays the fibers in
+ * the opposite order would silently hand one invocation the other's recorded
+ * outcome (issue #111); Temporal fails such replays with a nondeterminism
+ * error, and the engine refuses the hazard up front instead of detecting it
+ * after the corruption. Declare an `idempotencyKey` *distinguishing* the
+ * invocations to dispatch them concurrently; a sealed action with a key
+ * takes a pure cache key and is exempt.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export class ConcurrentKeylessDispatch extends Schema.TaggedError()("@smthrs/flow/ConcurrentKeylessDispatch", {
+    code: Schema.Literal("concurrent_keyless_dispatch").pipe(Schema.withConstructorDefault(Effect.succeed("concurrent_keyless_dispatch"))),
+    actionName: Schema.String
+}) {
+}
+//# sourceMappingURL=ConcurrentKeylessDispatch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ConcurrentKeylessDispatch.js","sourceRoot":"","sources":["../../../src/Action/ConcurrentKeylessDispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,yBAA0B,SAAQ,MAAM,CAAC,WAAW,EAA6B,CAC5F,wCAAwC,EACxC;IACE,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,6BAA6B,CAAC,CAAC,IAAI,CACtD,MAAM,CAAC,sBAAsB,CAAC,MAAM,CAAC,OAAO,CAAC,6BAA6B,CAAC,CAAC,CAC7E;IACD,UAAU,EAAE,MAAM,CAAC,MAAM;CAC1B,CACF;CAAG","sourcesContent":["/**\n * Defines the `ConcurrentKeylessDispatch` 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 * Two ordinal-keyed invocations of one allocation scope were in flight\n * concurrently, either keyless invocations of one declaration or same-key\n * invocations at a non-sealed tier (issue #130), so their ordinals, and with\n * them their step keys, attempt rows, and recorded outcomes, would be\n * assigned by fiber arrival order. A crash-resume that replays the fibers in\n * the opposite order would silently hand one invocation the other's recorded\n * outcome (issue #111); Temporal fails such replays with a nondeterminism\n * error, and the engine refuses the hazard up front instead of detecting it\n * after the corruption. Declare an `idempotencyKey` *distinguishing* the\n * invocations to dispatch them concurrently; a sealed action with a key\n * takes a pure cache key and is exempt.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class ConcurrentKeylessDispatch extends Schema.TaggedError<ConcurrentKeylessDispatch>()(\n  \"@smthrs/flow/ConcurrentKeylessDispatch\",\n  {\n    code: Schema.Literal(\"concurrent_keyless_dispatch\").pipe(\n      Schema.withConstructorDefault(Effect.succeed(\"concurrent_keyless_dispatch\"))\n    ),\n    actionName: Schema.String\n  }\n) {}\n"]}

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