@zapo-js/fake-server 0.3.0 → 1.0.0

package/dist/esm/protocol/signal/fake-peer-group-recv-session.js

@@ -0,0 +1,120 @@
+/** Receiver-side SenderKey session for group `skmsg` decrypt. */
+import { aesCbcDecrypt, hkdf, hmacSha256Sign, toRawPubKey, toSerializedPubKey, xeddsaVerify } from '../../transport/crypto.js';
+import { proto } from '../../transport/protos.js';
+import { TEXT_ENCODER } from '../../transport/util.js';
+const SIGNAL_GROUP_VERSION = 3;
+const SIGNAL_SIGNATURE_LENGTH = 64;
+const MESSAGE_KEY_LABEL = new Uint8Array([1]);
+const CHAIN_KEY_LABEL = new Uint8Array([2]);
+const WHISPER_GROUP_INFO = TEXT_ENCODER.encode('WhisperGroup');
+export class FakePeerGroupRecvSessionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'FakePeerGroupRecvSessionError';
+    }
+}
+export class FakePeerGroupRecvSession {
+    constructor() {
+        this.records = new Map();
+    }
+    addDistribution(groupId, senderJid, axolotlBytes) {
+        if (axolotlBytes.byteLength < 1) {
+            throw new FakePeerGroupRecvSessionError('SKDM payload empty');
+        }
+        const version = axolotlBytes[0] >>> 4;
+        if (version !== SIGNAL_GROUP_VERSION) {
+            throw new FakePeerGroupRecvSessionError(`unsupported SKDM version ${version}`);
+        }
+        const body = axolotlBytes.subarray(1);
+        const decoded = proto.SenderKeyDistributionMessage.decode(body);
+        if (decoded.id === null ||
+            decoded.id === undefined ||
+            decoded.iteration === null ||
+            decoded.iteration === undefined ||
+            !decoded.chainKey ||
+            !decoded.signingKey) {
+            throw new FakePeerGroupRecvSessionError('invalid SKDM');
+        }
+        if (decoded.chainKey.byteLength !== 32) {
+            throw new FakePeerGroupRecvSessionError(`SKDM chainKey must be 32 bytes, got ${decoded.chainKey.byteLength}`);
+        }
+        this.records.set(recordKey(groupId, senderJid), {
+            keyId: decoded.id,
+            nextIteration: decoded.iteration,
+            chainKey: decoded.chainKey,
+            signingPublicKey: toSerializedPubKey(decoded.signingKey)
+        });
+    }
+    async decryptGroupMessage(groupId, senderJid, skmsgBytes) {
+        const record = this.records.get(recordKey(groupId, senderJid));
+        if (!record) {
+            throw new FakePeerGroupRecvSessionError(`no senderkey state for group=${groupId} sender=${senderJid}`);
+        }
+        if (skmsgBytes.byteLength < 1 + SIGNAL_SIGNATURE_LENGTH) {
+            throw new FakePeerGroupRecvSessionError('skmsg too short');
+        }
+        const versionByte = skmsgBytes[0];
+        if (versionByte >>> 4 !== SIGNAL_GROUP_VERSION) {
+            throw new FakePeerGroupRecvSessionError(`unsupported skmsg version ${versionByte >>> 4}`);
+        }
+        const sigStart = skmsgBytes.byteLength - SIGNAL_SIGNATURE_LENGTH;
+        // xeddsaVerify mutates the signature buffer; isolate with copies.
+        const versionedContent = skmsgBytes.subarray(0, sigStart).slice();
+        const signature = skmsgBytes.subarray(sigStart).slice();
+        const protoBody = versionedContent.subarray(1);
+        const decoded = proto.SenderKeyMessage.decode(protoBody);
+        if (decoded.id === null ||
+            decoded.id === undefined ||
+            decoded.iteration === null ||
+            decoded.iteration === undefined ||
+            !decoded.ciphertext) {
+            throw new FakePeerGroupRecvSessionError('invalid SenderKeyMessage');
+        }
+        if (decoded.id !== record.keyId) {
+            throw new FakePeerGroupRecvSessionError(`senderKey id mismatch: got ${decoded.id}, expected ${record.keyId}`);
+        }
+        const validSignature = await xeddsaVerify(toRawPubKey(record.signingPublicKey), versionedContent, signature);
+        if (!validSignature) {
+            throw new FakePeerGroupRecvSessionError('invalid sender key signature');
+        }
+        const targetIteration = decoded.iteration;
+        if (targetIteration < record.nextIteration) {
+            throw new FakePeerGroupRecvSessionError(`out-of-order skmsg iteration ${targetIteration} < ${record.nextIteration}`);
+        }
+        let chainKey = record.chainKey;
+        let seed = null;
+        let iteration = record.nextIteration;
+        while (iteration <= targetIteration) {
+            const nextChainRaw = hmacSha256Sign(chainKey, CHAIN_KEY_LABEL);
+            const messageInputKey = hmacSha256Sign(chainKey, MESSAGE_KEY_LABEL);
+            const messageSeed = hkdf(messageInputKey, null, WHISPER_GROUP_INFO, 50);
+            if (iteration === targetIteration) {
+                seed = messageSeed;
+            }
+            chainKey = nextChainRaw.subarray(0, 32);
+            iteration += 1;
+        }
+        if (!seed) {
+            throw new FakePeerGroupRecvSessionError('failed to derive message seed');
+        }
+        record.chainKey = chainKey;
+        record.nextIteration = iteration;
+        const iv = seed.subarray(0, 16);
+        const keyBytes = seed.subarray(16, 48);
+        const padded = aesCbcDecrypt(keyBytes, iv, decoded.ciphertext);
+        return unpadPkcs7(padded);
+    }
+}
+function recordKey(groupId, senderJid) {
+    return `${groupId}\u0000${senderJid}`;
+}
+function unpadPkcs7(padded) {
+    if (padded.byteLength === 0)
+        return padded;
+    const padLen = padded[padded.byteLength - 1];
+    if (padLen === 0 || padLen > 16)
+        return padded;
+    if (padLen > padded.byteLength)
+        return padded;
+    return padded.subarray(0, padded.byteLength - padLen);
+}

