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

package/dist/cjs/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": ["/**\n * Control-plane contracts and projections for the Smithers harness.\n *\n * This is the public surface of the control plane: the transport-independent\n * `Control` service, the `ControlRuntime` port it writes through, the\n * projections it reads back, and the durable adapter that binds both to a real\n * database.\n *\n * `Control` is authority, not execution. Every mutation it accepts is\n * idempotent, principal-stamped, and recorded in the journal beside the state\n * change it caused, so \"who asked for this, and when did it take effect?\" is\n * answered from persisted evidence rather than from a log line.\n *\n * @since 0.1.0\n */\n\n/**\n * @category services\n * @since 0.1.0\n */\nexport * as Control from \"./Control.ts\"\n\n/**\n * @category services\n * @since 1.0.0\n */\nexport * as ApprovalAuthority from \"./ApprovalAuthority.ts\"\n\n/**\n * @category errors\n * @since 0.1.0\n */\nexport * as ControlError from \"./ControlError.ts\"\n\n/**\n * @category models\n * @since 0.1.0\n */\nexport * as ControlSchema from \"./ControlSchema.ts\"\n\n/**\n * @category projections\n * @since 0.1.0\n */\nexport * as Cancellation from \"./Cancellation.ts\"\n\n/**\n * @category projections\n * @since 0.1.0\n */\nexport * as Lineage from \"./Lineage.ts\"\n\n/**\n * @category projections\n * @since 0.1.0\n */\nexport * as Monitor from \"./Monitor.ts\"\n\n/**\n * @category projections\n * @since 0.1.0\n */\nexport * as Steering from \"./Steering.ts\"\n\n/**\n * @category services\n * @since 0.1.0\n */\nexport * as ControlRuntime from \"./ControlRuntime.ts\"\n\n/**\n * @category services\n * @since 0.1.0\n */\nexport * as ControlExecutor from \"./ControlExecutor.ts\"\n\n/**\n * @category services\n * @since 1.0.0\n */\nexport * as DispatchReader from \"./DispatchReader.ts\"\n\n/**\n * @category layers\n * @since 0.1.0\n */\nexport * as ControlLive from \"./ControlLive.ts\"\n\n/**\n * @category models\n * @since 0.1.0\n */\nexport * as SystemFlows from \"./SystemFlows.ts\"\n\n/**\n * @category rpc\n * @since 0.1.0\n */\nexport * as ControlRpcs from \"./ControlRpcs.ts\"\n\n/**\n * @category layers\n * @since 0.1.0\n */\nexport * as ControlServer from \"./ControlServer.ts\"\n\n/**\n * @category layers\n * @since 0.1.0\n */\nexport * as ControlClient from \"./ControlClient.ts\"\n\n/**\n * @category services\n * @since 0.1.0\n */\nexport * as Channels from \"./Channels.ts\"\n\n/**\n * @category channels\n * @since 0.1.0\n */\nexport * as WebhookChannel from \"./WebhookChannel.ts\"\n\n/**\n * @category services\n * @since 0.1.0\n */\nexport * as Credential from \"./Credential.ts\"\n\n/**\n * @category services\n * @since 0.1.0\n */\nexport * as CredentialCipher from \"./CredentialCipher.ts\"\n\n/**\n * @category services\n * @since 0.1.0\n */\nexport * as CredentialStore from \"./CredentialStore.ts\"\n\n/**\n * @category layers\n * @since 0.1.0\n */\nexport * as SqlCredentialStore from \"./SqlCredentialStore.ts\"\n\n/**\n * @category layers\n * @since 0.1.0\n */\nexport * as WebCryptoCipher from \"./WebCryptoCipher.ts\"\n\n/**\n * @category layers\n * @since 0.1.0\n */\nexport * as SqlControlRuntime from \"./SqlControlRuntime.ts\"\n\n/**\n * @category authentication\n * @since 1.0.0\n */\nexport * as ScopedToken from \"./ScopedToken.ts\"\n\n/**\n * @category migrations\n * @since 0.1.0\n */\nexport * as Migrations from \"./Migrations.ts\"\n\n/**\n * Observational health contracts.\n * @category health\n * @since 1.0.0\n */\nexport * as Health from \"./Health.ts\"\n\n/**\n * The Jev-decided session checker a host binds as `jev.session`.\n * @category health\n * @since 1.0.0\n */\nexport * as JevSessionChecker from \"./JevSessionChecker.ts\"\n\n/** Versioned control lifecycle producer and projection contract. */\nexport * as ControlFacts from \"./ControlFacts.ts\"\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBA,cAAyB;AAMzB,wBAAmC;AAMnC,mBAA8B;AAM9B,oBAA+B;AAM/B,mBAA8B;AAM9B,cAAyB;AAMzB,cAAyB;AAMzB,eAA0B;AAM1B,qBAAgC;AAMhC,sBAAiC;AAMjC,qBAAgC;AAMhC,kBAA6B;AAM7B,kBAA6B;AAM7B,kBAA6B;AAM7B,oBAA+B;AAM/B,oBAA+B;AAM/B,eAA0B;AAM1B,qBAAgC;AAMhC,iBAA4B;AAM5B,uBAAkC;AAMlC,sBAAiC;AAMjC,yBAAoC;AAMpC,sBAAiC;AAMjC,wBAAmC;AAMnC,kBAA6B;AAM7B,iBAA4B;AAO5B,aAAwB;AAOxB,wBAAmC;AAGnC,mBAA8B;",
+  "names": []
+}

