zapo-js 0.1.0 → 0.1.2

package/dist/esm/client/incoming.js

@@ -2,9 +2,8 @@ import { parseGroupNotificationEvents } from './events/group.js';
 import { WA_NODE_TAGS, WA_NOTIFICATION_TYPES } from '../protocol/constants.js';
 import { buildInboundReceiptAckNode, buildInboundRetryReceiptAckNode } from '../transport/node/builders/message.js';
 import { buildNotificationAckNode } from '../transport/node/builders/pairing.js';
-import { getFirstNodeChild, getNodeChildrenByTag } from '../transport/node/helpers.js';
-import { parseOptionalInt } from '../transport/stream/parse.js';
-import { toError } from '../util/primitives.js';
+import { getFirstNodeChild, getNodeChildrenNonEmptyAttrValuesByTag } from '../transport/node/helpers.js';
+import { parseOptionalInt, toError } from '../util/primitives.js';
 const LOGOUT_FAILURE_REASONS = new Set([401, 403, 406]);
 const DISCONNECT_FAILURE_REASONS = new Set([405, 409, 503]);
 const CORE_NOTIFICATION_TYPES = new Set([
@@ -141,47 +140,50 @@ export function createIncomingNotificationHandler(options) {
         const notificationType = node.attrs.type ?? '';
         const classification = classifyNotificationType(notificationType);
         const firstChildTag = getFirstNodeChild(node)?.tag;
+        const baseEvent = createIncomingBaseEvent(node);
         const serverSyncCollections = notificationType === 'server_sync'
-            ? getNodeChildrenByTag(node, WA_NODE_TAGS.COLLECTION)
-                .map((collectionNode) => collectionNode.attrs.name)
-                .filter((name) => typeof name === 'string' && name.length > 0)
+            ? getNodeChildrenNonEmptyAttrValuesByTag(node, WA_NODE_TAGS.COLLECTION, 'name')
             : [];
+        let details;
+        if (firstChildTag || serverSyncCollections.length > 0) {
+            details = {};
+            if (firstChildTag) {
+                details.firstChildTag = firstChildTag;
+            }
+            if (serverSyncCollections.length > 0) {
+                details.collections = serverSyncCollections;
+            }
+        }
         options.emitIncomingNotification({
-            ...createIncomingBaseEvent(node),
+            ...baseEvent,
             notificationType,
             classification,
-            details: firstChildTag || serverSyncCollections.length > 0
-                ? {
-                    ...(firstChildTag ? { firstChildTag } : {}),
-                    ...(serverSyncCollections.length > 0
-                        ? { collections: serverSyncCollections }
-                        : {})
-                }
-                : undefined
+            details
         });
         if (classification === 'out_of_scope') {
             options.emitUnhandledStanza({
-                ...createIncomingBaseEvent(node),
+                ...baseEvent,
                 reason: `notification.${notificationType}.out_of_scope`
             });
         }
         else if (classification === 'unknown') {
             options.emitUnhandledStanza({
-                ...createIncomingBaseEvent(node),
+                ...baseEvent,
                 reason: `notification.${notificationType || 'unknown'}.not_supported`
             });
         }
         await sendSafeAck(options.logger, options.sendNode, buildNotificationAckNode(node));
         if (notificationType === 'server_sync' && serverSyncCollections.length > 0) {
+            const collectionsCsv = serverSyncCollections.join(',');
             if (!options.syncAppState) {
                 options.logger.warn('received server_sync notification without app-state sync runtime', {
-                    collections: serverSyncCollections.join(',')
+                    collections: collectionsCsv
                 });
                 return true;
             }
             void options.syncAppState().catch((error) => {
                 options.logger.warn('failed to sync app-state after server_sync notification', {
-                    collections: serverSyncCollections.join(','),
+                    collections: collectionsCsv,
                     message: toError(error).message
                 });
             });
@@ -194,6 +196,7 @@ export function createIncomingGroupNotificationHandler(options) {
         if (node.attrs.type !== WA_NOTIFICATION_TYPES.GROUP) {
             return false;
         }
+        const baseEvent = createIncomingBaseEvent(node);
         const parsed = parseGroupNotificationEvents(node);
         for (const event of parsed.events) {
             options.emitGroupEvent(event);
@@ -203,7 +206,7 @@ export function createIncomingGroupNotificationHandler(options) {
         }
         if (parsed.events.length === 0 && parsed.unhandled.length === 0) {
             options.emitUnhandledStanza({
-                ...createIncomingBaseEvent(node),
+                ...baseEvent,
                 reason: `notification.${WA_NOTIFICATION_TYPES.GROUP}.empty`
             });
         }

package/dist/esm/client/mailbox.js

@@ -1,14 +1,12 @@
 import { proto } from '../proto.js';
 import { toError } from '../util/primitives.js';
 async function persistContacts(contactStore, event, nowMs) {
-    const candidateJids = new Set();
-    if (event.senderJid) {
-        candidateJids.add(event.senderJid);
-    }
-    if (event.rawNode.attrs.participant) {
-        candidateJids.add(event.rawNode.attrs.participant);
+    const candidateJids = [event.senderJid, event.rawNode.attrs.participant].filter((jid) => !!jid);
+    if (candidateJids.length === 0) {
+        return;
     }
-    await Promise.all(Array.from(candidateJids, (jid) => contactStore.upsert({ jid, lastUpdatedMs: nowMs })));
+    const contacts = [...new Set(candidateJids)].map((jid) => ({ jid, lastUpdatedMs: nowMs }));
+    await contactStore.upsertBatch(contacts);
 }
 export async function persistIncomingMailboxEntities(options) {
     const { logger, contactStore, messageStore, event } = options;
@@ -28,7 +26,9 @@ export async function persistIncomingMailboxEntities(options) {
                 senderJid: event.senderJid,
                 participantJid: event.rawNode.attrs.participant,
                 fromMe: false,
-                timestampMs: event.timestampSeconds === undefined ? undefined : event.timestampSeconds * 1000,
+                timestampMs: event.timestampSeconds === undefined
+                    ? undefined
+                    : event.timestampSeconds * 1000,
                 encType: event.encryptionType,
                 plaintext: event.plaintext,
                 messageBytes

package/dist/esm/client/messages.js

@@ -4,7 +4,7 @@ import { WaMediaCrypto } from '../media/WaMediaCrypto.js';
 import { isSendMediaMessage } from '../message/content.js';
 import { WA_DEFAULTS } from '../protocol/constants.js';
 import { buildMediaConnIq } from '../transport/node/builders/media.js';
-import { bytesToBase64UrlSafe } from '../util/base64.js';
+import { bytesToBase64UrlSafe } from '../util/bytes.js';
 import { TEXT_DECODER, toBytesView } from '../util/bytes.js';
 import { toError } from '../util/primitives.js';
 export async function buildMediaMessageContent(options, content) {

package/dist/esm/client/messaging/fanout.js

@@ -0,0 +1,186 @@
+import { normalizeDeviceJid, splitJid, toUserJid } from '../../protocol/jid.js';
+import { toError } from '../../util/primitives.js';
+export function createDeviceFanoutResolver(options) {
+    const { signalDeviceSync, getCurrentMeJid, getCurrentMeLid, logger } = options;
+    const requireCurrentMeJid = (context) => {
+        const meJid = getCurrentMeJid();
+        if (meJid) {
+            return meJid;
+        }
+        throw new Error(`${context} requires registered meJid`);
+    };
+    const resolveDirectFanoutDeviceJids = async (recipientJid, selfDeviceJidForRecipient) => {
+        const recipientUserJid = toUserJid(recipientJid);
+        const meUserJid = toUserJid(selfDeviceJidForRecipient);
+        const targets = recipientUserJid === meUserJid ? [recipientUserJid] : [recipientUserJid, meUserJid];
+        try {
+            const synced = await signalDeviceSync.syncDeviceList(targets);
+            const byUser = new Map(synced.map((entry) => [toUserJid(entry.jid), entry.deviceJids]));
+            const fanout = new Set();
+            const recipientDevices = byUser.get(recipientUserJid) ?? [];
+            if (recipientDevices.length === 0) {
+                fanout.add(recipientUserJid);
+            }
+            else {
+                for (let index = 0; index < recipientDevices.length; index += 1) {
+                    fanout.add(recipientDevices[index]);
+                }
+            }
+            const meDevices = byUser.get(meUserJid) ?? [];
+            const normalizedMeJid = normalizeDeviceJid(selfDeviceJidForRecipient);
+            for (let index = 0; index < meDevices.length; index += 1) {
+                const deviceJid = meDevices[index];
+                if (normalizeDeviceJid(deviceJid) === normalizedMeJid) {
+                    continue;
+                }
+                fanout.add(deviceJid);
+            }
+            return [...fanout];
+        }
+        catch (error) {
+            logger.warn('signal device fanout sync failed, falling back to direct recipient', {
+                to: recipientJid,
+                message: toError(error).message
+            });
+            return [recipientUserJid];
+        }
+    };
+    const resolveGroupParticipantDeviceJids = async (participantUserJids) => {
+        const meDeviceJids = new Set();
+        const meJid = getCurrentMeJid();
+        if (meJid) {
+            try {
+                meDeviceJids.add(normalizeDeviceJid(meJid));
+            }
+            catch (error) {
+                logger.trace('ignoring malformed me jid', {
+                    meJid,
+                    message: toError(error).message
+                });
+            }
+        }
+        const meLid = getCurrentMeLid();
+        if (meLid && meLid.includes('@')) {
+            try {
+                meDeviceJids.add(normalizeDeviceJid(meLid));
+            }
+            catch (error) {
+                logger.trace('ignoring malformed me lid jid', {
+                    meLid,
+                    message: toError(error).message
+                });
+            }
+        }
+        const candidateUsers = [...new Set(participantUserJids)];
+        if (candidateUsers.length === 0) {
+            return [];
+        }
+        try {
+            const synced = await signalDeviceSync.syncDeviceList(candidateUsers);
+            const fanout = new Set();
+            for (const entry of synced) {
+                if (entry.deviceJids.length === 0) {
+                    const normalizedEntryJid = normalizeDeviceJid(entry.jid);
+                    if (meDeviceJids.has(normalizedEntryJid)) {
+                        continue;
+                    }
+                    fanout.add(normalizedEntryJid);
+                    continue;
+                }
+                for (const deviceJid of entry.deviceJids) {
+                    const normalizedDeviceJid = normalizeDeviceJid(deviceJid);
+                    if (meDeviceJids.has(normalizedDeviceJid)) {
+                        continue;
+                    }
+                    fanout.add(normalizedDeviceJid);
+                }
+            }
+            return [...fanout];
+        }
+        catch (error) {
+            logger.warn('group participant device sync failed, falling back to participant user jids', {
+                participants: candidateUsers.length,
+                message: toError(error).message
+            });
+            const fallbackJids = new Set();
+            for (const candidateJid of candidateUsers) {
+                try {
+                    const normalizedCandidateJid = normalizeDeviceJid(candidateJid);
+                    if (meDeviceJids.has(normalizedCandidateJid)) {
+                        continue;
+                    }
+                    fallbackJids.add(normalizedCandidateJid);
+                }
+                catch (fallbackError) {
+                    logger.trace('ignoring malformed participant jid in fallback fanout resolution', {
+                        participantJid: candidateJid,
+                        message: toError(fallbackError).message
+                    });
+                }
+            }
+            return [...fallbackJids];
+        }
+    };
+    const resolveOwnPeerDeviceJids = async () => {
+        const meJid = requireCurrentMeJid('resolveOwnPeerDeviceJids');
+        const meUserJid = toUserJid(meJid);
+        const meDevices = new Set();
+        meDevices.add(normalizeDeviceJid(meJid));
+        const meLid = getCurrentMeLid();
+        if (meLid && meLid.includes('@')) {
+            try {
+                meDevices.add(normalizeDeviceJid(meLid));
+            }
+            catch (error) {
+                logger.trace('ignoring malformed me lid jid while resolving peer devices', {
+                    meLid,
+                    message: toError(error).message
+                });
+            }
+        }
+        try {
+            const synced = await signalDeviceSync.syncDeviceList([meUserJid]);
+            const peerDevices = new Set();
+            for (const entry of synced) {
+                const sourceDevices = entry.deviceJids.length > 0 ? entry.deviceJids : [entry.jid];
+                for (const deviceJid of sourceDevices) {
+                    try {
+                        const normalized = normalizeDeviceJid(deviceJid);
+                        if (meDevices.has(normalized)) {
+                            continue;
+                        }
+                        peerDevices.add(normalized);
+                    }
+                    catch (error) {
+                        logger.trace('ignoring malformed peer device jid while resolving app-state peers', {
+                            deviceJid,
+                            message: toError(error).message
+                        });
+                    }
+                }
+            }
+            return [...peerDevices];
+        }
+        catch (error) {
+            logger.warn('failed to resolve peer devices for app-state key request', {
+                message: toError(error).message
+            });
+            return [];
+        }
+    };
+    const resolveSelfDeviceJidForRecipient = (recipientJid, meJid, meLid) => {
+        if (splitJid(recipientJid).server !== 'lid') {
+            return meJid;
+        }
+        if (!meLid || !meLid.includes('@')) {
+            return meJid;
+        }
+        return meLid;
+    };
+    return {
+        resolveDirectFanoutDeviceJids,
+        resolveGroupParticipantDeviceJids,
+        resolveOwnPeerDeviceJids,
+        resolveSelfDeviceJidForRecipient
+    };
+}

package/dist/esm/client/messaging/key-protocol.js

@@ -0,0 +1,127 @@
+import { writeRandomPadMax16 } from '../../message/padding.js';
+import { proto } from '../../proto.js';
+import { normalizeDeviceJid } from '../../protocol/jid.js';
+import { bytesToHex } from '../../util/bytes.js';
+export function createAppStateSyncKeyProtocol(options) {
+    const { publishSignalMessage, fanoutResolver, getCurrentMeJid, getCurrentMeLid, logger } = options;
+    const requireCurrentIdentity = (context) => {
+        const meJid = getCurrentMeJid();
+        const meLid = getCurrentMeLid();
+        if (meJid || meLid) {
+            return;
+        }
+        throw new Error(`${context} requires registered identity`);
+    };
+    const publishProtocolMessageToDevice = async (deviceJid, protocolMessage) => {
+        const plaintext = await writeRandomPadMax16(proto.Message.encode({
+            protocolMessage
+        }).finish());
+        await publishSignalMessage({
+            to: deviceJid,
+            plaintext,
+            type: 'protocol',
+            category: 'peer',
+            pushPriority: 'high'
+        });
+    };
+    const requestKeys = async (keyIds) => {
+        requireCurrentIdentity('requestKeys');
+        const normalizedKeyIds = [];
+        const seenKeyIds = new Set();
+        for (const keyId of keyIds) {
+            if (keyId.byteLength === 0) {
+                continue;
+            }
+            const keyHex = bytesToHex(keyId);
+            if (seenKeyIds.has(keyHex)) {
+                continue;
+            }
+            seenKeyIds.add(keyHex);
+            normalizedKeyIds.push(keyId);
+        }
+        if (normalizedKeyIds.length === 0) {
+            return [];
+        }
+        const peerDeviceJids = await fanoutResolver.resolveOwnPeerDeviceJids();
+        if (peerDeviceJids.length === 0) {
+            logger.warn('app-state sync key request skipped: no peer devices available', {
+                keys: normalizedKeyIds.length
+            });
+            return [];
+        }
+        const protocolMessage = {
+            type: proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_REQUEST,
+            appStateSyncKeyRequest: {
+                keyIds: normalizedKeyIds.map((keyId) => ({
+                    keyId
+                }))
+            }
+        };
+        const publishResults = await Promise.allSettled(peerDeviceJids.map((deviceJid) => publishProtocolMessageToDevice(deviceJid, protocolMessage)));
+        const failedPublishes = publishResults.filter((result) => result.status === 'rejected').length;
+        if (failedPublishes > 0) {
+            logger.warn('some app-state sync key requests failed', {
+                total: peerDeviceJids.length,
+                failed: failedPublishes
+            });
+        }
+        logger.info('app-state sync key request sent to peer devices', {
+            devices: peerDeviceJids.length,
+            keys: normalizedKeyIds.length,
+            keyIds: normalizedKeyIds.map((keyId) => bytesToHex(keyId)).join(',')
+        });
+        return peerDeviceJids;
+    };
+    const sendKeyShare = async (toDeviceJid, keys, missingKeyIds = []) => {
+        requireCurrentIdentity('sendKeyShare');
+        const normalizedTo = normalizeDeviceJid(toDeviceJid);
+        const seenKeyIds = new Set();
+        const keyShareEntries = [];
+        let sharedKeyCount = 0;
+        for (const key of keys) {
+            const keyHex = bytesToHex(key.keyId);
+            if (seenKeyIds.has(keyHex)) {
+                continue;
+            }
+            seenKeyIds.add(keyHex);
+            sharedKeyCount += 1;
+            keyShareEntries.push({
+                keyId: { keyId: key.keyId },
+                keyData: {
+                    keyData: key.keyData,
+                    timestamp: key.timestamp,
+                    ...(key.fingerprint ? { fingerprint: key.fingerprint } : {})
+                }
+            });
+        }
+        for (const keyId of missingKeyIds) {
+            if (keyId.byteLength === 0) {
+                continue;
+            }
+            const keyHex = bytesToHex(keyId);
+            if (seenKeyIds.has(keyHex)) {
+                continue;
+            }
+            seenKeyIds.add(keyHex);
+            keyShareEntries.push({
+                keyId: { keyId }
+            });
+        }
+        const protocolMessage = {
+            type: proto.Message.ProtocolMessage.Type.APP_STATE_SYNC_KEY_SHARE,
+            appStateSyncKeyShare: {
+                keys: keyShareEntries
+            }
+        };
+        await publishProtocolMessageToDevice(normalizedTo, protocolMessage);
+        logger.info('app-state sync key share sent', {
+            to: normalizedTo,
+            keys: sharedKeyCount,
+            orphanKeys: keyShareEntries.length - sharedKeyCount
+        });
+    };
+    return {
+        requestKeys,
+        sendKeyShare
+    };
+}

package/dist/esm/client/messaging/participants.js

@@ -0,0 +1,188 @@
+import { toUserJid } from '../../protocol/jid.js';
+import { toError } from '../../util/primitives.js';
+export function createGroupParticipantsCache(options) {
+    const { participantsStore, queryGroupParticipantJids, logger } = options;
+    const sanitizeParticipantUsers = (participants) => {
+        const deduped = new Set();
+        for (const participant of participants) {
+            if (!participant || !participant.includes('@')) {
+                continue;
+            }
+            try {
+                deduped.add(toUserJid(participant));
+            }
+            catch (error) {
+                logger.trace('ignoring malformed participant jid', {
+                    participant,
+                    message: toError(error).message
+                });
+            }
+        }
+        return [...deduped];
+    };
+    const areParticipantListsEqual = (left, right) => {
+        if (left.length !== right.length) {
+            return false;
+        }
+        for (let index = 0; index < left.length; index += 1) {
+            if (left[index] !== right[index]) {
+                return false;
+            }
+        }
+        return true;
+    };
+    const mergeParticipantUsersIntoCache = async (groupJid, cachedParticipants, participantsToAdd) => {
+        if (participantsToAdd.length === 0) {
+            return;
+        }
+        const nextParticipants = [...cachedParticipants];
+        const existing = new Set(cachedParticipants);
+        for (const participant of participantsToAdd) {
+            if (existing.has(participant)) {
+                continue;
+            }
+            existing.add(participant);
+            nextParticipants.push(participant);
+        }
+        if (nextParticipants.length === cachedParticipants.length) {
+            return;
+        }
+        await participantsStore.upsertGroupParticipants({
+            groupJid,
+            participants: nextParticipants,
+            updatedAtMs: Date.now()
+        });
+    };
+    const removeParticipantUsersFromCache = async (groupJid, cachedParticipants, participantsToRemove) => {
+        if (participantsToRemove.length === 0) {
+            return;
+        }
+        const removed = new Set(participantsToRemove);
+        const nextParticipants = cachedParticipants.filter((participant) => !removed.has(participant));
+        if (nextParticipants.length === cachedParticipants.length) {
+            return;
+        }
+        if (nextParticipants.length === 0) {
+            await participantsStore.deleteGroupParticipants(groupJid);
+            return;
+        }
+        await participantsStore.upsertGroupParticipants({
+            groupJid,
+            participants: nextParticipants,
+            updatedAtMs: Date.now()
+        });
+    };
+    const replaceParticipantUsersInCache = async (groupJid, cachedParticipants, participantsToReplace, replacementParticipants) => {
+        const toReplace = new Set(participantsToReplace);
+        const nextParticipants = cachedParticipants.filter((participant) => !toReplace.has(participant));
+        const existing = new Set(nextParticipants);
+        for (const participant of replacementParticipants) {
+            if (existing.has(participant)) {
+                continue;
+            }
+            existing.add(participant);
+            nextParticipants.push(participant);
+        }
+        if (areParticipantListsEqual(cachedParticipants, nextParticipants)) {
+            return;
+        }
+        if (nextParticipants.length === 0) {
+            await participantsStore.deleteGroupParticipants(groupJid);
+            return;
+        }
+        await participantsStore.upsertGroupParticipants({
+            groupJid,
+            participants: nextParticipants,
+            updatedAtMs: Date.now()
+        });
+    };
+    const resolveGroupJidForParticipantCacheEvent = (event) => {
+        if (event.action === 'linked_group_promote' || event.action === 'linked_group_demote') {
+            return event.contextGroupJid ?? event.groupJid ?? null;
+        }
+        return event.groupJid ?? null;
+    };
+    const extractParticipantUsersFromGroupEvent = (event) => {
+        const candidates = [];
+        for (const participant of event.participants ?? []) {
+            if (participant.jid) {
+                candidates.push(participant.jid);
+            }
+            if (participant.lidJid) {
+                candidates.push(participant.lidJid);
+            }
+            if (participant.phoneJid) {
+                candidates.push(participant.phoneJid);
+            }
+        }
+        return sanitizeParticipantUsers(candidates);
+    };
+    const refreshParticipantUsers = async (groupJid) => {
+        const queried = await queryGroupParticipantJids(groupJid);
+        const participants = sanitizeParticipantUsers(queried);
+        await participantsStore.upsertGroupParticipants({
+            groupJid,
+            participants,
+            updatedAtMs: Date.now()
+        });
+        return participants;
+    };
+    const resolveParticipantUsers = async (groupJid) => {
+        const cached = await participantsStore.getGroupParticipants(groupJid);
+        if (cached && cached.participants.length > 0) {
+            return sanitizeParticipantUsers(cached.participants);
+        }
+        return refreshParticipantUsers(groupJid);
+    };
+    const mutateFromGroupEvent = async (event) => {
+        const groupJid = resolveGroupJidForParticipantCacheEvent(event);
+        if (!groupJid) {
+            return;
+        }
+        if (event.action === 'delete') {
+            await participantsStore.deleteGroupParticipants(groupJid);
+            return;
+        }
+        const participantUsers = extractParticipantUsersFromGroupEvent(event);
+        if (event.action === 'create') {
+            if (participantUsers.length === 0) {
+                return;
+            }
+            await participantsStore.upsertGroupParticipants({
+                groupJid,
+                participants: participantUsers,
+                updatedAtMs: Date.now()
+            });
+            return;
+        }
+        const cached = await participantsStore.getGroupParticipants(groupJid);
+        if (!cached || cached.participants.length === 0) {
+            return;
+        }
+        const cachedParticipants = sanitizeParticipantUsers(cached.participants);
+        if (cachedParticipants.length === 0) {
+            return;
+        }
+        if (event.action === 'add' ||
+            event.action === 'promote' ||
+            event.action === 'demote' ||
+            event.action === 'linked_group_promote' ||
+            event.action === 'linked_group_demote') {
+            await mergeParticipantUsersIntoCache(groupJid, cachedParticipants, participantUsers);
+            return;
+        }
+        if (event.action === 'remove') {
+            await removeParticipantUsersFromCache(groupJid, cachedParticipants, participantUsers);
+            return;
+        }
+        if (event.action === 'modify') {
+            const authorUsers = event.authorJid ? sanitizeParticipantUsers([event.authorJid]) : [];
+            await replaceParticipantUsersInCache(groupJid, cachedParticipants, authorUsers, participantUsers);
+        }
+    };
+    return {
+        resolveParticipantUsers,
+        refreshParticipantUsers,
+        mutateFromGroupEvent
+    };
+}

package/dist/esm/crypto/core/hkdf.js

@@ -1,22 +1,17 @@
 import { webcrypto } from 'node:crypto';
 import { EMPTY_BYTES, TEXT_ENCODER, toBytesView } from '../../util/bytes.js';
-/**
- * HKDF key derivation using SHA-256
- */
 export async function hkdf(ikm, salt, info, outLength) {
     const key = await webcrypto.subtle.importKey('raw', ikm, 'HKDF', false, ['deriveBits']);
+    const infoBytes = typeof info === 'string' ? (info === '' ? EMPTY_BYTES : TEXT_ENCODER.encode(info)) : info;
     const bits = await webcrypto.subtle.deriveBits({
         name: 'HKDF',
         hash: 'SHA-256',
         salt: salt ?? EMPTY_BYTES,
-        info: typeof info === 'string' ? TEXT_ENCODER.encode(info) : info
+        info: infoBytes
     }, key, outLength * 8);
     return toBytesView(bits);
 }
-/**
- * HKDF key derivation that outputs two 32-byte keys
- */
 export async function hkdfSplit(ikm, salt, info) {
     const out = await hkdf(ikm, salt, info, 64);
-    return [out.subarray(0, 32), out.subarray(32, 64)];
+    return [out.subarray(0, 32), out.subarray(32)];
 }

package/dist/esm/crypto/core/index.js

@@ -3,7 +3,6 @@
  */
 export { Ed25519 } from '../curves/Ed25519.js';
 export { X25519 } from '../curves/X25519.js';
-export { decodeBase64Url, assert32 } from '../core/encoding.js';
 export { hkdf, hkdfSplit } from '../core/hkdf.js';
 export { toSerializedPubKey, toRawPubKey, prependVersion, readVersionedContent } from '../core/keys.js';
 export { buildNonce } from '../core/nonce.js';