@zapo-js/fake-server 0.3.0 → 1.0.0

package/README.md

@@ -1,6 +1,6 @@
 # @zapo-js/fake-server
 
-In-process fake WhatsApp Web server that drives the real `zapo-js` `WaClient` end-to-end — full Noise XX/IK handshake, QR pairing, Signal Protocol (X3DH + Double Ratchet), SenderKey for groups, media upload/download over self-signed HTTPS, app-state sync — all without touching WhatsApp servers.
+In-process fake WhatsApp Web server that drives the real `zapo-js` `WaClient` end-to-end - full Noise XX/IK handshake, QR pairing, Signal Protocol (X3DH + Double Ratchet), SenderKey for groups, media upload/download over self-signed HTTPS, app-state sync - all without touching WhatsApp servers.
 
 ## Quick start
 
@@ -29,8 +29,8 @@ await server.stop()
 ```text
 src/
 ├── api/                     # Public-facing API
-│   ├── FakeWaServer.ts      # Main facade — WS server, IQ router, registries, lifecycle
-│   ├── FakePeer.ts          # Simulated WhatsApp peer — Signal crypto, send/recv, groups
+│   ├── FakeWaServer.ts      # Main facade – WS server, IQ router, registries, lifecycle
+│   ├── FakePeer.ts          # Simulated WhatsApp peer – Signal crypto, send/recv, groups
 │   ├── FakePairingDriver.ts # QR pairing flow orchestrator
 │   └── Scenario.ts          # Declarative test scenario DSL
 ├── protocol/                # Protocol-layer builders, parsers, crypto

package/dist/api/AppStateSyncManager.d.ts

@@ -24,4 +24,3 @@ export declare class AppStateSyncManager {
     pushServerSyncNotification(pipeline: WaFakeConnectionPipeline, input: BuildServerSyncNotificationInput): Promise<void>;
     consumeOutboundAppStatePatches(iq: BinaryNode): Promise<void>;
 }
-//# sourceMappingURL=AppStateSyncManager.d.ts.map

package/dist/api/AppStateSyncManager.js

@@ -148,4 +148,3 @@ class AppStateSyncManager {
     }
 }
 exports.AppStateSyncManager = AppStateSyncManager;
-//# sourceMappingURL=AppStateSyncManager.js.map

package/dist/api/FakePairingDriver.d.ts

@@ -24,4 +24,3 @@ export declare class FakePairingDriver {
     constructor(options: FakePairingDriverOptions, deps: FakePairingDriverDeps);
     run(): Promise<void>;
 }
-//# sourceMappingURL=FakePairingDriver.d.ts.map

package/dist/api/FakePairingDriver.js

@@ -33,4 +33,3 @@ class FakePairingDriver {
     }
 }
 exports.FakePairingDriver = FakePairingDriver;
-//# sourceMappingURL=FakePairingDriver.js.map

package/dist/api/FakePeer.d.ts

@@ -12,6 +12,13 @@ export interface CreateFakePeerOptions {
     readonly displayName?: string;
     readonly keyBundle?: FakePeerKeyBundle;
     readonly skipOneTimePreKey?: boolean;
+    /**
+     * Stash every outbound (id → plaintext + pristine ciphertext) so
+     * tests / benches can drive replays via {@link FakePeer.replaySentMessage}.
+     * Off by default to avoid inflating the fixture's heap on long
+     * memory-focused runs that never replay.
+     */
+    readonly enableReplayCache?: boolean;
 }
 export interface SendMessageOptions {
     readonly id?: string;
@@ -45,20 +52,57 @@ interface FakePeerDeps {
 export declare class FakePeer {
     readonly jid: string;
     readonly displayName?: string;
-    readonly keyBundle: FakePeerKeyBundle;
+    keyBundle: FakePeerKeyBundle;
     readonly identity: FakePeerIdentity;
     private readonly deps;
-    private readonly ratchet;
+    private ratchet;
     private readonly skipOneTimePreKey;
-    private readonly reservedOneTimePreKey;
+    private reservedOneTimePreKey;
     private ratchetInitiated;
     private nextMessageCounter;
+    private readonly replayCacheEnabled;
+    private readonly sentPlaintextById;
+    private readonly sentEncryptedById;
     private readonly senderKeysByGroup;
     private readonly groupsBootstrapped;
     private readonly groupRecvSession;
     private constructor();
     static create(options: CreateFakePeerOptions, deps: FakePeerDeps): Promise<FakePeer>;
     sendMessage(message: proto.IMessage, options?: SendMessageOptions): Promise<void>;
+    /**
+     * Re-encrypts and re-pushes a previously sent message identified by
+     * `originalMsgId`. Used by tests / benches that exercise the lib's
+     * incoming-retry path: after the lib emits `<receipt type="retry">`
+     * back to this peer, the peer is expected to re-send the same
+     * plaintext so the lib can decrypt it successfully on the second
+     * attempt.
+     *
+     * The replay reuses the original stanza id by default so the lib's
+     * dedup logic (and tests that wait for a specific id) see the resend
+     * as a continuation of the same outbound. Pass `resendId` to use a
+     * different id.
+     */
+    replaySentMessage(originalMsgId: string, options?: {
+        readonly resendId?: string;
+    }): Promise<void>;
+    /**
+     * Rotates the peer's prekey material and resets the Signal session
+     * state so the lib has to re-run X3DH on the next outbound. Keeps
+     * the identity key pair (same user) but issues a new signed prekey
+     * + new one-time prekey set. After this call:
+     *   - `keyBundle` reflects the new material;
+     *   - the underlying `FakePeerDoubleRatchet` is fresh – the next
+     *     inbound from the lib must be a `pkmsg` (initial signal
+     *     message), which the new `keyBundle` is wired to decrypt;
+     *   - any cached one-time prekey reservation in the dispenser is
+     *     dropped so subsequent retry-receipts include this peer's new
+     *     keys directly via {@link sendRetryReceipt}.
+     *
+     * Use this to simulate the "session lost" scenario that real
+     * WhatsApp clients trigger when they need the sender to fully
+     * re-bootstrap the Signal session via the retry-receipt path.
+     */
+    rotateForRetry(): Promise<void>;
     sendConversation(text: string, options?: SendMessageOptions): Promise<void>;
     sendMessageEdit(input: {
         readonly targetMessageId: string;
@@ -131,6 +175,36 @@ export declare class FakePeer {
     sendAppStateSyncKeyShare(input: BuildAppStateSyncKeyShareInput, options?: SendMessageOptions): Promise<void>;
     sendGroupConversation(groupJid: string, text: string, options?: SendMessageOptions): Promise<void>;
     sendGroupMessage(groupJid: string, message: proto.IMessage, options?: SendMessageOptions): Promise<void>;
+    /**
+     * Sends a `<receipt type="retry">` stanza to the lib asking it to
+     * re-encrypt and re-send the message identified by `originalMsgId`.
+     * Used by benches / tests that exercise the lib's outbound retry
+     * replay path.
+     *
+     * Shape matches WhatsApp Web's `WAWebRetryRequestParser`:
+     * `<receipt id type=retry from t><retry id count?/><registration>4B</registration>[<keys>...</keys>]</receipt>`.
+     *
+     * When `includeKeys` is true (default), the `<keys>` block carries
+     * the peer's current identity + signed prekey + one-time prekey.
+     * This forces the lib's `WaRetryCoordinator` to tear down the
+     * existing session and re-run X3DH against these fresh keys before
+     * re-encrypting the original payload, so the resend lands as a
+     * `pkmsg` against the peer's *new* prekey state. Pair this with
+     * {@link rotateForRetry} to simulate full session loss + recovery.
+     *
+     * `<device-identity>` is omitted: it's `maybeChild` in wa-web and
+     * also optional in the lib's parser. The fake-peer fixture doesn't
+     * have an ADV primary-device to sign one, and the lib's outbound
+     * retry replay path does not require it.
+     */
+    sendRetryReceipt(originalMsgId: string, options?: {
+        readonly count?: number;
+        readonly receiptId?: string;
+        readonly t?: number;
+        readonly error?: number;
+        readonly includeKeys?: boolean;
+    }): Promise<void>;
+    private buildRetryKeysNode;
     expectMessage(options?: ExpectMessageOptions): Promise<ReceivedMessage>;
     expectGroupMessage(groupJid: string, options?: ExpectGroupMessageOptions): Promise<ReceivedMessage>;
     private decryptPairwise;
@@ -140,4 +214,3 @@ export declare class FakePeer {
     private nextId;
 }
 export {};
-//# sourceMappingURL=FakePeer.d.ts.map

package/dist/api/FakePeer.js

@@ -14,6 +14,8 @@ class FakePeer {
     constructor(keyBundle, options, deps) {
         this.ratchetInitiated = false;
         this.nextMessageCounter = 0;
+        this.sentPlaintextById = new Map();
+        this.sentEncryptedById = new Map();
         this.senderKeysByGroup = new Map();
         this.groupsBootstrapped = new Set();
         this.groupRecvSession = new fake_peer_group_recv_session_1.FakePeerGroupRecvSession();
@@ -26,6 +28,7 @@ class FakePeer {
         this.displayName = options.displayName;
         this.deps = deps;
         this.skipOneTimePreKey = options.skipOneTimePreKey === true;
+        this.replayCacheEnabled = options.enableReplayCache === true;
         this.reservedOneTimePreKey =
             !this.skipOneTimePreKey && deps.reserveOneTimePreKey
                 ? deps.reserveOneTimePreKey()
@@ -45,6 +48,18 @@ class FakePeer {
             : ciphertext;
         const enc = { type, ciphertext: finalCiphertext };
         const id = options.id ?? this.nextId();
+        if (this.replayCacheEnabled) {
+            // Stash the plaintext so the bench / a test can replay this
+            // exact payload later in response to an incoming retry
+            // receipt from the lib (replaySentMessage). Also stash the
+            // PRISTINE ciphertext (pre-tamper) + signal type so a
+            // replay can put the original frame back on the wire –
+            // matches how a real Signal sender re-sends after a
+            // recipient asks for retry: same counter + ratchet key,
+            // just an uncorrupted body.
+            this.sentPlaintextById.set(id, message);
+            this.sentEncryptedById.set(id, { type, ciphertext });
+        }
         const stanza = (0, message_1.buildMessage)({
             id,
             from: options.from ?? this.jid,
@@ -56,6 +71,76 @@ class FakePeer {
         });
         await this.deps.pushStanza(stanza);
     }
+    /**
+     * Re-encrypts and re-pushes a previously sent message identified by
+     * `originalMsgId`. Used by tests / benches that exercise the lib's
+     * incoming-retry path: after the lib emits `<receipt type="retry">`
+     * back to this peer, the peer is expected to re-send the same
+     * plaintext so the lib can decrypt it successfully on the second
+     * attempt.
+     *
+     * The replay reuses the original stanza id by default so the lib's
+     * dedup logic (and tests that wait for a specific id) see the resend
+     * as a continuation of the same outbound. Pass `resendId` to use a
+     * different id.
+     */
+    async replaySentMessage(originalMsgId, options = {}) {
+        const stored = this.sentEncryptedById.get(originalMsgId);
+        if (stored) {
+            // Re-send the pristine ciphertext – same Signal counter +
+            // ratchet key as the original send, just without the
+            // tamper. The lib's recv chain still has the message key
+            // for that counter, so this is the recovery path real
+            // WhatsApp peers walk after observing a retry receipt for
+            // a frame the recipient failed to decrypt.
+            const enc = { type: stored.type, ciphertext: stored.ciphertext };
+            const id = options.resendId ?? originalMsgId;
+            const stanza = (0, message_1.buildMessage)({
+                id,
+                from: this.jid,
+                type: 'text',
+                notify: this.displayName,
+                enc: [enc]
+            });
+            await this.deps.pushStanza(stanza);
+            return;
+        }
+        const message = this.sentPlaintextById.get(originalMsgId);
+        if (!message) {
+            throw new Error(`FakePeer.replaySentMessage: no sent plaintext for id ${originalMsgId}`);
+        }
+        await this.sendMessage(message, { id: options.resendId ?? originalMsgId });
+    }
+    /**
+     * Rotates the peer's prekey material and resets the Signal session
+     * state so the lib has to re-run X3DH on the next outbound. Keeps
+     * the identity key pair (same user) but issues a new signed prekey
+     * + new one-time prekey set. After this call:
+     *   - `keyBundle` reflects the new material;
+     *   - the underlying `FakePeerDoubleRatchet` is fresh – the next
+     *     inbound from the lib must be a `pkmsg` (initial signal
+     *     message), which the new `keyBundle` is wired to decrypt;
+     *   - any cached one-time prekey reservation in the dispenser is
+     *     dropped so subsequent retry-receipts include this peer's new
+     *     keys directly via {@link sendRetryReceipt}.
+     *
+     * Use this to simulate the "session lost" scenario that real
+     * WhatsApp clients trigger when they need the sender to fully
+     * re-bootstrap the Signal session via the retry-receipt path.
+     */
+    async rotateForRetry() {
+        const refreshed = await (0, fake_peer_key_bundle_1.generateFakePeerKeyBundle)({
+            identityKeyPair: this.keyBundle.identityKeyPair,
+            registrationId: this.keyBundle.registrationId,
+            signedPreKeyId: this.keyBundle.signedPreKey.id + 1,
+            firstOneTimePreKeyId: (this.keyBundle.oneTimePreKeys[this.keyBundle.oneTimePreKeys.length - 1]?.id ?? 0) +
+                1
+        });
+        this.keyBundle = refreshed;
+        this.ratchet = new fake_peer_double_ratchet_1.FakePeerDoubleRatchet(refreshed);
+        this.ratchetInitiated = false;
+        this.reservedOneTimePreKey = null;
+    }
     sendConversation(text, options = {}) {
         return this.sendMessage({ conversation: text }, options);
     }
@@ -234,6 +319,112 @@ class FakePeer {
         });
         await this.deps.pushStanza(groupStanza);
     }
+    /**
+     * Sends a `<receipt type="retry">` stanza to the lib asking it to
+     * re-encrypt and re-send the message identified by `originalMsgId`.
+     * Used by benches / tests that exercise the lib's outbound retry
+     * replay path.
+     *
+     * Shape matches WhatsApp Web's `WAWebRetryRequestParser`:
+     * `<receipt id type=retry from t><retry id count?/><registration>4B</registration>[<keys>...</keys>]</receipt>`.
+     *
+     * When `includeKeys` is true (default), the `<keys>` block carries
+     * the peer's current identity + signed prekey + one-time prekey.
+     * This forces the lib's `WaRetryCoordinator` to tear down the
+     * existing session and re-run X3DH against these fresh keys before
+     * re-encrypting the original payload, so the resend lands as a
+     * `pkmsg` against the peer's *new* prekey state. Pair this with
+     * {@link rotateForRetry} to simulate full session loss + recovery.
+     *
+     * `<device-identity>` is omitted: it's `maybeChild` in wa-web and
+     * also optional in the lib's parser. The fake-peer fixture doesn't
+     * have an ADV primary-device to sign one, and the lib's outbound
+     * retry replay path does not require it.
+     */
+    async sendRetryReceipt(originalMsgId, options = {}) {
+        const receiptId = options.receiptId ?? originalMsgId;
+        const retryCount = options.count ?? 1;
+        const t = options.t ?? Math.floor(Date.now() / 1000);
+        const error = options.error;
+        const includeKeys = options.includeKeys !== false;
+        const registration = new Uint8Array(4);
+        const regId = this.keyBundle.registrationId & 0xffffffff;
+        registration[0] = (regId >>> 24) & 0xff;
+        registration[1] = (regId >>> 16) & 0xff;
+        registration[2] = (regId >>> 8) & 0xff;
+        registration[3] = regId & 0xff;
+        const retryAttrs = {
+            v: '1',
+            count: String(retryCount),
+            id: originalMsgId,
+            t: String(t)
+        };
+        if (error !== undefined && error !== 0) {
+            retryAttrs.error = String(error);
+        }
+        const content = [
+            {
+                tag: 'retry',
+                attrs: retryAttrs
+            },
+            {
+                tag: 'registration',
+                attrs: {},
+                content: registration
+            }
+        ];
+        if (includeKeys) {
+            content.push(this.buildRetryKeysNode());
+        }
+        const receipt = {
+            tag: 'receipt',
+            attrs: {
+                id: receiptId,
+                from: this.jid,
+                type: 'retry',
+                t: String(t)
+            },
+            content
+        };
+        await this.deps.pushStanza(receipt);
+    }
+    buildRetryKeysNode() {
+        const skey = this.keyBundle.signedPreKey;
+        const oneTime = this.keyBundle.oneTimePreKeys[0];
+        if (!oneTime) {
+            throw new Error('FakePeer.sendRetryReceipt: no one-time prekey available');
+        }
+        const skeyIdBytes = encodeUint3(skey.id);
+        const keyIdBytes = encodeUint3(oneTime.id);
+        return {
+            tag: 'keys',
+            attrs: {},
+            content: [
+                {
+                    tag: 'identity',
+                    attrs: {},
+                    content: this.keyBundle.identityKeyPair.pubKey
+                },
+                {
+                    tag: 'skey',
+                    attrs: {},
+                    content: [
+                        { tag: 'id', attrs: {}, content: skeyIdBytes },
+                        { tag: 'value', attrs: {}, content: skey.keyPair.pubKey },
+                        { tag: 'signature', attrs: {}, content: skey.signature }
+                    ]
+                },
+                {
+                    tag: 'key',
+                    attrs: {},
+                    content: [
+                        { tag: 'id', attrs: {}, content: keyIdBytes },
+                        { tag: 'value', attrs: {}, content: oneTime.keyPair.pubKey }
+                    ]
+                }
+            ]
+        };
+    }
     expectMessage(options = {}) {
         const timeoutMs = options.timeoutMs ?? 5000;
         return new Promise((resolve, reject) => {
@@ -395,6 +586,16 @@ function findTopLevelEnc(stanza, type) {
     }
     return null;
 }
+function encodeUint3(value) {
+    if (!Number.isInteger(value) || value < 0 || value > 0xffffff) {
+        throw new Error(`encodeUint3: value out of range: ${value}`);
+    }
+    const out = new Uint8Array(3);
+    out[0] = (value >>> 16) & 0xff;
+    out[1] = (value >>> 8) & 0xff;
+    out[2] = value & 0xff;
+    return out;
+}
 function encodePlaintextWithPadding(message) {
     const encoded = protos_1.proto.Message.encode(message).finish();
     const padLen = 16 - (encoded.byteLength % 16);
@@ -405,4 +606,3 @@ function encodePlaintextWithPadding(message) {
     }
     return out;
 }
-//# sourceMappingURL=FakePeer.js.map

package/dist/api/FakeWaServer.d.ts

@@ -62,6 +62,7 @@ export declare class FakeWaServer {
     private readonly pendingStanzaExpectations;
     private readonly authenticatedListeners;
     private readonly inboundStanzaListeners;
+    private readonly capturedStanzaListeners;
     private rootCa;
     private serverStaticKeyPair;
     private listenInfo;
@@ -122,6 +123,16 @@ export declare class FakeWaServer {
     scenario(configure: (s: Scenario) => void): void;
     expectIq(matcher: WaFakeIqMatcher, options?: ExpectIqOptions): Promise<BinaryNode>;
     capturedStanzaSnapshot(): readonly BinaryNode[];
+    /**
+     * Subscribes to every stanza captured from the client side (the lib).
+     * The listener is called synchronously for each new stanza as it
+     * arrives, in addition to `capturedStanzas` being appended. Returns
+     * an unsubscribe function. Useful for benches that need to count or
+     * react to a stream of receipts/messages without paying the O(N²)
+     * cost of polling `capturedStanzaSnapshot()` or queuing one
+     * `expectStanza(...)` per iteration.
+     */
+    onCapturedStanza(listener: (node: BinaryNode) => void): () => void;
     expectStanza(matcher: StanzaMatcher, options?: ExpectStanzaOptions): Promise<BinaryNode>;
     broadcastStanza(node: BinaryNode): Promise<number>;
     waitForAuthenticatedPipeline(timeoutMs?: number): Promise<WaFakeConnectionPipeline>;
@@ -164,4 +175,3 @@ export declare class FakeWaServer {
 }
 export type { WaFakeAuthenticatedInfo, WaFakeConnectionPipeline };
 export type { BinaryNode };
-//# sourceMappingURL=FakeWaServer.d.ts.map

package/dist/api/FakeWaServer.js

@@ -28,6 +28,7 @@ class FakeWaServer {
         this.pendingStanzaExpectations = new Set();
         this.authenticatedListeners = new Set();
         this.inboundStanzaListeners = new Set();
+        this.capturedStanzaListeners = new Set();
         this.rootCa = null;
         this.serverStaticKeyPair = null;
         this.listenInfo = null;
@@ -247,6 +248,21 @@ class FakeWaServer {
     capturedStanzaSnapshot() {
         return this.capturedStanzas.slice();
     }
+    /**
+     * Subscribes to every stanza captured from the client side (the lib).
+     * The listener is called synchronously for each new stanza as it
+     * arrives, in addition to `capturedStanzas` being appended. Returns
+     * an unsubscribe function. Useful for benches that need to count or
+     * react to a stream of receipts/messages without paying the O(N²)
+     * cost of polling `capturedStanzaSnapshot()` or queuing one
+     * `expectStanza(...)` per iteration.
+     */
+    onCapturedStanza(listener) {
+        this.capturedStanzaListeners.add(listener);
+        return () => {
+            this.capturedStanzaListeners.delete(listener);
+        };
+    }
     expectStanza(matcher, options = {}) {
         const timeoutMs = options.timeoutMs ?? 2000;
         for (const captured of this.capturedStanzas) {
@@ -318,7 +334,16 @@ class FakeWaServer {
     }
     get mediaProxyAgent() {
         if (!this.cachedMediaProxyAgent) {
-            this.cachedMediaProxyAgent = new node_https_1.Agent({ rejectUnauthorized: false });
+            // keepAlive is required for representative perf measurements
+            // and matches what real-world WhatsApp clients do – every
+            // media upload/download would otherwise pay a full TLS
+            // handshake. The `src/media/__tests__/media.test.ts` fixtures
+            // and a production-quality `proxy.mediaUpload` configuration
+            // all set this; mirroring it here keeps benches in line.
+            this.cachedMediaProxyAgent = new node_https_1.Agent({
+                rejectUnauthorized: false,
+                keepAlive: true
+            });
         }
         return this.cachedMediaProxyAgent;
     }
@@ -472,6 +497,14 @@ class FakeWaServer {
     }
     handleCapturedStanza(node) {
         this.capturedStanzas.push(node);
+        for (const listener of this.capturedStanzaListeners) {
+            try {
+                listener(node);
+            }
+            catch (error) {
+                void error;
+            }
+        }
         for (const listener of this.inboundStanzaListeners) {
             try {
                 listener(node);
@@ -649,4 +682,3 @@ function describeStanzaMatcher(matcher) {
         parts.push(`childTag=${matcher.childTag}`);
     return parts.length > 0 ? parts.join(', ') : 'any stanza';
 }
-//# sourceMappingURL=FakeWaServer.js.map

package/dist/api/PreKeyDispenser.d.ts

@@ -20,4 +20,3 @@ export declare class PreKeyDispenser {
         readonly force?: boolean;
     } | number): Promise<ClientPreKeyBundle>;
 }
-//# sourceMappingURL=PreKeyDispenser.d.ts.map

package/dist/api/PreKeyDispenser.js

@@ -95,4 +95,3 @@ class PreKeyDispenser {
     }
 }
 exports.PreKeyDispenser = PreKeyDispenser;
-//# sourceMappingURL=PreKeyDispenser.js.map

package/dist/api/Scenario.d.ts

@@ -21,4 +21,3 @@ export declare class IqExpectation {
     respond(responder: WaFakeIqResponder): this;
     respondOnce(response: BinaryNode | WaFakeIqResponder): this;
 }
-//# sourceMappingURL=Scenario.d.ts.map

package/dist/api/Scenario.js

@@ -35,4 +35,3 @@ class IqExpectation {
     }
 }
 exports.IqExpectation = IqExpectation;
-//# sourceMappingURL=Scenario.js.map

package/dist/api/ServerRegistries.d.ts

@@ -107,4 +107,3 @@ export declare class ServerRegistries {
     notifyDirtyBitsClear(op: CapturedDirtyBitsClear): void;
     handleProfilePictureSet(targetJid: string, newId: string): void;
 }
-//# sourceMappingURL=ServerRegistries.d.ts.map

package/dist/api/ServerRegistries.js

@@ -265,4 +265,3 @@ class ServerRegistries {
     }
 }
 exports.ServerRegistries = ServerRegistries;
-//# sourceMappingURL=ServerRegistries.js.map

package/dist/api/iq-handlers.d.ts

@@ -44,4 +44,3 @@ export interface IqHandlerDeps {
 export declare function parseUsyncRequestedUserJids(iq: BinaryNode): readonly string[];
 export declare function parseRequestedKeyJids(iq: BinaryNode): readonly string[];
 export declare function registerDefaultIqHandlers(router: WaFakeIqRouter, deps: IqHandlerDeps): void;
-//# sourceMappingURL=iq-handlers.d.ts.map

package/dist/api/iq-handlers.js

@@ -495,4 +495,3 @@ function registerDefaultIqHandlers(router, deps) {
         respond: (iq) => (0, router_1.buildIqResult)(iq)
     });
 }
-//# sourceMappingURL=iq-handlers.js.map

package/dist/{cli.d.ts → bin.d.ts}

@@ -1,4 +1,3 @@
 #!/usr/bin/env node
 /** Standalone CLI for `@zapo-js/fake-server`. */
 export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/{cli.js → bin.js}

@@ -62,7 +62,7 @@ function parseArgs(argv) {
     return { host, port, path, peerJids, groupSpecs, log, quiet, json, help };
 }
 function printHelp() {
-    process.stdout.write(`@zapo-js/fake-server — standalone fake WhatsApp Web server
+    process.stdout.write(`@zapo-js/fake-server – standalone fake WhatsApp Web server
 
 USAGE
   npx @zapo-js/fake-server [flags]
@@ -246,4 +246,3 @@ main().catch((error) => {
     process.stderr.write(`fatal: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`);
     process.exit(1);
 });
-//# sourceMappingURL=cli.js.map