package/dist/esm/protocol/signal/fake-peer-identity.js

@@ -0,0 +1,8 @@
+import { X25519 } from '../../transport/crypto.js';
+export async function generateFakePeerIdentity() {
+    const identityKeyPair = await X25519.generateKeyPair();
+    return {
+        identityKeyPair,
+        registrationId: Math.floor(Math.random() * 0x3fff) + 1
+    };
+}

package/dist/esm/protocol/signal/fake-peer-key-bundle.js

@@ -0,0 +1,25 @@
+/** Generates Signal prekey bundles for fake peers. */
+import { toSerializedPubKey, X25519, xeddsaSign } from '../../transport/crypto.js';
+export async function generateFakePeerKeyBundle(options = {}) {
+    const identityKeyPair = options.identityKeyPair ?? (await X25519.generateKeyPair());
+    const signedPreKeyKeyPair = await X25519.generateKeyPair();
+    const signedPreKeyId = options.signedPreKeyId ?? 1;
+    const signedPreKeySerialized = toSerializedPubKey(signedPreKeyKeyPair.pubKey);
+    const signedPreKeySignature = await xeddsaSign(identityKeyPair.privKey, signedPreKeySerialized);
+    const oneTimeCount = options.oneTimePreKeyCount ?? 4;
+    const firstId = options.firstOneTimePreKeyId ?? 1;
+    const oneTimePreKeys = await Promise.all(Array.from({ length: oneTimeCount }, async (_, idx) => ({
+        id: firstId + idx,
+        keyPair: await X25519.generateKeyPair()
+    })));
+    return {
+        registrationId: options.registrationId ?? Math.floor(Math.random() * 0x3fff) + 1,
+        identityKeyPair,
+        signedPreKey: {
+            id: signedPreKeyId,
+            keyPair: signedPreKeyKeyPair,
+            signature: signedPreKeySignature
+        },
+        oneTimePreKeys
+    };
+}

package/dist/esm/protocol/signal/fake-sender-key.js

