knitting 0.1.53 → 0.1.55

package/src/common/path-canonical.js

@@ -1,41 +0,0 @@
-import { existsSync, realpathSync, } from "node:fs";
-import { basename as pathBasename, dirname as pathDirname, join as pathJoin, resolve as pathResolve, } from "node:path";
-export const toCanonicalPath = (candidate, fsApi = {
-    existsSync,
-    realpathSync: realpathSync.native ?? realpathSync,
-}) => {
-    const absolute = pathResolve(candidate);
-    const { existsSync, realpathSync } = fsApi;
-    if (typeof realpathSync === "function") {
-        try {
-            return pathResolve(realpathSync(absolute));
-        }
-        catch {
-        }
-    }
-    else {
-        return absolute;
-    }
-    if (typeof existsSync !== "function")
-        return absolute;
-    const missingSegments = [];
-    let cursor = absolute;
-    while (!existsSync(cursor)) {
-        const parent = pathDirname(cursor);
-        if (parent === cursor)
-            return absolute;
-        missingSegments.push(pathBasename(cursor));
-        cursor = parent;
-    }
-    let base = cursor;
-    try {
-        base = realpathSync(cursor);
-    }
-    catch {
-    }
-    let rebuilt = base;
-    for (let i = missingSegments.length - 1; i >= 0; i--) {
-        rebuilt = pathJoin(rebuilt, missingSegments[i]);
-    }
-    return pathResolve(rebuilt);
-};

package/src/common/runtime.d.ts

@@ -1,15 +0,0 @@
-type RuntimeName = "deno" | "bun" | "node" | "unknown";
-export declare const IS_DENO: boolean;
-export declare const IS_BUN: boolean;
-export declare const IS_NODE: boolean;
-export declare const RUNTIME: RuntimeName;
-export declare const SET_IMMEDIATE: typeof setImmediate & ((cb: () => void) => void);
-export declare const HAS_SHARED_WASM_MEMORY: boolean;
-export declare const createWasmSharedArrayBuffer: (byteLength: number, maxByteLength?: number) => SharedArrayBuffer;
-export declare const HAS_SAB_GROW: boolean;
-export declare const createSharedArrayBuffer: (byteLength: number, maxByteLength?: number) => SharedArrayBuffer;
-export declare const isWasmSharedArrayBuffer: (sab: SharedArrayBuffer) => boolean;
-export declare const isGrowableSharedArrayBuffer: (sab: SharedArrayBuffer) => boolean;
-export declare const sharedArrayBufferMaxByteLength: (sab: SharedArrayBuffer) => number;
-export declare const growSharedArrayBuffer: (sab: SharedArrayBuffer, byteLength: number) => SharedArrayBuffer;
-export {};

package/src/common/runtime.js

