knitting 0.1.46 → 0.1.51

package/map.md

@@ -32,12 +32,31 @@ The core flow is:
 ## Build And Scripts
 
 - `build.ts`: Bundles `knitting.ts` to `out/` with Bun for a Node ESM target.
+- `tsconfig.npm.json`: TypeScript config for the npm release build. Emits
+  `.js` and `.d.ts` files beside the source tree.
+- `scripts/rewrite-declaration-imports.mjs`: Post-processes emitted `.d.ts`
+  files so declaration imports point at `.js` files for npm consumers.
 - `scripts/build-native-addons.ts`: Compiles the native Node addons into
-  `build/Release/` on Linux and macOS. It finds Node headers/libs, splits user
-  flags, and builds the shared-memory and futex addons.
+  `build/Release/` on Linux, macOS, and Windows. It finds Node headers/libs,
+  splits user flags, builds the shared-memory and futex addons, and emits the
+  Windows FFI DLL used by Deno and Bun.
 - `run.sh`: Runs every top-level benchmark in `bench/` across Node, Deno, and
   Bun. `--json` writes JSON result files.
 
+## CI And Release
+
+- `.github/workflows/test.yml`: Push/PR test matrix for Deno, Node, and Bun
+  across Linux, macOS, and Windows.
+- `.github/workflows/coverage.yml`: Node coverage workflow with a 90% line
+  coverage gate.
+- `.github/workflows/build-and-test.yml`: Manual workflow that builds native
+  prebuild artifacts and runs runtime tests against them.
+- `.github/workflows/publish.yml`: Manual native-prebuild workflow. Verifies
+  Node and Windows FFI prebuilds, checks the JSR package contents, and commits
+  updated `prebuilds/` artifacts back to the branch.
+- `docs/windows-process-worker-hang-fix.md`: Investigation notes for the
+  Windows process-worker shared-memory and parked-worker hang fixes.
+
 ## Public API Layer
 
 - `src/api.ts`: Defines `task`, `importTask`, `createPool`, `isMain`, task id
@@ -84,12 +103,20 @@ The core flow is:
   first-idle, random, and first-idle-random.
 - `src/runtime/inline-executor.ts`: Optional in-process executor used by the
   inliner path to run tasks without crossing the worker boundary.
+- `src/runtime/process-worker.ts`: Process-worker spawning, command/runtime
+  selection, process shared-memory layout, inherited/named mapping metadata, and
+  child boot payload construction.
 
 ## Worker Side
 
+- `src/worker/bootstrap.ts`: Optional user bootstrap hook that runs before task
+  modules import and revives process-shared-buffer metadata in bootstrap data.
 - `src/worker/loop.ts`: Worker entrypoint and main loop. Boots worker contexts,
   installs safety guards, receives tasks, executes batches, writes completions,
   and supports process-worker bootstrapping.
+- `src/worker/process-worker-bootstrap.ts`: Child-side process-worker boot
+  payload validation, shared-memory remapping, runtime primitive setup, and
+  startup handoff into the worker loop.
 - `src/worker/task-loader.ts`: Imports task modules inside workers, finds
   exported task definitions, filters by id/caller position, and normalizes
   timeout metadata.
@@ -153,16 +180,27 @@ The core flow is:
   payload-codec registration.
 - `src/connections/file-descriptor.ts`: File descriptor wrapper, metadata
   parsing, mapping support, and descriptor lifecycle helpers.
+- `src/connections/node-addons.ts`: Native addon specifier resolution for
+  committed Node ABI prebuilds with `build/Release` fallback loading.
 - `src/connections/node.ts`: Loads POSIX Node native addons and exposes Node
   shared memory, mapping, unlink, and futex primitives.
 - `src/connections/bun.ts`: Bun FFI implementation for POSIX shared memory.
 - `src/connections/deno.ts`: Deno FFI implementation for POSIX shared memory.
 - `src/connections/posix.ts`: POSIX constants, shared-memory naming, libc path
   detection, and close-on-exec helpers.
+- `src/connections/windows.ts`: Windows FFI loader and named file-mapping
+  primitives used by Deno and Bun.
 - `src/knitting_shared_memory.cc`: Native Node addon for shared-memory create,
