@dimina-kit/devtools 0.4.0 → 0.5.0-dev.20260908120530

package/dist/shared/appdata-accumulator.d.ts

@@ -1,95 +0,0 @@
-/**
- * Framework-agnostic AppData accumulator.
- *
- * The dimina runtime emits two service→render messages relevant to the AppData
- * panel, identical in shape on BOTH container paths:
- *   • update batches `{type:'ub', body:{bridgeId, updates:[{moduleId,data}]}}`
- *     — each `data` is a partial setData patch.
- *   • instance init: `type === 'page_*'`, body `{bridgeId, path, data}` with the
- *     COMPLETE initial state.
- *
- * Default (dimina-fe) path: the simulator preload sniffs these as Worker
- * `message` events (app-data.ts). Native-host path: they flow service→render
- * through bridge-router (SERVICE_PUBLISH). Both feed this one accumulator so the
- * decode/merge/page-only/init-gate policy can't drift between modes.
- */
-/**
- * The AppData snapshot — the full, cumulative panel state.
- *
- * - `bridges` lists every page bridge in chronological (insertion) order, each
- *   carrying its page route (`pagePath`), so renderer tabs render in a stable
- *   sequence.
- * - `entries` maps `bridgeId → (componentPath | moduleId) → setData state`.
- */
-export interface AppDataSnapshot {
-    bridges: Array<{
-        id: string;
-        pagePath: string | null;
-    }>;
-    entries: Record<string, Record<string, unknown>>;
-}
-export type DecodedEntry = {
-    mode: 'patch';
-    bridgeId: string;
-    moduleId: string;
-    data: unknown;
-} | {
-    mode: 'init';
-    bridgeId: string;
-    moduleId: string;
-    componentPath: string;
-    data: Record<string, unknown>;
-};
-/** Normalized input to the accumulator (built from a DecodedEntry or the hook). */
-export interface AppDataInput {
-    bridgeId?: string;
-    moduleId?: string;
-    componentPath?: string;
-    data?: unknown;
-    mode?: 'init' | 'patch';
-}
-/**
- * Decode a service→render message into AppData entries, or null when it is not
- * AppData-relevant. Policy: surface PAGE entries only — component entries are
- * dropped (they sometimes flow on a bridge id distinct from their owning page's
- * and never receive pageUnload, which would manifest as ghost tabs).
- */
-export declare function decodeWorkerMessage(message: unknown): DecodedEntry[] | null;
-/** main→worker direction: container signals page teardown so cache can evict. */
-export declare function decodeOutgoingMessage(message: unknown): {
-    type: string;
-    bridgeId?: string;
-} | null;
-/** Convert a decoded entry to the normalized accumulator input. */
-export declare function decodedToInput(entry: DecodedEntry): AppDataInput;
-/**
- * Cumulative per-(bridgeId, moduleId) setData state. Pure data structure — no
- * Worker / IPC / DOM. Callers own transport (publish/emit) and the automation
- * mirror.
- */
-export declare class AppDataAccumulator {
-    private readonly cache;
-    private readonly bridgeOrder;
-    private readonly bridgePagePath;
-    private recordBridge;
-    /**
-     * Apply one entry. Returns true if it was accepted (a mutation worth
-     * republishing), false if dropped (missing ids, or the init-gate).
-     */
-    apply(input: AppDataInput): boolean;
-    /** Evict every entry for a bridge (page teardown). */
-    clearBridge(bridgeId: string): void;
-    /** The full cumulative snapshot for the panel. */
-    snapshot(): AppDataSnapshot;
-    /**
-     * The current reactive page state for a bridge: shallow-merge of `entry.data`
-     * across every cache entry whose key starts with `${bridgeId}/`, in insertion
-     * order (later entries win on key conflicts). `{}` when no entries match
-     * (unknown bridge / after clearBridge). Pure, no side effects.
-     */
-    pageData(bridgeId: string): Record<string, unknown>;
-    /** Flat `key → data` map for the `__simulatorData.getAppdata()` mirror. */
-    flat(): Record<string, unknown>;
-    clear(): void;
-}
-//# sourceMappingURL=appdata-accumulator.d.ts.map

