knitting 0.1.62 → 0.1.70

package/src/connections/buffer-reference.js

@@ -4,18 +4,9 @@ import { RUNTIME_IS_MAIN_THREAD } from "../common/worker-runtime.js";
 import { loadNodeBufferPointerAddon } from "./node-buffer-pointer.js";
 import { getBufferReferenceCapabilities, } from "./buffer-reference-native.js";
 export const BUFFER_REFERENCE_KIND = "knitting.bufferReference";
-/** Named values for the `unsafe.BufferReferenceReturn` pool option. */
-export const BufferReferenceReturn = {
-    /** Safe default: Deno/Bun copy the returned bytes so they outlive the worker. */
-    Copy: "copy",
-    /** Zero-copy: borrow the worker's backing store until the reference is released. */
-    Borrow: "borrow",
-};
 export const BUFFER_REFERENCE_NUMERIC_TRANSFER = Symbol.for("knitting.bufferReference.numericTransfer");
-export const BUFFER_REFERENCE_RETURN_RELEASE_TOKEN = Symbol.for("knitting.bufferReference.returnReleaseToken");
 const EXTERNAL_PAYLOAD_BRAND = Symbol.for("knitting.payloadCodec");
 export const BUFFER_REFERENCE_CODEC_ID = BUFFER_REFERENCE_KIND;
