knitting 0.1.46

package/src/common/runtime.js

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

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

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

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

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

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

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

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

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

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

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

package/src/common/task-source.js

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

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

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

package/src/common/task-symbol.js

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

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

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

package/src/common/with-resolvers.js

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

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

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

package/src/common/worker-runtime.js

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

package/src/connections/bun.d.ts

@@ -0,0 +1,20 @@
+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 createBunConnectionPrimitives: (libc?: BunLibc) => SharedMemoryConnectionPrimitives<SharedMemoryMapping<ArrayBuffer>>;
+export {};

package/src/connections/bun.js

@@ -0,0 +1,159 @@
+import { DARWIN_O_CREAT, DARWIN_O_EXCL, DARWIN_SHM_MODE, setCloseOnExec, detectPosixPlatform, encodeCString, getPosixLibcPath, makeDarwinSharedMemoryName, MAP_SHARED, O_RDWR, PROT_READ, PROT_WRITE, } from "./posix.js";
+import { expectFd, expectPositiveSize, readCreateName, readCreateSize, } from "./types.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,
+        },
+    };
+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;
+    }
+};
+export const mapBunSharedMemory = (options, libc = openBunLibc()) => {
+    const sourceFd = expectFd(options.fd);
+    const size = expectPositiveSize(options.size);
+    let fd = sourceFd;
+    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,
+        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 name = readCreateName(options, "knitting_shared_memory");
+    const fd = createBunSharedMemoryFd(name, detectPosixPlatform(), libc);
+    try {
+        checkResult(libc.symbols.ftruncate(fd, BigInt(size)), "ftruncate failed");
+        return mapBunSharedMemory({ fd, size, duplicateFd: false }, libc);
+    }
+    catch (error) {
+        libc.symbols.close(fd);
+        throw error;
+    }
+};
+export const createBunConnectionPrimitives = (libc = openBunLibc()) => ({
+    runtime: "bun",
+    createSharedMemory: (options) => createBunSharedMemory(options, libc),
+    mapSharedMemory: (options) => mapBunSharedMemory(options, libc),
+});

package/src/connections/deno.d.ts

@@ -0,0 +1,20 @@
+import { type CreateSharedMemoryOptions, type MapSharedMemoryOptions, type SharedMemoryConnectionPrimitives, type SharedMemoryMapping } from "./types.js";
+type DenoLibc = {
+    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) => unknown;
+        munmap: (address: unknown, length: number) => number;
+        close: (fd: number) => number;
+    };
+    close: () => void;
+};
+export declare const openDenoLibc: () => DenoLibc;
+export declare const mapDenoSharedMemory: (options: MapSharedMemoryOptions, libc?: DenoLibc) => SharedMemoryMapping<ArrayBuffer>;
+export declare const createDenoSharedMemory: (options: number | CreateSharedMemoryOptions, libc?: DenoLibc) => SharedMemoryMapping<ArrayBuffer>;
+export declare const createDenoConnectionPrimitives: (libc?: DenoLibc) => SharedMemoryConnectionPrimitives<SharedMemoryMapping<ArrayBuffer>>;
+export {};