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

package/dist/cjs/WebCryptoCipher.js

@@ -0,0 +1,129 @@
+"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 WebCryptoCipher_exports = {};
+__export(WebCryptoCipher_exports, {
+  layer: () => layer,
+  make: () => make
+});
+module.exports = __toCommonJS(WebCryptoCipher_exports);
+var import_canonical = require("@smthrs/canonical");
+var import_effect = require("effect");
+var import_ControlError = require("./ControlError.js");
+var CredentialCipher = __toESM(require("./CredentialCipher.js"), 1);
+const algorithm = "AES-GCM";
+const nonceBytes = 12;
+const contextFormatVersion = 1;
+const toBase64 = (bytes) => {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+};
+const fromBase64 = (value) => {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+  return bytes;
+};
+const subtle = () => import_effect.Effect.suspend(() => {
+  const available = globalThis.crypto;
+  return available?.subtle === void 0 ? import_effect.Effect.fail(CredentialCipher.unavailable()) : import_effect.Effect.succeed(available.subtle);
+});
+const randomNonce = () => import_effect.Effect.suspend(() => {
+  const available = globalThis.crypto;
+  return available?.getRandomValues === void 0 ? import_effect.Effect.fail(CredentialCipher.unavailable()) : import_effect.Effect.succeed(available.getRandomValues(new Uint8Array(nonceBytes)));
+});
+const encodeContext = (context) => import_effect.Effect.try({
+  try: () => {
+    const document = (0, import_canonical.canonicalize)({
+      formatVersion: contextFormatVersion,
+      id: context.id,
+      name: context.name,
+      version: context.version
+    });
+    return new TextEncoder().encode(document);
+  },
+  catch: CredentialCipher.unavailable
+});
+const invalidKey = () => new import_ControlError.InvalidInput({ issue: "Credential key must be 32 base64-encoded bytes" });
+const unopenable = (reason, cause) => new import_ControlError.PersistenceError({
+  operation: "credential.open",
+  message: reason === "malformed_nonce" ? "Stored credential nonce is malformed" : "Credential failed authentication: a different key, changed metadata, or tampered ciphertext",
+  cause
+});
+const make = (options) => import_effect.Effect.gen(function* () {
+  const crypto = yield* subtle();
+  const raw = yield* import_effect.Effect.try({
+    try: () => fromBase64(import_effect.Redacted.value(options.key)),
+    catch: invalidKey
+  });
+  if (raw.length !== 32) return yield* import_effect.Effect.fail(invalidKey());
+  const key = yield* import_effect.Effect.tryPromise({
+    try: () => crypto.importKey("raw", raw, algorithm, false, ["encrypt", "decrypt"]),
+    catch: CredentialCipher.unavailable
+  });
+  return CredentialCipher.make({
+    seal: import_effect.Effect.fn("WebCryptoCipher.seal")(function* (plaintext, context) {
+      const additionalData = yield* encodeContext(context);
+      const nonce = yield* randomNonce();
+      const ciphertext = yield* import_effect.Effect.tryPromise({
+        try: () => crypto.encrypt(
+          { name: algorithm, iv: nonce, additionalData },
+          key,
+          new TextEncoder().encode(import_effect.Redacted.value(plaintext))
+        ),
+        catch: CredentialCipher.unavailable
+      });
+      return { ciphertext: toBase64(new Uint8Array(ciphertext)), nonce: toBase64(nonce) };
+    }),
+    open: import_effect.Effect.fn("WebCryptoCipher.open")(function* (sealed, context) {
+      const additionalData = yield* encodeContext(context);
+      const plaintext = yield* import_effect.Effect.try({
+        try: () => fromBase64(sealed.nonce),
+        catch: (cause) => unopenable("malformed_nonce", cause)
+      }).pipe(
+        import_effect.Effect.flatMap(
+          (nonce) => import_effect.Effect.tryPromise({
+            try: () => crypto.decrypt(
+              { name: algorithm, iv: nonce, additionalData },
+              key,
+              fromBase64(sealed.ciphertext)
+            ),
+            catch: (cause) => unopenable("authentication_failed", cause)
+          })
+        ),
+        import_effect.Effect.tapError(
+          (error) => import_effect.Effect.logWarning({ message: error.message, operation: error.operation, credentialId: context.id })
+        )
+      );
+      return import_effect.Redacted.make(new TextDecoder().decode(plaintext));
+    })
+  });
+});
+const layer = (options) => import_effect.Layer.effect(CredentialCipher.CredentialCipher)(make(options));
+//# sourceMappingURL=WebCryptoCipher.js.map

