zas-agent 0.3.0 → 0.4.0

package/dist/cli.js

@@ -118,7 +118,12 @@ var RENAMES = {
   file_too_large: "file_too_big",
   read_only: "send_forbidden",
   unknown_channel: "grant_missing",
-  no_account: "grant_missing"
+  no_account: "grant_missing",
+  // The Directo routes' words. `not_live` is an exchange that ended under the
+  // agent (expired, or cancelled from the receiving side); `direct_too_big`
+  // is the plan's Directo ceiling.
+  not_live: "direct_cancelled",
+  direct_too_big: "file_too_big"
 };
 var ZasError = class extends Error {
   constructor(code, status, message, retryAfterMs, serverCode) {
@@ -161,6 +166,13 @@ var SENTENCES = {
   read_forbidden: "This agent cannot read that channel.",
   direct_mode: "That channel is in Directo mode. Use zas_send_direct.",
   not_direct_mode: "That channel is not in Directo mode. Use zas_send_file.",
+  not_claimed: "Nobody received the file within ten minutes. The offer was withdrawn.",
+  direct_cancelled: "The offer was cancelled from the receiving side.",
+  direct_failed: "The Directo transfer failed ({path}). Ask the owner before you use zas_send_direct_fallback.",
+  direct_not_failed: "That job is not a Directo send that failed in flight.",
+  file_changed: "The file changed since the Directo offer. Send it again.",
+  webrtc_unavailable: "The WebRTC engine (node-datachannel) could not be loaded on this machine.",
+  fallback_unavailable: "Reliable delivery is not available right now. Try again later.",
   key_stale: "The channel key changed. The owner refreshes it by opening Zas.",
   quota_exceeded: "The account reached its storage limit.",
   rate_limited: "Too many sends in a row. Wait a moment.",
@@ -550,6 +562,17 @@ var ZasClient = class _ZasClient {
     if (!Array.isArray(parsed)) return [];
     return parsed.filter((row) => !!row && typeof row === "object" && "document" in row).map((row) => row.document);
   }
+  /** Firestore REST get of one document, `null` when it is not there. The
+   *  rules decide what an agent may read; here that is its own Directo offer,
+   *  which an offer's sender may read without a grant on the channel. */
+  async firestoreGet(path) {
+    const base = _ZasClient.firestoreBase(this.identity.firestore_project);
+    const res = await this.authed(`${base}/${path}`, "GET", void 0, {});
+    const parsed = await readBody2(res);
+    if (res.status === 404) return null;
+    if (!res.ok) throw errorFromResponse(res.status, parsed);
+    return parsed;
+  }
   /** The web app's public config value. It identifies the project, it is not a secret. */
   static apiKey() {
     return process.env.ZAS_FIREBASE_API_KEY || "AIzaSyAiZbAPrxH7EKaJftJoGcEVEL0h6rAVcvE";
@@ -797,6 +820,11 @@ async function runPair(opts) {
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 
+// src/direct.ts
+import { randomBytes } from "node:crypto";
+import { openAsBlob } from "node:fs";
+import { basename as basename2 } from "node:path";
+
 // src/shared/manifest.ts
 import { xchacha20poly1305 } from "@noble/ciphers/chacha";
 
@@ -861,6 +889,8 @@ function openSealed(key, sealed) {
   }
   return xchacha20poly1305(key, sealed.slice(0, 24)).decrypt(sealed.slice(24));
 }
+var sealRaw = sealBytes;
+var openRaw = openSealed;
 function sealManifest(channelKey, manifest, version = KEY_VERSION_LEGACY) {
   return sealBytes(channelKey, version, new TextEncoder().encode(JSON.stringify(manifest)));
 }
@@ -873,6 +903,604 @@ function decryptChannelName(channelKey, sealed) {
   return new TextDecoder().decode(openSealed(channelKey, sealed));
 }
 
+// src/shared/direct.ts
+var DIRECT_OFFER_TTL_MS = 10 * 60 * 1e3;
+var DIRECT_CLAIMED_TTL_MS = 6 * 60 * 60 * 1e3;
+var DIRECT_DONE_TTL_MS = 15 * 1e3;
+var DIRECT_FILE_MAX_BYTES = 20 * 1024 * 1024 * 1024;
+var DIRECT_FREE_FILE_MAX_BYTES = 10 * 1024 * 1024 * 1024;
+var DIRECT_ANON_FILE_MAX_BYTES = 5 * 1024 * 1024 * 1024;
+var DIRECT_ENTERPRISE_FILE_MAX_BYTES = 100 * 1024 * 1024 * 1024;
+var DIRECT_CHUNK_BYTES = 64 * 1024;
+var DIRECT_BUFFERED_HIGH = 8 * 1024 * 1024;
+var DIRECT_RECEIVE_WINDOW_BYTES = 4 * 1024 * 1024;
+var DIRECT_MEMORY_SINK_MAX_BYTES = 128 * 1024 * 1024;
+var DIRECT_FALLBACK_PART_BYTES = 16 * 1024 * 1024;
+var DIRECT_FALLBACK_TAG_BYTES = 16;
+var DIRECT_FALLBACK_TTL_MS = 24 * 60 * 60 * 1e3;
+function directFallbackPartCount(size) {
+  if (!Number.isSafeInteger(size) || size < 0) throw new Error("bad_size");
+  return Math.max(1, Math.ceil(size / DIRECT_FALLBACK_PART_BYTES));
+}
+function directFallbackCipherSize(size) {
+  return size + directFallbackPartCount(size) * DIRECT_FALLBACK_TAG_BYTES;
+}
+var DIRECT_CONNECT_TIMEOUT_MS = 30 * 1e3;
+var DIRECT_STALL_GRACE_MS = 5 * 1e3;
+var DIRECT_SIGNAL_WAIT_MS = 90 * 1e3;
+
+// src/shared/direct-engine.ts
+import { createSHA256 } from "hash-wasm";
+
+// src/shared/direct-protocol.ts
+var FRAME_META = 1;
+var FRAME_CHUNK = 2;
+var FRAME_DONE = 3;
+var FRAME_ABORT = 4;
+var FRAME_CREDIT = 5;
+function encodeMeta(meta) {
+  const body = new TextEncoder().encode(JSON.stringify(meta));
+  const frame = new Uint8Array(1 + body.length);
+  frame[0] = FRAME_META;
+  frame.set(body, 1);
+  return frame;
+}
+function encodeChunk(bytes) {
+  if (bytes.length > DIRECT_CHUNK_BYTES - 1) throw new Error("chunk_too_big");
+  const frame = new Uint8Array(1 + bytes.length);
+  frame[0] = FRAME_CHUNK;
+  frame.set(bytes, 1);
+  return frame;
+}
+function encodeDone(digest) {
+  if (!digest) return new Uint8Array([FRAME_DONE]);
+  const body = new TextEncoder().encode(JSON.stringify(digest));
+  const frame = new Uint8Array(1 + body.length);
+  frame[0] = FRAME_DONE;
+  frame.set(body, 1);
+  return frame;
+}
+var DONE_FRAME = encodeDone();
+var ABORT_FRAME = new Uint8Array([FRAME_ABORT]);
+function parseFrame(data) {
+  const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+  if (bytes.length === 0) throw new Error("empty_frame");
+  const payload = bytes.subarray(1);
+  switch (bytes[0]) {
+    case FRAME_META: {
+      const meta = JSON.parse(new TextDecoder().decode(payload));
+      if (typeof meta.name !== "string" || typeof meta.size !== "number") {
+        throw new Error("bad_meta");
+      }
+      return { type: "meta", meta };
+    }
+    case FRAME_CHUNK:
+      return { type: "chunk", payload };
+    case FRAME_DONE: {
+      if (payload.length === 0) return { type: "done" };
+      const digest = JSON.parse(new TextDecoder().decode(payload));
+      if (!Number.isSafeInteger(digest.size) || digest.size < 0 || typeof digest.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(digest.sha256)) throw new Error("bad_digest");
+      return { type: "done", digest };
+    }
+    case FRAME_ABORT:
+      return { type: "abort" };
+    case FRAME_CREDIT: {
+      const received = Number(new TextDecoder().decode(payload));
+      if (!Number.isSafeInteger(received) || received < 0) throw new Error("bad_credit");
+      return { type: "credit", received };
+    }
+    default:
+      throw new Error("unknown_frame");
+  }
+}
+
+// src/shared/direct-engine.ts
+var DIRECT_ICE = [
+  { urls: ["stun:stun.l.google.com:19302", "stun:stun.cloudflare.com:3478"] }
+];
+function candType(candidate) {
+  const m = /\styp\s+(\S+)/.exec(candidate?.candidate ?? "");
+  return m ? m[1] : "other";
+}
+function countCand(diag, side, c) {
+  if (!c) return;
+  const t = candType(c);
+  if (t === "host") diag[side === "local" ? "localHost" : "remoteHost"]++;
+  else if (t === "srflx" || t === "prflx") diag[side === "local" ? "localSrflx" : "remoteSrflx"]++;
+  else if (t === "relay") diag[side === "local" ? "localRelay" : "remoteRelay"]++;
+}
+function countTurnUrls(servers) {
+  let n = 0;
+  for (const server of servers ?? []) {
+    const urls = typeof server.urls === "string" ? [server.urls] : server.urls;
+    for (const url of urls ?? []) {
+      if (/^turns?:/i.test(url)) n++;
+    }
+    const legacy = server.url;
+    if (typeof legacy === "string" && /^turns?:/i.test(legacy)) n++;
+  }
+  return n;
+}
+function pairFromStats(stats) {
+  let pair;
+  stats.forEach((s) => {
+    if (s.type === "candidate-pair" && s.state === "succeeded" && (s.nominated || s.selected)) {
+      pair = s;
+    }
+  });
+  if (!pair?.localCandidateId || !pair.remoteCandidateId) return void 0;
+  const local = stats.get(pair.localCandidateId);
+  const remote = stats.get(pair.remoteCandidateId);
+  if (!local?.candidateType || !remote?.candidateType) return void 0;
+  return { local: local.candidateType, remote: remote.candidateType };
+}
+function pathOf(pair) {
+  if (pair.local === "relay" || pair.remote === "relay") return "relay";
+  return pair.local === "host" && pair.remote === "host" ? "lan" : "wan";
+}
+function session(ice, onPhase, onDiag, iceTransportPolicy = "all") {
+  const initialIce = ice ?? DIRECT_ICE;
+  const pc = new RTCPeerConnection({
+    iceServers: initialIce,
+    iceTransportPolicy
+  });
+  let phase = "connecting";
+  let disconnectTimer;
+  let restartTimer;
+  let stallState = "idle";
+  const startedAt = Date.now();
+  const diag = {
+    reason: "",
+    ms: 0,
+    iceState: "",
+    gatherState: "",
+    hadRemoteDesc: false,
+    localHost: 0,
+    localSrflx: 0,
+    localRelay: 0,
+    remoteHost: 0,
+    remoteSrflx: 0,
+    remoteRelay: 0,
+    turnUrlsSupplied: countTurnUrls(initialIce),
+    turnUrlsConfigured: 0,
+    bytes: 0,
+    restarts: 0
+  };
+  const cleanup = () => {
+    clearTimeout(waitTimer);
+    clearTimeout(connectTimer);
+    clearTimeout(disconnectTimer);
+    clearTimeout(restartTimer);
+    pc.onicecandidate = null;
+    pc.oniceconnectionstatechange = null;
+    pc.close();
+  };
+  const setPhase = (p) => {
+    if (phase === "done" || phase === "failed") return;
+    phase = p;
+    if (p === "done" || p === "failed") {
+      diag.ms = Date.now() - startedAt;
+      diag.iceState = String(pc.iceConnectionState ?? "");
+      diag.gatherState = String(pc.iceGatheringState ?? "");
+      diag.hadRemoteDesc = !!pc.remoteDescription;
+      diag.turnUrlsConfigured = countTurnUrls(pc.getConfiguration().iceServers);
+      onDiag?.(diag);
+      onPhase(p);
+      cleanup();
+      return;
+    }
+    onPhase(p);
+  };
+  const fail = (reason) => {
+    if (phase === "done" || phase === "failed") return;
+    if (!diag.reason) diag.reason = reason;
+    setPhase("failed");
+  };
+  const waitTimer = setTimeout(() => fail("peer_silent"), DIRECT_SIGNAL_WAIT_MS);
+  let connectTimer;
+  let heard = false;
+  const signaled = () => {
+    if (heard) return;
+    heard = true;
+    clearTimeout(waitTimer);
+    connectTimer = setTimeout(() => fail("connect_timeout"), DIRECT_CONNECT_TIMEOUT_MS);
+  };
+  let onStall;
+  let stallWindowMs = DIRECT_CONNECT_TIMEOUT_MS;
+  const stalled = () => {
+    if (phase === "done" || phase === "failed") return;
+    clearTimeout(disconnectTimer);
+    if (stallState === "restarting") return;
+    if (diag.msConnect === void 0 || !onStall) {
+      fail("disconnected");
+      return;
+    }
+    stallState = "restarting";
+    diag.restarts++;
+    clearTimeout(restartTimer);
+    restartTimer = setTimeout(() => fail("disconnected"), stallWindowMs);
+    onStall();
+  };
+  pc.oniceconnectionstatechange = () => {
+    const s = pc.iceConnectionState;
+    if (s === "failed") {
+      if (diag.msConnect !== void 0 && onStall) stalled();
+      else fail("ice_failed");
+    }
+    if (s === "disconnected" && stallState === "idle") {
+      stallState = "grace";
+      disconnectTimer = setTimeout(stalled, DIRECT_STALL_GRACE_MS);
+    }
+    if (s === "connected" || s === "completed") {
+      clearTimeout(disconnectTimer);
+      clearTimeout(restartTimer);
+      stallState = "idle";
+    }
+  };
+  return {
+    pc,
+    diag,
+    setPhase,
+    fail,
+    cleanup,
+    signaled,
+    connected: () => {
+      clearTimeout(waitTimer);
+      clearTimeout(connectTimer);
+      if (diag.msConnect === void 0) diag.msConnect = Date.now() - startedAt;
+    },
+    isTerminal: () => phase === "done" || phase === "failed",
+    setStall: (fn, windowMs) => {
+      onStall = fn;
+      stallWindowMs = windowMs;
+    },
+    setIceServers: (iceServers) => {
+      diag.turnUrlsSupplied = countTurnUrls(iceServers);
+      pc.setConfiguration({ iceServers });
+    }
+  };
+}
+function signalPlumbing(pc, send, onSendError, diag) {
+  let localGeneration = 1;
+  let remoteGeneration = 0;
+  let remoteReady = false;
+  const pendingByGeneration = /* @__PURE__ */ new Map();
+  let pendingLegacy = [];
+  pc.onicecandidate = (e) => {
+    const c = e.candidate;
+    countCand(diag, "local", c);
+    void send({
+      kind: "ice",
+      candidate: c ? c.toJSON ? c.toJSON() : c : null,
+      protocol: 2,
+      generation: localGeneration
+    }).catch(onSendError);
+  };
+  const apply = (candidate) => {
+    void pc.addIceCandidate(candidate ?? void 0).catch(() => void 0);
+  };
+  const applyIce = (candidate, generation) => {
+    countCand(diag, "remote", candidate);
+    const normalized = candidate ?? null;
+    if (generation === void 0) {
+      if (remoteReady) apply(normalized);
+      else pendingLegacy.push(normalized);
+      return;
+    }
+    if (generation < remoteGeneration) return;
+    if (remoteReady && generation === remoteGeneration) {
+      apply(normalized);
+      return;
+    }
+    const queued = pendingByGeneration.get(generation) ?? [];
+    queued.push(normalized);
+    pendingByGeneration.set(generation, queued);
+  };
+  const expectRemoteGeneration = (generation) => {
+    remoteGeneration = generation;
+    remoteReady = false;
+  };
+  const remoteDescriptionSet = (generation) => {
+    remoteGeneration = generation;
+    remoteReady = true;
+    const queued = pendingByGeneration.get(generation) ?? [];
+    pendingByGeneration.delete(generation);
+    const legacy = pendingLegacy;
+    pendingLegacy = [];
+    queued.forEach(apply);
+    legacy.forEach(apply);
+  };
+  return {
+    applyIce,
+    expectRemoteGeneration,
+    remoteDescriptionSet,
+    setLocalGeneration: (generation) => void (localGeneration = generation)
+  };
+}
+function startSender(opts) {
+  const s = session(opts.ice, opts.onPhase, opts.onDiag, opts.iceTransportPolicy);
+  opts.onPhase("connecting");
+  const { pc } = s;
+  const plumbing = signalPlumbing(pc, opts.send, () => s.fail("signal_send"), s.diag);
+  let generation = 1;
+  let peerProtocol = 1;
+  s.setStall(() => {
+    void (async () => {
+      generation++;
+      plumbing.setLocalGeneration(generation);
+      plumbing.expectRemoteGeneration(generation);
+      if (opts.refreshIce) {
+        const iceServers = await opts.refreshIce();
+        s.setIceServers(iceServers);
+      }
+      pc.restartIce?.();
+      const offer = await pc.createOffer({ iceRestart: true });
+      await pc.setLocalDescription(offer);
+      await opts.send({ kind: "offer", sdp: offer.sdp, protocol: 2, generation });
+    })().catch(() => s.fail("signaling"));
+  }, DIRECT_CONNECT_TIMEOUT_MS);
+  const dc = pc.createDataChannel("zas-direct", { ordered: true });
+  dc.binaryType = "arraybuffer";
+  dc.bufferedAmountLowThreshold = DIRECT_BUFFERED_HIGH / 8;
+  const waitLow = () => new Promise((resolve2) => {
+    const done = () => {
+      dc.removeEventListener("bufferedamountlow", done);
+      resolve2();
+    };
+    dc.addEventListener("bufferedamountlow", done);
+  });
+  let persisted = 0;
+  const creditWaiters = [];
+  const wakeCredits = () => {
+    for (let i = creditWaiters.length - 1; i >= 0; i--) {
+      if (s.isTerminal() || persisted >= creditWaiters[i].target) {
+        creditWaiters.splice(i, 1)[0].resolve();
+      }
+    }
+  };
+  const waitPersisted = (target) => {
+    if (peerProtocol < 2 || persisted >= target || s.isTerminal()) return Promise.resolve();
+    return new Promise((resolve2) => creditWaiters.push({ target, resolve: resolve2 }));
+  };
+  const pump = async () => {
+    const meta = {
+      name: opts.file.name ?? opts.name ?? "zas",
+      size: opts.file.size,
+      mime: opts.file.type || "application/octet-stream",
+      ...opts.label !== void 0 ? { label: opts.label } : {}
+    };
+    dc.send(encodeMeta(meta));
+    const hasher = await createSHA256();
+    let sent = 0;
+    for (let off = 0; off < opts.file.size; off += DIRECT_RECEIVE_WINDOW_BYTES) {
+      const window = new Uint8Array(
+        await opts.file.slice(
+          off,
+          Math.min(off + DIRECT_RECEIVE_WINDOW_BYTES, opts.file.size)
+        ).arrayBuffer()
+      );
+      hasher.update(window);
+      if (s.isTerminal()) return;
+      for (let at = 0; at < window.length; at += DIRECT_CHUNK_BYTES - 1) {
+        if (dc.bufferedAmount > DIRECT_BUFFERED_HIGH) await waitLow();
+        if (s.isTerminal()) return;
+        const slice = window.subarray(at, Math.min(at + DIRECT_CHUNK_BYTES - 1, window.length));
+        dc.send(encodeChunk(slice));
+        sent += slice.length;
+        s.diag.bytes = sent;
+        opts.onProgress?.(sent, opts.file.size);
+      }
+      await waitPersisted(sent);
+      if (s.isTerminal()) return;
+    }
+    dc.send(encodeDone({ size: sent, sha256: hasher.digest() }));
+  };
+  dc.onopen = () => {
+    s.connected();
+    s.setPhase("flight");
+    void pc.getStats().then((stats) => {
+      const pair = pairFromStats(stats);
+      if (!pair) return;
+      s.diag.pairLocal = pair.local;
+      s.diag.pairRemote = pair.remote;
+      opts.onPath?.(pathOf(pair));
+    }).catch(() => void 0);
+    void pump().catch(() => s.fail("transfer"));
+  };
+  dc.onmessage = (e) => {
+    try {
+      const frame = parseFrame(e.data);
+      if (frame.type === "done") s.setPhase("done");
+      if (frame.type === "abort") s.fail("peer_abort");
+      if (frame.type === "credit") {
+        if (frame.received < persisted || frame.received > opts.file.size) throw new Error("bad_credit");
+        persisted = frame.received;
+        wakeCredits();
+      }
+    } catch {
+      s.fail("protocol");
+    }
+  };
+  dc.onclose = () => {
+    wakeCredits();
+    if (!s.isTerminal()) s.fail("peer_closed");
+  };
+  void (async () => {
+    const offer = await pc.createOffer();
+    await pc.setLocalDescription(offer);
+    plumbing.setLocalGeneration(generation);
+    plumbing.expectRemoteGeneration(generation);
+    await opts.send({ kind: "offer", sdp: offer.sdp, protocol: 2, generation });
+  })().catch(() => s.fail("signaling"));
+  return {
+    accept: (msg) => {
+      if (s.isTerminal()) return;
+      s.signaled();
+      if (msg.kind === "answer" && pc.signalingState === "have-local-offer") {
+        const answerGeneration = msg.generation ?? generation;
+        if (msg.generation !== void 0 && answerGeneration !== generation) return;
+        peerProtocol = msg.protocol === 2 ? 2 : 1;
+        plumbing.expectRemoteGeneration(answerGeneration);
+        void pc.setRemoteDescription({ type: "answer", sdp: msg.sdp }).then(() => plumbing.remoteDescriptionSet(answerGeneration)).catch(() => s.fail("signaling"));
+      }
+      if (msg.kind === "ice") plumbing.applyIce(msg.candidate, msg.generation);
+    },
+    close: () => {
+      if (!s.isTerminal() && dc.readyState === "open") {
+        try {
+          dc.send(ABORT_FRAME);
+        } catch {
+        }
+      }
+      wakeCredits();
+      s.cleanup();
+    }
+  };
+}
+
+// src/shared/direct-fallback.ts
+function createFallbackMeta(file) {
+  const key = crypto.getRandomValues(new Uint8Array(32));
+  const nonce = crypto.getRandomValues(new Uint8Array(8));
+  return {
+    v: 1,
+    name: file.name,
+    size: file.size,
+    mime: file.type,
+    key_b64: bytesToB64(key),
+    nonce_b64: bytesToB64(nonce),
+    part_bytes: DIRECT_FALLBACK_PART_BYTES,
+    tag_bytes: DIRECT_FALLBACK_TAG_BYTES,
+    part_count: directFallbackPartCount(file.size),
+    cipher_size: directFallbackCipherSize(file.size)
+  };
+}
+function fallbackMetaOf(value) {
+  const meta = value;
+  if (!meta || meta.v !== 1 || typeof meta.name !== "string" || meta.name.length === 0 || typeof meta.mime !== "string" || !Number.isSafeInteger(meta.size) || (meta.size ?? -1) < 0 || typeof meta.key_b64 !== "string" || typeof meta.nonce_b64 !== "string" || meta.part_bytes !== DIRECT_FALLBACK_PART_BYTES || meta.tag_bytes !== DIRECT_FALLBACK_TAG_BYTES || meta.part_count !== directFallbackPartCount(meta.size) || meta.cipher_size !== directFallbackCipherSize(meta.size)) throw new Error("bad_fallback_meta");
+  let key;
+  let nonce;
+  try {
+    key = b64ToBytes(meta.key_b64);
+    nonce = b64ToBytes(meta.nonce_b64);
+  } catch {
+    throw new Error("bad_fallback_meta");
+  }
+  if (key.length !== 32 || nonce.length !== 8) throw new Error("bad_fallback_meta");
+  return meta;
+}
+function partPlainBytes(meta, partNumber) {
+  if (!Number.isInteger(partNumber) || partNumber < 1 || partNumber > meta.part_count) {
+    throw new Error("bad_fallback_part");
+  }
+  if (partNumber < meta.part_count) return meta.part_bytes;
+  return meta.size - meta.part_bytes * (meta.part_count - 1);
+}
+function ivFor(meta, partNumber) {
+  const iv = new Uint8Array(12);
+  iv.set(b64ToBytes(meta.nonce_b64), 0);
+  new DataView(iv.buffer).setUint32(8, partNumber, false);
+  return iv;
+}
+function aadFor(offerId, partNumber, plainBytes) {
+  return new TextEncoder().encode(
+    `zas-direct-fallback-v1\0${offerId}\0${partNumber}\0${plainBytes}`
+  );
+}
+async function aesKey(meta) {
+  return crypto.subtle.importKey(
+    "raw",
+    b64ToBytes(meta.key_b64),
+    { name: "AES-GCM" },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+async function encryptFallbackPart(meta, offerId, partNumber, plain, key) {
+  const expected = partPlainBytes(meta, partNumber);
+  if (plain.length !== expected) throw new Error("bad_fallback_part_size");
+  const out = await crypto.subtle.encrypt(
+    {
+      name: "AES-GCM",
+      iv: ivFor(meta, partNumber),
+      additionalData: aadFor(offerId, partNumber, plain.length),
+      tagLength: 128
+    },
+    key ?? await aesKey(meta),
+    plain
+  );
+  return new Uint8Array(out);
+}
+var RETRIES = 3;
+var URL_BATCH = 16;
+var CONCURRENCY = 2;
+function aborted(signal) {
+  if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+}
+var pause = (ms, signal) => new Promise((resolve2, reject) => {
+  const timer = setTimeout(resolve2, ms);
+  signal?.addEventListener("abort", () => {
+    clearTimeout(timer);
+    reject(new DOMException("Aborted", "AbortError"));
+  }, { once: true });
+});
+async function uploadFallback(options) {
+  const { file, offerId, meta, signal } = options;
+  fallbackMetaOf(meta);
+  if (file.size !== meta.size || file.name !== meta.name) throw new Error("fallback_file_changed");
+  const key = await aesKey(meta);
+  const completed = [];
+  const partProgress = /* @__PURE__ */ new Map();
+  const report = () => options.onProgress?.(
+    Math.min(meta.cipher_size, [...partProgress.values()].reduce((sum, value) => sum + value, 0)),
+    meta.cipher_size
+  );
+  for (let first = 1; first <= meta.part_count; first += URL_BATCH) {
+    aborted(signal);
+    const count = Math.min(URL_BATCH, meta.part_count - first + 1);
+    const signed = await options.getUrls(first, count);
+    if (signed.length !== count || signed.some((entry, i) => entry.part_number !== first + i || typeof entry.url !== "string")) throw new Error("bad_fallback_urls");
+    let cursor = 0;
+    const workers = Array.from({ length: Math.min(CONCURRENCY, signed.length) }, async () => {
+      for (; ; ) {
+        const at = cursor++;
+        if (at >= signed.length) return;
+        const entry = signed[at];
+        const partNumber = entry.part_number;
+        const plainStart = (partNumber - 1) * meta.part_bytes;
+        const plainEnd = Math.min(file.size, plainStart + meta.part_bytes);
+        const plain = new Uint8Array(await file.slice(plainStart, plainEnd).arrayBuffer());
+        const cipher = await encryptFallbackPart(meta, offerId, partNumber, plain, key);
+        let etag = "";
+        let lastError;
+        for (let attempt = 0; attempt < RETRIES; attempt++) {
+          aborted(signal);
+          partProgress.set(partNumber, 0);
+          report();
+          try {
+            etag = await options.put(entry.url, cipher, signal, (loaded) => {
+              partProgress.set(partNumber, loaded);
+              report();
+            });
+            break;
+          } catch (error) {
+            lastError = error;
+            if (error.name === "AbortError") throw error;
+            if (attempt + 1 < RETRIES) {
+              options.onRetry?.();
+              await pause(250 * 2 ** attempt, signal);
+            }
+          }
+        }
+        if (!etag) throw lastError ?? new Error("fallback_put_failed");
+        completed.push({ partNumber, etag });
+      }
+    });
+    await Promise.all(workers);
+  }
+  return completed.sort((a, b) => a.partNumber - b.partNumber);
+}
+
 // src/shared/sharedchannel.ts
 import { xchacha20poly1305 as xchacha20poly13052 } from "@noble/ciphers/chacha";
 import { x25519 as x255192 } from "@noble/curves/ed25519";
@@ -943,399 +1571,49 @@ function resolveChannel(identity, grants, channel) {
   throw new ZasError("grant_missing", 0);
 }
 
-// src/jobs.ts
-import { randomUUID } from "node:crypto";
-var DEFAULT_WAIT_MS = 6e4;
-var HISTORY = 50;
-var JobRunner = class {
-  now;
-  waitMs;
-  /** Newest first, and trimmed. */
-  jobs = [];
-  /** Keyed on the job object, not its id, so a caller holding a job that has
-   *  already aged out of the list can still wait for it to finish. */
-  settled = /* @__PURE__ */ new WeakMap();
-  constructor(opts = {}) {
-    this.now = opts.now ?? (() => Date.now());
-    this.waitMs = opts.waitMs ?? DEFAULT_WAIT_MS;
-  }
-  start(kind, title, channel, work) {
-    const job = {
-      id: randomUUID(),
-      kind,
-      title,
-      channel,
-      started_at: this.now(),
-      phase: null,
-      status: "running"
-    };
-    this.jobs.unshift(job);
-    this.jobs.length = Math.min(this.jobs.length, HISTORY);
-    const report = (phase) => {
-      if (job.status === "running") job.phase = phase;
-    };
-    this.settled.set(job, work(report).then(
-      (result) => {
-        job.status = "done";
-        job.result = result;
-        return job;
-      },
-      (error) => {
-        job.status = "failed";
-        job.error = error instanceof ZasError ? {
-          code: error.code,
-          status: error.status,
-          sentence: humanSentence(error),
-          message: error.message,
-          ...error.retryAfterMs !== void 0 ? { retryAfterMs: error.retryAfterMs } : {},
-          ...error.serverCode !== void 0 ? { serverCode: error.serverCode } : {}
-        } : { code: "upload_failed", status: 0, sentence: humanSentence(new ZasError("upload_failed", 0)) };
-        return job;
+// src/send.ts
+import { promises as fsp } from "node:fs";
+import { basename, extname } from "node:path";
+
+// src/shared/chunker.ts
+import { blake3 as blake32 } from "hash-wasm";
+var gearPromise = null;
+function gearTable() {
+  if (!gearPromise) {
+    gearPromise = (async () => {
+      const table = new Uint32Array(256);
+      for (let i = 0; i < 256; i++) {
+        const hex = await blake32(new TextEncoder().encode(GEAR_SEED + i), 256);
+        table[i] = parseInt(hex.slice(0, 8), 16) >>> 0;
       }
-    ));
-    return job;
+      return table;
+    })();
   }
-  /** Resolves when the work settles, or when the wait runs out — the same job
-   *  object either way, so the caller reads `status` rather than guessing. */
-  async wait(job) {
-    const settled = this.settled.get(job);
-    if (!settled) return job;
-    let timer;
-    const deadline = new Promise((resolve2) => {
-      timer = setTimeout(() => resolve2(job), this.waitMs);
-    });
-    try {
-      return await Promise.race([settled, deadline]);
-    } finally {
-      clearTimeout(timer);
-    }
+  return gearPromise;
+}
+var AVG = 1 << CHUNK_AVG_BITS;
+var MASK_S = (1 << CHUNK_AVG_BITS + 2) - 1;
+var MASK_L = (1 << CHUNK_AVG_BITS - 2) - 1;
+function cutPoint(buf, gear, eof) {
+  const len = Math.min(buf.length, CHUNK_MAX);
+  if (buf.length < CHUNK_MAX && !eof) {
+    if (buf.length <= CHUNK_MIN) return null;
   }
-  list() {
-    return this.jobs.slice(0, HISTORY);
+  if (eof && len <= CHUNK_MIN) return len > 0 ? len : null;
+  let hash = 0;
+  const normal = Math.min(AVG, len);
+  let i = CHUNK_MIN;
+  for (; i < normal; i++) {
+    hash = (hash << 1 >>> 0) + gear[buf[i]] >>> 0;
+    if ((hash & MASK_S) === 0) return i + 1;
   }
-  get(id) {
-    return this.jobs.find((job) => job.id === id);
+  for (; i < len; i++) {
+    hash = (hash << 1 >>> 0) + gear[buf[i]] >>> 0;
+    if ((hash & MASK_L) === 0) return i + 1;
   }
-};
-
-// src/read.ts
-import { randomBytes } from "node:crypto";
-import {
-  closeSync,
-  existsSync as existsSync2,
-  mkdirSync as mkdirSync2,
-  mkdtempSync,
-  openSync,
-  renameSync as renameSync2,
-  rmdirSync,
-  statSync,
-  unlinkSync,
-  writeSync
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, extname, join as join2 } from "node:path";
-
-// src/shared/mle.ts
-import { xchacha20poly1305 as xchacha20poly13053 } from "@noble/ciphers/chacha";
-function chunkKeyFromF(f) {
-  return {
-    key: hkdf512(f, HKDF_INFO_CHUNK_KEY, 32),
-    nonce: hkdf512(f, HKDF_INFO_CHUNK_NONCE, 24)
-  };
-}
-async function encryptChunk(f, plaintext) {
-  const { key, nonce } = chunkKeyFromF(f);
-  const ciphertext = xchacha20poly13053(key, nonce).encrypt(plaintext);
-  const blobId = await blake3Hex(ciphertext);
-  return { ciphertext, blobId, key, nonce };
-}
-function decryptChunk(key, nonce, ciphertext) {
-  return xchacha20poly13053(key, nonce).decrypt(ciphertext);
-}
-
-// src/read.ts
-var DEFAULT_LIMIT = 20;
-var MAX_LIMIT = 50;
-var DOWNLOAD_PREFIX = "zas-agent-";
-var ID_SEGMENT = /^(?!__)[A-Za-z0-9_-]{1,128}$/;
-var MAX_CHUNKS = 8192;
-var MAX_DUPLICATES = 100;
-function stringOf(value) {
-  return typeof value?.stringValue === "string" ? value.stringValue : void 0;
-}
-function timeOf(value) {
-  const parsed = typeof value?.timestampValue === "string" ? Date.parse(value.timestampValue) : NaN;
-  return Number.isFinite(parsed) ? parsed : null;
-}
-function rowOf(doc) {
-  const document = doc ?? {};
-  const name = typeof document.name === "string" ? document.name : "";
-  const fields = document.fields && typeof document.fields === "object" ? document.fields : {};
-  return {
-    id: name.slice(name.lastIndexOf("/") + 1),
-    manifestEnc: stringOf(fields.manifest_enc),
-    agent: stringOf(fields.agent),
-    createdAt: timeOf(fields.created_at),
-    expiresAt: timeOf(fields.expires_at),
-    bar: fields.bar?.booleanValue === true
-  };
-}
-function readable(row) {
-  if (!row.id || row.bar || !row.manifestEnc) return false;
-  return row.expiresAt === null || row.expiresAt > Date.now();
-}
-function openFor(channelKey, row) {
-  try {
-    return openManifest(channelKey, b64ToBytes(row.manifestEnc));
-  } catch {
-    return null;
-  }
-}
-function summaryOf(row, manifest) {
-  const kind = manifest.kind === "text" ? "text" : "file";
-  const name = typeof manifest.name === "string" ? manifest.name : "";
-  return {
-    id: row.id,
-    kind,
-    // Absence means "show the file name": the sender chose no title.
-    title: manifest.title ?? name,
-    name,
-    mime: typeof manifest.mime === "string" ? manifest.mime : "application/octet-stream",
-    size: typeof manifest.size === "number" ? manifest.size : 0,
-    // The sealed time is the sender's own; the row's is the server's, and it
-    // only answers for a manifest that carries none.
-    created_at: typeof manifest.created_at === "string" && manifest.created_at ? manifest.created_at : row.createdAt !== null ? new Date(row.createdAt).toISOString() : "",
-    by_agent: row.agent !== void 0,
-    ...kind === "text" ? { text: manifest.text ?? "" } : {}
-  };
-}
-async function readGrant(ctx, channel) {
-  const grant = resolveChannel(ctx.identity, await grantsFor(ctx.client, ctx.profile), channel);
-  if (!grant.read) throw new ZasError("read_forbidden", 403);
-  return grant;
-}
-function nameFrom(channelKey, grant) {
-  try {
-    return decryptChannelName(channelKey, b64ToBytes(grant.name_enc));
-  } catch {
-    throw new ZasError("key_stale", 0);
-  }
-}
-function linksParent(identity, grant) {
-  return `accounts/${identity.owner_uid}/channels/${grant.channel_id}`;
-}
-function linkPath(identity, grant, id) {
-  return `projects/${identity.firestore_project}/databases/(default)/documents/${linksParent(identity, grant)}/links/${id}`;
-}
-async function queryLinks(ctx, grant, query) {
-  try {
-    return await ctx.client.firestoreRunQuery(linksParent(ctx.identity, grant), query);
-  } catch (err) {
-    if (err instanceof ZasError && err.status === 403) throw new ZasError("read_forbidden", 403);
-    throw err;
-  }
-}
-function clampLimit(limit) {
-  if (limit === void 0 || !Number.isFinite(limit)) return DEFAULT_LIMIT;
-  return Math.min(MAX_LIMIT, Math.max(1, Math.trunc(limit)));
-}
-async function listItems(ctx, channel, limit) {
-  const grant = await readGrant(ctx, channel);
-  const channelKey = channelKeyOf(ctx.identity, grant);
-  const docs = await queryLinks(ctx, grant, {
-    from: [{ collectionId: "links" }],
-    orderBy: [{ field: { fieldPath: "created_at" }, direction: "DESCENDING" }],
-    limit: clampLimit(limit)
-  });
-  const items = [];
-  for (const doc of docs) {
-    const row = rowOf(doc);
-    if (!readable(row)) continue;
-    const manifest = openFor(channelKey, row);
-    if (!manifest) continue;
-    items.push(summaryOf(row, manifest));
-  }
-  return {
-    channel_id: grant.channel_id,
-    channel_name: nameFrom(channelKey, grant),
-    items
-  };
-}
-function redeemFailure(status) {
-  if (status === 429) return new ZasError("rate_limited", 429);
-  if (status >= 500) return new ZasError("network", status);
-  return new ZasError("invalid_cap", 403);
-}
-async function fetchChunk(ctx, chunk) {
-  if (typeof chunk.cap !== "string" || chunk.cap === "") throw new ZasError("invalid_cap", 403);
-  let headers = {};
-  try {
-    headers = { Authorization: `Bearer ${await ctx.client.idToken()}` };
-  } catch {
-    headers = {};
-  }
-  let url;
-  try {
-    const redeemed = await apiPublic(
-      ctx.identity.api_base,
-      "POST",
-      "/v1/blobs/redeem",
-      { cap: chunk.cap },
-      headers
-    );
-    url = typeof redeemed.url === "string" ? redeemed.url : "";
-  } catch (err) {
-    if (err instanceof ZasError) throw redeemFailure(err.status);
-    throw err;
-  }
-  if (url === "") throw new ZasError("invalid_cap", 403);
-  const res = await fetch(url);
-  if (!res.ok) {
-    await res.body?.cancel().catch(() => void 0);
-    throw res.status >= 500 ? new ZasError("network", res.status) : new ZasError("invalid_cap", 403);
-  }
-  const ciphertext = new Uint8Array(await res.arrayBuffer());
-  try {
-    return decryptChunk(b64ToBytes(chunk.key), b64ToBytes(chunk.nonce), ciphertext);
-  } catch {
-    throw new ZasError("invalid_cap", 403);
-  }
-}
-function safeName(name, fallback) {
-  const base = (typeof name === "string" ? name : "").split(/[\\/]/).pop() ?? "";
-  return base.replace(/^\.+/, "").trim() || fallback;
-}
-function freeName(target) {
-  if (!existsSync2(target)) return target;
-  const ext = extname(target);
-  const stem = target.slice(0, target.length - ext.length);
-  for (let n = 1; n <= MAX_DUPLICATES; n++) {
-    const candidate = `${stem} (${n})${ext}`;
-    if (!existsSync2(candidate)) return candidate;
-  }
-  throw new ZasError("write_failed", 0, target);
-}
-function destinationOf(dest, name, fallback) {
-  const base = safeName(name, fallback);
-  if (dest === void 0) {
-    const created = mkdtempSync(join2(tmpdir(), DOWNLOAD_PREFIX));
-    return { target: freeName(join2(created, base)), created };
-  }
-  const at = statSync(dest, { throwIfNoEntry: false })?.isDirectory() ? join2(dest, base) : dest;
-  return { target: freeName(at) };
-}
-async function getItem(ctx, channel, id, dest) {
-  const grant = await readGrant(ctx, channel);
-  if (!ID_SEGMENT.test(id)) throw new ZasError("not_found", 404);
-  const channelKey = channelKeyOf(ctx.identity, grant);
-  const docs = await queryLinks(ctx, grant, {
-    from: [{ collectionId: "links" }],
-    where: {
-      fieldFilter: {
-        field: { fieldPath: "__name__" },
-        op: "EQUAL",
-        value: { referenceValue: linkPath(ctx.identity, grant, id) }
-      }
-    },
-    limit: 1
-  });
-  const row = docs.length > 0 ? rowOf(docs[0]) : null;
-  if (!row || !readable(row)) throw new ZasError("not_found", 404);
-  const manifest = openFor(channelKey, row);
-  if (!manifest) throw new ZasError("not_found", 404);
-  if (manifest.kind === "text") {
-    const text2 = manifest.text ?? "";
-    return { text: text2, bytes: new TextEncoder().encode(text2).length };
-  }
-  if (manifest.chunks.length === 0) throw new ZasError("not_found", 404);
-  if (manifest.chunks.length > MAX_CHUNKS) throw new ZasError("not_found", 404);
-  let target;
-  let created;
-  let tmp;
-  let fd;
-  let written = 0;
-  try {
-    const chosen = destinationOf(dest, manifest.name, row.id);
-    target = chosen.target;
-    created = chosen.created;
-    mkdirSync2(dirname(target), { recursive: true, mode: 448 });
-    tmp = `${target}.${randomBytes(6).toString("hex")}.tmp`;
-    fd = openSync(tmp, "wx", 384);
-    for (const chunk of manifest.chunks) {
-      written += writeSync(fd, await fetchChunk(ctx, chunk));
-    }
-    const size = typeof manifest.size === "number" ? manifest.size : 0;
-    if (size > 0 && written !== size) throw new ZasError("not_found", 404);
-    closeSync(fd);
-    fd = void 0;
-    renameSync2(tmp, target);
-  } catch (err) {
-    if (err instanceof ZasError) throw err;
-    const failure = err;
-    if (typeof failure.syscall === "string" || typeof failure.errno === "number") {
-      throw new ZasError("write_failed", 0, failure.message);
-    }
-    throw new ZasError("network", 0, String(err?.message ?? err));
-  } finally {
-    if (fd !== void 0) try {
-      closeSync(fd);
-    } catch {
-    }
-    if (tmp !== void 0 && existsSync2(tmp)) try {
-      unlinkSync(tmp);
-    } catch {
-    }
-    if (created !== void 0) try {
-      rmdirSync(created);
-    } catch {
-    }
-  }
-  return { path: target, bytes: written };
-}
-
-// src/send.ts
-import { promises as fsp } from "node:fs";
-import { basename, extname as extname2 } from "node:path";
-
-// src/shared/chunker.ts
-import { blake3 as blake32 } from "hash-wasm";
-var gearPromise = null;
-function gearTable() {
-  if (!gearPromise) {
-    gearPromise = (async () => {
-      const table = new Uint32Array(256);
-      for (let i = 0; i < 256; i++) {
-        const hex = await blake32(new TextEncoder().encode(GEAR_SEED + i), 256);
-        table[i] = parseInt(hex.slice(0, 8), 16) >>> 0;
-      }
-      return table;
-    })();
-  }
-  return gearPromise;
-}
-var AVG = 1 << CHUNK_AVG_BITS;
-var MASK_S = (1 << CHUNK_AVG_BITS + 2) - 1;
-var MASK_L = (1 << CHUNK_AVG_BITS - 2) - 1;
-function cutPoint(buf, gear, eof) {
-  const len = Math.min(buf.length, CHUNK_MAX);
-  if (buf.length < CHUNK_MAX && !eof) {
-    if (buf.length <= CHUNK_MIN) return null;
-  }
-  if (eof && len <= CHUNK_MIN) return len > 0 ? len : null;
-  let hash = 0;
-  const normal = Math.min(AVG, len);
-  let i = CHUNK_MIN;
-  for (; i < normal; i++) {
-    hash = (hash << 1 >>> 0) + gear[buf[i]] >>> 0;
-    if ((hash & MASK_S) === 0) return i + 1;
-  }
-  for (; i < len; i++) {
-    hash = (hash << 1 >>> 0) + gear[buf[i]] >>> 0;
-    if ((hash & MASK_L) === 0) return i + 1;
-  }
-  if (len === CHUNK_MAX) return CHUNK_MAX;
-  if (eof) return len > 0 ? len : null;
-  return null;
+  if (len === CHUNK_MAX) return CHUNK_MAX;
+  if (eof) return len > 0 ? len : null;
+  return null;
 }
 async function* chunkStream(source) {
   const gear = await gearTable();
@@ -1371,6 +1649,24 @@ async function* chunkStream(source) {
   yield* drain(true);
 }
 
+// src/shared/mle.ts
+import { xchacha20poly1305 as xchacha20poly13053 } from "@noble/ciphers/chacha";
+function chunkKeyFromF(f) {
+  return {
+    key: hkdf512(f, HKDF_INFO_CHUNK_KEY, 32),
+    nonce: hkdf512(f, HKDF_INFO_CHUNK_NONCE, 24)
+  };
+}
+async function encryptChunk(f, plaintext) {
+  const { key, nonce } = chunkKeyFromF(f);
+  const ciphertext = xchacha20poly13053(key, nonce).encrypt(plaintext);
+  const blobId = await blake3Hex(ciphertext);
+  return { ciphertext, blobId, key, nonce };
+}
+function decryptChunk(key, nonce, ciphertext) {
+  return xchacha20poly13053(key, nonce).decrypt(ciphertext);
+}
+
 // src/shared/oprf.ts
 import { RistrettoPoint } from "@noble/curves/ed25519";
 import { sha512 as sha5122 } from "@noble/hashes/sha2";
@@ -1527,7 +1823,7 @@ var MIME = new Map(Object.entries({
   xml: "application/xml"
 }));
 function mimeFor(path) {
-  return MIME.get(extname2(path).slice(1).toLowerCase()) ?? "application/octet-stream";
+  return MIME.get(extname(path).slice(1).toLowerCase()) ?? "application/octet-stream";
 }
 async function mapLimit(items, limit, work) {
   const out = new Array(items.length);
@@ -1755,128 +2051,711 @@ async function sendFile(ctx, input, onPhase) {
       replayed: true
     };
   }
-  onPhase?.("hashing");
-  const plains = [];
-  for await (const piece of chunkStream([bytes])) plains.push(piece);
-  const hashes = await Promise.all(plains.map((p) => blake3Bytes(p)));
-  const blinds = hashes.map((h) => oprfBlind(h));
-  const evaluated = [];
-  for (const slice of batches(blinds.map((b) => bytesToB64(b.blindedElement)), sliceSize(ctx))) {
-    const answers = await ctx.client.oprfEvaluate(slice);
-    if (answers.length !== slice.length) throw new ZasError("oprf_failed", 0);
-    for (const one of answers) evaluated.push(one);
-  }
-  onPhase?.("encrypting");
-  const encs = await Promise.all(plains.map(
-    (plain, i) => encryptChunk(oprfFinalize(hashes[i], blinds[i].blind, b64ToBytes(evaluated[i])), plain)
-  ));
-  onPhase?.("uploading");
-  const placed = await placeChunks(ctx, encs);
-  onPhase?.("finishing");
-  const mime = mimeFor(input.path);
-  const thumb = await thumbnailFor(bytes, mime);
+  onPhase?.("hashing");
+  const plains = [];
+  for await (const piece of chunkStream([bytes])) plains.push(piece);
+  const hashes = await Promise.all(plains.map((p) => blake3Bytes(p)));
+  const blinds = hashes.map((h) => oprfBlind(h));
+  const evaluated = [];
+  for (const slice of batches(blinds.map((b) => bytesToB64(b.blindedElement)), sliceSize(ctx))) {
+    const answers = await ctx.client.oprfEvaluate(slice);
+    if (answers.length !== slice.length) throw new ZasError("oprf_failed", 0);
+    for (const one of answers) evaluated.push(one);
+  }
+  onPhase?.("encrypting");
+  const encs = await Promise.all(plains.map(
+    (plain, i) => encryptChunk(oprfFinalize(hashes[i], blinds[i].blind, b64ToBytes(evaluated[i])), plain)
+  ));
+  onPhase?.("uploading");
+  const placed = await placeChunks(ctx, encs);
+  onPhase?.("finishing");
+  const mime = mimeFor(input.path);
+  const thumb = await thumbnailFor(bytes, mime);
+  const manifest = newManifest({
+    kind: "file",
+    name,
+    // Only when the caller chose one: absence means "show the file name", and
+    // writing the file name into `title` would make a rename look deliberate.
+    ...input.title !== void 0 ? { title: input.title } : {},
+    mime,
+    size: bytes.length,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...thumb ? { thumb_data: thumb } : {},
+    chunks: placed.map((p) => p.entry)
+  });
+  const linkId = await postLink(
+    ctx,
+    grant,
+    manifest,
+    placed,
+    agentSendIdempotencyKey(grant.channel_id, contentHash, title)
+  );
+  const deduplicated = placed.filter((p) => p.proven).length;
+  remember(ctx, key, {
+    link_id: linkId,
+    bytes: bytes.length,
+    chunks: placed.length,
+    deduplicated,
+    at: Date.now()
+  });
+  return {
+    link_id: linkId,
+    channel_id: grant.channel_id,
+    channel_name: channelNameOf(ctx.identity, grant),
+    bytes: bytes.length,
+    chunks: placed.length,
+    deduplicated,
+    replayed: false
+  };
+}
+function noteName(text2) {
+  return text2.split("\n", 1)[0].trim().slice(0, NOTE_NAME_MAX) || "nota";
+}
+async function sendNote(ctx, input) {
+  const grant = await grantFor(ctx, input.channel);
+  const name = input.title ?? noteName(input.text);
+  const encoded = new TextEncoder().encode(input.text);
+  const contentHash = await blake3Hex(new TextEncoder().encode(
+    `${input.lang ?? ""}\0${input.secret ? "1" : "0"}\0${input.text}`
+  ));
+  const key = await receiptKey(ctx, grant.channel_id, contentHash, name);
+  const stored = receiptFor(ctx, key);
+  if (stored) {
+    return {
+      link_id: stored.link_id,
+      channel_id: grant.channel_id,
+      channel_name: channelNameOf(ctx.identity, grant),
+      bytes: stored.bytes,
+      chunks: 0,
+      deduplicated: 0,
+      replayed: true
+    };
+  }
   const manifest = newManifest({
-    kind: "file",
+    kind: "text",
     name,
-    // Only when the caller chose one: absence means "show the file name", and
-    // writing the file name into `title` would make a rename look deliberate.
     ...input.title !== void 0 ? { title: input.title } : {},
-    mime,
-    size: bytes.length,
+    mime: "text/plain",
+    size: encoded.length,
     created_at: (/* @__PURE__ */ new Date()).toISOString(),
-    ...thumb ? { thumb_data: thumb } : {},
-    chunks: placed.map((p) => p.entry)
+    text: input.text,
+    ...input.lang ? { code: { lang: input.lang, auto: false } } : {},
+    // Only ever true or absent, exactly as the note cover is defined: absent is
+    // "the sender did not classify", which no receiver may read as safe.
+    ...input.secret ? { sensitive: true } : {},
+    chunks: []
   });
   const linkId = await postLink(
     ctx,
     grant,
     manifest,
-    placed,
-    agentSendIdempotencyKey(grant.channel_id, contentHash, title)
+    [],
+    agentSendIdempotencyKey(grant.channel_id, contentHash, name)
   );
-  const deduplicated = placed.filter((p) => p.proven).length;
   remember(ctx, key, {
     link_id: linkId,
-    bytes: bytes.length,
-    chunks: placed.length,
-    deduplicated,
+    bytes: encoded.length,
+    chunks: 0,
+    deduplicated: 0,
     at: Date.now()
   });
   return {
     link_id: linkId,
     channel_id: grant.channel_id,
     channel_name: channelNameOf(ctx.identity, grant),
-    bytes: bytes.length,
-    chunks: placed.length,
-    deduplicated,
+    bytes: encoded.length,
+    chunks: 0,
+    deduplicated: 0,
     replayed: false
   };
 }
-function noteName(text2) {
-  return text2.split("\n", 1)[0].trim().slice(0, NOTE_NAME_MAX) || "nota";
+
+// src/direct.ts
+var OFFER_WAIT_MS = 9.5 * 60 * 1e3;
+var OFFER_POLL_MS = 1e3;
+var SIGNAL_POLL_MS = 400;
+var HEARTBEAT_MS = 4 * 60 * 1e3;
+var SIGNALS_FOR_SENDER = {
+  from: [{ collectionId: "signals" }],
+  where: { fieldFilter: { field: { fieldPath: "for" }, op: "EQUAL", value: { stringValue: "sender" } } }
+};
+var stringField = (doc, key) => doc?.fields?.[key]?.stringValue;
+var defaultSleep2 = (ms) => new Promise((resolve2) => {
+  setTimeout(resolve2, ms);
+});
+var newDeviceToken = () => randomBytes(16).toString("base64url");
+var webrtc = null;
+function installWebRtc() {
+  if (!webrtc) {
+    webrtc = import("node-datachannel/polyfill").then((poly) => {
+      const g = globalThis;
+      g.RTCPeerConnection ??= poly.RTCPeerConnection;
+      g.RTCIceCandidate ??= poly.RTCIceCandidate;
+      g.RTCSessionDescription ??= poly.RTCSessionDescription;
+      g.RTCDataChannel ??= poly.RTCDataChannel;
+    }, (error) => {
+      webrtc = null;
+      throw new ZasError("webrtc_unavailable", 0, String(error));
+    });
+  }
+  return webrtc;
+}
+async function directGrantFor(ctx, channel) {
+  const grant = resolveChannel(ctx.identity, await grantsFor(ctx.client, ctx.profile), channel);
+  if (!grant.send || grant.mode === "view") throw new ZasError("send_forbidden", 403);
+  if (!grant.direct_mode) throw new ZasError("not_direct_mode", 409);
+  return grant;
+}
+function nameOf(ctx, grant) {
+  try {
+    return channelNameOf(ctx.identity, grant);
+  } catch {
+    return grant.channel_id;
+  }
+}
+function sealer(key, keyVersion) {
+  return {
+    seal: (value) => bytesToB64(sealRaw(key, keyVersion, new TextEncoder().encode(JSON.stringify(value)))),
+    open: (enc) => JSON.parse(new TextDecoder().decode(openRaw(key, b64ToBytes(enc))))
+  };
+}
+async function sendDirect(ctx, input, report, deps = {}) {
+  const now = deps.now ?? (() => Date.now());
+  const sleep2 = deps.sleep ?? defaultSleep2;
+  const grant = await directGrantFor(ctx, input.channel);
+  const key = channelKeyOf(ctx.identity, grant);
+  const channelName = nameOf(ctx, grant);
+  const file = await (deps.openFile ?? openAsBlob)(input.path).catch(() => {
+    throw new ZasError("upload_failed", 400);
+  });
+  if (file.size > DIRECT_FILE_MAX_BYTES) throw new ZasError("file_too_big", 413);
+  const name = basename2(input.path);
+  const cid = grant.channel_id;
+  const owner = ctx.identity.owner_uid;
+  const device = deps.device ?? newDeviceToken();
+  const { seal, open } = sealer(key, grant.key_version);
+  const stamp = { device, owner_uid: owner };
+  const startedAt = now();
+  report("offer");
+  const meta = { name, size: file.size, mime: mimeFor(input.path) };
+  const { id } = await ctx.client.api("POST", `/direct/${cid}`, {
+    meta_enc: seal(meta),
+    key_version: grant.key_version,
+    sender_label_enc: seal(ctx.identity.name),
+    size_bytes: file.size,
+    ...stamp
+  });
+  const route = `/direct/${cid}/${id}`;
+  const offerPath = `accounts/${owner}/channels/${cid}/direct/${id}`;
+  const setState = (state) => ctx.client.api("POST", `${route}/state`, { state, ...stamp }).then(() => void 0, () => void 0);
+  const claimBy = startedAt + (deps.offerWaitMs ?? OFFER_WAIT_MS);
+  for (; ; ) {
+    const doc = await ctx.client.firestoreGet(offerPath);
+    const state = doc === null ? "cancelled" : stringField(doc, "state") ?? "open";
+    if (state === "claimed") break;
+    if (state !== "open") throw new ZasError("direct_cancelled", 0);
+    if (now() >= claimBy) {
+      await setState("cancelled");
+      throw new ZasError("not_claimed", 0);
+    }
+    await sleep2(deps.offerPollMs ?? OFFER_POLL_MS);
+  }
+  await (deps.installWebRtc ?? installWebRtc)();
+  const fetchIce = async () => {
+    try {
+      const r = await ctx.client.api("POST", `${route}/ice`, stamp);
+      return Array.isArray(r.ice) ? r.ice : [];
+    } catch {
+      return [];
+    }
+  };
+  const turn = await fetchIce();
+  report("connecting");
+  let resolveOutcome;
+  const outcome = new Promise((resolve2) => {
+    resolveOutcome = resolve2;
+  });
+  let diag;
+  let path;
+  let heartbeat;
+  const handle = (deps.engine ?? startSender)({
+    file,
+    name,
+    label: ctx.identity.name,
+    ice: [...DIRECT_ICE, ...turn],
+    refreshIce: async () => [...DIRECT_ICE, ...await fetchIce()],
+    send: (msg) => ctx.client.api("POST", `${route}/signal`, { payload_enc: seal(msg), for: "receiver", ...stamp }).then(() => void 0),
+    onPhase: (phase2) => {
+      if (phase2 === "flight") {
+        report("flight");
+        heartbeat ??= setInterval(() => {
+          void ctx.client.api("POST", `${route}/heartbeat`, stamp).catch(() => void 0);
+        }, deps.heartbeatMs ?? HEARTBEAT_MS);
+      }
+      if (phase2 === "done" || phase2 === "failed") resolveOutcome(phase2);
+    },
+    onPath: (p) => {
+      path = p;
+    },
+    onDiag: (d) => {
+      diag = d;
+    }
+  });
+  let over = false;
+  const pump = (async () => {
+    const seen = /* @__PURE__ */ new Set();
+    while (!over) {
+      let rows = [];
+      try {
+        rows = await ctx.client.firestoreRunQuery(offerPath, SIGNALS_FOR_SENDER);
+      } catch {
+      }
+      for (const row of rows) {
+        if (!row?.name || seen.has(row.name)) continue;
+        seen.add(row.name);
+        const enc = stringField(row, "payload_enc");
+        if (!enc) continue;
+        try {
+          handle.accept(open(enc));
+        } catch {
+        }
+      }
+      if (!over) await Promise.race([outcome, sleep2(deps.signalPollMs ?? SIGNAL_POLL_MS)]);
+    }
+  })();
+  const phase = await outcome;
+  over = true;
+  clearInterval(heartbeat);
+  await pump;
+  report("finishing");
+  if (phase === "done") {
+    await setState("done");
+    return {
+      offer_id: id,
+      channel_id: cid,
+      channel_name: channelName,
+      bytes: file.size,
+      ...path ? { path } : {},
+      duration_ms: now() - startedAt
+    };
+  }
+  await setState("failed");
+  const reason = diag?.reason || "unknown";
+  deps.onFailed?.({
+    channel_id: cid,
+    channel_name: channelName,
+    offer_id: id,
+    owner_uid: owner,
+    device,
+    path: input.path,
+    name,
+    size: file.size,
+    key,
+    key_version: grant.key_version,
+    reason
+  });
+  throw new ZasError("direct_failed", 0, reason);
+}
+var fetchPut = async (url, bytes, signal, onLoaded) => {
+  const body = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+  const res = await fetch(url, { method: "PUT", body, signal });
+  await res.body?.cancel().catch(() => void 0);
+  if (!res.ok) throw new Error(`fallback_put_${res.status}`);
+  const etag = res.headers.get("etag");
+  if (!etag) throw new Error("fallback_etag_missing");
+  onLoaded(bytes.length);
+  return etag;
+};
+async function sendDirectFallback(ctx, record, report, deps = {}) {
+  const now = deps.now ?? (() => Date.now());
+  const startedAt = now();
+  const opened = await (deps.openFile ?? openAsBlob)(record.path).catch(() => {
+    throw new ZasError("upload_failed", 400);
+  });
+  if (opened.size !== record.size) throw new ZasError("file_changed", 0);
+  const file = new File([opened], record.name, { type: mimeFor(record.path) });
+  const { seal } = sealer(record.key, record.key_version);
+  const stamp = { device: record.device, owner_uid: record.owner_uid };
+  const base = `/direct/${record.channel_id}/${record.offer_id}/fallback`;
+  report("encrypting");
+  const meta = createFallbackMeta(file);
+  await ctx.client.api("POST", `${base}/start`, {
+    meta_enc: seal(meta),
+    plain_size: meta.size,
+    cipher_size: meta.cipher_size,
+    part_count: meta.part_count,
+    ...stamp
+  });
+  report("uploading");
+  let parts;
+  try {
+    parts = await uploadFallback({
+      file,
+      offerId: record.offer_id,
+      meta,
+      put: deps.put ?? fetchPut,
+      getUrls: async (from, count) => {
+        const r = await ctx.client.api(
+          "POST",
+          `${base}/parts`,
+          { from, count, ...stamp }
+        );
+        return r.urls;
+      }
+    });
+  } catch (error) {
+    await ctx.client.api("POST", `${base}/abort`, stamp).catch(() => void 0);
+    if (error instanceof ZasError) throw error;
+    throw new ZasError("upload_failed", 0, error instanceof Error ? error.message : String(error));
+  }
+  report("finishing");
+  await ctx.client.api("POST", `${base}/complete`, {
+    parts: parts.map((part) => ({ part_number: part.partNumber, etag: part.etag })),
+    ...stamp
+  });
+  return {
+    offer_id: record.offer_id,
+    channel_id: record.channel_id,
+    channel_name: record.channel_name,
+    bytes: record.size,
+    duration_ms: now() - startedAt,
+    parts: parts.length
+  };
+}
+
+// src/jobs.ts
+import { randomUUID } from "node:crypto";
+var DEFAULT_WAIT_MS = 6e4;
+var HISTORY = 50;
+var JobRunner = class {
+  now;
+  waitMs;
+  /** Newest first, and trimmed. */
+  jobs = [];
+  /** Keyed on the job object, not its id, so a caller holding a job that has
+   *  already aged out of the list can still wait for it to finish. */
+  settled = /* @__PURE__ */ new WeakMap();
+  constructor(opts = {}) {
+    this.now = opts.now ?? (() => Date.now());
+    this.waitMs = opts.waitMs ?? DEFAULT_WAIT_MS;
+  }
+  start(kind, title, channel, work) {
+    const job = {
+      id: randomUUID(),
+      kind,
+      title,
+      channel,
+      started_at: this.now(),
+      phase: null,
+      status: "running"
+    };
+    this.jobs.unshift(job);
+    this.jobs.length = Math.min(this.jobs.length, HISTORY);
+    const report = (phase) => {
+      if (job.status === "running") job.phase = phase;
+    };
+    this.settled.set(job, work(report).then(
+      (result) => {
+        job.status = "done";
+        job.result = result;
+        return job;
+      },
+      (error) => {
+        job.status = "failed";
+        job.error = error instanceof ZasError ? {
+          code: error.code,
+          status: error.status,
+          sentence: humanSentence(error),
+          message: error.message,
+          ...error.retryAfterMs !== void 0 ? { retryAfterMs: error.retryAfterMs } : {},
+          ...error.serverCode !== void 0 ? { serverCode: error.serverCode } : {}
+        } : { code: "upload_failed", status: 0, sentence: humanSentence(new ZasError("upload_failed", 0)) };
+        return job;
+      }
+    ));
+    return job;
+  }
+  /** Resolves when the work settles, or when the wait runs out — the same job
+   *  object either way, so the caller reads `status` rather than guessing. */
+  async wait(job) {
+    const settled = this.settled.get(job);
+    if (!settled) return job;
+    let timer;
+    const deadline = new Promise((resolve2) => {
+      timer = setTimeout(() => resolve2(job), this.waitMs);
+    });
+    try {
+      return await Promise.race([settled, deadline]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  list() {
+    return this.jobs.slice(0, HISTORY);
+  }
+  get(id) {
+    return this.jobs.find((job) => job.id === id);
+  }
+};
+
+// src/read.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import {
+  closeSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  mkdtempSync,
+  openSync,
+  renameSync as renameSync2,
+  rmdirSync,
+  statSync,
+  unlinkSync,
+  writeSync
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, extname as extname2, join as join2 } from "node:path";
+var DEFAULT_LIMIT = 20;
+var MAX_LIMIT = 50;
+var DOWNLOAD_PREFIX = "zas-agent-";
+var ID_SEGMENT = /^(?!__)[A-Za-z0-9_-]{1,128}$/;
+var MAX_CHUNKS = 8192;
+var MAX_DUPLICATES = 100;
+function stringOf(value) {
+  return typeof value?.stringValue === "string" ? value.stringValue : void 0;
+}
+function timeOf(value) {
+  const parsed = typeof value?.timestampValue === "string" ? Date.parse(value.timestampValue) : NaN;
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function rowOf(doc) {
+  const document = doc ?? {};
+  const name = typeof document.name === "string" ? document.name : "";
+  const fields = document.fields && typeof document.fields === "object" ? document.fields : {};
+  return {
+    id: name.slice(name.lastIndexOf("/") + 1),
+    manifestEnc: stringOf(fields.manifest_enc),
+    agent: stringOf(fields.agent),
+    createdAt: timeOf(fields.created_at),
+    expiresAt: timeOf(fields.expires_at),
+    bar: fields.bar?.booleanValue === true
+  };
+}
+function readable(row) {
+  if (!row.id || row.bar || !row.manifestEnc) return false;
+  return row.expiresAt === null || row.expiresAt > Date.now();
+}
+function openFor(channelKey, row) {
+  try {
+    return openManifest(channelKey, b64ToBytes(row.manifestEnc));
+  } catch {
+    return null;
+  }
+}
+function summaryOf(row, manifest) {
+  const kind = manifest.kind === "text" ? "text" : "file";
+  const name = typeof manifest.name === "string" ? manifest.name : "";
+  return {
+    id: row.id,
+    kind,
+    // Absence means "show the file name": the sender chose no title.
+    title: manifest.title ?? name,
+    name,
+    mime: typeof manifest.mime === "string" ? manifest.mime : "application/octet-stream",
+    size: typeof manifest.size === "number" ? manifest.size : 0,
+    // The sealed time is the sender's own; the row's is the server's, and it
+    // only answers for a manifest that carries none.
+    created_at: typeof manifest.created_at === "string" && manifest.created_at ? manifest.created_at : row.createdAt !== null ? new Date(row.createdAt).toISOString() : "",
+    by_agent: row.agent !== void 0,
+    ...kind === "text" ? { text: manifest.text ?? "" } : {}
+  };
+}
+async function readGrant(ctx, channel) {
+  const grant = resolveChannel(ctx.identity, await grantsFor(ctx.client, ctx.profile), channel);
+  if (!grant.read) throw new ZasError("read_forbidden", 403);
+  return grant;
 }
-async function sendNote(ctx, input) {
-  const grant = await grantFor(ctx, input.channel);
-  const name = input.title ?? noteName(input.text);
-  const encoded = new TextEncoder().encode(input.text);
-  const contentHash = await blake3Hex(new TextEncoder().encode(
-    `${input.lang ?? ""}\0${input.secret ? "1" : "0"}\0${input.text}`
-  ));
-  const key = await receiptKey(ctx, grant.channel_id, contentHash, name);
-  const stored = receiptFor(ctx, key);
-  if (stored) {
-    return {
-      link_id: stored.link_id,
-      channel_id: grant.channel_id,
-      channel_name: channelNameOf(ctx.identity, grant),
-      bytes: stored.bytes,
-      chunks: 0,
-      deduplicated: 0,
-      replayed: true
-    };
+function nameFrom(channelKey, grant) {
+  try {
+    return decryptChannelName(channelKey, b64ToBytes(grant.name_enc));
+  } catch {
+    throw new ZasError("key_stale", 0);
   }
-  const manifest = newManifest({
-    kind: "text",
-    name,
-    ...input.title !== void 0 ? { title: input.title } : {},
-    mime: "text/plain",
-    size: encoded.length,
-    created_at: (/* @__PURE__ */ new Date()).toISOString(),
-    text: input.text,
-    ...input.lang ? { code: { lang: input.lang, auto: false } } : {},
-    // Only ever true or absent, exactly as the note cover is defined: absent is
-    // "the sender did not classify", which no receiver may read as safe.
-    ...input.secret ? { sensitive: true } : {},
-    chunks: []
-  });
-  const linkId = await postLink(
-    ctx,
-    grant,
-    manifest,
-    [],
-    agentSendIdempotencyKey(grant.channel_id, contentHash, name)
-  );
-  remember(ctx, key, {
-    link_id: linkId,
-    bytes: encoded.length,
-    chunks: 0,
-    deduplicated: 0,
-    at: Date.now()
+}
+function linksParent(identity, grant) {
+  return `accounts/${identity.owner_uid}/channels/${grant.channel_id}`;
+}
+function linkPath(identity, grant, id) {
+  return `projects/${identity.firestore_project}/databases/(default)/documents/${linksParent(identity, grant)}/links/${id}`;
+}
+async function queryLinks(ctx, grant, query) {
+  try {
+    return await ctx.client.firestoreRunQuery(linksParent(ctx.identity, grant), query);
+  } catch (err) {
+    if (err instanceof ZasError && err.status === 403) throw new ZasError("read_forbidden", 403);
+    throw err;
+  }
+}
+function clampLimit(limit) {
+  if (limit === void 0 || !Number.isFinite(limit)) return DEFAULT_LIMIT;
+  return Math.min(MAX_LIMIT, Math.max(1, Math.trunc(limit)));
+}
+async function listItems(ctx, channel, limit) {
+  const grant = await readGrant(ctx, channel);
+  const channelKey = channelKeyOf(ctx.identity, grant);
+  const docs = await queryLinks(ctx, grant, {
+    from: [{ collectionId: "links" }],
+    orderBy: [{ field: { fieldPath: "created_at" }, direction: "DESCENDING" }],
+    limit: clampLimit(limit)
   });
+  const items = [];
+  for (const doc of docs) {
+    const row = rowOf(doc);
+    if (!readable(row)) continue;
+    const manifest = openFor(channelKey, row);
+    if (!manifest) continue;
+    items.push(summaryOf(row, manifest));
+  }
   return {
-    link_id: linkId,
     channel_id: grant.channel_id,
-    channel_name: channelNameOf(ctx.identity, grant),
-    bytes: encoded.length,
-    chunks: 0,
-    deduplicated: 0,
-    replayed: false
+    channel_name: nameFrom(channelKey, grant),
+    items
   };
 }
+function redeemFailure(status) {
+  if (status === 429) return new ZasError("rate_limited", 429);
+  if (status >= 500) return new ZasError("network", status);
+  return new ZasError("invalid_cap", 403);
+}
+async function fetchChunk(ctx, chunk) {
+  if (typeof chunk.cap !== "string" || chunk.cap === "") throw new ZasError("invalid_cap", 403);
+  let headers = {};
+  try {
+    headers = { Authorization: `Bearer ${await ctx.client.idToken()}` };
+  } catch {
+    headers = {};
+  }
+  let url;
+  try {
+    const redeemed = await apiPublic(
+      ctx.identity.api_base,
+      "POST",
+      "/v1/blobs/redeem",
+      { cap: chunk.cap },
+      headers
+    );
+    url = typeof redeemed.url === "string" ? redeemed.url : "";
+  } catch (err) {
+    if (err instanceof ZasError) throw redeemFailure(err.status);
+    throw err;
+  }
+  if (url === "") throw new ZasError("invalid_cap", 403);
+  const res = await fetch(url);
+  if (!res.ok) {
+    await res.body?.cancel().catch(() => void 0);
+    throw res.status >= 500 ? new ZasError("network", res.status) : new ZasError("invalid_cap", 403);
+  }
+  const ciphertext = new Uint8Array(await res.arrayBuffer());
+  try {
+    return decryptChunk(b64ToBytes(chunk.key), b64ToBytes(chunk.nonce), ciphertext);
+  } catch {
+    throw new ZasError("invalid_cap", 403);
+  }
+}
+function safeName(name, fallback) {
+  const base = (typeof name === "string" ? name : "").split(/[\\/]/).pop() ?? "";
+  return base.replace(/^\.+/, "").trim() || fallback;
+}
+function freeName(target) {
+  if (!existsSync2(target)) return target;
+  const ext = extname2(target);
+  const stem = target.slice(0, target.length - ext.length);
+  for (let n = 1; n <= MAX_DUPLICATES; n++) {
+    const candidate = `${stem} (${n})${ext}`;
+    if (!existsSync2(candidate)) return candidate;
+  }
+  throw new ZasError("write_failed", 0, target);
+}
+function destinationOf(dest, name, fallback) {
+  const base = safeName(name, fallback);
+  if (dest === void 0) {
+    const created = mkdtempSync(join2(tmpdir(), DOWNLOAD_PREFIX));
+    return { target: freeName(join2(created, base)), created };
+  }
+  const at = statSync(dest, { throwIfNoEntry: false })?.isDirectory() ? join2(dest, base) : dest;
+  return { target: freeName(at) };
+}
+async function getItem(ctx, channel, id, dest) {
+  const grant = await readGrant(ctx, channel);
+  if (!ID_SEGMENT.test(id)) throw new ZasError("not_found", 404);
+  const channelKey = channelKeyOf(ctx.identity, grant);
+  const docs = await queryLinks(ctx, grant, {
+    from: [{ collectionId: "links" }],
+    where: {
+      fieldFilter: {
+        field: { fieldPath: "__name__" },
+        op: "EQUAL",
+        value: { referenceValue: linkPath(ctx.identity, grant, id) }
+      }
+    },
+    limit: 1
+  });
+  const row = docs.length > 0 ? rowOf(docs[0]) : null;
+  if (!row || !readable(row)) throw new ZasError("not_found", 404);
+  const manifest = openFor(channelKey, row);
+  if (!manifest) throw new ZasError("not_found", 404);
+  if (manifest.kind === "text") {
+    const text2 = manifest.text ?? "";
+    return { text: text2, bytes: new TextEncoder().encode(text2).length };
+  }
+  if (manifest.chunks.length === 0) throw new ZasError("not_found", 404);
+  if (manifest.chunks.length > MAX_CHUNKS) throw new ZasError("not_found", 404);
+  let target;
+  let created;
+  let tmp;
+  let fd;
+  let written = 0;
+  try {
+    const chosen = destinationOf(dest, manifest.name, row.id);
+    target = chosen.target;
+    created = chosen.created;
+    mkdirSync2(dirname(target), { recursive: true, mode: 448 });
+    tmp = `${target}.${randomBytes2(6).toString("hex")}.tmp`;
+    fd = openSync(tmp, "wx", 384);
+    for (const chunk of manifest.chunks) {
+      written += writeSync(fd, await fetchChunk(ctx, chunk));
+    }
+    const size = typeof manifest.size === "number" ? manifest.size : 0;
+    if (size > 0 && written !== size) throw new ZasError("not_found", 404);
+    closeSync(fd);
+    fd = void 0;
+    renameSync2(tmp, target);
+  } catch (err) {
+    if (err instanceof ZasError) throw err;
+    const failure = err;
+    if (typeof failure.syscall === "string" || typeof failure.errno === "number") {
+      throw new ZasError("write_failed", 0, failure.message);
+    }
+    throw new ZasError("network", 0, String(err?.message ?? err));
+  } finally {
+    if (fd !== void 0) try {
+      closeSync(fd);
+    } catch {
+    }
+    if (tmp !== void 0 && existsSync2(tmp)) try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    if (created !== void 0) try {
+      rmdirSync(created);
+    } catch {
+    }
+  }
+  return { path: target, bytes: written };
+}
 
 // src/server.ts
 function agentVersion() {
-  return true ? "0.3.0" : "0.0.0-dev";
+  return true ? "0.4.0" : "0.0.0-dev";
 }
 var AGENT_CUE = " The owner sees every item this agent sends with the >_ agent mark and this agent's name, on every device.";
 var PAIR_ANNOUNCE_MS = 15e3;
@@ -1886,7 +2765,7 @@ var delay = (ms) => new Promise((resolve2) => {
 });
 function rightsOf(grant) {
   const rights = [];
-  if (grant.send && grant.mode !== "view" && !grant.direct_mode) rights.push("send");
+  if (grant.send && grant.mode !== "view") rights.push(grant.direct_mode ? "send (Directo)" : "send");
   if (grant.read) rights.push("read");
   return rights.length > 0 ? rights.join(" \xB7 ") : "no access";
 }
@@ -2021,7 +2900,7 @@ function buildServer(profile, deps = {}) {
     return text2(["pending", ...pairing.logs].join("\n"));
   });
   server.registerTool("zas_send_file", {
-    description: "Send a file from this machine into one of the owner's Zas channels. Returns the item id, or a job id when the upload takes longer than a minute. Sends any file this process can read; confirm with the owner before sending secrets, keys or credentials." + AGENT_CUE,
+    description: "Send a file from this machine into one of the owner's Zas channels. Returns the item id, or a job id when the upload takes longer than a minute. A channel in Directo mode refuses this tool: use zas_send_direct there. Sends any file this process can read; confirm with the owner before sending secrets, keys or credentials." + AGENT_CUE,
     inputSchema: {
       path: z.string().describe("Absolute or relative path of the file to send."),
       channel: z.string().optional().describe("Channel name or id. Optional when the agent holds exactly one channel."),
@@ -2041,6 +2920,58 @@ function buildServer(profile, deps = {}) {
       return failed(e);
     }
   });
+  const failedDirects = /* @__PURE__ */ new Map();
+  const rememberFailed = (jobId, record) => {
+    failedDirects.set(jobId, record);
+    if (failedDirects.size > 50) failedDirects.delete(failedDirects.keys().next().value);
+  };
+  server.registerTool("zas_send_direct", {
+    description: "Send a file from this machine through Directo: a live, device-to-device transfer into one of the owner's channels that is in Directo mode. Nothing is stored. The owner has to press Receive on another device within ten minutes; the call waits a minute and then returns a job id to check with zas_jobs. Returns the transfer result, or a job id. Sends any file this process can read; confirm with the owner before sending secrets, keys or credentials." + AGENT_CUE,
+    inputSchema: {
+      path: z.string().describe("Absolute or relative path of the file to send."),
+      channel: z.string().optional().describe("Channel name or id. Optional when the agent holds exactly one channel.")
+    }
+  }, async (input) => {
+    try {
+      const c = ctx();
+      let job;
+      job = runner.start(
+        "direct",
+        input.path,
+        input.channel ?? "",
+        (report) => sendDirect(c, input, report, {
+          ...deps.direct ?? {},
+          onFailed: (record) => rememberFailed(job.id, record)
+        })
+      );
+      return settled(await runner.wait(job));
+    } catch (e) {
+      return failed(e);
+    }
+  });
+  server.registerTool("zas_send_direct_fallback", {
+    description: "After a zas_send_direct job failed in flight, deliver the same file through reliable delivery instead. Zas encrypts the file on this machine and stores only that encrypted copy in Cloudflare R2 for up to 24 hours; it uses none of the owner's space, and the device that claimed the offer can download it later. This stops being Directo: the encrypted bytes pass through storage. Ask the owner before you use it; it is their choice. Pass the failed job's id." + AGENT_CUE,
+    inputSchema: {
+      job: z.string().describe("The job id zas_send_direct or zas_jobs reported for the Directo send that failed.")
+    }
+  }, async (input) => {
+    try {
+      const c = ctx();
+      const record = failedDirects.get(input.job);
+      if (!record) return failed(new ZasError("direct_not_failed", 0));
+      const job = runner.start(
+        "fallback",
+        record.name,
+        record.channel_name,
+        (report) => sendDirectFallback(c, record, report, deps.direct)
+      );
+      const outcome = await runner.wait(job);
+      if (outcome.status === "done") failedDirects.delete(input.job);
+      return settled(outcome);
+    } catch (e) {
+      return failed(e);
+    }
+  });
   server.registerTool("zas_send_note", {
     description: "Send a note \u2014 plain text, or a code snippet with its language \u2014 into one of the owner's Zas channels." + AGENT_CUE,
     inputSchema: {
@@ -2092,7 +3023,7 @@ function buildServer(profile, deps = {}) {
     }
   });
   server.registerTool("zas_jobs", {
-    description: "List the sends this server started, newest first, with the phase each one reached and how it ended \u2014 including any `job_id` a send returned; a finished job keeps its result here." + AGENT_CUE
+    description: "List the sends and Directo transfers this server started, newest first, with the phase each one reached and how it ended \u2014 including any `job_id` a send returned; a finished job keeps its result here." + AGENT_CUE
   }, async () => text2(runner.list()));
   return server;
 }