@smthrs/control 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/Lineage.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Run ancestry as the control plane reads it.
+ *
+ * A run's ancestry is recorded by whoever created the run, in four different
+ * places: the run row's `parent_run_id`, `lineage_id`, and `round_ordinal`
+ * columns; the `flows_run_parents` edge a spawn writes; the `created` and
+ * `handed-off` run decisions the engine journals; and the `fork-created`
+ * marker time travel writes on a forked child. This module owns the one
+ * vocabulary they all project onto — {@link Origin} — and the pure functions
+ * that do the projecting, so the durable runtime and the watch stream cannot
+ * disagree about what a run's ancestry means.
+ *
+ * The two event types named here are produced by `@smthrs/engine-store` and
+ * `@smthrs/time-travel`. They are named as strings rather than imported
+ * because the control plane reads journals, not engines: a control plane that
+ * depended on the engine could not project a journal written by a different
+ * one.
+ *
+ * @since 0.1.0
+ */
+import { Schema } from "effect";
+import type { ControlEvent } from "./ControlSchema.ts";
+/**
+ * How a run came to exist.
+ *
+ * The three values are the lineage-edge kinds of
+ * `docs/pages/concepts/time-travel.md`: a `child` is a run its parent spawned, a
+ * `fork` is a run branched off a parent frame, and a `continuation` is a later
+ * round of one trampoline lineage. A rewind is deliberately absent — it
+ * truncates a run in place and creates none — and a run with no ancestor has
+ * no origin at all.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const Origin: Schema.Literals<readonly ["child", "fork", "continuation"]>;
+/**
+ * How a run came to exist.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Origin = typeof Origin.Type;
+/**
+ * The ancestry facts an origin is decided from.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Ancestry {
+    readonly parentRunId?: string | undefined;
+    readonly roundOrdinal?: number | undefined;
+    /** Whether a `fork-created` marker names this run. */
+    readonly forked?: boolean | undefined;
+}
+/**
+ * The journal event type carrying an engine run decision.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const runDecisionEventType = "flows.engine.run-decision";
+/**
+ * The journal event type time travel writes on a forked child.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const forkCreatedEventType = "flows.time-travel.fork-created";
+/**
+ * The kind `watch` reports a derived ancestry delta under.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const lineageEventType = "control.run.lineage";
+/**
+ * Decides how a run came to exist from its ancestry facts.
+ *
+ * A fork wins over a plain child because a fork records `parent_run_id` too:
+ * without the marker every fork would be reported as an ordinary child.
+ *
+ * @param ancestry the run's recorded ancestry
+ * @category projections
+ * @since 0.1.0
+ */
+export declare const originOf: (ancestry: Ancestry) => Origin | undefined;
+/**
+ * Derives the ancestry edge one journal entry discloses, if it discloses one.
+ *
+ * Three entries do, and each names a different pair:
+ *
+ * | Entry | Ancestor | Descendant |
+ * | --- | --- | --- |
+ * | `created` naming `parentExecutionId`, at round 0 or with no round | the spawning run | the entry's run |
+ * | `handed-off` naming `nextExecutionId` | the entry's run | the next round |
+ * | `fork-created` | the forked-from run | the entry's run |
+ *
+ * The handoff is what carries a trampoline, and a continuation round's own
+ * `created` decision is deliberately skipped. The engine journals BOTH in one
+ * transaction: `RunDriver` creates the next round with
+ * `{decision: "created", lineageId, roundOrdinal, parentExecutionId}` and then
+ * records `{decision: "handed-off", nextExecutionId}` on the round that
+ * finished. Both name the same pair, so deriving from both would report one
+ * run as a `child` of its predecessor on one entry and a `continuation` of it
+ * on the other. The handoff is the one kept, because it reaches a consumer
+ * watching the run that hands off — which is the run an operator is already
+ * following when a trampoline advances.
+ *
+ * A `created` decision at round 0, or with no round at all, is an ordinary
+ * spawn and derives a `child` edge.
+ *
+ * Everything else derives nothing. This is a projection over entries the
+ * control plane did not write, so an entry it does not recognize is not an
+ * error.
+ *
+ * @param event the projected journal entry
+ * @category projections
+ * @since 0.1.0
+ */
+export declare const derive: (event: ControlEvent) => ControlEvent | undefined;
+/**
+ * Expands one projected entry into itself plus any ancestry delta it
+ * discloses.
+ *
+ * @param event the projected journal entry
+ * @category projections
+ * @since 0.1.0
+ */
+export declare const expand: (event: ControlEvent) => ReadonlyArray<ControlEvent>;
+//# sourceMappingURL=Lineage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Lineage.d.ts","sourceRoot":"","sources":["../../src/Lineage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEtD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,6DAAqD,CAAA;AAExE;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACzC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1C,sDAAsD;IACtD,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CACtC;AAED;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,8BAA8B,CAAA;AAE/D;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,mCAAmC,CAAA;AAEpE;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,wBAAwB,CAAA;AAErD;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,GAAI,UAAU,QAAQ,KAAG,MAAM,GAAG,SAItD,CAAA;AAYD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,YAAY,KAAG,YAAY,GAAG,SA8C3D,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,YAAY,KAAG,aAAa,CAAC,YAAY,CAGtE,CAAA"}

