@celestial-community/baileys 0.0.1-security → 1.0.0

package/lib/Socket/username.d.ts

@@ -0,0 +1,185 @@
+import { SocketConfig } from '../Types'
+import { BinaryNode } from '../WABinary'
+
+export declare const makeUsernameSocket: (config: SocketConfig) => {
+    checkUsername: (username: string, includeSuggestions?: boolean) => Promise<{
+        available: boolean
+        username: string
+        suggestions?: string[]
+        rejectionReasons?: string[]
+        suggestionsEligible?: boolean
+    }>
+    checkUsernameMulti: (usernames: string[]) => Promise<any>
+    setUsername: (username: string, options?: {
+        source?: 'FB' | 'IG' | 'USER_INPUT' | 'SUGGESTION'
+        sessionId?: string
+        pin?: string
+    }) => Promise<any>
+    deleteUsername: () => Promise<any>
+    getMyUsername: () => Promise<string | null>
+    getUsernameRecommendations: (source?: string | null) => Promise<any>
+    setUsernamePin: (pin: string | null) => Promise<any>
+    findUserByUsername: (username: string, pin?: string) => Promise<{
+        jid: string
+        contact: boolean
+    } | null>
+    fetchContactUsernames: (...jids: string[]) => Promise<{
+        id: string
+        username: string | null
+    }[]>
+    USERNAME_QUERY_IDS: {
+        CHECK: string
+        CHECK_MULTI: string
+        SET: string
+        GET: string
+        GET_RECOMMENDATIONS: string
+        PIN_SET: string
+    }
+    USERNAME_CHECK_RESULT: {
+        SUCCESS: string
+        INVALID: string
+    }
+    USERNAME_SOURCE: {
+        FB: string
+        IG: string
+        USER_INPUT: string
+        SUGGESTION: string
+    }
+    subscribeNewsletterUpdates: (jid: string) => Promise<{
+        duration: string
+    }>
+    newsletterReactionMode: (jid: string, mode: import("../Types").NewsletterReactionMode) => Promise<void>
+    newsletterUpdateDescription: (jid: string, description?: string | undefined) => Promise<void>
+    newsletterUpdateName: (jid: string, name: string) => Promise<void>
+    newsletterUpdatePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<void>
+    newsletterRemovePicture: (jid: string) => Promise<void>
+    newsletterUnfollow: (jid: string) => Promise<void>
+    newsletterFollow: (jid: string) => Promise<void>
+    newsletterUnmute: (jid: string) => Promise<void>
+    newsletterMute: (jid: string) => Promise<void>
+    newsletterCreate: (name: string, description?: string, picture?: import("../Types").WAMediaUpload) => Promise<import("../Types").NewsletterMetadata>
+    newsletterQuery: (jid: string, type: string, content: BinaryNode) => Promise<BinaryNode>
+    newsletterWMexQuery: (jid?: string | undefined, query_id: number, content: BinaryNode) => Promise<BinaryNode>
+    newsletterMetadata: (type: "invite" | "jid", key: string, role?: import("../Types").NewsletterViewRole | undefined) => Promise<import("../Types").NewsletterMetadata>
+    newsletterFetchAllParticipating: () => Promise<{
+        [_: string]: import("../Types").NewsletterMetadata
+    }>
+    newsletterAdminCount: (jid: string) => Promise<number>
+    newsletterChangeOwner: (jid: string, userLid: string) => Promise<void>
+    newsletterDemote: (jid: string, userLid: string) => Promise<void>
+    newsletterDelete: (jid: string) => Promise<void>
+    newsletterReactMessage: (jid: string, server_id: string, code?: string | undefined) => Promise<void>
+    newsletterFetchMessages: (type: "invite" | "jid", key: string, count: number, after?: number | undefined) => Promise<import("../Types").NewsletterFetchedUpdate[]>
+    newsletterFetchUpdates: (jid: string, count: number, after?: number | undefined, since?: number | undefined) => Promise<import("../Types").NewsletterFetchedUpdate[]>
+    groupQuery: (jid: string, type: string, content: BinaryNode) => Promise<BinaryNode>
+    groupMetadata: (jid: string) => Promise<import("../Types").GroupMetadata>
+    groupCreate: (subject: string, participants: string[]) => Promise<import("../Types").GroupMetadata>
+    groupLeave: (id: string) => Promise<void>
+    groupUpdateSubject: (jid: string, subject: string) => Promise<void>
+    groupRequestParticipantsList: (jid: string) => Promise<{
+        [key: string]: string
+    }[]>
+    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: "reject" | "approve") => Promise<{
+        status: string
+        jid: string
+    }[]>
+    groupParticipantsUpdate: (jid: string, participants: string[], action: import("../Types").ParticipantAction) => Promise<{
+        status: string
+        jid: string
+        content: BinaryNode
+    }[]>
+    groupUpdateDescription: (jid: string, description?: string | undefined) => Promise<void>
+    groupInviteCode: (jid: string) => Promise<string | undefined>
+    groupRevokeInvite: (jid: string) => Promise<string | undefined>
+    groupAcceptInvite: (code: string) => Promise<string | undefined>
+    groupRevokeInviteV4: (groupJid: string, invitedJid: string) => Promise<boolean>
+    groupAcceptInviteV4: (key: string | import("../Types").WAMessageKey, inviteMessage: import("../Types").WAProto.Message.IGroupInviteMessage) => Promise<string>
+    groupGetInviteInfo: (code: string) => Promise<import("../Types").GroupMetadata>
+    groupToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>
+    groupSettingUpdate: (jid: string, setting: "announcement" | "locked" | "not_announcement" | "unlocked") => Promise<void>
+    groupMemberAddMode: (jid: string, mode: "all_member_add" | "admin_add") => Promise<void>
+    groupJoinApprovalMode: (jid: string, mode: "on" | "off") => Promise<void>
+    groupFetchAllParticipating: () => Promise<{
+        [_: string]: import("../Types").GroupMetadata
+    }>
+    processingMutex: {
+        mutex<T>(code: () => T | Promise<T>): Promise<T>
+    }
+    fetchPrivacySettings: (force?: boolean) => Promise<{
+        [_: string]: string
+    }>
+    upsertMessage: (msg: import("../Types").WAProto.IWebMessageInfo, type: import("../Types").MessageUpsertType) => Promise<void>
+    appPatch: (patchCreate: import("../Types").WAPatchCreate) => Promise<void>
+    createCallLink: (type: 'audio' | 'video', event?: number, timeoutMs?: number) => Promise<void>
+    sendPresenceUpdate: (type: import("../Types").WAPresence, toJid?: string | undefined, options?: { simulateTyping?: boolean; typingDuration?: number }) => Promise<void>
+    presenceSubscribe: (toJid: string, tcToken?: Buffer | undefined) => Promise<void>
+    getBotListV2: () => Promise<any>
+    getLidUser: (jid: string) => Promise<{
+        lid: string
+        id: string
+    }[] | undefined>
+    fetchBlocklist: () => Promise<string[]>
+    fetchDisappearingDuration: (...jids: string[]) => Promise<import("../index").USyncQueryResultList[] | undefined>
+    fetchStatus: (...jids: string[]) => Promise<import("../index").USyncQueryResultList[] | undefined>
+    updateProfilePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<void>
+    removeProfilePicture: (jid: string) => Promise<void>
+    updateProfileStatus: (status: string) => Promise<void>
+    updateProfileName: (name: string) => Promise<void>
+    updateBlockStatus: (jid: string, action: "block" | "unblock") => Promise<void>
+    updateCallPrivacy: (value: import("../Types").WAPrivacyCallValue) => Promise<void>
+    updateLastSeenPrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>
+    updateOnlinePrivacy: (value: import("../Types").WAPrivacyOnlineValue) => Promise<void>
+    updateProfilePicturePrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>
+    updateStatusPrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>
+    updateReadReceiptsPrivacy: (value: import("../Types").WAReadReceiptsValue) => Promise<void>
+    updateGroupsAddPrivacy: (value: import("../Types").WAPrivacyGroupAddValue) => Promise<void>
+    updateDefaultDisappearingMode: (duration: number) => Promise<void>
+    updateDisableLinkPreviewsPrivacy: (isPreviewsDisabled: boolean) => Promise<void>
+    getBusinessProfile: (jid: string) => Promise<void | import("../Types").WABusinessProfile>
+    resyncAppState: (collections: readonly ("critical_block" | "critical_unblock_low" | "regular_high" | "regular_low" | "regular")[], isInitialSync: boolean) => Promise<void>
+    chatModify: (mod: import("../Types").ChatModification, jid: string) => Promise<void>
+    cleanDirtyBits: (type: "account_sync" | "groups", fromTimestamp?: string | number | undefined) => Promise<void>
+    addChatLabel: (jid: string, labelId: string) => Promise<void>
+    removeChatLabel: (jid: string, labelId: string) => Promise<void>
+    addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>
+    removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>
+    clearMessage: (jid: string, key: import("../Types").WAProto.IMessageKey, timeStamp: number | import("long").Long) => Promise<void>
+    star: (jid: string, messages: {
+        id: string
+        fromMe?: boolean | undefined
+    }[], star: boolean) => Promise<void>
+    addOrEditQuickReply: (quickReply: import("../Types/Bussines").QuickReplyAction) => Promise<void>
+    removeQuickReply: (timestamp: string) => Promise<void>
+    addOrEditContact: (jid: string, contact: import("../Types").ContactAction) => Promise<void>
+    removeContact: (jid: string) => Promise<void>
+    executeUSyncQuery: (usyncQuery: import("../index").USyncQuery) => Promise<import("../index").USyncQueryResult | undefined>
+    type: "md"
+    ws: any
+    ev: import("../Types").BaileysEventEmitter & {
+        process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void
+        buffer(): void
+        createBufferedFunction<A extends any[], T_1>(work: (...args: A) => Promise<T_1>): (...args: A) => Promise<T_1>
+        flush(force?: boolean | undefined): boolean
+        isBuffering(): boolean
+    }
+    authState: {
+        creds: import("../Types").AuthenticationCreds
+        keys: import("../Types").SignalKeyStoreWithTransaction
+    }
+    signalRepository: import("../Types").SignalRepository
+    user: import("../Types").Contact | undefined
+    generateMessageTag: () => string
+    query: (node: BinaryNode, timeoutMs?: number | undefined) => Promise<BinaryNode>
+    waitForMessage: <T_2>(msgId: string, timeoutMs?: number | undefined) => Promise<T_2>
+    waitForSocketOpen: () => Promise<void>
+    sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>
+    sendNode: (frame: BinaryNode) => Promise<void>
+    logout: (msg?: string | undefined) => Promise<void>
+    end: (error: Error | undefined) => void
+    onUnexpectedError: (err: Error | import("@hapi/boom").Boom<any>, msg: string) => void
+    uploadPreKeys: (count?: number) => Promise<void>
+    uploadPreKeysToServerIfRequired: () => Promise<void>
+    requestPairingCode: (phoneNumber: string, code?: string) => Promise<string>
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number | undefined) => Promise<void>
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<BinaryNode>
+}

