@lynx-js/web-core-wasm-canary 0.0.0 → 0.0.1-canary-20260116-ce265e8f

package/dist/client/decodeWorker/decode.worker.js

@@ -0,0 +1,338 @@
+import { TemplateSectionLabel, MagicHeader } from '../../constants.js';
+import { DecodedStyle, wasmInstance } from '../wasm.js';
+let wasmModuleLoadedResolve;
+const wasmModuleLoadedPromise = new Promise((resolve) => {
+    wasmModuleLoadedResolve = resolve;
+});
+import { loadStyleFromJSON } from './cssLoader.js';
+class StreamReader {
+    #reader;
+    #buffer = new Uint8Array(0);
+    constructor(reader) {
+        this.#reader = reader;
+    }
+    async read(size) {
+        if (this.#buffer.length >= size) {
+            const result = this.#buffer.slice(0, size);
+            this.#buffer = this.#buffer.slice(size);
+            return result;
+        }
+        while (this.#buffer.length < size) {
+            const { done, value } = await this.#reader.read();
+            if (value) {
+                const newBuffer = new Uint8Array(this.#buffer.length + value.length);
+                newBuffer.set(this.#buffer);
+                newBuffer.set(value, this.#buffer.length);
+                this.#buffer = newBuffer;
+            }
+            if (done) {
+                break;
+            }
+        }
+        if (this.#buffer.length < size) {
+            if (this.#buffer.length === 0) {
+                return null;
+            }
+            throw new Error(`Unexpected end of stream. Expected ${size} bytes, got ${this.#buffer.length}`);
+        }
+        const result = this.#buffer.slice(0, size);
+        this.#buffer = this.#buffer.slice(size);
+        return result;
+    }
+    async readRest() {
+        while (true) {
+            const { done, value } = await this.#reader.read();
+            if (value) {
+                const newBuffer = new Uint8Array(this.#buffer.length + value.length);
+                newBuffer.set(this.#buffer);
+                newBuffer.set(value, this.#buffer.length);
+                this.#buffer = newBuffer;
+            }
+            if (done) {
+                break;
+            }
+        }
+        const result = this.#buffer;
+        this.#buffer = new Uint8Array(0);
+        return result;
+    }
+}
+function decodeJSONMap(buffer) {
+    const utf16Array = new Uint16Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 2);
+    let jsonString = '';
+    const CHUNK_SIZE = 8192;
+    for (let i = 0; i < utf16Array.length; i += CHUNK_SIZE) {
+        jsonString += String.fromCharCode.apply(null, utf16Array.subarray(i, i + CHUNK_SIZE));
+    }
+    return JSON.parse(jsonString);
+}
+function decodeBinaryMap(buffer) {
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    let offset = 0;
+    if (buffer.byteLength < 4) {
+        throw new Error('Buffer too short for count');
+    }
+    const count = view.getUint32(offset, true);
+    offset += 4;
+    const result = {};
+    const decoder = new TextDecoder();
+    for (let i = 0; i < count; i++) {
+        if (buffer.byteLength < offset + 4) {
+            throw new Error('Buffer too short for key length');
+        }
+        const keyLen = view.getUint32(offset, true);
+        offset += 4;
+        if (buffer.byteLength < offset + keyLen) {
+            throw new Error('Buffer too short for key');
+        }
+        const key = decoder.decode(buffer.subarray(offset, offset + keyLen));
+        offset += keyLen;
+        if (buffer.byteLength < offset + 4) {
+            throw new Error('Buffer too short for value length');
+        }
+        const valLen = view.getUint32(offset, true);
+        offset += 4;
+        if (buffer.byteLength < offset + valLen) {
+            throw new Error('Buffer too short for value');
+        }
+        const val = buffer.subarray(offset, offset + valLen);
+        offset += valLen;
+        result[key] = val;
+    }
+    return result;
+}
+self.onmessage = async (event) => {
+    const data = event.data;
+    if (data.type === 'init') {
+        const { wasmModule } = data;
+        wasmInstance.initSync({ module: wasmModule });
+        wasmModuleLoadedResolve();
+    }
+    else if (data.type === 'load') {
+        const { url, fetchUrl, overrideConfig } = data;
+        try {
+            const response = await fetch(fetchUrl, {
+                headers: {
+                    'Content-Type': 'octet-stream',
+                },
+            });
+            if (!response.body || response.status !== 200) {
+                throw new Error(`Failed to fetch template: ${response.statusText}`);
+            }
+            const reader = response.body.getReader();
+            await handleStream(url, reader, overrideConfig);
+            postMessage({ type: 'done', url });
+        }
+        catch (error) {
+            postMessage({ type: 'error', url, error: error.message });
+        }
+    }
+};
+async function handleStream(url, reader, overrideConfig) {
+    const streamReader = new StreamReader(reader);
+    let config = {};
+    // 1. Check MagicHeader
+    const headerBytes = await streamReader.read(8);
+    if (!headerBytes) {
+        throw new Error('Empty stream');
+    }
+    // Check if JSON (starts with {)
+    if (headerBytes[0] === 123) {
+        const rest = await streamReader.readRest();
+        const decoder = new TextDecoder();
+        const jsonStr = decoder.decode(headerBytes) + decoder.decode(rest);
+        const json = JSON.parse(jsonStr);
+        await handleJSON(json, url, overrideConfig);
+        return;
+    }
+    const view = new DataView(headerBytes.buffer, headerBytes.byteOffset, headerBytes.byteLength);
+    const magic = view.getBigUint64(0, true); // Little Endian
+    if (magic !== BigInt(MagicHeader)) {
+        throw new Error('Invalid Magic Header');
+    }
+    // 2. Check Version
+    const versionBytes = await streamReader.read(4);
+    if (!versionBytes) {
+        throw new Error('Unexpected EOF reading version');
+    }
+    const versionView = new DataView(versionBytes.buffer, versionBytes.byteOffset, versionBytes.byteLength);
+    const version = versionView.getUint32(0, true);
+    if (version > 1) {
+        throw new Error(`Unsupported version: ${version}`);
+    }
+    // 3. Read Sections
+    while (true) {
+        const labelBytes = await streamReader.read(4);
+        if (!labelBytes) {
+            break; // EOF
+        }
+        const labelView = new DataView(labelBytes.buffer, labelBytes.byteOffset, labelBytes.byteLength);
+        const label = labelView.getUint32(0, true);
+        const lengthBytes = await streamReader.read(4);
+        if (!lengthBytes) {
+            throw new Error('Unexpected EOF reading section length');
+        }
+        const lengthView = new DataView(lengthBytes.buffer, lengthBytes.byteOffset, lengthBytes.byteLength);
+        const length = lengthView.getUint32(0, true);
+        const content = await streamReader.read(length);
+        if (!content) {
+            throw new Error(`Unexpected EOF reading section content. Expected ${length} bytes.`);
+        }
+        switch (label) {
+            case TemplateSectionLabel.Configurations: {
+                config = overrideConfig
+                    ? { ...decodeJSONMap(content), ...overrideConfig }
+                    : decodeJSONMap(content);
+                postMessage({ type: 'section', label, url, data: config });
+                break;
+            }
+            case TemplateSectionLabel.StyleInfo: {
+                await wasmModuleLoadedPromise;
+                const buffer = DecodedStyle.webWorkerDecode(content, config['enableCSSSelector'] === 'true', config['isLazy'] === 'true' ? url : undefined);
+                postMessage({
+                    type: 'section',
+                    label,
+                    url,
+                    data: buffer.buffer,
+                    config,
+                }, {
+                    transfer: [buffer.buffer],
+                });
+                break;
+            }
+            case TemplateSectionLabel.LepusCode: {
+                const codeMap = decodeBinaryMap(content);
+                const isLazy = config['isLazy'] === 'true';
+                const blobMap = {};
+                for (const [key, code] of Object.entries(codeMap)) {
+                    const prefix = `(function(){ "use strict"; const navigator=void 0,postMessage=void 0,window=void 0; ${isLazy ? 'module.exports=' : ''} `;
+                    const suffix = ` \n })()\n//# sourceURL=${url}\n`;
+                    const blob = new Blob([prefix, code, suffix], {
+                        type: 'text/javascript; charset=utf-8',
+                    });
+                    blobMap[key] = URL.createObjectURL(blob);
+                }
+                postMessage({ type: 'section', label, url, data: blobMap, config });
+                break;
+            }
+            case TemplateSectionLabel.ElementTemplates: {
+                postMessage({ type: 'section', label, url, data: content }, [content.buffer]);
+                break;
+            }
+            case TemplateSectionLabel.CustomSections: {
+                postMessage({ type: 'section', label, url, data: content.buffer }, {
+                    transfer: [content.buffer],
+                });
+                break;
+            }
+            case TemplateSectionLabel.Manifest: {
+                const codeMap = decodeBinaryMap(content);
+                const blobMap = {};
+                for (const [key, code] of Object.entries(codeMap)) {
+                    const suffix = `//# sourceURL=${url}/${key}`;
+                    const blob = new Blob([code, suffix], {
+                        type: 'text/javascript; charset=utf-8',
+                    });
+                    blobMap[key] = URL.createObjectURL(blob);
+                }
+                postMessage({ type: 'section', label, url, data: blobMap });
+                break;
+            }
+            default:
+                throw new Error(`Unknown section label: ${label}`);
+        }
+    }
+}
+async function handleJSON(json, url, overrideConfig) {
+    // Configurations
+    let config = {};
+    if (json.pageConfig) {
+        config = { ...json.pageConfig };
+    }
+    if (overrideConfig) {
+        config = { ...config, ...overrideConfig };
+    }
+    postMessage({
+        type: 'section',
+        label: TemplateSectionLabel.Configurations,
+        url,
+        data: config,
+    });
+    // StyleInfo
+    if (json.styleInfo) {
+        await wasmModuleLoadedPromise;
+        const buffer = loadStyleFromJSON(json.styleInfo, config['enableCSSSelector'] === 'true', config['isLazy'] === 'true' ? url : undefined);
+        postMessage({
+            type: 'section',
+            label: TemplateSectionLabel.StyleInfo,
+            url,
+            data: buffer.buffer,
+            config,
+        }, {
+            transfer: [buffer.buffer],
+        });
+    }
+    // LepusCode
+    if (json.lepusCode) {
+        // Flattened structure in json: { root: "...", chunk1: "..." }
+        const isLazy = config['isLazy'] === 'true';
+        const blobMap = {};
+        for (const [key, code] of Object.entries(json.lepusCode)) {
+            if (typeof code !== 'string')
+                continue;
+            const prefix = `(function(){ "use strict"; const navigator=void 0,postMessage=void 0,window=void 0; ${isLazy ? 'module.exports=' : ''} `;
+            const suffix = ` \n })()\n//# sourceURL=${url}/${key}\n`;
+            const blob = new Blob([prefix, code, suffix], {
+                type: 'text/javascript;',
+            });
+            blobMap[key] = URL.createObjectURL(blob);
+        }
+        postMessage({
+            type: 'section',
+            label: TemplateSectionLabel.LepusCode,
+            url,
+            data: blobMap,
+            config,
+        });
+    }
+    // Manifest
+    if (json.manifest) {
+        const blobMap = {};
+        for (const [key, code] of Object.entries(json.manifest)) {
+            if (typeof code !== 'string')
+                continue;
+            const blob = new Blob([code], {
+                type: 'text/javascript;',
+            });
+            blobMap[key] = URL.createObjectURL(blob);
+        }
+        postMessage({
+            type: 'section',
+            label: TemplateSectionLabel.Manifest,
+            url,
+            data: blobMap,
+        });
+    }
+    // CustomSections
+    if (json.customSections) {
+        // Currently we don't have a way to encode custom sections here.
+        // If main thread accepts generic object, we send it.
+        // But TemplateManager expects buffer?
+        // TemplateManager: case CustomSections: #setCustomSection(url, data). data: any.
+        // So passing object is fine!
+        postMessage({
+            type: 'section',
+            label: TemplateSectionLabel.CustomSections,
+            url,
+            data: json.customSections,
+        });
+    }
+    // ElementTemplates
+    if (json.elementTemplates) {
+        // TemplateManager expects Uint8Array for ElementTemplates.
+        // We can't support this easily for JSON.
+        throw new Error('ElementTemplates in JSON artifacts are not supported yet.');
+    }
+}
+postMessage({ type: 'ready' });
+//# sourceMappingURL=decode.worker.js.map

package/dist/client/decodeWorker/types.d.ts

@@ -0,0 +1,32 @@
+import type { PageConfig } from '../../types/PageConfig.js';
+export interface DecodeWorkerMessage {
+    type: string;
+    url: string;
+}
+export interface InitMessage extends DecodeWorkerMessage {
+    type: 'init';
+    wasmModule: WebAssembly.Module;
+}
+export interface LoadTemplateMessage extends DecodeWorkerMessage {
+    type: 'load';
+    fetchUrl: string;
+    overrideConfig?: Record<string, string>;
+}
+export interface SectionMessage extends DecodeWorkerMessage {
+    type: 'section';
+    label: number;
+    data: any;
+    config?: PageConfig;
+}
+export interface ErrorMessage extends DecodeWorkerMessage {
+    type: 'error';
+    error: string;
+}
+export interface DoneMessage extends DecodeWorkerMessage {
+    type: 'done';
+}
+export interface ReadyMessage {
+    type: 'ready';
+}
+export type WorkerMessage = LoadTemplateMessage;
+export type MainMessage = SectionMessage | ErrorMessage | DoneMessage | ReadyMessage;

package/dist/client/decodeWorker/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/client/endpoints.d.ts

@@ -0,0 +1,53 @@
+import type { Cloneable, CloneableObject, LynxCrossThreadEvent, InvokeCallbackRes, ElementAnimationOptions, UpdateDataOptions, TimingEntry } from '../types/index.js';
+import type { IdentifierType } from '../constants.js';
+export declare const publicComponentEventEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsyncVoid<[componentId: string, hname: string, LynxCrossThreadEvent<{
+    [key: string]: string | number | null | undefined;
+}>]>;
+export declare const publishEventEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsyncVoid<[string, LynxCrossThreadEvent<{
+    [key: string]: string | number | null | undefined;
+}>]>;
+export declare const switchExposureServiceEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsyncVoid<[boolean, boolean]>;
+export declare const updateDataEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsync<[Cloneable, UpdateDataOptions | undefined], void>;
+export declare const sendGlobalEventEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsyncVoid<[string, Cloneable[] | undefined]>;
+export declare const disposeEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsync<[], void>;
+export declare const BackgroundThreadStartEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsync<[], void>;
+/**
+ * Error message, info
+ */
+export declare const reportErrorEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsyncVoid<[Error, unknown, string]>;
+export declare const callLepusMethodEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsync<[name: string, data: unknown], void>;
+export declare const invokeUIMethodEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsync<[type: IdentifierType, identifier: string, component_id: string, method: string, params: object, root_unique_id: number | undefined], InvokeCallbackRes>;
+export declare const setNativePropsEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsync<[type: IdentifierType, identifier: string, component_id: string, first_only: boolean, native_props: object, root_unique_id: number | undefined], void>;
+export declare const getPathInfoEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsync<[type: IdentifierType, identifier: string, component_id: string, first_only: boolean, root_unique_id?: number | undefined], InvokeCallbackRes>;
+export declare const nativeModulesCallEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsync<[name: string, data: Cloneable, moduleName: string], any>;
+export declare const napiModulesCallEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsyncWithTransfer<[name: string, data: Cloneable, moduleName: string], any>;
+export declare const getCustomSectionsEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsync<[string], Cloneable>;
+export declare const markTimingEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsyncVoid<[TimingEntry[]]>;
+export declare const postTimingFlagsEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsyncVoid<[timingFlags: string[], pipelineId: string | undefined]>;
+export declare const triggerComponentEventEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsyncVoid<[id: string, params: {
+    eventDetail: CloneableObject;
+    eventOption: CloneableObject;
+    componentId: string;
+}]>;
+export declare const selectComponentEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsync<[componentId: string, idSelector: string, single: boolean], void>;
+export declare const dispatchLynxViewEventEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsyncVoid<[eventType: string, detail: CloneableObject]>;
+export declare const dispatchNapiModuleEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsyncVoid<[data: Cloneable]>;
+export declare const dispatchCoreContextOnBackgroundEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsyncVoid<[{
+    type: string;
+    data: Cloneable;
+}]>;
+export declare const dispatchJSContextOnMainThreadEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsyncVoid<[{
+    type: string;
+    data: Cloneable;
+}]>;
+export declare const triggerElementMethodEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsyncVoid<[method: string, id: string, options: ElementAnimationOptions]>;
+export declare const updateGlobalPropsEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsyncVoid<[Cloneable]>;
+export declare const updateI18nResourcesEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsyncVoid<[Cloneable]>;
+export declare const dispatchI18nResourceEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsyncVoid<[Cloneable]>;
+export declare const queryComponentEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsync<[string], {
+    code: number;
+    detail: {
+        schema: string;
+    };
+}>;
+export declare const updateBTSChunkEndpoint: import("@lynx-js/web-worker-rpc").RpcEndpointAsync<[string, Record<string, string>], void>;

package/dist/client/endpoints.js

@@ -0,0 +1,37 @@
+// Copyright 2023 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+import { createRpcEndpoint } from '@lynx-js/web-worker-rpc';
+export const publicComponentEventEndpoint = createRpcEndpoint('publicComponentEvent', false, false);
+export const publishEventEndpoint = createRpcEndpoint('publishEvent', false, false);
+export const switchExposureServiceEndpoint = createRpcEndpoint('switchExposureServiceEndpoint', false, false);
+export const updateDataEndpoint = createRpcEndpoint('updateData', false, true);
+export const sendGlobalEventEndpoint = createRpcEndpoint('sendGlobalEventEndpoint', false, false);
+export const disposeEndpoint = createRpcEndpoint('dispose', false, true);
+export const BackgroundThreadStartEndpoint = createRpcEndpoint('start', false, true);
+/**
+ * Error message, info
+ */
+export const reportErrorEndpoint = createRpcEndpoint('reportError', false, false);
+export const callLepusMethodEndpoint = createRpcEndpoint('callLepusMethod', false, true);
+export const invokeUIMethodEndpoint = createRpcEndpoint('__invokeUIMethod', false, true);
+export const setNativePropsEndpoint = createRpcEndpoint('__setNativeProps', false, true);
+export const getPathInfoEndpoint = createRpcEndpoint('__getPathInfo', false, true);
+export const nativeModulesCallEndpoint = createRpcEndpoint('nativeModulesCall', false, true);
+export const napiModulesCallEndpoint = createRpcEndpoint('napiModulesCall', false, true, true);
+export const getCustomSectionsEndpoint = createRpcEndpoint('getCustomSections', false, true);
+export const markTimingEndpoint = createRpcEndpoint('markTiming', false, false);
+export const postTimingFlagsEndpoint = createRpcEndpoint('postTimingFlags', false, false);
+export const triggerComponentEventEndpoint = createRpcEndpoint('__triggerComponentEvent', false, false);
+export const selectComponentEndpoint = createRpcEndpoint('__selectComponent', false, true);
+export const dispatchLynxViewEventEndpoint = createRpcEndpoint('dispatchLynxViewEvent', false, false);
+export const dispatchNapiModuleEndpoint = createRpcEndpoint('dispatchNapiModule', false, false);
+export const dispatchCoreContextOnBackgroundEndpoint = createRpcEndpoint('dispatchCoreContextOnBackground', false, false);
+export const dispatchJSContextOnMainThreadEndpoint = createRpcEndpoint('dispatchJSContextOnMainThread', false, false);
+export const triggerElementMethodEndpoint = createRpcEndpoint('__triggerElementMethod', false, false);
+export const updateGlobalPropsEndpoint = createRpcEndpoint('updateGlobalProps', false, false);
+export const updateI18nResourcesEndpoint = createRpcEndpoint('updateI18nResources', false, false);
+export const dispatchI18nResourceEndpoint = createRpcEndpoint('dispatchI18nResource', false, false);
+export const queryComponentEndpoint = createRpcEndpoint('queryComponent', false, true);
+export const updateBTSChunkEndpoint = createRpcEndpoint('updateBTSChunkEndpoint', false, true);
+//# sourceMappingURL=endpoints.js.map

package/dist/client/index.d.ts

@@ -0,0 +1,3 @@
+import './mainthread/LynxView.js';
+import '../../css/index.css';
+export type { LynxViewElement } from './mainthread/LynxView.js';

package/dist/client/index.js

@@ -0,0 +1,3 @@
+import './mainthread/LynxView.js';
+import '../../css/index.css';
+//# sourceMappingURL=index.js.map

package/dist/client/mainthread/Background.d.ts

@@ -0,0 +1,30 @@
+import { type RpcCallType } from '@lynx-js/web-worker-rpc';
+import { postTimingFlagsEndpoint, publicComponentEventEndpoint, publishEventEndpoint, sendGlobalEventEndpoint, dispatchI18nResourceEndpoint, updateDataEndpoint, updateGlobalPropsEndpoint, updateBTSChunkEndpoint } from '../endpoints.js';
+import type { Cloneable, NapiModulesMap, NativeModulesMap } from '../../types/index.js';
+import { LynxCrossThreadContext } from '../LynxCrossThreadContext.js';
+import { type LynxViewInstance } from './LynxViewInstance.js';
+export declare class BackgroundThread implements AsyncDisposable {
+    #private;
+    static contextIdToBackgroundWorker: ({
+        worker: Worker;
+        runningCards: number;
+    } | undefined)[];
+    readonly jsContext: LynxCrossThreadContext;
+    readonly postTimingFlags: RpcCallType<typeof postTimingFlagsEndpoint>;
+    readonly sendGlobalEvent: RpcCallType<typeof sendGlobalEventEndpoint>;
+    readonly publicComponentEvent: RpcCallType<typeof publicComponentEventEndpoint>;
+    readonly publishEvent: RpcCallType<typeof publishEventEndpoint>;
+    readonly dispatchI18nResource: RpcCallType<typeof dispatchI18nResourceEndpoint>;
+    readonly updateData: RpcCallType<typeof updateDataEndpoint>;
+    readonly updateGlobalProps: RpcCallType<typeof updateGlobalPropsEndpoint>;
+    readonly updateBTSChunk: RpcCallType<typeof updateBTSChunkEndpoint>;
+    constructor(lynxGroupId: number | undefined, lynxViewInstance: LynxViewInstance);
+    startWebWorker(initData: Cloneable, globalProps: Cloneable, cardType: string, customSections: Record<string, Cloneable>, nativeModulesMap: NativeModulesMap, napiModulesMap: NapiModulesMap): void;
+    startBTS(): void;
+    markTiming(timingKey: string, pipelineId?: string, timeStamp?: number): void;
+    /**
+     * Flush the timing info immediately.
+     */
+    flushTimingInfo(): void;
+    [Symbol.asyncDispose](): Promise<void>;
+}