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

package/dist/cjs/ControlClient.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/ControlClient.ts"],
+  "sourcesContent": ["/**\n * RPC client layer projected back into the control service interface.\n *\n * @since 0.1.0\n */\n\nimport { Cause, Effect, Layer, Result, Schema, Stream } from \"effect\"\nimport { HttpClient, HttpClientRequest } from \"effect/unstable/http\"\nimport { RpcClient, RpcClientError } from \"effect/unstable/rpc\"\nimport { Control, make } from \"./Control.ts\"\nimport { type ControlError, ControlErrorSchema, TransportError, Unauthorized } from \"./ControlError.ts\"\nimport { ControlRpcs } from \"./ControlRpcs.ts\"\nimport {\n  ApprovalInputSchema,\n  CancelInputSchema,\n  ListRequest,\n  PlanInputSchema,\n  ResumeInputSchema,\n  RunInputSchema,\n  SignalInputSchema,\n  SteerInputSchema,\n  WatchFilter\n} from \"./ControlSchema.ts\"\n\n/**\n * Whether a value is one of the control plane's declared failures, as opposed\n * to a defect that escaped some other layer.\n *\n * Derived from `ControlError.ControlErrorSchema` rather than restated, so a new\n * error class cannot be a member of the union and a stranger to the client.\n *\n * @category refinements\n * @since 0.1.0\n */\nexport const isControlError = Schema.is(ControlErrorSchema)\n\ninterface TransportClassification {\n  readonly message: string\n  readonly retryable: boolean\n}\n\nconst requestEncoding: TransportClassification = {\n  message: \"The control request could not be encoded.\",\n  retryable: false\n}\n\nconst responseDecoding: TransportClassification = {\n  message: \"The control response could not be decoded.\",\n  retryable: false\n}\n\nconst connectionFailure: TransportClassification = {\n  message: \"The control server could not be reached.\",\n  retryable: true\n}\n\nconst clientHttpFailure: TransportClassification = {\n  message: \"The control server rejected the HTTP request.\",\n  retryable: false\n}\n\nconst serverHttpFailure: TransportClassification = {\n  message: \"The control server failed while handling the HTTP request.\",\n  retryable: true\n}\n\nconst invalidClientUrl: TransportClassification = {\n  message: \"The control server URL is invalid.\",\n  retryable: false\n}\n\nconst unknownClientFailure: TransportClassification = {\n  message: \"The control RPC client failed.\",\n  retryable: false\n}\n\nconst transportError = (cause: unknown, classification: TransportClassification): TransportError =>\n  new TransportError({\n    ...classification,\n    cause\n  })\n\n// A `StatusCodeError` reported by the RPC client always carries the concrete\n// error, and that error always carries its response. The three refusals below\n// are what keeps a hand-built wrapper without one from being read as a 5xx and\n// retried forever; none of them is reachable from the client's own transports.\nconst statusFrom = (cause: unknown): number | undefined => {\n  /* v8 ignore next -- a StatusCodeError cause always carries its response */\n  if (typeof cause !== \"object\" || cause === null || !(\"response\" in cause)) return undefined\n  const response = cause.response\n  /* v8 ignore next -- as above: the response is an object carrying a status */\n  if (typeof response !== \"object\" || response === null || !(\"status\" in response)) return undefined\n  /* v8 ignore next -- as above: the status is a number */\n  return typeof response.status === \"number\" ? response.status : undefined\n}\n\ntype HttpFailureKind = Extract<RpcClientError.RpcClientError[\"reason\"], { readonly _tag: \"HttpError\" }>[\"kind\"]\ntype TransportReason = RpcClientError.RpcClientError[\"reason\"][\"_tag\"]\n\n/**\n * What each HTTP failure means for a retry.\n *\n * `StatusCodeError` is absent on purpose: it is the one kind whose answer\n * depends on the response, not on the kind.\n */\nconst httpClassification: Record<Exclude<HttpFailureKind, \"StatusCodeError\">, TransportClassification> = {\n  TransportError: connectionFailure,\n  EncodeError: requestEncoding,\n  InvalidUrlError: invalidClientUrl,\n  DecodeError: responseDecoding,\n  EmptyBodyError: responseDecoding\n}\n\n/**\n * What each non-HTTP transport failure means for a retry.\n *\n * A table rather than a switch, because the mapping is data: the compiler\n * still requires every reason the RPC client can report to have an answer, and\n * a reader can check the whole policy at a glance.\n */\nconst reasonClassification: Record<Exclude<TransportReason, \"HttpError\">, TransportClassification> = {\n  RpcClientDefect: responseDecoding,\n  SocketReadError: connectionFailure,\n  SocketWriteError: connectionFailure,\n  SocketOpenError: connectionFailure,\n  // The socket cannot perform a requested protocol upgrade; retries of the\n  // same unsupported operation cannot change that host capability.\n  SocketUpgradeError: unknownClientFailure,\n  SocketCloseError: connectionFailure,\n  // A worker transport is not composable with this client, which speaks HTTP\n  // and WebSocket. The entries exist so the table stays exhaustive.\n  WorkerSpawnError: unknownClientFailure,\n  WorkerSendError: unknownClientFailure,\n  WorkerReceiveError: unknownClientFailure,\n  WorkerUnknownError: unknownClientFailure\n}\n\nconst classifyRpcClientError = (error: RpcClientError.RpcClientError): TransportClassification => {\n  const reason = error.reason\n  if (reason._tag !== \"HttpError\") return reasonClassification[reason._tag]\n  if (reason.kind !== \"StatusCodeError\") return httpClassification[reason.kind]\n  // Effect's serializable HttpError keeps the concrete StatusCodeError in\n  // `cause`. The wrapper has no separate status field, so a hand-built wrapper\n  // without that cause cannot safely be classified as retryable and falls back\n  // to the client class.\n  const status = statusFrom(reason.cause)\n  return status !== undefined && status >= 500 && status <= 599\n    ? serverHttpFailure\n    : clientHttpFailure\n}\n\nconst isRpcClientError = Schema.is(RpcClientError.RpcClientError)\n\nconst classify = (error: unknown): TransportClassification => {\n  if (Schema.isSchemaError(error)) return responseDecoding\n  if (isRpcClientError(error)) return classifyRpcClientError(error)\n  return unknownClientFailure\n}\n\n// Preserve the operation-specific control failures from the RPC schema while\n// replacing transport and decoding failures with the public TransportError.\nconst normalizedFailure = <E>(cause: Cause.Cause<E>): Effect.Effect<never, (E & ControlError) | TransportError> => {\n  const failure = Cause.findError(cause)\n  if (Result.isSuccess(failure)) {\n    return Effect.fail(\n      isControlError(failure.success)\n        ? failure.success\n        : transportError(failure.success, classify(failure.success))\n    )\n  }\n  const defect = Cause.findDefect(cause)\n  // A cause with neither a failure nor a defect is an interruption, and an\n  // operator's own cancellation is not the server failing. It is re-raised\n  // exactly as it arrived rather than described as a transport failure.\n  /* v8 ignore next 2 -- the fiber propagates an interrupt-only cause without reaching this operator */\n  return Result.isSuccess(defect)\n    ? Effect.fail(transportError(defect.success, classify(defect.success)))\n    : Effect.failCause(cause as Cause.Cause<(E & ControlError) | TransportError>)\n}\n\nconst normalize = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, (E & ControlError) | TransportError, R> =>\n  Effect.catchCause(effect, normalizedFailure)\n\ntype RequestEncoder = (input: unknown) => Effect.Effect<unknown, Schema.SchemaError>\n\nconst encoder = (schema: Schema.Top): RequestEncoder =>\n  // Every request schema in this module is service-free. `Schema.Top` erases\n  // that fact to `unknown`, so restore it at this one construction boundary.\n  Schema.encodeUnknownEffect(Schema.toCodecJson(schema)) as RequestEncoder\n\nconst planEncoder = encoder(PlanInputSchema)\nconst runEncoder = encoder(RunInputSchema)\nconst approvalEncoder = encoder(ApprovalInputSchema)\nconst steerEncoder = encoder(SteerInputSchema)\nconst signalEncoder = encoder(SignalInputSchema)\nconst cancelEncoder = encoder(CancelInputSchema)\nconst resumeEncoder = encoder(ResumeInputSchema)\nconst listEncoder = encoder(ListRequest)\nconst watchEncoder = encoder(WatchFilter)\n\nconst normalizeRequest = <A, E, R>(\n  encode: RequestEncoder,\n  input: unknown,\n  request: () => Effect.Effect<A, E, R>\n): Effect.Effect<A, (E & ControlError) | TransportError, R> =>\n  encode(input).pipe(\n    Effect.mapError((cause) => transportError(cause, requestEncoding)),\n    Effect.andThen(Effect.suspend(() => normalize(request())))\n  )\n\nconst normalizeStream = <A, E, R>(\n  stream: Stream.Stream<A, E, R>\n): Stream.Stream<A, (E & ControlError) | TransportError, R> =>\n  Stream.catchCause(stream, (cause) => Stream.fromEffect(normalizedFailure(cause)))\n\nconst normalizeStreamRequest = <A, E, R>(\n  encode: RequestEncoder,\n  input: unknown,\n  request: () => Stream.Stream<A, E, R>\n): Stream.Stream<A, (E & ControlError) | TransportError, R> =>\n  Stream.unwrap(\n    encode(input).pipe(\n      Effect.mapError((cause) => transportError(cause, requestEncoding)),\n      Effect.map(() => normalizeStream(request()))\n    )\n  )\n\n/**\n * Client transport configuration. Unary procedures use HTTP at this URL;\n * `watch` uses the abstract WebSocket supplied by the platform layer.\n *\n * `credential` reaches the HTTP protocol only. It is attached as a bearer\n * token on each HTTP RPC request; the `watch` stream rides a WebSocket whose\n * upgrade request a browser cannot add headers to, so the socket carries no\n * credential at all in a browser deployment. A deployment that authenticates\n * control traffic must therefore front the socket (terminate auth at a proxy\n * that injects the credential on the upgrade) or serve `watch` over the HTTP\n * protocol instead.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface ClientConfig {\n  readonly url: string\n  /**\n   * Bearer token attached to every HTTP RPC request when present.\n   *\n   * Not sent on the `watch` WebSocket: see {@link ClientConfig}.\n   */\n  readonly credential?: string | undefined\n}\n\n/**\n * Provides `Control` through an RPC client while preserving the local vtable.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer = (config: ClientConfig) => {\n  const http = RpcClient.layerProtocolHttp({\n    url: config.url,\n    transformClient: (client) => {\n      // The RPC protocol already admits HttpClientError, but transformClient's\n      // generic signature cannot express that filtering adds the same error\n      // its input client already carries.\n      const checked = HttpClient.filterStatusOk(client) as typeof client\n      return config.credential === undefined\n        ? checked\n        : HttpClient.mapRequest(checked, HttpClientRequest.bearerToken(config.credential))\n    }\n  })\n  const websocket = RpcClient.layerProtocolSocket()\n  return Layer.effect(\n    Control,\n    Effect.gen(function*() {\n      // Built into the layer's own scope: `Effect.provide(layer)` would close\n      // each protocol as soon as the client was constructed.\n      const httpServices = yield* Layer.build(http)\n      const websocketServices = yield* Layer.build(websocket)\n      const unary = yield* RpcClient.make(ControlRpcs).pipe(Effect.provide(httpServices))\n      const streaming = yield* RpcClient.make(ControlRpcs).pipe(Effect.provide(websocketServices))\n      return make({\n        plan: Effect.fn(\"Control.plan\")((input) => normalizeRequest(planEncoder, input, () => unary.Plan(input))),\n        run: Effect.fn(\"Control.run\")((input) => normalizeRequest(runEncoder, input, () => unary.Run(input))),\n        // RPC authenticates with this client's credential and does not carry\n        // local attribution. Refuse here before an agent becomes that operator.\n        approve: Effect.fn(\"Control.approve\")((input) =>\n          normalizeRequest(approvalEncoder, input, () =>\n            input.principal?.kind === \"agent\"\n              ? Effect.fail(new Unauthorized({ message: \"Approval decisions are operator-only\" }))\n              : unary.Approve(input))\n        ),\n        deny: Effect.fn(\"Control.deny\")((input) =>\n          normalizeRequest(approvalEncoder, input, () =>\n            input.principal?.kind === \"agent\"\n              ? Effect.fail(new Unauthorized({ message: \"Approval decisions are operator-only\" }))\n              : unary.Deny(input))\n        ),\n        steer: Effect.fn(\"Control.steer\")((input) => normalizeRequest(steerEncoder, input, () => unary.Steer(input))),\n        signal: Effect.fn(\"Control.signal\")((input) =>\n          normalizeRequest(signalEncoder, input, () => unary.Signal(input))\n        ),\n        cancel: Effect.fn(\"Control.cancel\")((input) =>\n          normalizeRequest(cancelEncoder, input, () => unary.Cancel(input))\n        ),\n        resume: Effect.fn(\"Control.resume\")((input) =>\n          normalizeRequest(resumeEncoder, input, () => unary.Resume(input))\n        ),\n        list: Effect.fn(\"Control.list\")((input) => normalizeRequest(listEncoder, input, () => unary.List(input))),\n        // `watch` is the only procedure on the socket protocol, and the\n        // socket is why `credential` cannot protect it: a browser's WebSocket\n        // upgrade takes no headers, so the bearer token that authenticates\n        // every unary call above never reaches this stream. Credentialed\n        // deployments front the socket or use the HTTP protocol for watch.\n        watch: (input) => normalizeStreamRequest(watchEncoder, input, () => streaming.Watch(input))\n      })\n    })\n  )\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/ControlError.d.ts

@@ -0,0 +1,318 @@
+/**
+ * Stable, schema-backed control-plane failures.
+ *
+ * @since 0.1.0
+ */
+import { NotificationError } from "@smthrs/notifications/NotificationQueue";
+import { Schema } from "effect";
+declare const RunNotFound_base: Schema.Class<RunNotFound, Schema.TaggedStruct<"/control/RunNotFound", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"run_not_found">>;
+    readonly runId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * No run with this id exists.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class RunNotFound extends RunNotFound_base {
+    /**
+     * The sentence an operator reads. Without one the CLI printed the bare
+     * fields, `run_not_found runId=nope`, which names no next action.
+     */
+    get message(): string;
+}
+declare const PlanNotFound_base: Schema.Class<PlanNotFound, Schema.TaggedStruct<"/control/PlanNotFound", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"plan_not_found">>;
+    readonly planId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * No plan with this id exists.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class PlanNotFound extends PlanNotFound_base {
+    /**
+     * The sentence an operator reads. Every renderer in the tree prints
+     * `message`, so a refusal without one does not explain the next action.
+     */
+    get message(): string;
+}
+declare const PlanDenied_base: Schema.Class<PlanDenied, Schema.TaggedStruct<"/control/PlanDenied", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"plan_denied">>;
+    readonly planId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The plan was denied and cannot be launched.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class PlanDenied extends PlanDenied_base {
+    /**
+     * The sentence an operator reads. Every renderer in the tree prints
+     * `message`, so a denial must state how to make a later launch possible.
+     */
+    get message(): string;
+}
+declare const FlowNotFound_base: Schema.Class<FlowNotFound, Schema.TaggedStruct<"/control/FlowNotFound", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"flow_not_found">>;
+    readonly flowId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * No flow with this id is registered.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class FlowNotFound extends FlowNotFound_base {
+    /**
+     * The sentence an operator reads, which names the command that lists the
+     * flows a caller can start.
+     */
+    get message(): string;
+}
+declare const PlanDigestMismatch_base: Schema.Class<PlanDigestMismatch, Schema.TaggedStruct<"/control/PlanDigestMismatch", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"plan_digest_mismatch">>;
+    readonly planId: Schema.String;
+    readonly expected: Schema.String;
+    readonly actual: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The submitted plan does not hash to the digest the caller declared, so
+ * the control plane refuses to store it.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class PlanDigestMismatch extends PlanDigestMismatch_base {
+}
+declare const EnvelopeMismatch_base: Schema.Class<EnvelopeMismatch, Schema.TaggedStruct<"/control/EnvelopeMismatch", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"envelope_mismatch">>;
+    readonly planId: Schema.String;
+    readonly expected: Schema.String;
+    readonly actual: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The plan's effect envelope differs from the one the caller declared.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class EnvelopeMismatch extends EnvelopeMismatch_base {
+}
+declare const ClaimLost_base: Schema.Class<ClaimLost, Schema.TaggedStruct<"/control/ClaimLost", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"claim_lost">>;
+    readonly runId: Schema.String;
+    readonly reason: Schema.optional<Schema.String>;
+    readonly parkedBy: Schema.optional<Schema.Struct<{
+        readonly hostId: Schema.String;
+        readonly pid: Schema.Number;
+    }>>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The caller's claim on this run lapsed or was fenced by a newer owner.
+ *
+ * `parkedBy` names the live process that parked the run: it, not the caller,
+ * drives the run, so `Control.resume` hands the resume to it.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class ClaimLost extends ClaimLost_base {
+}
+declare const CodeDrift_base: Schema.Class<CodeDrift, Schema.TaggedStruct<"/control/CodeDrift", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"code_drift">>;
+    readonly runId: Schema.String;
+    readonly flowId: Schema.String;
+    /** The execution digest the run started with; absent when only the engine changed. */
+    readonly recorded: Schema.optional<Schema.String>;
+    /** The flow's execution digest now; absent when the flow is gone or declares none. */
+    readonly current: Schema.optional<Schema.String>;
+    /** The engine version the run started on, when the engine changed. */
+    readonly recordedEngine: Schema.optional<Schema.String>;
+    /** The engine version resuming it, when the engine changed. */
+    readonly currentEngine: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The run's flow or engine changed since the run started, so resuming it would
+ * run code the run did not start with. Pass `allowCodeDrift` to resume it
+ * anyway; the run then records the code it resumed on.
+ *
+ * @category errors
+ * @since 1.0.0
+ */
+export declare class CodeDrift extends CodeDrift_base {
+    get message(): string;
+}
+declare const AlreadyResolved_base: Schema.Class<AlreadyResolved, Schema.TaggedStruct<"/control/AlreadyResolved", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"already_resolved">>;
+    readonly requestId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * This request was already answered; a second answer is refused rather
+ * than overwriting the first.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class AlreadyResolved extends AlreadyResolved_base {
+}
+declare const InvalidInput_base: Schema.Class<InvalidInput, Schema.TaggedStruct<"/control/InvalidInput", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"invalid_input">>;
+    readonly issue: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The request did not satisfy its schema or a stated precondition.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class InvalidInput extends InvalidInput_base {
+}
+declare const Unauthorized_base: Schema.Class<Unauthorized, Schema.TaggedStruct<"/control/Unauthorized", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"unauthorized">>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The caller lacks a usable credential or authority for this operation.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class Unauthorized extends Unauthorized_base {
+}
+declare const Unavailable_base: Schema.Class<Unavailable, Schema.TaggedStruct<"/control/Unavailable", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"unavailable">>;
+    readonly feature: Schema.String;
+    readonly ticket: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The operation is not implemented in this deployment. `ticket` names the
+ * issue that tracks it, per `Concepts/Tickets Not Exceptions.md`.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class Unavailable extends Unavailable_base {
+}
+declare const TransportError_base: Schema.Class<TransportError, Schema.TaggedStruct<"/control/TransportError", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"transport_error">>;
+    readonly message: Schema.String;
+    readonly retryable: Schema.Boolean;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The request failed before a declared control response reached the caller.
+ *
+ * `retryable` classifies only the transport phase. Connection failures and
+ * HTTP 5xx responses are retryable; local encode failures, response decode
+ * failures, and HTTP 4xx responses are not. A caller may resend a retryable
+ * mutation only when its idempotency key makes replay safe. A keyless request
+ * can have reached the server even when its response was lost.
+ *
+ * `message` is a fixed operator-facing sentence. `cause` retains the original
+ * client failure for diagnostics without copying its raw text into output.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class TransportError extends TransportError_base {
+}
+declare const PersistenceError_base: Schema.Class<PersistenceError, Schema.TaggedStruct<"/control/PersistenceError", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"persistence_failed">>;
+    readonly operation: Schema.String;
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A control-plane store operation failed.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class PersistenceError extends PersistenceError_base {
+}
+declare const LaunchFailed_base: Schema.Class<LaunchFailed, Schema.TaggedStruct<"/control/LaunchFailed", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"launch_failed">>;
+    readonly runId: Schema.String;
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The executor refused or could not start the run.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class LaunchFailed extends LaunchFailed_base {
+}
+declare const NoMatchingWait_base: Schema.Class<NoMatchingWait, Schema.TaggedStruct<"/control/NoMatchingWait", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"no_matching_wait">>;
+    readonly runId: Schema.String;
+    readonly waitName: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A signal named a wait point the run does not have open.
+ *
+ * `Control.signal` completes the `WaitFor` deferred a run is parked on. A
+ * signal whose name matches no open wait point completes nothing, and recording
+ * it anyway would leave an operator watching a delivery that never lands, so it
+ * is refused where it arrives.
+ *
+ * The signal's name is `waitName`, not `name`. A field spelled `name` on an
+ * `Error` subclass shadows `Error.prototype.name`, which every renderer in the
+ * tree reads: `smithers signal run-3 '{"name":"go"}'` against a timer-parked
+ * run printed `go: ` to stderr and exited 1, because `bin.ts` reports
+ * `${error.name}: ${error.message}` and this class had overwritten one and
+ * defined neither (release validation, defect D3).
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class NoMatchingWait extends NoMatchingWait_base {
+    /**
+     * The sentence an operator reads. Every other renderer in the tree prints
+     * `message`, so a refusal with none is a refusal with no reason.
+     */
+    get message(): string;
+}
+declare const CredentialConflict_base: Schema.Class<CredentialConflict, Schema.TaggedStruct<"/control/CredentialConflict", {
+    readonly code: Schema.withConstructorDefault<Schema.Literal<"credential_conflict">>;
+    readonly id: Schema.String;
+    readonly expectedVersion: Schema.Number;
+    readonly actualVersion: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A credential write lost a race: the record moved on before this writer
+ * committed, so the update is refused rather than silently overwriting the
+ * winner.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class CredentialConflict extends CredentialConflict_base {
+}
+/**
+ * Every stable failure emitted by the control plane, as one schema.
+ *
+ * This is the single membership list. The exported union type is derived from
+ * it and `ControlClient.isControlError` is `Schema.is` of it, so an error class
+ * added here reaches both. Two hand-maintained lists drifted: `ControlError`
+ * omitted `CredentialConflict` while the README documented it as a member, and
+ * `isControlError` repeated the same thirteen names a second time.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare const ControlErrorSchema: Schema.Union<readonly [typeof RunNotFound, typeof PlanNotFound, typeof PlanDenied, typeof FlowNotFound, typeof PlanDigestMismatch, typeof EnvelopeMismatch, typeof ClaimLost, typeof CodeDrift, typeof AlreadyResolved, typeof InvalidInput, typeof Unauthorized, typeof Unavailable, typeof TransportError, typeof PersistenceError, typeof LaunchFailed, typeof NoMatchingWait, typeof CredentialConflict, typeof NotificationError]>;
+/**
+ * Every stable failure emitted by the control plane.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export type ControlError = typeof ControlErrorSchema.Type;
+export {};
+//# sourceMappingURL=ControlError.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ControlError.d.ts","sourceRoot":"","sources":["../../src/ControlError.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,yCAAyC,CAAA;AAC3E,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;;;;;AAMvC;;;;;GAKG;AACH,qBAAa,WAAY,SAAQ,gBAG/B;IACA;;;OAGG;IACH,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;;AAED;;;;;GAKG;AACH,qBAAa,YAAa,SAAQ,iBAGhC;IACA;;;OAGG;IACH,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;;AAED;;;;;GAKG;AACH,qBAAa,UAAW,SAAQ,eAG9B;IACA;;;OAGG;IACH,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;;AAED;;;;;GAKG;AACH,qBAAa,YAAa,SAAQ,iBAGhC;IACA;;;OAGG;IACH,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;;;;AAED;;;;;;GAMG;AACH,qBAAa,kBAAmB,SAAQ,uBAKtC;CAAG;;;;;;;AAEL;;;;;GAKG;AACH,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;;;;;;AAEL;;;;;;;;GAQG;AACH,qBAAa,SAAU,SAAQ,cAK7B;CAAG;;;;;IAcH,sFAAsF;;IAEtF,sFAAsF;;IAEtF,sEAAsE;;IAEtE,+DAA+D;;;AAlBjE;;;;;;;GAOG;AACH,qBAAa,SAAU,SAAQ,cAY7B;IACA,IAAa,OAAO,IAAI,MAAM,CAc7B;CACF;;;;;AAED;;;;;;GAMG;AACH,qBAAa,eAAgB,SAAQ,oBAGnC;CAAG;;;;;AAEL;;;;;GAKG;AACH,qBAAa,YAAa,SAAQ,iBAGhC;CAAG;;;;;AAEL;;;;;GAKG;AACH,qBAAa,YAAa,SAAQ,iBAGhC;CAAG;;;;;;AAEL;;;;;;GAMG;AACH,qBAAa,WAAY,SAAQ,gBAI/B;CAAG;;;;;;;AAEL;;;;;;;;;;;;;;GAcG;AACH,qBAAa,cAAe,SAAQ,mBAKlC;CAAG;;;;;;;AAEL;;;;;GAKG;AACH,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;;;AAEL;;;;;GAKG;AACH,qBAAa,YAAa,SAAQ,iBAKhC;CAAG;;;;;;AAEL;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,cAAe,SAAQ,mBAIlC;IACA;;;OAGG;IACH,IAAa,OAAO,IAAI,MAAM,CAG7B;CACF;;;;;;;AAED;;;;;;;GAOG;AACH,qBAAa,kBAAmB,SAAQ,uBAKtC;CAAG;AAEL;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,kBAAkB,yaAmB7B,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,kBAAkB,CAAC,IAAI,CAAA"}

package/dist/cjs/ControlError.js

@@ -0,0 +1,249 @@
+"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 ControlError_exports = {};
+__export(ControlError_exports, {
+  AlreadyResolved: () => AlreadyResolved,
+  ClaimLost: () => ClaimLost,
+  CodeDrift: () => CodeDrift,
+  ControlErrorSchema: () => ControlErrorSchema,
+  CredentialConflict: () => CredentialConflict,
+  EnvelopeMismatch: () => EnvelopeMismatch,
+  FlowNotFound: () => FlowNotFound,
+  InvalidInput: () => InvalidInput,
+  LaunchFailed: () => LaunchFailed,
+  NoMatchingWait: () => NoMatchingWait,
+  PersistenceError: () => PersistenceError,
+  PlanDenied: () => PlanDenied,
+  PlanDigestMismatch: () => PlanDigestMismatch,
+  PlanNotFound: () => PlanNotFound,
+  RunNotFound: () => RunNotFound,
+  TransportError: () => TransportError,
+  Unauthorized: () => Unauthorized,
+  Unavailable: () => Unavailable
+});
+module.exports = __toCommonJS(ControlError_exports);
+var Fault = __toESM(require("@smthrs/flow/Fault"), 1);
+var import_NotificationQueue = require("@smthrs/notifications/NotificationQueue");
+var import_effect = require("effect");
+var import_ControlSchema = require("./ControlSchema.js");
+const constantCode = (code) => import_effect.Schema.Literal(code).pipe(import_effect.Schema.withConstructorDefault(import_effect.Effect.succeed(code)));
+class RunNotFound extends import_effect.Schema.TaggedError()("/control/RunNotFound", {
+  code: constantCode("run_not_found"),
+  runId: import_ControlSchema.RunId
+}) {
+  /**
+   * The sentence an operator reads. Without one the CLI printed the bare
+   * fields, `run_not_found runId=nope`, which names no next action.
+   */
+  get message() {
+    return `Run ${this.runId} was not found. Run \`smthrs runs list\` to see the runs you can read.`;
+  }
+}
+class PlanNotFound extends import_effect.Schema.TaggedError()("/control/PlanNotFound", {
+  code: constantCode("plan_not_found"),
+  planId: import_effect.Schema.String
+}) {
+  /**
+   * The sentence an operator reads. Every renderer in the tree prints
+   * `message`, so a refusal without one does not explain the next action.
+   */
+  get message() {
+    return `Plan ${this.planId} was not found. Create the plan again before approving or launching it.`;
+  }
+}
+class PlanDenied extends import_effect.Schema.TaggedError()("/control/PlanDenied", {
+  code: constantCode("plan_denied"),
+  planId: import_effect.Schema.String
+}) {
+  /**
+   * The sentence an operator reads. Every renderer in the tree prints
+   * `message`, so a denial must state how to make a later launch possible.
+   */
+  get message() {
+    return `Plan ${this.planId} was denied and cannot be launched. Create and approve a new plan before running it.`;
+  }
+}
+class FlowNotFound extends import_effect.Schema.TaggedError()("/control/FlowNotFound", {
+  code: constantCode("flow_not_found"),
+  flowId: import_ControlSchema.FlowId
+}) {
+  /**
+   * The sentence an operator reads, which names the command that lists the
+   * flows a caller can start.
+   */
+  get message() {
+    return `Flow ${this.flowId} is not registered. Run \`smthrs flow list\` to see the flows you can start.`;
+  }
+}
+class PlanDigestMismatch extends import_effect.Schema.TaggedError()("/control/PlanDigestMismatch", {
+  code: constantCode("plan_digest_mismatch"),
+  planId: import_effect.Schema.String,
+  expected: import_effect.Schema.String,
+  actual: import_effect.Schema.String
+}) {
+}
+class EnvelopeMismatch extends import_effect.Schema.TaggedError()("/control/EnvelopeMismatch", {
+  code: constantCode("envelope_mismatch"),
+  planId: import_effect.Schema.String,
+  expected: import_effect.Schema.String,
+  actual: import_effect.Schema.String
+}) {
+}
+class ClaimLost extends import_effect.Schema.TaggedError()("/control/ClaimLost", {
+  code: constantCode("claim_lost"),
+  runId: import_ControlSchema.RunId,
+  reason: import_effect.Schema.optional(import_effect.Schema.String),
+  parkedBy: import_effect.Schema.optional(import_ControlSchema.RunHost)
+}) {
+}
+class CodeDrift extends import_effect.Schema.TaggedError()("/control/CodeDrift", {
+  code: constantCode("code_drift"),
+  runId: import_ControlSchema.RunId,
+  flowId: import_ControlSchema.FlowId,
+  /** The execution digest the run started with; absent when only the engine changed. */
+  recorded: import_effect.Schema.optional(import_effect.Schema.String),
+  /** The flow's execution digest now; absent when the flow is gone or declares none. */
+  current: import_effect.Schema.optional(import_effect.Schema.String),
+  /** The engine version the run started on, when the engine changed. */
+  recordedEngine: import_effect.Schema.optional(import_effect.Schema.String),
+  /** The engine version resuming it, when the engine changed. */
+  currentEngine: import_effect.Schema.optional(import_effect.Schema.String)
+}) {
+  get message() {
+    const changes = [
+      ...this.recorded === void 0 ? [] : [`${this.flowId} ${this.recorded}, which is now ${this.current ?? "gone"}`],
+      ...this.recordedEngine === void 0 ? [] : [`engine ${this.recordedEngine}, which is now ${this.currentEngine ?? "unknown"}`]
+    ];
+    const next = this.recorded !== void 0 && this.current === void 0 ? "Restore the flow to resume it." : "Resume with --allow-code-drift to run the changed code.";
+    return `Run ${this.runId} started on ${changes.join(" and ")}. ${next}`;
+  }
+}
+class AlreadyResolved extends import_effect.Schema.TaggedError()("/control/AlreadyResolved", {
+  code: constantCode("already_resolved"),
+  requestId: import_effect.Schema.String
+}) {
+}
+class InvalidInput extends import_effect.Schema.TaggedError()("/control/InvalidInput", {
+  code: constantCode("invalid_input"),
+  issue: import_effect.Schema.String
+}) {
+}
+class Unauthorized extends import_effect.Schema.TaggedError()("/control/Unauthorized", {
+  code: constantCode("unauthorized"),
+  message: import_effect.Schema.String
+}) {
+}
+class Unavailable extends import_effect.Schema.TaggedError()("/control/Unavailable", {
+  code: constantCode("unavailable"),
+  feature: import_effect.Schema.String,
+  ticket: import_effect.Schema.String
+}) {
+}
+class TransportError extends import_effect.Schema.TaggedError()("/control/TransportError", {
+  code: constantCode("transport_error"),
+  message: import_effect.Schema.String,
+  retryable: import_effect.Schema.Boolean,
+  cause: import_effect.Schema.optional(import_effect.Schema.Defect())
+}) {
+}
+class PersistenceError extends import_effect.Schema.TaggedError()("/control/PersistenceError", {
+  code: constantCode("persistence_failed"),
+  operation: import_effect.Schema.String,
+  message: import_effect.Schema.String,
+  cause: import_effect.Schema.optional(import_effect.Schema.Defect())
+}) {
+}
+class LaunchFailed extends import_effect.Schema.TaggedError()("/control/LaunchFailed", {
+  code: constantCode("launch_failed"),
+  runId: import_ControlSchema.RunId,
+  message: import_effect.Schema.String,
+  cause: import_effect.Schema.optional(import_effect.Schema.Defect())
+}) {
+}
+class NoMatchingWait extends import_effect.Schema.TaggedError()("/control/NoMatchingWait", {
+  code: constantCode("no_matching_wait"),
+  runId: import_ControlSchema.RunId,
+  waitName: import_effect.Schema.String
+}) {
+  /**
+   * The sentence an operator reads. Every other renderer in the tree prints
+   * `message`, so a refusal with none is a refusal with no reason.
+   */
+  get message() {
+    return `no wait point named "${this.waitName}" is open on run ${this.runId}. Read \`smthrs runs show ${this.runId}\` to see what that run is waiting for.`;
+  }
+}
+class CredentialConflict extends import_effect.Schema.TaggedError()("/control/CredentialConflict", {
+  code: constantCode("credential_conflict"),
+  id: import_effect.Schema.String,
+  expectedVersion: import_effect.Schema.Number,
+  actualVersion: import_effect.Schema.Number
+}) {
+}
+const ControlErrorSchema = import_effect.Schema.Union([
+  RunNotFound,
+  PlanNotFound,
+  PlanDenied,
+  FlowNotFound,
+  PlanDigestMismatch,
+  EnvelopeMismatch,
+  ClaimLost,
+  CodeDrift,
+  AlreadyResolved,
+  InvalidInput,
+  Unauthorized,
+  Unavailable,
+  TransportError,
+  PersistenceError,
+  LaunchFailed,
+  NoMatchingWait,
+  CredentialConflict,
+  import_NotificationQueue.NotificationError
+]);
+for (const [tag, kind] of [
+  ["RunNotFound", "user"],
+  ["PlanNotFound", "user"],
+  ["PlanDenied", "user"],
+  ["FlowNotFound", "user"],
+  ["PlanDigestMismatch", "user"],
+  ["EnvelopeMismatch", "user"],
+  ["AlreadyResolved", "user"],
+  ["InvalidInput", "user"],
+  ["Unauthorized", "user"],
+  ["NoMatchingWait", "user"],
+  ["CredentialConflict", "user"],
+  // A flow without a model or an approved executable identity: the person's to fix.
+  ["LaunchFailed", "user"],
+  ["ClaimLost", "infra"],
+  ["CodeDrift", "infra"],
+  ["Unavailable", "infra"],
+  ["TransportError", "infra"],
+  ["PersistenceError", "infra"]
+]) Fault.register(`/control/${tag}`, kind);
+//# sourceMappingURL=ControlError.js.map

