knitting 0.1.55 → 0.1.56

package/src/connections/package-assets.js

@@ -0,0 +1,45 @@
+import { existsSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const safeExists = (path) => {
+    try {
+        return existsSync(path);
+    }
+    catch {
+        return false;
+    }
+};
+const safeIsDirectory = (path) => {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+};
+const moduleDirectory = (moduleUrl) => {
+    const path = fileURLToPath(moduleUrl);
+    return safeIsDirectory(path) ? path : dirname(path);
+};
+const isKnittingPackageRoot = (dir) => safeExists(join(dir, "package.json")) &&
+    (safeExists(join(dir, "prebuilds")) ||
+        safeExists(join(dir, "src")) ||
+        safeExists(join(dir, "build")));
+let cachedPackageRoot;
+export const findKnittingPackageRoot = (moduleUrl = import.meta.url) => {
+    if (cachedPackageRoot !== undefined)
+        return cachedPackageRoot;
+    let current = moduleDirectory(moduleUrl);
+    while (true) {
+        if (isKnittingPackageRoot(current)) {
+            cachedPackageRoot = current;
+            return current;
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            throw new Error(`Could not locate knitting package root from ${moduleUrl}`);
+        }
+        current = parent;
+    }
+};
+export const resolveKnittingPackageAsset = (...segments) => join(findKnittingPackageRoot(), ...segments);

package/src/connections/posix.d.ts

@@ -0,0 +1,32 @@
+export type PosixPlatform = "linux" | "darwin";
+export declare const LINUX_LIBC_SO = "libc.so.6";
+export declare const DARWIN_LIBSYSTEM = "/usr/lib/libSystem.B.dylib";
+export declare const PROT_READ = 1;
+export declare const PROT_WRITE = 2;
+export declare const MAP_SHARED = 1;
+export declare const O_RDWR = 2;
+export declare const LINUX_O_CREAT = 64;
+export declare const LINUX_O_EXCL = 128;
+export declare const DARWIN_O_CREAT = 512;
+export declare const DARWIN_O_EXCL = 2048;
+export declare const DARWIN_SHM_MODE = 384;
+export declare const POSIX_SHM_MODE = 384;
+export declare const F_GETFD = 1;
+export declare const F_SETFD = 2;
+export declare const FD_CLOEXEC = 1;
+export declare const encodeCString: (value: string) => Uint8Array;
+type FcntlLibc = {
+    symbols: {
+        fcntl: (fd: number, cmd: number, arg: number) => number;
+    };
+};
+export declare const setCloseOnExec: <T extends FcntlLibc>(libc: T, fd: number) => number;
+export declare const shmOpenCreateFlag: (platform: PosixPlatform) => number;
+export declare const shmOpenExclusiveFlag: (platform: PosixPlatform) => number;
+export declare const POSIX_SHM_MAX_NAME_LEN = 30;
+export declare const toPosixSharedMemoryName: (name: string) => string;
+export declare const detectPosixPlatform: () => PosixPlatform;
+export declare const assertPosixSharedMemoryPlatform: (feature: string) => void;
+export declare const getPosixLibcPath: (platform?: PosixPlatform) => string;
+export declare const makeDarwinSharedMemoryName: (_name: string, runtime: string) => string;
+export {};

package/src/connections/posix.js

@@ -0,0 +1,77 @@
+export const LINUX_LIBC_SO = "libc.so.6";
+export const DARWIN_LIBSYSTEM = "/usr/lib/libSystem.B.dylib";
+export const PROT_READ = 1;
+export const PROT_WRITE = 2;
+export const MAP_SHARED = 1;
+export const O_RDWR = 0x0002;
+export const LINUX_O_CREAT = 0x0040;
+export const LINUX_O_EXCL = 0x0080;
+export const DARWIN_O_CREAT = 0x0200;
+export const DARWIN_O_EXCL = 0x0800;
+export const DARWIN_SHM_MODE = 0o600;
+export const POSIX_SHM_MODE = 0o600;
+export const F_GETFD = 1;
+export const F_SETFD = 2;
+export const FD_CLOEXEC = 1;
+export const encodeCString = (value) => new TextEncoder().encode(`${value}\0`);
+export const setCloseOnExec = (libc, fd) => {
+    const flags = libc.symbols.fcntl(fd, F_GETFD, 0);
+    if (flags < 0) {
+        throw new Error("fcntl(F_GETFD) failed");
+    }
+    const result = libc.symbols.fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
+    if (result < 0) {
+        throw new Error("fcntl(F_SETFD) failed");
+    }
+    return fd;
+};
+export const shmOpenCreateFlag = (platform) => platform === "darwin" ? DARWIN_O_CREAT : LINUX_O_CREAT;
+export const shmOpenExclusiveFlag = (platform) => platform === "darwin" ? DARWIN_O_EXCL : LINUX_O_EXCL;
+// macOS limits POSIX shared memory names to 31 characters including the
+// leading "/", so the usable name portion is at most 30 characters.
+export const POSIX_SHM_MAX_NAME_LEN = 30;
+export const toPosixSharedMemoryName = (name) => {
+    if (name.length === 0) {
+        throw new TypeError("shared memory name must be non-empty");
+    }
+    if (name.includes("\0")) {
+        throw new TypeError("shared memory name must not contain NUL bytes");
+    }
+    const out = name.startsWith("/") ? name : `/${name}`;
+    if (out.length < 2 || out.slice(1).includes("/")) {
+        throw new TypeError("POSIX shared memory name must not contain path separators");
+    }
+    if (out.length > POSIX_SHM_MAX_NAME_LEN + 1) {
+        throw new TypeError(`POSIX shared memory name must be at most ${POSIX_SHM_MAX_NAME_LEN} characters (macOS limit); got ${out.length - 1}`);
+    }
+    return out;
+};
+export const detectPosixPlatform = () => {
+    const denoOs = globalThis.Deno?.build?.os;
+    if (denoOs === "darwin" || denoOs === "linux")
+        return denoOs;
+    const processPlatform = globalThis.process?.platform;
+    if (processPlatform === "darwin" || processPlatform === "linux") {
+        return processPlatform;
+    }
+    throw new Error("shared memory connections support Linux and macOS only");
+};
+export const assertPosixSharedMemoryPlatform = (feature) => {
+    try {
+        detectPosixPlatform();
+    }
+    catch {
+        throw new Error(`${feature} is supported on Linux and macOS only`);
+    }
+};
+export const getPosixLibcPath = (platform = detectPosixPlatform()) => platform === "darwin" ? DARWIN_LIBSYSTEM : LINUX_LIBC_SO;
+export const makeDarwinSharedMemoryName = (_name, runtime) => {
+    const processId = globalThis.process?.pid ??
+        globalThis.Deno?.pid ??
+        0;
+    const runtimeTag = runtime.slice(0, 1) || "x";
+    const pidTag = Math.abs(processId).toString(36).slice(-5);
+    const timeTag = Date.now().toString(36).slice(-6);
+    const nonce = Math.random().toString(36).slice(2, 6);
+    return `/knit_${runtimeTag}_${pidTag}_${timeTag}_${nonce}`;
+};

package/src/connections/process-shared-buffer.d.ts

@@ -0,0 +1,75 @@
+import type { SharedBuffer, SharedBufferRegion } from "../common/shared-buffer-region.js";
+import { FileDescriptor, type FileDescriptorMetadata } from "./file-descriptor.js";
+import { type CreateSharedMemoryOptions, type SharedMemoryConnectionPrimitives, type SharedMemoryMapping } from "./types.js";
+export type ProcessSharedBufferMetadata = {
+    version: 1;
+    descriptor: FileDescriptorMetadata;
+    byteOffset: number;
+    byteLength: number;
+};
+export declare const PROCESS_SHARED_BUFFER_BRAND: unique symbol;
+export declare const PROCESS_SHARED_BUFFER_NUMERIC_TRANSFER: unique symbol;
+declare const EXTERNAL_PAYLOAD_BRAND: unique symbol;
+export type ProcessSharedBufferNumericMetadata = readonly [
+    fd: number,
+    size: number,
+    descriptorByteLength: number,
+    byteOffset: number,
+    byteLength: number,
+    runtime: number,
+    kind: number,
+    baseAddressMod64: number
+];
+export type ProcessSharedBufferRange = {
+    byteOffset?: number;
+    byteLength?: number;
+};
+export type ProcessSharedBufferCreator = Pick<SharedMemoryConnectionPrimitives, "createSharedMemory">;
+export type ProcessSharedBufferMapper = Pick<SharedMemoryConnectionPrimitives, "mapSharedMemory">;
+export type ProcessSharedBufferPrimitives = Pick<SharedMemoryConnectionPrimitives, "createSharedMemory" | "mapSharedMemory"> & {
+    unlinkSharedMemory?: (name: string) => boolean;
+};
+export type ProcessSharedBufferView = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | BigInt64Array | BigUint64Array | Float32Array | Float64Array;
+export type ProcessSharedBufferViewConstructor<View extends ProcessSharedBufferView = ProcessSharedBufferView> = {
+    readonly BYTES_PER_ELEMENT: number;
+    new (buffer: SharedBuffer, byteOffset: number, length: number): View;
+};
+export declare const setDefaultProcessSharedBufferPrimitives: (primitives: ProcessSharedBufferPrimitives | undefined) => void;
+export declare const getDefaultProcessSharedBufferPrimitives: () => ProcessSharedBufferPrimitives;
+/**
+ * Zero-copy shared bytes for process workers.
+ *
+ * Use this when the boundary is a separate process, container, or sandbox.
+ * For thread workers, `SharedArrayBuffer` or `BufferReference` can be cheaper.
+ */
+export declare class ProcessSharedBuffer {
+    readonly [PROCESS_SHARED_BUFFER_BRAND] = true;
+    readonly [EXTERNAL_PAYLOAD_BRAND] = "knitting.processSharedBuffer";
+    readonly descriptor: FileDescriptor;
+    readonly byteOffset: number;
+    readonly byteLength: number;
+    constructor(descriptor: FileDescriptor, range?: ProcessSharedBufferRange);
+    static create(options: number | CreateSharedMemoryOptions, creator?: ProcessSharedBufferCreator): ProcessSharedBuffer;
+    static fromMapping(mapping: SharedMemoryMapping): ProcessSharedBuffer;
+    static fromDescriptor(descriptor: FileDescriptor, range?: ProcessSharedBufferRange): ProcessSharedBuffer;
+    static fromMetadata(metadata: unknown): ProcessSharedBuffer;
+    static parse(serialized: string): ProcessSharedBuffer;
+    static [PROCESS_SHARED_BUFFER_NUMERIC_TRANSFER](metadata: ProcessSharedBufferNumericMetadata): ProcessSharedBuffer;
+    get fd(): number;
+    get size(): number;
+    subbuffer(byteOffset: number, byteLength?: number): ProcessSharedBuffer;
+    getSharedArrayBuffer(mapper?: ProcessSharedBufferMapper): SharedArrayBuffer;
+    getSAB(mapper?: ProcessSharedBufferMapper): SharedArrayBuffer;
+    getBuffer(mapper?: ProcessSharedBufferMapper): SharedBuffer;
+    getRegion(mapper?: ProcessSharedBufferMapper): SharedBufferRegion;
+    view<View extends ProcessSharedBufferView>(constructor: ProcessSharedBufferViewConstructor<View>, mapper?: ProcessSharedBufferMapper): View;
+    bytes(mapper?: ProcessSharedBufferMapper): Uint8Array;
+    dataView(mapper?: ProcessSharedBufferMapper): DataView;
+    toMetadata(): ProcessSharedBufferMetadata;
+    toJSON(): ProcessSharedBufferMetadata;
+    stringify(): string;
+    stringifyMetadata(): string;
+    toString(): string;
+}
+export declare const parseProcessSharedBufferMetadata: (input: unknown) => ProcessSharedBufferMetadata;
+export {};

package/src/connections/process-shared-buffer.js

@@ -0,0 +1,279 @@
+import { getNodeBuiltinModule } from "../common/node-compat.js";
+import { FileDescriptor, } from "./file-descriptor.js";
+import { RUNTIME } from "../common/runtime.js";
+import { createBunConnectionPrimitives } from "./bun.js";
+import { createDenoConnectionPrimitives } from "./deno.js";
+import { loadNodeNativeAddon } from "./node-addons.js";
+import { expectFd, expectPositiveSize, readCreateMode, readCreateName, readRequiredCreateName, readCreateSize, } from "./types.js";
+export const PROCESS_SHARED_BUFFER_BRAND = Symbol.for("knitting.processSharedBuffer");
+export const PROCESS_SHARED_BUFFER_NUMERIC_TRANSFER = Symbol.for("knitting.processSharedBuffer.numericTransfer");
+const EXTERNAL_PAYLOAD_BRAND = Symbol.for("knitting.payloadCodec");
+const PROCESS_SHARED_BUFFER_CODEC_ID = "knitting.processSharedBuffer";
+const isRecord = (value) => typeof value === "object" && value !== null;
+const NUMERIC_SENTINEL = 0xffffffff;
+const RUNTIME_NODE = 1;
+const RUNTIME_DENO = 2;
+const RUNTIME_BUN = 3;
+const KIND_SHARED_ARRAY_BUFFER = 1;
+const KIND_EXTERNAL_ARRAY_BUFFER = 2;
+const decodeRuntime = (value) => {
+    switch (value) {
+        case RUNTIME_NODE:
+            return "node";
+        case RUNTIME_DENO:
+            return "deno";
+        case RUNTIME_BUN:
+            return "bun";
+        default:
+            return undefined;
+    }
+};
+const decodeKind = (value) => {
+    switch (value) {
+        case KIND_SHARED_ARRAY_BUFFER:
+            return "shared-array-buffer";
+        case KIND_EXTERNAL_ARRAY_BUFFER:
+            return "external-array-buffer";
+        default:
+            return undefined;
+    }
+};
+let defaultPrimitives;
+const fromDefaultNodeNativeMapping = (mapped) => {
+    const mapping = {
+        runtime: "node",
+        fd: mapped.fd,
+        size: mapped.size,
+        byteLength: mapped.sab.byteLength,
+        buffer: mapped.sab,
+        kind: "shared-array-buffer",
+        sab: mapped.sab,
+        baseAddressMod64: mapped.baseAddressMod64,
+    };
+    if (mapped.name !== undefined && mapped.name.length > 0) {
+        mapping.name = mapped.name;
+    }
+    return mapping;
+};
+const createDefaultNodePrimitives = () => {
+    const nodeModule = getNodeBuiltinModule("node:module");
+    if (nodeModule === undefined) {
+        throw new TypeError("ProcessSharedBuffer needs connection primitives in this runtime");
+    }
+    const require = nodeModule.createRequire(import.meta.url);
+    const addon = loadNodeNativeAddon(require, "knitting_shared_memory");
+    return {
+        createSharedMemory: (options) => {
+            const size = expectPositiveSize(readCreateSize(options));
+            const mode = readCreateMode(options);
+            const name = mode === "anonymous"
+                ? readCreateName(options, "knitting_shared_memory")
+                : readRequiredCreateName(options);
+            return fromDefaultNodeNativeMapping(addon.createSharedMemory(size, name, mode));
+        },
+        mapSharedMemory: (options) => {
+            const fd = expectFd(options.fd);
+            const size = expectPositiveSize(options.size);
+            return fromDefaultNodeNativeMapping(addon.mapSharedMemory(fd, size, options.name));
+        },
+    };
+};
+const createDefaultPrimitives = () => {
+    if (RUNTIME === "bun")
+        return createBunConnectionPrimitives();
+    if (RUNTIME === "deno")
+        return createDenoConnectionPrimitives();
+    return createDefaultNodePrimitives();
+};
+export const setDefaultProcessSharedBufferPrimitives = (primitives) => {
+    defaultPrimitives = primitives;
+};
+export const getDefaultProcessSharedBufferPrimitives = () => {
+    defaultPrimitives ??= createDefaultPrimitives();
+    return defaultPrimitives;
+};
+const expectNonNegativeInteger = (value, label) => {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new RangeError(`${label} must be a non-negative integer`);
+    }
+    return value;
+};
+const readOptionalNonNegativeInteger = (value, label) => {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "number") {
+        throw new TypeError(`${label} must be a number`);
+    }
+    return expectNonNegativeInteger(value, label);
+};
+const expectRange = (byteOffset, byteLength, availableByteLength) => {
+    expectNonNegativeInteger(byteOffset, "process shared buffer byteOffset");
+    if (byteOffset > availableByteLength) {
+        throw new RangeError("process shared buffer byteOffset is out of bounds");
+    }
+    expectNonNegativeInteger(byteLength, "process shared buffer byteLength");
+    if (byteLength > availableByteLength - byteOffset) {
+        throw new RangeError("process shared buffer byteLength is out of bounds");
+    }
+};
+/**
+ * Zero-copy shared bytes for process workers.
+ *
+ * Use this when the boundary is a separate process, container, or sandbox.
+ * For thread workers, `SharedArrayBuffer` or `BufferReference` can be cheaper.
+ */
+export class ProcessSharedBuffer {
+    [PROCESS_SHARED_BUFFER_BRAND] = true;
+    [EXTERNAL_PAYLOAD_BRAND] = PROCESS_SHARED_BUFFER_CODEC_ID;
+    descriptor;
+    byteOffset;
+    byteLength;
+    constructor(descriptor, range = {}) {
+        const byteOffset = range.byteOffset ?? 0;
+        const byteLength = range.byteLength ??
+            descriptor.byteLength - byteOffset;
+        expectRange(byteOffset, byteLength, descriptor.byteLength);
+        this.descriptor = descriptor;
+        this.byteOffset = byteOffset;
+        this.byteLength = byteLength;
+    }
+    static create(options, creator = getDefaultProcessSharedBufferPrimitives()) {
+        return ProcessSharedBuffer.fromMapping(creator.createSharedMemory(options));
+    }
+    static fromMapping(mapping) {
+        return new ProcessSharedBuffer(FileDescriptor.fromMapping(mapping));
+    }
+    static fromDescriptor(descriptor, range = {}) {
+        return new ProcessSharedBuffer(descriptor, range);
+    }
+    static fromMetadata(metadata) {
+        const parsed = parseProcessSharedBufferMetadata(metadata);
+        return new ProcessSharedBuffer(FileDescriptor.fromMetadata(parsed.descriptor), {
+            byteOffset: parsed.byteOffset,
+            byteLength: parsed.byteLength,
+        });
+    }
+    static parse(serialized) {
+        return ProcessSharedBuffer.fromMetadata(serialized);
+    }
+    // Rebuilds from the 8 raw words (no name -> no JSON):
+    // fd, size, descByteLength, byteOffset, byteLength, runtime, kind, baseAddressMod64
+    static [PROCESS_SHARED_BUFFER_NUMERIC_TRANSFER](metadata) {
+        const [fd, size, descriptorByteLength, byteOffset, byteLength, runtime, kind, baseAddressMod64,] = metadata;
+        return new ProcessSharedBuffer(new FileDescriptor({
+            version: 1,
+            fd,
+            size,
+            byteLength: descriptorByteLength,
+            runtime: decodeRuntime(runtime),
+            kind: decodeKind(kind),
+            baseAddressMod64: baseAddressMod64 === NUMERIC_SENTINEL
+                ? undefined
+                : baseAddressMod64,
+        }), {
+            byteOffset,
+            byteLength,
+        });
+    }
+    get fd() {
+        return this.descriptor.fd;
+    }
+    get size() {
+        return this.descriptor.size;
+    }
+    subbuffer(byteOffset, byteLength) {
+        const relativeByteOffset = expectNonNegativeInteger(byteOffset, "process shared buffer subbuffer byteOffset");
+        const relativeByteLength = byteLength === undefined
+            ? this.byteLength - relativeByteOffset
+            : expectNonNegativeInteger(byteLength, "process shared buffer subbuffer byteLength");
+        expectRange(relativeByteOffset, relativeByteLength, this.byteLength);
+        return new ProcessSharedBuffer(this.descriptor, {
+            byteOffset: this.byteOffset + relativeByteOffset,
+            byteLength: relativeByteLength,
+        });
+    }
+    getSharedArrayBuffer(mapper) {
+        return this.descriptor.getSAB(mapper ??
+            (this.descriptor.mapping?.sab === undefined
+                ? getDefaultProcessSharedBufferPrimitives()
+                : undefined));
+    }
+    getSAB(mapper) {
+        return this.getSharedArrayBuffer(mapper);
+    }
+    getBuffer(mapper) {
+        return this.descriptor.getBuffer(mapper ??
+            (this.descriptor.mapping?.buffer === undefined
+                ? getDefaultProcessSharedBufferPrimitives()
+                : undefined));
+    }
+    getRegion(mapper) {
+        return {
+            sab: this.getBuffer(mapper),
+            byteOffset: this.byteOffset,
+            byteLength: this.byteLength,
+        };
+    }
+    view(constructor, mapper) {
+        const bytesPerElement = constructor.BYTES_PER_ELEMENT;
+        if (this.byteOffset % bytesPerElement !== 0) {
+            throw new RangeError("process shared buffer byteOffset is not aligned for this view");
+        }
+        if (this.byteLength % bytesPerElement !== 0) {
+            throw new RangeError("process shared buffer byteLength is not aligned for this view");
+        }
+        return new constructor(this.getBuffer(mapper), this.byteOffset, this.byteLength / bytesPerElement);
+    }
+    bytes(mapper) {
+        return this.view(Uint8Array, mapper);
+    }
+    dataView(mapper) {
+        return new DataView(this.getBuffer(mapper), this.byteOffset, this.byteLength);
+    }
+    toMetadata() {
+        return {
+            version: 1,
+            descriptor: this.descriptor.toMetadata(),
+            byteOffset: this.byteOffset,
+            byteLength: this.byteLength,
+        };
+    }
+    toJSON() {
+        return this.toMetadata();
+    }
+    stringify() {
+        return JSON.stringify(this.toMetadata());
+    }
+    stringifyMetadata() {
+        return this.stringify();
+    }
+    toString() {
+        return this.stringify();
+    }
+}
+export const parseProcessSharedBufferMetadata = (input) => {
+    const value = typeof input === "string" ? JSON.parse(input) : input;
+    if (!isRecord(value)) {
+        throw new TypeError("process shared buffer metadata must be an object");
+    }
+    if (value.version !== 1) {
+        throw new TypeError("unsupported process shared buffer metadata version");
+    }
+    const descriptor = FileDescriptor.fromMetadata(value.descriptor);
+    const byteOffset = readOptionalNonNegativeInteger(value.byteOffset, "process shared buffer byteOffset") ?? 0;
+    const byteLength = readOptionalNonNegativeInteger(value.byteLength, "process shared buffer byteLength") ?? descriptor.byteLength - byteOffset;
+    expectRange(byteOffset, byteLength, descriptor.byteLength);
+    return {
+        version: 1,
+        descriptor: descriptor.toMetadata(),
+        byteOffset,
+        byteLength,
+    };
+};
+const processSharedBufferGlobal = globalThis;
+const codecs = processSharedBufferGlobal.__KNITTING_PAYLOAD_CODECS__ ??=
+    Object.create(null);
+codecs[PROCESS_SHARED_BUFFER_CODEC_ID] = {
+    decode: (metadata) => ProcessSharedBuffer.fromMetadata(metadata),
+    decodeNumeric: (metadata) => ProcessSharedBuffer[PROCESS_SHARED_BUFFER_NUMERIC_TRANSFER](metadata),
+};

