@oxidezap/baileyrs 0.2.12 → 0.3.0

package/lib/Compatibility/encode-proto.d.ts

@@ -1,12 +1,16 @@
 /**
- * `encodeProto`, with the two inputs the bridge codec stopped accepting put back.
+ * `encodeProto`, with the three inputs the bridge codec refuses put back.
  *
  * From 0.8.0 the codec refuses an empty string where the schema declares a
  * 64-bit integer, and an unpaired surrogate in a text field. Both were written
  * before — as `0` and as U+FFFD — and upstream Baileys still encodes both, so a
  * message that used to reach the server would now throw in the caller's face.
- * This is where that is absorbed, so the strict contract stays true of the
- * bridge and the tolerant one stays true of this library.
+ * The codec also refuses enum names where the schema declares an enum
+ * (issue #109: `"NONE"` where an int32 goes on the wire), which upstream's
+ * `fromObject` resolves and its direct `encode` coerces — that repair lives in
+ * `repairProtoMessage`, next to the other two. This is where all three are
+ * absorbed, so the strict contract stays true of the bridge and the tolerant
+ * one stays true of this library.
  *
  * Repair on failure rather than check on write: the ordinary encode is exactly
  * the call it was before, with no scan of any field, and the repair runs only

package/lib/Compatibility/encode-proto.js

@@ -1,14 +1,18 @@
 import { encodeProto } from '@oxidezap/whatsapp-rust-bridge';
 import { repairProtoMessage } from './proto-runtime.js';
 /**
- * `encodeProto`, with the two inputs the bridge codec stopped accepting put back.
+ * `encodeProto`, with the three inputs the bridge codec refuses put back.
  *
  * From 0.8.0 the codec refuses an empty string where the schema declares a
  * 64-bit integer, and an unpaired surrogate in a text field. Both were written
  * before — as `0` and as U+FFFD — and upstream Baileys still encodes both, so a
  * message that used to reach the server would now throw in the caller's face.
- * This is where that is absorbed, so the strict contract stays true of the
- * bridge and the tolerant one stays true of this library.
+ * The codec also refuses enum names where the schema declares an enum
+ * (issue #109: `"NONE"` where an int32 goes on the wire), which upstream's
+ * `fromObject` resolves and its direct `encode` coerces — that repair lives in
+ * `repairProtoMessage`, next to the other two. This is where all three are
+ * absorbed, so the strict contract stays true of the bridge and the tolerant
+ * one stays true of this library.
  *
  * Repair on failure rather than check on write: the ordinary encode is exactly
  * the call it was before, with no scan of any field, and the repair runs only
@@ -22,8 +26,9 @@ export const encodeProtoCompat = (path, message) => {
     catch (error) {
         const repaired = repairProtoMessage(path, message);
         // Reference equality: nothing was coerced, so the failure is something this
-        // does not explain — an unmodelled type, a number no int64 can hold — and
-        // it has to keep propagating rather than be retried into a second throw.
+        // does not explain — an unmodelled type, a number no int64 can hold, an
+        // unknown enum name — and it has to keep propagating rather than be
+        // retried into a second throw.
         if (repaired === message)
             throw error;
         return encodeProto(path, repaired);

package/lib/Compatibility/proto-runtime.js

@@ -53,7 +53,7 @@ const UNPAIRED_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBF
 /**
  * Puts back what the codec used to do with an input it now refuses.
  *
- * Two cases, both measured against upstream Baileys, which still encodes both:
+ * Three cases, all measured against upstream Baileys, which still encodes them:
  *
  * - An empty string where the schema declares a 64-bit integer. Every one of the
  *   134 send-path failures this addresses carried exactly `''`; a string that is
@@ -62,6 +62,13 @@ const UNPAIRED_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBF
  * - An unpaired surrogate in a text field, replaced with U+FFFD. That is the
  *   substitution `TextEncoder` used to make, so the bytes are unchanged from what
  *   this library sent before.
+ * - An enum name where the schema declares an enum (issue #109: `"NONE"` where
+ *   an int32 goes on the wire). Upstream's `fromObject` resolves names to numbers
+ *   and its direct `encode` coerces any string with `| 0`, so a caller passing a
+ *   name never sees a throw. The bridge codec accepts only numbers (numeric
+ *   strings aside) and throws `invalid int32: "NONE"`. An unknown name is left to
+ *   throw rather than silenced to `0`: upstream's direct encode would write `0`
+ *   for it, but that puts a value on the wire nobody sent.
  *
  * Returns `item` itself when it has nothing to do, so the caller can tell a
  * repair from a failure it does not understand.
@@ -77,6 +84,36 @@ const repairScalar = (kind, item) => {
     const replaced = item.replace(UNPAIRED_SURROGATE, '\uFFFD');
     return replaced === item ? item : replaced;
 };
+/**
+ * Enum name to wire number, built per enum on the first repair that needs it.
+ *
+ * Only the repair path reads this, and only for a field that actually holds a
+ * string — a message the codec accepts never reaches here, and a numeric enum
+ * never touches a map. Each table is built once from the generated entries and
+ * then reused; an importer that never sends a refused value allocates nothing.
+ * A `Map` (not a plain object) so names like `__proto__` are keys, not hazards.
+ */
+let enumTablesById;
+const enumValueFor = (enumId, name) => {
+    if (enumId < 0 || enumId >= PROTO_ENUM_SCHEMAS.length)
+        return undefined;
+    enumTablesById ?? (enumTablesById = []);
+    let byName = enumTablesById[enumId];
+    if (byName === undefined) {
+        const entries = PROTO_ENUM_SCHEMAS[enumId]?.[1];
+        if (!entries)
+            return undefined;
+        byName = new Map();
+        for (let index = 0; index < entries.length; index += 2) {
+            const entryName = entries[index];
+            const entryValue = entries[index + 1];
+            if (typeof entryName === 'string' && typeof entryValue === 'number')
+                byName.set(entryName, entryValue);
+        }
+        enumTablesById[enumId] = byName;
+    }
+    return byName.get(name);
+};
 const longFromWords = (low, high, unsigned) => LongRuntime.fromBits(low, high, unsigned);
 /**
  * Split a decoded 64-bit value into the low/high words `longFromWords` takes.
@@ -254,12 +291,13 @@ const schemaIdFor = (path) => {
     return schemaIdsByPath.get(path);
 };
 /**
- * Coerces the two inputs the bridge codec stopped accepting back to what it
- * used to write, and returns `value` itself when there was nothing to coerce.
+ * Coerces the three inputs the bridge codec refuses back to what upstream
+ * Baileys writes, and returns `value` itself when there was nothing to coerce.
  *
  * Reference equality is the signal: the caller only reaches here after an
  * encode threw, and an unchanged result means the failure was something else
- * — a genuinely invalid number, a missing codec — which must keep propagating.
+ * — a genuinely invalid number, an unknown enum name, a missing codec — which
+ * must keep propagating.
  *
  * Copy-on-write throughout, like `projectForEncode`: a branch with nothing to
  * fix is shared, not rebuilt.
@@ -286,7 +324,16 @@ const repairMessage = (schemaId, value, ancestors) => {
         const current = value[field[0]];
         if (current === null || current === undefined)
             continue;
-        const repair = (item) => field[1] === PROTO_FIELD_KIND.message ? repairMessage(field[2], item, seen) : repairScalar(field[1], item);
+        const repair = (item) => {
+            if (field[1] === PROTO_FIELD_KIND.message)
+                return repairMessage(field[2], item, seen);
+            // `?? item`, not `|| item`: 0 is a valid wire value (e.g. `"NONE"`).
+            // Unknown names stay strings, so the retry still throws and the
+            // original failure keeps propagating instead of becoming a silent 0.
+            if (field[1] === PROTO_FIELD_KIND.enum && typeof item === 'string')
+                return enumValueFor(field[2], item) ?? item;
+            return repairScalar(field[1], item);
+        };
         let converted = current;
         if (field[3] & PROTO_FIELD_FLAG.repeated) {
             if (Array.isArray(current)) {
@@ -457,8 +504,8 @@ class ProtoCompatibilityRuntime {
                 throw new Error(`protobuf codec unavailable for ${path}`);
             const projected = this.projectForEncode(schemaId, message);
             const encoded = sourceCodec.encode(projected);
-            // The bridge refuses two inputs it used to accept silently, and upstream
-            // Baileys still encodes both. Repairing on failure rather than checking
+            // The bridge refuses three inputs it used to accept silently, and upstream
+            // Baileys still encodes all three. Repairing on failure rather than checking
             // every field on the way in is what keeps the ordinary encode free: a
             // message the codec accepts never reaches the repair, and one that does
             // not was already going to throw.

package/lib/Compatibility/signal-repository.d.ts

@@ -1,7 +1,7 @@
 import type { LIDMapping, SignalAuthState, SignalRepositoryWithLIDStore } from '../Types/index.js';
 import type { ILogger } from '../Utils/logger.js';
 import type { SocketContext } from '../Socket/types.js';
-type SignalRepositoryContext = Pick<SocketContext, 'getClient' | 'logger'>;
+type SignalRepositoryContext = Pick<SocketContext, 'logger' | 'withClient'>;
 export declare const jidToSignalProtocolAddressCompat: (jid: string) => string;
 export declare const bindSignalRepositoryContext: (auth: SignalAuthState, ctx: SignalRepositoryContext) => void;
 /** Default public factory; the socket binds its native context before invoking it. */