package/dist/cjs/WebCryptoCipher.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/WebCryptoCipher.ts"],
+  "sourcesContent": ["/**\n * AES-256-GCM credential encryption over the Web Crypto API.\n *\n * One adapter serves both hosts the project supports: `globalThis.crypto.subtle`\n * is the browser's own API and has been Node's since v19, so this module\n * imports nothing from `node:*` and still runs unmodified on the server. A host\n * without Web Crypto, such as an old runtime or a locked-down worker, fails\n * with the typed `Unavailable`, never a defect. A key that is not 32\n * base64-encoded bytes fails with `InvalidInput`. A record that does not open\n * fails with `PersistenceError` on operation `credential.open`, which names\n * whether the stored nonce was malformed or the ciphertext failed\n * authentication (a different key, changed metadata, or tampered bytes).\n *\n * The key is host-managed and supplied at layer construction. It is held as a\n * non-extractable `CryptoKey`, so it cannot be read back out of the cipher, and\n * it never reaches `CredentialStore`.\n *\n * @since 0.1.0\n */\n\nimport { canonicalize } from \"@smthrs/canonical\"\nimport { Effect, Layer, Redacted } from \"effect\"\nimport { InvalidInput, PersistenceError, type Unavailable } from \"./ControlError.ts\"\nimport * as CredentialCipher from \"./CredentialCipher.ts\"\n\nconst algorithm = \"AES-GCM\"\nconst nonceBytes = 12\nconst contextFormatVersion = 1\n\nconst toBase64 = (bytes: Uint8Array): string => {\n  let binary = \"\"\n  for (const byte of bytes) binary += String.fromCharCode(byte)\n  return btoa(binary)\n}\n\nconst fromBase64 = (value: string): Uint8Array<ArrayBuffer> => {\n  const binary = atob(value)\n  const bytes = new Uint8Array(binary.length)\n  for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index)\n  return bytes\n}\n\nconst subtle = (): Effect.Effect<SubtleCrypto, Unavailable> =>\n  Effect.suspend(() => {\n    const available = globalThis.crypto as Crypto | undefined\n    return available?.subtle === undefined\n      ? Effect.fail(CredentialCipher.unavailable())\n      : Effect.succeed(available.subtle)\n  })\n\nconst randomNonce = (): Effect.Effect<Uint8Array<ArrayBuffer>, Unavailable> =>\n  Effect.suspend(() => {\n    const available = globalThis.crypto as Crypto | undefined\n    return available?.getRandomValues === undefined\n      ? Effect.fail(CredentialCipher.unavailable())\n      : Effect.succeed(available.getRandomValues(new Uint8Array(nonceBytes)))\n  })\n\nconst encodeContext = (context: CredentialCipher.Context): Effect.Effect<Uint8Array<ArrayBuffer>, Unavailable> =>\n  Effect.try({\n    try: () => {\n      // Canonical JSON names and escapes each field, so embedded delimiters\n      // cannot make two metadata tuples authenticate as the same bytes. The\n      // explicit format version makes a future byte contract distinguishable.\n      const document = canonicalize({\n        formatVersion: contextFormatVersion,\n        id: context.id,\n        name: context.name,\n        version: context.version\n      })\n      return new TextEncoder().encode(document)\n    },\n    catch: CredentialCipher.unavailable\n  })\n\nconst invalidKey = (): InvalidInput => new InvalidInput({ issue: \"Credential key must be 32 base64-encoded bytes\" })\n\nconst unopenable = (reason: \"malformed_nonce\" | \"authentication_failed\", cause: unknown): PersistenceError =>\n  new PersistenceError({\n    operation: \"credential.open\",\n    message: reason === \"malformed_nonce\"\n      ? \"Stored credential nonce is malformed\"\n      : \"Credential failed authentication: a different key, changed metadata, or tampered ciphertext\",\n    cause\n  })\n\n/**\n * Host-managed key material for the cipher.\n *\n * `key` is 32 raw bytes, base64-encoded, held redacted so it cannot be printed\n * or serialized by accident.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Options {\n  readonly key: Redacted.Redacted<string>\n}\n\n/**\n * Imports the host key and constructs the cipher.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = (options: Options): Effect.Effect<CredentialCipher.Service, Unavailable | InvalidInput> =>\n  Effect.gen(function*() {\n    const crypto = yield* subtle()\n    const raw = yield* Effect.try({\n      try: () => fromBase64(Redacted.value(options.key)),\n      catch: invalidKey\n    })\n    if (raw.length !== 32) return yield* Effect.fail(invalidKey())\n    const key = yield* Effect.tryPromise({\n      try: () => crypto.importKey(\"raw\", raw, algorithm, false, [\"encrypt\", \"decrypt\"]),\n      catch: CredentialCipher.unavailable\n    })\n\n    return CredentialCipher.make({\n      seal: Effect.fn(\"WebCryptoCipher.seal\")(function*(plaintext, context) {\n        const additionalData = yield* encodeContext(context)\n        const nonce = yield* randomNonce()\n        const ciphertext = yield* Effect.tryPromise({\n          try: () =>\n            crypto.encrypt(\n              { name: algorithm, iv: nonce, additionalData: additionalData },\n              key,\n              new TextEncoder().encode(Redacted.value(plaintext))\n            ),\n          catch: CredentialCipher.unavailable\n        })\n        return { ciphertext: toBase64(new Uint8Array(ciphertext)), nonce: toBase64(nonce) }\n      }),\n      open: Effect.fn(\"WebCryptoCipher.open\")(function*(sealed, context) {\n        const additionalData = yield* encodeContext(context)\n        const plaintext = yield* Effect.try({\n          try: () => fromBase64(sealed.nonce),\n          catch: (cause) => unopenable(\"malformed_nonce\", cause)\n        }).pipe(\n          Effect.flatMap((nonce) =>\n            Effect.tryPromise({\n              try: () =>\n                crypto.decrypt(\n                  { name: algorithm, iv: nonce, additionalData: additionalData },\n                  key,\n                  fromBase64(sealed.ciphertext)\n                ),\n              catch: (cause) => unopenable(\"authentication_failed\", cause)\n            })\n          ),\n          Effect.tapError((error) =>\n            Effect.logWarning({ message: error.message, operation: error.operation, credentialId: context.id })\n          )\n        )\n        return Redacted.make(new TextDecoder().decode(plaintext))\n      })\n    })\n  })\n\n/**\n * Provides AES-256-GCM credential encryption under a host-managed key.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer = (\n  options: Options\n): Layer.Layer<CredentialCipher.CredentialCipher, Unavailable | InvalidInput> =>\n  Layer.effect(CredentialCipher.CredentialCipher)(make(options))\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/WebhookChannel.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Webhook channel construction over Effect's transport-neutral HTTP request.
+ *
+ * @since 0.1.0
+ */
+import { Effect, type Redacted, Schema } from "effect";
+import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
+import { type Channel, Channels, type InboundResult, type RawInbound } from "./Channels.ts";
+import { InvalidInput, type Unauthorized } from "./ControlError.ts";
+import type { IdempotencyKey } from "./ControlSchema.ts";
+import type { CredentialRef } from "./Credential.ts";
+/**
+ * Signature verifier injected by a webhook transport.
+ *
+ * The credential is intentionally a redacted reference. Resolution belongs at
+ * the host adapter boundary, never in webhook input or its persisted record.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type SignatureVerifier = (raw: RawInbound, credential: Redacted.Redacted<CredentialRef>) => Effect.Effect<void, Unauthorized>;
+/**
+ * Configuration for a schema-declared webhook channel.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Config<A> {
+    readonly name: string;
+    readonly schema: Schema.Schema<A>;
+    readonly credential: Redacted.Redacted<CredentialRef>;
+    readonly fingerprintHeaders?: Channel<A>["fingerprintHeaders"];
+    readonly verify: SignatureVerifier;
+    readonly map: (payload: A) => Effect.Effect<InboundResult, InvalidInput>;
+    readonly project: Channel<A>["project"];
+}
+/**
+ * Largest webhook request body one mount reads by default, in bytes.
+ *
+ * A webhook is the one control-plane ingress a bearer holder reaches with an
+ * arbitrary payload, and `handler` used to materialize whatever arrived before
+ * anything looked at its size. The default is deliberately smaller than the
+ * 4 MiB mutation-identity budget in `internal/mutationBoundary.ts`: a body that
+ * cannot become a durable mutation is refused at the door rather than copied,
+ * decoded, and refused later.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const maximumBodyBytes: number;
+/**
+ * Per-mount overrides for the webhook request handler.
+ *
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export interface HandlerOptions {
+    /** Body ceiling for this mount. Defaults to `maximumBodyBytes`. */
+    readonly maximumBodyBytes?: number | undefined;
+}
+/**
+ * Builds a webhook channel. Verification receives raw bytes and headers before
+ * JSON parsing and schema decoding.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: <A>(config: Config<A>) => Channel<A>;
+/**
+ * Reads an abstract Effect HTTP request and dispatches it through Channels.
+ * This is mountable by any Effect HTTP host; it contains no Node transport
+ * dependencies.
+ *
+ * The body is bounded twice. A `content-length` over the limit is refused
+ * before the body is read at all, so a declared flood costs nothing; the
+ * measured length is checked before retaining each streamed chunk. Reading
+ * stops at the first chunk exceeding the limit, including when the caller
+ * understates or omits the length. Both refusals are `InvalidInput` naming the
+ * two byte counts and no body content.
+ *
+ * @category handlers
+ * @since 0.1.0
+ */
+export declare const handler: (channel: string, idempotencyKey: IdempotencyKey, options?: HandlerOptions | undefined) => Effect.Effect<{
+    readonly _tag: "Accepted";
+    readonly receiptId: string;
+    readonly runId?: string | undefined;
+    readonly inputConsumed?: boolean | undefined;
+    readonly inputBody?: string | undefined;
+    readonly handedTo?: {
+        readonly hostId: string;
+        readonly pid: number;
+    } | undefined;
+} | {
+    readonly _tag: "AlreadyApplied";
+    readonly receiptId: string;
+    readonly runId?: string | undefined;
+    readonly inputConsumed?: boolean | undefined;
+    readonly inputBody?: string | undefined;
+} | {
+    readonly _tag: "Parked";
+    readonly receiptId: string;
+    readonly planId: string;
+    readonly status: "waiting-approval";
+} | {
+    readonly _tag: "Conflict";
+    readonly message: string;
+} | {
+    readonly _tag: "Terminal";
+    readonly runId: string;
+    readonly status: "running" | "completed" | "failed" | "cancelled" | "accepted" | "parked" | "waiting-approval";
+}, import("@smthrs/notifications/NotificationQueue").NotificationError | import("./ControlError.ts").RunNotFound | import("./ControlError.ts").PlanNotFound | import("./ControlError.ts").PlanDenied | import("./ControlError.ts").FlowNotFound | import("./ControlError.ts").PlanDigestMismatch | import("./ControlError.ts").EnvelopeMismatch | import("./ControlError.ts").ClaimLost | import("./ControlError.ts").CodeDrift | import("./ControlError.ts").AlreadyResolved | InvalidInput | Unauthorized | import("./ControlError.ts").Unavailable | import("./ControlError.ts").TransportError | import("./ControlError.ts").PersistenceError | import("./ControlError.ts").LaunchFailed | import("./ControlError.ts").NoMatchingWait | import("./ControlError.ts").CredentialConflict | import("effect/unstable/http/HttpServerError").HttpServerError, Channels | HttpServerRequest.HttpServerRequest>;
+//# sourceMappingURL=WebhookChannel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WebhookChannel.d.ts","sourceRoot":"","sources":["../../src/WebhookChannel.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,KAAK,QAAQ,EAAE,MAAM,EAAU,MAAM,QAAQ,CAAA;AAC9D,OAAO,KAAK,iBAAiB,MAAM,wCAAwC,CAAA;AAC3E,OAAO,EAAE,KAAK,OAAO,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,MAAM,eAAe,CAAA;AAC3F,OAAO,EAAE,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,mBAAmB,CAAA;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAEpD;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC9B,GAAG,EAAE,UAAU,EACf,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,aAAa,CAAC,KACzC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,CAAA;AAEtC;;;;;GAKG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IACjC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAA;IACrD,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAA;IAC9D,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAA;IAClC,QAAQ,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,YAAY,CAAC,CAAA;IACxE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAA;CACxC;AAID;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,QAAc,CAAA;AAE3C;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,mEAAmE;IACnE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC/C;AAoBD;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,QAAQ,MAAM,CAAC,CAAC,CAAC,KAAG,OAAO,CAAC,CAAC,CAmBpD,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,OAAO,GAClB,SAAS,MAAM,EACf,gBAAgB,cAAc,EAC9B,UAAU,cAAc,GAAG,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;42BA8BlC,CAAA"}