package/dist/cjs/internal/MutationBoundary.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Bounded inert JSON admission for control mutations.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+import * as BoundedJson from "@smthrs/canonical/BoundedJson";
+/** Result of admitting an unknown mutation value. */
+type Result = {
+    readonly ok: true;
+    readonly value: BoundedJson.Json;
+} | {
+    readonly ok: false;
+    readonly complaint: string;
+};
+/**
+ * Copies one mutation without invoking getters or `toJSON`.
+ *
+ * `bounds` defaults to the control mutation limits. Tests pass smaller ones to
+ * reach a byte-exact boundary without building multi-megabyte values.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const admit: (input: unknown, bounds?: BoundedJson.Limits) => Result;
+export {};
+//# sourceMappingURL=MutationBoundary.d.ts.map

package/dist/cjs/internal/MutationBoundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MutationBoundary.d.ts","sourceRoot":"","sources":["../../../src/internal/MutationBoundary.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,WAAW,MAAM,+BAA+B,CAAA;AAa5D,qDAAqD;AACrD,KAAK,MAAM,GACP;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,IAAI,CAAA;CAAE,GACvD;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAA;AAEtD;;;;;;;;GAQG;AACH,eAAO,MAAM,KAAK,GAAI,OAAO,OAAO,EAAE,SAAQ,WAAW,CAAC,MAAe,KAAG,MAW3E,CAAA"}

package/dist/cjs/internal/MutationBoundary.js

@@ -0,0 +1,50 @@
+"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 MutationBoundary_exports = {};
+__export(MutationBoundary_exports, {
+  admit: () => admit
+});
+module.exports = __toCommonJS(MutationBoundary_exports);
+var BoundedJson = __toESM(require("@smthrs/canonical/BoundedJson"), 1);
+const limits = {
+  maxBytes: 4 * 1024 * 1024,
+  maxStringBytes: 4 * 1024 * 1024,
+  maxKeyBytes: 4 * 1024 * 1024,
+  maxDepth: 128,
+  maxNodes: 1e5,
+  maxMembers: 1e5,
+  maxTotalMembers: 1e5
+};
+const admit = (input, bounds = limits) => {
+  const result = BoundedJson.admit(input, bounds, { preflightObjects: false });
+  if (result.ok) return { ok: true, value: result.value };
+  const complaint = result.code === "members" ? `contains more than ${bounds.maxTotalMembers} JSON members` : result.code === "string" ? "contains oversized or ill-formed text" : result.code === "key" ? "contains an oversized or ill-formed object key" : result.complaint;
+  return { ok: false, complaint };
+};
+//# sourceMappingURL=MutationBoundary.js.map

package/dist/cjs/internal/MutationBoundary.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/MutationBoundary.ts"],
+  "sourcesContent": ["/**\n * Bounded inert JSON admission for control mutations.\n *\n * @since 1.0.0-rc.0\n * @private\n */\n\nimport * as BoundedJson from \"@smthrs/canonical/BoundedJson\"\n\n/** Limits and diagnostic precedence of the control mutation boundary. */\nconst limits = {\n  maxBytes: 4 * 1024 * 1024,\n  maxStringBytes: 4 * 1024 * 1024,\n  maxKeyBytes: 4 * 1024 * 1024,\n  maxDepth: 128,\n  maxNodes: 100_000,\n  maxMembers: 100_000,\n  maxTotalMembers: 100_000\n} satisfies BoundedJson.Limits\n\n/** Result of admitting an unknown mutation value. */\ntype Result =\n  | { readonly ok: true; readonly value: BoundedJson.Json }\n  | { readonly ok: false; readonly complaint: string }\n\n/**\n * Copies one mutation without invoking getters or `toJSON`.\n *\n * `bounds` defaults to the control mutation limits. Tests pass smaller ones to\n * reach a byte-exact boundary without building multi-megabyte values.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const admit = (input: unknown, bounds: BoundedJson.Limits = limits): Result => {\n  const result = BoundedJson.admit(input, bounds, { preflightObjects: false })\n  if (result.ok) return { ok: true, value: result.value }\n  const complaint = result.code === \"members\"\n    ? `contains more than ${bounds.maxTotalMembers} JSON members`\n    : result.code === \"string\"\n    ? \"contains oversized or ill-formed text\"\n    : result.code === \"key\"\n    ? \"contains an oversized or ill-formed object key\"\n    : result.complaint\n  return { ok: false, complaint }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,kBAA6B;AAG7B,MAAM,SAAS;AAAA,EACb,UAAU,IAAI,OAAO;AAAA,EACrB,gBAAgB,IAAI,OAAO;AAAA,EAC3B,aAAa,IAAI,OAAO;AAAA,EACxB,UAAU;AAAA,EACV,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,iBAAiB;AACnB;AAgBO,MAAM,QAAQ,CAAC,OAAgB,SAA6B,WAAmB;AACpF,QAAM,SAAS,YAAY,MAAM,OAAO,QAAQ,EAAE,kBAAkB,MAAM,CAAC;AAC3E,MAAI,OAAO,GAAI,QAAO,EAAE,IAAI,MAAM,OAAO,OAAO,MAAM;AACtD,QAAM,YAAY,OAAO,SAAS,YAC9B,sBAAsB,OAAO,eAAe,kBAC5C,OAAO,SAAS,WAChB,0CACA,OAAO,SAAS,QAChB,mDACA,OAAO;AACX,SAAO,EAAE,IAAI,OAAO,UAAU;AAChC;",
+  "names": []
+}