package/dist/cjs/Lineage.js

@@ -0,0 +1,81 @@
+"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 Lineage_exports = {};
+__export(Lineage_exports, {
+  Origin: () => Origin,
+  derive: () => derive,
+  expand: () => expand,
+  forkCreatedEventType: () => forkCreatedEventType,
+  lineageEventType: () => lineageEventType,
+  originOf: () => originOf,
+  runDecisionEventType: () => runDecisionEventType
+});
+module.exports = __toCommonJS(Lineage_exports);
+var import_effect = require("effect");
+const Origin = import_effect.Schema.Literals(["child", "fork", "continuation"]);
+const runDecisionEventType = "flows.engine.run-decision";
+const forkCreatedEventType = "flows.time-travel.fork-created";
+const lineageEventType = "control.run.lineage";
+const originOf = (ancestry) => {
+  if (ancestry.forked === true) return "fork";
+  if (ancestry.roundOrdinal !== void 0 && ancestry.roundOrdinal > 0) return "continuation";
+  return ancestry.parentRunId === void 0 ? void 0 : "child";
+};
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+const text = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+const ordinal = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+const derive = (event) => {
+  if (event.runId === void 0) return void 0;
+  const payload = record(event.payload);
+  if (payload === void 0) return void 0;
+  const edge = event.kind === forkCreatedEventType ? { runId: event.runId, parentRunId: text(payload["parentRunId"]), forked: true } : event.kind !== runDecisionEventType ? void 0 : payload["decision"] === "created" ? (ordinal(payload["roundOrdinal"]) ?? 0) > 0 ? void 0 : { runId: event.runId, parentRunId: text(payload["parentExecutionId"]), forked: false } : payload["decision"] === "handed-off" ? {
+    runId: text(payload["nextExecutionId"]),
+    parentRunId: event.runId,
+    forked: false,
+    lineageId: text(payload["lineageId"]),
+    roundOrdinal: ordinal(payload["roundOrdinal"])
+  } : void 0;
+  if (edge === void 0 || edge.runId === void 0 || edge.parentRunId === void 0) return void 0;
+  const lineageId = "lineageId" in edge ? edge.lineageId : void 0;
+  const roundOrdinal = "roundOrdinal" in edge ? edge.roundOrdinal : void 0;
+  const origin = originOf({
+    parentRunId: edge.parentRunId,
+    ...roundOrdinal === void 0 ? {} : { roundOrdinal },
+    forked: edge.forked
+  });
+  return {
+    sequence: event.sequence,
+    kind: lineageEventType,
+    runId: event.runId,
+    occurredAt: event.occurredAt,
+    payload: {
+      runId: edge.runId,
+      parentRunId: edge.parentRunId,
+      ...lineageId === void 0 ? {} : { lineageId },
+      ...roundOrdinal === void 0 ? {} : { roundOrdinal },
+      /* v8 ignore next -- `originOf` answers nothing only without a parent, and the guard above already refused an edge with no parent */
+      ...origin === void 0 ? {} : { origin }
+    }
+  };
+};
+const expand = (event) => {
+  const derived = derive(event);
+  return derived === void 0 ? [event] : [event, derived];
+};
+//# sourceMappingURL=Lineage.js.map

