@be-link/pos-cli-nodejs 1.0.236 → 1.0.239

package/README.md

@@ -1,6 +1,49 @@
 # pos-cli-nodejs
 正向订单服务Nodejs客户端
 
+## 旅顾归属事实查询（开发中）
+
+`AdvisorQueryService` 提供四个固定 DTO 查询方法：
+`queryAdvisorShareOrderList`、`getAdvisorShareOrderFacts`、
+`getAdvisorShareOrderFactsBatch`、`getAdvisorShareAdjustmentCreateFacts`。
+返回值不包装完整订单 Proxy；金额 `remainingFeeCent` 是小管家的“合计”
+（原单 remainFee），quantity 是剩余份数，不是差价数量或实付累计。
+
+这组方法只向 transport 提供四条准确协议路径；`createSignedAdvisorTransport` 使用显式配置的 `origin` 构造目标地址，不沿用旧 BaseService 的 SFC／CLOUD_RUN 内网选择。DS／VS 现有 `new AdvisorQueryService(transport)` 装配方式保持不变；自定义 transport 同样须根据自身固定目标解析该协议路径，不能回退到旧网络模式。
+
+这组方法与旧 `queryByUserService` 隔离。必须由受信应用装配
+`AdvisorProtectedTransport`；没有 transport 时拒绝请求，不回退到共享 inside
+Token。该接口仅定义集成边界，不证明调用方可信，也不实现签名协议。
+transport 必须按后续冻结的 POS 协议绑定调用方、旅顾身份、动作、完整请求、
+目标地址与有效期，并处理宿主错误和凭据日志脱敏。业务 body 不接受 caller、
+actor、买家身份等额外参数。VS 专用创建事实的服务端授权不能由客户端方法名代替。
+
+已提供签名 transport 与专用 `createAdvisorHttpsSender({origin, timeoutMs, maxResponseBytes})`，但尚未装配真实信任配置或接通服务端路由，因此不可据此直接联调或发布。sender仅接受固定HTTPS origin和四条准确路径，使用Node原生HTTPS、证书验证及独立连接；不使用环境代理、不跟随重定向、不自动重试，不允许自报额外headers。超时为整次调用截止时间，响应容量必须显式配置（技术容量，不是业务金额/数量上限）。HTTP失败统一脱敏；当前不透传HTTP业务错误码，以免未经验证的错误正文泄露。sender仅做Mock离线验证，未进行真实网络/代理/证书环境验收。
+
+专用sender离线检查：
+```bash
+out=$(mktemp -d /tmp/pos-sdk-sender.XXXXXX)
+tsc src/pos/modules/orderQuery/advisorHttpSender.ts --rootDir src --strict --target ES2020 --module commonjs \
+  --typeRoots /opt/homebrew/lib/node_modules/ts-node/node_modules/@types --types node --outDir "$out"
+node src/pos/modules/orderQuery/advisorHttpSender.offline.cjs "$out"
+```
+transport 返回 POS 原生 `{data,message,success?,requestId?}`，本层只解包一次；
+不接收 DS 的 code/SUCCESS envelope。方法本身不重试，依赖错误原样传播。
+集成方 transport 的重试和错误脱敏仍须单独验证。
+
+无项目依赖时可复现离线检查（不等于 Jest 或完整构建）：
+
+```bash
+out=$(mktemp -d /tmp/pos-sdk-advisor.XXXXXX)
+tsc src/pos/modules/orderQuery/advisor.ts --strict --target ES2020 --module commonjs \
+  --typeRoots /opt/homebrew/lib/node_modules/ts-node/node_modules/@types \
+  --types node --outDir "$out"
+node src/pos/modules/orderQuery/advisor.offline.cjs "$out"
+```
+
+上述 typeRoots 是本机已有 Node 类型声明的位置；其他机器应使用其已安装的声明路径。
+
+
 ## 安装
 ```
 npm install @be-link/pos-cli-nodejs

package/index.d.ts

@@ -1,3 +1,11 @@
+export { AdvisorBusinessError } from './pos/modules/orderQuery/advisorBusinessError';
+export type { AdvisorBusinessCode } from './pos/modules/orderQuery/advisorBusinessError';
+export { AdvisorQueryService } from './pos/modules/orderQuery/advisor';
+export { createAdvisorHttpsSender } from './pos/modules/orderQuery/advisorHttpSender';
+export type { AdvisorHttpSenderOptions } from './pos/modules/orderQuery/advisorHttpSender';
+export { canonicalAdvisorJson, createAdvisorRequestSigner, createAdvisorRequestVerifier, createSignedAdvisorTransport } from './pos/modules/orderQuery/advisorProtection';
+export type { AdvisorActor, AdvisorCaller, AdvisorSignedRequest, AdvisorVerifiedContext, AdvisorVerificationConfig, AdvisorAssertionSender } from './pos/modules/orderQuery/advisorProtection';
+export type { AdvisorOrderFacts, AdvisorOrderListRequest, AdvisorOrderRequest, AdvisorOrderBatchRequest, AdvisorOrderPage, AdvisorAdjustmentCreateFacts, AdvisorQueryController, AdvisorQueryMethod, AdvisorProtectedRequest, AdvisorProtectedTransport, AdvisorResponseEnvelope, } from './pos/modules/orderQuery/advisorTypes';
 import * as PosConstants from 'vitality-meta/enums/pos';
 import * as PosDto from './types';
 import BizError from './errors/BizError';

package/index.js

@@ -26,7 +26,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VenueInfoProxy = exports.ComboInfoProxy = exports.SkuInfoProxy = exports.ItemInfoProxy = exports.PosProxyFactory = exports.BizError = exports.PosDto = exports.PosConstants = exports.tongchengService = exports.orderRoomShareService = exports.orderAbnormalFollowService = exports.orderTouristMaterialService = exports.dataMigrateService = exports.orderJobService = exports.orderNoteService = exports.queryByPandoraService = exports.queryBySupplierService = exports.queryByWebService = exports.queryByUserService = exports.queryByStoreService = exports.queryByCommodityService = exports.orderFulfillService = exports.orderCoreService = void 0;
+exports.VenueInfoProxy = exports.ComboInfoProxy = exports.SkuInfoProxy = exports.ItemInfoProxy = exports.PosProxyFactory = exports.BizError = exports.PosDto = exports.PosConstants = exports.tongchengService = exports.orderRoomShareService = exports.orderAbnormalFollowService = exports.orderTouristMaterialService = exports.dataMigrateService = exports.orderJobService = exports.orderNoteService = exports.queryByPandoraService = exports.queryBySupplierService = exports.queryByWebService = exports.queryByUserService = exports.queryByStoreService = exports.queryByCommodityService = exports.orderFulfillService = exports.orderCoreService = exports.createSignedAdvisorTransport = exports.createAdvisorRequestVerifier = exports.createAdvisorRequestSigner = exports.canonicalAdvisorJson = exports.createAdvisorHttpsSender = exports.AdvisorQueryService = exports.AdvisorBusinessError = void 0;
+var advisorBusinessError_1 = require("./pos/modules/orderQuery/advisorBusinessError");
+Object.defineProperty(exports, "AdvisorBusinessError", { enumerable: true, get: function () { return advisorBusinessError_1.AdvisorBusinessError; } });
+var advisor_1 = require("./pos/modules/orderQuery/advisor");
+Object.defineProperty(exports, "AdvisorQueryService", { enumerable: true, get: function () { return advisor_1.AdvisorQueryService; } });
+var advisorHttpSender_1 = require("./pos/modules/orderQuery/advisorHttpSender");
+Object.defineProperty(exports, "createAdvisorHttpsSender", { enumerable: true, get: function () { return advisorHttpSender_1.createAdvisorHttpsSender; } });
+var advisorProtection_1 = require("./pos/modules/orderQuery/advisorProtection");
+Object.defineProperty(exports, "canonicalAdvisorJson", { enumerable: true, get: function () { return advisorProtection_1.canonicalAdvisorJson; } });
+Object.defineProperty(exports, "createAdvisorRequestSigner", { enumerable: true, get: function () { return advisorProtection_1.createAdvisorRequestSigner; } });
+Object.defineProperty(exports, "createAdvisorRequestVerifier", { enumerable: true, get: function () { return advisorProtection_1.createAdvisorRequestVerifier; } });
+Object.defineProperty(exports, "createSignedAdvisorTransport", { enumerable: true, get: function () { return advisorProtection_1.createSignedAdvisorTransport; } });
 const PosConstants = __importStar(require("vitality-meta/enums/pos"));
 exports.PosConstants = PosConstants;
 const PosDto = __importStar(require("./types"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@be-link/pos-cli-nodejs",
-  "version": "1.0.236",
+  "version": "1.0.239",
   "description": "正向订单服务Nodejs客户端",
   "main": "index.js",
   "scripts": {

package/pos/modules/orderCore/seniorConfirmationRecovery.d.ts

@@ -0,0 +1,2 @@
+export declare const SENIOR_CONFIRMATION_REQUIRED = "SENIOR_CONFIRMATION_REQUIRED";
+export declare const SENIOR_CONFIRMATION_RECOVERY_MESSAGE = "\u8BA2\u5355\u5DF2\u4ED8\u6B3E\uFF0C\u9700\u5B8C\u6210\u9AD8\u9F84\u51FA\u884C\u4EBA\u5065\u5EB7\u53CA\u514D\u8D23\u786E\u8BA4\u540E\u65B9\u53EF\u63A5\u5355\u3002\u8BF7\u5728\u8BA2\u5355\u8BE6\u60C5\u7EE7\u7EED\u786E\u8BA4\uFF1B\u5982\u65E0\u786E\u8BA4\u5165\u53E3\uFF0C\u8BF7\u66F4\u65B0\u6216\u91CD\u65B0\u6253\u5F00\u5C0F\u7A0B\u5E8F\uFF0C\u518D\u5230\u201C\u6211\u7684\u8BA2\u5355\u201D\u627E\u5230\u672C\u5355\u3002\u6682\u65F6\u65E0\u6CD5\u66F4\u65B0\u8BF7\u8054\u7CFB\u5BA2\u670D\uFF0C\u8BA2\u5355\u4FDD\u7559\u5F85\u786E\u8BA4\uFF0C\u8BF7\u52FF\u91CD\u590D\u4ED8\u6B3E\u3002";

package/pos/modules/orderCore/seniorConfirmationRecovery.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SENIOR_CONFIRMATION_RECOVERY_MESSAGE = exports.SENIOR_CONFIRMATION_REQUIRED = void 0;
+// Stable code; keep the message readable for clients that only display msg/message.
+exports.SENIOR_CONFIRMATION_REQUIRED = 'SENIOR_CONFIRMATION_REQUIRED';
+exports.SENIOR_CONFIRMATION_RECOVERY_MESSAGE = '订单已付款，需完成高龄出行人健康及免责确认后方可接单。请在订单详情继续确认；如无确认入口，请更新或重新打开小程序，再到“我的订单”找到本单。暂时无法更新请联系客服，订单保留待确认，请勿重复付款。';

package/pos/modules/orderCore/service.d.ts

@@ -1,8 +1,18 @@
-import { Service } from './types';
+import { Service, SeniorDisclaimerPreparation, SeniorConfirmationState } from './types';
 import BaseService from '../service';
 import { IPositiveOrderInvoice } from '../../../types';
 declare class OrderCoreService extends BaseService implements Service.OrderCoreController {
     protected prefixUrl: string;
+    getSeniorConfirmation(request: Service.Request.getSeniorConfirmation): Promise<SeniorConfirmationState>;
+    saveSeniorHealthDraft(request: Service.Request.saveSeniorHealthDraft): Promise<void>;
+    markSeniorConfirmationRead(request: Service.Request.markSeniorConfirmationRead): Promise<{
+        readToken: string;
+    }>;
+    acceptSeniorConfirmation(request: Service.Request.acceptSeniorConfirmation): Promise<void>;
+    prepareSeniorDisclaimer(request: Service.Request.prepareSeniorDisclaimer): Promise<SeniorDisclaimerPreparation>;
+    acceptSeniorDisclaimer(request: Service.Request.acceptSeniorDisclaimer): Promise<{
+        recordId: string;
+    }>;
     orderFulfill(request: Service.Request.orderFulfill): Promise<void>;
     updateOrderInvoice(request: IPositiveOrderInvoice): Promise<string>;
     orderCreateInvoice(request: IPositiveOrderInvoice): Promise<IPositiveOrderInvoice>;

package/pos/modules/orderCore/service.js

@@ -10,6 +10,24 @@ class OrderCoreService extends service_1.default {
         super(...arguments);
         this.prefixUrl = '/core';
     }
+    getSeniorConfirmation(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.getSeniorConfirmation), request);
+    }
+    saveSeniorHealthDraft(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.saveSeniorHealthDraft), request);
+    }
+    markSeniorConfirmationRead(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.markSeniorConfirmationRead), request);
+    }
+    acceptSeniorConfirmation(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.acceptSeniorConfirmation), request);
+    }
+    prepareSeniorDisclaimer(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.prepareSeniorDisclaimer), request);
+    }
+    acceptSeniorDisclaimer(request) {
+        return (0, http_1.callApi)(this.getApiUrl(this.acceptSeniorDisclaimer), request);
+    }
     orderFulfill(request) {
         return (0, http_1.callApi)(this.getApiUrl(this.orderFulfill), request);
     }

package/pos/modules/orderCore/types.d.ts

@@ -1,8 +1,121 @@
 import * as PosConstants from 'vitality-meta/enums/pos';
 import * as DTO from '../../../types';
 export type RescheduleSource = 'WEB' | 'BIZ_FLOW' | 'ORDER_CHANGE';
+export interface SeniorDisclaimerTourist {
+    id: string;
+    name: string;
+    age: number;
+    maskedIdCard: string;
+}
+export interface SeniorDisclaimerPreparation {
+    required: boolean;
+    accepted?: boolean;
+    recordId?: string;
+    title?: string;
+    content?: string;
+    contentHash?: string;
+    agreementVersion?: string;
+    minimumReadSeconds?: number;
+    tourists?: SeniorDisclaimerTourist[];
+    departureDate?: string;
+    itemName?: string;
+}
+export interface SeniorHealthAnswers {
+    emergencyContact: {
+        name: string;
+        relationship: string;
+        phone: string;
+        nonTraveler: boolean;
+    };
+    diseaseGroup1: string[];
+    diseaseGroup2: string[];
+    allergyDetails: string;
+    otherDetails: string;
+    recentDiscomfort: string;
+    regularMedication: string;
+    mobility: string;
+    canAdapt: string;
+}
+export interface SeniorConfirmationPerson extends SeniorDisclaimerTourist {
+    gender: string;
+    mobile: string;
+    birthday: string;
+}
+export interface SeniorHealthProgress {
+    touristId: string;
+    answers: SeniorHealthAnswers | null;
+    confirmedAt: number | null;
+    disclaimerConfirmedAt: number | null;
+    disclaimerText?: string;
+}
+export interface SeniorConfirmationState {
+    required: boolean;
+    paid: boolean;
+    completed: boolean;
+    orderId: string;
+    sessionId?: string;
+    stateLabel?: string;
+    itemName?: string;
+    departureDate?: string;
+    returnDate?: string;
+    tourists?: SeniorConfirmationPerson[];
+    healthRecords?: SeniorHealthProgress[];
+    relationships?: Record<string, string>;
+    documents?: {
+        version: string;
+        notice: string;
+        confirmationText: string;
+        healthConfirmationText: string;
+        healthText: string;
+        disclaimerText: string;
+        diseaseGroups: Array<Array<{
+            id: string;
+            label: string;
+        }>>;
+        questions: Array<{
+            key: string;
+            label: string;
+            options: Array<{
+                value: string;
+                label: string;
+            }>;
+        }>;
+    };
+}
 export declare namespace Service {
     namespace Request {
+        interface getSeniorConfirmation {
+            orderId: string;
+            unionId: string;
+        }
+        interface saveSeniorHealthDraft extends getSeniorConfirmation {
+            sessionId: string;
+            touristId: string;
+            answers: SeniorHealthAnswers;
+        }
+        interface markSeniorConfirmationRead extends getSeniorConfirmation {
+            sessionId: string;
+            kind: 'HEALTH' | 'DISCLAIMER';
+            touristId: string;
+            phase: 'START' | 'BOTTOM';
+            readToken?: string;
+            answers?: SeniorHealthAnswers;
+            relationships?: Record<string, string>;
+        }
+        interface acceptSeniorConfirmation extends getSeniorConfirmation {
+            sessionId: string;
+            kind: 'HEALTH' | 'DISCLAIMER';
+            touristId: string;
+            readToken: string;
+        }
+        interface prepareSeniorDisclaimer {
+            version: 'V1' | 'V2';
+            orderRequest: orderCreate | orderCreateV2;
+        }
+        interface acceptSeniorDisclaimer {
+            recordId: string;
+            unionId: string;
+        }
         interface createOrderInvoice {
             /** 快照:订单ID */
             tradeOrderId?: string;
@@ -33,6 +146,7 @@ export declare namespace Service {
             };
         }
         interface orderCreate {
+            seniorDisclaimerRecordId?: string;
             /** 基础信息 */
             basicInfo: {
                 /** 用户id */
@@ -126,6 +240,7 @@ export declare namespace Service {
             storeAdjustmentReason?: string;
         }
         interface orderCreateV2 {
+            seniorDisclaimerRecordId?: string;
             /** 基础信息 */
             basicInfo: {
                 /** 用户id */
@@ -534,6 +649,18 @@ export declare namespace Service {
         }[];
     }
     interface OrderCoreController {
+        getSeniorConfirmation(request: Request.getSeniorConfirmation): Promise<SeniorConfirmationState>;
+        saveSeniorHealthDraft(request: Request.saveSeniorHealthDraft): Promise<void>;
+        markSeniorConfirmationRead(request: Request.markSeniorConfirmationRead): Promise<{
+            readToken: string;
+            readText?: string;
+            documentVersion?: string;
+        }>;
+        acceptSeniorConfirmation(request: Request.acceptSeniorConfirmation): Promise<void>;
+        prepareSeniorDisclaimer(request: Request.prepareSeniorDisclaimer): Promise<SeniorDisclaimerPreparation>;
+        acceptSeniorDisclaimer(request: Request.acceptSeniorDisclaimer): Promise<{
+            recordId: string;
+        }>;
         /**
          * 订单发票修改
          * @path /core/update-order-invoice

package/pos/modules/orderQuery/advisor.d.ts

@@ -0,0 +1,14 @@
+import BaseService from '../service';
+import { AdvisorAdjustmentCreateFacts, AdvisorOrderBatchRequest, AdvisorOrderFacts, AdvisorOrderListRequest, AdvisorOrderPage, AdvisorOrderRequest, AdvisorProtectedTransport, AdvisorQueryController } from './advisorTypes';
+export declare class AdvisorQueryService extends BaseService implements AdvisorQueryController {
+    private readonly transport?;
+    protected prefixUrl: string;
+    constructor(transport?: AdvisorProtectedTransport | undefined);
+    private invoke;
+    queryAdvisorShareOrderList(request: AdvisorOrderListRequest): Promise<AdvisorOrderPage>;
+    getAdvisorShareOrderFacts(request: AdvisorOrderRequest): Promise<AdvisorOrderFacts>;
+    getAdvisorShareOrderFactsBatch(request: AdvisorOrderBatchRequest): Promise<{
+        list: AdvisorOrderFacts[];
+    }>;
+    getAdvisorShareAdjustmentCreateFacts(request: AdvisorOrderRequest): Promise<AdvisorAdjustmentCreateFacts>;
+}

package/pos/modules/orderQuery/advisor.js

@@ -0,0 +1,111 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdvisorQueryService = void 0;
+const service_1 = __importDefault(require("../service"));
+const advisorProtection_1 = require("./advisorProtection");
+function invalid() {
+    throw new Error('INVALID_ARGUMENT');
+}
+function id(value) {
+    if (typeof value !== 'string' || !value || value.trim() !== value)
+        invalid();
+}
+function body(request, allowed) {
+    if (!request || typeof request !== 'object' || Array.isArray(request))
+        invalid();
+    const result = Object.assign({}, request);
+    if (Object.keys(result).some((key) => !allowed.includes(key)))
+        invalid();
+    id(result.advisorId);
+    return result;
+}
+// Separate from queryByUserService: there is deliberately no inside-token fallback.
+class AdvisorQueryService extends service_1.default {
+    constructor(transport) {
+        super();
+        this.transport = transport;
+        this.prefixUrl = '/query/user';
+    }
+    invoke(action, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof this.transport !== 'function')
+                throw new Error('ADVISOR_PROTECTED_TRANSPORT_REQUIRED');
+            const response = yield this.transport(Object.freeze({
+                method: 'POST',
+                // The protected transport owns the configured origin, independently of legacy network mode.
+                url: advisorProtection_1.advisorActionPaths[action],
+                action,
+                body: Object.freeze(request),
+            }));
+            if (!response || typeof response !== 'object' || Array.isArray(response) ||
+                !Object.prototype.hasOwnProperty.call(response, 'data') || response.data == null || 'code' in response ||
+                typeof response.message !== 'string' ||
+                (response.success !== undefined && response.success !== true)) {
+                throw new Error('ADVISOR_RESPONSE_INVALID');
+            }
+            return response.data;
+        });
+    }
+    queryAdvisorShareOrderList(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = body(request, ['advisorId', 'statusList', 'categoryTwo', 'keyword', 'cursor', 'pageSize']);
+            if (result.statusList !== undefined) {
+                if (!Array.isArray(result.statusList) || !result.statusList.length)
+                    invalid();
+                const statuses = Array.from(result.statusList);
+                statuses.forEach(id);
+                result.statusList = Object.freeze(statuses);
+            }
+            if (result.categoryTwo !== undefined)
+                id(result.categoryTwo);
+            if (result.keyword !== undefined && typeof result.keyword !== 'string')
+                invalid();
+            if (result.cursor !== undefined)
+                id(result.cursor);
+            if (result.pageSize !== undefined &&
+                (typeof result.pageSize !== 'number' || !Number.isInteger(result.pageSize) || result.pageSize < 1 || result.pageSize > 50))
+                invalid();
+            return this.invoke('queryAdvisorShareOrderList', result);
+        });
+    }
+    getAdvisorShareOrderFacts(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = body(request, ['advisorId', 'orderId']);
+            id(result.orderId);
+            return this.invoke('getAdvisorShareOrderFacts', result);
+        });
+    }
+    getAdvisorShareOrderFactsBatch(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = body(request, ['advisorId', 'orderIds']);
+            if (!Array.isArray(result.orderIds) || !result.orderIds.length || result.orderIds.length > 50)
+                invalid();
+            const ids = Array.from(result.orderIds);
+            ids.forEach(id);
+            if (new Set(ids).size !== ids.length)
+                invalid();
+            result.orderIds = Object.freeze(ids);
+            return this.invoke('getAdvisorShareOrderFactsBatch', result);
+        });
+    }
+    getAdvisorShareAdjustmentCreateFacts(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = body(request, ['advisorId', 'orderId']);
+            id(result.orderId);
+            return this.invoke('getAdvisorShareAdjustmentCreateFacts', result);
+        });
+    }
+}
+exports.AdvisorQueryService = AdvisorQueryService;

package/pos/modules/orderQuery/advisorBusinessError.d.ts

@@ -0,0 +1,8 @@
+export declare const advisorBusinessCodes: readonly ["INVALID_ARGUMENT", "INVALID_CURSOR", "ORDER_NOT_ACCESSIBLE", "ADVISOR_FORBIDDEN"];
+export type AdvisorBusinessCode = typeof advisorBusinessCodes[number];
+export declare class AdvisorBusinessError extends Error {
+    readonly code: AdvisorBusinessCode;
+    constructor(code: AdvisorBusinessCode);
+}
+export declare function copyAdvisorBusinessError(error: unknown): AdvisorBusinessError | null;
+export declare function advisorBusinessErrorFromResponse(status: number, value: unknown): AdvisorBusinessError | null;

package/pos/modules/orderQuery/advisorBusinessError.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.advisorBusinessErrorFromResponse = exports.copyAdvisorBusinessError = exports.AdvisorBusinessError = exports.advisorBusinessCodes = void 0;
+// Preserve only the POS advisor routes' known rejection codes, never server messages.
+exports.advisorBusinessCodes = [
+    'INVALID_ARGUMENT', 'INVALID_CURSOR', 'ORDER_NOT_ACCESSIBLE', 'ADVISOR_FORBIDDEN',
+];
+const issued = new WeakMap();
+class AdvisorBusinessError extends Error {
+    constructor(code) {
+        if (!exports.advisorBusinessCodes.includes(code))
+            throw new Error('ADVISOR_BUSINESS_CODE_INVALID');
+        super(code);
+        this.code = code;
+        issued.set(this, code);
+        Object.freeze(this);
+    }
+}
+exports.AdvisorBusinessError = AdvisorBusinessError;
+// The WeakMap rejects prototype/shape impersonation and ignores caller-added fields.
+function copyAdvisorBusinessError(error) {
+    const code = error && typeof error === 'object' ? issued.get(error) : undefined;
+    return code ? new AdvisorBusinessError(code) : null;
+}
+exports.copyAdvisorBusinessError = copyAdvisorBusinessError;
+function advisorBusinessErrorFromResponse(status, value) {
+    if (!Number.isInteger(status) || status < 400 || status >= 500 || !value ||
+        typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const body = value;
+    if (!Object.prototype.hasOwnProperty.call(body, 'data') || body.data !== null ||
+        typeof body.message !== 'string' || (body.success !== undefined && body.success !== false) ||
+        typeof body.code !== 'string' || !exports.advisorBusinessCodes.includes(body.code))
+        return null;
+    return new AdvisorBusinessError(body.code);
+}
+exports.advisorBusinessErrorFromResponse = advisorBusinessErrorFromResponse;

package/pos/modules/orderQuery/advisorHttpSender.d.ts

@@ -0,0 +1,7 @@
+import { AdvisorAssertionSender } from './advisorProtection';
+export type AdvisorHttpSenderOptions = {
+    origin: string;
+    timeoutMs: number;
+    maxResponseBytes: number;
+};
+export declare function createAdvisorHttpsSender(options: AdvisorHttpSenderOptions): AdvisorAssertionSender;

package/pos/modules/orderQuery/advisorHttpSender.js

@@ -0,0 +1,138 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAdvisorHttpsSender = void 0;
+const https_1 = require("https");
+const advisorProtection_1 = require("./advisorProtection");
+const advisorBusinessError_1 = require("./advisorBusinessError");
+function failed() { return new Error('ADVISOR_HTTP_REQUEST_FAILED'); }
+// Native HTTPS ignores HTTP(S)_PROXY environment variables and does not follow redirects.
+// A dedicated connection avoids process-global agents/interceptors and implicit retry plugins.
+function createAdvisorHttpsSender(options) {
+    if (!options || typeof options.origin !== 'string' ||
+        !Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 1 || options.timeoutMs > 2147483647 ||
+        !Number.isSafeInteger(options.maxResponseBytes) || options.maxResponseBytes < 1) {
+        throw new Error('ADVISOR_HTTP_CONFIG_REQUIRED');
+    }
+    let endpoint;
+    try {
+        endpoint = new URL(options.origin);
+    }
+    catch (_a) {
+        throw new Error('ADVISOR_HTTP_CONFIG_REQUIRED');
+    }
+    if (endpoint.protocol !== 'https:' || endpoint.username || endpoint.password ||
+        endpoint.search || endpoint.hash || endpoint.pathname !== '/')
+        throw new Error('ADVISOR_HTTP_CONFIG_REQUIRED');
+    const origin = endpoint.origin;
+    const { timeoutMs, maxResponseBytes } = options;
+    const paths = Object.values(advisorProtection_1.advisorActionPaths);
+    return (input) => __awaiter(this, void 0, void 0, function* () {
+        let url;
+        let body;
+        let assertion;
+        try {
+            url = new URL(input.url);
+            if (input.method !== 'POST' || url.protocol !== 'https:' || url.origin !== origin ||
+                url.username || url.password || url.search || url.hash || !paths.includes(url.pathname) ||
+                !input.headers || Object.keys(input.headers).length !== 1 ||
+                typeof input.headers['x-advisor-assertion'] !== 'string' ||
+                !input.headers['x-advisor-assertion'] || /[\r\n]/.test(input.headers['x-advisor-assertion']))
+                throw failed();
+            assertion = input.headers['x-advisor-assertion'];
+            body = (0, advisorProtection_1.canonicalAdvisorJson)(input.body);
+        }
+        catch (_b) {
+            throw failed();
+        }
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            let timer;
+            const finish = (error, value) => {
+                var _a;
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                if (error)
+                    reject((_a = (0, advisorBusinessError_1.copyAdvisorBusinessError)(error)) !== null && _a !== void 0 ? _a : failed());
+                else
+                    resolve(value);
+            };
+            try {
+                const req = (0, https_1.request)(url, {
+                    method: 'POST', agent: false, rejectUnauthorized: true,
+                    headers: { 'Content-Type': 'application/json', 'Accept': 'application/json',
+                        'Accept-Encoding': 'identity', 'Content-Length': Buffer.byteLength(body),
+                        'x-advisor-assertion': assertion },
+                }, (res) => {
+                    if (settled) {
+                        res.destroy();
+                        return;
+                    }
+                    const status = res.statusCode;
+                    const type = res.headers['content-type'];
+                    if (typeof status !== 'number' || !((status >= 200 && status < 300) || (status >= 400 && status < 500)) ||
+                        typeof type !== 'string' || !/^application\/json(?:\s*;|$)/i.test(type) ||
+                        (res.headers['content-encoding'] && res.headers['content-encoding'] !== 'identity')) {
+                        finish(failed());
+                        res.destroy();
+                        return;
+                    }
+                    const chunks = [];
+                    let size = 0;
+                    res.on('error', () => finish(failed()));
+                    res.on('aborted', () => finish(failed()));
+                    res.on('data', (chunk) => {
+                        if (settled)
+                            return;
+                        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                        size += bytes.length;
+                        if (size > maxResponseBytes) {
+                            finish(failed());
+                            res.destroy();
+                            return;
+                        }
+                        chunks.push(bytes);
+                    });
+                    res.on('end', () => {
+                        var _a;
+                        if (settled)
+                            return;
+                        try {
+                            const value = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+                            if (status >= 400) {
+                                finish((_a = (0, advisorBusinessError_1.advisorBusinessErrorFromResponse)(status, value)) !== null && _a !== void 0 ? _a : failed());
+                                return;
+                            }
+                            if (!value || typeof value !== 'object' || Array.isArray(value) ||
+                                typeof value.message !== 'string' || value.data == null || 'code' in value ||
+                                (value.success !== undefined && value.success !== true))
+                                throw failed();
+                            finish(undefined, value);
+                        }
+                        catch (_b) {
+                            finish(failed());
+                        }
+                    });
+                });
+                req.on('error', () => finish(failed()));
+                timer = setTimeout(() => { finish(failed()); req.destroy(); }, timeoutMs);
+                req.end(body);
+            }
+            catch (_a) {
+                finish(failed());
+            }
+        });
+    });
+}
+exports.createAdvisorHttpsSender = createAdvisorHttpsSender;