package/dist/shared/appdata-accumulator.js

@@ -1,218 +0,0 @@
-/**
- * Framework-agnostic AppData accumulator.
- *
- * The dimina runtime emits two service→render messages relevant to the AppData
- * panel, identical in shape on BOTH container paths:
- *   • update batches `{type:'ub', body:{bridgeId, updates:[{moduleId,data}]}}`
- *     — each `data` is a partial setData patch.
- *   • instance init: `type === 'page_*'`, body `{bridgeId, path, data}` with the
- *     COMPLETE initial state.
- *
- * Default (dimina-fe) path: the simulator preload sniffs these as Worker
- * `message` events (app-data.ts). Native-host path: they flow service→render
- * through bridge-router (SERVICE_PUBLISH). Both feed this one accumulator so the
- * decode/merge/page-only/init-gate policy can't drift between modes.
- */
-/** Parse a service/worker message payload; a non-string is passed through as-is. */
-function parseMessagePayload(message) {
-    if (typeof message !== 'string')
-        return message;
-    try {
-        return JSON.parse(message);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Decode a `ub` (update batch) body into patch entries, PAGE modules only —
- * component-module updates are dropped (see `decodeWorkerMessage`).
- */
-function decodeUpdateBatchBody(rawBody) {
-    const body = rawBody;
-    if (!body || typeof body !== 'object')
-        return null;
-    if (typeof body.bridgeId !== 'string' || !Array.isArray(body.updates))
-        return null;
-    const out = [];
-    for (const u of body.updates) {
-        if (!u || typeof u.moduleId !== 'string')
-            continue;
-        if (!u.moduleId.startsWith('page_'))
-            continue;
-        out.push({ mode: 'patch', bridgeId: body.bridgeId, moduleId: u.moduleId, data: u.data });
-    }
-    return out.length > 0 ? out : null;
-}
-/** Decode a `page_*` instance-init body into its single init entry. */
-function decodePageInitBody(moduleId, rawBody) {
-    const body = rawBody;
-    if (!body || typeof body !== 'object')
-        return null;
-    if (typeof body.bridgeId !== 'string' || typeof body.path !== 'string')
-        return null;
-    if (!body.data || typeof body.data !== 'object')
-        return null;
-    return [{
-            mode: 'init',
-            bridgeId: body.bridgeId,
-            moduleId,
-            componentPath: body.path,
-            data: body.data,
-        }];
-}
-/**
- * Decode a service→render message into AppData entries, or null when it is not
- * AppData-relevant. Policy: surface PAGE entries only — component entries are
- * dropped (they sometimes flow on a bridge id distinct from their owning page's
- * and never receive pageUnload, which would manifest as ghost tabs).
- */
-export function decodeWorkerMessage(message) {
-    const payload = parseMessagePayload(message);
-    if (!payload || typeof payload !== 'object')
-        return null;
-    const record = payload;
-    if (record.type === 'ub')
-        return decodeUpdateBatchBody(record.body);
-    if (typeof record.type === 'string' && record.type.startsWith('page_')) {
-        return decodePageInitBody(record.type, record.body);
-    }
-    return null;
-}
-/** main→worker direction: container signals page teardown so cache can evict. */
-export function decodeOutgoingMessage(message) {
-    const payload = parseMessagePayload(message);
-    if (!payload || typeof payload !== 'object')
-        return null;
-    const r = payload;
-    if (typeof r.type !== 'string')
-        return null;
-    return {
-        type: r.type,
-        bridgeId: typeof r.body?.bridgeId === 'string' ? r.body.bridgeId : undefined,
-    };
-}
-/** Convert a decoded entry to the normalized accumulator input. */
-export function decodedToInput(entry) {
-    const input = {
-        bridgeId: entry.bridgeId,
-        moduleId: entry.moduleId,
-        data: entry.data,
-        mode: entry.mode,
-    };
-    if (entry.mode === 'init')
-        input.componentPath = entry.componentPath;
-    return input;
-}
-/**
- * Cumulative per-(bridgeId, moduleId) setData state. Pure data structure — no
- * Worker / IPC / DOM. Callers own transport (publish/emit) and the automation
- * mirror.
- */
-export class AppDataAccumulator {
-    cache = new Map();
-    // Bridges in insertion order — drives the `bridges` array (stable tab order).
-    bridgeOrder = [];
-    // Page path per bridge: set from `page_*` init's body.path (the page route).
-    bridgePagePath = new Map();
-    recordBridge(bridgeId) {
-        if (!this.bridgeOrder.includes(bridgeId))
-            this.bridgeOrder.push(bridgeId);
-    }
-    /**
-     * Apply one entry. Returns true if it was accepted (a mutation worth
-     * republishing), false if dropped (missing ids, or the init-gate).
-     */
-    apply(input) {
-        if (!input.bridgeId || !input.moduleId)
-            return false;
-        // Drop ub patches whose bridge has never been initialised. dimina
-        // dispatches pageUnload → onUnload, whose setData produces a late `ub`
-        // arriving AFTER clearBridge; without this gate it would resurrect the
-        // unloaded bridge as a ghost tab.
-        if (input.mode !== 'init' && !this.bridgePagePath.has(input.bridgeId))
-            return false;
-        const key = `${input.bridgeId}/${input.moduleId}`;
-        const prev = this.cache.get(key);
-        const incoming = input.data && typeof input.data === 'object'
-            ? input.data
-            : {};
-        // init = full-state replace; patch = merge into previous (setData semantics)
-        const merged = input.mode === 'init'
-            ? { ...incoming }
-            : { ...(prev?.data ?? {}), ...incoming };
-        const componentPath = input.componentPath ?? prev?.componentPath;
-        const next = componentPath !== undefined
-            ? { componentPath, data: merged }
-            : { data: merged };
-        this.cache.set(key, next);
-        this.recordBridge(input.bridgeId);
-        if (input.mode === 'init' && input.moduleId.startsWith('page_') && input.componentPath) {
-            this.bridgePagePath.set(input.bridgeId, input.componentPath);
-        }
-        return true;
-    }
-    /** Evict every entry for a bridge (page teardown). */
-    clearBridge(bridgeId) {
-        const prefix = `${bridgeId}/`;
-        for (const key of [...this.cache.keys()]) {
-            if (key.startsWith(prefix))
-                this.cache.delete(key);
-        }
-        const idx = this.bridgeOrder.indexOf(bridgeId);
-        if (idx >= 0)
-            this.bridgeOrder.splice(idx, 1);
-        this.bridgePagePath.delete(bridgeId);
-    }
-    /** The full cumulative snapshot for the panel. */
-    snapshot() {
-        const bridges = [];
-        for (const id of this.bridgeOrder) {
-            bridges.push({ id, pagePath: this.bridgePagePath.get(id) ?? null });
-        }
-        const entries = {};
-        for (const [key, entry] of this.cache) {
-            const slash = key.indexOf('/');
-            if (slash < 0)
-                continue;
-            const bridgeId = key.slice(0, slash);
-            const moduleId = key.slice(slash + 1);
-            if (!entries[bridgeId])
-                entries[bridgeId] = {};
-            const displayKey = entry.componentPath ?? moduleId;
-            entries[bridgeId][displayKey] = entry.data;
-        }
-        return { bridges, entries };
-    }
-    /**
-     * The current reactive page state for a bridge: shallow-merge of `entry.data`
-     * across every cache entry whose key starts with `${bridgeId}/`, in insertion
-     * order (later entries win on key conflicts). `{}` when no entries match
-     * (unknown bridge / after clearBridge). Pure, no side effects.
-     */
-    pageData(bridgeId) {
-        const merged = {};
-        for (const [key, entry] of this.cache) {
-            const slash = key.indexOf('/');
-            if (slash < 0)
-                continue;
-            if (key.slice(0, slash) !== bridgeId)
-                continue;
-            Object.assign(merged, entry.data);
-        }
-        return merged;
-    }
-    /** Flat `key → data` map for the `__simulatorData.getAppdata()` mirror. */
-    flat() {
-        const data = {};
-        for (const [key, entry] of this.cache)
-            data[key] = entry.data;
-        return data;
-    }
-    clear() {
-        this.cache.clear();
-        this.bridgeOrder.length = 0;
-        this.bridgePagePath.clear();
-    }
-}
-//# sourceMappingURL=appdata-accumulator.js.map

package/dist/shared/request-core.d.ts

@@ -1,84 +0,0 @@
-/**
- * Single authoritative implementation of wx.request network semantics, shared
- * by every request surface (simulator `directRequest`, preload api-compat
- * `wx.request` shim). Keeping the semantics in one module is what prevents the
- * surfaces from drifting apart on the core contract.
- *
- * The contract (official wx.request semantics):
- *  - success vs fail is decided ONLY by whether a server response was
- *    received. Any HTTP response — 200, 401, 500 — resolves via `success`
- *    with `{ data, statusCode, header, errMsg: 'request:ok' }`; callers
- *    branch on `statusCode` (e.g. 401 → re-login).
- *  - `fail` fires only for network-layer failures and always carries a
- *    non-empty errMsg: 'request:fail timeout' (deadline hit),
- *    'request:fail abort' (caller aborted), 'request:fail <reason>' (DNS/
- *    connection/protocol errors).
- *  - `timeout` defaults to 60000ms (the wx default) when omitted or
- *    non-positive — a request never hangs indefinitely.
- *  - `dataType` (default 'json') controls body decoding: 'json' attempts
- *    JSON.parse with raw-text fallback; anything else keeps raw text.
- *    `responseType: 'arraybuffer'` (or the legacy `dataType: 'arraybuffer'`
- *    spelling) yields an ArrayBuffer instead.
- *  - Outgoing headers merge case-insensitively via `Headers` so a caller's
- *    `content-type` in any casing wins exactly once; the `application/json`
- *    default applies only when the caller supplied none. Plain-object merges
- *    would keep both casings as distinct keys and comma-join them on the wire.
- *  - GET/HEAD serialize object `data` into URL query params (no body);
- *    other methods send string data verbatim, form-encode objects under
- *    application/x-www-form-urlencoded, and JSON-encode otherwise.
- *  - `complete` fires exactly once, after success or fail, with that same
- *    result object.
- *
- * Not provided: `cookies` on the success result — fetch() cannot read
- * Set-Cookie response headers, so surfacing a fabricated list would lie.
- */
-export interface RequestSuccessResult {
-    data: unknown;
-    statusCode: number;
-    header: Record<string, string>;
-    errMsg: 'request:ok';
-}
-export interface RequestFailResult {
-    errMsg: string;
-    errno?: number;
-}
-export interface RequestHandle {
-    abort(): void;
-}
-export interface RequestCoreOptions {
-    url: string;
-    data?: unknown;
-    header?: Record<string, string>;
-    timeout?: number;
-    method?: string;
-    dataType?: string;
-    responseType?: string;
-}
-export interface RequestCoreCallbacks {
-    success?: (res: RequestSuccessResult) => void;
-    fail?: (err: RequestFailResult) => void;
-    complete?: (res: RequestSuccessResult | RequestFailResult) => void;
-}
-/**
- * The wx.request default timeout budget. Exported as the single source of
- * truth for every layer that reasons about a request's time budget — the
- * bridge-router watchdog (apiCallWatchdogMs in simulator-api-metadata.ts)
- * derives its window from this so the two cannot drift apart.
- */
-export declare const DEFAULT_REQUEST_TIMEOUT_MS = 60000;
-/**
- * Largest delay setTimeout honours (2^31-1 ms). Anything above overflows the
- * signed-32-bit timer register and fires ~immediately (~1ms) instead of late —
- * so an oversized caller timeout must be rejected, never passed through.
- */
-export declare const MAX_TIMEOUT_MS = 2147483647;
-/**
- * Resolve a caller-supplied wx timeout into a usable budget: a finite positive
- * number within setTimeout's range is honoured; anything else (absent, 0,
- * negative, NaN, Infinity, overflowing) falls back to the wx default. Shared
- * by performRequest and the bridge-router watchdog (apiCallWatchdogMs) so the
- * two layers can never disagree on what a valid timeout is.
- */
-export declare function resolveTimeoutBudgetMs(timeout: unknown): number;
-export declare function performRequest(opts: RequestCoreOptions, callbacks: RequestCoreCallbacks): RequestHandle;
-//# sourceMappingURL=request-core.d.ts.map

package/dist/shared/request-core.js

@@ -1,168 +0,0 @@
-/**
- * Single authoritative implementation of wx.request network semantics, shared
- * by every request surface (simulator `directRequest`, preload api-compat
- * `wx.request` shim). Keeping the semantics in one module is what prevents the
- * surfaces from drifting apart on the core contract.
- *
- * The contract (official wx.request semantics):
- *  - success vs fail is decided ONLY by whether a server response was
- *    received. Any HTTP response — 200, 401, 500 — resolves via `success`
- *    with `{ data, statusCode, header, errMsg: 'request:ok' }`; callers
- *    branch on `statusCode` (e.g. 401 → re-login).
- *  - `fail` fires only for network-layer failures and always carries a
- *    non-empty errMsg: 'request:fail timeout' (deadline hit),
- *    'request:fail abort' (caller aborted), 'request:fail <reason>' (DNS/
- *    connection/protocol errors).
- *  - `timeout` defaults to 60000ms (the wx default) when omitted or
- *    non-positive — a request never hangs indefinitely.
- *  - `dataType` (default 'json') controls body decoding: 'json' attempts
- *    JSON.parse with raw-text fallback; anything else keeps raw text.
- *    `responseType: 'arraybuffer'` (or the legacy `dataType: 'arraybuffer'`
- *    spelling) yields an ArrayBuffer instead.
- *  - Outgoing headers merge case-insensitively via `Headers` so a caller's
- *    `content-type` in any casing wins exactly once; the `application/json`
- *    default applies only when the caller supplied none. Plain-object merges
- *    would keep both casings as distinct keys and comma-join them on the wire.
- *  - GET/HEAD serialize object `data` into URL query params (no body);
- *    other methods send string data verbatim, form-encode objects under
- *    application/x-www-form-urlencoded, and JSON-encode otherwise.
- *  - `complete` fires exactly once, after success or fail, with that same
- *    result object.
- *
- * Not provided: `cookies` on the success result — fetch() cannot read
- * Set-Cookie response headers, so surfacing a fabricated list would lie.
- */
-/**
- * The wx.request default timeout budget. Exported as the single source of
- * truth for every layer that reasons about a request's time budget — the
- * bridge-router watchdog (apiCallWatchdogMs in simulator-api-metadata.ts)
- * derives its window from this so the two cannot drift apart.
- */
-export const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
-/**
- * Largest delay setTimeout honours (2^31-1 ms). Anything above overflows the
- * signed-32-bit timer register and fires ~immediately (~1ms) instead of late —
- * so an oversized caller timeout must be rejected, never passed through.
- */
-export const MAX_TIMEOUT_MS = 2_147_483_647;
-/**
- * Resolve a caller-supplied wx timeout into a usable budget: a finite positive
- * number within setTimeout's range is honoured; anything else (absent, 0,
- * negative, NaN, Infinity, overflowing) falls back to the wx default. Shared
- * by performRequest and the bridge-router watchdog (apiCallWatchdogMs) so the
- * two layers can never disagree on what a valid timeout is.
- */
-export function resolveTimeoutBudgetMs(timeout) {
-    const t = Number(timeout);
-    return Number.isFinite(t) && t > 0 && t <= MAX_TIMEOUT_MS ? t : DEFAULT_REQUEST_TIMEOUT_MS;
-}
-function buildHeaders(header) {
-    const headers = new Headers();
-    for (const [key, value] of Object.entries(header ?? {})) {
-        if (value != null)
-            headers.set(key, String(value));
-    }
-    if (!headers.has('content-type'))
-        headers.set('content-type', 'application/json');
-    return headers;
-}
-function appendQueryParams(url, data) {
-    // Resolve against the current document when available so page-relative URLs
-    // keep working in the render-window shim.
-    const base = typeof location !== 'undefined' ? location.href : undefined;
-    const resolved = new URL(url, base);
-    for (const [key, value] of Object.entries(data)) {
-        resolved.searchParams.append(key, String(value));
-    }
-    return resolved.toString();
-}
-function encodeBody(data, contentType) {
-    if (typeof data === 'string')
-        return data;
-    if (contentType.includes('application/x-www-form-urlencoded')) {
-        const form = new URLSearchParams();
-        for (const [key, value] of Object.entries(data)) {
-            form.append(key, String(value));
-        }
-        return form.toString();
-    }
-    return JSON.stringify(data);
-}
-async function decodeResponseData(response, dataType, responseType) {
-    if (responseType === 'arraybuffer' || dataType === 'arraybuffer') {
-        return response.arrayBuffer();
-    }
-    const text = await response.text();
-    if (dataType !== 'json')
-        return text;
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return text;
-    }
-}
-export function performRequest(opts, callbacks) {
-    const method = (opts.method || 'GET').toUpperCase();
-    const canHaveBody = method !== 'GET' && method !== 'HEAD';
-    const headers = buildHeaders(opts.header);
-    let url = opts.url;
-    const init = { method, headers };
-    if (!canHaveBody) {
-        if (opts.data && typeof opts.data === 'object') {
-            url = appendQueryParams(url, opts.data);
-        }
-    }
-    else if (opts.data != null) {
-        init.body = encodeBody(opts.data, headers.get('content-type') ?? '');
-    }
-    const controller = new AbortController();
-    init.signal = controller.signal;
-    // First verdict wins: a timeout/abort settles the call even though the fetch
-    // promise is still pending, and the fetch's own late resolution/AbortError
-    // rejection must not fire a second callback round.
-    let settled = false;
-    function settleSuccess(res) {
-        if (settled)
-            return;
-        settled = true;
-        clearTimeout(timer);
-        callbacks.success?.(res);
-        callbacks.complete?.(res);
-    }
-    function settleFail(err) {
-        if (settled)
-            return;
-        settled = true;
-        clearTimeout(timer);
-        callbacks.fail?.(err);
-        callbacks.complete?.(err);
-    }
-    const timeoutMs = resolveTimeoutBudgetMs(opts.timeout);
-    const timer = setTimeout(() => {
-        settleFail({ errMsg: 'request:fail timeout' });
-        controller.abort();
-    }, timeoutMs);
-    const dataType = opts.dataType ?? 'json';
-    const responseType = opts.responseType ?? 'text';
-    fetch(url, init)
-        .then(async (response) => {
-        const header = {};
-        response.headers.forEach((value, key) => {
-            header[key] = value;
-        });
-        const data = await decodeResponseData(response, dataType, responseType);
-        settleSuccess({ data, statusCode: response.status, header, errMsg: 'request:ok' });
-    })
-        .catch((error) => {
-        const reason = error instanceof Error ? error.message : String(error);
-        settleFail({ errMsg: `request:fail ${reason || 'network error'}` });
-    });
-    return {
-        abort() {
-            settleFail({ errMsg: 'request:fail abort' });
-            controller.abort();
-        },
-    };
-}
-//# sourceMappingURL=request-core.js.map

package/dist/shared/simulator-api-metadata.d.ts

@@ -1,26 +0,0 @@
-export declare const PERSISTENT_SIMULATOR_APIS: ReadonlySet<string>;
-export declare function isPersistentSimulatorApi(name: string): boolean;
-/**
- * APIs whose one-shot call legitimately runs as long as the caller's wx
- * network timeout budget (`params.timeout`, default 60000ms) — the simulator
- * handler answers when the network answers, not within a fixed router window.
- */
-export declare const NETWORK_BUDGET_SIMULATOR_APIS: ReadonlySet<string>;
-/**
- * Flat watchdog window for forwarded one-shot calls whose handler is expected
- * to answer promptly; it guards against a missing handler / dead seam.
- */
-export declare const API_CALL_WATCHDOG_MS = 5000;
-/**
- * How long bridge-router's one-shot "no handler" watchdog waits before
- * tearing a forwarded simulator-API call down.
- *
- * Network-budget APIs get their wx timeout budget plus the flat window as
- * forwarding grace: the handler owns the real deadline (performRequest emits
- * `request:fail timeout` at the budget), so the watchdog only has to catch
- * the case where no verdict ever comes back. A flat 5s window here would
- * kill any HTTP call slower than 5s and drop its late — perfectly valid —
- * response. Every other API keeps the flat window.
- */
-export declare function apiCallWatchdogMs(name: string, params: Record<string, unknown> | undefined): number;
-//# sourceMappingURL=simulator-api-metadata.d.ts.map

package/dist/shared/simulator-api-metadata.js

@@ -1,59 +0,0 @@
-/**
- * Persistent (subscription) simulator APIs — a call that, once made, keeps
- * delivering a response on every underlying event instead of settling once.
- *
- * The dimina service runtime strips `keep` / `evtId` / `success` before the
- * call leaves the service host (it stores them service-local in
- * `callback.store`), so by the time `audioListen` reaches the container its
- * `keep: true` intent is gone and it would degrade to a one-shot call —
- * dropping every audio DOM event after the first. The container and router
- * therefore recognise these APIs by NAME and treat them as persistent
- * regardless of the (stripped) params.
- *
- * Currently only `audioListen` — the InnerAudioContext DOM-event bridge
- * (canplay / play / pause / ended / error / timeupdate / waiting / seeking /
- * seeked). Add any new subscription API here: this is the single source of
- * truth, consumed by `bridge-router` (skip the one-shot timeout, keep-alive
- * responses) and `run-api-async` (no premature settle, re-fire on every event).
- */
-import { MAX_TIMEOUT_MS, resolveTimeoutBudgetMs } from './request-core.js';
-export const PERSISTENT_SIMULATOR_APIS = new Set(['audioListen']);
-export function isPersistentSimulatorApi(name) {
-    return PERSISTENT_SIMULATOR_APIS.has(name);
-}
-/**
- * APIs whose one-shot call legitimately runs as long as the caller's wx
- * network timeout budget (`params.timeout`, default 60000ms) — the simulator
- * handler answers when the network answers, not within a fixed router window.
- */
-export const NETWORK_BUDGET_SIMULATOR_APIS = new Set([
-    'request',
-    'downloadFile',
-    'uploadFile',
-]);
-/**
- * Flat watchdog window for forwarded one-shot calls whose handler is expected
- * to answer promptly; it guards against a missing handler / dead seam.
- */
-export const API_CALL_WATCHDOG_MS = 5_000;
-/**
- * How long bridge-router's one-shot "no handler" watchdog waits before
- * tearing a forwarded simulator-API call down.
- *
- * Network-budget APIs get their wx timeout budget plus the flat window as
- * forwarding grace: the handler owns the real deadline (performRequest emits
- * `request:fail timeout` at the budget), so the watchdog only has to catch
- * the case where no verdict ever comes back. A flat 5s window here would
- * kill any HTTP call slower than 5s and drop its late — perfectly valid —
- * response. Every other API keeps the flat window.
- */
-export function apiCallWatchdogMs(name, params) {
-    if (!NETWORK_BUDGET_SIMULATOR_APIS.has(name))
-        return API_CALL_WATCHDOG_MS;
-    // resolveTimeoutBudgetMs rejects non-finite/oversized caller timeouts, and
-    // the final clamp keeps budget+grace inside setTimeout's range — an
-    // overflowing delay would wrap to ~1ms and fire the watchdog immediately.
-    const budget = resolveTimeoutBudgetMs(params?.timeout);
-    return Math.min(budget + API_CALL_WATCHDOG_MS, MAX_TIMEOUT_MS);
-}
-//# sourceMappingURL=simulator-api-metadata.js.map