@lanes-sh/link 0.6.11 → 0.7.0

package/src/connectivity/transports/http/index.ts

@@ -1,4 +1,5 @@
 import type { McpOpenAPITool, ParameterMapper } from 'mcp-from-openapi';
+import { withLegalKeys } from './keys.ts';
 import { shortenName } from '../mcp/index.ts';
 import {
   READ_BUNDLE,
@@ -186,17 +187,22 @@ export function createHttpConnector(options: HttpConnectorOptions): Connector {
           tool.description || `${tool.metadata.method.toUpperCase()} ${tool.metadata.path}`;
         const hint = context.manifest.hints?.[name];
 
+        const legal = withLegalKeys(
+          tool.inputSchema as unknown as Record<string, unknown>,
+          tool.mapper as unknown as ParameterMapper[],
+        );
+
         return {
           name,
           description: hint ? `${described}\n\n${hint}` : described,
-          inputSchema: tool.inputSchema as unknown as Record<string, unknown>,
+          inputSchema: legal.schema,
           bundle: bundleForMethod(tool.metadata.method),
           // Everything needed to rebuild the request without re-reading the spec,
           // so a cold instance serves from the cache alone.
           target: {
             path: tool.metadata.path,
             method: tool.metadata.method,
-            mapper: tool.mapper as unknown as Record<string, unknown>[],
+            mapper: legal.mapper as unknown as Record<string, unknown>[],
           },
         };
       });

package/src/connectivity/transports/http/keys.ts

@@ -0,0 +1,83 @@
+import type { ParameterMapper } from 'mcp-from-openapi';
+
+/**
+ * Property keys the Anthropic API will accept.
+ *
+ * It enforces `^[a-zA-Z0-9_.-]{1,64}$` on every key in a tool's input schema and
+ * rejects **the whole `tools` array** when one fails — so a single argument named
+ * `$top` takes down every provider on the endpoint at once, not just its own.
+ * That has happened: Google's `$.xgafv` produced 107 tools, one 400, and nothing
+ * working.
+ *
+ * Guarding it in the vendoring script was the first answer and it is the wrong
+ * layer. A script only protects the specs it runs over, and the constraint
+ * belongs to every `http` provider, including a YAML manifest in `providers.d/`
+ * pointing at a document nobody here has read. Microsoft Graph makes that
+ * concrete: OData names every query parameter `$top`, `$select`, `$filter`,
+ * `$orderby`, and dropping them would leave an agent unable to ask for less than
+ * a whole mailbox.
+ *
+ * So the key is renamed and the *wire name is not*. `ParameterMapper` already
+ * carries the two separately — `inputKey` is what the caller passes, `key` is
+ * what the request sends — and nothing but this function has ever needed them to
+ * differ.
+ */
+export const LEGAL_KEY = /^[a-zA-Z0-9_.-]{1,64}$/;
+
+function legalKey(name: string, taken: ReadonlySet<string>): string {
+  const stripped = name.replace(/[^a-zA-Z0-9_.-]/g, '').slice(0, 64);
+  // Everything illegal, or a name that was only its illegal characters.
+  const base = stripped === '' ? 'argument' : stripped;
+
+  if (!taken.has(base)) return base;
+  for (let suffix = 2; ; suffix += 1) {
+    const candidate = `${base.slice(0, 61)}_${suffix}`;
+    if (!taken.has(candidate)) return candidate;
+  }
+}
+
+/**
+ * Rename what the caller passes, leaving what the request sends alone.
+ *
+ * Returns the schema unchanged when every key is already legal, which is every
+ * provider but Microsoft today — so this costs nothing where it is not needed
+ * and cannot quietly reshape a schema that was fine.
+ */
+export function withLegalKeys(
+  schema: Record<string, unknown>,
+  mapper: readonly ParameterMapper[],
+): { schema: Record<string, unknown>; mapper: readonly ParameterMapper[] } {
+  const properties = schema['properties'] as Record<string, unknown> | undefined;
+  if (!properties) return { schema, mapper };
+
+  const illegal = Object.keys(properties).filter((key) => !LEGAL_KEY.test(key));
+  if (illegal.length === 0) return { schema, mapper };
+
+  const taken = new Set(Object.keys(properties).filter((key) => LEGAL_KEY.test(key)));
+  const renamed = new Map<string, string>();
+  for (const key of illegal) {
+    const legal = legalKey(key, taken);
+    taken.add(legal);
+    renamed.set(key, legal);
+  }
+
+  const nextProperties: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(properties)) {
+    nextProperties[renamed.get(key) ?? key] = value;
+  }
+
+  const required = schema['required'];
+  return {
+    schema: {
+      ...schema,
+      properties: nextProperties,
+      ...(Array.isArray(required)
+        ? { required: required.map((key) => renamed.get(String(key)) ?? key) }
+        : {}),
+    },
+    mapper: mapper.map((entry) =>
+      renamed.has(entry.inputKey) ? { ...entry, inputKey: renamed.get(entry.inputKey)! } : entry,
+    ),
+  };
+}
+

