knitting 0.1.62 → 0.1.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knitting",
-  "version": "0.1.62",
+  "version": "0.1.70",
   "description": "Shared-memory IPC runtime for Node.js, Deno, and Bun.",
   "license": "Apache-2.0",
   "repository": {
@@ -86,8 +86,9 @@
     "test:deno": "deno test -A --ignore=test/runtime.node.test.ts --ignore=test/runtime.process.test.ts",
     "test:node": "node --no-warnings --experimental-transform-types --test \"./test/*.test.ts\"",
     "test:node:26": "node --no-warnings --experimental-ffi test/node26-ffi.integration.mjs",
-    "test:bun": "bun test ./test/*.test.ts --path-ignore-patterns=**/tx-queue.test.ts",
+    "test:bun": "bun test",
     "test:browser": "bun run scripts/test-browser.ts",
+    "check:windows-park": "bun run scripts/check-windows-park.ts",
     "test:runtimes": "npm run test:node && npm run test:bun",
     "test:all": "npm run test:deno && npm run test:runtimes && npm run test:browser",
     "coverage:node": "node --no-warnings --experimental-transform-types --experimental-test-coverage --test \"./test/*.test.ts\"",
@@ -107,7 +108,6 @@
     "@types/bun": "latest",
     "@types/deno": "latest",
     "@types/node": "latest",
-    "dts-bundle-generator": "^9.5.1",
     "mitata": "^1.0.34",
     "typescript": "^5.2.0"
   }

package/scripts/build-native-addons.ts

@@ -237,6 +237,11 @@ const addons = [
     source: "src/knitting_buffer_pointer.cc",
     output: "build/Release/knitting_buffer_pointer.node",
   },