package/dist/cjs/internal/activeFibers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Completion-aware, replacement-safe ownership of live fibers.
+ * @since 1.0.0
+ */
+import type * as Fiber from "effect/Fiber";
+/**
+ * A completed predecessor must never unregister its replacement.
+ * @category registration
+ * @since 1.0.0
+ */
+export declare const register: <K>(fibers: Map<K, Fiber.Fiber<unknown, unknown>>, key: K, fiber: Fiber.Fiber<unknown, unknown>) => void;
+//# sourceMappingURL=activeFibers.d.ts.map

package/dist/cjs/internal/activeFibers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activeFibers.d.ts","sourceRoot":"","sources":["../../../src/internal/activeFibers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAE1C;;;;GAIG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EACxB,QAAQ,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,EAC7C,KAAK,CAAC,EACN,OAAO,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,KACnC,IAKF,CAAA"}

package/dist/cjs/internal/activeFibers.js

@@ -0,0 +1,30 @@
+"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 activeFibers_exports = {};
+__export(activeFibers_exports, {
+  register: () => register
+});
+module.exports = __toCommonJS(activeFibers_exports);
+const register = (fibers, key, fiber) => {
+  fibers.set(key, fiber);
+  fiber.addObserver(() => {
+    if (fibers.get(key) === fiber) fibers.delete(key);
+  });
+};
+//# sourceMappingURL=activeFibers.js.map

