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

package/dist/cjs/ControlRuntime.js

@@ -0,0 +1,744 @@
+"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 ControlRuntime_exports = {};
+__export(ControlRuntime_exports, {
+  ApprovalDecision: () => ApprovalDecision,
+  ApprovalDenied: () => ApprovalDenied,
+  ApprovalPending: () => ApprovalPending,
+  ControlRuntime: () => ControlRuntime,
+  idPageLimit: () => idPageLimit,
+  launchedByMatches: () => launchedByMatches,
+  layerMemory: () => layerMemory,
+  make: () => make,
+  requireApproved: () => requireApproved
+});
+module.exports = __toCommonJS(ControlRuntime_exports);
+var Fault = __toESM(require("@smthrs/flow/Fault"), 1);
+var import_effect = require("effect");
+var ApprovalAuthority = __toESM(require("./ApprovalAuthority.js"), 1);
+var import_ControlError = require("./ControlError.js");
+var import_ControlSchema = require("./ControlSchema.js");
+var import_issues = require("./internal/issues.js");
+var import_planning = require("./internal/planning.js");
+var import_SystemFlows = require("./SystemFlows.js");
+const launchedByMatches = (run, launcher) => run.launchedBy !== void 0 && run.launchedBy.id === launcher.id && (launcher.kind === void 0 || run.launchedBy.kind === launcher.kind);
+const ApprovalDecision = import_effect.Schema.Union([
+  import_effect.Schema.Struct({ _tag: import_effect.Schema.Literal("Pending") }),
+  import_effect.Schema.Struct({
+    _tag: import_effect.Schema.Literal("Approved"),
+    decisionPrincipal: import_ControlSchema.Principal,
+    decidedAt: import_effect.Schema.Number.check(import_effect.Schema.isInt(), import_effect.Schema.isGreaterThanOrEqualTo(0)),
+    scope: import_ControlSchema.GrantScope
+  }),
+  import_effect.Schema.Struct({
+    _tag: import_effect.Schema.Literal("Denied"),
+    decisionPrincipal: import_ControlSchema.Principal,
+    decidedAt: import_effect.Schema.Number.check(import_effect.Schema.isInt(), import_effect.Schema.isGreaterThanOrEqualTo(0))
+  })
+]);
+class ApprovalPending extends import_effect.Schema.TaggedError()("/control/ApprovalPending", {
+  tokenId: import_effect.Schema.String
+}) {
+  get message() {
+    return "Approval is still pending. Wait for a decision before proceeding.";
+  }
+}
+class ApprovalDenied extends import_effect.Schema.TaggedError()("/control/ApprovalDenied", {
+  tokenId: import_effect.Schema.String,
+  decisionPrincipal: import_ControlSchema.Principal
+}) {
+  get message() {
+    return "Approval was denied. This request cannot authorize the gated work.";
+  }
+}
+const requireApproved = (token) => token._tag === "Approved" ? import_effect.Effect.succeed(token) : token._tag === "Pending" ? import_effect.Effect.fail(new ApprovalPending({ tokenId: token.tokenId })) : import_effect.Effect.fail(new ApprovalDenied({ tokenId: token.tokenId, decisionPrincipal: token.decisionPrincipal }));
+class ControlRuntime extends import_effect.Context.Service()(
+  "/control/ControlRuntime"
+) {
+}
+const make = (implementation) => ControlRuntime.of(implementation);
+const idPageLimit = (limit) => Number.isSafeInteger(limit) && limit >= 1 && limit <= 500 ? import_effect.Effect.void : import_effect.Effect.fail(new import_ControlError.InvalidInput({ issue: "limit: must be an integer between 1 and 500" }));
+const pageByPosition = (request, newest, idAt) => {
+  const through = request.through ?? newest;
+  const ids = [];
+  let position = request.after ?? 0;
+  let visited = 0;
+  while (position < through && visited < request.limit) {
+    position += 1;
+    visited += 1;
+    const id = idAt(position);
+    if (id !== void 0) ids.push(id);
+  }
+  return position < through ? { ids, next: position, through } : { ids, through };
+};
+const snapshot = (value) => structuredClone(value);
+const asStored = (plan) => ({
+  card: snapshot(plan.card),
+  decodedInput: snapshot(plan.decodedInput),
+  decision: plan.decision
+});
+const approvalKey = (target) => target._tag === "Plan" ? JSON.stringify([target._tag, target.planId]) : JSON.stringify([target._tag, target.runId, target.requestId]);
+const sameApprovalIdentity = (left, right) => left._tag === "Plan" ? right._tag === "Plan" && left.planId === right.planId : right._tag === "Node" && left.runId === right.runId && left.requestId === right.requestId;
+const approvalToken = (token) => ({
+  tokenId: token.tokenId,
+  target: snapshot(token.target),
+  ...snapshot(token.decision)
+});
+const layerMemory = (options = {}) => import_effect.Layer.effect(
+  ControlRuntime,
+  import_effect.Effect.gen(function* () {
+    const crypto = yield* import_effect.Crypto.Crypto;
+    const now = options.now ?? Date.now;
+    const approvalAuthority = options.approvalAuthority ?? (yield* ApprovalAuthority.make([
+      {
+        principal: { id: "local", kind: "operator" },
+        scopes: ["once", "run", "remembered"],
+        targets: ["Plan", "Node"]
+      },
+      { principal: { id: "memory", kind: "test" }, scopes: ["once", "run", "remembered"], targets: ["Plan", "Node"] }
+    ]).pipe(import_effect.Effect.orDie));
+    const authorizeApproval = approvalAuthority.authorize.bind(approvalAuthority);
+    const configuredFlows = options.flows ?? import_SystemFlows.plannable.map((entry) => ({
+      flowId: entry.flowId,
+      description: `Reserved ${entry.verb} system flow`,
+      deployClass: entry.deployClass,
+      envelope: import_planning.emptyEnvelope
+    }));
+    const flows = new Map(configuredFlows.map(
+      (flow) => [
+        flow.flowId,
+        { ...flow, envelope: snapshot(flow.envelope) }
+      ]
+    ));
+    const plans = /* @__PURE__ */ new Map();
+    const planKeys = /* @__PURE__ */ new Map();
+    const tokens = /* @__PURE__ */ new Map();
+    const runs = /* @__PURE__ */ new Map();
+    const mutations = /* @__PURE__ */ new Map();
+    const runKeys = /* @__PURE__ */ new Map();
+    const installedGrants = [];
+    const installedGrantKeys = /* @__PURE__ */ new Set();
+    let planSequence = 0;
+    const signalCommands = /* @__PURE__ */ new Map();
+    let pendingSignalOffset = 0;
+    let runSequence = 0;
+    let fenceSequence = 0;
+    let resumeSequence = 0;
+    const requireRun = (runId) => import_effect.Effect.fromOption(import_effect.Option.fromNullishOr(runs.get(runId)), () => new import_ControlError.RunNotFound({ runId }));
+    const updateSummary = (run, fields) => {
+      run.summary = snapshot({ ...run.summary, ...fields, updatedAt: now() });
+      return snapshot(run.summary);
+    };
+    const checkFence = (runId, run, fence) => run.fence === void 0 || run.fence !== fence ? import_effect.Effect.fail(new import_ControlError.ClaimLost({ runId })) : import_effect.Effect.void;
+    const resumeRun = (runId, adopt) => import_effect.Effect.gen(function* () {
+      const run = yield* requireRun(runId);
+      if (run.summary.status === "cancelled" || run.summary.status === "completed" || run.summary.status === "failed") return snapshot(run.summary);
+      if (run.fence !== void 0) {
+        if (run.localFence === void 0 || run.fence !== run.localFence) {
+          return yield* new import_ControlError.ClaimLost({ runId });
+        }
+        return snapshot(run.summary);
+      }
+      const adopted = adopt === void 0 ? void 0 : yield* adopt(run);
+      const fence = `fence-${++fenceSequence}`;
+      run.fence = fence;
+      run.localFence = fence;
+      return updateSummary(run, {
+        ...adopted,
+        status: "accepted",
+        ownerId: "memory-owner",
+        parkedBy: void 0
+      });
+    });
+    const service = make({
+      authorizeApproval,
+      plan: import_effect.Effect.fn("ControlRuntime.plan")(function* (input) {
+        const flow = flows.get(input.flowId);
+        if (flow === void 0) return yield* new import_ControlError.FlowNotFound({ flowId: input.flowId });
+        const requestFingerprint = yield* import_effect.Effect.try({
+          // Validate before cloning. Canonicalization reports a throwing
+          // getter at its stable path, while `structuredClone` would invoke
+          // the getter first and erase that safe diagnostic.
+          try: () => (0, import_planning.planFingerprint)(input),
+          catch: (cause) => new import_ControlError.InvalidInput({ issue: (0, import_issues.canonicalIssue)(cause) })
+        });
+        const submitted = yield* import_effect.Effect.try({
+          try: () => snapshot(input),
+          catch: (cause) => new import_ControlError.InvalidInput({ issue: (0, import_issues.canonicalIssue)(cause) })
+        });
+        if (submitted.idempotencyKey !== void 0) {
+          const prior = planKeys.get(submitted.idempotencyKey);
+          if (prior !== void 0) {
+            if (prior.fingerprint !== requestFingerprint) {
+              return yield* new import_ControlError.InvalidInput({
+                issue: `idempotency key ${submitted.idempotencyKey} was used for another plan`
+              });
+            }
+            const stored = plans.get(prior.planId);
+            if (stored !== void 0) return { card: snapshot(stored.card), created: false };
+          }
+        }
+        const decoded = yield* flow.decode?.(submitted.input) ?? import_effect.Effect.try({
+          try: () => {
+            (0, import_planning.canonical)(submitted.input);
+            return submitted.input;
+          },
+          catch: (cause) => new import_ControlError.InvalidInput({ issue: (0, import_issues.canonicalIssue)(cause) })
+        });
+        const planId = `plan-${++planSequence}`;
+        const handoff = flow.plan === void 0 ? void 0 : yield* flow.plan(decoded, planId);
+        const card = snapshot(
+          yield* (0, import_planning.planCard)({
+            planId,
+            flowId: submitted.flowId,
+            decodedInput: decoded,
+            envelope: (0, import_planning.budgeted)(flow.envelope, submitted.budget),
+            deployClass: flow.deployClass,
+            executionDigest: flow.executionDigest,
+            handoff,
+            idempotencyKey: submitted.idempotencyKey
+          }).pipe(import_effect.Effect.provideService(import_effect.Crypto.Crypto, crypto))
+        );
+        if (submitted.idempotencyKey !== void 0) {
+          const prior = planKeys.get(submitted.idempotencyKey);
+          if (prior !== void 0) {
+            if (prior.fingerprint !== requestFingerprint) {
+              return yield* new import_ControlError.InvalidInput({
+                issue: `idempotency key ${submitted.idempotencyKey} was used for another plan`
+              });
+            }
+            const stored = plans.get(prior.planId);
+            if (stored !== void 0) return { card: snapshot(stored.card), created: false };
+          }
+        }
+        plans.set(planId, { card, decodedInput: snapshot(decoded), decision: "pending" });
+        tokens.set(approvalKey(card.approval.target), {
+          tokenId: planId,
+          target: snapshot(card.approval.target),
+          decision: { _tag: "Pending" }
+        });
+        if (submitted.idempotencyKey !== void 0) {
+          planKeys.set(submitted.idempotencyKey, {
+            fingerprint: requestFingerprint,
+            planId
+          });
+        }
+        return { card: snapshot(card), created: true };
+      }),
+      getPlan: import_effect.Effect.fn("ControlRuntime.getPlan")(
+        (planId) => import_effect.Effect.fromOption(import_effect.Option.fromNullishOr(plans.get(planId)), () => new import_ControlError.PlanNotFound({ planId })).pipe(
+          import_effect.Effect.map(asStored)
+        )
+      ),
+      pagePlanIds: import_effect.Effect.fn("ControlRuntime.pagePlanIds")(function* (request) {
+        yield* idPageLimit(request.limit);
+        return pageByPosition(
+          request,
+          planSequence,
+          (position) => plans.has(`plan-${position}`) ? `plan-${position}` : void 0
+        );
+      }),
+      queryPlans: import_effect.Effect.fn("ControlRuntime.queryPlans")(function* (request) {
+        yield* idPageLimit(request.limit);
+        const matched = [];
+        let position = request.after ?? 0;
+        while (position < planSequence && matched.length < request.limit) {
+          position += 1;
+          const plan = plans.get(`plan-${position}`);
+          if (plan !== void 0 && (request.flowId === void 0 || plan.card.flowId === request.flowId) && (request.decision === void 0 || plan.decision === request.decision)) matched.push(asStored(plan));
+        }
+        return position < planSequence ? { plans: matched, next: position } : { plans: matched };
+      }),
+      lookupApproval: import_effect.Effect.fn("ControlRuntime.lookupApproval")(function* (target) {
+        const requested = snapshot(target);
+        const tokenId = requested._tag === "Plan" ? requested.planId : requested.requestId;
+        const token = yield* import_effect.Effect.fromOption(
+          import_effect.Option.fromNullishOr(tokens.get(approvalKey(requested))),
+          () => requested._tag === "Node" ? new import_ControlError.RunNotFound({ runId: requested.runId }) : new import_ControlError.PlanNotFound({ planId: requested.planId })
+        );
+        if (!sameApprovalIdentity(token.target, requested)) {
+          return yield* new import_ControlError.PersistenceError({
+            operation: "validate an approval token",
+            message: "The stored approval target does not match its identity"
+          });
+        }
+        if (token.target.digest !== requested.digest) {
+          return yield* new import_ControlError.PlanDigestMismatch({
+            planId: tokenId,
+            expected: token.target.digest,
+            actual: requested.digest
+          });
+        }
+        if (!(0, import_planning.sameEnvelope)(token.target.envelope, requested.envelope)) {
+          return yield* new import_ControlError.EnvelopeMismatch({
+            planId: tokenId,
+            expected: (0, import_planning.canonical)(token.target.envelope),
+            actual: (0, import_planning.canonical)(requested.envelope)
+          });
+        }
+        if (token.decision._tag !== "Pending") return yield* new import_ControlError.AlreadyResolved({ requestId: tokenId });
+        return approvalToken(token);
+      }),
+      registerApproval: import_effect.Effect.fn("ControlRuntime.registerApproval")(function* (target) {
+        const requested = snapshot(target);
+        yield* requireRun(requested.runId);
+        const key = approvalKey(requested);
+        const existing = tokens.get(key);
+        if (existing === void 0) {
+          const stored = {
+            tokenId: requested.requestId,
+            target: requested,
+            decision: { _tag: "Pending" }
+          };
+          tokens.set(key, stored);
+          return approvalToken(stored);
+        }
+        if (!sameApprovalIdentity(existing.target, requested)) {
+          return yield* new import_ControlError.PersistenceError({
+            operation: "validate an approval token",
+            message: "The stored approval target does not match its identity"
+          });
+        }
+        if (existing.target.digest !== requested.digest) {
+          return yield* new import_ControlError.PlanDigestMismatch({
+            planId: requested.requestId,
+            expected: existing.target.digest,
+            actual: requested.digest
+          });
+        }
+        if (!(0, import_planning.sameEnvelope)(existing.target.envelope, requested.envelope)) {
+          return yield* new import_ControlError.EnvelopeMismatch({
+            planId: requested.requestId,
+            expected: (0, import_planning.canonical)(existing.target.envelope),
+            actual: (0, import_planning.canonical)(requested.envelope)
+          });
+        }
+        return approvalToken(existing);
+      }),
+      installBulkGrant: import_effect.Effect.fn("ControlRuntime.installBulkGrant")(
+        (token, envelope, scope) => import_effect.Effect.sync(() => {
+          const storedToken = snapshot(token);
+          const key = approvalKey(storedToken.target);
+          if (installedGrantKeys.has(key)) return;
+          installedGrantKeys.add(key);
+          installedGrants.push({
+            tokenId: storedToken.tokenId,
+            envelope: snapshot(envelope),
+            scope,
+            installedAt: now()
+          });
+        })
+      ),
+      resolveApproval: import_effect.Effect.fn("ControlRuntime.resolveApproval")(
+        function* (token, decision, principal, scope = "once") {
+          const requested = snapshot(token);
+          const requestedPrincipal = snapshot(principal);
+          const answer = yield* import_effect.Schema.decodeUnknownEffect(ApprovalDecision)(
+            decision === "approved" ? { _tag: "Approved", decisionPrincipal: requestedPrincipal, decidedAt: now(), scope } : { _tag: "Denied", decisionPrincipal: requestedPrincipal, decidedAt: now() }
+          ).pipe(
+            import_effect.Effect.mapError(
+              () => new import_ControlError.PersistenceError({
+                operation: "record an approval decision",
+                message: "The approval decision metadata is invalid"
+              })
+            )
+          );
+          yield* authorizeApproval({ principal: requestedPrincipal, target: requested.target, decision, scope });
+          const mutable = tokens.get(approvalKey(requested.target));
+          if (mutable === void 0 || mutable.decision._tag !== "Pending") {
+            return yield* new import_ControlError.AlreadyResolved({ requestId: requested.tokenId });
+          }
+          mutable.decision = answer;
+          if (requested.target._tag === "Plan") {
+            const plan = plans.get(requested.target.planId);
+            if (plan !== void 0) plan.decision = decision;
+          }
+        }
+      ),
+      launch: import_effect.Effect.fn("ControlRuntime.launch")(
+        function* (planId, requestedDigest, envelope, principal, reservedRunId) {
+          const plan = yield* import_effect.Effect.fromOption(
+            import_effect.Option.fromNullishOr(plans.get(planId)),
+            () => new import_ControlError.PlanNotFound({ planId })
+          );
+          if (plan.card.digest !== requestedDigest) {
+            return yield* new import_ControlError.PlanDigestMismatch({
+              planId,
+              expected: plan.card.digest,
+              actual: requestedDigest
+            });
+          }
+          if (!(0, import_planning.sameEnvelope)(plan.card.envelope, envelope)) {
+            return yield* new import_ControlError.EnvelopeMismatch({
+              planId,
+              expected: (0, import_planning.canonical)(plan.card.envelope),
+              actual: (0, import_planning.canonical)(envelope)
+            });
+          }
+          if (plan.decision === "pending") {
+            return {
+              _tag: "Parked",
+              receipt: {
+                _tag: "Parked",
+                receiptId: `launch:${planId}`,
+                planId,
+                status: "waiting-approval"
+              }
+            };
+          }
+          if (plan.decision !== "approved") {
+            return yield* new import_ControlError.PlanDenied({ planId });
+          }
+          const sequence = ++runSequence;
+          const runId = reservedRunId ?? `run-${sequence}`;
+          if (runs.has(runId)) {
+            return yield* new import_ControlError.PersistenceError({ operation: "reserve a run", message: "Run identity already exists" });
+          }
+          const fence = `fence-${++fenceSequence}`;
+          const timestamp = now();
+          const summary = {
+            runId,
+            flowId: plan.card.flowId,
+            status: "accepted",
+            planId,
+            planDigest: plan.card.digest,
+            ...plan.card.executionDigest === void 0 ? {} : { executionDigest: plan.card.executionDigest },
+            ...options.engineVersion === void 0 ? {} : { engineVersion: options.engineVersion },
+            ownerId: "memory-owner",
+            ...principal === void 0 ? {} : { launchedBy: { id: principal.id, kind: principal.kind } },
+            ...plan.card.envelope.budget.deadline === void 0 ? {} : { deadlineAt: timestamp + plan.card.envelope.budget.deadline },
+            createdAt: timestamp,
+            updatedAt: timestamp
+          };
+          runs.set(runId, {
+            summary: snapshot(summary),
+            fence,
+            localFence: fence,
+            sequence: runSequence,
+            signals: []
+          });
+          return {
+            _tag: "Started",
+            receipt: (0, import_planning.accepted)(`launch:${planId}:${runId}`, runId),
+            run: snapshot(summary)
+          };
+        }
+      ),
+      getRun: import_effect.Effect.fn("ControlRuntime.getRun")(
+        (runId) => import_effect.Effect.map(requireRun(runId), (run) => snapshot(run.summary))
+      ),
+      pageRunIds: import_effect.Effect.fn("ControlRuntime.pageRunIds")(function* (request) {
+        yield* idPageLimit(request.limit);
+        return pageByPosition(
+          request,
+          runSequence,
+          (position) => runs.has(`run-${position}`) ? `run-${position}` : void 0
+        );
+      }),
+      queryRuns: import_effect.Effect.fn("ControlRuntime.queryRuns")(function* (request) {
+        if (!Number.isSafeInteger(request.limit) || request.limit < 1 || request.limit > 500) {
+          return yield* new import_ControlError.InvalidInput({ issue: "limit: must be an integer between 1 and 500" });
+        }
+        const selected = [];
+        const filters = request.filters;
+        const newest = request.order === "newest";
+        const oldest = request.order === "oldest";
+        const candidates = newest ? Array.from(runs.values()).sort(
+          (a, b) => b.summary.createdAt - a.summary.createdAt || b.sequence - a.sequence
+        ) : oldest ? Array.from(runs.values()).sort(
+          (a, b) => a.summary.createdAt - b.summary.createdAt || a.sequence - b.sequence
+        ) : runs.values();
+        for (const run of candidates) {
+          const after = request.cursor;
+          if (after !== void 0 && (after.source !== 0 || (newest ? run.summary.createdAt > after.createdAt || run.summary.createdAt === after.createdAt && run.sequence >= after.sequence : oldest ? run.summary.createdAt < after.createdAt || run.summary.createdAt === after.createdAt && run.sequence <= after.sequence : run.sequence <= after.sequence))) continue;
+          const summary = run.summary;
+          if (filters?.since !== void 0 && summary.createdAt < filters.since) continue;
+          if (filters?.until !== void 0 && summary.createdAt >= filters.until) continue;
+          if (filters?.runIds !== void 0 && !filters.runIds.includes(summary.runId)) continue;
+          if (filters?.flowId !== void 0 && summary.flowId !== filters.flowId) continue;
+          if (filters?.status !== void 0 && summary.status !== filters.status) continue;
+          if (filters?.terminal !== void 0 && ["completed", "failed", "cancelled"].includes(summary.status) !== filters.terminal) continue;
+          if (filters?.parentRunId !== void 0 && summary.parentRunId !== filters.parentRunId) continue;
+          if (filters?.lineageId !== void 0 && summary.lineageId !== filters.lineageId) continue;
+          if (filters?.launchedBy !== void 0 && !launchedByMatches(summary, filters.launchedBy)) continue;
+          selected.push(run);
+          if (selected.length > request.limit) break;
+        }
+        const page = selected.slice(0, request.limit);
+        const last = page.at(-1);
+        return {
+          items: page.map((run) => snapshot(run.summary)),
+          ...selected.length <= request.limit || last === void 0 ? {} : {
+            nextCursor: {
+              source: 0,
+              sequence: last.sequence,
+              createdAt: last.summary.createdAt,
+              runId: last.summary.runId
+            }
+          }
+        };
+      }),
+      listFlows: import_effect.Effect.fn("ControlRuntime.listFlows")(
+        () => import_effect.Effect.sync(
+          () => Array.from(flows.values(), (flow) => ({
+            flowId: flow.flowId,
+            description: flow.description
+          }))
+        )
+      )(),
+      deliverSignal: import_effect.Effect.fn("ControlRuntime.deliverSignal")(
+        (runId, signal) => import_effect.Effect.tap(requireRun(runId), (run) => import_effect.Effect.sync(() => void run.signals.push(snapshot(signal))))
+      ),
+      admitSignal: import_effect.Effect.fn("ControlRuntime.admitSignal")(function* (commandId, runId, signal, principal) {
+        yield* requireRun(runId);
+        if (!signalCommands.has(commandId)) {
+          signalCommands.set(
+            commandId,
+            snapshot({
+              commandId,
+              runId,
+              signal,
+              token: null,
+              state: "pending",
+              ...principal === void 0 ? {} : { principal }
+            })
+          );
+        }
+      }),
+      signalCommand: (commandId) => import_effect.Effect.sync(() => snapshot(signalCommands.get(commandId))),
+      pendingSignals: import_effect.Effect.sync(() => {
+        const pending = Array.from(signalCommands.values()).filter((command) => command.state === "pending");
+        if (pendingSignalOffset >= pending.length) pendingSignalOffset = 0;
+        const page = pending.slice(pendingSignalOffset, pendingSignalOffset + 100);
+        pendingSignalOffset += page.length;
+        return snapshot(page);
+      }),
+      bindSignal: (commandId, token) => import_effect.Effect.gen(function* () {
+        const command = signalCommands.get(commandId);
+        if (command === void 0) {
+          return yield* new import_ControlError.PersistenceError({
+            operation: "bind signal",
+            message: `No pending signal command ${commandId}`
+          });
+        }
+        if (command.state !== "pending") return command.token;
+        if (command.token === null && Array.from(signalCommands.values()).some(
+          (other) => other.commandId !== commandId && other.token === token
+        )) return null;
+        const bound = command.token ?? token;
+        signalCommands.set(commandId, { ...command, token: bound });
+        return bound;
+      }),
+      settleSignal: (commandId, state) => import_effect.Effect.sync(() => {
+        const command = signalCommands.get(commandId);
+        if (command !== void 0 && command.state === "pending") {
+          signalCommands.set(commandId, { ...command, state });
+        }
+      }),
+      deliveredSignals: import_effect.Effect.fn("ControlRuntime.deliveredSignals")(
+        (runId) => import_effect.Effect.map(
+          requireRun(runId),
+          (run) => snapshot([
+            ...run.signals,
+            ...Array.from(signalCommands.values()).filter(
+              (command) => command.runId === runId && command.state !== "rejected"
+            ).map((command) => command.signal)
+          ])
+        )
+      ),
+      requestResume: import_effect.Effect.fn("ControlRuntime.requestResume")(function* (runId, options2) {
+        const run = yield* requireRun(runId);
+        if (run.summary.status === "cancelled" || run.summary.status === "completed" || run.summary.status === "failed") {
+          return yield* new import_ControlError.InvalidInput({
+            issue: `run ${runId} is ${run.summary.status} and cannot take a resume`
+          });
+        }
+        const sequence = ++resumeSequence;
+        run.pendingResume = sequence;
+        run.pendingResumeAtMs = now();
+        run.pendingConsent = options2?.consent ?? run.pendingConsent;
+        updateSummary(run, { pendingResume: sequence });
+        return sequence;
+      }),
+      pendingResumes: import_effect.Effect.sync(
+        () => Array.from(runs.entries()).flatMap(
+          ([runId, run]) => run.pendingResume === void 0 || run.pendingResumeAtMs === void 0 || run.summary.status === "cancelled" || run.summary.status === "completed" || run.summary.status === "failed" ? [] : [{
+            runId,
+            sequence: run.pendingResume,
+            requestedAtMs: run.pendingResumeAtMs,
+            ...run.pendingConsent === void 0 ? {} : { consent: run.pendingConsent }
+          }]
+        )
+      ),
+      clearResume: import_effect.Effect.fn("ControlRuntime.clearResume")(
+        (runId, sequence) => import_effect.Effect.sync(() => {
+          const run = runs.get(runId);
+          if (run === void 0 || run.pendingResume !== sequence) return;
+          run.pendingResume = void 0;
+          run.pendingResumeAtMs = void 0;
+          run.pendingConsent = void 0;
+          updateSummary(run, { pendingResume: void 0 });
+        })
+      ),
+      registerFiber: import_effect.Effect.fn("ControlRuntime.registerFiber")(
+        (runId, fiber) => import_effect.Effect.tap(requireRun(runId), (run) => import_effect.Effect.sync(() => {
+          run.fiber = fiber;
+          fiber.addObserver(() => {
+            if (run.fiber === fiber) run.fiber = void 0;
+          });
+        }))
+      ),
+      interrupt: import_effect.Effect.fn("ControlRuntime.interrupt")(function* (runId, settle = (effect) => effect) {
+        const run = yield* requireRun(runId);
+        if (run.summary.status === "cancelled" || run.summary.status === "completed" || run.summary.status === "failed") return snapshot(run.summary);
+        if (run.localFence === void 0) return yield* new import_ControlError.ClaimLost({ runId });
+        const fence = run.localFence;
+        yield* checkFence(runId, run, fence);
+        if (run.fiber !== void 0) yield* import_effect.Fiber.interrupt(run.fiber);
+        return yield* settle(import_effect.Effect.gen(function* () {
+          if (run.summary.status === "cancelled" || run.summary.status === "completed" || run.summary.status === "failed") return snapshot(run.summary);
+          yield* checkFence(runId, run, fence);
+          run.fence = void 0;
+          run.localFence = void 0;
+          return updateSummary(run, { status: "cancelled", ownerId: void 0, parkedBy: void 0 });
+        }));
+      }),
+      codeDrift: import_effect.Effect.fn("ControlRuntime.codeDrift")(function* (runId) {
+        const run = yield* requireRun(runId);
+        return (0, import_planning.codeDriftOf)(run.summary, flows.get(run.summary.flowId), options.engineVersion);
+      }),
+      recordedCode: import_effect.Effect.fn("ControlRuntime.recordedCode")(function* (runId) {
+        const { executionDigest, engineVersion } = (yield* requireRun(runId)).summary;
+        return { executionDigest, engineVersion };
+      }),
+      resume: import_effect.Effect.fn("ControlRuntime.resume")((runId) => resumeRun(runId)),
+      // `plan` refuses a flow this catalog does not hold, and the catalog is
+      // fixed at construction, so a run's flow is never gone here and there
+      // is always code to adopt. `SqlControlRuntime` reads a catalog that can
+      // lose a flow, and refuses that case before the claim.
+      resumeAdopting: import_effect.Effect.fn("ControlRuntime.resumeAdopting")(
+        (runId) => resumeRun(
+          runId,
+          (run) => import_effect.Effect.succeed((0, import_planning.adoptedCode)(run.summary, flows.get(run.summary.flowId), options.engineVersion))
+        )
+      ),
+      claimFence: import_effect.Effect.fn("ControlRuntime.claimFence")(function* (runId) {
+        const run = yield* requireRun(runId);
+        if (run.localFence === void 0) return yield* new import_ControlError.ClaimLost({ runId });
+        return run.localFence;
+      }),
+      releasePending: import_effect.Effect.fn("ControlRuntime.releasePending")(function* (runId, fence) {
+        const run = yield* requireRun(runId);
+        yield* checkFence(runId, run, fence);
+        run.fence = void 0;
+        run.localFence = void 0;
+        return updateSummary(run, {
+          status: "accepted",
+          ownerId: void 0,
+          parkedBy: void 0
+        });
+      }),
+      writeStatus: import_effect.Effect.fn("ControlRuntime.writeStatus")(function* (runId, fence, status) {
+        const run = yield* requireRun(runId);
+        yield* checkFence(runId, run, fence);
+        if (status === "accepted" || status === "running") {
+          return updateSummary(run, { status, parkedBy: void 0 });
+        }
+        run.fence = void 0;
+        run.localFence = void 0;
+        return updateSummary(run, {
+          status,
+          ownerId: void 0,
+          parkedBy: status === "parked" || status === "waiting-approval" ? fence : void 0
+        });
+      }),
+      // Precedence matches `SqlControlRuntime`: the submitted identity is
+      // the one a server authenticated, and the configured one is this
+      // composition's fallback for a caller that named none.
+      stampPrincipal: import_effect.Effect.fn("ControlRuntime.stampPrincipal")(
+        (submitted) => import_effect.Effect.sync(() => ({
+          id: submitted?.id ?? options.principal?.id ?? "memory",
+          kind: submitted?.kind ?? options.principal?.kind ?? "test",
+          stampedAt: now()
+        }))
+      ),
+      lookupMutation: import_effect.Effect.fn("ControlRuntime.lookupMutation")(
+        (key, fingerprint) => import_effect.Effect.sync(() => {
+          const record = mutations.get(key);
+          if (record === void 0) return void 0;
+          return record.fingerprint === fingerprint ? (0, import_planning.alreadyApplied)(key, record.receipt) : { _tag: "Conflict", message: `idempotency key ${key} was used for another mutation` };
+        })
+      ),
+      recordMutation: import_effect.Effect.fn("ControlRuntime.recordMutation")(
+        (key, fingerprint, receipt) => import_effect.Effect.gen(function* () {
+          const prior = mutations.get(key);
+          if (prior !== void 0 && (prior.fingerprint !== fingerprint || (0, import_planning.canonical)(prior.receipt) !== (0, import_planning.canonical)(receipt))) {
+            return yield* import_effect.Effect.fail(
+              new import_ControlError.PersistenceError({
+                operation: "record a mutation",
+                message: `Idempotency key ${key} was already settled by another mutation`
+              })
+            );
+          }
+          mutations.set(key, { fingerprint, receipt: snapshot(receipt) });
+        })
+      ),
+      claimRunKey: import_effect.Effect.fn("ControlRuntime.claimRunKey")(function* (key, fingerprint) {
+        const holder = runKeys.get(key);
+        if (holder !== void 0) {
+          if (holder.fingerprint !== fingerprint) {
+            return yield* new import_ControlError.InvalidInput({
+              issue: `idempotency key ${key} was used for another run`
+            });
+          }
+          const record = mutations.get(key);
+          if (record === void 0) {
+            return yield* new import_ControlError.PersistenceError({
+              operation: "read a mutation",
+              message: `run key ${key} was claimed by a mutation that recorded no receipt`
+            });
+          }
+          return { _tag: "Raced", receipt: snapshot(record.receipt) };
+        }
+        runKeys.set(key, { fingerprint });
+        return { _tag: "Claimed" };
+      }),
+      releaseRunKey: import_effect.Effect.fn("ControlRuntime.releaseRunKey")(
+        (key) => import_effect.Effect.sync(() => {
+          runKeys.delete(key);
+        })
+      ),
+      grants: import_effect.Effect.fn("ControlRuntime.grants")(() => import_effect.Effect.sync(() => snapshot(installedGrants)))()
+    });
+    return service;
+  })
+);
+Fault.register("/control/ApprovalPending", "wait");
+Fault.register("/control/ApprovalDenied", "user");
+//# sourceMappingURL=ControlRuntime.js.map