knitting 0.1.55 → 0.1.60

package/src/connections/node.d.ts

@@ -0,0 +1,30 @@
+import { type CreateSharedMemoryOptions, type MapSharedMemoryOptions, type SharedMemoryConnectionPrimitives, type SharedMemoryMapping } from "./types.js";
+export type NodeSharedMemoryNativeMapping = {
+    sab: SharedArrayBuffer;
+    fd: number;
+    name?: string;
+    size: number;
+    baseAddressMod64?: number;
+};
+export type NodeSharedMemoryAddon = {
+    createSharedMemory: (size: number, name?: string, mode?: CreateSharedMemoryOptions["mode"]) => NodeSharedMemoryNativeMapping;
+    mapSharedMemory: (fd: number, size: number, name?: string) => NodeSharedMemoryNativeMapping;
+    unlinkSharedMemory?: (name: string) => boolean;
+};
+export type NodeFutexWaitResult = "woken" | "changed" | "interrupted" | "timed-out";
+export type NodeFutexAddon = {
+    waitU32: (buffer: ArrayBuffer | SharedArrayBuffer, byteOffset: number, expected: number, timeoutMs?: number) => NodeFutexWaitResult;
+    wakeU32: (buffer: ArrayBuffer | SharedArrayBuffer, byteOffset: number, count?: number) => number;
+    notifyU32?: (buffer: ArrayBuffer | SharedArrayBuffer, byteOffset: number, count?: number) => number;
+    sleep?: (milliseconds?: number) => void;
+    yield?: () => void;
+};
+export declare const DEFAULT_NODE_SHARED_MEMORY_ADDON = "../../build/Release/knitting_shared_memory.node";
+export declare const DEFAULT_NODE_FUTEX_ADDON = "../../build/Release/knitting_shm.node";
+export declare const loadNodeSharedMemoryAddon: (specifier?: string) => NodeSharedMemoryAddon;
+export declare const loadNodeFutexAddon: (specifier?: string) => NodeFutexAddon;
+export declare const fromNodeNativeMapping: (mapped: NodeSharedMemoryNativeMapping) => SharedMemoryMapping<SharedArrayBuffer>;
+export declare const createNodeSharedMemory: (options: number | CreateSharedMemoryOptions, addon?: NodeSharedMemoryAddon) => SharedMemoryMapping<SharedArrayBuffer>;
+export declare const mapNodeSharedMemory: (options: MapSharedMemoryOptions, addon?: NodeSharedMemoryAddon) => SharedMemoryMapping<SharedArrayBuffer>;
+export declare const createNodeConnectionPrimitives: (addon?: NodeSharedMemoryAddon) => SharedMemoryConnectionPrimitives;
+export declare const unlinkNodeSharedMemory: (name: string, addon?: NodeSharedMemoryAddon) => boolean;

package/src/connections/node.js

