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

package/dist/cjs/Stall.d.ts

@@ -0,0 +1,173 @@
+/**
+ * The stall breaker: end a round loop that has stopped making progress.
+ *
+ * A round bound is only a budget. A loop whose rounds change nothing spends
+ * the whole budget anyway: an agent that rewrites the same tree, a check that
+ * fails the same way after every repair, a reviser that hands back the same
+ * draft. This module counts consecutive rounds whose signal did not move and
+ * reports a {@link Stalled} verdict once one signal has held for
+ * `rounds` rounds in a row.
+ *
+ * Three signals are read, each optional per round:
+ *
+ * - `tree`: a fingerprint of the files the round left behind, such as a JJ
+ *   tree id or a `TreeFingerprint` checksum.
+ * - `checks`: the ids of the checks that failed. Order does not matter, and
+ *   an empty list is not compared.
+ * - `output`: the round's value, compared by the SHA-256 of its RFC 8785
+ *   canonical JSON. A value with no canonical form is not compared.
+ *
+ * Everything here is data. The {@link State} a round carries forward is a
+ * plain record, so a durable trampoline keeps it in its payload and a replay
+ * reads the same verdict. The loop decides what `on` means: `stop` settles
+ * with the stalled value, `park` settles the same way tagged for a caller
+ * that hands it to a person (the coding correction reports it `blocked`),
+ * and `escalate` fails.
+ *
+ * @since 1.0.0
+ */
+import * as Schema from "effect/Schema";
+/**
+ * What a loop does once it has stalled.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export declare const On: Schema.Literals<readonly ["stop", "park", "escalate"]>;
+/**
+ * The `on` values as a type.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type On = typeof On.Type;
+/**
+ * The signal that held still.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export declare const Signal: Schema.Literals<readonly ["tree", "checks", "output"]>;
+/**
+ * The signal names as a type.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Signal = typeof Signal.Type;
+/**
+ * A resolved stall policy: `rounds` identical rounds in a row, at least two,
+ * trigger `on`.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export declare const Policy: Schema.Struct<{
+    readonly rounds: Schema.Int;
+    readonly on: Schema.Literals<readonly ["stop", "park", "escalate"]>;
+}>;
+/**
+ * A resolved policy as a type.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Policy = typeof Policy.Type;
+/**
+ * The authoring form of a {@link Policy}; `on` defaults to `"stop"`.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Options {
+    readonly rounds: number;
+    readonly on?: On | undefined;
+}
+/**
+ * What one round reports. An absent signal is not compared and resets its
+ * streak.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface Observation {
+    readonly tree?: string | undefined;
+    readonly checks?: ReadonlyArray<string> | undefined;
+    readonly output?: unknown;
+}
+/**
+ * The streak of every signal, carried from one round to the next.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export declare const State: Schema.Struct<{
+    readonly tree: Schema.NullOr<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly rounds: Schema.Int;
+    }>>;
+    readonly checks: Schema.NullOr<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly rounds: Schema.Int;
+    }>>;
+    readonly output: Schema.NullOr<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly rounds: Schema.Int;
+    }>>;
+}>;
+/**
+ * The carried streaks as a type.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type State = typeof State.Type;
+/**
+ * The state before the first round.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const initial: State;
+/**
+ * The typed verdict: which signal held, for how many rounds, and what the
+ * policy says to do.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export declare const Stalled: Schema.Struct<{
+    readonly _tag: Schema.Literal<"Stalled">;
+    readonly signal: Schema.Literals<readonly ["tree", "checks", "output"]>;
+    readonly rounds: Schema.Int;
+    readonly on: Schema.Literals<readonly ["stop", "park", "escalate"]>;
+}>;
+/**
+ * The verdict as a type.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export type Stalled = typeof Stalled.Type;
+/**
+ * Validates authoring options into a {@link Policy}. Throws a `RangeError`
+ * for fewer than two rounds, since one round cannot repeat anything.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const policy: (options: Options) => Policy;
+/**
+ * Folds one round into the state and reports whether the loop has stalled.
+ *
+ * Signals are judged in the order `tree`, `checks`, `output`; the first that
+ * reached `policy.rounds` names the verdict.
+ *
+ * @category combinators
+ * @since 1.0.0
+ */
+export declare const observe: (policy: Policy, state: State, observation: Observation) => {
+    readonly state: State;
+    readonly stalled: Stalled | undefined;
+};
+//# sourceMappingURL=Stall.d.ts.map

package/dist/cjs/Stall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stall.d.ts","sourceRoot":"","sources":["../../src/Stall.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,EAAE,wDAAgD,CAAA;AAE/D;;;;;GAKG;AACH,MAAM,MAAM,EAAE,GAAG,OAAO,EAAE,CAAC,IAAI,CAAA;AAE/B;;;;;GAKG;AACH,eAAO,MAAM,MAAM,wDAAgD,CAAA;AAEnE;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,MAAM;;;EAGjB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;GAKG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,SAAS,CAAA;CAC7B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAClC,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,SAAS,CAAA;IACnD,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAC1B;AAID;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;;EAAkE,CAAA;AAEpF;;;;;GAKG;AACH,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAErC;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,KAAkD,CAAA;AAExE;;;;;;GAMG;AACH,eAAO,MAAM,OAAO;;;;;EAKlB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,GAAI,SAAS,OAAO,KAAG,MAKzC,CAAA;AAsBD;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,GAClB,QAAQ,MAAM,EACd,OAAO,KAAK,EACZ,aAAa,WAAW,KACvB;IAAE,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,CAAA;CAYhE,CAAA"}

package/dist/cjs/Stall.js