package/lib/Socket/username.js

@@ -0,0 +1,168 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.makeUsernameSocket = void 0
+
+const { executeWMexQuery } = require('./mex')
+const { USyncQuery, USyncUser } = require('../WAUSync')
+const { makeCommunitiesSocket } = require('./community')
+
+const USERNAME_QUERY_IDS = {
+    CHECK: '26124072630599520', // UsernameCheck
+    CHECK_MULTI: '27134626522840290', // UsernameCheckMulti
+    SET: '27108705368767936', // UsernameSet
+    GET: '32618050064506056', // UsernameGet
+    GET_RECOMMENDATIONS: '26077456248616956', // UsernameGetRecommendationsQuery
+    PIN_SET: '25529696019976770' // UsernamePinSet
+}
+
+const USERNAME_CHECK_RESULT = {
+    SUCCESS: 'SUCCESS',
+    INVALID: 'INVALID'
+}
+
+const USERNAME_SOURCE = {
+    FB: 'FB',
+    IG: 'IG',
+    USER_INPUT: 'USER_INPUT',
+    SUGGESTION: 'SUGGESTION'
+}
+
+const makeUsernameSocket = (config) => {
+    const sock = makeCommunitiesSocket(config)
+    const { query, generateMessageTag, executeUSyncQuery } = sock
+
+    const mexQuery = (variables, queryId, dataPath) =>
+        executeWMexQuery(variables, queryId, dataPath, query, generateMessageTag)
+
+    const checkUsername = async (username, includeSuggestions = true) => {
+        if (!USERNAME_QUERY_IDS.CHECK) {
+            throw new Error(
+                'Username CHECK query_id not configured — capture a live WA session to obtain it'
+            )
+        }
+        const data = await mexQuery(
+            { username, include_suggestions: includeSuggestions },
+            USERNAME_QUERY_IDS.CHECK,
+            'xwa2_username_check'
+        )
+        if (data?.result === USERNAME_CHECK_RESULT.SUCCESS) {
+            return { available: true, username }
+        }
+        return {
+            available: false,
+            username,
+            suggestions: data?.suggestions ?? [],
+            rejectionReasons: data?.rejection_reasons ?? [],
+            suggestionsEligible: data?.suggestions_eligible ?? true
+        }
+    }
+
+    const setUsername = async (username, options = {}) => {
+        if (!USERNAME_QUERY_IDS.SET) {
+            throw new Error(
+                'Username SET query_id not configured — capture a live WA session to obtain it'
+            )
+        }
+        const { source = USERNAME_SOURCE.USER_INPUT, sessionId, pin } = options
+        const variables = {
+            username,
+            reserved: false,
+            source,
+            ...(sessionId ? { session_id: sessionId } : {}),
+            ...(pin ? { pin } : {})
+        }
+        return mexQuery(variables, USERNAME_QUERY_IDS.SET, 'xwa2_username_set')
+    }
+
+    const deleteUsername = async () => {
+        if (!USERNAME_QUERY_IDS.SET) {
+            throw new Error(
+                'Username SET query_id not configured — capture a live WA session to obtain it'
+            )
+        }
+        return mexQuery({ username: null }, USERNAME_QUERY_IDS.SET, 'xwa2_username_delete')
+    }
+
+    const getMyUsername = async () => {
+        if (!USERNAME_QUERY_IDS.GET) {
+            throw new Error(
+                'Username GET query_id not configured — capture a live WA session to obtain it'
+            )
+        }
+        const data = await mexQuery({}, USERNAME_QUERY_IDS.GET, 'xwa2_username_get')
+        return data?.username ?? null
+    }
+
+    const setUsernamePin = async (pin) => {
+        if (!USERNAME_QUERY_IDS.PIN_SET) {
+            throw new Error(
+                'Username PIN_SET query_id not configured — capture a live WA session to obtain it'
+            )
+        }
+        return mexQuery({ pin }, USERNAME_QUERY_IDS.PIN_SET, 'xwa2_username_pin_set')
+    }
+
+    const findUserByUsername = async (username, pin) => {
+        const usyncQuery = new USyncQuery().withContactProtocol()
+        const user = new USyncUser().withUsername(username)
+        if (pin) user.withUsernameKey(pin)
+        usyncQuery.withUser(user)
+        const result = await executeUSyncQuery(usyncQuery)
+        if (!result?.list?.length) return null
+        const entry = result.list[0]
+        return {
+            jid: entry.id,
+            contact: entry.contact ?? false
+        }
+    }
+
+    const fetchContactUsernames = async (...jids) => {
+        const usyncQuery = new USyncQuery().withUsernameProtocol()
+        for (const jid of jids) {
+            usyncQuery.withUser(new USyncUser().withId(jid))
+        }
+        const result = await executeUSyncQuery(usyncQuery)
+        return result?.list ?? []
+    }
+
+    const checkUsernameMulti = async (usernames) => {
+        const data = await mexQuery(
+            { usernames },
+            USERNAME_QUERY_IDS.CHECK_MULTI,
+            'xwa2_username_check_multi'
+        )
+        return data
+    }
+
+    const getUsernameRecommendations = async (source = null) => {
+        const variables = {}
+        if (source) variables.source = source
+        return mexQuery(
+            variables,
+            USERNAME_QUERY_IDS.GET_RECOMMENDATIONS,
+            'xwa2_username_get_recommendations'
+        )
+    }
+
+    return {
+        ...sock,
+        checkUsername,
+        checkUsernameMulti,
+        setUsername,
+        deleteUsername,
+        getMyUsername,
+        getUsernameRecommendations,
+        setUsernamePin,
+        findUserByUsername,
+        fetchContactUsernames,
+        USERNAME_QUERY_IDS,
+        USERNAME_CHECK_RESULT,
+        USERNAME_SOURCE
+    }
+}
+
+exports.makeUsernameSocket = makeUsernameSocket
+module.exports = {
+    makeUsernameSocket
+}