@@ -1,91 +0,0 @@
-import { getNodeProcess } from "./node-compat.js";
-const globals = globalThis;
-const nodeProcess = getNodeProcess();
-export const IS_DENO = typeof globals.Deno?.version?.deno === "string";
-export const IS_BUN = typeof globals.Bun?.version === "string";
-export const IS_NODE = typeof nodeProcess?.versions?.node === "string";
-export const RUNTIME = (IS_DENO ? "deno" : IS_BUN ? "bun" : IS_NODE ? "node" : "unknown");
-export const SET_IMMEDIATE = typeof globals.setImmediate === "function" ? globals.setImmediate : undefined;
-const WASM_MEMORY_PAGE_BYTES = 64 * 1024;
-const wasmSharedBufferMemory = new WeakMap();
-const wasmSharedBufferMaxByteLength = new WeakMap();
-const hasSharedWasmMemory = (() => {
-    if (typeof WebAssembly?.Memory !== "function")
-        return false;
-    try {
-        void new WebAssembly.Memory({ initial: 0, maximum: 1, shared: true });
-        return true;
-    }
-    catch {
-        return false;
-    }
-})();
-export const HAS_SHARED_WASM_MEMORY = hasSharedWasmMemory;
-const roundupWasmPages = (byteLength) => Math.ceil(Math.max(0, byteLength) / WASM_MEMORY_PAGE_BYTES);
-const createSharedWasmBuffer = (byteLength, maxByteLength) => {
-    const memory = new WebAssembly.Memory({
-        initial: roundupWasmPages(byteLength),
-        maximum: Math.max(roundupWasmPages(byteLength), roundupWasmPages(maxByteLength)),
-        shared: true,
-    });
-    const buffer = memory.buffer;
-    wasmSharedBufferMemory.set(buffer, memory);
-    wasmSharedBufferMaxByteLength.set(buffer, maxByteLength);
-    return buffer;
-};
-export const createWasmSharedArrayBuffer = (byteLength, maxByteLength = byteLength) => {
-    if (hasSharedWasmMemory) {
-        return createSharedWasmBuffer(byteLength, maxByteLength);
-    }
-    return new SharedArrayBuffer(byteLength);
-};
-const HAS_NATIVE_SAB_GROW = typeof SharedArrayBuffer === "function" &&
-    typeof SharedArrayBuffer.prototype.grow === "function";
-export const HAS_SAB_GROW = HAS_NATIVE_SAB_GROW || hasSharedWasmMemory;
-export const createSharedArrayBuffer = (byteLength, maxByteLength) => {
-    if (HAS_NATIVE_SAB_GROW && typeof maxByteLength === "number") {
-        return new SharedArrayBuffer(byteLength, { maxByteLength });
-    }
-    if (hasSharedWasmMemory && typeof maxByteLength === "number") {
-        return createSharedWasmBuffer(byteLength, maxByteLength);
-    }
-    return new SharedArrayBuffer(byteLength);
-};
-export const isWasmSharedArrayBuffer = (sab) => wasmSharedBufferMemory.has(sab);
-export const isGrowableSharedArrayBuffer = (sab) => {
-    const value = sab;
-    return (HAS_NATIVE_SAB_GROW &&
-        typeof value.grow === "function" &&
-        value.growable === true) ||
-        wasmSharedBufferMemory.has(sab);
-};
-export const sharedArrayBufferMaxByteLength = (sab) => {
-    const value = sab;
-    if (typeof value.maxByteLength === "number") {
-        return value.maxByteLength;
-    }
-    return wasmSharedBufferMaxByteLength.get(sab) ?? sab.byteLength;
-};
-export const growSharedArrayBuffer = (sab, byteLength) => {
-    const native = sab;
-    if (typeof native.grow === "function") {
-        native.grow(byteLength);
-        return sab;
-    }
-    const memory = wasmSharedBufferMemory.get(sab);
-    if (memory == null) {
-        throw new TypeError("SharedArrayBuffer is not growable");
-    }
-    const currentBuffer = memory.buffer;
-    if (currentBuffer.byteLength >= byteLength) {
-        return currentBuffer;
-    }
-    const targetPages = roundupWasmPages(byteLength);
-    const currentPages = roundupWasmPages(currentBuffer.byteLength);
-    memory.grow(targetPages - currentPages);
-    const nextBuffer = memory.buffer;
-    const maxByteLength = wasmSharedBufferMaxByteLength.get(sab) ?? currentBuffer.byteLength;
-    wasmSharedBufferMemory.set(nextBuffer, memory);
-    wasmSharedBufferMaxByteLength.set(nextBuffer, maxByteLength);
-    return nextBuffer;
-};

package/src/common/shared-buffer-region.d.ts

@@ -1,11 +0,0 @@
-export type SharedBuffer = SharedArrayBuffer | ArrayBuffer;
-export type SharedBufferRegion = {
-    sab: SharedBuffer;
-    byteOffset: number;
-    byteLength: number;
-};
-export type SharedBufferSource = SharedBuffer | SharedBufferRegion;
-export declare const isSharedBuffer: (value: unknown) => value is SharedBuffer;
-export declare const isSharedBufferRegion: (value: unknown) => value is SharedBufferRegion;
-export declare const isSharedBufferSource: (value: unknown) => value is SharedBufferSource;
-export declare const toSharedBufferRegion: (value: SharedBufferSource) => SharedBufferRegion;

package/src/common/shared-buffer-region.js

