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

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

@@ -0,0 +1,81 @@
+"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 FileBoundary_exports = {};
+__export(FileBoundary_exports, {
+  FileBoundary: () => FileBoundary
+});
+module.exports = __toCommonJS(FileBoundary_exports);
+var FileSet = __toESM(require("@smthrs/plan/FileSet"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var import_BoundaryMode = require("./BoundaryMode.js");
+var import_FileInput = require("./FileInput.js");
+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([import_FileInput.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: import_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/cjs/Action/FileBoundary.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Action/FileBoundary.ts"],
+  "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 \u2014 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 \u2014\n   * Bazel's `SkyframeActionExecutor.checkOutputs` reports \"output was not\n   * created\" and fails the action \u2014 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 \u2014\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"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAcA,cAAyB;AACzB,aAAwB;AACxB,0BAA6B;AAC7B,uBAA0B;AAQnB,MAAM,eAAe,OAAO,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASxC,SAAS,OAAO,MAAM,OAAO,MAAM,CAAC,4BAAW,QAAQ,IAAI,CAAC,CAAC;AAAA;AAAA,EAE7D,UAAU,OAAO,MAAM,QAAQ,KAAK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBpC,SAAS,OAAO,SAAS,OAAO,MAAM,QAAQ,OAAO,CAAC;AAAA;AAAA,EAEtD,cAAc;AAChB,CAAC,EAAE;AAAA,EACD,OAAO;AAAA,IACL,CAAC,aAAa;AACZ,YAAM,QAAQ,SAAS,WAAW,CAAC,GAAG;AAAA,QAAO,CAAC,SAC5C,SAAS,SAAS,KAAK,CAAC,UAAU,QAAQ,SAAS,OAAO,IAAI,CAAC;AAAA,MACjE;AACA,aAAO,KAAK,WAAW,KACrB,8CAA8C,KAAK,KAAK,IAAI,CAAC;AAAA,IACjE;AAAA,IACA,EAAE,OAAO,2BAA2B;AAAA,EACtC;AACF;",
+  "names": []
+}

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

@@ -0,0 +1,42 @@
+"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 FileInput_exports = {};
+__export(FileInput_exports, {
+  FileInput: () => FileInput
+});
+module.exports = __toCommonJS(FileInput_exports);
+var FileSet = __toESM(require("@smthrs/plan/FileSet"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+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/cjs/Action/FileInput.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Action/FileInput.ts"],
+  "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 \u2014 the same path holds different bytes on\n * different days \u2014 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"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,cAAyB;AACzB,aAAwB;AAejB,MAAM,YAAY,OAAO,OAAO;AAAA;AAAA,EAErC,MAAM,QAAQ;AAAA;AAAA,EAEd,QAAQ,OAAO;AACjB,CAAC;",
+  "names": []
+}

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

@@ -0,0 +1,27 @@
+"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 Filegroup_exports = {};
+__export(Filegroup_exports, {
+  Filegroup: () => import_FileSet.Filegroup,
+  make: () => make
+});
+module.exports = __toCommonJS(Filegroup_exports);
+var import_FileSet = require("@smthrs/plan/FileSet");
+const make = import_FileSet.makeFilegroup;
+//# sourceMappingURL=Filegroup.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Action/Filegroup.ts"],
+  "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"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAAyC;AASlC,MAAM,OAAO;",
+  "names": []
+}

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

@@ -0,0 +1,28 @@
+"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 Glob_exports = {};
+__export(Glob_exports, {
+  Glob: () => import_FileSet.Glob,
+  Pattern: () => import_FileSet.Pattern,
+  matchesGlob: () => import_FileSet.matchesGlob,
+  matchesPattern: () => import_FileSet.matchesPattern
+});
+module.exports = __toCommonJS(Glob_exports);
+var import_FileSet = require("@smthrs/plan/FileSet");
+//# sourceMappingURL=Glob.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Action/Glob.ts"],
+  "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"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,qBAA2D;",
+  "names": []
+}

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

@@ -0,0 +1,45 @@
+"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 ImplementationVersionMismatch_exports = {};
+__export(ImplementationVersionMismatch_exports, {
+  ImplementationVersionMismatch: () => ImplementationVersionMismatch
+});
+module.exports = __toCommonJS(ImplementationVersionMismatch_exports);
+var Schema = __toESM(require("effect/Schema"), 1);
+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/cjs/Action/ImplementationVersionMismatch.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Action/ImplementationVersionMismatch.ts"],
+  "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"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,aAAwB;AAQjB,MAAM,sCAAsC,OAAO,YAA2C;AAAA,EACnG;AAAA,EACA;AAAA,IACE,YAAY,OAAO;AAAA,IACnB,iBAAiB,OAAO,OAAO,OAAO,MAAM;AAAA,IAC5C,mBAAmB,OAAO,OAAO,OAAO,MAAM;AAAA,IAC9C,SAAS,OAAO;AAAA,EAClB;AACF,EAAE;AAAC;",
+  "names": []
+}

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

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

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

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

package/dist/cjs/Action/Implementations.js

@@ -0,0 +1,65 @@
+"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 Implementations_exports = {};
+__export(Implementations_exports, {
+  Implementations: () => Implementations,
+  layerImplementations: () => layerImplementations
+});
+module.exports = __toCommonJS(Implementations_exports);
+var Context = __toESM(require("effect/Context"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var import_DuplicateImplementation = require("./DuplicateImplementation.js");
+class Implementations extends Context.Service()("@smthrs/flow/Action/Implementations") {
+}
+const layerImplementations = Layer.effect(Implementations)(
+  Effect.sync(() => {
+    const registered = /* @__PURE__ */ new Map();
+    return Implementations.of({
+      add: (implementation, options) => Effect.suspend(() => {
+        const entries = registered.get(implementation.name) ?? [];
+        if (entries.length > 0 && options?.override !== true && entries.at(-1)?.implementation !== implementation) {
+          return Effect.die(new import_DuplicateImplementation.DuplicateImplementation({ name: implementation.name }));
+        }
+        const entry = { implementation };
+        entries.push(entry);
+        registered.set(implementation.name, entries);
+        return Effect.addFinalizer(
+          () => Effect.sync(() => {
+            entries.splice(entries.indexOf(entry), 1);
+            if (entries.length === 0) registered.delete(implementation.name);
+          })
+        );
+      }),
+      get: (name) => Effect.sync(() => Option.fromNullishOr(registered.get(name)?.at(-1)?.implementation))
+    });
+  })
+);
+//# sourceMappingURL=Implementations.js.map