-  map, unlink, and descriptor operations.
+  map, unlink, and descriptor operations, including Windows named mappings.
 - `src/knitting_shm.cc`: Native Node addon for futex/wait helpers used by parked
   workers.
+- `src/knitting_windows_shared_memory.cc`: Runtime-neutral Windows DLL exports
+  for creating, opening, mapping, and closing named shared-memory objects from
+  FFI runtimes.
+- `prebuilds/*/*.node`: Tracked Node native-addon prebuilds for supported
+  platform/Node ABI combinations.
+- `prebuilds/win32-x64/*.dll`: Tracked Windows FFI DLL prebuild used by Bun and
+  Deno shared-memory primitives on Windows.
 
 ## Permissions
 
@@ -184,6 +222,9 @@ The core flow is:
 - `bench/withload.ts`: Measures behavior under main-thread load.
 - `bench/call-growth.ts`: Measures call cost as payload size grows.
 - `bench/call-growth-batch.ts`: Batch-focused version of call-growth tests.
+- `bench/startup.ts`: Measures `createPool` to first-response startup latency
+  across thread and process workers, with optional cross-runtime and named
+  shared-memory candidates.
 - `bench/tokio-mpsc-knitting.ts`: Batch latency benchmark for string, number,
   and Uint8Array echo tasks.
 - `bench/payload-sweep.ts`: Uint8Array payload-size sweep promoted from the old
@@ -213,6 +254,7 @@ The core flow is:
 
 ## Tests
 
+- `test/_runner.ts`: Runtime-neutral test runner shim used by the test suite.
 - `test/abortSignal.test.ts`: Shared abort bitset behavior.
 - `test/api-cap.test.ts`: API limits such as maximum task id count.
 - `test/shared-buffer-io.test.ts`: Shared-buffer IO read/write behavior.
@@ -244,6 +286,8 @@ The core flow is:
 - `test/task-abort-context-api.test.ts`: Worker abort toolkit/context behavior.
 - `test/tx-queue.test.ts`: Host transmit queue behavior and late-result safety.
 - `test/type-inference.test.ts`: Public type inference guarantees.
+- `test/worker-bootstrap.test.ts`: Worker bootstrap hook behavior, shared-buffer
+  metadata revival, startup failure propagation, and inliner incompatibility.
 - `test/fixtures/*.ts`: Task modules used by tests.
 - `test/fixtures/probes/*.ts`: Probe programs for crash, permission, process,
   file-descriptor, and shared-memory-corruption safety cases.
@@ -253,12 +297,12 @@ The core flow is:
 - `build/Release/*.node`: Native addon output produced by
   `scripts/build-native-addons.ts`.
 - `out/`: Bundled output produced by `build.ts`.
+- `dest/`: Scratch output used by the `build:node` package script.
+- `knitting.js`, `knitting.d.ts`, `process-shared-buffer.js`,
+  `process-shared-buffer.d.ts`, and `src/**/*.js` / `src/**/*.d.ts`: npm
+  release build artifacts produced by `tsconfig.npm.json`.
 - `results/`: Benchmark output produced by `run.sh`.
+- `log/`, `logs`, and `*.log`: Local runtime/log output.
 - `node_modules/`: Installed dependencies. Not part of the source map.
 
-## Deleted Or Intentionally Absent
 
-- Browser-mode build/smoke files are no longer part of the project.
-- The old top-level scratch files `uwu.ts` and `examples.ts` are removed.
-- Python graph scripts under `graphs/` were removed; current benchmark output is
-  kept in the TypeScript benchmark suite.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knitting",
-  "version": "0.1.46",
+  "version": "0.1.51",
   "description": "Shared-memory IPC runtime for Node.js, Deno, and Bun.",
   "license": "Apache-2.0",
   "repository": {
@@ -30,6 +30,7 @@
     "map.md",
     "LICENSE",
     "prebuilds/**/*.node",
+    "prebuilds/**/*.dll",
     "scripts/build-native-addons.ts",
     "src/**/*.cc",
     "src/**/*.d.ts",
@@ -65,13 +66,13 @@
     "bun": ">=1.0.0"
   },
   "peerDependencies": {
-    "typescript": "^5.0.0"
+    "typescript": "^5.2.0"
   },
   "devDependencies": {
     "@types/bun": "latest",
     "@types/deno": "latest",
     "@types/node": "latest",
     "mitata": "^1.0.34",
-    "typescript": "^5.0.0"
+    "typescript": "^5.2.0"
   }
 }