+  {
+    name: "knitting_doorbell",
+    source: "src/knitting_doorbell.cc",
+    output: "build/Release/knitting_doorbell.node",
+  },
 ];
 const ffiLibraries = isWindows
   ? [

package/shared-memory.d.ts

@@ -1 +1,4 @@
 export { getDefaultProcessSharedBufferPrimitives, parseProcessSharedBufferMetadata, PROCESS_SHARED_BUFFER_BRAND, ProcessSharedBuffer, setDefaultProcessSharedBufferPrimitives, type ProcessSharedBufferCreator, type ProcessSharedBufferMapper, type ProcessSharedBufferMetadata, type ProcessSharedBufferPrimitives, type ProcessSharedBufferRange, type ProcessSharedBufferView, type ProcessSharedBufferViewConstructor, } from "./src/connections/process-shared-buffer.js";
+export { attachKnittingAllocator, createKnittingAllocator, DEFAULT_ARENA_BYTE_LENGTH, detectRegion, type KnittingAllocator, type KnittingAllocatorOptions, type KnittingBufferDescriptor, KnittingSharedBuffer, } from "./src/memory/knitting-buffer.js";
+export { createBodyReader, type KnittingBody, type KnittingBodyWire, type KnittingTransport, } from "./src/memory/knitting-body.js";
+export { HTTP_BODY_STREAM_THRESHOLD_BYTES, HTTP_BODY_REFERENCE_THRESHOLD_BYTES, type ReadBodyIntoBytesOptions, type ReadBodyOptions, type ReadBodyOrReferOptions, type ReadBodyPayload, readBodyIntoBytes, readBodyIntoRegion, readBodyOrRefer, type RegionAllocator, } from "./src/memory/knitting-buffer-http.js";

package/shared-memory.js

@@ -1 +1,4 @@
 export { getDefaultProcessSharedBufferPrimitives, parseProcessSharedBufferMetadata, PROCESS_SHARED_BUFFER_BRAND, ProcessSharedBuffer, setDefaultProcessSharedBufferPrimitives, } from "./src/connections/process-shared-buffer.js";
+export { attachKnittingAllocator, createKnittingAllocator, DEFAULT_ARENA_BYTE_LENGTH, detectRegion, KnittingSharedBuffer, } from "./src/memory/knitting-buffer.js";
+export { createBodyReader, } from "./src/memory/knitting-body.js";
+export { HTTP_BODY_STREAM_THRESHOLD_BYTES, HTTP_BODY_REFERENCE_THRESHOLD_BYTES, readBodyIntoBytes, readBodyIntoRegion, readBodyOrRefer, } from "./src/memory/knitting-buffer-http.js";

package/src/api.js

@@ -5,6 +5,7 @@ import { toModuleUrl } from "./common/module-url.js";
 import { endpointSymbol } from "./common/task-symbol.js";
 import { createStealPoolBuffers, MAX_STEAL_CONSUMERS, spawnWorkerContext, } from "./runtime/pool.js";
 import { ChannelHandler, hostDispatcherLoop } from "./runtime/dispatcher.js";
+import { createDenoCompletionDoorbell } from "./runtime/deno-doorbell.js";
 import { createSharedArrayBuffer, RUNTIME } from "./common/runtime.js";
 import { RUNTIME_IS_MAIN_THREAD, RUNTIME_POOL_DEPTH, RUNTIME_WORKER_DATA, } from "./common/worker-runtime.js";
 import { classifyProcessPermissionCompatibility, enforceProcessPermissionCompatibility, resolvePermissionProtocol, toRuntimePermissionFlags, } from "./permission/index.js";
@@ -14,6 +15,7 @@ import { TRANSPORT_SIGNAL_BYTES } from "./ipc/transport/shared-memory.js";
 import { inspectCompiledWorkerArtifact } from "./runtime/compiled-artifact.js";
 import { managerMethod } from "./runtime/balancer.js";
 import { createInlineExecutor } from "./runtime/inline-executor.js";
+import { createHostArgAllocator } from "./runtime/host-arg-arena.js";
 const hasDebugNamespace = (namespaces, namespace) => namespaces.has("*") || namespaces.has(namespace);
 const createHostDebug = (namespaces) => {
     const enabled = (namespace) => hasDebugNamespace(namespaces, namespace);
@@ -242,7 +244,8 @@ const toPoolTaskEntries = (input, callerHref) => Object.entries(input).map(([nam
  * argument; use an object or tuple for multiple values.
  */
 export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe, abortSignalCapacity, source, worker, workerExecArgv, permission, host, }) => (tasks) => {
-    const bufferReferenceReturn = unsafe?.BufferReferenceReturn;
+    const sharedBytesEnabled = unsafe?.SharedBytes === true;
+    const sharedArgsEnabled = unsafe?.SharedArgs === true;
     const debugRequested = DEBUG_ENABLED ||
         (debug !== undefined && debug !== false);
     let debugNamespaces;
@@ -371,14 +374,21 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         : stealEnvRaw === "0" || stealEnvRaw === "false"
             ? false
             : undefined;
-    // Shared-submit stealing is the default for compatible multi-worker pools.
-    // An explicit option wins over the environment; compiled and inline
-    // transports retain their existing topology.
+    // Shared-submit stealing is the default for compatible multi-worker pools;
+    // explicit options take precedence over the environment.
     const dispatcherExplicitlySelected = host?.dispatcher !== undefined ||
         dispatcherEnv === "serial-channel" || dispatcherEnv === "per-thread";
     const stealDefaultCompatible = balancer === undefined &&
         !dispatcherExplicitlySelected && (threads ?? 1) <= MAX_STEAL_CONSUMERS;
     const stealRequested = host?.steal ?? stealEnv ?? stealDefaultCompatible;
+    const stealClaimEnvRaw = nodeProcess?.env?.KNITTING_STEAL_CLAIM?.trim()
+        .toLowerCase();
+    const stealClaimEnv = stealClaimEnvRaw === "cas-mask" ||
+        stealClaimEnvRaw === "dekker"
+        ? stealClaimEnvRaw
+        : undefined;
+    // Select the stealing claim discipline, preferring the explicit option.
+    const stealClaim = host?.stealClaim ?? stealClaimEnv ?? "dekker";
     const usingCompiledWorker = resolvedWorker?.runtime === "compiled";
     if (resolvedWorker?.compiled !== undefined && !usingCompiledWorker) {
         throw new Error("worker.compiled requires worker.runtime to be compiled");
@@ -463,9 +473,8 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
             ? dispatcherEnv
             : undefined);
     const autoDispatcher = (() => {
-        // Experimental default for HTTP-style bursts: Bun still favors direct
-        // per-thread channels, while Node/Deno multi-worker pools favor one shared
-        // macro channel over the per-lane dispatcher checks.
+        // Bun and single-worker pools use per-thread dispatch; other pools share a
+        // channel across their private lanes.
         if (RUNTIME === "bun")
             return "per-thread";
         if ((threads ?? 1) <= 1)
@@ -473,10 +482,8 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         return "serial-channel";
     })();
     const dispatcher = explicitDispatcher ?? autoDispatcher;
-    // Work stealing: one shared submit region, private return lanes, one
-    // pool-global pending registry. It is the compatible multi-worker default;
-    // an explicit balancer/dispatcher keeps the private-lane topology unless
-    // stealing itself was explicitly requested.
+    // Stealing uses one submit region and private return lanes. Explicit balancer
+    // or dispatcher settings retain private lanes unless stealing is requested.
     const useSteal = stealRequested &&
         !usingCompiledWorker &&
         (threads ?? 1) > 1 &&
@@ -485,7 +492,9 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         ? createStealPoolBuffers({
             threads: threads ?? 1,
             payload,
+            sharedArgs: sharedArgsEnabled,
             regionLanes: host?.stealRegionLanes,
+            stealClaim,
             abortSignalCapacity,
             usesAbortSignal,
             processWorker: resolvedWorker?.runtime === "process"
@@ -498,13 +507,16 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         : undefined;
     const serialChannel = !usingCompiledWorker && !useSteal &&
         dispatcher === "serial-channel";
-    // One serial-channel hop drives every lane check in turn, and it depends on
-    // the channel's delivery to do that: swapping in the cheaper `setImmediate`
-    // pump cost 25% throughput and tripled p99 here, where every other topology
-    // gained. See ChannelHandler's note.
+    // The serial topology relies on channel delivery to run each lane check.
     const serialDispatcherChannel = serialChannel
         ? new ChannelHandler("channel")
         : undefined;
+    // Deno uses a threadSafe FFI callback because waitAsync does not wake an idle
+    // event loop; process workers cannot use the process-local pointer.
+    const denoCompletionDoorbell = !usingCompiledWorker &&
+        resolvedWorker?.runtime !== "process" && host?.doorbell !== false
+        ? createDenoCompletionDoorbell()
+        : undefined;
     let workers = Array.from({
         length: threads ?? 1,
     }).map((_, thread) => spawnWorkerContext({
@@ -516,16 +528,20 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         debug,
         hostDebug: hostDebug?.log,
         totalNumberOfThread,
+        // Worker count without the inline lane. The inliner runs on the host
+        // thread and never spins, so it must not count towards the spin policy.
+        workerCount: threads ?? 1,
         source,
         workerOptions: resolvedWorker,
         workerExecArgv: execArgv,
         host,
         payload,
-        bufferReferenceReturn,
+        sharedBytesEnabled,
         abortSignalCapacity,
         usesAbortSignal,
         permission: permissionProtocol,
         sharedChannelHandler: serialDispatcherChannel,
+        denoCompletionDoorbell,
         stealPool: stealBuffers === undefined ? undefined : {
             submitBuffers: stealBuffers.submitBuffers,
             returnBuffers: stealBuffers.returnBuffers[thread],
@@ -535,6 +551,7 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
             consumers: threads ?? 1,
             consumerId: thread,
             regionLanes: stealBuffers.regionLanes,
+            stealClaim: stealBuffers.stealClaim,
             abortSignalSAB: stealBuffers.abortSignalSAB,
             abortSignalMax: stealBuffers.abortSignalMax,
             processMemory: stealBuffers.processMemory,
@@ -544,10 +561,8 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
     if (useSteal) {
         const channel = stealChannel;
         const queue = stealBuffers.sharedQueue;
-        // Wake exactly one worker per drain, round-robin. Stealing decouples the
-        // wake target from the assignment: if the woken worker is busy, any other
-        // idle endpoint claims the region instead. So this costs one notify per
-        // publish regardless of pool size, rather than one per lane.
+        // Round-robin wake keeps stealing at one notify per publish; any idle worker
+        // can claim the region.
         let wakeCursor = 0;
         const wakeOne = () => {
             const lanes = workers.length;
@@ -560,7 +575,7 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         // The shared dispatcher drives one queue, so it needs signal words of its
         // own rather than any single lane's; waking is delegated to `wakeOne`.
         const signalWords = new Int32Array(createSharedArrayBuffer(3 * Int32Array.BYTES_PER_ELEMENT));
-        const { check } = hostDispatcherLoop({
+        const { check, wakeCompletion } = hostDispatcherLoop({
             signalBox: {
                 opView: signalWords.subarray(0, 1),
                 txStatus: signalWords.subarray(1, 2),
@@ -571,18 +586,30 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
             dispatcherOptions: host,
             notifySignal: wakeOne,
             crossProcess: resolvedWorker?.runtime === "process",
+            nativeCompletionDoorbell: denoCompletionDoorbell !== undefined ||
+                workers.some((context) => context
+                    .nodeCompletionDoorbell === true),
+            processCompletionDoorbell: workers.some((context) => context.processCompletionDoorbell === true),
         });
         channel.open(check);
+        if (denoCompletionDoorbell !== undefined) {
+            workers.forEach((_, thread) => {
+                denoCompletionDoorbell.listen(thread, wakeCompletion);
+            });
+        }
+        workers.forEach((context) => {
+            context.bindCompletionWake?.(wakeCompletion);
+        });
         workers.forEach((context) => {
             context.bindSend(() => {
                 if (check.isRunning !== true) {
                     check.isRunning = true;
-                    Promise.resolve().then(check);
+                    queueMicrotask(check);
                 }
                 wakeOne();
             });
         });
-        hostDebug?.log(`dispatcher=steal lanes=${workers.length} g=${stealBuffers.regionLanes}`);
+        hostDebug?.log(`dispatcher=steal lanes=${workers.length} g=${stealBuffers.regionLanes} claim=${stealClaim}`);
     }
     const sharedDispatcherChannel = serialDispatcherChannel;
     if (serialChannel) {
@@ -592,11 +619,7 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         let serialScheduled = false;
         let serialInFlight = false;
         let serialRerun = false;
-        // Busy-lane set: a tick walks only the lanes that have work, not all of
-        // them. `active` is a dense list of lane indices; `isActive` keeps the
-        // membership test O(1). A lane joins on send() and leaves once its queue
-        // reports idle, so an N-worker pool with one busy lane costs one check per
-        // tick instead of N.
+        // Visit only active private lanes; inactive lanes stay out of the tick.
         const active = [];
         const isActive = new Uint8Array(checks.length);
         const markActive = (lane) => {
@@ -639,7 +662,7 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
             if (serialScheduled)
                 return;
             serialScheduled = true;
-            Promise.resolve().then(runSerialChecks);
+            queueMicrotask(runSerialChecks);
         };
         channel.open(runSerialChecks);
         workers.forEach((context, lane) => {
@@ -687,10 +710,29 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         if (closePromise)
             return closePromise;
         closing = true;
-        closePromise = Promise.allSettled(workers.map((context) => context.kills()))
+        let canCloseNativeDoorbells = denoCompletionDoorbell === undefined;
+        closePromise = Promise.allSettled(workers.map((context) => context.requestStop?.()))
+            .then((stops) => {
+            if (denoCompletionDoorbell !== undefined) {
+                canCloseNativeDoorbells = stops.every((result, index) => {
+                    if (workers[index].requestStop === undefined)
+                        return true;
+                    return result.status === "fulfilled" && result.value === true;
+                });
+            }
+            return Promise.allSettled(workers.map((context) => context.kills()));
+        })
             .then(() => {
             sharedDispatcherChannel?.close();
             stealChannel?.close();
+        })
+            .finally(() => {
+            if (canCloseNativeDoorbells) {
+                denoCompletionDoorbell?.close();
+                return;
+            }
+            // Keep the callback alive if a worker failed to acknowledge shutdown.
+            denoCompletionDoorbell?.unref();
         });
         return closePromise;
     };
@@ -759,23 +801,41 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
     for (const { name } of indexedFunctions) {
         callHandlers.set(name, []);
     }
-    for (const worker of workers) {
+    if (useSteal) {
+        // Every worker context points at the same pool-global submit queue in the
+        // stealing topology. There is therefore no worker to assign here: the
+        // claimant is selected later by decodeSteal(). Keep one call closure per
+        // task and avoid paying N equivalent wrapper allocations at pool setup.
+        const sharedWorker = workers[0];
         for (const { name, index, timeout, abortSignal } of indexedFunctions) {
-            callHandlers.get(name).push(wrapGuardedInvoke({
-                taskName: name,
-                invoke: worker.call({
-                    fnNumber: index,
-                    timeout,
-                    abortSignal,
+            callHandlers.set(name, [
+                wrapGuardedInvoke({
+                    taskName: name,
+                    invoke: sharedWorker.call({
+                        fnNumber: index,
+                        timeout,
+                        abortSignal,
+                    }),
                 }),
-            }));
+            ]);
+        }
+    }
+    else {
+        for (const worker of workers) {
+            for (const { name, index, timeout, abortSignal } of indexedFunctions) {
+                callHandlers.get(name).push(wrapGuardedInvoke({
+                    taskName: name,
+                    invoke: worker.call({
+                        fnNumber: index,
+                        timeout,
+                        abortSignal,
+                    }),
+                }));
+            }
         }
     }
     const useDirectHandler = (threads ?? 1) === 1 && !usingInliner;
-    // 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.
+    // Imported tasks must run on a worker so worker-side permission policies apply.
     const buildImportedInvoker = (handlers) => {
         const workerHandlers = [];
         const workerContexts = [];
@@ -800,6 +860,11 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         });
     };
     const buildInvoker = (handlers, imported) => {
+        // Stealing owns one shared submit queue. The worker that runs a call is
+        // deliberately chosen by the worker-side claim protocol, not by the host
+        // balancer, so round-robin/first-idle selection would only add overhead.
+        if (useSteal)
+            return handlers[0];
         if (imported && usingInliner) {
             return buildImportedInvoker(handlers);
         }
@@ -832,6 +897,8 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         shutdown: shutdownWithDelay,
         [Symbol.dispose]: disposePool,
         call: Object.fromEntries(callEntries),
+        // Only the shared submit queue has a single arena to build arguments in.
+        sharedArgBytes: createHostArgAllocator(sharedArgsEnabled ? stealBuffers?.submitBuffers.payload : undefined),
     };
 };
 const SINGLE_TASK_KEY = "__task__";

package/src/common/with-resolvers.js

@@ -7,11 +7,8 @@ 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,
-        };
+        attachReject(deferred.promise, deferred.reject);
+        return deferred;
     }
     let resolve;
     let reject;

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

@@ -29,6 +29,13 @@ 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_POOL_DEPTH_ENV = "KNITTING_POOL_DEPTH";
+/**
+ * A coalesced completion wake sent over a process worker's existing IPC
+ * channel. The result itself remains in shared memory; this is only the
+ * doorbell byte.
+ */
+export declare const PROCESS_COMPLETION_DOORBELL = "__knittingCompletionDoorbell";
+export declare const isProcessCompletionDoorbell: (value: unknown) => boolean;
 export declare const RUNTIME_IS_PROCESS_WORKER: boolean;
 export declare const RUNTIME_POOL_DEPTH: number;
 export declare const RUNTIME_WORKER: new (specifier: string | URL, options?: Record<string, unknown>) => RuntimeWorkerLike;

package/src/common/worker-runtime.js

@@ -4,6 +4,13 @@ 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;
 export const RUNTIME_POOL_DEPTH_ENV = "KNITTING_POOL_DEPTH";
+/**
+ * A coalesced completion wake sent over a process worker's existing IPC
+ * channel. The result itself remains in shared memory; this is only the
+ * doorbell byte.
+ */
+export const PROCESS_COMPLETION_DOORBELL = "__knittingCompletionDoorbell";
+export const isProcessCompletionDoorbell = (value) => value === PROCESS_COMPLETION_DOORBELL;
 const nodeProcess = getNodeProcess();
 export const RUNTIME_IS_PROCESS_WORKER = nodeProcess?.env?.[RUNTIME_PROCESS_WORKER_ENV] === "1";
 const readPoolDepth = () => {

package/src/connections/buffer-reference.d.ts

@@ -1,19 +1,9 @@
 import { type BufferReferenceRuntime } from "./buffer-reference-native.js";
 export type { BufferReferenceRuntime } from "./buffer-reference-native.js";
 export declare const BUFFER_REFERENCE_KIND: "knitting.bufferReference";
-/** Named values for the `unsafe.BufferReferenceReturn` pool option. */
-export declare const BufferReferenceReturn: {
-    /** Safe default: Deno/Bun copy the returned bytes so they outlive the worker. */
-    readonly Copy: "copy";
-    /** Zero-copy: borrow the worker's backing store until the reference is released. */
-    readonly Borrow: "borrow";
-};
-export type BufferReferenceReturn = (typeof BufferReferenceReturn)[keyof typeof BufferReferenceReturn];
 export declare const BUFFER_REFERENCE_NUMERIC_TRANSFER: unique symbol;
-export declare const BUFFER_REFERENCE_RETURN_RELEASE_TOKEN: unique symbol;
 declare const EXTERNAL_PAYLOAD_BRAND: unique symbol;
 export declare const BUFFER_REFERENCE_CODEC_ID: "knitting.bufferReference";
-declare const BUFFER_REFERENCE_RETURN_RELEASE_MESSAGE_KEY = "__knittingBufferReferenceRelease";
 export type BufferReferenceNumericMetadata = readonly [
     pointerLow: number,
     pointerHigh: number,
@@ -34,26 +24,17 @@ export type BufferReferenceMetadata = {
     readonly byteOffset: number;
     readonly byteLength: number;
 };
-export type BufferReferenceReturnReleaseMessage = {
-    readonly [BUFFER_REFERENCE_RETURN_RELEASE_MESSAGE_KEY]: string;
-};
-type BufferReferenceReturnReleaser = (token: bigint) => void;
-/** Host-side hooks for borrowed returns: release channel plus shutdown tracking. */
-export type BufferReferenceReturnHooks = {
-    /** Ask the producing worker to drop its pin for `token`. */
-    release: BufferReferenceReturnReleaser;
-    /**
-     * Record a borrowed reference so the pool can revoke it before its worker
-     * dies. Called at claim time without `aliasBuffer`, then again on first
-     * materialize with the alias buffer once it exists.
-     */
-    track?: (ref: BufferReference, token: bigint, aliasBuffer?: ArrayBuffer) => void;
-};
 type BufferSource = ArrayBufferView | ArrayBuffer;
 declare const PAYLOAD_TRANSPORT_FINALIZER: unique symbol;
-export declare const withBufferReferenceReturnReleaser: <T>(releaser: BufferReferenceReturnReleaser | BufferReferenceReturnHooks | undefined, run: () => T) => T;
-export declare const createBufferReferenceReturnReleaseMessage: (token: bigint) => BufferReferenceReturnReleaseMessage;
-export declare const readBufferReferenceReturnReleaseMessage: (value: unknown) => bigint | undefined;
+/**
+ * Whether a buffer has given up its bytes.
+ *
+ * Exported so a caller that *moved* a source can confirm the move actually
+ * happened. A runtime that cannot detach a buffer -- WASM memory, anything an
+ * external API has pinned -- otherwise leaves the producer still able to write
+ * memory the consumer has been told it owns.
+ */
+export declare const isArrayBufferDetached: (buffer: ArrayBuffer) => boolean;
 /** Revocation primitive: detach `buffer` so every view over it is neutralized. */
 export declare const detachArrayBufferBestEffort: (runtime: BufferReferenceRuntime, buffer: ArrayBuffer) => boolean;
 export declare const isBufferReferenceMetadata: (value: unknown) => value is BufferReferenceMetadata;
@@ -80,19 +61,12 @@ export declare class BufferReference {
     [BUFFER_REFERENCE_NUMERIC_TRANSFER](): BufferReferenceNumericMetadata | undefined;
     get isLocal(): boolean;
     /** Prepare a returned reference before the worker-side producer hold drains. */
-    claimOwnership(releaser?: BufferReferenceReturnReleaser | BufferReferenceReturnHooks | undefined): this;
+    claimOwnership(): this;
     toArrayBuffer(): ArrayBuffer;
     toUint8Array(): Uint8Array;
     /** The source is moved on construction, so it is never retained here. */
     get source(): undefined;
     release(): void;
-    /**
-     * Revoke a borrowed return before its producing worker goes away: detach
-     * the borrowed alias so no view can dangle. With `copyBytes` the reference
-     * itself survives on an owned copy; without it (worker bytes already gone)
-     * later reads fail loud instead of aliasing freed memory.
-     */
-    revokeBorrow(copyBytes: boolean): void;
     [Symbol.dispose](): void;
     [PAYLOAD_TRANSPORT_FINALIZER](): (() => void) | undefined;
 }