@@ -0,0 +1,92 @@
+"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 Stall_exports = {};
+__export(Stall_exports, {
+  On: () => On,
+  Policy: () => Policy,
+  Signal: () => Signal,
+  Stalled: () => Stalled,
+  State: () => State,
+  initial: () => initial,
+  observe: () => observe,
+  policy: () => policy
+});
+module.exports = __toCommonJS(Stall_exports);
+var import_canonical = require("@smthrs/canonical");
+var import_crypto = require("@smthrs/crypto");
+var Schema = __toESM(require("effect/Schema"), 1);
+const On = Schema.Literals(["stop", "park", "escalate"]);
+const Signal = Schema.Literals(["tree", "checks", "output"]);
+const Policy = Schema.Struct({
+  rounds: Schema.Int.check(Schema.isGreaterThanOrEqualTo(2)),
+  on: On
+});
+const Streak = Schema.NullOr(Schema.Struct({ key: Schema.String, rounds: Schema.Int }));
+const State = Schema.Struct({ tree: Streak, checks: Streak, output: Streak });
+const initial = { tree: null, checks: null, output: null };
+const Stalled = Schema.Struct({
+  _tag: Schema.Literal("Stalled"),
+  signal: Signal,
+  rounds: Schema.Int,
+  on: On
+});
+const policy = (options) => {
+  if (!Number.isSafeInteger(options.rounds) || options.rounds < 2) {
+    throw new RangeError("Stall rounds must be a safe integer of at least 2");
+  }
+  return { rounds: options.rounds, on: options.on ?? "stop" };
+};
+const hash = (value) => {
+  try {
+    return (0, import_crypto.digestSync)((0, import_canonical.canonicalize)(value ?? null));
+  } catch {
+    return void 0;
+  }
+};
+const keys = (observation) => ({
+  tree: observation.tree,
+  // No failing check is not a repeated failure.
+  checks: observation.checks === void 0 || observation.checks.length === 0 ? void 0 : JSON.stringify([...new Set(observation.checks)].sort()),
+  output: "output" in observation ? hash(observation.output) : void 0
+});
+const signals = ["tree", "checks", "output"];
+const observe = (policy2, state, observation) => {
+  const current = keys(observation);
+  const next = Object.fromEntries(signals.map((signal2) => {
+    const key = current[signal2];
+    const prior = state[signal2];
+    return [signal2, key === void 0 ? null : { key, rounds: prior?.key === key ? prior.rounds + 1 : 1 }];
+  }));
+  const signal = signals.find((signal2) => (next[signal2]?.rounds ?? 0) >= policy2.rounds);
+  return {
+    state: next,
+    stalled: signal === void 0 ? void 0 : { _tag: "Stalled", signal, rounds: next[signal].rounds, on: policy2.on }
+  };
+};
+//# sourceMappingURL=Stall.js.map