package/dist/cjs/internal/activeFibers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/activeFibers.ts"],
+  "sourcesContent": ["/**\n * Completion-aware, replacement-safe ownership of live fibers.\n * @since 1.0.0\n */\n\nimport type * as Fiber from \"effect/Fiber\"\n\n/**\n * A completed predecessor must never unregister its replacement.\n * @category registration\n * @since 1.0.0\n */\nexport const register = <K>(\n  fibers: Map<K, Fiber.Fiber<unknown, unknown>>,\n  key: K,\n  fiber: Fiber.Fiber<unknown, unknown>\n): void => {\n  fibers.set(key, fiber)\n  fiber.addObserver(() => {\n    if (fibers.get(key) === fiber) fibers.delete(key)\n  })\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAYO,MAAM,WAAW,CACtB,QACA,KACA,UACS;AACT,SAAO,IAAI,KAAK,KAAK;AACrB,QAAM,YAAY,MAAM;AACtB,QAAI,OAAO,IAAI,GAAG,MAAM,MAAO,QAAO,OAAO,GAAG;AAAA,EAClD,CAAC;AACH;",
+  "names": []
+}

package/dist/cjs/internal/issues.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Bounded diagnostics for failures that cross the control wire boundary.
+ *
+ * @since 0.1.0
+ */
+/**
+ * Joins a stable location and reason without allowing an RPC error to grow
+ * without bound.
+ *
+ * @private
+ * @since 0.1.0
+ */
+export declare const cappedIssue: (path: string, reason: string) => string;
+/**
+ * Renders canonical's stable located failure without copying its rejected
+ * value or a nested cause message into an RPC error.
+ *
+ * @private
+ * @since 0.1.0
+ */
+export declare const canonicalIssue: (cause: unknown) => string;
+/**
+ * Finds the first rejected field without rendering its value.
+ * @private
+ * @since 0.1.0
+ */
+export { firstPath as schemaIssuePath } from "@smthrs/canonical/IssuePath";
+//# sourceMappingURL=issues.d.ts.map

package/dist/cjs/internal/issues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issues.d.ts","sourceRoot":"","sources":["../../../src/internal/issues.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,EAAE,QAAQ,MAAM,KAAG,MAG1D,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,OAAO,KAAG,MAGC,CAAA;AAEjD;;;;GAIG;AACH,OAAO,EAAE,SAAS,IAAI,eAAe,EAAE,MAAM,6BAA6B,CAAA"}

package/dist/cjs/internal/issues.js

@@ -0,0 +1,34 @@
+"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 issues_exports = {};
+__export(issues_exports, {
+  canonicalIssue: () => canonicalIssue,
+  cappedIssue: () => cappedIssue,
+  schemaIssuePath: () => import_IssuePath.firstPath
+});
+module.exports = __toCommonJS(issues_exports);
+var import_canonical = require("@smthrs/canonical");
+var import_IssuePath = require("@smthrs/canonical/IssuePath");
+const maximumIssueLength = 512;
+const cappedIssue = (path, reason) => {
+  const issue = `${path}: ${reason}`;
+  return issue.length <= maximumIssueLength ? issue : `${issue.slice(0, maximumIssueLength - 3)}...`;
+};
+const canonicalIssue = (cause) => cause instanceof import_canonical.CanonicalError ? cappedIssue(cause.path, cause.code) : cappedIssue("$", "canonicalization failed");
+//# sourceMappingURL=issues.js.map

package/dist/cjs/internal/issues.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/issues.ts"],
+  "sourcesContent": ["/**\n * Bounded diagnostics for failures that cross the control wire boundary.\n *\n * @since 0.1.0\n */\n\nimport { CanonicalError } from \"@smthrs/canonical\"\n\nconst maximumIssueLength = 512\n\n/**\n * Joins a stable location and reason without allowing an RPC error to grow\n * without bound.\n *\n * @private\n * @since 0.1.0\n */\nexport const cappedIssue = (path: string, reason: string): string => {\n  const issue = `${path}: ${reason}`\n  return issue.length <= maximumIssueLength ? issue : `${issue.slice(0, maximumIssueLength - 3)}...`\n}\n\n/**\n * Renders canonical's stable located failure without copying its rejected\n * value or a nested cause message into an RPC error.\n *\n * @private\n * @since 0.1.0\n */\nexport const canonicalIssue = (cause: unknown): string =>\n  cause instanceof CanonicalError\n    ? cappedIssue(cause.path, cause.code)\n    : cappedIssue(\"$\", \"canonicalization failed\")\n\n/**\n * Finds the first rejected field without rendering its value.\n * @private\n * @since 0.1.0\n */\nexport { firstPath as schemaIssuePath } from \"@smthrs/canonical/IssuePath\"\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,uBAA+B;AAiC/B,uBAA6C;AA/B7C,MAAM,qBAAqB;AASpB,MAAM,cAAc,CAAC,MAAc,WAA2B;AACnE,QAAM,QAAQ,GAAG,IAAI,KAAK,MAAM;AAChC,SAAO,MAAM,UAAU,qBAAqB,QAAQ,GAAG,MAAM,MAAM,GAAG,qBAAqB,CAAC,CAAC;AAC/F;AASO,MAAM,iBAAiB,CAAC,UAC7B,iBAAiB,kCACb,YAAY,MAAM,MAAM,MAAM,IAAI,IAClC,YAAY,KAAK,yBAAyB;",
+  "names": []
+}

