knitting 0.1.55 → 0.1.56

package/src/connections/buffer-reference.js

@@ -0,0 +1,461 @@
+import { RUNTIME } from "../common/runtime.js";
+import { getNodeProcess } from "../common/node-compat.js";
+import { RUNTIME_IS_MAIN_THREAD } from "../common/worker-runtime.js";
+import { loadNodeBufferPointerAddon } from "./node-buffer-pointer.js";
+import { getBufferReferenceCapabilities, } from "./buffer-reference-native.js";
+export const BUFFER_REFERENCE_KIND = "knitting.bufferReference";
+/** Named values for the `unsafe.BufferReferenceReturn` pool option. */
+export const BufferReferenceReturn = {
+    /** Safe default: Deno/Bun copy the returned bytes so they outlive the worker. */
+    Copy: "copy",
+    /** Zero-copy: borrow the worker's backing store until the reference is released. */
+    Borrow: "borrow",
+};
+export const BUFFER_REFERENCE_NUMERIC_TRANSFER = Symbol.for("knitting.bufferReference.numericTransfer");
+export const BUFFER_REFERENCE_RETURN_RELEASE_TOKEN = Symbol.for("knitting.bufferReference.returnReleaseToken");
+const EXTERNAL_PAYLOAD_BRAND = Symbol.for("knitting.payloadCodec");
+export const BUFFER_REFERENCE_CODEC_ID = BUFFER_REFERENCE_KIND;
+const BUFFER_REFERENCE_RETURN_RELEASE_MESSAGE_KEY = "__knittingBufferReferenceRelease";
+const getRuntime = () => {
+    if (RUNTIME === "deno" || RUNTIME === "bun" || RUNTIME === "node") {
+        return RUNTIME;
+    }
+    throw new Error(`BufferReference cannot run in runtime "${RUNTIME}"`);
+};
+const getProcessId = () => {
+    const proc = getNodeProcess();
+    if (proc !== undefined && typeof proc.pid === "number")
+        return proc.pid;
+    const deno = globalThis.Deno;
+    if (typeof deno?.pid === "number")
+        return deno.pid;
+    return 0;
+};
+const PROCESS_ORIGIN = `${RUNTIME}:${getProcessId()}`;
+const NUMERIC_WORD_MASK = 0xffffffffn;
+const RUNTIME_NODE = 1;
+const RUNTIME_DENO = 2;
+const RUNTIME_BUN = 3;
+const PAYLOAD_TRANSPORT_FINALIZER = Symbol.for("knitting.payloadCodec.transportFinalizer");
+let currentReturnReleaser;
+const encodeRuntime = (runtime) => {
+    switch (runtime) {
+        case "node":
+            return RUNTIME_NODE;
+        case "deno":
+            return RUNTIME_DENO;
+        case "bun":
+            return RUNTIME_BUN;
+    }
+};
+const decodeRuntime = (runtime) => {
+    switch (runtime) {
+        case RUNTIME_NODE:
+            return "node";
+        case RUNTIME_DENO:
+            return "deno";
+        case RUNTIME_BUN:
+            return "bun";
+        default:
+            return undefined;
+    }
+};
+const splitU64 = (value) => [
+    Number(value & NUMERIC_WORD_MASK) >>> 0,
+    Number((value >> 32n) & NUMERIC_WORD_MASK) >>> 0,
+];
+const joinU64 = (low, high) => (BigInt(high >>> 0) << 32n) | BigInt(low >>> 0);
+const readOriginPid = (origin) => {
+    const separator = origin.indexOf(":");
+    if (separator < 0)
+        return undefined;
+    const pid = Number(origin.slice(separator + 1));
+    return Number.isInteger(pid) && pid >= 0 && pid <= 0xffffffff
+        ? pid >>> 0
+        : undefined;
+};
+const numericMetadataToMetadata = (words) => {
+    const runtime = decodeRuntime(words[6] ?? 0);
+    if (runtime === undefined) {
+        throw new TypeError("Invalid BufferReference numeric runtime");
+    }
+    const originPid = words[7];
+    if (originPid === undefined ||
+        !Number.isInteger(originPid) ||
+        originPid < 0) {
+        throw new TypeError("Invalid BufferReference numeric origin");
+    }
+    return {
+        kind: BUFFER_REFERENCE_KIND,
+        origin: `${runtime}:${originPid >>> 0}`,
+        runtime,
+        pointer: joinU64(words[0] ?? 0, words[1] ?? 0).toString(),
+        token: joinU64(words[2] ?? 0, words[3] ?? 0).toString(),
+        byteOffset: words[4] ?? 0,
+        byteLength: words[5] ?? 0,
+    };
+};
+export const withBufferReferenceReturnReleaser = (releaser, run) => {
+    if (releaser === undefined)
+        return run();
+    const previous = currentReturnReleaser;
+    currentReturnReleaser = releaser;
+    try {
+        return run();
+    }
+    finally {
+        currentReturnReleaser = previous;
+    }
+};
+export const createBufferReferenceReturnReleaseMessage = (token) => ({
+    [BUFFER_REFERENCE_RETURN_RELEASE_MESSAGE_KEY]: token.toString(),
+});
+export const readBufferReferenceReturnReleaseMessage = (value) => {
+    if (value === null || typeof value !== "object")
+        return undefined;
+    const raw = value[BUFFER_REFERENCE_RETURN_RELEASE_MESSAGE_KEY];
+    if (typeof raw !== "string")
+        return undefined;
+    try {
+        const token = BigInt(raw);
+        return token > 0n ? token : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+// Backstop for references that never flow through the transport.
+const producerFinalizer = typeof FinalizationRegistry === "function"
+    ? new FinalizationRegistry(({ token, release }) => {
+        try {
+            release(token);
+        }
+        catch {
+            // best effort
+        }
+    })
+    : undefined;
+const borrowedReturnFinalizer = typeof FinalizationRegistry === "function"
+    ? new FinalizationRegistry(({ token, release }) => {
+        try {
+            release(token);
+        }
+        catch {
+            // best effort
+        }
+    })
+    : undefined;
+const isSharedArrayBufferInstance = (value) => typeof SharedArrayBuffer === "function" && value instanceof SharedArrayBuffer;
+const assertMovableSource = (source) => {
+    if (isSharedArrayBufferInstance(source)) {
+        throw new TypeError("BufferReference expects ArrayBuffer memory; SharedArrayBuffer is already shared and cannot be detached");
+    }
+    if (ArrayBuffer.isView(source)) {
+        if (isSharedArrayBufferInstance(source.buffer)) {
+            throw new TypeError("BufferReference expects ArrayBuffer-backed views; SharedArrayBuffer is already shared and cannot be detached");
+        }
+        return;
+    }
+    if (!(source instanceof ArrayBuffer)) {
+        throw new TypeError("BufferReference expects an ArrayBuffer or typed-array view");
+    }
+};
+const isDetached = (buffer) => buffer.detached === true ||
+    buffer.byteLength === 0;
+const detachArrayBufferBestEffort = (runtime, buffer) => {
+    if (isDetached(buffer))
+        return true;
+    if (runtime === "node") {
+        try {
+            return loadNodeBufferPointerAddon().detachArrayBuffer(buffer);
+        }
+        catch {
+            // fall through to the JS detach paths
+        }
+    }
+    const transferable = buffer;
+    try {
+        if (typeof transferable.transferToFixedLength === "function") {
+            transferable.transferToFixedLength(0);
+            return isDetached(buffer);
+        }
+        if (typeof transferable.transfer === "function") {
+            transferable.transfer(0);
+            return isDetached(buffer);
+        }
+    }
+    catch {
+        // fall through
+    }
+    try {
+        if (typeof structuredClone === "function") {
+            structuredClone(buffer, { transfer: [buffer] });
+            return isDetached(buffer);
+        }
+    }
+    catch {
+        // give up
+    }
+    return false;
+};
+export const isBufferReferenceMetadata = (value) => {
+    if (value === null || typeof value !== "object")
+        return false;
+    const meta = value;
+    return (meta.kind === BUFFER_REFERENCE_KIND &&
+        typeof meta.origin === "string" &&
+        (meta.runtime === "node" || meta.runtime === "deno" ||
+            meta.runtime === "bun") &&
+        typeof meta.pointer === "string" &&
+        typeof meta.token === "string" &&
+        typeof meta.byteOffset === "number" &&
+        Number.isInteger(meta.byteOffset) &&
+        meta.byteOffset >= 0 &&
+        typeof meta.byteLength === "number" &&
+        Number.isInteger(meta.byteLength) &&
+        meta.byteLength >= 0);
+};
+/**
+ * Zero-copy handle for moving ArrayBuffer bytes to/from **thread** workers.
+ *
+ * Construction detaches the source. Consumers materialize the moved region in
+ * their isolate: owning on Node, alias/copy on Deno/Bun. Return a
+ * `BufferReference` for large binary results to avoid copying back through the
+ * transport. Use `ProcessSharedBuffer` across process boundaries.
+ */
+export class BufferReference {
+    [EXTERNAL_PAYLOAD_BRAND] = BUFFER_REFERENCE_CODEC_ID;
+    runtime;
+    origin;
+    pointer;
+    byteOffset;
+    byteLength;
+    #token;
+    #isProducer;
+    #finalizerToken;
+    #materializedRegions;
+    #owned;
+    #borrowedReturnReleaser;
+    #borrowedReturnFinalizerToken;
+    #transportRefs = 0;
+    #released = false;
+    constructor(source, meta) {
+        if (meta !== undefined) {
+            // Consumer side: rebuilt from metadata, materializes via the pointer/token.
+            this.runtime = meta.runtime;
+            this.origin = meta.origin;
+            this.pointer = BigInt(meta.pointer);
+            this.byteOffset = meta.byteOffset;
+            this.byteLength = meta.byteLength;
+            this.#token = BigInt(meta.token);
+            this.#isProducer = false;
+            return;
+        }
+        if (source === undefined) {
+            throw new TypeError("BufferReference requires a buffer source");
+        }
+        assertMovableSource(source);
+        const caps = getBufferReferenceCapabilities();
+        const produced = caps.produce(source); // detaches the source
+        this.runtime = getRuntime();
+        this.origin = PROCESS_ORIGIN;
+        this.pointer = produced.pointer;
+        this.byteOffset = produced.byteOffset;
+        this.byteLength = produced.byteLength;
+        this.#token = produced.token;
+        this.#isProducer = true;
+        this.#finalizerToken = {};
+        producerFinalizer?.register(this, { token: this.#token, release: caps.release }, this.#finalizerToken);
+    }
+    static fromMetadata(meta) {
+        if (!isBufferReferenceMetadata(meta)) {
+            throw new TypeError("Invalid BufferReferenceMetadata");
+        }
+        return new BufferReference(undefined, meta);
+    }
+    toMetadata() {
+        this.#assertActive();
+        return {
+            kind: BUFFER_REFERENCE_KIND,
+            origin: this.origin,
+            runtime: this.runtime,
+            pointer: this.pointer.toString(),
+            token: this.#token.toString(),
+            byteOffset: this.byteOffset,
+            byteLength: this.byteLength,
+        };
+    }
+    [BUFFER_REFERENCE_NUMERIC_TRANSFER]() {
+        this.#assertActive();
+        const originPid = readOriginPid(this.origin);
+        if (originPid === undefined ||
+            this.byteOffset > 0xffffffff ||
+            this.byteLength > 0xffffffff) {
+            return undefined;
+        }
+        const [pointerLow, pointerHigh] = splitU64(this.pointer);
+        const [tokenLow, tokenHigh] = splitU64(this.#token);
+        return [
+            pointerLow,
+            pointerHigh,
+            tokenLow,
+            tokenHigh,
+            this.byteOffset >>> 0,
+            this.byteLength >>> 0,
+            encodeRuntime(this.runtime),
+            originPid,
+        ];
+    }
+    get isLocal() {
+        return this.origin === PROCESS_ORIGIN && this.runtime === RUNTIME;
+    }
+    #assertLocal() {
+        if (this.origin !== PROCESS_ORIGIN) {
+            throw new Error(`BufferReference cannot cross a process boundary (origin ${this.origin} ` +
+                `!= ${PROCESS_ORIGIN}). Use ProcessSharedBuffer for cross-process memory.`);
+        }
+        if (this.runtime !== RUNTIME) {
+            throw new Error(`BufferReference runtime mismatch: produced on ${this.runtime}, ` +
+                `materializing on ${RUNTIME}.`);
+        }
+    }
+    #assertActive() {
+        if (this.#released) {
+            throw new Error("BufferReference has been released");
+        }
+    }
+    /** Prepare a returned reference before the worker-side producer hold drains. */
+    claimOwnership(releaser = currentReturnReleaser) {
+        if (this.#owned !== undefined || this.#borrowedReturnReleaser !== undefined ||
+            this.#released)
+            return this;
+        this.#assertLocal();
+        const caps = getBufferReferenceCapabilities();
+        const input = {
+            token: this.#token,
+            pointer: this.pointer,
+            byteOffset: this.byteOffset,
+            byteLength: this.byteLength,
+        };
+        if (releaser !== undefined) {
+            this.#borrowedReturnReleaser = releaser;
+            this.#borrowedReturnFinalizerToken = {};
+            borrowedReturnFinalizer?.register(this, { token: this.#token, release: releaser }, this.#borrowedReturnFinalizerToken);
+            return this;
+        }
+        this.#owned = caps.adopt(input, caps.supportsOwningAdopt ? undefined : { copy: true });
+        return this;
+    }
+    #materialize() {
+        this.#assertActive();
+        if (this.#owned !== undefined)
+            return this.#owned;
+        this.#assertLocal();
+        const region = getBufferReferenceCapabilities().adopt({
+            token: this.#token,
+            pointer: this.pointer,
+            byteOffset: this.byteOffset,
+            byteLength: this.byteLength,
+        });
+        if (this.#borrowedReturnReleaser !== undefined) {
+            this.#owned = region;
+            return region;
+        }
+        (this.#materializedRegions ??= []).push(region);
+        return region;
+    }
+    toArrayBuffer() {
+        const region = this.#materialize();
+        if (region.byteOffset === 0 && region.buffer.byteLength === region.byteLength) {
+            return region.buffer;
+        }
+        return region.buffer.slice(region.byteOffset, region.byteOffset + region.byteLength);
+    }
+    toUint8Array() {
+        const region = this.#materialize();
+        return new Uint8Array(region.buffer, region.byteOffset, region.byteLength);
+    }
+    /** The source is moved on construction, so it is never retained here. */
+    get source() {
+        return undefined;
+    }
+    release() {
+        if (this.#released)
+            return;
+        this.#released = true;
+        const regions = this.#materializedRegions;
+        this.#materializedRegions = undefined;
+        if (regions !== undefined) {
+            for (let i = 0; i < regions.length; i++) {
+                detachArrayBufferBestEffort(this.runtime, regions[i].buffer);
+            }
+        }
+        if (this.#borrowedReturnFinalizerToken !== undefined) {
+            borrowedReturnFinalizer?.unregister(this.#borrowedReturnFinalizerToken);
+            this.#borrowedReturnFinalizerToken = undefined;
+        }
+        const borrowedReturnReleaser = this.#borrowedReturnReleaser;
+        this.#borrowedReturnReleaser = undefined;
+        if (borrowedReturnReleaser !== undefined) {
+            const owned = this.#owned;
+            this.#owned = undefined;
+            if (owned !== undefined) {
+                detachArrayBufferBestEffort(this.runtime, owned.buffer);
+            }
+            try {
+                borrowedReturnReleaser(this.#token);
+            }
+            catch {
+                // best effort
+            }
+        }
+        if (this.#finalizerToken !== undefined) {
+            producerFinalizer?.unregister(this.#finalizerToken);
+            this.#finalizerToken = undefined;
+        }
+        // Only the producer owns the registry hold; consumers must not drop it.
+        if (this.#isProducer) {
+            try {
+                getBufferReferenceCapabilities().release(this.#token);
+            }
+            catch {
+                // best effort
+            }
+        }
+    }
+    [Symbol.dispose]() {
+        this.release();
+    }
+    [PAYLOAD_TRANSPORT_FINALIZER]() {
+        if (this.#released)
+            return undefined;
+        this.#transportRefs++;
+        let finalized = false;
+        const finalizer = (() => {
+            if (finalized)
+                return;
+            finalized = true;
+            this.#transportRefs--;
+            if (this.#transportRefs <= 0)
+                this.release();
+        });
+        if (this.#isProducer) {
+            finalizer[BUFFER_REFERENCE_RETURN_RELEASE_TOKEN] = this.#token;
+        }
+        return finalizer;
+    }
+}
+const codecGlobal = globalThis;
+const codecs = codecGlobal.__KNITTING_PAYLOAD_CODECS__ ??= Object.create(null);
+codecs[BUFFER_REFERENCE_CODEC_ID] = {
+    decode: (metadata) => {
+        const ref = BufferReference.fromMetadata(metadata);
+        // Host decodes are return values; claim before the worker drains.
+        // Worker decodes are forward inputs and stay lazy for the call.
+        return RUNTIME_IS_MAIN_THREAD ? ref.claimOwnership() : ref;
+    },
+    decodeNumeric: (metadata) => {
+        const ref = BufferReference.fromMetadata(numericMetadataToMetadata(metadata));
+        return RUNTIME_IS_MAIN_THREAD ? ref.claimOwnership() : ref;
+    },
+};

package/src/connections/bun.d.ts

@@ -0,0 +1,22 @@
+import { type CreateSharedMemoryOptions, type MapSharedMemoryOptions, type SharedMemoryConnectionPrimitives, type SharedMemoryMapping } from "./types.js";
+type BunPointer = number;
+type BunLibc = {
+    symbols: {
+        memfd_create?: (name: Uint8Array, flags: number) => number;
+        shm_open?: (name: Uint8Array, flags: number, mode: number) => number;
+        shm_unlink?: (name: Uint8Array) => number;
+        ftruncate: (fd: number, length: bigint) => number;
+        dup: (fd: number) => number;
+        fcntl: (fd: number, cmd: number, arg: number) => number;
+        mmap: (address: null, length: number, protection: number, flags: number, fd: number, offset: bigint) => BunPointer;
+        munmap: (address: BunPointer, length: number) => number;
+        close: (fd: number) => number;
+    };
+};
+export declare const openBunLibc: () => BunLibc;
+export declare const mapBunSharedMemory: (options: MapSharedMemoryOptions, libc?: BunLibc) => SharedMemoryMapping<ArrayBuffer>;
+export declare const createBunSharedMemory: (options: number | CreateSharedMemoryOptions, libc?: BunLibc) => SharedMemoryMapping<ArrayBuffer>;
+export declare const unlinkBunSharedMemory: (name: string, libc?: BunLibc) => boolean;
+export declare const createBunPosixConnectionPrimitives: (libc?: BunLibc) => SharedMemoryConnectionPrimitives<SharedMemoryMapping<ArrayBuffer>>;
+export declare const createBunConnectionPrimitives: (libc?: BunLibc) => SharedMemoryConnectionPrimitives<SharedMemoryMapping<ArrayBuffer>>;
+export {};

package/src/connections/bun.js

@@ -0,0 +1,214 @@
+import { DARWIN_O_CREAT, DARWIN_O_EXCL, DARWIN_SHM_MODE, LINUX_O_CREAT, LINUX_O_EXCL, setCloseOnExec, detectPosixPlatform, encodeCString, getPosixLibcPath, makeDarwinSharedMemoryName, MAP_SHARED, O_RDWR, POSIX_SHM_MODE, PROT_READ, PROT_WRITE, toPosixSharedMemoryName, } from "./posix.js";
+import { expectFd, expectPositiveSize, readCreateName, readCreateMode, readRequiredCreateName, readCreateSize, } from "./types.js";
+import { createBunWindowsConnectionPrimitives, isWindowsRuntime, } from "./windows.js";
+const FFIType = {
+    i32: 5,
+    i64: 7,
+    u32: 6,
+    usize: 8,
+    ptr: 12,
+};
+const getBunFFI = () => {
+    const ffi = globalThis.Bun?.FFI;
+    if (typeof ffi?.dlopen !== "function" ||
+        typeof ffi?.toArrayBuffer !== "function") {
+        throw new Error("Bun FFI is not available in this runtime");
+    }
+    return ffi;
+};
+export const openBunLibc = () => getBunFFI().dlopen(getPosixLibcPath(), {
+    ...getBunCreateSymbols(),
+    ftruncate: {
+        args: [FFIType.i32, FFIType.i64],
+        returns: FFIType.i32,
+    },
+    dup: {
+        args: [FFIType.i32],
+        returns: FFIType.i32,
+    },
+    fcntl: {
+        args: [FFIType.i32, FFIType.i32, FFIType.i32],
+        returns: FFIType.i32,
+    },
+    mmap: {
+        args: [
+            FFIType.ptr,
+            FFIType.usize,
+            FFIType.i32,
+            FFIType.i32,
+            FFIType.i32,
+            FFIType.i64,
+        ],
+        returns: FFIType.ptr,
+    },
+    munmap: {
+        args: [FFIType.ptr, FFIType.usize],
+        returns: FFIType.i32,
+    },
+    close: {
+        args: [FFIType.i32],
+        returns: FFIType.i32,
+    },
+});
+const getBunCreateSymbols = (platform = detectPosixPlatform()) => platform === "darwin"
+    ? {
+        shm_open: {
+            args: [FFIType.ptr, FFIType.i32, FFIType.u32],
+            returns: FFIType.i32,
+        },
+        shm_unlink: {
+            args: [FFIType.ptr],
+            returns: FFIType.i32,
+        },
+    }
+    : {
+        memfd_create: {
+            args: [FFIType.ptr, FFIType.u32],
+            returns: FFIType.i32,
+        },
+        shm_open: {
+            args: [FFIType.ptr, FFIType.i32, FFIType.u32],
+            returns: FFIType.i32,
+        },
+        shm_unlink: {
+            args: [FFIType.ptr],
+            returns: FFIType.i32,
+        },
+    };
+const checkResult = (result, message) => {
+    if (result < 0)
+        throw new Error(message);
+    return result;
+};
+const isBunMmapFailed = (pointer) => !pointer || pointer < 0 || pointer >= Number.MAX_SAFE_INTEGER;
+const createBunSharedMemoryFd = (name, platform, libc) => {
+    if (platform === "darwin") {
+        const shmOpen = libc.symbols.shm_open;
+        const shmUnlink = libc.symbols.shm_unlink;
+        if (shmOpen === undefined || shmUnlink === undefined) {
+            throw new Error("shm_open symbols are not available");
+        }
+        const shmName = encodeCString(makeDarwinSharedMemoryName(name, "bun"));
+        const fd = checkResult(shmOpen(shmName, O_RDWR | DARWIN_O_CREAT | DARWIN_O_EXCL, DARWIN_SHM_MODE), "shm_open failed");
+        shmUnlink(shmName);
+        try {
+            return setCloseOnExec(libc, fd);
+        }
+        catch (error) {
+            libc.symbols.close(fd);
+            throw error;
+        }
+    }
+    const memfdCreate = libc.symbols.memfd_create;
+    if (memfdCreate === undefined) {
+        throw new Error("memfd_create symbol is not available");
+    }
+    const fd = checkResult(memfdCreate(encodeCString(name), 0), "memfd_create failed");
+    try {
+        return setCloseOnExec(libc, fd);
+    }
+    catch (error) {
+        libc.symbols.close(fd);
+        throw error;
+    }
+};
+const createNamedBunSharedMemoryFd = (name, mode, platform, libc) => {
+    const shmOpen = libc.symbols.shm_open;
+    if (shmOpen === undefined) {
+        throw new Error("shm_open symbol is not available");
+    }
+    const createFlags = platform === "darwin" ? DARWIN_O_CREAT : LINUX_O_CREAT;
+    const exclusiveFlags = platform === "darwin" ? DARWIN_O_EXCL : LINUX_O_EXCL;
+    const flags = mode === "create"
+        ? O_RDWR | createFlags | exclusiveFlags
+        : O_RDWR;
+    const fd = checkResult(shmOpen(encodeCString(toPosixSharedMemoryName(name)), flags, platform === "darwin" ? DARWIN_SHM_MODE : POSIX_SHM_MODE), "shm_open failed");
+    try {
+        return setCloseOnExec(libc, fd);
+    }
+    catch (error) {
+        libc.symbols.close(fd);
+        throw error;
+    }
+};
+export const mapBunSharedMemory = (options, libc = openBunLibc()) => {
+    const sourceFd = options.name === undefined ? expectFd(options.fd) : -1;
+    const size = expectPositiveSize(options.size);
+    let fd = sourceFd;
+    if (options.name !== undefined) {
+        fd = createNamedBunSharedMemoryFd(options.name, "open", detectPosixPlatform(), libc);
+    }
+    else if (options.duplicateFd !== false) {
+        fd = checkResult(libc.symbols.dup(sourceFd), "dup(fd) failed");
+        try {
+            setCloseOnExec(libc, fd);
+        }
+        catch (error) {
+            libc.symbols.close(fd);
+            throw error;
+        }
+    }
+    const pointer = libc.symbols.mmap(null, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0n);
+    if (isBunMmapFailed(pointer)) {
+        if (options.duplicateFd !== false)
+            libc.symbols.close(fd);
+        throw new Error("mmap failed");
+    }
+    const arrayBuffer = getBunFFI().toArrayBuffer(pointer, 0, size);
+    return {
+        runtime: "bun",
+        fd,
+        name: options.name,
+        size,
+        byteLength: arrayBuffer.byteLength,
+        buffer: arrayBuffer,
+        kind: "external-array-buffer",
+        arrayBuffer,
+        unsafePointer: pointer,
+        close: () => {
+            libc.symbols.munmap(pointer, size);
+            libc.symbols.close(fd);
+        },
+    };
+};
+export const createBunSharedMemory = (options, libc = openBunLibc()) => {
+    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"
+        ? createBunSharedMemoryFd(name, platform, libc)
+        : createNamedBunSharedMemoryFd(name, mode, platform, libc);
+    try {
+        if (mode !== "open") {
+            checkResult(libc.symbols.ftruncate(fd, BigInt(size)), "ftruncate failed");
+        }
+        const mapping = mapBunSharedMemory({ fd, size, duplicateFd: false }, libc);
+        if (mode !== "anonymous") {
+            return { ...mapping, name };
+        }
+        return mapping;
+    }
+    catch (error) {
+        libc.symbols.close(fd);
+        throw error;
+    }
+};
+export const unlinkBunSharedMemory = (name, libc = openBunLibc()) => {
+    const shmUnlink = libc.symbols.shm_unlink;
+    if (shmUnlink === undefined) {
+        throw new Error("shm_unlink symbol is not available");
+    }
+    return shmUnlink(encodeCString(toPosixSharedMemoryName(name))) === 0;
+};
+export const createBunPosixConnectionPrimitives = (libc = openBunLibc()) => ({
+    runtime: "bun",
+    createSharedMemory: (options) => createBunSharedMemory(options, libc),
+    mapSharedMemory: (options) => mapBunSharedMemory(options, libc),
+    unlinkSharedMemory: (name) => unlinkBunSharedMemory(name, libc),
+});
+export const createBunConnectionPrimitives = (libc) => isWindowsRuntime()
+    ? createBunWindowsConnectionPrimitives()
+    : createBunPosixConnectionPrimitives(libc);