knitting 0.1.54 → 0.1.55

package/unsafe.js

@@ -1 +1,878 @@
-export { BUFFER_REFERENCE_CODEC_ID, BUFFER_REFERENCE_KIND, BufferReference, BufferReferenceReturn, isBufferReferenceMetadata, } from "./src/connections/buffer-reference.js";
+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/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/common/worker-runtime.ts
+var RUNTIME_PROCESS_WORKER_ENV = "KNITTING_PROCESS_WORKER";
+var RUNTIME_PROCESS_WORKER_BOOT_ENV = "KNITTING_PROCESS_WORKER_BOOT";
+var RUNTIME_PROCESS_WORKER_BOOT_VERSION = 1;
+var RUNTIME_POOL_DEPTH_ENV = "KNITTING_POOL_DEPTH";
+var nodeProcess3 = getNodeProcess();
+var RUNTIME_IS_PROCESS_WORKER = nodeProcess3?.env?.[RUNTIME_PROCESS_WORKER_ENV] === "1";
+var readPoolDepth = () => {
+  const raw = nodeProcess3?.env?.[RUNTIME_POOL_DEPTH_ENV];
+  if (typeof raw !== "string")
+    return 0;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+};
+var RUNTIME_POOL_DEPTH = readPoolDepth();
+var workerThreads = getNodeBuiltinModule("node:worker_threads");
+var isWorkerGlobalScope = () => {
+  const scopeCtor = globalThis.WorkerGlobalScope;
+  if (typeof scopeCtor !== "function")
+    return false;
+  try {
+    return globalThis instanceof scopeCtor;
+  } catch {
+    return false;
+  }
+};
+var RUNTIME_WORKER = workerThreads?.Worker ?? globalThis.Worker;
+var RUNTIME_MESSAGE_CHANNEL = workerThreads?.MessageChannel ?? globalThis.MessageChannel;
+var HAS_NODE_WORKER_THREADS = workerThreads != null;
+var RUNTIME_IS_MAIN_THREAD = RUNTIME_IS_PROCESS_WORKER ? false : workerThreads?.isMainThread ?? !isWorkerGlobalScope();
+var RUNTIME_WORKER_DATA = workerThreads?.workerData;
+var RUNTIME_PARENT_PORT = workerThreads?.parentPort ?? (RUNTIME_IS_PROCESS_WORKER && typeof nodeProcess3?.send === "function" ? {
+  postMessage: (message) => nodeProcess3.send(message)
+} : undefined);
+var createRuntimeMessageChannel = () => {
+  if (typeof RUNTIME_MESSAGE_CHANNEL !== "function") {
+    throw new Error("MessageChannel is not available in this runtime");
+  }
+  return new RUNTIME_MESSAGE_CHANNEL;
+};
+var addRuntimeDataListener = (target, handler) => {
+  if (typeof target.on === "function") {
+    target.on("message", handler);
+    return;
+  }
+  if (typeof target.addEventListener === "function") {
+    target.addEventListener("message", (event) => handler(event?.data));
+    return;
+  }
+  target.onmessage = (event) => handler(event?.data);
+};
+
+// 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/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/node-buffer-pointer.ts
+var cached;
+var loadNodeBufferPointerAddon = (specifier) => {
+  if (specifier === undefined && cached !== undefined)
+    return cached;
+  const nodeModule = getNodeBuiltinModule("node:module");
+  if (nodeModule === undefined) {
+    throw new Error("Node buffer-pointer addon can only be loaded in Node");
+  }
+  const require2 = nodeModule.createRequire(import.meta.url);
+  const addon = loadNodeNativeAddon(require2, "knitting_buffer_pointer", specifier);
+  if (specifier === undefined)
+    cached = addon;
+  return addon;
+};
+
+// src/connections/buffer-reference-native.ts
+var isSharedArrayBufferInstance = (value) => typeof SharedArrayBuffer === "function" && value instanceof SharedArrayBuffer;
+var assertMovableSource = (source) => {
+  const buffer = ArrayBuffer.isView(source) ? source.buffer : source;
+  if (isSharedArrayBufferInstance(buffer)) {
+    throw new TypeError("BufferReference expects ArrayBuffer-backed views; SharedArrayBuffer is already " + "shared and cannot be moved");
+  }
+};
+var readSourceRegion = (source) => {
+  if (ArrayBuffer.isView(source)) {
+    return {
+      buffer: source.buffer,
+      byteOffset: source.byteOffset,
+      byteLength: source.byteLength
+    };
+  }
+  return { buffer: source, byteOffset: 0, byteLength: source.byteLength };
+};
+var detachIntoFixedLength = (buffer) => {
+  const transferable = buffer;
+  if (typeof transferable.transferToFixedLength === "function") {
+    return transferable.transferToFixedLength();
+  }
+  if (typeof transferable.transfer === "function") {
+    return transferable.transfer();
+  }
+  throw new TypeError("BufferReference requires ArrayBuffer.prototype.transfer to move a buffer in this runtime");
+};
+var ffiPinned = new Map;
+var nextFfiToken = 1n;
+var pinTransferred = (buffer) => {
+  const token = nextFfiToken++;
+  ffiPinned.set(token, buffer);
+  return token;
+};
+var pinShared = (sab) => {
+  const token = nextFfiToken++;
+  ffiPinned.set(token, sab);
+  return token;
+};
+var releaseFfi = (token) => {
+  ffiPinned.delete(token);
+};
+var produceSharedFfi = (sab, readPointer) => {
+  const pointer = readPointer(new Uint8Array(sab));
+  const token = pinShared(sab);
+  return { token, pointer, byteOffset: 0, byteLength: sab.byteLength };
+};
+var getDeno = () => {
+  const deno = globalThis.Deno;
+  if (deno?.UnsafePointer === undefined || deno.UnsafePointerView === undefined) {
+    throw new Error("Deno FFI (UnsafePointer) is not available in this runtime");
+  }
+  return deno;
+};
+var getBunFFI = () => {
+  const ffi = globalThis.Bun?.FFI;
+  if (typeof ffi?.ptr !== "function" || typeof ffi?.toArrayBuffer !== "function") {
+    throw new Error("Bun FFI (ptr/toArrayBuffer) is not available in this runtime");
+  }
+  return ffi;
+};
+var produceFfi = (source, readPointer) => {
+  assertMovableSource(source);
+  const { buffer, byteOffset, byteLength } = readSourceRegion(source);
+  const moved = detachIntoFixedLength(buffer);
+  const region = new Uint8Array(moved, byteOffset, byteLength);
+  const pointer = readPointer(region);
+  const token = pinTransferred(moved);
+  return { token, pointer, byteOffset, byteLength };
+};
+var finishAlias = (alias, copy) => {
+  if (copy) {
+    const owned = alias.slice(0);
+    return { buffer: owned, byteOffset: 0, byteLength: owned.byteLength };
+  }
+  return { buffer: alias, byteOffset: 0, byteLength: alias.byteLength };
+};
+var createDenoCapabilities = () => {
+  const deno = getDeno();
+  return {
+    runtime: "deno",
+    supportsOwningAdopt: false,
+    produce: (view) => produceFfi(view, (region) => deno.UnsafePointer.value(deno.UnsafePointer.of(region))),
+    adopt: ({ pointer, byteLength }, opts) => {
+      const alias = denoAlias(deno, pointer, byteLength);
+      return finishAlias(alias, opts?.copy);
+    },
+    release: releaseFfi,
+    supportsSharedAdopt: false,
+    produceShared: (sab) => produceSharedFfi(sab, (region) => deno.UnsafePointer.value(deno.UnsafePointer.of(region))),
+    adoptShared: ({ pointer, byteLength }) => {
+      const alias = denoAlias(deno, pointer, byteLength);
+      return { buffer: alias, byteOffset: 0, byteLength, isShared: false };
+    },
+    releaseShared: releaseFfi
+  };
+};
+var denoAlias = (deno, pointer, byteLength) => {
+  const handle = deno.UnsafePointer.create(pointer);
+  if (handle === null || handle === undefined) {
+    throw new Error("Deno.UnsafePointer.create returned null");
+  }
+  return new deno.UnsafePointerView(handle).getArrayBuffer(byteLength);
+};
+var createBunCapabilities = () => {
+  const ffi = getBunFFI();
+  return {
+    runtime: "bun",
+    supportsOwningAdopt: false,
+    produce: (view) => produceFfi(view, (region) => BigInt(ffi.ptr(region))),
+    adopt: ({ pointer, byteLength }, opts) => {
+      const alias = ffi.toArrayBuffer(Number(pointer), 0, byteLength);
+      return finishAlias(alias, opts?.copy);
+    },
+    release: releaseFfi,
+    supportsSharedAdopt: false,
+    produceShared: (sab) => produceSharedFfi(sab, (region) => BigInt(ffi.ptr(region))),
+    adoptShared: ({ pointer, byteLength }) => {
+      const alias = ffi.toArrayBuffer(Number(pointer), 0, byteLength);
+      return { buffer: alias, byteOffset: 0, byteLength, isShared: false };
+    },
+    releaseShared: releaseFfi
+  };
+};
+var createNodeCapabilities = () => {
+  const addon = loadNodeBufferPointerAddon();
+  const owning = typeof addon.retainBackingStore === "function" && typeof addon.adoptBackingStore === "function" && typeof addon.releaseBackingStore === "function";
+  const sharedCapabilities = {
+    supportsSharedAdopt: false,
+    produceShared: (sab) => produceSharedFfi(sab, (region) => addon.getPointer(region)),
+    adoptShared: ({ pointer, byteLength }) => {
+      const alias = addon.wrapPointer(pointer, byteLength);
+      return { buffer: alias, byteOffset: 0, byteLength, isShared: false };
+    },
+    releaseShared: releaseFfi
+  };
+  if (owning) {
+    return {
+      runtime: "node",
+      supportsOwningAdopt: true,
+      produce: (source) => {
+        assertMovableSource(source);
+        const r = addon.retainBackingStore(source);
+        return {
+          token: r.token,
+          pointer: r.pointer,
+          byteOffset: r.byteOffset,
+          byteLength: r.byteLength
+        };
+      },
+      adopt: ({ token, byteOffset, byteLength }, opts) => {
+        const buffer = addon.adoptBackingStore(token);
+        if (opts?.copy) {
+          const owned = buffer.slice(byteOffset, byteOffset + byteLength);
+          return { buffer: owned, byteOffset: 0, byteLength: owned.byteLength };
+        }
+        return { buffer, byteOffset, byteLength };
+      },
+      release: (token) => void addon.releaseBackingStore(token),
+      ...sharedCapabilities
+    };
+  }
+  return {
+    runtime: "node",
+    supportsOwningAdopt: false,
+    produce: (source) => {
+      assertMovableSource(source);
+      const retained = addon.retainPointer(source);
+      const byteOffset = ArrayBuffer.isView(source) ? source.byteOffset : 0;
+      return {
+        token: retained.token,
+        pointer: retained.pointer,
+        byteOffset,
+        byteLength: retained.byteLength
+      };
+    },
+    adopt: ({ pointer, byteLength }, opts) => {
+      const alias = addon.wrapPointer(pointer, byteLength);
+      return finishAlias(alias, opts?.copy);
+    },
+    release: (token) => void addon.releasePointer(token),
+    ...sharedCapabilities
+  };
+};
+var cached2;
+var getBufferReferenceCapabilities = () => {
+  if (cached2 !== undefined)
+    return cached2;
+  switch (RUNTIME) {
+    case "node":
+      return cached2 = createNodeCapabilities();
+    case "deno":
+      return cached2 = createDenoCapabilities();
+    case "bun":
+      return cached2 = createBunCapabilities();
+    default:
+      throw new Error(`BufferReference cannot run in runtime "${RUNTIME}"`);
+  }
+};
+
+// src/connections/buffer-reference.ts
+var BUFFER_REFERENCE_KIND = "knitting.bufferReference";
+var BufferReferenceReturn = {
+  Copy: "copy",
+  Borrow: "borrow"
+};
+var BUFFER_REFERENCE_NUMERIC_TRANSFER = Symbol.for("knitting.bufferReference.numericTransfer");
+var BUFFER_REFERENCE_RETURN_RELEASE_TOKEN = Symbol.for("knitting.bufferReference.returnReleaseToken");
+var EXTERNAL_PAYLOAD_BRAND = Symbol.for("knitting.payloadCodec");
+var BUFFER_REFERENCE_CODEC_ID = BUFFER_REFERENCE_KIND;
+var BUFFER_REFERENCE_RETURN_RELEASE_MESSAGE_KEY = "__knittingBufferReferenceRelease";
+var getRuntime = () => {
+  if (RUNTIME === "deno" || RUNTIME === "bun" || RUNTIME === "node") {
+    return RUNTIME;
+  }
+  throw new Error(`BufferReference cannot run in runtime "${RUNTIME}"`);
+};
+var getProcessId = () => {
+  const proc = getNodeProcess();
+  if (proc !== undefined && typeof proc.pid === "number")
+    return proc.pid;
+  const deno = globalThis.Deno;
+  if (typeof deno?.pid === "number")
+    return deno.pid;
+  return 0;
+};
+var PROCESS_ORIGIN = `${RUNTIME}:${getProcessId()}`;
+var NUMERIC_WORD_MASK = 0xffffffffn;
+var RUNTIME_NODE = 1;
+var RUNTIME_DENO = 2;
+var RUNTIME_BUN = 3;
+var PAYLOAD_TRANSPORT_FINALIZER = Symbol.for("knitting.payloadCodec.transportFinalizer");
+var currentReturnReleaser;
+var encodeRuntime = (runtime) => {
+  switch (runtime) {
+    case "node":
+      return RUNTIME_NODE;
+    case "deno":
+      return RUNTIME_DENO;
+    case "bun":
+      return RUNTIME_BUN;
+  }
+};
+var decodeRuntime = (runtime) => {
+  switch (runtime) {
+    case RUNTIME_NODE:
+      return "node";
+    case RUNTIME_DENO:
+      return "deno";
+    case RUNTIME_BUN:
+      return "bun";
+    default:
+      return;
+  }
+};
+var splitU64 = (value) => [
+  Number(value & NUMERIC_WORD_MASK) >>> 0,
+  Number(value >> 32n & NUMERIC_WORD_MASK) >>> 0
+];
+var joinU64 = (low, high) => BigInt(high >>> 0) << 32n | BigInt(low >>> 0);
+var readOriginPid = (origin) => {
+  const separator = origin.indexOf(":");
+  if (separator < 0)
+    return;
+  const pid = Number(origin.slice(separator + 1));
+  return Number.isInteger(pid) && pid >= 0 && pid <= 4294967295 ? pid >>> 0 : undefined;
+};
+var numericMetadataToMetadata = (words) => {
+  const runtime = decodeRuntime(words[6] ?? 0);
+  if (runtime === undefined) {
+    throw new TypeError("Invalid BufferReference numeric runtime");
+  }
+  const originPid = words[7];
+  if (originPid === undefined || !Number.isInteger(originPid) || originPid < 0) {
+    throw new TypeError("Invalid BufferReference numeric origin");
+  }
+  return {
+    kind: BUFFER_REFERENCE_KIND,
+    origin: `${runtime}:${originPid >>> 0}`,
+    runtime,
+    pointer: joinU64(words[0] ?? 0, words[1] ?? 0).toString(),
+    token: joinU64(words[2] ?? 0, words[3] ?? 0).toString(),
+    byteOffset: words[4] ?? 0,
+    byteLength: words[5] ?? 0
+  };
+};
+var withBufferReferenceReturnReleaser = (releaser, run) => {
+  if (releaser === undefined)
+    return run();
+  const previous = currentReturnReleaser;
+  currentReturnReleaser = releaser;
+  try {
+    return run();
+  } finally {
+    currentReturnReleaser = previous;
+  }
+};
+var createBufferReferenceReturnReleaseMessage = (token) => ({
+  [BUFFER_REFERENCE_RETURN_RELEASE_MESSAGE_KEY]: token.toString()
+});
+var readBufferReferenceReturnReleaseMessage = (value) => {
+  if (value === null || typeof value !== "object")
+    return;
+  const raw = value[BUFFER_REFERENCE_RETURN_RELEASE_MESSAGE_KEY];
+  if (typeof raw !== "string")
+    return;
+  try {
+    const token = BigInt(raw);
+    return token > 0n ? token : undefined;
+  } catch {
+    return;
+  }
+};
+var producerFinalizer = typeof FinalizationRegistry === "function" ? new FinalizationRegistry(({ token, release }) => {
+  try {
+    release(token);
+  } catch {}
+}) : undefined;
+var borrowedReturnFinalizer = typeof FinalizationRegistry === "function" ? new FinalizationRegistry(({ token, release }) => {
+  try {
+    release(token);
+  } catch {}
+}) : undefined;
+var isSharedArrayBufferInstance2 = (value) => typeof SharedArrayBuffer === "function" && value instanceof SharedArrayBuffer;
+var assertMovableSource2 = (source) => {
+  if (isSharedArrayBufferInstance2(source)) {
+    throw new TypeError("BufferReference expects ArrayBuffer memory; SharedArrayBuffer is already shared and cannot be detached");
+  }
+  if (ArrayBuffer.isView(source)) {
+    if (isSharedArrayBufferInstance2(source.buffer)) {
+      throw new TypeError("BufferReference expects ArrayBuffer-backed views; SharedArrayBuffer is already shared and cannot be detached");
+    }
+    return;
+  }
+  if (!(source instanceof ArrayBuffer)) {
+    throw new TypeError("BufferReference expects an ArrayBuffer or typed-array view");
+  }
+};
+var isDetached = (buffer) => buffer.detached === true || buffer.byteLength === 0;
+var detachArrayBufferBestEffort = (runtime, buffer) => {
+  if (isDetached(buffer))
+    return true;
+  if (runtime === "node") {
+    try {
+      return loadNodeBufferPointerAddon().detachArrayBuffer(buffer);
+    } catch {}
+  }
+  const transferable = buffer;
+  try {
+    if (typeof transferable.transferToFixedLength === "function") {
+      transferable.transferToFixedLength(0);
+      return isDetached(buffer);
+    }
+    if (typeof transferable.transfer === "function") {
+      transferable.transfer(0);
+      return isDetached(buffer);
+    }
+  } catch {}
+  try {
+    if (typeof structuredClone === "function") {
+      structuredClone(buffer, { transfer: [buffer] });
+      return isDetached(buffer);
+    }
+  } catch {}
+  return false;
+};
+var isBufferReferenceMetadata = (value) => {
+  if (value === null || typeof value !== "object")
+    return false;
+  const meta = value;
+  return meta.kind === BUFFER_REFERENCE_KIND && typeof meta.origin === "string" && (meta.runtime === "node" || meta.runtime === "deno" || meta.runtime === "bun") && typeof meta.pointer === "string" && typeof meta.token === "string" && typeof meta.byteOffset === "number" && Number.isInteger(meta.byteOffset) && meta.byteOffset >= 0 && typeof meta.byteLength === "number" && Number.isInteger(meta.byteLength) && meta.byteLength >= 0;
+};
+
+class BufferReference {
+  [EXTERNAL_PAYLOAD_BRAND] = BUFFER_REFERENCE_CODEC_ID;
+  runtime;
+  origin;
+  pointer;
+  byteOffset;
+  byteLength;
+  #token;
+  #isProducer;
+  #finalizerToken;
+  #materializedRegions;
+  #owned;
+  #borrowedReturnReleaser;
+  #borrowedReturnFinalizerToken;
+  #transportRefs = 0;
+  #released = false;
+  constructor(source, meta) {
+    if (meta !== undefined) {
+      this.runtime = meta.runtime;
+      this.origin = meta.origin;
+      this.pointer = BigInt(meta.pointer);
+      this.byteOffset = meta.byteOffset;
+      this.byteLength = meta.byteLength;
+      this.#token = BigInt(meta.token);
+      this.#isProducer = false;
+      return;
+    }
+    if (source === undefined) {
+      throw new TypeError("BufferReference requires a buffer source");
+    }
+    assertMovableSource2(source);
+    const caps = getBufferReferenceCapabilities();
+    const produced = caps.produce(source);
+    this.runtime = getRuntime();
+    this.origin = PROCESS_ORIGIN;
+    this.pointer = produced.pointer;
+    this.byteOffset = produced.byteOffset;
+    this.byteLength = produced.byteLength;
+    this.#token = produced.token;
+    this.#isProducer = true;
+    this.#finalizerToken = {};
+    producerFinalizer?.register(this, { token: this.#token, release: caps.release }, this.#finalizerToken);
+  }
+  static fromMetadata(meta) {
+    if (!isBufferReferenceMetadata(meta)) {
+      throw new TypeError("Invalid BufferReferenceMetadata");
+    }
+    return new BufferReference(undefined, meta);
+  }
+  toMetadata() {
+    this.#assertActive();
+    return {
+      kind: BUFFER_REFERENCE_KIND,
+      origin: this.origin,
+      runtime: this.runtime,
+      pointer: this.pointer.toString(),
+      token: this.#token.toString(),
+      byteOffset: this.byteOffset,
+      byteLength: this.byteLength
+    };
+  }
+  [BUFFER_REFERENCE_NUMERIC_TRANSFER]() {
+    this.#assertActive();
+    const originPid = readOriginPid(this.origin);
+    if (originPid === undefined || this.byteOffset > 4294967295 || this.byteLength > 4294967295) {
+      return;
+    }
+    const [pointerLow, pointerHigh] = splitU64(this.pointer);
+    const [tokenLow, tokenHigh] = splitU64(this.#token);
+    return [
+      pointerLow,
+      pointerHigh,
+      tokenLow,
+      tokenHigh,
+      this.byteOffset >>> 0,
+      this.byteLength >>> 0,
+      encodeRuntime(this.runtime),
+      originPid
+    ];
+  }
+  get isLocal() {
+    return this.origin === PROCESS_ORIGIN && this.runtime === RUNTIME;
+  }
+  #assertLocal() {
+    if (this.origin !== PROCESS_ORIGIN) {
+      throw new Error(`BufferReference cannot cross a process boundary (origin ${this.origin} ` + `!= ${PROCESS_ORIGIN}). Use ProcessSharedBuffer for cross-process memory.`);
+    }
+    if (this.runtime !== RUNTIME) {
+      throw new Error(`BufferReference runtime mismatch: produced on ${this.runtime}, ` + `materializing on ${RUNTIME}.`);
+    }
+  }
+  #assertActive() {
+    if (this.#released) {
+      throw new Error("BufferReference has been released");
+    }
+  }
+  claimOwnership(releaser = currentReturnReleaser) {
+    if (this.#owned !== undefined || this.#borrowedReturnReleaser !== undefined || this.#released)
+      return this;
+    this.#assertLocal();
+    const caps = getBufferReferenceCapabilities();
+    const input = {
+      token: this.#token,
+      pointer: this.pointer,
+      byteOffset: this.byteOffset,
+      byteLength: this.byteLength
+    };
+    if (releaser !== undefined) {
+      this.#borrowedReturnReleaser = releaser;
+      this.#borrowedReturnFinalizerToken = {};
+      borrowedReturnFinalizer?.register(this, { token: this.#token, release: releaser }, this.#borrowedReturnFinalizerToken);
+      return this;
+    }
+    this.#owned = caps.adopt(input, caps.supportsOwningAdopt ? undefined : { copy: true });
+    return this;
+  }
+  #materialize() {
+    this.#assertActive();
+    if (this.#owned !== undefined)
+      return this.#owned;
+    this.#assertLocal();
+    const region = getBufferReferenceCapabilities().adopt({
+      token: this.#token,
+      pointer: this.pointer,
+      byteOffset: this.byteOffset,
+      byteLength: this.byteLength
+    });
+    if (this.#borrowedReturnReleaser !== undefined) {
+      this.#owned = region;
+      return region;
+    }
+    (this.#materializedRegions ??= []).push(region);
+    return region;
+  }
+  toArrayBuffer() {
+    const region = this.#materialize();
+    if (region.byteOffset === 0 && region.buffer.byteLength === region.byteLength) {
+      return region.buffer;
+    }
+    return region.buffer.slice(region.byteOffset, region.byteOffset + region.byteLength);
+  }
+  toUint8Array() {
+    const region = this.#materialize();
+    return new Uint8Array(region.buffer, region.byteOffset, region.byteLength);
+  }
+  get source() {
+    return;
+  }
+  release() {
+    if (this.#released)
+      return;
+    this.#released = true;
+    const regions = this.#materializedRegions;
+    this.#materializedRegions = undefined;
+    if (regions !== undefined) {
+      for (let i = 0;i < regions.length; i++) {
+        detachArrayBufferBestEffort(this.runtime, regions[i].buffer);
+      }
+    }
+    if (this.#borrowedReturnFinalizerToken !== undefined) {
+      borrowedReturnFinalizer?.unregister(this.#borrowedReturnFinalizerToken);
+      this.#borrowedReturnFinalizerToken = undefined;
+    }
+    const borrowedReturnReleaser = this.#borrowedReturnReleaser;
+    this.#borrowedReturnReleaser = undefined;
+    if (borrowedReturnReleaser !== undefined) {
+      const owned = this.#owned;
+      this.#owned = undefined;
+      if (owned !== undefined) {
+        detachArrayBufferBestEffort(this.runtime, owned.buffer);
+      }
+      try {
+        borrowedReturnReleaser(this.#token);
+      } catch {}
+    }
+    if (this.#finalizerToken !== undefined) {
+      producerFinalizer?.unregister(this.#finalizerToken);
+      this.#finalizerToken = undefined;
+    }
+    if (this.#isProducer) {
+      try {
+        getBufferReferenceCapabilities().release(this.#token);
+      } catch {}
+    }
+  }
+  [Symbol.dispose]() {
+    this.release();
+  }
+  [PAYLOAD_TRANSPORT_FINALIZER]() {
+    if (this.#released)
+      return;
+    this.#transportRefs++;
+    let finalized = false;
+    const finalizer = () => {
+      if (finalized)
+        return;
+      finalized = true;
+      this.#transportRefs--;
+      if (this.#transportRefs <= 0)
+        this.release();
+    };
+    if (this.#isProducer) {
+      finalizer[BUFFER_REFERENCE_RETURN_RELEASE_TOKEN] = this.#token;
+    }
+    return finalizer;
+  }
+}
+var codecGlobal = globalThis;
+var codecs = codecGlobal.__KNITTING_PAYLOAD_CODECS__ ??= Object.create(null);
+codecs[BUFFER_REFERENCE_CODEC_ID] = {
+  decode: (metadata) => {
+    const ref = BufferReference.fromMetadata(metadata);
+    return RUNTIME_IS_MAIN_THREAD ? ref.claimOwnership() : ref;
+  },
+  decodeNumeric: (metadata) => {
+    const ref = BufferReference.fromMetadata(numericMetadataToMetadata(metadata));
+    return RUNTIME_IS_MAIN_THREAD ? ref.claimOwnership() : ref;
+  }
+};
+export {
+  isBufferReferenceMetadata,
+  BufferReferenceReturn,
+  BufferReference,
+  BUFFER_REFERENCE_KIND,
+  BUFFER_REFERENCE_CODEC_ID
+};