package/dist/cjs/Stall.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Stall.ts"],
+  "sourcesContent": ["/**\n * The stall breaker: end a round loop that has stopped making progress.\n *\n * A round bound is only a budget. A loop whose rounds change nothing spends\n * the whole budget anyway: an agent that rewrites the same tree, a check that\n * fails the same way after every repair, a reviser that hands back the same\n * draft. This module counts consecutive rounds whose signal did not move and\n * reports a {@link Stalled} verdict once one signal has held for\n * `rounds` rounds in a row.\n *\n * Three signals are read, each optional per round:\n *\n * - `tree`: a fingerprint of the files the round left behind, such as a JJ\n *   tree id or a `TreeFingerprint` checksum.\n * - `checks`: the ids of the checks that failed. Order does not matter, and\n *   an empty list is not compared.\n * - `output`: the round's value, compared by the SHA-256 of its RFC 8785\n *   canonical JSON. A value with no canonical form is not compared.\n *\n * Everything here is data. The {@link State} a round carries forward is a\n * plain record, so a durable trampoline keeps it in its payload and a replay\n * reads the same verdict. The loop decides what `on` means: `stop` settles\n * with the stalled value, `park` settles the same way tagged for a caller\n * that hands it to a person (the coding correction reports it `blocked`),\n * and `escalate` fails.\n *\n * @since 1.0.0\n */\n\nimport { canonicalize } from \"@smthrs/canonical\"\nimport { digestSync } from \"@smthrs/crypto\"\nimport * as Schema from \"effect/Schema\"\n\n/**\n * What a loop does once it has stalled.\n *\n * @category models\n * @since 1.0.0\n */\nexport const On = Schema.Literals([\"stop\", \"park\", \"escalate\"])\n\n/**\n * The `on` values as a type.\n *\n * @category models\n * @since 1.0.0\n */\nexport type On = typeof On.Type\n\n/**\n * The signal that held still.\n *\n * @category models\n * @since 1.0.0\n */\nexport const Signal = Schema.Literals([\"tree\", \"checks\", \"output\"])\n\n/**\n * The signal names as a type.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Signal = typeof Signal.Type\n\n/**\n * A resolved stall policy: `rounds` identical rounds in a row, at least two,\n * trigger `on`.\n *\n * @category models\n * @since 1.0.0\n */\nexport const Policy = Schema.Struct({\n  rounds: Schema.Int.check(Schema.isGreaterThanOrEqualTo(2)),\n  on: On\n})\n\n/**\n * A resolved policy as a type.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Policy = typeof Policy.Type\n\n/**\n * The authoring form of a {@link Policy}; `on` defaults to `\"stop\"`.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Options {\n  readonly rounds: number\n  readonly on?: On | undefined\n}\n\n/**\n * What one round reports. An absent signal is not compared and resets its\n * streak.\n *\n * @category models\n * @since 1.0.0\n */\nexport interface Observation {\n  readonly tree?: string | undefined\n  readonly checks?: ReadonlyArray<string> | undefined\n  readonly output?: unknown\n}\n\nconst Streak = Schema.NullOr(Schema.Struct({ key: Schema.String, rounds: Schema.Int }))\n\n/**\n * The streak of every signal, carried from one round to the next.\n *\n * @category models\n * @since 1.0.0\n */\nexport const State = Schema.Struct({ tree: Streak, checks: Streak, output: Streak })\n\n/**\n * The carried streaks as a type.\n *\n * @category models\n * @since 1.0.0\n */\nexport type State = typeof State.Type\n\n/**\n * The state before the first round.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const initial: State = { tree: null, checks: null, output: null }\n\n/**\n * The typed verdict: which signal held, for how many rounds, and what the\n * policy says to do.\n *\n * @category models\n * @since 1.0.0\n */\nexport const Stalled = Schema.Struct({\n  _tag: Schema.Literal(\"Stalled\"),\n  signal: Signal,\n  rounds: Schema.Int,\n  on: On\n})\n\n/**\n * The verdict as a type.\n *\n * @category models\n * @since 1.0.0\n */\nexport type Stalled = typeof Stalled.Type\n\n/**\n * Validates authoring options into a {@link Policy}. Throws a `RangeError`\n * for fewer than two rounds, since one round cannot repeat anything.\n *\n * @category constructors\n * @since 1.0.0\n */\nexport const policy = (options: Options): Policy => {\n  if (!Number.isSafeInteger(options.rounds) || options.rounds < 2) {\n    throw new RangeError(\"Stall rounds must be a safe integer of at least 2\")\n  }\n  return { rounds: options.rounds, on: options.on ?? \"stop\" }\n}\n\n// A value with no canonical form (an `Error`, a `bigint`) is not compared.\nconst hash = (value: unknown): string | undefined => {\n  try {\n    return digestSync(canonicalize(value ?? null))\n  } catch {\n    return undefined\n  }\n}\n\nconst keys = (observation: Observation): Record<Signal, string | undefined> => ({\n  tree: observation.tree,\n  // No failing check is not a repeated failure.\n  checks: observation.checks === undefined || observation.checks.length === 0\n    ? undefined\n    : JSON.stringify([...new Set(observation.checks)].sort()),\n  output: \"output\" in observation ? hash(observation.output) : undefined\n})\n\nconst signals: ReadonlyArray<Signal> = [\"tree\", \"checks\", \"output\"]\n\n/**\n * Folds one round into the state and reports whether the loop has stalled.\n *\n * Signals are judged in the order `tree`, `checks`, `output`; the first that\n * reached `policy.rounds` names the verdict.\n *\n * @category combinators\n * @since 1.0.0\n */\nexport const observe = (\n  policy: Policy,\n  state: State,\n  observation: Observation\n): { readonly state: State; readonly stalled: Stalled | undefined } => {\n  const current = keys(observation)\n  const next = Object.fromEntries(signals.map((signal) => {\n    const key = current[signal]\n    const prior = state[signal]\n    return [signal, key === undefined ? null : { key, rounds: prior?.key === key ? prior.rounds + 1 : 1 }]\n  })) as unknown as State\n  const signal = signals.find((signal) => (next[signal]?.rounds ?? 0) >= policy.rounds)\n  return {\n    state: next,\n    stalled: signal === undefined ? undefined : { _tag: \"Stalled\", signal, rounds: next[signal]!.rounds, on: policy.on }\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA6BA,uBAA6B;AAC7B,oBAA2B;AAC3B,aAAwB;AAQjB,MAAM,KAAK,OAAO,SAAS,CAAC,QAAQ,QAAQ,UAAU,CAAC;AAgBvD,MAAM,SAAS,OAAO,SAAS,CAAC,QAAQ,UAAU,QAAQ,CAAC;AAiB3D,MAAM,SAAS,OAAO,OAAO;AAAA,EAClC,QAAQ,OAAO,IAAI,MAAM,OAAO,uBAAuB,CAAC,CAAC;AAAA,EACzD,IAAI;AACN,CAAC;AAkCD,MAAM,SAAS,OAAO,OAAO,OAAO,OAAO,EAAE,KAAK,OAAO,QAAQ,QAAQ,OAAO,IAAI,CAAC,CAAC;AAQ/E,MAAM,QAAQ,OAAO,OAAO,EAAE,MAAM,QAAQ,QAAQ,QAAQ,QAAQ,OAAO,CAAC;AAgB5E,MAAM,UAAiB,EAAE,MAAM,MAAM,QAAQ,MAAM,QAAQ,KAAK;AAShE,MAAM,UAAU,OAAO,OAAO;AAAA,EACnC,MAAM,OAAO,QAAQ,SAAS;AAAA,EAC9B,QAAQ;AAAA,EACR,QAAQ,OAAO;AAAA,EACf,IAAI;AACN,CAAC;AAiBM,MAAM,SAAS,CAAC,YAA6B;AAClD,MAAI,CAAC,OAAO,cAAc,QAAQ,MAAM,KAAK,QAAQ,SAAS,GAAG;AAC/D,UAAM,IAAI,WAAW,mDAAmD;AAAA,EAC1E;AACA,SAAO,EAAE,QAAQ,QAAQ,QAAQ,IAAI,QAAQ,MAAM,OAAO;AAC5D;AAGA,MAAM,OAAO,CAAC,UAAuC;AACnD,MAAI;AACF,eAAO,8BAAW,+BAAa,SAAS,IAAI,CAAC;AAAA,EAC/C,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEA,MAAM,OAAO,CAAC,iBAAkE;AAAA,EAC9E,MAAM,YAAY;AAAA;AAAA,EAElB,QAAQ,YAAY,WAAW,UAAa,YAAY,OAAO,WAAW,IACtE,SACA,KAAK,UAAU,CAAC,GAAG,IAAI,IAAI,YAAY,MAAM,CAAC,EAAE,KAAK,CAAC;AAAA,EAC1D,QAAQ,YAAY,cAAc,KAAK,YAAY,MAAM,IAAI;AAC/D;AAEA,MAAM,UAAiC,CAAC,QAAQ,UAAU,QAAQ;AAW3D,MAAM,UAAU,CACrBA,SACA,OACA,gBACqE;AACrE,QAAM,UAAU,KAAK,WAAW;AAChC,QAAM,OAAO,OAAO,YAAY,QAAQ,IAAI,CAACC,YAAW;AACtD,UAAM,MAAM,QAAQA,OAAM;AAC1B,UAAM,QAAQ,MAAMA,OAAM;AAC1B,WAAO,CAACA,SAAQ,QAAQ,SAAY,OAAO,EAAE,KAAK,QAAQ,OAAO,QAAQ,MAAM,MAAM,SAAS,IAAI,EAAE,CAAC;AAAA,EACvG,CAAC,CAAC;AACF,QAAM,SAAS,QAAQ,KAAK,CAACA,aAAY,KAAKA,OAAM,GAAG,UAAU,MAAMD,QAAO,MAAM;AACpF,SAAO;AAAA,IACL,OAAO;AAAA,IACP,SAAS,WAAW,SAAY,SAAY,EAAE,MAAM,WAAW,QAAQ,QAAQ,KAAK,MAAM,EAAG,QAAQ,IAAIA,QAAO,GAAG;AAAA,EACrH;AACF;",
+  "names": ["policy", "signal"]
+}