package/dist/cjs/WebhookChannel.js

@@ -0,0 +1,98 @@
+"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 WebhookChannel_exports = {};
+__export(WebhookChannel_exports, {
+  handler: () => handler,
+  make: () => make,
+  maximumBodyBytes: () => maximumBodyBytes
+});
+module.exports = __toCommonJS(WebhookChannel_exports);
+var import_effect = require("effect");
+var HttpServerRequest = __toESM(require("effect/unstable/http/HttpServerRequest"), 1);
+var import_Channels = require("./Channels.js");
+var import_ControlError = require("./ControlError.js");
+const invalidInput = (issue) => new import_ControlError.InvalidInput({ issue });
+const maximumBodyBytes = 1024 * 1024;
+const declaredLength = (headers) => {
+  for (const [name, value] of Object.entries(headers)) {
+    if (name.toLowerCase() !== "content-length" || value === void 0) continue;
+    const parsed = Number(value.trim());
+    return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : void 0;
+  }
+  return void 0;
+};
+const make = (config) => {
+  const decode = import_effect.Schema.decodeUnknownEffect(config.schema);
+  return {
+    name: config.name,
+    schema: config.schema,
+    ...config.fingerprintHeaders === void 0 ? {} : { fingerprintHeaders: config.fingerprintHeaders },
+    verify: import_effect.Effect.fn("WebhookChannel.verify")((raw) => config.verify(raw, config.credential)),
+    decode: import_effect.Effect.fn("WebhookChannel.decode")(
+      (raw) => import_effect.Effect.try({
+        try: () => JSON.parse(new TextDecoder().decode(raw.body)),
+        catch: () => invalidInput("invalid webhook JSON")
+      }).pipe(
+        import_effect.Effect.flatMap((json) => decode(json)),
+        import_effect.Effect.mapError((cause) => cause instanceof import_ControlError.InvalidInput ? cause : invalidInput(String(cause)))
+      )
+    ),
+    map: import_effect.Effect.fn("WebhookChannel.map")((payload) => config.map(payload)),
+    project: config.project
+  };
+};
+const handler = (channel, idempotencyKey, options) => import_effect.Effect.gen(function* () {
+  const limit = options?.maximumBodyBytes ?? maximumBodyBytes;
+  const request = yield* HttpServerRequest.HttpServerRequest;
+  const declared = declaredLength(request.headers);
+  if (declared !== void 0 && declared > limit) {
+    return yield* invalidInput(`webhook body: declared ${declared} bytes exceeds the ${limit} byte limit`);
+  }
+  const chunks = [];
+  let size = 0;
+  yield* import_effect.Stream.runForEach(request.stream, (chunk) => import_effect.Effect.gen(function* () {
+    size += chunk.byteLength;
+    if (size > limit) {
+      return yield* invalidInput(`webhook body: ${size} bytes exceeds the ${limit} byte limit`);
+    }
+    if (chunk.byteLength > 0) chunks.push(chunk.slice());
+  }));
+  const body = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  const channels = yield* import_Channels.Channels;
+  return yield* channels.ingest({
+    channel,
+    raw: { body, headers: request.headers, idempotencyKey }
+  });
+});
+//# sourceMappingURL=WebhookChannel.js.map