package/src/connectivity/transports/imap/attachment.ts

@@ -12,11 +12,20 @@ import { decodeMailboxName, encodeMailboxName } from './utf7.ts';
  * the bytes to make a round trip through the model. Here they never leave the
  * process.
  *
- * A message is named by its RFC 2822 `Message-ID` rather than by UID, because
- * that is what `get_message` and `search_messages` already report and it does not
- * oblige the caller to also remember which folder the message was in. The cost is
- * a search: INBOX first, since that is where it almost always is, then the rest
- * of the folders in the order the server lists them.
+ * Two ways to name the message, and the order of preference is the opposite of
+ * the order they were built in.
+ *
+ * A **uid** — with the mailbox it belongs to — is what IMAP itself uses, and it
+ * is already in front of the caller: `search_messages` reports both and
+ * `get_message` takes both. One `EXAMINE` and one `UID FETCH`, no searching.
+ *
+ * A **Message-ID** obliges a search, because the caller has not said which folder
+ * the message is in: INBOX first, since that is where it almost always is, then
+ * the rest in the order the server lists them, matching on `HEADER MESSAGE-ID`.
+ * That is a substring match the server implements however it likes, and a server
+ * that implements it poorly answers "no such message" while holding the message.
+ * It stays because a Message-ID survives being moved between folders and a uid
+ * does not — but a caller holding a uid should send the uid.
  *
  * Kept out of `commands.ts` because that file is near the size budget and this is
  * a self-contained question — which bytes, given a Message-ID — rather than