package/lib/Compatibility/signal-repository.js

@@ -34,12 +34,12 @@ export const bindSignalRepositoryContext = (auth, ctx) => {
 /** Default public factory; the socket binds its native context before invoking it. */
 export const makeDefaultSignalRepository = (auth, logger, _pnToLIDFunc) => makeSignalRepository({
     logger,
-    getClient: () => {
+    withClient: operation => {
         const ctx = nativeContexts.get(auth);
         if (!ctx) {
             return Promise.reject(new Error('Signal repository is not bound to an active socket; pass it through SocketConfig'));
         }
-        return ctx.getClient();
+        return ctx.withClient(operation);
     }
 });
 const resolveMappings = async (client, inputs, direction, ctx) => {
@@ -69,63 +69,67 @@ const resolveMappings = async (client, inputs, direction, ctx) => {
     return mappings.length ? mappings : null;
 };
 /** Translate the neutral bridge Signal surface into the public repository contract. */
-export const makeSignalRepository = (ctx) => ({
-    decryptMessage: async (opts) => (await ctx.getClient()).signalDecryptMessage(opts.jid, opts.type, opts.ciphertext),
-    encryptMessage: async (opts) => (await ctx.getClient()).signalEncryptMessage(opts.jid, opts.data),
-    decryptGroupMessage: async (opts) => (await ctx.getClient()).signalDecryptGroupMessage(opts.group, opts.authorJid, opts.msg),
-    encryptGroupMessage: async (opts) => (await ctx.getClient()).signalEncryptGroupMessage(opts.group, opts.data, opts.meId),
-    processSenderKeyDistributionMessage: async ({ item, authorJid }) => {
-        if (!item.groupId) {
-            throw new Error('Group ID is required for sender key distribution message');
-        }
-        const distribution = item.axolotlSenderKeyDistributionMessage;
-        if (!distribution) {
-            throw new Error('Sender key distribution payload is required');
-        }
-        await (await ctx.getClient()).signalProcessSenderKeyDistribution(item.groupId, authorJid, distribution);
-    },
-    getSenderKeyDistributionMessage: async ({ group, meId }) => (await ctx.getClient()).signalGetSenderKeyDistribution(group, meId),
-    hasSenderKey: async ({ group, meId }) => (await ctx.getClient()).signalHasSenderKey(group, meId),
-    getSessionInfo: async (jid) => (await (await ctx.getClient()).signalGetSessionInfo(jid)) ?? null,
-    injectE2ESession: async ({ jid, session }) => {
-        await (await ctx.getClient()).signalInstallPreKeyBundle(jid, session);
-    },
-    validateSession: async (jid) => ({ exists: await (await ctx.getClient()).signalValidateSession(jid) }),
-    jidToSignalProtocolAddress: jidToSignalProtocolAddressCompat,
-    migrateSession: async (fromJid, toJid) => {
-        if (!fromJid || !isLidNamespace(toJid))
-            return { migrated: 0, skipped: 0, total: 0 };
-        if (!isPnNamespace(fromJid))
-            return { migrated: 0, skipped: 0, total: 1 };
-        return (await ctx.getClient()).signalMigrateSessions(fromJid, toJid);
-    },
-    deleteSession: async (jids) => {
-        if (jids.length)
-            await (await ctx.getClient()).signalDeleteSessions(jids);
-    },
-    lidMapping: {
-        storeLIDPNMappings: async (pairs) => {
-            const valid = pairs.filter(({ lid, pn }) => {
-                const accepted = isLidNamespace(lid) && isPnNamespace(pn);
-                if (!accepted)
-                    ctx.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
-                return accepted;
-            });
-            if (valid.length)
-                await (await ctx.getClient()).addLidPnMappings(valid);
+export const makeSignalRepository = (ctx) => {
+    return {
+        decryptMessage: async (opts) => ctx.withClient(client => client.signalDecryptMessage(opts.jid, opts.type, opts.ciphertext)),
+        encryptMessage: async (opts) => ctx.withClient(client => client.signalEncryptMessage(opts.jid, opts.data)),
+        decryptGroupMessage: async (opts) => ctx.withClient(client => client.signalDecryptGroupMessage(opts.group, opts.authorJid, opts.msg)),
+        encryptGroupMessage: async (opts) => ctx.withClient(client => client.signalEncryptGroupMessage(opts.group, opts.data, opts.meId)),
+        processSenderKeyDistributionMessage: async ({ item, authorJid }) => {
+            if (!item.groupId) {
+                throw new Error('Group ID is required for sender key distribution message');
+            }
+            const distribution = item.axolotlSenderKeyDistributionMessage;
+            if (!distribution) {
+                throw new Error('Sender key distribution payload is required');
+            }
+            await ctx.withClient(client => client.signalProcessSenderKeyDistribution(item.groupId, authorJid, distribution));
+        },
+        getSenderKeyDistributionMessage: async ({ group, meId }) => ctx.withClient(client => client.signalGetSenderKeyDistribution(group, meId)),
+        hasSenderKey: async ({ group, meId }) => ctx.withClient(client => client.signalHasSenderKey(group, meId)),
+        getSessionInfo: async (jid) => (await ctx.withClient(client => client.signalGetSessionInfo(jid))) ?? null,
+        injectE2ESession: async ({ jid, session }) => {
+            await ctx.withClient(client => client.signalInstallPreKeyBundle(jid, session));
         },
-        getLIDForPN: async (pn) => {
-            const client = await ctx.getClient();
-            return (await resolveMappings(client, [pn], 'pn-to-lid', ctx))?.[0]?.lid ?? null;
+        validateSession: async (jid) => ({ exists: await ctx.withClient(client => client.signalValidateSession(jid)) }),
+        jidToSignalProtocolAddress: jidToSignalProtocolAddressCompat,
+        migrateSession: async (fromJid, toJid) => {
+            if (!fromJid || !isLidNamespace(toJid))
+                return { migrated: 0, skipped: 0, total: 0 };
+            if (!isPnNamespace(fromJid))
+                return { migrated: 0, skipped: 0, total: 1 };
+            return ctx.withClient(client => client.signalMigrateSessions(fromJid, toJid));
         },
-        getLIDsForPNs: async (pns) => resolveMappings(await ctx.getClient(), pns, 'pn-to-lid', ctx),
-        getPNForLID: async (lid) => {
-            const client = await ctx.getClient();
-            return (await resolveMappings(client, [lid], 'lid-to-pn', ctx))?.[0]?.pn ?? null;
+        deleteSession: async (jids) => {
+            if (jids.length)
+                await ctx.withClient(client => client.signalDeleteSessions(jids));
+        },
+        lidMapping: {
+            storeLIDPNMappings: async (pairs) => {
+                const valid = pairs.filter(({ lid, pn }) => {
+                    const accepted = isLidNamespace(lid) && isPnNamespace(pn);
+                    if (!accepted)
+                        ctx.logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`);
+                    return accepted;
+                });
+                if (valid.length)
+                    await ctx.withClient(client => client.addLidPnMappings(valid));
+            },
+            getLIDForPN: async (pn) => {
+                return ctx.withClient(async (client) => {
+                    return (await resolveMappings(client, [pn], 'pn-to-lid', ctx))?.[0]?.lid ?? null;
+                });
+            },
+            getLIDsForPNs: async (pns) => ctx.withClient(client => resolveMappings(client, pns, 'pn-to-lid', ctx)),
+            getPNForLID: async (lid) => {
+                return ctx.withClient(async (client) => {
+                    return (await resolveMappings(client, [lid], 'lid-to-pn', ctx))?.[0]?.pn ?? null;
+                });
+            },
+            getPNsForLIDs: async (lids) => ctx.withClient(client => resolveMappings(client, lids, 'lid-to-pn', ctx)),
+            close: () => undefined
         },
-        getPNsForLIDs: async (lids) => resolveMappings(await ctx.getClient(), lids, 'lid-to-pn', ctx),
         close: () => undefined
-    },
-    close: () => undefined
-});
+    };
+};
 //# sourceMappingURL=signal-repository.js.map

package/lib/Compatibility/stanza-responses.d.ts

@@ -1,11 +1,11 @@
 import type { WasmWhatsAppClient } from '@oxidezap/whatsapp-rust-bridge';
 import type { BinaryNode } from '../Types/index.js';
+import type { ClientOperations } from '../Socket/client-operations.js';
 type StanzaResponseClient = Pick<WasmWhatsAppClient, 'acknowledgeStanza' | 'rejectStanza' | 'requestMessageRetry'>;
-export interface StanzaResponseContext {
-    getClient: () => Promise<StanzaResponseClient>;
+export interface StanzaResponseContext extends ClientOperations<StanzaResponseClient> {
 }
 /** Translate the public socket calls into the core-owned response operations. */
-export declare const makeStanzaResponseMethods: ({ getClient }: StanzaResponseContext) => {
+export declare const makeStanzaResponseMethods: (ctx: StanzaResponseContext) => {
     sendMessageAck: (node: BinaryNode, errorCode?: number) => Promise<void>;
     sendRetryRequest: (node: BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
 };

package/lib/Compatibility/stanza-responses.js

@@ -1,16 +1,19 @@
 /** Translate the public socket calls into the core-owned response operations. */
-export const makeStanzaResponseMethods = ({ getClient }) => ({
-    sendMessageAck: async (node, errorCode) => {
-        const client = await getClient();
-        if (errorCode) {
-            await client.rejectStanza(node, errorCode);
+export const makeStanzaResponseMethods = (ctx) => {
+    return {
+        sendMessageAck: async (node, errorCode) => {
+            return ctx.withClient(async (client) => {
+                if (errorCode) {
+                    await client.rejectStanza(node, errorCode);
+                }
+                else {
+                    await client.acknowledgeStanza(node);
+                }
+            });
+        },
+        sendRetryRequest: async (node, forceIncludeKeys = false) => {
+            await ctx.withClient(client => client.requestMessageRetry(node, forceIncludeKeys));
         }
-        else {
-            await client.acknowledgeStanza(node);
-        }
-    },
-    sendRetryRequest: async (node, forceIncludeKeys = false) => {
-        await (await getClient()).requestMessageRetry(node, forceIncludeKeys);
-    }
-});
+    };
+};
 //# sourceMappingURL=stanza-responses.js.map

package/lib/Socket/blocking.js

@@ -1,13 +1,15 @@
 import { bridgeBlocklistToBaileys } from '../Compatibility/socket-results.js';
 import { assertArgumentDomain } from '../Utils/argument-domain.js';
 export const BLOCK_ACTIONS = ['block', 'unblock'];
-export const makeBlockingMethods = (ctx) => ({
-    updateBlockStatus: async (jid, action) => {
-        assertArgumentDomain('updateBlockStatus', 'action', action, BLOCK_ACTIONS);
-        await (await ctx.getClient()).updateBlockStatus(jid, action);
-    },
-    fetchBlocklist: async () => {
-        return bridgeBlocklistToBaileys(await (await ctx.getClient()).fetchBlocklist());
-    }
-});
+export const makeBlockingMethods = (ctx) => {
+    return {
+        updateBlockStatus: async (jid, action) => {
+            assertArgumentDomain('updateBlockStatus', 'action', action, BLOCK_ACTIONS);
+            await ctx.withClient(client => client.updateBlockStatus(jid, action));
+        },
+        fetchBlocklist: async () => {
+            return bridgeBlocklistToBaileys(await ctx.withClient(client => client.fetchBlocklist()));
+        }
+    };
+};
 //# sourceMappingURL=blocking.js.map

package/lib/Socket/bridge-error-boundary.d.ts

@@ -21,8 +21,8 @@
  *  - Anything that is not the bridge's shape (an `Error` carrying a string
  *    `kind`) passes through with the same identity it arrived with.
  *
- * The wrap happens once per client: `getClient()`/`getClientSync()` hand out
- * a `Proxy` whose method wrappers are built on first access and cached, so
+ * The private `getClient()` getter returns a cached `Proxy` for each client.
+ * Its method wrappers are built on first access and cached, so
  * the happy path pays one property trap and one extra promise layer, and the
  * error path pays for everything else.
  */

package/lib/Socket/bridge-error-boundary.js

@@ -21,8 +21,8 @@
  *  - Anything that is not the bridge's shape (an `Error` carrying a string
  *    `kind`) passes through with the same identity it arrived with.
  *
- * The wrap happens once per client: `getClient()`/`getClientSync()` hand out
- * a `Proxy` whose method wrappers are built on first access and cached, so
+ * The private `getClient()` getter returns a cached `Proxy` for each client.
+ * Its method wrappers are built on first access and cached, so
  * the happy path pays one property trap and one extra promise layer, and the
  * error path pays for everything else.
  */

package/lib/Socket/business.js

@@ -39,66 +39,68 @@ const catalogSubject = (method, ctx, jid) => {
     }
     return subject;
 };
-export const makeBusinessMethods = (ctx) => ({
-    getCatalog: async ({ jid, limit, cursor }) => {
-        const subject = catalogSubject('getCatalog', ctx, jid);
-        return await (await ctx.getClient()).getCatalog(subject, { limit, after: cursor });
-    },
-    getCollections: async (jid, limit) => {
-        const subject = catalogSubject('getCollections', ctx, jid);
-        return await (await ctx.getClient()).getCollections(subject, { collectionLimit: limit });
-    },
-    /**
-     * `sellerJid` is not in upstream's signature because upstream reads orders
-     * over the legacy `fb:thrift_iq` route, which addresses the server. The
-     * route the real client uses is a MEX query keyed by the seller, so the JID
-     * is required here. It is on the order message the token came from.
-     */
-    getOrderDetails: async (orderId, tokenBase64, sellerJid) => {
-        if (!sellerJid) {
-            throw new Boom('getOrderDetails: a third argument with the seller jid is required, because orders are read through a query keyed by the business rather than the legacy server-addressed one', { statusCode: 400 });
-        }
-        return await (await ctx.getClient()).getOrder(sellerJid, orderId, tokenBase64);
-    },
-    updateBussinesProfile: async (args) => {
-        const update = {
-            address: args.address,
-            description: args.description,
-            email: args.email,
-            websites: args.websites,
-            ...(args.hours !== undefined
-                ? {
-                    businessHours: {
-                        timezone: args.hours.timezone,
-                        // Minutes past midnight as a number; upstream types the two
-                        // as strings and the core rejects them on the other modes.
-                        config: args.hours.days.map(day => ({
-                            dayOfWeek: day.day,
-                            mode: day.mode,
-                            openTime: day.mode === 'specific_hours' ? minutesPastMidnight(day.openTimeInMinutes, 'open') : undefined,
-                            closeTime: day.mode === 'specific_hours' ? minutesPastMidnight(day.closeTimeInMinutes, 'close') : undefined
-                        }))
+export const makeBusinessMethods = (ctx) => {
+    return {
+        getCatalog: async ({ jid, limit, cursor }) => {
+            const subject = catalogSubject('getCatalog', ctx, jid);
+            return await ctx.withClient(client => client.getCatalog(subject, { limit, after: cursor }));
+        },
+        getCollections: async (jid, limit) => {
+            const subject = catalogSubject('getCollections', ctx, jid);
+            return await ctx.withClient(client => client.getCollections(subject, { collectionLimit: limit }));
+        },
+        /**
+         * `sellerJid` is not in upstream's signature because upstream reads orders
+         * over the legacy `fb:thrift_iq` route, which addresses the server. The
+         * route the real client uses is a MEX query keyed by the seller, so the JID
+         * is required here. It is on the order message the token came from.
+         */
+        getOrderDetails: async (orderId, tokenBase64, sellerJid) => {
+            if (!sellerJid) {
+                throw new Boom('getOrderDetails: a third argument with the seller jid is required, because orders are read through a query keyed by the business rather than the legacy server-addressed one', { statusCode: 400 });
+            }
+            return await ctx.withClient(client => client.getOrder(sellerJid, orderId, tokenBase64));
+        },
+        updateBussinesProfile: async (args) => {
+            const update = {
+                address: args.address,
+                description: args.description,
+                email: args.email,
+                websites: args.websites,
+                ...(args.hours !== undefined
+                    ? {
+                        businessHours: {
+                            timezone: args.hours.timezone,
+                            // Minutes past midnight as a number; upstream types the two
+                            // as strings and the core rejects them on the other modes.
+                            config: args.hours.days.map(day => ({
+                                dayOfWeek: day.day,
+                                mode: day.mode,
+                                openTime: day.mode === 'specific_hours' ? minutesPastMidnight(day.openTimeInMinutes, 'open') : undefined,
+                                closeTime: day.mode === 'specific_hours' ? minutesPastMidnight(day.closeTimeInMinutes, 'close') : undefined
+                            }))
+                        }
                     }
-                }
-                : {})
-        };
-        await (await ctx.getClient()).updateBusinessProfile(update);
-    },
-    /**
-     * Declared but not callable end to end. The core and the bridge take the
-     * `{fbid, meta_hmac, ts}` receipt of a cover photo upload, and this
-     * package's upload path cannot produce one: it requires a url and a
-     * direct path, which that endpoint does not return.
-     */
-    updateCoverPhoto: async (photo) => {
-        void photo;
-        throw new Boom('updateCoverPhoto is not available yet: the cover photo upload returns an {fbid, meta_hmac, ts} receipt that this package cannot obtain. removeCoverPhoto works.', { statusCode: 501 });
-    },
-    removeCoverPhoto: async (id) => {
-        await (await ctx.getClient()).removeBusinessCoverPhoto(id);
-    },
-    productCreate: async (create) => noProductWriteRoute('productCreate', create),
-    productUpdate: async (productId, update) => noProductWriteRoute('productUpdate', productId, update),
-    productDelete: async (productIds) => noProductWriteRoute('productDelete', productIds)
-});
+                    : {})
+            };
+            await ctx.withClient(client => client.updateBusinessProfile(update));
+        },
+        /**
+         * Declared but not callable end to end. The core and the bridge take the
+         * `{fbid, meta_hmac, ts}` receipt of a cover photo upload, and this
+         * package's upload path cannot produce one: it requires a url and a
+         * direct path, which that endpoint does not return.
+         */
+        updateCoverPhoto: async (photo) => {
+            void photo;
+            throw new Boom('updateCoverPhoto is not available yet: the cover photo upload returns an {fbid, meta_hmac, ts} receipt that this package cannot obtain. removeCoverPhoto works.', { statusCode: 501 });
+        },
+        removeCoverPhoto: async (id) => {
+            await ctx.withClient(client => client.removeBusinessCoverPhoto(id));
+        },
+        productCreate: async (create) => noProductWriteRoute('productCreate', create),
+        productUpdate: async (productId, update) => noProductWriteRoute('productUpdate', productId, update),
+        productDelete: async (productIds) => noProductWriteRoute('productDelete', productIds)
+    };
+};
 //# sourceMappingURL=business.js.map