package/lib/Socket/usync.js

@@ -0,0 +1,80 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', { value: true })
+
+const boom_1 = require('@hapi/boom')
+const WABinary_1 = require('../WABinary')
+const socket_1 = require('./socket')
+
+const makeUSyncSocket = (config) => {
+    const suki = socket_1.makeSocket(config)
+    const { generateMessageTag, query } = suki
+
+    const executeUSyncQuery = async (usyncQuery) => {
+        if (usyncQuery.protocols.length === 0) {
+            throw new boom_1.Boom('USyncQuery must have at least one protocol')
+        }
+
+        // todo: validate users, throw WARNING on no valid users
+        // variable below has only validated users
+        const validUsers = usyncQuery.users
+
+        const userNodes = validUsers.map((user) => {
+            return {
+                tag: 'user',
+                attrs: {
+                    jid: !user.phone ? user.id : undefined
+                },
+                content: usyncQuery.protocols
+                    .map((a) => a.getUserElement(user))
+                    .filter((a) => a !== null)
+            }
+        })
+
+        const listNode = {
+            tag: 'list',
+            attrs: {},
+            content: userNodes
+        }
+
+        const queryNode = {
+            tag: 'query',
+            attrs: {},
+            content: usyncQuery.protocols.map((a) => a.getQueryElement())
+        }
+
+        const iq = {
+            tag: 'iq',
+            attrs: {
+                to: WABinary_1.S_WHATSAPP_NET,
+                type: 'get',
+                xmlns: 'usync'
+            },
+            content: [
+                {
+                    tag: 'usync',
+                    attrs: {
+                        context: usyncQuery.context,
+                        mode: usyncQuery.mode,
+                        sid: generateMessageTag(),
+                        last: 'true',
+                        index: '0'
+                    },
+                    content: [queryNode, listNode]
+                }
+            ]
+        }
+
+        const result = await query(iq)
+
+        return usyncQuery.parseUSyncQueryResult(result)
+    }
+    return {
+        ...suki,
+        executeUSyncQuery
+    }
+}
+
+module.exports = {
+    makeUSyncSocket
+}