@@ -1,21 +0,0 @@
-export const isSharedBuffer = (value) => value instanceof SharedArrayBuffer || value instanceof ArrayBuffer;
-export const isSharedBufferRegion = (value) => {
-    if (!value || typeof value !== "object")
-        return false;
-    const candidate = value;
-    return isSharedBuffer(candidate.sab) &&
-        typeof candidate.byteOffset === "number" &&
-        Number.isInteger(candidate.byteOffset) &&
-        candidate.byteOffset >= 0 &&
-        typeof candidate.byteLength === "number" &&
-        Number.isInteger(candidate.byteLength) &&
-        candidate.byteLength >= 0;
-};
-export const isSharedBufferSource = (value) => isSharedBuffer(value) || isSharedBufferRegion(value);
-export const toSharedBufferRegion = (value) => isSharedBuffer(value)
-    ? {
-        sab: value,
-        byteOffset: 0,
-        byteLength: value.byteLength,
-    }
-    : value;

package/src/common/shared-buffer-text.d.ts

@@ -1,16 +0,0 @@
-import { type SharedBufferSource } from "./shared-buffer-region.js";
-export type SharedBufferTextCompat = {
-    encodeInto: boolean;
-    decode: boolean;
-};
-export type LockBufferTextCompat = {
-    headers: SharedBufferTextCompat;
-    payload: SharedBufferTextCompat;
-};
-export declare const isSharedBufferTextCompat: (value: unknown) => value is SharedBufferTextCompat;
-export declare const isLockBufferTextCompat: (value: unknown) => value is LockBufferTextCompat;
-export declare const probeSharedBufferTextCompat: (source: SharedBufferSource) => SharedBufferTextCompat;
-export declare const probeLockBufferTextCompat: ({ headers, payload, }: {
-    headers: SharedBufferSource;
-    payload: SharedBufferSource;
-}) => LockBufferTextCompat;

package/src/common/shared-buffer-text.js

@@ -1,65 +0,0 @@
-import { toSharedBufferRegion, } from "./shared-buffer-region.js";
-const textEncode = new TextEncoder();
-const textDecode = new TextDecoder();
-const isSharedBufferTextCompatTypeError = (error) => error instanceof TypeError;
-const makeProbeView = (source) => {
-    const region = toSharedBufferRegion(source);
-    const probeLength = Math.min(1, region.byteLength);
-    return new Uint8Array(region.sab, region.byteOffset, probeLength);
-};
-export const isSharedBufferTextCompat = (value) => {
-    if (!value || typeof value !== "object")
-        return false;
-    const candidate = value;
-    return typeof candidate.encodeInto === "boolean" &&
-        typeof candidate.decode === "boolean";
-};
-export const isLockBufferTextCompat = (value) => {
-    if (!value || typeof value !== "object")
-        return false;
-    const candidate = value;
-    return isSharedBufferTextCompat(candidate.headers) &&
-        isSharedBufferTextCompat(candidate.payload);
-};
-export const probeSharedBufferTextCompat = (source) => {
-    const view = makeProbeView(source);
-    const encodeInto = (() => {
-        if (typeof textEncode.encodeInto !== "function")
-            return false;
-        const probe = view.byteLength > 0 ? view : view.subarray(0, 0);
-        const restoredByte = probe.byteLength > 0 ? probe[0] : undefined;
-        try {
-            textEncode.encodeInto(probe.byteLength > 0 ? "a" : "", probe);
-            return true;
-        }
-        catch (error) {
-            if (!isSharedBufferTextCompatTypeError(error))
-                throw error;
-            return false;
-        }
-        finally {
-            if (restoredByte !== undefined) {
-                probe[0] = restoredByte;
-            }
-        }
-    })();
-    const decode = (() => {
-        try {
-            textDecode.decode(view);
-            return true;
-        }
-        catch (error) {
-            if (!isSharedBufferTextCompatTypeError(error))
-                throw error;
-            return false;
-        }
-    })();
-    return {
-        encodeInto,
-        decode,
-    };
-};
-export const probeLockBufferTextCompat = ({ headers, payload, }) => ({
-    headers: probeSharedBufferTextCompat(headers),
-    payload: probeSharedBufferTextCompat(payload),
-});

package/src/common/task-source.d.ts

@@ -1,3 +0,0 @@
-export declare const genTaskID: () => number;
-export declare const getCallerHref: (offset?: number) => string;
-export declare const getCallerFilePath: (offset?: number) => [string, number];

package/src/common/task-source.js