@@ -0,0 +1,62 @@
+import { getNodeBuiltinModule } from "../common/node-compat.js";
+import { loadNodeNativeAddon, } from "./node-addons.js";
+import { createNodeFfiConnectionPrimitives, isNodeFfiTarget, } from "./node-ffi.js";
+import { expectFd, expectPositiveSize, readCreateMode, readCreateName, readCreateSize, readRequiredCreateName, } from "./types.js";
+export const DEFAULT_NODE_SHARED_MEMORY_ADDON = "../../build/Release/knitting_shared_memory.node";
+export const DEFAULT_NODE_FUTEX_ADDON = "../../build/Release/knitting_shm.node";
+const loadNodeAddon = (label, name, specifier) => {
+    const nodeModule = getNodeBuiltinModule("node:module");
+    if (nodeModule === undefined) {
+        throw new Error(`Node ${label} addon can only be loaded in Node`);
+    }
+    return loadNodeNativeAddon(nodeModule.createRequire(import.meta.url), name, specifier);
+};
+export const loadNodeSharedMemoryAddon = (specifier) => loadNodeAddon("shared memory", "knitting_shared_memory", specifier);
+export const loadNodeFutexAddon = (specifier) => loadNodeAddon("futex", "knitting_shm", specifier);
+export const fromNodeNativeMapping = (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;
+};
+export const createNodeSharedMemory = (options, addon = loadNodeSharedMemoryAddon()) => {
+    const size = expectPositiveSize(readCreateSize(options));
+    const mode = readCreateMode(options);
+    const name = mode === "anonymous"
+        ? readCreateName(options, "knitting_shared_memory")
+        : readRequiredCreateName(options);
+    return fromNodeNativeMapping(addon.createSharedMemory(size, name, mode));
+};
+export const mapNodeSharedMemory = (options, addon = loadNodeSharedMemoryAddon()) => {
+    const fd = expectFd(options.fd);
+    const size = expectPositiveSize(options.size);
+    return fromNodeNativeMapping(addon.mapSharedMemory(fd, size, options.name));
+};
+export const createNodeConnectionPrimitives = (addon) => {
+    if (addon === undefined && isNodeFfiTarget()) {
+        return createNodeFfiConnectionPrimitives();
+    }
+    const resolvedAddon = addon ?? loadNodeSharedMemoryAddon();
+    return {
+        runtime: "node",
+        createSharedMemory: (options) => createNodeSharedMemory(options, resolvedAddon),
+        mapSharedMemory: (options) => mapNodeSharedMemory(options, resolvedAddon),
+        unlinkSharedMemory: (name) => unlinkNodeSharedMemory(name, resolvedAddon),
+    };
+};
+export const unlinkNodeSharedMemory = (name, addon = loadNodeSharedMemoryAddon()) => {
+    if (typeof addon.unlinkSharedMemory !== "function") {
+        throw new Error("Node shared memory addon cannot unlink named mappings");
+    }
+    return addon.unlinkSharedMemory(name);
+};

package/src/connections/numeric-array.d.ts

@@ -0,0 +1,5 @@
+export declare const NUMERIC_ARRAY_BRAND: unique symbol;
+export declare class NumericArray extends Array<number> {
+}
+export declare const isNumericArray: (value: object) => value is NumericArray;
+export declare const numericArrayFromFloat64: (view: Float64Array) => NumericArray;

package/src/connections/numeric-array.js

@@ -0,0 +1,17 @@
+export const NUMERIC_ARRAY_BRAND = Symbol.for("knitting.numericArray");
+export class NumericArray extends Array {
+}
+Object.defineProperty(NumericArray.prototype, NUMERIC_ARRAY_BRAND, {
+    value: true,
+    enumerable: false,
+    writable: false,
+    configurable: false,
+});
+export const isNumericArray = (value) => value[NUMERIC_ARRAY_BRAND] === true;
+export const numericArrayFromFloat64 = (view) => {
+    const length = view.length;
+    const out = new NumericArray(length);
+    for (let i = 0; i < length; i++)
+        out[i] = view[i];
+    return out;
+};

package/src/connections/package-assets.d.ts

@@ -0,0 +1,2 @@
+export declare const findKnittingPackageRoot: (moduleUrl?: string) => string;
+export declare const resolveKnittingPackageAsset: (...segments: string[]) => string;

package/src/connections/package-assets.js

@@ -0,0 +1,55 @@
+import { getNodeBuiltinModule } from "../common/node-compat.js";
+let fsModule;
+let pathModule;
+let urlModule;
+const requireNode = (value, specifier) => {
+    if (value === undefined) {
+        throw new Error(`${specifier} is not available in this runtime`);
+    }
+    return value;
+};
+const fs = () => requireNode(fsModule ??= getNodeBuiltinModule("node:fs"), "node:fs");
+const path = () => requireNode(pathModule ??= getNodeBuiltinModule("node:path"), "node:path");
+const url = () => requireNode(urlModule ??= getNodeBuiltinModule("node:url"), "node:url");
+const safeExists = (target) => {
+    try {
+        return fs().existsSync(target);
+    }
+    catch {
+        return false;
+    }
+};
+const safeIsDirectory = (target) => {
+    try {
+        return fs().statSync(target).isDirectory();
+    }
+    catch {
+        return false;
+    }
+};
+const moduleDirectory = (moduleUrl) => {
+    const target = url().fileURLToPath(moduleUrl);
+    return safeIsDirectory(target) ? target : path().dirname(target);
+};
+const isKnittingPackageRoot = (dir) => safeExists(path().join(dir, "package.json")) &&
+    (safeExists(path().join(dir, "prebuilds")) ||
+        safeExists(path().join(dir, "src")) ||
+        safeExists(path().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 = path().dirname(current);
+        if (parent === current) {
+            throw new Error(`Could not locate knitting package root from ${moduleUrl}`);
+        }
+        current = parent;
+    }
+};
+export const resolveKnittingPackageAsset = (...segments) => path().join(findKnittingPackageRoot(), ...segments);