package/src/connections/shared-array-buffer-payload.d.ts

@@ -0,0 +1,36 @@
+export declare const SHARED_ARRAY_BUFFER_CODEC_ID: "knitting.sharedArrayBuffer";
+export declare const SHARED_ARRAY_BUFFER_NUMERIC_TRANSFER: unique symbol;
+export declare const SHARED_ARRAY_BUFFER_NUMERIC_WORDS = 8;
+declare const EXTERNAL_PAYLOAD_BRAND: unique symbol;
+type SharedArrayBufferMetadata = {
+    readonly kind: typeof SHARED_ARRAY_BUFFER_CODEC_ID;
+    readonly origin: string;
+    readonly runtime: string;
+    readonly pointer: string;
+    readonly token: string;
+    readonly byteLength: number;
+};
+type SharedArrayBufferNumericMetadata = readonly [
+    tokenLow: number,
+    tokenHigh: number,
+    pointerLow: number,
+    pointerHigh: number,
+    byteLength: number,
+    runtime: number,
+    originPid: number,
+    mode: number
+];
+type SharedArrayBufferTokenNumericMetadata = readonly [
+    tokenLow: number,
+    tokenHigh: number
+];
+type SharedArrayBufferPayload = {
+    readonly [EXTERNAL_PAYLOAD_BRAND]: typeof SHARED_ARRAY_BUFFER_CODEC_ID;
+    readonly toMetadata: () => SharedArrayBufferMetadata;
+    readonly [SHARED_ARRAY_BUFFER_NUMERIC_TRANSFER]: (transportKey?: object) => SharedArrayBufferNumericMetadata | SharedArrayBufferTokenNumericMetadata | undefined;
+};
+export declare const isSharedArrayBufferValue: (value: unknown) => value is SharedArrayBuffer;
+/** Wrap a SAB as external payload; GC-managed pins mean no settle finalizer. */
+export declare const wrapSharedArrayBufferPayload: (sab: SharedArrayBuffer) => SharedArrayBufferPayload;
+export declare const getSharedArrayBufferPayload: (value: object) => SharedArrayBufferPayload | undefined;
+export {};