@@ -0,0 +1,83 @@
+/** SenderKey state used by fake peers for group encryption. */
+import { aesCbcEncrypt, hkdf, hmacSha256Sign, prependVersion, randomBytesAsync, toSerializedPubKey, X25519, xeddsaSign } from '../../transport/crypto.js';
+import { proto } from '../../transport/protos.js';
+const SIGNAL_GROUP_VERSION = 3;
+const WHISPER_GROUP_INFO = new TextEncoder().encode('WhisperGroup');
+const MESSAGE_KEY_LABEL = new Uint8Array([1]);
+const CHAIN_KEY_LABEL = new Uint8Array([2]);
+export class FakeSenderKey {
+    constructor(state) {
+        this.state = state;
+    }
+    static async generate() {
+        const [chainKey, signingKeyPair, idBytes] = await Promise.all([
+            randomBytesAsync(32),
+            X25519.generateKeyPair(),
+            randomBytesAsync(4)
+        ]);
+        const id = ((idBytes[0] << 24) | (idBytes[1] << 16) | (idBytes[2] << 8) | idBytes[3]) >>> 0;
+        return new FakeSenderKey({
+            id,
+            chainKey,
+            iteration: 0,
+            signingKeyPair
+        });
+    }
+    get id() {
+        return this.state.id;
+    }
+    async encrypt(plaintext) {
+        const distributionMessage = this.buildDistributionMessage();
+        const { messageKey, nextChainKey } = await deriveSenderKeyMessageKey(this.state.iteration, this.state.chainKey);
+        const { iv, cipherKey } = splitSenderKeyMessageSeed(messageKey.seed);
+        const ciphertext = aesCbcEncrypt(cipherKey, iv, plaintext);
+        const senderKeyMessage = proto.SenderKeyMessage.encode({
+            id: this.state.id,
+            iteration: messageKey.iteration,
+            ciphertext
+        }).finish();
+        const versioned = prependVersion(senderKeyMessage, SIGNAL_GROUP_VERSION);
+        const signature = await xeddsaSign(this.state.signingKeyPair.privKey, versioned);
+        const finalCiphertext = new Uint8Array(versioned.byteLength + signature.byteLength);
+        finalCiphertext.set(versioned, 0);
+        finalCiphertext.set(signature, versioned.byteLength);
+        this.state = {
+            ...this.state,
+            chainKey: nextChainKey,
+            iteration: messageKey.iteration + 1
+        };
+        return {
+            ciphertext: finalCiphertext,
+            distributionMessage,
+            keyId: this.state.id
+        };
+    }
+    buildDistributionMessage() {
+        const proto1 = proto.SenderKeyDistributionMessage.encode({
+            id: this.state.id,
+            iteration: this.state.iteration,
+            chainKey: this.state.chainKey,
+            signingKey: toSerializedPubKey(this.state.signingKeyPair.pubKey)
+        }).finish();
+        return prependVersion(proto1, SIGNAL_GROUP_VERSION);
+    }
+}
+// eslint-disable-next-line @typescript-eslint/require-await
+async function deriveSenderKeyMessageKey(iteration, chainKey) {
+    const messageInputKey = hmacSha256Sign(chainKey, MESSAGE_KEY_LABEL);
+    const nextChainRaw = hmacSha256Sign(chainKey, CHAIN_KEY_LABEL);
+    const seed = hkdf(messageInputKey, null, WHISPER_GROUP_INFO, 50);
+    return {
+        messageKey: { iteration, seed },
+        nextChainKey: nextChainRaw.subarray(0, 32)
+    };
+}
+function splitSenderKeyMessageSeed(seed) {
+    if (seed.byteLength < 48) {
+        throw new Error(`sender key message seed too short: ${seed.byteLength}`);
+    }
+    return {
+        iv: seed.subarray(0, 16),
+        cipherKey: seed.subarray(16, 48)
+    };
+}

package/dist/esm/protocol/signal/prekey-upload.js