@@ -27,12 +36,21 @@ import { decodeMailboxName, encodeMailboxName } from './utf7.ts';
 const SKIP_FLAGS = new Set(['\\trash', '\\junk']);
 
 export function mailboxAttachments(client: ImapClient): MailboxAttachmentSource {
-  return async ({ messageId, attachmentId }) =>
+  return async ({ messageId, mailbox, uid, attachmentId }) =>
     client.run(async (session) => {
-      const bytes = await findMessageBytes(session, messageId);
+      const named = uid === undefined ? messageId : `uid ${uid} in ${mailbox ?? 'INBOX'}`;
+      const bytes =
+        uid === undefined
+          ? await findMessageBytes(session, messageId!)
+          : await fetchByUid(session, mailbox ?? 'INBOX', uid);
+
       if (!bytes) {
         throw new Error(
-          `No message with Message-ID ${messageId} in this account, so its attachment cannot be re-attached.`,
+          uid === undefined
+            ? `No message with Message-ID ${messageId} was found in this account. Every folder but Trash and Junk was searched, ` +
+              `and some servers match the Message-ID header poorly — if search_messages or get_message reported a uid and a ` +
+              `mailbox for this message, name those instead: { "uid": 1234, "mailbox": "INBOX" }.`
+            : `No message with ${named} — a uid is only valid in the mailbox it was reported for, and stops being valid if the message moves.`,
         );
       }
 
@@ -40,10 +58,10 @@ export function mailboxAttachments(client: ImapClient): MailboxAttachmentSource
       const attachments = mail.attachments;
 
       if (attachments.length === 0) {
-        throw new Error(`Message ${messageId} has no attachments.`);
+        throw new Error(`Message ${named} has no attachments.`);
       }
 
-      const chosen = pick(attachments, attachmentId, messageId);
+      const chosen = pick(attachments, attachmentId, named!);
 
       return {
         bytes:
@@ -155,6 +173,31 @@ async function fetchByMessageId(
 
   if (uid === undefined) return null;
 
+  return await fetchBody(session, uid);
+}
+
+/**
+ * The direct route: the caller already knows which mailbox and which uid.
+ *
+ * `EXAMINE` rather than `SELECT`, and `BODY.PEEK[]` rather than `BODY[]`, for the
+ * same reason as every other read here — fetching something to attach must not
+ * mark it as read.
+ */
+async function fetchByUid(
+  session: ImapSession,
+  mailbox: string,
+  uid: number,
+): Promise<Uint8Array | null> {
+  try {
+    await session.command(`EXAMINE ${quoted(encodeMailboxName(mailbox))}`);
+  } catch {
+    return null;
+  }
+
+  return await fetchBody(session, uid);
+}
+
+async function fetchBody(session: ImapSession, uid: number): Promise<Uint8Array | null> {
   const fetched = await session.command(`UID FETCH ${uid} (BODY.PEEK[])`);
   const record = fetched.untagged.find(
     (tokens) => asText(tokens[2]) === 'FETCH' && tokens[3]?.kind === 'list',

package/src/connectivity/transports/imap/capabilities.ts

@@ -69,6 +69,34 @@ export function imapCapabilities(input: {
           ),
           target: { operation: OPERATIONS.getMessage },
         },
+        {
+          name: OPERATIONS.getAttachment,
+          description:
+            'Take one attachment out of a message and hold it on the endpoint, returning a handle rather than the file. Fetch the bytes with GET /attachments?connection=<provider>.<account>&handle=<handle>, or name the handle in a later send_message. get_message lists what a message carries; this is how you get one.',
+          bundle: READ_BUNDLE,
+          inputSchema: object(
+            {
+              mailbox: mailboxArgument,
+              uid: {
+                type: 'integer',
+                minimum: 1,
+                description: 'UID as search_messages and get_message report it. Preferred — it names the message directly.',
+              },
+              message_id: {
+                type: 'string',
+                description:
+                  'RFC 2822 Message-ID, if you do not have a uid. Slower and less reliable: it has no mailbox attached, so every folder is searched.',
+              },
+              attachment_id: {
+                type: 'string',
+                description:
+                  'Which attachment: its filename, or its 1-based position. Omit when the message has exactly one.',
+              },
+            },
+            [],
+          ),
+          target: { operation: OPERATIONS.getAttachment },
+        },
         {
           name: OPERATIONS.markMessages,
           description: 'Add or remove flags on messages — read, flagged, answered, draft.',

package/src/connectivity/transports/imap/download.ts

@@ -0,0 +1,111 @@
+import { createHash } from 'node:crypto';
+import {
+  newHandle,
+  putStaged,
+  sweepStaged,
+  STAGED_TTL_MS,
+  type MailboxAttachmentSource,
+} from '#connectivity/mail';
+import type { ConnectionInfo, ToolResult } from '#connectivity';
+import type { AuditLogger } from '#audit';
+import type { BlobStore } from '#stores/blobs';
+
+/**
+ * Taking an attachment *out* of a mailbox.
+ *
+ * The direction that was missing. `get_message` reports what a message carries
+ * — filename, type, size — and `send_message` can attach one back out, so an
+ * attachment could be described and forwarded but never simply had. The two
+ * routes people tried instead are both dead ends: storing it as an asset, which
+ * cannot resolve a mailbox reference because a provider's store is scoped to
+ * its own connection; and mailing it to yourself, which needs the message found
+ * again by a header search some servers do badly.
+ *
+ * So this is the same staging the upload route already uses, run the other way.
+ * The bytes are read here, put in *this connection's* namespace under a handle,
+ * and the handle is what comes back. Nothing crosses between connections and no
+ * provider gains reach it did not have — the bytes were already in this
+ * account's area — and the client collects them over HTTP, out of band, exactly
+ * as it hands them in.
+ *
+ * **The bytes never enter the tool result.** That is the whole rule of ADR-017
+ * and it does not stop applying because the direction reversed: a 239 KB PDF is
+ * about 320,000 characters of base64, and a model that has to read the file in
+ * order to have it has not been handed anything.
+ */
+export async function getAttachment(
+  attachments: MailboxAttachmentSource,
+  args: Record<string, unknown>,
+  audit: AuditLogger,
+  storage: BlobStore,
+  connection: ConnectionInfo,
+): Promise<ToolResult> {
+  const uid = typeof args['uid'] === 'number' ? args['uid'] : undefined;
+  const messageId = typeof args['message_id'] === 'string' ? args['message_id'] : undefined;
+
+  if (uid === undefined && messageId === undefined) {
+    throw new Error(
+      'Name the message: uid (with its mailbox, as search_messages reports both) or message_id.',
+    );
+  }
+  if (uid !== undefined && messageId !== undefined) {
+    throw new Error('Name the message by uid or by message_id, not both — they are alternatives.');
+  }
+
+  const mailbox = typeof args['mailbox'] === 'string' ? args['mailbox'] : undefined;
+  const attachmentId =
+    typeof args['attachment_id'] === 'string' ? args['attachment_id'] : undefined;
+
+  const found = await attachments({ messageId, mailbox, uid, attachmentId });
+
+  const filename = found.filename ?? 'attachment';
+  const contentType = found.contentType ?? 'application/octet-stream';
+  const sha256 = createHash('sha256').update(found.bytes).digest('hex');
+
+  // Swept before writing, for the same reason the upload path sweeps: there is
+  // no scheduler here, and staging is the only thing that makes this garbage.
+  await sweepStaged(storage).catch(() => 0);
+
+  const handle = newHandle();
+  const expiresAt = Date.now() + STAGED_TTL_MS;
+
+  await putStaged(storage, {
+    handle,
+    bytes: found.bytes,
+    metadata: { filename, content_type: contentType, sha256, expires_at: expiresAt },
+  });
+
+  // The resolved facts rather than the arguments — identifiers, not content, the
+  // same annotation the send path records. What makes "which file left this
+  // mailbox" answerable is the name and the digest, not the bytes.
+  audit.annotate({
+    filename,
+    bytes: found.bytes.byteLength,
+    content_type: contentType,
+    sha256,
+    handle,
+  });
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(
+          {
+            handle,
+            filename,
+            bytes: found.bytes.byteLength,
+            content_type: contentType,
+            sha256,
+            expires_at: new Date(expiresAt).toISOString(),
+            connection: connection.key,
+            fetch: `GET /attachments?connection=${connection.key}&handle=${handle}`,
+            hint: `Download it with the GET above, or attach it to a message: { "handle": "${handle}" }. It is kept for 24 hours.`,
+          },
+          null,
+          2,
+        ),
+      },
+    ],
+  };
+}

package/src/connectivity/transports/imap/index.ts

@@ -44,6 +44,8 @@ import type { SocketFactory } from './socket.ts';
  */
 
 import { imapCapabilities } from './capabilities.ts';
+import { mailboxAttachments } from './attachment.ts';
+import { getAttachment } from './download.ts';
 import { OPERATIONS } from './operations.ts';
 import { error, json } from './result.ts';
 import {
@@ -114,6 +116,17 @@ export function createImapConnector(options: ImapConnectorOptions): Connector {
             return await client.run((session) => searchMessages(session, args));
           case OPERATIONS.getMessage:
             return await client.run((session) => getMessage(session, args, options.maxBodyBytes));
+          case OPERATIONS.getAttachment:
+            // Handed the context for the same reason `send_message` is: what
+            // came out is worth recording as resolved facts, and the raw
+            // argument cannot say what the file turned out to be.
+            return await getAttachment(
+              mailboxAttachments(client),
+              args as Record<string, unknown>,
+              context.provider.audit,
+              context.provider.storage,
+              context.provider.connection,
+            );
           case OPERATIONS.markMessages:
             // Never retried. A repeated flag change is harmless, but keeping the
             // rule uniform is what stops the exceptions from multiplying.

package/src/connectivity/transports/imap/operations.ts

@@ -11,6 +11,7 @@ export const OPERATIONS = {
   listMailboxes: 'list_mailboxes',
   searchMessages: 'search_messages',
   getMessage: 'get_message',
+  getAttachment: 'get_attachment',
   markMessages: 'mark_messages',
   moveMessages: 'move_messages',
   sendMessage: 'send_message',

package/src/deployments/adapters/s3.ts

@@ -15,7 +15,7 @@ import type { BlobMetadata, BlobStore } from '#stores/blobs';
  *
  * Named for the protocol rather than the vendor, which is ADR-008's rule
  * applied to an adapter: Supabase Storage, Cloudflare R2, MinIO, and AWS differ
- * only in the endpoint. Supabase is what `docs/detailed/deployment-cloudrun.md`
+ * only in the endpoint. Supabase is what `https://lanes.sh/docs/link/deployment-cloudrun`
  * documents, because it is already the Postgres host and a second vendor for
  * the blobs would be one more thing to hold.
  *

package/src/deployments/gcp/provision.ts

@@ -8,7 +8,7 @@ import type { PolicyReader } from './iam.ts';
 /**
  * The project-level things a Cloud Run deploy needs to already exist.
  *
- * These used to be a numbered list in `docs/detailed/deployment-cloudrun.md` that the
+ * These used to be a numbered list in `https://lanes.sh/docs/link/deployment-cloudrun` that the
  * operator worked through by hand before their first deploy could get past its
  * first step. Everything here is derivable from what the target already
  * declares, so asking someone to transcribe it into a console was work with no

package/src/deployments/knowledge.ts

@@ -1,6 +1,7 @@
 import type { SecretStore } from '#secrets';
 import type { BlobStore } from '#stores/blobs';
-import { knowledgeRoot, type KnowledgeConfig } from '#profile';
+import type { BlobRoute } from '#stores/blobs/route.ts';
+import { KNOWLEDGE_LAYOUT, knowledgeRoot, type KnowledgeArea, type KnowledgeConfig } from '#profile';
 import { requireSecret, type TargetInput } from './target.ts';
 import type { FetchLike } from './adapters/github-api.ts';
 // Type-only, so a target with no `knowledge` block never loads the adapter.
@@ -14,13 +15,13 @@ import type { GithubRepository } from './adapters/github-repo.ts';
 export type { FetchLike } from './adapters/github-api.ts';
 
 /**
- * Opening the place a profile keeps its memory and its skills, when that is not
- * the place it keeps everything else.
+ * Opening the place a profile keeps its memory, skills and entities, when that
+ * is not the place it keeps everything else.
  *
  * Its own file rather than a fifth case in `target.ts`, because it is not the
  * same kind of decision. `target.ts` answers "where does this target run" —
  * credentials here, bytes there — and every consumer of a `BlobStore` rides
- * that one answer. This answers a narrower one: two directories of documents
+ * that one answer. This answers a narrower one: three directories of documents
  * the owner wrote have somewhere else to be, and nothing else moves with them.
  *
  * ADR-041 has the argument. `src/profile/knowledge.ts` has the contract, and
@@ -29,19 +30,22 @@ export type { FetchLike } from './adapters/github-api.ts';
  */
 
 /**
- * One repository client, two stores.
+ * One repository client, three stores.
  *
- * Memory and skills are two directories in one repository, and pointing both at
- * one client means one branch head, one tree, and one blob cache between them —
- * so the endpoint's two-second skill poll keeps memory's view current for free.
- * Two clients would each poll, each cache, and could disagree about which
- * commit is current.
+ * Memory, skills and entities are three directories in one repository, and
+ * pointing all of them at one client means one branch head, one tree, and one
+ * blob cache between them — so the endpoint's two-second skill poll keeps the
+ * other two views current for free. Three clients would each poll, each cache,
+ * and could disagree about which commit is current. The argument got stronger
+ * with a third area rather than weaker, which is why adding one is a line here.
  */
 export interface KnowledgeStores {
   readonly repository: GithubRepository;
   readonly skills: BlobStore;
   /** Rooted at the repository's memory directory; keys are `<connection>/<id>.md`. */
   readonly memory: BlobStore;
+  /** The same shape again, plus the derived `<connection>/_index.json`. */
+  readonly entities: BlobStore;
   /** One line for `target show` and `doctor`, so the config file is not the only witness. */
   readonly describe: string;
 }
@@ -88,7 +92,7 @@ export async function openKnowledge(
 }
 
 /**
- * The two stores a knowledge repository holds.
+ * The three stores a knowledge repository holds.
  *
  * Separate from `openKnowledge` because `lanes link knowledge use` builds these
  * against a repository it is still probing — before any of it has been written
@@ -98,21 +102,43 @@ export async function openKnowledge(
 export async function knowledgeStores(
   repository: GithubRepository,
   knowledge: KnowledgeConfig,
-): Promise<{ skills: BlobStore; memory: BlobStore }> {
+): Promise<{ skills: BlobStore; memory: BlobStore; entities: BlobStore }> {
   const { createGithubBlobStore } = await import('./adapters/github.ts');
 
-  const build = (area: 'memory' | 'skills'): BlobStore =>
+  // What the commit says it did. Named per area rather than left to the
+  // adapter's default, because "Store main/note.md" in a repository holding
+  // three of them is a line that does not say which one changed.
+  const noun: Record<KnowledgeArea, string> = {
+    memory: 'memory',
+    skills: 'skill',
+    entities: 'entity',
+  };
+
+  const build = (area: KnowledgeArea): BlobStore =>
     createGithubBlobStore({
       repository,
       root: knowledgeRoot(knowledge, area),
-      // What the commit says it did. Named per area rather than left to the
-      // adapter's default, because "Store main/note.md" in a repository holding
-      // both is a line that does not say which of them changed.
       message: (operation, key) =>
-        `${operation === 'store' ? 'Store' : 'Remove'} ${area === 'skills' ? 'skill' : 'memory'} ${key}`,
+        `${operation === 'store' ? 'Store' : 'Remove'} ${noun[area]} ${key}`,
     });
 
-  return { skills: build('skills'), memory: build('memory') };
+  return { skills: build('skills'), memory: build('memory'), entities: build('entities') };
+}
+
+/**
+ * Which key prefixes of the profile's blob root lead to the repository.
+ *
+ * Here rather than at the call site because it is the same fact
+ * `KNOWLEDGE_LAYOUT` states: a directory name in the repository *is* the
+ * provider namespace that routes into it, and spelling the pair in two files is
+ * how they would come to disagree. `skills` is absent because it is not a
+ * prefix of that root — it is a store of its own, handed over whole.
+ */
+export function knowledgeRoutes(stores: KnowledgeStores): BlobRoute[] {
+  return [
+    { prefix: `${KNOWLEDGE_LAYOUT.memory}/`, store: stores.memory },
+    { prefix: `${KNOWLEDGE_LAYOUT.entities}/`, store: stores.entities },
+  ];
 }
 
 /** `github:owner/name#branch/path`, in one place so every reader agrees. */

package/src/deployments/prepare.ts

@@ -208,7 +208,7 @@ export async function prepareSecrets(input: PrepareInput): Promise<PrepareResult
  *
  * Minted here for the same reason the profile token is: it is a random string
  * this process generates correctly and nobody can usefully choose. It used to be
- * three manual commands in `docs/detailed/deployment-cloudrun.md` — generate, store,
+ * three manual commands in `https://lanes.sh/docs/link/deployment-cloudrun` — generate, store,
  * mount — whose only failure mode was forgetting them and finding out when the
  * first `vault.*` call failed against a revision that had booted healthy.
  *

package/src/deployments/serving.ts

@@ -102,7 +102,7 @@ async function choosePrimary(
  *
  * References are flat — `gmail/main`, not `personal/gmail/main` — and a target
  * has one credential store, so two profiles deployed to the same project share
- * a namespace. `docs/detailed/configuration.md` admits this in an aside about
+ * a namespace. `https://lanes.sh/docs/link/configuration` admits this in an aside about
  * removing a profile; deploying both at once is where it stops being an aside.
  *
  * The failure is silent and it is the bad kind: `personal`'s Gmail refresh

package/src/dispatch/dispatch.ts

@@ -16,7 +16,8 @@ import type {
 import { isToolResult, strategyContextFrom, strategyFor } from '#connectivity';
 import type { Config } from '#profile';
 import { buildProviderContext, createProviderLogger } from './context.ts';
-import { stageAttachment, type StagedAttachment, type StageRequest } from './staging.ts';
+import { fetchStaged, stageAttachment } from './staging.ts';
+import type { FetchStagedRequest, StagedAttachment, StageRequest } from './staging.ts';
 import type { ProviderRegistry } from '#registry';
 
 /**
@@ -104,16 +105,22 @@ export class Dispatcher {
    * operator's file inside the endpoint, where a later send can post it outward
    * — so it is audited on the same path as the send rather than beside it.
    */
+  /** What both halves of staging take. One place, so the two cannot diverge. */
+  get #staging() {
+    return {
+      storage: this.#deps.storage,
+      audit: this.#deps.audit,
+      profile: this.#deps.config.instance.profile,
+    };
+  }
+
   async stageAttachment(request: StageRequest): Promise<StagedAttachment> {
-    return stageAttachment(
-      {
-        storage: this.#deps.storage,
-        audit: this.#deps.audit,
-        profile: this.#deps.config.instance.profile,
-        now: this.#now,
-      },
-      request,
-    );
+    return stageAttachment({ ...this.#staging, now: this.#now }, request);
+  }
+
+  /** The same door, outward — bytes back to the client. See `fetchStaged`. */
+  async fetchStagedAttachment(request: FetchStagedRequest) {
+    return fetchStaged(this.#staging, request);
   }
 
   /**