@oxidezap/baileyrs 0.0.26 → 0.0.28

package/lib/Utils/wrap-legacy-store.js

@@ -1,1218 +1,11 @@
 /**
- * Wraps any upstream Baileys AuthenticationState as bridge-compatible
- * JsStoreCallbacks. Users keep their existing custom stores (MySQL,
- * MongoDB, Redis, etc.) — zero migration needed.
+ * Compatibility facade for callers that still provide Baileys
+ * `{ creds, keys }` authentication state.
  *
- * ```typescript
- * const { state, saveCreds } = await useMongoAuthState(db)
- * const sock = makeWASocket({
- *   auth: { store: await wrapLegacyStore(state, saveCreds) }
- * })
- * ```
+ * The implementation lives in `Compatibility/legacy-store/`: the WASM bridge sees only its
+ * native byte-store contract, while every Baileys-specific projection remains
+ * in this package.
  */
-import { Buffer } from 'node:buffer';
-import { createHmac } from 'node:crypto';
-import { mkdir, readFile, stat, unlink, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { proto } from 'whatsapp-rust-bridge/proto-types';
-import { jidDecode } from "../WABinary/jid-utils.js";
-import { BufferJSON } from "./generics.js";
-const protoLookup = proto;
-const ADVSignedDeviceIdentity = protoLookup.ADVSignedDeviceIdentity ?? protoLookup.AdvSignedDeviceIdentity;
-function warn(msg, err) {
-    if (_warnFn)
-        _warnFn(msg, err);
-    else
-        console.warn(`[wrapLegacyStore] ${msg}`, err ?? '');
-}
-let _warnFn;
-// ---- Store routing ----
-// Bridge store name → upstream store type name for keys.get/set.
-// ALL data goes through the user-provided keys interface — no separate files.
-const STORE_MAP = {
-    // Signal protocol (binary passthrough with write-through cache)
-    identity: 'identity-key',
-    session: 'session',
-    sender_key: 'sender-key',
-    // Upstream Baileys types (with format converters)
-    prekey: 'pre-key',
-    sync_key: 'app-state-sync-key',
-    sync_version: 'app-state-sync-version',
-    tc_token: 'tctoken',
-    device_list: 'device-list',
-    // Bridge-only (stored as raw Buffers with their own type prefix)
-    lid_mapping: 'lid-mapping',
-    signed_prekey: 'bridge-signed-prekey',
-    sender_key_devices: 'bridge-sender-key-devices',
-    base_key: 'bridge-base-key',
-    sent_message: 'bridge-sent-message',
-    mutation_mac: 'bridge-mutation-mac',
-    meta: 'bridge-meta'
-};
-// Stores that are byte-compatible between bridge and upstream and so can
-// be persisted unchanged. Currently empty — every Signal record needs
-// either a key rewrite or a value-byte conversion, both handled by
-// `converters` below.
-const BINARY_STORES = new Set();
-// Bridge-only stores — raw binary persisted through the keys interface.
-// Derived from STORE_MAP: anything mapped to a `bridge-*` upstream type
-// has no peer in upstream Baileys' SignalDataTypeMap and must round-trip
-// as raw bytes. `lid_mapping` is mapped to upstream's `lid-mapping` type
-// instead (its converter rewrites the key prefixes), so it's not
-// bridge-only and is naturally excluded by the prefix filter.
-const BRIDGE_ONLY_STORES = new Set(Object.entries(STORE_MAP)
-    .filter(([, upstreamType]) => upstreamType.startsWith('bridge-'))
-    .map(([bridgeName]) => bridgeName));
-/** Reconstruct a JID string from the bridge's serialized Jid object.
- *  Format: `user[_<agent>][:<device>]@<server>`. The agent suffix is
- *  required to round-trip hosted Business accounts (`5511_2@hosted`) —
- *  `credsToDeviceJson` stores it, so the load path must also emit it.
- *  Without this, `creds.me.id` would lose the `_<agent>` half on every
- *  reload and the next `credsToDeviceJson` save would zero `agent`. */
-function bridgeJidToString(j) {
-    if (!j?.user || !j?.server)
-        return null;
-    const agent = j.agent ?? 0;
-    const device = j.device ?? 0;
-    return `${j.user}${agent > 0 ? '_' + agent : ''}${device > 0 ? ':' + device : ''}@${j.server}`;
-}
-// ---- Helpers ----
-const toJson = (v) => new TextEncoder().encode(JSON.stringify(v));
-const fromJson = (b) => JSON.parse(new TextDecoder().decode(b));
-const toBuf = (v) => v instanceof Uint8Array ? v : Buffer.isBuffer(v) ? new Uint8Array(v) : null;
-/** Convert Buffer/Uint8Array to a plain number[] for JSON serialization.
- *  Matches Rust's serde_json Vec<u8> format: [byte, byte, ...] */
-const bufToNumArray = (v) => Array.from(Buffer.from(v));
-/**
- * `true` when the key bytes are absent or all zeros. Used at the device-read
- * boundary to detect a partially-hydrated creds object (e.g. migration
- * remnants where only `me.id` survived) and tell the bridge to bootstrap
- * fresh material instead of blowing up the noise handshake with `precondition-required`.
- */
-const isZeroKey = (b) => {
-    if (!b)
-        return true;
-    // Buffer is a Uint8Array subclass at runtime, so this view is always safe.
-    const view = b;
-    if (view.length === 0)
-        return true;
-    for (let i = 0; i < view.length; i++)
-        if (view[i] !== 0)
-            return false;
-    return true;
-};
-/** Bridge uses hex-encoded key IDs for sync_key; upstream uses base64. Convert hex→base64. */
-const hexToBase64 = (hex) => Buffer.from(hex, 'hex').toString('base64');
-const converters = {
-    prekey: {
-        toBridge(key, value) {
-            if (value instanceof Uint8Array || Buffer.isBuffer(value))
-                return toBuf(value);
-            const kp = value;
-            return kp.private && kp.public
-                ? encodePreKeyRecord(parseInt(key) || 0, Buffer.from(kp.public), Buffer.from(kp.private))
-                : null;
-        },
-        fromBridge(_key, value) {
-            return decodePreKeyRecord(value) ?? Buffer.from(value);
-        }
-    },
-    sync_key: {
-        toBridge(_key, value) {
-            if (value instanceof Uint8Array || Buffer.isBuffer(value))
-                return toBuf(value);
-            // Rust AppStateSyncKey: key_data=Vec<u8>, fingerprint=Vec<u8> (protobuf-encoded),
-            // timestamp=i64. serde_json serializes Vec<u8> as array of numbers.
-            const msg = value;
-            const fingerprintBytes = msg.fingerprint
-                ? proto.Message.AppStateSyncKeyFingerprint.encode(proto.Message.AppStateSyncKeyFingerprint.create(msg.fingerprint)).finish()
-                : null;
-            return toJson({
-                key_data: msg.keyData ? bufToNumArray(Buffer.from(msg.keyData)) : [],
-                fingerprint: fingerprintBytes ? bufToNumArray(fingerprintBytes) : [],
-                timestamp: Number(msg.timestamp ?? 0)
-            });
-        },
-        fromBridge(_key, value) {
-            try {
-                const j = fromJson(value);
-                const keyData = Array.isArray(j.key_data) ? Buffer.from(j.key_data) : undefined;
-                const fingerprint = Array.isArray(j.fingerprint) && j.fingerprint.length > 0
-                    ? proto.Message.AppStateSyncKeyFingerprint.decode(Buffer.from(j.fingerprint))
-                    : undefined;
-                return proto.Message.AppStateSyncKeyData.fromObject({
-                    keyData,
-                    fingerprint,
-                    timestamp: j.timestamp ?? 0
-                });
-            }
-            catch {
-                return Buffer.from(value);
-            }
-        }
-    },
-    sync_version: {
-        toBridge(_key, value) {
-            if (value instanceof Uint8Array || Buffer.isBuffer(value))
-                return toBuf(value);
-            // Rust HashState: version=u64, hash=[u8;128] (BigArray → number array),
-            // index_value_map=HashMap<String, Vec<u8>> (snake_case, plain byte arrays).
-            // Upstream LTHashState: hash=Buffer, indexValueMap={[k]: {valueMac: Buffer}} (camelCase, wrapped).
-            const v = value;
-            const indexValueMap = {};
-            if (v.indexValueMap) {
-                for (const [k, entry] of Object.entries(v.indexValueMap)) {
-                    indexValueMap[k] = bufToNumArray(Buffer.from(entry.valueMac));
-                }
-            }
-            return toJson({
-                version: v.version ?? 0,
-                hash: v.hash ? bufToNumArray(Buffer.from(v.hash)) : Array(128).fill(0),
-                index_value_map: indexValueMap
-            });
-        },
-        fromBridge(_key, value) {
-            try {
-                const j = fromJson(value);
-                const indexValueMap = {};
-                if (j.index_value_map) {
-                    for (const [k, v] of Object.entries(j.index_value_map)) {
-                        indexValueMap[k] = { valueMac: Buffer.from(v) };
-                    }
-                }
-                return {
-                    version: j.version ?? 0,
-                    hash: Buffer.from(j.hash ?? []),
-                    indexValueMap
-                };
-            }
-            catch {
-                return Buffer.from(value);
-            }
-        }
-    },
-    tc_token: {
-        toBridge(_key, value) {
-            // Rust `TcTokenEntry { token: Vec<u8>, token_timestamp: i64,
-            // sender_timestamp: Option<i64> }`. serde_json maps Vec<u8> to a
-            // numeric array — base64 strings make the deserializer choke
-            // with "invalid type: string ... expected a sequence".
-            const tc = value;
-            return toJson({
-                token: tc.token ? bufToNumArray(Buffer.from(tc.token)) : [],
-                token_timestamp: tc.timestamp ? parseInt(tc.timestamp) : 0,
-                sender_timestamp: tc.senderTimestamp ? parseInt(tc.senderTimestamp) : null
-            });
-        },
-        fromBridge(_key, value) {
-            try {
-                const j = fromJson(value);
-                return {
-                    token: Array.isArray(j.token) ? Buffer.from(j.token) : Buffer.alloc(0),
-                    timestamp: j.token_timestamp?.toString(),
-                    senderTimestamp: j.sender_timestamp != null ? j.sender_timestamp.toString() : undefined
-                };
-            }
-            catch {
-                return { token: Buffer.from(value) };
-            }
-        }
-    },
-    device_list: {
-        toBridge(key, value) {
-            const list = value;
-            return toJson({
-                user: key,
-                devices: list.map(id => ({ device_id: parseInt(id) || 0 })),
-                timestamp: Math.floor(Date.now() / 1000)
-            });
-        },
-        fromBridge(_key, value) {
-            try {
-                const r = fromJson(value);
-                const items = r.devices ?? [];
-                return items.map(d => String(d.device_id ?? 0));
-            }
-            catch {
-                return [];
-            }
-        }
-    },
-    // identity: bridge holds 32-byte raw DJB pubkey, upstream holds 33 bytes
-    // (0x05 || 32-byte) — the curve25519-XEdDSA wire form.
-    identity: {
-        toBridge(_key, value) {
-            const buf = toBuf(value);
-            if (!buf)
-                return null;
-            return buf.length === 33 && buf[0] === 0x05 ? new Uint8Array(buf.slice(1)) : buf;
-        },
-        fromBridge(_key, value) {
-            const v = Buffer.isBuffer(value) ? value : Buffer.from(value);
-            return v.length === 32 ? Buffer.concat([Buffer.from([0x05]), v]) : Buffer.from(v);
-        }
-    },
-    // lid_mapping: bridge uses prefixed keys (`lid:{X}` JSON entry,
-    // `pn:{X}` raw LID bytes); upstream uses bare keys (`{pnUser}` string LID,
-    // `{lidUser}_reverse` string PN). No upstream timestamps; we synthesise.
-    lid_mapping: {
-        toBridge(key, value) {
-            try {
-                const asString = typeof value === 'string' ? value : Buffer.from(value).toString('utf-8');
-                if (!asString)
-                    return null;
-                if (key.startsWith('pn:'))
-                    return new TextEncoder().encode(asString);
-                if (key.startsWith('lid:')) {
-                    const now = Math.floor(Date.now() / 1000);
-                    return toJson({
-                        lid: key.slice(4),
-                        phone_number: asString,
-                        created_at: now,
-                        updated_at: now,
-                        learning_source: 'wrap-legacy-store'
-                    });
-                }
-                warn(`lid_mapping.toBridge: unknown key prefix in "${key}"`);
-                return null;
-            }
-            catch (e) {
-                warn('lid_mapping.toBridge failed:', e);
-                return null;
-            }
-        },
-        fromBridge(key, value) {
-            try {
-                if (key.startsWith('pn:'))
-                    return Buffer.from(value).toString('utf-8');
-                if (key.startsWith('lid:')) {
-                    const entry = fromJson(value);
-                    return entry.phone_number ?? '';
-                }
-                warn(`lid_mapping.fromBridge: unknown key prefix in "${key}"`);
-                return Buffer.from(value);
-            }
-            catch (e) {
-                warn('lid_mapping.fromBridge failed:', e);
-                return Buffer.from(value);
-            }
-        }
-    },
-    // session: bridge=protobuf RecordStructure, upstream=JS object
-    // `{_sessions: {[b64BaseKey]: SessionEntry}, version: 'v1'}` with byte
-    // fields stored as base64 strings inside the entry. messageKeys cache
-    // is lossy in the Rust→JS direction (HKDF is one-way) — see
-    // `bridgeSessionProtoToUpstreamRecord`.
-    session: {
-        toBridge(_key, value) {
-            try {
-                if (value == null)
-                    return null;
-                return upstreamSessionRecordToProto(value);
-            }
-            catch (e) {
-                warn('session.toBridge encode failed:', e);
-                return null;
-            }
-        },
-        fromBridge(_key, value) {
-            try {
-                return bridgeSessionProtoToUpstreamRecord(value);
-            }
-            catch (e) {
-                warn('session.fromBridge decode failed:', e);
-                return Buffer.from(value);
-            }
-        }
-    },
-    // sender_key: bridge=protobuf SenderKeyRecordStructure, upstream=
-    // `Buffer.from(JSON.stringify(states, BufferJSON.replacer), 'utf-8')`
-    // — Buffer fields wrapped as `{type:'Buffer', data:'<base64>'}`.
-    sender_key: {
-        toBridge(_key, value) {
-            try {
-                const buf = toBuf(value);
-                if (!buf)
-                    return null;
-                return upstreamSenderKeyJsonToProto(buf);
-            }
-            catch (e) {
-                warn('sender_key.toBridge decode failed:', e);
-                return null;
-            }
-        },
-        fromBridge(_key, value) {
-            try {
-                return bridgeSenderKeyProtoToJson(value);
-            }
-            catch (e) {
-                warn('sender_key.fromBridge encode failed:', e);
-                return Buffer.from(value);
-            }
-        }
-    }
-};
-const sk_toBytes = (v) => v ? new Uint8Array(Buffer.from(v)) : new Uint8Array();
-const sk_toBuffer = (v) => Buffer.from(v ?? new Uint8Array());
-function bridgeSenderKeyProtoToJson(protoBytes) {
-    const struct = proto.SenderKeyRecordStructure.decode(Buffer.from(protoBytes));
-    const states = (struct.senderKeyStates ?? []).map(s => ({
-        senderKeyId: s.senderKeyId ?? 0,
-        senderChainKey: { iteration: s.senderChainKey?.iteration ?? 0, seed: sk_toBuffer(s.senderChainKey?.seed) },
-        senderSigningKey: {
-            public: sk_toBuffer(s.senderSigningKey?.public),
-            private: sk_toBuffer(s.senderSigningKey?.private)
-        },
-        senderMessageKeys: (s.senderMessageKeys ?? []).map(mk => ({
-            iteration: mk.iteration ?? 0,
-            seed: sk_toBuffer(mk.seed)
-        }))
-    }));
-    return Buffer.from(JSON.stringify(states, BufferJSON.replacer), 'utf-8');
-}
-function upstreamSenderKeyJsonToProto(jsonBuf) {
-    const states = JSON.parse(Buffer.from(jsonBuf).toString('utf-8'), BufferJSON.reviver);
-    const senderKeyStates = states.map(s => ({
-        senderKeyId: s.senderKeyId ?? 0,
-        senderChainKey: { iteration: s.senderChainKey?.iteration ?? 0, seed: sk_toBytes(s.senderChainKey?.seed) },
-        senderSigningKey: {
-            public: sk_toBytes(s.senderSigningKey?.public),
-            private: sk_toBytes(s.senderSigningKey?.private)
-        },
-        senderMessageKeys: (s.senderMessageKeys ?? []).map(mk => ({
-            iteration: mk.iteration ?? 0,
-            seed: sk_toBytes(mk.seed)
-        }))
-    }));
-    return proto.SenderKeyRecordStructure.encode(proto.SenderKeyRecordStructure.create({ senderKeyStates })).finish();
-}
-// sender_key key translation: bridge `{group}:{user}[:dev]@{server}.{sig}`
-// → upstream `{group}::{signalUser}::{deviceId}`. Group JIDs never contain
-// `:`, so the first `:` separates group from sender address.
-function bridgeSenderKeyToUpstream(bridgeKey) {
-    const sep = bridgeKey.indexOf(':');
-    if (sep < 0)
-        return null;
-    const groupJid = bridgeKey.slice(0, sep);
-    const addrStr = bridgeKey.slice(sep + 1);
-    const dotIdx = addrStr.lastIndexOf('.');
-    if (dotIdx < 0)
-        return null;
-    const jidPart = addrStr.slice(0, dotIdx);
-    const atIdx = jidPart.indexOf('@');
-    if (atIdx < 0)
-        return null;
-    const userPart = jidPart.slice(0, atIdx);
-    const server = jidPart.slice(atIdx + 1);
-    const [user, jidDev] = userPart.includes(':')
-        ? [userPart.slice(0, userPart.indexOf(':')), parseInt(userPart.slice(userPart.indexOf(':') + 1), 10) || 0]
-        : [userPart, 0];
-    const domainType = DOMAIN_TYPE_MAP[server];
-    if (domainType === undefined)
-        return null;
-    return `${groupJid}::${domainType !== 0 ? `${user}_${domainType}` : user}::${jidDev}`;
-}
-const CHAIN_TYPE_SENDING = 1;
-const CHAIN_TYPE_RECEIVING = 2;
-const BASE_KEY_TYPE_OURS = 1;
-const BASE_KEY_TYPE_THEIRS = 2;
-// Non-nullable to keep the empty-vs-missing distinction visible at call sites.
-const b64 = (b) => Buffer.from(b).toString('base64');
-const fromB64 = (s) => Buffer.from(s, 'base64');
-const EMPTY_BYTES = new Uint8Array();
-// Rust `chain_key.index` and JS `chainKey.counter` differ by 1 (fresh = 0 vs -1).
-const rustIndexToJsCounter = (index) => (index ?? 0) - 1;
-const jsCounterToRustIndex = (counter) => counter + 1;
-/**
- * Derive Rust's per-message split (cipher 32 / mac 32 / iv 16) from JS's
- * 32-byte `messageKey` seed. Both impls compute HKDF-SHA256 with
- * salt=[0u8;32] and info="WhisperMessageKeys" — Rust's `None` salt
- * defaults to a zero-byte HashLen string, so the output is byte-identical.
- * Reverse direction (Rust→JS) is impossible: HKDF is one-way.
- */
-function deriveProtoMessageKey(seed, counter) {
-    const prk = createHmac('sha256', Buffer.alloc(32)).update(seed).digest();
-    const info = Buffer.from('WhisperMessageKeys');
-    const expand = (prev, n) => createHmac('sha256', prk)
-        .update(Buffer.concat([prev, info, Buffer.from([n])]))
-        .digest();
-    const t1 = expand(Buffer.alloc(0), 0x01);
-    const t2 = expand(t1, 0x02);
-    const t3 = expand(t2, 0x03);
-    // Message keys use the same counter/index value in both impls — only the
-    // chain key has the off-by-one (see `rustIndexToJsCounter`).
-    return {
-        index: counter,
-        cipherKey: new Uint8Array(t1),
-        macKey: new Uint8Array(t2),
-        iv: new Uint8Array(t3.subarray(0, 16))
-    };
-}
-function jsChainMessageKeysToProto(messageKeys) {
-    if (!messageKeys)
-        return [];
-    const out = [];
-    for (const [counterStr, seedB64] of Object.entries(messageKeys)) {
-        const counter = parseInt(counterStr, 10);
-        if (!Number.isFinite(counter))
-            continue;
-        const seed = fromB64(seedB64);
-        if (seed.length > 0)
-            out.push(deriveProtoMessageKey(seed, counter));
-    }
-    return out;
-}
-function sessionStructureToEntry(session, closedTs) {
-    if (!session.senderChain || !session.rootKey)
-        return null;
-    // aliceBaseKey is set by Rust on BOTH sides (alice=our ephemeral, bob=
-    // peer's ephemeral). pendingPreKey is the side discriminator (alice
-    // only, cleared on first reply).
-    const baseKeyBytes = session.aliceBaseKey ?? session.senderChain.senderRatchetKey;
-    if (!baseKeyBytes)
-        return null;
-    const weAreAlice = !!session.pendingPreKey?.baseKey;
-    const baseKeyType = weAreAlice ? BASE_KEY_TYPE_OURS : BASE_KEY_TYPE_THEIRS;
-    // lastRemoteEphemeralKey precedence: tail receiverChain → aliceBaseKey
-    // (when bob, matches JS init) → empty. NEVER senderRatchetKey: that
-    // collides with the SENDER chain in `_chains`, and upstream's
-    // `maybeStepRatchet` would `delete previousRatchet.chainKey.key` on
-    // the sender chain when the peer ratchets, corrupting outbound encryption.
-    const receiverChains = session.receiverChains ?? [];
-    const lastReceiver = receiverChains[receiverChains.length - 1];
-    const lastRemoteEph = lastReceiver?.senderRatchetKey && lastReceiver.senderRatchetKey.length > 0
-        ? lastReceiver.senderRatchetKey
-        : !weAreAlice && session.aliceBaseKey && session.aliceBaseKey.length > 0
-            ? session.aliceBaseKey
-            : EMPTY_BYTES;
-    const senderRatchetPub = session.senderChain.senderRatchetKey ?? EMPTY_BYTES;
-    const senderRatchetPriv = session.senderChain.senderRatchetKeyPrivate ?? EMPTY_BYTES;
-    const _chains = {};
-    const senderChainKey = session.senderChain.chainKey;
-    if (senderChainKey?.key?.length && senderRatchetPub.length > 0) {
-        _chains[b64(senderRatchetPub)] = {
-            chainKey: { counter: rustIndexToJsCounter(senderChainKey.index), key: b64(senderChainKey.key) },
-            chainType: CHAIN_TYPE_SENDING,
-            messageKeys: {}
-        };
-    }
-    for (const rc of receiverChains) {
-        if (!rc.chainKey?.key?.length || !rc.senderRatchetKey?.length)
-            continue;
-        _chains[b64(rc.senderRatchetKey)] = {
-            chainKey: { counter: rustIndexToJsCounter(rc.chainKey.index), key: b64(rc.chainKey.key) },
-            chainType: CHAIN_TYPE_RECEIVING,
-            messageKeys: {}
-        };
-    }
-    const now = Date.now();
-    const entry = {
-        registrationId: session.remoteRegistrationId ?? 0,
-        currentRatchet: {
-            ephemeralKeyPair: { pubKey: b64(senderRatchetPub), privKey: b64(senderRatchetPriv) },
-            lastRemoteEphemeralKey: b64(lastRemoteEph),
-            previousCounter: session.previousCounter ?? 0,
-            rootKey: b64(session.rootKey)
-        },
-        indexInfo: {
-            baseKey: b64(baseKeyBytes),
-            baseKeyType,
-            closed: closedTs,
-            used: now,
-            created: now,
-            remoteIdentityKey: b64(session.remoteIdentityPublic ?? EMPTY_BYTES)
-        },
-        _chains
-    };
-    if (session.pendingPreKey?.baseKey) {
-        entry.pendingPreKey = {
-            preKeyId: session.pendingPreKey.preKeyId ?? undefined,
-            signedKeyId: session.pendingPreKey.signedPreKeyId ?? undefined,
-            baseKey: b64(session.pendingPreKey.baseKey)
-        };
-    }
-    return entry;
-}
-function bridgeSessionProtoToUpstreamRecord(protoBytes) {
-    const record = proto.RecordStructure.decode(Buffer.from(protoBytes));
-    const _sessions = {};
-    const current = record.currentSession ? sessionStructureToEntry(record.currentSession, -1) : null;
-    if (current)
-        _sessions[current.indexInfo.baseKey] = current;
-    // Synthesize descending close timestamps so removeOldSessions can sort:
-    // front of Rust `previous_sessions` is the most recently archived.
-    const previous = record.previousSessions ?? [];
-    for (let i = 0; i < previous.length; i++) {
-        const entry = sessionStructureToEntry(previous[i], Math.max(1, Date.now() - i));
-        if (entry && !_sessions[entry.indexInfo.baseKey])
-            _sessions[entry.indexInfo.baseKey] = entry;
-    }
-    return { _sessions, version: 'v1' };
-}
-function entryToSessionStructure(entry) {
-    const ratchet = entry.currentRatchet;
-    const senderRatchetPub = fromB64(ratchet.ephemeralKeyPair.pubKey);
-    const senderRatchetPriv = fromB64(ratchet.ephemeralKeyPair.privKey);
-    const senderKeyB64 = senderRatchetPub.toString('base64');
-    const senderChainEntry = entry._chains[senderKeyB64];
-    const senderChain = {
-        senderRatchetKey: new Uint8Array(senderRatchetPub),
-        senderRatchetKeyPrivate: new Uint8Array(senderRatchetPriv),
-        chainKey: senderChainEntry
-            ? {
-                index: jsCounterToRustIndex(senderChainEntry.chainKey.counter),
-                key: new Uint8Array(fromB64(senderChainEntry.chainKey.key))
-            }
-            : { index: 0, key: EMPTY_BYTES },
-        messageKeys: [] // sender chain is sequential — no skipped cache either side
-    };
-    const receiverChains = [];
-    for (const [k, ch] of Object.entries(entry._chains)) {
-        if (ch.chainType !== CHAIN_TYPE_RECEIVING)
-            continue;
-        receiverChains.push({
-            senderRatchetKey: new Uint8Array(fromB64(k)),
-            chainKey: { index: jsCounterToRustIndex(ch.chainKey.counter), key: new Uint8Array(fromB64(ch.chainKey.key)) },
-            // JS holds 32-byte HMAC seeds; Rust holds the post-HKDF split.
-            // Lossless JS→Rust derivation via deriveProtoMessageKey.
-            messageKeys: jsChainMessageKeysToProto(ch.messageKeys)
-        });
-    }
-    // `indexInfo.baseKey` IS the alice_base_key in either direction
-    // (alice=our ephemeral, bob=peer's ephemeral). Rust populates it
-    // symmetrically; dropping it would break find_matching_previous_session_index.
-    const session = {
-        rootKey: new Uint8Array(fromB64(ratchet.rootKey)),
-        previousCounter: ratchet.previousCounter,
-        senderChain,
-        receiverChains,
-        remoteIdentityPublic: new Uint8Array(fromB64(entry.indexInfo.remoteIdentityKey)),
-        remoteRegistrationId: entry.registrationId ?? 0,
-        aliceBaseKey: new Uint8Array(fromB64(entry.indexInfo.baseKey))
-    };
-    if (entry.pendingPreKey?.baseKey) {
-        session.pendingPreKey = {
-            preKeyId: entry.pendingPreKey.preKeyId ?? null,
-            signedPreKeyId: entry.pendingPreKey.signedKeyId ?? null,
-            baseKey: new Uint8Array(fromB64(entry.pendingPreKey.baseKey))
-        };
-    }
-    return session;
-}
-function upstreamSessionRecordToProto(record) {
-    const sessions = record?._sessions ?? {};
-    let currentSession = null;
-    const previousSessions = [];
-    for (const entry of Object.values(sessions)) {
-        const ss = entryToSessionStructure(entry);
-        if (!currentSession && entry.indexInfo.closed === -1)
-            currentSession = ss;
-        else
-            previousSessions.push(ss);
-    }
-    const recordOut = proto.RecordStructure.create({
-        currentSession: currentSession ?? undefined,
-        previousSessions
-    });
-    return proto.RecordStructure.encode(recordOut).finish();
-}
-// session/identity key translation: bridge `{user}[:dev]@{server}.{sig}`
-// → upstream `{signalUser}.{deviceId}` via `bridgeAddrToBaileysAddr`.
-// ---- Device/Creds ----
-/**
- * Extract the literal `_<n>` agent suffix from a raw JID. `jidDecode`
- * folds it into `domainType` only for plain `s.whatsapp.net`; for special
- * servers (`hosted`, `hosted.lid`) it is parsed-then-discarded because
- * `domainType` is taken from the server. The bridge's `Jid.agent`
- * field needs the literal number, so recover it here.
- */
-function jidAgent(rawJid) {
-    if (!rawJid)
-        return 0;
-    const atIdx = rawJid.indexOf('@');
-    if (atIdx < 0)
-        return 0;
-    const userPart = rawJid.slice(0, atIdx).split(':', 1)[0];
-    if (!userPart)
-        return 0;
-    const sepIdx = userPart.indexOf('_');
-    if (sepIdx < 0)
-        return 0;
-    const n = parseInt(userPart.slice(sepIdx + 1), 10);
-    return Number.isFinite(n) ? n : 0;
-}
-function credsToDeviceJson(creds) {
-    /** Serialize a key pair as [private(32) + public(32)] matching Rust key_pair_serde */
-    const kp = (pair) => {
-        if (!pair)
-            return Array(64).fill(0);
-        return bufToNumArray(Buffer.from(pair.private)).concat(bufToNumArray(Buffer.from(pair.public)));
-    };
-    const pnJid = jidDecode(creds.me?.id);
-    const lidJid = jidDecode(creds.me?.lid);
-    const deviceNum = pnJid?.device ?? lidJid?.device ?? 0;
-    const pnAgent = jidAgent(creds.me?.id);
-    const lidAgent = jidAgent(creds.me?.lid);
-    // Preserve `server` and recover the literal `_<n>` agent suffix so
-    // hosted / hosted.lid accounts (e.g. `5511_2@hosted`) survive a
-    // drop-in migration from upstream Baileys.
-    return toJson({
-        pn: pnJid ? { user: pnJid.user, server: pnJid.server, device: deviceNum, agent: pnAgent, integrator: 0 } : null,
-        lid: lidJid
-            ? { user: lidJid.user, server: lidJid.server, device: lidJid.device ?? 0, agent: lidAgent, integrator: 0 }
-            : null,
-        registration_id: creds.registrationId ?? 0,
-        noise_key: kp(creds.noiseKey),
-        identity_key: kp(creds.signedIdentityKey),
-        signed_pre_key: kp(creds.signedPreKey?.keyPair),
-        signed_pre_key_id: creds.signedPreKey?.keyId ?? 1,
-        signed_pre_key_signature: creds.signedPreKey?.signature
-            ? bufToNumArray(Buffer.from(creds.signedPreKey.signature))
-            : Array(64).fill(0),
-        adv_secret_key: creds.advSecretKey
-            ? bufToNumArray(Buffer.from(creds.advSecretKey, 'base64'))
-            : Array(32).fill(0),
-        account: null,
-        push_name: creds.me?.name ?? '',
-        app_version_primary: 2,
-        app_version_secondary: 3000,
-        app_version_tertiary: 0,
-        app_version_last_fetched_ms: 0,
-        edge_routing_info: creds.routingInfo ? bufToNumArray(creds.routingInfo) : null,
-        props_hash: creds.lastPropHash ?? null,
-        next_pre_key_id: creds.nextPreKeyId ?? 1
-    });
-}
-/**
- * Decode a `[priv(32)…pub(32)]` byte array (the bridge's `kp` shape) back into
- * the upstream Baileys `{public, private}` keypair. Returns `undefined` for
- * absent / all-zero arrays so callers can use `??` to keep prior values.
- */
-function numArrayToKeyPair(arr) {
-    if (!Array.isArray(arr) || arr.length < 64)
-        return undefined;
-    if (arr.every(b => b === 0))
-        return undefined;
-    return {
-        private: new Uint8Array(arr.slice(0, 32)),
-        public: new Uint8Array(arr.slice(32, 64))
-    };
-}
-function updateCredsFromDevice(bytes, creds) {
-    try {
-        const d = fromJson(bytes);
-        // Reconstruct pn JID: bridge stores Jid as { user, server, device, agent, integrator }
-        // bridgeJidToString produces "user:device@server" (device omitted when 0)
-        const pnJid = bridgeJidToString(d.pn);
-        if (pnJid) {
-            if (!creds.me)
-                creds.me = { id: pnJid };
-            else
-                creds.me.id = pnJid;
-        }
-        // Reconstruct LID JID
-        const lidJid = bridgeJidToString(d.lid);
-        if (lidJid && creds.me)
-            creds.me.lid = lidJid;
-        if (d.push_name && creds.me)
-            creds.me.name = d.push_name;
-        if (d.registration_id)
-            creds.registrationId = d.registration_id;
-        if (d.next_pre_key_id) {
-            creds.nextPreKeyId = d.next_pre_key_id;
-            // Keep `firstUnuploadedPreKeyId` pinned to `nextPreKeyId`. Upstream
-            // Baileys uses `nextPreKeyId - firstUnuploadedPreKeyId` to decide
-            // whether a fresh `getNextPreKeys()` call needs to generate a new
-            // keypair or can reuse one already in the store. Bridge consumes
-            // prekeys without bumping `firstUnuploadedPreKeyId`, so without
-            // this pin upstream sees a non-empty "available" range pointing at
-            // IDs that have already been deleted from disk — leading to
-            // `preKeys = {}` from `getNextPreKeys`, then
-            // `xmppPreKey(undefined)` → TypeError on retry receipt
-            // construction, then no retry sent, then upstream never decrypts
-            // the first post-handoff message from a bridge peer.
-            //
-            // Pinning to `nextPreKeyId` forces upstream to always generate a
-            // fresh keypair on `getNextPreKeys`, side-stepping the inconsistent
-            // "available" range. The cost is one extra Curve keygen on the
-            // first retry after handoff — negligible.
-            creds.firstUnuploadedPreKeyId = d.next_pre_key_id;
-        }
-        if (d.props_hash !== undefined)
-            creds.lastPropHash = d.props_hash ?? undefined;
-        if (d.platform)
-            creds.platform = d.platform;
-        // adv_secret_key: bridge stores as [u8; 32] (array of 32 numbers),
-        // upstream stores as base64 string
-        if (Array.isArray(d.adv_secret_key)) {
-            const buf = Buffer.from(d.adv_secret_key);
-            if (buf.some(b => b !== 0)) {
-                creds.advSecretKey = buf.toString('base64');
-            }
-        }
-        // Hydrate the noise / identity / signed pre-key material so the next
-        // `credsToDeviceJson(creds)` round-trip emits real bytes instead of
-        // zero-filled placeholders. Without this, a paired session looks
-        // half-valid on the next process start (`me.id` set, but key slots
-        // all zero) and the bridge's noise handshake gets rejected by the
-        // server with stream-error precondition-required.
-        const noise = numArrayToKeyPair(d.noise_key);
-        if (noise)
-            creds.noiseKey = noise;
-        const identity = numArrayToKeyPair(d.identity_key);
-        if (identity)
-            creds.signedIdentityKey = identity;
-        const signedPreKeyPair = numArrayToKeyPair(d.signed_pre_key);
-        if (signedPreKeyPair &&
-            Array.isArray(d.signed_pre_key_signature) &&
-            d.signed_pre_key_signature.length === 64 &&
-            d.signed_pre_key_signature.some(b => b !== 0)) {
-            creds.signedPreKey = {
-                keyPair: signedPreKeyPair,
-                keyId: d.signed_pre_key_id ?? 1,
-                signature: new Uint8Array(d.signed_pre_key_signature)
-            };
-        }
-    }
-    catch (e) {
-        warn('updateCredsFromDevice failed:', e);
-    }
-}
-// ---- Protobuf helpers (PreKeyRecordStructure) ----
-function encodePreKeyRecord(id, pub, priv) {
-    const out = [];
-    out.push(0x08);
-    encodeVarint(out, id); // field 1: id
-    out.push(0x12);
-    encodeVarint(out, pub.length); // field 2: public_key
-    for (let i = 0; i < pub.length; i++)
-        out.push(pub[i]);
-    out.push(0x1a);
-    encodeVarint(out, priv.length); // field 3: private_key
-    for (let i = 0; i < priv.length; i++)
-        out.push(priv[i]);
-    return new Uint8Array(out);
-}
-function decodePreKeyRecord(data) {
-    try {
-        let pos = 0, pub = null, priv = null;
-        while (pos < data.length) {
-            const [tag, p1] = readVarint(data, pos);
-            pos = p1;
-            const wt = tag & 7, fn = tag >> 3;
-            if (wt === 0) {
-                const [, p2] = readVarint(data, pos);
-                pos = p2;
-            }
-            else if (wt === 2) {
-                const [len, p2] = readVarint(data, pos);
-                pos = p2;
-                const bytes = Buffer.from(data.slice(pos, pos + len));
-                pos += len;
-                if (fn === 2)
-                    pub = bytes;
-                else if (fn === 3)
-                    priv = bytes;
-            }
-            else
-                break;
-        }
-        return pub && priv ? { public: pub, private: priv } : null;
-    }
-    catch {
-        return null;
-    }
-}
-// ---- Protobuf varint helpers ----
-function encodeVarint(out, v) {
-    while (v > 0x7f) {
-        out.push((v & 0x7f) | 0x80);
-        v >>>= 7;
-    }
-    out.push(v & 0x7f);
-}
-function readVarint(d, p) {
-    let r = 0, s = 0;
-    while (p < d.length) {
-        const b = d[p];
-        p++;
-        r |= (b & 0x7f) << s;
-        if (!(b & 0x80))
-            return [r, p];
-        s += 7;
-    }
-    return [r, p];
-}
-// ---- Signal address translation ----
-// Bridge uses JID-based addresses: "236395184570386@lid.0", "559984726662@c.us.0"
-// Baileys uses domain-type addresses: "236395184570386_1.0", "559984726662.0"
-// Domain types: s.whatsapp.net/c.us=0, lid=1, hosted=2, hosted.lid=3
-const DOMAIN_TYPE_MAP = { lid: 1, 'c.us': 0, 's.whatsapp.net': 0, hosted: 2, 'hosted.lid': 3 };
-/** Convert bridge signal address to Baileys signal address */
-function bridgeAddrToBaileysAddr(bridgeAddr) {
-    // Format: "user@domain.signalDevice" or "user:jidDevice@domain.signalDevice"
-    const dotIdx = bridgeAddr.lastIndexOf('.');
-    if (dotIdx < 0)
-        return null;
-    const signalDevice = bridgeAddr.slice(dotIdx + 1);
-    const jidPart = bridgeAddr.slice(0, dotIdx); // "user@domain" or "user:jidDevice@domain"
-    const atIdx = jidPart.indexOf('@');
-    if (atIdx < 0)
-        return null;
-    const domain = jidPart.slice(atIdx + 1);
-    const userPart = jidPart.slice(0, atIdx); // "user" or "user:jidDevice"
-    const domainType = DOMAIN_TYPE_MAP[domain];
-    if (domainType === undefined)
-        return null;
-    // Baileys format: "user_domainType.device" or "user.device" (when domainType=0)
-    // For JID device: "user_domainType:jidDevice.device"
-    let baileysUser;
-    if (userPart.includes(':')) {
-        // Has JID device: "user:jidDevice" → for signal address, device is the JID device
-        const [user, jidDevice] = userPart.split(':');
-        baileysUser = domainType !== 0 ? `${user}_${domainType}` : user;
-        return `${baileysUser}.${jidDevice}`;
-    }
-    else {
-        baileysUser = domainType !== 0 ? `${userPart}_${domainType}` : userPart;
-        return `${baileysUser}.${signalDevice}`;
-    }
-}
-// ---- Account normalization ----
-// Upstream Baileys stores account fields as base64 strings (protobuf.js toJSON),
-// but the bridge's encodeProto expects Uint8Array for bytes fields.
-function normalizeAccountForEncode(account) {
-    const toBytes = (v) => {
-        if (v instanceof Uint8Array)
-            return v;
-        if (Buffer.isBuffer(v))
-            return new Uint8Array(v);
-        if (typeof v === 'string')
-            return Buffer.from(v, 'base64');
-        return undefined;
-    };
-    return {
-        details: toBytes(account.details),
-        accountSignatureKey: toBytes(account.accountSignatureKey),
-        accountSignature: toBytes(account.accountSignature),
-        deviceSignature: toBytes(account.deviceSignature)
-    };
-}
-// ---- Main ----
-export async function wrapLegacyStore(state, saveCreds, logger) {
-    if (logger) {
-        _warnFn = (msg, err) => logger.warn({ err }, msg);
-    }
-    if (!state.creds || !state.keys) {
-        throw new Error('wrapLegacyStore requires an AuthenticationState with creds and keys');
-    }
-    const creds = state.creds;
-    const keys = state.keys;
-    const store = keys;
-    const storeGetOne = async (type, id) => {
-        const result = await store.get(type, [id]);
-        return result[id] ?? null;
-    };
-    const storeSetOne = (type, id, value) => store.set({ [type]: { [id]: value } });
-    let credsTimer = null;
-    const debounceSave = () => {
-        if (credsTimer)
-            clearTimeout(credsTimer);
-        credsTimer = setTimeout(() => {
-            credsTimer = null;
-            saveCreds().catch(err => warn('saveCreds failed', err));
-        }, 100);
-    };
-    /** Route a store to its handler */
-    const resolve = (storeName) => {
-        if (storeName === 'device')
-            return 'device';
-        if (BINARY_STORES.has(storeName))
-            return 'signal';
-        if (BRIDGE_ONLY_STORES.has(storeName))
-            return 'bridge-only';
-        if (STORE_MAP[storeName])
-            return 'converter';
-        return 'unknown';
-    };
-    /** Translate bridge key format to upstream Baileys key format */
-    const translateKey = (storeName, key) => {
-        // Bridge encodes sync_key IDs as hex; upstream stores use base64
-        if (storeName === 'sync_key')
-            return hexToBase64(key);
-        // Bridge sender_key cache_key uses single-colon separator + signal-
-        // device suffix; upstream's `SenderKeyName.serialize()` uses double
-        // colons and drops the signal device — see bridgeSenderKeyToUpstream.
-        if (storeName === 'sender_key') {
-            const translated = bridgeSenderKeyToUpstream(key);
-            if (translated == null) {
-                warn(`sender_key key translation failed for "${key}", falling back to passthrough`);
-                return key;
-            }
-            return translated;
-        }
-        // Bridge session/identity keys are the protocol address
-        // (`user[:dev]@server.sig`); upstream's libsignal looks under
-        // `signalUser.deviceId`. `bridgeAddrToBaileysAddr` does the LID/PN
-        // → signalUser rewrite + JID-device extraction.
-        if (storeName === 'session' || storeName === 'identity') {
-            const translated = bridgeAddrToBaileysAddr(key);
-            if (translated == null) {
-                warn(`${storeName} key translation failed for "${key}", falling back to passthrough`);
-                return key;
-            }
-            return translated;
-        }
-        // Bridge lid_mapping uses prefixed keys (`lid:{X}`, `pn:{X}`) that
-        // upstream's `Signal/lid-mapping.js` doesn't recognize. Map them to
-        // upstream's bare-userpart shape: `pn:{X}` → `{X}`, `lid:{X}` →
-        // `{X}_reverse`.
-        if (storeName === 'lid_mapping') {
-            if (key.startsWith('pn:'))
-                return key.slice(3);
-            if (key.startsWith('lid:'))
-                return `${key.slice(4)}_reverse`;
-            return key;
-        }
-        return key;
-    };
-    /** Read a binary value from the keys store */
-    async function readBinary(type, id) {
-        try {
-            const val = await storeGetOne(type, id);
-            return val != null ? toBuf(val) : null;
-        }
-        catch (e) {
-            warn(`GET ${type}/${id} failed:`, e);
-            return null;
-        }
-    }
-    /** Write a binary value to the keys store */
-    async function writeBinary(type, id, value) {
-        try {
-            await storeSetOne(type, id, Buffer.from(value));
-        }
-        catch (e) {
-            warn(`SET ${type}/${id} failed:`, e);
-        }
-    }
-    /** Delete a value from the keys store */
-    async function storeDelete(type, id) {
-        try {
-            await storeSetOne(type, id, null);
-        }
-        catch (e) {
-            warn(`DELETE ${type}/${id} failed:`, e);
-        }
-    }
-    return {
-        async get(bridgeStore, key) {
-            const route = resolve(bridgeStore);
-            const type = STORE_MAP[bridgeStore];
-            if (route === 'device') {
-                if (key === 'device') {
-                    // Fresh/stub creds (baileyrs' `initAuthCreds()` shim, or an
-                    // upstream flow that hadn't finished its first pair) carry
-                    // neither a noise key nor a paired `me.id`. Returning a
-                    // zeroed `credsToDeviceJson` in that state poisons the
-                    // bridge's noise handshake (server responds 428 Precondition
-                    // Required). Signaling `null` instead lets the bridge
-                    // bootstrap its own device identity and write it back
-                    // through `set('device', 'device', …)` on pair-success.
-                    if (!creds.noiseKey && !creds.me?.id)
-                        return null;
-                    // Even when `noiseKey` is present as an object, the bytes
-                    // can still be all-zero — happens after a partial migration
-                    // from a legacy creds.json that only persisted `me.id`.
-                    // `credsToDeviceJson` would happily emit zero-filled key
-                    // slots, which the server rejects with the same 428. Treat
-                    // any zero-byte critical key as a bootstrap signal.
-                    if (isZeroKey(creds.noiseKey?.private) || isZeroKey(creds.signedIdentityKey?.private)) {
-                        warn('device read: noiseKey/signedIdentityKey is zero-valued; signaling bootstrap to bridge');
-                        return null;
-                    }
-                    return credsToDeviceJson(creds);
-                }
-                if (key === 'account') {
-                    if (!creds.account)
-                        return null;
-                    return new Uint8Array(ADVSignedDeviceIdentity.encode(normalizeAccountForEncode(creds.account)).finish());
-                }
-                return readBinary(type, key);
-            }
-            // `signal` route is currently unreachable (BINARY_STORES is empty);
-            // kept for future byte-compatible stores.
-            if (route === 'signal')
-                return readBinary(type, key);
-            if (route === 'bridge-only')
-                return readBinary(type, key);
-            if (route === 'converter') {
-                try {
-                    const upstreamKey = translateKey(bridgeStore, key);
-                    const value = await storeGetOne(type, upstreamKey);
-                    if (value == null)
-                        return null;
-                    return converters[bridgeStore]?.toBridge(key, value) ?? toBuf(value);
-                }
-                catch (e) {
-                    warn(`GET ${bridgeStore}/${key} failed:`, e);
-                    return null;
-                }
-            }
-            warn(`GET unknown store: ${bridgeStore}/${key}`);
-            return null;
-        },
-        async set(bridgeStore, key, value) {
-            const route = resolve(bridgeStore);
-            const type = STORE_MAP[bridgeStore];
-            if (route === 'device') {
-                if (key === 'device') {
-                    updateCredsFromDevice(value, creds);
-                    debounceSave();
-                    return;
-                }
-                if (key === 'account') {
-                    try {
-                        creds.account = ADVSignedDeviceIdentity.decode(value);
-                        debounceSave();
-                    }
-                    catch (e) {
-                        warn('failed to decode account update:', e);
-                    }
-                    return;
-                }
-                return writeBinary(type, key, value);
-            }
-            if (route === 'signal')
-                return writeBinary(type, key, value);
-            if (route === 'bridge-only')
-                return writeBinary(type, key, value);
-            if (route === 'converter') {
-                try {
-                    const upstreamKey = translateKey(bridgeStore, key);
-                    const typed = converters[bridgeStore]?.fromBridge(key, value) ?? Buffer.from(value);
-                    await storeSetOne(type, upstreamKey, typed);
-                }
-                catch (e) {
-                    warn(`SET ${bridgeStore}/${key} failed:`, e);
-                }
-                return;
-            }
-            warn(`SET unknown store: ${bridgeStore}/${key}`);
-        },
-        async delete(bridgeStore, key) {
-            if (bridgeStore === 'device')
-                return;
-            const route = resolve(bridgeStore);
-            const type = STORE_MAP[bridgeStore];
-            if (type) {
-                const storeKey = route === 'converter' ? translateKey(bridgeStore, key) : key;
-                await storeDelete(type, storeKey);
-            }
-        },
-        async flush() {
-            // Drain in a loop because `set('device', ...)` calls landing
-            // during `await saveCreds()` queue a fresh `credsTimer`. A
-            // single-pass flush would leave the latest creds on the timer
-            // — `dispose()` then fires saveCreds() but the orchestrator
-            // has already moved on (`free()`), so the write is racing
-            // against process exit. Looping until the timer is null after
-            // a save closes the window deterministically. Bounded by a
-            // small max-iterations guard so a saveCreds() that re-emits
-            // credentials in a tight loop can't lock us forever.
-            for (let i = 0; i < 32 && credsTimer; i++) {
-                clearTimeout(credsTimer);
-                credsTimer = null;
-                await saveCreds();
-            }
-            if (credsTimer) {
-                warn('flush hit max-iterations cap; pending credsTimer dropped — saveCreds may be re-emitting in a loop');
-                clearTimeout(credsTimer);
-                credsTimer = null;
-            }
-        },
-        dispose() {
-            if (credsTimer) {
-                clearTimeout(credsTimer);
-                saveCreds().catch(err => warn('saveCreds failed during dispose', err));
-            }
-        }
-    };
-}
-// ---- Legacy multi-file auth state loader ----
-// Reads upstream Baileys' creds.json + per-key .json files via the
-// shared `BufferJSON` codec (same as @whiskeysockets/baileys
-// useMultiFileAuthState).
-const fixFileName = (file) => file?.replace(/\//g, '__')?.replace(/:/g, '-');
-/**
- * Loads an upstream Baileys session (creds.json + key .json files) and returns
- * the standard `{ state, saveCreds }` tuple that `wrapLegacyStore` expects.
- *
- * ```typescript
- * const { state, saveCreds } = await useLegacyMultiFileAuthState('/path/to/baileys_auth_info')
- * const store = await wrapLegacyStore(state, saveCreds)
- * const sock = makeWASocket({ auth: { store } })
- * ```
- */
-export async function useLegacyMultiFileAuthState(folder) {
-    const folderInfo = await stat(folder).catch(() => null);
-    if (folderInfo && !folderInfo.isDirectory()) {
-        throw new Error(`found something that is not a directory at ${folder}`);
-    }
-    if (!folderInfo) {
-        await mkdir(folder, { recursive: true });
-    }
-    const readData = async (file) => {
-        try {
-            const data = await readFile(join(folder, fixFileName(file)), 'utf-8');
-            return JSON.parse(data, BufferJSON.reviver);
-        }
-        catch {
-            return null;
-        }
-    };
-    const writeData = async (data, file) => {
-        await writeFile(join(folder, fixFileName(file)), JSON.stringify(data, BufferJSON.replacer));
-    };
-    const removeData = async (file) => {
-        try {
-            await unlink(join(folder, fixFileName(file)));
-        }
-        catch { }
-    };
-    const creds = await readData('creds.json');
-    if (!creds) {
-        throw new Error(`No creds.json found in ${folder}. This loader requires an existing upstream Baileys session.`);
-    }
-    return {
-        state: {
-            creds,
-            keys: {
-                get: async (type, ids) => {
-                    const data = {};
-                    await Promise.all(ids.map(async (id) => {
-                        let value = await readData(`${type}-${id}.json`);
-                        if (type === 'app-state-sync-key' && value) {
-                            value = proto.Message.AppStateSyncKeyData.fromObject(value);
-                        }
-                        data[id] = value;
-                    }));
-                    return data;
-                },
-                set: async (data) => {
-                    const tasks = [];
-                    for (const category in data) {
-                        for (const id in data[category]) {
-                            const value = data[category][id];
-                            const file = `${category}-${id}.json`;
-                            tasks.push(value ? writeData(value, file) : removeData(file));
-                        }
-                    }
-                    await Promise.all(tasks);
-                }
-            }
-        },
-        saveCreds: () => writeData(creds, 'creds.json')
-    };
-}
+export { wrapLegacyStore } from '../Compatibility/legacy-store/adapter.js';
+export { useLegacyMultiFileAuthState } from '../Compatibility/legacy-store/multi-file.js';
 //# sourceMappingURL=wrap-legacy-store.js.map