knitting 0.1.56 → 0.1.61

package/src/connections/posix.js

@@ -14,6 +14,107 @@ 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) {

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

@@ -71,5 +71,6 @@ export declare class ProcessSharedBuffer {
     stringifyMetadata(): string;
     toString(): string;
 }
+export declare const isProcessSharedBufferValue: (value: unknown) => value is ProcessSharedBuffer;
 export declare const parseProcessSharedBufferMetadata: (input: unknown) => ProcessSharedBufferMetadata;
 export {};

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

@@ -1,10 +1,8 @@
-import { getNodeBuiltinModule } from "../common/node-compat.js";
 import { FileDescriptor, } from "./file-descriptor.js";
 import { RUNTIME } from "../common/runtime.js";
 import { createBunConnectionPrimitives } from "./bun.js";
 import { createDenoConnectionPrimitives } from "./deno.js";
-import { loadNodeNativeAddon } from "./node-addons.js";
-import { expectFd, expectPositiveSize, readCreateMode, readCreateName, readRequiredCreateName, readCreateSize, } from "./types.js";
+import { createNodeConnectionPrimitives } from "./node.js";
 export const PROCESS_SHARED_BUFFER_BRAND = Symbol.for("knitting.processSharedBuffer");
 export const PROCESS_SHARED_BUFFER_NUMERIC_TRANSFER = Symbol.for("knitting.processSharedBuffer.numericTransfer");
 const EXTERNAL_PAYLOAD_BRAND = Symbol.for("knitting.payloadCodec");
@@ -39,51 +37,15 @@ const decodeKind = (value) => {
     }
 };
 let defaultPrimitives;