package/src/connections/posix.d.ts

@@ -0,0 +1,74 @@
+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;
+export declare const getErrnoSymbolName: (platform: PosixPlatform) => string;
+/** Best effort: the runtime can issue its own libc call before errno is read. */
+export type ErrnoReader = () => number | undefined;
+/**
+ * Wraps a bound `__error`/`__errno_location` into a reader that never throws.
+ * Runtimes differ only in how they turn the returned address into an int.
+ */
+export declare const makeErrnoReader: <Pointer>(locate: (() => Pointer) | undefined, readInt32: (pointer: Pointer) => number) => ErrnoReader;
+/**
+ * Builds `<message>: EACCES (13)`, reading errno as late as possible, or the
+ * bare message when the runtime has no errno reader.
+ */
+export declare const posixError: (message: string, errno?: ErrnoReader, platform?: PosixPlatform) => Error;
+export declare const checkPosixResult: (result: number, message: string, errno?: ErrnoReader, platform?: PosixPlatform) => number;
+type FcntlLibc = {
+    symbols: {
+        fcntl: (fd: number, cmd: number, arg: number) => number;
+    };
+};
+/**
+ * Whether `shm_open`'s mode argument has to be delivered on the stack.
+ *
+ * macOS declares `shm_open(const char *, int, ...)` variadic and its libc
+ * wrapper reads the mode with `va_arg`. Apple's arm64 ABI passes variadic
+ * arguments on the stack, not in registers, so the mode a fixed-arity FFI call
+ * leaves in a register is never read: the segment is created with whatever the
+ * stack happened to hold. The creator's own descriptor still works, so the
+ * damage only surfaces when the name is opened again and fails with EACCES —
+ * and because the value comes from uninitialized stack, unrelated changes to
+ * the calling code can flip it between working and not.
+ *
+ * Declaring six extra register arguments moves the mode into the first stack
+ * slot, which is exactly where `va_arg` looks. Linux (fixed prototype) and
+ * x86-64 macOS (variadic arguments in registers) both want the plain form.
+ */
+export declare const shmOpenModeIsStackPassed: (platform?: PosixPlatform) => boolean;
+/** Fills x2–x7 so the mode becomes the first stack argument. */
+export declare const SHM_OPEN_STACK_PAD: readonly number[];
+/**
+ * Proves a freshly created macOS segment can be reopened by name, closing the
+ * owner descriptor and throwing if it cannot.
+ *
+ * Without this, a mode that failed to apply produces a confusing EACCES in
+ * whichever process later opens the name, far from the call that caused it.
+ * No-ops off macOS, where the mode always applies.
+ */
+export declare const assertNamedSharedMemoryIsReopenable: (platform: PosixPlatform, ownerFd: number, reopen: () => number, close: (fd: number) => number, errno?: ErrnoReader) => void;
+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,178 @@
+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`);
+// libc exposes errno through a function returning its address: `__error()` on
+// macOS, `__errno_location()` on Linux. FFI callers read the int behind it to
+// turn a bare -1 into something diagnosable.
+export const getErrnoSymbolName = (platform) => platform === "darwin" ? "__error" : "__errno_location";
+// Only the codes shm_open/mmap/ftruncate/dup realistically return; anything
+// else prints as a bare number.
+const ERRNO_NAMES = {
+    1: "EPERM",
+    2: "ENOENT",
+    9: "EBADF",
+    12: "ENOMEM",
+    13: "EACCES",
+    17: "EEXIST",
+    22: "EINVAL",
+    24: "EMFILE",
+    28: "ENOSPC",
+};
+const PLATFORM_ERRNO_NAMES = {
+    darwin: { 45: "ENOTSUP", 63: "ENAMETOOLONG" },
+    linux: { 36: "ENAMETOOLONG", 95: "ENOTSUP" },
+};
+const isNullPointer = (pointer) => pointer === null || pointer === undefined || pointer === 0 || pointer === 0n;
+/**
+ * Wraps a bound `__error`/`__errno_location` into a reader that never throws.
+ * Runtimes differ only in how they turn the returned address into an int.
+ */
+export const makeErrnoReader = (locate, readInt32) => {
+    if (locate === undefined)
+        return () => undefined;
+    return () => {
+        try {
+            const pointer = locate();
+            return isNullPointer(pointer) ? undefined : readInt32(pointer);
+        }
+        catch {
+            return undefined;
+        }
+    };
+};
+const describeErrno = (errno, platform) => {
+    if (errno === undefined)
+        return "errno unavailable";
+    const name = PLATFORM_ERRNO_NAMES[platform][errno] ?? ERRNO_NAMES[errno];
+    return name === undefined ? `errno ${errno}` : `${name} (${errno})`;
+};
+/**
+ * Builds `<message>: EACCES (13)`, reading errno as late as possible, or the
+ * bare message when the runtime has no errno reader.
+ */
+export const posixError = (message, errno, platform = detectPosixPlatform()) => errno === undefined
+    ? new Error(message)
+    : new Error(`${message}: ${describeErrno(errno(), platform)}`);
+export const checkPosixResult = (result, message, errno, platform) => {
+    if (result < 0)
+        throw posixError(message, errno, platform);
+    return result;
+};
+const detectArch = () => globalThis
+    .Deno?.build?.arch ??
+    globalThis
+        .process?.arch ??
+    "";
+/**
+ * Whether `shm_open`'s mode argument has to be delivered on the stack.
+ *
+ * macOS declares `shm_open(const char *, int, ...)` variadic and its libc
+ * wrapper reads the mode with `va_arg`. Apple's arm64 ABI passes variadic
+ * arguments on the stack, not in registers, so the mode a fixed-arity FFI call
+ * leaves in a register is never read: the segment is created with whatever the
+ * stack happened to hold. The creator's own descriptor still works, so the
+ * damage only surfaces when the name is opened again and fails with EACCES —
+ * and because the value comes from uninitialized stack, unrelated changes to
+ * the calling code can flip it between working and not.
+ *
+ * Declaring six extra register arguments moves the mode into the first stack
+ * slot, which is exactly where `va_arg` looks. Linux (fixed prototype) and
+ * x86-64 macOS (variadic arguments in registers) both want the plain form.
+ */
+export const shmOpenModeIsStackPassed = (platform = detectPosixPlatform()) => platform === "darwin" && /arm64|aarch64/.test(detectArch());
+/** Fills x2–x7 so the mode becomes the first stack argument. */
+export const SHM_OPEN_STACK_PAD = [0, 0, 0, 0, 0, 0];
+/**
+ * Proves a freshly created macOS segment can be reopened by name, closing the
+ * owner descriptor and throwing if it cannot.
+ *
+ * Without this, a mode that failed to apply produces a confusing EACCES in
+ * whichever process later opens the name, far from the call that caused it.
+ * No-ops off macOS, where the mode always applies.
+ */
+export const assertNamedSharedMemoryIsReopenable = (platform, ownerFd, reopen, close, errno) => {
+    if (platform !== "darwin")
+        return;
+    const probe = reopen();
+    if (probe >= 0) {
+        close(probe);
+        return;
+    }
+    const error = posixError("created shared memory could not be reopened by name", errno, platform);
+    close(ownerFd);
+    throw error;
+};
+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,76 @@
+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 isProcessSharedBufferValue: (value: unknown) => value is ProcessSharedBuffer;
+export declare const parseProcessSharedBufferMetadata: (input: unknown) => ProcessSharedBufferMetadata;
+export {};