@@ -0,0 +1,107 @@
+/** Parser for client prekey upload IQs (`xmlns=encrypt`, `type=set`). */
+export class PreKeyUploadParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PreKeyUploadParseError';
+    }
+}
+export function parsePreKeyUploadIq(iq) {
+    if (iq.tag !== 'iq') {
+        throw new PreKeyUploadParseError(`expected iq stanza, got ${iq.tag}`);
+    }
+    if (iq.attrs.xmlns !== 'encrypt' || iq.attrs.type !== 'set') {
+        throw new PreKeyUploadParseError(`expected iq with xmlns=encrypt type=set, got xmlns=${iq.attrs.xmlns} type=${iq.attrs.type}`);
+    }
+    const children = iq.content;
+    if (!Array.isArray(children)) {
+        throw new PreKeyUploadParseError('iq has no children');
+    }
+    const registrationNode = findChild(children, 'registration');
+    const identityNode = findChild(children, 'identity');
+    const listNode = findChild(children, 'list');
+    const skeyNode = findChild(children, 'skey');
+    const registrationId = readBigEndianInt(requireBytes(registrationNode?.content, 'registration'));
+    const identityKey = requireBytes(identityNode?.content, 'identity');
+    if (identityKey.byteLength !== 32) {
+        throw new PreKeyUploadParseError(`identity key must be 32 bytes, got ${identityKey.byteLength}`);
+    }
+    const signedPreKey = parseSignedPreKey(skeyNode);
+    const preKeys = parsePreKeyList(listNode);
+    return {
+        registrationId,
+        identityKey,
+        signedPreKey,
+        preKeys
+    };
+}
+function findChild(children, tag) {
+    for (const child of children) {
+        if (child.tag === tag)
+            return child;
+    }
+    return null;
+}
+function parseSignedPreKey(node) {
+    if (!node) {
+        throw new PreKeyUploadParseError('skey child missing');
+    }
+    if (!Array.isArray(node.content)) {
+        throw new PreKeyUploadParseError('skey has no inner nodes');
+    }
+    const idNode = findChild(node.content, 'id');
+    const valueNode = findChild(node.content, 'value');
+    const signatureNode = findChild(node.content, 'signature');
+    const keyId = readBigEndianInt(requireBytes(idNode?.content, 'skey.id'));
+    const publicKey = requireBytes(valueNode?.content, 'skey.value');
+    const signature = requireBytes(signatureNode?.content, 'skey.signature');
+    if (publicKey.byteLength !== 32) {
+        throw new PreKeyUploadParseError(`skey value must be 32 bytes, got ${publicKey.byteLength}`);
+    }
+    if (signature.byteLength !== 64) {
+        throw new PreKeyUploadParseError(`skey signature must be 64 bytes, got ${signature.byteLength}`);
+    }
+    return { keyId, publicKey, signature };
+}
+function parsePreKeyList(node) {
+    if (!node) {
+        throw new PreKeyUploadParseError('list child missing');
+    }
+    if (!Array.isArray(node.content)) {
+        throw new PreKeyUploadParseError('list has no inner key entries');
+    }
+    const out = [];
+    for (const entry of node.content) {
+        if (entry.tag !== 'key')
+            continue;
+        if (!Array.isArray(entry.content))
+            continue;
+        const idNode = findChild(entry.content, 'id');
+        const valueNode = findChild(entry.content, 'value');
+        const keyId = readBigEndianInt(requireBytes(idNode?.content, 'key.id'));
+        const publicKey = requireBytes(valueNode?.content, 'key.value');
+        if (publicKey.byteLength !== 32) {
+            throw new PreKeyUploadParseError(`key value must be 32 bytes, got ${publicKey.byteLength}`);
+        }
+        out.push({ keyId, publicKey });
+    }
+    if (out.length === 0) {
+        throw new PreKeyUploadParseError('list is empty');
+    }
+    return out;
+}
+function requireBytes(content, label) {
+    if (content === undefined || content === null) {
+        throw new PreKeyUploadParseError(`${label} child has no content`);
+    }
+    if (!(content instanceof Uint8Array)) {
+        throw new PreKeyUploadParseError(`${label} content must be bytes`);
+    }
+    return content;
+}
+function readBigEndianInt(bytes) {
+    let value = 0;
+    for (let i = 0; i < bytes.byteLength; i += 1) {
+        value = value * 256 + bytes[i];
+    }
+    return value;
+}

package/dist/esm/protocol/stream/stream-error.js