package/dist/cjs/Lineage.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Lineage.ts"],
+  "sourcesContent": ["/**\n * Run ancestry as the control plane reads it.\n *\n * A run's ancestry is recorded by whoever created the run, in four different\n * places: the run row's `parent_run_id`, `lineage_id`, and `round_ordinal`\n * columns; the `flows_run_parents` edge a spawn writes; the `created` and\n * `handed-off` run decisions the engine journals; and the `fork-created`\n * marker time travel writes on a forked child. This module owns the one\n * vocabulary they all project onto \u2014 {@link Origin} \u2014 and the pure functions\n * that do the projecting, so the durable runtime and the watch stream cannot\n * disagree about what a run's ancestry means.\n *\n * The two event types named here are produced by `@smthrs/engine-store` and\n * `@smthrs/time-travel`. They are named as strings rather than imported\n * because the control plane reads journals, not engines: a control plane that\n * depended on the engine could not project a journal written by a different\n * one.\n *\n * @since 0.1.0\n */\n\nimport { Schema } from \"effect\"\nimport type { ControlEvent } from \"./ControlSchema.ts\"\n\n/**\n * How a run came to exist.\n *\n * The three values are the lineage-edge kinds of\n * `docs/pages/concepts/time-travel.md`: a `child` is a run its parent spawned, a\n * `fork` is a run branched off a parent frame, and a `continuation` is a later\n * round of one trampoline lineage. A rewind is deliberately absent \u2014 it\n * truncates a run in place and creates none \u2014 and a run with no ancestor has\n * no origin at all.\n *\n * @category models\n * @since 0.1.0\n */\nexport const Origin = Schema.Literals([\"child\", \"fork\", \"continuation\"])\n\n/**\n * How a run came to exist.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Origin = typeof Origin.Type\n\n/**\n * The ancestry facts an origin is decided from.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Ancestry {\n  readonly parentRunId?: string | undefined\n  readonly roundOrdinal?: number | undefined\n  /** Whether a `fork-created` marker names this run. */\n  readonly forked?: boolean | undefined\n}\n\n/**\n * The journal event type carrying an engine run decision.\n *\n * @category constants\n * @since 0.1.0\n */\nexport const runDecisionEventType = \"flows.engine.run-decision\"\n\n/**\n * The journal event type time travel writes on a forked child.\n *\n * @category constants\n * @since 0.1.0\n */\nexport const forkCreatedEventType = \"flows.time-travel.fork-created\"\n\n/**\n * The kind `watch` reports a derived ancestry delta under.\n *\n * @category constants\n * @since 0.1.0\n */\nexport const lineageEventType = \"control.run.lineage\"\n\n/**\n * Decides how a run came to exist from its ancestry facts.\n *\n * A fork wins over a plain child because a fork records `parent_run_id` too:\n * without the marker every fork would be reported as an ordinary child.\n *\n * @param ancestry the run's recorded ancestry\n * @category projections\n * @since 0.1.0\n */\nexport const originOf = (ancestry: Ancestry): Origin | undefined => {\n  if (ancestry.forked === true) return \"fork\"\n  if (ancestry.roundOrdinal !== undefined && ancestry.roundOrdinal > 0) return \"continuation\"\n  return ancestry.parentRunId === undefined ? undefined : \"child\"\n}\n\nconst record = (value: unknown): Readonly<Record<string, unknown>> | undefined =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value)\n    ? value as Readonly<Record<string, unknown>>\n    : undefined\n\nconst text = (value: unknown): string | undefined => typeof value === \"string\" && value.length > 0 ? value : undefined\n\nconst ordinal = (value: unknown): number | undefined =>\n  typeof value === \"number\" && Number.isSafeInteger(value) && value >= 0 ? value : undefined\n\n/**\n * Derives the ancestry edge one journal entry discloses, if it discloses one.\n *\n * Three entries do, and each names a different pair:\n *\n * | Entry | Ancestor | Descendant |\n * | --- | --- | --- |\n * | `created` naming `parentExecutionId`, at round 0 or with no round | the spawning run | the entry's run |\n * | `handed-off` naming `nextExecutionId` | the entry's run | the next round |\n * | `fork-created` | the forked-from run | the entry's run |\n *\n * The handoff is what carries a trampoline, and a continuation round's own\n * `created` decision is deliberately skipped. The engine journals BOTH in one\n * transaction: `RunDriver` creates the next round with\n * `{decision: \"created\", lineageId, roundOrdinal, parentExecutionId}` and then\n * records `{decision: \"handed-off\", nextExecutionId}` on the round that\n * finished. Both name the same pair, so deriving from both would report one\n * run as a `child` of its predecessor on one entry and a `continuation` of it\n * on the other. The handoff is the one kept, because it reaches a consumer\n * watching the run that hands off \u2014 which is the run an operator is already\n * following when a trampoline advances.\n *\n * A `created` decision at round 0, or with no round at all, is an ordinary\n * spawn and derives a `child` edge.\n *\n * Everything else derives nothing. This is a projection over entries the\n * control plane did not write, so an entry it does not recognize is not an\n * error.\n *\n * @param event the projected journal entry\n * @category projections\n * @since 0.1.0\n */\nexport const derive = (event: ControlEvent): ControlEvent | undefined => {\n  if (event.runId === undefined) return undefined\n  const payload = record(event.payload)\n  if (payload === undefined) return undefined\n  const edge = event.kind === forkCreatedEventType\n    ? { runId: event.runId, parentRunId: text(payload[\"parentRunId\"]), forked: true }\n    : event.kind !== runDecisionEventType\n    ? undefined\n    : payload[\"decision\"] === \"created\"\n    // A continuation round's `created` names its predecessor too. The handoff\n    // the previous round journals in the SAME transaction already discloses\n    // that edge, so deriving here as well would contradict it.\n    ? (ordinal(payload[\"roundOrdinal\"]) ?? 0) > 0\n      ? undefined\n      : { runId: event.runId, parentRunId: text(payload[\"parentExecutionId\"]), forked: false }\n    : payload[\"decision\"] === \"handed-off\"\n    ? {\n      runId: text(payload[\"nextExecutionId\"]),\n      parentRunId: event.runId,\n      forked: false,\n      lineageId: text(payload[\"lineageId\"]),\n      roundOrdinal: ordinal(payload[\"roundOrdinal\"])\n    }\n    : undefined\n  if (edge === undefined || edge.runId === undefined || edge.parentRunId === undefined) return undefined\n  const lineageId = \"lineageId\" in edge ? edge.lineageId : undefined\n  const roundOrdinal = \"roundOrdinal\" in edge ? edge.roundOrdinal : undefined\n  const origin = originOf({\n    parentRunId: edge.parentRunId,\n    ...(roundOrdinal === undefined ? {} : { roundOrdinal }),\n    forked: edge.forked\n  })\n  return {\n    sequence: event.sequence,\n    kind: lineageEventType,\n    runId: event.runId,\n    occurredAt: event.occurredAt,\n    payload: {\n      runId: edge.runId,\n      parentRunId: edge.parentRunId,\n      ...(lineageId === undefined ? {} : { lineageId }),\n      ...(roundOrdinal === undefined ? {} : { roundOrdinal }),\n      /* v8 ignore next -- `originOf` answers nothing only without a parent, and the guard above already refused an edge with no parent */\n      ...(origin === undefined ? {} : { origin })\n    }\n  }\n}\n\n/**\n * Expands one projected entry into itself plus any ancestry delta it\n * discloses.\n *\n * @param event the projected journal entry\n * @category projections\n * @since 0.1.0\n */\nexport const expand = (event: ControlEvent): ReadonlyArray<ControlEvent> => {\n  const derived = derive(event)\n  return derived === undefined ? [event] : [event, derived]\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBA,oBAAuB;AAgBhB,MAAM,SAAS,qBAAO,SAAS,CAAC,SAAS,QAAQ,cAAc,CAAC;AA6BhE,MAAM,uBAAuB;AAQ7B,MAAM,uBAAuB;AAQ7B,MAAM,mBAAmB;AAYzB,MAAM,WAAW,CAAC,aAA2C;AAClE,MAAI,SAAS,WAAW,KAAM,QAAO;AACrC,MAAI,SAAS,iBAAiB,UAAa,SAAS,eAAe,EAAG,QAAO;AAC7E,SAAO,SAAS,gBAAgB,SAAY,SAAY;AAC1D;AAEA,MAAM,SAAS,CAAC,UACd,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK,IAC/D,QACA;AAEN,MAAM,OAAO,CAAC,UAAuC,OAAO,UAAU,YAAY,MAAM,SAAS,IAAI,QAAQ;AAE7G,MAAM,UAAU,CAAC,UACf,OAAO,UAAU,YAAY,OAAO,cAAc,KAAK,KAAK,SAAS,IAAI,QAAQ;AAmC5E,MAAM,SAAS,CAAC,UAAkD;AACvE,MAAI,MAAM,UAAU,OAAW,QAAO;AACtC,QAAM,UAAU,OAAO,MAAM,OAAO;AACpC,MAAI,YAAY,OAAW,QAAO;AAClC,QAAM,OAAO,MAAM,SAAS,uBACxB,EAAE,OAAO,MAAM,OAAO,aAAa,KAAK,QAAQ,aAAa,CAAC,GAAG,QAAQ,KAAK,IAC9E,MAAM,SAAS,uBACf,SACA,QAAQ,UAAU,MAAM,aAIvB,QAAQ,QAAQ,cAAc,CAAC,KAAK,KAAK,IACxC,SACA,EAAE,OAAO,MAAM,OAAO,aAAa,KAAK,QAAQ,mBAAmB,CAAC,GAAG,QAAQ,MAAM,IACvF,QAAQ,UAAU,MAAM,eACxB;AAAA,IACA,OAAO,KAAK,QAAQ,iBAAiB,CAAC;AAAA,IACtC,aAAa,MAAM;AAAA,IACnB,QAAQ;AAAA,IACR,WAAW,KAAK,QAAQ,WAAW,CAAC;AAAA,IACpC,cAAc,QAAQ,QAAQ,cAAc,CAAC;AAAA,EAC/C,IACE;AACJ,MAAI,SAAS,UAAa,KAAK,UAAU,UAAa,KAAK,gBAAgB,OAAW,QAAO;AAC7F,QAAM,YAAY,eAAe,OAAO,KAAK,YAAY;AACzD,QAAM,eAAe,kBAAkB,OAAO,KAAK,eAAe;AAClE,QAAM,SAAS,SAAS;AAAA,IACtB,aAAa,KAAK;AAAA,IAClB,GAAI,iBAAiB,SAAY,CAAC,IAAI,EAAE,aAAa;AAAA,IACrD,QAAQ,KAAK;AAAA,EACf,CAAC;AACD,SAAO;AAAA,IACL,UAAU,MAAM;AAAA,IAChB,MAAM;AAAA,IACN,OAAO,MAAM;AAAA,IACb,YAAY,MAAM;AAAA,IAClB,SAAS;AAAA,MACP,OAAO,KAAK;AAAA,MACZ,aAAa,KAAK;AAAA,MAClB,GAAI,cAAc,SAAY,CAAC,IAAI,EAAE,UAAU;AAAA,MAC/C,GAAI,iBAAiB,SAAY,CAAC,IAAI,EAAE,aAAa;AAAA;AAAA,MAErD,GAAI,WAAW,SAAY,CAAC,IAAI,EAAE,OAAO;AAAA,IAC3C;AAAA,EACF;AACF;AAUO,MAAM,SAAS,CAAC,UAAqD;AAC1E,QAAM,UAAU,OAAO,KAAK;AAC5B,SAAO,YAAY,SAAY,CAAC,KAAK,IAAI,CAAC,OAAO,OAAO;AAC1D;",
+  "names": []
+}

