@wyw-in-js/transform 1.1.0 → 2.0.0-alpha.0

package/types/eval/lru.d.ts

@@ -0,0 +1,10 @@
+export declare class LruCache<K, V> {
+    private readonly maxSize;
+    private readonly map;
+    constructor(maxSize: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    has(key: K): boolean;
+    delete(key: K): void;
+    clear(): void;
+}

package/types/eval/lru.js

@@ -0,0 +1,36 @@
+export class LruCache {
+    maxSize;
+    map = new Map();
+    constructor(maxSize) {
+        this.maxSize = Math.max(1, maxSize);
+    }
+    get(key) {
+        const value = this.map.get(key);
+        if (value === undefined)
+            return undefined;
+        this.map.delete(key);
+        this.map.set(key, value);
+        return value;
+    }
+    set(key, value) {
+        if (this.map.has(key)) {
+            this.map.delete(key);
+        }
+        this.map.set(key, value);
+        if (this.map.size > this.maxSize) {
+            const firstKey = this.map.keys().next().value;
+            if (firstKey !== undefined) {
+                this.map.delete(firstKey);
+            }
+        }
+    }
+    has(key) {
+        return this.map.has(key);
+    }
+    delete(key) {
+        this.map.delete(key);
+    }
+    clear() {
+        this.map.clear();
+    }
+}

package/types/eval/prepareModuleOnDemand.d.ts

@@ -0,0 +1,7 @@
+import type { Services } from '../transform/types';
+export type PreparedModule = {
+    code: string;
+    imports: Map<string, string[]> | null;
+    only: string[];
+};
+export declare function prepareModuleOnDemand(services: Services, id: string, only: string[]): PreparedModule;

package/types/eval/prepareModuleOnDemand.js

@@ -0,0 +1,24 @@
+import { oxcShaker } from '../shaker';
+import { Entrypoint } from '../transform/Entrypoint';
+import { prepareCodeForEvalRuntime } from '../transform/generators/transform';
+export function prepareModuleOnDemand(services, id, only) {
+    const entrypoint = Entrypoint.createRoot(services, id, only, undefined, {
+        mergeCachedOnly: !only.includes('__wywPreval'),
+    });
+    if (entrypoint.ignored) {
+        return {
+            code: entrypoint.loadedAndParsed.code ?? '',
+            imports: null,
+            only: entrypoint.only,
+        };
+    }
+    const ast = entrypoint.loadedAndParsed.evaluator === oxcShaker
+        ? null
+        : entrypoint.loadedAndParsed.ast;
+    const [code, imports] = prepareCodeForEvalRuntime(services, entrypoint, ast);
+    return {
+        code,
+        imports,
+        only: entrypoint.only,
+    };
+}

package/types/eval/protocol.d.ts

@@ -0,0 +1,97 @@
+import type { EvalResolverKind, EvalWarning, FeatureFlags, ImportOverrides } from '@wyw-in-js/shared';
+import type { SerializedError, SerializedValue } from './serialize';
+export type EvalRunnerInitPayload = {
+    evalOptions: {
+        mode: 'strict' | 'loose';
+        require: 'warn-and-run' | 'error' | 'off';
+        globals: Record<string, unknown>;
+        importOverrides?: ImportOverrides;
+        root?: string;
+        extensions?: string[];
+    };
+    features: FeatureFlags<'happyDOM'>;
+    entrypoint: string;
+    reuseModules?: boolean;
+};
+export type EvalRequest = {
+    id: string;
+};
+export type EvalResultPayload = {
+    values: Record<string, SerializedValue> | null;
+    modules?: Record<string, Record<string, SerializedValue>>;
+};
+export type ResolveRequestPayload = {
+    specifier: string;
+    importerId: string;
+    kind: EvalResolverKind;
+};
+export type ResolveResultPayload = {
+    resolvedId: string | null;
+    external?: boolean;
+    error?: SerializedError;
+};
+export type LoadRequestPayload = {
+    id: string;
+    importerId?: string | null;
+    request?: string | null;
+};
+export type LoadResultPayload = {
+    id: string;
+    code?: string;
+    codeChunk?: string;
+    chunkIndex?: number;
+    chunkCount?: number;
+    map?: unknown;
+    hash?: string;
+    only?: string[];
+    exports?: Record<string, SerializedValue>;
+    error?: SerializedError;
+};
+export type InitMessage = {
+    type: 'INIT';
+    id: string;
+    payload: EvalRunnerInitPayload;
+};
+export type InitAckMessage = {
+    type: 'INIT_ACK';
+    id: string;
+    error?: SerializedError;
+    modulesReset?: boolean;
+};
+export type EvalMessage = {
+    type: 'EVAL';
+    id: string;
+    payload: EvalRequest;
+};
+export type EvalResultMessage = {
+    type: 'EVAL_RESULT';
+    id: string;
+    payload: EvalResultPayload;
+    error?: SerializedError;
+};
+export type ResolveMessage = {
+    type: 'RESOLVE';
+    id: string;
+    payload: ResolveRequestPayload;
+};
+export type ResolveResultMessage = {
+    type: 'RESOLVE_RESULT';
+    id: string;
+    payload: ResolveResultPayload;
+};
+export type LoadMessage = {
+    type: 'LOAD';
+    id: string;
+    payload: LoadRequestPayload;
+};
+export type LoadResultMessage = {
+    type: 'LOAD_RESULT';
+    id: string;
+    payload: LoadResultPayload;
+};
+export type WarnMessage = {
+    type: 'WARN';
+    payload: EvalWarning;
+};
+export type RunnerToMainMessage = ResolveMessage | LoadMessage | WarnMessage | InitAckMessage | EvalResultMessage;
+export type MainToRunnerMessage = InitMessage | EvalMessage | ResolveResultMessage | LoadResultMessage;

package/types/eval/protocol.js

@@ -0,0 +1 @@
+export {};

package/types/eval/resolverStrategy.d.ts

@@ -0,0 +1,13 @@
+import type { EvalResolverMode } from '@wyw-in-js/shared';
+export type HybridResolverRoute = 'bundler' | 'oxc';
+export type HybridResolverReason = 'ambiguous-specifier' | 'bundler-owned-prefix' | 'query-or-hash' | 'safe-relative-specifier';
+export type HybridResolverDecision = {
+    reason: HybridResolverReason;
+    route: HybridResolverRoute;
+};
+export type HybridResolverClassifierOptions = {
+    bundlerOwnedPrefixes?: readonly string[];
+};
+export declare const defaultBundlerOwnedSpecifierPrefixes: readonly ["\0", "/@", "virtual:"];
+export declare const getResolverPrecedence: (mode: EvalResolverMode) => readonly string[];
+export declare const classifyHybridResolverSpecifier: (specifier: string, { bundlerOwnedPrefixes, }?: HybridResolverClassifierOptions) => HybridResolverDecision;

package/types/eval/resolverStrategy.js

@@ -0,0 +1,46 @@
+export const defaultBundlerOwnedSpecifierPrefixes = [
+    '\0',
+    '/@',
+    'virtual:',
+];
+export const getResolverPrecedence = (mode) => {
+    if (mode === 'hybrid') {
+        return [
+            'customResolver',
+            'safeOxcResolver',
+            'bundlerResolver',
+            'nodeFallback',
+        ];
+    }
+    if (mode === 'bundler') {
+        return ['customResolver', 'bundlerResolver', 'nodeFallback'];
+    }
+    if (mode === 'custom') {
+        return ['customResolver'];
+    }
+    return ['nodeFallback'];
+};
+export const classifyHybridResolverSpecifier = (specifier, { bundlerOwnedPrefixes = defaultBundlerOwnedSpecifierPrefixes, } = {}) => {
+    if (bundlerOwnedPrefixes.some((prefix) => specifier.startsWith(prefix))) {
+        return {
+            reason: 'bundler-owned-prefix',
+            route: 'bundler',
+        };
+    }
+    if (!specifier.startsWith('./') && !specifier.startsWith('../')) {
+        return {
+            reason: 'ambiguous-specifier',
+            route: 'bundler',
+        };
+    }
+    if (/[?#]/.test(specifier)) {
+        return {
+            reason: 'query-or-hash',
+            route: 'bundler',
+        };
+    }
+    return {
+        reason: 'safe-relative-specifier',
+        route: 'oxc',
+    };
+};

package/types/eval/serialize.d.ts

@@ -0,0 +1,78 @@
+export type SerializedError = {
+    message: string;
+    name?: string;
+    stack?: string;
+    cause?: SerializedError;
+};
+export type SerializedValue = {
+    kind: 'value';
+    value: unknown;
+} | {
+    kind: 'null';
+} | {
+    kind: 'boolean';
+    value: boolean;
+} | {
+    kind: 'string';
+    value: string;
+} | {
+    kind: 'number';
+    value: number;
+} | {
+    kind: 'function';
+} | {
+    kind: 'symbol';
+    description: string;
+} | {
+    kind: 'error';
+    error: SerializedError;
+} | {
+    kind: 'undefined';
+} | {
+    kind: 'bigint';
+    value: string;
+} | {
+    kind: 'nan';
+} | {
+    kind: 'infinity';
+} | {
+    kind: '-infinity';
+} | {
+    kind: 'array';
+    items: SerializedValue[];
+} | {
+    kind: 'object';
+    entries: Record<string, SerializedValue>;
+};
+declare const ENCODED_GLOBAL_ENVELOPE_KEY = "__wyw_eval_global";
+declare const ENCODED_GLOBAL_SIGNATURE = "wyw-eval-global";
+declare const ENCODED_GLOBAL_VERSION = 1;
+type EncodedFunctionPayload = {
+    signature: typeof ENCODED_GLOBAL_SIGNATURE;
+    version: typeof ENCODED_GLOBAL_VERSION;
+    kind: 'function';
+    source: string;
+};
+type EncodedSymbolPayload = {
+    signature: typeof ENCODED_GLOBAL_SIGNATURE;
+    version: typeof ENCODED_GLOBAL_VERSION;
+    kind: 'symbol';
+    description: string;
+};
+type EncodedGlobalPayload = EncodedFunctionPayload | EncodedSymbolPayload;
+export type EncodedGlobal = {
+    [ENCODED_GLOBAL_ENVELOPE_KEY]: EncodedGlobalPayload;
+};
+type PathSegment = string | number | symbol;
+type SerializeValueOptions = {
+    allowFunctions?: boolean;
+    allowSymbols?: boolean;
+    path?: PathSegment[];
+    rootLabel?: string;
+};
+export declare const serializeValue: (value: unknown, options?: SerializeValueOptions) => SerializedValue;
+export declare const deserializeValue: (value: SerializedValue) => unknown;
+export declare const serializePreval: (values: Record<string, unknown>) => Record<string, SerializedValue>;
+export declare const encodeGlobals: (value: unknown) => unknown;
+export declare const decodeGlobals: (value: unknown) => unknown;
+export {};

package/types/eval/serialize.js

@@ -0,0 +1,357 @@
+const ENCODED_GLOBAL_ENVELOPE_KEY = '__wyw_eval_global';
+const ENCODED_GLOBAL_SIGNATURE = 'wyw-eval-global';
+const ENCODED_GLOBAL_VERSION = 1;
+const IDENTIFIER_RE = /^[A-Za-z_$][\w$]*$/u;
+const ARRAY_INDEX_RE = /^(?:0|[1-9]\d*)$/;
+const IPC_SUPPORTED_VALUE_HINT = 'Use importOverrides to mock the import or return plain data: null, booleans, strings, numbers, bigint, undefined, arrays, plain objects, and Error.';
+const isPlainObject = (value) => {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype === null || prototype === Object.prototype) {
+        return true;
+    }
+    return Object.getPrototypeOf(prototype) === null;
+};
+const isLikeError = (value) => typeof value === 'object' &&
+    value !== null &&
+    !isPlainObject(value) &&
+    'message' in value &&
+    typeof value.message === 'string' &&
+    ('stack' in value || 'name' in value);
+const isCallable = (value) => typeof value === 'function';
+const getBoxedPrimitiveValue = (value) => {
+    const tag = Object.prototype.toString.call(value);
+    if (tag === '[object String]') {
+        return { kind: 'string', value: String(value.valueOf()) };
+    }
+    if (tag === '[object Number]') {
+        return { kind: 'number', value: Number(value.valueOf()) };
+    }
+    if (tag === '[object Boolean]') {
+        return { kind: 'boolean', value: Boolean(value.valueOf()) };
+    }
+    return null;
+};
+const getObjectTypeName = (value) => {
+    const { constructor } = value;
+    if (constructor &&
+        typeof constructor.name === 'string' &&
+        constructor.name.length > 0) {
+        return constructor.name;
+    }
+    const tag = Object.prototype.toString.call(value);
+    return tag.slice(8, -1) || 'Object';
+};
+const formatPath = (rootLabel, path, identifierRe = IDENTIFIER_RE) => path.reduce((acc, segment) => {
+    if (typeof segment === 'number') {
+        return `${acc}[${segment}]`;
+    }
+    if (typeof segment === 'symbol') {
+        return `${acc}[${String(segment)}]`;
+    }
+    if (identifierRe.test(segment)) {
+        return `${acc}.${segment}`;
+    }
+    return `${acc}[${JSON.stringify(segment)}]`;
+}, rootLabel);
+const formatGlobalsPath = (path) => formatPath('eval.globals', path);
+const getEnumerableSymbolKeys = (value) => Object.getOwnPropertySymbols(value).filter((key) => Object.prototype.propertyIsEnumerable.call(value, key));
+const throwUnsupportedIpcValue = (rootLabel, path, description) => {
+    throw new Error(`[wyw-in-js] ${rootLabel} contains ${description} at ${formatPath(rootLabel, path)}. ${IPC_SUPPORTED_VALUE_HINT}`);
+};
+const serializeValueAtPath = (value, rootLabel, path, seen, allowFunctions, allowSymbols) => {
+    if (value === null) {
+        return { kind: 'null' };
+    }
+    if (value === undefined) {
+        return { kind: 'undefined' };
+    }
+    if (typeof value === 'boolean') {
+        return { kind: 'boolean', value };
+    }
+    if (typeof value === 'string') {
+        return { kind: 'string', value };
+    }
+    if (typeof value === 'number') {
+        if (Number.isNaN(value)) {
+            return { kind: 'nan' };
+        }
+        if (value === Infinity) {
+            return { kind: 'infinity' };
+        }
+        if (value === -Infinity) {
+            return { kind: '-infinity' };
+        }
+        return { kind: 'number', value };
+    }
+    if (typeof value === 'bigint') {
+        return { kind: 'bigint', value: value.toString() };
+    }
+    if (typeof value === 'function') {
+        if (allowFunctions) {
+            // __wywPreval consumers only rely on function-ness, not implementation
+            // identity. Preserve that signal explicitly instead of letting JSON
+            // coerce to null/undefined.
+            return { kind: 'function' };
+        }
+        throwUnsupportedIpcValue(rootLabel, path, 'an unsupported function');
+    }
+    if (typeof value === 'symbol') {
+        if (allowSymbols) {
+            return { kind: 'symbol', description: value.description ?? '' };
+        }
+        throwUnsupportedIpcValue(rootLabel, path, 'an unsupported symbol');
+    }
+    if (typeof value === 'object' && value !== null) {
+        const boxed = getBoxedPrimitiveValue(value);
+        if (boxed) {
+            if (boxed.kind === 'number') {
+                if (Number.isNaN(boxed.value)) {
+                    return { kind: 'nan' };
+                }
+                if (boxed.value === Infinity) {
+                    return { kind: 'infinity' };
+                }
+                if (boxed.value === -Infinity) {
+                    return { kind: '-infinity' };
+                }
+            }
+            return boxed;
+        }
+    }
+    if (isLikeError(value)) {
+        return {
+            kind: 'error',
+            error: {
+                message: value.message,
+                name: value.name,
+                stack: value.stack,
+            },
+        };
+    }
+    const currentPath = formatPath(rootLabel, path);
+    const seenAt = seen.get(value);
+    if (seenAt) {
+        throw new Error(`[wyw-in-js] ${rootLabel} contains a circular reference at ${currentPath} (from ${seenAt}). ${IPC_SUPPORTED_VALUE_HINT}`);
+    }
+    if (Array.isArray(value)) {
+        const symbolKeys = getEnumerableSymbolKeys(value);
+        if (symbolKeys.length > 0) {
+            throwUnsupportedIpcValue(rootLabel, [...path, symbolKeys[0]], 'an unsupported symbol-keyed property');
+        }
+        const extraKey = Object.keys(value).find((key) => !ARRAY_INDEX_RE.test(key) || Number(key) >= value.length);
+        if (extraKey !== undefined) {
+            throwUnsupportedIpcValue(rootLabel, [...path, extraKey], 'an unsupported non-index array property');
+        }
+        seen.set(value, currentPath);
+        try {
+            return {
+                kind: 'array',
+                items: Array.from({ length: value.length }, (_, index) => serializeValueAtPath(value[index], rootLabel, [...path, index], seen, allowFunctions, allowSymbols)),
+            };
+        }
+        finally {
+            seen.delete(value);
+        }
+    }
+    if (!isPlainObject(value)) {
+        throwUnsupportedIpcValue(rootLabel, path, `an unsupported non-plain object (${getObjectTypeName(value)})`);
+    }
+    const symbolKeys = getEnumerableSymbolKeys(value);
+    if (symbolKeys.length > 0) {
+        throwUnsupportedIpcValue(rootLabel, [...path, symbolKeys[0]], 'an unsupported symbol-keyed property');
+    }
+    seen.set(value, currentPath);
+    try {
+        return {
+            kind: 'object',
+            entries: Object.fromEntries(Object.entries(value).map(([key, item]) => [
+                key,
+                serializeValueAtPath(item, rootLabel, [...path, key], seen, allowFunctions, allowSymbols),
+            ])),
+        };
+    }
+    finally {
+        seen.delete(value);
+    }
+};
+export const serializeValue = (value, options = {}) => serializeValueAtPath(value, options.rootLabel ?? 'value', options.path ?? [], new WeakMap(), options.allowFunctions ?? false, options.allowSymbols ?? false);
+export const deserializeValue = (value) => {
+    switch (value.kind) {
+        case 'null':
+            return null;
+        case 'boolean':
+        case 'string':
+        case 'number':
+            return value.value;
+        case 'undefined':
+            return undefined;
+        case 'bigint':
+            return BigInt(value.value);
+        case 'nan':
+            return Number.NaN;
+        case 'infinity':
+            return Infinity;
+        case '-infinity':
+            return -Infinity;
+        case 'function':
+            return () => { };
+        case 'symbol':
+            // eslint-disable-next-line symbol-description
+            return value.description ? Symbol.for(value.description) : Symbol();
+        case 'error': {
+            const error = new Error(value.error.message);
+            if (value.error.name) {
+                error.name = value.error.name;
+            }
+            if (value.error.stack) {
+                error.stack = value.error.stack;
+            }
+            return error;
+        }
+        case 'array':
+            return value.items.map((item) => deserializeValue(item));
+        case 'object':
+            return Object.fromEntries(Object.entries(value.entries).map(([key, item]) => [
+                key,
+                deserializeValue(item),
+            ]));
+        case 'value':
+        default:
+            return value.value;
+    }
+};
+export const serializePreval = (values) => Object.fromEntries(Object.entries(values).map(([key, value]) => [
+    key,
+    serializeValue(value, {
+        allowFunctions: true,
+        allowSymbols: true,
+        rootLabel: '__wywPreval',
+        path: [key],
+    }),
+]));
+const throwUnsupportedNonPlainObject = (value, path) => {
+    throw new Error(`[wyw-in-js] eval.globals contains an unsupported non-plain object at ${formatGlobalsPath(path)} (${getObjectTypeName(value)}). ` +
+        `Use JSON-like primitives, arrays, plain objects, functions, and symbols.`);
+};
+const restoreFunction = (source, path) => {
+    try {
+        // eslint-disable-next-line no-eval
+        const restored = eval(`(${source})`);
+        if (typeof restored !== 'function') {
+            throw new TypeError('decoded source is not a function');
+        }
+        return restored;
+    }
+    catch (error) {
+        throw new Error(`[wyw-in-js] Failed to restore eval.globals function at ${formatGlobalsPath(path)}. ` +
+            `Ensure the value is a user-defined function expression/arrow function. ` +
+            `Native and bound functions are not supported. ` +
+            `Original error: ${String(error)}`);
+    }
+};
+const validateFunctionSource = (source, path) => {
+    try {
+        // eslint-disable-next-line no-eval
+        const restored = eval(`(${source})`);
+        if (typeof restored !== 'function') {
+            throw new TypeError('decoded source is not a function');
+        }
+    }
+    catch (error) {
+        throw new Error(`[wyw-in-js] eval.globals contains an unsupported function at ${formatGlobalsPath(path)}. ` +
+            `Ensure the value is a user-defined function expression/arrow function. ` +
+            `Native and bound functions are not supported. ` +
+            `Original error: ${String(error)}`);
+    }
+};
+const serializeFunction = (value, path) => {
+    const source = value.toString();
+    // Validate that the source is restorable before storing it.
+    validateFunctionSource(source, path);
+    return source;
+};
+const isEncodedGlobalPayload = (value) => {
+    if (!isPlainObject(value)) {
+        return false;
+    }
+    if (value.signature !== ENCODED_GLOBAL_SIGNATURE ||
+        value.version !== ENCODED_GLOBAL_VERSION) {
+        return false;
+    }
+    if (value.kind === 'function') {
+        return typeof value.source === 'string';
+    }
+    if (value.kind === 'symbol') {
+        return typeof value.description === 'string';
+    }
+    return false;
+};
+const isEncodedGlobal = (value) => {
+    if (!isPlainObject(value)) {
+        return false;
+    }
+    const keys = Object.keys(value);
+    if (keys.length !== 1 || keys[0] !== ENCODED_GLOBAL_ENVELOPE_KEY) {
+        return false;
+    }
+    return isEncodedGlobalPayload(value[ENCODED_GLOBAL_ENVELOPE_KEY]);
+};
+const encodeGlobalsAtPath = (value, path) => {
+    if (isCallable(value)) {
+        return {
+            [ENCODED_GLOBAL_ENVELOPE_KEY]: {
+                signature: ENCODED_GLOBAL_SIGNATURE,
+                version: ENCODED_GLOBAL_VERSION,
+                kind: 'function',
+                source: serializeFunction(value, path),
+            },
+        };
+    }
+    if (typeof value === 'symbol') {
+        return {
+            [ENCODED_GLOBAL_ENVELOPE_KEY]: {
+                signature: ENCODED_GLOBAL_SIGNATURE,
+                version: ENCODED_GLOBAL_VERSION,
+                kind: 'symbol',
+                description: value.description ?? '',
+            },
+        };
+    }
+    if (Array.isArray(value)) {
+        return value.map((item, index) => encodeGlobalsAtPath(item, [...path, index]));
+    }
+    if (isPlainObject(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            key,
+            encodeGlobalsAtPath(item, [...path, key]),
+        ]));
+    }
+    if (typeof value === 'object' && value !== null) {
+        throwUnsupportedNonPlainObject(value, path);
+    }
+    return value;
+};
+export const encodeGlobals = (value) => encodeGlobalsAtPath(value, []);
+const decodeGlobalsAtPath = (value, path) => {
+    if (Array.isArray(value)) {
+        return value.map((item, index) => decodeGlobalsAtPath(item, [...path, index]));
+    }
+    if (isEncodedGlobal(value)) {
+        const payload = value[ENCODED_GLOBAL_ENVELOPE_KEY];
+        if (payload.kind === 'function') {
+            return restoreFunction(payload.source, path);
+        }
+        return Symbol(payload.description);
+    }
+    if (isPlainObject(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            key,
+            decodeGlobalsAtPath(item, [...path, key]),
+        ]));
+    }
+    return value;
+};
+export const decodeGlobals = (value) => decodeGlobalsAtPath(value, []);

package/types/eval/writeQueue.d.ts

@@ -0,0 +1,13 @@
+type StreamWriteCallback = (error?: Error | null) => void;
+type QueueWritable = {
+    off(event: 'close' | 'drain' | 'error', listener: (...args: unknown[]) => void): void;
+    once(event: 'close' | 'drain' | 'error', listener: (...args: unknown[]) => void): void;
+    write(chunk: string, callback?: StreamWriteCallback): boolean;
+};
+export type WriteQueue = {
+    onIdle(): Promise<void>;
+    write(chunk: string): Promise<void>;
+};
+export declare const writeToStream: (stream: QueueWritable, chunk: string, label: string) => Promise<void>;
+export declare const createWriteQueue: (stream: QueueWritable, label: string) => WriteQueue;
+export {};