package/dist/cjs/internal/planning.d.ts

@@ -0,0 +1,347 @@
+/**
+ * Plan construction shared by every `ControlRuntime` implementation.
+ *
+ * The plan digest is what an approval is bound to, so the memory runtime and
+ * the durable runtime must compute it the same way or an approval taken on one
+ * would not validate on the other. Keeping the construction here is what makes
+ * that a compile-time fact rather than a convention.
+ *
+ * @since 0.1.0
+ */
+import type * as PersistedPlan from "@smthrs/plan/Plan";
+import { Effect } from "effect";
+import type { PlanInput } from "../Control.ts";
+import { CodeDrift } from "../ControlError.ts";
+import type { Envelope, FlowId, IdempotencyKey, PlanGraph, PlanNode, Principal, Receipt, RunId, RunSummary } from "../ControlSchema.ts";
+/**
+ * The drift between the code a run recorded and the code that would resume
+ * it, or `undefined` when there is none. A run that recorded no digest (a flow
+ * without one, or a row older than the field) is not checked for flow drift,
+ * and one that recorded no engine version is not checked for engine drift.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const codeDriftOf: (run: RunSummary, flow: {
+    readonly executionDigest?: string | undefined;
+} | undefined, engineVersion: string | undefined) => CodeDrift | undefined;
+/**
+ * The code identity a resume the operator allowed to drift records on the run,
+ * so later checks compare against the code it now runs.
+ *
+ * @since 1.0.0
+ * @private
+ */
+export declare const adoptedCode: (run: RunSummary, flow: {
+    readonly executionDigest?: string | undefined;
+} | undefined, engineVersion: string | undefined) => Pick<RunSummary, "executionDigest" | "engineVersion">;
+/**
+ * The envelope a flow with no declared capabilities carries.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export declare const emptyEnvelope: Envelope;
+/**
+ * Canonical bytes for a value.
+ * Throws on a non-serializable value; every caller either wraps it in
+ * `Effect.try` or has already validated the value.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export declare const canonical: (value: unknown) => string;
+/**
+ * The durable key a caller's idempotency key is stored under.
+ *
+ * Namespaced by the effective actor: the submitted principal, or the runtime's
+ * configured fallback when the caller named none. The principal's clock is
+ * omitted, so an equal retry lands on the same key.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export declare const mutationKey: (operation: string, key: IdempotencyKey, principal: Pick<Principal, "id" | "kind">) => string;
+/**
+ * The content digest of a value's canonical bytes.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export declare const digest: (value: unknown) => Effect.Effect<string & import("effect/Brand").Brand<"@smthrs/crypto/Sha256/Digest">, never, import("effect/Crypto").Crypto>;
+/**
+ * Envelope equality by canonical bytes, not by reference or key order.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export declare const sameEnvelope: (left: Envelope, right: Envelope) => boolean;
+/**
+ * A flow's envelope with a planner's budget fields laid over its declared ones.
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+export declare const budgeted: (envelope: Envelope, budget: Envelope["budget"] | undefined) => Envelope;
+/**
+ * What one plan request asks for, for idempotency: a key replayed with another
+ * budget is another plan.
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+export declare const planFingerprint: (input: PlanInput) => string;
+/**
+ * An accepted receipt, carrying a run id when one exists.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export declare const accepted: (receiptId: string, runId?: RunId) => Receipt;
+/**
+ * The receipt a replayed mutation returns, derived from the recorded one.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export declare const alreadyApplied: (key: IdempotencyKey, receipt: Receipt) => Receipt;
+/**
+ * The plan inputs a card is derived from.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export interface PlanSource {
+    readonly planId: string;
+    readonly flowId: FlowId;
+    readonly decodedInput: unknown;
+    readonly envelope: Envelope;
+    readonly deployClass: boolean;
+    readonly executionDigest?: string | undefined;
+    /** The persisted plan value and cache verdicts produced by the host. */
+    readonly handoff?: {
+        readonly plan: PersistedPlan.Plan;
+        readonly statuses?: Readonly<Record<string, PlanNode["status"]>> | undefined;
+        readonly graph?: PlanGraph | undefined;
+    } | undefined;
+    readonly idempotencyKey?: IdempotencyKey | undefined;
+}
+/**
+ * Builds the immutable plan card and the approval target bound to its digest.
+ *
+ * @since 0.1.0
+ * @private
+ */
+export declare const planCard: (source: PlanSource) => Effect.Effect<{
+    approval: {
+        target: {
+            readonly _tag: "Plan";
+            readonly planId: string;
+            readonly digest: string;
+            readonly envelope: {
+                readonly capabilities: readonly string[];
+                readonly flows: readonly string[];
+                readonly budget: {
+                    readonly deadline?: number | undefined;
+                    readonly tokens?: number | undefined;
+                    readonly milliseconds?: number | undefined;
+                    readonly usd?: number | undefined;
+                    readonly onExceeded?: "fail" | "park" | "warn" | "skip-remaining" | undefined;
+                };
+                readonly hostImports?: readonly string[] | undefined;
+                readonly host?: string | undefined;
+            };
+        };
+        scope: "run";
+        idempotencyKey: string;
+    };
+    graph?: {
+        readonly edges: readonly {
+            readonly from: string;
+            readonly to: string;
+            readonly reason: "value" | "continuation" | "failure" | "conflict" | "lane-merge";
+        }[];
+        readonly nodes?: readonly {
+            readonly id: string;
+            readonly declaredAt?: {
+                readonly path: string;
+                readonly line: number;
+            };
+        }[] | undefined;
+        readonly sourceRevision?: string | undefined;
+    };
+    nodes: readonly {
+        readonly status: "run" | "cached";
+        readonly id: string;
+        readonly kind: "step" | "agent" | "merge";
+        readonly key: string & import("effect/Brand").Brand<"@smthrs/keys/Key">;
+        readonly material: {
+            readonly capabilities: readonly string[];
+            readonly version: "flows/key-material/v2";
+            readonly inputs: readonly ({
+                readonly _tag: "Literal";
+                readonly value: unknown;
+            } | {
+                readonly _tag: "Ref";
+                readonly from: string;
+                readonly path: readonly string[];
+            } | {
+                readonly _tag: "Pending";
+                readonly from: string;
+            })[];
+            readonly layers: readonly string[];
+            readonly kind: "sealed" | "compensable" | "irreversible";
+            readonly body: unknown;
+            readonly nondeterministic?: true | undefined;
+            readonly effects?: unknown;
+            readonly placement?: unknown;
+        };
+        readonly effects: {
+            readonly reads: readonly (string | {
+                readonly _tag: "Glob";
+                readonly include: readonly [string, ...string[]];
+                readonly exclude?: readonly string[] | undefined;
+            } | {
+                readonly _tag: "Filegroup";
+                readonly name: string;
+                readonly entries: readonly (string | {
+                    readonly _tag: "Glob";
+                    readonly include: readonly [string, ...string[]];
+                    readonly exclude?: readonly string[] | undefined;
+                })[];
+            })[];
+            readonly writes: readonly (string | {
+                readonly _tag: "Glob";
+                readonly include: readonly [string, ...string[]];
+                readonly exclude?: readonly string[] | undefined;
+            } | {
+                readonly _tag: "TreeArtifact";
+                readonly path: string;
+            } | {
+                readonly _tag: "Filegroup";
+                readonly name: string;
+                readonly entries: readonly (string | {
+                    readonly _tag: "Glob";
+                    readonly include: readonly [string, ...string[]];
+                    readonly exclude?: readonly string[] | undefined;
+                } | {
+                    readonly _tag: "TreeArtifact";
+                    readonly path: string;
+                })[];
+            })[];
+            readonly boundaryMode: "expected" | "hard";
+            readonly removes?: readonly string[] | undefined;
+        };
+        readonly dependsOn: readonly string[];
+        readonly conflicts: readonly {
+            readonly with: string;
+            readonly paths: readonly string[];
+            readonly strategy: "serialize" | "lane" | "fail";
+            readonly runtime: "delay-rebase" | "stop-merge";
+        }[];
+        readonly strategy: "serialize" | "lane" | "fail";
+        readonly runtime: "delay-rebase" | "stop-merge";
+        readonly priority: number;
+        readonly generation: number;
+    }[];
+    plan?: {
+        readonly planId: string;
+        readonly flow: string;
+        readonly generation: number;
+        readonly baseDigest: string & import("effect/Brand").Brand<"@smthrs/keys/Key">;
+        readonly digest: string & import("effect/Brand").Brand<"@smthrs/keys/Key">;
+        readonly nodes: readonly {
+            readonly id: string;
+            readonly kind: "step" | "agent" | "merge";
+            readonly key: string & import("effect/Brand").Brand<"@smthrs/keys/Key">;
+            readonly material: {
+                readonly capabilities: readonly string[];
+                readonly version: "flows/key-material/v2";
+                readonly inputs: readonly ({
+                    readonly _tag: "Literal";
+                    readonly value: unknown;
+                } | {
+                    readonly _tag: "Ref";
+                    readonly from: string;
+                    readonly path: readonly string[];
+                } | {
+                    readonly _tag: "Pending";
+                    readonly from: string;
+                })[];
+                readonly layers: readonly string[];
+                readonly kind: "sealed" | "compensable" | "irreversible";
+                readonly body: unknown;
+                readonly nondeterministic?: true | undefined;
+                readonly effects?: unknown;
+                readonly placement?: unknown;
+            };
+            readonly effects: {
+                readonly reads: readonly (string | {
+                    readonly _tag: "Glob";
+                    readonly include: readonly [string, ...string[]];
+                    readonly exclude?: readonly string[] | undefined;
+                } | {
+                    readonly _tag: "Filegroup";
+                    readonly name: string;
+                    readonly entries: readonly (string | {
+                        readonly _tag: "Glob";
+                        readonly include: readonly [string, ...string[]];
+                        readonly exclude?: readonly string[] | undefined;
+                    })[];
+                })[];
+                readonly writes: readonly (string | {
+                    readonly _tag: "Glob";
+                    readonly include: readonly [string, ...string[]];
+                    readonly exclude?: readonly string[] | undefined;
+                } | {
+                    readonly _tag: "TreeArtifact";
+                    readonly path: string;
+                } | {
+                    readonly _tag: "Filegroup";
+                    readonly name: string;
+                    readonly entries: readonly (string | {
+                        readonly _tag: "Glob";
+                        readonly include: readonly [string, ...string[]];
+                        readonly exclude?: readonly string[] | undefined;
+                    } | {
+                        readonly _tag: "TreeArtifact";
+                        readonly path: string;
+                    })[];
+                })[];
+                readonly boundaryMode: "expected" | "hard";
+                readonly removes?: readonly string[] | undefined;
+            };
+            readonly dependsOn: readonly string[];
+            readonly conflicts: readonly {
+                readonly with: string;
+                readonly paths: readonly string[];
+                readonly strategy: "serialize" | "lane" | "fail";
+                readonly runtime: "delay-rebase" | "stop-merge";
+            }[];
+            readonly strategy: "serialize" | "lane" | "fail";
+            readonly runtime: "delay-rebase" | "stop-merge";
+            readonly priority: number;
+            readonly generation: number;
+        }[];
+    };
+    executionDigest?: string;
+    planId: string;
+    flowId: string;
+    digest: string & import("effect/Brand").Brand<"@smthrs/crypto/Sha256/Digest">;
+    inputSummary: string;
+    envelope: {
+        readonly capabilities: readonly string[];
+        readonly flows: readonly string[];
+        readonly budget: {
+            readonly deadline?: number | undefined;
+            readonly tokens?: number | undefined;
+            readonly milliseconds?: number | undefined;
+            readonly usd?: number | undefined;
+            readonly onExceeded?: "fail" | "park" | "warn" | "skip-remaining" | undefined;
+        };
+        readonly hostImports?: readonly string[] | undefined;
+        readonly host?: string | undefined;
+    };
+    deployClass: boolean;
+}, never, import("effect/Crypto").Crypto>;
+//# sourceMappingURL=planning.d.ts.map

package/dist/cjs/internal/planning.d.ts.map

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