knitting 0.1.46 → 0.1.51

package/src/connections/windows.js

@@ -0,0 +1,224 @@
+import { fileURLToPath } from "node:url";
+import { expectFd, expectPositiveSize, readCreateMode, readCreateSize, readRequiredCreateName, } from "./types.js";
+const WINDOWS_CREATE_MODE_CREATE = 1;
+const WINDOWS_CREATE_MODE_OPEN = 2;
+const WINDOWS_MAPPING_RECORD_BYTES = 32;
+const POINTER_OFFSET = 0;
+const HANDLE_OFFSET = 8;
+const SIZE_OFFSET = 16;
+const BASE_ADDRESS_MOD_64_OFFSET = 24;
+const FFIType = {
+    i32: 5,
+    u32: 6,
+    i64: 7,
+    ptr: 12,
+};
+let anonymousNameCounter = 0;
+const getDeno = () => {
+    const deno = globalThis.Deno;
+    if (deno === undefined) {
+        throw new Error("Deno Windows shared memory primitives can only run in Deno");
+    }
+    return deno;
+};
+const getBunFFI = () => {
+    const ffi = globalThis.Bun?.FFI;
+    if (typeof ffi?.dlopen !== "function" ||
+        typeof ffi?.toArrayBuffer !== "function") {
+        throw new Error("Bun FFI is not available in this runtime");
+    }
+    return ffi;
+};
+export const isWindowsRuntime = () => {
+    const denoOs = globalThis.Deno?.build?.os;
+    if (denoOs !== undefined)
+        return denoOs === "windows";
+    const processPlatform = globalThis.process?.platform;
+    return processPlatform === "win32";
+};
+const windowsArch = () => {
+    const denoArch = globalThis.Deno?.build?.arch;
+    if (denoArch === "x86_64")
+        return "x64";
+    const processArch = globalThis.process?.arch;
+    if (processArch === "x64")
+        return processArch;
+    throw new Error("Windows shared memory prebuilds support x64 only");
+};
+export const windowsSharedMemoryPrebuildPath = () => fileURLToPath(new URL(`../../prebuilds/win32-${windowsArch()}/knitting_windows_shared_memory.dll`, import.meta.url));
+export const makeWindowsAnonymousSharedMemoryName = (runtime) => {
+    const processId = globalThis.process?.pid ??
+        globalThis.Deno?.pid ??
+        0;
+    const next = anonymousNameCounter++;
+    const timeTag = Date.now().toString(36);
+    const randomTag = Math.random().toString(36).slice(2, 10);
+    const runtimeTag = runtime.replace(/[^a-z0-9_-]/gi, "").slice(0, 12) || "js";
+    return `Local\\knit_${runtimeTag}_${processId}_${timeTag}_${next}_${randomTag}`;
+};
+const readWindowsCreate = (options, runtime) => {
+    const mode = readCreateMode(options);
+    if (mode === "anonymous") {
+        return {
+            mode: WINDOWS_CREATE_MODE_CREATE,
+            name: makeWindowsAnonymousSharedMemoryName(runtime),
+        };
+    }
+    return {
+        mode: mode === "open"
+            ? WINDOWS_CREATE_MODE_OPEN
+            : WINDOWS_CREATE_MODE_CREATE,
+        name: readRequiredCreateName(options),
+    };
+};
+const encodeWideCString = (value) => {
+    const out = new Uint16Array((value?.length ?? 0) + 1);
+    if (value === undefined)
+        return out;
+    for (let index = 0; index < value.length; index += 1) {
+        out[index] = value.charCodeAt(index);
+    }
+    return out;
+};
+const readWindowsNativeMapping = (record) => {
+    const view = new DataView(record.buffer, record.byteOffset, record.byteLength);
+    const address = view.getBigUint64(POINTER_OFFSET, true);
+    const handle = view.getBigUint64(HANDLE_OFFSET, true);
+    const size = view.getBigUint64(SIZE_OFFSET, true);
+    if (address === 0n || handle === 0n) {
+        throw new Error("Windows shared memory backend returned an empty mapping");
+    }
+    if (size > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new RangeError("Windows shared memory mapping is too large");
+    }
+    return {
+        address,
+        handle,
+        size: Number(size),
+        baseAddressMod64: view.getUint32(BASE_ADDRESS_MOD_64_OFFSET, true),
+    };
+};
+const fdFromHandle = (handle) => handle <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(handle) : 0;
+const checkWindowsResult = (result, message) => {
+    if (result !== 0) {
+        throw new Error(`${message} failed with Windows error ${result}`);
+    }
+};
+const createRecord = () => new Uint8Array(WINDOWS_MAPPING_RECORD_BYTES);
+export const openDenoWindowsSharedMemoryLibrary = () => getDeno().dlopen(windowsSharedMemoryPrebuildPath(), {
+    knitting_windows_create_shared_memory: {
+        parameters: ["u64", "buffer", "u32", "buffer"],
+        result: "i32",
+    },
+    knitting_windows_map_shared_memory: {
+        parameters: ["u64", "u64", "buffer", "buffer"],
+        result: "i32",
+    },
+    knitting_windows_close_shared_memory: {
+        parameters: ["buffer"],
+        result: "i32",
+    },
+});
+export const openBunWindowsSharedMemoryLibrary = () => getBunFFI().dlopen(windowsSharedMemoryPrebuildPath(), {
+    knitting_windows_create_shared_memory: {
+        args: [FFIType.i64, FFIType.ptr, FFIType.u32, FFIType.ptr],
+        returns: FFIType.i32,
+    },
+    knitting_windows_map_shared_memory: {
+        args: [FFIType.i64, FFIType.i64, FFIType.ptr, FFIType.ptr],
+        returns: FFIType.i32,
+    },
+    knitting_windows_close_shared_memory: {
+        args: [FFIType.ptr],
+        returns: FFIType.i32,
+    },
+});
+const closeWindowsMapping = (record, closeSharedMemory) => {
+    let closed = false;
+    return () => {
+        if (closed)
+            return;
+        closed = true;
+        checkWindowsResult(closeSharedMemory(record), "knitting_windows_close_shared_memory");
+    };
+};
+const fromDenoWindowsRecord = (record, name, lib) => {
+    const mapping = readWindowsNativeMapping(record);
+    const pointer = getDeno().UnsafePointer?.create(mapping.address);
+    if (pointer === undefined || pointer === null || typeof pointer !== "object") {
+        throw new Error("Deno UnsafePointer.create is not available");
+    }
+    const arrayBuffer = new (getDeno().UnsafePointerView)(pointer)
+        .getArrayBuffer(mapping.size);
+    return {
+        runtime: "deno",
+        fd: fdFromHandle(mapping.handle),
+        name,
+        size: mapping.size,
+        byteLength: arrayBuffer.byteLength,
+        buffer: arrayBuffer,
+        kind: "external-array-buffer",
+        arrayBuffer,
+        unsafePointer: pointer,
+        baseAddressMod64: mapping.baseAddressMod64,
+        close: closeWindowsMapping(record, lib.symbols.knitting_windows_close_shared_memory),
+    };
+};
+const fromBunWindowsRecord = (record, name, lib) => {
+    const mapping = readWindowsNativeMapping(record);
+    if (mapping.address > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new RangeError("Windows mapping pointer is too large for Bun FFI");
+    }
+    const arrayBuffer = getBunFFI().toArrayBuffer(Number(mapping.address), 0, mapping.size);
+    return {
+        runtime: "bun",
+        fd: fdFromHandle(mapping.handle),
+        name,
+        size: mapping.size,
+        byteLength: arrayBuffer.byteLength,
+        buffer: arrayBuffer,
+        kind: "external-array-buffer",
+        arrayBuffer,
+        unsafePointer: Number(mapping.address),
+        baseAddressMod64: mapping.baseAddressMod64,
+        close: closeWindowsMapping(record, lib.symbols.knitting_windows_close_shared_memory),
+    };
+};
+export const createDenoWindowsSharedMemory = (options, lib = openDenoWindowsSharedMemoryLibrary()) => {
+    const size = expectPositiveSize(readCreateSize(options));
+    const { mode, name } = readWindowsCreate(options, "deno");
+    const record = createRecord();
+    checkWindowsResult(lib.symbols.knitting_windows_create_shared_memory(BigInt(size), encodeWideCString(name), mode, record), "knitting_windows_create_shared_memory");
+    return fromDenoWindowsRecord(record, name, lib);
+};
+export const mapDenoWindowsSharedMemory = (options, lib = openDenoWindowsSharedMemoryLibrary()) => {
+    const fd = expectFd(options.fd);
+    const size = expectPositiveSize(options.size);
+    const record = createRecord();
+    checkWindowsResult(lib.symbols.knitting_windows_map_shared_memory(BigInt(fd), BigInt(size), encodeWideCString(options.name), record), "knitting_windows_map_shared_memory");
+    return fromDenoWindowsRecord(record, options.name, lib);
+};
+export const createDenoWindowsConnectionPrimitives = (lib = openDenoWindowsSharedMemoryLibrary()) => ({
+    runtime: "deno",
+    createSharedMemory: (options) => createDenoWindowsSharedMemory(options, lib),
+    mapSharedMemory: (options) => mapDenoWindowsSharedMemory(options, lib),
+});
+export const createBunWindowsSharedMemory = (options, lib = openBunWindowsSharedMemoryLibrary()) => {
+    const size = expectPositiveSize(readCreateSize(options));
+    const { mode, name } = readWindowsCreate(options, "bun");
+    const record = createRecord();
+    checkWindowsResult(lib.symbols.knitting_windows_create_shared_memory(BigInt(size), encodeWideCString(name), mode, record), "knitting_windows_create_shared_memory");
+    return fromBunWindowsRecord(record, name, lib);
+};
+export const mapBunWindowsSharedMemory = (options, lib = openBunWindowsSharedMemoryLibrary()) => {
+    const fd = expectFd(options.fd);
+    const size = expectPositiveSize(options.size);
+    const record = createRecord();
+    checkWindowsResult(lib.symbols.knitting_windows_map_shared_memory(BigInt(fd), BigInt(size), encodeWideCString(options.name), record), "knitting_windows_map_shared_memory");
+    return fromBunWindowsRecord(record, options.name, lib);
+};
+export const createBunWindowsConnectionPrimitives = (lib = openBunWindowsSharedMemoryLibrary()) => ({
+    runtime: "bun",
+    createSharedMemory: (options) => createBunWindowsSharedMemory(options, lib),
+    mapSharedMemory: (options) => mapBunWindowsSharedMemory(options, lib),
+});

