@wacando/agent 2.3.0 → 2.4.1

package/packages/runtime/files.mjs

@@ -29,8 +29,10 @@ import { protectedDirectory, SafeError, storageError } from '../onboarding/stora
 // directory (0700/0600). The runtime never opens, extracts or executes it.
 // Nothing here logs; errors carry no name, digest, URL token or key.
 //
-// Local retention (lbframe/wacando-agent#21): sweep() runs at every connection
-// and before every listing; it deletes the local ciphertext, keys and
+// Local retention (lbframe/wacando-agent#21, #24): sweep() runs before the
+// first file operation of each connection (at every connection for the
+// daemon, never from a read-only tool), before every listing and before a
+// full queue or quarantine refuses; it deletes the local ciphertext, keys and
 // quarantined descriptors of transfers that can never continue (STOP or any
 // other closed conversation, rejected, expired or unknown on the server, or
 // past their 30-day expiry by the local clock). A RECEIVED file, written to
@@ -40,11 +42,15 @@ import { protectedDirectory, SafeError, storageError } from '../onboarding/stora
 export const FILE_POLL_MS = 2000;
 export const MAX_PENDING_OUTGOING = 10;
 export const MAX_QUARANTINED_INCOMING = 100;
+// One conversation (one peer) can fill only part of the quarantine (lbframe/wacando-agent#24).
+export const MAX_QUARANTINED_PER_CONVERSATION = 20;
 export const FILE_RETENTION_MS = 30 * 24 * 3600 * 1000;
-// Leftovers of an interrupted write (staged ciphertext, .part) older than this are removed by the sweep.
+// Leftovers of an interrupted write (staged ciphertext, .part, a ciphertext
+// without its record) older than this are removed by the sweep.
 const STALE_LEFTOVER_MS = 3600 * 1000;
 const STAGED = /^staged-[0-9a-f-]{36}\.bin$/;
 const PART = /^\.[0-9a-f-]{36}\.part$/;
