@whanext/core 0.19.5 → 0.19.8

package/dist/index.js

@@ -90,11 +90,40 @@ function toWhaNextError(error, context) {
     return error;
   }
   const message = error instanceof Error ? error.message : "An unknown error occurred.";
+  if (isReachoutTimelockError(error)) {
+    return new WhaNextError(
+      "MESSAGE_REACHOUT_LOCKED",
+      "WhatsApp rejected the outgoing message (ack 463: reach-out time-lock).",
+      {
+        cause: error,
+        context: {
+          ...context ?? {},
+          ackCode: 463
+        },
+        recoverable: false
+      }
+    );
+  }
   return new WhaNextError("UNKNOWN_ERROR", message, {
     cause: error,
     ...context ? { context } : {}
   });
 }
+function isReachoutTimelockError(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  for (let depth = 0; depth < 8 && current !== void 0 && current !== null; depth += 1) {
+    if (seen.has(current)) return false;
+    seen.add(current);
+    const message = current instanceof Error ? current.message : typeof current === "string" ? current : void 0;
+    if (message && /negative publish ack:.*\berror=463\b/i.test(message)) {
+      return true;
+    }
+    if (typeof current !== "object") return false;
+    current = Reflect.get(current, "cause");
+  }
+  return false;
+}
 
 // src/models/identity.ts
 function normalizeIdentity(identity) {
@@ -370,7 +399,7 @@ var CommandConcurrencyController = class {
         recoverable: true
       });
     } else if (strategy === "queue" && state.active >= max) {
-      await new Promise((resolve3) => state.queue.push(resolve3));
+      await new Promise((resolve4) => state.queue.push(resolve4));
     }
     const controller = new AbortController();
     state.controllers.add(controller);
