knitting 0.1.55 → 0.1.60

package/src/connections/file-descriptor.js

@@ -0,0 +1,161 @@
+import { expectFd, expectPositiveSize, requireSharedArrayBuffer, } from "./types.js";
+const isRecord = (value) => typeof value === "object" && value !== null;
+const readOptionalRuntime = (value) => {
+    if (value === undefined)
+        return undefined;
+    if (value === "node" || value === "deno" || value === "bun")
+        return value;
+    throw new TypeError("file descriptor runtime is invalid");
+};
+const readOptionalKind = (value) => {
+    if (value === undefined)
+        return undefined;
+    if (value === "shared-array-buffer" ||
+        value === "external-array-buffer") {
+        return value;
+    }
+    throw new TypeError("file descriptor buffer kind is invalid");
+};
+const readOptionalNumber = (value, label) => {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new TypeError(`file descriptor ${label} must be a finite number`);
+    }
+    return Math.trunc(value);
+};
+const readOptionalName = (value) => {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.length === 0) {
+        throw new TypeError("file descriptor name must be a non-empty string when provided");
+    }
+    if (value.includes("\0")) {
+        throw new TypeError("file descriptor name must not contain NUL bytes");
+    }
+    return value;
+};
+export class FileDescriptor {
+    fd;
+    name;
+    size;
+    byteLength;
+    runtime;
+    kind;
+    baseAddressMod64;
+    #mapping;
+    constructor(metadata, mapping) {
+        this.fd = expectFd(metadata.fd);
+        this.name = metadata.name;
+        this.size = expectPositiveSize(metadata.size);
+        this.byteLength = expectPositiveSize(metadata.byteLength);
+        this.runtime = metadata.runtime;
+        this.kind = metadata.kind;
+        this.baseAddressMod64 = metadata.baseAddressMod64;
+        this.#mapping = mapping;
+    }
+    static fromMapping(mapping) {
+        return new FileDescriptor({
+            version: 1,
+            fd: mapping.fd,
+            name: mapping.name,
+            size: mapping.size,
+            byteLength: mapping.byteLength,
+            runtime: mapping.runtime,
+            kind: mapping.kind,
+            baseAddressMod64: mapping.baseAddressMod64,
+        }, mapping);
+    }
+    static fromMetadata(metadata) {
+        return new FileDescriptor(parseFileDescriptorMetadata(metadata));
+    }
+    static parse(serialized) {
+        return FileDescriptor.fromMetadata(serialized);
+    }
+    toMetadata() {
+        const metadata = {
+            version: 1,
+            fd: this.fd,
+            size: this.size,
+            byteLength: this.byteLength,
+            runtime: this.runtime,
+            kind: this.kind,
+            baseAddressMod64: this.baseAddressMod64,
+        };
+        if (this.name !== undefined)
+            metadata.name = this.name;
+        return metadata;
+    }
+    toJSON() {
+        return this.toMetadata();
+    }
+    stringify() {
+        return JSON.stringify(this.toMetadata());
+    }
+    stringifyMetadata() {
+        // This describes an fd; it does not transfer fd ownership to another process.
+        return this.stringify();
+    }
+    toString() {
+        return this.stringify();
+    }
+    attach(mapping) {
+        this.#mapping = mapping;
+        return this;
+    }
+    get mapping() {
+        return this.#mapping;
+    }
+    map(mapper) {
+        const options = {
+            fd: this.fd,
+            name: this.name,
+            size: this.size,
+        };
+        this.#mapping = mapper.mapSharedMemory(options);
+        return this.#mapping;
+    }
+    getBuffer(mapper) {
+        if (this.#mapping?.buffer !== undefined)
+            return this.#mapping.buffer;
+        if (mapper === undefined) {
+            throw new TypeError("file descriptor is not attached to a shared memory mapping");
+        }
+        return this.map(mapper).buffer;
+    }
+    getSharedArrayBuffer(mapper) {
+        if (this.#mapping?.sab !== undefined)
+            return this.#mapping.sab;
+        if (mapper === undefined) {
+            throw new TypeError("file descriptor is not attached to a SharedArrayBuffer mapping");
+        }
+        return requireSharedArrayBuffer(this.map(mapper));
+    }
+    getSAB(mapper) {
+        return this.getSharedArrayBuffer(mapper);
+    }
+}
+export const parseFileDescriptorMetadata = (input) => {
+    const value = typeof input === "string" ? JSON.parse(input) : input;
+    if (!isRecord(value)) {
+        throw new TypeError("file descriptor metadata must be an object");
+    }
+    if (value.version !== 1) {
+        throw new TypeError("unsupported file descriptor metadata version");
+    }
+    const parsed = {
+        version: 1,
+        fd: expectFd(readOptionalNumber(value.fd, "fd") ?? -1),
+        size: expectPositiveSize(readOptionalNumber(value.size, "size") ?? 0),
+        byteLength: expectPositiveSize(readOptionalNumber(value.byteLength, "byteLength") ??
+            readOptionalNumber(value.size, "size") ??
+            0),
+        runtime: readOptionalRuntime(value.runtime),
+        kind: readOptionalKind(value.kind),
+        baseAddressMod64: readOptionalNumber(value.baseAddressMod64, "baseAddressMod64"),
+    };
+    const name = readOptionalName(value.name);
+    if (name !== undefined)
+        parsed.name = name;
+    return parsed;
+};

package/src/connections/index.d.ts

@@ -0,0 +1,4 @@
+export { alignToCacheLine, CACHE_LINE_SIZE, type ConnectionRuntime, type CreateSharedMemoryOptions, expectFd, expectPositiveSize, type MapSharedMemoryOptions, requireSharedArrayBuffer, type SharedMemoryBuffer, type SharedMemoryBufferKind, type SharedMemoryConnectionPrimitives, type SharedMemoryMapping, } from "./types.js";
+export { BufferReference, BUFFER_REFERENCE_KIND, type BufferReferenceMetadata, type BufferReferenceRuntime, isBufferReferenceMetadata, } from "./buffer-reference.js";
+export { FileDescriptor, type FileDescriptorMetadata, parseFileDescriptorMetadata, } from "./file-descriptor.js";
+export { getDefaultProcessSharedBufferPrimitives, parseProcessSharedBufferMetadata, PROCESS_SHARED_BUFFER_BRAND, ProcessSharedBuffer, type ProcessSharedBufferCreator, type ProcessSharedBufferMapper, type ProcessSharedBufferMetadata, type ProcessSharedBufferPrimitives, type ProcessSharedBufferRange, type ProcessSharedBufferView, type ProcessSharedBufferViewConstructor, setDefaultProcessSharedBufferPrimitives, } from "./process-shared-buffer.js";

package/src/connections/index.js

@@ -0,0 +1,4 @@
+export { alignToCacheLine, CACHE_LINE_SIZE, expectFd, expectPositiveSize, requireSharedArrayBuffer, } from "./types.js";
+export { BufferReference, BUFFER_REFERENCE_KIND, isBufferReferenceMetadata, } from "./buffer-reference.js";
+export { FileDescriptor, parseFileDescriptorMetadata, } from "./file-descriptor.js";
+export { getDefaultProcessSharedBufferPrimitives, parseProcessSharedBufferMetadata, PROCESS_SHARED_BUFFER_BRAND, ProcessSharedBuffer, setDefaultProcessSharedBufferPrimitives, } from "./process-shared-buffer.js";

package/src/connections/node-addons.d.ts

@@ -0,0 +1,16 @@
+type NodeRequire = (specifier: string) => unknown;
+export type NodeNativeAddonName = "knitting_shared_memory" | "knitting_shm" | "knitting_buffer_pointer";
+export type NodePlatformInfo = {
+    arch: string;
+    modules?: string;
+    platform: string;
+    version?: string;
+};
+export declare const SUPPORTED_NODE_NATIVE_ADDON_ABIS: {
+    readonly "127": "22";
+    readonly "137": "24";
+};
+export declare const formatNodeNativeAddonLoadError: (name: NodeNativeAddonName, platformInfo: NodePlatformInfo | undefined, errors: readonly string[]) => string;
+export declare const nodeNativeAddonSpecifiers: (name: NodeNativeAddonName) => readonly string[];
+export declare const loadNodeNativeAddon: <T>(require: NodeRequire, name: NodeNativeAddonName, specifier?: string) => T;
+export {};

package/src/connections/node-addons.js

@@ -0,0 +1,92 @@
+import { resolveKnittingPackageAsset } from "./package-assets.js";
+export const SUPPORTED_NODE_NATIVE_ADDON_ABIS = {
+    "127": "22",
+    "137": "24",
+};
+const NODE_26_MODULE_ABI = "147";
+const SUPPORTED_NODE_NATIVE_TARGETS = new Set([
+    "darwin-arm64",
+    "darwin-x64",
+    "linux-x64",
+    "win32-x64",
+]);
+const readNodePlatformInfo = () => {
+    const processLike = globalThis.process;
+    if (typeof processLike?.platform !== "string" ||
+        typeof processLike.arch !== "string") {
+        return undefined;
+    }
+    return {
+        arch: processLike.arch,
+        modules: processLike.versions?.modules,
+        platform: processLike.platform,
+        version: processLike.versions?.node,
+    };
+};
+const formatAttemptErrors = (errors) => errors.length > 0 ? `\nTried:\n${errors.join("\n")}` : "";
+export const formatNodeNativeAddonLoadError = (name, platformInfo, errors) => {
+    const attempts = formatAttemptErrors(errors);
+    if (platformInfo === undefined) {
+        return `knitting: could not load native addon ${name}.${attempts}`;
+    }
+    const abi = platformInfo.modules;
+    const version = platformInfo.version === undefined
+        ? "an unknown version"
+        : `v${platformInfo.version}`;
+    const target = `${platformInfo.platform}-${platformInfo.arch}`;
+    if (abi === NODE_26_MODULE_ABI) {
+        return (`knitting: Node.js 26 uses node:ffi instead of ABI-specific addons. ` +
+            `Restart Node with the --experimental-ffi flag` +
+            ` (--allow-ffi is also required when using Node's Permission Model). ` +
+            `No Node ABI 147 addon is shipped.${attempts}`);
+    }
+    if (typeof abi === "string" &&
+        !(abi in SUPPORTED_NODE_NATIVE_ADDON_ABIS)) {
+        return (`knitting: no native addon is shipped for Node.js ${version} ` +
+            `(ABI ${abi}). Packaged native features support Node.js 22 ` +
+            `(ABI 127) and Node.js 24 (ABI 137) only. Plain thread workers that do ` +
+            `not use ProcessSharedBuffer or BufferReference do not need these ` +
+            `addons.${attempts}`);
+    }
+    if (!SUPPORTED_NODE_NATIVE_TARGETS.has(target)) {
+        return (`knitting: Node.js ${version} uses a supported ABI (${abi ?? "unknown"}), ` +
+            `but no packaged native addon target is shipped for ${target}. ` +
+            `Published targets are linux-x64, darwin-x64, darwin-arm64, and ` +
+            `win32-x64. You can build locally with "bun run build:native".${attempts}`);
+    }
+    return (`knitting: could not load native addon ${name} for Node.js ${version} ` +
+        `(ABI ${abi ?? "unknown"}, ${target}). The prebuild may be missing, ` +
+        `damaged, or incompatible; reinstall the package or build locally with ` +
+        `"bun run build:native".${attempts}`);
+};
+export const nodeNativeAddonSpecifiers = (name) => {
+    const platformInfo = readNodePlatformInfo();
+    const fallback = resolveKnittingPackageAsset("build", "Release", `${name}.node`);
+    if (platformInfo === undefined)
+        return [fallback];
+    const nodeModuleAbi = platformInfo.modules;
+    if (typeof nodeModuleAbi === "string" && nodeModuleAbi.length > 0) {
+        return [
+            resolveKnittingPackageAsset("prebuilds", `${platformInfo.platform}-${platformInfo.arch}-node-${nodeModuleAbi}`, `${name}.node`),
+            fallback,
+        ];
+    }
+    return [
+        resolveKnittingPackageAsset("prebuilds", `${platformInfo.platform}-${platformInfo.arch}`, `${name}.node`),
+        fallback,
+    ];
+};
+export const loadNodeNativeAddon = (require, name, specifier) => {
+    if (specifier !== undefined)
+        return require(specifier);
+    const errors = [];
+    for (const candidate of nodeNativeAddonSpecifiers(name)) {
+        try {
+            return require(candidate);
+        }
+        catch (error) {
+            errors.push(`${candidate}: ${String(error)}`);
+        }
+    }
+    throw new Error(formatNodeNativeAddonLoadError(name, readNodePlatformInfo(), errors));
+};

package/src/connections/node-buffer-pointer.d.ts

@@ -0,0 +1,20 @@
+export type NodeBufferPointerAddon = {
+    getPointer: (buffer: ArrayBufferView | ArrayBuffer | SharedArrayBuffer) => bigint;
+    retainPointer: (buffer: ArrayBufferView | ArrayBuffer | SharedArrayBuffer) => {
+        pointer: bigint;
+        byteLength: number;
+        token: bigint;
+    };
+    releasePointer: (token: bigint) => boolean;
+    wrapPointer: (pointer: bigint, byteLength: number) => ArrayBuffer;
+    detachArrayBuffer: (buffer: ArrayBuffer) => boolean;
+    retainBackingStore?: (buffer: ArrayBufferView | ArrayBuffer) => {
+        pointer: bigint;
+        byteOffset: number;
+        byteLength: number;
+        token: bigint;
+    };
+    adoptBackingStore?: (token: bigint) => ArrayBuffer;
+    releaseBackingStore?: (token: bigint) => boolean;
+};
+export declare const loadNodeBufferPointerAddon: (specifier?: string) => NodeBufferPointerAddon;

package/src/connections/node-buffer-pointer.js

@@ -0,0 +1,16 @@
+import { getNodeBuiltinModule } from "../common/node-compat.js";
+import { loadNodeNativeAddon } from "./node-addons.js";
+let cached;
+export const loadNodeBufferPointerAddon = (specifier) => {
+    if (specifier === undefined && cached !== undefined)
+        return cached;
+    const nodeModule = getNodeBuiltinModule("node:module");
+    if (nodeModule === undefined) {
+        throw new Error("Node buffer-pointer addon can only be loaded in Node");
+    }
+    const require = nodeModule.createRequire(import.meta.url);
+    const addon = loadNodeNativeAddon(require, "knitting_buffer_pointer", specifier);
+    if (specifier === undefined)
+        cached = addon;
+    return addon;
+};

package/src/connections/node-ffi-api.d.ts

@@ -0,0 +1,19 @@
+export type NodeFfiFunctionSignature = {
+    arguments?: string[];
+    return?: string;
+};
+export type NodeFfiLibrary = {
+    close: () => void;
+};
+export type NodeFfiDlopenResult<Functions extends Record<string, (...args: never[]) => unknown>> = {
+    functions: Functions;
+    lib: NodeFfiLibrary;
+};
+export type NodeFfiApi = {
+    dlopen: <Functions extends Record<string, (...args: never[]) => unknown>>(path: string | null, definitions: Record<string, NodeFfiFunctionSignature>) => NodeFfiDlopenResult<Functions>;
+    getRawPointer: (source: ArrayBuffer | SharedArrayBuffer | ArrayBufferView) => bigint;
+    suffix: string;
+    toArrayBuffer: (pointer: bigint, length: number, copy?: boolean) => ArrayBuffer;
+};
+export declare const isNodeFfiTarget: () => boolean;
+export declare const getNodeFfi: () => NodeFfiApi;

package/src/connections/node-ffi-api.js

@@ -0,0 +1,28 @@
+import { getNodeBuiltinModule, getNodeProcess } from "../common/node-compat.js";
+const readNodeMajor = () => {
+    const version = getNodeProcess()?.versions?.node;
+    if (typeof version !== "string")
+        return undefined;
+    const major = Number.parseInt(version.split(".", 1)[0] ?? "", 10);
+    return Number.isInteger(major) ? major : undefined;
+};
+export const isNodeFfiTarget = () => {
+    const major = readNodeMajor() ?? 0;
+    return major >= 26 && major % 2 === 0;
+};
+let cachedNodeFfi;
+export const getNodeFfi = () => {
+    if (cachedNodeFfi !== undefined)
+        return cachedNodeFfi;
+    const ffi = getNodeBuiltinModule("node:ffi");
+    if (ffi === undefined ||
+        typeof ffi.dlopen !== "function" ||
+        typeof ffi.getRawPointer !== "function" ||
+        typeof ffi.toArrayBuffer !== "function") {
+        throw new Error("knitting: Node.js 26 native features require node:ffi. " +
+            "Restart Node with --experimental-ffi" +
+            " (--allow-ffi is also required when using Node's Permission Model).");
+    }
+    cachedNodeFfi = ffi;
+    return ffi;
+};

package/src/connections/node-ffi.d.ts

@@ -0,0 +1,27 @@
+import { type NodeFfiLibrary } from "./node-ffi-api.js";
+import { type CreateSharedMemoryOptions, type MapSharedMemoryOptions, type SharedMemoryConnectionPrimitives, type SharedMemoryMapping } from "./types.js";
+export { getNodeFfi, isNodeFfiTarget } from "./node-ffi-api.js";
+export type { NodeFfiApi, NodeFfiDlopenResult, NodeFfiFunctionSignature, NodeFfiLibrary, } from "./node-ffi-api.js";
+type NodePosixFunctions = {
+    memfd_create?: (name: Uint8Array, flags: number) => number;
+    shm_open?: (name: Uint8Array, flags: number, ...rest: number[]) => number;
+    shm_unlink?: (name: Uint8Array) => number;
+    __error?: () => bigint;
+    __errno_location?: () => bigint;
+    ftruncate: (fd: number, length: bigint) => number;
+    dup: (fd: number) => number;
+    fcntl: (fd: number, cmd: number, arg: number) => number;
+    mmap: (address: null, length: bigint, protection: number, flags: number, fd: number, offset: bigint) => bigint;
+    munmap: (address: bigint, length: bigint) => number;
+    close: (fd: number) => number;
+};
+type NodePosixLibrary = {
+    functions: NodePosixFunctions;
+    lib: NodeFfiLibrary;
+};
+export declare const openNodePosixLibrary: () => NodePosixLibrary;
+export declare const mapNodeFfiSharedMemory: (options: MapSharedMemoryOptions, library?: NodePosixLibrary) => SharedMemoryMapping<ArrayBuffer>;
+export declare const createNodeFfiSharedMemory: (options: number | CreateSharedMemoryOptions, library?: NodePosixLibrary) => SharedMemoryMapping<ArrayBuffer>;
+export declare const unlinkNodeFfiSharedMemory: (name: string, library?: NodePosixLibrary) => boolean;
+export declare const createNodeFfiPosixConnectionPrimitives: (library?: NodePosixLibrary) => SharedMemoryConnectionPrimitives<SharedMemoryMapping<ArrayBuffer>>;
+export declare const createNodeFfiConnectionPrimitives: () => SharedMemoryConnectionPrimitives<SharedMemoryMapping<ArrayBuffer>>;

package/src/connections/node-ffi.js

@@ -0,0 +1,262 @@
+import { assertNamedSharedMemoryIsReopenable, checkPosixResult, DARWIN_O_CREAT, DARWIN_O_EXCL, DARWIN_SHM_MODE, detectPosixPlatform, encodeCString, getErrnoSymbolName, getPosixLibcPath, LINUX_O_CREAT, LINUX_O_EXCL, makeDarwinSharedMemoryName, makeErrnoReader, MAP_SHARED, O_RDWR, POSIX_SHM_MODE, posixError, PROT_READ, PROT_WRITE, setCloseOnExec, SHM_OPEN_STACK_PAD, shmOpenModeIsStackPassed, toPosixSharedMemoryName, } from "./posix.js";
+import { createNodeWindowsConnectionPrimitives, isWindowsRuntime, } from "./windows.js";
+import { requireDetachedExternalArrayBuffer } from "./external-array-buffer.js";
+import { getNodeFfi, } from "./node-ffi-api.js";
+import { expectFd, expectPositiveSize, readCreateMode, readCreateName, readCreateSize, readRequiredCreateName, } from "./types.js";
+export { getNodeFfi, isNodeFfiTarget } from "./node-ffi-api.js";
+let cachedNodePosixLibrary;
+const getNodeCreateSymbols = (platform = detectPosixPlatform()) => {
+    if (platform === "darwin") {
+        return {
+            shm_open: {
+                arguments: shmOpenModeIsStackPassed(platform)
+                    ? ["pointer", "i32", ...SHM_OPEN_STACK_PAD.map(() => "i32"), "u32"]
+                    : ["pointer", "i32", "u32"],
+                return: "i32",
+            },
+            shm_unlink: {
+                arguments: ["pointer"],
+                return: "i32",
+            },
+        };
+    }
+    return {
+        memfd_create: {
+            arguments: ["pointer", "u32"],
+            return: "i32",
+        },
+        shm_open: {
+            arguments: ["pointer", "i32", "u32"],
+            return: "i32",
+        },
+        shm_unlink: {
+            arguments: ["pointer"],
+            return: "i32",
+        },
+    };
+};
+const getNodeErrnoSymbols = (platform = detectPosixPlatform()) => ({
+    [getErrnoSymbolName(platform)]: {
+        arguments: [],
+        return: "pointer",
+    },
+});
+const getNodePosixSymbols = () => ({
+    ...getNodeCreateSymbols(),
+    ftruncate: {
+        arguments: ["i32", "i64"],
+        return: "i32",
+    },
+    dup: {
+        arguments: ["i32"],
+        return: "i32",
+    },
+    fcntl: {
+        arguments: ["i32", "i32", "i32"],
+        return: "i32",
+    },
+    mmap: {
+        arguments: ["pointer", "u64", "i32", "i32", "i32", "i64"],
+        return: "pointer",
+    },
+    munmap: {
+        arguments: ["pointer", "u64"],
+        return: "i32",
+    },
+    close: {
+        arguments: ["i32"],
+        return: "i32",
+    },
+});
+export const openNodePosixLibrary = () => {
+    if (cachedNodePosixLibrary !== undefined)
+        return cachedNodePosixLibrary;
+    const symbols = getNodePosixSymbols();
+    const ffi = getNodeFfi();
+    // errno is diagnostics only: if this libc or FFI build will not bind the
+    // nullary errno accessor, open without it rather than lose shared memory.
+    let opened;
+    try {
+        opened = ffi.dlopen(getPosixLibcPath(), {
+            ...symbols,
+            ...getNodeErrnoSymbols(),
+        });
+    }
+    catch {
+        opened = ffi.dlopen(getPosixLibcPath(), symbols);
+    }
+    cachedNodePosixLibrary = opened;
+    return opened;
+};
+const callShmOpen = (shmOpen, name, flags, mode, platform) => shmOpenModeIsStackPassed(platform)
+    ? shmOpen(name, flags, ...SHM_OPEN_STACK_PAD, mode)
+    : shmOpen(name, flags, mode);
+const errnoOf = (libc, platform = detectPosixPlatform()) => makeErrnoReader(platform === "darwin" ? libc.__error : libc.__errno_location, (pointer) => new Int32Array(getNodeFfi().toArrayBuffer(pointer, 4, true))[0]);
+const isMapFailed = (pointer) => pointer === 0n ||
+    pointer === -1n ||
+    pointer === BigInt.asUintN(64, -1n);
+const createAnonymousFd = (name, platform, libc) => {
+    if (platform === "darwin") {
+        const shmOpen = libc.shm_open;
+        const shmUnlink = libc.shm_unlink;
+        if (shmOpen === undefined || shmUnlink === undefined) {
+            throw new Error("shm_open symbols are not available");
+        }
+        const shmName = encodeCString(makeDarwinSharedMemoryName(name, "node"));
+        const fd = checkPosixResult(callShmOpen(shmOpen, shmName, O_RDWR | DARWIN_O_CREAT | DARWIN_O_EXCL, DARWIN_SHM_MODE, platform), "shm_open failed", errnoOf(libc, platform), platform);
+        shmUnlink(shmName);
+        try {
+            return setCloseOnExec({ symbols: libc }, fd);
+        }
+        catch (error) {
+            libc.close(fd);
+            throw error;
+        }
+    }
+    const memfdCreate = libc.memfd_create;
+    if (memfdCreate === undefined) {
+        throw new Error("memfd_create symbol is not available");
+    }
+    const fd = checkPosixResult(memfdCreate(encodeCString(name), 0), "memfd_create failed", errnoOf(libc, platform), platform);
+    try {
+        return setCloseOnExec({ symbols: libc }, fd);
+    }
+    catch (error) {
+        libc.close(fd);
+        throw error;
+    }
+};
+const createNamedFd = (name, mode, platform, libc) => {
+    const shmOpen = libc.shm_open;
+    if (shmOpen === undefined) {
+        throw new Error("shm_open symbol is not available");
+    }
+    const createFlag = platform === "darwin" ? DARWIN_O_CREAT : LINUX_O_CREAT;
+    const exclusiveFlag = platform === "darwin" ? DARWIN_O_EXCL : LINUX_O_EXCL;
+    const flags = mode === "create"
+        ? O_RDWR | createFlag | exclusiveFlag
+        : O_RDWR;
+    const shmMode = platform === "darwin" ? DARWIN_SHM_MODE : POSIX_SHM_MODE;
+    const shmName = encodeCString(toPosixSharedMemoryName(name));
+    const fd = checkPosixResult(callShmOpen(shmOpen, shmName, flags, shmMode, platform), "shm_open failed", errnoOf(libc, platform), platform);
+    if (mode === "create") {
+        assertNamedSharedMemoryIsReopenable(platform, fd, () => callShmOpen(shmOpen, shmName, O_RDWR, shmMode, platform), libc.close, errnoOf(libc, platform));
+    }
+    try {
+        return setCloseOnExec({ symbols: libc }, fd);
+    }
+    catch (error) {
+        libc.close(fd);
+        throw error;
+    }
+};
+const mapFd = (fd, size, name, libc, closeFdOnFailure) => {
+    const pointer = libc.mmap(null, BigInt(size), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0n);
+    if (isMapFailed(pointer)) {
+        // errno first: fcntl below overwrites it.
+        const error = posixError("mmap failed", errnoOf(libc));
+        const descriptorFlags = libc.fcntl(fd, 1, 0);
+        if (closeFdOnFailure)
+            libc.close(fd);
+        error.message +=
+            ` (fd ${fd}, size ${size}, descriptor flags ${descriptorFlags})`;
+        throw error;
+    }
+    let arrayBuffer;
+    try {
+        arrayBuffer = getNodeFfi().toArrayBuffer(pointer, size, false);
+    }
+    catch (error) {
+        libc.munmap(pointer, BigInt(size));
+        if (closeFdOnFailure)
+            libc.close(fd);
+        throw error;
+    }
+    let closed = false;
+    return {
+        runtime: "node",
+        fd,
+        name,
+        size,
+        byteLength: arrayBuffer.byteLength,
+        buffer: arrayBuffer,
+        kind: "external-array-buffer",
+        arrayBuffer,
+        unsafePointer: pointer,
+        baseAddressMod64: Number(pointer % 64n),
+        close: () => {
+            if (closed)
+                return;
+            requireDetachedExternalArrayBuffer(arrayBuffer);
+            closed = true;
+            try {
+                libc.munmap(pointer, BigInt(size));
+            }
+            finally {
+                libc.close(fd);
+            }
+        },
+    };
+};
+export const mapNodeFfiSharedMemory = (options, library = openNodePosixLibrary()) => {
+    const libc = library.functions;
+    const size = expectPositiveSize(options.size);
+    let fd;
+    let closeFdOnFailure = true;
+    if (options.name !== undefined) {
+        fd = createNamedFd(options.name, "open", detectPosixPlatform(), libc);
+    }
+    else {
+        const sourceFd = expectFd(options.fd);
+        closeFdOnFailure = options.duplicateFd !== false;
+        fd = closeFdOnFailure
+            ? checkPosixResult(libc.dup(sourceFd), "dup(fd) failed", errnoOf(libc))
+            : sourceFd;
+        if (closeFdOnFailure) {
+            try {
+                setCloseOnExec({ symbols: libc }, fd);
+            }
+            catch (error) {
+                libc.close(fd);
+                throw error;
+            }
+        }
+    }
+    // A non-duplicated descriptor remains caller-owned until mmap and the
+    // JavaScript wrapper both succeed. The returned mapping owns it thereafter.
+    return mapFd(fd, size, options.name, libc, closeFdOnFailure);
+};
+export const createNodeFfiSharedMemory = (options, library = openNodePosixLibrary()) => {
+    const libc = library.functions;
+    const size = expectPositiveSize(readCreateSize(options));
+    const mode = readCreateMode(options);
+    const name = mode === "anonymous"
+        ? readCreateName(options, "knitting_shared_memory")
+        : readRequiredCreateName(options);
+    const platform = detectPosixPlatform();
+    const fd = mode === "anonymous"
+        ? createAnonymousFd(name, platform, libc)
+        : createNamedFd(name, mode, platform, libc);
+    if (mode !== "open" && libc.ftruncate(fd, BigInt(size)) < 0) {
+        const error = posixError("ftruncate failed", errnoOf(libc, platform), platform);
+        libc.close(fd);
+        throw error;
+    }
+    return mapFd(fd, size, mode === "anonymous" ? undefined : name, libc, true);
+};
+export const unlinkNodeFfiSharedMemory = (name, library = openNodePosixLibrary()) => {
+    const shmUnlink = library.functions.shm_unlink;
+    if (shmUnlink === undefined) {
+        throw new Error("shm_unlink symbol is not available");
+    }
+    return shmUnlink(encodeCString(toPosixSharedMemoryName(name))) === 0;
+};
+export const createNodeFfiPosixConnectionPrimitives = (library = openNodePosixLibrary()) => ({
+    runtime: "node",
+    createSharedMemory: (options) => createNodeFfiSharedMemory(options, library),
+    mapSharedMemory: (options) => mapNodeFfiSharedMemory(options, library),
+    unlinkSharedMemory: (name) => unlinkNodeFfiSharedMemory(name, library),
+});
+export const createNodeFfiConnectionPrimitives = () => isWindowsRuntime()
+    ? createNodeWindowsConnectionPrimitives()
+    : createNodeFfiPosixConnectionPrimitives();