+const COMMITTED = /^(fil_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.bin$/;
 const FILE_ID = /^fil_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 const UPLOAD_PATH = /^\/v1\/uploads\/(fil_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\/[A-Za-z0-9_-]{43}$/;
 const LOOPBACK = new Set(['localhost', '127.0.0.1', '[::1]']);
@@ -66,6 +72,7 @@ export const fileErrors = {
   download: 'The encrypted file could not be downloaded from the configured Wacando upload origin. Retry later.',
   plainText: 'A message body may not be a file share; use wacando_send_file.',
   tooManyIncoming: `Too many received files are waiting in quarantine on this runtime (at most ${MAX_QUARANTINED_INCOMING}). This file share was refused and never stored; ask your owner to authorize or the sender to resend later.`,
+  tooManyInConversation: `Too many received files of this conversation are waiting in quarantine (at most ${MAX_QUARANTINED_PER_CONVERSATION} per conversation). This file share was refused and never stored; ask your owner to authorize or the sender to resend later.`,
   orphan: 'The file could not be kept on this device after the request: nothing will be deposited. Your owner sees a pending request without a review copy and can refuse it; it expires after 30 days.',
   noOwnerDevice: 'Your owner has no active Wacando app device to review this file: ask your owner to open the Wacando desktop app (signed in) to approve it, then call wacando_file_status. The file stays pending; nothing was deposited.',
   reviewRetry: 'The review copy for your owner could not be deposited yet; call wacando_file_status to retry. The file stays pending.',
@@ -161,23 +168,67 @@ export function ownOwnerId(view, agentId) {
 }
 
 /**
- * Pure: whether a message body is a Wacando file descriptor, whatever its
- * whitespace or key order: 'share' (file share, `wacandoFile`), 'review'
- * (owner review descriptor, `wacandoFileReview`, never meant for a room) or
- * null. Such a body is never shown nor sent as text (it carries a key).
+ * Pure: whether a message body is, or carries, a Wacando file descriptor:
+ * 'share' (file share, `wacandoFile`), 'review' (owner review descriptor,
+ * `wacandoFileReview`, never meant for a room) or null. Such a body is never
+ * shown nor sent as text: it carries a key (lbframe/wacando-agent#21, #24).
+ * Detected whatever the whitespace, key order or JSON escaping, behind
+ * invisible format characters (ZWSP, BOM, word joiner...) or compatibility
+ * forms (fullwidth braces):
+ * - a JSON object with such a key at its top level (strict: whatever its
+ *   values), or a body that opens like one but is not valid JSON;
+ * - a descriptor anywhere else (nested in JSON, in an array, in prose, a code
+ *   block or a JSON string), only when its key material is there too: an
+ *   `aesgcm://...#<88 hex>` URL for a share, a `"secret"` of 88 hex for a
+ *   review. Text that merely names the format (e.g. a nested
+ *   `{"wacandoFile":false}` setting) carries no key and stays text.
+ * Linear in the body size (a hostile body cannot stall the event loop).
  */
 export function fileBodyKind(text) {
   if (typeof text !== 'string') return null;
-  const trimmed = text.trim();
-  if (!trimmed.startsWith('{')) return null;
-  let value;
-  try { value = JSON.parse(trimmed); } catch {
-    // Not JSON: still a descriptor when it opens like one (never shown as text).
-    return /^\{\s*"wacandoFileReview"\s*:/.test(trimmed) ? 'review' : /^\{\s*"wacandoFile"\s*:/.test(trimmed) ? 'share' : null;
-  }
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
-  if (Object.hasOwn(value, 'wacandoFileReview')) return 'review';
-  return Object.hasOwn(value, 'wacandoFile') ? 'share' : null;
+  // Detection only: the body itself is never rewritten.
+  const plain = text.normalize('NFKC').replace(/\p{Cf}/gu, '').trim();
+  if (plain.startsWith('{') || plain.startsWith('[')) {
+    let value;
+    let parsed = true;
+    try { value = JSON.parse(plain); } catch { parsed = false; }
+    if (parsed) {
+      if (value && typeof value === 'object' && !Array.isArray(value)) {
+        if (Object.hasOwn(value, 'wacandoFileReview')) return 'review';
+        if (Object.hasOwn(value, 'wacandoFile')) return 'share';
+      }
+    } else if (/^[[\s]*\{\s*"wacandoFileReview"\s*:/.test(plain)) return 'review';
+    else if (/^[[\s]*\{\s*"wacandoFile"\s*:/.test(plain)) return 'share';
+  }
+  let unescaped = plain;
+  for (let i = 0; i < 3; i++) {
+    const next = unescaped.replace(/\\u([0-9a-fA-F]{4})/g, (_, code) => String.fromCharCode(Number.parseInt(code, 16))).replace(/\\(["/\\])/g, '$1');
+    if (next === unescaped) break;
+    unescaped = next;
+  }
+  if (/"wacandoFileReview"\s*:/.test(unescaped) && /"secret"\s*:\s*"[0-9a-fA-F]{88}"/.test(unescaped)) return 'review';
+  if (/"wacandoFile"\s*:/.test(unescaped) && hasAesgcmKey(unescaped)) return 'share';
+  return null;
+}
+
+const URL_END = /[\s"#]/;
+const KEY_HEX = /^[0-9a-fA-F]{88}/;
+/**
+ * Pure: whether the text holds an `aesgcm://<no space, quote or #>#<88 hex>`
+ * URL, in one linear pass (the equivalent regular expression is quadratic on
+ * `aesgcm://` repeated without a `#`, #24 review LOW-2): every later
+ * `aesgcm://` inside the same URL body ends at the same character.
+ */
+function hasAesgcmKey(text) {
+  let from = 0;
+  for (;;) {
+    const start = text.indexOf('aesgcm://', from);
+    if (start < 0) return false;
+    let end = start + 'aesgcm://'.length;
+    while (end < text.length && !URL_END.test(text[end])) end++;
+    if (text[end] === '#' && KEY_HEX.test(text.slice(end + 1, end + 89))) return true;
+    from = end;
+  }
 }
 
 const BARE_JID = /^[^\s/@]+@[^\s/@]+$/;
@@ -269,15 +320,24 @@ export class FileVault {
     try { await rename(join(dir, staged), join(dir, `${FileVault.id(fileId)}.bin`)); } catch { throw storageError(); }
   }
   async dropStaged(staged) { if (STAGED.test(staged ?? '')) await unlink(join(await this.dir('outgoing'), staged)).catch(() => {}); }
-  /** Remove interrupted-write leftovers (staged ciphertext, .part files) older than `before` (ms). Returns the count. */
+  /**
+   * Remove interrupted-write leftovers older than `before` (ms): staged
+   * ciphertext, .part files, and a committed ciphertext whose record was never
+   * written (a crash between the rename and the record, lbframe/wacando-agent#24;
+   * without its record it has no key and can never be used). Returns the count.
+   */
   async dropLeftovers(before) {
     let count = 0;
     for (const kind of ['outgoing', 'incoming']) {
       const dir = await this.dir(kind);
       for (const name of await readdir(dir)) {
-        if (!STAGED.test(name) && !PART.test(name)) continue;
+        const orphan = kind === 'outgoing' ? COMMITTED.exec(name)?.[1] : null;
+        if (!STAGED.test(name) && !PART.test(name) && !orphan) continue;
         const info = await stat(join(dir, name)).catch(() => null);
-        if (info?.isFile() && info.mtimeMs < before && await unlink(join(dir, name)).then(() => true, () => false)) count++;
+        if (!info?.isFile() || info.mtimeMs >= before) continue;
+        // Its record may have been written since the directory was read.
+        if (orphan && await lstat(join(dir, `${orphan}.json`)).then(() => true, error => error.code !== 'ENOENT')) continue;
+        if (await unlink(join(dir, name)).then(() => true, () => false)) count++;
       }
     }
     return count;
@@ -326,6 +386,7 @@ export class FileTransfers {
     this.pollMs = pollMs;
     this.fetch = fetch;
     this.busy = new Map(); // fileId -> in-flight advance (one at a time per file)
+    this.claims = new WeakSet(); // busy entries that are a sweep removal
   }
 
   get pin() { return this.pinSetting ?? (this.pinSetting = uploadPin(this.c.agent.origin)); }
@@ -489,15 +550,24 @@ export class FileTransfers {
   async status(fileId, { timeoutMs = 0 } = {}) {
     FileVault.id(fileId);
     if (await this.vault.read('outgoing', fileId)) return this.once(fileId, () => this.advance(fileId, timeoutMs));
-    const incoming = await this.vault.read('incoming', fileId);
-    if (!incoming) throw new SafeError(fileErrors.unknown);
-    return this.incomingState(incoming, { timeoutMs, fetch: false });
+    // Incoming: one step at a time per file, like receive (a record written by
+    // a receive in flight is never dropped by this step, #24 review LOW-1).
+    return this.once(fileId, async () => {
+      const incoming = await this.vault.read('incoming', fileId);
+      if (!incoming) throw new SafeError(fileErrors.unknown);
+      return this.incomingState(incoming, { timeoutMs, fetch: false });
+    });
   }
 
+  /**
+   * One transfer step at a time per file in this process: a caller joins the
+   * step in flight; a removal by the sweep (a claim) is waited for first.
+   */
   once(fileId, run) {
     const running = this.busy.get(fileId);
-    if (running) return running;
-    const task = run().finally(() => this.busy.delete(fileId));
+    if (running && !this.claims.has(running)) return running;
+    const task = (running ? running.then(() => run(), () => run()) : run())
+      .finally(() => { if (this.busy.get(fileId) === task) this.busy.delete(fileId); });
     this.busy.set(fileId, task);
     return task;
   }
@@ -617,19 +687,36 @@ export class FileTransfers {
       }
       return { ...publicIncoming(known), state: known.path ? 'received' : 'quarantined' };
     }
-    if ((await this.vault.list('incoming')).filter(r => !r.path).length >= MAX_QUARANTINED_INCOMING) {
-      return { state: 'refused', reason: 'too_many_quarantined', note: fileErrors.tooManyIncoming };
+    // Bounded quarantine, and one conversation (one peer) fills at most part of
+    // it. Ended transfers do not count: clean them up before refusing (#24).
+    let full = await this.quarantineFull(conversationId);
+    if (full) {
+      await this.sweep().catch(() => null);
+      full = await this.quarantineFull(conversationId);
     }
+    if (full) return { state: 'refused', reason: 'too_many_quarantined', note: full };
     const record = { fileId, conversationId, messageId, share, ciphertextSha256: share.ciphertextSha256, receivedAt: new Date(this.now()).toISOString() };
     await this.vault.write('incoming', fileId, record);
     return { ...publicIncoming(record), state: 'quarantined', note: `In quarantine until your owner authorizes it; then call wacando_receive_file. ${UNTRUSTED}` };
   }
 
+  /** The refusal note when the quarantine (or this conversation's share of it) is full, else null. */
+  async quarantineFull(conversationId) {
+    const waiting = (await this.vault.list('incoming')).filter(r => !r.path);
+    if (waiting.length >= MAX_QUARANTINED_INCOMING) return fileErrors.tooManyIncoming;
+    if (waiting.filter(r => r.conversationId === conversationId).length >= MAX_QUARANTINED_PER_CONVERSATION) return fileErrors.tooManyInConversation;
+    return null;
+  }
+
   /** Fetch a released incoming file into the quarantine directory (bounded wait for the release). */
   async receive(fileId, { timeoutMs = 0 } = {}) {
-    const record = await this.vault.read('incoming', FileVault.id(fileId));
-    if (!record) throw new SafeError(fileErrors.unknown);
-    return this.once(fileId, () => this.incomingState(record, { timeoutMs, fetch: true }));
+    FileVault.id(fileId);
+    // Read inside the step: a removal by the sweep is never overtaken.
+    return this.once(fileId, async () => {
+      const record = await this.vault.read('incoming', fileId);
+      if (!record) throw new SafeError(fileErrors.unknown);
+      return this.incomingState(record, { timeoutMs, fetch: true });
+    });
   }
 
   async incomingState(record, { timeoutMs, fetch }) {
@@ -640,17 +727,17 @@ export class FileTransfers {
       const view = await this.c.conversation(record.conversationId);
       if (view.state !== 'active') {
         // STOP is terminal: this agent can never fetch it; drop the key.
-        await this.vault.remove('incoming', record.fileId);
+        await this.dropIncoming(record);
         return { file: summary, state: 'refused', reason: 'conversation_closed', note: fileErrors.notActive(view.state) };
       }
       const dto = (await this.serverFiles(record.conversationId)).find(f => f.id === record.fileId);
       if (!dto || dto.recipientAgentId !== this.c.agent.agentId || dto.ciphertextSha256 !== record.share.ciphertextSha256 ||
           dto.sizeBytes !== record.share.ciphertextSize || dto.mediaType !== record.share.mediaType) {
-        await this.vault.remove('incoming', record.fileId);
+        await this.dropIncoming(record);
         return { file: summary, state: 'refused', reason: 'not_approved_file', note: 'The server does not list this file as approved for this agent. It was refused and never fetched.' };
       }
       if (this.expired(dto)) {
-        await this.vault.remove('incoming', record.fileId);
+        await this.dropIncoming(record);
         return { file: summary, state: 'expired', note: fileApiMessages.FILE_EXPIRED };
       }
       if (dto.status === 'released' && fetch) return this.fetchReleased(record, dto, summary);
@@ -663,6 +750,12 @@ export class FileTransfers {
     }
   }
 
+  /** Drop a quarantined descriptor (its key), never the record of a file received meanwhile. */
+  async dropIncoming(record) {
+    if ((await this.vault.read('incoming', record.fileId))?.path) return;
+    await this.vault.remove('incoming', record.fileId);
+  }
+
   async fetchReleased(record, dto, summary) {
     let file;
     try {
@@ -690,16 +783,22 @@ export class FileTransfers {
 
   /**
    * Delete the local secrets of every transfer that can never continue
-   * (lbframe/wacando-agent#21), at connection and before each listing:
+   * (lbframe/wacando-agent#21, #24), before the first file operation of a
+   * connection (at every connection for the daemon), before each listing and
+   * before a full queue or quarantine refuses:
    * - pending/deposited sends (ciphertext + key) and quarantined descriptors
    *   (key): conversation no longer active (STOP is terminal) or unknown to
    *   the server, file unknown, different, rejected or expired on the server,
    *   or past its 30-day expiry by the local clock (even offline);
    * - sent records (public metadata only, no key): past their expiry;
-   * - interrupted-write leftovers older than an hour.
+   * - interrupted-write leftovers older than an hour, including a ciphertext
+   *   whose record was never written.
    * A received file (written to the quarantine directory) and its record are
    * never touched. A server that cannot be reached removes nothing it cannot
-   * decide locally. Transfers in progress in this process are skipped.
+   * decide locally. Transfers in progress in this process are skipped; a
+   * record that changed since it was listed (e.g. a file received meanwhile)
+   * is kept. Another process of the same identity may sweep at the same time:
+   * every step tolerates a file the other one already removed.
    * Returns content-free counts.
    */
   sweep() {
@@ -721,14 +820,31 @@ export class FileTransfers {
         if (this.busy.has(record.fileId)) continue;
         if (!(await this.ended(direction, record, now, server))) continue;
         if (this.busy.has(record.fileId)) continue;
-        await this.vault.remove(direction, record.fileId);
-        counts[direction]++;
+        if (await this.claim(direction, record)) counts[direction]++;
       }
     }
     await this.vault.dropLeftovers(now - STALE_LEFTOVER_MS).catch(() => 0);
     return counts;
   }
 
+  /**
+   * Remove an ended record unless it changed since it was listed. Set as the
+   * file's busy step in the same tick as the caller's last busy check, so no
+   * step of this process (receive, status) interleaves with the removal.
+   */
+  claim(direction, record) {
+    const removal = (async () => {
+      const fresh = await this.vault.read(direction, record.fileId);
+      if (!fresh || JSON.stringify(fresh) !== JSON.stringify(record)) return false;
+      await this.vault.remove(direction, record.fileId);
+      return true;
+    })();
+    const held = removal.finally(() => { if (this.busy.get(record.fileId) === held) this.busy.delete(record.fileId); });
+    this.claims.add(held);
+    this.busy.set(record.fileId, held);
+    return held;
+  }
+
   /** Conversation state and files as the server lists them for this agent; 'gone' when unknown; null when unreachable. */
   async serverState(conversationId) {
     let state;

package/packages/runtime/runtime.mjs

@@ -30,9 +30,12 @@ export function publicIdentity(agent, state) {
  */
 export class AgentRuntime {
   /**
-   * `files`: `{ uploadOrigin, quarantineDir }` (defaults: WACANDO_UPLOAD_ORIGIN
-   * or the API origin; WACANDO_QUARANTINE_DIR or a directory inside the
-   * protected runtime state) plus test hooks (`now`, `sleep`, `pollMs`, `fetch`).
+   * `files`: `{ uploadOrigin, quarantineDir, sweepOnConnect }` (defaults:
+   * WACANDO_UPLOAD_ORIGIN or the API origin; WACANDO_QUARANTINE_DIR or a
+   * directory inside the protected runtime state; `sweepOnConnect: true`
+   * cleans up ended transfers at every connection, as the daemon does,
+   * otherwise before the first file operation of a connection) plus test
+   * hooks (`now`, `sleep`, `pollMs`, `fetch`).
    */
   constructor({ host = 'cli', origin, store = new CredentialStore(), report, request, connect, onStanza, files = {} } = {}) {
     if (!/^[a-z0-9][a-z0-9_-]{0,31}$/.test(host)) throw new SafeError('Invalid runtime host name.');
@@ -147,7 +150,7 @@ export class AgentRuntime {
     if (client && client.session !== session) this.rebind(agent.agentId, session);
     if (!client) {
       const files = await this.fileTransfersFor(agent);
-      client = new ConversationClient({ runtime: this, agent, session, files });
+      client = new ConversationClient({ runtime: this, agent, session, files, sweepOnConnect: this.fileOptions.sweepOnConnect === true });
       this.clients.set(agent.agentId, client);
       for (const stanza of this.buffered.get(agent.agentId) ?? []) client.handle(stanza);
       this.buffered.delete(agent.agentId);
@@ -220,7 +223,7 @@ export class AgentRuntime {
 
   /** File transfer state of one identity: private directories, pinned upload origin. */
   async fileTransfersFor(agent) {
-    const { uploadOrigin, quarantineDir = process.env.WACANDO_QUARANTINE_DIR, ...hooks } = this.fileOptions;
+    const { uploadOrigin, quarantineDir = process.env.WACANDO_QUARANTINE_DIR, sweepOnConnect: _sweep, ...hooks } = this.fileOptions;
     const pin = uploadPin(agent.origin, uploadOrigin ?? process.env.WACANDO_UPLOAD_ORIGIN);
     const base = join(await this.store.directory(agent.origin, this.host), `files-${digest(agent.agentId)}`);
     const vault = new FileVault(base, quarantineDir ? join(quarantineDir, digest(`${agent.origin}\n${agent.agentId}`).slice(0, 32)) : undefined);

package/packages/runtime/session.mjs

@@ -1,10 +1,13 @@
-import { client } from '@xmpp/client';
-import { announceAvailable, refuseSubscriptionRequests, xml } from '#wacando/xmpp';
+import { announceAvailable, refuseSubscriptionRequests, ScramAuthError, scramClient, startScramClient, xml } from '#wacando/xmpp';
+import { SCRAM_REFUSED, XMPP_SERVER_UNVERIFIED } from '../onboarding/service.mjs';
 import { SafeError } from '../onboarding/storage.mjs';
 import { loadDevice } from './device.mjs';
 
 const unavailable = () => new SafeError('Secure messaging is unavailable. Retry the saved identity.');
 
+/** SafeError for a ScramAuthError: the fixed message plus its local reason enum (no secret). */
+const serverUnverified = error => Object.assign(new SafeError(XMPP_SERVER_UNVERIFIED), { code: SCRAM_REFUSED, reason: error.reason });
+
 /**
  * One XMPP c2s stream (WebSocket) + this identity's native OMEMO device.
  *
@@ -13,12 +16,23 @@ const unavailable = () => new SafeError('Secure messaging is unavailable. Retry
  * delivery addressed to the bare JID after that point reaches this resource
  * and none can be missed between "online" and the caller subscribing.
  * Raw XMPP errors, stanzas and credentials are never logged.
+ *
+ * The client is the embedded `scramClient` (lbframe/wacando#186): SCRAM only,
+ * SASL1 only, and authentication succeeds only once the server's
+ * ServerSignature (`v=`) was verified. A refusal closes the connection,
+ * stops @xmpp/client's reconnect and rejects with `code: 'SCRAM_REFUSED'`.
+ * Any failure (start, presence echo or deadline) stops the reconnect loop and
+ * the client before rejecting: the same guarantee as the embedded
+ * `startOrStop`, extended to the presence echo, so that helper is not used.
  */
 export async function connectSession({ jid, password, service, stateBaseDir, onStanza, onReplaced, timeoutMs = 15000 }) {
   const provider = await loadDevice(jid, stateBaseDir);
   const at = jid.indexOf('@');
   const domain = jid.slice(at + 1);
-  const xmpp = client({ service, domain, username: jid.slice(0, at), password });
+  // scramClient applies the embedded guardStart (lbframe/wacando#200): an
+  // 'error' while the stream opens rejects start() (an ordinary, retried
+  // failure here), never leaves an unhandled rejection behind.
+  const xmpp = scramClient({ service, domain, username: jid.slice(0, at), password });
   // One server-enforced session per agent (lbframe/wacando #15): a newer login
   // ends this one with <conflict/>. Remember it so nothing reconnects in a loop.
   let replaced = false;
@@ -31,15 +45,16 @@ export async function connectSession({ jid, password, service, stateBaseDir, onS
   let timer;
   const deadline = new Promise((_, reject) => { timer = setTimeout(() => reject(new Error('timeout')), timeoutMs); });
   try {
-    await Promise.race([xmpp.start(), deadline]);
+    await Promise.race([startScramClient(xmpp), deadline]);
     xmpp.reconnect?.stop();
     // The control plane owns the roster (#13): never approve a subscription.
     refuseSubscriptionRequests(xmpp);
     if (onStanza) xmpp.on('stanza', stanza => onStanza(stanza, xmpp));
     await Promise.race([announceAvailable(xmpp, timeoutMs), deadline]);
-  } catch {
+  } catch (error) {
+    xmpp.reconnect?.stop();
     await xmpp.stop().catch(() => {});
-    throw unavailable();
+    throw error instanceof ScramAuthError ? serverUnverified(error) : unavailable();
   } finally { clearTimeout(timer); }
   return {
     client: xmpp, provider, bareJid: provider.bareJid, domain,

package/packages/wacando/chunks/{chunk-PZDQXGA6.mjs → chunk-4Z6TL6JY.mjs}

@@ -1,4 +1,4 @@
-// Embedded from lbframe/wacando@618922ecaf2213da18949a8b27d343c8767b64c5 by scripts/embed-wacando.mjs. Do not edit; see provenance.json.
+// Embedded from lbframe/wacando@87b51a96aff0a13ca5ad6650c9c841bee72e1612 by scripts/embed-wacando.mjs. Do not edit; see provenance.json.
 
 // packages/contracts/src/errors.ts
 var DomainError = class extends Error {