zapo-js 0.1.0 → 0.1.2

package/dist/esm/message/reporting-token.js

@@ -0,0 +1,438 @@
+import { hkdf, hmacSign, importHmacKey } from '../crypto/index.js';
+import { proto } from '../proto.js';
+import { base64ToBytesChecked, concatBytes, EMPTY_BYTES, TEXT_ENCODER, toBytesView } from '../util/bytes.js';
+const WA_REPORTING_TOKEN_BYTES = 16;
+const WA_REPORTING_TOKEN_KEY_BYTES = 32;
+const WA_REPORTING_TOKEN_USE_CASE = 'Report Token';
+const WA_REPORTING_TOKEN_CONFIG_BASE64 = 'CgQIARIACjQIAxIwKgQIAhIAKgQIAxIAKgQICBIAKgQICxIAKhAIERIMKgQIFRIAKgQIFhIAKgQIGRIACioIBBImCAIqBggBEgIIAioGCBASAggCKhIIERIOCAIqBAgVEgAqBAgWEgAKOggFEjYIAioGCAMSAggCKgYIBBICCAIqBggFEgIIAioGCBASAggCKhIIERIOCAIqBAgVEgAqBAgWEgAKIggGEh4qBAgBEgAqEAgREgwqBAgVEgAqBAgWEgAqBAgeEgAKLggHEioqBAgCEgAqBAgHEgAqBAgKEgAqEAgREgwqBAgVEgAqBAgWEgAqBAgUEgAKLggIEioqBAgCEgAqBAgHEgAqBAgJEgAqEAgREgwqBAgVEgAqBAgWEgAqBAgVEgAKNAgJEjAqBAgCEgAqBAgGEgAqBAgHEgAqBAgNEgAqEAgREgwqBAgVEgAqBAgWEgAqBAgUEgAKKAgMEiQIAioGCAESAggCKgYIAhICCAIqCAgOEgQIAiABKgYIDxICCAIKKggSEiYIAioGCAYSAggCKgYIEBICCAIqEggREg4IAioECBUSACoECBYSAAouCBoSKioECAQSACoECAUSACoECAgSACoECA0SACoQCBESDCoECBUSACoECBYSAApCCBwSPggCKgYIARICCAIqBggCEgIIAioGCAQSAggCKgYIBRICCAIqBggGEgIIAioSCAcSDggCKgQIFRIAKgQIFhIACgwIJRIIKgYIARICIAEKUggxEk4IAioGCAISAggCKhYIAxISCAIqBggBEgIIAioGCAISAggCKhIIBRIOCAIqBAgVEgAqBAgWEgAqFggIEhIIAioGCAESAggCKgYIAhICCAIKDAg1EggqBggBEgIgAQoOCDcSCggCKgYIARICIAEKDgg6EgoIAioGCAESAiABCg4IOxIKCAIqBggBEgIgAQpSCDwSTggCKgYIAhICCAIqFggDEhIIAioGCAESAggCKgYIAhICCAIqEggFEg4IAioECBUSACoECBYSACoWCAgSEggCKgYIARICCAIqBggCEgIIAgpSCEASTggCKgYIAhICCAIqFggDEhIIAioGCAESAggCKgYIAhICCAIqEggFEg4IAioECBUSACoECBYSACoWCAgSEggCKgYIARICCAIqBggCEgIIAgo2CEISMggCKgQIAhIAKgQIBhIAKgQIBxIAKgQIDRIAKhAIERIMKgQIFRIAKgQIFhIAKgQIFBIACg4IShIKCAIqBggBEgIgAQoOCFcSCggCKgYIARICIAEKMghYEi4IAioGCAESAggCKg4IAhIKCAIqBggBEgIIAioSCAMSDggCKgQIFRIAKgQIFhIACg4IXBIKCAIqBggBEgIgAQoOCF0SCggCKgYIARICIAEKDgheEgoIAioGCAESAiAB';
+const WA_REPORTING_TOKEN_CONFIG_BYTES = base64ToBytesChecked(WA_REPORTING_TOKEN_CONFIG_BASE64, 'reporting_token.config');
+export const WA_REPORTING_TOKEN_VERSION = 2;
+let reportingTokenConfigSpec = null;
+const reportingTokenConfigCache = new Map();
+export async function buildReportingTokenNode(input) {
+    const artifacts = await buildReportingTokenArtifacts(input);
+    return artifacts?.node ?? null;
+}
+export async function buildReportingTokenArtifacts(input) {
+    const stanzaId = input.stanzaId.trim();
+    if (!stanzaId || !isMessageReportingTokenCompatible(input.message)) {
+        return null;
+    }
+    const messageSecret = input.message.messageContextInfo?.messageSecret;
+    if (!messageSecret || toBytesView(messageSecret).byteLength === 0) {
+        return null;
+    }
+    const reportingTokenContent = computeReportingTokenContent(proto.Message.encode(input.message).finish(), input.version ?? WA_REPORTING_TOKEN_VERSION);
+    if (reportingTokenContent.byteLength === 0) {
+        return null;
+    }
+    const secretInfo = concatBytes([
+        TEXT_ENCODER.encode(stanzaId),
+        TEXT_ENCODER.encode(input.senderUserJid),
+        TEXT_ENCODER.encode(input.remoteJid),
+        TEXT_ENCODER.encode(WA_REPORTING_TOKEN_USE_CASE)
+    ]);
+    const reportingTokenKey = await hkdf(toBytesView(messageSecret), null, secretInfo, WA_REPORTING_TOKEN_KEY_BYTES);
+    const hmacKey = await importHmacKey(reportingTokenKey);
+    const reportingToken = (await hmacSign(hmacKey, reportingTokenContent)).subarray(0, WA_REPORTING_TOKEN_BYTES);
+    const version = input.version ?? WA_REPORTING_TOKEN_VERSION;
+    return {
+        node: {
+            tag: 'reporting',
+            attrs: {},
+            content: [
+                {
+                    tag: 'reporting_token',
+                    attrs: {
+                        v: String(version)
+                    },
+                    content: reportingToken
+                }
+            ]
+        },
+        version,
+        reportingToken,
+        reportingTokenContent,
+        reportingTokenKey
+    };
+}
+function isMessageReportingTokenCompatible(message) {
+    return (!message.reactionMessage &&
+        !message.encReactionMessage &&
+        !message.encEventResponseMessage &&
+        !message.pollUpdateMessage);
+}
+function computeReportingTokenContent(messageBytes, version) {
+    const reportingConfig = getReportingTokenConfig(version);
+    const extracted = extractProtobufFieldParts(messageBytes, 0, messageBytes.length, reportingConfig, reportingConfig);
+    if (extracted.totalSize === 0) {
+        return EMPTY_BYTES;
+    }
+    const output = new Uint8Array(extracted.totalSize);
+    let offset = 0;
+    for (const part of extracted.parts) {
+        output.set(part.bytes, offset);
+        offset += part.bytes.length;
+    }
+    return output;
+}
+function getReportingTokenConfig(version) {
+    const cached = reportingTokenConfigCache.get(version);
+    if (cached) {
+        return cached;
+    }
+    const spec = getReportingTokenConfigSpec();
+    const fields = new Map();
+    for (const [fieldNumber, fieldSpec] of spec.fields) {
+        const selectedField = selectFieldForVersion(version, fieldNumber, fieldSpec);
+        if (selectedField) {
+            fields.set(fieldNumber, selectedField);
+        }
+    }
+    const config = { fields };
+    reportingTokenConfigCache.set(version, config);
+    return config;
+}
+function getReportingTokenConfigSpec() {
+    if (reportingTokenConfigSpec) {
+        return reportingTokenConfigSpec;
+    }
+    reportingTokenConfigSpec = parseReportingTokenConfigSpec(WA_REPORTING_TOKEN_CONFIG_BYTES);
+    return reportingTokenConfigSpec;
+}
+function parseReportingTokenConfigSpec(bytes) {
+    let cursor = 0;
+    const fields = new Map();
+    while (cursor < bytes.length) {
+        const tag = readVarint(bytes, cursor, bytes.length);
+        cursor = tag.next;
+        const fieldNumber = Math.floor(tag.value / 8);
+        const wireType = tag.value & 0x07;
+        if (fieldNumber === 1 && wireType === 2) {
+            const lengthInfo = readVarint(bytes, cursor, bytes.length);
+            const entryStart = lengthInfo.next;
+            const entryEnd = entryStart + lengthInfo.value;
+            if (entryEnd > bytes.length) {
+                throw new Error('invalid reporting token config map entry length');
+            }
+            const parsedEntry = parseReportingTokenConfigMapEntry(bytes, entryStart, entryEnd);
+            if (parsedEntry) {
+                fields.set(parsedEntry.key, parsedEntry.value);
+            }
+            cursor = entryEnd;
+            continue;
+        }
+        cursor = skipField(bytes, cursor, bytes.length, wireType);
+    }
+    return { fields };
+}
+function parseReportingTokenConfigMapEntry(bytes, start, end) {
+    let cursor = start;
+    let key = null;
+    let value = null;
+    while (cursor < end) {
+        const tag = readVarint(bytes, cursor, end);
+        cursor = tag.next;
+        const fieldNumber = Math.floor(tag.value / 8);
+        const wireType = tag.value & 0x07;
+        if (fieldNumber === 1 && wireType === 0) {
+            const keyVarint = readVarint(bytes, cursor, end);
+            key = keyVarint.value;
+            cursor = keyVarint.next;
+            continue;
+        }
+        if (fieldNumber === 2 && wireType === 2) {
+            const valueLength = readVarint(bytes, cursor, end);
+            const valueStart = valueLength.next;
+            const valueEnd = valueStart + valueLength.value;
+            if (valueEnd > end) {
+                throw new Error('invalid reporting token config field value length');
+            }
+            value = parseReportingTokenFieldSpec(bytes, valueStart, valueEnd);
+            cursor = valueEnd;
+            continue;
+        }
+        cursor = skipField(bytes, cursor, end, wireType);
+    }
+    if (key === null || value === null) {
+        return null;
+    }
+    return { key, value };
+}
+function parseReportingTokenFieldSpec(bytes, start, end) {
+    let cursor = start;
+    let minVersion = 1;
+    let maxVersion = null;
+    let isMessage = false;
+    const subfields = new Map();
+    while (cursor < end) {
+        const tag = readVarint(bytes, cursor, end);
+        cursor = tag.next;
+        const fieldNumber = Math.floor(tag.value / 8);
+        const wireType = tag.value & 0x07;
+        if (fieldNumber === 1 && wireType === 0) {
+            const value = readVarint(bytes, cursor, end);
+            minVersion = value.value;
+            cursor = value.next;
+            continue;
+        }
+        if (fieldNumber === 2 && wireType === 0) {
+            const value = readVarint(bytes, cursor, end);
+            maxVersion = value.value;
+            cursor = value.next;
+            continue;
+        }
+        if (fieldNumber === 4 && wireType === 0) {
+            const value = readVarint(bytes, cursor, end);
+            isMessage = value.value !== 0;
+            cursor = value.next;
+            continue;
+        }
+        if (fieldNumber === 5 && wireType === 2) {
+            const lengthInfo = readVarint(bytes, cursor, end);
+            const entryStart = lengthInfo.next;
+            const entryEnd = entryStart + lengthInfo.value;
+            if (entryEnd > end) {
+                throw new Error('invalid reporting token subfield map entry length');
+            }
+            const parsedEntry = parseReportingTokenConfigMapEntry(bytes, entryStart, entryEnd);
+            if (parsedEntry) {
+                subfields.set(parsedEntry.key, parsedEntry.value);
+            }
+            cursor = entryEnd;
+            continue;
+        }
+        cursor = skipField(bytes, cursor, end, wireType);
+    }
+    return {
+        minVersion,
+        maxVersion,
+        isMessage,
+        subfields: subfields.size > 0 ? subfields : null
+    };
+}
+function selectFieldForVersion(version, fieldNumber, fieldSpec) {
+    if (version < fieldSpec.minVersion) {
+        return null;
+    }
+    if (fieldSpec.maxVersion !== null && version > fieldSpec.maxVersion) {
+        return null;
+    }
+    if (!fieldSpec.subfields) {
+        return {
+            fieldNumber,
+            isMessage: fieldSpec.isMessage,
+            subfields: null
+        };
+    }
+    const selectedSubfields = new Map();
+    for (const [subFieldNumber, subFieldSpec] of fieldSpec.subfields) {
+        const selectedField = selectFieldForVersion(version, subFieldNumber, subFieldSpec);
+        if (selectedField) {
+            selectedSubfields.set(subFieldNumber, selectedField);
+        }
+    }
+    return {
+        fieldNumber,
+        isMessage: fieldSpec.isMessage,
+        subfields: {
+            fields: selectedSubfields
+        }
+    };
+}
+function extractProtobufFieldParts(bytes, start, end, config, rootConfig) {
+    const parts = [];
+    let totalSize = 0;
+    let cursor = start;
+    while (cursor < end) {
+        const parsedField = parseProtobufField(bytes, cursor, end);
+        cursor = parsedField.next;
+        const configuredField = config.fields.get(parsedField.fieldNumber);
+        if (!configuredField) {
+            continue;
+        }
+        if (!configuredField.isMessage && isExtractWholeField(configuredField)) {
+            const fieldBytes = bytes.subarray(parsedField.start, parsedField.next);
+            parts.push({
+                fieldNumber: parsedField.fieldNumber,
+                bytes: fieldBytes
+            });
+            totalSize += fieldBytes.length;
+            continue;
+        }
+        if (parsedField.wireType !== 2) {
+            continue;
+        }
+        const nestedConfig = configuredField.isMessage ? rootConfig : configuredField.subfields;
+        if (!nestedConfig) {
+            continue;
+        }
+        const nestedFields = extractProtobufFieldParts(bytes, parsedField.valueStart, parsedField.valueEnd, nestedConfig, rootConfig);
+        if (nestedFields.parts.length === 0 || nestedFields.totalSize === 0) {
+            continue;
+        }
+        const tagBytes = encodeVarint(parsedField.tag);
+        const nestedLengthBytes = encodeVarint(nestedFields.totalSize);
+        const fieldBytes = new Uint8Array(tagBytes.length + nestedLengthBytes.length + nestedFields.totalSize);
+        fieldBytes.set(tagBytes, 0);
+        fieldBytes.set(nestedLengthBytes, tagBytes.length);
+        let nestedOffset = tagBytes.length + nestedLengthBytes.length;
+        for (const nestedPart of nestedFields.parts) {
+            fieldBytes.set(nestedPart.bytes, nestedOffset);
+            nestedOffset += nestedPart.bytes.length;
+        }
+        parts.push({
+            fieldNumber: parsedField.fieldNumber,
+            bytes: fieldBytes
+        });
+        totalSize += fieldBytes.length;
+    }
+    parts.sort((left, right) => left.fieldNumber - right.fieldNumber);
+    return {
+        parts,
+        totalSize
+    };
+}
+function isExtractWholeField(field) {
+    return !field.subfields || field.subfields.fields.size === 0;
+}
+function parseProtobufField(bytes, start, end) {
+    const tag = readVarint(bytes, start, end);
+    const tagValue = tag.value;
+    if (tagValue <= 0 || tagValue > 4294967295) {
+        throw new Error(`protobuf field tag out of bounds: ${tagValue}`);
+    }
+    const fieldNumber = Math.floor(tagValue / 8);
+    if (fieldNumber < 1) {
+        throw new Error(`invalid protobuf field number: ${fieldNumber}`);
+    }
+    const wireType = tagValue & 0x07;
+    if (wireType === 0) {
+        const value = readVarint(bytes, tag.next, end);
+        return {
+            tag: tagValue,
+            fieldNumber,
+            wireType,
+            start,
+            next: value.next,
+            valueStart: value.next,
+            valueEnd: value.next
+        };
+    }
+    if (wireType === 1) {
+        const next = tag.next + 8;
+        if (next > end) {
+            throw new Error('invalid protobuf fixed64 field length');
+        }
+        return {
+            tag: tagValue,
+            fieldNumber,
+            wireType,
+            start,
+            next,
+            valueStart: next,
+            valueEnd: next
+        };
+    }
+    if (wireType === 2) {
+        const valueLength = readVarint(bytes, tag.next, end);
+        const valueStart = valueLength.next;
+        const valueEnd = valueStart + valueLength.value;
+        if (valueEnd > end) {
+            throw new Error('invalid protobuf length-delimited field length');
+        }
+        return {
+            tag: tagValue,
+            fieldNumber,
+            wireType,
+            start,
+            next: valueEnd,
+            valueStart,
+            valueEnd
+        };
+    }
+    if (wireType === 5) {
+        const next = tag.next + 4;
+        if (next > end) {
+            throw new Error('invalid protobuf fixed32 field length');
+        }
+        return {
+            tag: tagValue,
+            fieldNumber,
+            wireType,
+            start,
+            next,
+            valueStart: next,
+            valueEnd: next
+        };
+    }
+    throw new Error(`unsupported protobuf wire type: ${wireType}`);
+}
+function readVarint(bytes, start, end) {
+    let cursor = start;
+    let value = 0;
+    let factor = 1;
+    while (cursor < end) {
+        const byte = bytes[cursor];
+        value += (byte & 0x7f) * factor;
+        if (!Number.isSafeInteger(value)) {
+            throw new Error('varint exceeds safe integer range');
+        }
+        cursor += 1;
+        if ((byte & 0x80) === 0) {
+            return {
+                value,
+                next: cursor
+            };
+        }
+        factor *= 128;
+        if (factor > 2 ** 56) {
+            throw new Error('varint exceeds supported range');
+        }
+    }
+    throw new Error('unexpected end of buffer while reading varint');
+}
+function skipField(bytes, start, end, wireType) {
+    if (wireType === 0) {
+        return readVarint(bytes, start, end).next;
+    }
+    if (wireType === 1) {
+        const next = start + 8;
+        if (next > end) {
+            throw new Error('invalid fixed64 field size while skipping');
+        }
+        return next;
+    }
+    if (wireType === 2) {
+        const lengthInfo = readVarint(bytes, start, end);
+        const next = lengthInfo.next + lengthInfo.value;
+        if (next > end) {
+            throw new Error('invalid length-delimited field size while skipping');
+        }
+        return next;
+    }
+    if (wireType === 5) {
+        const next = start + 4;
+        if (next > end) {
+            throw new Error('invalid fixed32 field size while skipping');
+        }
+        return next;
+    }
+    throw new Error(`unsupported wire type while skipping field: ${wireType}`);
+}
+function encodeVarint(value) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`invalid varint value: ${value}`);
+    }
+    if (value === 0) {
+        return new Uint8Array([0]);
+    }
+    const bytes = [];
+    let current = value;
+    while (current >= 128) {
+        bytes.push((current % 128) + 128);
+        current = Math.floor(current / 128);
+    }
+    bytes.push(current);
+    return new Uint8Array(bytes);
+}