package/src/knitting_shared_memory.cc

@@ -63,7 +63,7 @@ bool SetCloseOnExec(int fd) {
   return fcntl(fd, F_SETFD, flags | FD_CLOEXEC) != -1;
 }
 
-int CreateSharedMemoryFd(const char* name) {
+int CreateAnonymousSharedMemoryFd(const char* name) {
 #ifdef __linux__
   return static_cast<int>(syscall(SYS_memfd_create, name, MFD_CLOEXEC));
 #else
@@ -156,6 +156,80 @@ void ThrowRange(v8::Isolate* isolate, const char* message) {
   ));
 }
 
+#ifndef _WIN32
+bool ToPosixSharedMemoryName(
+  v8::Isolate* isolate,
+  const std::string& name,
+  std::string* out
+) {
+  if (name.empty()) {
+    ThrowType(isolate, "shared memory name must be non-empty");
+    return false;
+  }
+  if (name.find('\0') != std::string::npos) {
+    ThrowType(isolate, "shared memory name must not contain NUL bytes");
+    return false;
+  }
+
+  *out = name[0] == '/' ? name : "/" + name;
+  if (out->size() < 2 || out->find('/', 1) != std::string::npos) {
+    ThrowType(
+      isolate,
+      "POSIX shared memory name must not contain path separators"
+    );
+    return false;
+  }
+  // macOS limits POSIX shared memory names to 31 characters including the
+  // leading "/", so the usable name portion is at most 30 characters.
+  if (out->size() > 31) {
+    ThrowType(
+      isolate,
+      "POSIX shared memory name must be at most 30 characters (macOS limit)"
+    );
+    return false;
+  }
+  return true;
+}
+
+int OpenNamedSharedMemoryFd(const std::string& posix_name, const std::string& mode) {
+  int flags = O_RDWR;
+  if (mode == "create") {
+    flags |= O_CREAT | O_EXCL;
+  }
+  return shm_open(posix_name.c_str(), flags, 0600);
+}
+#endif
+
+bool ReadOptionalUtf8String(
+  v8::Isolate* isolate,
+  const v8::FunctionCallbackInfo<v8::Value>& args,
+  int index,
+  std::string* out
+) {
+  out->clear();
+  if (
+    args.Length() <= index ||
+    args[index]->IsUndefined() ||
+    args[index]->IsNull()
+  ) {
+    return true;
+  }
+
+  if (!args[index]->IsString()) {
+    ThrowType(isolate, "expected a string argument");
+    return false;
+  }
+
+  v8::String::Utf8Value value(isolate, args[index]);
+  if (*value == nullptr) {
+    ThrowType(isolate, "expected a valid UTF-8 string");
+    return false;
+  }
+
+  out->assign(*value, value.length());
+  return true;
+}
+
 #ifdef _WIN32
 std::atomic<int> next_mapping_id{1};
 std::mutex registry_mutex;