package/dist/cjs/WaitFor.d.ts

@@ -0,0 +1,109 @@
+/**
+ * The system wait point, as an ordinary declared action.
+ *
+ * `docs/concepts/flows-and-actions.md` names wait-for-event the
+ * other half of the timer gap and says how to close it: ship it over the
+ * existing `DurableDeferred`, so an external signal is a visible, keyed plan
+ * node. That is this module. {@link action} is a plain `Action.make`
+ * declaration — catalogable, `.call()`-able, one node in the built plan — and
+ * {@link layer} is the implementation.
+ *
+ * Nothing about resolution is new. The wait is a `DurableDeferred`, so whoever
+ * satisfies it completes it the way every other durable deferred is completed:
+ * a token, and `DurableDeferred.succeed`, `fail`, `failCause`, or `done`.
+ * {@link deferred} is how a resolver names the same wait point the action
+ * awaits. The park is declared through the ordinary waiting vocabulary
+ * ({@link module:WaitingAnnotation.annotateWaiting}) under `event`, carrying
+ * that token as the compare-and-swap material a wake handler matches. Replay is
+ * the deferred's: once a result is recorded, a re-driven round reads it and
+ * runs through instead of parking again.
+ *
+ * @since 0.1.0
+ */
+import type * as Crypto from "effect/Crypto";
+import type * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as Action from "./Action/index.ts";
+import * as DurableDeferred from "./DurableDeferred.ts";
+import type { FlowRuntime } from "./FlowRuntime/FlowRuntime.ts";
+declare const WaitForRequestInvalid_base: Schema.Class<WaitForRequestInvalid, Schema.TaggedStruct<"@smthrs/flow/WaitForRequestInvalid", {
+    readonly code: Schema.Literals<readonly ["missing_target", "ambiguous_target", "malformed_token", "foreign_execution"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A wait whose payload does not name exactly one reachable wait point.
+ *
+ * A payload names the wait point by `name`, relative to the running execution,
+ * or by an absolute `token`. Naming both, or neither, leaves nothing to await;
+ * a token that does not parse names nothing either; and a token addressed to a
+ * different flow or a different execution names a wait point this execution
+ * cannot observe, because a durable deferred result is recorded against the
+ * flow and execution that own it.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class WaitForRequestInvalid extends WaitForRequestInvalid_base {
+}
+/**
+ * The tag the wait declaration is catalogued and resolved under.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const tag = "system/wait-for";
+/**
+ * The durable deferred a named wait point resolves through.
+ *
+ * This is the resolver's half of {@link action}: the value to hand
+ * `DurableDeferred.tokenFromExecutionId` and `DurableDeferred.succeed`, so a
+ * wait that a body declared by name is completed through the existing deferred
+ * completion path rather than a second one.
+ *
+ * ```ts
+ * const gate = WaitFor.deferred("approval")
+ * const token = DurableDeferred.tokenFromExecutionId(gate, { flow, executionId })
+ * yield* DurableDeferred.succeed(gate, { token, value: { approved: true } })
+ * ```
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const deferred: (name: string) => DurableDeferred.DurableDeferred<typeof Schema.Json>;
+/**
+ * The declared wait action: a wait point named by `name` or by `token`.
+ *
+ * **When to use**
+ *
+ * Use it in a body wherever a round has to wait for something outside the run —
+ * an approval, a webhook, a human — `WaitFor.action.call({ name: "approval"
+ * })`. The node settles with whatever value resolved the wait, so downstream
+ * steps read it the way they read any other step result.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const action: Action.Declared<typeof tag, Schema.Struct<{
+    readonly token: Schema.optional<Schema.String>;
+    readonly name: Schema.optional<Schema.String>;
+}>, typeof Schema.Json, typeof WaitForRequestInvalid, never>;
+/**
+ * The wait implementation: park under `event` with the wake token, and settle
+ * with the value that resolved the wait.
+ *
+ * Provide it beside the other action implementation layers a body calls, over
+ * the {@link module:Implementations.layerImplementations} table they file
+ * themselves in:
+ *
+ * ```ts
+ * Layer.mergeAll(WaitFor.layer, Interpreter.layer(Pipeline)).pipe(
+ *   Layer.provideMerge(Action.layerImplementations)
+ * )
+ * ```
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: Layer.Layer<never, never, Crypto.Crypto | FlowRuntime>;
+export {};
+//# sourceMappingURL=WaitFor.d.ts.map

package/dist/cjs/WaitFor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaitFor.d.ts","sourceRoot":"","sources":["../../src/WaitFor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAE5C,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAC3C,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AAEvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAA;;;;;AAG/D;;;;;;;;;;;;GAYG;AACH,qBAAa,qBAAsB,SAAQ,0BAW1C;CAAG;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,GAAG,oBAAoB,CAAA;AAEpC;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAM,MAAM,KAAG,eAAe,CAAC,eAAe,CAAC,OAAO,MAAM,CAAC,IAAI,CACvB,CAAA;AAEnE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,QAAQ,CAClC,OAAO,GAAG,EACV,MAAM,CAAC,MAAM,CAAC;IACZ,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;CAC9C,CAAC,EACF,OAAO,MAAM,CAAC,IAAI,EAClB,OAAO,qBAAqB,EAC5B,KAAK,CASL,CAAA;AAkFF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,GAAG,WAAW,CAWxE,CAAA"}

package/dist/cjs/WaitFor.js

@@ -0,0 +1,117 @@
+"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 = (target2, all) => {
+  for (var name in all)
+    __defProp(target2, 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, target2) => (target2 = 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(target2, "default", { value: mod, enumerable: true }) : target2,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var WaitFor_exports = {};
+__export(WaitFor_exports, {
+  WaitForRequestInvalid: () => WaitForRequestInvalid,
+  action: () => action,
+  deferred: () => deferred,
+  layer: () => layer,
+  tag: () => tag
+});
+module.exports = __toCommonJS(WaitFor_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var Action = __toESM(require("./Action/index.js"), 1);
+var DurableDeferred = __toESM(require("./DurableDeferred.js"), 1);
+var import_FlowInstance = require("./FlowRuntime/FlowInstance.js");
+var import_WaitingAnnotation = require("./FlowRuntime/WaitingAnnotation.js");
+class WaitForRequestInvalid extends Schema.TaggedError()(
+  "@smthrs/flow/WaitForRequestInvalid",
+  {
+    code: Schema.Literals([
+      "missing_target",
+      "ambiguous_target",
+      "malformed_token",
+      "foreign_execution"
+    ]),
+    message: Schema.String
+  }
+) {
+}
+const tag = "system/wait-for";
+const deferred = (name) => DurableDeferred.make(`WaitFor/${name}`, { success: Schema.Json });
+const action = Action.makeSystem(tag, {
+  payload: {
+    token: Schema.optional(Schema.String),
+    name: Schema.optional(Schema.String)
+  },
+  success: Schema.Json,
+  error: WaitForRequestInvalid,
+  tier: "sealed"
+});
+const parseToken = (token) => Effect.mapError(
+  DurableDeferred.TokenParsed.parse(token),
+  (error) => new WaitForRequestInvalid({
+    code: "malformed_token",
+    message: `${tag} was called with a token that is not a durable deferred token. ${error.message}`
+  })
+);
+const target = (payload, flowName, executionId) => {
+  if (payload.token !== void 0 && payload.name !== void 0) {
+    return Effect.fail(
+      new WaitForRequestInvalid({
+        code: "ambiguous_target",
+        message: `${tag} was called with both "token" and "name". A wait names one wait point: a name relative to this execution, or an absolute token.`
+      })
+    );
+  }
+  if (payload.name !== void 0) return Effect.succeed(deferred(payload.name));
+  if (payload.token !== void 0) {
+    return Effect.flatMap(
+      parseToken(payload.token),
+      (parsed) => parsed.flowName !== flowName || parsed.executionId !== executionId ? Effect.fail(
+        new WaitForRequestInvalid({
+          code: "foreign_execution",
+          message: `${tag} was called with a token addressed to flow "${parsed.flowName}" in execution "${parsed.executionId}", but it is running as flow "${flowName}" in execution "${executionId}". A durable deferred result is recorded against the execution that owns it, so only that execution can await it.`
+        })
+      ) : Effect.succeed(
+        DurableDeferred.make(parsed.deferredName, { success: Schema.Json })
+      )
+    );
+  }
+  return Effect.fail(
+    new WaitForRequestInvalid({
+      code: "missing_target",
+      message: `${tag} was called with neither "token" nor "name", so there is no wait point to await.`
+    })
+  );
+};
+const layer = action.toLayer(
+  (payload) => Effect.gen(function* () {
+    const instance = yield* import_FlowInstance.FlowInstance;
+    const waitPoint = yield* target(payload, instance.flow._tag, instance.executionId);
+    const token = DurableDeferred.tokenFromExecutionId(waitPoint, {
+      flow: instance.flow,
+      executionId: instance.executionId
+    });
+    yield* (0, import_WaitingAnnotation.annotateWaiting)({ reason: "event", token });
+    return yield* DurableDeferred.await(waitPoint);
+  })
+);
+//# sourceMappingURL=WaitFor.js.map

package/dist/cjs/WaitFor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/WaitFor.ts"],
+  "sourcesContent": ["/**\n * The system wait point, as an ordinary declared action.\n *\n * `docs/concepts/flows-and-actions.md` names wait-for-event the\n * other half of the timer gap and says how to close it: ship it over the\n * existing `DurableDeferred`, so an external signal is a visible, keyed plan\n * node. That is this module. {@link action} is a plain `Action.make`\n * declaration \u2014 catalogable, `.call()`-able, one node in the built plan \u2014 and\n * {@link layer} is the implementation.\n *\n * Nothing about resolution is new. The wait is a `DurableDeferred`, so whoever\n * satisfies it completes it the way every other durable deferred is completed:\n * a token, and `DurableDeferred.succeed`, `fail`, `failCause`, or `done`.\n * {@link deferred} is how a resolver names the same wait point the action\n * awaits. The park is declared through the ordinary waiting vocabulary\n * ({@link module:WaitingAnnotation.annotateWaiting}) under `event`, carrying\n * that token as the compare-and-swap material a wake handler matches. Replay is\n * the deferred's: once a result is recorded, a re-driven round reads it and\n * runs through instead of parking again.\n *\n * @since 0.1.0\n */\n\nimport type * as Crypto from \"effect/Crypto\"\nimport * as Effect from \"effect/Effect\"\nimport type * as Layer from \"effect/Layer\"\nimport * as Schema from \"effect/Schema\"\nimport * as Action from \"./Action/index.ts\"\nimport * as DurableDeferred from \"./DurableDeferred.ts\"\nimport { FlowInstance } from \"./FlowRuntime/FlowInstance.ts\"\nimport type { FlowRuntime } from \"./FlowRuntime/FlowRuntime.ts\"\nimport { annotateWaiting } from \"./FlowRuntime/WaitingAnnotation.ts\"\n\n/**\n * A wait whose payload does not name exactly one reachable wait point.\n *\n * A payload names the wait point by `name`, relative to the running execution,\n * or by an absolute `token`. Naming both, or neither, leaves nothing to await;\n * a token that does not parse names nothing either; and a token addressed to a\n * different flow or a different execution names a wait point this execution\n * cannot observe, because a durable deferred result is recorded against the\n * flow and execution that own it.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class WaitForRequestInvalid extends Schema.TaggedError<WaitForRequestInvalid>()(\n  \"@smthrs/flow/WaitForRequestInvalid\",\n  {\n    code: Schema.Literals([\n      \"missing_target\",\n      \"ambiguous_target\",\n      \"malformed_token\",\n      \"foreign_execution\"\n    ]),\n    message: Schema.String\n  }\n) {}\n\n/**\n * The tag the wait declaration is catalogued and resolved under.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const tag = \"system/wait-for\"\n\n/**\n * The durable deferred a named wait point resolves through.\n *\n * This is the resolver's half of {@link action}: the value to hand\n * `DurableDeferred.tokenFromExecutionId` and `DurableDeferred.succeed`, so a\n * wait that a body declared by name is completed through the existing deferred\n * completion path rather than a second one.\n *\n * ```ts\n * const gate = WaitFor.deferred(\"approval\")\n * const token = DurableDeferred.tokenFromExecutionId(gate, { flow, executionId })\n * yield* DurableDeferred.succeed(gate, { token, value: { approved: true } })\n * ```\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const deferred = (name: string): DurableDeferred.DurableDeferred<typeof Schema.Json> =>\n  DurableDeferred.make(`WaitFor/${name}`, { success: Schema.Json })\n\n/**\n * The declared wait action: a wait point named by `name` or by `token`.\n *\n * **When to use**\n *\n * Use it in a body wherever a round has to wait for something outside the run \u2014\n * an approval, a webhook, a human \u2014 `WaitFor.action.call({ name: \"approval\"\n * })`. The node settles with whatever value resolved the wait, so downstream\n * steps read it the way they read any other step result.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const action: Action.Declared<\n  typeof tag,\n  Schema.Struct<{\n    readonly token: Schema.optional<Schema.String>\n    readonly name: Schema.optional<Schema.String>\n  }>,\n  typeof Schema.Json,\n  typeof WaitForRequestInvalid,\n  never\n> = Action.makeSystem(tag, {\n  payload: {\n    token: Schema.optional(Schema.String),\n    name: Schema.optional(Schema.String)\n  },\n  success: Schema.Json,\n  error: WaitForRequestInvalid,\n  tier: \"sealed\"\n})\n\n/**\n * The deferred name a token addresses, refused when the token does not parse.\n *\n * @private\n */\nconst parseToken = (token: string): Effect.Effect<DurableDeferred.TokenParsed, WaitForRequestInvalid> =>\n  Effect.mapError(\n    DurableDeferred.TokenParsed.parse(token),\n    (error) =>\n      new WaitForRequestInvalid({\n        code: \"malformed_token\",\n        message: `${tag} was called with a token that is not a durable deferred token. ${error.message}`\n      })\n  )\n\n/**\n * The wait point a payload names, resolved against the running execution.\n *\n * DECIDED: a payload names EXACTLY one of `name`\n * and `token`, and a token must address the execution that is waiting. A\n * deferred result is recorded against (flow name, execution id, deferred name)\n * and read back the same way, so awaiting a foreign token would park forever\n * while the value it names was recorded elsewhere; refusing it names the\n * mistake instead. BOTH halves of the owning execution's identity are compared:\n * a token carries its own flow name, so a same-execution token minted for\n * another flow completes under that flow while this one reads under its own,\n * which is the same permanent park by a different route.\n *\n * DECIDED: a wait point is addressed by the\n * PAYLOAD, and the per-dispatch identity {@link module:Sleep} derives its clock\n * from is deliberately NOT applied here. A wait is a rendezvous with something\n * outside the run, and a resolver has to name the same wait point to complete\n * it, so the name is the author's and two calls naming one wait point await one\n * fact \u2014 which is the intended reading, not an aliasing bug. A sleep has no\n * counterpart to agree with, which is why it takes its identity from the node.\n *\n * @private\n */\nconst target = (\n  payload: { readonly token?: string | undefined; readonly name?: string | undefined },\n  flowName: string,\n  executionId: string\n): Effect.Effect<DurableDeferred.DurableDeferred<typeof Schema.Json>, WaitForRequestInvalid> => {\n  if (payload.token !== undefined && payload.name !== undefined) {\n    return Effect.fail(\n      new WaitForRequestInvalid({\n        code: \"ambiguous_target\",\n        message: `${tag} was called with both \"token\" and \"name\". A wait names one wait point: ` +\n          \"a name relative to this execution, or an absolute token.\"\n      })\n    )\n  }\n  if (payload.name !== undefined) return Effect.succeed(deferred(payload.name))\n  if (payload.token !== undefined) {\n    return Effect.flatMap(\n      parseToken(payload.token),\n      (parsed) =>\n        parsed.flowName !== flowName || parsed.executionId !== executionId\n          ? Effect.fail(\n            new WaitForRequestInvalid({\n              code: \"foreign_execution\",\n              message: `${tag} was called with a token addressed to flow \"${parsed.flowName}\" in execution ` +\n                `\"${parsed.executionId}\", but it is running as flow \"${flowName}\" in execution ` +\n                `\"${executionId}\". A durable deferred result is recorded against the execution that owns it, ` +\n                \"so only that execution can await it.\"\n            })\n          )\n          : Effect.succeed(\n            DurableDeferred.make(parsed.deferredName, { success: Schema.Json })\n          )\n    )\n  }\n  return Effect.fail(\n    new WaitForRequestInvalid({\n      code: \"missing_target\",\n      message: `${tag} was called with neither \"token\" nor \"name\", so there is no wait point to await.`\n    })\n  )\n}\n\n/**\n * The wait implementation: park under `event` with the wake token, and settle\n * with the value that resolved the wait.\n *\n * Provide it beside the other action implementation layers a body calls, over\n * the {@link module:Implementations.layerImplementations} table they file\n * themselves in:\n *\n * ```ts\n * Layer.mergeAll(WaitFor.layer, Interpreter.layer(Pipeline)).pipe(\n *   Layer.provideMerge(Action.layerImplementations)\n * )\n * ```\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer: Layer.Layer<never, never, Crypto.Crypto | FlowRuntime> = action.toLayer((payload) =>\n  Effect.gen(function*() {\n    const instance = yield* FlowInstance\n    const waitPoint = yield* target(payload, instance.flow._tag, instance.executionId)\n    const token = DurableDeferred.tokenFromExecutionId(waitPoint, {\n      flow: instance.flow,\n      executionId: instance.executionId\n    })\n    yield* annotateWaiting({ reason: \"event\", token })\n    return yield* DurableDeferred.await(waitPoint)\n  })\n)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAwBA,aAAwB;AAExB,aAAwB;AACxB,aAAwB;AACxB,sBAAiC;AACjC,0BAA6B;AAE7B,+BAAgC;AAezB,MAAM,8BAA8B,OAAO,YAAmC;AAAA,EACnF;AAAA,EACA;AAAA,IACE,MAAM,OAAO,SAAS;AAAA,MACpB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF,CAAC;AAAA,IACD,SAAS,OAAO;AAAA,EAClB;AACF,EAAE;AAAC;AAQI,MAAM,MAAM;AAmBZ,MAAM,WAAW,CAAC,SACvB,gBAAgB,KAAK,WAAW,IAAI,IAAI,EAAE,SAAS,OAAO,KAAK,CAAC;AAe3D,MAAM,SAST,OAAO,WAAW,KAAK;AAAA,EACzB,SAAS;AAAA,IACP,OAAO,OAAO,SAAS,OAAO,MAAM;AAAA,IACpC,MAAM,OAAO,SAAS,OAAO,MAAM;AAAA,EACrC;AAAA,EACA,SAAS,OAAO;AAAA,EAChB,OAAO;AAAA,EACP,MAAM;AACR,CAAC;AAOD,MAAM,aAAa,CAAC,UAClB,OAAO;AAAA,EACL,gBAAgB,YAAY,MAAM,KAAK;AAAA,EACvC,CAAC,UACC,IAAI,sBAAsB;AAAA,IACxB,MAAM;AAAA,IACN,SAAS,GAAG,GAAG,kEAAkE,MAAM,OAAO;AAAA,EAChG,CAAC;AACL;AAyBF,MAAM,SAAS,CACb,SACA,UACA,gBAC8F;AAC9F,MAAI,QAAQ,UAAU,UAAa,QAAQ,SAAS,QAAW;AAC7D,WAAO,OAAO;AAAA,MACZ,IAAI,sBAAsB;AAAA,QACxB,MAAM;AAAA,QACN,SAAS,GAAG,GAAG;AAAA,MAEjB,CAAC;AAAA,IACH;AAAA,EACF;AACA,MAAI,QAAQ,SAAS,OAAW,QAAO,OAAO,QAAQ,SAAS,QAAQ,IAAI,CAAC;AAC5E,MAAI,QAAQ,UAAU,QAAW;AAC/B,WAAO,OAAO;AAAA,MACZ,WAAW,QAAQ,KAAK;AAAA,MACxB,CAAC,WACC,OAAO,aAAa,YAAY,OAAO,gBAAgB,cACnD,OAAO;AAAA,QACP,IAAI,sBAAsB;AAAA,UACxB,MAAM;AAAA,UACN,SAAS,GAAG,GAAG,+CAA+C,OAAO,QAAQ,mBACvE,OAAO,WAAW,iCAAiC,QAAQ,mBAC3D,WAAW;AAAA,QAEnB,CAAC;AAAA,MACH,IACE,OAAO;AAAA,QACP,gBAAgB,KAAK,OAAO,cAAc,EAAE,SAAS,OAAO,KAAK,CAAC;AAAA,MACpE;AAAA,IACN;AAAA,EACF;AACA,SAAO,OAAO;AAAA,IACZ,IAAI,sBAAsB;AAAA,MACxB,MAAM;AAAA,MACN,SAAS,GAAG,GAAG;AAAA,IACjB,CAAC;AAAA,EACH;AACF;AAmBO,MAAM,QAAgE,OAAO;AAAA,EAAQ,CAAC,YAC3F,OAAO,IAAI,aAAY;AACrB,UAAM,WAAW,OAAO;AACxB,UAAM,YAAY,OAAO,OAAO,SAAS,SAAS,KAAK,MAAM,SAAS,WAAW;AACjF,UAAM,QAAQ,gBAAgB,qBAAqB,WAAW;AAAA,MAC5D,MAAM,SAAS;AAAA,MACf,aAAa,SAAS;AAAA,IACxB,CAAC;AACD,eAAO,0CAAgB,EAAE,QAAQ,SAAS,MAAM,CAAC;AACjD,WAAO,OAAO,gBAAgB,MAAM,SAAS;AAAA,EAC/C,CAAC;AACH;",
+  "names": []
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,107 @@
+/**
+ * @since 0.1.0
+ */
+/**
+ * Durable action definitions and combinators.
+ *
+ * @since 0.1.0
+ */
+export * as Action from "./Action/index.ts";
+/**
+ * Durable clock and timer services.
+ *
+ * @since 0.1.0
+ */
+export * as Deadline from "./Deadline.ts";
+export * as DurableClock from "./DurableClock.ts";
+/**
+ * Durable deferred values.
+ *
+ * @since 0.1.0
+ */
+export * as DurableDeferred from "./DurableDeferred.ts";
+/**
+ * Durable queues.
+ *
+ * @since 0.1.0
+ */
+export * as DurableQueue from "./DurableQueue.ts";
+/**
+ * Durable flow definitions.
+ *
+ * @since 0.1.0
+ */
+export * as Flow from "./Flow/index.ts";
+/**
+ * The execution contract flow authoring APIs are written against.
+ *
+ * @since 0.1.0
+ */
+export * as FlowRuntime from "./FlowRuntime/index.ts";
+/**
+ * One typed fault for every failure, and the response table that reads it.
+ *
+ * @since 1.0.0
+ */
+export * as Fault from "./Fault.ts";
+/**
+ * External workers observed through durable actions and timers.
+ *
+ * @since 1.0.0
+ */
+export * as ExternalJob from "./ExternalJob.ts";
+/**
+ * Plan-time graph building from flow declarations.
+ *
+ * @since 0.1.0
+ */
+export * as Graph from "./Graph.ts";
+/**
+ * Asking a person something: typed answers, re-asking, and a deadline.
+ *
+ * @since 0.1.0
+ */
+export * as HumanTask from "./HumanTask.ts";
+/**
+ * Execution of a flow body, and the layer that registers it.
+ *
+ * @since 0.1.0
+ */
+export * as Interpreter from "./Interpreter.ts";
+/**
+ * The durable poller: attempts as rounds, waits as durable timers.
+ *
+ * @since 0.1.0
+ */
+export * as Poll from "./Poll.ts";
+/**
+ * The stall breaker: rounds whose tree, failing checks, or output held still.
+ *
+ * @since 1.0.0
+ */
+export * as Stall from "./Stall.ts";
+/**
+ * Retry policy models and constructors.
+ *
+ * @since 0.1.0
+ */
+export * as RetryPolicy from "./RetryPolicy.ts";
+/**
+ * The system timer action and its implementation layer.
+ *
+ * @since 0.1.0
+ */
+export * as Sleep from "./Sleep.ts";
+/**
+ * Stable step identity construction.
+ *
+ * @since 0.1.0
+ */
+export * as StepIdentity from "./Action/StepIdentity.ts";
+/**
+ * The system wait-point action and its implementation layer.
+ *
+ * @since 0.1.0
+ */
+export * as WaitFor from "./WaitFor.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAEA;;GAEG;AAEH;;;;GAIG;AACH,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAA;AAE3C;;;;GAIG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;;GAIG;AACH,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AAEvD;;;;GAIG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;;GAIG;AACH,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAA;AAEvC;;;;GAIG;AACH,OAAO,KAAK,WAAW,MAAM,wBAAwB,CAAA;AAErD;;;;GAIG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC;;;;GAIG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAE/C;;;;GAIG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC;;;;GAIG;AACH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAE3C;;;;GAIG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAE/C;;;;GAIG;AACH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AAEjC;;;;GAIG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC;;;;GAIG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAE/C;;;;GAIG;AACH,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AAEnC;;;;GAIG;AACH,OAAO,KAAK,YAAY,MAAM,0BAA0B,CAAA;AAExD;;;;GAIG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA"}