package/dist/esm/message/use-case-secret.js

@@ -0,0 +1,49 @@
+import { hkdf, randomBytesAsync } from '../crypto/index.js';
+import { TEXT_ENCODER, toBytesView } from '../util/bytes.js';
+export const WA_MESSAGE_SECRET_BYTES = 32;
+export const WA_USE_CASE_SECRET_MODIFICATION_TYPES = Object.freeze({
+    POLL_VOTE: 'Poll Vote',
+    ENC_REACTION: 'Enc Reaction',
+    ENC_COMMENT: 'Enc Comment',
+    REPORT_TOKEN: 'Report Token',
+    EVENT_RESPONSE: 'Event Response',
+    EVENT_EDIT_ENCRYPTED: 'Event Edit',
+    MESSAGE_EDIT: 'Message Edit'
+});
+export function assertMessageSecret(messageSecret, context = 'message secret') {
+    const bytes = toBytesView(messageSecret);
+    if (bytes.byteLength !== WA_MESSAGE_SECRET_BYTES) {
+        throw new Error(`${context} must be ${WA_MESSAGE_SECRET_BYTES} bytes (got ${bytes.byteLength})`);
+    }
+    return bytes;
+}
+export async function ensureMessageSecret(message) {
+    const messageSecret = message.messageContextInfo?.messageSecret;
+    if (messageSecret && toBytesView(messageSecret).byteLength > 0) {
+        return message;
+    }
+    const generatedMessageSecret = await randomBytesAsync(WA_MESSAGE_SECRET_BYTES);
+    return {
+        ...message,
+        messageContextInfo: {
+            ...(message.messageContextInfo ?? {}),
+            messageSecret: generatedMessageSecret
+        }
+    };
+}
+export async function createUseCaseSecret(input) {
+    if (!input.stanzaId.trim()) {
+        throw new Error('stanza id must be a non-empty string');
+    }
+    if (!input.parentMsgOriginalSender.trim()) {
+        throw new Error('parent message original sender must be a non-empty string');
+    }
+    if (!input.modificationSender.trim()) {
+        throw new Error('modification sender must be a non-empty string');
+    }
+    const secretInfo = TEXT_ENCODER.encode(input.stanzaId +
+        input.parentMsgOriginalSender +
+        input.modificationSender +
+        input.modificationType);
+    return hkdf(assertMessageSecret(input.messageSecret), null, secretInfo, WA_MESSAGE_SECRET_BYTES);
+}