-const fromDefaultNodeNativeMapping = (mapped) => {
-    const mapping = {
-        runtime: "node",
-        fd: mapped.fd,
-        size: mapped.size,
-        byteLength: mapped.sab.byteLength,
-        buffer: mapped.sab,
-        kind: "shared-array-buffer",
-        sab: mapped.sab,
-        baseAddressMod64: mapped.baseAddressMod64,
-    };
-    if (mapped.name !== undefined && mapped.name.length > 0) {
-        mapping.name = mapped.name;
-    }
-    return mapping;
-};
-const createDefaultNodePrimitives = () => {
-    const nodeModule = getNodeBuiltinModule("node:module");
-    if (nodeModule === undefined) {
-        throw new TypeError("ProcessSharedBuffer needs connection primitives in this runtime");
-    }
-    const require = nodeModule.createRequire(import.meta.url);
-    const addon = loadNodeNativeAddon(require, "knitting_shared_memory");
-    return {
-        createSharedMemory: (options) => {
-            const size = expectPositiveSize(readCreateSize(options));
-            const mode = readCreateMode(options);
-            const name = mode === "anonymous"
-                ? readCreateName(options, "knitting_shared_memory")
-                : readRequiredCreateName(options);
-            return fromDefaultNodeNativeMapping(addon.createSharedMemory(size, name, mode));
-        },
-        mapSharedMemory: (options) => {
-            const fd = expectFd(options.fd);
-            const size = expectPositiveSize(options.size);
-            return fromDefaultNodeNativeMapping(addon.mapSharedMemory(fd, size, options.name));
-        },
-    };
-};
+const processSharedBufferInstances = new WeakSet();
 const createDefaultPrimitives = () => {
     if (RUNTIME === "bun")
         return createBunConnectionPrimitives();
     if (RUNTIME === "deno")
         return createDenoConnectionPrimitives();
-    return createDefaultNodePrimitives();
+    if (RUNTIME === "node")
+        return createNodeConnectionPrimitives();
+    throw new TypeError("ProcessSharedBuffer needs connection primitives in this runtime");
 };
 export const setDefaultProcessSharedBufferPrimitives = (primitives) => {
     defaultPrimitives = primitives;
@@ -136,6 +98,7 @@ export class ProcessSharedBuffer {
         this.descriptor = descriptor;
         this.byteOffset = byteOffset;
         this.byteLength = byteLength;
+        processSharedBufferInstances.add(this);
     }
     static create(options, creator = getDefaultProcessSharedBufferPrimitives()) {
         return ProcessSharedBuffer.fromMapping(creator.createSharedMemory(options));
@@ -251,6 +214,9 @@ export class ProcessSharedBuffer {
         return this.stringify();
     }
 }
+export const isProcessSharedBufferValue = (value) => value !== null &&
+    typeof value === "object" &&
+    processSharedBufferInstances.has(value);
 export const parseProcessSharedBufferMetadata = (input) => {
     const value = typeof input === "string" ? JSON.parse(input) : input;
     if (!isRecord(value)) {
@@ -271,8 +237,8 @@ export const parseProcessSharedBufferMetadata = (input) => {
     };
 };
 const processSharedBufferGlobal = globalThis;
-const codecs = processSharedBufferGlobal.__KNITTING_PAYLOAD_CODECS__ ??=
-    Object.create(null);
+const codecs = processSharedBufferGlobal.__KNITTING_PAYLOAD_CODECS__ ??= Object
+    .create(null);
 codecs[PROCESS_SHARED_BUFFER_CODEC_ID] = {
     decode: (metadata) => ProcessSharedBuffer.fromMetadata(metadata),
     decodeNumeric: (metadata) => ProcessSharedBuffer[PROCESS_SHARED_BUFFER_NUMERIC_TRANSFER](metadata),

package/src/connections/types.d.ts

@@ -31,6 +31,10 @@ export type MapSharedMemoryOptions = {
     fd: number;
     name?: string;
     size: number;
+    /**
+     * When false, map the supplied descriptor directly. Ownership transfers to
+     * the returned mapping only after mapping succeeds; failures leave it open.
+     */
     duplicateFd?: boolean;
 };
 export type SharedMemoryConnectionPrimitives<Mapping extends SharedMemoryMapping = SharedMemoryMapping> = {

package/src/connections/windows.d.ts

@@ -1,28 +1,37 @@
+import { type NodeFfiLibrary } from "./node-ffi-api.js";
 import { type CreateSharedMemoryOptions, type MapSharedMemoryOptions, type SharedMemoryConnectionPrimitives, type SharedMemoryMapping } from "./types.js";
+declare const WINDOWS_CREATE_SHARED_MEMORY = "knitting_windows_create_shared_memory";
+declare const WINDOWS_MAP_SHARED_MEMORY = "knitting_windows_map_shared_memory";
+declare const WINDOWS_CLOSE_SHARED_MEMORY = "knitting_windows_close_shared_memory";
+type WindowsSharedMemorySymbols = {
+    [WINDOWS_CREATE_SHARED_MEMORY]: (size: bigint, name: Uint16Array, mode: number, out: Uint8Array) => number;
+    [WINDOWS_MAP_SHARED_MEMORY]: (handle: bigint, size: bigint, name: Uint16Array, out: Uint8Array) => number;
+    [WINDOWS_CLOSE_SHARED_MEMORY]: (mapping: Uint8Array) => number;
+};
 type DenoWindowsLibrary = {
-    symbols: {
-        knitting_windows_create_shared_memory: (size: bigint, name: Uint16Array, mode: number, out: Uint8Array) => number;
-        knitting_windows_map_shared_memory: (handle: bigint, size: bigint, name: Uint16Array, out: Uint8Array) => number;
-        knitting_windows_close_shared_memory: (mapping: Uint8Array) => number;
-    };
+    symbols: WindowsSharedMemorySymbols;
     close: () => void;
 };
 type BunWindowsLibrary = {
-    symbols: {
-        knitting_windows_create_shared_memory: (size: bigint, name: Uint16Array, mode: number, out: Uint8Array) => number;
-        knitting_windows_map_shared_memory: (handle: bigint, size: bigint, name: Uint16Array, out: Uint8Array) => number;
-        knitting_windows_close_shared_memory: (mapping: Uint8Array) => number;
-    };
+    symbols: WindowsSharedMemorySymbols;
+};
+type NodeWindowsLibrary = {
+    functions: WindowsSharedMemorySymbols;
+    lib: NodeFfiLibrary;
 };
 export declare const isWindowsRuntime: () => boolean;
 export declare const windowsSharedMemoryPrebuildPath: () => string;
 export declare const makeWindowsAnonymousSharedMemoryName: (runtime: string) => string;
 export declare const openDenoWindowsSharedMemoryLibrary: () => DenoWindowsLibrary;
 export declare const openBunWindowsSharedMemoryLibrary: () => BunWindowsLibrary;
+export declare const openNodeWindowsSharedMemoryLibrary: () => NodeWindowsLibrary;
 export declare const createDenoWindowsSharedMemory: (options: number | CreateSharedMemoryOptions, lib?: DenoWindowsLibrary) => SharedMemoryMapping<ArrayBuffer>;
 export declare const mapDenoWindowsSharedMemory: (options: MapSharedMemoryOptions, lib?: DenoWindowsLibrary) => SharedMemoryMapping<ArrayBuffer>;
 export declare const createDenoWindowsConnectionPrimitives: (lib?: DenoWindowsLibrary) => SharedMemoryConnectionPrimitives<SharedMemoryMapping<ArrayBuffer>>;
 export declare const createBunWindowsSharedMemory: (options: number | CreateSharedMemoryOptions, lib?: BunWindowsLibrary) => SharedMemoryMapping<ArrayBuffer>;
 export declare const mapBunWindowsSharedMemory: (options: MapSharedMemoryOptions, lib?: BunWindowsLibrary) => SharedMemoryMapping<ArrayBuffer>;
 export declare const createBunWindowsConnectionPrimitives: (lib?: BunWindowsLibrary) => SharedMemoryConnectionPrimitives<SharedMemoryMapping<ArrayBuffer>>;
+export declare const createNodeWindowsSharedMemory: (options: number | CreateSharedMemoryOptions, lib?: NodeWindowsLibrary) => SharedMemoryMapping<ArrayBuffer>;
+export declare const mapNodeWindowsSharedMemory: (options: MapSharedMemoryOptions, lib?: NodeWindowsLibrary) => SharedMemoryMapping<ArrayBuffer>;
+export declare const createNodeWindowsConnectionPrimitives: (lib?: NodeWindowsLibrary) => SharedMemoryConnectionPrimitives<SharedMemoryMapping<ArrayBuffer>>;
 export {};

package/src/connections/windows.js

@@ -1,4 +1,6 @@
 import { resolveKnittingPackageAsset } from "./package-assets.js";
+import { requireDetachedExternalArrayBuffer } from "./external-array-buffer.js";
+import { getNodeFfi, } from "./node-ffi-api.js";
 import { expectFd, expectPositiveSize, readCreateMode, readCreateSize, readRequiredCreateName, } from "./types.js";
 const WINDOWS_CREATE_MODE_CREATE = 1;
 const WINDOWS_CREATE_MODE_OPEN = 2;
@@ -7,6 +9,9 @@ const POINTER_OFFSET = 0;
 const HANDLE_OFFSET = 8;
 const SIZE_OFFSET = 16;
 const BASE_ADDRESS_MOD_64_OFFSET = 24;
+const WINDOWS_CREATE_SHARED_MEMORY = "knitting_windows_create_shared_memory";
+const WINDOWS_MAP_SHARED_MEMORY = "knitting_windows_map_shared_memory";
+const WINDOWS_CLOSE_SHARED_MEMORY = "knitting_windows_close_shared_memory";
 const FFIType = {
     i32: 5,
     u32: 6,
@@ -105,34 +110,59 @@ const checkWindowsResult = (result, message) => {
     }
 };
 const createRecord = () => new Uint8Array(WINDOWS_MAPPING_RECORD_BYTES);
-export const openDenoWindowsSharedMemoryLibrary = () => getDeno().dlopen(windowsSharedMemoryPrebuildPath(), {
-    knitting_windows_create_shared_memory: {
+const DENO_WINDOWS_SYMBOLS = {
+    [WINDOWS_CREATE_SHARED_MEMORY]: {
         parameters: ["u64", "buffer", "u32", "buffer"],
         result: "i32",
     },
-    knitting_windows_map_shared_memory: {
+    [WINDOWS_MAP_SHARED_MEMORY]: {
         parameters: ["u64", "u64", "buffer", "buffer"],
         result: "i32",
     },
-    knitting_windows_close_shared_memory: {
+    [WINDOWS_CLOSE_SHARED_MEMORY]: {
         parameters: ["buffer"],
         result: "i32",
     },
-});
-export const openBunWindowsSharedMemoryLibrary = () => getBunFFI().dlopen(windowsSharedMemoryPrebuildPath(), {
-    knitting_windows_create_shared_memory: {
+};
+const BUN_WINDOWS_SYMBOLS = {
+    [WINDOWS_CREATE_SHARED_MEMORY]: {
         args: [FFIType.i64, FFIType.ptr, FFIType.u32, FFIType.ptr],
         returns: FFIType.i32,
     },
-    knitting_windows_map_shared_memory: {
+    [WINDOWS_MAP_SHARED_MEMORY]: {
         args: [FFIType.i64, FFIType.i64, FFIType.ptr, FFIType.ptr],
         returns: FFIType.i32,
     },
-    knitting_windows_close_shared_memory: {
+    [WINDOWS_CLOSE_SHARED_MEMORY]: {
         args: [FFIType.ptr],
         returns: FFIType.i32,
     },
-});
+};
+const NODE_WINDOWS_SYMBOLS = {
+    [WINDOWS_CREATE_SHARED_MEMORY]: {
+        arguments: ["u64", "pointer", "u32", "pointer"],
+        return: "i32",
+    },
+    [WINDOWS_MAP_SHARED_MEMORY]: {
+        arguments: ["u64", "u64", "pointer", "pointer"],
+        return: "i32",
+    },
+    [WINDOWS_CLOSE_SHARED_MEMORY]: {
+        arguments: ["pointer"],
+        return: "i32",
+    },
+};
+export const openDenoWindowsSharedMemoryLibrary = () => getDeno().dlopen(windowsSharedMemoryPrebuildPath(), DENO_WINDOWS_SYMBOLS);
+export const openBunWindowsSharedMemoryLibrary = () => getBunFFI().dlopen(windowsSharedMemoryPrebuildPath(), BUN_WINDOWS_SYMBOLS);
+let cachedNodeWindowsLibrary;
+export const openNodeWindowsSharedMemoryLibrary = () => {
+    if (cachedNodeWindowsLibrary !== undefined) {
+        return cachedNodeWindowsLibrary;
+    }
+    const opened = getNodeFfi().dlopen(windowsSharedMemoryPrebuildPath(), NODE_WINDOWS_SYMBOLS);
+    cachedNodeWindowsLibrary = opened;
+    return opened;
+};
 const closeWindowsMapping = (record, closeSharedMemory) => {
     let closed = false;
     return () => {
@@ -142,6 +172,19 @@ const closeWindowsMapping = (record, closeSharedMemory) => {
         checkWindowsResult(closeSharedMemory(record), "knitting_windows_close_shared_memory");
     };
 };
+const makeWindowsMapping = (runtime, mapping, name, arrayBuffer, unsafePointer, close) => ({
+    runtime,
+    fd: fdFromHandle(mapping.handle),
+    name,
+    size: mapping.size,
+    byteLength: arrayBuffer.byteLength,
+    buffer: arrayBuffer,
+    kind: "external-array-buffer",
+    arrayBuffer,
+    unsafePointer,
+    baseAddressMod64: mapping.baseAddressMod64,
+    close,
+});
 const fromDenoWindowsRecord = (record, name, lib) => {
     const mapping = readWindowsNativeMapping(record);
     const pointer = getDeno().UnsafePointer?.create(mapping.address);
@@ -150,19 +193,7 @@ const fromDenoWindowsRecord = (record, name, lib) => {
     }
     const arrayBuffer = new (getDeno().UnsafePointerView)(pointer)
         .getArrayBuffer(mapping.size);
-    return {
-        runtime: "deno",
-        fd: fdFromHandle(mapping.handle),
-        name,
-        size: mapping.size,
-        byteLength: arrayBuffer.byteLength,
-        buffer: arrayBuffer,
-        kind: "external-array-buffer",
-        arrayBuffer,
-        unsafePointer: pointer,
-        baseAddressMod64: mapping.baseAddressMod64,
-        close: closeWindowsMapping(record, lib.symbols.knitting_windows_close_shared_memory),
-    };
+    return makeWindowsMapping("deno", mapping, name, arrayBuffer, pointer, closeWindowsMapping(record, lib.symbols[WINDOWS_CLOSE_SHARED_MEMORY]));
 };
 const fromBunWindowsRecord = (record, name, lib) => {
     const mapping = readWindowsNativeMapping(record);
@@ -170,55 +201,45 @@ const fromBunWindowsRecord = (record, name, lib) => {
         throw new RangeError("Windows mapping pointer is too large for Bun FFI");
     }
     const arrayBuffer = getBunFFI().toArrayBuffer(Number(mapping.address), 0, mapping.size);
-    return {
-        runtime: "bun",
-        fd: fdFromHandle(mapping.handle),
-        name,
-        size: mapping.size,
-        byteLength: arrayBuffer.byteLength,
-        buffer: arrayBuffer,
-        kind: "external-array-buffer",
-        arrayBuffer,
-        unsafePointer: Number(mapping.address),
-        baseAddressMod64: mapping.baseAddressMod64,
-        close: closeWindowsMapping(record, lib.symbols.knitting_windows_close_shared_memory),
-    };
-};
-export const createDenoWindowsSharedMemory = (options, lib = openDenoWindowsSharedMemoryLibrary()) => {
-    const size = expectPositiveSize(readCreateSize(options));
-    const { mode, name } = readWindowsCreate(options, "deno");
-    const record = createRecord();
-    checkWindowsResult(lib.symbols.knitting_windows_create_shared_memory(BigInt(size), encodeWideCString(name), mode, record), "knitting_windows_create_shared_memory");
-    return fromDenoWindowsRecord(record, name, lib);
+    return makeWindowsMapping("bun", mapping, name, arrayBuffer, Number(mapping.address), closeWindowsMapping(record, lib.symbols[WINDOWS_CLOSE_SHARED_MEMORY]));
 };
-export const mapDenoWindowsSharedMemory = (options, lib = openDenoWindowsSharedMemoryLibrary()) => {
-    const fd = expectFd(options.fd);
-    const size = expectPositiveSize(options.size);
-    const record = createRecord();
-    checkWindowsResult(lib.symbols.knitting_windows_map_shared_memory(BigInt(fd), BigInt(size), encodeWideCString(options.name), record), "knitting_windows_map_shared_memory");
-    return fromDenoWindowsRecord(record, options.name, lib);
+const fromNodeWindowsRecord = (record, name, lib) => {
+    const mapping = readWindowsNativeMapping(record);
+    const arrayBuffer = getNodeFfi().toArrayBuffer(mapping.address, mapping.size, false);
+    let closed = false;
+    return makeWindowsMapping("node", mapping, name, arrayBuffer, mapping.address, () => {
+        if (closed)
+            return;
+        requireDetachedExternalArrayBuffer(arrayBuffer);
+        checkWindowsResult(lib.functions[WINDOWS_CLOSE_SHARED_MEMORY](record), WINDOWS_CLOSE_SHARED_MEMORY);
+        closed = true;
+    });
 };
-export const createDenoWindowsConnectionPrimitives = (lib = openDenoWindowsSharedMemoryLibrary()) => ({
-    runtime: "deno",
-    createSharedMemory: (options) => createDenoWindowsSharedMemory(options, lib),
-    mapSharedMemory: (options) => mapDenoWindowsSharedMemory(options, lib),
-});
-export const createBunWindowsSharedMemory = (options, lib = openBunWindowsSharedMemoryLibrary()) => {
+const createWindowsSharedMemory = (options, runtime, lib, createSharedMemory, fromRecord) => {
     const size = expectPositiveSize(readCreateSize(options));
-    const { mode, name } = readWindowsCreate(options, "bun");
+    const { mode, name } = readWindowsCreate(options, runtime);
     const record = createRecord();
-    checkWindowsResult(lib.symbols.knitting_windows_create_shared_memory(BigInt(size), encodeWideCString(name), mode, record), "knitting_windows_create_shared_memory");
-    return fromBunWindowsRecord(record, name, lib);
+    checkWindowsResult(createSharedMemory(BigInt(size), encodeWideCString(name), mode, record), WINDOWS_CREATE_SHARED_MEMORY);
+    return fromRecord(record, name, lib);
 };
-export const mapBunWindowsSharedMemory = (options, lib = openBunWindowsSharedMemoryLibrary()) => {
+const mapWindowsSharedMemory = (options, lib, mapSharedMemory, fromRecord) => {
     const fd = expectFd(options.fd);
     const size = expectPositiveSize(options.size);
     const record = createRecord();
-    checkWindowsResult(lib.symbols.knitting_windows_map_shared_memory(BigInt(fd), BigInt(size), encodeWideCString(options.name), record), "knitting_windows_map_shared_memory");
-    return fromBunWindowsRecord(record, options.name, lib);
-};
-export const createBunWindowsConnectionPrimitives = (lib = openBunWindowsSharedMemoryLibrary()) => ({
-    runtime: "bun",
-    createSharedMemory: (options) => createBunWindowsSharedMemory(options, lib),
-    mapSharedMemory: (options) => mapBunWindowsSharedMemory(options, lib),
+    checkWindowsResult(mapSharedMemory(BigInt(fd), BigInt(size), encodeWideCString(options.name), record), WINDOWS_MAP_SHARED_MEMORY);
+    return fromRecord(record, options.name, lib);
+};
+export const createDenoWindowsSharedMemory = (options, lib = openDenoWindowsSharedMemoryLibrary()) => createWindowsSharedMemory(options, "deno", lib, lib.symbols[WINDOWS_CREATE_SHARED_MEMORY], fromDenoWindowsRecord);
+export const mapDenoWindowsSharedMemory = (options, lib = openDenoWindowsSharedMemoryLibrary()) => mapWindowsSharedMemory(options, lib, lib.symbols[WINDOWS_MAP_SHARED_MEMORY], fromDenoWindowsRecord);
+const createWindowsConnectionPrimitives = (runtime, lib, createSharedMemory, mapSharedMemory) => ({
+    runtime,
+    createSharedMemory: (options) => createSharedMemory(options, lib),
+    mapSharedMemory: (options) => mapSharedMemory(options, lib),
 });
+export const createDenoWindowsConnectionPrimitives = (lib = openDenoWindowsSharedMemoryLibrary()) => createWindowsConnectionPrimitives("deno", lib, createDenoWindowsSharedMemory, mapDenoWindowsSharedMemory);
+export const createBunWindowsSharedMemory = (options, lib = openBunWindowsSharedMemoryLibrary()) => createWindowsSharedMemory(options, "bun", lib, lib.symbols[WINDOWS_CREATE_SHARED_MEMORY], fromBunWindowsRecord);
+export const mapBunWindowsSharedMemory = (options, lib = openBunWindowsSharedMemoryLibrary()) => mapWindowsSharedMemory(options, lib, lib.symbols[WINDOWS_MAP_SHARED_MEMORY], fromBunWindowsRecord);
+export const createBunWindowsConnectionPrimitives = (lib = openBunWindowsSharedMemoryLibrary()) => createWindowsConnectionPrimitives("bun", lib, createBunWindowsSharedMemory, mapBunWindowsSharedMemory);
+export const createNodeWindowsSharedMemory = (options, lib = openNodeWindowsSharedMemoryLibrary()) => createWindowsSharedMemory(options, "node", lib, lib.functions[WINDOWS_CREATE_SHARED_MEMORY], fromNodeWindowsRecord);
+export const mapNodeWindowsSharedMemory = (options, lib = openNodeWindowsSharedMemoryLibrary()) => mapWindowsSharedMemory(options, lib, lib.functions[WINDOWS_MAP_SHARED_MEMORY], fromNodeWindowsRecord);
+export const createNodeWindowsConnectionPrimitives = (lib = openNodeWindowsSharedMemoryLibrary()) => createWindowsConnectionPrimitives("node", lib, createNodeWindowsSharedMemory, mapNodeWindowsSharedMemory);

package/src/error.d.ts

@@ -1,10 +1,11 @@
 import { type PromisePayloadHandler, type Task } from "./memory/lock.js";
-export declare enum ErrorKnitting {
-    Function = 0,
-    Symbol = 1,
-    Json = 2,
-    Serializable = 3
-}
+export declare const ErrorKnitting: {
+    readonly Function: 0;
+    readonly Symbol: 1;
+    readonly Json: 2;
+    readonly Serializable: 3;
+};
+export type ErrorKnitting = typeof ErrorKnitting[keyof typeof ErrorKnitting];
 export declare const encoderError: ({ task, type, onPromise, detail, }: {
     task: Task;
     type: ErrorKnitting;

package/src/error.js

@@ -1,12 +1,13 @@
 import { beginPromisePayload, finishPromisePayload, TaskFlag, TaskIndex, } from "./memory/lock.js";
 import { RUNTIME_IS_MAIN_THREAD } from "./common/worker-runtime.js";
-export var ErrorKnitting;
-(function (ErrorKnitting) {
-    ErrorKnitting[ErrorKnitting["Function"] = 0] = "Function";
-    ErrorKnitting[ErrorKnitting["Symbol"] = 1] = "Symbol";
-    ErrorKnitting[ErrorKnitting["Json"] = 2] = "Json";
-    ErrorKnitting[ErrorKnitting["Serializable"] = 3] = "Serializable";
-})(ErrorKnitting || (ErrorKnitting = {}));
+// const object, not `enum`: Andromeda's Nova engine can't parse `enum`. Same
+// value access and emit on Node/Deno/Bun.
+export const ErrorKnitting = {
+    Function: 0,
+    Symbol: 1,
+    Json: 2,
+    Serializable: 3,
+};
 const reasonFrom = (task, type, detail) => {
     switch (type) {
         case ErrorKnitting.Function: {