package/dist/cjs/WebhookChannel.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/WebhookChannel.ts"],
+  "sourcesContent": ["/**\n * Webhook channel construction over Effect's transport-neutral HTTP request.\n *\n * @since 0.1.0\n */\n\nimport { Effect, type Redacted, Schema, Stream } from \"effect\"\nimport * as HttpServerRequest from \"effect/unstable/http/HttpServerRequest\"\nimport { type Channel, Channels, type InboundResult, type RawInbound } from \"./Channels.ts\"\nimport { InvalidInput, type Unauthorized } from \"./ControlError.ts\"\nimport type { IdempotencyKey } from \"./ControlSchema.ts\"\nimport type { CredentialRef } from \"./Credential.ts\"\n\n/**\n * Signature verifier injected by a webhook transport.\n *\n * The credential is intentionally a redacted reference. Resolution belongs at\n * the host adapter boundary, never in webhook input or its persisted record.\n *\n * @category models\n * @since 0.1.0\n */\nexport type SignatureVerifier = (\n  raw: RawInbound,\n  credential: Redacted.Redacted<CredentialRef>\n) => Effect.Effect<void, Unauthorized>\n\n/**\n * Configuration for a schema-declared webhook channel.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Config<A> {\n  readonly name: string\n  readonly schema: Schema.Schema<A>\n  readonly credential: Redacted.Redacted<CredentialRef>\n  readonly fingerprintHeaders?: Channel<A>[\"fingerprintHeaders\"]\n  readonly verify: SignatureVerifier\n  readonly map: (payload: A) => Effect.Effect<InboundResult, InvalidInput>\n  readonly project: Channel<A>[\"project\"]\n}\n\nconst invalidInput = (issue: string): InvalidInput => new InvalidInput({ issue })\n\n/**\n * Largest webhook request body one mount reads by default, in bytes.\n *\n * A webhook is the one control-plane ingress a bearer holder reaches with an\n * arbitrary payload, and `handler` used to materialize whatever arrived before\n * anything looked at its size. The default is deliberately smaller than the\n * 4 MiB mutation-identity budget in `internal/mutationBoundary.ts`: a body that\n * cannot become a durable mutation is refused at the door rather than copied,\n * decoded, and refused later.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const maximumBodyBytes = 1024 * 1024\n\n/**\n * Per-mount overrides for the webhook request handler.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface HandlerOptions {\n  /** Body ceiling for this mount. Defaults to `maximumBodyBytes`. */\n  readonly maximumBodyBytes?: number | undefined\n}\n\n/**\n * The declared body length, when the caller stated one this host can trust.\n *\n * Header names arrive lower-cased from Effect's HTTP layer, but a hand-built\n * request is not obliged to, so the lookup folds case itself. An absent,\n * non-numeric, fractional, or negative declaration is not evidence of\n * anything: it falls through to the streaming measurement rather than being\n * treated as zero.\n */\nconst declaredLength = (headers: Readonly<Record<string, string | undefined>>): number | undefined => {\n  for (const [name, value] of Object.entries(headers)) {\n    if (name.toLowerCase() !== \"content-length\" || value === undefined) continue\n    const parsed = Number(value.trim())\n    return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : undefined\n  }\n  return undefined\n}\n\n/**\n * Builds a webhook channel. Verification receives raw bytes and headers before\n * JSON parsing and schema decoding.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = <A>(config: Config<A>): Channel<A> => {\n  const decode = Schema.decodeUnknownEffect(config.schema)\n  return {\n    name: config.name,\n    schema: config.schema,\n    ...(config.fingerprintHeaders === undefined ? {} : { fingerprintHeaders: config.fingerprintHeaders }),\n    verify: Effect.fn(\"WebhookChannel.verify\")((raw) => config.verify(raw, config.credential)),\n    decode: Effect.fn(\"WebhookChannel.decode\")((raw) =>\n      Effect.try({\n        try: () => JSON.parse(new TextDecoder().decode(raw.body)),\n        catch: () => invalidInput(\"invalid webhook JSON\")\n      }).pipe(\n        Effect.flatMap((json) => decode(json)),\n        Effect.mapError((cause) => cause instanceof InvalidInput ? cause : invalidInput(String(cause)))\n      ) as Effect.Effect<A, InvalidInput>\n    ),\n    map: Effect.fn(\"WebhookChannel.map\")((payload) => config.map(payload)),\n    project: config.project\n  }\n}\n\n/**\n * Reads an abstract Effect HTTP request and dispatches it through Channels.\n * This is mountable by any Effect HTTP host; it contains no Node transport\n * dependencies.\n *\n * The body is bounded twice. A `content-length` over the limit is refused\n * before the body is read at all, so a declared flood costs nothing; the\n * measured length is checked before retaining each streamed chunk. Reading\n * stops at the first chunk exceeding the limit, including when the caller\n * understates or omits the length. Both refusals are `InvalidInput` naming the\n * two byte counts and no body content.\n *\n * @category handlers\n * @since 0.1.0\n */\nexport const handler = (\n  channel: string,\n  idempotencyKey: IdempotencyKey,\n  options?: HandlerOptions | undefined\n) =>\n  Effect.gen(function*() {\n    const limit = options?.maximumBodyBytes ?? maximumBodyBytes\n    const request = yield* HttpServerRequest.HttpServerRequest\n    const declared = declaredLength(request.headers)\n    if (declared !== undefined && declared > limit) {\n      return yield* invalidInput(`webhook body: declared ${declared} bytes exceeds the ${limit} byte limit`)\n    }\n    const chunks: Array<Uint8Array> = []\n    let size = 0\n    yield* Stream.runForEach(request.stream, (chunk) =>\n      Effect.gen(function*() {\n        size += chunk.byteLength\n        if (size > limit) {\n          return yield* invalidInput(`webhook body: ${size} bytes exceeds the ${limit} byte limit`)\n        }\n        if (chunk.byteLength > 0) chunks.push(chunk.slice())\n      }))\n    const body = new Uint8Array(size)\n    let offset = 0\n    for (const chunk of chunks) {\n      body.set(chunk, offset)\n      offset += chunk.byteLength\n    }\n    const channels = yield* Channels\n    return yield* channels.ingest({\n      channel,\n      raw: { body, headers: request.headers, idempotencyKey }\n    })\n  })\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,oBAAsD;AACtD,wBAAmC;AACnC,sBAA4E;AAC5E,0BAAgD;AAkChD,MAAM,eAAe,CAAC,UAAgC,IAAI,iCAAa,EAAE,MAAM,CAAC;AAezE,MAAM,mBAAmB,OAAO;AAsBvC,MAAM,iBAAiB,CAAC,YAA8E;AACpG,aAAW,CAAC,MAAM,KAAK,KAAK,OAAO,QAAQ,OAAO,GAAG;AACnD,QAAI,KAAK,YAAY,MAAM,oBAAoB,UAAU,OAAW;AACpE,UAAM,SAAS,OAAO,MAAM,KAAK,CAAC;AAClC,WAAO,OAAO,cAAc,MAAM,KAAK,UAAU,IAAI,SAAS;AAAA,EAChE;AACA,SAAO;AACT;AASO,MAAM,OAAO,CAAI,WAAkC;AACxD,QAAM,SAAS,qBAAO,oBAAoB,OAAO,MAAM;AACvD,SAAO;AAAA,IACL,MAAM,OAAO;AAAA,IACb,QAAQ,OAAO;AAAA,IACf,GAAI,OAAO,uBAAuB,SAAY,CAAC,IAAI,EAAE,oBAAoB,OAAO,mBAAmB;AAAA,IACnG,QAAQ,qBAAO,GAAG,uBAAuB,EAAE,CAAC,QAAQ,OAAO,OAAO,KAAK,OAAO,UAAU,CAAC;AAAA,IACzF,QAAQ,qBAAO,GAAG,uBAAuB;AAAA,MAAE,CAAC,QAC1C,qBAAO,IAAI;AAAA,QACT,KAAK,MAAM,KAAK,MAAM,IAAI,YAAY,EAAE,OAAO,IAAI,IAAI,CAAC;AAAA,QACxD,OAAO,MAAM,aAAa,sBAAsB;AAAA,MAClD,CAAC,EAAE;AAAA,QACD,qBAAO,QAAQ,CAAC,SAAS,OAAO,IAAI,CAAC;AAAA,QACrC,qBAAO,SAAS,CAAC,UAAU,iBAAiB,mCAAe,QAAQ,aAAa,OAAO,KAAK,CAAC,CAAC;AAAA,MAChG;AAAA,IACF;AAAA,IACA,KAAK,qBAAO,GAAG,oBAAoB,EAAE,CAAC,YAAY,OAAO,IAAI,OAAO,CAAC;AAAA,IACrE,SAAS,OAAO;AAAA,EAClB;AACF;AAiBO,MAAM,UAAU,CACrB,SACA,gBACA,YAEA,qBAAO,IAAI,aAAY;AACrB,QAAM,QAAQ,SAAS,oBAAoB;AAC3C,QAAM,UAAU,OAAO,kBAAkB;AACzC,QAAM,WAAW,eAAe,QAAQ,OAAO;AAC/C,MAAI,aAAa,UAAa,WAAW,OAAO;AAC9C,WAAO,OAAO,aAAa,0BAA0B,QAAQ,sBAAsB,KAAK,aAAa;AAAA,EACvG;AACA,QAAM,SAA4B,CAAC;AACnC,MAAI,OAAO;AACX,SAAO,qBAAO,WAAW,QAAQ,QAAQ,CAAC,UACxC,qBAAO,IAAI,aAAY;AACrB,YAAQ,MAAM;AACd,QAAI,OAAO,OAAO;AAChB,aAAO,OAAO,aAAa,iBAAiB,IAAI,sBAAsB,KAAK,aAAa;AAAA,IAC1F;AACA,QAAI,MAAM,aAAa,EAAG,QAAO,KAAK,MAAM,MAAM,CAAC;AAAA,EACrD,CAAC,CAAC;AACJ,QAAM,OAAO,IAAI,WAAW,IAAI;AAChC,MAAI,SAAS;AACb,aAAW,SAAS,QAAQ;AAC1B,SAAK,IAAI,OAAO,MAAM;AACtB,cAAU,MAAM;AAAA,EAClB;AACA,QAAM,WAAW,OAAO;AACxB,SAAO,OAAO,SAAS,OAAO;AAAA,IAC5B;AAAA,IACA,KAAK,EAAE,MAAM,SAAS,QAAQ,SAAS,eAAe;AAAA,EACxD,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Control-plane contracts and projections for the Smithers harness.
+ *
+ * This is the public surface of the control plane: the transport-independent
+ * `Control` service, the `ControlRuntime` port it writes through, the
+ * projections it reads back, and the durable adapter that binds both to a real
+ * database.
+ *
+ * `Control` is authority, not execution. Every mutation it accepts is
+ * idempotent, principal-stamped, and recorded in the journal beside the state
+ * change it caused, so "who asked for this, and when did it take effect?" is
+ * answered from persisted evidence rather than from a log line.
+ *
+ * @since 0.1.0
+ */
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as Control from "./Control.ts";
+/**
+ * @category services
+ * @since 1.0.0
+ */
+export * as ApprovalAuthority from "./ApprovalAuthority.ts";
+/**
+ * @category errors
+ * @since 0.1.0
+ */
+export * as ControlError from "./ControlError.ts";
+/**
+ * @category models
+ * @since 0.1.0
+ */
+export * as ControlSchema from "./ControlSchema.ts";
+/**
+ * @category projections
+ * @since 0.1.0
+ */
+export * as Cancellation from "./Cancellation.ts";
+/**
+ * @category projections
+ * @since 0.1.0
+ */
+export * as Lineage from "./Lineage.ts";
+/**
+ * @category projections
+ * @since 0.1.0
+ */
+export * as Monitor from "./Monitor.ts";
+/**
+ * @category projections
+ * @since 0.1.0
+ */
+export * as Steering from "./Steering.ts";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as ControlRuntime from "./ControlRuntime.ts";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as ControlExecutor from "./ControlExecutor.ts";
+/**
+ * @category services
+ * @since 1.0.0
+ */
+export * as DispatchReader from "./DispatchReader.ts";
+/**
+ * @category layers
+ * @since 0.1.0
+ */
+export * as ControlLive from "./ControlLive.ts";
+/**
+ * @category models
+ * @since 0.1.0
+ */
+export * as SystemFlows from "./SystemFlows.ts";
+/**
+ * @category rpc
+ * @since 0.1.0
+ */
+export * as ControlRpcs from "./ControlRpcs.ts";
+/**
+ * @category layers
+ * @since 0.1.0
+ */
+export * as ControlServer from "./ControlServer.ts";
+/**
+ * @category layers
+ * @since 0.1.0
+ */
+export * as ControlClient from "./ControlClient.ts";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as Channels from "./Channels.ts";
+/**
+ * @category channels
+ * @since 0.1.0
+ */
+export * as WebhookChannel from "./WebhookChannel.ts";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as Credential from "./Credential.ts";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as CredentialCipher from "./CredentialCipher.ts";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as CredentialStore from "./CredentialStore.ts";
+/**
+ * @category layers
+ * @since 0.1.0
+ */
+export * as SqlCredentialStore from "./SqlCredentialStore.ts";
+/**
+ * @category layers
+ * @since 0.1.0
+ */
+export * as WebCryptoCipher from "./WebCryptoCipher.ts";
+/**
+ * @category layers
+ * @since 0.1.0
+ */
+export * as SqlControlRuntime from "./SqlControlRuntime.ts";
+/**
+ * @category authentication
+ * @since 1.0.0
+ */
+export * as ScopedToken from "./ScopedToken.ts";
+/**
+ * @category migrations
+ * @since 0.1.0
+ */
+export * as Migrations from "./Migrations.ts";
+/**
+ * Observational health contracts.
+ * @category health
+ * @since 1.0.0
+ */
+export * as Health from "./Health.ts";
+/**
+ * The Jev-decided session checker a host binds as `jev.session`.
+ * @category health
+ * @since 1.0.0
+ */
+export * as JevSessionChecker from "./JevSessionChecker.ts";
+/** Versioned control lifecycle producer and projection contract. */
+export * as ControlFacts from "./ControlFacts.ts";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;GAGG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;;GAGG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAE3D;;;GAGG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;GAGG;AACH,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD;;;GAGG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;GAGG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;;GAGG;AACH,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;;GAGG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;GAGG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;GAGG;AACH,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AAEvD;;;GAGG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;GAGG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAE/C;;;GAGG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAE/C;;;GAGG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAE/C;;;GAGG;AACH,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD;;;GAGG;AACH,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD;;;GAGG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;GAGG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;GAGG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AAEzD;;;GAGG;AACH,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AAEvD;;;GAGG;AACH,OAAO,KAAK,kBAAkB,MAAM,yBAAyB,CAAA;AAE7D;;;GAGG;AACH,OAAO,KAAK,eAAe,MAAM,sBAAsB,CAAA;AAEvD;;;GAGG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAE3D;;;GAGG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAE/C;;;GAGG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;;GAIG;AACH,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC;;;;GAIG;AACH,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAA;AAE3D,oEAAoE;AACpE,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA"}

package/dist/cjs/index.js

@@ -0,0 +1,91 @@
+"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 index_exports = {};
+__export(index_exports, {
+  ApprovalAuthority: () => ApprovalAuthority,
+  Cancellation: () => Cancellation,
+  Channels: () => Channels,
+  Control: () => Control,
+  ControlClient: () => ControlClient,
+  ControlError: () => ControlError,
+  ControlExecutor: () => ControlExecutor,
+  ControlFacts: () => ControlFacts,
+  ControlLive: () => ControlLive,
+  ControlRpcs: () => ControlRpcs,
+  ControlRuntime: () => ControlRuntime,
+  ControlSchema: () => ControlSchema,
+  ControlServer: () => ControlServer,
+  Credential: () => Credential,
+  CredentialCipher: () => CredentialCipher,
+  CredentialStore: () => CredentialStore,
+  DispatchReader: () => DispatchReader,
+  Health: () => Health,
+  JevSessionChecker: () => JevSessionChecker,
+  Lineage: () => Lineage,
+  Migrations: () => Migrations,
+  Monitor: () => Monitor,
+  ScopedToken: () => ScopedToken,
+  SqlControlRuntime: () => SqlControlRuntime,
+  SqlCredentialStore: () => SqlCredentialStore,
+  Steering: () => Steering,
+  SystemFlows: () => SystemFlows,
+  WebCryptoCipher: () => WebCryptoCipher,
+  WebhookChannel: () => WebhookChannel
+});
+module.exports = __toCommonJS(index_exports);
+var Control = __toESM(require("./Control.js"), 1);
+var ApprovalAuthority = __toESM(require("./ApprovalAuthority.js"), 1);
+var ControlError = __toESM(require("./ControlError.js"), 1);
+var ControlSchema = __toESM(require("./ControlSchema.js"), 1);
+var Cancellation = __toESM(require("./Cancellation.js"), 1);
+var Lineage = __toESM(require("./Lineage.js"), 1);
+var Monitor = __toESM(require("./Monitor.js"), 1);
+var Steering = __toESM(require("./Steering.js"), 1);
+var ControlRuntime = __toESM(require("./ControlRuntime.js"), 1);
+var ControlExecutor = __toESM(require("./ControlExecutor.js"), 1);
+var DispatchReader = __toESM(require("./DispatchReader.js"), 1);
+var ControlLive = __toESM(require("./ControlLive.js"), 1);
+var SystemFlows = __toESM(require("./SystemFlows.js"), 1);
+var ControlRpcs = __toESM(require("./ControlRpcs.js"), 1);
+var ControlServer = __toESM(require("./ControlServer.js"), 1);
+var ControlClient = __toESM(require("./ControlClient.js"), 1);
+var Channels = __toESM(require("./Channels.js"), 1);
+var WebhookChannel = __toESM(require("./WebhookChannel.js"), 1);
+var Credential = __toESM(require("./Credential.js"), 1);
+var CredentialCipher = __toESM(require("./CredentialCipher.js"), 1);
+var CredentialStore = __toESM(require("./CredentialStore.js"), 1);
+var SqlCredentialStore = __toESM(require("./SqlCredentialStore.js"), 1);
+var WebCryptoCipher = __toESM(require("./WebCryptoCipher.js"), 1);
+var SqlControlRuntime = __toESM(require("./SqlControlRuntime.js"), 1);
+var ScopedToken = __toESM(require("./ScopedToken.js"), 1);
+var Migrations = __toESM(require("./Migrations.js"), 1);
+var Health = __toESM(require("./Health.js"), 1);
+var JevSessionChecker = __toESM(require("./JevSessionChecker.js"), 1);
+var ControlFacts = __toESM(require("./ControlFacts.js"), 1);
+//# sourceMappingURL=index.js.map