package/dist/esm/protocol/appstate.js

@@ -32,3 +32,61 @@ export const WA_APP_STATE_KDF_INFO = Object.freeze({
     MUTATION_KEYS: 'WhatsApp Mutation Keys',
     PATCH_INTEGRITY: 'WhatsApp Patch Integrity'
 });
+export const WA_APP_STATE_CHAT_MUTATION_ACTIONS = Object.freeze({
+    STAR: 'star',
+    MUTE: 'mute',
+    PIN: 'pin_v1',
+    ARCHIVE: 'archive',
+    DELETE_MESSAGE_FOR_ME: 'deleteMessageForMe',
+    MARK_CHAT_AS_READ: 'markChatAsRead',
+    CLEAR_CHAT: 'clearChat',
+    DELETE_CHAT: 'deleteChat',
+    LOCK_CHAT: 'lock'
+});
+export const WA_APP_STATE_CHAT_MUTATION_SPECS = Object.freeze({
+    STAR: {
+        collection: WA_APP_STATE_COLLECTIONS.REGULAR_HIGH,
+        action: WA_APP_STATE_CHAT_MUTATION_ACTIONS.STAR,
+        version: 2
+    },
+    MUTE: {
+        collection: WA_APP_STATE_COLLECTIONS.REGULAR_HIGH,
+        action: WA_APP_STATE_CHAT_MUTATION_ACTIONS.MUTE,
+        version: 2
+    },
+    PIN: {
+        collection: WA_APP_STATE_COLLECTIONS.REGULAR_LOW,
+        action: WA_APP_STATE_CHAT_MUTATION_ACTIONS.PIN,
+        version: 5
+    },
+    ARCHIVE: {
+        collection: WA_APP_STATE_COLLECTIONS.REGULAR_LOW,
+        action: WA_APP_STATE_CHAT_MUTATION_ACTIONS.ARCHIVE,
+        version: 3
+    },
+    DELETE_MESSAGE_FOR_ME: {
+        collection: WA_APP_STATE_COLLECTIONS.REGULAR_HIGH,
+        action: WA_APP_STATE_CHAT_MUTATION_ACTIONS.DELETE_MESSAGE_FOR_ME,
+        version: 3
+    },
+    MARK_CHAT_AS_READ: {
+        collection: WA_APP_STATE_COLLECTIONS.REGULAR_LOW,
+        action: WA_APP_STATE_CHAT_MUTATION_ACTIONS.MARK_CHAT_AS_READ,
+        version: 3
+    },
+    CLEAR_CHAT: {
+        collection: WA_APP_STATE_COLLECTIONS.REGULAR_HIGH,
+        action: WA_APP_STATE_CHAT_MUTATION_ACTIONS.CLEAR_CHAT,
+        version: 6
+    },
+    DELETE_CHAT: {
+        collection: WA_APP_STATE_COLLECTIONS.REGULAR_HIGH,
+        action: WA_APP_STATE_CHAT_MUTATION_ACTIONS.DELETE_CHAT,
+        version: 6
+    },
+    LOCK_CHAT: {
+        collection: WA_APP_STATE_COLLECTIONS.REGULAR_LOW,
+        action: WA_APP_STATE_CHAT_MUTATION_ACTIONS.LOCK_CHAT,
+        version: 7
+    }
+});