@@ -1,84 +0,0 @@
-import { toModuleUrl } from "./module-url.js";
-export const genTaskID = ((counter) => () => counter++)(0);
-const INTERNAL_CALLER_HINTS = [
-    "/src/common/task-source.ts",
-    "/src/common/task-source.js",
-    "\\src\\common\\task-source.ts",
-    "\\src\\common\\task-source.js",
-    "/src/api.ts",
-    "/src/api.js",
-    "\\src\\api.ts",
-    "\\src\\api.js",
-];
-const INTERNAL_CALLER_FUNCTIONS = new Set([
-    "collectStackFrames",
-    "resolveCallerHref",
-    "getCallerFilePath",
-    "buildTaskDefinition",
-    "buildTaskDefinitionFromCaller",
-    "task",
-    "importTask",
-]);
-const isDefined = (value) => value !== undefined;
-const isInternalCallerFrame = (file) => INTERNAL_CALLER_HINTS.some((hint) => file.includes(hint));
-const isRuntimeInternalFrame = (file) => file.startsWith("node:") ||
-    file.startsWith("native:") ||
-    file.startsWith("bun:") ||
-    file.startsWith("internal/");
-const isInternalCallerFunction = (functionName, methodName) => (functionName !== undefined && INTERNAL_CALLER_FUNCTIONS.has(functionName)) ||
-    (methodName !== undefined && INTERNAL_CALLER_FUNCTIONS.has(methodName));
-const collectStackFrames = () => {
-    const ErrorCtor = Error;
-    const original = ErrorCtor.prepareStackTrace;
-    try {
-        ErrorCtor.prepareStackTrace = (_error, stack) => stack;
-        const stack = new Error().stack;
-        if (!Array.isArray(stack))
-            return [];
-        const frames = stack
-            .map((site) => {
-            try {
-                const file = site?.getFileName?.();
-                if (typeof file !== "string" || file.length === 0)
-                    return undefined;
-                return {
-                    file,
-                    functionName: site?.getFunctionName?.() ?? undefined,
-                    methodName: site?.getMethodName?.() ?? undefined,
-                };
-            }
-            catch {
-                return undefined;
-            }
-        })
-            .filter(isDefined);
-        return frames;
-    }
-    finally {
-        ErrorCtor.prepareStackTrace = original;
-    }
-};
-const isInternalFrame = (frame) => isRuntimeInternalFrame(frame.file) ||
-    isInternalCallerFrame(frame.file) ||
-    isInternalCallerFunction(frame.functionName, frame.methodName);
-const resolveCallerHref = (offset) => {
-    const frames = collectStackFrames();
-    const direct = frames[offset];
-    const caller = (direct && !isInternalFrame(direct)
-        ? direct.file
-        : undefined) ??
-        frames.find((frame) => !isInternalFrame(frame))?.file ??
-        frames.find((frame) => !isRuntimeInternalFrame(frame.file))?.file;
-    if (!caller) {
-        throw new Error("Unable to determine caller file.");
-    }
-    return toModuleUrl(caller);
-};
-const linkingMap = new Map();
-export const getCallerHref = (offset = 3) => resolveCallerHref(offset);
-export const getCallerFilePath = (offset = 3) => {
-    const href = resolveCallerHref(offset);
-    const at = linkingMap.get(href) ?? 0;
-    linkingMap.set(href, at + 1);
-    return [href, at];
-};

package/src/common/task-symbol.d.ts

@@ -1 +0,0 @@
-export declare const endpointSymbol: unique symbol;

package/src/common/task-symbol.js

@@ -1 +0,0 @@
-export const endpointSymbol = Symbol.for("task");

package/src/common/with-resolvers.d.ts

@@ -1,9 +0,0 @@
-export type PromiseWithMaybeReject<T> = Promise<T> & {
-    reject: (reason?: unknown) => void;
-};
-export type Deferred<T> = {
-    promise: PromiseWithMaybeReject<T>;
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason?: unknown) => void;
-};
-export declare const withResolvers: <T = unknown>() => Deferred<T>;

package/src/common/with-resolvers.js

@@ -1,23 +0,0 @@
-const attachReject = (promise, reject) => {
-    const deferredPromise = promise;
-    deferredPromise.reject = reject;
-    return deferredPromise;
-};
-export const withResolvers = () => {
-    const native = Promise.withResolvers;
-    if (typeof native === "function") {
-        const deferred = native.call(Promise);
-        return {
-            promise: attachReject(deferred.promise, deferred.reject),
-            resolve: deferred.resolve,
-            reject: deferred.reject,
-        };
-    }
-    let resolve;
-    let reject;
-    const promise = attachReject(new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-    }), reject);
-    return { promise, resolve, reject };
-};

