zapo-js 0.3.0 → 1.0.1

package/dist/appstate/{response-parser.js → parsers/response-parser.js}

@@ -2,10 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSyncResponse = parseSyncResponse;
 exports.parseCollectionState = parseCollectionState;
-const utils_1 = require("./utils");
-const _proto_1 = require("../proto.js");
-const constants_1 = require("../protocol/constants");
-const helpers_1 = require("../transport/node/helpers");
+const utils_1 = require("../utils");
+const _proto_1 = require("../../proto");
+const constants_1 = require("../../protocol/constants");
+const helpers_1 = require("../../transport/node/helpers");
+const primitives_1 = require("../../util/primitives");
+/**
+ * Parses an app-state `sync` IQ response into one payload per collection,
+ * decoding embedded patches and snapshot references. Throws when the IQ is
+ * an error envelope or missing the `<sync>` child.
+ */
 function parseSyncResponse(iqNode) {
     if (iqNode.tag !== constants_1.WA_NODE_TAGS.IQ) {
         throw new Error(`invalid sync response tag ${iqNode.tag}`);
@@ -30,11 +36,10 @@ function parseSyncResponse(iqNode) {
         const versionAttr = collectionNode.attrs.version;
         let version;
         if (versionAttr) {
-            const parsedVersion = Number.parseInt(versionAttr, 10);
-            if (!Number.isSafeInteger(parsedVersion) || parsedVersion < 0) {
+            version = (0, primitives_1.parseOptionalInt)(versionAttr);
+            if (version === undefined) {
                 throw new Error(`invalid app-state collection version "${versionAttr}"`);
             }
-            version = parsedVersion;
         }
         const [patchesNode, snapshotNode] = (0, helpers_1.findNodeChildrenByTags)(collectionNode, [
             constants_1.WA_NODE_TAGS.PATCHES,
@@ -59,6 +64,11 @@ function parseSyncResponse(iqNode) {
     }
     return payloads;
 }
+/**
+ * Reads a `<collection>` node and returns the right
+ * {@link AppStateCollectionState} (success / has-more / conflict / fatal /
+ * retryable) based on its `type` attribute and embedded error code.
+ */
 function parseCollectionState(node) {
     const type = node.attrs.type;
     const hasMorePatches = node.attrs.has_more_patches === 'true';
@@ -75,7 +85,9 @@ function parseCollectionState(node) {
             : constants_1.WA_APP_STATE_COLLECTION_STATES.CONFLICT;
     }
     if (code === constants_1.WA_APP_STATE_ERROR_CODES.BAD_REQUEST ||
-        code === constants_1.WA_APP_STATE_ERROR_CODES.NOT_FOUND) {
+        code === constants_1.WA_APP_STATE_ERROR_CODES.NOT_FOUND ||
+        code === constants_1.WA_APP_STATE_ERROR_CODES.NOT_ALLOWED ||
+        code === constants_1.WA_APP_STATE_ERROR_CODES.NOT_ACCEPTABLE) {
         return constants_1.WA_APP_STATE_COLLECTION_STATES.ERROR_FATAL;
     }
     return constants_1.WA_APP_STATE_COLLECTION_STATES.ERROR_RETRY;

package/dist/appstate/{WaAppStateSyncClient.js → sync/WaAppStateSyncClient.js}

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WaAppStateSyncClient = exports.WaAppStateMissingKeyError = void 0;
-const constants_1 = require("./constants");
-const response_parser_1 = require("./response-parser");
-const WaAppStateCrypto_1 = require("./WaAppStateCrypto");
-const _crypto_1 = require("../crypto/index.js");
-const _proto_1 = require("../proto.js");
-const constants_2 = require("../protocol/constants");
-const jid_1 = require("../protocol/jid");
-const query_1 = require("../transport/node/query");
-const bytes_1 = require("../util/bytes");
-const primitives_1 = require("../util/primitives");
+exports.WaAppStateSyncClient = void 0;
+const constants_1 = require("../constants");
+const WaAppStateCrypto_1 = require("../crypto/WaAppStateCrypto");
+const response_parser_1 = require("../parsers/response-parser");
+const _crypto_1 = require("../../crypto");
+const _proto_1 = require("../../proto");
+const constants_2 = require("../../protocol/constants");
+const jid_1 = require("../../protocol/jid");
+const query_1 = require("../../transport/node/query");
+const bytes_1 = require("../../util/bytes");
+const primitives_1 = require("../../util/primitives");
 class WaAppStateMissingKeyError extends Error {
     constructor(message, keyId, collection) {
         super(message);
@@ -19,25 +19,33 @@ class WaAppStateMissingKeyError extends Error {
         this.name = 'WaAppStateMissingKeyError';
     }
 }
-exports.WaAppStateMissingKeyError = WaAppStateMissingKeyError;
+/**
+ * App-state synchronization client. Owns the sync key inventory, processes
+ * snapshots/patches, encrypts pending mutations, and persists the resulting
+ * collection state in the {@link WaAppStateStore}.
+ */
 class WaAppStateSyncClient {
     constructor(options) {
         this.logger = options.logger;
         this.query = options.query;
         this.store = options.store;
+        this.serverClock = options.serverClock;
         this.getCurrentMeJid = options.getCurrentMeJid;
         this.hostDomain = options.hostDomain ?? constants_2.WA_DEFAULTS.HOST_DOMAIN;
         this.defaultTimeoutMs = options.defaultTimeoutMs ?? constants_2.WA_DEFAULTS.APP_STATE_SYNC_TIMEOUT_MS;
         this.onMissingKeys = options.onMissingKeys;
+        this.isOwnAccountDevice = options.isOwnAccountDevice;
+        this.sendKeyShare = options.sendKeyShare;
+        this.triggerSync = options.triggerSync;
         this.crypto = new WaAppStateCrypto_1.WaAppStateCrypto(undefined, options.skipMacVerification === true);
         this.mobilePrimary = options.mobilePrimary ?? false;
         this.syncContext = null;
         this.syncPromise = null;
     }
-    async exportState() {
-        this.logger.trace('app-state export requested');
-        return this.store.exportData();
-    }
+    /**
+     * Returns the active app-state sync key, generating and persisting a new
+     * one when the store is empty (used during initial setup).
+     */
     async ensureInitialSyncKey() {
         const existing = await this.store.getActiveSyncKey();
         if (existing) {
@@ -49,7 +57,7 @@ class WaAppStateSyncClient {
         const key = {
             keyId: keyIdBytes,
             keyData,
-            timestamp: Date.now(),
+            timestamp: this.serverClock.nowMs(),
             fingerprint: { rawId, currentIndex: 0, deviceIndexes: [0] }
         };
         await this.store.upsertSyncKeys([key]);
@@ -60,6 +68,7 @@ class WaAppStateSyncClient {
         });
         return key;
     }
+    /** Imports peer-shared sync keys into the store; returns the count actually added. */
     async importSyncKeys(keys) {
         this.logger.debug('app-state importing sync keys', { count: keys.length });
         const inserted = await this.store.upsertSyncKeys(keys);
@@ -69,6 +78,119 @@ class WaAppStateSyncClient {
         }
         return inserted;
     }
+    /** Handler for `AppStateSyncKeyShare` protocol messages – stores received keys and triggers a sync. */
+    async handleIncomingKeyShare(context, protocolMessage) {
+        const log = this.logger.child({ id: context.id, from: context.remoteJid });
+        const share = protocolMessage.appStateSyncKeyShare;
+        if (!share) {
+            log.warn('incoming app-state key share protocol message without payload');
+            return;
+        }
+        try {
+            const imported = await this.importSyncKeyShare(share);
+            log.info('imported app-state sync key share from protocol message', { imported });
+            if (imported > 0 && this.triggerSync) {
+                void this.triggerSync().catch((error) => {
+                    log.warn('failed to sync app-state after key share import', {
+                        message: (0, primitives_1.toError)(error).message
+                    });
+                });
+            }
+        }
+        catch (error) {
+            log.warn('failed to import app-state sync key share from protocol message', {
+                message: (0, primitives_1.toError)(error).message
+            });
+        }
+    }
+    /** Handler for `AppStateSyncKeyRequest` protocol messages – replies with the requested keys via `sendKeyShare`. */
+    async handleIncomingKeyRequest(context, protocolMessage) {
+        const log = this.logger.child({ id: context.id, from: context.remoteJid });
+        const request = protocolMessage.appStateSyncKeyRequest;
+        if (!request) {
+            log.warn('incoming app-state key request protocol message without payload');
+            return;
+        }
+        const senderJid = context.participant ?? context.remoteJid;
+        if (!senderJid) {
+            log.warn('incoming app-state key request missing sender jid');
+            return;
+        }
+        let requesterDeviceJid;
+        try {
+            const requesterRaw = (0, jid_1.applyDeviceToJid)(senderJid, context.senderDevice);
+            requesterDeviceJid = (0, jid_1.normalizeDeviceJid)(requesterRaw);
+        }
+        catch (error) {
+            log.warn('incoming app-state key request has malformed sender jid', {
+                senderJid,
+                message: (0, primitives_1.toError)(error).message
+            });
+            return;
+        }
+        const deviceLog = log.child({ to: requesterDeviceJid });
+        if (this.isOwnAccountDevice && !this.isOwnAccountDevice(requesterDeviceJid)) {
+            deviceLog.warn('incoming app-state key request ignored: sender is not own account');
+            return;
+        }
+        const requestedKeyIds = this.extractKeyRequestIds(request);
+        if (requestedKeyIds.length === 0) {
+            deviceLog.warn('incoming app-state key request has no valid key ids');
+            return;
+        }
+        if (!this.sendKeyShare) {
+            deviceLog.warn('incoming app-state key request received but no sendKeyShare wired');
+            return;
+        }
+        const requestedKeys = await this.store.getSyncKeysBatch(requestedKeyIds);
+        const availableKeys = [];
+        const missingKeyIds = [];
+        for (let i = 0; i < requestedKeys.length; i += 1) {
+            const key = requestedKeys[i];
+            if (key !== null) {
+                availableKeys.push(key);
+            }
+            else {
+                missingKeyIds.push(requestedKeyIds[i]);
+            }
+        }
+        try {
+            await this.sendKeyShare(requesterDeviceJid, availableKeys, missingKeyIds);
+            deviceLog.info('responded to app-state key request', {
+                requested: requestedKeyIds.length,
+                shared: availableKeys.length,
+                missing: missingKeyIds.length
+            });
+        }
+        catch (error) {
+            deviceLog.warn('failed to respond to app-state key request', {
+                requested: requestedKeyIds.length,
+                shared: availableKeys.length,
+                missing: missingKeyIds.length,
+                message: (0, primitives_1.toError)(error).message
+            });
+        }
+    }
+    extractKeyRequestIds(request) {
+        const deduped = new Map();
+        for (const key of request.keyIds ?? []) {
+            try {
+                const keyId = (0, bytes_1.decodeProtoBytes)(key.keyId, 'appStateSyncKeyRequest.keyIds[].keyId');
+                const keyHex = (0, bytes_1.bytesToHex)(keyId);
+                if (deduped.has(keyHex)) {
+                    continue;
+                }
+                deduped.set(keyHex, keyId);
+            }
+            catch (error) {
+                this.logger.trace('ignoring malformed app-state key id request entry', {
+                    message: (0, primitives_1.toError)(error).message
+                });
+            }
+        }
+        return [...deduped.values()];
+    }
+    /** Imports the keys from a decoded `AppStateSyncKeyShare` proto message. */
     async importSyncKeyShare(share) {
         const keys = [];
         for (const item of share.keys ?? []) {
@@ -84,13 +206,19 @@ class WaAppStateSyncClient {
                 keyId,
                 keyData,
                 timestamp: item.keyData?.timestamp === null || item.keyData?.timestamp === undefined
-                    ? Date.now()
+                    ? this.serverClock.nowMs()
                     : this.normalizeProtoLong(item.keyData?.timestamp, 'appStateSyncKeyShare.keys[].keyData.timestamp'),
                 fingerprint: item.keyData?.fingerprint ?? undefined
             });
         }
         return this.importSyncKeys(keys);
     }
+    /**
+     * Runs one app-state sync round across the requested collections,
+     * applying any `pendingMutations` and downloading external snapshots
+     * via `options.downloadExternalBlob` when present. Concurrent calls
+     * share the in-flight promise.
+     */
     async sync(options = {}) {
         if (this.syncPromise) {
             this.logger.debug('app-state sync already in flight, joining existing run');
@@ -122,7 +250,7 @@ class WaAppStateSyncClient {
             for (let index = 0; index < collections.length; index += 1) {
                 context.collections.set(collections[index], initialCollectionStates[index]);
             }
-            this.logger.info('app-state sync start', {
+            this.logger.debug('app-state sync start', {
                 collections: collections.length,
                 pendingMutations: options.pendingMutations?.length ?? 0
             });
@@ -172,13 +300,13 @@ class WaAppStateSyncClient {
             }
             if (stateChanged && context.dirtyCollections.size > 0) {
                 await this.persistCollectionUpdates();
-                this.logger.info('app-state sync persisted updated state');
+                this.logger.debug('app-state sync persisted updated state');
             }
             const orderedResults = collections.map((collection) => resultMap.get(collection) ?? {
                 collection,
                 state: constants_2.WA_APP_STATE_COLLECTION_STATES.ERROR_RETRY
             });
-            this.logger.info('app-state sync finished', {
+            this.logger.debug('app-state sync finished', {
                 collections: orderedResults.length,
                 stateChanged
             });
@@ -332,11 +460,12 @@ class WaAppStateSyncClient {
         return payloadByCollection;
     }
     async processCollectionRound({ collection, payloadByCollection, pendingByCollection, options, outgoingContexts, skippedUploadCollections }) {
+        const collectionLogger = this.logger.child({ collection });
         const payload = payloadByCollection.get(collection);
         let shouldRefetch = false;
         let collectionStateChanged = false;
         if (!payload) {
-            this.logger.warn('app-state sync response missing collection payload', { collection });
+            collectionLogger.warn('app-state sync response missing collection payload');
             return this.createCollectionOutcome(collection, constants_2.WA_APP_STATE_COLLECTION_STATES.ERROR_RETRY);
         }
         if (payload.state === constants_2.WA_APP_STATE_COLLECTION_STATES.ERROR_FATAL ||
@@ -396,8 +525,7 @@ class WaAppStateSyncClient {
                     payload.state === constants_2.WA_APP_STATE_COLLECTION_STATES.SUCCESS_HAS_MORE ||
                     (payload.state === constants_2.WA_APP_STATE_COLLECTION_STATES.SUCCESS &&
                         skippedUploadCollections.has(collection));
-            this.logger.debug('app-state collection processed', {
-                collection: payload.collection,
+            collectionLogger.debug('app-state collection processed', {
                 state: payload.state,
                 version: payload.version,
                 appliedMutations: appliedMutations.length
@@ -406,16 +534,13 @@ class WaAppStateSyncClient {
         }
         catch (error) {
             if (error instanceof WaAppStateMissingKeyError) {
-                this.logger.warn('app-state blocked by missing key', {
-                    collection: payload.collection,
+                collectionLogger.debug('app-state blocked by missing key', {
                     message: error.message
                 });
                 return this.createCollectionOutcome(collection, constants_2.WA_APP_STATE_COLLECTION_STATES.BLOCKED, payload.version, shouldRefetch, collectionStateChanged, undefined, error.keyId);
             }
-            const message = error instanceof Error ? error.message : String(error);
-            this.logger.warn('app-state collection processing failed', {
-                collection: payload.collection,
-                message
+            collectionLogger.debug('app-state collection processing failed', {
+                message: (0, primitives_1.toError)(error).message
             });
             return this.createCollectionOutcome(collection, constants_2.WA_APP_STATE_COLLECTION_STATES.ERROR_RETRY, payload.version, true, collectionStateChanged);
         }
@@ -441,11 +566,13 @@ class WaAppStateSyncClient {
             return;
         }
         const keyIdsHex = keyIds.map((keyId) => (0, bytes_1.bytesToHex)(keyId));
-        this.logger.info('app-state requesting missing sync keys', {
+        const requestLogger = this.logger.child({
             keys: keyIdsHex.length,
-            keyIds: keyIdsHex.join(','),
             collections: collections.join(',')
         });
+        requestLogger.debug('app-state requesting missing sync keys', {
+            keyIds: keyIdsHex.join(',')
+        });
         try {
             await input.onMissingKeys({
                 keyIds,
@@ -453,10 +580,8 @@ class WaAppStateSyncClient {
             });
         }
         catch (error) {
-            this.logger.warn('app-state missing key callback failed', {
-                keys: keyIdsHex.length,
-                collections: collections.join(','),
-                message: error instanceof Error ? error.message : String(error)
+            requestLogger.warn('app-state missing key callback failed', {
+                message: (0, primitives_1.toError)(error).message
             });
         }
     }
@@ -479,7 +604,8 @@ class WaAppStateSyncClient {
                 const decodedMutations = _proto_1.proto.SyncdMutations.decode(patchBytes);
                 readyPatch = {
                     ...readyPatch,
-                    mutations: decodedMutations.mutations ?? []
+                    mutations: decodedMutations.mutations ?? [],
+                    externalMutations: undefined
                 };
             }
             return this.validatePatch(payload.collection, readyPatch);
@@ -569,7 +695,7 @@ class WaAppStateSyncClient {
         const ltHash = await this.crypto.ltHashAdd(constants_1.APP_STATE_EMPTY_LT_HASH, ltHashInput);
         if (keyData !== null) {
             const expectedSnapshotMac = await this.crypto.generateSnapshotMac(keyData, ltHash, version, collection);
-            if (!(0, bytes_1.uint8Equal)(expectedSnapshotMac, snapshot.mac)) {
+            if (!(0, bytes_1.uint8TimingSafeEqual)(expectedSnapshotMac, snapshot.mac)) {
                 throw new Error(`snapshot MAC mismatch for ${collection}`);
             }
         }
@@ -708,12 +834,16 @@ class WaAppStateSyncClient {
     async assertPatchMacsMatch(patch, collection, patchKeyData, patchVersion, nextHash, valueMacs) {
         const snapshotMac = (0, bytes_1.decodeProtoBytes)(patch.snapshotMac, `patch.snapshotMac (${collection})`);
         const expectedSnapshotMac = await this.crypto.generateSnapshotMac(patchKeyData, nextHash, patchVersion, collection);
-        if (!(0, bytes_1.uint8Equal)(expectedSnapshotMac, snapshotMac)) {
-            throw new Error(`patch snapshot MAC mismatch for ${collection}`);
+        // non-fatal: wa-mob/wa-web tolerate this – patchMac below covers payload integrity.
+        if (!(0, bytes_1.uint8TimingSafeEqual)(expectedSnapshotMac, snapshotMac)) {
+            this.logger.debug('patch snapshot MAC mismatch (tolerated)', {
+                collection,
+                patchVersion
+            });
         }
         const patchMac = (0, bytes_1.decodeProtoBytes)(patch.patchMac, `patch.patchMac (${collection})`);
         const expectedPatchMac = await this.crypto.generatePatchMac(patchKeyData, snapshotMac, valueMacs, patchVersion, collection);
-        if (!(0, bytes_1.uint8Equal)(expectedPatchMac, patchMac)) {
+        if (!(0, bytes_1.uint8TimingSafeEqual)(expectedPatchMac, patchMac)) {
             throw new Error(`patch MAC mismatch for ${collection}`);
         }
     }
@@ -722,7 +852,7 @@ class WaAppStateSyncClient {
             throw new WaAppStateMissingKeyError(`no sync key available to upload ${collection}`, null, collection);
         }
         const encryptedResults = await Promise.all(pendingMutations.map(async (mutation) => {
-            const value = mutation.operation === 'set' ? mutation.value : mutation.previousValue;
+            const value = mutation.operation === 'set' ? mutation.value : null;
             const operationCode = mutation.operation === 'remove'
                 ? _proto_1.proto.SyncdMutation.SyncdOperation.REMOVE
                 : _proto_1.proto.SyncdMutation.SyncdOperation.SET;
@@ -761,14 +891,12 @@ class WaAppStateSyncClient {
         const snapshotMac = await this.crypto.generateSnapshotMac(activeKey.keyData, nextState.hash, patchVersion, collection);
         const patchMac = await this.crypto.generatePatchMac(activeKey.keyData, snapshotMac, valueMacs, patchVersion, collection);
         const deviceIndex = this.resolveDeviceIndex();
-        const clientDebugData = this.buildPatchClientDebugData();
         const encodedPatch = _proto_1.proto.SyncdPatch.encode({
             mutations: encryptedMutations,
             snapshotMac,
             patchMac,
             keyId: { id: activeKey.keyId },
-            ...(deviceIndex === undefined ? {} : { deviceIndex }),
-            clientDebugData
+            ...(deviceIndex === undefined ? {} : { deviceIndex })
         }).finish();
         return {
             encodedPatch,
@@ -796,12 +924,6 @@ class WaAppStateSyncClient {
             return undefined;
         }
     }
-    buildPatchClientDebugData() {
-        return _proto_1.proto.PatchDebugData.encode({
-            isSenderPrimary: false,
-            senderPlatform: _proto_1.proto.PatchDebugData.Platform.WEB
-        }).finish();
-    }
     async computeNextCollectionState(baseHash, baseMap, mutations, collection) {
         const indexValueMap = new Map(baseMap);
         const addValues = [];
@@ -842,8 +964,7 @@ class WaAppStateSyncClient {
             return (0, primitives_1.longToNumber)(value);
         }
         catch (error) {
-            const reason = error instanceof Error ? error.message : String(error);
-            throw new Error(`invalid ${field}: ${reason}`);
+            throw new Error(`invalid ${field}: ${(0, primitives_1.toError)(error).message}`);
         }
     }
     groupPendingMutations(pendingMutations) {

package/dist/appstate/utils.js

@@ -7,17 +7,29 @@ exports.downloadExternalBlobReference = downloadExternalBlobReference;
 const constants_1 = require("../protocol/constants");
 const bytes_1 = require("../util/bytes");
 const APP_STATE_COLLECTION_NAMES = new Set(Object.values(constants_1.WA_APP_STATE_COLLECTIONS));
+/**
+ * Returns `value` typed as a known {@link AppStateCollectionName}, or `null`
+ * when the string is unrecognized.
+ */
 function parseCollectionName(value) {
     return value && APP_STATE_COLLECTION_NAMES.has(value) ? value : null;
 }
 function keyDeviceId(keyId) {
     return keyId.byteLength < 6 ? null : (keyId[0] << 8) | keyId[1];
 }
+/**
+ * Reads the 32-bit big-endian epoch encoded in bytes 2..5 of an app-state key id.
+ * Returns `-1` when the key id is too short.
+ */
 function keyEpoch(keyId) {
     return keyId.byteLength < 6
         ? -1
         : keyId[2] * 16777216 + keyId[3] * 65536 + keyId[4] * 256 + keyId[5];
 }
+/**
+ * Picks the highest-epoch app-state sync key from `keys`. Ties are broken by
+ * the lower device id. Returns `null` when the iterable is empty.
+ */
 function pickActiveSyncKey(keys) {
     let active = null;
     for (const key of keys) {
@@ -42,6 +54,10 @@ function pickActiveSyncKey(keys) {
     }
     return active;
 }
+/**
+ * Downloads and decrypts an external app-state blob via the media transfer
+ * client. Throws when the reference is missing required fields.
+ */
 async function downloadExternalBlobReference(mediaTransfer, reference) {
     if (!reference.directPath) {
         throw new Error('external blob reference is missing directPath');

package/dist/appstate-spec.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WA_APPSTATE_SCHEMA_BY_ACTION_NAME = exports.WA_APPSTATE_SCHEMAS = exports.WA_APPSTATE_COLLECTIONS = void 0;
+exports.getAppstateSchemaByActionName = getAppstateSchemaByActionName;
+exports.resolveEnumObject = resolveEnumObject;
+exports.encodeEnumValue = encodeEnumValue;
+exports.decodeEnumValue = decodeEnumValue;
+exports.decodeIndexArgsFromSchema = decodeIndexArgsFromSchema;
+const _proto_1 = require("./proto");
+const appstate_1 = require("../spec/appstate");
+var appstate_2 = require("../spec/appstate");
+Object.defineProperty(exports, "WA_APPSTATE_COLLECTIONS", { enumerable: true, get: function () { return appstate_2.WA_APPSTATE_COLLECTIONS; } });
+Object.defineProperty(exports, "WA_APPSTATE_SCHEMAS", { enumerable: true, get: function () { return appstate_2.WA_APPSTATE_SCHEMAS; } });
+const SCHEMA_BY_ACTION_NAME_BUILDER = {};
+for (const key of Object.keys(appstate_1.WA_APPSTATE_SCHEMAS)) {
+    SCHEMA_BY_ACTION_NAME_BUILDER[appstate_1.WA_APPSTATE_SCHEMAS[key].name] = key;
+}
+exports.WA_APPSTATE_SCHEMA_BY_ACTION_NAME = Object.freeze(SCHEMA_BY_ACTION_NAME_BUILDER);
+function getAppstateSchemaByActionName(actionName) {
+    const key = exports.WA_APPSTATE_SCHEMA_BY_ACTION_NAME[actionName];
+    if (!key) {
+        return null;
+    }
+    return { key, schema: appstate_1.WA_APPSTATE_SCHEMAS[key] };
+}
+function resolveEnumObject(protoEnumPath) {
+    const segments = protoEnumPath.split('.');
+    let cursor = _proto_1.proto.SyncActionValue;
+    for (const seg of segments) {
+        if (cursor === null || cursor === undefined)
+            return null;
+        if (typeof cursor !== 'object' && typeof cursor !== 'function')
+            return null;
+        cursor = cursor[seg];
+    }
+    if (cursor === null || cursor === undefined)
+        return null;
+    if (typeof cursor !== 'object' && typeof cursor !== 'function')
+        return null;
+    return cursor;
+}
+function encodeEnumValue(protoEnumPath, name) {
+    const enumObj = resolveEnumObject(protoEnumPath);
+    if (!enumObj)
+        return null;
+    const value = enumObj[name];
+    return typeof value === 'number' ? value : null;
+}
+function decodeEnumValue(protoEnumPath, value) {
+    const enumObj = resolveEnumObject(protoEnumPath);
+    if (!enumObj)
+        return null;
+    for (const key of Object.keys(enumObj)) {
+        if (enumObj[key] === value)
+            return key;
+    }
+    return null;
+}
+function decodeIndexArgsFromSchema(schema, parts) {
+    if (parts.length !== schema.indexParts.length) {
+        return null;
+    }
+    const args = {};
+    for (let i = 0; i < schema.indexParts.length; i += 1) {
+        const part = schema.indexParts[i];
+        const raw = parts[i];
+        if (part.type === 'literal') {
+            continue;
+        }
+        if (part.type === 'boolString') {
+            if (raw !== '0' && raw !== '1')
+                return null;
+            args[part.name] = raw === '1';
+            continue;
+        }
+        if (part.type === 'jidOrZero') {
+            args[part.name] = raw === '0' ? null : raw;
+            continue;
+        }
+        if (part.type === 'enum') {
+            const numeric = Number(raw);
+            const name = Number.isFinite(numeric) ? decodeEnumValue(part.protoEnum, numeric) : null;
+            args[part.name] = name ?? raw;
+            continue;
+        }
+        args[part.name] = raw;
+    }
+    return args;
+}