@canonmsg/agent-sdk 13.2.0 → 13.2.1

package/dist/chunks/{chunk-5YKGDUJX.js → chunk-HTLKCUQG.js}

@@ -5,7 +5,7 @@ import {
   createHttpEndpointTransport,
   createNodeEndpointStore,
   validateEndpointContentBoundary
-} from "./chunk-YJUPKU47.js";
+} from "./chunk-BPSFHEAA.js";
 import {
   CANON_ENDPOINT_PROTOCOL,
   CANON_VERB_WIRE_SCHEMA_VERSION,
@@ -40,8 +40,6 @@ import {
   isMlsDevTextProtocol,
   isMlsEnvironmentId,
   isMlsPrincipalAlias,
-  logicalMediaBlobId,
-  mergeDeliveryObservation,
   mlsAdmissionWait,
   mlsDevProtocolCarriesCards,
   normalizePublicRuntimeDescriptor,
@@ -102,12 +100,11 @@ import {
   parseMlsPrincipalOpening,
   parseMlsRoomIdentities,
   prepareJsonContent,
-  projectDeliveryStatus,
   projectVerbIntentToWire,
   readMembershipChangeMetadata,
   resolveAllowedUploadMimeType,
   sanitizeDownloadFileName
-} from "./chunk-5WPAB5MB.js";
+} from "./chunk-VIS5WXNH.js";
 
 // src/media.ts
 import { createWriteStream as createWriteStream2 } from "node:fs";
@@ -587,7 +584,6 @@ function endpointIntentOrdering(intent2) {
   const body = { ...intent2.body, ...intent2.envelope };
   if (intent2.action === "consume_runtime_signal") return "independent";
   if (intent2.action === "generate_image") return "provider";
-  if (["append_artifact_command", "retain_artifact_asset"].includes(intent2.action) && typeof body.artifactId === "string") return "artifact";
   if (intent2.action === "session_control" && !body.primitive && typeof body.agentId === "string") {
     const type = body.signal?.type;
     if (type === "interrupt" || type === "stop_and_drop") return "signal";
@@ -609,12 +605,10 @@ async function orderOperation(tx, operation) {
 }
 __name(orderOperation, "orderOperation");
 var outboxKey = /* @__PURE__ */ __name((operation) => operation.queueOrder === void 0 ? `outbox/${operation.operationId}` : `outbox/${ordinal(operation.queueOrder)}/${operation.operationId}`, "outboxKey");
-var artifactOrderingPrefix = /* @__PURE__ */ __name((conversationId, artifactId) => `outbound-artifact-order/${scope(conversationId)}/${scope(artifactId)}/`, "artifactOrderingPrefix");
 var controlOrderingKey = /* @__PURE__ */ __name((operation) => operation.action === "session_control" && operation.conversationId && operation.agentId ? `outbound-control-order/${scope(operation.conversationId)}/${scope(operation.agentId)}/` : void 0, "controlOrderingKey");
 var operationOrderingKey = /* @__PURE__ */ __name((operation) => {
   if (!operation.conversationId || operation.ordering === "independent" || operation.ordering === "provider") return void 0;
   if (operation.ordering === "signal") return controlOrderingKey(operation);
-  if (operation.ordering === "artifact") return artifactOrderingPrefix(operation.conversationId, operation.artifactId ?? "~");
   return operation.ordering === "message" ? `outbound-ack-order/${scope(operation.conversationId)}/${scope(operation.messageId)}/` : `outbound-order/${scope(operation.conversationId)}/`;
 }, "operationOrderingKey");
 var outboundPrefix = /* @__PURE__ */ __name((operation) => operationOrderingKey(operation), "outboundPrefix");
@@ -1106,42 +1100,18 @@ var ROOM_QUERIES = /* @__PURE__ */ new Set([
   "list_voice_sessions",
   "get_voice_session"
 ]);
-var ARTIFACT_QUERIES = /* @__PURE__ */ new Set(["list_artifacts", "get_artifact_log", "get_artifact_asset"]);
 var INBOX_QUERIES = /* @__PURE__ */ new Set(["list_conversations", "get_unread_summary"]);
 var CONTACT_QUERIES = /* @__PURE__ */ new Set(["list_contacts", "get_contact", "list_contact_requests"]);
 var ROOM_OPERATIONS = /* @__PURE__ */ new Set(["send_message", "mls_application", "mls_group_control", "react", "delete_message", "mark_read"]);
-var ARTIFACT_OPERATIONS = /* @__PURE__ */ new Set(["append_artifact_command", "retain_artifact_asset"]);
 function queryAffectedByOperation(operation, query, parameters) {
-  if (ARTIFACT_OPERATIONS.has(operation.action)) {
-    if (operation.status !== "succeeded" || !ARTIFACT_QUERIES.has(query)) return false;
-    return typeof parameters.conversationId !== "string" || !operation.conversationId || parameters.conversationId === operation.conversationId;
-  }
-  if (ARTIFACT_QUERIES.has(query)) return false;
   if (!ROOM_OPERATIONS.has(operation.action)) return true;
   if (operation.status !== "succeeded" && !(operation.action === "mls_application" && ["rejected", "uncertain"].includes(operation.status))) return false;
   return queryAffectedByEvent({ kind: "conversation.changed", data: { conversationId: operation.conversationId } }, query, parameters);
 }
 __name(queryAffectedByOperation, "queryAffectedByOperation");
-function artifactQueryAffected(event, query, parameters) {
-  const conversationId = parameters.conversationId;
-  const sameRoom = typeof conversationId !== "string" || typeof event.data.conversationId !== "string" || event.data.conversationId === conversationId;
-  if (event.kind === "artifact.changed") {
-    if (!sameRoom) return false;
-    return query === "list_artifacts" || typeof parameters.artifactId !== "string" || typeof event.data.artifactId !== "string" || parameters.artifactId === event.data.artifactId;
-  }
-  if (event.kind === "conversation.removed") return sameRoom;
-  if (event.kind === "conversations.changed") {
-    const removed = event.data.removedConversationIds;
-    return Array.isArray(removed) && (typeof conversationId !== "string" || removed.includes(conversationId));
-  }
-  return false;
-}
-__name(artifactQueryAffected, "artifactQueryAffected");
 function queryAffectedByEvent(event, query, parameters) {
-  if (!ROOM_QUERIES.has(query) && !ARTIFACT_QUERIES.has(query) && !INBOX_QUERIES.has(query) && !CONTACT_QUERIES.has(query)) return true;
+  if (!ROOM_QUERIES.has(query) && !INBOX_QUERIES.has(query) && !CONTACT_QUERIES.has(query)) return true;
   if (event.kind === "agent.context" || event.kind.startsWith("replay.")) return true;
-  if (ARTIFACT_QUERIES.has(query)) return artifactQueryAffected(event, query, parameters);
-  if (event.kind === "artifact.changed") return false;
   if (/^contacts?\./.test(event.kind)) return CONTACT_QUERIES.has(query);
   if (!/^(message\.|conversations?\.|voice\.session\.)/.test(event.kind)) return true;
   if (CONTACT_QUERIES.has(query)) return false;
@@ -1172,10 +1142,10 @@ async function prepareEndpointIntent(input) {
   const { intent: intent2 } = input;
   const nested = intent2.action === "verb_execute";
   const action = nested ? intent2.body.verb : intent2.action;
-  if (!["remove_member", "update_member_role", "leave_conversation", "append_artifact_command", "retain_artifact_asset"].includes(String(action))) return intent2;
+  if (!["remove_member", "update_member_role", "leave_conversation"].includes(String(action))) return intent2;
   const body = intentBody(intent2);
   const conversationId = body.conversationId ?? body.targetConversationId;
-  const ownAdmission = ["leave_conversation", "append_artifact_command", "retain_artifact_asset"].includes(String(action));
+  const ownAdmission = action === "leave_conversation";
   const targetUserId = body.targetUserId ?? body.userId ?? body.agentId;
   if (typeof conversationId !== "string" || !ownAdmission && typeof targetUserId !== "string") {
     throw new EndpointError("Membership control requires a conversation and target", { status: 400, code: "INVALID_MEMBERSHIP_CONTROL", retryable: false });
@@ -2035,7 +2005,7 @@ __name(createEndpointMigration, "createEndpointMigration");
 
 // ../endpoint/src/media.ts
 function createEndpointMediaPipeline(options) {
-  const { endpoint, store, bytes, background } = options;
+  const { endpoint, store, bytes } = options;
   const clock = options.clock ?? Date.now;
   const ids = options.ids ?? (() => crypto.randomUUID());
   const leaseMs = Math.max(1e3, options.leaseMs ?? 3e4);
@@ -2090,14 +2060,6 @@ function createEndpointMediaPipeline(options) {
   const listeners = /* @__PURE__ */ new Set();
   let closed = false;
   let foreground = true;
-  let restoredNativeObservations = false;
-  const reconciliation = /* @__PURE__ */ new Map();
-  const observations = /* @__PURE__ */ new Map();
-  let backgroundCapability;
-  let lastServerBackgroundCapability;
-  let serverPreparedContentVersion;
-  const preparationGeneration = background ? endpoint.ready().then(() => readPreparationGeneration(store)) : Promise.resolve(0);
-  void preparationGeneration.catch(() => void 0);
   let timer;
   const prefix3 = "media-flow/";
   const attachmentFor = /* @__PURE__ */ __name((file, value, resultUploadId) => {
@@ -2117,7 +2079,6 @@ function createEndpointMediaPipeline(options) {
       for (const file of previous?.files ?? []) if (file.uploadId && !currentIds.has(file.uploadId)) await tx.delete(`media-prepared-upload/${file.uploadId}`);
       for (const uploadId of currentIds) await tx.put(`media-prepared-upload/${uploadId}`, { id: flow.id });
     }
-    if (flow.status === "succeeded" || flow.status === "cancelled") delete flow.preparedContent;
     await tx.put(`${prefix3}${flow.id}`, flow);
     if (flow.status === "pending" || flow.status === "sending") await tx.put(`media-pending/${flow.id}`, { id: flow.id });
     else await tx.delete(`media-pending/${flow.id}`);
@@ -2158,10 +2119,6 @@ function createEndpointMediaPipeline(options) {
     timer.unref?.();
   }
   __name(schedule, "schedule");
-  const stopConnections = background ? endpoint.observeEvents?.(() => void 0, { families: ["messages"], onConnected: /* @__PURE__ */ __name(() => {
-    for (const state of reconciliation.values()) state.nextAt = Math.min(state.nextAt, clock() + 5e3);
-    schedule();
-  }, "onConnected") }) : void 0;
   const unsubscribe = endpoint.subscribe((operation) => {
     if (operation.status === "succeeded" && operation.action.endsWith("_upload")) schedule();
   });
@@ -2170,265 +2127,21 @@ function createEndpointMediaPipeline(options) {
     await Promise.allSettled(flow.files.filter((file) => file.reference).map((file) => bytes.release(file.reference)));
   }
   __name(release, "release");
-  function probeBackgroundCapability() {
-    if (!background) return Promise.resolve(false);
-    if (!backgroundCapability) {
-      const check = Promise.resolve().then(() => Promise.all([background.available(), endpoint.capabilities()])).then(([nativeAvailable, capabilities]) => {
-        if (capabilities) serverPreparedContentVersion = capabilities.preparedMediaContentVersion;
-        if (capabilities) lastServerBackgroundCapability = capabilities.actions.includes("stage_media_message") && (background.observationVersion !== 2 || capabilities.mediaDeliveryObservationVersion === 2);
-        return nativeAvailable && lastServerBackgroundCapability === true;
-      }).catch(() => false).then((enabled) => {
-        if (!enabled && backgroundCapability === check) backgroundCapability = void 0;
-        return enabled;
-      });
-      backgroundCapability = check;
-    }
-    return backgroundCapability;
-  }
-  __name(probeBackgroundCapability, "probeBackgroundCapability");
   const encryptedRoom = /* @__PURE__ */ __name(async (conversationId) => await endpoint.getConversationContentMode(conversationId) !== "plaintext", "encryptedRoom");
-  async function canSendInBackground(options2) {
-    if (!background) return false;
-    if (options2?.conversationId !== void 0 && await encryptedRoom(options2.conversationId).catch(() => true)) return false;
-    if (options2?.maxProbeWaitMs === void 0) return probeBackgroundCapability();
-    const nativeAvailable = await Promise.resolve().then(() => background.available()).catch(() => false);
-    if (!nativeAvailable) return false;
-    if (lastServerBackgroundCapability === false) {
-      void probeBackgroundCapability();
-      return false;
-    }
-    const check = probeBackgroundCapability();
-    const waitMs = Math.max(0, options2.maxProbeWaitMs);
-    if (waitMs === 0) return false;
-    return new Promise((resolve3) => {
-      const timer2 = setTimeout(() => resolve3(false), waitMs);
-      void check.then((enabled) => {
-        clearTimeout(timer2);
-        resolve3(enabled);
-      });
-    });
-  }
-  __name(canSendInBackground, "canSendInBackground");
-  async function applyBackgroundSnapshot(snapshot) {
-    if (closed || !background) return;
-    const flow = await read(snapshot.deliveryId);
-    if (!flow || flow.deliveryMode !== "background") return;
-    if (snapshot.schemaVersion === 2) {
-      const identity = await endpoint.ready();
-      if (!snapshot.identity || snapshot.identity.installationId !== identity.installationId || snapshot.identity.environmentId !== identity.environmentId || snapshot.identity.conversationId !== flow.conversationId || snapshot.identity.messageId !== flow.messageId) {
-        schedule();
-        return;
-      }
-    }
-    const owner = await acquire(flow.id).catch(() => null);
-    if (!owner) {
-      schedule();
-      return;
-    }
-    try {
-      const current = await read(flow.id);
-      if (!current || current.deliveryMode !== "background" || current.status === "succeeded" || current.status === "cancelled") return;
-      if (snapshot.schemaVersion === 2) {
-        const identity = await endpoint.ready();
-        if (snapshot.observation) current.observation = mergeDeliveryObservation(current.observation, snapshot.observation, {
-          deliveryId: flow.id,
-          conversationId: flow.conversationId,
-          messageId: flow.messageId,
-          installationId: identity.installationId,
-          environmentId: identity.environmentId
-        });
-        current.attention = snapshot.attention;
-        const phase = ["published", "cancelled", "expired", "rejected"].includes(snapshot.status) ? "idle" : snapshot.status;
-        current.status = projectDeliveryStatus(current.observation?.outcome ?? "unknown", phase);
-        current.background = { phase: snapshot.status, uploadedBytes: Math.max(0, snapshot.uploadedBytes), totalBytes: Math.max(0, snapshot.totalBytes) };
-        if (current.attention) current.error = { code: current.attention.code, message: snapshot.errorMessage ?? "Delivery needs attention. Its server outcome is being checked." };
-        else delete current.error;
-      } else {
-        current.background = {
-          phase: snapshot.status,
-          uploadedBytes: Math.max(0, snapshot.uploadedBytes),
-          totalBytes: Math.max(0, snapshot.totalBytes)
-        };
-        if (snapshot.status === "published") {
-          current.status = "succeeded";
-          delete current.error;
-        } else if (snapshot.status === "cancelled") {
-          current.status = "cancelled";
-          delete current.error;
-        } else if (snapshot.status === "expired" || snapshot.status === "rejected") {
-          current.status = "rejected";
-          current.error = { code: snapshot.errorCode ?? (snapshot.status === "expired" ? "MEDIA_BACKGROUND_EXPIRED" : "MEDIA_BACKGROUND_REJECTED"), message: snapshot.errorMessage ?? "Attachment delivery needs attention" };
-        } else {
-          current.status = snapshot.status === "sending" ? "sending" : "pending";
-          delete current.error;
-        }
-      }
-      await write(current, owner);
-      if (current.status === "succeeded" || current.status === "cancelled") {
-        delete current.attention;
-        delete current.error;
-        await Promise.allSettled(current.files.filter((file) => file.descriptor.cleanupAfterSend).map((file) => background.cleanupSource?.(file.reference)));
-        await write({ ...current, message: {}, files: [] }, owner);
-      }
-      if (current.status === "pending" || current.status === "sending") schedule();
-    } finally {
-      await unlock(flow.id, owner);
-    }
-  }
-  __name(applyBackgroundSnapshot, "applyBackgroundSnapshot");
-  async function authoritativeSnapshot(id2) {
-    if (!background?.reconcile || !foreground) return void 0;
-    const state = reconciliation.get(id2) ?? { nextAt: 0, failures: 0 };
-    if (state.pending) return state.pending;
-    if (clock() < state.nextAt) {
-      schedule();
-      return void 0;
-    }
-    state.nextAt = clock() + 5e3;
-    const pending = background.reconcile(id2).then((snapshot) => {
-      state.failures = 0;
-      state.nextAt = clock() + 5e3;
-      return snapshot;
-    }, (error) => {
-      state.failures += 1;
-      state.nextAt = clock() + Math.min(3e5, 5e3 * 2 ** Math.min(6, state.failures));
-      schedule();
-      throw error;
-    }).finally(() => {
-      delete state.pending;
-    });
-    state.pending = pending;
-    reconciliation.set(id2, state);
-    return pending;
-  }
-  __name(authoritativeSnapshot, "authoritativeSnapshot");
-  async function resumeBackground(flow, onProgress) {
-    if (!background) throw new EndpointError("This delivery needs a Canon version with background transfer support", { code: "MEDIA_BACKGROUND_MODULE_UNAVAILABLE", retryable: false });
+  async function retireBackground(flow) {
     if (flow.status === "succeeded") return flow.messageId;
-    if (flow.status === "cancelled") throw new EndpointError("Attachment was cancelled", { code: "MEDIA_FLOW_CANCELLED", retryable: false });
-    const snapshots = await background.inspect();
-    let snapshot = snapshots.find((item) => item.deliveryId === flow.id);
-    if (!snapshot && flow.background?.phase === "cancelling") {
-      throw new EndpointError("Cancellation is being reconciled", { code: "MEDIA_CANCELLING", retryable: true });
-    }
-    if (!snapshot) {
-      const identity = await endpoint.ready();
-      snapshot = await background.enqueue({
-        deliveryId: flow.id,
-        installationId: identity.installationId,
-        conversationId: flow.conversationId,
-        messageId: flow.messageId,
-        message: copyJson(flow.message),
-        ...flow.preparedContent ? { preparedContent: copyJson(flow.preparedContent) } : {},
-        files: flow.files.map((file) => ({ source: file.reference, descriptor: copyJson(file.descriptor) }))
-      });
-    }
-    await applyBackgroundSnapshot(snapshot);
-    if (background.reconcile) {
-      const authoritative = await authoritativeSnapshot(flow.id).catch(() => void 0);
-      if (authoritative) {
-        snapshot = authoritative;
-        await applyBackgroundSnapshot(snapshot);
-      }
-      schedule();
-    }
-    if (snapshot.schemaVersion !== 2 && (snapshot.status === "expired" || snapshot.status === "rejected")) {
-      throw new EndpointError(snapshot.errorMessage ?? "Attach this file again to send it", {
-        code: snapshot.errorCode ?? (snapshot.status === "expired" ? "MEDIA_BACKGROUND_EXPIRED" : "MEDIA_BACKGROUND_REJECTED"),
-        retryable: false
-      });
-    }
-    const phase = snapshot.status === "waiting_for_connection" ? "waiting_for_connection" : snapshot.status === "cancelling" ? "cancelling" : snapshot.status === "sending" || snapshot.status === "published" ? "sending" : snapshot.status === "uploading" ? "uploading" : "preparing";
-    onProgress?.({ phase, uploadedBytes: snapshot.uploadedBytes, totalBytes: snapshot.totalBytes });
-    return flow.messageId;
-  }
-  __name(resumeBackground, "resumeBackground");
-  async function stageBackground(input, sendOptions) {
-    if (!background) throw new Error("Background media adapter is missing");
-    const id2 = flowId(input.conversationId, input.messageId);
-    const existing = staging.get(id2);
-    if (existing) {
-      await existing;
-      return stageBackground(input, sendOptions);
-    }
-    const staged = (async () => {
-      if (closed || sendOptions?.signal?.aborted) throw new DOMException("Attachment cancelled", "AbortError");
-      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 {
-        if (closed || sendOptions?.signal?.aborted) throw new DOMException("Attachment cancelled", "AbortError");
-        const prior = await read(id2);
-        if (prior) {
-          if (prior.deliveryMode !== "background" || prior.fingerprint !== fingerprint) throw new EndpointError("Message identity already belongs to another attachment", { status: 409, code: "MEDIA_FLOW_CONFLICT", retryable: false });
-        } else {
-          const flow = {
-            id: id2,
-            conversationId: input.conversationId,
-            messageId: input.messageId,
-            message: copyJson(input.message),
-            fingerprint,
-            createdAt: new Date(clock()).toISOString(),
-            files: input.files.map((file) => ({ descriptor: copyJson(file.descriptor), reference: background.sourceIdentity(file.source) })),
-            deliveryMode: "background",
-            status: "pending",
-            background: { phase: "preparing", uploadedBytes: 0, totalBytes: input.files.reduce((sum, file) => sum + file.descriptor.sizeBytes, 0) }
-          };
-          if (background.preparedContentVersion === 1 && serverPreparedContentVersion === 1) {
-            const generation2 = await preparationGeneration;
-            const operationId = `media:${id2}`;
-            await reservePreparedIdentity(store, { operationId, action: "send_message", fingerprint, installationGeneration: generation2 });
-            const committed = await prepareAndCommitContent({
-              store,
-              scope: input.conversationId,
-              installationGeneration: generation2,
-              existing: /* @__PURE__ */ __name((tx) => tx.get(`${prefix3}${id2}`), "existing"),
-              prepare: /* @__PURE__ */ __name(async (snapshot) => ({ nextProtocolState: snapshot.protocolState, payload: prepareJsonContent({
-                context: { action: "send_message", conversationId: input.conversationId, messageId: input.messageId },
-                body: { ...input.message, conversationId: input.conversationId, messageId: input.messageId },
-                blobs: input.files.map((_, index) => ({ id: logicalMediaBlobId(input.conversationId, input.messageId, index), index })),
-                expected: { installationGeneration: generation2, protocolRevision: snapshot.protocolRevision, ...snapshot.admission ? { admission: snapshot.admission } : {} }
-              }) }), "prepare"),
-              commit: /* @__PURE__ */ __name(async (tx, preparedContent) => {
-                if (closed || sendOptions?.signal?.aborted) throw new DOMException("Attachment cancelled", "AbortError");
-                const sealed = { ...flow, preparedContent };
-                await writeInTransaction(tx, sealed, owner);
-                await tx.delete(`preparation/${operationId}`);
-                return sealed;
-              }, "commit")
-            });
-            notifyFlow(committed);
-          } else await write(flow, owner);
-        }
-      } finally {
-        await unlock(id2, owner);
-      }
-      const onAbort = /* @__PURE__ */ __name(() => {
-        void pipeline3.cancel(id2).catch(() => void 0);
-      }, "onAbort");
-      sendOptions?.signal?.addEventListener("abort", onAbort, { once: true });
+    if (flow.status !== "cancelled") {
+      const owner = await acquire(flow.id);
       try {
-        if (sendOptions?.signal?.aborted) onAbort();
-        return await resumeBackground(await read(id2), sendOptions?.onProgress);
+        const { id: id2, conversationId, messageId, createdAt, deliveryMode } = flow;
+        await write({ id: id2, conversationId, messageId, createdAt, deliveryMode, message: {}, files: [], status: "cancelled" }, owner);
       } finally {
-        sendOptions?.signal?.removeEventListener("abort", onAbort);
+        await unlock(flow.id, owner);
       }
-    })();
-    staging.set(id2, staged);
-    try {
-      return await staged;
-    } finally {
-      if (staging.get(id2) === staged) staging.delete(id2);
     }
+    throw new EndpointError("Attachment was cancelled", { code: "MEDIA_FLOW_CANCELLED", retryable: false });
   }
-  __name(stageBackground, "stageBackground");
-  const stopBackground = background?.subscribe((snapshot) => {
-    const next = (observations.get(snapshot.deliveryId) ?? Promise.resolve()).then(() => applyBackgroundSnapshot(snapshot)).catch(() => schedule());
-    observations.set(snapshot.deliveryId, next);
-    void next.finally(() => {
-      if (observations.get(snapshot.deliveryId) === next) observations.delete(snapshot.deliveryId);
-    });
-  });
+  __name(retireBackground, "retireBackground");
   async function stage(input, sendOptions, prepareOnly = false) {
     if (closed) throw new Error("Endpoint media pipeline is closed");
     const id2 = flowId(input.conversationId, input.messageId);
@@ -2470,7 +2183,7 @@ function createEndpointMediaPipeline(options) {
             files.push({ descriptor: copyJson(file.descriptor), reference: await bytes.retain(`${id2}:${fingerprint}:${index}`, file.source) });
           }
           checkOpen();
-          await write({ id: id2, ...prepareOnly ? { purpose: "prepare" } : {}, conversationId: input.conversationId, messageId: input.messageId, fingerprint, createdAt: new Date(clock()).toISOString(), ...sendOptions?.beforePublish ? { requiresPublicationApproval: true } : {}, message: copyJson(input.message), files, deliveryMode: "legacy", status: "pending" }, owner);
+          await write({ id: id2, ...prepareOnly ? { purpose: "prepare" } : {}, conversationId: input.conversationId, messageId: input.messageId, fingerprint, createdAt: new Date(clock()).toISOString(), ...sendOptions?.beforePublish ? { requiresPublicationApproval: true } : {}, message: copyJson(input.message), files, status: "pending" }, owner);
         }
       } catch (error) {
         await Promise.allSettled(files.map((file) => bytes.release(file.reference)));
@@ -2492,18 +2205,9 @@ function createEndpointMediaPipeline(options) {
   }
   __name(stage, "stage");
   const pipeline3 = {
-    canSendInBackground,
     async send(input, sendOptions) {
-      const id2 = flowId(input.conversationId, input.messageId);
-      const prior = await read(id2);
-      if (prior?.deliveryMode === "background") return stageBackground(input, sendOptions);
-      if (!prior && !sendOptions?.beforePublish && sendOptions?.handoffMode !== "legacy") {
-        const encrypted = await encryptedRoom(input.conversationId);
-        if (encrypted && sendOptions?.handoffMode === "background") {
-          throw new EndpointError("An encrypted room's attachments are prepared on this device", { code: "MEDIA_BACKGROUND_UNAVAILABLE", retryable: false });
-        }
-        if (!encrypted && (sendOptions?.handoffMode === "background" || await canSendInBackground())) return stageBackground(input, sendOptions);
-      }
+      const prior = await read(flowId(input.conversationId, input.messageId));
+      if (prior?.deliveryMode === "background") return retireBackground(prior);
       return stage(input, sendOptions);
     },
     async prepare(input, prepareOptions) {
@@ -2515,7 +2219,7 @@ function createEndpointMediaPipeline(options) {
     },
     async resume(id2, resumeOptions) {
       const persisted = await read(id2);
-      if (persisted?.deliveryMode === "background") return resumeBackground(persisted, resumeOptions?.onProgress);
+      if (persisted?.deliveryMode === "background") return retireBackground(persisted);
       installGuard(id2, resumeOptions?.beforePublish);
       const existing = running.get(id2);
       if (existing) return existing;
@@ -2771,15 +2475,6 @@ function createEndpointMediaPipeline(options) {
     },
     async resumePending() {
       if (closed) return;
-      if (background?.reconcile && !restoredNativeObservations) {
-        restoredNativeObservations = true;
-        try {
-          for (const snapshot of await background.inspect()) await applyBackgroundSnapshot(snapshot);
-        } catch {
-          restoredNativeObservations = false;
-          schedule();
-        }
-      }
       let after;
       do {
         const records = await store.transaction((tx) => tx.scan("media-pending/", { after, limit: 100 }));
@@ -2793,20 +2488,9 @@ function createEndpointMediaPipeline(options) {
       if (saved) await pipeline3.cancel(saved.id);
     },
     async cancel(id2) {
-      const backgroundFlow = await read(id2);
-      if (backgroundFlow?.deliveryMode === "background") {
-        if (!background || backgroundFlow.status === "succeeded" || backgroundFlow.status === "cancelled") return;
-        const owner2 = await acquire(id2);
-        try {
-          const current = await read(id2);
-          if (!current || current.status === "succeeded" || current.status === "cancelled") return;
-          current.background = { phase: "cancelling", uploadedBytes: current.background?.uploadedBytes ?? 0, totalBytes: current.background?.totalBytes ?? 0 };
-          await write(current, owner2);
-        } finally {
-          await unlock(id2, owner2);
-        }
-        await background.cancel(id2);
-        schedule();
+      const retired = await read(id2);
+      if (retired?.deliveryMode === "background") {
+        await retireBackground(retired).catch(() => void 0);
         return;
       }
       if (staging.has(id2)) cancelledStages.add(id2);
@@ -2829,15 +2513,12 @@ function createEndpointMediaPipeline(options) {
     async close(closeOptions) {
       closed = true;
       unsubscribe();
-      stopConnections?.();
-      stopBackground?.();
       listeners.clear();
       for (const guard of publicationGuards.values()) guard.unregister();
       publicationGuards.clear();
       if (timer) clearTimeout(timer);
       for (const controller of controllers.values()) controller.abort();
       await Promise.allSettled([...staging.values(), ...running.values()]);
-      if (closeOptions?.discard) await background?.cleanup();
       if (closeOptions?.discard) {
         let after;
         do {
@@ -3412,13 +3093,6 @@ function createExternalInboundClaims(input) {
 }
 __name(createExternalInboundClaims, "createExternalInboundClaims");
 
-// ../endpoint/src/artifact-context.ts
-var contexts = /* @__PURE__ */ new WeakMap();
-function registerArtifactEndpoint(endpoint, context) {
-  contexts.set(endpoint, context);
-}
-__name(registerArtifactEndpoint, "registerArtifactEndpoint");
-
 // ../endpoint/src/receipts.ts
 function endpointReceiptResult(receipt) {
   if (receipt.resultError) throw new EndpointError(receipt.resultError.message, { status: receipt.resultError.status, code: receipt.resultError.code, retryable: receipt.resultError.retryable, operationId: receipt.operationId });
@@ -7931,6 +7605,51 @@ function createEndpoint(options) {
     }
   }
   __name(refreshMlsRoomFromHint, "refreshMlsRoomFromHint");
+  const roomHints = /* @__PURE__ */ new Map();
+  let roomHintWorker;
+  function queueRoomHint(key3, run, last = false) {
+    if (closed) return Promise.resolve();
+    let hint = roomHints.get(key3);
+    if (hint && last) roomHints.delete(key3);
+    if (!hint) {
+      let settle;
+      const done = new Promise((resolve3, reject) => {
+        settle = /* @__PURE__ */ __name((error) => error === void 0 ? resolve3() : reject(error), "settle");
+      });
+      done.catch(() => void 0);
+      hint = { run, done, settle };
+    }
+    roomHints.set(key3, hint);
+    drainRoomHints();
+    return hint.done;
+  }
+  __name(queueRoomHint, "queueRoomHint");
+  function drainRoomHints() {
+    if (roomHintWorker) return;
+    roomHintWorker = (async () => {
+      for (const [key3, hint] of roomHints) {
+        roomHints.delete(key3);
+        if (closed) {
+          hint.settle();
+          continue;
+        }
+        try {
+          await hint.run();
+          hint.settle();
+        } catch (error) {
+          hint.settle(error);
+        }
+      }
+    })().finally(() => {
+      roomHintWorker = void 0;
+      if (roomHints.size) drainRoomHints();
+    });
+  }
+  __name(drainRoomHints, "drainRoomHints");
+  const hintRoom = /* @__PURE__ */ __name((conversationId) => queueRoomHint(`room/${conversationId}`, async () => {
+    await refreshMlsRoomFromHint(conversationId);
+    await sendDeferredOpeners(conversationId);
+  }), "hintRoom");
   const queryObserver = createEndpointQueryObserver({ query: /* @__PURE__ */ __name((name, parameters) => endpoint.query(name, parameters), "query"), getPollInterval: /* @__PURE__ */ __name(() => events.isConnected() ? Math.max(options.queryIntervalMs ?? 0, 6e4) : options.queryIntervalMs ?? 3e3, "getPollInterval") });
   const invalidateEvent = /* @__PURE__ */ __name((event) => queryObserver.invalidate(event ? (query, parameters) => queryAffectedByEvent(event, query, parameters) : void 0), "invalidateEvent");
   const syncConversation = createConversationSynchronizer({ store, query: /* @__PURE__ */ __name((name, parameters) => endpoint.query(name, parameters), "query"), ready: /* @__PURE__ */ __name(() => initialization, "ready"), clock, invalidate: /* @__PURE__ */ __name((conversationId) => invalidateEvent({ kind: "conversation.changed", data: { conversationId } }), "invalidate"), admitRecoveredMessages: options.admitRecoveredMessages, preparationGeneration: /* @__PURE__ */ __name(() => installationGeneration, "preparationGeneration"), prepareProtocol: /* @__PURE__ */ __name((id2) => refreshMlsRoom(id2, true), "prepareProtocol"), syncProtocol: /* @__PURE__ */ __name(async (id2, opts) => {
@@ -7939,19 +7658,20 @@ function createEndpoint(options) {
     return mlsDevGroups.syncText(id2, opts);
   }, "syncProtocol") });
   const events = createEndpointEventHub({ transport, invalidate: invalidateEvent, onDisconnected: /* @__PURE__ */ __name(() => queryObserver.reschedule(), "onDisconnected"), onEvent: /* @__PURE__ */ __name(async (event) => {
+    const hinted = [];
     if (mlsDevGroups && ["conversation.changed", "conversation.updated", "conversation.removed"].includes(event.kind)) {
       const id2 = event.data.conversationId ?? event.data.id;
       if (typeof id2 === "string" && ENDPOINT_ID_PATTERN.test(id2)) {
         if (event.kind === "conversation.changed" && event.data.projection === void 0) forgetStubReads(id2);
         const unseenRemoval = event.kind === "conversation.removed" && await store.transaction(async (tx) => await tx.get(`conversation/${id2}`) === void 0 && !await isMlsDevRoomProtected(tx, id2));
-        if (!unseenRemoval) await refreshMlsRoomFromHint(id2);
-        await sendDeferredOpeners(id2);
+        if (!unseenRemoval) hinted.push(hintRoom(id2));
+        else await sendDeferredOpeners(id2);
       }
     }
     if (mlsDevGroups && event.kind === "conversations.changed" && Array.isArray(event.data.conversationIds)) {
       for (const id2 of event.data.conversationIds) {
         if (typeof id2 === "string" && ENDPOINT_ID_PATTERN.test(id2) && await store.transaction((tx) => isMlsDevRoomProtected(tx, id2))) {
-          await refreshMlsRoomFromHint(id2);
+          hinted.push(hintRoom(id2));
         }
       }
     }
@@ -7963,13 +7683,16 @@ function createEndpoint(options) {
       if (event.kind === "connected") serverRoomMode = void 0;
       for (let after; ; ) {
         const page = await store.transaction((tx) => tx.scan("mls-dev-group/mode/", { after, limit: 100 }));
-        for (const item of page) await refreshMlsRoomFromHint(decodeURIComponent(item.key.slice("mls-dev-group/mode/".length)));
+        for (const item of page) hinted.push(hintRoom(decodeURIComponent(item.key.slice("mls-dev-group/mode/".length))));
         if (page.length < 100) break;
         after = page[page.length - 1].key;
       }
-      await sendDeferredOpeners();
-      await discoverInviteeRooms().catch(() => void 0);
+      hinted.push(queueRoomHint("after/reconnect", async () => {
+        await sendDeferredOpeners();
+        await discoverInviteeRooms().catch(() => void 0);
+      }, true));
     }
+    if (event.id) await Promise.all(hinted);
     if ((event.kind === "message.updated" || event.kind === "message.deleted") && typeof event.data.conversationId === "string" && typeof event.data.messageId === "string" && ENDPOINT_ID_PATTERN.test(event.data.conversationId)) {
       const room = event.data.conversationId, message = event.data.messageId;
       const applied = await store.transaction(async (tx) => {
@@ -8540,7 +8263,6 @@ function createEndpoint(options) {
           ...endpointIntentConversationId(normalized) ? { conversationId: endpointIntentConversationId(normalized) } : {},
           ...typeof routedBody.messageId === "string" ? { messageId: routedBody.messageId } : {},
           ...normalized.action === "session_control" && typeof routedBody.agentId === "string" ? { agentId: routedBody.agentId } : {},
-          ...endpointIntentOrdering(normalized) === "artifact" && typeof routedBody.artifactId === "string" ? { artifactId: routedBody.artifactId } : {},
           sensitive,
           status: "queued",
           attempts: 0,
@@ -8606,7 +8328,7 @@ function createEndpoint(options) {
       let dispatched = 0;
       let hasDeferred = false;
       const blockedKeys = /* @__PURE__ */ new Set();
-      for (const ordering of ["independent", "signal", "message", "provider", "artifact", "conversation"]) {
+      for (const ordering of ["independent", "signal", "message", "provider", "conversation"]) {
         let after;
         do {
           const batch = await store.transaction(async (tx) => {
@@ -8782,9 +8504,9 @@ function createEndpoint(options) {
     },
     refreshQueries: /* @__PURE__ */ __name(() => queryObserver.invalidate(), "refreshQueries"),
     observeEvents: events.observe,
-    createMediaPipeline(bytes, mediaOptions) {
+    createMediaPipeline(bytes) {
       assertOpen();
-      const pipeline3 = createEndpointMediaPipeline({ endpoint, store, bytes, hash, ids, clock, background: mediaOptions?.background });
+      const pipeline3 = createEndpointMediaPipeline({ endpoint, store, bytes, hash, ids, clock });
       mediaPipelines2.add(pipeline3);
       return pipeline3;
     },
@@ -9088,7 +8810,7 @@ function createEndpoint(options) {
       listeners.clear();
       closing = (async () => {
         await Promise.allSettled([handoffs.close(), recovery.close(), syncConversation.close(), events.close(), ...[...consumers].map((consumer) => consumer.close()), ...[...mediaPipelines2].map((pipeline3) => pipeline3.close({ discard: true }))]);
-        await Promise.allSettled([...running.values(), ...reads.values(), ...deviceRuns, initialization]);
+        await Promise.allSettled([...running.values(), ...reads.values(), ...deviceRuns, initialization, roomHintWorker]);
         await endpoint.discardPending();
         await eraseEndpointPlaintext(store);
         await store.close();
@@ -9111,11 +8833,10 @@ function createEndpoint(options) {
       sensitiveRequests.clear();
       sensitiveFingerprints.clear();
       listeners.clear();
-      closing = Promise.allSettled([handoffs.close(), recovery.close(), syncConversation.close(), events.close(), ...[...consumers].map((consumer) => consumer.close()), ...[...mediaPipelines2].map((pipeline3) => pipeline3.close())]).then(() => Promise.allSettled([...running.values(), ...reads.values(), ...deviceRuns, initialization])).then(() => store.close());
+      closing = Promise.allSettled([handoffs.close(), recovery.close(), syncConversation.close(), events.close(), ...[...consumers].map((consumer) => consumer.close()), ...[...mediaPipelines2].map((pipeline3) => pipeline3.close())]).then(() => Promise.allSettled([...running.values(), ...reads.values(), ...deviceRuns, initialization, roomHintWorker])).then(() => store.close());
       return closing;
     }
   };
-  registerArtifactEndpoint(endpoint, { store, closed: /* @__PURE__ */ __name(() => closed, "closed"), assertCurrent: assertCurrentInstallation });
   void initialization.then(() => scheduleRetry(0)).catch(() => void 0);
   void initialization.then(() => sendDeferredOpeners()).catch(() => void 0);
   if (mlsDevGroups) void initialization.then(() => resumeHeldTexts()).catch(() => void 0);
@@ -9173,7 +8894,7 @@ async function acquireAgentEndpoint(input) {
   }
   const requestedMls = input.options.mlsDev;
   const mls = requestedMls ? await (async () => {
-    const crypto2 = await import("./mls-crypto-NZVMSUFU.js");
+    const crypto2 = await import("./mls-crypto-ZBEC26B5.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;