package/dist/cjs/Migrations.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Control-plane and credential schema migrations.
+ *
+ * This package reserves the migration block immediately after time travel.
+ * Hosts compose this set with the journal and run-store sets before opening a
+ * shared control database.
+ *
+ * @since 0.1.0
+ */
+import * as DatabaseMigrations from "@smthrs/database/Migrations";
+import * as Layer from "effect/Layer";
+/**
+ * The control package's namespaced migration set.
+ *
+ * @category migrations
+ * @since 0.1.0
+ */
+export declare const set: DatabaseMigrations.MigrationSet;
+/**
+ * Creates every durable control-plane and credential table.
+ *
+ * @category migrations
+ * @since 0.1.0
+ */
+export declare const run: import("effect/Effect").Effect<readonly (readonly [id: number, name: string])[], import("effect/unstable/sql/SqlError").SqlError | import("effect/unstable/sql/Migrator").MigrationError, import("effect/unstable/sql/SqlClient").SqlClient>;
+/**
+ * Layer that runs control migrations before exposing the database to control
+ * services.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: Layer.Layer<never, import("effect/unstable/sql/SqlError").SqlError | import("effect/unstable/sql/Migrator").MigrationError, import("effect/unstable/sql/SqlClient").SqlClient>;
+//# sourceMappingURL=Migrations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Migrations.d.ts","sourceRoot":"","sources":["../../src/Migrations.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,kBAAkB,MAAM,6BAA6B,CAAA;AACjE,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AASrC;;;;;GAKG;AACH,eAAO,MAAM,GAAG,EAAE,kBAAkB,CAAC,YAYpC,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,GAAG,8OAAgC,CAAA;AAEhD;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,gLAA2B,CAAA"}

package/dist/cjs/Migrations.js

@@ -0,0 +1,60 @@
+"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 Migrations_exports = {};
+__export(Migrations_exports, {
+  layer: () => layer,
+  run: () => run,
+  set: () => set
+});
+module.exports = __toCommonJS(Migrations_exports);
+var DatabaseMigrations = __toESM(require("@smthrs/database/Migrations"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var import_control_tables = require("./migrations/0001_control_tables.js");
+var import_run_keys = require("./migrations/0002_run_keys.js");
+var import_signal_commands = require("./migrations/0003_signal_commands.js");
+var import_approval_decisions = require("./migrations/0004_approval_decisions.js");
+var import_signal_principals = require("./migrations/0005_signal_principals.js");
+var import_run_principals = require("./migrations/0006_run_principals.js");
+var import_resume_consent = require("./migrations/0007_resume_consent.js");
+const set = {
+  namespace: "control",
+  idOffset: DatabaseMigrations.idBlock * 6,
+  migrations: {
+    "0001_control_tables": import_control_tables.initial,
+    "0002_run_keys": import_run_keys.runKeys,
+    "0003_signal_commands": import_signal_commands.signalCommands,
+    "0004_approval_decisions": import_approval_decisions.approvalDecisions,
+    "0005_signal_principals": import_signal_principals.signalPrincipals,
+    "0006_run_principals": import_run_principals.runPrincipals,
+    "0007_resume_consent": import_resume_consent.resumeConsent
+  }
+};
+const run = DatabaseMigrations.run([set]);
+const layer = Layer.effectDiscard(run);
+//# sourceMappingURL=Migrations.js.map

package/dist/cjs/Migrations.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Migrations.ts"],
+  "sourcesContent": ["/**\n * Control-plane and credential schema migrations.\n *\n * This package reserves the migration block immediately after time travel.\n * Hosts compose this set with the journal and run-store sets before opening a\n * shared control database.\n *\n * @since 0.1.0\n */\n\nimport * as DatabaseMigrations from \"@smthrs/database/Migrations\"\nimport * as Layer from \"effect/Layer\"\nimport { initial } from \"./migrations/0001_control_tables.ts\"\nimport { runKeys } from \"./migrations/0002_run_keys.ts\"\nimport { signalCommands } from \"./migrations/0003_signal_commands.ts\"\nimport { approvalDecisions } from \"./migrations/0004_approval_decisions.ts\"\nimport { signalPrincipals } from \"./migrations/0005_signal_principals.ts\"\nimport { runPrincipals } from \"./migrations/0006_run_principals.ts\"\nimport { resumeConsent } from \"./migrations/0007_resume_consent.ts\"\n\n/**\n * The control package's namespaced migration set.\n *\n * @category migrations\n * @since 0.1.0\n */\nexport const set: DatabaseMigrations.MigrationSet = {\n  namespace: \"control\",\n  idOffset: DatabaseMigrations.idBlock * 6,\n  migrations: {\n    \"0001_control_tables\": initial,\n    \"0002_run_keys\": runKeys,\n    \"0003_signal_commands\": signalCommands,\n    \"0004_approval_decisions\": approvalDecisions,\n    \"0005_signal_principals\": signalPrincipals,\n    \"0006_run_principals\": runPrincipals,\n    \"0007_resume_consent\": resumeConsent\n  }\n}\n\n/**\n * Creates every durable control-plane and credential table.\n *\n * @category migrations\n * @since 0.1.0\n */\nexport const run = DatabaseMigrations.run([set])\n\n/**\n * Layer that runs control migrations before exposing the database to control\n * services.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer = Layer.effectDiscard(run)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,yBAAoC;AACpC,YAAuB;AACvB,4BAAwB;AACxB,sBAAwB;AACxB,6BAA+B;AAC/B,gCAAkC;AAClC,+BAAiC;AACjC,4BAA8B;AAC9B,4BAA8B;AAQvB,MAAM,MAAuC;AAAA,EAClD,WAAW;AAAA,EACX,UAAU,mBAAmB,UAAU;AAAA,EACvC,YAAY;AAAA,IACV,uBAAuB;AAAA,IACvB,iBAAiB;AAAA,IACjB,wBAAwB;AAAA,IACxB,2BAA2B;AAAA,IAC3B,0BAA0B;AAAA,IAC1B,uBAAuB;AAAA,IACvB,uBAAuB;AAAA,EACzB;AACF;AAQO,MAAM,MAAM,mBAAmB,IAAI,CAAC,GAAG,CAAC;AASxC,MAAM,QAAQ,MAAM,cAAc,GAAG;",
+  "names": []
+}

