knitting 0.1.46 → 0.1.50

package/src/api.js

@@ -6,7 +6,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { getCallerFilePath } from "./common/task-source.js";
+import { getCallerFilePath, getCallerHref } from "./common/task-source.js";
 import { genTaskID } from "./common/task-source.js";
 import { toModuleUrl } from "./common/module-url.js";
 import { endpointSymbol } from "./common/task-symbol.js";
@@ -18,6 +18,7 @@ import { managerMethod } from "./runtime/balancer.js";
 import { createInlineExecutor } from "./runtime/inline-executor.js";
 const MAX_FUNCTION_ID = 0xFFFF;
 const MAX_FUNCTION_COUNT = MAX_FUNCTION_ID + 1;
+const DEFAULT_IMPORT_EXPORT_NAME = "default";
 export const isMain = RUNTIME_IS_MAIN_THREAD;
 export { endpointSymbol as endpointSymbol };
 /**
@@ -44,6 +45,34 @@ export const toListAndIds = (args) => {
         at: [...result[2]],
     };
 };
+const resolveImportHref = (href, callerHref) => {
+    try {
+        return new URL(href, callerHref).href;
+    }
+    catch {
+        return toModuleUrl(href);
+    }
+};
+const resolveWorkerBootstrapSettings = (worker, callerHref) => {
+    const bootstrap = worker?.bootstrap;
+    if (bootstrap === undefined)
+        return worker;
+    const name = bootstrap.name ?? DEFAULT_IMPORT_EXPORT_NAME;
+    if (typeof bootstrap.href !== "string" || bootstrap.href.length === 0) {
+        throw new TypeError("worker.bootstrap.href must be a non-empty string");
+    }
+    if (typeof name !== "string" || name.length === 0) {
+        throw new TypeError("worker.bootstrap.name must be a non-empty string");
+    }
+    return {
+        ...worker,
+        bootstrap: {
+            ...bootstrap,
+            href: resolveImportHref(bootstrap.href, callerHref),
+            name,
+        },
+    };
+};
 export const createPool = ({ threads, debug, inliner, balancer, payload, payloadInitialBytes, payloadMaxBytes, bufferMode, maxPayloadBytes, abortSignalCapacity, source, worker, workerExecArgv, permission, dispatcher, host, }) => (tasks) => {
     /**
      *  This functions is only available in the main thread.
@@ -148,8 +177,12 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, payload
     const execArgv = sanitizeExecArgv(combinedExecArgv.length > 0 ? combinedExecArgv : undefined);
     const hostDispatcher = host ?? dispatcher;
     const usesAbortSignal = listOfFunctions.some((fn) => fn.abortSignal !== undefined);
-    const hardTimeoutMs = Number.isFinite(worker?.hardTimeoutMs)
-        ? Math.max(1, Math.floor(worker?.hardTimeoutMs))
+    const resolvedWorker = resolveWorkerBootstrapSettings(worker, getCallerHref(3));
+    if (usingInliner && resolvedWorker?.bootstrap !== undefined) {
+        throw new Error("worker.bootstrap cannot be used with the inliner");
+    }
+    const hardTimeoutMs = Number.isFinite(resolvedWorker?.hardTimeoutMs)
+        ? Math.max(1, Math.floor(resolvedWorker?.hardTimeoutMs))
         : undefined;
     let workers = Array.from({
         length: threads ?? 1,
@@ -161,7 +194,7 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, payload
         debug,
         totalNumberOfThread,
         source,
-        workerOptions: worker,
+        workerOptions: resolvedWorker,
         workerExecArgv: execArgv,
         host: hostDispatcher,
         payload,
@@ -303,7 +336,6 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, payload
     };
 };
 const SINGLE_TASK_KEY = "__task__";
-const DEFAULT_IMPORT_EXPORT_NAME = "default";
 const createSingleTaskPool = (single, options) => {
     const pool = createPool(options ?? {})({
         [SINGLE_TASK_KEY]: single,
@@ -334,14 +366,6 @@ const buildTaskDefinition = (input, callerOffset) => {
     const [href, at] = getCallerFilePath(callerOffset);
     return buildTaskDefinitionFromCaller(input, href, at);
 };
-const resolveImportHref = (href, callerHref) => {
-    try {
-        return new URL(href, callerHref).href;
-    }
-    catch {
-        return toModuleUrl(href);
-    }
-};
 const createImportedTaskFn = (href, exportName) => {
     let cachedFn;
     let cachedLoad;

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

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

package/src/common/task-source.js

@@ -71,6 +71,7 @@ const resolveCallerHref = (offset) => {
     return toModuleUrl(caller);
 };
 const linkingMap = new Map();
+export const getCallerHref = (offset = 3) => resolveCallerHref(offset);
 export const getCallerFilePath = (offset = 3) => {
     const href = resolveCallerHref(offset);
     const at = linkingMap.get(href) ?? 0;

package/src/connections/bun.d.ts

@@ -16,5 +16,7 @@ type BunLibc = {
 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

@@ -1,5 +1,6 @@
-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";
+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,
@@ -65,6 +66,14 @@ const getBunCreateSymbols = (platform = detectPosixPlatform()) => platform === "
             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)
@@ -103,11 +112,33 @@ const createBunSharedMemoryFd = (name, platform, libc) => {
         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 = expectFd(options.fd);
+    const sourceFd = options.name === undefined ? expectFd(options.fd) : -1;
     const size = expectPositiveSize(options.size);
     let fd = sourceFd;
-    if (options.duplicateFd !== false) {
+    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);
@@ -127,6 +158,7 @@ export const mapBunSharedMemory = (options, libc = openBunLibc()) => {
     return {
         runtime: "bun",
         fd,
+        name: options.name,
         size,
         byteLength: arrayBuffer.byteLength,
         buffer: arrayBuffer,
@@ -141,19 +173,42 @@ export const mapBunSharedMemory = (options, libc = openBunLibc()) => {
 };
 export const createBunSharedMemory = (options, libc = openBunLibc()) => {
     const size = expectPositiveSize(readCreateSize(options));
-    const name = readCreateName(options, "knitting_shared_memory");
-    const fd = createBunSharedMemoryFd(name, detectPosixPlatform(), libc);
+    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 {
-        checkResult(libc.symbols.ftruncate(fd, BigInt(size)), "ftruncate failed");
-        return mapBunSharedMemory({ fd, size, duplicateFd: false }, libc);
+        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 createBunConnectionPrimitives = (libc = openBunLibc()) => ({
+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);

package/src/connections/deno.d.ts

@@ -16,5 +16,7 @@ type DenoLibc = {
 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 unlinkDenoSharedMemory: (name: string, libc?: DenoLibc) => boolean;
+export declare const createDenoPosixConnectionPrimitives: (libc?: DenoLibc) => SharedMemoryConnectionPrimitives<SharedMemoryMapping<ArrayBuffer>>;
 export declare const createDenoConnectionPrimitives: (libc?: DenoLibc) => SharedMemoryConnectionPrimitives<SharedMemoryMapping<ArrayBuffer>>;
 export {};

package/src/connections/deno.js

@@ -1,5 +1,6 @@
-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";
+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 { createDenoWindowsConnectionPrimitives, isWindowsRuntime, } from "./windows.js";
 const getDeno = () => {
     const deno = globalThis.Deno;
     if (deno === undefined) {
@@ -50,6 +51,14 @@ const getDenoCreateSymbols = (platform = detectPosixPlatform()) => platform ===
             parameters: ["buffer", "u32"],
             result: "i32",
         },
+        shm_open: {
+            parameters: ["buffer", "i32", "u32"],
+            result: "i32",
+        },
+        shm_unlink: {
+            parameters: ["buffer"],
+            result: "i32",
+        },
     };
 const checkResult = (result, message) => {
     if (result < 0)
@@ -93,11 +102,33 @@ const createDenoSharedMemoryFd = (name, platform, libc) => {
         throw error;
     }
 };
+const createNamedDenoSharedMemoryFd = (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 mapDenoSharedMemory = (options, libc = openDenoLibc()) => {
-    const sourceFd = expectFd(options.fd);
+    const sourceFd = options.name === undefined ? expectFd(options.fd) : -1;
     const size = expectPositiveSize(options.size);
     let fd = sourceFd;
-    if (options.duplicateFd !== false) {
+    if (options.name !== undefined) {
+        fd = createNamedDenoSharedMemoryFd(options.name, "open", detectPosixPlatform(), libc);
+    }
+    else if (options.duplicateFd !== false) {
         fd = checkResult(libc.symbols.dup(sourceFd), "dup(fd) failed");
         try {
             setCloseOnExec(libc, fd);
@@ -118,6 +149,7 @@ export const mapDenoSharedMemory = (options, libc = openDenoLibc()) => {
     return {
         runtime: "deno",
         fd,
+        name: options.name,
         size,
         byteLength: arrayBuffer.byteLength,
         buffer: arrayBuffer,
@@ -132,19 +164,42 @@ export const mapDenoSharedMemory = (options, libc = openDenoLibc()) => {
 };
 export const createDenoSharedMemory = (options, libc = openDenoLibc()) => {
     const size = expectPositiveSize(readCreateSize(options));
-    const name = readCreateName(options, "knitting_shared_memory");
-    const fd = createDenoSharedMemoryFd(name, detectPosixPlatform(), libc);
+    const mode = readCreateMode(options);
+    const name = mode === "anonymous"
+        ? readCreateName(options, "knitting_shared_memory")
+        : readRequiredCreateName(options);
+    const platform = detectPosixPlatform();
+    const fd = mode === "anonymous"
+        ? createDenoSharedMemoryFd(name, platform, libc)
+        : createNamedDenoSharedMemoryFd(name, mode, platform, libc);
     try {
-        checkResult(libc.symbols.ftruncate(fd, BigInt(size)), "ftruncate failed");
-        return mapDenoSharedMemory({ fd, size, duplicateFd: false }, libc);
+        if (mode !== "open") {
+            checkResult(libc.symbols.ftruncate(fd, BigInt(size)), "ftruncate failed");
+        }
+        const mapping = mapDenoSharedMemory({ fd, size, duplicateFd: false }, libc);
+        if (mode !== "anonymous") {
+            return { ...mapping, name };
+        }
+        return mapping;
     }
     catch (error) {
         libc.symbols.close(fd);
         throw error;
     }
 };
-export const createDenoConnectionPrimitives = (libc = openDenoLibc()) => ({
+export const unlinkDenoSharedMemory = (name, libc = openDenoLibc()) => {
+    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 createDenoPosixConnectionPrimitives = (libc = openDenoLibc()) => ({
     runtime: "deno",
     createSharedMemory: (options) => createDenoSharedMemory(options, libc),
     mapSharedMemory: (options) => mapDenoSharedMemory(options, libc),
+    unlinkSharedMemory: (name) => unlinkDenoSharedMemory(name, libc),
 });
+export const createDenoConnectionPrimitives = (libc) => isWindowsRuntime()
+    ? createDenoWindowsConnectionPrimitives()
+    : createDenoPosixConnectionPrimitives(libc);

package/src/connections/file-descriptor.d.ts

@@ -2,6 +2,7 @@ import { type ConnectionRuntime, type SharedMemoryBuffer, type SharedMemoryConne
 export type FileDescriptorMetadata = {
     version: 1;
     fd: number;
+    name?: string;
     size: number;
     byteLength: number;
     runtime?: ConnectionRuntime;
@@ -12,6 +13,7 @@ type FileDescriptorMapper = Pick<SharedMemoryConnectionPrimitives, "mapSharedMem
 export declare class FileDescriptor {
     #private;
     readonly fd: number;
+    readonly name?: string;
     readonly size: number;
     readonly byteLength: number;
     readonly runtime?: ConnectionRuntime;

package/src/connections/file-descriptor.js

@@ -24,8 +24,20 @@ const readOptionalNumber = (value, label) => {
     }
     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;
@@ -34,6 +46,7 @@ export class FileDescriptor {
     #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;
@@ -45,6 +58,7 @@ export class FileDescriptor {
         return new FileDescriptor({
             version: 1,
             fd: mapping.fd,
+            name: mapping.name,
             size: mapping.size,
             byteLength: mapping.byteLength,
             runtime: mapping.runtime,
@@ -59,7 +73,7 @@ export class FileDescriptor {
         return FileDescriptor.fromMetadata(serialized);
     }
     toMetadata() {
-        return {
+        const metadata = {
             version: 1,
             fd: this.fd,
             size: this.size,
@@ -68,6 +82,9 @@ export class FileDescriptor {
             kind: this.kind,
             baseAddressMod64: this.baseAddressMod64,
         };
+        if (this.name !== undefined)
+            metadata.name = this.name;
+        return metadata;
     }
     toJSON() {
         return this.toMetadata();
@@ -92,6 +109,7 @@ export class FileDescriptor {
     map(mapper) {
         const options = {
             fd: this.fd,
+            name: this.name,
             size: this.size,
         };
         this.#mapping = mapper.mapSharedMemory(options);
@@ -125,7 +143,7 @@ export const parseFileDescriptorMetadata = (input) => {
     if (value.version !== 1) {
         throw new TypeError("unsupported file descriptor metadata version");
     }
-    return {
+    const parsed = {
         version: 1,
         fd: expectFd(readOptionalNumber(value.fd, "fd") ?? -1),
         size: expectPositiveSize(readOptionalNumber(value.size, "size") ?? 0),
@@ -136,4 +154,8 @@ export const parseFileDescriptorMetadata = (input) => {
         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/node.d.ts

@@ -2,12 +2,13 @@ import { type CreateSharedMemoryOptions, type MapSharedMemoryOptions, type Share
 export type NodeSharedMemoryNativeMapping = {
     sab: SharedArrayBuffer;
     fd: number;
+    name?: string;
     size: number;
     baseAddressMod64?: number;
 };
 export type NodeSharedMemoryAddon = {
     createSharedMemory: (size: number, name?: string, mode?: CreateSharedMemoryOptions["mode"]) => NodeSharedMemoryNativeMapping;
-    mapSharedMemory: (fd: number, size: number) => NodeSharedMemoryNativeMapping;
+    mapSharedMemory: (fd: number, size: number, name?: string) => NodeSharedMemoryNativeMapping;
     unlinkSharedMemory?: (name: string) => boolean;
 };
 export type NodeFutexWaitResult = "woken" | "changed" | "interrupted" | "timed-out";

package/src/connections/node.js

@@ -1,11 +1,9 @@
 import { getNodeBuiltinModule } from "../common/node-compat.js";
 import { loadNodeNativeAddon } from "./node-addons.js";
-import { assertPosixSharedMemoryPlatform } from "./posix.js";
 import { expectFd, expectPositiveSize, readCreateMode, readCreateName, readRequiredCreateName, readCreateSize, } from "./types.js";
 export const DEFAULT_NODE_SHARED_MEMORY_ADDON = "../../build/Release/knitting_shared_memory.node";
 export const DEFAULT_NODE_FUTEX_ADDON = "../../build/Release/knitting_shm.node";
 export const loadNodeSharedMemoryAddon = (specifier) => {
-    assertPosixSharedMemoryPlatform("Node native shared memory");
     const nodeModule = getNodeBuiltinModule("node:module");
     if (nodeModule === undefined) {
         throw new Error("Node shared memory addon can only be loaded in Node");
@@ -14,7 +12,6 @@ export const loadNodeSharedMemoryAddon = (specifier) => {
     return loadNodeNativeAddon(require, "knitting_shared_memory", specifier);
 };
 export const loadNodeFutexAddon = (specifier) => {
-    assertPosixSharedMemoryPlatform("Node native futex helpers");
     const nodeModule = getNodeBuiltinModule("node:module");
     if (nodeModule === undefined) {
         throw new Error("Node futex addon can only be loaded in Node");
@@ -22,16 +19,22 @@ export const loadNodeFutexAddon = (specifier) => {
     const require = nodeModule.createRequire(import.meta.url);
     return loadNodeNativeAddon(require, "knitting_shm", specifier);
 };
-export const fromNodeNativeMapping = (mapped) => ({
-    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,
-});
+export const fromNodeNativeMapping = (mapped) => {
+    const mapping = {
+        runtime: "node",
+        fd: mapped.fd,
+        size: mapped.size,
+        byteLength: mapped.sab.byteLength,
+        buffer: mapped.sab,
+        kind: "shared-array-buffer",
+        sab: mapped.sab,
+        baseAddressMod64: mapped.baseAddressMod64,
+    };
+    if (mapped.name !== undefined && mapped.name.length > 0) {
+        mapping.name = mapped.name;
+    }
+    return mapping;
+};
 export const createNodeSharedMemory = (options, addon = loadNodeSharedMemoryAddon()) => {
     const size = expectPositiveSize(readCreateSize(options));
     const mode = readCreateMode(options);
@@ -43,7 +46,7 @@ export const createNodeSharedMemory = (options, addon = loadNodeSharedMemoryAddo
 export const mapNodeSharedMemory = (options, addon = loadNodeSharedMemoryAddon()) => {
     const fd = expectFd(options.fd);
     const size = expectPositiveSize(options.size);
-    return fromNodeNativeMapping(addon.mapSharedMemory(fd, size));
+    return fromNodeNativeMapping(addon.mapSharedMemory(fd, size, options.name));
 };
 export const createNodeConnectionPrimitives = (addon = loadNodeSharedMemoryAddon()) => ({
     runtime: "node",

package/src/connections/posix.d.ts

@@ -23,6 +23,7 @@ type FcntlLibc = {
 export declare const setCloseOnExec: <T extends FcntlLibc>(libc: T, fd: number) => number;
 export declare const shmOpenCreateFlag: (platform: PosixPlatform) => number;
 export declare const shmOpenExclusiveFlag: (platform: PosixPlatform) => number;
+export declare const POSIX_SHM_MAX_NAME_LEN = 30;
 export declare const toPosixSharedMemoryName: (name: string) => string;
 export declare const detectPosixPlatform: () => PosixPlatform;
 export declare const assertPosixSharedMemoryPlatform: (feature: string) => void;

package/src/connections/posix.js

@@ -27,6 +27,9 @@ export const setCloseOnExec = (libc, fd) => {
 };
 export const shmOpenCreateFlag = (platform) => platform === "darwin" ? DARWIN_O_CREAT : LINUX_O_CREAT;
 export const shmOpenExclusiveFlag = (platform) => platform === "darwin" ? DARWIN_O_EXCL : LINUX_O_EXCL;
+// macOS limits POSIX shared memory names to 31 characters including the
+// leading "/", so the usable name portion is at most 30 characters.
+export const POSIX_SHM_MAX_NAME_LEN = 30;
 export const toPosixSharedMemoryName = (name) => {
     if (name.length === 0) {
         throw new TypeError("shared memory name must be non-empty");
@@ -38,6 +41,9 @@ export const toPosixSharedMemoryName = (name) => {
     if (out.length < 2 || out.slice(1).includes("/")) {
         throw new TypeError("POSIX shared memory name must not contain path separators");
     }
+    if (out.length > POSIX_SHM_MAX_NAME_LEN + 1) {
+        throw new TypeError(`POSIX shared memory name must be at most ${POSIX_SHM_MAX_NAME_LEN} characters (macOS limit); got ${out.length - 1}`);
+    }
     return out;
 };
 export const detectPosixPlatform = () => {

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

@@ -26,7 +26,9 @@ export type ProcessSharedBufferRange = {
 };
 export type ProcessSharedBufferCreator = Pick<SharedMemoryConnectionPrimitives, "createSharedMemory">;
 export type ProcessSharedBufferMapper = Pick<SharedMemoryConnectionPrimitives, "mapSharedMemory">;
-export type ProcessSharedBufferPrimitives = Pick<SharedMemoryConnectionPrimitives, "createSharedMemory" | "mapSharedMemory">;
+export type ProcessSharedBufferPrimitives = Pick<SharedMemoryConnectionPrimitives, "createSharedMemory" | "mapSharedMemory"> & {
+    unlinkSharedMemory?: (name: string) => boolean;
+};
 export type ProcessSharedBufferView = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | BigInt64Array | BigUint64Array | Float32Array | Float64Array;
 export type ProcessSharedBufferViewConstructor<View extends ProcessSharedBufferView = ProcessSharedBufferView> = {
     readonly BYTES_PER_ELEMENT: number;

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

@@ -4,7 +4,6 @@ import { RUNTIME } from "../common/runtime.js";
 import { createBunConnectionPrimitives } from "./bun.js";
 import { createDenoConnectionPrimitives } from "./deno.js";
 import { loadNodeNativeAddon } from "./node-addons.js";
-import { assertPosixSharedMemoryPlatform } from "./posix.js";
 import { expectFd, expectPositiveSize, readCreateMode, readCreateName, readRequiredCreateName, readCreateSize, } from "./types.js";
 export const PROCESS_SHARED_BUFFER_BRAND = Symbol.for("knitting.processSharedBuffer");
 export const PROCESS_SHARED_BUFFER_NUMERIC_TRANSFER = Symbol.for("knitting.processSharedBuffer.numericTransfer");
@@ -40,16 +39,22 @@ const decodeKind = (value) => {
     }
 };
 let defaultPrimitives;
-const fromDefaultNodeNativeMapping = (mapped) => ({
-    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,
-});
+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) {
@@ -69,12 +74,11 @@ const createDefaultNodePrimitives = () => {
         mapSharedMemory: (options) => {
             const fd = expectFd(options.fd);
             const size = expectPositiveSize(options.size);
-            return fromDefaultNodeNativeMapping(addon.mapSharedMemory(fd, size));
+            return fromDefaultNodeNativeMapping(addon.mapSharedMemory(fd, size, options.name));
         },
     };
 };
 const createDefaultPrimitives = () => {
-    assertPosixSharedMemoryPlatform("ProcessSharedBuffer");
     if (RUNTIME === "bun")
         return createBunConnectionPrimitives();
     if (RUNTIME === "deno")

package/src/connections/types.d.ts

@@ -6,6 +6,7 @@ export type SharedMemoryCreateMode = "anonymous" | "create" | "open";
 export type SharedMemoryMapping<Buffer extends SharedMemoryBuffer = SharedMemoryBuffer> = {
     runtime: ConnectionRuntime;
     fd: number;
+    name?: string;
     size: number;
     byteLength: number;
     buffer: Buffer;
@@ -28,6 +29,7 @@ export type CreateSharedMemoryOptions = {
 };
 export type MapSharedMemoryOptions = {
     fd: number;
+    name?: string;
     size: number;
     duplicateFd?: boolean;
 };