-const BUFFER_REFERENCE_RETURN_RELEASE_MESSAGE_KEY = "__knittingBufferReferenceRelease";
 const getRuntime = () => {
     if (RUNTIME === "deno" || RUNTIME === "bun" || RUNTIME === "node") {
         return RUNTIME;
@@ -37,7 +28,6 @@ const RUNTIME_NODE = 1;
 const RUNTIME_DENO = 2;
 const RUNTIME_BUN = 3;
 const PAYLOAD_TRANSPORT_FINALIZER = Symbol.for("knitting.payloadCodec.transportFinalizer");
-let currentReturnHooks;
 const bufferReferenceInstances = new WeakSet();
 const encodeRuntime = (runtime) => {
     switch (runtime) {
@@ -96,36 +86,6 @@ const numericMetadataToMetadata = (words) => {
         byteLength: words[5] ?? 0,
     };
 };
-const toReturnHooks = (releaser) => typeof releaser === "function" ? { release: releaser } : releaser;
-export const withBufferReferenceReturnReleaser = (releaser, run) => {
-    if (releaser === undefined)
-        return run();
-    const previous = currentReturnHooks;
-    currentReturnHooks = toReturnHooks(releaser);
-    try {
-        return run();
-    }
-    finally {
-        currentReturnHooks = previous;
-    }
-};
-export const createBufferReferenceReturnReleaseMessage = (token) => ({
-    [BUFFER_REFERENCE_RETURN_RELEASE_MESSAGE_KEY]: token.toString(),
-});
-export const readBufferReferenceReturnReleaseMessage = (value) => {
-    if (value === null || typeof value !== "object")
-        return undefined;
-    const raw = value[BUFFER_REFERENCE_RETURN_RELEASE_MESSAGE_KEY];
-    if (typeof raw !== "string")
-        return undefined;
-    try {
-        const token = BigInt(raw);
-        return token > 0n ? token : undefined;
-    }
-    catch {
-        return undefined;
-    }
-};
 const producerFinalizer = typeof FinalizationRegistry === "function"
     ? new FinalizationRegistry((backstop) => {
         backstop.count -= 1;
@@ -139,16 +99,6 @@ const producerFinalizer = typeof FinalizationRegistry === "function"
         }
     })
     : undefined;
-const borrowedReturnFinalizer = typeof FinalizationRegistry === "function"
-    ? new FinalizationRegistry(({ token, release }) => {
-        try {
-            release(token);
-        }
-        catch {
-            // best effort
-        }
-    })
-    : undefined;
 const isSharedArrayBufferInstance = (value) => typeof SharedArrayBuffer === "function" && value instanceof SharedArrayBuffer;
 const assertMovableSource = (source) => {
     if (isSharedArrayBufferInstance(source)) {
@@ -166,6 +116,15 @@ const assertMovableSource = (source) => {
 };
 const isDetached = (buffer) => buffer.detached === true ||
     buffer.byteLength === 0;
+/**
+ * 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 const isArrayBufferDetached = (buffer) => isDetached(buffer);
 /** Revocation primitive: detach `buffer` so every view over it is neutralized. */
 export const detachArrayBufferBestEffort = (runtime, buffer) => {
     if (isDetached(buffer))
@@ -241,9 +200,6 @@ export class BufferReference {
     #producerBackstop;
     #materializedRegions;
     #owned;
-    #borrowedReturnReleaser;
-    #borrowedReturnTrack;
-    #borrowedReturnFinalizerToken;
     #transportRefs = 0;
     #released = false;
     constructor(source, meta) {
@@ -341,9 +297,8 @@ export class BufferReference {
         }
     }
     /** Prepare a returned reference before the worker-side producer hold drains. */
-    claimOwnership(releaser = currentReturnHooks) {
-        if (this.#owned !== undefined || this.#borrowedReturnReleaser !== undefined ||
-            this.#released)
+    claimOwnership() {
+        if (this.#owned !== undefined || this.#released)
             return this;
         this.#assertLocal();
         const caps = getBufferReferenceCapabilities();
@@ -353,21 +308,6 @@ export class BufferReference {
             byteOffset: this.byteOffset,
             byteLength: this.byteLength,
         };
-        if (releaser !== undefined) {
-            const hooks = toReturnHooks(releaser);
-            // Borrow: adopt lazily — the alias costs GC-visible external memory on
-            // FFI runtimes, so it is only created when the bytes are actually read.
-            // Until then no view can exist, so the GC backstop safely watches the
-            // reference itself; first materialize migrates it to the alias buffer
-            // (views strongly reference their buffer, so the worker pin can only
-            // drop once no view can reach the borrowed bytes).
-            this.#borrowedReturnReleaser = hooks.release;
-            this.#borrowedReturnTrack = hooks.track;
-            this.#borrowedReturnFinalizerToken = {};
-            borrowedReturnFinalizer?.register(this, { token: this.#token, release: hooks.release }, this.#borrowedReturnFinalizerToken);
-            hooks.track?.(this, this.#token);
-            return this;
-        }
         this.#owned = caps.adopt(input, caps.supportsOwningAdopt ? undefined : { copy: true });
         return this;
     }
@@ -382,18 +322,6 @@ export class BufferReference {
             byteOffset: this.byteOffset,
             byteLength: this.byteLength,
         });
-        if (this.#borrowedReturnReleaser !== undefined) {
-            // First borrowed read: views over this alias exist from here on, so
-            // move the GC backstop from the reference onto the alias buffer.
-            this.#owned = region;
-            if (this.#borrowedReturnFinalizerToken !== undefined &&
-                borrowedReturnFinalizer !== undefined) {
-                borrowedReturnFinalizer.unregister(this.#borrowedReturnFinalizerToken);
-                borrowedReturnFinalizer.register(region.buffer, { token: this.#token, release: this.#borrowedReturnReleaser }, this.#borrowedReturnFinalizerToken);
-            }
-            this.#borrowedReturnTrack?.(this, this.#token, region.buffer);
-            return region;
-        }
         (this.#materializedRegions ??= []).push(region);
         if (this.#producerBackstop !== undefined && producerFinalizer !== undefined) {
             this.#producerBackstop.count += 1;
@@ -420,6 +348,10 @@ export class BufferReference {
         if (this.#released)
             return;
         this.#released = true;
+        // A claimed Node return is an owning ArrayBuffer, not a borrow. Drop this
+        // wrapper's ownership immediately; any ArrayBuffer or typed-array the
+        // caller kept still co-owns the backing store and stays valid.
+        this.#owned = undefined;
         // Revoke every alias this reference handed out before any pin can drop.
         // Leak-not-UAF: if a detach fails, the pin must stay held — the GC
         // backstops remain registered and retry once the buffers are unreachable.
@@ -433,31 +365,6 @@ export class BufferReference {
                         allDetached;
             }
         }
-        const borrowedReturnReleaser = this.#borrowedReturnReleaser;
-        this.#borrowedReturnReleaser = undefined;
-        this.#borrowedReturnTrack = undefined;
-        if (borrowedReturnReleaser !== undefined) {
-            const owned = this.#owned;
-            this.#owned = undefined;
-            if (owned !== undefined) {
-                allDetached = detachArrayBufferBestEffort(this.runtime, owned.buffer) &&
-                    allDetached;
-            }
-            if (allDetached) {
-                if (this.#borrowedReturnFinalizerToken !== undefined) {
-                    borrowedReturnFinalizer?.unregister(this.#borrowedReturnFinalizerToken);
-                    this.#borrowedReturnFinalizerToken = undefined;
-                }
-                try {
-                    borrowedReturnReleaser(this.#token);
-                }
-                catch {
-                    // best effort
-                }
-            }
-            // else: the finalizer stays registered on the alias buffer and sends
-            // the release once every escaped view is gone.
-        }
         // Only the producer owns the registry hold; consumers must not drop it.
         if (this.#isProducer && allDetached) {
             if (this.#finalizerToken !== undefined) {
@@ -475,65 +382,6 @@ export class BufferReference {
         // else on failed detach: the countdown backstop drops the pin when the
         // reference and every materialized alias are unreachable.
     }
-    /**
-     * 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) {
-        const releaser = this.#borrowedReturnReleaser;
-        if (releaser === undefined || this.#released)
-            return;
-        const owned = this.#owned;
-        let nextOwned;
-        let detached = true;
-        if (owned !== undefined) {
-            if (copyBytes) {
-                nextOwned = {
-                    buffer: owned.buffer.slice(owned.byteOffset, owned.byteOffset + owned.byteLength),
-                    byteOffset: 0,
-                    byteLength: owned.byteLength,
-                };
-            }
-            // Without a copy, keep the (now detached) region so reads throw
-            // instead of re-materializing an alias over freed worker memory.
-            detached = detachArrayBufferBestEffort(this.runtime, owned.buffer);
-        }
-        else if (copyBytes) {
-            // Never materialized: take the bytes now, while the worker still pins
-            // them, so the reference stays readable after its worker dies.
-            const caps = getBufferReferenceCapabilities();
-            nextOwned = caps.adopt({
-                token: this.#token,
-                pointer: this.pointer,
-                byteOffset: this.byteOffset,
-                byteLength: this.byteLength,
-            }, { copy: !caps.supportsOwningAdopt });
-        }
-        else {
-            // Never materialized and the worker bytes are already gone: no view
-            // exists, so poison future reads instead of aliasing freed memory.
-            this.#released = true;
-        }
-        if (!detached)
-            return;
-        if (nextOwned !== undefined)
-            this.#owned = nextOwned;
-        this.#borrowedReturnReleaser = undefined;
-        this.#borrowedReturnTrack = undefined;
-        if (this.#borrowedReturnFinalizerToken !== undefined) {
-            borrowedReturnFinalizer?.unregister(this.#borrowedReturnFinalizerToken);
-            this.#borrowedReturnFinalizerToken = undefined;
-        }
-        // Best effort: if the worker is still alive it can drop its pin early.
-        try {
-            releaser(this.#token);
-        }
-        catch {
-            // best effort
-        }
-    }
     [Symbol.dispose]() {
         this.release();
     }
@@ -550,9 +398,6 @@ export class BufferReference {
             if (this.#transportRefs <= 0)
                 this.release();
         });
-        if (this.#isProducer) {
-            finalizer[BUFFER_REFERENCE_RETURN_RELEASE_TOKEN] = this.#token;
-        }
         return finalizer;
     }
 }

package/src/connections/node-addons.d.ts

@@ -1,5 +1,5 @@
 type NodeRequire = (specifier: string) => unknown;
-export type NodeNativeAddonName = "knitting_shared_memory" | "knitting_shm" | "knitting_buffer_pointer";
+export type NodeNativeAddonName = "knitting_shared_memory" | "knitting_shm" | "knitting_buffer_pointer" | "knitting_doorbell";
 export type NodePlatformInfo = {
     arch: string;
     modules?: string;

package/src/connections/shared-array-buffer-payload.d.ts

@@ -30,6 +30,13 @@ type SharedArrayBufferPayload = {
     readonly [SHARED_ARRAY_BUFFER_NUMERIC_TRANSFER]: (transportKey?: object) => SharedArrayBufferNumericMetadata | SharedArrayBufferTokenNumericMetadata | undefined;
 };
 export declare const isSharedArrayBufferValue: (value: unknown) => value is SharedArrayBuffer;
+type SharedPin = {
+    token: bigint;
+    pointer: bigint;
+    byteLength: number;
+};
+/** The pin backing `buffer`, when it has been shared at least once. */
+export declare const getSharedPin: (buffer: object) => SharedPin | undefined;
 /** Wrap a SAB as external payload; GC-managed pins mean no settle finalizer. */
 export declare const wrapSharedArrayBufferPayload: (sab: SharedArrayBuffer) => SharedArrayBufferPayload;
 export declare const getSharedArrayBufferPayload: (value: object) => SharedArrayBufferPayload | undefined;

package/src/connections/shared-array-buffer-payload.js

@@ -1,12 +1,13 @@
 import { RUNTIME } from "../common/runtime.js";
 import { getNodeProcess } from "../common/node-compat.js";
 import { getBufferReferenceCapabilities } from "./buffer-reference-native.js";
-// Thread-worker SharedArrayBuffer transport by process-local pointer.
-// SABs are shared, not moved or detached; process workers reject them.
+// SharedArrayBuffer transport uses a process-local pointer and is limited to
+// thread workers; SABs are not moved or detached.
 export const SHARED_ARRAY_BUFFER_CODEC_ID = "knitting.sharedArrayBuffer";
 export const SHARED_ARRAY_BUFFER_NUMERIC_TRANSFER = Symbol.for("knitting.sharedArrayBuffer.numericTransfer");
 export const SHARED_ARRAY_BUFFER_NUMERIC_WORDS = 8;
 const SHARED_ARRAY_BUFFER_TOKEN_NUMERIC_WORDS = 2;
+// Slice frames carry an explicit length; warm frames carry only the token.
 const EXTERNAL_PAYLOAD_BRAND = Symbol.for("knitting.payloadCodec");
 const getProcessId = () => {
     const proc = getNodeProcess();
@@ -23,7 +24,19 @@ export const isSharedArrayBufferValue = (value) => hasSharedArrayBuffer && value
 const pinnedBySab = new WeakMap();
 const payloadBySharedBuffer = new WeakMap();
 const warmedTokensByTransport = new WeakMap();
-const cachedSharedBuffersByToken = new Map();
+// Tokens are isolate-local, so adopted aliases are cached per transport lane.
+const adoptedByTransport = new WeakMap();
+const adoptedWithoutTransport = new Map();
+const adoptedCacheFor = (transportKey) => {
+    if (transportKey === undefined)
+        return adoptedWithoutTransport;
+    let cache = adoptedByTransport.get(transportKey);
+    if (cache === undefined) {
+        cache = new Map();
+        adoptedByTransport.set(transportKey, cache);
+    }
+    return cache;
+};
 const pinFinalizer = typeof FinalizationRegistry === "function"
     ? new FinalizationRegistry((token) => {
         try {
@@ -87,6 +100,8 @@ const pinSab = (sab) => {
     }
     return pin;
 };
+/** The pin backing `buffer`, when it has been shared at least once. */
+export const getSharedPin = (buffer) => pinnedBySab.get(buffer);
 const makeMetadata = (pin) => ({
     kind: SHARED_ARRAY_BUFFER_CODEC_ID,
     origin: PROCESS_ORIGIN,
@@ -167,13 +182,14 @@ const isSharedArrayBufferMetadata = (value) => {
         Number.isInteger(meta.byteLength) &&
         meta.byteLength >= 0);
 };
-const materializeSharedBuffer = (metadata, warmOnly) => {
+const materializeSharedBuffer = (metadata, warmOnly, transportKey) => {
     if (metadata.origin !== PROCESS_ORIGIN) {
         throw new Error(`SharedArrayBuffer cannot cross a process boundary (origin ${metadata.origin} ` +
             `!= ${PROCESS_ORIGIN}); it is shared by reference to thread workers only.`);
     }
     const token = BigInt(metadata.token);
-    const cached = cachedSharedBuffersByToken.get(token);
+    const cache = adoptedCacheFor(transportKey);
+    const cached = cache.get(token);
     if (cached !== undefined)
         return cached;
     if (warmOnly) {
@@ -185,7 +201,7 @@ const materializeSharedBuffer = (metadata, warmOnly) => {
         byteOffset: 0,
         byteLength: metadata.byteLength,
     });
-    cachedSharedBuffersByToken.set(token, region.buffer);
+    cache.set(token, region.buffer);
     createSharedArrayBufferPayload(region.buffer, {
         token,
         pointer: BigInt(metadata.pointer),
@@ -193,16 +209,16 @@ const materializeSharedBuffer = (metadata, warmOnly) => {
     }, metadata);
     return region.buffer;
 };
-const decode = (metadata) => {
+const decode = (metadata, transportKey) => {
     if (!isSharedArrayBufferMetadata(metadata)) {
         throw new TypeError("Invalid SharedArrayBuffer payload metadata");
     }
-    return materializeSharedBuffer(metadata, false);
+    return materializeSharedBuffer(metadata, false, transportKey);
 };
-const decodeNumeric = (words) => {
+const decodeNumeric = (words, transportKey) => {
     if (words.length === SHARED_ARRAY_BUFFER_TOKEN_NUMERIC_WORDS) {
         const token = joinU64(words[0] ?? 0, words[1] ?? 0);
-        const cached = cachedSharedBuffersByToken.get(token);
+        const cached = adoptedCacheFor(transportKey).get(token);
         if (cached !== undefined)
             return cached;
         throw new TypeError("SharedArrayBuffer cache miss for warm token payload");
@@ -228,7 +244,7 @@ const decodeNumeric = (words) => {
         token: joinU64(words[0] ?? 0, words[1] ?? 0).toString(),
         byteLength: words[4] ?? 0,
     };
-    return materializeSharedBuffer(metadata, false);
+    return materializeSharedBuffer(metadata, false, transportKey);
 };
 const codecGlobal = globalThis;
 const codecs = codecGlobal.__KNITTING_PAYLOAD_CODECS__ ??= Object.create(null);

package/src/ipc/transport/shared-memory.d.ts

@@ -1,6 +1,13 @@
 export type SignalArguments = ReturnType<typeof createSharedMemoryTransport>;
 import { type SharedBufferSource } from "../../common/shared-buffer-region.js";
 export declare const TRANSPORT_SIGNAL_BYTES: number;
+/** States of the worker-stop word. */
+export declare const WORKER_STOP: {
+    readonly running: 0;
+    readonly requested: 1;
+    /** The worker has left its dispatch loop. */
+    readonly acknowledged: 2;
+};
 export type Sab = {
     size?: number;
     sharedSab?: SharedBufferSource;
@@ -18,6 +25,7 @@ export declare const createSharedMemoryTransport: ({ sabObject, isMain, startTim
     opView: Int32Array<import("../../common/shared-buffer-region.js").SharedBuffer>;
     rxStatus: Int32Array<import("../../common/shared-buffer-region.js").SharedBuffer>;
     txStatus: Int32Array<import("../../common/shared-buffer-region.js").SharedBuffer>;
+    stopView: Int32Array<import("../../common/shared-buffer-region.js").SharedBuffer>;
 };
-export type MainSignal = Pick<SignalArguments, "opView" | "startAt" | "rxStatus" | "txStatus">;
+export type MainSignal = Pick<SignalArguments, "opView" | "startAt" | "rxStatus" | "txStatus" | "stopView">;
 export {};

package/src/ipc/transport/shared-memory.js

@@ -7,8 +7,16 @@ const SIGNAL_OFFSETS = {
     op: 0,
     rxStatus: CACHE_LINE_BYTES,
     txStatus: CACHE_LINE_BYTES * 2,
+    stop: CACHE_LINE_BYTES * 3,
+};
+export const TRANSPORT_SIGNAL_BYTES = CACHE_LINE_BYTES * 4;
+/** States of the worker-stop word. */
+export const WORKER_STOP = {
+    running: 0,
+    requested: 1,
+    /** The worker has left its dispatch loop. */
+    acknowledged: 2,
 };
-export const TRANSPORT_SIGNAL_BYTES = CACHE_LINE_BYTES * 3;
 const a_store = Atomics.store;
 export const createSharedMemoryTransport = ({ sabObject, isMain, startTime }) => {
     const toGrow = sabObject?.size ?? page;
@@ -24,6 +32,9 @@ export const createSharedMemoryTransport = ({ sabObject, isMain, startTime }) =>
         a_store(opView, 0, 0);
     const rxStatus = new Int32Array(sab, baseByteOffset + SIGNAL_OFFSETS.rxStatus, 1);
     a_store(rxStatus, 0, 1);
+    const stopView = new Int32Array(sab, baseByteOffset + SIGNAL_OFFSETS.stop, 1);
+    if (isMain)
+        a_store(stopView, 0, WORKER_STOP.running);
     return {
         sab: signalRegion,
         op: opView,
@@ -31,5 +42,6 @@ export const createSharedMemoryTransport = ({ sabObject, isMain, startTime }) =>
         opView,
         rxStatus,
         txStatus: new Int32Array(sab, baseByteOffset + SIGNAL_OFFSETS.txStatus, 1),
+        stopView,
     };
 };

package/src/knitting_buffer_pointer.cc

@@ -9,6 +9,7 @@
 #include <memory>
 #include <mutex>
 #include <unordered_map>
+#include <vector>
 
 namespace knitting_buffer_pointer {
 
@@ -27,12 +28,51 @@ struct RetainedBackingStore {
   std::shared_ptr<v8::BackingStore> store;
   size_t byte_offset;
   size_t byte_length;
+  // The isolate that produced the move. This is only a registry hold: a
+  // consumer's adopted ArrayBuffer owns its own shared_ptr.
+  v8::Isolate* producer_isolate;
 };
 
 std::mutex backing_mutex;
 uint64_t next_backing_id = 1;
 std::unordered_map<uint64_t, RetainedBackingStore> retained_backings;
 
+// Node tears a worker down without running its JavaScript finalizers. Both
+// registries are process-global, so discard holds produced by that environment
+// during teardown. Any consumer that adopted a backing store already has an
+// independent shared_ptr and is unaffected.
+void CleanupEnvironment(void* data) {
+  v8::Isolate* isolate = static_cast<v8::Isolate*>(data);
+  // Collect first, destroy on scope exit: releasing a hold must not run under
+  // the registry lock that found it.
+  std::vector<std::unique_ptr<RetainedReference>> released_refs;
+  std::vector<RetainedBackingStore> released_backings;
+
+  {
+    std::lock_guard<std::mutex> lock(retained_mutex);
+    for (auto it = retained_refs.begin(); it != retained_refs.end();) {
+      if (it->second->isolate != isolate) {
+        ++it;
+        continue;
+      }
+      released_refs.push_back(std::move(it->second));
+      it = retained_refs.erase(it);
+    }
+  }
+
+  {
+    std::lock_guard<std::mutex> lock(backing_mutex);
+    for (auto it = retained_backings.begin(); it != retained_backings.end();) {
+      if (it->second.producer_isolate != isolate) {
+        ++it;
+        continue;
+      }
+      released_backings.push_back(std::move(it->second));
+      it = retained_backings.erase(it);
+    }
+  }
+}
+
 void ThrowType(v8::Isolate* isolate, const char* message) {
   isolate->ThrowException(v8::Exception::TypeError(
     v8::String::NewFromUtf8(isolate, message).ToLocalChecked()
@@ -318,7 +358,18 @@ void RetainBackingStore(const v8::FunctionCallbackInfo<v8::Value>& args) {
   uintptr_t address = reinterpret_cast<uintptr_t>(base + byte_offset);
 
   // Detach only after taking the shared_ptr; ordinary JS buffers use no key.
-  DetachDefaultArrayBuffer(buffer);
+  // A failed detach must not be ignored: retaining the store while the source
+  // stays live hands the consumer an "owned" buffer that still aliases memory
+  // the producer can write. WASM memory and externally pinned buffers are the
+  // ones that land here, and the caller falls back to copying.
+  if (!DetachDefaultArrayBuffer(buffer)) {
+    ThrowType(
+      isolate,
+      "retainBackingStore requires a detachable ArrayBuffer; this buffer "
+      "cannot be moved without leaving the source aliasing it"
+    );
+    return;
+  }
 
   uint64_t token = 0;
   {
@@ -327,7 +378,9 @@ void RetainBackingStore(const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (token == 0) token = next_backing_id++;
     retained_backings.emplace(
       token,
-      RetainedBackingStore{ std::move(store), byte_offset, byte_length }
+      RetainedBackingStore{
+        std::move(store), byte_offset, byte_length, isolate
+      }
     );
   }
 
@@ -410,6 +463,8 @@ void Initialize(
   v8::Local<v8::Value>,
   v8::Local<v8::Context>
 ) {
+  v8::Isolate* isolate = exports->GetIsolate();
+  node::AddEnvironmentCleanupHook(isolate, CleanupEnvironment, isolate);
   NODE_SET_METHOD(exports, "getPointer", GetPointer);
   NODE_SET_METHOD(exports, "retainPointer", RetainPointer);
   NODE_SET_METHOD(exports, "releasePointer", ReleasePointer);