package/src/common/worker-runtime.d.ts

@@ -1,42 +0,0 @@
-type RuntimePortMessageHandler = (message: unknown) => void;
-export type RuntimeMessagePortLike = {
-    postMessage: (message: unknown) => void;
-    close?: () => void;
-    start?: () => void;
-    on?: (event: string, handler: (...args: unknown[]) => void) => void;
-    onmessage?: ((event: {
-        data?: unknown;
-    }) => void) | null;
-    addEventListener?: (type: string, listener: (event: {
-        data?: unknown;
-        error?: unknown;
-        message?: unknown;
-    }) => void) => void;
-    removeEventListener?: (type: string, listener: (event: {
-        data?: unknown;
-        error?: unknown;
-        message?: unknown;
-    }) => void) => void;
-};
-export type RuntimeWorkerLike = RuntimeMessagePortLike & {
-    terminate: () => unknown;
-};
-export type RuntimeMessageChannelLike = {
-    port1: RuntimeMessagePortLike;
-    port2: RuntimeMessagePortLike;
-};
-export declare const RUNTIME_PROCESS_WORKER_ENV = "KNITTING_PROCESS_WORKER";
-export declare const RUNTIME_PROCESS_WORKER_BOOT_ENV = "KNITTING_PROCESS_WORKER_BOOT";
-export declare const RUNTIME_PROCESS_WORKER_BOOT_VERSION = 1;
-export declare const RUNTIME_POOL_DEPTH_ENV = "KNITTING_POOL_DEPTH";
-export declare const RUNTIME_IS_PROCESS_WORKER: boolean;
-export declare const RUNTIME_POOL_DEPTH: number;
-export declare const RUNTIME_WORKER: new (specifier: string | URL, options?: Record<string, unknown>) => RuntimeWorkerLike;
-export declare const RUNTIME_MESSAGE_CHANNEL: new () => RuntimeMessageChannelLike;
-export declare const HAS_NODE_WORKER_THREADS: boolean;
-export declare const RUNTIME_IS_MAIN_THREAD: boolean;
-export declare const RUNTIME_WORKER_DATA: unknown;
-export declare const RUNTIME_PARENT_PORT: RuntimeMessagePortLike;
-export declare const createRuntimeMessageChannel: () => RuntimeMessageChannelLike;
-export declare const addRuntimeDataListener: (target: RuntimeMessagePortLike, handler: RuntimePortMessageHandler) => void;
-export {};

package/src/common/worker-runtime.js