package/lib/Store/index.js

@@ -0,0 +1,14 @@
+'use strict'
+var __importDefault =
+    (this && this.__importDefault) ||
+    function (mod) {
+        return mod && mod.__esModule ? mod : { default: mod }
+    }
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.makeCacheManagerAuthState = exports.makeInMemoryStore = exports.keyed_db = void 0
+const make_cache_manager_store_1 = __importDefault(require('./make-cache-manager-store'))
+exports.makeCacheManagerAuthState = make_cache_manager_store_1.default
+const make_in_memory_store_1 = __importDefault(require('./make-in-memory-store'))
+exports.makeInMemoryStore = make_in_memory_store_1.default
+const keyed_db_1 = __importDefault(require('./keyed-db'))
+exports.keyed_db = keyed_db_1.default

package/lib/Store/keyed-db.js

@@ -0,0 +1,158 @@
+"use strict"
+Object.defineProperty(exports, "__esModule", { value: true })
+exports.keyed_db = void 0
+
+/**
+ * @file keyed-db.js
+ * @description In-memory sorted store with O(1) id lookup — keeps an
+ *   array sorted by a compare function (for ordered iteration/pagination)
+ *   plus a dict keyed by id (for instant get/update/delete). Used as a
+ *   fast alternative index for chats/contacts/messages stores.
+ * @author Denzy ZeroDay
+ */
+
+class keyed_db {
+    /**
+     * @param {(a, b) => number} compare_fn - sort comparator for the ordered array
+     * @param {(entry) => string} id_getter - extracts the unique id from an entry
+     */
+    constructor(compare_fn, id_getter) {
+        if (typeof compare_fn !== 'function' || typeof id_getter !== 'function') {
+            throw new Error('keyed_db requires compare and id_getter functions')
+        }
+        this._compare = compare_fn
+        this._id_getter = id_getter
+        this._array = []
+        this._dict = {}
+    }
+
+    get length() {
+        return this._array.length
+    }
+
+    /** Get an entry by its id — O(1) */
+    get(id) {
+        return this._dict[id]
+    }
+
+    /**
+     * Insert an entry in sorted position.
+     * mode: 'insert' (default, fails if id exists) or 'upsert'-like overwrite via other methods.
+     */
+    insert(entry, mode = 'insert') {
+        const id = this._id_getter(entry)
+        const existing = this._dict[id]
+        if (existing && mode === 'insert') return false
+
+        this._dict[id] = entry
+        let inserted = false
+        for (let i = 0; i < this._array.length; i++) {
+            const cmp = this._compare(entry, this._array[i])
+            if (cmp < 0) {
+                this._array.splice(i, 0, entry)
+                inserted = true
+                break
+            }
+        }
+        if (!inserted) this._array.push(entry)
+        return true
+    }
+
+    /** Insert only entries whose id doesn't already exist. Returns the ones actually added. */
+    insert_if_absent(...entries) {
+        const added = []
+        for (const entry of entries) {
+            if (!this._dict[this._id_getter(entry)]) {
+                this.insert(entry)
+                added.push(entry)
+            }
+        }
+        return added
+    }
+
+    /** Insert or replace entries by id. Returns the newly-added ones (not the replaced ones). */
+    upsert(...entries) {
+        const added = []
+        for (const entry of entries) {
+            const id = this._id_getter(entry)
+            if (this._dict[id]) {
+                const idx = this._array.findIndex(e => this._id_getter(e) === id)
+                if (idx >= 0) this._array[idx] = entry
+                this._dict[id] = entry
+            } else {
+                this.insert(entry)
+                added.push(entry)
+            }
+        }
+        return added
+    }
+
+    /** Mutate an existing entry in place via updater(item). Returns false if id not found. */
+    update(id, updater) {
+        const item = this._dict[id]
+        if (!item) return false
+        updater(item)
+        const idx = this._array.findIndex(e => this._id_getter(e) === id)
+        if (idx >= 0) this._array[idx] = item
+        return true
+    }
+
+    /** Object.assign a partial update onto an existing entry. Returns false if id not found. */
+    update_assign(id, update) {
+        const item = this._dict[id]
+        if (!item) return false
+        Object.assign(item, update)
+        const idx = this._array.findIndex(e => this._id_getter(e) === id)
+        if (idx >= 0) this._array[idx] = item
+        return true
+    }
+
+    /** Remove an entry by id. Returns false if id not found. */
+    delete_by_id(id) {
+        if (!this._dict[id]) return false
+        delete this._dict[id]
+        const idx = this._array.findIndex(e => this._id_getter(e) === id)
+        if (idx >= 0) this._array.splice(idx, 1)
+        return true
+    }
+
+    /** Remove all entries */
+    clear() {
+        this._array = []
+        this._dict = {}
+    }
+
+    /** Get a snapshot copy of all entries in sorted order */
+    all() {
+        return [...this._array]
+    }
+
+    /** Filter entries in place, keeping only those matching predicate. Rebuilds the id dict. */
+    filter(predicate) {
+        this._array = this._array.filter(predicate)
+        this._dict = {}
+        for (const entry of this._array) {
+            this._dict[this._id_getter(entry)] = entry
+        }
+    }
+
+    /** Number of entries currently stored */
+    count() {
+        return this._array.length
+    }
+
+    /** Serialize to a plain array for persistence */
+    to_json() {
+        return this._array
+    }
+
+    /** Restore from a plain array (clears existing entries first) */
+    from_json(array) {
+        this.clear()
+        for (const entry of array) this.insert(entry)
+    }
+}
+
+exports.keyed_db = keyed_db
+module.exports = keyed_db
+module.exports.keyed_db = keyed_db