package/scripts/build-native-addons.ts

@@ -70,11 +70,6 @@ const nodeInfo = JSON.parse(runCapture(nodeBinary, [
   "JSON.stringify({arch:process.arch,execPath:process.execPath,modules:process.versions.modules,nodedir:process.config.variables.nodedir||null,platform:process.platform,version:process.versions.node})",
 ])) as NodeInfo;
 const isWindows = nodeInfo.platform === "win32";
-if (isWindows) {
-  throw new Error(
-    "Knitting native shared-memory addons are supported on Linux and macOS only",
-  );
-}
 const cacheRoot = join(
   resolve(
     Bun.env.KNITTING_NODE_CACHE_DIR ??
@@ -238,11 +233,25 @@ const addons = [
     output: "build/Release/knitting_shm.node",
   },
 ];
+const ffiLibraries = isWindows
+  ? [
+    {
+      name: "knitting_windows_shared_memory",
+      source: "src/knitting_windows_shared_memory.cc",
+      output: "build/Release/knitting_windows_shared_memory.dll",
+    },
+  ]
+  : [];
 const prebuildDir = join(
   root,
   "prebuilds",
   `${nodeInfo.platform}-${nodeInfo.arch}-node-${nodeInfo.modules}`,
 );
+const ffiPrebuildDir = join(
+  root,
+  "prebuilds",
+  `${nodeInfo.platform}-${nodeInfo.arch}`,
+);
 
 console.log(`Using Node: ${nodeInfo.execPath}`);
 console.log(`Using Node module ABI: ${nodeInfo.modules}`);
@@ -282,6 +291,23 @@ for (const addon of addons) {
   copiedPrebuilds.push(prebuildPath);
 }
 
+for (const library of ffiLibraries) {
+  const outputPath = join(root, library.output);
+  run(cxx, [
+    ...compileFlags,
+    join(root, library.source),
+    "/link",
+    `/OUT:${outputPath}`,
+    ...extraLdFlags,
+  ]);
+  builtAddons.push(library.output);
+
+  mkdirSync(ffiPrebuildDir, { recursive: true });
+  const prebuildPath = join(ffiPrebuildDir, `${library.name}.dll`);
+  copyFileSync(outputPath, prebuildPath);
+  copiedPrebuilds.push(prebuildPath);
+}
+
 console.log(
   `Built ${builtAddons.length} native addon${
     builtAddons.length === 1 ? "" : "s"

package/src/api.d.ts

@@ -1,11 +1,12 @@
 import { endpointSymbol } from "./common/task-symbol.js";
-import type { Args, AbortSignalConfig, AbortSignalOption, AbortSignalToolkit, CreatePool, FixPoint, MaybePromise, Pool, TaskInput, ReturnFixed, ImportTaskOptions, TaskTimeout, tasks } from "./types.js";
+import type { Args, AbortSignalConfig, AbortSignalOption, AbortSignalToolkit, ComposedWithKey, CreatePool, FixPoint, MaybePromise, Pool, TaskInput, ReturnFixed, ImportTaskOptions, TaskTimeout, tasks } from "./types.js";
 type ToListAndIds = {
     list: string[];
     ids: number[];
+    names: string[];
     at: number[];
 };
-type ToListAndIdsFn = (args: tasks) => ToListAndIds;
+type ToListAndIdsFn = (args: ComposedWithKey[]) => ToListAndIds;
 type CreatePoolFactory = (options: CreatePool) => <T extends tasks>(tasks: T) => Pool<T>;
 type InferredTaskFunction = (...args: any[]) => MaybePromise<Args>;
 type InferredTaskInput<F extends InferredTaskFunction, AS extends AbortSignalOption> = Parameters<F> extends [] ? void : AS extends undefined ? Parameters<F> extends [infer A] ? A extends TaskInput ? A : never : never : Parameters<F> extends [infer A] ? A extends TaskInput ? A : never : Parameters<F> extends [infer A, AbortSignalToolkit<AS>] ? A extends TaskInput ? A : never : never;

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 };
 /**
@@ -29,21 +30,74 @@ export { endpointSymbol as endpointSymbol };
  *
  */
 export const toListAndIds = (args) => {
-    const result = Object.values(args)
+    const result = args
         .reduce((acc, v) => (acc[0].add(v.importedFrom),
         acc[1].add(v.id),
         acc[2].add(v.at),
+        acc[3].push(v.name),
         acc), [
         new Set(),
         new Set(),
-        new Set()
+        new Set(),
+        [],
     ]);
     return {
         list: [...result[0]],
         ids: [...result[1]],
         at: [...result[2]],
+        names: result[3],
+    };
+};
+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,
+        },
     };
 };
+const isTaskDefinition = (value) => value != null &&
+    typeof value === "object" &&
+    typeof value.f === "function";
+const toPoolTaskEntries = (input, callerHref) => Object.entries(input).map(([name, value]) => {
+    if (isTaskDefinition(value)) {
+        return {
+            ...value,
+            name,
+        };
+    }
+    if (typeof value === "function") {
+        return {
+            f: value,
+            id: -1,
+            importedFrom: new URL(callerHref).href,
+            at: -1,
+            name,
+            [endpointSymbol]: true,
+        };
+    }
+    throw new TypeError(`createPool task "${name}" must be a task definition or exported function`);
+});
 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.
@@ -68,14 +122,14 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, payload
         //@ts-ignore
         return {
             shutdown: mainThreadOnlyProxy,
+            [Symbol.dispose]: () => { },
             call: mainThreadOnlyProxy,
         };
     }
-    const { list, ids, at } = toListAndIds(tasks), listOfFunctions = Object.entries(tasks).map(([k, v]) => ({
-        ...v,
-        name: k,
-    }))
+    const callerHref = getCallerHref(3);
+    const listOfFunctions = toPoolTaskEntries(tasks, callerHref)
         .sort((a, b) => a.name.localeCompare(b.name));
+    const { list, ids, names, at } = toListAndIds(listOfFunctions);
     if (listOfFunctions.length > MAX_FUNCTION_COUNT) {
         throw new RangeError(`Too many tasks: received ${listOfFunctions.length}. ` +
             `Maximum is ${MAX_FUNCTION_COUNT} (Uint16 function IDs: 0..${MAX_FUNCTION_ID}).`);
@@ -148,20 +202,25 @@ 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, callerHref);
+    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,
     }).map((_, thread) => spawnWorkerContext({
         list,
         ids,
+        names,
         at,
         thread,
         debug,
         totalNumberOfThread,
         source,
-        workerOptions: worker,
+        workerOptions: resolvedWorker,
         workerExecArgv: execArgv,
         host: hostDispatcher,
         payload,
@@ -175,7 +234,7 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, payload
     }));
     if (usingInliner) {
         const mainThread = createInlineExecutor({
-            tasks,
+            tasks: listOfFunctions,
             genTaskID,
             batchSize: inliner?.batchSize ?? 1,
         });
@@ -260,11 +319,15 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, payload
         })();
         return shutdownPromise;
     };
+    const disposePool = () => {
+        void shutdownWithDelay();
+    };
     const indexedFunctions = listOfFunctions.map((fn, index) => ({
         name: fn.name,
         index,
         timeout: fn.timeout,
         abortSignal: fn.abortSignal,
+        imported: fn.imported === true,
     }));
     const callHandlers = new Map();
     for (const { name } of indexedFunctions) {
@@ -283,27 +346,71 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, payload
         }
     }
     const useDirectHandler = (threads ?? 1) === 1 && !usingInliner;
-    const buildInvoker = (handlers) => useDirectHandler
-        ? handlers[0]
-        : managerMethod({
-            contexts: workers,
+    // Imported tasks must never execute on the host inliner lane: their module
+    // import is meant to happen inside the worker so worker permission policies
+    // apply. When the inliner is active we strip the inline lane from their
+    // handler set so they only ever reach real worker lanes.
+    const buildImportedInvoker = (handlers) => {
+        const workerHandlers = [];
+        const workerContexts = [];
+        for (let lane = 0; lane < handlers.length; lane += 1) {
+            if (lane === inlinerIndex)
+                continue;
+            workerHandlers.push(handlers[lane]);
+            workerContexts.push(workers[lane]);
+        }
+        if (workerHandlers.length === 0) {
+            throw new Error("Imported task has no worker lane to run on: the pool only has the " +
+                "host inliner. Imported tasks are never inlined on the host; add at " +
+                "least one worker thread.");
+        }
+        if (workerHandlers.length === 1)
+            return workerHandlers[0];
+        return managerMethod({
+            contexts: workerContexts,
             balancer,
-            handlers,
-            inlinerGate: usingInliner
-                ? {
-                    index: inlinerIndex,
-                    threshold: inlinerDispatchThreshold,
-                }
-                : undefined,
+            handlers: workerHandlers,
+            // No inlinerGate: the inline lane is intentionally excluded here.
         });
-    const callEntries = Array.from(callHandlers.entries(), ([name, handlers]) => [name, buildInvoker(handlers)]);
+    };
+    const buildInvoker = (handlers, imported) => {
+        if (imported && usingInliner) {
+            return buildImportedInvoker(handlers);
+        }
+        return useDirectHandler
+            ? handlers[0]
+            : managerMethod({
+                contexts: workers,
+                balancer,
+                handlers,
+                inlinerGate: usingInliner
+                    ? {
+                        index: inlinerIndex,
+                        threshold: inlinerDispatchThreshold,
+                    }
+                    : undefined,
+            });
+    };
+    let callEntries;
+    try {
+        callEntries = indexedFunctions.map(({ name, imported }) => [name, buildInvoker(callHandlers.get(name), imported)]);
+    }
+    catch (error) {
+        // Building invokers can throw (e.g. an imported task with no worker lane,
+        // or a balancer that needs >=2 lanes). The inline executor and any spawned
+        // workers are already live here, so tear them down before propagating —
+        // otherwise their MessageChannel ports / worker handles keep the event
+        // loop alive and hang the process.
+        void closePoolNow();
+        throw error;
+    }
     return {
         shutdown: shutdownWithDelay,
+        [Symbol.dispose]: disposePool,
         call: Object.fromEntries(callEntries),
     };
 };
 const SINGLE_TASK_KEY = "__task__";
-const DEFAULT_IMPORT_EXPORT_NAME = "default";
 const createSingleTaskPool = (single, options) => {
     const pool = createPool(options ?? {})({
         [SINGLE_TASK_KEY]: single,
@@ -311,15 +418,17 @@ const createSingleTaskPool = (single, options) => {
     return {
         call: pool.call[SINGLE_TASK_KEY],
         shutdown: pool.shutdown,
+        [Symbol.dispose]: pool[Symbol.dispose],
     };
 };
-const buildTaskDefinitionFromCaller = (input, callerHref, at) => {
+const buildTaskDefinitionFromCaller = (input, callerHref, at, imported = false) => {
     const importedFrom = new URL(callerHref).href;
     const out = ({
         ...input,
         id: genTaskID(),
         importedFrom,
         at,
+        imported,
         [endpointSymbol]: true,
     });
     out.createPool = (options) => {
@@ -334,14 +443,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;
@@ -380,5 +481,5 @@ export function importTask(options) {
     return buildTaskDefinitionFromCaller({
         ...rest,
         f: createImportedTaskFn(resolvedHref, name),
-    }, callerHref, at);
+    }, callerHref, at, true);
 }

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

@@ -2,9 +2,13 @@ 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.js",
     "\\src\\common\\task-source.ts",
+    "\\src\\common\\task-source.js",
     "/src/api.ts",
+    "/src/api.js",
     "\\src\\api.ts",
+    "\\src\\api.js",
 ];
 const INTERNAL_CALLER_FUNCTIONS = new Set([
     "collectStackFrames",
@@ -71,6 +75,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 {};