package/dist/esm/protocol/constants.js

@@ -3,9 +3,10 @@ export { WA_SIGNALING, WA_PAIRING_KDF_INFO } from './auth.js';
 export { WA_DISCONNECT_REASONS, WA_LOGOUT_REASONS, WA_READY_STATES, WA_STREAM_SIGNALING } from './stream.js';
 export { WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from './nodes.js';
 export { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_RETRYABLE_ACK_CODES } from './message.js';
-export { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE } from './appstate.js';
+export { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_CHAT_MUTATION_ACTIONS, WA_APP_STATE_CHAT_MUTATION_SPECS, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE } from './appstate.js';
 export { getWaMediaHkdfInfo, WA_MEDIA_HKDF_INFO, WA_PREVIEW_MEDIA_HKDF_INFO } from './media.js';
 export { WA_ACCOUNT_SYNC_PROTOCOLS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_SUPPORTED_DIRTY_TYPES } from './dirty.js';
 export { WA_GROUP_NOTIFICATION_TAGS, WA_NOTIFICATION_TYPES } from './notification.js';
 export { WA_DEFAULTS } from './defaults.js';
 export { WA_GROUP_PARTICIPANT_TYPES } from './group.js';
+export { WA_USYNC_CONTEXTS, WA_USYNC_DEFAULTS, WA_USYNC_MODES } from './usync.js';

package/dist/esm/protocol/index.js

@@ -1,11 +1,3 @@
-export { getWaCompanionPlatformId, WA_BROWSERS, WA_COMPANION_PLATFORM_IDS } from './browser.js';
-export { WA_SIGNALING, WA_PAIRING_KDF_INFO } from './auth.js';
-export { WA_DISCONNECT_REASONS, WA_LOGOUT_REASONS, WA_READY_STATES, WA_STREAM_SIGNALING } from './stream.js';
-export { WA_IQ_TYPES, WA_NODE_TAGS, WA_XMLNS } from './nodes.js';
-export { WA_MESSAGE_TAGS, WA_MESSAGE_TYPES, WA_RETRYABLE_ACK_CODES } from './message.js';
-export { WA_APP_STATE_COLLECTIONS, WA_APP_STATE_COLLECTION_STATES, WA_APP_STATE_ERROR_CODES, WA_APP_STATE_KDF_INFO, WA_APP_STATE_KEY_TYPES, WA_APP_STATE_SYNC_DATA_TYPE } from './appstate.js';
-export { getWaMediaHkdfInfo, WA_MEDIA_HKDF_INFO, WA_PREVIEW_MEDIA_HKDF_INFO } from './media.js';
-export { WA_ACCOUNT_SYNC_PROTOCOLS, WA_DIRTY_PROTOCOLS, WA_DIRTY_TYPES, WA_SUPPORTED_DIRTY_TYPES } from './dirty.js';
-export { WA_GROUP_NOTIFICATION_TAGS, WA_NOTIFICATION_TYPES } from './notification.js';
-export { WA_DEFAULTS } from './defaults.js';
+export * from './constants.js';
 export { getLoginIdentity, isGroupJid, normalizeDeviceJid, normalizeRecipientJid, parsePhoneJid, parseSignalAddressFromJid, splitJid, toUserJid } from './jid.js';
+export { WA_USYNC_CONTEXTS, WA_USYNC_DEFAULTS, WA_USYNC_MODES } from './usync.js';