@canonmsg/agent-sdk 12.5.1 → 12.6.1

package/dist/chunks/{chunk-TFSURFF6.js → chunk-5J4YPLNW.js}

@@ -1,18 +1,20 @@
 import {
-  CANON_CLIENT_HEADER,
+  EndpointError,
+  copyJson,
+  createEndpointEventHub,
+  createHttpEndpointTransport,
+  createNodeEndpointStore,
+  validateEndpointContentBoundary
+} from "./chunk-FVYKLH6I.js";
+import {
   CANON_ENDPOINT_PROTOCOL,
   CANON_VERB_WIRE_SCHEMA_VERSION,
-  CLIENT_UPDATE_REQUIRED,
   ENDPOINT_ACTION_PATTERN,
   ENDPOINT_ID_PATTERN,
   MAX_PUBLIC_RUNTIME_COMMANDS,
-  MLS_DEV_CREDENTIAL_MAX_BYTES,
-  MLS_DEV_CREDENTIAL_RECONCILIATION_MAX_BYTES,
   MLS_DEV_DISCLOSED_PROCESSING_FIELDS,
-  MLS_DEV_ENROLLMENT_MAX_BYTES,
   MLS_DEV_GROUP_RECEIPT_CLOCK_SKEW,
   MLS_DEV_INTERACTION_LIMITS,
-  MLS_DEV_KEY_PACKAGES_MAX_BYTES,
   MLS_DEV_REPLY_QUOTE_MAX_CHARACTERS,
   MLS_DEV_TEXT_PROTOCOL_V3,
   MLS_DEV_UNSUPPORTED_CONTENT_ACTIONS,
@@ -22,8 +24,6 @@ import {
   __name,
   assertMlsDevInteractionPayloadBinding,
   canonicalEndpointJson,
-  classifyTransferHttpFailure,
-  classifyTransferReceipt,
   createMlsDevCredentialSigningInput,
   decodePreparedJsonContent,
   describeAttachment,
@@ -32,14 +32,11 @@ import {
   encodeMlsPrincipalAliasInput,
   endpointContentBoundary,
   endpointOperationRequestRetention,
-  formatCanonClientHeader,
   formatMembershipChangeNotice,
   getCanonEnvironmentContract,
   isCanonMediaOrigin,
   isCanonUploadUrl,
-  isEndpointOperationReceipt,
   isMlsDevInteractionAnswerAllowed,
-  isMlsDevReceiptClockSkew,
   isMlsDevTextProtocol,
   isMlsEnvironmentId,
   isMlsPrincipalAlias,
@@ -61,7 +58,6 @@ import {
   parseMlsDevCredentialReconciliationComplete,
   parseMlsDevCredentialReconciliationReceipt,
   parseMlsDevCredentialRevocationReceipt,
-  parseMlsDevCredentialRevoke,
   parseMlsDevCredentialToken,
   parseMlsDevDeviceBinding,
   parseMlsDevDeviceCommand,
@@ -110,1428 +106,44 @@ import {
   readMembershipChangeMetadata,
   resolveAllowedUploadMimeType,
   sanitizeDownloadFileName
-} from "./chunk-C2WJT3VX.js";
+} from "./chunk-S7BV74DN.js";
 
 // src/media.ts
 import { createWriteStream as createWriteStream2 } from "node:fs";
 import { randomUUID as randomUUID8 } from "node:crypto";
-import { mkdir as mkdir3, open as open4, rename as rename2, stat as stat2, unlink as unlink2 } from "node:fs/promises";
-import { basename, dirname as dirname3, extname, join as join7 } from "node:path";
+import { mkdir as mkdir2, open as open2, rename as rename2, stat as stat2, unlink as unlink2 } from "node:fs/promises";
+import { basename, dirname as dirname2, extname, join as join5 } from "node:path";
 import { Readable, Transform as Transform2 } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
 
-// ../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(prefix3, 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, prefix3, `${prefix3}\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/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";
-
-// ../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((resolve6) => {
-        const finish = /* @__PURE__ */ __name(() => {
-          clearTimeout(timer);
-          signal.removeEventListener("abort", finish);
-          resolve6();
-        }, "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 id2;
-  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 { ...id2 ? { id: id2 } : {}, kind, data: value2 };
-            }
-            kind = "message";
-            id2 = 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")) id2 = 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 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 dependencies.fetch(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 invalid2 = /* @__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 invalid2();
-  const reader = response.body?.getReader();
-  if (!reader) throw invalid2();
-  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 invalid2();
-      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 invalid2();
-  } 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 prefix3 = Buffer.alloc(4);
-    prefix3.writeUInt32BE(bytes?.length ?? 4294967295);
-    chunks.push(prefix3);
-    if (bytes) chunks.push(bytes);
-    length += 4 + (bytes?.length ?? 0);
-    requireValue(length <= MAX_INPUT);
-  }
-  return Buffer.concat(chunks, length);
-}
-__name(frame, "frame");
-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
-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 invalid2 = 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") invalid2 = true;
-        }
-      }, "kill");
-      const cancel = /* @__PURE__ */ __name(() => {
-        invalid2 = 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 (invalid2 || 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/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 invalid2 = 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") invalid2 = true;
-          }
-        }, "kill");
-        const cancel = /* @__PURE__ */ __name(() => {
-          invalid2 = 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 (invalid2 || 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");
-
 // ../core/src/node-media.ts
-import { createHash as createHash4, randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { createReadStream, createWriteStream } from "node:fs";
-import { mkdir as mkdir2, open as open3, readdir, rename, stat, unlink } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { mkdir, open, readdir, rename, stat, unlink } from "node:fs/promises";
+import { join } from "node:path";
 import { Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 var MAX_BYTES = 100 * 1024 * 1024;
 function createNodeEndpointMediaBytes(options) {
   const expectedDigests = /* @__PURE__ */ new Map();
-  const initialized = mkdir2(options.directory, { recursive: true, mode: 448 });
+  const initialized = mkdir(options.directory, { recursive: true, mode: 448 });
   const referencePath = /* @__PURE__ */ __name((reference) => {
     if (!/^[a-f0-9]{64}\.bytes$/.test(reference)) throw new Error("Invalid retained Canon media reference");
-    return join3(options.directory, reference);
+    return join(options.directory, reference);
   }, "referencePath");
   async function digest(source) {
-    const handle = await open3(source, "r");
+    const handle = await open(source, "r");
     try {
       const info = await handle.stat();
       if (!info.isFile() || info.size < 1 || info.size > MAX_BYTES) throw new Error("Canon media must be a regular file from 1 byte to 100 MiB");
-      const hash3 = createHash4("sha256");
+      const hash = createHash("sha256");
       let size = 0;
       for await (const chunk of handle.createReadStream({ autoClose: false })) {
         size += chunk.length;
         if (size > MAX_BYTES) throw new Error("Canon media grew beyond its upload limit");
-        hash3.update(chunk);
+        hash.update(chunk);
       }
-      const result = hash3.digest("hex");
+      const result = hash.digest("hex");
       expectedDigests.set(source, result);
       return result;
     } finally {
@@ -1545,36 +157,38 @@ function createNodeEndpointMediaBytes(options) {
       await initialized;
       const expected = expectedDigests.get(source);
       if (!expected) throw new Error("Canon media must be fingerprinted before retaining bytes");
-      const reference = `${createHash4("sha256").update(key).digest("hex")}.bytes`;
+      const reference = `${createHash("sha256").update(key).digest("hex")}.bytes`;
       const destination = referencePath(reference);
       const temporary = `${destination}.${randomUUID()}.tmp`;
-      const sourceHandle = await open3(source, "r");
+      const sourceHandle = await open(source, "r");
       try {
         const info = await sourceHandle.stat();
         if (!info.isFile()) throw new Error("Canon media source is no longer a regular file");
-        const hash3 = createHash4("sha256");
+        const hash = createHash("sha256");
         let size = 0;
         await pipeline(sourceHandle.createReadStream({ autoClose: false }), new Transform({
           transform(chunk, _encoding, callback) {
             size += chunk.length;
             if (size > MAX_BYTES) return callback(new Error("Canon media grew beyond its upload limit"));
-            hash3.update(chunk);
+            hash.update(chunk);
             callback(null, chunk);
           }
         }), createWriteStream(temporary, { flags: "wx", mode: 384 }));
-        if (hash3.digest("hex") !== expected) throw new Error("Canon media changed while preparing delivery");
-        const retained = await open3(temporary, "r");
+        if (hash.digest("hex") !== expected) throw new Error("Canon media changed while preparing delivery");
+        const retained = await open(temporary, "r+");
         try {
           await retained.sync();
         } finally {
           await retained.close();
         }
         await rename(temporary, destination);
-        const directory = await open3(options.directory, "r");
-        try {
-          await directory.sync();
-        } finally {
-          await directory.close();
+        if (process.platform !== "win32") {
+          const directory = await open(options.directory, "r");
+          try {
+            await directory.sync();
+          } finally {
+            await directory.close();
+          }
         }
         return reference;
       } catch (error) {
@@ -1625,7 +239,7 @@ function createNodeEndpointMediaBytes(options) {
     async discardAll() {
       await initialized;
       for (const name of await readdir(options.directory)) {
-        if (/^[a-f0-9]{64}\.bytes(?:\.[a-f0-9-]+\.tmp)?$/.test(name)) await unlink(join3(options.directory, name));
+        if (/^[a-f0-9]{64}\.bytes(?:\.[a-f0-9-]+\.tmp)?$/.test(name)) await unlink(join(options.directory, name));
       }
     }
   };
@@ -1777,15 +391,15 @@ function normalizeDefaults(environmentId, value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new Error(`Invalid Canon runtime endpoint defaults for ${environmentId}`);
   }
-  const record7 = value;
-  const firebaseWebApiKey = typeof record7.firebaseWebApiKey === "string" ? record7.firebaseWebApiKey.trim() : "";
+  const record6 = value;
+  const firebaseWebApiKey = typeof record6.firebaseWebApiKey === "string" ? record6.firebaseWebApiKey.trim() : "";
   if (!firebaseWebApiKey) {
     throw new Error(`Missing Canon runtime endpoint default: ${environmentId}.firebaseWebApiKey`);
   }
   return Object.freeze({
-    apiBaseUrl: normalizedHttpsUrl(record7.apiBaseUrl, `${environmentId}.apiBaseUrl`),
-    streamUrl: normalizedHttpsUrl(record7.streamUrl, `${environmentId}.streamUrl`),
-    rtdbUrl: normalizedHttpsUrl(record7.rtdbUrl, `${environmentId}.rtdbUrl`),
+    apiBaseUrl: normalizedHttpsUrl(record6.apiBaseUrl, `${environmentId}.apiBaseUrl`),
+    streamUrl: normalizedHttpsUrl(record6.streamUrl, `${environmentId}.streamUrl`),
+    rtdbUrl: normalizedHttpsUrl(record6.rtdbUrl, `${environmentId}.rtdbUrl`),
     firebaseWebApiKey
   });
 }
@@ -1879,13 +493,7 @@ var DEFAULT_CANON_RUNTIME_ENDPOINTS = requireCanonRuntimeEndpointDefaults(
 var DEFAULT_BASE_URL = DEFAULT_CANON_RUNTIME_ENDPOINTS.apiBaseUrl;
 
 // ../core/src/client.ts
-import { createHash as createHash6, randomUUID as randomUUID2 } from "node:crypto";
-
-// ../endpoint/src/store.ts
-function copyJson(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-__name(copyJson, "copyJson");
+import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
 
 // ../endpoint/src/prepared-content.ts
 var protocolKey = /* @__PURE__ */ __name((scope5) => `protocol-state/${encodeURIComponent(scope5)}`, "protocolKey");
@@ -2052,23 +660,23 @@ async function isFirstOrderedOperation(tx, operation) {
   }
 }
 __name(isFirstOrderedOperation, "isFirstOrderedOperation");
-var inboundReadyKey = /* @__PURE__ */ __name((record7) => record7.queueKey ?? `inbound-ready/${record7.event.id}`, "inboundReadyKey");
-async function orderInbound(tx, record7) {
-  if (record7.queueKey) return record7;
-  const message = record7.event.data.message;
-  const sourceTime = message?.createdAt ?? record7.event.data.createdAt;
+var inboundReadyKey = /* @__PURE__ */ __name((record6) => record6.queueKey ?? `inbound-ready/${record6.event.id}`, "inboundReadyKey");
+async function orderInbound(tx, record6) {
+  if (record6.queueKey) return record6;
+  const message = record6.event.data.message;
+  const sourceTime = message?.createdAt ?? record6.event.data.createdAt;
   const millis = typeof sourceTime === "string" ? Date.parse(sourceTime) : typeof sourceTime === "number" ? sourceTime : NaN;
-  const timestamp = Number.isFinite(millis) ? new Date(millis).toISOString() : record7.createdAt;
-  const tie = Number.isFinite(millis) ? `0-${lexicalIdentity(record7.event.id)}` : `1-${ordinal(await nextQueueSequence(tx, "inbound"))}`;
-  return { ...record7, queueKey: `inbound-ready/${scope(record7.event.conversationId)}/${timestamp}/${tie}` };
+  const timestamp = Number.isFinite(millis) ? new Date(millis).toISOString() : record6.createdAt;
+  const tie = Number.isFinite(millis) ? `0-${lexicalIdentity(record6.event.id)}` : `1-${ordinal(await nextQueueSequence(tx, "inbound"))}`;
+  return { ...record6, queueKey: `inbound-ready/${scope(record6.event.conversationId)}/${timestamp}/${tie}` };
 }
 __name(orderInbound, "orderInbound");
-async function enqueueInbound(tx, record7) {
-  await tx.put(inboundReadyKey(record7), { id: record7.event.id, kind: record7.event.kind, conversationId: record7.event.conversationId });
+async function enqueueInbound(tx, record6) {
+  await tx.put(inboundReadyKey(record6), { id: record6.event.id, kind: record6.event.kind, conversationId: record6.event.conversationId });
 }
 __name(enqueueInbound, "enqueueInbound");
-async function removeInboundReady(tx, record7) {
-  await tx.delete(inboundReadyKey(record7));
+async function removeInboundReady(tx, record6) {
+  await tx.delete(inboundReadyKey(record6));
 }
 __name(removeInboundReady, "removeInboundReady");
 
@@ -2203,11 +811,11 @@ function createMessageGroupCoordinator(input) {
         const group = await tx.get(groupKey(id2));
         if (!group) return;
         const children = await Promise.all(group.children.map((child) => tx.get(`operation/${child.operationId}`)));
-        const rejected2 = children.find((child) => child?.status === "rejected" || child?.status === "succeeded" && !messageGroupChildSucceeded(child));
+        const rejected = children.find((child) => child?.status === "rejected" || child?.status === "succeeded" && !messageGroupChildSucceeded(child));
         const uncertain = children.find((child) => child?.status === "uncertain");
         const succeeded = children.every(messageGroupChildSucceeded);
-        const status = succeeded ? "succeeded" : rejected2 || group.cancelled ? "rejected" : uncertain ? "uncertain" : "pending";
-        const error = rejected2?.receipt?.error ?? (rejected2 ? { code: "PROACTIVE_NOT_ADMITTED", status: 403, message: "Proactive message was not admitted", retryable: false } : void 0) ?? (group.cancelled ? { code: "OPERATION_DISCARDED", message: "Remaining message parts were cancelled", retryable: false } : uncertain?.receipt?.error);
+        const status = succeeded ? "succeeded" : rejected || group.cancelled ? "rejected" : uncertain ? "uncertain" : "pending";
+        const error = rejected?.receipt?.error ?? (rejected ? { code: "PROACTIVE_NOT_ADMITTED", status: 403, message: "Proactive message was not admitted", retryable: false } : void 0) ?? (group.cancelled ? { code: "OPERATION_DISCARDED", message: "Remaining message parts were cancelled", retryable: false } : uncertain?.receipt?.error);
         return {
           operationId: id2,
           installationId: group.installationId,
@@ -2597,12 +1205,12 @@ async function assertMlsDevPlaintextAllowed(tx, intent2, lane = "operation.reque
   const conversationId = endpointIntentConversationId(intent2);
   if (!conversationId) return;
   if (!await isMlsDevRoomProtected(tx, conversationId)) return;
-  const failure2 = /* @__PURE__ */ __name(() => new EndpointError("This MLS conversation requires encrypted content", {
+  const failure = /* @__PURE__ */ __name(() => new EndpointError("This MLS conversation requires encrypted content", {
     code: "MLS_DEV_ENCRYPTED_CONTENT_REQUIRED",
     retryable: false
   }), "failure");
   const action = intent2.action === "verb_execute" ? intent2.body.verb : intent2.action;
-  if (typeof action === "string" && MLS_DEV_UNSUPPORTED_CONTENT_ACTIONS.some((unsupported) => unsupported === action)) throw failure2();
+  if (typeof action === "string" && MLS_DEV_UNSUPPORTED_CONTENT_ACTIONS.some((unsupported) => unsupported === action)) throw failure();
   const disclosed = lane === "operation.request" && Object.hasOwn(MLS_DEV_DISCLOSED_PROCESSING_FIELDS, intent2.action) ? MLS_DEV_DISCLOSED_PROCESSING_FIELDS[intent2.action] : void 0;
   if (disclosed && !intent2.envelope && Object.keys(intent2.body).every((field) => disclosed.includes(field))) return;
   const payload = lane === "operation.request" ? { body: { encoding: "json", value: intent2.body }, ...intent2.envelope ? { envelope: intent2.envelope } : {} } : intent2.body;
@@ -2610,7 +1218,7 @@ async function assertMlsDevPlaintextAllowed(tx, intent2, lane = "operation.reque
   try {
     boundary = endpointContentBoundary(lane, intent2.action, payload);
   } catch {
-    throw failure2();
+    throw failure();
   }
   const privateLeaf = /* @__PURE__ */ __name((value, path) => {
     if (value && typeof value === "object") {
@@ -2620,8 +1228,8 @@ async function assertMlsDevPlaintextAllowed(tx, intent2, lane = "operation.reque
     return boundary.classify(path) !== "public-metadata";
   }, "privateLeaf");
   if (lane === "operation.request") {
-    if (privateLeaf(intent2.body, ["body", "value"]) || intent2.envelope && privateLeaf(intent2.envelope, ["envelope"])) throw failure2();
-  } else if (privateLeaf(intent2.body, [])) throw failure2();
+    if (privateLeaf(intent2.body, ["body", "value"]) || intent2.envelope && privateLeaf(intent2.envelope, ["envelope"])) throw failure();
+  } else if (privateLeaf(intent2.body, [])) throw failure();
 }
 __name(assertMlsDevPlaintextAllowed, "assertMlsDevPlaintextAllowed");
 
@@ -2630,15 +1238,15 @@ function isInboundProjectionKind(kind) {
   return ["artifact.changed", "message.updated", "message.media_terminal"].includes(kind);
 }
 __name(isInboundProjectionKind, "isInboundProjectionKind");
-async function settleInboundProjection(tx, record7, timestamp) {
-  if (!isInboundProjectionKind(record7.event.kind)) return false;
-  await removeInboundReady(tx, record7);
-  if (record7.state !== "settled" && record7.state !== "uncertain" && !record7.externalClaim) {
-    await tx.put(`inbound/${record7.event.id}`, {
-      event: copyJson(record7.event),
+async function settleInboundProjection(tx, record6, timestamp) {
+  if (!isInboundProjectionKind(record6.event.kind)) return false;
+  await removeInboundReady(tx, record6);
+  if (record6.state !== "settled" && record6.state !== "uncertain" && !record6.externalClaim) {
+    await tx.put(`inbound/${record6.event.id}`, {
+      event: copyJson(record6.event),
       state: "settled",
       reason: "projection_hint",
-      createdAt: record7.createdAt,
+      createdAt: record6.createdAt,
       updatedAt: timestamp
     });
   }
@@ -2707,9 +1315,9 @@ async function recordInboundEvent(tx, incoming, timestamp) {
     return true;
   }
   if (existing) return false;
-  const record7 = await orderInbound(tx, { event: copyJson(event), state: "observed", createdAt: timestamp, updatedAt: timestamp });
-  await tx.put(key, record7);
-  await enqueueInbound(tx, record7);
+  const record6 = await orderInbound(tx, { event: copyJson(event), state: "observed", createdAt: timestamp, updatedAt: timestamp });
+  await tx.put(key, record6);
+  await enqueueInbound(tx, record6);
   return true;
 }
 __name(recordInboundEvent, "recordInboundEvent");
@@ -2740,15 +1348,15 @@ async function recordVerifiedMlsInboundEvent(tx, event, feedOrdinal, timestamp,
   if (!event.conversationId || !Number.isSafeInteger(feedOrdinal) || feedOrdinal < 1) throw new Error("Invalid verified MLS input");
   const key = `inbound/${event.id}`, existing = await tx.get(key);
   if (existing && existing.reason !== "mls_plaintext_withheld") return false;
-  const record7 = {
+  const record6 = {
     event: copyJson(event),
     state: own ? "settled" : "observed",
     ...own ? { reason: "own_mls_message" } : { queueKey: `inbound-ready/${encodeURIComponent(event.conversationId)}/mls/${String(feedOrdinal).padStart(16, "0")}/${encodeURIComponent(event.id)}` },
     createdAt: timestamp,
     updatedAt: timestamp
   };
-  await tx.put(key, record7);
-  if (!own) await enqueueInbound(tx, record7);
+  await tx.put(key, record6);
+  if (!own) await enqueueInbound(tx, record6);
   return true;
 }
 __name(recordVerifiedMlsInboundEvent, "recordVerifiedMlsInboundEvent");
@@ -2763,10 +1371,10 @@ function createInboundConsumer(input) {
   let timer;
   const scheduled = /* @__PURE__ */ new Set();
   const rooms = /* @__PURE__ */ new Map();
-  function matches2(record7) {
-    return record7.event.kind === options.kind && (!options.conversationId || record7.event.conversationId === options.conversationId);
+  function matches(record6) {
+    return record6.event.kind === options.kind && (!options.conversationId || record6.event.conversationId === options.conversationId);
   }
-  __name(matches2, "matches");
+  __name(matches, "matches");
   function report(error) {
     try {
       options.onError?.(error);
@@ -2788,15 +1396,15 @@ function createInboundConsumer(input) {
     if (await input.refreshHandoff?.(id2)) return true;
     const selected = await store.transaction(async (tx) => {
       const current = await tx.get(`inbound/${id2}`);
-      if (!current || current.deleted || !matches2(current) || current.state === "uncertain" || current.state === "settled") return { blocked: false };
+      if (!current || current.deleted || !matches(current) || current.state === "uncertain" || current.state === "settled") return { blocked: false };
       if (current.lease && current.lease.expiresAt > clock()) return { blocked: current.lease.owner !== owner };
       const next = { ...current, state: "offered", lease: { owner, expiresAt: clock() + leaseMs }, updatedAt: new Date(clock()).toISOString() };
       delete next.handoffGeneration;
       await tx.put(`inbound/${id2}`, next);
       return { record: next, blocked: false };
     });
-    const record7 = selected.record;
-    if (!record7) return !selected.blocked;
+    const record6 = selected.record;
+    if (!record6) return !selected.blocked;
     const heartbeat = setInterval(() => {
       void store.transaction(async (tx) => {
         const current = await tx.get(`inbound/${id2}`);
@@ -2807,8 +1415,8 @@ function createInboundConsumer(input) {
     }, Math.floor(leaseMs / 3));
     heartbeat.unref?.();
     try {
-      await input.beforeOffer?.(record7.event);
-      await options.offer(record7.event);
+      await input.beforeOffer?.(record6.event);
+      await options.offer(record6.event);
       const handedOff = await endpoint.getInbound(id2);
       return !handedOff || handedOff.state !== "deferred" && handedOff.state !== "observed";
     } catch (error) {
@@ -2874,8 +1482,8 @@ function createInboundConsumer(input) {
               const rows = await tx.scan("inbound-ready/", { after, limit: 100 });
               for (const row of rows) {
                 if (!isInboundProjectionKind(row.value.kind)) continue;
-                const record7 = await tx.get(`inbound/${row.value.id}`);
-                if (record7 && await settleInboundProjection(tx, record7, new Date(clock()).toISOString())) await tx.delete(row.key);
+                const record6 = await tx.get(`inbound/${row.value.id}`);
+                if (record6 && await settleInboundProjection(tx, record6, new Date(clock()).toISOString())) await tx.delete(row.key);
               }
               return rows;
             });
@@ -3362,16 +1970,16 @@ function createEndpointMigration(input) {
           if (canonicalEndpointJson(await tx.get(activeKey)) !== canonicalEndpointJson(progress)) return;
           const cursor = await tx.get(`cursor/${room.conversationId}`);
           if (cursor && (cursor.migrationInventorySha256 !== manifest.inventorySha256 || cursor.cursor !== room.cursor)) invalid("Recovery cursor changed during migration", "MIGRATION_BASELINE_EXISTS");
-          for (const record7 of records) {
-            const existing = await tx.get(`inbound/${record7.event.id}`);
+          for (const record6 of records) {
+            const existing = await tx.get(`inbound/${record6.event.id}`);
             if (existing && existing.migrationInventorySha256 !== manifest.inventorySha256 && !["observed", "deferred"].includes(existing.state)) invalid("Existing native work requires reconciliation before importing", "MIGRATION_INBOX_CONFLICT");
           }
-          for (const record7 of records) {
-            const previous = await tx.get(`inbound/${record7.event.id}`);
+          for (const record6 of records) {
+            const previous = await tx.get(`inbound/${record6.event.id}`);
             if (previous) await removeInboundReady(tx, previous);
-            const ordered = await orderInbound(tx, record7);
-            await tx.put(`inbound/${record7.event.id}`, ordered);
-            if (record7.state === "observed" || record7.state === "deferred") await enqueueInbound(tx, ordered);
+            const ordered = await orderInbound(tx, record6);
+            await tx.put(`inbound/${record6.event.id}`, ordered);
+            if (record6.state === "observed" || record6.state === "deferred") await enqueueInbound(tx, ordered);
           }
           const done = progress.item + batch.length >= room.items.length;
           await tx.put(activeKey, { ...progress, room: progress.room + (done ? 1 : 0), item: done ? 0 : progress.item + batch.length });
@@ -3466,7 +2074,7 @@ function createEndpointMediaPipeline(options) {
   const running = /* @__PURE__ */ new Map();
   const staging = /* @__PURE__ */ new Map();
   const cancelledStages = /* @__PURE__ */ new Set();
-  const hash3 = options.hash ?? (async (value) => {
+  const hash = options.hash ?? (async (value) => {
     const result = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
     return [...new Uint8Array(result)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
   });
@@ -3528,7 +2136,7 @@ function createEndpointMediaPipeline(options) {
   let activeUploads = 0;
   const uploadWaiters = [];
   async function upload(work) {
-    if (activeUploads >= 2) await new Promise((resolve6) => uploadWaiters.push(resolve6));
+    if (activeUploads >= 2) await new Promise((resolve3) => uploadWaiters.push(resolve3));
     else activeUploads += 1;
     try {
       if (closed) throw new Error("Endpoint media pipeline is closed");
@@ -3591,11 +2199,11 @@ function createEndpointMediaPipeline(options) {
     const check = probeBackgroundCapability();
     const waitMs = Math.max(0, options2.maxProbeWaitMs);
     if (waitMs === 0) return false;
-    return new Promise((resolve6) => {
-      const timer2 = setTimeout(() => resolve6(false), waitMs);
+    return new Promise((resolve3) => {
+      const timer2 = setTimeout(() => resolve3(false), waitMs);
       void check.then((enabled) => {
         clearTimeout(timer2);
-        resolve6(enabled);
+        resolve3(enabled);
       });
     });
   }
@@ -3744,7 +2352,7 @@ function createEndpointMediaPipeline(options) {
     }
     const staged = (async () => {
       if (closed || sendOptions?.signal?.aborted) throw new DOMException("Attachment cancelled", "AbortError");
-      const fingerprint = await hash3(canonicalEndpointJson({ message: input.message, files: input.files.map((file) => ({ descriptor: file.descriptor, source: background.sourceIdentity(file.source) })) }));
+      const fingerprint = await hash(canonicalEndpointJson({ message: input.message, files: input.files.map((file) => ({ descriptor: file.descriptor, source: background.sourceIdentity(file.source) })) }));
       if (closed || sendOptions?.signal?.aborted) throw new DOMException("Attachment cancelled", "AbortError");
       const owner = await acquire(id2);
       try {
@@ -3782,10 +2390,10 @@ function createEndpointMediaPipeline(options) {
               }) }), "prepare"),
               commit: /* @__PURE__ */ __name(async (tx, preparedContent) => {
                 if (closed || sendOptions?.signal?.aborted) throw new DOMException("Attachment cancelled", "AbortError");
-                const sealed2 = { ...flow, preparedContent };
-                await writeInTransaction(tx, sealed2, owner);
+                const sealed = { ...flow, preparedContent };
+                await writeInTransaction(tx, sealed, owner);
                 await tx.delete(`preparation/${operationId}`);
-                return sealed2;
+                return sealed;
               }, "commit")
             });
             notifyFlow(committed);
@@ -3839,7 +2447,7 @@ function createEndpointMediaPipeline(options) {
         checkOpen();
         digests.push(await bytes.digest(file.source));
       }
-      const fingerprint = await hash3(canonicalEndpointJson({ ...prepareOnly ? { purpose: "prepare" } : {}, message: input.message, files: input.files.map((file, index) => ({ ...file.descriptor, digest: digests[index] })) }));
+      const fingerprint = await hash(canonicalEndpointJson({ ...prepareOnly ? { purpose: "prepare" } : {}, message: input.message, files: input.files.map((file, index) => ({ ...file.descriptor, digest: digests[index] })) }));
       checkOpen();
       const owner = await acquire(id2);
       const controller = new AbortController();
@@ -3937,8 +2545,8 @@ function createEndpointMediaPipeline(options) {
               if (!operation || ["rejected", "uncertain", "succeeded"].includes(operation.status)) throw error;
               const receipt = await endpoint.waitForOperation(error.operationId, { signal: controller.signal });
               if (receipt.status !== "succeeded" || receipt.resultError) {
-                const failure2 = receipt.resultError ?? receipt.error;
-                throw new EndpointError(failure2?.message ?? "Attachment delivery requires attention", { code: failure2?.code ?? "OPERATION_UNCERTAIN", status: failure2?.status, retryable: failure2?.retryable ?? false, operationId: error.operationId });
+                const failure = receipt.resultError ?? receipt.error;
+                throw new EndpointError(failure?.message ?? "Attachment delivery requires attention", { code: failure?.code ?? "OPERATION_UNCERTAIN", status: failure?.status, retryable: failure?.retryable ?? false, operationId: error.operationId });
               }
               return receipt.result;
             }
@@ -4090,7 +2698,7 @@ function createEndpointMediaPipeline(options) {
                 await write(flow, owner);
               }
               for (let wait = 1e3; file.attachment?.processingStatus === "processing"; wait = Math.min(wait * 2, 15e3)) {
-                await new Promise((resolve6) => setTimeout(resolve6, wait));
+                await new Promise((resolve3) => setTimeout(resolve3, wait));
                 if (closed || controller.signal.aborted) throw new DOMException("Attachment cancelled", "AbortError");
                 const current = await endpoint.query("get_upload", { uploadId: file.uploadId });
                 if (current.attachment) {
@@ -4272,8 +2880,8 @@ function createInboundHandoffs(input) {
     if (currentEntry(entry)) entries2.delete(entry.handle.id);
   }
   __name(forget, "forget");
-  function owns(entry, record7) {
-    return !!record7 && record7.handoffGeneration === entry.generation && (record7.state === "uncertain" || !record7.lease || record7.lease.owner === entry.leaseOwner);
+  function owns(entry, record6) {
+    return !!record6 && record6.handoffGeneration === entry.generation && (record6.state === "uncertain" || !record6.lease || record6.lease.owner === entry.leaseOwner);
   }
   __name(owns, "owns");
   async function applyDisposition(entry, kind, reason) {
@@ -4361,7 +2969,7 @@ function createInboundHandoffs(input) {
     entries2.set(id2, entry);
     capabilities.set(handle, entry);
     try {
-      const record7 = await store.transaction(async (tx) => {
+      const record6 = await store.transaction(async (tx) => {
         const current = await tx.get(`inbound/${id2}`);
         if (current && await settleInboundProjection(tx, current, now())) return void 0;
         if (!current || current.deleted || current.state === "uncertain" || current.state === "settled") return void 0;
@@ -4377,11 +2985,11 @@ function createInboundHandoffs(input) {
         await tx.put(`inbound/${id2}`, next);
         return next;
       });
-      if (!record7) {
+      if (!record6) {
         forget(entry, "released");
         return null;
       }
-      conversationId = record7.event.conversationId;
+      conversationId = record6.event.conversationId;
       if (closing) {
         await handle.release("consumer-closed");
         return null;
@@ -4403,8 +3011,8 @@ function createInboundHandoffs(input) {
     if (!selected.length || closing || selected.some((entry) => !currentEntry(entry) || entry.phase !== "queued")) return { status: "unavailable" };
     if (selected.some((entry) => entry.transition || entry.request)) return { status: "deferred" };
     let finishClaim;
-    const boundary = new Promise((resolve6) => {
-      finishClaim = resolve6;
+    const boundary = new Promise((resolve3) => {
+      finishClaim = resolve3;
     });
     for (const entry of selected) {
       entry.phase = "claiming";
@@ -4413,11 +3021,11 @@ function createInboundHandoffs(input) {
     let claimed = false;
     try {
       const records = await store.transaction(async (tx) => Promise.all(selected.map((entry) => tx.get(`inbound/${entry.handle.id}`))));
-      await input.assertReady(records.filter((record7) => !!record7));
+      await input.assertReady(records.filter((record6) => !!record6));
       const claim = await store.transaction(async (tx) => {
         if (await tx.get("migration/active")) throw new EndpointError("Migration is incomplete; native execution is gated", { code: "MIGRATION_IN_PROGRESS", retryable: false });
         const current = await Promise.all(selected.map((entry) => tx.get(`inbound/${entry.handle.id}`)));
-        const eligible = current.map((record7, index) => owns(selected[index], record7) && !record7.deleted && record7.state !== "uncertain" && record7.state !== "settled");
+        const eligible = current.map((record6, index) => owns(selected[index], record6) && !record6.deleted && record6.state !== "uncertain" && record6.state !== "settled");
         if (eligible.some((value) => !value)) return { claimed: false, eligible };
         for (let index = 0; index < current.length; index++) {
           const next = { ...current[index], state: "uncertain", updatedAt: now() };
@@ -4442,9 +3050,9 @@ function createInboundHandoffs(input) {
         await store.transaction(async (tx) => {
           for (const entry of selected) {
             if (entry.request) continue;
-            const record7 = await tx.get(`inbound/${entry.handle.id}`);
-            if (!owns(entry, record7) || record7.state !== "uncertain") continue;
-            const next = { ...record7, state: "offered", lease: { owner: entry.leaseOwner, expiresAt: clock() + leaseMs }, updatedAt: now() };
+            const record6 = await tx.get(`inbound/${entry.handle.id}`);
+            if (!owns(entry, record6) || record6.state !== "uncertain") continue;
+            const next = { ...record6, state: "offered", lease: { owner: entry.leaseOwner, expiresAt: clock() + leaseMs }, updatedAt: now() };
             await tx.put(`inbound/${entry.handle.id}`, next);
             await enqueueInbound(tx, next);
           }
@@ -4545,9 +3153,9 @@ function createInboundHandoffs(input) {
       if (!entry) return false;
       if (entry.phase !== "queued" || entry.transition) return true;
       const held = await store.transaction(async (tx) => {
-        const record7 = await tx.get(`inbound/${id2}`);
-        if (!owns(entry, record7) || record7.deleted || record7.state === "settled" || record7.state === "uncertain") return false;
-        await tx.put(`inbound/${id2}`, { ...record7, lease: { owner: entry.leaseOwner, expiresAt: clock() + leaseMs } });
+        const record6 = await tx.get(`inbound/${id2}`);
+        if (!owns(entry, record6) || record6.deleted || record6.state === "settled" || record6.state === "uncertain") return false;
+        await tx.put(`inbound/${id2}`, { ...record6, lease: { owner: entry.leaseOwner, expiresAt: clock() + leaseMs } });
         return true;
       });
       if (!held) forget(entry, "released");
@@ -4666,9 +3274,9 @@ function createExternalInboundClaims(input) {
         if (!current || current.state !== "uncertain" || !claim?.replyIntent || claim.requestId !== requestId || claim.installationGeneration !== generation2 || claim.replyOperationId && claim.replyOperationId !== operationId) {
           throw new EndpointError("Reply no longer belongs to this claim", { code: "INBOUND_CLAIM_CONFLICT", retryable: false });
         }
-        const sealed2 = !!await tx.get(`preparation/${operationId}`) || !!await tx.get(`operation/${operationId}`);
-        if (current.deleted && !sealed2) throw new EndpointError("Reply source was deleted before preparation", { code: "INBOUND_CLAIM_CONFLICT", retryable: false });
-        return { current, claim, generation: generation2, sealed: sealed2 };
+        const sealed = !!await tx.get(`preparation/${operationId}`) || !!await tx.get(`operation/${operationId}`);
+        if (current.deleted && !sealed) throw new EndpointError("Reply source was deleted before preparation", { code: "INBOUND_CLAIM_CONFLICT", retryable: false });
+        return { current, claim, generation: generation2, sealed };
       }, "read");
       const before = await input.store.transaction(read);
       if (before.sealed) return { event: before.current.event, replayed: true };
@@ -4676,8 +3284,8 @@ function createExternalInboundClaims(input) {
       const authored = copyJson(prepared.intent);
       const fingerprint = await input.hash(canonicalEndpointJson({ ...authored, ...input.ownershipVersion !== void 0 ? { ownershipVersion: input.ownershipVersion } : {} }));
       return input.store.transaction(async (tx) => {
-        const { current, claim, generation: generation2, sealed: sealed2 } = await read(tx);
-        if (sealed2) return { event: current.event, replayed: true };
+        const { current, claim, generation: generation2, sealed } = await read(tx);
+        if (sealed) return { event: current.event, replayed: true };
         const event = prepared.event;
         const admissionId = event.data.replyAuthority?.admissionId ?? null;
         if (event.id !== id2 || event.kind !== "message.created" || !event.durable || event.conversationId !== claim.source.conversationId || event.data.message?.id !== claim.source.messageId || admissionId !== claim.source.admissionId || authored.action !== "send_message" || authored.envelope || authored.preconditions || authored.body.conversationId !== claim.source.conversationId || authored.body.replyTo !== claim.source.messageId || authored.body.messageId !== claim.replyIntent.messageId || authored.body.metadata?.turnId !== claim.replyIntent.turnId || canonicalEndpointJson(authored.body.replyAuthority) !== canonicalEndpointJson(event.data.replyAuthority)) {
@@ -4752,7 +3360,7 @@ function same(left, right) {
   return canonicalEndpointJson(left) === canonicalEndpointJson(right);
 }
 __name(same, "same");
-function record2(value, required, optional = []) {
+function record(value, required, optional = []) {
   if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) fail();
   const descriptors = Object.getOwnPropertyDescriptors(value);
   const keys = Reflect.ownKeys(descriptors);
@@ -4765,7 +3373,7 @@ function record2(value, required, optional = []) {
   }
   return result;
 }
-__name(record2, "record");
+__name(record, "record");
 function uuid(value) {
   if (typeof value !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/.test(value)) fail();
   return value;
@@ -4813,7 +3421,7 @@ function createMlsDevDeviceCoordinator(input) {
       return void 0;
     }
     if (snapshot.protocolState === null || raw === void 0 || snapshot.protocolRevision === 0) fail();
-    const stored = record2(snapshot.protocolState, ["version", "binding", "wrappedState", "signaturePublicKey"]);
+    const stored = record(snapshot.protocolState, ["version", "binding", "wrappedState", "signaturePublicKey"]);
     if (stored.version !== 1 || !same(parseMlsDevDeviceBinding(stored.binding), binding)) fail();
     const prepared = parseMlsDevDevicePreparation({
       wrappedState: stored.wrappedState,
@@ -4825,7 +3433,7 @@ function createMlsDevDeviceCoordinator(input) {
       wrappedState: prepared.wrappedState,
       signaturePublicKey: prepared.payload.signaturePublicKey
     };
-    const data = record2(raw, ["version", "binding", "signaturePublicKey"], ["registration", "credential", "generationObservation", "revocation"]);
+    const data = record(raw, ["version", "binding", "signaturePublicKey"], ["registration", "credential", "generationObservation", "revocation"]);
     if (data.version !== 1 || !same(parseMlsDevDeviceBinding(data.binding), binding) || data.signaturePublicKey !== envelope2.signaturePublicKey) fail();
     const metadata = { version: 1, binding, signaturePublicKey: envelope2.signaturePublicKey };
     if (Object.hasOwn(data, "registration")) {
@@ -4893,7 +3501,7 @@ function createMlsDevDeviceCoordinator(input) {
   async function readProof(tx, op, id2) {
     const raw = await tx.get(proofKey(op, id2));
     if (raw === void 0) return void 0;
-    const data = record2(raw, ["command", "request"]);
+    const data = record(raw, ["command", "request"]);
     const command = parseMlsDevDeviceCommand(data.command);
     if (command.op !== op || command.challenge.challengeId !== id2) fail();
     const request = parseComplete(op, data.request);
@@ -5198,12 +3806,26 @@ function parseFlow(value) {
   return fail2();
 }
 __name(parseFlow, "parseFlow");
+var MAX_CHALLENGE_CLOCK_LAG_MS = 3e4;
 function createMlsDevDeviceClient(options, context) {
   const principal = JSON.parse(JSON.stringify(options.principal));
   const { prepareProtected, verifyCredential } = options;
   const transport = context.transport;
   let running;
   let renewalRetryAtMs = 0;
+  async function untilIssued(challenge) {
+    const lag = challenge.issuedAtMs - context.clock();
+    if (lag <= 0 || lag > MAX_CHALLENGE_CLOCK_LAG_MS) return;
+    await new Promise((resolve3) => {
+      const timer = setTimeout(resolve3, lag + 1);
+      context.signal.addEventListener("abort", () => {
+        clearTimeout(timer);
+        resolve3();
+      }, { once: true });
+    });
+    context.assertOpen();
+  }
+  __name(untilIssued, "untilIssued");
   function guardedStore(expected) {
     return { close: /* @__PURE__ */ __name(async () => {
     }, "close"), transaction: /* @__PURE__ */ __name((work) => context.store.transaction(async (tx) => {
@@ -5373,6 +3995,7 @@ function createMlsDevDeviceClient(options, context) {
             await replace({ version: 1, id: context.ids(), goal: "enroll", phase: "enrollment", begin: captured.begin });
             continue;
           }
+          if (!previous2) await untilIssued(captured.challenge);
           const request2 = previous2 ?? await device.prepareEnrollmentProof(captured.challenge);
           const receipt2 = await external(() => http.completeEnrollment(request2, context.signal));
           const view3 = await device.acceptRegistration(captured.challenge.challengeId, receipt2);
@@ -5398,6 +4021,7 @@ function createMlsDevDeviceClient(options, context) {
             await replace({ version: 1, id: context.ids(), goal: "renew", phase: "credential", begin: captured.begin });
             continue;
           }
+          if (!previous2) await untilIssued(captured.challenge);
           const request2 = previous2 ?? await device.prepareCredentialProof(captured.challenge, captured.begin.expectedCredentialGeneration);
           const receipt2 = await external(() => http.completeCredential(request2, context.signal));
           const accepted2 = await device.acceptCredential(captured.challenge.challengeId, receipt2);
@@ -5420,6 +4044,7 @@ function createMlsDevDeviceClient(options, context) {
           await replace(await reconciliation(await device.read()));
           continue;
         }
+        if (!previous) await untilIssued(captured.challenge);
         const request = previous ?? await device.prepareCredentialReconciliationProof(captured.challenge, captured.begin.expectedCredentialGeneration);
         const receipt = await external(() => http.completeReconciliation(request, context.signal));
         const accepted = await device.acceptGenerationObservation(captured.challenge.challengeId, receipt);
@@ -5525,6 +4150,12 @@ function createMlsDevDeviceClient(options, context) {
     return device.acceptRevocation(receipt);
   }
   __name(revoke, "revoke");
+  async function revokeOther(deviceId) {
+    const { coordinator, transport: http } = await initialized();
+    if ((await coordinator(store).read()).registration?.device.deviceId === deviceId) throw new EndpointError("This device leaves by signing out", { code: "MLS_DEV_DEVICE_IS_CURRENT", retryable: false });
+    await http.revokeCredential({ version: 1, deviceId }, context.signal);
+  }
+  __name(revokeOther, "revokeOther");
   function run(goal) {
     context.assertOpen();
     const preceding = running;
@@ -5570,7 +4201,8 @@ function createMlsDevDeviceClient(options, context) {
     renew: /* @__PURE__ */ __name(() => run("renew"), "renew"),
     reconcile: /* @__PURE__ */ __name(() => run("reconcile"), "reconcile"),
     ensureReady: /* @__PURE__ */ __name(() => run("ready"), "ensureReady"),
-    revoke: /* @__PURE__ */ __name(() => context.run(revoke), "revoke")
+    revoke: /* @__PURE__ */ __name(() => context.run(revoke), "revoke"),
+    revokeOther: /* @__PURE__ */ __name((deviceId) => context.run(() => revokeOther(deviceId)), "revokeOther")
   });
 }
 __name(createMlsDevDeviceClient, "createMlsDevDeviceClient");
@@ -5581,20 +4213,20 @@ function fail3(code = "MLS_DEV_KEY_PACKAGE_STATE_INVALID", retryable = false) {
   throw new EndpointError(code, { code, retryable });
 }
 __name(fail3, "fail");
-function record3(value, keys) {
+function record2(value, keys) {
   if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) fail3();
   const fields = Object.getOwnPropertyDescriptors(value);
   if (Reflect.ownKeys(fields).length !== keys.length || keys.some((key) => !Object.hasOwn(fields, key) || !Object.hasOwn(fields[key], "value") || !fields[key].enumerable)) fail3();
   return Object.fromEntries(keys.map((key) => [key, fields[key].value]));
 }
-__name(record3, "record");
+__name(record2, "record");
 function createMlsDevKeyPackageService(options, context, store, initialized, readPrepared) {
   const verifyCredential = options.verifyCredential;
   const fence = /* @__PURE__ */ __name(() => store.transaction(async () => {
   }), "fence");
   const network = /* @__PURE__ */ __name(() => context.transport?.keyPackages ?? fail3("MLS_DEV_KEY_PACKAGE_TRANSPORT_REQUIRED"), "network");
   function parseJournal(raw, binding, current, op) {
-    const value = record3(raw, ["version", "binding", "registration", "request", "receipt"]);
+    const value = record2(raw, ["version", "binding", "registration", "request", "receipt"]);
     const registration = parseMlsDevEnrollmentResult(value.registration);
     if (value.version !== 1 || !same3(parseMlsDevDeviceBinding(value.binding), binding) || !same3(registration, current.registration)) fail3("MLS_DEV_KEY_PACKAGE_BINDING_MISMATCH");
     return {
@@ -5700,7 +4332,7 @@ function createMlsDevKeyPackageService(options, context, store, initialized, rea
       equivalent: /* @__PURE__ */ __name((a, b) => same3({ ...a, claimantCredential: null }, { ...b, claimantCredential: null }), "equivalent"),
       forgetsRefusal: true,
       async make(tx, _binding, current) {
-        const raw = input ?? record3(
+        const raw = input ?? record2(
           (await tx.get("mls-dev-key-package/claim/" + id2))?.request,
           ["version", "requestId", "claimantCredential", "recipientDeviceId", "preconditions"]
         );
@@ -5732,11 +4364,11 @@ function createMlsDevKeyPackageService(options, context, store, initialized, rea
   __name(run, "run");
   return {
     publish(input) {
-      const id2 = parseMlsDevKeyPackageId(record3(input, ["keyPackageId"]).keyPackageId);
+      const id2 = parseMlsDevKeyPackageId(record2(input, ["keyPackageId"]).keyPackageId);
       return run(async () => Object.freeze({ status: "published", receipt: await exchange(id2, true, publication(id2)) ?? fail3() }));
     },
     claim(input) {
-      const data = record3(input, ["requestId", "recipientDeviceId", "preconditions"]);
+      const data = record2(input, ["requestId", "recipientDeviceId", "preconditions"]);
       const frozen = Object.freeze({
         requestId: parseMlsDevKeyPackageId(data.requestId),
         recipientDeviceId: parseMlsDevKeyPackageId(data.recipientDeviceId),
@@ -5813,20 +4445,20 @@ function fail4(code = "MLS_DEV_KEY_PACKAGE_STATE_INVALID", retryable = false) {
 }
 __name(fail4, "fail");
 var same4 = /* @__PURE__ */ __name((a, b) => canonicalEndpointJson(a) === canonicalEndpointJson(b), "same");
-function record4(value, keys) {
+function record3(value, keys) {
   if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) fail4();
   const fields = Object.getOwnPropertyDescriptors(value);
   if (Reflect.ownKeys(fields).length !== keys.length || keys.some((key) => !Object.hasOwn(fields, key) || !Object.hasOwn(fields[key], "value") || !fields[key].enumerable)) fail4();
   return Object.fromEntries(keys.map((key) => [key, fields[key].value]));
 }
-__name(record4, "record");
+__name(record3, "record");
 function boundPayload(command, payload) {
   const claims = parseMlsDevCredentialToken(command.credential).unsigned.claims;
   if (payload.keyPackageId !== command.keyPackageId || payload.deviceId !== claims.device.deviceId || payload.credentialId !== claims.credentialId || payload.credentialGeneration !== claims.generation || payload.signaturePublicKey !== claims.device.signaturePublicKey || payload.ciphersuite !== claims.device.ciphersuite || payload.notBeforeMs < claims.issuedAtMs || payload.expiresAtMs > claims.expiresAtMs) fail4("MLS_DEV_KEY_PACKAGE_BINDING_MISMATCH");
 }
 __name(boundPayload, "boundPayload");
 function intent(value, binding, id2) {
-  const data = record4(value, ["version", "binding", "command", "payload"]);
+  const data = record3(value, ["version", "binding", "command", "payload"]);
   const command = parseMlsDevKeyPackageCommand(data.command), payload = parseMlsDevKeyPackagePayload(data.payload);
   if (data.version !== 1 || !same4(parseMlsDevDeviceBinding(data.binding), binding) || command.keyPackageId !== id2) fail4();
   const device = parseMlsDevCredentialToken(command.credential).unsigned.claims.device;
@@ -5845,7 +4477,7 @@ async function captureMlsDevPreparedKeyPackage(tx, binding, id2, current) {
   const stored = intent(raw, binding, id2);
   await assertMlsDevKeyPackageUnconsumed(tx, id2, stored.payload.keyPackageRef);
   if (!same4(parseMlsDevCredentialToken(stored.command.credential).unsigned.claims.device, current.registration.device)) fail4("MLS_DEV_KEY_PACKAGE_BINDING_MISMATCH");
-  const state = record4(snapshot.protocolState, ["version", "binding", "keyPackageId", "wrappedState", "payload"]);
+  const state = record3(snapshot.protocolState, ["version", "binding", "keyPackageId", "wrappedState", "payload"]);
   const preparation = parseMlsDevKeyPackagePreparation({ wrappedState: state.wrappedState, payload: state.payload });
   if (state.version !== 1 || !same4(parseMlsDevDeviceBinding(state.binding), binding) || state.keyPackageId !== id2 || !same4(preparation.payload, stored.payload)) fail4();
   return {
@@ -5912,7 +4544,7 @@ function createMlsDevKeyPackageClient(options, context) {
     if (historical) {
       const consumed = await tx.get(`mls-dev-key-package/consumed/${id2}`);
       if (consumed !== void 0) {
-        const data = record4(consumed, ["version", "binding", "payload", "conversationId", "groupId", "controlSequence"]);
+        const data = record3(consumed, ["version", "binding", "payload", "conversationId", "groupId", "controlSequence"]);
         const payload = parseMlsDevKeyPackagePayload(data.payload);
         if (data.version !== 1 || !same4(parseMlsDevDeviceBinding(data.binding), binding) || payload.keyPackageId !== id2 || payload.deviceId !== current.registration.device.deviceId || payload.signaturePublicKey !== current.registration.device.signaturePublicKey) fail4();
         return payload;
@@ -6070,7 +4702,7 @@ function createMlsDevKeyPackageClient(options, context) {
   return {
     ...service,
     prepare(input) {
-      const data = record4(input, ["keyPackageId"]);
+      const data = record3(input, ["keyPackageId"]);
       return run(parseMlsDevKeyPackageId(data.keyPackageId), true).then((result) => result ?? fail4());
     },
     read: /* @__PURE__ */ __name((id2) => run(id2, false), "read"),
@@ -6320,6 +4952,27 @@ function mlsDevReplyQuote(value, maximum) {
   return quoted ? [...quoted.trim()].slice(0, maximum).join("") || void 0 : void 0;
 }
 __name(mlsDevReplyQuote, "mlsDevReplyQuote");
+var MLS_DEV_INBOX_PREVIEW_MAX = 200;
+async function readMlsDevInboxPreview(tx, conversationId, messageId) {
+  const value = await tx.get(mlsDevTextMessageKey(conversationId, messageId));
+  if (!value || value.deleted || await tx.get(mlsDevTextDeletedKey(conversationId, messageId)) !== void 0) return void 0;
+  if (value.message.kind === "interaction.request") return { text: value.message.interaction.title, contentType: "text" };
+  const text = mlsDevReplyQuote(value, MLS_DEV_INBOX_PREVIEW_MAX);
+  return text ? { text, contentType: value.message.kind === "item" ? value.message.item.type : "text" } : void 0;
+}
+__name(readMlsDevInboxPreview, "readMlsDevInboxPreview");
+async function overlayMlsDevInboxPreviews(tx, page) {
+  const rows = page?.conversations;
+  if (!Array.isArray(rows)) return page;
+  const conversations = [];
+  for (const row of rows) {
+    const messageId = row.lastMessage?.messageId;
+    const preview = typeof row.id === "string" && typeof messageId === "string" ? await readMlsDevInboxPreview(tx, row.id, messageId) : void 0;
+    conversations.push(preview ? { ...row, lastMessage: { ...row.lastMessage, ...preview } } : row);
+  }
+  return { ...page, conversations };
+}
+__name(overlayMlsDevInboxPreviews, "overlayMlsDevInboxPreviews");
 function projectMlsDevTextMessage(value, account) {
   const message = value.message;
   if (message.kind === "item") return projectMlsDevItemMessage({ ...value, message }, account);
@@ -6435,7 +5088,7 @@ var MLS_ERASED_SENDER_ID = "erased_user";
 var checked = /* @__PURE__ */ new Map();
 var checkKey = /* @__PURE__ */ __name((environmentId, alias, opening) => JSON.stringify([environmentId, alias, opening.type, opening.accountId, opening.salt]), "checkKey");
 var hexBytes = /* @__PURE__ */ __name((hex) => Uint8Array.from(hex.match(/../g) ?? [], (pair) => Number.parseInt(pair, 16)), "hexBytes");
-async function opensMlsAlias(environmentId, alias, opening, hash3) {
+async function opensMlsAlias(environmentId, alias, opening, hash) {
   let value;
   try {
     value = parseMlsPrincipalOpening(opening);
@@ -6446,7 +5099,7 @@ async function opensMlsAlias(environmentId, alias, opening, hash3) {
   const key = checkKey(environmentId, alias, value);
   let opens = checked.get(key);
   if (opens === void 0) {
-    const digest = await hash3(encodeMlsPrincipalAliasInput(environmentId, value));
+    const digest = await hash(encodeMlsPrincipalAliasInput(environmentId, value));
     opens = /^[0-9a-f]{64}$/.test(digest) && MLS_PRINCIPAL_ALIAS_PREFIX + encodeCanonicalMlsBase64Url(hexBytes(digest)) === alias;
     if (checked.size >= 4096) checked.clear();
     checked.set(key, opens);
@@ -6464,8 +5117,8 @@ function openings(room) {
   }
 }
 __name(openings, "openings");
-async function checkMlsRoomOpenings(room, environmentId, hash3) {
-  for (const [alias, opening] of Object.entries(openings(room))) await opensMlsAlias(environmentId, alias, opening, hash3);
+async function checkMlsRoomOpenings(room, environmentId, hash) {
+  for (const [alias, opening] of Object.entries(openings(room))) await opensMlsAlias(environmentId, alias, opening, hash);
 }
 __name(checkMlsRoomOpenings, "checkMlsRoomOpenings");
 function mlsRoomAccounts(room, environmentId) {
@@ -6481,8 +5134,8 @@ function mlsAccountOf(accounts, principal) {
 }
 __name(mlsAccountOf, "mlsAccountOf");
 function mlsAliasOf(accounts, accountId, type, admitted) {
-  const matches2 = [...accounts].filter(([alias, identity]) => identity.accountId === accountId && identity.type === type && (!admitted || admitted.includes(alias))).map(([alias]) => alias);
-  return matches2.length === 1 ? matches2[0] : void 0;
+  const matches = [...accounts].filter(([alias, identity]) => identity.accountId === accountId && identity.type === type && (!admitted || admitted.includes(alias))).map(([alias]) => alias);
+  return matches.length === 1 ? matches[0] : void 0;
 }
 __name(mlsAliasOf, "mlsAliasOf");
 async function primeMlsRoomIdentities(input) {
@@ -6529,6 +5182,11 @@ async function roomRemoval(tx, conversationId) {
   }
 }
 __name(roomRemoval, "roomRemoval");
+async function roomRetired(tx, conversationId) {
+  const room = await tx.get(`conversation/${conversationId}`);
+  return Array.isArray(room?.mlsRetiredDeviceIds) ? room.mlsRetiredDeviceIds : [];
+}
+__name(roomRetired, "roomRetired");
 async function assertRoomOpen(tx, conversationId, roster) {
   const removal = await roomRemoval(tx, conversationId);
   if (removal && removal.status !== "pending") fail6("MLS_DEV_GROUP_CLOSED");
@@ -6545,19 +5203,19 @@ function id(value) {
   return value;
 }
 __name(id, "id");
-function record5(value, required, optional = []) {
+function record4(value, required, optional = []) {
   if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) fail6();
   const descriptors = Object.getOwnPropertyDescriptors(value), fields = Reflect.ownKeys(descriptors);
   if (required.some((key) => !Object.hasOwn(descriptors, key)) || fields.some((key) => typeof key !== "string" || ![...required, ...optional].includes(key) || !Object.hasOwn(descriptors[key], "value") || !descriptors[key].enumerable)) fail6();
   return Object.fromEntries(fields.map((key) => [key, descriptors[key].value]));
 }
-__name(record5, "record");
+__name(record4, "record");
 function envelope(value, binding, conversationId) {
   if (value === null) return null;
-  const data = record5(value, ["version", "binding", "conversationId", "groupId", "wrappedState", "head", "roster", "removed", "pending"], ["protocol"]);
+  const data = record4(value, ["version", "binding", "conversationId", "groupId", "wrappedState", "head", "roster", "removed", "pending"], ["protocol"]);
   if (data.version !== 1 || !same6(parseMlsDevDeviceBinding(data.binding), binding) || data.conversationId !== conversationId || typeof data.removed !== "boolean") fail6();
   const head = data.head === null ? null : parseMlsDevGroupHead(data.head), roster = parseMlsDevGroupRoster(data.roster);
-  const pending = data.pending === null ? null : record5(data.pending, ["operationId", "control"]);
+  const pending = data.pending === null ? null : record4(data.pending, ["operationId", "control"]);
   const control = pending ? parseMlsDevGroupControl(pending.control) : null;
   parseMlsDevGroupPreparation({ wrappedState: data.wrappedState, payload: control ? { kind: "control", control } : { kind: "applied", head: head ?? fail6(), roster, removed: data.removed, consumedKeyPackageId: null } });
   if (control && (control.conversationId !== conversationId || control.groupId !== data.groupId || !same6(control.expectedHead, head))) fail6();
@@ -6579,7 +5237,7 @@ function envelope(value, binding, conversationId) {
 __name(envelope, "envelope");
 function authority(value, conversationId) {
   if (value === void 0) return void 0;
-  const data = record5(value, ["version", "marker", "membershipRevision", "admissionId", "roster", "terminal", "observedSequence"]);
+  const data = record4(value, ["version", "marker", "membershipRevision", "admissionId", "roster", "terminal", "observedSequence"]);
   const parsed = parseMlsDevGroupQueryResult({
     version: data.version,
     conversationId,
@@ -6605,7 +5263,7 @@ function authority(value, conversationId) {
 __name(authority, "authority");
 function recoveryFailure(value, conversationId) {
   if (value === void 0) return void 0;
-  const data = record5(value, ["version", "conversationId", "code", "lastAppliedSequence", "observedAtMs"]);
+  const data = record4(value, ["version", "conversationId", "code", "lastAppliedSequence", "observedAtMs"]);
   if (data.version !== 1 || data.conversationId !== conversationId || !roomRecoveryCodes.some((code) => code === data.code) || !Number.isSafeInteger(data.lastAppliedSequence) || data.lastAppliedSequence < 0 || !Number.isSafeInteger(data.observedAtMs) || data.observedAtMs < 0) fail6();
   return Object.freeze({
     version: 1,
@@ -7208,7 +5866,7 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
   __name(catchUpFeed, "catchUpFeed");
   const canonItemReference = /* @__PURE__ */ __name((item, conversationId, environmentId) => isCanonUploadUrl(item.url, { environmentId, conversationId, uploadId: item.uploadId }) && (item.thumbnailUrl === void 0 || isCanonUploadUrl(item.thumbnailUrl, { environmentId, conversationId, uploadId: item.uploadId, poster: true })), "canonItemReference");
   function itemInput(attachment, caption) {
-    const data = record5(attachment, ["kind", "url", "mimeType", "sizeBytes", "uploadId"], ["fileName", "width", "height", "durationMs", "thumbnailUrl", "processingStatus"]);
+    const data = record4(attachment, ["kind", "url", "mimeType", "sizeBytes", "uploadId"], ["fileName", "width", "height", "durationMs", "thumbnailUrl", "processingStatus"]);
     if (data.processingStatus !== void 0 && data.processingStatus !== null && data.processingStatus !== "ready") fail6("MLS_DEV_ITEM_PROCESSING", true);
     const raw = {
       type: data.kind,
@@ -7240,7 +5898,7 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
   }
   __name(validItem, "validItem");
   function textInput(value) {
-    const data = record5(value, ["conversationId"], ["text", "messageId", "contentType", "mentions", "attachments", "replyTo", "replyToPosition", "metadata", "forwarded", "contactCardUserId"]);
+    const data = record4(value, ["conversationId"], ["text", "messageId", "contentType", "mentions", "attachments", "replyTo", "replyToPosition", "metadata", "forwarded", "contactCardUserId"]);
     const attachments = data.attachments ?? [];
     if (!Array.isArray(attachments) || attachments.length > 1) fail6(Array.isArray(attachments) ? "MLS_DEV_ONE_ITEM_PER_MESSAGE" : "MLS_DEV_TEXT_ONLY");
     const item = attachments.length ? itemInput(attachments[0], data.text) : void 0;
@@ -7260,8 +5918,11 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
     await primeIdentities(conversationId, init);
     return store.transaction(async (tx) => {
       const room = await tx.get(`conversation/${conversationId}`);
-      if (room?.mlsAdmissionHold !== true) return Object.freeze({ held: false, waitingPrincipalIds: Object.freeze([]) });
       const group = envelope((await readPreparationSnapshot(tx, scope4(conversationId))).protocolState, init.binding, conversationId);
+      if (room?.mlsAdmissionHold !== true) {
+        const joining = !!room && !!room.mls && (!group || group.removed);
+        return Object.freeze({ held: joining, waitingPrincipalIds: Object.freeze(joining ? [init.identity.principalId] : []) });
+      }
       const accounts = mlsRoomAccounts(room, init.binding.environmentId);
       const admitted = new Set((group && !group.removed ? group.roster : []).map((entry) => mlsAccountOf(accounts, entry.device.principal)));
       const waiting = [.../* @__PURE__ */ new Set([
@@ -7443,14 +6104,14 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
   }
   __name(aliasedInteraction, "aliasedInteraction");
   function interactionInput(value) {
-    const data = record5(value, ["conversationId"], ["messageId", "operationId", "guardId", "request", "response", "withdraw"]);
+    const data = record4(value, ["conversationId"], ["messageId", "operationId", "guardId", "request", "response", "withdraw"]);
     const conversationId = id(data.conversationId), messageId = data.messageId === void 0 ? void 0 : id(data.messageId);
     const roles = ["request", "response", "withdraw"].filter((role) => data[role] !== void 0);
     if (roles.length !== 1) fail6("INVALID_MLS_DEV_INTERACTION_INPUT");
     try {
       if (data.request !== void 0) {
         if (principal.type !== "ai_agent") fail6("MLS_DEV_INTERACTION_REQUESTER_INVALID");
-        const input = record5(
+        const input = record4(
           data.request,
           ["requestId", "kind", "title", "responderIds", "expiresAtMs"],
           ["details", "options", "multiple", "risk", "allowSession", "scopeKey"]
@@ -7466,7 +6127,7 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
       }
       if (data.response !== void 0) {
         if (principal.type !== "human") fail6("MLS_DEV_INTERACTION_RESPONDER_INVALID");
-        const input = record5(data.response, ["requestId", "agentId"], ["answer", "secret"]);
+        const input = record4(data.response, ["requestId", "agentId"], ["answer", "secret"]);
         const binding = { role: "response", requestId: input.requestId, agentId: input.agentId };
         if (Object.hasOwn(input, "secret") === Object.hasOwn(input, "answer")) fail6("INVALID_MLS_DEV_INTERACTION_INPUT");
         if (Object.hasOwn(input, "answer")) {
@@ -7944,12 +6605,13 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
   async function commitHeldRemoval(conversationId) {
     const init = await initialized();
     const target = await store.transaction(async (tx) => {
-      const removal = await roomRemoval(tx, conversationId);
-      if (removal?.status !== "pending") return void 0;
+      const removal = await roomRemoval(tx, conversationId), retired = await roomRetired(tx, conversationId);
+      if (removal ? removal.status !== "pending" : !retired.length) return void 0;
       const current = await capture(tx, await readPreparationSnapshot(tx, scope4(conversationId)), init, conversationId), group = current.envelope;
-      const held = new Set(removal.pending.flatMap((entry) => entry.deviceIds));
-      if (!group?.head || group.removed || group.pending || current.authority?.terminal || held.has(current.device.registration.device.deviceId)) return void 0;
-      const removedDeviceId = group.roster.map((entry) => entry.device.deviceId).filter((deviceId) => held.has(deviceId)).sort()[0];
+      const held = new Set(removal?.pending.flatMap((entry) => entry.deviceIds)), own = current.device.registration.device.deviceId;
+      if (!group?.head || group.removed || group.pending || current.authority?.terminal || held.has(own)) return void 0;
+      const stays = /* @__PURE__ */ __name((entry) => group.roster.some((other) => other !== entry && other.device.principal.id === entry.device.principal.id), "stays");
+      const removedDeviceId = group.roster.filter((entry) => removal ? held.has(entry.device.deviceId) : entry.device.deviceId !== own && retired.includes(entry.device.deviceId) && stays(entry)).map((entry) => entry.device.deviceId).sort()[0];
       return removedDeviceId ? {
         deviceId: current.device.registration.device.deviceId,
         removedDeviceId,
@@ -8043,7 +6705,7 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
   __name(run, "run");
   const client = {
     createRoom(input) {
-      const data = record5(input, ["conversationId", "name", "memberIds"], ["operationId", "protocol"]);
+      const data = record4(input, ["conversationId", "name", "memberIds"], ["operationId", "protocol"]);
       const conversationId = id(data.conversationId), operationId = id(data.operationId ?? context.ids());
       if (typeof data.name !== "string" || data.name.trim().length > 100) fail6("INVALID_MLS_DEV_GROUP_INPUT");
       if (data.protocol !== void 0 && !isMlsDevTextProtocol(data.protocol)) fail6("MLS_DEV_TEXT_PROTOCOL_UNSUPPORTED");
@@ -8097,15 +6759,15 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
       });
     },
     create: /* @__PURE__ */ __name((input) => {
-      const data = record5(input, ["conversationId"], ["operationId"]);
+      const data = record4(input, ["conversationId"], ["operationId"]);
       return run(() => serializeInboundPreparation(store, id(data.conversationId), () => submit("create", data)));
     }, "create"),
     add: /* @__PURE__ */ __name((input) => {
-      const data = record5(input, ["conversationId", "claimRequestId"], ["operationId"]);
+      const data = record4(input, ["conversationId", "claimRequestId"], ["operationId"]);
       return run(() => serializeInboundPreparation(store, id(data.conversationId), () => submit("add", data)));
     }, "add"),
     remove: /* @__PURE__ */ __name((input) => {
-      const data = record5(input, ["conversationId", "removedDeviceId"], ["operationId"]);
+      const data = record4(input, ["conversationId", "removedDeviceId"], ["operationId"]);
       return run(() => serializeInboundPreparation(store, id(data.conversationId), () => submit("remove", data)));
     }, "remove"),
     refresh: /* @__PURE__ */ __name((value) => run(() => serializeInboundPreparation(store, id(value), () => refresh(id(value)))), "refresh"),
@@ -8120,13 +6782,13 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
     }, false), "heldCurrent"),
     read: /* @__PURE__ */ __name((value) => run(() => read(id(value)), false), "read"),
     readVerifiedMessageBinding: /* @__PURE__ */ __name((input) => {
-      const data = record5(input, ["conversationId", "messageId"]);
+      const data = record4(input, ["conversationId", "messageId"]);
       const conversationId = id(data.conversationId), messageId = id(data.messageId);
       return run(() => readVerifiedMessageBinding(conversationId, messageId), false);
     }, "readVerifiedMessageBinding"),
     readCurrentAudience: /* @__PURE__ */ __name((value) => run(() => serializeInboundPreparation(store, id(value), () => readCurrentAudience(id(value)))), "readCurrentAudience"),
     assertCurrentAudience: /* @__PURE__ */ __name((value) => {
-      const data = record5(value, ["version", "protocol", "conversationId", "groupId", "ownDeviceId", "head", "membershipRevision", "admissionId", "roster", "feedOrdinal"]);
+      const data = record4(value, ["version", "protocol", "conversationId", "groupId", "ownDeviceId", "head", "membershipRevision", "admissionId", "roster", "feedOrdinal"]);
       const expected = JSON.parse(canonicalEndpointJson(data)), conversationId = id(expected.conversationId);
       if (!Number.isSafeInteger(expected.feedOrdinal) || expected.feedOrdinal < 1) fail6("MLS_DEV_AUDIENCE_CHANGED");
       return run(() => serializeInboundPreparation(store, conversationId, async () => {
@@ -8148,12 +6810,12 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
       return run(() => serializeInboundPreparation(store, input.conversationId, () => sendInteraction(input, operationId, guardId)));
     }, "sendInteraction"),
     readInteraction: /* @__PURE__ */ __name(async (value) => {
-      const data = record5(value, ["conversationId", "agentId", "requestId"]);
+      const data = record4(value, ["conversationId", "agentId", "requestId"]);
       const conversationId = id(data.conversationId), agentId = id(data.agentId), requestId = id(data.requestId);
       return run(() => serializeInboundPreparation(store, conversationId, () => readInteraction(conversationId, agentId, requestId)), false);
     }, "readInteraction"),
     openSecretAnswer: /* @__PURE__ */ __name(async (value) => {
-      const data = record5(value, ["conversationId", "requestId"]), conversationId = id(data.conversationId), requestId = id(data.requestId);
+      const data = record4(value, ["conversationId", "requestId"]), conversationId = id(data.conversationId), requestId = id(data.requestId);
       return run(() => serializeInboundPreparation(store, conversationId, () => openSecretAnswer(conversationId, requestId)));
     }, "openSecretAnswer")
   };
@@ -8161,13 +6823,14 @@ function createMlsDevGroups(options, context, keyPackages, bridge) {
     client,
     async commitHeldRemoval(conversationId) {
       const cid = id(conversationId);
-      if ((await store.transaction((tx) => roomRemoval(tx, cid)))?.status !== "pending") return void 0;
+      const due = await store.transaction(async (tx) => (await roomRemoval(tx, cid))?.status === "pending" || (await roomRetired(tx, cid)).length > 0);
+      if (!due) return void 0;
       return run(() => serializeInboundPreparation(store, cid, () => commitHeldRemoval(cid)));
     },
     /** Forwards an encrypted text by re-encryption: this device's own decrypted copy, sent as new text to another
      * encrypted room (mls-payload-v3.md §4). Items and cards are not forwarded yet. */
     forwardText(value, operationId, guardId) {
-      const data = record5(value, ["sourceConversationId", "messageId", "targetConversationId"]);
+      const data = record4(value, ["sourceConversationId", "messageId", "targetConversationId"]);
       const source = id(data.sourceConversationId), messageId = id(data.messageId), target = id(data.targetConversationId);
       const selectedId = id(operationId), selectedGuard = guardId === void 0 ? void 0 : id(guardId);
       return run(async () => {
@@ -8324,7 +6987,7 @@ function createEndpoint(options) {
   const { store, transport } = options;
   const clock = options.clock ?? Date.now;
   const ids = options.ids ?? randomId;
-  const hash3 = options.hash ?? sha256;
+  const hash = options.hash ?? sha256;
   const hashBytes = options.hashBytes ?? sha256Bytes;
   const owner = ids();
   const leaseMs = Math.max(5e3, options.leaseMs ?? 6e4);
@@ -8437,7 +7100,7 @@ function createEndpoint(options) {
   const mlsDevDevice = options.mlsDevDevice ? createMlsDevDeviceClient(options.mlsDevDevice, mlsDevContext) : void 0;
   const mlsDevKeyPackages = options.mlsDevDevice?.prepareProtectedKeyPackage ? createMlsDevKeyPackageClient(options.mlsDevDevice, mlsDevContext) : void 0;
   const mlsDevGroups = options.mlsDevDevice?.prepareProtectedGroup ? createMlsDevGroups(options.mlsDevDevice, mlsDevContext, mlsDevKeyPackages, {
-    hash: hash3,
+    hash,
     hashBytes,
     readRoom,
     resolveProtocol: /* @__PURE__ */ __name((conversationId) => resolveMlsRoomMode(conversationId).then((value) => value.protocol), "resolveProtocol"),
@@ -8466,7 +7129,7 @@ function createEndpoint(options) {
       scheduleAdmission(conversationId, 0);
     }, "controlSettled"),
     // Whatever fetched them (a hint, the reconnect sweep, a send, recovery), the room's local reads show them now.
-    historyChanged: /* @__PURE__ */ __name((conversationId) => queryObserver.invalidate((query, parameters) => parameters.conversationId === conversationId && ["list_messages", "get_messages", "get_runtime_card_state"].includes(query)), "historyChanged"),
+    historyChanged: /* @__PURE__ */ __name((conversationId) => queryObserver.invalidate((query, parameters) => options.localInboxPreviews && query === "list_conversations" || parameters.conversationId === conversationId && ["list_messages", "get_messages", "get_runtime_card_state"].includes(query)), "historyChanged"),
     streamLive: /* @__PURE__ */ __name(() => events.isConnected(), "streamLive")
   }) : void 0;
   async function inMlsEnvironment() {
@@ -8597,13 +7260,14 @@ function createEndpoint(options) {
     if (!mlsDevGroups || await mlsDevGroups.client.read(conversationId)) return;
     if (!isMlsDevTextProtocol((await resolveMlsRoomMode(conversationId, false)).protocol) || await readServerRoomMode() !== "default") return;
     const { installationId } = await initialization;
-    const digest = await hash3(canonicalEndpointJson(["canon.mls.room-birth.v1", installationId, conversationId]));
+    const digest = await hash(canonicalEndpointJson(["canon.mls.room-birth.v1", installationId, conversationId]));
     await mlsDevGroups.client.create({ conversationId, operationId: `mls-birth-${digest.slice(0, 48)}` }).catch((error) => {
       if (!(error instanceof EndpointError) || ["ENDPOINT_CLOSED", "PREPARATION_INSTALLATION_FENCED"].includes(error.code)) throw error;
     });
   }
   __name(createBornGroup, "createBornGroup");
   const admissionRuns = /* @__PURE__ */ new Map(), admitting = /* @__PURE__ */ new Set(), admissionDelays = /* @__PURE__ */ new Map();
+  const announcementsSeen = /* @__PURE__ */ new Map();
   const admissionTimers = /* @__PURE__ */ new Map();
   const ADMISSION_IDLE_MS = 10 * 6e4, CLAIM_JOURNAL_KEEP_MS = 60 * 6e4;
   const admissionUnfinished = /* @__PURE__ */ new Set();
@@ -8635,9 +7299,11 @@ function createEndpoint(options) {
     const missing = [...local?.memberIds ?? [], ...typeof invitee === "string" ? [invitee] : []].some((memberId) => !inRoster.has(memberId)) || admissionUnfinished.has(conversationId);
     if (!missing) admissionDelays.delete(conversationId);
     const delay = admissionDelays.get(conversationId) ?? admissionRetry.initial;
-    const due = (admissionRuns.get(conversationId) ?? -Infinity) + (missing ? delay : ADMISSION_IDLE_MS);
+    const announced = local?.mlsDeviceAnnouncedAtMs;
+    const due = announced !== announcementsSeen.get(conversationId) ? -Infinity : (admissionRuns.get(conversationId) ?? -Infinity) + (missing ? delay : ADMISSION_IDLE_MS);
     if (clock() < due) return missing ? scheduleAdmission(conversationId, due - clock()) : void 0;
     admitting.add(conversationId);
+    announcementsSeen.set(conversationId, announced);
     try {
       admissionRuns.set(conversationId, clock());
       await mlsDevKeyPackages.pruneClaims(clock() - CLAIM_JOURNAL_KEEP_MS);
@@ -9014,7 +7680,7 @@ function createEndpoint(options) {
     observe: events.observe,
     isProtocolReady: /* @__PURE__ */ __name(async (id2) => isMlsDevTextProtocol((await resolveMlsRoomMode(id2)).protocol) ? await mlsDevGroups?.isTextReady(id2) ?? false : void 0, "isProtocolReady")
   });
-  const migration = createEndpointMigration({ store, ready: /* @__PURE__ */ __name(() => initialization, "ready"), query: /* @__PURE__ */ __name((name, parameters) => endpoint.query(name, parameters), "query"), hash: hash3, clock });
+  const migration = createEndpointMigration({ store, ready: /* @__PURE__ */ __name(() => initialization, "ready"), query: /* @__PURE__ */ __name((name, parameters) => endpoint.query(name, parameters), "query"), hash, clock });
   const handoffs = createInboundHandoffs({
     store,
     owner,
@@ -9026,16 +7692,16 @@ function createEndpoint(options) {
     assertCurrent: assertCurrentInstallation,
     assertReady: /* @__PURE__ */ __name(async (records) => {
       if (options.admitRecoveredMessages) {
-        for (const id2 of new Set(records.map((record7) => record7.event.conversationId).filter((id3) => !!id3))) await recovery.assertReady(id2);
+        for (const id2 of new Set(records.map((record6) => record6.event.conversationId).filter((id3) => !!id3))) await recovery.assertReady(id2);
       }
     }, "assertReady")
   });
-  const externalInbound = createExternalInboundClaims({ store, clock, hash: hash3, ownershipVersion: options.identity.ownershipVersion, ready: /* @__PURE__ */ __name(() => initialization, "ready"), assertOpen, assertCurrent: assertCurrentInstallation });
+  const externalInbound = createExternalInboundClaims({ store, clock, hash, ownershipVersion: options.identity.ownershipVersion, ready: /* @__PURE__ */ __name(() => initialization, "ready"), assertOpen, assertCurrent: assertCurrentInstallation });
   const messageGroups = createMessageGroupCoordinator({
     store,
     endpoint: /* @__PURE__ */ __name(() => endpoint, "endpoint"),
     ready: /* @__PURE__ */ __name(() => initialization, "ready"),
-    hash: hash3,
+    hash,
     clock,
     wake: /* @__PURE__ */ __name(() => scheduleRetry(0), "wake"),
     preparationGeneration: /* @__PURE__ */ __name(() => installationGeneration, "preparationGeneration"),
@@ -9183,7 +7849,7 @@ function createEndpoint(options) {
         const index = group?.children.findIndex((child) => child.operationId === operationId) ?? -1;
         const previous = group && index > 0 ? await tx.get(key(group.children[index - 1].operationId)) : void 0;
         if (previous?.status === "rejected" || previous?.status === "succeeded" && !messageGroupChildSucceeded(previous)) {
-          const rejected2 = { ...current, status: "rejected", updatedAt: now(), receipt: {
+          const rejected = { ...current, status: "rejected", updatedAt: now(), receipt: {
             protocol: CANON_ENDPOINT_PROTOCOL,
             operationId,
             installationId: current.installationId,
@@ -9193,12 +7859,12 @@ function createEndpoint(options) {
             updatedAt: now(),
             error: { code: "DEPENDENCY_REJECTED", message: "An earlier part of this reply could not be delivered", retryable: false }
           } };
-          delete rejected2.request;
-          delete rejected2.preparedContent;
-          await tx.put(key(operationId), rejected2);
-          await removeOperationOutbox(tx, rejected2);
-          await settleOperationOrder(tx, rejected2);
-          return { operation: rejected2, acquired: false };
+          delete rejected.request;
+          delete rejected.preparedContent;
+          await tx.put(key(operationId), rejected);
+          await removeOperationOutbox(tx, rejected);
+          await settleOperationOrder(tx, rejected);
+          return { operation: rejected, acquired: false };
         }
         if (!messageGroups.allowed(current.messageGroupId) || !group || index < 0 || group.cancelled || index > 0 && !messageGroupChildSucceeded(previous)) return { operation: current, acquired: false };
       }
@@ -9325,8 +7991,8 @@ function createEndpoint(options) {
       await persistReceipt(operation, receipt);
       return receipt;
     } catch (error) {
-      const failure2 = safeError(error);
-      if (reconcileOnly && failure2.retryable) {
+      const failure = safeError(error);
+      if (reconcileOnly && failure.retryable) {
         await store.transaction(async (tx) => {
           const current = await tx.get(key(operationId));
           if (current?.lease?.owner === owner) {
@@ -9335,17 +8001,17 @@ function createEndpoint(options) {
             await tx.put(key(operationId), next);
           }
         });
-        return deferredReceipt(operation, failure2);
+        return deferredReceipt(operation, failure);
       }
       const updated = await store.transaction(async (tx) => {
         const current = await tx.get(key(operationId));
-        if (!current) throw failure2;
+        if (!current) throw failure;
         if (current.lease?.owner !== owner || terminal(current.status)) return current;
-        const lookupUncertain = resolvingReceipt && !failure2.retryable;
-        const generationUncertain = current.attempted && failure2.code === "PREPARATION_INSTALLATION_FENCED";
-        const contentModeUncertain = current.attempted && checkingContentMode && !failure2.retryable;
-        const guardUncertain = current.attempted && checkingDeliveryGuard && !failure2.retryable;
-        const next = { ...current, status: current.status === "uncertain" || lookupUncertain || generationUncertain || contentModeUncertain || guardUncertain ? "uncertain" : failure2.retryable ? "deferred" : "rejected", updatedAt: now(), nextAttemptAt: clock() + Math.max(failure2.retryAfterMs ?? 0, Math.min(3e4, 1e3 * 2 ** Math.min(current.attempts, 5))) };
+        const lookupUncertain = resolvingReceipt && !failure.retryable;
+        const generationUncertain = current.attempted && failure.code === "PREPARATION_INSTALLATION_FENCED";
+        const contentModeUncertain = current.attempted && checkingContentMode && !failure.retryable;
+        const guardUncertain = current.attempted && checkingDeliveryGuard && !failure.retryable;
+        const next = { ...current, status: current.status === "uncertain" || lookupUncertain || generationUncertain || contentModeUncertain || guardUncertain ? "uncertain" : failure.retryable ? "deferred" : "rejected", updatedAt: now(), nextAttemptAt: clock() + Math.max(failure.retryAfterMs ?? 0, Math.min(3e4, 1e3 * 2 ** Math.min(current.attempts, 5))) };
         delete next.lease;
         if (current.sensitive) {
           delete next.request;
@@ -9355,14 +8021,14 @@ function createEndpoint(options) {
           next.receipt = { protocol: CANON_ENDPOINT_PROTOCOL, operationId: current.operationId, installationId: current.installationId, action: current.action, status: "uncertain", error: {
             code: generationUncertain ? "PREPARATION_INSTALLATION_FENCED" : guardUncertain ? "DELIVERY_GUARD_RECONCILIATION_REQUIRED" : contentModeUncertain ? "CONTENT_MODE_RECONCILIATION_REQUIRED" : "RECEIPT_LOOKUP_REJECTED",
             message: generationUncertain ? "The installation changed before the attempted operation could be reconciled" : contentModeUncertain || guardUncertain ? "The attempted operation requires receipt reconciliation before its outcome is known" : "The attempted operation could not be reconciled with the current credentials",
-            status: failure2.status,
+            status: failure.status,
             retryable: false
           }, createdAt: current.createdAt, updatedAt: now() };
           delete next.request;
           delete next.preparedContent;
           delete next.nextAttemptAt;
-        } else if (!failure2.retryable && current.status !== "uncertain") {
-          next.receipt = { protocol: CANON_ENDPOINT_PROTOCOL, operationId: current.operationId, installationId: current.installationId, action: current.action, status: "rejected", error: { code: failure2.code, message: current.sensitive ? "Sensitive operation could not complete" : failure2.message, status: failure2.status, retryable: false }, createdAt: current.createdAt, updatedAt: now() };
+        } else if (!failure.retryable && current.status !== "uncertain") {
+          next.receipt = { protocol: CANON_ENDPOINT_PROTOCOL, operationId: current.operationId, installationId: current.installationId, action: current.action, status: "rejected", error: { code: failure.code, message: current.sensitive ? "Sensitive operation could not complete" : failure.message, status: failure.status, retryable: false }, createdAt: current.createdAt, updatedAt: now() };
           delete next.nextAttemptAt;
         }
         await tx.put(key(operationId), next);
@@ -9383,8 +8049,8 @@ function createEndpoint(options) {
       if (updated.messageGroupId && terminal(updated.status)) await messageGroups.settled(updated);
       if (terminal(updated.status)) scheduleRetry(0);
       notify(updated);
-      if (failure2.retryable && updated.status !== "uncertain" && !closed) scheduleRetry(Math.max(1e3, (updated.nextAttemptAt ?? clock()) - clock()));
-      return deferredReceipt(updated, failure2);
+      if (failure.retryable && updated.status !== "uncertain" && !closed) scheduleRetry(Math.max(1e3, (updated.nextAttemptAt ?? clock()) - clock()));
+      return deferredReceipt(updated, failure);
     } finally {
       clearInterval(heartbeat);
     }
@@ -9435,7 +8101,7 @@ function createEndpoint(options) {
       }
       const authored = JSON.parse(canonicalEndpointJson(intent2));
       const sensitive = executeOptions.sensitive === true || endpointOperationRequestRetention(authored.action, authored.body, authored.envelope) === "memory";
-      const inputFingerprint = sensitive ? void 0 : await hash3(canonicalEndpointJson({ ...authored, ...identity.ownershipVersion !== void 0 ? { ownershipVersion: identity.ownershipVersion } : {} }));
+      const inputFingerprint = sensitive ? void 0 : await hash(canonicalEndpointJson({ ...authored, ...identity.ownershipVersion !== void 0 ? { ownershipVersion: identity.ownershipVersion } : {} }));
       const previous = await store.transaction(async (tx) => {
         await assertCurrentInstallation(tx);
         return tx.get(key(operationId));
@@ -9487,8 +8153,8 @@ function createEndpoint(options) {
       if (!sensitive && !previous) await reservePreparedIdentity(store, { operationId, action: authored.action, fingerprint: inputFingerprint, installationGeneration });
       const normalized = await prepareEndpointIntent({ intent: authored, previousPreconditions: previous?.preconditions, query: /* @__PURE__ */ __name((name, parameters) => endpoint.query(name, parameters), "query") });
       const routedBody = { ...normalized.body, ...normalized.envelope };
-      const sensitiveFingerprint = sensitive ? await hash3(canonicalEndpointJson({ ...normalized, ...identity.ownershipVersion !== void 0 ? { ownershipVersion: identity.ownershipVersion } : {} })) : void 0;
-      const fingerprint = await hash3(canonicalEndpointJson({ ...sensitive ? { action: normalized.action, preconditions: normalized.preconditions } : normalized, ...identity.ownershipVersion !== void 0 ? { ownershipVersion: identity.ownershipVersion } : {} }));
+      const sensitiveFingerprint = sensitive ? await hash(canonicalEndpointJson({ ...normalized, ...identity.ownershipVersion !== void 0 ? { ownershipVersion: identity.ownershipVersion } : {} })) : void 0;
+      const fingerprint = await hash(canonicalEndpointJson({ ...sensitive ? { action: normalized.action, preconditions: normalized.preconditions } : normalized, ...identity.ownershipVersion !== void 0 ? { ownershipVersion: identity.ownershipVersion } : {} }));
       assertOpen();
       const includePreparedContent = !sensitive && negotiatedCapabilities?.preparedContentVersion === 1;
       const request = {
@@ -9640,7 +8306,7 @@ function createEndpoint(options) {
       return store.transaction((tx) => tx.get(key(operationId)));
     },
     waitForOperation(operationId, waitOptions = {}) {
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve3, reject) => {
         let finished = false;
         let checking = false;
         let poll;
@@ -9654,7 +8320,7 @@ function createEndpoint(options) {
           controller.signal.removeEventListener("abort", abort);
           waitOptions.signal?.removeEventListener("abort", abort);
           if (error) reject(error);
-          else resolve6(receipt);
+          else resolve3(receipt);
         }, "finish");
         const abort = /* @__PURE__ */ __name(() => finish(void 0, new EndpointError("Delivery remains in the endpoint journal for reconciliation", {
           code: "OPERATION_PENDING",
@@ -9739,6 +8405,7 @@ function createEndpoint(options) {
         }
         const result = await transport.query(name, normalized, controller.signal);
         if (name === "mls_interactions") return await accountMlsInteractions(result);
+        if (name === "list_conversations" && options.localInboxPreviews && mlsDevGroups) return await store.transaction((tx) => overlayMlsDevInboxPreviews(tx, result));
         return result;
       }).finally(() => {
         reads.delete(queryKey);
@@ -9773,7 +8440,7 @@ function createEndpoint(options) {
     observeEvents: events.observe,
     createMediaPipeline(bytes, mediaOptions) {
       assertOpen();
-      const pipeline3 = createEndpointMediaPipeline({ endpoint, store, bytes, hash: hash3, ids, clock, background: mediaOptions?.background });
+      const pipeline3 = createEndpointMediaPipeline({ endpoint, store, bytes, hash, ids, clock, background: mediaOptions?.background });
       mediaPipelines2.add(pipeline3);
       return pipeline3;
     },
@@ -9803,14 +8470,14 @@ function createEndpoint(options) {
       await initialization;
       if (typeof input.messageId !== "string" || !input.messageId || typeof input.text !== "string")
         throw new EndpointError("Invalid deferred opening line", { status: 400, code: "INVALID_DEFERRED_OPENER", retryable: false });
-      const digest = await hash3(canonicalEndpointJson(["canon.withheld-opener.v1", input.messageId]));
+      const digest = await hash(canonicalEndpointJson(["canon.withheld-opener.v1", input.messageId]));
       const operationId = `start-opener-${digest.slice(0, 48)}`;
       const body = {
         targetUserId: input.targetUserId,
         opener: { withheld: true, messageId: input.messageId },
         ...input.selection ? { selection: copyJson(input.selection) } : {}
       };
-      const openerFingerprint = await hash3(canonicalEndpointJson([body, input.text]));
+      const openerFingerprint = await hash(canonicalEndpointJson([body, input.text]));
       const recordKey = `${openerPrefix()}/${encodeURIComponent(input.messageId)}`;
       await store.transaction(async (tx) => {
         await assertCurrentInstallation(tx);
@@ -9947,15 +8614,15 @@ function createEndpoint(options) {
       if (!eventIds.length) return false;
       if (options.admitRecoveredMessages) {
         const records = await Promise.all(eventIds.map((id2) => endpoint.getInbound(id2)));
-        for (const id2 of new Set(records.map((record7) => record7?.event.conversationId).filter((id3) => !!id3))) await recovery.assertReady(id2);
+        for (const id2 of new Set(records.map((record6) => record6?.event.conversationId).filter((id3) => !!id3))) await recovery.assertReady(id2);
       }
       return store.transaction(async (tx) => {
         if (await tx.get("migration/active")) throw new EndpointError("Migration is incomplete; native execution is gated", { code: "MIGRATION_IN_PROGRESS", retryable: false });
         const records = await Promise.all(eventIds.map((id2) => tx.get(`inbound/${id2}`)));
         let projection = false;
-        for (const record7 of records) if (record7 && await settleInboundProjection(tx, record7, now())) projection = true;
+        for (const record6 of records) if (record6 && await settleInboundProjection(tx, record6, now())) projection = true;
         if (projection) return false;
-        if (records.some((record7) => !record7 || record7.deleted || record7.externalClaim || record7.handoffGeneration && record7.lease || record7.state === "uncertain" || record7.state === "settled" || record7.lease && !record7.lease.owner.startsWith(`${owner}:`) && record7.lease.expiresAt > clock())) return false;
+        if (records.some((record6) => !record6 || record6.deleted || record6.externalClaim || record6.handoffGeneration && record6.lease || record6.state === "uncertain" || record6.state === "settled" || record6.lease && !record6.lease.owner.startsWith(`${owner}:`) && record6.lease.expiresAt > clock())) return false;
         for (let i = 0; i < records.length; i++) {
           const next = { ...records[i], state: "uncertain", updatedAt: now() };
           delete next.lease;
@@ -10110,7 +8777,7 @@ function createEndpoint(options) {
   return endpoint;
 }
 __name(createEndpoint, "createEndpoint");
-async function matchingRecords(tx, prefix3, options, matches2) {
+async function matchingRecords(tx, prefix3, options, matches) {
   const limit = Math.max(1, Math.min(options.limit ?? 100, 1e3));
   const result = [];
   let after = options.after ? `${prefix3}${options.after}` : void 0;
@@ -10118,7 +8785,7 @@ async function matchingRecords(tx, prefix3, options, matches2) {
     const batch = await tx.scan(prefix3, { after, limit: 100 });
     for (const entry of batch) {
       after = entry.key;
-      if (matches2(entry.value)) result.push(entry.value);
+      if (matches(entry.value)) result.push(entry.value);
       if (result.length === limit) return result;
     }
     if (batch.length < 100) return result;
@@ -10127,9 +8794,9 @@ async function matchingRecords(tx, prefix3, options, matches2) {
 __name(matchingRecords, "matchingRecords");
 
 // ../core/src/endpoint-client.ts
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { homedir } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join2 } from "node:path";
 var mediaPipelines = /* @__PURE__ */ new WeakMap();
 function acquireFileMediaPipeline(endpoint, options, fetchImpl) {
   const existing = mediaPipelines.get(endpoint);
@@ -10139,7 +8806,7 @@ function acquireFileMediaPipeline(endpoint, options, fetchImpl) {
     if (options.endpoint && !options.mediaBytes && !options.mediaDirectory && !options.stateDirectory) {
       throw new Error("An injected Canon cloud endpoint requires durable mediaBytes or a persistent mediaDirectory.");
     }
-    const directory = options.mediaDirectory ?? join4(options.stateDirectory ?? process.env.CANON_ENDPOINT_STATE_DIR ?? join4(process.env.CANON_HOME || join4(homedir(), ".canon"), "endpoint"), "media", identity.installationId);
+    const directory = options.mediaDirectory ?? join2(options.stateDirectory ?? process.env.CANON_ENDPOINT_STATE_DIR ?? join2(process.env.CANON_HOME || join2(homedir(), ".canon"), "endpoint"), "media", identity.installationId);
     const pipeline3 = endpoint.createMediaPipeline(options.mediaBytes ?? createNodeEndpointMediaBytes({ directory, fetch: fetchImpl }));
     if (options.autoDrain !== false) void pipeline3.resumePending();
     return pipeline3;
@@ -10161,7 +8828,7 @@ async function acquireAgentEndpoint(input) {
   }
   const requestedMls = input.options.mlsDev;
   const mls = requestedMls ? await (async () => {
-    const crypto2 = await import("./mls-crypto-Y44BOSEM.js");
+    const crypto2 = await import("./mls-crypto-4DZT2UFH.js");
     const configuration = crypto2.parseMlsDevClientConfiguration(requestedMls.configuration);
     if (configuration.environmentId !== environmentId || baseUrl !== CANON_RUNTIME_ENDPOINT_DEFAULTS[configuration.environmentId]?.apiBaseUrl || configuration.principalIds && !configuration.principalIds.includes(input.principalId) || !Number.isSafeInteger(input.ownershipVersion) || input.ownershipVersion < 0) throw new Error("MLS_DEV_AGENT_CONFIGURATION_BINDING_MISMATCH");
     const custody = requestedMls.custody;
@@ -10190,8 +8857,8 @@ async function acquireAgentEndpoint(input) {
   }
   const streamUrl = input.options.streamUrl ?? Object.entries(CANON_RUNTIME_ENDPOINT_DEFAULTS).find(([id2]) => id2 === environmentId)?.[1]?.streamUrl;
   if (!streamUrl) throw new Error("Canon endpoint requires a streamUrl for this environment.");
-  const directory = input.options.stateDirectory ?? process.env.CANON_ENDPOINT_STATE_DIR ?? join4(process.env.CANON_HOME || join4(homedir(), ".canon"), "endpoint");
-  const namespace = createHash5("sha256").update(`${environmentId}
+  const directory = input.options.stateDirectory ?? process.env.CANON_ENDPOINT_STATE_DIR ?? join2(process.env.CANON_HOME || join2(homedir(), ".canon"), "endpoint");
+  const namespace = createHash2("sha256").update(`${environmentId}
 ${baseUrl}
 ${input.principalId}
 ${input.ownershipVersion}`).digest("hex");
@@ -10933,7 +9600,7 @@ function asCanonApiError(error) {
 }
 __name(asCanonApiError, "asCanonApiError");
 function stableOperationId(...parts) {
-  return createHash6("sha256").update(JSON.stringify(parts)).digest("hex");
+  return createHash3("sha256").update(JSON.stringify(parts)).digest("hex");
 }
 __name(stableOperationId, "stableOperationId");
 function normalizeMessage(raw) {
@@ -11193,14 +9860,14 @@ async function resumeRegistration(options) {
     if (status.status === "rejected") return { status: "rejected", requestId };
     const remaining = deadline - Date.now();
     if (remaining <= 0) return { status: "pending", requestId };
-    await new Promise((resolve6, reject) => {
+    await new Promise((resolve3, reject) => {
       const abort = /* @__PURE__ */ __name(() => {
         clearTimeout(timer);
         reject(signal.reason);
       }, "abort");
       const timer = setTimeout(() => {
         signal?.removeEventListener("abort", abort);
-        resolve6();
+        resolve3();
       }, Math.min(pollIntervalMs, remaining));
       signal?.addEventListener("abort", abort, { once: true });
       if (signal?.aborted) abort();
@@ -11213,7 +9880,7 @@ __name(resumeRegistration, "resumeRegistration");
 import { existsSync, readFileSync as readFileSync2, renameSync, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, mkdirSync } from "node:fs";
 import { closeSync as closeSync2, openSync as openSync2 } from "node:fs";
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { join as join5, resolve as resolve4 } from "node:path";
+import { join as join3, resolve } from "node:path";
 import { homedir as homedir2 } from "node:os";
 
 // ../core/src/process-lock.ts
@@ -11254,15 +9921,15 @@ function claimStaleLockReaper(lockPath) {
 __name(claimStaleLockReaper, "claimStaleLockReaper");
 
 // ../core/src/agent-profiles.ts
-var CANON_DIR = process.env.CANON_HOME ? resolve4(process.env.CANON_HOME) : join5(homedir2(), ".canon");
-var AGENTS_PATH = join5(CANON_DIR, "agents.json");
-var LOCKS_DIR = join5(CANON_DIR, "locks");
-var PENDING_REGISTRATIONS_PATH = join5(CANON_DIR, "pending-registrations.json");
+var CANON_DIR = process.env.CANON_HOME ? resolve(process.env.CANON_HOME) : join3(homedir2(), ".canon");
+var AGENTS_PATH = join3(CANON_DIR, "agents.json");
+var LOCKS_DIR = join3(CANON_DIR, "locks");
+var PENDING_REGISTRATIONS_PATH = join3(CANON_DIR, "pending-registrations.json");
 var AGENTS_JSON_BOOTSTRAP_ENV = "CANON_AGENTS_JSON_BOOTSTRAP";
 function canonPaths(home) {
   if (!home) return { dir: CANON_DIR, agents: AGENTS_PATH, locks: LOCKS_DIR };
-  const dir = resolve4(home);
-  return { dir, agents: join5(dir, "agents.json"), locks: join5(dir, "locks") };
+  const dir = resolve(home);
+  return { dir, agents: join3(dir, "agents.json"), locks: join3(dir, "locks") };
 }
 __name(canonPaths, "canonPaths");
 function normalizeAgentProfile(name, value, source) {
@@ -11429,7 +10096,7 @@ function sameProcess(owner) {
 }
 __name(sameProcess, "sameProcess");
 function isProfileLocked(profile, home) {
-  const lockPath = join5(canonPaths(home).locks, `${profile}.lock`);
+  const lockPath = join3(canonPaths(home).locks, `${profile}.lock`);
   try {
     const lock = parseLock(readFileSync2(lockPath, "utf-8"));
     const pid = lock?.pid;
@@ -11454,7 +10121,7 @@ __name(parseLock, "parseLock");
 function acquireLock(profile, home) {
   const locks = canonPaths(home).locks;
   mkdirSync(locks, { recursive: true });
-  const lockPath = join5(locks, `${profile}.lock`);
+  const lockPath = join3(locks, `${profile}.lock`);
   const token = randomUUID5();
   const payload = JSON.stringify({
     pid: process.pid,
@@ -11506,7 +10173,7 @@ function acquireLock(profile, home) {
 }
 __name(acquireLock, "acquireLock");
 function releaseLock(profile, token, home) {
-  const lockPath = join5(canonPaths(home).locks, `${profile}.lock`);
+  const lockPath = join3(canonPaths(home).locks, `${profile}.lock`);
   if (token) {
     try {
       const lock = parseLock(readFileSync2(lockPath, "utf-8"));
@@ -11803,7 +10470,7 @@ var RuntimeRequestManager = class {
     }
     const key = pendingKey(kind, conversationId, effectiveId);
     const signal = options.signal;
-    return await new Promise((resolve6, reject) => {
+    return await new Promise((resolve3, reject) => {
       let settled = false;
       const finishCommon = /* @__PURE__ */ __name(() => {
         settled = true;
@@ -11829,7 +10496,7 @@ var RuntimeRequestManager = class {
             } catch {
             }
           }
-          resolve6(finalResult);
+          resolve3(finalResult);
         })();
       }, "settle");
       const abort = /* @__PURE__ */ __name((error) => {
@@ -11963,7 +10630,7 @@ var RuntimeRequestManager = class {
       pending.wakeRequested = false;
       return Promise.resolve();
     }
-    return new Promise((resolve6) => {
+    return new Promise((resolve3) => {
       let done = false;
       const finish = /* @__PURE__ */ __name(() => {
         if (done) return;
@@ -11975,7 +10642,7 @@ var RuntimeRequestManager = class {
           current.wake = () => {
           };
         }
-        resolve6();
+        resolve3();
       }, "finish");
       const timer = setTimeout(finish, ms);
       const entry = this.pending.get(key);
@@ -12752,11 +11419,11 @@ function buildRuntimeActivityItemPath(conversationId, agentId, itemId) {
   return `${buildRuntimeActivityPath(conversationId, agentId)}/${runtimeActivityItemKey(itemId)}`;
 }
 __name(buildRuntimeActivityItemPath, "buildRuntimeActivityItemPath");
-function record6(value) {
+function record5(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Expected runtime projection object");
   return value;
 }
-__name(record6, "record");
+__name(record5, "record");
 var PROJECTIONS = /* @__PURE__ */ new Set(["agent-session", "turn-state", "runtime-info", "runtime-activity", "streaming"]);
 function createRTDBClientHandle(client) {
   async function scope5(path) {
@@ -12783,40 +11450,40 @@ function createRTDBClientHandle(client) {
     const target = await scope5(path);
     const clear = method === "remove" || data === null;
     if (target.family === "agent-runtime") {
-      if (clear || record6(data).updatedAt === 0) return client.updateRuntimeStatus({ online: false });
-      const value = record6(data);
+      if (clear || record5(data).updatedAt === 0) return client.updateRuntimeStatus({ online: false });
+      const value = record5(data);
       if (typeof value.clientType !== "string" || !value.clientType) throw new Error("Missing runtime client type");
       return client.updateRuntimeStatus({
         runtime: value.clientType,
         ...typeof value.hostMode === "boolean" ? { hostMode: value.hostMode } : {},
-        ...value.runtimeDescriptor ? { runtimeDescriptor: record6(value.runtimeDescriptor) } : {}
+        ...value.runtimeDescriptor ? { runtimeDescriptor: record5(value.runtimeDescriptor) } : {}
       });
     }
     if (target.family === "agent-session") {
       if (clear) return client.publishRuntimeSession(target.conversationId, "clear");
-      const state = sanitizeAgentSessionSnapshotPatch(record6(data));
+      const state = sanitizeAgentSessionSnapshotPatch(record5(data));
       return client.publishRuntimeSession(target.conversationId, "patch", state);
     }
     if (target.family === "runtime-info") {
       if (clear) return client.publishRuntimeInfo(target.conversationId, "clear");
-      const { updatedAt: _updatedAt, ...info } = record6(data);
+      const { updatedAt: _updatedAt, ...info } = record5(data);
       return client.publishRuntimeInfo(target.conversationId, method === "patch" ? "patch" : "replace", info);
     }
     if (target.family === "runtime-activity") {
       if (clear) return client.publishRuntimeActivity(target.conversationId, target.itemId ? { mode: "remove", itemId: target.itemId } : { mode: "clear" });
       if (!target.itemId) throw new Error("Write one runtime activity item");
-      const item = record6(data);
+      const item = record5(data);
       if (typeof item.id !== "string" || runtimeActivityItemKey(item.id) !== target.itemId) throw new Error("Runtime activity identity mismatch");
       return client.publishRuntimeActivity(target.conversationId, { mode: "upsert", item });
     }
     if (target.family === "streaming") {
       if (clear) return client.clearStreaming(target.conversationId);
-      const { updatedAt: _updatedAt, startedAt: _startedAt, ...patch2 } = record6(data);
+      const { updatedAt: _updatedAt, startedAt: _startedAt, ...patch2 } = record5(data);
       if (Object.keys(patch2).some((key) => !["text", "status", "messageId", "turnId", "blocks"].includes(key))) throw new Error("Unsupported streaming projection field");
       return client.patchRuntimeStreaming(target.conversationId, patch2);
     }
     if (target.family === "turn-state") {
-      const value = clear ? { state: "idle", queueDepth: 0, turnId: null, openedAt: null, turnUpdatedAt: null } : record6(data);
+      const value = clear ? { state: "idle", queueDepth: 0, turnId: null, openedAt: null, turnUpdatedAt: null } : record5(data);
       const { updatedAt: _updatedAt, completedAt: _completedAt, openedAt, turnUpdatedAt, ...turn } = value;
       return client.setRuntimeTurn({
         ...turn,
@@ -13201,12 +11868,12 @@ __name(applyFenceLine, "applyFenceLine");
 function scanFenceState(text, fence) {
   if (!text) return fence;
   const lines = text.split("\n");
-  let open5 = fence;
+  let open3 = fence;
   for (let index = 0; index < lines.length; index += 1) {
     if (index === lines.length - 1 && lines[index] === "") continue;
-    open5 = applyFenceLine(open5, lines[index]);
+    open3 = applyFenceLine(open3, lines[index]);
   }
-  return open5;
+  return open3;
 }
 __name(scanFenceState, "scanFenceState");
 function codePointUtf8Bytes(codePoint) {
@@ -13417,12 +12084,12 @@ __name(sendMessageWithRetryChunked, "sendMessageWithRetryChunked");
 
 // ../core/src/cli-metadata.ts
 import { readFileSync as readFileSync3, realpathSync } from "node:fs";
-import { dirname as dirname2, resolve as resolve5 } from "node:path";
+import { dirname, resolve as resolve2 } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 function isDirectExecution(moduleUrl) {
   const entry = process.argv[1];
   if (!entry) return false;
-  const abs = resolve5(entry);
+  const abs = resolve2(entry);
   let real = abs;
   try {
     real = realpathSync(abs);
@@ -13432,13 +12099,13 @@ function isDirectExecution(moduleUrl) {
 }
 __name(isDirectExecution, "isDirectExecution");
 function readCliPackageVersion(moduleUrl) {
-  let current = dirname2(fileURLToPath(moduleUrl));
+  let current = dirname(fileURLToPath(moduleUrl));
   while (true) {
     try {
-      const manifest = JSON.parse(readFileSync3(resolve5(current, "package.json"), "utf8"));
+      const manifest = JSON.parse(readFileSync3(resolve2(current, "package.json"), "utf8"));
       return typeof manifest.version === "string" ? manifest.version : null;
     } catch {
-      const parent = dirname2(current);
+      const parent = dirname(current);
       if (parent === current) return null;
       current = parent;
     }
@@ -13477,7 +12144,7 @@ function runCli(moduleUrl, main, onError, metadata) {
 __name(runCli, "runCli");
 
 // ../core/src/completed-output-journal.ts
-import { createHash as createHash7, randomUUID as randomUUID7 } from "node:crypto";
+import { createHash as createHash4, randomUUID as randomUUID7 } from "node:crypto";
 import {
   closeSync as closeSync3,
   existsSync as existsSync2,
@@ -13490,12 +12157,13 @@ import {
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join4 } from "node:path";
 function createCompletedOutputJournal(directory, scope5, options) {
   const label = options.label;
-  const folder = join6(directory, createHash7("sha256").update(JSON.stringify(scope5)).digest("hex"));
-  const filename = /* @__PURE__ */ __name((turnId) => join6(folder, `${createHash7("sha256").update(turnId).digest("hex")}.json`), "filename");
+  const folder = join4(directory, createHash4("sha256").update(JSON.stringify(scope5)).digest("hex"));
+  const filename = /* @__PURE__ */ __name((turnId) => join4(folder, `${createHash4("sha256").update(turnId).digest("hex")}.json`), "filename");
   function syncDirectory() {
+    if (process.platform === "win32") return;
     const fd = openSync3(folder, "r");
     try {
       fsyncSync(fd);
@@ -13504,8 +12172,8 @@ function createCompletedOutputJournal(directory, scope5, options) {
     }
   }
   __name(syncDirectory, "syncDirectory");
-  function validate(record7) {
-    if (record7?.version !== 1 || typeof record7.turnId !== "string" || !record7.turnId || typeof record7.conversationId !== "string" || !record7.conversationId || typeof record7.createdAt !== "string" || options.validate && !options.validate(record7)) {
+  function validate(record6) {
+    if (record6?.version !== 1 || typeof record6.turnId !== "string" || !record6.turnId || typeof record6.conversationId !== "string" || !record6.conversationId || typeof record6.createdAt !== "string" || options.validate && !options.validate(record6)) {
       throw new Error(`Invalid completed ${label} output record; operator reconciliation is required`);
     }
   }
@@ -13520,21 +12188,21 @@ function createCompletedOutputJournal(directory, scope5, options) {
       } catch (error) {
         if (error.code !== "ESRCH") continue;
       }
-      const path = join6(folder, name);
-      let record7;
+      const path = join4(folder, name);
+      let record6;
       try {
-        record7 = JSON.parse(readFileSync4(path, "utf8"));
-        validate(record7);
+        record6 = JSON.parse(readFileSync4(path, "utf8"));
+        validate(record6);
       } catch {
         unlinkSync3(path);
         throw new Error(`Incomplete ${label} output write removed; reconcile its native transcript`);
       }
-      const destination = filename(record7.turnId);
-      if (destination !== join6(folder, `${match[1]}.json`)) {
+      const destination = filename(record6.turnId);
+      if (destination !== join4(folder, `${match[1]}.json`)) {
         throw new Error(`Completed ${label} output temporary file identity mismatch`);
       }
       if (existsSync2(destination)) {
-        if (readFileSync4(destination, "utf8") !== JSON.stringify(record7)) {
+        if (readFileSync4(destination, "utf8") !== JSON.stringify(record6)) {
           throw new Error(`Conflicting completed ${label} outputs require reconciliation`);
         }
         unlinkSync3(path);
@@ -13544,11 +12212,11 @@ function createCompletedOutputJournal(directory, scope5, options) {
   }
   __name(recoverTemporaryFiles, "recoverTemporaryFiles");
   return {
-    save(record7) {
-      validate(record7);
+    save(record6) {
+      validate(record6);
       mkdirSync2(folder, { recursive: true, mode: 448 });
-      const path = filename(record7.turnId);
-      const serialized = JSON.stringify(record7);
+      const path = filename(record6.turnId);
+      const serialized = JSON.stringify(record6);
       if (existsSync2(path)) {
         if (readFileSync4(path, "utf8") !== serialized) throw new Error(`Completed ${label} output cannot be replaced`);
         return;
@@ -13576,10 +12244,10 @@ function createCompletedOutputJournal(directory, scope5, options) {
       if (!existsSync2(folder)) return [];
       recoverTemporaryFiles();
       return readdirSync(folder).filter((name) => name.endsWith(".json")).map((name) => {
-        const record7 = JSON.parse(readFileSync4(join6(folder, name), "utf8"));
-        validate(record7);
-        if (filename(record7.turnId) !== join6(folder, name)) throw new Error(`Completed ${label} output identity mismatch`);
-        return record7;
+        const record6 = JSON.parse(readFileSync4(join4(folder, name), "utf8"));
+        validate(record6);
+        if (filename(record6.turnId) !== join4(folder, name)) throw new Error(`Completed ${label} output identity mismatch`);
+        return record6;
       }).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
     },
     remove(turnId) {
@@ -13593,8 +12261,8 @@ function createCompletedOutputJournal(directory, scope5, options) {
   };
 }
 __name(createCompletedOutputJournal, "createCompletedOutputJournal");
-function assertCompletedOutputAudience(record7, current, label) {
-  if (!record7.audience || !current || record7.audience.membershipRevision !== void 0 && record7.audience.membershipRevision !== current.membershipRevision || JSON.stringify([...record7.audience.memberIds].sort()) !== JSON.stringify([...current.memberIds].sort())) {
+function assertCompletedOutputAudience(record6, current, label) {
+  if (!record6.audience || !current || record6.audience.membershipRevision !== void 0 && record6.audience.membershipRevision !== current.membershipRevision || JSON.stringify([...record6.audience.memberIds].sort()) !== JSON.stringify([...current.memberIds].sort())) {
     throw new Error(`Completed ${label} output audience changed; operator reconciliation is required`);
   }
 }
@@ -13602,9 +12270,9 @@ __name(assertCompletedOutputAudience, "assertCompletedOutputAudience");
 
 // src/bounded-file-read.ts
 var BoundedFileReadError = class extends Error {
-  constructor(failure2) {
-    super(failure2);
-    this.failure = failure2;
+  constructor(failure) {
+    super(failure);
+    this.failure = failure;
     this.name = "BoundedFileReadError";
   }
   failure;
@@ -13643,7 +12311,7 @@ var ANTHROPIC_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
   "image/gif",
   "image/webp"
 ]);
-var DEFAULT_MEDIA_CACHE_DIR = join7(CANON_DIR, "media-cache");
+var DEFAULT_MEDIA_CACHE_DIR = join5(CANON_DIR, "media-cache");
 var DEFAULT_MEDIA_MATERIALIZATION_BYTES = 10 * 1024 * 1024;
 var MAX_CANON_MEDIA_BYTES = 100 * 1024 * 1024;
 var MAX_ANTHROPIC_IMAGE_RAW_BYTES = 7 * 1024 * 1024;
@@ -13711,7 +12379,7 @@ function inferExtension(input) {
 }
 __name(inferExtension, "inferExtension");
 function conversationMediaCacheDir(input) {
-  return join7(
+  return join5(
     input.rootDir ?? DEFAULT_MEDIA_CACHE_DIR,
     sanitizeSegment(input.agentId, "agent"),
     sanitizeSegment(input.conversationId, "conversation")
@@ -13727,7 +12395,7 @@ function buildCachePath(input) {
   const fallbackName = `${input.attachment.kind}-${input.index}${extension}`;
   const preferredName = input.attachment.fileName ? sanitizeDownloadFileName(input.attachment.fileName, fallbackName) : fallbackName;
   const fileName = extname(preferredName) ? preferredName : `${preferredName}${extension}`;
-  return join7(
+  return join5(
     conversationMediaCacheDir({ agentId: input.agentId, conversationId: input.conversationId, rootDir }),
     sanitizeSegment(input.messageId, "message"),
     `${String(input.index).padStart(2, "0")}-${fileName}`
@@ -13840,7 +12508,7 @@ async function materializeAttachment(attachment, options) {
     index: options.index ?? 0,
     rootDir: options.rootDir
   });
-  await mkdir3(dirname3(path), { recursive: true });
+  await mkdir2(dirname2(path), { recursive: true });
   const maxBytes = resolveMaxBytes(options.maxBytes);
   const expectedBytes = typeof attachment.sizeBytes === "number" && Number.isSafeInteger(attachment.sizeBytes) && attachment.sizeBytes >= 0 ? attachment.sizeBytes : null;
   if (expectedBytes !== null && expectedBytes > maxBytes) {
@@ -14056,7 +12724,7 @@ async function toAnthropicImageBlock(attachment, options) {
 }
 __name(toAnthropicImageBlock, "toAnthropicImageBlock");
 async function readAnthropicImageBytes(attachment, maxRawBytes) {
-  const handle = await open4(attachment.path, "r");
+  const handle = await open2(attachment.path, "r");
   try {
     return await readBoundedRegularFileHandle(handle, maxRawBytes);
   } catch (error) {
@@ -14162,9 +12830,6 @@ function getCodexImagePath(attachment) {
 __name(getCodexImagePath, "getCodexImagePath");
 
 export {
-  NodeMlsDevCustodyError,
-  createNodeMlsDevCustody,
-  createPortableNodeMlsDevCustody,
   resolveCanonRuntimeConnection,
   verifyCanonRuntimeConnection,
   CanonClient,