@@ -1,61 +0,0 @@
-import { getNodeBuiltinModule, getNodeProcess } from "./node-compat.js";
-export const RUNTIME_PROCESS_WORKER_ENV = "KNITTING_PROCESS_WORKER";
-export const RUNTIME_PROCESS_WORKER_BOOT_ENV = "KNITTING_PROCESS_WORKER_BOOT";
-export const RUNTIME_PROCESS_WORKER_BOOT_VERSION = 1;
-export const RUNTIME_POOL_DEPTH_ENV = "KNITTING_POOL_DEPTH";
-const nodeProcess = getNodeProcess();
-export const RUNTIME_IS_PROCESS_WORKER = nodeProcess?.env?.[RUNTIME_PROCESS_WORKER_ENV] === "1";
-const readPoolDepth = () => {
-    const raw = nodeProcess?.env?.[RUNTIME_POOL_DEPTH_ENV];
-    if (typeof raw !== "string")
-        return 0;
-    const parsed = Number.parseInt(raw, 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
-};
-export const RUNTIME_POOL_DEPTH = readPoolDepth();
-const workerThreads = getNodeBuiltinModule("node:worker_threads");
-const isWorkerGlobalScope = () => {
-    const scopeCtor = globalThis.WorkerGlobalScope;
-    if (typeof scopeCtor !== "function")
-        return false;
-    try {
-        return globalThis instanceof
-            scopeCtor;
-    }
-    catch {
-        return false;
-    }
-};
-export const RUNTIME_WORKER = workerThreads?.Worker ??
-    (globalThis.Worker);
-export const RUNTIME_MESSAGE_CHANNEL = workerThreads?.MessageChannel ??
-    (globalThis
-        .MessageChannel);
-export const HAS_NODE_WORKER_THREADS = workerThreads != null;
-export const RUNTIME_IS_MAIN_THREAD = RUNTIME_IS_PROCESS_WORKER
-    ? false
-    : workerThreads?.isMainThread ?? !isWorkerGlobalScope();
-export const RUNTIME_WORKER_DATA = workerThreads?.workerData;
-export const RUNTIME_PARENT_PORT = workerThreads?.parentPort ??
-    (RUNTIME_IS_PROCESS_WORKER && typeof nodeProcess?.send === "function"
-        ? {
-            postMessage: (message) => nodeProcess.send(message),
-        }
-        : undefined);
-export const createRuntimeMessageChannel = () => {
-    if (typeof RUNTIME_MESSAGE_CHANNEL !== "function") {
-        throw new Error("MessageChannel is not available in this runtime");
-    }
-    return new RUNTIME_MESSAGE_CHANNEL();
-};
-export const addRuntimeDataListener = (target, handler) => {
-    if (typeof target.on === "function") {
-        target.on("message", handler);
-        return;
-    }
-    if (typeof target.addEventListener === "function") {
-        target.addEventListener("message", (event) => handler(event?.data));
-        return;
-    }
-    target.onmessage = (event) => handler(event?.data);
-};

package/src/connections/buffer-reference-native.d.ts

@@ -1,56 +0,0 @@
-export type BufferReferenceRuntime = "node" | "deno" | "bun";
-/** A backing store the producer has taken exclusive ownership of (source detached). */
-export type ProducedBuffer = {
-    /** Producer-side release handle. */
-    token: bigint;
-    /** Address of the region start (view offset already applied). */
-    pointer: bigint;
-    /** Offset of the region inside the backing store (used by the Node owning adopt). */
-    byteOffset: number;
-    byteLength: number;
-};
-export type AdoptInput = {
-    token: bigint;
-    pointer: bigint;
-    byteOffset: number;
-    byteLength: number;
-};
-/** The materialized region: bytes live in `buffer` at `[byteOffset, byteOffset+byteLength)`. */
-export type AdoptedRegion = {
-    buffer: ArrayBuffer;
-    byteOffset: number;
-    byteLength: number;
-};
-/** Materialized SAB region; `isShared` means `buffer` is a real SharedArrayBuffer. */
-export type SharedAdoptedRegion = {
-    buffer: SharedArrayBuffer | ArrayBuffer;
-    byteOffset: number;
-    byteLength: number;
-    isShared: boolean;
-};
-export type AdoptOptions = {
-    /** Copy when bytes must survive producer release on non-owning runtimes. */
-    copy?: boolean;
-};
-type MovableBufferSource = ArrayBuffer | ArrayBufferView;
-export type BufferReferenceCapabilities = {
-    readonly runtime: BufferReferenceRuntime;
-    /** True when `adopt` returns a buffer that co-owns the store and survives `release`. */
-    readonly supportsOwningAdopt: boolean;
-    /** Take exclusive ownership of `source`'s bytes, detaching the source. */
-    produce(source: MovableBufferSource): ProducedBuffer;
-    /** Materialize the region in the current isolate (owning on Node, alias/copy elsewhere). */
-    adopt(input: AdoptInput, opts?: AdoptOptions): AdoptedRegion;
-    /** Drop the producer's hold on the backing store. */
-    release(token: bigint): void;
-    /** True when `adoptShared` returns a real SharedArrayBuffer (Node). */
-    readonly supportsSharedAdopt: boolean;
-    /** Share a SharedArrayBuffer by reference (no detach — SABs persist). */
-    produceShared(sab: SharedArrayBuffer): ProducedBuffer;
-    /** Materialize a shared region as a non-owning alias over the same bytes. */
-    adoptShared(input: AdoptInput): SharedAdoptedRegion;
-    /** Drop the producer's pin on a shared buffer (JS-side; teardown-safe). */
-    releaseShared(token: bigint): void;
-};
-export declare const getBufferReferenceCapabilities: () => BufferReferenceCapabilities;
-export {};