knitting 0.1.54 → 0.1.55

package/shared-memory.js

@@ -0,0 +1,1342 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/common/node-compat.ts
+var nodeProcess = (() => {
+  const candidate = globalThis.process;
+  return typeof candidate?.versions?.node === "string" ? candidate : undefined;
+})();
+var getNodeProcess = () => nodeProcess;
+var getNodeBuiltinModule = (specifier) => {
+  const getter = nodeProcess?.getBuiltinModule;
+  if (typeof getter !== "function")
+    return;
+  try {
+    return getter.call(nodeProcess, specifier);
+  } catch {}
+  if (!specifier.startsWith("node:"))
+    return;
+  try {
+    return getter.call(nodeProcess, specifier.slice(5));
+  } catch {
+    return;
+  }
+};
+
+// src/connections/types.ts
+var CACHE_LINE_SIZE = 64;
+var alignToCacheLine = (size) => size + (CACHE_LINE_SIZE - size % CACHE_LINE_SIZE) % CACHE_LINE_SIZE;
+var readCreateSize = (options) => typeof options === "number" ? options : options.size;
+var readCreateName = (options, fallback) => typeof options === "number" ? fallback : options.name ?? fallback;
+var readCreateMode = (options) => typeof options === "number" ? "anonymous" : options.mode ?? "anonymous";
+var expectSharedMemoryName = (name) => {
+  if (typeof name !== "string" || name.length === 0) {
+    throw new TypeError("shared memory name must be a non-empty string");
+  }
+  if (name.includes("\x00")) {
+    throw new TypeError("shared memory name must not contain NUL bytes");
+  }
+  return name;
+};
+var readRequiredCreateName = (options) => {
+  if (typeof options === "number" || options.name === undefined) {
+    throw new TypeError("named shared memory requires a name");
+  }
+  return expectSharedMemoryName(options.name);
+};
+var expectPositiveSize = (size) => {
+  if (!Number.isFinite(size) || size <= 0) {
+    throw new RangeError("shared memory size must be positive");
+  }
+  return alignToCacheLine(Math.trunc(size));
+};
+var expectFd = (fd) => {
+  if (!Number.isInteger(fd) || fd < 0) {
+    throw new RangeError("shared memory fd must be non-negative");
+  }
+  return fd;
+};
+var requireSharedArrayBuffer = (mapping) => {
+  if (mapping.sab !== undefined)
+    return mapping.sab;
+  throw new TypeError(`${mapping.runtime} mapping is ${mapping.kind}; a native SAB wrapper is required`);
+};
+
+// src/connections/file-descriptor.ts
+var isRecord = (value) => typeof value === "object" && value !== null;
+var readOptionalRuntime = (value) => {
+  if (value === undefined)
+    return;
+  if (value === "node" || value === "deno" || value === "bun")
+    return value;
+  throw new TypeError("file descriptor runtime is invalid");
+};
+var readOptionalKind = (value) => {
+  if (value === undefined)
+    return;
+  if (value === "shared-array-buffer" || value === "external-array-buffer") {
+    return value;
+  }
+  throw new TypeError("file descriptor buffer kind is invalid");
+};
+var readOptionalNumber = (value, label) => {
+  if (value === undefined)
+    return;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new TypeError(`file descriptor ${label} must be a finite number`);
+  }
+  return Math.trunc(value);
+};
+var readOptionalName = (value) => {
+  if (value === undefined)
+    return;
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError("file descriptor name must be a non-empty string when provided");
+  }
+  if (value.includes("\x00")) {
+    throw new TypeError("file descriptor name must not contain NUL bytes");
+  }
+  return value;
+};
+
+class FileDescriptor {
+  fd;
+  name;
+  size;
+  byteLength;
+  runtime;
+  kind;
+  baseAddressMod64;
+  #mapping;
+  constructor(metadata, mapping) {
+    this.fd = expectFd(metadata.fd);
+    this.name = metadata.name;
+    this.size = expectPositiveSize(metadata.size);
+    this.byteLength = expectPositiveSize(metadata.byteLength);
+    this.runtime = metadata.runtime;
+    this.kind = metadata.kind;
+    this.baseAddressMod64 = metadata.baseAddressMod64;
+    this.#mapping = mapping;
+  }
+  static fromMapping(mapping) {
+    return new FileDescriptor({
+      version: 1,
+      fd: mapping.fd,
+      name: mapping.name,
+      size: mapping.size,
+      byteLength: mapping.byteLength,
+      runtime: mapping.runtime,
+      kind: mapping.kind,
+      baseAddressMod64: mapping.baseAddressMod64
+    }, mapping);
+  }
+  static fromMetadata(metadata) {
+    return new FileDescriptor(parseFileDescriptorMetadata(metadata));
+  }
+  static parse(serialized) {
+    return FileDescriptor.fromMetadata(serialized);
+  }
+  toMetadata() {
+    const metadata = {
+      version: 1,
+      fd: this.fd,
+      size: this.size,
+      byteLength: this.byteLength,
+      runtime: this.runtime,
+      kind: this.kind,
+      baseAddressMod64: this.baseAddressMod64
+    };
+    if (this.name !== undefined)
+      metadata.name = this.name;
+    return metadata;
+  }
+  toJSON() {
+    return this.toMetadata();
+  }
+  stringify() {
+    return JSON.stringify(this.toMetadata());
+  }
+  stringifyMetadata() {
+    return this.stringify();
+  }
+  toString() {
+    return this.stringify();
+  }
+  attach(mapping) {
+    this.#mapping = mapping;
+    return this;
+  }
+  get mapping() {
+    return this.#mapping;
+  }
+  map(mapper) {
+    const options = {
+      fd: this.fd,
+      name: this.name,
+      size: this.size
+    };
+    this.#mapping = mapper.mapSharedMemory(options);
+    return this.#mapping;
+  }
+  getBuffer(mapper) {
+    if (this.#mapping?.buffer !== undefined)
+      return this.#mapping.buffer;
+    if (mapper === undefined) {
+      throw new TypeError("file descriptor is not attached to a shared memory mapping");
+    }
+    return this.map(mapper).buffer;
+  }
+  getSharedArrayBuffer(mapper) {
+    if (this.#mapping?.sab !== undefined)
+      return this.#mapping.sab;
+    if (mapper === undefined) {
+      throw new TypeError("file descriptor is not attached to a SharedArrayBuffer mapping");
+    }
+    return requireSharedArrayBuffer(this.map(mapper));
+  }
+  getSAB(mapper) {
+    return this.getSharedArrayBuffer(mapper);
+  }
+}
+var parseFileDescriptorMetadata = (input) => {
+  const value = typeof input === "string" ? JSON.parse(input) : input;
+  if (!isRecord(value)) {
+    throw new TypeError("file descriptor metadata must be an object");
+  }
+  if (value.version !== 1) {
+    throw new TypeError("unsupported file descriptor metadata version");
+  }
+  const parsed = {
+    version: 1,
+    fd: expectFd(readOptionalNumber(value.fd, "fd") ?? -1),
+    size: expectPositiveSize(readOptionalNumber(value.size, "size") ?? 0),
+    byteLength: expectPositiveSize(readOptionalNumber(value.byteLength, "byteLength") ?? readOptionalNumber(value.size, "size") ?? 0),
+    runtime: readOptionalRuntime(value.runtime),
+    kind: readOptionalKind(value.kind),
+    baseAddressMod64: readOptionalNumber(value.baseAddressMod64, "baseAddressMod64")
+  };
+  const name = readOptionalName(value.name);
+  if (name !== undefined)
+    parsed.name = name;
+  return parsed;
+};
+
+// src/common/runtime.ts
+var globals = globalThis;
+var nodeProcess2 = getNodeProcess();
+var IS_DENO = typeof globals.Deno?.version?.deno === "string";
+var IS_BUN = typeof globals.Bun?.version === "string";
+var IS_NODE = typeof nodeProcess2?.versions?.node === "string";
+var RUNTIME = IS_DENO ? "deno" : IS_BUN ? "bun" : IS_NODE ? "node" : "unknown";
+var SET_IMMEDIATE = typeof globals.setImmediate === "function" ? globals.setImmediate : undefined;
+var WASM_MEMORY_PAGE_BYTES = 64 * 1024;
+var wasmSharedBufferMemory = new WeakMap;
+var wasmSharedBufferMaxByteLength = new WeakMap;
+var hasSharedWasmMemory = (() => {
+  if (typeof WebAssembly?.Memory !== "function")
+    return false;
+  try {
+    new WebAssembly.Memory({ initial: 0, maximum: 1, shared: true });
+    return true;
+  } catch {
+    return false;
+  }
+})();
+var roundupWasmPages = (byteLength) => Math.ceil(Math.max(0, byteLength) / WASM_MEMORY_PAGE_BYTES);
+var createSharedWasmBuffer = (byteLength, maxByteLength) => {
+  const memory = new WebAssembly.Memory({
+    initial: roundupWasmPages(byteLength),
+    maximum: Math.max(roundupWasmPages(byteLength), roundupWasmPages(maxByteLength)),
+    shared: true
+  });
+  const buffer = memory.buffer;
+  wasmSharedBufferMemory.set(buffer, memory);
+  wasmSharedBufferMaxByteLength.set(buffer, maxByteLength);
+  return buffer;
+};
+var createWasmSharedArrayBuffer = (byteLength, maxByteLength = byteLength) => {
+  if (hasSharedWasmMemory) {
+    return createSharedWasmBuffer(byteLength, maxByteLength);
+  }
+  return new SharedArrayBuffer(byteLength);
+};
+var HAS_NATIVE_SAB_GROW = typeof SharedArrayBuffer === "function" && typeof SharedArrayBuffer.prototype.grow === "function";
+var HAS_SAB_GROW = HAS_NATIVE_SAB_GROW || hasSharedWasmMemory;
+var createSharedArrayBuffer = (byteLength, maxByteLength) => {
+  if (HAS_NATIVE_SAB_GROW && typeof maxByteLength === "number") {
+    return new SharedArrayBuffer(byteLength, { maxByteLength });
+  }
+  if (hasSharedWasmMemory && typeof maxByteLength === "number") {
+    return createSharedWasmBuffer(byteLength, maxByteLength);
+  }
+  return new SharedArrayBuffer(byteLength);
+};
+var isGrowableSharedArrayBuffer = (sab) => {
+  const value = sab;
+  return HAS_NATIVE_SAB_GROW && typeof value.grow === "function" && value.growable === true || wasmSharedBufferMemory.has(sab);
+};
+var sharedArrayBufferMaxByteLength = (sab) => {
+  const value = sab;
+  if (typeof value.maxByteLength === "number") {
+    return value.maxByteLength;
+  }
+  return wasmSharedBufferMaxByteLength.get(sab) ?? sab.byteLength;
+};
+var growSharedArrayBuffer = (sab, byteLength) => {
+  const native = sab;
+  if (typeof native.grow === "function") {
+    native.grow(byteLength);
+    return sab;
+  }
+  const memory = wasmSharedBufferMemory.get(sab);
+  if (memory == null) {
+    throw new TypeError("SharedArrayBuffer is not growable");
+  }
+  const currentBuffer = memory.buffer;
+  if (currentBuffer.byteLength >= byteLength) {
+    return currentBuffer;
+  }
+  const targetPages = roundupWasmPages(byteLength);
+  const currentPages = roundupWasmPages(currentBuffer.byteLength);
+  memory.grow(targetPages - currentPages);
+  const nextBuffer = memory.buffer;
+  const maxByteLength = wasmSharedBufferMaxByteLength.get(sab) ?? currentBuffer.byteLength;
+  wasmSharedBufferMemory.set(nextBuffer, memory);
+  wasmSharedBufferMaxByteLength.set(nextBuffer, maxByteLength);
+  return nextBuffer;
+};
+
+// src/connections/posix.ts
+var LINUX_LIBC_SO = "libc.so.6";
+var DARWIN_LIBSYSTEM = "/usr/lib/libSystem.B.dylib";
+var PROT_READ = 1;
+var PROT_WRITE = 2;
+var MAP_SHARED = 1;
+var O_RDWR = 2;
+var LINUX_O_CREAT = 64;
+var LINUX_O_EXCL = 128;
+var DARWIN_O_CREAT = 512;
+var DARWIN_O_EXCL = 2048;
+var DARWIN_SHM_MODE = 384;
+var POSIX_SHM_MODE = 384;
+var F_GETFD = 1;
+var F_SETFD = 2;
+var FD_CLOEXEC = 1;
+var encodeCString = (value) => new TextEncoder().encode(`${value}\x00`);
+var setCloseOnExec = (libc, fd) => {
+  const flags = libc.symbols.fcntl(fd, F_GETFD, 0);
+  if (flags < 0) {
+    throw new Error("fcntl(F_GETFD) failed");
+  }
+  const result = libc.symbols.fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
+  if (result < 0) {
+    throw new Error("fcntl(F_SETFD) failed");
+  }
+  return fd;
+};
+var POSIX_SHM_MAX_NAME_LEN = 30;
+var toPosixSharedMemoryName = (name) => {
+  if (name.length === 0) {
+    throw new TypeError("shared memory name must be non-empty");
+  }
+  if (name.includes("\x00")) {
+    throw new TypeError("shared memory name must not contain NUL bytes");
+  }
+  const out = name.startsWith("/") ? name : `/${name}`;
+  if (out.length < 2 || out.slice(1).includes("/")) {
+    throw new TypeError("POSIX shared memory name must not contain path separators");
+  }
+  if (out.length > POSIX_SHM_MAX_NAME_LEN + 1) {
+    throw new TypeError(`POSIX shared memory name must be at most ${POSIX_SHM_MAX_NAME_LEN} characters (macOS limit); got ${out.length - 1}`);
+  }
+  return out;
+};
+var detectPosixPlatform = () => {
+  const denoOs = globalThis.Deno?.build?.os;
+  if (denoOs === "darwin" || denoOs === "linux")
+    return denoOs;
+  const processPlatform = globalThis.process?.platform;
+  if (processPlatform === "darwin" || processPlatform === "linux") {
+    return processPlatform;
+  }
+  throw new Error("shared memory connections support Linux and macOS only");
+};
+var getPosixLibcPath = (platform = detectPosixPlatform()) => platform === "darwin" ? DARWIN_LIBSYSTEM : LINUX_LIBC_SO;
+var makeDarwinSharedMemoryName = (_name, runtime) => {
+  const processId = globalThis.process?.pid ?? globalThis.Deno?.pid ?? 0;
+  const runtimeTag = runtime.slice(0, 1) || "x";
+  const pidTag = Math.abs(processId).toString(36).slice(-5);
+  const timeTag = Date.now().toString(36).slice(-6);
+  const nonce = Math.random().toString(36).slice(2, 6);
+  return `/knit_${runtimeTag}_${pidTag}_${timeTag}_${nonce}`;
+};
+
+// src/connections/package-assets.ts
+import { existsSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var safeExists = (path) => {
+  try {
+    return existsSync(path);
+  } catch {
+    return false;
+  }
+};
+var safeIsDirectory = (path) => {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+};
+var moduleDirectory = (moduleUrl) => {
+  const path = fileURLToPath(moduleUrl);
+  return safeIsDirectory(path) ? path : dirname(path);
+};
+var isKnittingPackageRoot = (dir) => safeExists(join(dir, "package.json")) && (safeExists(join(dir, "prebuilds")) || safeExists(join(dir, "src")) || safeExists(join(dir, "build")));
+var cachedPackageRoot;
+var findKnittingPackageRoot = (moduleUrl = import.meta.url) => {
+  if (cachedPackageRoot !== undefined)
+    return cachedPackageRoot;
+  let current = moduleDirectory(moduleUrl);
+  while (true) {
+    if (isKnittingPackageRoot(current)) {
+      cachedPackageRoot = current;
+      return current;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      throw new Error(`Could not locate knitting package root from ${moduleUrl}`);
+    }
+    current = parent;
+  }
+};
+var resolveKnittingPackageAsset = (...segments) => join(findKnittingPackageRoot(), ...segments);
+
+// src/connections/windows.ts
+var WINDOWS_CREATE_MODE_CREATE = 1;
+var WINDOWS_CREATE_MODE_OPEN = 2;
+var WINDOWS_MAPPING_RECORD_BYTES = 32;
+var POINTER_OFFSET = 0;
+var HANDLE_OFFSET = 8;
+var SIZE_OFFSET = 16;
+var BASE_ADDRESS_MOD_64_OFFSET = 24;
+var FFIType = {
+  i32: 5,
+  u32: 6,
+  i64: 7,
+  ptr: 12
+};
+var anonymousNameCounter = 0;
+var getDeno = () => {
+  const deno = globalThis.Deno;
+  if (deno === undefined) {
+    throw new Error("Deno Windows shared memory primitives can only run in Deno");
+  }
+  return deno;
+};
+var 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;
+};
+var isWindowsRuntime = () => {
+  const denoOs = globalThis.Deno?.build?.os;
+  if (denoOs !== undefined)
+    return denoOs === "windows";
+  const processPlatform = globalThis.process?.platform;
+  return processPlatform === "win32";
+};
+var 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");
+};
+var windowsSharedMemoryPrebuildPath = () => resolveKnittingPackageAsset("prebuilds", `win32-${windowsArch()}`, "knitting_windows_shared_memory.dll");
+var 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}`;
+};
+var 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)
+  };
+};
+var 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;
+};
+var 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)
+  };
+};
+var fdFromHandle = (handle) => handle <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(handle) : 0;
+var checkWindowsResult = (result, message) => {
+  if (result !== 0) {
+    throw new Error(`${message} failed with Windows error ${result}`);
+  }
+};
+var createRecord = () => new Uint8Array(WINDOWS_MAPPING_RECORD_BYTES);
+var 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"
+  }
+});
+var 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
+  }
+});
+var closeWindowsMapping = (record, closeSharedMemory) => {
+  let closed = false;
+  return () => {
+    if (closed)
+      return;
+    closed = true;
+    checkWindowsResult(closeSharedMemory(record), "knitting_windows_close_shared_memory");
+  };
+};
+var 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)
+  };
+};
+var 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)
+  };
+};
+var 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);
+};
+var 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);
+};
+var createDenoWindowsConnectionPrimitives = (lib = openDenoWindowsSharedMemoryLibrary()) => ({
+  runtime: "deno",
+  createSharedMemory: (options) => createDenoWindowsSharedMemory(options, lib),
+  mapSharedMemory: (options) => mapDenoWindowsSharedMemory(options, lib)
+});
+var 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);
+};
+var 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);
+};
+var createBunWindowsConnectionPrimitives = (lib = openBunWindowsSharedMemoryLibrary()) => ({
+  runtime: "bun",
+  createSharedMemory: (options) => createBunWindowsSharedMemory(options, lib),
+  mapSharedMemory: (options) => mapBunWindowsSharedMemory(options, lib)
+});
+
+// src/connections/bun.ts
+var FFIType2 = {
+  i32: 5,
+  i64: 7,
+  u32: 6,
+  usize: 8,
+  ptr: 12
+};
+var getBunFFI2 = () => {
+  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;
+};
+var openBunLibc = () => getBunFFI2().dlopen(getPosixLibcPath(), {
+  ...getBunCreateSymbols(),
+  ftruncate: {
+    args: [FFIType2.i32, FFIType2.i64],
+    returns: FFIType2.i32
+  },
+  dup: {
+    args: [FFIType2.i32],
+    returns: FFIType2.i32
+  },
+  fcntl: {
+    args: [FFIType2.i32, FFIType2.i32, FFIType2.i32],
+    returns: FFIType2.i32
+  },
+  mmap: {
+    args: [
+      FFIType2.ptr,
+      FFIType2.usize,
+      FFIType2.i32,
+      FFIType2.i32,
+      FFIType2.i32,
+      FFIType2.i64
+    ],
+    returns: FFIType2.ptr
+  },
+  munmap: {
+    args: [FFIType2.ptr, FFIType2.usize],
+    returns: FFIType2.i32
+  },
+  close: {
+    args: [FFIType2.i32],
+    returns: FFIType2.i32
+  }
+});
+var getBunCreateSymbols = (platform = detectPosixPlatform()) => platform === "darwin" ? {
+  shm_open: {
+    args: [FFIType2.ptr, FFIType2.i32, FFIType2.u32],
+    returns: FFIType2.i32
+  },
+  shm_unlink: {
+    args: [FFIType2.ptr],
+    returns: FFIType2.i32
+  }
+} : {
+  memfd_create: {
+    args: [FFIType2.ptr, FFIType2.u32],
+    returns: FFIType2.i32
+  },
+  shm_open: {
+    args: [FFIType2.ptr, FFIType2.i32, FFIType2.u32],
+    returns: FFIType2.i32
+  },
+  shm_unlink: {
+    args: [FFIType2.ptr],
+    returns: FFIType2.i32
+  }
+};
+var checkResult = (result, message) => {
+  if (result < 0)
+    throw new Error(message);
+  return result;
+};
+var isBunMmapFailed = (pointer) => !pointer || pointer < 0 || pointer >= Number.MAX_SAFE_INTEGER;
+var createBunSharedMemoryFd = (name, platform, libc) => {
+  if (platform === "darwin") {
+    const shmOpen = libc.symbols.shm_open;
+    const shmUnlink = libc.symbols.shm_unlink;
+    if (shmOpen === undefined || shmUnlink === undefined) {
+      throw new Error("shm_open symbols are not available");
+    }
+    const shmName = encodeCString(makeDarwinSharedMemoryName(name, "bun"));
+    const fd2 = checkResult(shmOpen(shmName, O_RDWR | DARWIN_O_CREAT | DARWIN_O_EXCL, DARWIN_SHM_MODE), "shm_open failed");
+    shmUnlink(shmName);
+    try {
+      return setCloseOnExec(libc, fd2);
+    } catch (error) {
+      libc.symbols.close(fd2);
+      throw error;
+    }
+  }
+  const memfdCreate = libc.symbols.memfd_create;
+  if (memfdCreate === undefined) {
+    throw new Error("memfd_create symbol is not available");
+  }
+  const fd = checkResult(memfdCreate(encodeCString(name), 0), "memfd_create failed");
+  try {
+    return setCloseOnExec(libc, fd);
+  } catch (error) {
+    libc.symbols.close(fd);
+    throw error;
+  }
+};
+var createNamedBunSharedMemoryFd = (name, mode, platform, libc) => {
+  const shmOpen = libc.symbols.shm_open;
+  if (shmOpen === undefined) {
+    throw new Error("shm_open symbol is not available");
+  }
+  const createFlags = platform === "darwin" ? DARWIN_O_CREAT : LINUX_O_CREAT;
+  const exclusiveFlags = platform === "darwin" ? DARWIN_O_EXCL : LINUX_O_EXCL;
+  const flags = mode === "create" ? O_RDWR | createFlags | exclusiveFlags : O_RDWR;
+  const fd = checkResult(shmOpen(encodeCString(toPosixSharedMemoryName(name)), flags, platform === "darwin" ? DARWIN_SHM_MODE : POSIX_SHM_MODE), "shm_open failed");
+  try {
+    return setCloseOnExec(libc, fd);
+  } catch (error) {
+    libc.symbols.close(fd);
+    throw error;
+  }
+};
+var mapBunSharedMemory = (options, libc = openBunLibc()) => {
+  const sourceFd = options.name === undefined ? expectFd(options.fd) : -1;
+  const size = expectPositiveSize(options.size);
+  let fd = sourceFd;
+  if (options.name !== undefined) {
+    fd = createNamedBunSharedMemoryFd(options.name, "open", detectPosixPlatform(), libc);
+  } else if (options.duplicateFd !== false) {
+    fd = checkResult(libc.symbols.dup(sourceFd), "dup(fd) failed");
+    try {
+      setCloseOnExec(libc, fd);
+    } catch (error) {
+      libc.symbols.close(fd);
+      throw error;
+    }
+  }
+  const pointer = libc.symbols.mmap(null, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0n);
+  if (isBunMmapFailed(pointer)) {
+    if (options.duplicateFd !== false)
+      libc.symbols.close(fd);
+    throw new Error("mmap failed");
+  }
+  const arrayBuffer = getBunFFI2().toArrayBuffer(pointer, 0, size);
+  return {
+    runtime: "bun",
+    fd,
+    name: options.name,
+    size,
+    byteLength: arrayBuffer.byteLength,
+    buffer: arrayBuffer,
+    kind: "external-array-buffer",
+    arrayBuffer,
+    unsafePointer: pointer,
+    close: () => {
+      libc.symbols.munmap(pointer, size);
+      libc.symbols.close(fd);
+    }
+  };
+};
+var createBunSharedMemory = (options, libc = openBunLibc()) => {
+  const size = expectPositiveSize(readCreateSize(options));
+  const mode = readCreateMode(options);
+  const name = mode === "anonymous" ? readCreateName(options, "knitting_shared_memory") : readRequiredCreateName(options);
+  const platform = detectPosixPlatform();
+  const fd = mode === "anonymous" ? createBunSharedMemoryFd(name, platform, libc) : createNamedBunSharedMemoryFd(name, mode, platform, libc);
+  try {
+    if (mode !== "open") {
+      checkResult(libc.symbols.ftruncate(fd, BigInt(size)), "ftruncate failed");
+    }
+    const mapping = mapBunSharedMemory({ fd, size, duplicateFd: false }, libc);
+    if (mode !== "anonymous") {
+      return { ...mapping, name };
+    }
+    return mapping;
+  } catch (error) {
+    libc.symbols.close(fd);
+    throw error;
+  }
+};
+var unlinkBunSharedMemory = (name, libc = openBunLibc()) => {
+  const shmUnlink = libc.symbols.shm_unlink;
+  if (shmUnlink === undefined) {
+    throw new Error("shm_unlink symbol is not available");
+  }
+  return shmUnlink(encodeCString(toPosixSharedMemoryName(name))) === 0;
+};
+var createBunPosixConnectionPrimitives = (libc = openBunLibc()) => ({
+  runtime: "bun",
+  createSharedMemory: (options) => createBunSharedMemory(options, libc),
+  mapSharedMemory: (options) => mapBunSharedMemory(options, libc),
+  unlinkSharedMemory: (name) => unlinkBunSharedMemory(name, libc)
+});
+var createBunConnectionPrimitives = (libc) => isWindowsRuntime() ? createBunWindowsConnectionPrimitives() : createBunPosixConnectionPrimitives(libc);
+
+// src/connections/deno.ts
+var getDeno2 = () => {
+  const deno = globalThis.Deno;
+  if (deno === undefined) {
+    throw new Error("Deno shared memory primitives can only run in Deno");
+  }
+  return deno;
+};
+var openDenoLibc = () => getDeno2().dlopen(getPosixLibcPath(), {
+  ...getDenoCreateSymbols(),
+  ftruncate: {
+    parameters: ["i32", "i64"],
+    result: "i32"
+  },
+  dup: {
+    parameters: ["i32"],
+    result: "i32"
+  },
+  fcntl: {
+    parameters: ["i32", "i32", "i32"],
+    result: "i32"
+  },
+  mmap: {
+    parameters: ["pointer", "usize", "i32", "i32", "i32", "i64"],
+    result: "pointer"
+  },
+  munmap: {
+    parameters: ["pointer", "usize"],
+    result: "i32"
+  },
+  close: {
+    parameters: ["i32"],
+    result: "i32"
+  }
+});
+var getDenoCreateSymbols = (platform = detectPosixPlatform()) => platform === "darwin" ? {
+  shm_open: {
+    parameters: ["buffer", "i32", "u32"],
+    result: "i32"
+  },
+  shm_unlink: {
+    parameters: ["buffer"],
+    result: "i32"
+  }
+} : {
+  memfd_create: {
+    parameters: ["buffer", "u32"],
+    result: "i32"
+  },
+  shm_open: {
+    parameters: ["buffer", "i32", "u32"],
+    result: "i32"
+  },
+  shm_unlink: {
+    parameters: ["buffer"],
+    result: "i32"
+  }
+};
+var checkResult2 = (result, message) => {
+  if (result < 0)
+    throw new Error(message);
+  return result;
+};
+var isDenoMmapFailed = (pointer) => {
+  if (pointer === null)
+    return true;
+  const value = getDeno2().UnsafePointer?.value(pointer);
+  return value === -1n || value === BigInt.asUintN(64, -1n);
+};
+var createDenoSharedMemoryFd = (name, platform, libc) => {
+  if (platform === "darwin") {
+    const shmOpen = libc.symbols.shm_open;
+    const shmUnlink = libc.symbols.shm_unlink;
+    if (shmOpen === undefined || shmUnlink === undefined) {
+      throw new Error("shm_open symbols are not available");
+    }
+    const shmName = encodeCString(makeDarwinSharedMemoryName(name, "deno"));
+    const fd2 = checkResult2(shmOpen(shmName, O_RDWR | DARWIN_O_CREAT | DARWIN_O_EXCL, DARWIN_SHM_MODE), "shm_open failed");
+    shmUnlink(shmName);
+    try {
+      return setCloseOnExec(libc, fd2);
+    } catch (error) {
+      libc.symbols.close(fd2);
+      throw error;
+    }
+  }
+  const memfdCreate = libc.symbols.memfd_create;
+  if (memfdCreate === undefined) {
+    throw new Error("memfd_create symbol is not available");
+  }
+  const fd = checkResult2(memfdCreate(encodeCString(name), 0), "memfd_create failed");
+  try {
+    return setCloseOnExec(libc, fd);
+  } catch (error) {
+    libc.symbols.close(fd);
+    throw error;
+  }
+};
+var createNamedDenoSharedMemoryFd = (name, mode, platform, libc) => {
+  const shmOpen = libc.symbols.shm_open;
+  if (shmOpen === undefined) {
+    throw new Error("shm_open symbol is not available");
+  }
+  const createFlags = platform === "darwin" ? DARWIN_O_CREAT : LINUX_O_CREAT;
+  const exclusiveFlags = platform === "darwin" ? DARWIN_O_EXCL : LINUX_O_EXCL;
+  const flags = mode === "create" ? O_RDWR | createFlags | exclusiveFlags : O_RDWR;
+  const fd = checkResult2(shmOpen(encodeCString(toPosixSharedMemoryName(name)), flags, platform === "darwin" ? DARWIN_SHM_MODE : POSIX_SHM_MODE), "shm_open failed");
+  try {
+    return setCloseOnExec(libc, fd);
+  } catch (error) {
+    libc.symbols.close(fd);
+    throw error;
+  }
+};
+var mapDenoSharedMemory = (options, libc = openDenoLibc()) => {
+  const sourceFd = options.name === undefined ? expectFd(options.fd) : -1;
+  const size = expectPositiveSize(options.size);
+  let fd = sourceFd;
+  if (options.name !== undefined) {
+    fd = createNamedDenoSharedMemoryFd(options.name, "open", detectPosixPlatform(), libc);
+  } else if (options.duplicateFd !== false) {
+    fd = checkResult2(libc.symbols.dup(sourceFd), "dup(fd) failed");
+    try {
+      setCloseOnExec(libc, fd);
+    } catch (error) {
+      libc.symbols.close(fd);
+      throw error;
+    }
+  }
+  const pointer = libc.symbols.mmap(null, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0n);
+  if (isDenoMmapFailed(pointer)) {
+    if (options.duplicateFd !== false)
+      libc.symbols.close(fd);
+    throw new Error("mmap failed");
+  }
+  const arrayBuffer = new (getDeno2()).UnsafePointerView(pointer).getArrayBuffer(size);
+  return {
+    runtime: "deno",
+    fd,
+    name: options.name,
+    size,
+    byteLength: arrayBuffer.byteLength,
+    buffer: arrayBuffer,
+    kind: "external-array-buffer",
+    arrayBuffer,
+    unsafePointer: pointer,
+    close: () => {
+      libc.symbols.munmap(pointer, size);
+      libc.symbols.close(fd);
+    }
+  };
+};
+var createDenoSharedMemory = (options, libc = openDenoLibc()) => {
+  const size = expectPositiveSize(readCreateSize(options));
+  const mode = readCreateMode(options);
+  const name = mode === "anonymous" ? readCreateName(options, "knitting_shared_memory") : readRequiredCreateName(options);
+  const platform = detectPosixPlatform();
+  const fd = mode === "anonymous" ? createDenoSharedMemoryFd(name, platform, libc) : createNamedDenoSharedMemoryFd(name, mode, platform, libc);
+  try {
+    if (mode !== "open") {
+      checkResult2(libc.symbols.ftruncate(fd, BigInt(size)), "ftruncate failed");
+    }
+    const mapping = mapDenoSharedMemory({ fd, size, duplicateFd: false }, libc);
+    if (mode !== "anonymous") {
+      return { ...mapping, name };
+    }
+    return mapping;
+  } catch (error) {
+    libc.symbols.close(fd);
+    throw error;
+  }
+};
+var unlinkDenoSharedMemory = (name, libc = openDenoLibc()) => {
+  const shmUnlink = libc.symbols.shm_unlink;
+  if (shmUnlink === undefined) {
+    throw new Error("shm_unlink symbol is not available");
+  }
+  return shmUnlink(encodeCString(toPosixSharedMemoryName(name))) === 0;
+};
+var createDenoPosixConnectionPrimitives = (libc = openDenoLibc()) => ({
+  runtime: "deno",
+  createSharedMemory: (options) => createDenoSharedMemory(options, libc),
+  mapSharedMemory: (options) => mapDenoSharedMemory(options, libc),
+  unlinkSharedMemory: (name) => unlinkDenoSharedMemory(name, libc)
+});
+var createDenoConnectionPrimitives = (libc) => isWindowsRuntime() ? createDenoWindowsConnectionPrimitives() : createDenoPosixConnectionPrimitives(libc);
+
+// src/connections/node-addons.ts
+var readNodePlatformInfo = () => {
+  const processLike = globalThis.process;
+  if (typeof processLike?.platform !== "string" || typeof processLike.arch !== "string") {
+    return;
+  }
+  return {
+    arch: processLike.arch,
+    modules: processLike.versions?.modules,
+    platform: processLike.platform
+  };
+};
+var nodeNativeAddonSpecifiers = (name) => {
+  const platformInfo = readNodePlatformInfo();
+  const fallback = resolveKnittingPackageAsset("build", "Release", `${name}.node`);
+  if (platformInfo === undefined)
+    return [fallback];
+  const nodeModuleAbi = platformInfo.modules;
+  if (typeof nodeModuleAbi === "string" && nodeModuleAbi.length > 0) {
+    return [
+      resolveKnittingPackageAsset("prebuilds", `${platformInfo.platform}-${platformInfo.arch}-node-${nodeModuleAbi}`, `${name}.node`),
+      fallback
+    ];
+  }
+  return [
+    resolveKnittingPackageAsset("prebuilds", `${platformInfo.platform}-${platformInfo.arch}`, `${name}.node`),
+    fallback
+  ];
+};
+var loadNodeNativeAddon = (require2, name, specifier) => {
+  if (specifier !== undefined)
+    return require2(specifier);
+  const errors = [];
+  for (const candidate of nodeNativeAddonSpecifiers(name)) {
+    try {
+      return require2(candidate);
+    } catch (error) {
+      errors.push(`${candidate}: ${String(error)}`);
+    }
+  }
+  throw new Error(`Could not load native addon ${name}. Tried:
+${errors.join(`
+`)}`);
+};
+
+// src/connections/process-shared-buffer.ts
+var PROCESS_SHARED_BUFFER_BRAND = Symbol.for("knitting.processSharedBuffer");
+var PROCESS_SHARED_BUFFER_NUMERIC_TRANSFER = Symbol.for("knitting.processSharedBuffer.numericTransfer");
+var EXTERNAL_PAYLOAD_BRAND = Symbol.for("knitting.payloadCodec");
+var PROCESS_SHARED_BUFFER_CODEC_ID = "knitting.processSharedBuffer";
+var isRecord2 = (value) => typeof value === "object" && value !== null;
+var NUMERIC_SENTINEL = 4294967295;
+var RUNTIME_NODE = 1;
+var RUNTIME_DENO = 2;
+var RUNTIME_BUN = 3;
+var KIND_SHARED_ARRAY_BUFFER = 1;
+var KIND_EXTERNAL_ARRAY_BUFFER = 2;
+var decodeRuntime = (value) => {
+  switch (value) {
+    case RUNTIME_NODE:
+      return "node";
+    case RUNTIME_DENO:
+      return "deno";
+    case RUNTIME_BUN:
+      return "bun";
+    default:
+      return;
+  }
+};
+var decodeKind = (value) => {
+  switch (value) {
+    case KIND_SHARED_ARRAY_BUFFER:
+      return "shared-array-buffer";
+    case KIND_EXTERNAL_ARRAY_BUFFER:
+      return "external-array-buffer";
+    default:
+      return;
+  }
+};
+var defaultPrimitives;
+var fromDefaultNodeNativeMapping = (mapped) => {
+  const mapping = {
+    runtime: "node",
+    fd: mapped.fd,
+    size: mapped.size,
+    byteLength: mapped.sab.byteLength,
+    buffer: mapped.sab,
+    kind: "shared-array-buffer",
+    sab: mapped.sab,
+    baseAddressMod64: mapped.baseAddressMod64
+  };
+  if (mapped.name !== undefined && mapped.name.length > 0) {
+    mapping.name = mapped.name;
+  }
+  return mapping;
+};
+var createDefaultNodePrimitives = () => {
+  const nodeModule = getNodeBuiltinModule("node:module");
+  if (nodeModule === undefined) {
+    throw new TypeError("ProcessSharedBuffer needs connection primitives in this runtime");
+  }
+  const require2 = nodeModule.createRequire(import.meta.url);
+  const addon = loadNodeNativeAddon(require2, "knitting_shared_memory");
+  return {
+    createSharedMemory: (options) => {
+      const size = expectPositiveSize(readCreateSize(options));
+      const mode = readCreateMode(options);
+      const name = mode === "anonymous" ? readCreateName(options, "knitting_shared_memory") : readRequiredCreateName(options);
+      return fromDefaultNodeNativeMapping(addon.createSharedMemory(size, name, mode));
+    },
+    mapSharedMemory: (options) => {
+      const fd = expectFd(options.fd);
+      const size = expectPositiveSize(options.size);
+      return fromDefaultNodeNativeMapping(addon.mapSharedMemory(fd, size, options.name));
+    }
+  };
+};
+var createDefaultPrimitives = () => {
+  if (RUNTIME === "bun")
+    return createBunConnectionPrimitives();
+  if (RUNTIME === "deno")
+    return createDenoConnectionPrimitives();
+  return createDefaultNodePrimitives();
+};
+var setDefaultProcessSharedBufferPrimitives = (primitives) => {
+  defaultPrimitives = primitives;
+};
+var getDefaultProcessSharedBufferPrimitives = () => {
+  defaultPrimitives ??= createDefaultPrimitives();
+  return defaultPrimitives;
+};
+var expectNonNegativeInteger = (value, label) => {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new RangeError(`${label} must be a non-negative integer`);
+  }
+  return value;
+};
+var readOptionalNonNegativeInteger = (value, label) => {
+  if (value === undefined)
+    return;
+  if (typeof value !== "number") {
+    throw new TypeError(`${label} must be a number`);
+  }
+  return expectNonNegativeInteger(value, label);
+};
+var expectRange = (byteOffset, byteLength, availableByteLength) => {
+  expectNonNegativeInteger(byteOffset, "process shared buffer byteOffset");
+  if (byteOffset > availableByteLength) {
+    throw new RangeError("process shared buffer byteOffset is out of bounds");
+  }
+  expectNonNegativeInteger(byteLength, "process shared buffer byteLength");
+  if (byteLength > availableByteLength - byteOffset) {
+    throw new RangeError("process shared buffer byteLength is out of bounds");
+  }
+};
+
+class ProcessSharedBuffer {
+  [PROCESS_SHARED_BUFFER_BRAND] = true;
+  [EXTERNAL_PAYLOAD_BRAND] = PROCESS_SHARED_BUFFER_CODEC_ID;
+  descriptor;
+  byteOffset;
+  byteLength;
+  constructor(descriptor, range = {}) {
+    const byteOffset = range.byteOffset ?? 0;
+    const byteLength = range.byteLength ?? descriptor.byteLength - byteOffset;
+    expectRange(byteOffset, byteLength, descriptor.byteLength);
+    this.descriptor = descriptor;
+    this.byteOffset = byteOffset;
+    this.byteLength = byteLength;
+  }
+  static create(options, creator = getDefaultProcessSharedBufferPrimitives()) {
+    return ProcessSharedBuffer.fromMapping(creator.createSharedMemory(options));
+  }
+  static fromMapping(mapping) {
+    return new ProcessSharedBuffer(FileDescriptor.fromMapping(mapping));
+  }
+  static fromDescriptor(descriptor, range = {}) {
+    return new ProcessSharedBuffer(descriptor, range);
+  }
+  static fromMetadata(metadata) {
+    const parsed = parseProcessSharedBufferMetadata(metadata);
+    return new ProcessSharedBuffer(FileDescriptor.fromMetadata(parsed.descriptor), {
+      byteOffset: parsed.byteOffset,
+      byteLength: parsed.byteLength
+    });
+  }
+  static parse(serialized) {
+    return ProcessSharedBuffer.fromMetadata(serialized);
+  }
+  static [PROCESS_SHARED_BUFFER_NUMERIC_TRANSFER](metadata) {
+    const [
+      fd,
+      size,
+      descriptorByteLength,
+      byteOffset,
+      byteLength,
+      runtime,
+      kind,
+      baseAddressMod64
+    ] = metadata;
+    return new ProcessSharedBuffer(new FileDescriptor({
+      version: 1,
+      fd,
+      size,
+      byteLength: descriptorByteLength,
+      runtime: decodeRuntime(runtime),
+      kind: decodeKind(kind),
+      baseAddressMod64: baseAddressMod64 === NUMERIC_SENTINEL ? undefined : baseAddressMod64
+    }), {
+      byteOffset,
+      byteLength
+    });
+  }
+  get fd() {
+    return this.descriptor.fd;
+  }
+  get size() {
+    return this.descriptor.size;
+  }
+  subbuffer(byteOffset, byteLength) {
+    const relativeByteOffset = expectNonNegativeInteger(byteOffset, "process shared buffer subbuffer byteOffset");
+    const relativeByteLength = byteLength === undefined ? this.byteLength - relativeByteOffset : expectNonNegativeInteger(byteLength, "process shared buffer subbuffer byteLength");
+    expectRange(relativeByteOffset, relativeByteLength, this.byteLength);
+    return new ProcessSharedBuffer(this.descriptor, {
+      byteOffset: this.byteOffset + relativeByteOffset,
+      byteLength: relativeByteLength
+    });
+  }
+  getSharedArrayBuffer(mapper) {
+    return this.descriptor.getSAB(mapper ?? (this.descriptor.mapping?.sab === undefined ? getDefaultProcessSharedBufferPrimitives() : undefined));
+  }
+  getSAB(mapper) {
+    return this.getSharedArrayBuffer(mapper);
+  }
+  getBuffer(mapper) {
+    return this.descriptor.getBuffer(mapper ?? (this.descriptor.mapping?.buffer === undefined ? getDefaultProcessSharedBufferPrimitives() : undefined));
+  }
+  getRegion(mapper) {
+    return {
+      sab: this.getBuffer(mapper),
+      byteOffset: this.byteOffset,
+      byteLength: this.byteLength
+    };
+  }
+  view(constructor, mapper) {
+    const bytesPerElement = constructor.BYTES_PER_ELEMENT;
+    if (this.byteOffset % bytesPerElement !== 0) {
+      throw new RangeError("process shared buffer byteOffset is not aligned for this view");
+    }
+    if (this.byteLength % bytesPerElement !== 0) {
+      throw new RangeError("process shared buffer byteLength is not aligned for this view");
+    }
+    return new constructor(this.getBuffer(mapper), this.byteOffset, this.byteLength / bytesPerElement);
+  }
+  bytes(mapper) {
+    return this.view(Uint8Array, mapper);
+  }
+  dataView(mapper) {
+    return new DataView(this.getBuffer(mapper), this.byteOffset, this.byteLength);
+  }
+  toMetadata() {
+    return {
+      version: 1,
+      descriptor: this.descriptor.toMetadata(),
+      byteOffset: this.byteOffset,
+      byteLength: this.byteLength
+    };
+  }
+  toJSON() {
+    return this.toMetadata();
+  }
+  stringify() {
+    return JSON.stringify(this.toMetadata());
+  }
+  stringifyMetadata() {
+    return this.stringify();
+  }
+  toString() {
+    return this.stringify();
+  }
+}
+var parseProcessSharedBufferMetadata = (input) => {
+  const value = typeof input === "string" ? JSON.parse(input) : input;
+  if (!isRecord2(value)) {
+    throw new TypeError("process shared buffer metadata must be an object");
+  }
+  if (value.version !== 1) {
+    throw new TypeError("unsupported process shared buffer metadata version");
+  }
+  const descriptor = FileDescriptor.fromMetadata(value.descriptor);
+  const byteOffset = readOptionalNonNegativeInteger(value.byteOffset, "process shared buffer byteOffset") ?? 0;
+  const byteLength = readOptionalNonNegativeInteger(value.byteLength, "process shared buffer byteLength") ?? descriptor.byteLength - byteOffset;
+  expectRange(byteOffset, byteLength, descriptor.byteLength);
+  return {
+    version: 1,
+    descriptor: descriptor.toMetadata(),
+    byteOffset,
+    byteLength
+  };
+};
+var processSharedBufferGlobal = globalThis;
+var codecs = processSharedBufferGlobal.__KNITTING_PAYLOAD_CODECS__ ??= Object.create(null);
+codecs[PROCESS_SHARED_BUFFER_CODEC_ID] = {
+  decode: (metadata) => ProcessSharedBuffer.fromMetadata(metadata),
+  decodeNumeric: (metadata) => ProcessSharedBuffer[PROCESS_SHARED_BUFFER_NUMERIC_TRANSFER](metadata)
+};
+export {
+  setDefaultProcessSharedBufferPrimitives,
+  parseProcessSharedBufferMetadata,
+  getDefaultProcessSharedBufferPrimitives,
+  ProcessSharedBuffer,
+  PROCESS_SHARED_BUFFER_BRAND
+};