@@ -205,6 +279,46 @@ HANDLE DuplicateRegisteredMappingHandle(int id) {
   }
   return duplicate;
 }
+
+std::wstring Utf8ToWide(const std::string& value) {
+  if (value.empty()) return std::wstring();
+
+  int wide_len = MultiByteToWideChar(
+    CP_UTF8,
+    MB_ERR_INVALID_CHARS,
+    value.data(),
+    static_cast<int>(value.size()),
+    nullptr,
+    0
+  );
+  if (wide_len <= 0) return std::wstring();
+
+  std::wstring wide(static_cast<size_t>(wide_len), L'\0');
+  MultiByteToWideChar(
+    CP_UTF8,
+    MB_ERR_INVALID_CHARS,
+    value.data(),
+    static_cast<int>(value.size()),
+    wide.data(),
+    wide_len
+  );
+  return wide;
+}
+
+std::string MakeAnonymousMappingName() {
+  static std::atomic<unsigned long> counter{0};
+  unsigned long next = counter.fetch_add(1);
+  char name[128];
+  std::snprintf(
+    name,
+    sizeof(name),
+    "Local\\knit_node_%lu_%llu_%lu",
+    static_cast<unsigned long>(GetCurrentProcessId()),
+    static_cast<unsigned long long>(GetTickCount64()),
+    next
+  );
+  return std::string(name);
+}
 #endif
 
 void MappingDeleter(void* data, size_t length, void* deleter_data) {
@@ -248,8 +362,10 @@ void ReturnMappedRegion(
 #ifdef _WIN32
   HANDLE handle,
   int fd,
+  const std::string& name,
 #else
   int fd,
+  const std::string& name,
 #endif
   size_t size
 ) {
@@ -294,6 +410,15 @@ void ReturnMappedRegion(
   v8::Local<v8::Object> out = v8::Object::New(isolate);
   SetValue(isolate, context, out, "sab", sab);
   SetValue(isolate, context, out, "fd", v8::Integer::New(isolate, fd));
+  if (!name.empty()) {
+    SetValue(
+      isolate,
+      context,
+      out,
+      "name",
+      v8::String::NewFromUtf8(isolate, name.c_str()).ToLocalChecked()
+    );
+  }
   SetValue(
     isolate,
     context,
@@ -333,17 +458,66 @@ void CreateSharedMemory(const v8::FunctionCallbackInfo<v8::Value>& args) {
   size_t size = AlignUp(static_cast<size_t>(maybe_size.FromJust()), CACHE_LINE_SIZE);
 
 #ifdef _WIN32
+  std::string name;
+  if (!ReadOptionalUtf8String(isolate, args, 1, &name)) {
+    return;
+  }
+
+  std::string mode = "anonymous";
+  if (!ReadOptionalUtf8String(isolate, args, 2, &mode)) {
+    return;
+  }
+  if (mode.empty()) {
+    mode = "anonymous";
+  }
+
+  const bool open_existing = mode == "open";
+  const bool create_named = mode == "create";
+  const bool anonymous = mode == "anonymous";
+  if (!open_existing && !create_named && !anonymous) {
+    ThrowType(isolate, "mode must be anonymous, create, or open");
+    return;
+  }
+
+  if (anonymous || name.empty()) {
+    name = MakeAnonymousMappingName();
+  }
+
+  std::wstring wide_name = Utf8ToWide(name);
+  if (wide_name.empty()) {
+    ThrowType(isolate, "shared memory name must be valid UTF-8");
+    return;
+  }
+
   uint64_t wide_size = static_cast<uint64_t>(size);
-  HANDLE handle = CreateFileMappingW(
-    INVALID_HANDLE_VALUE,
-    nullptr,
-    PAGE_READWRITE,
-    static_cast<DWORD>(wide_size >> 32),
-    static_cast<DWORD>(wide_size & 0xffffffffULL),
-    nullptr
-  );
+  HANDLE handle = nullptr;
+  if (open_existing) {
+    handle = OpenFileMappingW(FILE_MAP_ALL_ACCESS, FALSE, wide_name.c_str());
+  } else {
+    handle = CreateFileMappingW(
+      INVALID_HANDLE_VALUE,
+      nullptr,
+      PAGE_READWRITE,
+      static_cast<DWORD>(wide_size >> 32),
+      static_cast<DWORD>(wide_size & 0xffffffffULL),
+      wide_name.c_str()
+    );
+  }
   if (handle == nullptr) {
-    ThrowWindowsError(isolate, "CreateFileMappingW failed");
+    ThrowWindowsError(
+      isolate,
+      open_existing ? "OpenFileMappingW failed" : "CreateFileMappingW failed"
+    );
+    return;
+  }
+
+  if (create_named && GetLastError() == ERROR_ALREADY_EXISTS) {
+    CloseHandle(handle);
+    ThrowWindowsError(
+      isolate,
+      "CreateFileMappingW failed",
+      ERROR_ALREADY_EXISTS
+    );
     return;
   }
 
@@ -355,22 +529,64 @@ void CreateSharedMemory(const v8::FunctionCallbackInfo<v8::Value>& args) {
     return;
   }
 
-  ReturnMappedRegion(args, handle, fd, size);
+  ReturnMappedRegion(args, handle, fd, name, size);
 #else
-  int fd = CreateSharedMemoryFd("knitting_shared_memory");
+  std::string name;
+  if (!ReadOptionalUtf8String(isolate, args, 1, &name)) {
+    return;
+  }
+
+  std::string mode = "anonymous";
+  if (!ReadOptionalUtf8String(isolate, args, 2, &mode)) {
+    return;
+  }
+  if (mode.empty()) {
+    mode = "anonymous";
+  }
+
+  const bool open_existing = mode == "open";
+  const bool create_named = mode == "create";
+  const bool anonymous = mode == "anonymous";
+  if (!open_existing && !create_named && !anonymous) {
+    ThrowType(isolate, "mode must be anonymous, create, or open");
+    return;
+  }
+
+  std::string returned_name;
+  int fd = -1;
+  if (anonymous) {
+    fd = CreateAnonymousSharedMemoryFd("knitting_shared_memory");
+  } else {
+    std::string posix_name;
+    if (!ToPosixSharedMemoryName(isolate, name, &posix_name)) {
+      return;
+    }
+    fd = OpenNamedSharedMemoryFd(posix_name, mode);
+    returned_name = name;
+  }
   if (fd == -1) {
-    ThrowErrno(isolate, "shared memory fd create failed");
+    ThrowErrno(
+      isolate,
+      anonymous ? "shared memory fd create failed" : "shm_open failed"
+    );
+    return;
+  }
+
+  if (!SetCloseOnExec(fd)) {
+    int saved = errno;
+    close(fd);
+    ThrowErrno(isolate, "fcntl(F_SETFD) failed", saved);
     return;
   }
 
-  if (ftruncate(fd, static_cast<off_t>(size)) == -1) {
+  if (!open_existing && ftruncate(fd, static_cast<off_t>(size)) == -1) {
     int saved = errno;
     close(fd);
     ThrowErrno(isolate, "ftruncate failed", saved);
     return;
   }
 
-  ReturnMappedRegion(args, fd, size);
+  ReturnMappedRegion(args, fd, returned_name, size);
 #endif
 }
 
@@ -399,22 +615,59 @@ void MapSharedMemory(const v8::FunctionCallbackInfo<v8::Value>& args) {
 
 #ifdef _WIN32
   int fd = maybe_fd.FromJust();
-  HANDLE handle = DuplicateRegisteredMappingHandle(fd);
+  std::string name;
+  if (!ReadOptionalUtf8String(isolate, args, 2, &name)) {
+    return;
+  }
+
+  HANDLE handle = nullptr;
+  if (!name.empty()) {
+    std::wstring wide_name = Utf8ToWide(name);
+    if (wide_name.empty()) {
+      ThrowType(isolate, "shared memory name must be valid UTF-8");
+      return;
+    }
+    handle = OpenFileMappingW(FILE_MAP_ALL_ACCESS, FALSE, wide_name.c_str());
+  } else {
+    handle = DuplicateRegisteredMappingHandle(fd);
+  }
+
   if (handle == nullptr) {
-    ThrowWindowsError(isolate, "DuplicateHandle failed");
+    ThrowWindowsError(
+      isolate,
+      name.empty() ? "DuplicateHandle failed" : "OpenFileMappingW failed"
+    );
     return;
   }
 
-  ReturnMappedRegion(args, handle, fd, size);
+  ReturnMappedRegion(args, handle, fd, name, size);
 #else
-  // Duplicate so each returned SAB owns exactly one fd. The caller can keep
-  // using or transferring its original descriptor independently.
-  int fd = dup(maybe_fd.FromJust());
-  if (fd == -1) {
-    ThrowErrno(isolate, "dup(fd) failed");
+  std::string name;
+  if (!ReadOptionalUtf8String(isolate, args, 2, &name)) {
     return;
   }
 
+  int fd = -1;
+  if (!name.empty()) {
+    std::string posix_name;
+    if (!ToPosixSharedMemoryName(isolate, name, &posix_name)) {
+      return;
+    }
+    fd = shm_open(posix_name.c_str(), O_RDWR, 0600);
+    if (fd == -1) {
+      ThrowErrno(isolate, "shm_open failed");
+      return;
+    }
+  } else {
+    // Duplicate so each returned SAB owns exactly one fd. The caller can keep
+    // using or transferring its original descriptor independently.
+    fd = dup(maybe_fd.FromJust());
+    if (fd == -1) {
+      ThrowErrno(isolate, "dup(fd) failed");
+      return;
+    }
+  }
+
   if (!SetCloseOnExec(fd)) {
     int saved = errno;
     close(fd);
@@ -422,15 +675,55 @@ void MapSharedMemory(const v8::FunctionCallbackInfo<v8::Value>& args) {
     return;
   }
 
-  ReturnMappedRegion(args, fd, size);
+  ReturnMappedRegion(args, fd, name, size);
+#endif
+}
+
+void UnlinkSharedMemory(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  v8::Isolate* isolate = args.GetIsolate();
+
+  std::string name;
+  if (!ReadOptionalUtf8String(isolate, args, 0, &name)) {
+    return;
+  }
+  if (name.empty()) {
+    ThrowType(isolate, "unlinkSharedMemory(name) requires name");
+    return;
+  }
+
+#ifdef _WIN32
+  args.GetReturnValue().Set(v8::Boolean::New(isolate, false));
+#else
+  std::string posix_name;
+  if (!ToPosixSharedMemoryName(isolate, name, &posix_name)) {
+    return;
+  }
+
+  if (shm_unlink(posix_name.c_str()) == 0) {
+    args.GetReturnValue().Set(v8::Boolean::New(isolate, true));
+    return;
+  }
+  if (errno == ENOENT) {
+    args.GetReturnValue().Set(v8::Boolean::New(isolate, false));
+    return;
+  }
+  ThrowErrno(isolate, "shm_unlink failed");
 #endif
 }
 
-void Initialize(v8::Local<v8::Object> exports) {
+void Initialize(
+  v8::Local<v8::Object> exports,
+  v8::Local<v8::Value> /*module*/,
+  v8::Local<v8::Context> /*context*/
+) {
   NODE_SET_METHOD(exports, "createSharedMemory", CreateSharedMemory);
   NODE_SET_METHOD(exports, "mapSharedMemory", MapSharedMemory);
+  NODE_SET_METHOD(exports, "unlinkSharedMemory", UnlinkSharedMemory);
 }
 
-NODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)
+// This addon needs V8 APIs to expose mmap'd memory as a SharedArrayBuffer.
+// Context-aware registration lets Node initialize it inside worker threads
+// even after the main thread has already loaded the shared library.
+NODE_MODULE_CONTEXT_AWARE(NODE_GYP_MODULE_NAME, Initialize)
 
 }  // namespace knitting_shared_memory