@@ -0,0 +1,56 @@
+/** Builders for `<stream:error/>` stanzas pushed to the client. */
+const STREAM_ERROR_TAG = 'stream:error';
+export function buildStreamErrorCode(code) {
+    return {
+        tag: STREAM_ERROR_TAG,
+        attrs: { code: String(code) }
+    };
+}
+export function buildStreamErrorReplaced() {
+    return {
+        tag: STREAM_ERROR_TAG,
+        attrs: {},
+        content: [
+            {
+                tag: 'conflict',
+                attrs: { type: 'replaced' }
+            }
+        ]
+    };
+}
+export function buildStreamErrorDeviceRemoved() {
+    return {
+        tag: STREAM_ERROR_TAG,
+        attrs: {},
+        content: [
+            {
+                tag: 'conflict',
+                attrs: { type: 'device_removed' }
+            }
+        ]
+    };
+}
+export function buildStreamErrorAck(id) {
+    return {
+        tag: STREAM_ERROR_TAG,
+        attrs: {},
+        content: [
+            {
+                tag: 'ack',
+                attrs: { id }
+            }
+        ]
+    };
+}
+export function buildStreamErrorXmlNotWellFormed() {
+    return {
+        tag: STREAM_ERROR_TAG,
+        attrs: {},
+        content: [
+            {
+                tag: 'xml-not-well-formed',
+                attrs: {}
+            }
+        ]
+    };
+}

package/dist/esm/state/fake-app-state-collection.js

@@ -0,0 +1,134 @@
+/** In-memory app-state collection tracker (version/LTHash + patch queue). */
+import { APP_STATE_EMPTY_LT_HASH, FakeAppStateCrypto } from '../protocol/signal/fake-app-state-crypto.js';
+import { proto } from '../transport/protos.js';
+export class FakeAppStateCollection {
+    constructor(options) {
+        this.currentVersion = 0;
+        this.currentLtHash = APP_STATE_EMPTY_LT_HASH;
+        this.recordsByIndexMacHex = new Map();
+        this.pendingPatchMutations = [];
+        this.hasUnflushedSnapshotChanges = false;
+        this.name = options.name;
+        this.keyId = options.keyId;
+        this.keyData = options.keyData;
+        this.crypto = options.crypto ?? new FakeAppStateCrypto();
+    }
+    get version() {
+        return this.currentVersion;
+    }
+    get ltHash() {
+        return this.currentLtHash;
+    }
+    async applyMutation(input) {
+        const baseInput = {
+            operation: input.operation,
+            keyId: this.keyId,
+            keyData: this.keyData,
+            index: input.index,
+            value: input.value,
+            version: input.version
+        };
+        const encrypted = await this.crypto.encryptMutation(baseInput);
+        const indexMacHex = bytesToHex(encrypted.indexMac);
+        const existing = this.recordsByIndexMacHex.get(indexMacHex);
+        const removeValues = [];
+        const addValues = [];
+        if (existing) {
+            removeValues.push(existing.valueMac);
+            this.recordsByIndexMacHex.delete(indexMacHex);
+        }
+        if (input.operation === 'set') {
+            const record = {
+                indexMacHex,
+                indexMac: encrypted.indexMac,
+                valueMac: encrypted.valueMac,
+                valueBlob: encrypted.valueBlob
+            };
+            this.recordsByIndexMacHex.set(indexMacHex, record);
+            addValues.push(encrypted.valueMac);
+            this.pendingPatchMutations.push({ operation: 'set', record });
+        }
+        else {
+            this.pendingPatchMutations.push({
+                operation: 'remove',
+                record: {
+                    indexMacHex,
+                    indexMac: encrypted.indexMac,
+                    valueMac: encrypted.valueMac,
+                    valueBlob: encrypted.valueBlob
+                }
+            });
+        }
+        const nextHash = await this.applyLtHash(this.currentLtHash, addValues, removeValues);
+        this.currentLtHash = nextHash;
+        this.hasUnflushedSnapshotChanges = true;
+    }
+    async encodeSnapshot() {
+        this.currentVersion += 1;
+        const records = [];
+        for (const record of this.recordsByIndexMacHex.values()) {
+            records.push({
+                index: { blob: record.indexMac },
+                value: { blob: record.valueBlob },
+                keyId: { id: this.keyId }
+            });
+        }
+        const mac = await this.crypto.generateSnapshotMac(this.keyData, this.currentLtHash, this.currentVersion, this.name);
+        this.pendingPatchMutations.length = 0;
+        this.hasUnflushedSnapshotChanges = false;
+        return proto.SyncdSnapshot.encode({
+            version: { version: this.currentVersion },
+            records,
+            mac,
+            keyId: { id: this.keyId }
+        }).finish();
+    }
+    async encodePendingPatch() {
+        if (this.pendingPatchMutations.length === 0) {
+            throw new Error(`fake app-state collection ${this.name}: no pending mutations to encode`);
+        }
+        this.currentVersion += 1;
+        const patchVersion = this.currentVersion;
+        const mutations = [];
+        const valueMacs = [];
+        for (const pending of this.pendingPatchMutations) {
+            mutations.push({
+                operation: pending.operation === 'set'
+                    ? proto.SyncdMutation.SyncdOperation.SET
+                    : proto.SyncdMutation.SyncdOperation.REMOVE,
+                record: {
+                    keyId: { id: this.keyId },
+                    index: { blob: pending.record.indexMac },
+                    value: { blob: pending.record.valueBlob }
+                }
+            });
+            valueMacs.push(pending.record.valueMac);
+        }
+        const snapshotMac = await this.crypto.generateSnapshotMac(this.keyData, this.currentLtHash, patchVersion, this.name);
+        const patchMac = await this.crypto.generatePatchMac(this.keyData, snapshotMac, valueMacs, patchVersion, this.name);
+        this.pendingPatchMutations.length = 0;
+        this.hasUnflushedSnapshotChanges = false;
+        return proto.SyncdPatch.encode({
+            version: { version: patchVersion },
+            mutations,
+            snapshotMac,
+            patchMac,
+            keyId: { id: this.keyId }
+        }).finish();
+    }
+    hasPending() {
+        return this.pendingPatchMutations.length > 0 || this.hasUnflushedSnapshotChanges;
+    }
+    async applyLtHash(base, addValues, removeValues) {
+        const afterRemove = await this.crypto.ltHashSubtract(base, removeValues);
+        return this.crypto.ltHashAdd(afterRemove, addValues);
+    }
+}
+function bytesToHex(bytes) {
+    let out = '';
+    for (let index = 0; index < bytes.byteLength; index += 1) {
+        const value = bytes[index];
+        out += value < 16 ? `0${value.toString(16)}` : value.toString(16);
+    }
+    return out;
+}