@@ -1617,8 +1646,8 @@ var SqliteMuteStore = class {
     }
     let database;
     try {
-      const require2 = createRequire(import.meta.url);
-      const sqlite = require2("node:sqlite");
+      const require3 = createRequire(import.meta.url);
+      const sqlite = require3("node:sqlite");
       database = new sqlite.DatabaseSync(databasePath);
       database.exec("PRAGMA journal_mode = WAL");
       database.exec("PRAGMA busy_timeout = 5000");
@@ -2203,12 +2232,12 @@ var WhaNextApp = class {
     this.logger.info("Login started");
     let unsubscribe = () => void 0;
     let timer;
-    const connected = new Promise((resolve3, reject) => {
+    const connected = new Promise((resolve4, reject) => {
       unsubscribe = this.#provider.on("connection", (update) => {
-        if (update.state === "connected") resolve3();
+        if (update.state === "connected") resolve4();
         if (update.state === "closed") {
           reject(
-            new WhaNextError(
+            update.error instanceof WhaNextError ? update.error : new WhaNextError(
               "CONNECTION_FAILED",
               "WhatsApp closed the connection before login completed.",
               {
@@ -2375,8 +2404,9 @@ var Browser = /* @__PURE__ */ ((Browser2) => {
 })(Browser || {});
 
 // src/provider/zapo/zapo-provider.ts
-import { mkdir } from "fs/promises";
-import { join } from "path";
+import { mkdir, stat } from "fs/promises";
+import { createRequire as createRequire2 } from "module";
+import { basename, dirname as dirname2, join, resolve as resolve2 } from "path";
 import { createMediaProcessor } from "@zapo-js/media-utils";
 import { createSqliteStore } from "@zapo-js/store-sqlite";
 import {
@@ -2706,6 +2736,25 @@ function toNumber(value) {
 }
 
 // src/provider/zapo/zapo-provider.ts
+var require2 = createRequire2(import.meta.url);
+var sharedZapoStores = /* @__PURE__ */ new Map();
+var sharedZapoStorePromises = /* @__PURE__ */ new Map();
+var fatalDisconnectReasons = /* @__PURE__ */ new Set([
+  "stream_error_replaced",
+  "stream_error_device_removed",
+  "stream_error_force_logout",
+  "failure_not_authorized",
+  "failure_banned",
+  "failure_locked",
+  "failure_client_too_old",
+  "failure_bad_user_agent",
+  "primary_identity_key_change"
+]);
+var fatalDisconnectCodes = /* @__PURE__ */ new Set([401, 403, 405, 406, 409, 516]);
+var sharedMediaProcessor = createMediaProcessor();
+var messageSnapshotRetentionSeconds = 7 * 24 * 60 * 60;
+var messageSnapshotMaxPerSession = 2e4;
+var messageSnapshotPruneInterval = 256;
 var ZapoProvider = class {
   #options;
   #events = new TypedEventEmitter();
@@ -2716,14 +2765,19 @@ var ZapoProvider = class {
   #handledProtocolStore = /* @__PURE__ */ new Set();
   #callCreatorStore = /* @__PURE__ */ new Map();
   #messageCacheSize;
+  #protocolMutationQueue = Promise.resolve();
   #client;
+  #storeEntry;
+  #storePath;
   #intentionalClose = false;
+  #closedNotified = false;
   #reconnectAttempt = 0;
   #reconnectTimer;
   #connectPromise;
   #pairingRequired = false;
   #connected = false;
   #connectedAtSeconds = 0;
+  #messageSnapshotsSincePrune = 0;
   #pairingReady = Promise.resolve();
   #resolvePairingReady;
   constructor(options) {
@@ -2736,6 +2790,7 @@ var ZapoProvider = class {
   }
   async connect() {
     this.#intentionalClose = false;
+    this.#closedNotified = false;
     const client = await this.#ensureClient();
     if (this.#connected || this.#connectPromise) {
       return;
@@ -2755,12 +2810,16 @@ var ZapoProvider = class {
     }
     const client = this.#client;
     this.#connectPromise = void 0;
-    if (client) {
-      await client.disconnect();
-    } else {
-      await this.#events.emit("connection", { state: "closed" });
+    try {
+      if (client) {
+        await client.disconnect();
+      } else {
+        await this.#emitClosedOnce();
+      }
+    } finally {
+      this.#connected = false;
+      await this.#releaseStore();
     }
-    this.#connected = false;
   }
   getCurrentUserIds() {
     const credentials = this.#client?.getCredentials();
@@ -2819,7 +2878,7 @@ var ZapoProvider = class {
     return this.#sent(result, chatId);
   }
   async repostMessage(source, chatId, options = {}) {
-    const original = this.#findStoredMessage(this.#toZapoKey(source));
+    const original = await this.#findStoredMessage(this.#toZapoKey(source));
     if (!original?.message) {
       throw new WhaNextError(
         "MESSAGE_NOT_FOUND",
@@ -2849,7 +2908,7 @@ var ZapoProvider = class {
     return this.#sent(result, key.chatId);
   }
   async downloadMedia(key) {
-    const message = this.#messageKeyStore.get(key) ?? this.#findStoredMessage(this.#toZapoKey(key));
+    const message = this.#messageKeyStore.get(key) ?? await this.#findStoredMessage(this.#toZapoKey(key));
     if (!message?.message) {
       throw new WhaNextError(
         "MEDIA_NOT_AVAILABLE",
@@ -2993,44 +3052,36 @@ var ZapoProvider = class {
   }
   async #ensureClient() {
     if (this.#client) return this.#client;
-    await mkdir(this.#options.auth, { recursive: true });
-    const store = createStore({
-      backends: {
-        sqlite: createSqliteStore({
-          path: join(this.#options.auth, "state.sqlite"),
-          driver: "auto"
-        })
-      },
-      providers: {
-        auth: "sqlite",
-        signal: "sqlite",
-        preKey: "sqlite",
-        session: "sqlite",
-        identity: "sqlite",
-        senderKey: "sqlite",
-        appState: "sqlite",
-        privacyToken: "sqlite",
-        messages: "none",
-        threads: "none",
-        contacts: "none"
-      },
-      cacheProviders: {
-        messageSecret: "sqlite"
-      }
-    });
+    const authPath = resolve2(this.#options.auth);
+    const sessionId = this.#sessionId();
+    const authPathExisted = await fileExists(authPath);
+    const legacyStorePath = join(authPath, "state.sqlite");
+    const canShareByDirectory = sessionId !== "default" && basename(authPath) === sessionId;
+    const storePath = canShareByDirectory ? join(dirname2(authPath), "state.sqlite") : legacyStorePath;
+    const resetSharedSession = canShareByDirectory && !authPathExisted && await fileExists(storePath);
+    await mkdir(authPath, { recursive: true });
+    const storeEntry = await acquireSharedZapoStore(
+      storePath,
+      sessionId,
+      legacyStorePath,
+      resetSharedSession,
+      this.#logger
+    );
     const client = new WaClient({
-      store,
-      sessionId: this.#options.sessionId ?? "default",
+      store: storeEntry.store,
+      sessionId,
       markOnlineOnConnect: false,
       deviceBrowser: this.#deviceBrowser(),
       deviceOsDisplayName: this.#deviceOsDisplayName(),
-      history: { enabled: false },
+      history: { enabled: true, requireFullSync: true },
       addons: {
         autoDecrypt: true,
         persistAllSecrets: true
       },
-      media: { processor: createMediaProcessor() }
+      media: { processor: sharedMediaProcessor }
     }, new WhaNextZapoLogger(this.#logger));
+    this.#storeEntry = storeEntry;
+    this.#storePath = storePath;
     this.#client = client;
     this.#bind(client);
     return client;
@@ -3045,10 +3096,19 @@ var ZapoProvider = class {
     client.on("auth_paired", () => {
       this.#pairingRequired = false;
     });
+    client.on("auth_passkey_required", ({ hasSigner }) => {
+      if (hasSigner) return;
+      const error = new WhaNextError(
+        "AUTH_PASSKEY_REQUIRED",
+        "WhatsApp requires a passkey assertion to link this account, but no passkey signer is configured.",
+        { recoverable: false }
+      );
+      void this.#stopTerminalConnection(client, error);
+    });
     client.on("message", (event) => {
       const protocol = this.#protocolMessage(event);
       if (protocol && this.#isMessageMutationProtocol(protocol.type)) {
-        this.#handleProtocolEvent({
+        this.#enqueueProtocolEvent({
           ...event,
           protocolMessage: protocol
         });
@@ -3069,7 +3129,7 @@ var ZapoProvider = class {
       });
     });
     client.on("message_protocol", (event) => {
-      this.#handleProtocolEvent(event);
+      this.#enqueueProtocolEvent(event);
     });
     client.on("message_addon", (event) => {
       this.#handleAddonEvent(event);
@@ -3139,7 +3199,7 @@ var ZapoProvider = class {
       ...protocolKey?.participant !== void 0 ? { participant: protocolKey.participant } : event.key.participant !== void 0 ? { participant: event.key.participant } : {},
       ...protocolKey?.participantAlt !== void 0 ? { participantAlt: protocolKey.participantAlt } : event.key.participantAlt !== void 0 ? { participantAlt: event.key.participantAlt } : {}
     };
-    this.#handleProtocolEvent({
+    void this.#handleProtocolEvent({
       key: event.key,
       ...event.timestampSeconds !== void 0 ? { timestampSeconds: event.timestampSeconds } : {},
       protocolMessage: {
@@ -3212,7 +3272,15 @@ var ZapoProvider = class {
     if (timestamp === void 0) return false;
     return timestamp < this.#connectedAtSeconds - 3;
   }
-  #handleProtocolEvent(event) {
+  #enqueueProtocolEvent(event) {
+    this.#protocolMutationQueue = this.#protocolMutationQueue.then(() => this.#handleProtocolEvent(event)).catch((error) => {
+      this.#logger.debug("Could not process a Zapo protocol mutation.", {
+        error: error instanceof Error ? error : new Error(String(error)),
+        messageId: event.key.id ?? void 0
+      });
+    });
+  }
+  async #handleProtocolEvent(event) {
     if (this.#shouldIgnoreProtocolEvent(event)) {
       this.#logger.debug("Ignored protocol mutation from before the current live connection.", {
         messageId: event.key.id ?? void 0,
@@ -3240,7 +3308,7 @@ var ZapoProvider = class {
       ...participant !== void 0 ? { participant } : {},
       ...participantAlt !== void 0 ? { participantAlt } : {}
     };
-    const stored = this.#findStoredMessage(target);
+    const stored = await this.#findStoredMessage(target);
     if (!target.remoteJid && stored?.key.remoteJid) target.remoteJid = stored.key.remoteJid;
     if (!target.remoteJid) return;
     const type = protocol.type;
@@ -3335,20 +3403,26 @@ var ZapoProvider = class {
       this.#connected = true;
       this.#connectedAtSeconds = Math.floor(Date.now() / 1e3);
       this.#reconnectAttempt = 0;
+      this.#closedNotified = false;
       await this.#events.emit("connection", { state: "connected" });
       return;
     }
     this.#connectPromise = void 0;
     this.#connected = false;
-    const error = event.reason instanceof Error ? event.reason : event.reason ? new Error(String(event.reason)) : void 0;
-    if (this.#intentionalClose || event.isLogout) {
-      await this.#events.emit("connection", {
-        state: "closed",
-        ...error ? { error } : {}
-      });
+    const details = disconnectDetails(event.reason, event.code);
+    const error = connectionError(event.reason, details);
+    if (this.#intentionalClose || event.isLogout === true || shouldStopAutomaticReconnect(details)) {
+      if (!this.#intentionalClose && shouldStopAutomaticReconnect(details)) {
+        this.#logger.warn("WhatsApp closed the session with a non-retryable reason.", {
+          ...details.reason ? { reason: details.reason } : {},
+          ...details.code !== void 0 ? { code: details.code } : {}
+        });
+      }
+      await this.#emitClosedOnce(error);
+      await this.#releaseStore();
       return;
     }
-    await this.#scheduleReconnect(error);
+    await this.#scheduleReconnect(error, reconnectDelayOverride(details));
   }
   #startConnect(client) {
     const promise = client.connect();
@@ -3357,20 +3431,65 @@ var ZapoProvider = class {
       if (this.#connectPromise !== promise) return;
       this.#connectPromise = void 0;
       if (this.#intentionalClose) return;
-      const normalized = error instanceof Error ? error : new Error(String(error));
+      const details = disconnectDetails(error);
+      const normalized = connectionError(error, details) ?? (error instanceof Error ? error : new Error(String(error)));
       this.#logger.warn("WhatsApp connection attempt failed.", { error: normalized });
-      await this.#scheduleReconnect(normalized);
+      if (shouldStopAutomaticReconnect(details)) {
+        await this.#stopTerminalConnection(client, normalized);
+        return;
+      }
+      await this.#scheduleReconnect(normalized, reconnectDelayOverride(details));
     });
   }
-  async #scheduleReconnect(error) {
+  async #stopTerminalConnection(client, error) {
+    if (client !== this.#client) return;
+    this.#intentionalClose = true;
+    if (this.#reconnectTimer) {
+      clearTimeout(this.#reconnectTimer);
+      this.#reconnectTimer = void 0;
+    }
+    this.#connectPromise = void 0;
+    this.#connected = false;
+    await this.#emitClosedOnce(error);
+    this.#client = void 0;
+    try {
+      await client.disconnect();
+    } catch (disconnectError) {
+      this.#logger.debug("Could not close a terminal Zapo connection cleanly.", {
+        error: disconnectError instanceof Error ? disconnectError : new Error(String(disconnectError))
+      });
+    } finally {
+      await this.#releaseStore();
+    }
+  }
+  async #emitClosedOnce(error) {
+    if (this.#closedNotified) return;
+    this.#closedNotified = true;
+    await this.#events.emit("connection", {
+      state: "closed",
+      ...error ? { error } : {}
+    });
+  }
+  async #releaseStore() {
+    const entry = this.#storeEntry;
+    const storePath = this.#storePath;
+    const sessionId = this.#sessionId();
+    this.#storeEntry = void 0;
+    this.#storePath = void 0;
+    this.#client = void 0;
+    if (!entry || !storePath) return;
+    await releaseSharedZapoStore(storePath, sessionId, entry, this.#logger);
+  }
+  #sessionId() {
+    return this.#options.sessionId ?? "default";
+  }
+  async #scheduleReconnect(error, delayOverrideMs) {
     if (this.#reconnectTimer) return;
     const options = this.#options.reconnect;
     const maxAttempts = options?.maxAttempts ?? 10;
     if (options?.enabled === false || this.#reconnectAttempt >= maxAttempts) {
-      await this.#events.emit("connection", {
-        state: "closed",
-        ...error ? { error } : {}
-      });
+      await this.#emitClosedOnce(error);
+      await this.#releaseStore();
       return;
     }
     this.#reconnectAttempt += 1;
@@ -3381,11 +3500,13 @@ var ZapoProvider = class {
     });
     const initial = options?.initialDelayMs ?? 1e3;
     const maximum = options?.maxDelayMs ?? 3e4;
-    const delay = Math.min(maximum, initial * 2 ** (this.#reconnectAttempt - 1));
+    const exponential = Math.min(maximum, initial * 2 ** (this.#reconnectAttempt - 1));
+    const delay = delayOverrideMs ?? exponential;
+    const jitter = delay > 0 ? Math.floor(Math.random() * 250) : 0;
     this.#reconnectTimer = setTimeout(() => {
       this.#reconnectTimer = void 0;
       void this.connect();
-    }, delay + Math.floor(Math.random() * 250));
+    }, delay + jitter);
   }
   async #sendButtons(chatId, content, replyTo) {
     this.#validateButtons(content);
@@ -3718,7 +3839,7 @@ var ZapoProvider = class {
   #groupParticipantIds(event) {
     return uniqueIdentities((event.participants ?? []).map((participant) => participant.jid ?? participant.lidJid ?? participant.phoneJid));
   }
-  #findStoredMessage(key) {
+  async #findStoredMessage(key) {
     const direct = this.#messageStore.get(this.#messageStoreKey(key));
     if (direct) return direct;
     if (!key.id) return void 0;
@@ -3734,18 +3855,103 @@ var ZapoProvider = class {
       this.#remember(storedQuoted);
       return storedQuoted;
     }
-    return void 0;
+    return this.#readArchivedMessage(key);
   }
   #remember(message) {
     if (!message.key.id || !message.message) return;
     const key = this.#messageStoreKey(message.key);
     this.#messageStore.delete(key);
     this.#messageStore.set(key, message);
+    void this.#archiveMessage(message);
     while (this.#messageStore.size > this.#messageCacheSize) {
       const oldest = this.#messageStore.keys().next().value;
       if (oldest) this.#messageStore.delete(oldest);
     }
   }
+  async #archiveMessage(message) {
+    const id = message.key.id;
+    const chatId = message.key.remoteJid;
+    const content = message.message;
+    const entry = this.#storeEntry;
+    if (!id || !chatId || !content || !entry) return;
+    try {
+      const participantId = message.key.participant ?? message.key.participantAlt ?? null;
+      const timestampSeconds = toSeconds(message.timestampSeconds) ?? null;
+      const messageBytes = Buffer.from(proto.Message.encode(content).finish());
+      const storedAtSeconds = Math.floor(Date.now() / 1e3);
+      const sessionId = this.#sessionId();
+      entry.snapshotUpsert.run(
+        sessionId,
+        id,
+        chatId,
+        participantId,
+        message.key.fromMe === true ? 1 : 0,
+        timestampSeconds,
+        messageBytes,
+        storedAtSeconds
+      );
+      this.#messageSnapshotsSincePrune += 1;
+      if (this.#messageSnapshotsSincePrune >= messageSnapshotPruneInterval) {
+        this.#messageSnapshotsSincePrune = 0;
+        entry.snapshotPruneAge.run(
+          sessionId,
+          storedAtSeconds - messageSnapshotRetentionSeconds
+        );
+        entry.snapshotPruneOverflow.run(
+          sessionId,
+          sessionId,
+          messageSnapshotMaxPerSession
+        );
+      }
+    } catch (error) {
+      this.#logger.debug("Could not archive a message snapshot for mutation recovery.", {
+        error: error instanceof Error ? error : new Error(String(error)),
+        messageId: id,
+        chatId
+      });
+    }
+  }
+  async #readArchivedMessage(key) {
+    const id = key.id;
+    const entry = this.#storeEntry;
+    if (!id || !entry) return void 0;
+    try {
+      const archived = entry.snapshotGet.get(
+        this.#sessionId(),
+        id
+      );
+      const messageBytes = bytesField(archived?.message_bytes);
+      if (!archived || !messageBytes) return void 0;
+      const archivedChatId = stringValue(archived.chat_id);
+      const remoteJid = key.remoteJid ?? archivedChatId;
+      if (!remoteJid) return void 0;
+      const participant = key.participant ?? key.participantAlt ?? stringValue(archived.participant_id);
+      const archivedFromMe = booleanValue(archived.from_me);
+      const timestampSeconds = numberValue(archived.timestamp_seconds);
+      const fromMe = key.fromMe ?? archivedFromMe;
+      const restored = {
+        key: {
+          ...key,
+          id,
+          remoteJid,
+          ...fromMe !== void 0 ? { fromMe } : {},
+          ...participant ? { participant } : {}
+        },
+        message: proto.Message.decode(messageBytes),
+        ...timestampSeconds !== void 0 ? { timestampSeconds } : {}
+      };
+      const cacheKey = this.#messageStoreKey(restored.key);
+      this.#messageStore.delete(cacheKey);
+      this.#messageStore.set(cacheKey, restored);
+      return restored;
+    } catch (error) {
+      this.#logger.debug("Could not restore a message snapshot for mutation recovery.", {
+        error: error instanceof Error ? error : new Error(String(error)),
+        messageId: id
+      });
+      return void 0;
+    }
+  }
   #messageStoreKey(key) {
     return `${key.remoteJid ?? ""}:${key.id ?? ""}:${key.participant ?? key.participantAlt ?? ""}`;
   }
@@ -3788,8 +3994,8 @@ var ZapoProvider = class {
   }
   #preparePairingGate() {
     this.#pairingRequired = false;
-    this.#pairingReady = new Promise((resolve3) => {
-      this.#resolvePairingReady = resolve3;
+    this.#pairingReady = new Promise((resolve4) => {
+      this.#resolvePairingReady = resolve4;
     });
   }
   #deviceBrowser() {
@@ -3831,6 +4037,395 @@ var ZapoProvider = class {
     }
   }
 };
+function disconnectDetails(value, explicitCode) {
+  let code = typeof explicitCode === "number" ? explicitCode : void 0;
+  let reason;
+  const queue = [value];
+  const seen = /* @__PURE__ */ new Set();
+  for (let depth = 0; queue.length > 0 && depth < 12; depth += 1) {
+    const current = queue.shift();
+    if (typeof current === "string") {
+      if (/^\d+$/.test(current)) {
+        code ??= Number(current);
+      } else {
+        reason ??= current;
+      }
+      continue;
+    }
+    if (!current || typeof current !== "object") continue;
+    if (seen.has(current)) continue;
+    seen.add(current);
+    const record = current;
+    const directCode = record.code;
+    const statusCode = record.statusCode;
+    if (typeof directCode === "number") code ??= directCode;
+    if (typeof statusCode === "number") code ??= statusCode;
+    const directReason = record.reason;
+    const failureReason = record.failureReason;
+    if (typeof directReason === "string") {
+      if (/^\d+$/.test(directReason)) code ??= Number(directReason);
+      else reason ??= directReason;
+    }
+    if (typeof failureReason === "string") reason ??= failureReason;
+    const output = record.output;
+    const data = record.data;
+    if (output && typeof output === "object") queue.push(output);
+    if (data && typeof data === "object") queue.push(data);
+    if (record.cause !== void 0) queue.push(record.cause);
+  }
+  return {
+    ...reason ? { reason } : {},
+    ...code !== void 0 ? { code } : {}
+  };
+}
+function shouldStopAutomaticReconnect(details) {
+  if (details.reason === "client_disconnected") return true;
+  if (details.reason && fatalDisconnectReasons.has(details.reason)) return true;
+  return details.code !== void 0 && fatalDisconnectCodes.has(details.code);
+}
+function reconnectDelayOverride(details) {
+  if (details.code === 515) return 0;
+  if (details.code === 402) return 6e4;
+  return void 0;
+}
+function connectionError(value, details) {
+  if (value === void 0 && details.code === void 0 && details.reason === void 0) {
+    return void 0;
+  }
+  const authExpired = details.code === 401 || details.code === 516 || details.reason === "failure_not_authorized" || details.reason === "stream_error_device_removed" || details.reason === "stream_error_force_logout" || details.reason === "primary_identity_key_change";
+  const cause = value instanceof Error ? value : details.code !== void 0 ? {
+    output: { statusCode: details.code },
+    data: { reason: String(details.code) },
+    ...value !== void 0 ? { cause: value } : {}
+  } : value;
+  const message = authExpired ? "WhatsApp authorization is no longer valid and the account must be paired again." : details.code === 402 ? "WhatsApp temporarily refused this session. The next reconnect will use an extended backoff." : "WhatsApp closed the connection.";
+  return new WhaNextError(
+    authExpired ? "AUTH_EXPIRED" : "CONNECTION_FAILED",
+    message,
+    {
+      ...cause !== void 0 ? { cause } : {},
+      context: {
+        ...details.reason ? { reason: details.reason } : {},
+        ...details.code !== void 0 ? { statusCode: details.code } : {}
+      },
+      recoverable: details.code === 402 || details.code === 500 || details.code === 503 || details.code === 515
+    }
+  );
+}
+async function acquireSharedZapoStore(storePath, sessionId, legacyStorePath, resetSession, logger) {
+  if (storePath === legacyStorePath) {
+    const entry2 = createZapoStoreEntry(storePath);
+    entry2.refs = 1;
+    entry2.sessionRefs.set(sessionId, 1);
+    return entry2;
+  }
+  let pending = sharedZapoStorePromises.get(storePath);
+  if (!pending) {
+    pending = (async () => {
+      await mkdir(dirname2(storePath), { recursive: true });
+      const entry2 = createZapoStoreEntry(storePath);
+      sharedZapoStores.set(storePath, entry2);
+      return entry2;
+    })();
+    sharedZapoStorePromises.set(storePath, pending);
+  }
+  let entry;
+  try {
+    entry = await pending;
+  } catch (error) {
+    if (sharedZapoStorePromises.get(storePath) === pending) {
+      sharedZapoStorePromises.delete(storePath);
+    }
+    throw error;
+  }
+  entry.refs += 1;
+  entry.sessionRefs.set(sessionId, (entry.sessionRefs.get(sessionId) ?? 0) + 1);
+  if (resetSession || await fileExists(legacyStorePath)) {
+    entry.migrationQueue = entry.migrationQueue.then(async () => {
+      if (resetSession) {
+        clearZapoSessionData(storePath, sessionId);
+        entry.snapshotClearSession.run(sessionId);
+      }
+      if (await fileExists(legacyStorePath)) {
+        await migrateLegacyZapoStore(storePath, legacyStorePath, sessionId, logger);
+      }
+    });
+    await entry.migrationQueue;
+  }
+  return entry;
+}
+function createZapoStoreEntry(storePath) {
+  const store = createStore({
+    backends: {
+      sqlite: createSqliteStore({
+        path: storePath,
+        driver: "auto"
+      })
+    },
+    providers: {
+      auth: "sqlite",
+      signal: "sqlite",
+      preKey: "sqlite",
+      session: "sqlite",
+      identity: "sqlite",
+      senderKey: "sqlite",
+      appState: "sqlite",
+      privacyToken: "sqlite",
+      messages: "sqlite",
+      threads: "sqlite",
+      contacts: "sqlite"
+    },
+    cacheProviders: {
+      messageSecret: "sqlite"
+    }
+  });
+  const Database = require2("better-sqlite3");
+  const snapshotDb = new Database(messageSnapshotStorePath(storePath));
+  snapshotDb.exec(`
+    PRAGMA busy_timeout = 5000;
+    CREATE TABLE IF NOT EXISTS whanext_message_snapshots (
+      session_id TEXT NOT NULL,
+      message_id TEXT NOT NULL,
+      chat_id TEXT NOT NULL,
+      participant_id TEXT,
+      from_me INTEGER NOT NULL,
+      timestamp_seconds INTEGER,
+      message_bytes BLOB NOT NULL,
+      stored_at_seconds INTEGER NOT NULL,
+      PRIMARY KEY (session_id, message_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_whanext_message_snapshots_chat
+      ON whanext_message_snapshots (session_id, chat_id);
+  `);
+  const snapshotColumns = snapshotDb.prepare(
+    "PRAGMA table_info(whanext_message_snapshots)"
+  ).all().map((column) => stringField2(column, "name")).filter((name) => name !== void 0);
+  if (!snapshotColumns.includes("stored_at_seconds")) {
+    snapshotDb.exec(
+      "ALTER TABLE whanext_message_snapshots ADD COLUMN stored_at_seconds INTEGER NOT NULL DEFAULT 0"
+    );
+  }
+  snapshotDb.exec(`
+    CREATE INDEX IF NOT EXISTS idx_whanext_message_snapshots_retention
+      ON whanext_message_snapshots (session_id, stored_at_seconds);
+  `);
+  return {
+    store,
+    snapshotDb,
+    snapshotUpsert: snapshotDb.prepare(`
+      INSERT INTO whanext_message_snapshots (
+        session_id, message_id, chat_id, participant_id, from_me,
+        timestamp_seconds, message_bytes, stored_at_seconds
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(session_id, message_id) DO UPDATE SET
+        chat_id = excluded.chat_id,
+        participant_id = excluded.participant_id,
+        from_me = excluded.from_me,
+        timestamp_seconds = excluded.timestamp_seconds,
+        message_bytes = excluded.message_bytes,
+        stored_at_seconds = excluded.stored_at_seconds
+    `),
+    snapshotGet: snapshotDb.prepare(`
+      SELECT chat_id, participant_id, from_me, timestamp_seconds, message_bytes
+      FROM whanext_message_snapshots
+      WHERE session_id = ? AND message_id = ?
+      LIMIT 1
+    `),
+    snapshotPruneAge: snapshotDb.prepare(`
+      DELETE FROM whanext_message_snapshots
+      WHERE session_id = ? AND stored_at_seconds < ?
+    `),
+    snapshotPruneOverflow: snapshotDb.prepare(`
+      DELETE FROM whanext_message_snapshots
+      WHERE session_id = ?
+        AND message_id IN (
+          SELECT message_id
+          FROM whanext_message_snapshots
+          WHERE session_id = ?
+          ORDER BY stored_at_seconds DESC
+          LIMIT -1 OFFSET ?
+        )
+    `),
+    snapshotClearSession: snapshotDb.prepare(`
+      DELETE FROM whanext_message_snapshots
+      WHERE session_id = ?
+    `),
+    refs: 0,
+    sessionRefs: /* @__PURE__ */ new Map(),
+    migrationQueue: Promise.resolve()
+  };
+}
+function messageSnapshotStorePath(storePath) {
+  return join(dirname2(storePath), "whanext-messages.sqlite");
+}
+async function releaseSharedZapoStore(storePath, sessionId, entry, logger) {
+  const currentSessionRefs = entry.sessionRefs.get(sessionId) ?? 0;
+  if (currentSessionRefs <= 1) {
+    entry.sessionRefs.delete(sessionId);
+    try {
+      await entry.store.session(sessionId).destroy();
+    } catch (error) {
+      logger.warn("Could not release the Zapo session store cleanly.", {
+        error: error instanceof Error ? error : new Error(String(error)),
+        sessionId
+      });
+    }
+  } else {
+    entry.sessionRefs.set(sessionId, currentSessionRefs - 1);
+  }
+  entry.refs = Math.max(0, entry.refs - 1);
+  if (entry.refs > 0) return;
+  if (sharedZapoStores.get(storePath) === entry) {
+    sharedZapoStores.delete(storePath);
+    sharedZapoStorePromises.delete(storePath);
+  }
+  try {
+    await entry.store.destroy();
+  } catch (error) {
+    logger.warn("Could not close the shared Zapo store cleanly.", {
+      error: error instanceof Error ? error : new Error(String(error)),
+      storePath
+    });
+  } finally {
+    try {
+      entry.snapshotDb.close();
+    } catch (error) {
+      logger.debug("Could not close the WhaNext message snapshot database cleanly.", {
+        error: error instanceof Error ? error : new Error(String(error)),
+        storePath
+      });
+    }
+  }
+}
+function clearZapoSessionData(storePath, sessionId) {
+  let db;
+  try {
+    const Database = require2("better-sqlite3");
+    db = new Database(storePath);
+    const tables = db.prepare(
+      "SELECT name FROM main.sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'"
+    ).all();
+    db.exec("BEGIN IMMEDIATE");
+    try {
+      for (const row of tables) {
+        const table = stringField2(row, "name");
+        if (!table || table === "wa_migrations" || table === "whanext_core_migrations") {
+          continue;
+        }
+        const quoted = sqliteIdentifier(table);
+        const columns = db.prepare(`PRAGMA main.table_info(${quoted})`).all().map((column) => stringField2(column, "name")).filter((name) => name !== void 0);
+        if (!columns.includes("session_id")) continue;
+        db.prepare(`DELETE FROM main.${quoted} WHERE session_id = ?`).run(sessionId);
+      }
+      db.exec("COMMIT");
+    } catch (error) {
+      db.exec("ROLLBACK");
+      throw error;
+    }
+  } finally {
+    db?.close();
+  }
+}
+async function migrateLegacyZapoStore(storePath, legacyStorePath, sessionId, logger) {
+  let db;
+  try {
+    const Database = require2("better-sqlite3");
+    db = new Database(storePath);
+    db.exec(`ATTACH DATABASE ${sqliteString(legacyStorePath)} AS legacy`);
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS whanext_core_migrations (
+        migration_key TEXT PRIMARY KEY,
+        migrated_at INTEGER NOT NULL
+      )
+    `);
+    const migrationKey = `shared-store:${resolve2(legacyStorePath)}:${sessionId}`;
+    const migrated = db.prepare(
+      "SELECT migration_key FROM whanext_core_migrations WHERE migration_key = ?"
+    ).get(migrationKey);
+    if (migrated) return;
+    const mainTables = new Set(
+      db.prepare("SELECT name FROM main.sqlite_master WHERE type = 'table'").all().map((row) => stringField2(row, "name")).filter((name) => name !== void 0)
+    );
+    const legacyTables = db.prepare(
+      "SELECT name FROM legacy.sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'"
+    ).all();
+    db.exec("BEGIN IMMEDIATE");
+    try {
+      for (const row of legacyTables) {
+        const table = stringField2(row, "name");
+        if (!table || !mainTables.has(table) || table === "wa_migrations" || table === "whanext_core_migrations") {
+          continue;
+        }
+        const quoted = sqliteIdentifier(table);
+        const mainColumns = db.prepare(`PRAGMA main.table_info(${quoted})`).all().map((column) => stringField2(column, "name")).filter((name) => name !== void 0);
+        const legacyColumns = new Set(
+          db.prepare(`PRAGMA legacy.table_info(${quoted})`).all().map((column) => stringField2(column, "name")).filter((name) => name !== void 0)
+        );
+        const columns = mainColumns.filter((column) => legacyColumns.has(column));
+        if (!columns.includes("session_id") || columns.length === 0) continue;
+        const selected = columns.map(sqliteIdentifier).join(", ");
+        db.prepare(
+          `INSERT OR REPLACE INTO main.${quoted} (${selected}) SELECT ${selected} FROM legacy.${quoted} WHERE session_id = ?`
+        ).run(sessionId);
+      }
+      db.prepare(
+        "INSERT OR REPLACE INTO whanext_core_migrations (migration_key, migrated_at) VALUES (?, ?)"
+      ).run(migrationKey, Date.now());
+      db.exec("COMMIT");
+    } catch (error) {
+      db.exec("ROLLBACK");
+      throw error;
+    }
+  } catch (error) {
+    logger.warn("Could not migrate the legacy per-account Zapo store; keeping the shared store active.", {
+      error: error instanceof Error ? error : new Error(String(error)),
+      sessionId,
+      legacyStorePath,
+      storePath
+    });
+  } finally {
+    if (db) {
+      try {
+        db.exec("DETACH DATABASE legacy");
+      } catch {
+      }
+      db.close();
+    }
+  }
+}
+async function fileExists(path2) {
+  try {
+    await stat(path2);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sqliteIdentifier(value) {
+  return `"${value.replaceAll('"', '""')}"`;
+}
+function sqliteString(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function stringField2(record, field) {
+  const value = record[field];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function booleanValue(value) {
+  if (value === true || value === 1) return true;
+  if (value === false || value === 0) return false;
+  return void 0;
+}
+function bytesField(value) {
+  if (value instanceof Uint8Array) return value;
+  return void 0;
+}
 var WhaNextZapoLogger = class _WhaNextZapoLogger {
   level;
   #logger;
@@ -3903,7 +4498,7 @@ async function create(options = {}) {
 // src/app/multi-app.ts
 import {
   join as join2,
-  resolve as resolve2
+  resolve as resolve3
 } from "path";
 var MultiCommandRouter = class {
   #apps;
@@ -4048,7 +4643,7 @@ async function createMulti(options) {
     }
     normalizedIds.add(normalizedId);
     if (account.provider === void 0) {
-      const authPath = resolve2(account.auth ?? join2(authRoot, account.id));
+      const authPath = resolve3(account.auth ?? join2(authRoot, account.id));
       if (authPaths.has(authPath)) {
         throw new WhaNextError(
           "ARGUMENT_INVALID",