@canonmsg/agent-sdk 12.4.1 → 12.6.1

package/dist/chunks/chunk-FVYKLH6I.js

@@ -0,0 +1,1475 @@
+import {
+  CANON_CLIENT_HEADER,
+  CANON_ENDPOINT_PROTOCOL,
+  CLIENT_UPDATE_REQUIRED,
+  MLS_DEV_CREDENTIAL_MAX_BYTES,
+  MLS_DEV_CREDENTIAL_RECONCILIATION_MAX_BYTES,
+  MLS_DEV_ENROLLMENT_MAX_BYTES,
+  MLS_DEV_GROUP_RECEIPT_CLOCK_SKEW,
+  MLS_DEV_KEY_PACKAGES_MAX_BYTES,
+  __name,
+  canonicalEndpointJson,
+  classifyTransferHttpFailure,
+  classifyTransferReceipt,
+  endpointContentBoundary,
+  formatCanonClientHeader,
+  isEndpointOperationReceipt,
+  isMlsDevReceiptClockSkew,
+  isMlsEnvironmentId,
+  parseMlsDevCredentialBegin,
+  parseMlsDevCredentialChallenge,
+  parseMlsDevCredentialComplete,
+  parseMlsDevCredentialReceipt,
+  parseMlsDevCredentialReconciliationBegin,
+  parseMlsDevCredentialReconciliationChallenge,
+  parseMlsDevCredentialReconciliationComplete,
+  parseMlsDevCredentialReconciliationReceipt,
+  parseMlsDevCredentialRevocationReceipt,
+  parseMlsDevCredentialRevoke,
+  parseMlsDevCredentialToken,
+  parseMlsDevDeviceCommand,
+  parseMlsDevDeviceContext,
+  parseMlsDevDevicePreparation,
+  parseMlsDevEnrollmentBegin,
+  parseMlsDevEnrollmentChallenge,
+  parseMlsDevEnrollmentComplete,
+  parseMlsDevEnrollmentResult,
+  parseMlsDevGroupCommand,
+  parseMlsDevGroupContext,
+  parseMlsDevGroupPreparation,
+  parseMlsDevKeyPackageClaim,
+  parseMlsDevKeyPackageClaimReceipt,
+  parseMlsDevKeyPackageCommand,
+  parseMlsDevKeyPackagePreparation,
+  parseMlsDevKeyPackagePublicationReceipt,
+  parseMlsDevKeyPackagePublish
+} from "./chunk-S7BV74DN.js";
+
+// ../endpoint/src/events.ts
+function createEndpointEventHub(input) {
+  const observers = /* @__PURE__ */ new Set();
+  let controller;
+  let running;
+  let closed = false;
+  let connected = false;
+  let terminalError = false;
+  let lastEventId;
+  let subscribedScopes = "";
+  const principalScopes = /* @__PURE__ */ __name(() => [...new Set([...observers].flatMap(({ hooks }) => hooks?.principalScopes ?? []))].sort(), "principalScopes");
+  const families = /* @__PURE__ */ __name(() => [...new Set([...observers].flatMap(({ hooks }) => hooks?.families ?? ["messages", "contacts"]))].sort(), "families");
+  const subscriptionKey = /* @__PURE__ */ __name(() => JSON.stringify([families(), principalScopes()]), "subscriptionKey");
+  const safe = /* @__PURE__ */ __name((callback) => {
+    try {
+      callback?.();
+    } catch {
+    }
+  }, "safe");
+  async function loop(signal) {
+    let attempt = 0;
+    while (!signal.aborted && observers.size) {
+      let retryAfterMs = 0;
+      let handling = false;
+      try {
+        if (!input.transport.events) return;
+        for await (const event of input.transport.events({ lastEventId, signal, families: families(), principalScopes: principalScopes(), onConnected: /* @__PURE__ */ __name(() => {
+          connected = true;
+          for (const { hooks } of observers) safe(hooks?.onConnected);
+          input.invalidate();
+        }, "onConnected") })) {
+          if (signal.aborted) break;
+          validateEndpointContentBoundary("event", event.kind, event.data);
+          if (event.kind === "error") throw decodeEndpointError(event.data, { stream: true });
+          handling = true;
+          await input.onEvent?.(event);
+          handling = false;
+          attempt = 0;
+          if (event.kind === "replay.expired") lastEventId = void 0;
+          else if (event.id) lastEventId = event.id;
+          for (const observer of observers) safe(() => observer.listener(event));
+          if (/^(artifact\.|message\.|conversations?\.|contacts?\.|agent\.context$|replay\.|voice\.session\.)/.test(event.kind)) input.invalidate(event);
+        }
+      } catch (error) {
+        if (!signal.aborted) {
+          terminalError = !handling && error instanceof EndpointError && !error.retryable;
+          if (error instanceof EndpointError && typeof error.retryAfterMs === "number" && Number.isFinite(error.retryAfterMs)) retryAfterMs = Math.max(0, Math.min(3e5, error.retryAfterMs));
+          for (const { hooks } of observers) safe(() => hooks?.onError?.(error instanceof Error ? error : new EndpointError("Stream connection failed")));
+        }
+      } finally {
+        if (connected) {
+          connected = false;
+          safe(input.onDisconnected);
+          for (const { hooks } of observers) safe(hooks?.onDisconnected);
+        }
+      }
+      if (signal.aborted || !observers.size || terminalError) break;
+      const delay = Math.max(retryAfterMs, Math.min(3e4, 500 * 2 ** Math.min(attempt++, 6)) * (0.8 + Math.random() * 0.4));
+      await new Promise((resolve4) => {
+        const finish = /* @__PURE__ */ __name(() => {
+          clearTimeout(timer);
+          signal.removeEventListener("abort", finish);
+          resolve4();
+        }, "finish");
+        const timer = setTimeout(finish, delay);
+        timer.unref?.();
+        signal.addEventListener("abort", finish, { once: true });
+      });
+    }
+  }
+  __name(loop, "loop");
+  function start() {
+    if (running || closed || terminalError || !observers.size || !input.transport.events) return;
+    controller = new AbortController();
+    subscribedScopes = subscriptionKey();
+    running = loop(controller.signal).finally(() => {
+      running = void 0;
+      controller = void 0;
+      if (!closed && observers.size) start();
+    });
+  }
+  __name(start, "start");
+  return {
+    isConnected: /* @__PURE__ */ __name(() => connected, "isConnected"),
+    observe(listener, hooks) {
+      if (closed) throw new EndpointError("Endpoint is closed", { code: "ENDPOINT_CLOSED", retryable: false });
+      const observer = { listener, hooks };
+      observers.add(observer);
+      if (connected) safe(hooks?.onConnected);
+      if (running && subscribedScopes !== subscriptionKey()) controller?.abort();
+      start();
+      return () => {
+        observers.delete(observer);
+        if (!observers.size || subscribedScopes !== subscriptionKey()) controller?.abort();
+      };
+    },
+    async close() {
+      closed = true;
+      controller?.abort();
+      observers.clear();
+      await running;
+    }
+  };
+}
+__name(createEndpointEventHub, "createEndpointEventHub");
+var MAX_EVENT_FRAME_CHARS = 2 * 1024 * 1024;
+var DECODE_SLICE_BYTES = 64 * 1024;
+async function* readEndpointEvents(response, options) {
+  if (!response.body) throw new EndpointError("Canon returned an empty event stream", { code: "INVALID_EVENT_STREAM" });
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let kind = "message";
+  let id;
+  let data = [];
+  let dataSize = 0;
+  let frameSize = 0;
+  const abort = /* @__PURE__ */ __name(() => {
+    void reader.cancel().catch(() => void 0);
+  }, "abort");
+  options.signal.addEventListener("abort", abort, { once: true });
+  try {
+    while (!options.signal.aborted) {
+      let timer;
+      const chunk = await Promise.race([
+        reader.read(),
+        new Promise((_, reject) => {
+          timer = setTimeout(() => {
+            void reader.cancel().catch(() => void 0);
+            reject(new EndpointError("Canon event stream stalled", { code: "STREAM_IDLE" }));
+          }, options.idleTimeoutMs ?? 6e4);
+        })
+      ]).finally(() => {
+        if (timer) clearTimeout(timer);
+      });
+      if (chunk.done) break;
+      for (let offset = 0; offset < chunk.value.length; offset += DECODE_SLICE_BYTES) {
+        buffer += decoder.decode(chunk.value.subarray(offset, offset + DECODE_SLICE_BYTES), { stream: true });
+        let newline;
+        while ((newline = buffer.indexOf("\n")) !== -1) {
+          const line = buffer.slice(0, newline).replace(/\r$/, "");
+          buffer = buffer.slice(newline + 1);
+          frameSize += line.length + 1;
+          if (frameSize > MAX_EVENT_FRAME_CHARS) throw new EndpointError("Canon event frame is too large", { code: "INVALID_EVENT_STREAM" });
+          if (!line) {
+            if (data.length) {
+              const value2 = JSON.parse(data.join("\n"));
+              if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) throw new EndpointError("Invalid Canon event payload", { code: "INVALID_EVENT_STREAM" });
+              validateEndpointContentBoundary("event", kind, value2);
+              if (kind === "error") throw decodeEndpointError(value2, { stream: true, ...!response.ok ? { status: response.status } : {}, retryAfter: response.headers.get("Retry-After") });
+              yield { ...id ? { id } : {}, kind, data: value2 };
+            }
+            kind = "message";
+            id = void 0;
+            data = [];
+            dataSize = 0;
+            frameSize = 0;
+            continue;
+          }
+          if (line.startsWith(":")) continue;
+          const separator = line.indexOf(":");
+          const field = separator < 0 ? line : line.slice(0, separator);
+          const value = separator < 0 ? "" : line.slice(separator + 1).replace(/^ /, "");
+          if (field === "event") kind = value;
+          else if (field === "id" && !value.includes("\0")) id = value;
+          else if (field === "data") {
+            data.push(value);
+            dataSize += value.length + 1;
+            if (dataSize > MAX_EVENT_FRAME_CHARS) throw new EndpointError("Canon event frame is too large", { code: "INVALID_EVENT_STREAM" });
+          }
+        }
+        if (frameSize + buffer.length > MAX_EVENT_FRAME_CHARS) throw new EndpointError("Canon event frame is too large", { code: "INVALID_EVENT_STREAM" });
+      }
+    }
+  } finally {
+    options.signal.removeEventListener("abort", abort);
+    await reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  }
+}
+__name(readEndpointEvents, "readEndpointEvents");
+
+// ../endpoint/src/mls-dev-transport.ts
+var utf8 = new TextEncoder();
+function failure(code, status = 0, retryable = false, retryAfterMs) {
+  return new EndpointError("MLS Dev request failed", { code, status, retryable, ...retryAfterMs === void 0 ? {} : { retryAfterMs } });
+}
+__name(failure, "failure");
+function discard(response) {
+  try {
+    void response.body?.cancel().catch(() => {
+    });
+  } catch {
+  }
+}
+__name(discard, "discard");
+function createMlsDevDeviceHttpTransport(config, dependencies) {
+  const invalidConfig = /* @__PURE__ */ __name(() => failure("INVALID_MLS_DEV_TRANSPORT_CONFIG"), "invalidConfig");
+  const send = dependencies.fetch;
+  const timeoutMs = dependencies.timeoutMs ?? 3e4;
+  const environment = dependencies.environmentId;
+  if (!isMlsEnvironmentId(environment) || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 12e4 || !config || !Array.isArray(config.trustedOrigins) || !config.trustedOrigins.length || config.trustedOrigins.length > 16 || config.allowSyntheticLoopbackHttp !== void 0 && typeof config.allowSyntheticLoopbackHttp !== "boolean") throw invalidConfig();
+  function url(value) {
+    try {
+      if (typeof value !== "string" || value.length > 2048) throw invalidConfig();
+      const parsed = new URL(value);
+      const localHttp = config.allowSyntheticLoopbackHttp === true && parsed.protocol === "http:" && (parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]");
+      if (parsed.href !== value || parsed.username || parsed.password || parsed.search || parsed.hash || parsed.protocol !== "https:" && !localHttp) throw invalidConfig();
+      return parsed;
+    } catch {
+      throw invalidConfig();
+    }
+  }
+  __name(url, "url");
+  const origins = new Set(config.trustedOrigins.map((value) => {
+    const parsed = url(value + "/");
+    if (parsed.origin !== value || parsed.pathname !== "/") throw invalidConfig();
+    return parsed.origin;
+  }));
+  function route(value) {
+    const parsed = url(value);
+    if (!origins.has(parsed.origin) || !/^\/(?:[A-Za-z0-9_-]+(?:\/[A-Za-z0-9_-]+)*\/?)?$/.test(parsed.pathname)) throw invalidConfig();
+    return parsed.href.replace(/\/$/, "");
+  }
+  __name(route, "route");
+  const enrollmentUrl = route(config.enrollmentUrl);
+  const credentialUrl = route(config.credentialUrl);
+  const reconciliationUrl = route(config.reconciliationUrl);
+  const keyPackagesUrl = config.keyPackagesUrl === void 0 ? void 0 : route(config.keyPackagesUrl);
+  const observations = /* @__PURE__ */ new Map();
+  async function call(base, action, input, parseInput, parseOutput, maxBytes, signal) {
+    let request;
+    let body;
+    try {
+      request = parseInput(input);
+      body = JSON.stringify(request);
+      if (utf8.encode(body).length > maxBytes) throw new Error();
+    } catch {
+      throw failure("INVALID_MLS_DEV_REQUEST");
+    }
+    const controller = new AbortController();
+    let stopError;
+    let rejectStopped;
+    const stopped = new Promise((_resolve, reject) => {
+      rejectStopped = reject;
+    });
+    void stopped.catch(() => {
+    });
+    const stop = /* @__PURE__ */ __name((error) => {
+      if (stopError) return;
+      stopError = error;
+      controller.abort();
+      rejectStopped(error);
+    }, "stop");
+    const abort = /* @__PURE__ */ __name(() => stop(failure("MLS_DEV_REQUEST_ABORTED")), "abort");
+    if (signal?.aborted) abort();
+    else signal?.addEventListener("abort", abort, { once: true });
+    const timeout = setTimeout(() => stop(failure("MLS_DEV_REQUEST_TIMEOUT", 0, true)), timeoutMs);
+    async function bounded(work) {
+      if (stopError) throw stopError;
+      const result = await Promise.race([Promise.resolve().then(() => {
+        if (stopError) throw stopError;
+        return work();
+      }), stopped]);
+      if (stopError) throw stopError;
+      return result;
+    }
+    __name(bounded, "bounded");
+    const target = base + "/" + action;
+    let response;
+    try {
+      for (let attempt = 0; attempt < 2; attempt++) {
+        let token;
+        try {
+          token = await bounded(() => dependencies.credentials.getToken(attempt > 0));
+        } catch {
+          throw stopError ?? failure("MLS_DEV_AUTHENTICATION_UNAVAILABLE", 0, true);
+        }
+        if (typeof token !== "string" || !token || token.length > 8185 || /\s/.test(token)) throw failure("UNAUTHENTICATED", 401);
+        let ownership;
+        try {
+          ownership = dependencies.ownershipHeaders();
+        } catch {
+          throw failure("INVALID_OWNERSHIP_VERSION");
+        }
+        response = await bounded(async () => {
+          let value;
+          try {
+            value = await send(target, {
+              method: "POST",
+              redirect: "error",
+              cache: "no-store",
+              credentials: "omit",
+              referrerPolicy: "no-referrer",
+              signal: controller.signal,
+              headers: {
+                Authorization: "Bearer " + token,
+                "Content-Type": "application/json",
+                Accept: "application/json",
+                "X-Canon-Endpoint-Protocol": CANON_ENDPOINT_PROTOCOL,
+                ...ownership
+              },
+              body
+            });
+          } catch {
+            throw stopError ?? failure("MLS_DEV_REQUEST_UNAVAILABLE", 0, true);
+          }
+          if (stopError) discard(value);
+          return value;
+        });
+        if (response.redirected || response.url !== target || response.status >= 300 && response.status < 400) {
+          throw failure("MLS_DEV_REDIRECT_REJECTED");
+        }
+        const responseEnvironment = response.headers.get("X-Canon-Environment-Id");
+        const gateway = response.status === 429 || response.status >= 500;
+        if (responseEnvironment !== environment && !(responseEnvironment === null && gateway)) throw failure("ENVIRONMENT_MISMATCH", 409);
+        if (response.status === 401 && attempt === 0) {
+          discard(response);
+          response = void 0;
+          continue;
+        }
+        if (!response.ok) {
+          const retry = response.headers.get("Retry-After");
+          const seconds = retry && /^\d{1,6}$/.test(retry) ? Number(retry) : 0;
+          throw failure("HTTP_" + response.status, response.status, gateway, seconds > 0 ? seconds * 1e3 : void 0);
+        }
+        if (!/^application\/json(?:\s*;|$)/i.test(response.headers.get("Content-Type") ?? "")) throw failure("INVALID_MLS_DEV_RESPONSE", 502);
+        const length = response.headers.get("Content-Length");
+        if (length !== null && (!/^\d+$/.test(length) || Number(length) > maxBytes)) throw failure("INVALID_MLS_DEV_RESPONSE", 502);
+        const reader = response.body?.getReader();
+        if (!reader) throw failure("INVALID_MLS_DEV_RESPONSE", 502);
+        let count = 0;
+        let text = "";
+        const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+        try {
+          for (; ; ) {
+            const chunk = await bounded(() => reader.read());
+            if (chunk.done) break;
+            count += chunk.value.byteLength;
+            if (count > maxBytes) throw failure("INVALID_MLS_DEV_RESPONSE", 502);
+            text += decoder.decode(chunk.value, { stream: true });
+          }
+          text += decoder.decode();
+          const result = parseOutput(JSON.parse(text));
+          if (stopError) throw stopError;
+          return { request, result };
+        } catch (error) {
+          if (error === stopError) throw error;
+          throw failure("INVALID_MLS_DEV_RESPONSE", 502);
+        } finally {
+          try {
+            void reader.cancel().catch(() => {
+            });
+          } catch {
+          }
+          reader.releaseLock();
+        }
+      }
+      throw failure("UNAUTHENTICATED", 401);
+    } catch (error) {
+      if (error instanceof EndpointError) throw error;
+      throw stopError ?? failure("MLS_DEV_REQUEST_UNAVAILABLE", 0, true);
+    } finally {
+      if (response) discard(response);
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", abort);
+    }
+  }
+  __name(call, "call");
+  const invalidResponse = /* @__PURE__ */ __name(() => failure("INVALID_MLS_DEV_RESPONSE", 502), "invalidResponse");
+  return {
+    ...keyPackagesUrl ? { keyPackages: {
+      async publish(input, signal) {
+        const { request, result } = await call(
+          keyPackagesUrl,
+          "publish",
+          input,
+          parseMlsDevKeyPackagePublish,
+          parseMlsDevKeyPackagePublicationReceipt,
+          MLS_DEV_KEY_PACKAGES_MAX_BYTES,
+          signal
+        );
+        if (result.requestId !== request.requestId) throw invalidResponse();
+        return result;
+      },
+      async claim(input, signal) {
+        const { request, result } = await call(
+          keyPackagesUrl,
+          "claim",
+          input,
+          parseMlsDevKeyPackageClaim,
+          parseMlsDevKeyPackageClaimReceipt,
+          MLS_DEV_KEY_PACKAGES_MAX_BYTES,
+          signal
+        );
+        if (result.requestId !== request.requestId || result.recipientDeviceId !== request.recipientDeviceId || result.claimantDeviceId !== parseMlsDevCredentialToken(request.claimantCredential).unsigned.claims.device.deviceId || canonicalEndpointJson(result.preconditions) !== canonicalEndpointJson(request.preconditions)) throw invalidResponse();
+        return result;
+      }
+    } } : {},
+    async beginEnrollment(input, signal) {
+      const { request, result } = await call(enrollmentUrl, "begin", input, parseMlsDevEnrollmentBegin, parseMlsDevEnrollmentChallenge, MLS_DEV_ENROLLMENT_MAX_BYTES, signal);
+      if (result.installationId !== request.installationId || result.signaturePublicKey !== request.signaturePublicKey) throw invalidResponse();
+      return result;
+    },
+    async completeEnrollment(input, signal) {
+      return (await call(enrollmentUrl, "complete", input, parseMlsDevEnrollmentComplete, parseMlsDevEnrollmentResult, MLS_DEV_ENROLLMENT_MAX_BYTES, signal)).result;
+    },
+    async beginCredential(input, signal) {
+      const { request, result } = await call(credentialUrl, "begin", input, parseMlsDevCredentialBegin, parseMlsDevCredentialChallenge, MLS_DEV_CREDENTIAL_MAX_BYTES, signal);
+      if (result.credential.claims.device.deviceId !== request.deviceId || result.credential.claims.generation !== request.expectedCredentialGeneration + 1) throw invalidResponse();
+      return result;
+    },
+    async completeCredential(input, signal) {
+      return (await call(credentialUrl, "complete", input, parseMlsDevCredentialComplete, parseMlsDevCredentialReceipt, MLS_DEV_CREDENTIAL_MAX_BYTES, signal)).result;
+    },
+    async beginReconciliation(input, signal) {
+      const { request, result } = await call(reconciliationUrl, "begin", input, parseMlsDevCredentialReconciliationBegin, parseMlsDevCredentialReconciliationChallenge, MLS_DEV_CREDENTIAL_RECONCILIATION_MAX_BYTES, signal);
+      if (result.device.deviceId !== request.deviceId || result.requestId !== request.requestId || result.expectedCredentialGeneration !== request.expectedCredentialGeneration) throw invalidResponse();
+      return result;
+    },
+    async completeReconciliation(input, signal) {
+      const { request, result } = await call(reconciliationUrl, "complete", input, parseMlsDevCredentialReconciliationComplete, parseMlsDevCredentialReconciliationReceipt, MLS_DEV_CREDENTIAL_RECONCILIATION_MAX_BYTES, signal);
+      if (result.challenge.challengeId !== request.challengeId) throw invalidResponse();
+      const key = JSON.stringify(result);
+      observations.set(key, true);
+      if (observations.size > 32) observations.delete(observations.keys().next().value);
+      return result;
+    },
+    async revokeCredential(input, signal) {
+      const { request, result } = await call(credentialUrl, "revoke", input, parseMlsDevCredentialRevoke, parseMlsDevCredentialRevocationReceipt, MLS_DEV_CREDENTIAL_MAX_BYTES, signal);
+      if (result.deviceId !== request.deviceId) throw invalidResponse();
+      return result;
+    },
+    verifyGenerationObservation(receipt) {
+      try {
+        return observations.has(JSON.stringify(parseMlsDevCredentialReconciliationReceipt(receipt)));
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+__name(createMlsDevDeviceHttpTransport, "createMlsDevDeviceHttpTransport");
+
+// ../endpoint/src/transport.ts
+var EndpointError = class extends Error {
+  static {
+    __name(this, "EndpointError");
+  }
+  status;
+  code;
+  retryable;
+  operationId;
+  retryAfterMs;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "EndpointError";
+    this.status = options.status ?? 0;
+    this.code = options.code ?? "ENDPOINT_UNAVAILABLE";
+    this.retryable = options.retryable ?? classifyTransferHttpFailure(this.status) === "retry";
+    this.operationId = options.operationId;
+    this.retryAfterMs = options.retryAfterMs;
+  }
+};
+var retryableStreamErrors = /* @__PURE__ */ new Set([
+  "rate_limited",
+  "connection_limit",
+  "service_overloaded",
+  "listener_failed",
+  "connection_reclaimed",
+  "connection_stale",
+  "server_shutting_down",
+  "authorization_changed",
+  "authorization_check_failed"
+]);
+function decodeEndpointError(value, options = {}) {
+  const details = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  const status = options.status ?? (typeof details.status === "number" && Number.isInteger(details.status) && details.status >= 400 && details.status <= 599 ? details.status : 0);
+  const code = typeof details.code === "string" ? details.code : options.stream ? "STREAM_UNAVAILABLE" : `HTTP_${status}`;
+  const positive = /* @__PURE__ */ __name((value2) => typeof value2 === "number" && Number.isFinite(value2) && value2 > 0 ? value2 : void 0, "positive");
+  const retryHeader = options.retryAfter?.trim();
+  const retryAfterMs = positive(retryHeader ? /^\d+(?:\.\d+)?$/.test(retryHeader) ? Number(retryHeader) * 1e3 : Date.parse(retryHeader) - Date.now() : void 0) ?? positive(details.retryAfterMs) ?? positive(typeof details.retryAfter === "number" ? details.retryAfter * 1e3 : void 0);
+  const accessTokenExpired = status === 401 && code === "CONNECTOR_ACCESS_TOKEN_EXPIRED";
+  const retryable = details.retryable !== false && (status ? accessTokenExpired || status === 429 || status >= 500 : options.stream ? retryableStreamErrors.has(code) : true);
+  return new EndpointError(typeof details.error === "string" ? details.error : typeof details.message === "string" ? details.message : `Canon ${options.stream ? "stream" : "request"} failed${status ? ` (${status})` : ""}`, {
+    status,
+    code,
+    retryable,
+    ...retryAfterMs === void 0 ? {} : { retryAfterMs }
+  });
+}
+__name(decodeEndpointError, "decodeEndpointError");
+async function readHttpError(response, signal) {
+  if (response.headers.get("Content-Type")?.toLowerCase().startsWith("text/event-stream")) {
+    try {
+      for await (const _event of readEndpointEvents(response, { signal })) {
+      }
+    } catch (error) {
+      if (error instanceof EndpointError) return error;
+      throw error;
+    }
+  } else {
+    return decodeEndpointError(await response.json().catch(() => null), { status: response.status, retryAfter: response.headers.get("Retry-After") });
+  }
+  return decodeEndpointError(null, { status: response.status, retryAfter: response.headers.get("Retry-After"), stream: true });
+}
+__name(readHttpError, "readHttpError");
+async function readBoundedGroupJson(response, signal) {
+  const maximum = 4 * 1024 * 1024;
+  const invalid = /* @__PURE__ */ __name(() => new EndpointError("Invalid MLS group response", { status: 502, code: "INVALID_MLS_DEV_GROUP_RESPONSE", retryable: false }), "invalid");
+  const length = response.headers.get("Content-Length");
+  if (length !== null && (!/^\d+$/.test(length) || Number(length) > maximum)) throw invalid();
+  const reader = response.body?.getReader();
+  if (!reader) throw invalid();
+  let rejectAbort;
+  const stopped = new Promise((_resolve, reject) => {
+    rejectAbort = reject;
+  });
+  void stopped.catch(() => {
+  });
+  const abort = /* @__PURE__ */ __name(() => rejectAbort(new EndpointError("MLS group request aborted", { code: "MLS_DEV_REQUEST_ABORTED", retryable: true })), "abort");
+  if (signal.aborted) abort();
+  else signal.addEventListener("abort", abort, { once: true });
+  try {
+    const decoder = new TextDecoder("utf-8", { fatal: true }), parts = [];
+    let size = 0;
+    for (; ; ) {
+      if (signal.aborted) throw new EndpointError("MLS group request aborted", { code: "MLS_DEV_REQUEST_ABORTED", retryable: true });
+      const chunk = await Promise.race([reader.read(), stopped]);
+      if (chunk.done) break;
+      size += chunk.value.byteLength;
+      if (size > maximum) throw invalid();
+      parts.push(decoder.decode(chunk.value, { stream: true }));
+    }
+    parts.push(decoder.decode());
+    return JSON.parse(parts.join(""));
+  } catch (error) {
+    if (error instanceof EndpointError) throw error;
+    throw invalid();
+  } finally {
+    signal.removeEventListener("abort", abort);
+    try {
+      void reader.cancel().catch(() => {
+      });
+    } catch {
+    }
+    reader.releaseLock();
+  }
+}
+__name(readBoundedGroupJson, "readBoundedGroupJson");
+function hasEnvironmentMismatch(response, expected) {
+  const environment = response.headers.get("X-Canon-Environment-Id");
+  return environment !== expected && !(environment === null && (response.status === 429 || response.status >= 500));
+}
+__name(hasEnvironmentMismatch, "hasEnvironmentMismatch");
+function validateEndpointContentBoundary(lane, name, payload) {
+  try {
+    endpointContentBoundary(lane, name, payload);
+  } catch {
+    throw new EndpointError("Endpoint content lane requires a protocol update", { code: "ENDPOINT_CONTENT_UNCLASSIFIED", retryable: false });
+  }
+}
+__name(validateEndpointContentBoundary, "validateEndpointContentBoundary");
+function createHttpEndpointTransport(options) {
+  const fetcher = options.fetch ?? globalThis.fetch;
+  const clientHeaders = options.client ? { [CANON_CLIENT_HEADER]: formatCanonClientHeader(options.client) } : {};
+  const updateRequired = /* @__PURE__ */ __name((error) => {
+    if (error.code === CLIENT_UPDATE_REQUIRED) try {
+      options.onClientUpdateRequired?.(error);
+    } catch {
+    }
+    return error;
+  }, "updateRequired");
+  const baseUrl = options.baseUrl.replace(/\/$/, "");
+  let resolvedStreamId;
+  function streamIdentity() {
+    return resolvedStreamId ??= Promise.resolve().then(async () => {
+      const value = typeof options.streamId === "function" ? await options.streamId() : options.streamId;
+      if (value !== void 0 && (typeof value !== "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(value))) {
+        throw new EndpointError("Invalid logical stream identity", { code: "INVALID_STREAM_ID", retryable: false });
+      }
+      return value;
+    });
+  }
+  __name(streamIdentity, "streamIdentity");
+  function ownershipHeaders() {
+    const version = typeof options.ownershipVersion === "function" ? options.ownershipVersion() : options.ownershipVersion;
+    if (version === void 0) return {};
+    if (!Number.isSafeInteger(version) || version < 0) throw new EndpointError("Invalid endpoint ownership generation", { code: "INVALID_OWNERSHIP_VERSION", retryable: false });
+    return { "X-Canon-Ownership-Version": String(version) };
+  }
+  __name(ownershipHeaders, "ownershipHeaders");
+  async function call(path, method, body, signal, origin = baseUrl, groupResponse = false) {
+    for (let authAttempt = 0; authAttempt < 2; authAttempt++) {
+      const token = await options.credentials.getToken(authAttempt > 0);
+      if (!token) throw new EndpointError("Authentication is required", { status: 401, code: "UNAUTHENTICATED", retryable: false });
+      const controller = new AbortController();
+      const abort = /* @__PURE__ */ __name(() => controller.abort(signal?.reason), "abort");
+      if (signal?.aborted) abort();
+      else signal?.addEventListener("abort", abort, { once: true });
+      const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 3e4);
+      try {
+        const response = await fetcher(`${origin.replace(/\/$/, "")}${path}`, {
+          method,
+          signal: controller.signal,
+          headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json", "X-Canon-Endpoint-Protocol": CANON_ENDPOINT_PROTOCOL, ...clientHeaders, ...ownershipHeaders() },
+          ...body === void 0 ? {} : { body: JSON.stringify(body) }
+        });
+        if (hasEnvironmentMismatch(response, options.environmentId)) {
+          throw new EndpointError("Canon environment does not match this endpoint", { status: 409, code: "ENVIRONMENT_MISMATCH", retryable: false });
+        }
+        if (response.status === 401 && authAttempt === 0) {
+          await response.body?.cancel();
+          continue;
+        }
+        if (!response.ok) throw updateRequired(await readHttpError(response, controller.signal));
+        return groupResponse ? await readBoundedGroupJson(response, controller.signal) : await response.json().catch(() => null);
+      } finally {
+        clearTimeout(timeout);
+        signal?.removeEventListener("abort", abort);
+      }
+    }
+    throw new EndpointError("Authentication is required", { status: 401, code: "UNAUTHENTICATED", retryable: false });
+  }
+  __name(call, "call");
+  function receipt(value, operationId, installationId, action) {
+    if (!isEndpointOperationReceipt(value) || classifyTransferReceipt(value, { protocol: CANON_ENDPOINT_PROTOCOL, operationId, installationId, action: action ?? value.action }) === "invalid") throw new EndpointError("Canon returned an invalid operation receipt", { status: 502, code: "INVALID_RECEIPT" });
+    if (value.operationId !== operationId || value.installationId !== installationId || action !== void 0 && value.action !== action) throw new EndpointError("Canon returned another operation receipt", { status: 502, code: "INVALID_RECEIPT" });
+    validateEndpointContentBoundary("operation.receipt", value.action, value);
+    return value;
+  }
+  __name(receipt, "receipt");
+  return {
+    ...options.mlsDevDevice ? { mlsDevDevice: createMlsDevDeviceHttpTransport(options.mlsDevDevice, {
+      environmentId: options.environmentId,
+      credentials: options.credentials,
+      fetch: fetcher,
+      timeoutMs: options.timeoutMs,
+      ownershipHeaders
+    }) } : {},
+    async capabilities() {
+      const result = await call("/endpoint/capabilities", "GET", void 0);
+      if (!result || typeof result !== "object" || result.protocol !== CANON_ENDPOINT_PROTOCOL || !Array.isArray(result.actions) || !Array.isArray(result.queries)) {
+        throw new EndpointError("Canon returned invalid endpoint capabilities", { status: 502, code: "INVALID_CAPABILITIES" });
+      }
+      return result;
+    },
+    ...options.streamUrl ? {
+      async *events(streamOptions) {
+        const streamId = await streamIdentity();
+        for (let attempt = 0; attempt < 2; attempt++) {
+          const token = await options.credentials.getToken(attempt > 0);
+          if (!token) throw new EndpointError("Authentication is required", { status: 401, code: "UNAUTHENTICATED", retryable: false });
+          const connection = new AbortController();
+          const abort = /* @__PURE__ */ __name(() => connection.abort(streamOptions.signal.reason), "abort");
+          if (streamOptions.signal.aborted) abort();
+          else streamOptions.signal.addEventListener("abort", abort, { once: true });
+          const handshake = setTimeout(() => connection.abort(), options.timeoutMs ?? 3e4);
+          try {
+            const scopeQuery = streamOptions.principalScopes?.length ? `&principalScopes=${encodeURIComponent([...new Set(streamOptions.principalScopes)].sort().join(","))}` : "";
+            const response = await fetcher(`${options.streamUrl.replace(/\/$/, "")}/endpoint/events?events=${encodeURIComponent((streamOptions.families ?? ["messages", "contacts"]).join(","))}${scopeQuery}`, {
+              signal: connection.signal,
+              headers: { Authorization: `Bearer ${token}`, Accept: "text/event-stream", "X-Canon-Endpoint-Protocol": CANON_ENDPOINT_PROTOCOL, ...clientHeaders, ...streamId ? { "X-Canon-Stream-Id": streamId } : {}, ...ownershipHeaders(), ...streamOptions.lastEventId ? { "Last-Event-ID": streamOptions.lastEventId } : {} }
+            });
+            if (hasEnvironmentMismatch(response, options.environmentId)) {
+              await response.body?.cancel();
+              throw new EndpointError("Canon stream environment does not match this endpoint", { status: 409, code: "ENVIRONMENT_MISMATCH", retryable: false });
+            }
+            if (response.status === 401 && attempt === 0) {
+              await response.body?.cancel();
+              continue;
+            }
+            if (!response.ok) throw updateRequired(await readHttpError(response, connection.signal));
+            if (!response.headers.get("Content-Type")?.toLowerCase().startsWith("text/event-stream")) {
+              await response.body?.cancel();
+              throw new EndpointError("Canon returned an invalid event stream", { status: 502, code: "INVALID_EVENT_STREAM" });
+            }
+            clearTimeout(handshake);
+            let connected = false;
+            for await (const event of readEndpointEvents(response, { ...streamOptions, signal: connection.signal })) {
+              if (!connected) {
+                connected = true;
+                streamOptions.onConnected?.();
+              }
+              yield event;
+            }
+            return;
+          } finally {
+            clearTimeout(handshake);
+            streamOptions.signal.removeEventListener("abort", abort);
+            connection.abort();
+          }
+        }
+      }
+    } : {},
+    async execute(operation, signal) {
+      validateEndpointContentBoundary("operation.request", operation.action, operation);
+      return receipt(await call("/endpoint/operations", "POST", operation, signal, baseUrl, operation.action === "mls_group_control"), operation.operationId, operation.installationId, operation.action);
+    },
+    async getOperation(operationId, installationId, signal) {
+      try {
+        return receipt(await call(`/endpoint/operations/${encodeURIComponent(operationId)}?installationId=${encodeURIComponent(installationId)}`, "GET", void 0, signal, baseUrl, true), operationId, installationId);
+      } catch (error) {
+        if (error instanceof EndpointError && error.status === 404) return null;
+        throw error;
+      }
+    },
+    async query(query, parameters, signal) {
+      validateEndpointContentBoundary("query.request", query, parameters);
+      if (query === "admit_messages" && !options.streamUrl) throw new EndpointError("Agent recovery requires the shared stream endpoint", { code: "STREAM_CONFIGURATION_REQUIRED", retryable: false });
+      const response = await call("/endpoint/query", "POST", { protocol: CANON_ENDPOINT_PROTOCOL, query, parameters }, signal, query === "admit_messages" ? options.streamUrl : baseUrl, ["mls_group_controls", "mls_group_feed"].includes(query));
+      if (!response || typeof response !== "object" || response.protocol !== CANON_ENDPOINT_PROTOCOL || !Object.hasOwn(response, "result")) {
+        throw new EndpointError("Canon returned an invalid query response", { status: 502, code: "INVALID_QUERY_RESPONSE" });
+      }
+      validateEndpointContentBoundary("query.result", query, response.result);
+      return response.result;
+    },
+    async publish(action, body, signal) {
+      validateEndpointContentBoundary("ephemeral.request", action, body);
+      const response = await call("/endpoint/ephemeral", "POST", { protocol: CANON_ENDPOINT_PROTOCOL, action, body }, signal);
+      if (!response || typeof response !== "object" || response.protocol !== CANON_ENDPOINT_PROTOCOL || !Object.hasOwn(response, "result")) {
+        throw new EndpointError("Canon returned an invalid ephemeral response", { status: 502, code: "INVALID_EPHEMERAL_RESPONSE" });
+      }
+      validateEndpointContentBoundary("ephemeral.result", action, response.result);
+      return response.result;
+    }
+  };
+}
+__name(createHttpEndpointTransport, "createHttpEndpointTransport");
+
+// ../endpoint/src/node-mls-custody-protocol.ts
+var NodeMlsDevCustodyError = class extends Error {
+  static {
+    __name(this, "NodeMlsDevCustodyError");
+  }
+  code = "MLS_NODE_CUSTODY_REJECTED";
+  constructor() {
+    super("MLS_NODE_CUSTODY_REJECTED");
+    this.name = "NodeMlsDevCustodyError";
+  }
+};
+var MAX_INPUT = 8 * 1024 * 1024;
+var MAX_OUTPUT = 4 * 1024 * 1024;
+var DOMAIN = Buffer.from("canon.mls.agent-host.v1\0");
+function rejected() {
+  throw new NodeMlsDevCustodyError();
+}
+__name(rejected, "rejected");
+function custodyValue(output, operation) {
+  const parsed = parseJson(output);
+  if (operation === 4 && isMlsDevReceiptClockSkew(parsed)) throw new EndpointError("Canon accepted this entry ahead of this device's clock", { code: MLS_DEV_GROUP_RECEIPT_CLOCK_SKEW, retryable: true });
+  const result = record(parsed, ["version", "ok", "value"]);
+  requireValue(result.version === 1 && result.ok === true);
+  return result.value;
+}
+__name(custodyValue, "custodyValue");
+function custodyFailure(error) {
+  if (error instanceof EndpointError && error.code === MLS_DEV_GROUP_RECEIPT_CLOCK_SKEW) throw error;
+  return rejected();
+}
+__name(custodyFailure, "custodyFailure");
+function requireValue(value) {
+  if (!value) rejected();
+}
+__name(requireValue, "requireValue");
+function record(value, fields) {
+  requireValue(value !== null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype);
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  requireValue(Object.keys(descriptors).length === fields.length && fields.every((key) => descriptors[key] && "value" in descriptors[key]));
+  return value;
+}
+__name(record, "record");
+function sealed(value, maximum, nullable = false) {
+  if (nullable && value === null) return null;
+  requireValue(typeof value === "string" && value.length <= maximum && value.startsWith("v1:"));
+  const body = value.slice(3);
+  requireValue(body.length >= 40 && Buffer.from(body, "base64").toString("base64") === body);
+  return value;
+}
+__name(sealed, "sealed");
+function frame(operation, values) {
+  const chunks = [DOMAIN, Buffer.from([operation])];
+  let length = DOMAIN.length + 1;
+  for (const value of values) {
+    const bytes = value === null ? null : Buffer.from(value, "utf8");
+    const prefix = Buffer.alloc(4);
+    prefix.writeUInt32BE(bytes?.length ?? 4294967295);
+    chunks.push(prefix);
+    if (bytes) chunks.push(bytes);
+    length += 4 + (bytes?.length ?? 0);
+    requireValue(length <= MAX_INPUT);
+  }
+  return Buffer.concat(chunks, length);
+}
+__name(frame, "frame");
+function parseFrame(input) {
+  requireValue(input.length > DOMAIN.length && input.length <= MAX_INPUT && input.subarray(0, DOMAIN.length).equals(DOMAIN));
+  const values = [];
+  let offset = DOMAIN.length + 1;
+  while (offset < input.length) {
+    requireValue(input.length - offset >= 4);
+    const length = input.readUInt32BE(offset);
+    offset += 4;
+    if (length === 4294967295) {
+      values.push(null);
+      continue;
+    }
+    requireValue(length <= input.length - offset);
+    values.push(new TextDecoder("utf-8", { fatal: true }).decode(input.subarray(offset, offset + length)));
+    offset += length;
+  }
+  return { operation: input[DOMAIN.length], values };
+}
+__name(parseFrame, "parseFrame");
+function parseJson(bytes) {
+  const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  const value = JSON.parse(text);
+  let offset = 0;
+  const whitespace = /* @__PURE__ */ __name(() => {
+    while (/\s/.test(text[offset] ?? "") && offset < text.length) offset++;
+  }, "whitespace");
+  const string = /* @__PURE__ */ __name(() => {
+    const start = offset++;
+    while (offset < text.length) {
+      const c = text[offset++];
+      if (c === "\\") offset++;
+      else if (c === '"') return JSON.parse(text.slice(start, offset));
+    }
+    return rejected();
+  }, "string");
+  const scan = /* @__PURE__ */ __name((depth) => {
+    requireValue(depth <= 64);
+    whitespace();
+    const c = text[offset];
+    if (c === "{") {
+      offset++;
+      whitespace();
+      const keys = /* @__PURE__ */ new Set();
+      if (text[offset] === "}") {
+        offset++;
+        return;
+      }
+      while (true) {
+        whitespace();
+        requireValue(text[offset] === '"');
+        const key = string();
+        requireValue(!keys.has(key));
+        keys.add(key);
+        whitespace();
+        requireValue(text[offset++] === ":");
+        scan(depth + 1);
+        whitespace();
+        if (text[offset++] === "}") return;
+      }
+    }
+    if (c === "[") {
+      offset++;
+      whitespace();
+      if (text[offset] === "]") {
+        offset++;
+        return;
+      }
+      while (true) {
+        scan(depth + 1);
+        whitespace();
+        if (text[offset++] === "]") return;
+      }
+    }
+    if (c === '"') {
+      string();
+      return;
+    }
+    while (offset < text.length && !/[\s,\]}]/.test(text[offset])) offset++;
+  }, "scan");
+  scan(0);
+  whitespace();
+  requireValue(offset === text.length);
+  return value;
+}
+__name(parseJson, "parseJson");
+function typedNodeMlsDevCustody(job, invoke, close) {
+  return Object.freeze({
+    prepareProtected: /* @__PURE__ */ __name(((context, commandValue, wrappedState) => job(async (signal) => {
+      const contextJson = JSON.stringify(parseMlsDevDeviceContext(context)), command = parseMlsDevDeviceCommand(commandValue);
+      const wrapped = sealed(wrappedState, 6144, true);
+      requireValue(command.op === "create" === (wrapped === null));
+      requireValue(await invoke(1, [contextJson], signal) === null);
+      return parseMlsDevDevicePreparation(await invoke(2, [contextJson, JSON.stringify(command), wrapped], signal), command.op);
+    })), "prepareProtected"),
+    prepareProtectedKeyPackage: /* @__PURE__ */ __name(((context, command, wrappedState) => job(async (signal) => {
+      const contextJson = JSON.stringify(parseMlsDevDeviceContext(context)), commandJson = JSON.stringify(parseMlsDevKeyPackageCommand(command));
+      const wrapped = sealed(wrappedState, 6144);
+      requireValue(await invoke(1, [contextJson], signal) === null);
+      return parseMlsDevKeyPackagePreparation(await invoke(3, [contextJson, commandJson, wrapped], signal));
+    })), "prepareProtectedKeyPackage"),
+    prepareProtectedGroup: /* @__PURE__ */ __name(((identity, group, command, identityState, groupState, packageState) => job(async (signal) => {
+      const contextJson = JSON.stringify(parseMlsDevDeviceContext(identity)), groupJson = JSON.stringify(parseMlsDevGroupContext(group)), commandJson = JSON.stringify(parseMlsDevGroupCommand(command));
+      const wrapped = sealed(identityState, 6144), protectedGroup = sealed(groupState, 3 * 1024 * 1024, true), protectedPackage = sealed(packageState, 192 * 1024, true);
+      requireValue(await invoke(1, [contextJson], signal) === null);
+      const prepared = parseMlsDevGroupPreparation(await invoke(4, [contextJson, groupJson, commandJson, wrapped, protectedGroup, protectedPackage], signal));
+      const expected = ["create", "add", "remove"].includes(command.op) ? ["control"] : ["join", "process", "finalize"].includes(command.op) ? ["applied"] : command.op === "encrypt_text" || command.op === "encrypt_item" ? ["application"] : command.op === "encrypt_interaction" ? ["interaction_application"] : command.op === "process_application" ? ["text", "item", "interaction", "invalid"] : command.op === "open_secret_answer" ? ["secret"] : ["discarded"];
+      requireValue(expected.includes(prepared.payload.kind));
+      if (prepared.payload.kind === "application") requireValue(command.op === "encrypt_item" === (prepared.payload.payload !== void 0));
+      return prepared;
+    })), "prepareProtectedGroup"),
+    close
+  });
+}
+__name(typedNodeMlsDevCustody, "typedNodeMlsDevCustody");
+
+// ../endpoint/src/node-mls-custody.ts
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { lstat, open, realpath } from "node:fs/promises";
+import { constants } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { platform } from "node:os";
+var EXECUTABLE = "Contents/MacOS/CanonMlsAgent";
+var HASH = /^[0-9a-f]{64}$/;
+var matches = /* @__PURE__ */ __name((pattern, value) => pattern.exec(value)?.[0] === value, "matches");
+var hash = /* @__PURE__ */ __name((bytes) => createHash("sha256").update(bytes).digest("hex"), "hash");
+function createNodeMlsDevCustody(options) {
+  const captured = (() => {
+    try {
+      const keys = ["bundlePath", "manifestSha256", "executableSha256", "bundleIdentifier", "teamIdentifier"];
+      if (Object.hasOwn(options, "timeoutMs")) keys.push("timeoutMs");
+      if (Object.hasOwn(options, "signal")) keys.push("signal");
+      const data = record(options, keys);
+      requireValue(typeof data.bundlePath === "string" && isAbsolute(data.bundlePath) && resolve(data.bundlePath) === data.bundlePath && data.bundlePath.endsWith(".app"));
+      for (const key of ["manifestSha256", "executableSha256"]) requireValue(typeof data[key] === "string" && HASH.test(data[key]));
+      requireValue(typeof data.bundleIdentifier === "string" && matches(/^[A-Za-z0-9][A-Za-z0-9.-]{2,150}$/, data.bundleIdentifier));
+      requireValue(typeof data.teamIdentifier === "string" && matches(/^[A-Z0-9]{10}$/, data.teamIdentifier));
+      const timeoutMs = data.timeoutMs ?? 3e4;
+      requireValue(typeof timeoutMs === "number" && Number.isSafeInteger(timeoutMs) && timeoutMs >= 100 && timeoutMs <= 6e4);
+      requireValue(data.signal === void 0 || data.signal instanceof AbortSignal);
+      return Object.freeze({ ...data, timeoutMs });
+    } catch {
+      return rejected();
+    }
+  })();
+  let closed = false;
+  const jobs = /* @__PURE__ */ new Set(), children = /* @__PURE__ */ new Set();
+  const alive = /* @__PURE__ */ __name((signal) => requireValue(!closed && !signal.aborted && !captured.signal?.aborted), "alive");
+  async function file(path, maximum) {
+    const info = await lstat(path);
+    requireValue(info.isFile() && !info.isSymbolicLink() && (info.mode & 18) === 0 && info.size > 0 && info.size <= maximum && (info.uid === process.getuid?.() || info.uid === 0) && await realpath(path) === path);
+    const fd = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+      const current = await fd.stat();
+      requireValue(current.ino === info.ino && current.dev === info.dev && current.size === info.size);
+      const bytes = Buffer.alloc(current.size);
+      let count = 0;
+      while (count < bytes.length) {
+        const read = await fd.read(bytes, count, bytes.length - count, count);
+        requireValue(read.bytesRead > 0);
+        count += read.bytesRead;
+      }
+      const after = await fd.stat();
+      requireValue(after.size === current.size && after.mtimeMs === current.mtimeMs);
+      return bytes;
+    } finally {
+      await fd.close();
+    }
+  }
+  __name(file, "file");
+  function command(binary, args, input, signal, maximum) {
+    alive(signal);
+    const result = new Promise((resolveCommand, rejectCommand) => {
+      const child = spawn(binary, args, { detached: true, stdio: ["pipe", "pipe", "pipe"], env: { PATH: "/usr/bin:/bin" } });
+      let invalid = false, stdoutBytes = 0, stderrBytes = 0;
+      const chunks = [];
+      const kill = /* @__PURE__ */ __name(() => {
+        try {
+          if (child.pid) process.kill(-child.pid, "SIGKILL");
+        } catch (error) {
+          if (error.code !== "ESRCH") invalid = true;
+        }
+      }, "kill");
+      const cancel = /* @__PURE__ */ __name(() => {
+        invalid = true;
+        kill();
+      }, "cancel");
+      signal.addEventListener("abort", cancel, { once: true });
+      child.stdout.on("data", (chunk) => {
+        stdoutBytes += chunk.length;
+        if (stdoutBytes > maximum) cancel();
+        else chunks.push(chunk);
+      });
+      child.stderr.on("data", (chunk) => {
+        stderrBytes += chunk.length;
+        if (stderrBytes > 65536) cancel();
+      });
+      child.on("error", cancel);
+      child.stdin.on("error", cancel);
+      child.on("close", (code) => {
+        signal.removeEventListener("abort", cancel);
+        kill();
+        if (invalid || code !== 0 || signal.aborted || closed) rejectCommand(new NodeMlsDevCustodyError());
+        else resolveCommand(Buffer.concat(chunks));
+      });
+      if (signal.aborted) cancel();
+      else child.stdin.end(input);
+    });
+    children.add(result);
+    void result.then(() => children.delete(result), () => children.delete(result));
+    return result;
+  }
+  __name(command, "command");
+  async function verify(signal) {
+    alive(signal);
+    requireValue(platform() === "darwin");
+    const directory = await lstat(captured.bundlePath);
+    requireValue(directory.isDirectory() && !directory.isSymbolicLink() && (directory.mode & 18) === 0 && await realpath(captured.bundlePath) === captured.bundlePath);
+    const manifestBytes = await file(captured.bundlePath + ".manifest.json", 65536);
+    alive(signal);
+    requireValue(hash(manifestBytes) === captured.manifestSha256);
+    const manifest = record(parseJson(manifestBytes), ["schemaVersion", "purpose", "buildStatus", "bundleIdentifier", "teamIdentifier", "executable", "infoPlist", "nativeLibrarySha256", "sourceSha", "sourceDirty", "sourceHashes"]);
+    requireValue(manifest.schemaVersion === 1 && manifest.purpose === "canon.mls.dev-macos-custody" && manifest.buildStatus === "signed" && manifest.bundleIdentifier === captured.bundleIdentifier && manifest.teamIdentifier === captured.teamIdentifier);
+    for (const [name, expectedPath, maximum] of [["executable", EXECUTABLE, 128 * 1024 * 1024], ["infoPlist", "Contents/Info.plist", 32768]]) {
+      const artifact = record(manifest[name], ["path", "sha256", "bytes"]);
+      requireValue(artifact.path === expectedPath && typeof artifact.sha256 === "string" && HASH.test(artifact.sha256));
+      const bytes = await file(join(captured.bundlePath, expectedPath), maximum);
+      alive(signal);
+      requireValue(artifact.bytes === bytes.length && artifact.sha256 === hash(bytes));
+      if (name === "executable") requireValue(artifact.sha256 === captured.executableSha256);
+    }
+    const requirement = `anchor apple generic and identifier "${captured.bundleIdentifier}" and certificate leaf[subject.OU] = "${captured.teamIdentifier}"`;
+    await command("/usr/bin/codesign", ["--verify", "--strict", "--all-architectures", `-R=${requirement}`, captured.bundlePath], null, signal, 16384);
+    alive(signal);
+    return join(captured.bundlePath, EXECUTABLE);
+  }
+  __name(verify, "verify");
+  async function invoke(operation, values, signal) {
+    const executable = await verify(signal);
+    alive(signal);
+    const output = await command(executable, [], frame(operation, values), signal, MAX_OUTPUT);
+    alive(signal);
+    await verify(signal);
+    alive(signal);
+    return custodyValue(output, operation);
+  }
+  __name(invoke, "invoke");
+  async function job(work) {
+    const controller = new AbortController();
+    let timer;
+    const cancel = /* @__PURE__ */ __name(() => controller.abort(), "cancel");
+    jobs.add(controller);
+    try {
+      alive(controller.signal);
+      captured.signal?.addEventListener("abort", cancel, { once: true });
+      const cancelled = new Promise((_, reject) => {
+        controller.signal.addEventListener("abort", () => reject(new NodeMlsDevCustodyError()), { once: true });
+        timer = setTimeout(cancel, captured.timeoutMs);
+      });
+      return await Promise.race([work(controller.signal), cancelled]);
+    } catch (error) {
+      return custodyFailure(error);
+    } finally {
+      if (timer) clearTimeout(timer);
+      controller.abort();
+      captured.signal?.removeEventListener("abort", cancel);
+      jobs.delete(controller);
+    }
+  }
+  __name(job, "job");
+  return typedNodeMlsDevCustody(job, invoke, async () => {
+    closed = true;
+    for (const job2 of jobs) job2.abort();
+    await Promise.allSettled([...children]);
+  });
+}
+__name(createNodeMlsDevCustody, "createNodeMlsDevCustody");
+
+// ../endpoint/src/node.ts
+import { mkdir, chmod } from "node:fs/promises";
+import { createHash as createHash3 } from "node:crypto";
+import { join as join2, resolve as resolve3 } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+
+// ../endpoint/src/sqlite.ts
+async function createSqliteEndpointStore(options) {
+  const { database, namespace } = options;
+  if (!namespace) throw new Error("Endpoint store namespace is required");
+  await database.transaction(async (tx) => {
+    await tx.run("CREATE TABLE IF NOT EXISTS canon_endpoint_records (namespace TEXT NOT NULL, key TEXT NOT NULL, value TEXT NOT NULL, PRIMARY KEY(namespace, key))");
+  });
+  return {
+    transaction: /* @__PURE__ */ __name((work) => database.transaction(async (sql) => {
+      const transaction = {
+        async get(key) {
+          const rows = await sql.all("SELECT value FROM canon_endpoint_records WHERE namespace = ? AND key = ?", [namespace, key]);
+          return rows[0] ? JSON.parse(rows[0].value) : void 0;
+        },
+        async put(key, value) {
+          await sql.run("INSERT INTO canon_endpoint_records(namespace, key, value) VALUES (?, ?, ?) ON CONFLICT(namespace, key) DO UPDATE SET value = excluded.value", [namespace, key, JSON.stringify(value)]);
+        },
+        async delete(key) {
+          await sql.run("DELETE FROM canon_endpoint_records WHERE namespace = ? AND key = ?", [namespace, key]);
+        },
+        async scan(prefix, scanOptions = {}) {
+          const limit = Math.max(1, Math.min(scanOptions.limit ?? 100, 1e3));
+          const rows = await sql.all(
+            "SELECT key, value FROM canon_endpoint_records WHERE namespace = ? AND key >= ? AND key < ? AND key > ? ORDER BY key LIMIT ?",
+            [namespace, prefix, `${prefix}\uFFFF`, scanOptions.after ?? "", limit]
+          );
+          return rows.map((row) => ({ key: row.key, value: JSON.parse(row.value) }));
+        }
+      };
+      return work(transaction);
+    }), "transaction"),
+    async close() {
+      await database.close?.();
+    }
+  };
+}
+__name(createSqliteEndpointStore, "createSqliteEndpointStore");
+
+// ../endpoint/src/portable-node-mls-custody.ts
+import { spawn as spawn2 } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
+import { constants as constants2 } from "node:fs";
+import { lstat as lstat2, open as open2, realpath as realpath2 } from "node:fs/promises";
+import { dirname, isAbsolute as isAbsolute2, relative, resolve as resolve2 } from "node:path";
+import { platform as platform2 } from "node:os";
+var HASH2 = /^[0-9a-f]{64}$/;
+var absolute = /* @__PURE__ */ __name((value) => typeof value === "string" && isAbsolute2(value) && resolve2(value) === value && !value.includes("\0"), "absolute");
+var hash2 = /* @__PURE__ */ __name((bytes) => createHash2("sha256").update(bytes).digest("hex"), "hash");
+var sameIdentity = /* @__PURE__ */ __name((a, b) => a.version === b.version && a.environmentId === b.environmentId && a.installationId === b.installationId && a.principal.type === b.principal.type && a.principal.id === b.principal.id && ("ownershipVersion" in a.principal ? a.principal.ownershipVersion : void 0) === ("ownershipVersion" in b.principal ? b.principal.ownershipVersion : void 0), "sameIdentity");
+function createPortableNodeMlsDevCustody(options) {
+  const captured = (() => {
+    try {
+      const fields = ["executablePath", "executableSha256", "configurationPath", "configurationSha256", "secretSource"];
+      if (Object.hasOwn(options, "timeoutMs")) fields.push("timeoutMs");
+      if (Object.hasOwn(options, "signal")) fields.push("signal");
+      const value = record(options, fields), source = record(value.secretSource, ["kind", "path"]);
+      requireValue(absolute(value.executablePath) && absolute(value.configurationPath) && absolute(source.path) && source.kind === "managed-file");
+      for (const field of ["executableSha256", "configurationSha256"]) requireValue(typeof value[field] === "string" && HASH2.test(value[field]));
+      const timeoutMs = value.timeoutMs ?? 3e4;
+      requireValue(typeof timeoutMs === "number" && Number.isSafeInteger(timeoutMs) && timeoutMs >= 100 && timeoutMs <= 6e4);
+      requireValue(value.signal === void 0 || value.signal instanceof AbortSignal);
+      return Object.freeze({ ...value, secretSource: Object.freeze({ ...source }), timeoutMs });
+    } catch {
+      return rejected();
+    }
+  })();
+  let closed = false;
+  const jobs = /* @__PURE__ */ new Set(), children = /* @__PURE__ */ new Set();
+  const alive = /* @__PURE__ */ __name((signal) => requireValue(!closed && !signal.aborted && !captured.signal?.aborted), "alive");
+  async function trustedExecutableAncestry() {
+    for (let path = dirname(captured.executablePath); ; path = dirname(path)) {
+      const info = await lstat2(path);
+      requireValue(info.isDirectory() && !info.isSymbolicLink() && (info.uid === process.getuid?.() || info.uid === 0) && (info.mode & 18) === 0);
+      if (dirname(path) === path) return;
+    }
+  }
+  __name(trustedExecutableAncestry, "trustedExecutableAncestry");
+  async function checkedFile(path, maximum, secret = false) {
+    requireValue(await realpath2(path) === path);
+    const info = await lstat2(path);
+    requireValue(info.isFile() && !info.isSymbolicLink() && info.nlink === 1 && info.size > 0 && info.size <= maximum && (info.uid === process.getuid?.() || info.uid === 0) && (info.mode & (secret ? 63 : 18)) === 0);
+    const file = await open2(path, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+    try {
+      const current = await file.stat();
+      requireValue(current.ino === info.ino && current.dev === info.dev && current.size === info.size && current.mode === info.mode && current.uid === info.uid && current.nlink === 1 && await realpath2(path) === path);
+      return file;
+    } catch (error) {
+      await file.close();
+      throw error;
+    }
+  }
+  __name(checkedFile, "checkedFile");
+  async function publicBytes(path, maximum) {
+    const file = await checkedFile(path, maximum);
+    try {
+      const before = await file.stat(), bytes = Buffer.alloc(before.size);
+      let length = 0;
+      while (length < bytes.length) {
+        const read = await file.read(bytes, length, bytes.length - length, length);
+        requireValue(read.bytesRead > 0);
+        length += read.bytesRead;
+      }
+      const after = await file.stat();
+      requireValue(after.size === before.size && after.mtimeMs === before.mtimeMs && after.ctimeMs === before.ctimeMs);
+      return bytes;
+    } finally {
+      await file.close();
+    }
+  }
+  __name(publicBytes, "publicBytes");
+  async function verify(signal) {
+    alive(signal);
+    requireValue(platform2() === "darwin" || platform2() === "linux");
+    await trustedExecutableAncestry();
+    alive(signal);
+    const binary = await publicBytes(captured.executablePath, 128 * 1024 * 1024);
+    alive(signal);
+    requireValue(hash2(binary) === captured.executableSha256);
+    const bytes = await publicBytes(captured.configurationPath, 65536);
+    alive(signal);
+    requireValue(hash2(bytes) === captured.configurationSha256);
+    const config = record(parseJson(bytes), ["version", "environmentId", "context", "vaultPath", "issuerKeys", "receiptKeys"]);
+    requireValue(config.version === 1 && isMlsEnvironmentId(config.environmentId) && absolute(config.vaultPath));
+    const configuredContext = record(config.context, ["version", "environmentId", "principal", "installationId"]);
+    const context = parseMlsDevDeviceContext({ ...configuredContext, revision: 0 });
+    requireValue(context.environmentId === config.environmentId);
+    const vaultParent = dirname(config.vaultPath);
+    requireValue(await realpath2(vaultParent) === vaultParent);
+    const parent = await lstat2(vaultParent);
+    requireValue(parent.isDirectory() && parent.uid === process.getuid?.() && (parent.mode & 63) === 0);
+    const fromVault = relative(vaultParent, captured.secretSource.path);
+    requireValue(fromVault.startsWith("../") || isAbsolute2(fromVault));
+    requireValue(captured.secretSource.path !== captured.configurationPath && captured.secretSource.path !== captured.executablePath);
+    return { context, vaultParent };
+  }
+  __name(verify, "verify");
+  async function command(input, provision, signal) {
+    const secret = await checkedFile(captured.secretSource.path, 32, true);
+    try {
+      requireValue((await secret.stat()).size === 32);
+      alive(signal);
+      const result = new Promise((resolveCommand, rejectCommand) => {
+        const child = spawn2(
+          captured.executablePath,
+          [
+            "--config",
+            captured.configurationPath,
+            "--config-sha256",
+            captured.configurationSha256,
+            "--secret-fd",
+            "3",
+            ...provision ? ["--provision"] : []
+          ],
+          { detached: true, stdio: ["pipe", "pipe", "pipe", secret.fd], env: { PATH: "/usr/bin:/bin" } }
+        );
+        let invalid = false, stdoutBytes = 0, stderrBytes = 0;
+        const chunks = [];
+        const kill = /* @__PURE__ */ __name(() => {
+          try {
+            if (child.pid) process.kill(-child.pid, "SIGKILL");
+          } catch (error) {
+            if (error.code !== "ESRCH") invalid = true;
+          }
+        }, "kill");
+        const cancel = /* @__PURE__ */ __name(() => {
+          invalid = true;
+          kill();
+        }, "cancel");
+        signal.addEventListener("abort", cancel, { once: true });
+        child.stdout.on("data", (chunk) => {
+          stdoutBytes += chunk.length;
+          if (stdoutBytes > MAX_OUTPUT) cancel();
+          else chunks.push(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+          stderrBytes += chunk.length;
+          if (stderrBytes > 65536) cancel();
+        });
+        child.on("error", cancel);
+        child.stdin.on("error", cancel);
+        child.on("close", (code) => {
+          signal.removeEventListener("abort", cancel);
+          kill();
+          if (invalid || code !== 0 || signal.aborted || closed) rejectCommand(new NodeMlsDevCustodyError());
+          else resolveCommand(Buffer.concat(chunks));
+        });
+        if (signal.aborted) cancel();
+        else child.stdin.end(input);
+      });
+      children.add(result);
+      void result.then(() => children.delete(result), () => children.delete(result));
+      return await result;
+    } finally {
+      await secret.close();
+    }
+  }
+  __name(command, "command");
+  async function invoke(operation, values, signal) {
+    const config = await verify(signal);
+    requireValue(values[0] !== null && sameIdentity(parseMlsDevDeviceContext(JSON.parse(values[0])), config.context));
+    const output = await command(frame(operation, values), false, signal);
+    alive(signal);
+    await verify(signal);
+    alive(signal);
+    return custodyValue(output, operation);
+  }
+  __name(invoke, "invoke");
+  async function job(work) {
+    const controller = new AbortController();
+    let timer;
+    const cancel = /* @__PURE__ */ __name(() => controller.abort(), "cancel");
+    jobs.add(controller);
+    try {
+      alive(controller.signal);
+      captured.signal?.addEventListener("abort", cancel, { once: true });
+      const cancellation = new Promise((_, reject) => {
+        controller.signal.addEventListener("abort", () => reject(new NodeMlsDevCustodyError()), { once: true });
+        timer = setTimeout(cancel, captured.timeoutMs);
+      });
+      return await Promise.race([work(controller.signal), cancellation]);
+    } catch (error) {
+      return custodyFailure(error);
+    } finally {
+      if (timer) clearTimeout(timer);
+      controller.abort();
+      captured.signal?.removeEventListener("abort", cancel);
+      jobs.delete(controller);
+    }
+  }
+  __name(job, "job");
+  const custody = typedNodeMlsDevCustody(job, invoke, async () => {
+    closed = true;
+    for (const job2 of jobs) job2.abort();
+    await Promise.allSettled([...children]);
+  });
+  return Object.freeze({ ...custody, provision: /* @__PURE__ */ __name((context) => job(async (signal) => {
+    const config = await verify(signal);
+    requireValue(sameIdentity(parseMlsDevDeviceContext(context), config.context));
+    const output = await command(null, true, signal);
+    alive(signal);
+    await verify(signal);
+    alive(signal);
+    const result = record(parseJson(output), ["version", "ok", "value"]);
+    requireValue(result.version === 1 && result.ok === true && result.value === null);
+  }), "provision") });
+}
+__name(createPortableNodeMlsDevCustody, "createPortableNodeMlsDevCustody");
+
+// ../endpoint/src/node.ts
+var databases = /* @__PURE__ */ new Map();
+async function createNodeEndpointStore(options) {
+  const directory = resolve3(options.directory);
+  await mkdir(directory, { recursive: true, mode: 448 });
+  const filename = join2(directory, `${createHash3("sha256").update(options.namespace).digest("hex")}.sqlite`);
+  let opening = databases.get(filename);
+  if (!opening) {
+    opening = (async () => {
+      const sqlite = new DatabaseSync(filename);
+      try {
+        await chmod(filename, 384);
+        sqlite.exec("PRAGMA journal_mode = WAL; PRAGMA synchronous = FULL; PRAGMA busy_timeout = 5000;");
+        return { sqlite, tail: Promise.resolve(), references: 0 };
+      } catch (error) {
+        sqlite.close();
+        throw error;
+      }
+    })();
+    databases.set(filename, opening);
+    void opening.catch(() => {
+      if (databases.get(filename) === opening) databases.delete(filename);
+    });
+  }
+  const shared = await opening;
+  if (shared.closed) return createNodeEndpointStore(options);
+  shared.references++;
+  let closing;
+  const database = {
+    transaction(work) {
+      if (closing) return Promise.reject(new Error("Endpoint store is closed"));
+      const result = shared.tail.then(async () => {
+        shared.sqlite.exec("BEGIN IMMEDIATE");
+        try {
+          const transaction = {
+            async all(sql, parameters = []) {
+              return shared.sqlite.prepare(sql).all(...parameters);
+            },
+            async run(sql, parameters = []) {
+              shared.sqlite.prepare(sql).run(...parameters);
+            }
+          };
+          const value = await work(transaction);
+          shared.sqlite.exec("COMMIT");
+          return value;
+        } catch (error) {
+          shared.sqlite.exec("ROLLBACK");
+          throw error;
+        }
+      });
+      shared.tail = result.catch(() => void 0);
+      return result;
+    },
+    close() {
+      if (closing) return closing;
+      closing = shared.tail.then(() => {
+        shared.references--;
+        if (!shared.references) {
+          shared.closed = true;
+          if (databases.get(filename) === opening) databases.delete(filename);
+          shared.sqlite.close();
+        }
+      });
+      return closing;
+    }
+  };
+  try {
+    return await createSqliteEndpointStore({ database, namespace: options.namespace });
+  } catch (error) {
+    await database.close?.();
+    throw error;
+  }
+}
+__name(createNodeEndpointStore, "createNodeEndpointStore");
+
+// ../endpoint/src/store.ts
+function copyJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+__name(copyJson, "copyJson");
+
+export {
+  createEndpointEventHub,
+  EndpointError,
+  validateEndpointContentBoundary,
+  createHttpEndpointTransport,
+  NodeMlsDevCustodyError,
+  MAX_INPUT,
+  MAX_OUTPUT,
+  rejected,
+  custodyValue,
+  custodyFailure,
+  requireValue,
+  frame,
+  parseFrame,
+  typedNodeMlsDevCustody,
+  createNodeMlsDevCustody,
+  createPortableNodeMlsDevCustody,
+  createNodeEndpointStore,
+  copyJson
+};