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

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

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

package/dist/cjs/ControlSchema.js

@@ -0,0 +1,634 @@
+"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 ControlSchema_exports = {};
+__export(ControlSchema_exports, {
+  ApprovalInputSchema: () => ApprovalInputSchema,
+  ApprovalPayload: () => ApprovalPayload,
+  ApprovalTarget: () => ApprovalTarget,
+  CancelInputSchema: () => CancelInputSchema,
+  CancelSource: () => CancelSource,
+  Cancellation: () => Cancellation,
+  ControlEvent: () => ControlEvent,
+  Envelope: () => Envelope,
+  ExecutionBatch: () => ExecutionBatch,
+  FireOutcome: () => FireOutcome,
+  FireSummary: () => FireSummary,
+  FlowId: () => FlowId,
+  GrantScope: () => GrantScope,
+  IdempotencyKey: () => IdempotencyKey,
+  ListRequest: () => ListRequest,
+  ListResponse: () => ListResponse,
+  MessageSteer: () => MessageSteer,
+  PageLimit: () => PageLimit,
+  PendingWait: () => PendingWait,
+  PlanCard: () => PlanCard,
+  PlanDecision: () => PlanDecision,
+  PlanEdge: () => PlanEdge,
+  PlanEdgeReason: () => PlanEdgeReason,
+  PlanGraph: () => PlanGraph,
+  PlanGraphNode: () => PlanGraphNode,
+  PlanInputSchema: () => PlanInputSchema,
+  PlanNode: () => PlanNode,
+  PlanNodeStatus: () => PlanNodeStatus,
+  PlanSummary: () => PlanSummary,
+  Principal: () => Principal,
+  ReasonedMutationInputSchema: () => ReasonedMutationInputSchema,
+  Receipt: () => Receipt,
+  ResumeInputSchema: () => ResumeInputSchema,
+  RunHost: () => RunHost,
+  RunId: () => RunId,
+  RunInputSchema: () => RunInputSchema,
+  RunMutationInputSchema: () => RunMutationInputSchema,
+  RunOrigin: () => RunOrigin,
+  RunStatus: () => RunStatus,
+  RunSummary: () => RunSummary,
+  SeatSteer: () => SeatSteer,
+  SignalInputSchema: () => SignalInputSchema,
+  SignalPayload: () => SignalPayload,
+  SteerInputSchema: () => SteerInputSchema,
+  SteerMessage: () => SteerMessage,
+  ThinkingSteer: () => ThinkingSteer,
+  ToolsSteer: () => ToolsSteer,
+  TriggerSummary: () => TriggerSummary,
+  WatchCursor: () => WatchCursor,
+  WatchFilter: () => WatchFilter,
+  defaultPageSize: () => defaultPageSize,
+  maxPageSize: () => maxPageSize,
+  steerItem: () => steerItem
+});
+module.exports = __toCommonJS(ControlSchema_exports);
+var import_journal = require("@smthrs/journal");
+var import_Notification = require("@smthrs/notifications/Notification");
+var SteerPayload = __toESM(require("@smthrs/notifications/SteerPayload"), 1);
+var PersistedPlan = __toESM(require("@smthrs/plan/Plan"), 1);
+var import_Descriptor = require("@smthrs/registry/Descriptor");
+var import_effect = require("effect");
+var import_Lineage = require("./Lineage.js");
+const RunId = import_effect.Schema.String;
+const FlowId = import_effect.Schema.String;
+const IdempotencyKey = import_effect.Schema.String;
+const Principal = import_effect.Schema.Struct({
+  id: import_effect.Schema.String,
+  kind: import_effect.Schema.String,
+  stampedAt: import_effect.Schema.Number
+});
+const Envelope = import_effect.Schema.Struct({
+  capabilities: import_effect.Schema.Array(import_effect.Schema.String),
+  /** Unrestricted builtin/addon/package imports, outside the guarded capability ceiling. */
+  hostImports: import_effect.Schema.optional(import_effect.Schema.Array(import_effect.Schema.String)),
+  flows: import_effect.Schema.Array(import_effect.Schema.String),
+  budget: import_effect.Schema.Struct({
+    tokens: import_effect.Schema.optional(import_effect.Schema.Number),
+    milliseconds: import_effect.Schema.optional(import_effect.Schema.Number),
+    usd: import_effect.Schema.optional(import_effect.Schema.Number),
+    onExceeded: import_effect.Schema.optional(import_Descriptor.BudgetOnExceeded),
+    deadline: import_effect.Schema.optional(import_effect.Schema.Int.check(import_effect.Schema.isGreaterThan(0)))
+  }),
+  host: import_effect.Schema.optional(import_effect.Schema.String)
+});
+const GrantScope = import_effect.Schema.Literals(["once", "run", "remembered"]);
+const ApprovalTarget = import_effect.Schema.Union([
+  import_effect.Schema.TaggedStruct("Plan", {
+    planId: import_effect.Schema.String,
+    digest: import_effect.Schema.String,
+    envelope: Envelope
+  }),
+  import_effect.Schema.TaggedStruct("Node", {
+    runId: RunId,
+    requestId: import_effect.Schema.String,
+    digest: import_effect.Schema.String,
+    envelope: Envelope
+  })
+]);
+const ApprovalPayload = import_effect.Schema.Struct({
+  target: ApprovalTarget,
+  scope: GrantScope,
+  idempotencyKey: IdempotencyKey
+});
+const PlanNodeStatus = import_effect.Schema.Literals(["cached", "run"]);
+const PlanNode = import_effect.Schema.Struct({
+  ...PersistedPlan.PlanNode.fields,
+  status: PlanNodeStatus
+});
+const PlanEdgeReason = import_effect.Schema.Literals(["value", "continuation", "failure", "conflict", "lane-merge"]);
+const PlanEdge = import_effect.Schema.Struct({
+  from: import_effect.Schema.NonEmptyString,
+  to: import_effect.Schema.NonEmptyString,
+  reason: PlanEdgeReason
+});
+const PlanGraphNode = import_effect.Schema.Struct({
+  id: import_effect.Schema.NonEmptyString,
+  declaredAt: import_effect.Schema.optionalKey(import_journal.EngineEvent.DeclaredAt)
+});
+const PlanGraph = import_effect.Schema.Struct({
+  edges: import_effect.Schema.Array(PlanEdge),
+  nodes: import_effect.Schema.optional(import_effect.Schema.Array(PlanGraphNode)),
+  /**
+   * The revision of the workspace those declaration sites were read out of.
+   *
+   * A site is a path and a line, and neither says which bytes were there: a
+   * host's working tree moves, so the same path after an edit or a branch
+   * switch is a different file. This is the immutable name of the tree the
+   * host loaded the flow from — a jj working-copy commit id, or a git commit
+   * for a tree that still matches one — and a reader asks the content route
+   * for the file AT this revision rather than for whatever is on disk now.
+   *
+   * A host that cannot name one reports nothing, and a reader that has
+   * nothing shows no code at all rather than code it cannot bind (D-068).
+   *
+   * Exactly the forty lowercase hex digits the only producer emits
+   * (`SourceRevision.objectId`), because the app puts this value straight
+   * into a contents route's `?ref=` and a route that spawns jj or git from it
+   * should never see anything else.
+   */
+  sourceRevision: import_effect.Schema.optional(
+    import_effect.Schema.NonEmptyString.check(import_effect.Schema.makeFilter((value) => /^[0-9a-f]{40}$/.test(value)))
+  )
+});
+const PlanCard = import_effect.Schema.Struct({
+  planId: import_effect.Schema.String,
+  flowId: FlowId,
+  digest: import_effect.Schema.String,
+  inputSummary: import_effect.Schema.String,
+  /** Discovery diagnostics for the selected flow; outside the approval identity. */
+  warnings: import_effect.Schema.optional(import_effect.Schema.Array(import_Descriptor.DiscoveryWarning)),
+  envelope: Envelope,
+  deployClass: import_effect.Schema.Boolean,
+  /** Executable source/metadata identity supplied by a discovery-based host. */
+  executionDigest: import_effect.Schema.optional(import_effect.Schema.String),
+  plan: import_effect.Schema.optional(PersistedPlan.Plan),
+  nodes: import_effect.Schema.Array(PlanNode),
+  /**
+   * The labelled edges of the graph this plan was built from, and where its
+   * nodes were declared.
+   *
+   * Deliberately OUTSIDE the digest an approval binds to: the edges and the
+   * declaration sites describe the plan a reader draws, and nothing here
+   * changes what will run. The
+   * persisted plan's own digest already covers keys, edges, effects,
+   * conflicts, priorities and generations, so a host that starts reporting
+   * this field re-plans to the digest it planned to before and every parked
+   * approval still validates.
+   */
+  graph: import_effect.Schema.optional(PlanGraph),
+  approval: ApprovalPayload
+});
+const RunStatus = import_effect.Schema.Literals([
+  "accepted",
+  "running",
+  "parked",
+  "waiting-approval",
+  "cancelled",
+  "completed",
+  "failed"
+]);
+const RunOrigin = import_Lineage.Origin;
+const CancelSource = import_effect.Schema.Literals(["control", "engine", "cascade"]);
+const Cancellation = import_effect.Schema.Struct({
+  requestedAt: import_effect.Schema.Number,
+  source: CancelSource,
+  principal: import_effect.Schema.optional(Principal),
+  reason: import_effect.Schema.optional(import_effect.Schema.String),
+  /** The cancelled ancestor this run was swept up with, on a cascade. */
+  cascadedFrom: import_effect.Schema.optional(RunId)
+});
+const PendingWait = import_effect.Schema.Struct({
+  /** The execution parked on this wait, which may be the root run itself. */
+  runId: RunId,
+  /** The flow that execution is running. */
+  flowId: import_effect.Schema.optional(FlowId),
+  /** The supervisor vocabulary: `approval` for people or `event` for a named signal. */
+  reason: import_effect.Schema.String,
+  /** The durable wait address a decision is routed to. */
+  token: import_effect.Schema.String,
+  /** Digest used to join replayed display facts to this current operational address. */
+  tokenDigest: import_effect.Schema.optional(import_effect.Schema.String),
+  /** The wait point's own name, when the token addresses a named one. */
+  name: import_effect.Schema.optional(import_effect.Schema.String),
+  /** Which attempt of a re-asked question this is, counting from 1. */
+  attempt: import_effect.Schema.optional(import_effect.Schema.Number),
+  /** What the wait declared about itself, absent when it declared nothing. */
+  request: import_effect.Schema.optional(import_effect.Schema.Json),
+  /** When the execution holding this wait was created. */
+  createdAt: import_effect.Schema.Number
+});
+const RunSummary = import_effect.Schema.Struct({
+  /** Whether lifecycle fields were observed in the engine or no engine row was visible. */
+  executionObservation: import_effect.Schema.optional(import_effect.Schema.Literals(["observed", "missing"])),
+  /** Exact native semantic observation; never a control-stream fact. */
+  executionView: import_effect.Schema.optional(import_journal.ExecutionFact.View),
+  runId: RunId,
+  flowId: FlowId,
+  status: RunStatus,
+  planId: import_effect.Schema.optional(import_effect.Schema.String),
+  planDigest: import_effect.Schema.optional(import_effect.Schema.String),
+  /** The flow's executable identity when the run started; resume refuses a different one. */
+  executionDigest: import_effect.Schema.optional(import_effect.Schema.String),
+  /** The engine version that started the run. */
+  engineVersion: import_effect.Schema.optional(import_effect.Schema.String),
+  /**
+   * How the code that would resume this run differs from the code it
+   * recorded. Computed by an exact run lookup, never stored; absent when
+   * nothing changed or the run is terminal.
+   */
+  codeDrift: import_effect.Schema.optional(import_effect.Schema.Struct({
+    recorded: import_effect.Schema.optional(import_effect.Schema.String),
+    current: import_effect.Schema.optional(import_effect.Schema.String),
+    recordedEngine: import_effect.Schema.optional(import_effect.Schema.String),
+    currentEngine: import_effect.Schema.optional(import_effect.Schema.String)
+  })),
+  ownerId: import_effect.Schema.optional(import_effect.Schema.String),
+  /**
+   * The authenticated principal that launched this run through the control
+   * plane. A reader that does not see every run sees only the runs its own
+   * principal launched. Absent on a run the engine created (a child, a fork,
+   * a later trampoline round) and on a run launched before it was recorded;
+   * only a reader that sees every run sees those.
+   */
+  launchedBy: import_effect.Schema.optional(import_effect.Schema.Struct({ id: import_effect.Schema.String, kind: import_effect.Schema.String })),
+  /**
+   * The run this one branched from: the spawning run, the forked-from run, or
+   * the previous trampoline round. Absent on a run with no ancestor.
+   */
+  parentRunId: import_effect.Schema.optional(RunId),
+  /**
+   * The trampoline lineage this run is a round of, and which round it is.
+   * Both absent means a lineage of one, read as round 0 of itself.
+   */
+  lineageId: import_effect.Schema.optional(import_effect.Schema.String),
+  roundOrdinal: import_effect.Schema.optional(import_effect.Schema.Number),
+  origin: import_effect.Schema.optional(RunOrigin),
+  /**
+   * What a parked run is holding on: `approval`, `event`, `timer`, `quota`, or
+   * a reason a plugin declared. Absent on a run that is not parked, and on a
+   * park whose owner released the run without declaring one.
+   *
+   * The CLI's `ps` and `status` listings also render `executor` here for a run
+   * that has sat at `accepted` with no owner process past the launch handoff
+   * window. That value is computed at render time and never stored, so a
+   * reader going through the control RPC, the gateway projection, or a plugin
+   * sees the field absent on the same run.
+   */
+  waitingReason: import_effect.Schema.optional(import_effect.Schema.String),
+  /** What has been steered to this run and not yet delivered. */
+  steering: import_effect.Schema.optional(import_effect.Schema.Struct({ pending: import_effect.Schema.Number })),
+  /**
+   * A resume this run has been told to take and no host has taken up yet.
+   *
+   * A decision on an in-run approval restarts the run server-side, and the
+   * process that decides is usually not the process that hosts the execution:
+   * an operator's `smithers approve`, a gateway, a second CLI. The intent is
+   * therefore recorded durably here, and the host that owns the execution
+   * takes it up on its next tick and clears it. The number is the durable
+   * sequence of the request, so an operator can tell a delegation that is
+   * still outstanding from one that has been taken up. Absent means nothing
+   * is waiting to be taken up.
+   */
+  pendingResume: import_effect.Schema.optional(import_effect.Schema.Number),
+  /**
+   * The executor claim this run was parked under.
+   *
+   * A parked execution releases its owner columns — that is what makes it
+   * resumable at all — so after a park nothing on the row says which process
+   * is hosting it. Every process that shares the databases can therefore see
+   * the parked execution and resume it, including a short-lived `smithers
+   * approve` that would drive the run and then exit. The fence the park was
+   * written under is recorded here instead, so the host that parked the run
+   * recognizes its own park and every other composition can tell that the
+   * execution is not its to take up (triage B-15). Absent on a run that is not
+   * parked, and on a park written by something that held no fence.
+   */
+  parkedBy: import_effect.Schema.optional(import_effect.Schema.String),
+  /** Who cancelled this run, why, and on whose behalf. Absent until one did. */
+  cancellation: import_effect.Schema.optional(Cancellation),
+  /**
+   * Open human waits anywhere in this run's tree, nearest execution first.
+   *
+   * Present only when there is at least one, so a run nobody owes an answer
+   * carries no field rather than an empty array. `status` rolls up with it:
+   * a run any of whose descendants is parked on `approval` reports
+   * `waiting-approval`, which is what the existing inbox filters select on.
+   */
+  pendingWaits: import_effect.Schema.optional(import_effect.Schema.Array(PendingWait)),
+  /**
+   * When the run's approved deadline passes: its `createdAt` plus the
+   * envelope's `budget.deadline`, which is the instant the run is failed with
+   * `deadline_exceeded` if it has not settled. Absent on a run approved with
+   * no deadline.
+   */
+  deadlineAt: import_effect.Schema.optional(import_effect.Schema.Number),
+  createdAt: import_effect.Schema.Number,
+  updatedAt: import_effect.Schema.Number
+});
+const steerEnvelope = {
+  messageId: import_effect.Schema.String,
+  /**
+   * The run this message is for. `Control.steer` refuses a message whose
+   * `runId` disagrees with the one the call names: the notification would be
+   * admitted to the call's run while the stored message claimed another, and an
+   * operator reading it later would be told it belongs somewhere it was never
+   * delivered.
+   */
+  runId: RunId,
+  principal: Principal,
+  // Producer labels are data, distinct from principal. Public RPC strips
+  // these; a trusted product bridge may relay its already-authorized sender.
+  attribution: import_effect.Schema.optional(import_Notification.Attribution),
+  /**
+   * When the caller says it wrote the message. It is the caller's own
+   * statement, recorded on `control.steer.enqueued` and never used to decide
+   * anything. Over RPC the server's own clock is already on
+   * `principal.stampedAt`, which is the time a decision may be replayed
+   * against.
+   */
+  createdAt: import_effect.Schema.Number
+};
+const MessageSteer = import_effect.Schema.Struct({
+  ...steerEnvelope,
+  kind: import_effect.Schema.optional(import_effect.Schema.Literal("Message")),
+  body: import_effect.Schema.String
+});
+const SeatSteer = import_effect.Schema.Struct({ ...steerEnvelope, ...SteerPayload.SeatPayload.fields });
+const ThinkingSteer = import_effect.Schema.Struct({ ...steerEnvelope, ...SteerPayload.ThinkingPayload.fields });
+const ToolsSteer = import_effect.Schema.Struct({ ...steerEnvelope, ...SteerPayload.ToolsPayload.fields });
+const SteerMessage = import_effect.Schema.Union([MessageSteer, SeatSteer, ThinkingSteer, ToolsSteer]);
+const steerItem = (message) => {
+  switch (message.kind) {
+    case void 0:
+    case "Message":
+      return { kind: "Message", body: message.body };
+    case "Seat":
+      return { kind: "Seat", seat: message.seat };
+    case "Thinking":
+      return { kind: "Thinking", thinking: message.thinking };
+    case "Tools":
+      return { kind: "Tools", toolNames: message.toolNames };
+  }
+};
+const SignalPayload = import_effect.Schema.Struct({
+  name: import_effect.Schema.String,
+  payload: import_effect.Schema.Json
+});
+const PlanInputSchema = import_effect.Schema.Struct({
+  flowId: FlowId,
+  input: import_effect.Schema.Json,
+  idempotencyKey: import_effect.Schema.optional(IdempotencyKey),
+  budget: import_effect.Schema.optional(Envelope.fields.budget)
+});
+const RunInputSchema = import_effect.Schema.Union([
+  import_effect.Schema.TaggedStruct("Plan", {
+    planId: import_effect.Schema.String,
+    digest: import_effect.Schema.String,
+    envelope: Envelope,
+    idempotencyKey: IdempotencyKey
+  }),
+  import_effect.Schema.TaggedStruct("Resume", {
+    runId: RunId,
+    idempotencyKey: IdempotencyKey,
+    allowCodeDrift: import_effect.Schema.optional(import_effect.Schema.Boolean)
+  })
+]);
+const ApprovalInputSchema = ApprovalPayload;
+const SteerInputSchema = import_effect.Schema.Struct({
+  version: import_effect.Schema.optional(import_effect.Schema.Number),
+  runId: RunId,
+  message: SteerMessage,
+  idempotencyKey: IdempotencyKey
+});
+const SignalInputSchema = import_effect.Schema.Struct({
+  runId: RunId,
+  signal: SignalPayload,
+  idempotencyKey: IdempotencyKey
+});
+const RunMutationInputSchema = import_effect.Schema.Struct({ runId: RunId, idempotencyKey: IdempotencyKey });
+const ReasonedMutationInputSchema = import_effect.Schema.Struct({
+  ...RunMutationInputSchema.fields,
+  reason: import_effect.Schema.optional(import_effect.Schema.String)
+});
+const CancelInputSchema = ReasonedMutationInputSchema;
+const ResumeInputSchema = import_effect.Schema.Struct({
+  ...ReasonedMutationInputSchema.fields,
+  allowCodeDrift: import_effect.Schema.optional(import_effect.Schema.Boolean)
+});
+const WatchCursor = import_effect.Schema.Struct({
+  sequence: import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0), import_effect.Schema.isLessThan(Number.MAX_SAFE_INTEGER)),
+  offset: import_effect.Schema.optional(
+    import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0), import_effect.Schema.isLessThan(Number.MAX_SAFE_INTEGER))
+  )
+});
+const WatchFilter = import_effect.Schema.Struct({
+  runId: import_effect.Schema.optional(RunId),
+  /** Resume after a fully consumed source entry, including all its deltas. Requires `runId`. */
+  afterSequence: import_effect.Schema.optional(import_effect.Schema.Number),
+  /** Resume after one emitted event, even inside an expansion. Requires `runId`. Cannot be combined with `afterSequence`. */
+  afterCursor: import_effect.Schema.optional(WatchCursor),
+  follow: import_effect.Schema.optional(import_effect.Schema.Boolean)
+});
+const ControlEvent = import_effect.Schema.Struct({
+  /** Present on `ControlLive.watch` events; absent on raw projections and older providers. */
+  cursor: import_effect.Schema.optional(WatchCursor),
+  sequence: import_effect.Schema.Number,
+  kind: import_effect.Schema.String,
+  runId: import_effect.Schema.optional(RunId),
+  occurredAt: import_effect.Schema.Number,
+  payload: import_effect.Schema.Json
+});
+const defaultPageSize = 100;
+const maxPageSize = 500;
+const PageLimit = import_effect.Schema.Int.check(
+  import_effect.Schema.isGreaterThanOrEqualTo(1),
+  import_effect.Schema.isLessThanOrEqualTo(maxPageSize)
+);
+const FireOutcome = import_effect.Schema.Literals(["launched", "completed", "skipped", "buffered", "superseded", "failed"]);
+const TriggerSummary = import_effect.Schema.Struct({
+  triggerId: import_effect.Schema.String,
+  flowId: FlowId,
+  input: import_effect.Schema.Json,
+  cron: import_effect.Schema.String,
+  timezone: import_effect.Schema.optional(import_effect.Schema.String),
+  overlap: import_effect.Schema.Literals(["skip", "buffer-one", "supersede"]),
+  catchUp: import_effect.Schema.Literals(["none", "one", "all"]),
+  maxCatchUp: import_effect.Schema.optional(import_effect.Schema.Number),
+  enabled: import_effect.Schema.Boolean,
+  revision: import_effect.Schema.Number,
+  lastFiredAtMs: import_effect.Schema.optional(import_effect.Schema.Number),
+  pendingAtMs: import_effect.Schema.optional(import_effect.Schema.Number),
+  activeRunId: import_effect.Schema.optional(RunId),
+  nextOccurrencesMs: import_effect.Schema.Array(import_effect.Schema.Number),
+  schedulerLastTickMs: import_effect.Schema.optional(import_effect.Schema.Number)
+});
+const FireSummary = import_effect.Schema.Struct({
+  triggerId: import_effect.Schema.String,
+  occurrenceAtMs: import_effect.Schema.Number,
+  outcome: import_effect.Schema.NullOr(FireOutcome),
+  runId: import_effect.Schema.optional(RunId),
+  error: import_effect.Schema.optional(import_effect.Schema.String),
+  waiting: import_effect.Schema.optional(import_effect.Schema.Literal("approval"))
+});
+const PlanDecision = import_effect.Schema.Literals(["pending", "approved", "denied"]);
+const PlanSummary = import_effect.Schema.Struct({
+  card: PlanCard,
+  input: import_effect.Schema.Json,
+  decision: PlanDecision
+});
+const ExecutionBatch = import_effect.Schema.Struct({
+  source: import_effect.Schema.NullOr(import_effect.Schema.String),
+  revision: import_effect.Schema.NullOr(import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0))),
+  snapshots: import_effect.Schema.Array(import_effect.Schema.Union([
+    import_effect.Schema.TaggedStruct("Observed", {
+      executionId: RunId,
+      source: import_effect.Schema.String,
+      revision: import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0)),
+      observation: import_journal.ExecutionFact.Observation
+    }),
+    import_effect.Schema.TaggedStruct("Missing", {
+      executionId: RunId,
+      source: import_effect.Schema.String,
+      revision: import_effect.Schema.Int.check(import_effect.Schema.isGreaterThanOrEqualTo(0)),
+      deleted: import_effect.Schema.Boolean
+    }),
+    import_effect.Schema.TaggedStruct("Unavailable", {
+      executionId: RunId,
+      reason: import_effect.Schema.Literals(["unsupported", "outside-run", "ancestry-unavailable"])
+    })
+  ]))
+});
+const ListRequest = import_effect.Schema.Union([
+  import_effect.Schema.TaggedStruct("executions", {
+    runId: RunId,
+    executionIds: import_effect.Schema.Array(import_effect.Schema.NonEmptyString).check(import_effect.Schema.isMaxLength(200))
+  }),
+  import_effect.Schema.TaggedStruct("flows", {
+    filters: import_effect.Schema.optional(import_effect.Schema.Json),
+    cursor: import_effect.Schema.optional(import_effect.Schema.String),
+    limit: import_effect.Schema.optional(PageLimit)
+  }),
+  import_effect.Schema.TaggedStruct("runs", {
+    filters: import_effect.Schema.optional(import_effect.Schema.Struct({
+      runId: import_effect.Schema.optional(RunId),
+      flowId: import_effect.Schema.optional(FlowId),
+      status: import_effect.Schema.optional(RunStatus),
+      terminal: import_effect.Schema.optional(import_effect.Schema.Boolean),
+      principalId: import_effect.Schema.optional(import_effect.Schema.String),
+      parentRunId: import_effect.Schema.optional(RunId),
+      lineageId: import_effect.Schema.optional(import_effect.Schema.String),
+      /** Runs created at or after this epoch millisecond. */
+      since: import_effect.Schema.optional(import_effect.Schema.Number),
+      /** Runs created before this epoch millisecond. */
+      until: import_effect.Schema.optional(import_effect.Schema.Number),
+      /** Runs a fire of this trigger started. */
+      triggerId: import_effect.Schema.optional(import_effect.Schema.String)
+    })),
+    /** Creation time, newest or oldest first; omitted preserves the historical listing order. */
+    order: import_effect.Schema.optional(import_effect.Schema.Literals(["newest", "oldest"])),
+    cursor: import_effect.Schema.optional(import_effect.Schema.String),
+    limit: import_effect.Schema.optional(PageLimit)
+  }),
+  import_effect.Schema.TaggedStruct("triggers", {
+    filters: import_effect.Schema.optional(import_effect.Schema.Struct({
+      triggerId: import_effect.Schema.optional(import_effect.Schema.String),
+      flowId: import_effect.Schema.optional(FlowId),
+      enabled: import_effect.Schema.optional(import_effect.Schema.Boolean)
+    })),
+    cursor: import_effect.Schema.optional(import_effect.Schema.String),
+    limit: import_effect.Schema.optional(PageLimit)
+  }),
+  import_effect.Schema.TaggedStruct("fires", {
+    filters: import_effect.Schema.optional(import_effect.Schema.Struct({
+      triggerId: import_effect.Schema.optional(import_effect.Schema.String),
+      runId: import_effect.Schema.optional(RunId),
+      outcome: import_effect.Schema.optional(FireOutcome)
+    })),
+    cursor: import_effect.Schema.optional(import_effect.Schema.String),
+    limit: import_effect.Schema.optional(PageLimit)
+  }),
+  import_effect.Schema.TaggedStruct("plans", {
+    filters: import_effect.Schema.optional(import_effect.Schema.Struct({
+      flowId: import_effect.Schema.optional(FlowId),
+      decision: import_effect.Schema.optional(PlanDecision)
+    })),
+    cursor: import_effect.Schema.optional(import_effect.Schema.String),
+    limit: import_effect.Schema.optional(PageLimit)
+  })
+]);
+const ListResponse = import_effect.Schema.Union([
+  import_effect.Schema.TaggedStruct("executions", {
+    source: ExecutionBatch.fields.source,
+    revision: ExecutionBatch.fields.revision,
+    items: ExecutionBatch.fields.snapshots,
+    nextCursor: import_effect.Schema.optional(import_effect.Schema.Never)
+  }),
+  import_effect.Schema.TaggedStruct("flows", {
+    items: import_effect.Schema.Array(
+      import_effect.Schema.Struct({ flowId: FlowId, description: import_effect.Schema.String, inputSchema: import_effect.Schema.optional(import_effect.Schema.Json) })
+    ),
+    warnings: import_effect.Schema.optional(import_effect.Schema.Array(import_Descriptor.DiscoveryWarning)),
+    nextCursor: import_effect.Schema.optional(import_effect.Schema.String)
+  }),
+  import_effect.Schema.TaggedStruct("runs", {
+    items: import_effect.Schema.Array(RunSummary),
+    nextCursor: import_effect.Schema.optional(import_effect.Schema.String)
+  }),
+  import_effect.Schema.TaggedStruct("triggers", {
+    items: import_effect.Schema.Array(TriggerSummary),
+    nextCursor: import_effect.Schema.optional(import_effect.Schema.String)
+  }),
+  import_effect.Schema.TaggedStruct("fires", {
+    items: import_effect.Schema.Array(FireSummary),
+    nextCursor: import_effect.Schema.optional(import_effect.Schema.String)
+  }),
+  import_effect.Schema.TaggedStruct("plans", {
+    items: import_effect.Schema.Array(PlanSummary),
+    nextCursor: import_effect.Schema.optional(import_effect.Schema.String)
+  })
+]);
+const RunHost = import_effect.Schema.Struct({ hostId: import_effect.Schema.String, pid: import_effect.Schema.Number });
+const Receipt = import_effect.Schema.Union([
+  import_effect.Schema.TaggedStruct("Accepted", {
+    inputConsumed: import_effect.Schema.optional(import_effect.Schema.Boolean),
+    inputBody: import_effect.Schema.optional(import_effect.Schema.String),
+    receiptId: import_effect.Schema.String,
+    runId: import_effect.Schema.optional(RunId),
+    handedTo: import_effect.Schema.optional(RunHost)
+  }),
+  import_effect.Schema.TaggedStruct("AlreadyApplied", {
+    receiptId: import_effect.Schema.String,
+    runId: import_effect.Schema.optional(RunId),
+    inputConsumed: import_effect.Schema.optional(import_effect.Schema.Boolean),
+    inputBody: import_effect.Schema.optional(import_effect.Schema.String)
+  }),
+  import_effect.Schema.TaggedStruct("Parked", {
+    receiptId: import_effect.Schema.String,
+    planId: import_effect.Schema.String,
+    status: import_effect.Schema.Literal("waiting-approval")
+  }),
+  import_effect.Schema.TaggedStruct("Conflict", { message: import_effect.Schema.String }),
+  import_effect.Schema.TaggedStruct("Terminal", { runId: RunId, status: RunStatus })
+]);
+//# sourceMappingURL=ControlSchema.js.map