package/dist/esm/state/fake-media-store.js

@@ -0,0 +1,53 @@
+/** In-memory media blob store served by the fake media endpoint. */
+import { randomBytes } from 'node:crypto';
+import { WaMediaCrypto } from '../transport/crypto.js';
+import { bytesToHex } from '../transport/util.js';
+export class FakeMediaStore {
+    constructor() {
+        this.blobs = new Map();
+    }
+    async publish(input) {
+        const mediaKey = input.mediaKey ?? new Uint8Array(randomBytes(32));
+        const encrypted = await WaMediaCrypto.encryptBytes(input.mediaType, mediaKey, input.plaintext);
+        const path = input.path ?? this.randomPath(input.mediaType);
+        const stored = {
+            mediaType: input.mediaType,
+            encryptedBytes: encrypted.ciphertextHmac,
+            mediaKey,
+            fileSha256: encrypted.fileSha256,
+            fileEncSha256: encrypted.fileEncSha256
+        };
+        this.blobs.set(path, stored);
+        return {
+            path,
+            mediaKey,
+            fileSha256: encrypted.fileSha256,
+            fileEncSha256: encrypted.fileEncSha256,
+            fileLength: encrypted.ciphertextHmac.byteLength,
+            mediaType: input.mediaType
+        };
+    }
+    /** Stores pre-encrypted bytes uploaded by the lib so the download path can serve them back. */
+    setRaw(path, encryptedBytes, mediaType = 'image') {
+        this.blobs.set(path, {
+            mediaType,
+            encryptedBytes,
+            mediaKey: new Uint8Array(32),
+            fileSha256: new Uint8Array(32),
+            fileEncSha256: new Uint8Array(32)
+        });
+    }
+    get(path) {
+        return this.blobs.get(path);
+    }
+    delete(path) {
+        return this.blobs.delete(path);
+    }
+    clear() {
+        this.blobs.clear();
+    }
+    randomPath(mediaType) {
+        const slug = bytesToHex(randomBytes(16));
+        return `/fake-media/${mediaType}/${slug}`;
+    }
+}