package/dist/cjs/ControlError.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/ControlError.ts"],
+  "sourcesContent": ["/**\n * Stable, schema-backed control-plane failures.\n *\n * @since 0.1.0\n */\n\nimport * as Fault from \"@smthrs/flow/Fault\"\nimport { NotificationError } from \"@smthrs/notifications/NotificationQueue\"\nimport { Effect, Schema } from \"effect\"\nimport { FlowId, RunHost, RunId } from \"./ControlSchema.ts\"\n\nconst constantCode = <const Code extends string>(code: Code) =>\n  Schema.Literal(code).pipe(Schema.withConstructorDefault(Effect.succeed(code)))\n\n/**\n * No run with this id exists.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class RunNotFound extends Schema.TaggedError<RunNotFound>()(\"/control/RunNotFound\", {\n  code: constantCode(\"run_not_found\"),\n  runId: RunId\n}) {\n  /**\n   * The sentence an operator reads. Without one the CLI printed the bare\n   * fields, `run_not_found runId=nope`, which names no next action.\n   */\n  override get message(): string {\n    return `Run ${this.runId} was not found. Run \\`smthrs runs list\\` to see the runs you can read.`\n  }\n}\n\n/**\n * No plan with this id exists.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class PlanNotFound extends Schema.TaggedError<PlanNotFound>()(\"/control/PlanNotFound\", {\n  code: constantCode(\"plan_not_found\"),\n  planId: Schema.String\n}) {\n  /**\n   * The sentence an operator reads. Every renderer in the tree prints\n   * `message`, so a refusal without one does not explain the next action.\n   */\n  override get message(): string {\n    return `Plan ${this.planId} was not found. Create the plan again before approving or launching it.`\n  }\n}\n\n/**\n * The plan was denied and cannot be launched.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class PlanDenied extends Schema.TaggedError<PlanDenied>()(\"/control/PlanDenied\", {\n  code: constantCode(\"plan_denied\"),\n  planId: Schema.String\n}) {\n  /**\n   * The sentence an operator reads. Every renderer in the tree prints\n   * `message`, so a denial must state how to make a later launch possible.\n   */\n  override get message(): string {\n    return `Plan ${this.planId} was denied and cannot be launched. Create and approve a new plan before running it.`\n  }\n}\n\n/**\n * No flow with this id is registered.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class FlowNotFound extends Schema.TaggedError<FlowNotFound>()(\"/control/FlowNotFound\", {\n  code: constantCode(\"flow_not_found\"),\n  flowId: FlowId\n}) {\n  /**\n   * The sentence an operator reads, which names the command that lists the\n   * flows a caller can start.\n   */\n  override get message(): string {\n    return `Flow ${this.flowId} is not registered. Run \\`smthrs flow list\\` to see the flows you can start.`\n  }\n}\n\n/**\n * The submitted plan does not hash to the digest the caller declared, so\n * the control plane refuses to store it.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class PlanDigestMismatch extends Schema.TaggedError<PlanDigestMismatch>()(\"/control/PlanDigestMismatch\", {\n  code: constantCode(\"plan_digest_mismatch\"),\n  planId: Schema.String,\n  expected: Schema.String,\n  actual: Schema.String\n}) {}\n\n/**\n * The plan's effect envelope differs from the one the caller declared.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class EnvelopeMismatch extends Schema.TaggedError<EnvelopeMismatch>()(\"/control/EnvelopeMismatch\", {\n  code: constantCode(\"envelope_mismatch\"),\n  planId: Schema.String,\n  expected: Schema.String,\n  actual: Schema.String\n}) {}\n\n/**\n * The caller's claim on this run lapsed or was fenced by a newer owner.\n *\n * `parkedBy` names the live process that parked the run: it, not the caller,\n * drives the run, so `Control.resume` hands the resume to it.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class ClaimLost extends Schema.TaggedError<ClaimLost>()(\"/control/ClaimLost\", {\n  code: constantCode(\"claim_lost\"),\n  runId: RunId,\n  reason: Schema.optional(Schema.String),\n  parkedBy: Schema.optional(RunHost)\n}) {}\n\n/**\n * The run's flow or engine changed since the run started, so resuming it would\n * run code the run did not start with. Pass `allowCodeDrift` to resume it\n * anyway; the run then records the code it resumed on.\n *\n * @category errors\n * @since 1.0.0\n */\nexport class CodeDrift extends Schema.TaggedError<CodeDrift>()(\"/control/CodeDrift\", {\n  code: constantCode(\"code_drift\"),\n  runId: RunId,\n  flowId: FlowId,\n  /** The execution digest the run started with; absent when only the engine changed. */\n  recorded: Schema.optional(Schema.String),\n  /** The flow's execution digest now; absent when the flow is gone or declares none. */\n  current: Schema.optional(Schema.String),\n  /** The engine version the run started on, when the engine changed. */\n  recordedEngine: Schema.optional(Schema.String),\n  /** The engine version resuming it, when the engine changed. */\n  currentEngine: Schema.optional(Schema.String)\n}) {\n  override get message(): string {\n    const changes = [\n      ...(this.recorded === undefined\n        ? []\n        : [`${this.flowId} ${this.recorded}, which is now ${this.current ?? \"gone\"}`]),\n      ...(this.recordedEngine === undefined\n        ? []\n        : [`engine ${this.recordedEngine}, which is now ${this.currentEngine ?? \"unknown\"}`])\n    ]\n    // A flow that is gone has no code to adopt, so the flag would not help.\n    const next = this.recorded !== undefined && this.current === undefined\n      ? \"Restore the flow to resume it.\"\n      : \"Resume with --allow-code-drift to run the changed code.\"\n    return `Run ${this.runId} started on ${changes.join(\" and \")}. ${next}`\n  }\n}\n\n/**\n * This request was already answered; a second answer is refused rather\n * than overwriting the first.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class AlreadyResolved extends Schema.TaggedError<AlreadyResolved>()(\"/control/AlreadyResolved\", {\n  code: constantCode(\"already_resolved\"),\n  requestId: Schema.String\n}) {}\n\n/**\n * The request did not satisfy its schema or a stated precondition.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class InvalidInput extends Schema.TaggedError<InvalidInput>()(\"/control/InvalidInput\", {\n  code: constantCode(\"invalid_input\"),\n  issue: Schema.String\n}) {}\n\n/**\n * The caller lacks a usable credential or authority for this operation.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class Unauthorized extends Schema.TaggedError<Unauthorized>()(\"/control/Unauthorized\", {\n  code: constantCode(\"unauthorized\"),\n  message: Schema.String\n}) {}\n\n/**\n * The operation is not implemented in this deployment. `ticket` names the\n * issue that tracks it, per `Concepts/Tickets Not Exceptions.md`.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class Unavailable extends Schema.TaggedError<Unavailable>()(\"/control/Unavailable\", {\n  code: constantCode(\"unavailable\"),\n  feature: Schema.String,\n  ticket: Schema.String\n}) {}\n\n/**\n * The request failed before a declared control response reached the caller.\n *\n * `retryable` classifies only the transport phase. Connection failures and\n * HTTP 5xx responses are retryable; local encode failures, response decode\n * failures, and HTTP 4xx responses are not. A caller may resend a retryable\n * mutation only when its idempotency key makes replay safe. A keyless request\n * can have reached the server even when its response was lost.\n *\n * `message` is a fixed operator-facing sentence. `cause` retains the original\n * client failure for diagnostics without copying its raw text into output.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class TransportError extends Schema.TaggedError<TransportError>()(\"/control/TransportError\", {\n  code: constantCode(\"transport_error\"),\n  message: Schema.String,\n  retryable: Schema.Boolean,\n  cause: Schema.optional(Schema.Defect())\n}) {}\n\n/**\n * A control-plane store operation failed.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class PersistenceError extends Schema.TaggedError<PersistenceError>()(\"/control/PersistenceError\", {\n  code: constantCode(\"persistence_failed\"),\n  operation: Schema.String,\n  message: Schema.String,\n  cause: Schema.optional(Schema.Defect())\n}) {}\n\n/**\n * The executor refused or could not start the run.\n *\n * @category errors\n * @since 0.1.0\n */\nexport class LaunchFailed extends Schema.TaggedError<LaunchFailed>()(\"/control/LaunchFailed\", {\n  code: constantCode(\"launch_failed\"),\n  runId: RunId,\n  message: Schema.String,\n  cause: Schema.optional(Schema.Defect())\n}) {}\n\n/**\n * A signal named a wait point the run does not have open.\n *\n * `Control.signal` completes the `WaitFor` deferred a run is parked on. A\n * signal whose name matches no open wait point completes nothing, and recording\n * it anyway would leave an operator watching a delivery that never lands, so it\n * is refused where it arrives.\n *\n * The signal's name is `waitName`, not `name`. A field spelled `name` on an\n * `Error` subclass shadows `Error.prototype.name`, which every renderer in the\n * tree reads: `smithers signal run-3 '{\"name\":\"go\"}'` against a timer-parked\n * run printed `go: ` to stderr and exited 1, because `bin.ts` reports\n * `${error.name}: ${error.message}` and this class had overwritten one and\n * defined neither (release validation, defect D3).\n *\n * @category errors\n * @since 0.1.0\n */\nexport class NoMatchingWait extends Schema.TaggedError<NoMatchingWait>()(\"/control/NoMatchingWait\", {\n  code: constantCode(\"no_matching_wait\"),\n  runId: RunId,\n  waitName: Schema.String\n}) {\n  /**\n   * The sentence an operator reads. Every other renderer in the tree prints\n   * `message`, so a refusal with none is a refusal with no reason.\n   */\n  override get message(): string {\n    return `no wait point named \"${this.waitName}\" is open on run ${this.runId}. ` +\n      `Read \\`smthrs runs show ${this.runId}\\` to see what that run is waiting for.`\n  }\n}\n\n/**\n * A credential write lost a race: the record moved on before this writer\n * committed, so the update is refused rather than silently overwriting the\n * winner.\n *\n * @since 0.1.0\n * @category errors\n */\nexport class CredentialConflict extends Schema.TaggedError<CredentialConflict>()(\"/control/CredentialConflict\", {\n  code: constantCode(\"credential_conflict\"),\n  id: Schema.String,\n  expectedVersion: Schema.Number,\n  actualVersion: Schema.Number\n}) {}\n\n/**\n * Every stable failure emitted by the control plane, as one schema.\n *\n * This is the single membership list. The exported union type is derived from\n * it and `ControlClient.isControlError` is `Schema.is` of it, so an error class\n * added here reaches both. Two hand-maintained lists drifted: `ControlError`\n * omitted `CredentialConflict` while the README documented it as a member, and\n * `isControlError` repeated the same thirteen names a second time.\n *\n * @since 0.1.0\n * @category errors\n */\nexport const ControlErrorSchema = Schema.Union([\n  RunNotFound,\n  PlanNotFound,\n  PlanDenied,\n  FlowNotFound,\n  PlanDigestMismatch,\n  EnvelopeMismatch,\n  ClaimLost,\n  CodeDrift,\n  AlreadyResolved,\n  InvalidInput,\n  Unauthorized,\n  Unavailable,\n  TransportError,\n  PersistenceError,\n  LaunchFailed,\n  NoMatchingWait,\n  CredentialConflict,\n  NotificationError\n])\n\n/**\n * Every stable failure emitted by the control plane.\n *\n * @since 0.1.0\n * @category errors\n */\nexport type ControlError = typeof ControlErrorSchema.Type\n\n// Whose problem each control refusal is when it ends a run.\nfor (\n  const [tag, kind] of [\n    [\"RunNotFound\", \"user\"],\n    [\"PlanNotFound\", \"user\"],\n    [\"PlanDenied\", \"user\"],\n    [\"FlowNotFound\", \"user\"],\n    [\"PlanDigestMismatch\", \"user\"],\n    [\"EnvelopeMismatch\", \"user\"],\n    [\"AlreadyResolved\", \"user\"],\n    [\"InvalidInput\", \"user\"],\n    [\"Unauthorized\", \"user\"],\n    [\"NoMatchingWait\", \"user\"],\n    [\"CredentialConflict\", \"user\"],\n    // A flow without a model or an approved executable identity: the person's to fix.\n    [\"LaunchFailed\", \"user\"],\n    [\"ClaimLost\", \"infra\"],\n    [\"CodeDrift\", \"infra\"],\n    [\"Unavailable\", \"infra\"],\n    [\"TransportError\", \"infra\"],\n    [\"PersistenceError\", \"infra\"]\n  ] as const\n) Fault.register(`/control/${tag}`, kind)\n"],
+  "mappings": "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",
+  "names": []
+}