package/dist/cjs/Monitor.d.ts

@@ -0,0 +1,282 @@
+/**
+ * Run health over the control plane: what a run's state means, and what to do
+ * about it.
+ *
+ * A control plane answers "what is this run doing". A monitor answers the
+ * question after it — "is that all right, and if not, what now" — and the two
+ * are deliberately separate modules. {@link classify} is a pure function of
+ * one observation, so the vocabulary an operator reads on a dashboard is the
+ * same one a heal loop branches on and the same one a test can enumerate.
+ * {@link run} is the loop that beats over `Control` and journals what it saw.
+ *
+ * The classification is decided from durable evidence only: the run summary
+ * the control plane projects, and the journal entries `watch` replays. Nothing
+ * here reads an in-process fiber, which is what makes a monitor able to watch
+ * a run in another process at all.
+ *
+ * @since 0.1.0
+ */
+import { Journal } from "@smthrs/journal";
+import { Effect } from "effect";
+import { Control } from "./Control.ts";
+import type { ControlError } from "./ControlError.ts";
+import type { ControlEvent, Receipt, RunId, RunSummary } from "./ControlSchema.ts";
+import * as SubjectHealth from "./Health.ts";
+/**
+ * The journal event type the engine records when an action attempt starts.
+ *
+ * Named as a string rather than imported, exactly as in `Lineage`: a monitor
+ * reads journals, not engines.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const attemptStartedEventType = "flows.engine.attempt-started";
+/**
+ * The journal event type the engine records when an action attempt settles.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const attemptFinishedEventType = "flows.engine.attempt-finished";
+/**
+ * The journal event type one monitor beat is recorded under.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const beatEventType = "control.monitor.beat";
+/**
+ * The journal event type one applied remedy is recorded under.
+ *
+ * A beat and a heal are two records because they are two facts, and only one
+ * of them is true before the remedy runs. A single record carrying `healed`
+ * has to be written either before the remedy — leaving durable evidence of a
+ * heal that a crash one instruction later never performed — or after it, which
+ * loses the evidence of what a monitor decided when the remedy is what killed
+ * it. Splitting them keeps both.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const healedEventType = "control.monitor.healed";
+/**
+ * What a run looks like to a monitor.
+ *
+ * `healthy` covers both "moving" and "finished": a completed run needs nothing
+ * done to it, and neither does one that is making progress. The other six name
+ * a specific thing that is wrong, because a heal that cannot tell them apart
+ * would resume a run that is waiting for a human.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const Health: import("effect/Schema").Literals<readonly ["healthy", "stalled", "wedged-node", "runaway-loop", "awaiting-human", "failing", "unknown"]>;
+/**
+ * What a run looks like to a monitor.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Health = typeof Health.Type;
+/**
+ * Everything one classification is decided from.
+ *
+ * `events` is the run's journal as `watch` projects it, oldest first.
+ * `beatsWithoutProgress` counts consecutive beats that added no entry, and
+ * `stallBeats` is how many of those make a stall. Splitting the count from the
+ * threshold is what lets the same pure function serve a monitor that beats
+ * every second and one that beats every hour.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Observation {
+    /** The run's projection, or nothing when the control plane has no such run. */
+    readonly summary?: RunSummary | undefined;
+    readonly events: ReadonlyArray<ControlEvent>;
+    readonly beatsWithoutProgress: number;
+    readonly stallBeats: number;
+    /**
+     * The trampoline round at which a lineage stops being a loop and starts
+     * being a runaway. A run past it is looping without converging.
+     */
+    readonly roundBound?: number | undefined;
+    /** Fresh, explicitly reported semantic work; never inferred from bytes or monitor events. */
+    readonly semanticProgress?: boolean | undefined;
+}
+/**
+ * Decides what a run's state means.
+ *
+ * The order is the order an operator would read it in, and each rule earns its
+ * place by naming a different response:
+ *
+ * | Condition | Health | Because |
+ * | --- | --- | --- |
+ * | No summary | `unknown` | Nothing to say, and nothing to do. |
+ * | `failed` | `failing` | The run itself reported the failure. |
+ * | `completed`, `cancelled` | `healthy` | A finished run needs nothing. |
+ * | `waiting-approval`, or parked on `approval` | `awaiting-human` | A human owes it an answer; no machine can supply one. |
+ * | Parked with no waiting reason | `awaiting-human` | Only an operator's own park writes no waiting reason, so a person stopped it and a person restarts it. |
+ * | `roundOrdinal` at or past the bound | `runaway-loop` | The lineage is looping without converging. |
+ * | The last settled attempt failed | `failing` | The run is still alive but its work is not landing. |
+ * | No progress for `stallBeats`, an attempt open | `wedged-node` | One attempt started and never settled: the work is stuck, not the run. |
+ * | No progress for `stallBeats` | `stalled` | Nothing is happening and nothing is in flight. |
+ * | Anything else | `healthy` | Entries are still arriving. |
+ *
+ * `awaiting-human` deliberately outranks `failing`: a run parked for approval
+ * after a failed attempt is waiting for a person, and resuming or cancelling
+ * it would take the decision away from them.
+ *
+ * A park with no reason is the same case. The engine names every park it makes
+ * — `event`, `approval`, `timer`, `quota`, `released` — so a parked run whose
+ * `waitingReason` is absent was parked by an operator through
+ * `ControlRuntime.writeStatus`. Calling that a stall and resuming it would undo
+ * a deliberate act, which is the worst thing an unattended heal loop can do.
+ *
+ * @param observation what the beat saw
+ * @category projections
+ * @since 0.1.0
+ */
+export declare const classify: (observation: Observation) => Health;
+/**
+ * What a monitor does about one unhealthy run.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Remedy = "resume" | "cancel" | "none";
+/**
+ * The remedy a health warrants, before `autoHeal` decides whether to apply it.
+ *
+ * A stalled or wedged run is one nobody is driving, and a resume claims it. A
+ * failing or runaway run is one that will not get better by being driven
+ * harder. Everything else is left alone.
+ *
+ * @param health what the beat classified
+ * @category projections
+ * @since 0.1.0
+ */
+export declare const remedyFor: (health: Health) => Remedy;
+/**
+ * One beat of a monitor.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Beat {
+    /** Which beat this was, counting from zero. */
+    readonly beat: number;
+    readonly health: Health;
+    /** The newest journal sequence the run had, ignoring the monitor's own records. */
+    readonly sequence: number;
+    /**
+     * The remedy that ran and returned, absent when none did.
+     *
+     * Present only after the heal succeeded, which is also when
+     * `control.monitor.healed` is journaled. A beat that decided on a remedy the
+     * monitor never got to apply reports nothing here.
+     */
+    readonly healed?: Remedy | undefined;
+    /** The receipt the remedy returned, absent when none was applied. */
+    readonly receipt?: Receipt | undefined;
+}
+/**
+ * What a monitor found.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Report {
+    readonly runId: RunId;
+    readonly beats: ReadonlyArray<Beat>;
+    /** The last beat's health, or `unknown` when no beat ran. */
+    readonly health: Health;
+}
+/**
+ * How a monitor beats.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Options {
+    readonly runId: RunId;
+    /** Optional configured observational checker; checker results never authorize a remedy. */
+    readonly healthCheck?: SubjectHealth.ResolvedCheck | undefined;
+    /** Shared host admission limit around probes. */
+    readonly withProbePermit?: (<A>(effect: Effect.Effect<A>) => Effect.Effect<A>) | undefined;
+    /** Bounded retained beat history for long-lived host monitoring. */
+    readonly retainBeats?: number | undefined;
+    /** Hosts with structured status observations omit redundant legacy heartbeat records. */
+    readonly recordBeats?: boolean | undefined;
+    /**
+     * Who is watching. Defaults to `default`.
+     *
+     * It reaches the journal twice: as the source of every record this monitor
+     * writes, and as `monitorId` in each payload. Two monitors pointed at one
+     * run both beat and both remedy — nothing on the control plane leases a run
+     * to one watcher — so the identity is what makes their evidence tellable
+     * apart, and what keeps their remedies on separate idempotency keys.
+     */
+    readonly monitorId?: string | undefined;
+    /** How long to wait between beats. Defaults to one second. */
+    readonly intervalMs?: number | undefined;
+    /** How many beats to take before reporting. Defaults to ten. */
+    readonly maxChecks?: number | undefined;
+    /** How many beats without progress make a stall. Defaults to three. */
+    readonly stallBeats?: number | undefined;
+    /** The round at which a trampoline is a runaway. Defaults to 32. */
+    readonly roundBound?: number | undefined;
+    /** Which healths the monitor is allowed to act on. Defaults to none. */
+    readonly autoHeal?: ReadonlyArray<Health> | undefined;
+    /**
+     * What to do about an unhealthy run. Defaults to `Control.resume` and
+     * `Control.cancel` per {@link remedyFor}.
+     *
+     * A heal that fails does not abort the monitor: the failure is logged, the
+     * beat is recorded without `healed` or `receipt`, and the loop moves to the
+     * next beat, where the stall evidence still stands and the remedy is
+     * retried under that beat's own idempotency key.
+     */
+    readonly heal?: (input: {
+        readonly runId: RunId;
+        readonly health: Health;
+        readonly remedy: Remedy;
+        readonly beat: number;
+    }) => Effect.Effect<Receipt, ControlError>;
+}
+/**
+ * Watches one run and, when told to, heals it.
+ *
+ * The loop stops early on a terminal run, because a finished run has nothing
+ * left to observe and beating at it would fill its journal with heartbeats.
+ * Otherwise it takes `maxChecks` beats and reports what it saw.
+ *
+ * Every beat is journaled as `control.monitor.beat` before any remedy is
+ * applied, carrying the `remedy` it is about to attempt, so a monitor that
+ * crashes mid-heal leaves the evidence of what it decided. The remedy itself
+ * is journaled separately as `control.monitor.healed`, and only once the heal
+ * returned a receipt: a heal that failed, or a process that died running one,
+ * must not leave a durable record saying the run was healed.
+ *
+ * `autoHeal` is empty by default. A monitor that healed by default would be a
+ * monitor that cancels a run the first time it looks at one, which is the
+ * wrong default for a thing an operator points at production.
+ *
+ * Nothing here leases the run. Two monitors on one run both beat and both
+ * remedy, so a remedy has to be idempotent on the control plane — which the
+ * two defaults are, through `Control.resume` and `Control.cancel`
+ * idempotency keys that name the monitor, the run, and the beat. A custom
+ * `heal` owes the same property.
+ *
+ * @param options how to beat and what to heal
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const run: (options: Options) => Effect.Effect<Report, ControlError, Control | Journal.Journal>;
+/** Observer and notification bookkeeping is never execution progress.
+ * @category predicates
+ * @since 1.0.0
+ */
+export declare const isBookkeepingEvent: (kind: string) => boolean;
+//# sourceMappingURL=Monitor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Monitor.d.ts","sourceRoot":"","sources":["../../src/Monitor.ts"],"names":[],"mappings":"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"}