package/dist/esm/transport/codec.js

@@ -0,0 +1,8 @@
+/**
+ * Layer 1 – binary stanza codec wrapper.
+ *
+ * Re-exports the bit-exact WhatsApp WAP token encoder/decoder from zapo-js.
+ * This file is the only sanctioned import path for binary node serialization
+ * inside the fake server.
+ */
+export { decodeBinaryNode, decodeBinaryNodeStanza, encodeBinaryNode, encodeBinaryNodeStanza, verifyNoiseCertificateChain } from 'zapo-js/transport';

package/dist/esm/transport/crypto.js

@@ -0,0 +1,8 @@
+/**
+ * Layer 1 – crypto primitives wrapper.
+ *
+ * Re-exports bit-exact cryptographic primitives from zapo-js. No protocol
+ * interpretation, so reusing them does not create a test-vs-impl tautology.
+ */
+export { aesCbcDecrypt, aesCbcEncrypt, aesGcmDecrypt, aesGcmEncrypt, Ed25519, hkdf, hkdfSplit, hmacSha256Sign, hmacSha512Sign, prependVersion, randomBytesAsync, readVersionedContent, sha256, sha512, toRawPubKey, toSerializedPubKey, X25519, xeddsaSign, xeddsaVerify } from 'zapo-js/crypto';
+export { WaMediaCrypto } from 'zapo-js/media';

package/dist/esm/transport/protos.js

@@ -0,0 +1,7 @@
+/**
+ * Layer 1 – generated protobuf wrapper.
+ *
+ * Re-exports the proto namespace from zapo-js. The protos are generated from
+ * `.proto` definitions, not lib behavior, so direct reuse is safe.
+ */
+export { proto } from 'zapo-js/proto';

package/dist/esm/transport/util.js

@@ -0,0 +1,8 @@
+/**
+ * Layer 1 – byte/encoding primitives wrapper.
+ *
+ * Re-exports bit-exact byte helpers from zapo-js so Layer 2/3 of the fake
+ * server can use them without importing zapo-js directly.
+ */
+export { bytesToBase64, bytesToBase64UrlSafe, bytesToHex, decodeBase64Url } from 'zapo-js/util';
+export const TEXT_ENCODER = new TextEncoder();

package/dist/index.d.ts

@@ -48,4 +48,3 @@ export type { BuildPairDeviceIqInput, BuildPairSuccessIqInput, ParsedPairingQr }
 export { parsePreKeyUploadIq, PreKeyUploadParseError } from './protocol/signal/prekey-upload';
 export type { ClientPreKeyBundle, ClientPreKeyEntry, ClientSignedPreKey } from './protocol/signal/prekey-upload';
 export { buildStreamErrorAck, buildStreamErrorCode, buildStreamErrorDeviceRemoved, buildStreamErrorReplaced, buildStreamErrorXmlNotWellFormed } from './protocol/stream/stream-error';
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -71,4 +71,3 @@ Object.defineProperty(exports, "buildStreamErrorCode", { enumerable: true, get:
 Object.defineProperty(exports, "buildStreamErrorDeviceRemoved", { enumerable: true, get: function () { return stream_error_1.buildStreamErrorDeviceRemoved; } });
 Object.defineProperty(exports, "buildStreamErrorReplaced", { enumerable: true, get: function () { return stream_error_1.buildStreamErrorReplaced; } });
 Object.defineProperty(exports, "buildStreamErrorXmlNotWellFormed", { enumerable: true, get: function () { return stream_error_1.buildStreamErrorXmlNotWellFormed; } });
-//# sourceMappingURL=index.js.map

package/dist/infra/WaFakeConnection.d.ts

@@ -20,4 +20,3 @@ export declare class WaFakeConnection {
     close(code?: number, reason?: string): void;
     private bindSocketEvents;
 }
-//# sourceMappingURL=WaFakeConnection.d.ts.map

package/dist/infra/WaFakeConnection.js

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

package/dist/infra/WaFakeConnectionPipeline.d.ts

@@ -48,4 +48,3 @@ export declare class WaFakeConnectionPipeline {
     private handleAuthenticatedFrame;
     private fail;
 }
-//# sourceMappingURL=WaFakeConnectionPipeline.d.ts.map