@opentui/core 0.4.4 → 0.5.0

package/{index-za1krqsf.js → chunk-node-savhj5rp.js}

@@ -1,4 +1,3 @@
-import { createRequire } from "node:module";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
@@ -43,7 +42,6 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // ../../node_modules/.bun/emoji-regex@10.6.0/node_modules/emoji-regex/index.js
 var require_emoji_regex = __commonJS((exports, module) => {
@@ -151,7 +149,7 @@ __export(exports_yoga, {
 });
 
 // src/platform/ffi.ts
-import { createRequire as createRequire2 } from "node:module";
+import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 var FFIType = {
   char: "char",
@@ -231,7 +229,8 @@ function createUnsupportedBackend(cause) {
   };
 }
 var isBun = typeof process !== "undefined" && typeof process.versions === "object" && process.versions !== null && typeof process.versions.bun === "string";
-var requireModule = createRequire2(import.meta.url);
+var usesBunFFI = isBun;
+var requireModule = createRequire(import.meta.url);
 var backend = loadBackend();
 function loadBackend() {
   if (isBun) {
@@ -256,6 +255,11 @@ function toPointer(value) {
 function ffiBool(value) {
   return value ? 1 : 0;
 }
+function trimNodeFFIOutputBytes(buffer, length) {
+  if (length === buffer.byteLength)
+    return buffer;
+  return new Uint8Array(buffer.buffer.transferToFixedLength(length));
+}
 function toSafeNumberPointer(pointer) {
   if (pointer < 0n) {
     throw new Error(POINTER_NEGATIVE);
@@ -421,6 +425,34 @@ function wrapNodeSymbol(fn, definition) {
   if (pointerArgIndexes.length === 0) {
     return fn;
   }
+  if (definition.args?.length === 7 && pointerArgIndexes.length >= 2) {
+    return wrapNodeSymbol7(fn, pointerArgIndexes);
+  }
+  if (definition.args?.length === 8) {
+    return wrapNodeSymbol8(fn, pointerArgIndexes);
+  }
+  const pointerArgs = new Set(pointerArgIndexes);
+  const normalize = (value, index) => pointerArgs.has(index) ? toNodePointerArgumentFast(value) : value;
+  switch (definition.args?.length) {
+    case 1:
+      return function(arg0) {
+        if (arguments.length !== 1)
+          return Reflect.apply(fn, undefined, arguments);
+        return fn(normalize(arg0, 0));
+      };
+    case 2:
+      return function(arg0, arg1) {
+        if (arguments.length !== 2)
+          return Reflect.apply(fn, undefined, arguments);
+        return fn(normalize(arg0, 0), normalize(arg1, 1));
+      };
+    case 3:
+      return function(arg0, arg1, arg2) {
+        if (arguments.length !== 3)
+          return Reflect.apply(fn, undefined, arguments);
+        return fn(normalize(arg0, 0), normalize(arg1, 1), normalize(arg2, 2));
+      };
+  }
   return (...args) => {
     const normalizedArgs = args.slice();
     for (const index of pointerArgIndexes) {
@@ -429,6 +461,49 @@ function wrapNodeSymbol(fn, definition) {
     return fn(...normalizedArgs);
   };
 }
+function wrapNodeSymbol7(fn, pointerArgIndexes) {
+  const pointer0 = pointerArgIndexes.includes(0);
+  const pointer1 = pointerArgIndexes.includes(1);
+  const pointer2 = pointerArgIndexes.includes(2);
+  const pointer3 = pointerArgIndexes.includes(3);
+  const pointer4 = pointerArgIndexes.includes(4);
+  const pointer5 = pointerArgIndexes.includes(5);
+  const pointer6 = pointerArgIndexes.includes(6);
+  const normalize = (value, pointer) => pointer ? toNodePointerArgumentFast(value) : value;
+  return function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+    if (arguments.length !== 7)
+      return Reflect.apply(fn, undefined, arguments);
+    return fn(normalize(arg0, pointer0), normalize(arg1, pointer1), normalize(arg2, pointer2), normalize(arg3, pointer3), normalize(arg4, pointer4), normalize(arg5, pointer5), normalize(arg6, pointer6));
+  };
+}
+function wrapNodeSymbol8(fn, pointerArgIndexes) {
+  const pointer0 = pointerArgIndexes.includes(0);
+  const pointer1 = pointerArgIndexes.includes(1);
+  const pointer2 = pointerArgIndexes.includes(2);
+  const pointer3 = pointerArgIndexes.includes(3);
+  const pointer4 = pointerArgIndexes.includes(4);
+  const pointer5 = pointerArgIndexes.includes(5);
+  const pointer6 = pointerArgIndexes.includes(6);
+  const pointer7 = pointerArgIndexes.includes(7);
+  const normalize = (value, pointer) => pointer ? toNodePointerArgumentFast(value) : value;
+  return function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+    if (arguments.length !== 8)
+      return Reflect.apply(fn, undefined, arguments);
+    return fn(normalize(arg0, pointer0), normalize(arg1, pointer1), normalize(arg2, pointer2), normalize(arg3, pointer3), normalize(arg4, pointer4), normalize(arg5, pointer5), normalize(arg6, pointer6), normalize(arg7, pointer7));
+  };
+}
+function toNodePointerArgumentFast(value) {
+  if (typeof value === "bigint") {
+    return value >= 0n ? value : toNodePointerArgument(value);
+  }
+  if (ArrayBuffer.isView(value) && value.byteLength > 0 && value.buffer instanceof ArrayBuffer) {
+    return value;
+  }
+  if (value instanceof ArrayBuffer && value.byteLength > 0) {
+    return value;
+  }
+  return toNodePointerArgument(value);
+}
 function isNodePointerArgumentType(type) {
   return type === FFIType.ptr || type === FFIType.pointer || type === FFIType.function || type === FFIType.callback;
 }
@@ -570,8 +645,8 @@ var toArrayBuffer = backend.toArrayBuffer;
 // src/platform/runtime.ts
 import { existsSync } from "node:fs";
 import { mkdir, writeFile as writeFileNode } from "node:fs/promises";
-import { dirname, isAbsolute, resolve } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { dirname, isAbsolute as isAbsolute2, resolve } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // ../../node_modules/.bun/ansi-regex@6.2.2/node_modules/ansi-regex/index.js
 function ansiRegex({ onlyFirst = false } = {}) {
@@ -665,6 +740,240 @@ function stringWidth(string, options = {}) {
   return width;
 }
 
+// src/platform/assets.ts
+import { statSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// src/lib/singleton.ts
+var singletonCacheSymbol = Symbol.for("@opentui/core/singleton");
+function singleton(key, factory) {
+  const bag = globalThis[singletonCacheSymbol] ??= {};
+  if (!(key in bag)) {
+    bag[key] = factory();
+  }
+  return bag[key];
+}
+function getSingleton(key) {
+  const bag = globalThis[singletonCacheSymbol];
+  return bag?.[key];
+}
+function destroySingleton(key) {
+  const bag = globalThis[singletonCacheSymbol];
+  if (bag && key in bag) {
+    delete bag[key];
+  }
+}
+
+// src/lib/env.ts
+var envRegistry = singleton("env-registry", () => ({}));
+function registerEnvVar(config) {
+  const existing = envRegistry[config.name];
+  if (existing) {
+    if (existing.description !== config.description || existing.type !== config.type || existing.default !== config.default || existing.required !== config.required) {
+      throw new Error(`Environment variable "${config.name}" is already registered with different configuration. ` + `Existing: ${JSON.stringify(existing)}, New: ${JSON.stringify(config)}`);
+    }
+    return;
+  }
+  envRegistry[config.name] = config;
+}
+function normalizeBoolean(value) {
+  const lowerValue = value.toLowerCase();
+  return ["true", "1", "on", "yes"].includes(lowerValue);
+}
+function parseEnvValue(config) {
+  const envValue = process.env[config.name];
+  if (envValue === undefined && config.default !== undefined) {
+    return config.default;
+  }
+  if (envValue === undefined && config.required === false) {
+    return;
+  }
+  if (envValue === undefined) {
+    throw new Error(`Required environment variable ${config.name} is not set. ${config.description}`);
+  }
+  switch (config.type) {
+    case "boolean":
+      return typeof envValue === "boolean" ? envValue : normalizeBoolean(envValue);
+    case "number":
+      const numValue = Number(envValue);
+      if (isNaN(numValue)) {
+        throw new Error(`Environment variable ${config.name} must be a valid number, got: ${envValue}`);
+      }
+      return numValue;
+    case "string":
+    default:
+      return envValue;
+  }
+}
+
+class EnvStore {
+  parsedValues = new Map;
+  get(key) {
+    if (this.parsedValues.has(key)) {
+      return this.parsedValues.get(key);
+    }
+    if (!(key in envRegistry)) {
+      throw new Error(`Environment variable ${key} is not registered.`);
+    }
+    try {
+      const value = parseEnvValue(envRegistry[key]);
+      this.parsedValues.set(key, value);
+      return value;
+    } catch (error) {
+      throw new Error(`Failed to parse env var ${key}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  has(key) {
+    return key in envRegistry;
+  }
+  clearCache() {
+    this.parsedValues.clear();
+  }
+}
+var envStore = singleton("env-store", () => new EnvStore);
+function clearEnvCache() {
+  envStore.clearCache();
+}
+function generateEnvMarkdown() {
+  const configs = Object.values(envRegistry);
+  if (configs.length === 0) {
+    return `# Environment Variables
+
+No environment variables registered.
+`;
+  }
+  let markdown = `# Environment Variables
+
+`;
+  for (const config of configs) {
+    markdown += `## ${config.name}
+
+`;
+    markdown += `${config.description}
+
+`;
+    markdown += `**Type:** \`${config.type || "string"}\`  
+`;
+    if (config.default !== undefined) {
+      const defaultValue = typeof config.default === "string" ? `"${config.default}"` : String(config.default);
+      markdown += `**Default:** \`${defaultValue}\`
+`;
+    } else if (config.required === false) {
+      markdown += `**Default:** *unset*
+`;
+    } else {
+      markdown += `**Default:** *Required*
+`;
+    }
+    markdown += `
+`;
+  }
+  return markdown;
+}
+function generateEnvColored() {
+  const configs = Object.values(envRegistry);
+  if (configs.length === 0) {
+    return `\x1B[1;36mEnvironment Variables\x1B[0m
+
+No environment variables registered.
+`;
+  }
+  let output = `\x1B[1;36mEnvironment Variables\x1B[0m
+
+`;
+  for (const config of configs) {
+    output += `\x1B[1;33m${config.name}\x1B[0m
+`;
+    output += `${config.description}
+`;
+    output += `\x1B[32mType:\x1B[0m \x1B[36m${config.type || "string"}\x1B[0m
+`;
+    if (config.default !== undefined) {
+      const defaultValue = typeof config.default === "string" ? `"${config.default}"` : String(config.default);
+      output += `\x1B[32mDefault:\x1B[0m \x1B[35m${defaultValue}\x1B[0m
+`;
+    } else if (config.required === false) {
+      output += `\x1B[32mDefault:\x1B[0m \x1B[35munset\x1B[0m
+`;
+    } else {
+      output += `\x1B[32mDefault:\x1B[0m \x1B[31mRequired\x1B[0m
+`;
+    }
+    output += `
+`;
+  }
+  return output;
+}
+var env = new Proxy({}, {
+  get(target, prop) {
+    if (typeof prop !== "string") {
+      return;
+    }
+    return envStore.get(prop);
+  },
+  has(target, prop) {
+    return envStore.has(prop);
+  },
+  ownKeys() {
+    return Object.keys(envRegistry);
+  },
+  getOwnPropertyDescriptor(target, prop) {
+    if (envStore.has(prop)) {
+      return {
+        enumerable: true,
+        configurable: true,
+        get: () => envStore.get(prop)
+      };
+    }
+    return;
+  }
+});
+
+// src/platform/assets.ts
+registerEnvVar({
+  name: "OTUI_ASSET_ROOT",
+  description: "Absolute directory containing relocatable OpenTUI runtime assets",
+  type: "string",
+  default: ""
+});
+function resolveAssetPath(key, fallback) {
+  validateAssetKey(key);
+  const configuredPath = resolveAssetRootPath(key);
+  if (configuredPath !== undefined) {
+    return configuredPath;
+  }
+  if (fallback === undefined) {
+    throw new Error(`OpenTUI asset ${JSON.stringify(key)} has no package-relative fallback`);
+  }
+  const value = typeof fallback === "function" ? fallback() : fallback;
+  return value instanceof URL ? fileURLToPath2(value) : value;
+}
+function resolveAssetRootPath(key) {
+  validateAssetKey(key);
+  const root = process.env.OTUI_ASSET_ROOT;
+  if (!root) {
+    return;
+  }
+  if (!isAbsolute(root)) {
+    throw new Error(`OTUI_ASSET_ROOT must be an absolute directory, got ${JSON.stringify(root)}`);
+  }
+  const assetPath = join(root, key);
+  let isFile = false;
+  try {
+    isFile = statSync(assetPath).isFile();
+  } catch {}
+  if (!isFile) {
+    throw new Error(`Missing OpenTUI asset ${JSON.stringify(key)} at ${JSON.stringify(assetPath)}`);
+  }
+  return assetPath;
+}
+function validateAssetKey(key) {
+  if (key.length === 0 || isAbsolute(key) || key.includes("\\") || key.split("/").includes("..")) {
+    throw new Error(`Invalid OpenTUI asset key: ${JSON.stringify(key)}`);
+  }
+}
+
 // src/platform/runtime.ts
 var TEXT_ENCODER = new TextEncoder;
 var bun = globalThis.Bun;
@@ -672,33 +981,50 @@ var sleep = bun?.sleep ?? standardSleep;
 var stringWidth2 = bun?.stringWidth ?? stringWidth;
 var stripANSI = bun?.stripANSI ?? stripAnsi;
 var writeFile = bun?.write ?? writeFilePortable;
-async function resolveBundledFilePath(loadBundledFile, fallbackPath, metaUrl) {
+async function resolveBundledFilePath(key, loadBundledFile, fallbackPath, metaUrl, options = {}) {
+  if (options.useAssetRoot ?? true) {
+    const configuredPath = resolveAssetRootPath(key);
+    if (configuredPath !== undefined) {
+      return configuredPath;
+    }
+  }
   if (!bun) {
     const path = resolveFallbackFilePath(fallbackPath, metaUrl);
     if (existsSync(path)) {
       return path;
     }
-    return await loadBundledFilePath(loadBundledFile, metaUrl) ?? path;
+    return await loadBundledFilePath(loadBundledFile, metaUrl, options.loadBundledFileFallback ?? false) ?? path;
+  }
+  const loaded = (await loadBundledFile()).default;
+  if (typeof loaded !== "string") {
+    return resolveFallbackFilePath(fallbackPath, metaUrl);
   }
-  return normalizeLoadedFilePath((await loadBundledFile()).default, metaUrl);
+  return normalizeLoadedFilePath(loaded, metaUrl);
 }
 function resolveFallbackFilePath(fallbackPath, metaUrl) {
   const path = typeof fallbackPath === "function" ? fallbackPath() : fallbackPath;
-  return fileURLToPath2(path instanceof URL ? path : new URL(path, metaUrl));
+  return fileURLToPath3(path instanceof URL ? path : new URL(path, metaUrl));
 }
 function normalizeLoadedFilePath(loadedPath, baseUrl) {
   if (loadedPath.startsWith("file:")) {
-    return fileURLToPath2(loadedPath);
+    return fileURLToPath3(loadedPath);
   }
-  if (isAbsolute(loadedPath)) {
+  if (isAbsolute2(loadedPath)) {
     return loadedPath;
   }
-  return resolve(dirname(fileURLToPath2(baseUrl)), loadedPath);
+  return resolve(dirname(fileURLToPath3(baseUrl)), loadedPath);
 }
-async function loadBundledFilePath(loadBundledFile, metaUrl) {
+async function loadBundledFilePath(loadBundledFile, metaUrl, loadBundledFileFallback) {
   const specifier = extractBundledImportSpecifier(loadBundledFile);
   if (!specifier) {
-    return;
+    if (!loadBundledFileFallback) {
+      return;
+    }
+    try {
+      return normalizeLoadedFilePath((await loadBundledFile()).default, metaUrl);
+    } catch {
+      return;
+    }
   }
   try {
     const moduleUrl = new URL(specifier, metaUrl);
@@ -717,7 +1043,7 @@ function standardSleep(msOrDate) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 async function writeFilePortable(destination, data, options) {
-  const destinationPath = destination instanceof URL ? fileURLToPath2(destination) : destination;
+  const destinationPath = destination instanceof URL ? fileURLToPath3(destination) : destination;
   if (options?.createPath) {
     await mkdir(dirname(destinationPath), { recursive: true });
   }
@@ -5906,181 +6232,6 @@ class ASCIIFontSelectionHelper {
     return previousSelection?.start !== this.localSelection?.start || previousSelection?.end !== this.localSelection?.end;
   }
 }
-// src/lib/singleton.ts
-var singletonCacheSymbol = Symbol.for("@opentui/core/singleton");
-function singleton(key, factory) {
-  const bag = globalThis[singletonCacheSymbol] ??= {};
-  if (!(key in bag)) {
-    bag[key] = factory();
-  }
-  return bag[key];
-}
-function getSingleton(key) {
-  const bag = globalThis[singletonCacheSymbol];
-  return bag?.[key];
-}
-function destroySingleton(key) {
-  const bag = globalThis[singletonCacheSymbol];
-  if (bag && key in bag) {
-    delete bag[key];
-  }
-}
-
-// src/lib/env.ts
-var envRegistry = singleton("env-registry", () => ({}));
-function registerEnvVar(config) {
-  const existing = envRegistry[config.name];
-  if (existing) {
-    if (existing.description !== config.description || existing.type !== config.type || existing.default !== config.default) {
-      throw new Error(`Environment variable "${config.name}" is already registered with different configuration. ` + `Existing: ${JSON.stringify(existing)}, New: ${JSON.stringify(config)}`);
-    }
-    return;
-  }
-  envRegistry[config.name] = config;
-}
-function normalizeBoolean(value) {
-  const lowerValue = value.toLowerCase();
-  return ["true", "1", "on", "yes"].includes(lowerValue);
-}
-function parseEnvValue(config) {
-  const envValue = process.env[config.name];
-  if (envValue === undefined && config.default !== undefined) {
-    return config.default;
-  }
-  if (envValue === undefined) {
-    throw new Error(`Required environment variable ${config.name} is not set. ${config.description}`);
-  }
-  switch (config.type) {
-    case "boolean":
-      return typeof envValue === "boolean" ? envValue : normalizeBoolean(envValue);
-    case "number":
-      const numValue = Number(envValue);
-      if (isNaN(numValue)) {
-        throw new Error(`Environment variable ${config.name} must be a valid number, got: ${envValue}`);
-      }
-      return numValue;
-    case "string":
-    default:
-      return envValue;
-  }
-}
-
-class EnvStore {
-  parsedValues = new Map;
-  get(key) {
-    if (this.parsedValues.has(key)) {
-      return this.parsedValues.get(key);
-    }
-    if (!(key in envRegistry)) {
-      throw new Error(`Environment variable ${key} is not registered.`);
-    }
-    try {
-      const value = parseEnvValue(envRegistry[key]);
-      this.parsedValues.set(key, value);
-      return value;
-    } catch (error) {
-      throw new Error(`Failed to parse env var ${key}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  has(key) {
-    return key in envRegistry;
-  }
-  clearCache() {
-    this.parsedValues.clear();
-  }
-}
-var envStore = singleton("env-store", () => new EnvStore);
-function clearEnvCache() {
-  envStore.clearCache();
-}
-function generateEnvMarkdown() {
-  const configs = Object.values(envRegistry);
-  if (configs.length === 0) {
-    return `# Environment Variables
-
-No environment variables registered.
-`;
-  }
-  let markdown = `# Environment Variables
-
-`;
-  for (const config of configs) {
-    markdown += `## ${config.name}
-
-`;
-    markdown += `${config.description}
-
-`;
-    markdown += `**Type:** \`${config.type || "string"}\`  
-`;
-    if (config.default !== undefined) {
-      const defaultValue = typeof config.default === "string" ? `"${config.default}"` : String(config.default);
-      markdown += `**Default:** \`${defaultValue}\`
-`;
-    } else {
-      markdown += `**Default:** *Required*
-`;
-    }
-    markdown += `
-`;
-  }
-  return markdown;
-}
-function generateEnvColored() {
-  const configs = Object.values(envRegistry);
-  if (configs.length === 0) {
-    return `\x1B[1;36mEnvironment Variables\x1B[0m
-
-No environment variables registered.
-`;
-  }
-  let output = `\x1B[1;36mEnvironment Variables\x1B[0m
-
-`;
-  for (const config of configs) {
-    output += `\x1B[1;33m${config.name}\x1B[0m
-`;
-    output += `${config.description}
-`;
-    output += `\x1B[32mType:\x1B[0m \x1B[36m${config.type || "string"}\x1B[0m
-`;
-    if (config.default !== undefined) {
-      const defaultValue = typeof config.default === "string" ? `"${config.default}"` : String(config.default);
-      output += `\x1B[32mDefault:\x1B[0m \x1B[35m${defaultValue}\x1B[0m
-`;
-    } else {
-      output += `\x1B[32mDefault:\x1B[0m \x1B[31mRequired\x1B[0m
-`;
-    }
-    output += `
-`;
-  }
-  return output;
-}
-var env = new Proxy({}, {
-  get(target, prop) {
-    if (typeof prop !== "string") {
-      return;
-    }
-    return envStore.get(prop);
-  },
-  has(target, prop) {
-    return envStore.has(prop);
-  },
-  ownKeys() {
-    return Object.keys(envRegistry);
-  },
-  getOwnPropertyDescriptor(target, prop) {
-    if (envStore.has(prop)) {
-      return {
-        enumerable: true,
-        configurable: true,
-        get: () => envStore.get(prop)
-      };
-    }
-    return;
-  }
-});
 // src/lib/stdin-parser.ts
 import { Buffer as Buffer3 } from "node:buffer";
 var DEFAULT_TIMEOUT_MS = 20;
@@ -6295,6 +6446,31 @@ function canStillBeStartupCursorCprPrefix(state) {
 function canStillBePixelResolution(state) {
   return state.firstParamValue === 4 && state.semicolons === 2;
 }
+function canStillBePixelResolutionPrefix(bytes) {
+  const fixedPrefix = [ESC, 91, 52, 59];
+  const fixedLength = Math.min(bytes.length, fixedPrefix.length);
+  for (let index2 = 0;index2 < fixedLength; index2 += 1) {
+    if (bytes[index2] !== fixedPrefix[index2])
+      return false;
+  }
+  if (bytes.length <= fixedPrefix.length)
+    return bytes.length > 0;
+  let index = fixedPrefix.length;
+  const heightStart = index;
+  while (index < bytes.length && isAsciiDigit(bytes[index]))
+    index += 1;
+  if (index === bytes.length)
+    return index > heightStart;
+  if (index === heightStart || bytes[index] !== 59)
+    return false;
+  index += 1;
+  const widthStart = index;
+  while (index < bytes.length && isAsciiDigit(bytes[index]))
+    index += 1;
+  if (index === bytes.length)
+    return true;
+  return index > widthStart && bytes[index] === 116;
+}
 function canDeferParametricCsi(state, context) {
   return context.kittyKeyboardEnabled && (canStillBeKittyU(state) || canStillBeKittySpecial(state)) || context.explicitWidthCprActive && canStillBeExplicitWidthCpr(state) || context.startupCursorCprActive && canStillBeStartupCursorCpr(state) || context.pixelResolutionQueryActive && canStillBePixelResolution(state);
 }
@@ -6417,6 +6593,8 @@ class StdinParser {
   timeoutId = null;
   destroyed = false;
   pendingSinceMs = null;
+  pendingTimeoutPaused = false;
+  suspendedPixelResolutionPrefixLength = 0;
   forceFlush = false;
   justFlushedEsc = false;
   state = { tag: "ground" };
@@ -6445,6 +6623,12 @@ class StdinParser {
   updateProtocolContext(patch) {
     this.ensureAlive();
     this.protocolContext = { ...this.protocolContext, ...patch };
+    if (!this.protocolContext.pixelResolutionQueryActive && this.suspendedPixelResolutionPrefixLength > 0) {
+      const prefixLength = this.suspendedPixelResolutionPrefixLength;
+      this.state = { tag: "ground" };
+      this.consumePrefix(prefixLength);
+      this.scanPending();
+    }
     this.reconcileDeferredStateWithProtocolContext();
     this.reconcileTimeoutState();
   }
@@ -6519,6 +6703,11 @@ class StdinParser {
       const appendEnd = immediatePasteStartIndex === -1 ? remainder.length : immediatePasteStartIndex + BRACKETED_PASTE_START.length;
       this.pending.append(remainder.subarray(0, appendEnd));
       remainder = remainder.subarray(appendEnd);
+      if (this.suspendedPixelResolutionPrefixLength > 0 && this.protocolContext.pixelResolutionQueryActive && !canStillBePixelResolutionPrefix(this.pending.view())) {
+        const prefixLength = this.suspendedPixelResolutionPrefixLength;
+        this.state = { tag: "ground" };
+        this.consumePrefix(prefixLength);
+      }
       this.scanPending();
       if (this.paste && this.pending.length > 0) {
         remainder = this.consumePasteBytes(this.takePendingBytes());
@@ -6575,6 +6764,23 @@ class StdinParser {
     this.clearTimeout();
     this.resetState();
   }
+  hasPendingPixelResolutionResponse() {
+    if (!this.protocolContext.pixelResolutionQueryActive || this.pending.length === 0)
+      return false;
+    return canStillBePixelResolutionPrefix(this.pending.view());
+  }
+  pausePendingTimeout() {
+    this.ensureAlive();
+    this.pendingTimeoutPaused = true;
+    this.suspendedPixelResolutionPrefixLength = this.pending.length;
+    this.clearTimeout();
+  }
+  resumePendingTimeout() {
+    this.ensureAlive();
+    if (this.pending.length === 0)
+      this.pendingTimeoutPaused = false;
+    this.reconcileTimeoutState();
+  }
   resetMouseState() {
     this.ensureAlive();
     this.mouseParser.reset();
@@ -7402,6 +7608,8 @@ class StdinParser {
   }
   consumePrefix(endExclusive) {
     this.pending.consume(endExclusive);
+    this.pendingTimeoutPaused = false;
+    this.suspendedPixelResolutionPrefixLength = 0;
     this.cursor = 0;
     this.unitStart = 0;
     this.pendingSinceMs = null;
@@ -7424,6 +7632,8 @@ class StdinParser {
     this.cursor = 0;
     this.unitStart = 0;
     this.pendingSinceMs = null;
+    this.pendingTimeoutPaused = false;
+    this.suspendedPixelResolutionPrefixLength = 0;
     this.forceFlush = false;
     this.state = { tag: "ground" };
   }
@@ -7480,6 +7690,10 @@ class StdinParser {
     if (!this.armTimeouts) {
       return;
     }
+    if (this.pendingTimeoutPaused) {
+      this.clearTimeout();
+      return;
+    }
     if (this.paste || this.pendingSinceMs === null || this.pending.length === 0) {
       this.clearTimeout();
       return;
@@ -7509,6 +7723,8 @@ class StdinParser {
     this.pending.reset(INITIAL_PENDING_CAPACITY);
     this.events.length = 0;
     this.pendingSinceMs = null;
+    this.pendingTimeoutPaused = false;
+    this.suspendedPixelResolutionPrefixLength = 0;
     this.forceFlush = false;
     this.justFlushedEsc = false;
     this.state = { tag: "ground" };
@@ -7843,92 +8059,151 @@ class ProcessQueue {
   }
 }
 
+// src/node-asset-target.ts
+var NATIVE_FILE_NAMES = {
+  darwin: "libopentui.dylib",
+  linux: "libopentui.so",
+  win32: "opentui.dll"
+};
+function getNativeAssetDescriptor(target) {
+  if (!Object.hasOwn(NATIVE_FILE_NAMES, target.platform) || target.arch !== "arm64" && target.arch !== "x64") {
+    throw new Error(`Unsupported OpenTUI Node asset target: ${String(target.platform)}-${String(target.arch)}`);
+  }
+  if (target.libc !== undefined && target.libc !== "glibc" && target.libc !== "musl") {
+    throw new Error(`Unsupported libc for OpenTUI Node assets: ${String(target.libc)}`);
+  }
+  if (target.platform !== "linux" && target.libc !== undefined) {
+    throw new Error(`OpenTUI Node asset target libc is only supported on Linux, got ${target.platform}`);
+  }
+  const libcSuffix = target.platform === "linux" && target.libc === "musl" ? "-musl" : "";
+  const packageName = `@opentui/core-${target.platform}-${target.arch}${libcSuffix}`;
+  const fileName = NATIVE_FILE_NAMES[target.platform];
+  return {
+    key: `${packageName}/${fileName}`,
+    packageName,
+    fileName
+  };
+}
+function getCurrentNodeAssetTarget() {
+  const libc = process.env.OPENTUI_LIBC;
+  if (process.platform === "linux" && libc !== undefined && libc !== "" && libc !== "glibc" && libc !== "musl") {
+    throw new Error(`On Linux, OPENTUI_LIBC must be unset, empty, "glibc", or "musl", got ${JSON.stringify(libc)}`);
+  }
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    ...process.platform === "linux" && libc === "musl" ? { libc } : {}
+  };
+}
+
+// src/platform/runtime-assets.node.ts
+var CORE_ASSET_PREFIX = "@opentui/core/";
+var PARSER_WORKER_ASSET_KEY = `${CORE_ASSET_PREFIX}parser.worker.js`;
+var TREE_SITTER_WASM_ASSET_KEY = "web-tree-sitter/tree-sitter.wasm";
+function resolveDefaultParserAsset(relativePath, fallbackPath) {
+  return Promise.resolve(resolveAssetPath(`${CORE_ASSET_PREFIX}${relativePath}`, fallbackPath));
+}
+function resolveDefaultTreeSitterWorkerPath(fallbackPath) {
+  return resolveAssetPath(PARSER_WORKER_ASSET_KEY, fallbackPath);
+}
+function resolveTreeSitterWasm() {
+  return Promise.resolve(resolveAssetPath(TREE_SITTER_WASM_ASSET_KEY, () => new URL(import.meta.resolve(TREE_SITTER_WASM_ASSET_KEY))));
+}
+async function resolveNativeLibraryPath() {
+  const asset = getNativeAssetDescriptor(getCurrentNodeAssetTarget());
+  const configuredPath = resolveAssetRootPath(asset.key);
+  if (configuredPath !== undefined) {
+    return configuredPath;
+  }
+  const specifier = asset.packageName;
+  return (await import(specifier)).default;
+}
+
 // src/lib/tree-sitter/default-parsers.ts
-var _cachedParsers;
-function getParsers() {
-  if (!_cachedParsers) {
-    _cachedParsers = loadParsers();
-  }
-  return _cachedParsers;
-}
-async function loadParsers() {
-  const javascript_highlights = await resolveBundledFilePath(() => import("./assets/javascript/highlights.scm", { with: { type: "file" } }), "./assets/javascript/highlights.scm", import.meta.url);
-  const javascript_language = await resolveBundledFilePath(() => import("./assets/javascript/tree-sitter-javascript.wasm", { with: { type: "file" } }), "./assets/javascript/tree-sitter-javascript.wasm", import.meta.url);
-  const typescript_highlights = await resolveBundledFilePath(() => import("./assets/typescript/highlights.scm", { with: { type: "file" } }), "./assets/typescript/highlights.scm", import.meta.url);
-  const typescript_language = await resolveBundledFilePath(() => import("./assets/typescript/tree-sitter-typescript.wasm", { with: { type: "file" } }), "./assets/typescript/tree-sitter-typescript.wasm", import.meta.url);
-  const markdown_highlights = await resolveBundledFilePath(() => import("./assets/markdown/highlights.scm", { with: { type: "file" } }), "./assets/markdown/highlights.scm", import.meta.url);
-  const markdown_language = await resolveBundledFilePath(() => import("./assets/markdown/tree-sitter-markdown.wasm", { with: { type: "file" } }), "./assets/markdown/tree-sitter-markdown.wasm", import.meta.url);
-  const markdown_injections = await resolveBundledFilePath(() => import("./assets/markdown/injections.scm", { with: { type: "file" } }), "./assets/markdown/injections.scm", import.meta.url);
-  const markdown_inline_highlights = await resolveBundledFilePath(() => import("./assets/markdown_inline/highlights.scm", { with: { type: "file" } }), "./assets/markdown_inline/highlights.scm", import.meta.url);
-  const markdown_inline_language = await resolveBundledFilePath(() => import("./assets/markdown_inline/tree-sitter-markdown_inline.wasm", { with: { type: "file" } }), "./assets/markdown_inline/tree-sitter-markdown_inline.wasm", import.meta.url);
-  const zig_highlights = await resolveBundledFilePath(() => import("./assets/zig/highlights.scm", { with: { type: "file" } }), "./assets/zig/highlights.scm", import.meta.url);
-  const zig_language = await resolveBundledFilePath(() => import("./assets/zig/tree-sitter-zig.wasm", { with: { type: "file" } }), "./assets/zig/tree-sitter-zig.wasm", import.meta.url);
-  return [
-    {
-      filetype: "javascript",
-      aliases: ["javascriptreact"],
-      queries: {
-        highlights: [javascript_highlights]
-      },
-      wasm: javascript_language
-    },
-    {
-      filetype: "typescript",
-      aliases: ["typescriptreact"],
-      queries: {
-        highlights: [typescript_highlights]
-      },
-      wasm: typescript_language
-    },
-    {
-      filetype: "markdown",
-      queries: {
-        highlights: [markdown_highlights],
-        injections: [markdown_injections]
-      },
-      wasm: markdown_language,
-      injectionMapping: {
-        nodeTypes: {
-          inline: "markdown_inline",
-          pipe_table_cell: "markdown_inline"
-        },
-        infoStringMap: {
-          javascript: "javascript",
-          js: "javascript",
-          jsx: "javascriptreact",
-          javascriptreact: "javascriptreact",
-          typescript: "typescript",
-          ts: "typescript",
-          tsx: "typescriptreact",
-          typescriptreact: "typescriptreact",
-          markdown: "markdown",
-          md: "markdown"
-        }
+var defaultParserDescriptors = [
+  {
+    filetype: "javascript",
+    aliases: ["javascriptreact"],
+    queries: { highlights: ["assets/javascript/highlights.scm"] },
+    wasm: "assets/javascript/tree-sitter-javascript.wasm"
+  },
+  {
+    filetype: "typescript",
+    aliases: ["typescriptreact"],
+    queries: { highlights: ["assets/typescript/highlights.scm"] },
+    wasm: "assets/typescript/tree-sitter-typescript.wasm"
+  },
+  {
+    filetype: "markdown",
+    queries: {
+      highlights: ["assets/markdown/highlights.scm"],
+      injections: ["assets/markdown/injections.scm"]
+    },
+    wasm: "assets/markdown/tree-sitter-markdown.wasm",
+    injectionMapping: {
+      nodeTypes: { inline: "markdown_inline", pipe_table_cell: "markdown_inline" },
+      infoStringMap: {
+        javascript: "javascript",
+        js: "javascript",
+        jsx: "javascriptreact",
+        javascriptreact: "javascriptreact",
+        typescript: "typescript",
+        ts: "typescript",
+        tsx: "typescriptreact",
+        typescriptreact: "typescriptreact",
+        markdown: "markdown",
+        md: "markdown"
       }
-    },
-    {
-      filetype: "markdown_inline",
-      queries: {
-        highlights: [markdown_inline_highlights]
-      },
-      wasm: markdown_inline_language
-    },
-    {
-      filetype: "zig",
-      queries: {
-        highlights: [zig_highlights]
-      },
-      wasm: zig_language
     }
-  ];
+  },
+  {
+    filetype: "markdown_inline",
+    queries: { highlights: ["assets/markdown_inline/highlights.scm"] },
+    wasm: "assets/markdown_inline/tree-sitter-markdown_inline.wasm"
+  },
+  {
+    filetype: "zig",
+    queries: { highlights: ["assets/zig/highlights.scm"] },
+    wasm: "assets/zig/tree-sitter-zig.wasm"
+  }
+];
+var defaultParserAssetPaths = [
+  ...new Set(defaultParserDescriptors.flatMap((parser) => [
+    ...parser.queries.highlights,
+    parser.wasm,
+    ...parser.queries.injections ?? []
+  ]))
+];
+var cachedParsers;
+function getParsers() {
+  cachedParsers ??= Promise.all(defaultParserDescriptors.map(resolveDefaultParser));
+  return cachedParsers;
+}
+async function resolveDefaultParser(parser) {
+  const queries = {
+    highlights: await Promise.all(parser.queries.highlights.map(resolveParserAsset))
+  };
+  if (parser.queries.injections) {
+    queries.injections = await Promise.all(parser.queries.injections.map(resolveParserAsset));
+  }
+  return {
+    filetype: parser.filetype,
+    ...parser.aliases ? { aliases: [...parser.aliases] } : {},
+    queries,
+    wasm: await resolveParserAsset(parser.wasm),
+    ...parser.injectionMapping ? { injectionMapping: parser.injectionMapping } : {}
+  };
+}
+function resolveParserAsset(relativePath) {
+  return resolveDefaultParserAsset(relativePath, new URL(`./${relativePath}`, import.meta.url));
 }
 
 // src/lib/tree-sitter/client.ts
-import { resolve as resolve2, isAbsolute as isAbsolute2, parse } from "path";
+import { resolve as resolve2, isAbsolute as isAbsolute3, parse } from "path";
 import { existsSync as existsSync2 } from "fs";
 
 // src/lib/bunfs.ts
-import { basename, join } from "node:path";
+import { basename, join as join2 } from "node:path";
 function isBunfsPath(path) {
   return path.includes("$bunfs") || /^B:[\\/]~BUN/i.test(path);
 }
@@ -7936,7 +8211,7 @@ function getBunfsRootPath() {
   return process.platform === "win32" ? "B:\\~BUN\\root" : "/$bunfs/root";
 }
 function normalizeBunfsPath(fileName) {
-  return join(getBunfsRootPath(), basename(fileName));
+  return join2(getBunfsRootPath(), basename(fileName));
 }
 
 // src/platform/worker.ts
@@ -8323,8 +8598,8 @@ class TreeSitterClient extends EventEmitter2 {
     if (typeof OTUI_TREE_SITTER_WORKER_PATH !== "undefined") {
       return OTUI_TREE_SITTER_WORKER_PATH;
     }
-    let workerPath = new URL("./parser.worker.js", import.meta.url).href;
-    if (!existsSync2(resolve2(import.meta.dirname, "parser.worker.js"))) {
+    let workerPath = resolveDefaultTreeSitterWorkerPath(new URL("./parser.worker.js", import.meta.url));
+    if (!process.env.OTUI_ASSET_ROOT && !existsSync2(workerPath)) {
       workerPath = new URL("./parser.worker.ts", import.meta.url).href;
     }
     return workerPath;
@@ -8401,6 +8676,8 @@ class TreeSitterClient extends EventEmitter2 {
     }
   }
   async initializeClient(generation, worker) {
+    const treeSitterWasmPath = await resolveTreeSitterWasm();
+    this.assertCurrentInitialization(generation, worker);
     await new Promise((resolve3, reject) => {
       const timeoutMs = this.options.initTimeout ?? 1e4;
       const timeoutId = setTimeout(() => {
@@ -8412,7 +8689,8 @@ class TreeSitterClient extends EventEmitter2 {
       this.initializeResolvers = { resolve: resolve3, reject, timeoutId };
       this.sendWorkerMessage({
         type: "INIT",
-        dataPath: this.options.dataPath
+        dataPath: this.options.dataPath,
+        treeSitterWasmPath
       });
     });
     this.assertCurrentInitialization(generation, worker);
@@ -8438,7 +8716,7 @@ class TreeSitterClient extends EventEmitter2 {
     if (isBunfsPath(path)) {
       return normalizeBunfsPath(parse(path).base);
     }
-    if (!isAbsolute2(path)) {
+    if (!isAbsolute3(path)) {
       return resolve2(path);
     }
     return path;
@@ -10325,6 +10603,11 @@ function detectLinks(chunks, context) {
   return chunks;
 }
 // src/buffer.ts
+function requireInteger(value, name, min, max) {
+  if (!Number.isSafeInteger(value) || value < min || value > max) {
+    throw new RangeError(`${name} must be an integer from ${min} to ${max}`);
+  }
+}
 function packDrawOptions(border2, shouldFill, titleAlignment, bottomTitleAlignment) {
   let packed = 0;
   if (border2 === true) {
@@ -10563,6 +10846,23 @@ class OptimizedBuffer {
     this.guard();
     this.lib.bufferDrawSuperSampleBuffer(this.bufferPtr, x, y, toPointer(pixelDataPtr), pixelDataLength, format, alignedBytesPerRow);
   }
+  drawImage(image, x, y, width, height, pixelWidth = 0, pixelHeight = 0, sourceX = 0, sourceY = 0, sourceWidth = image.width, sourceHeight = image.height, protocol = "auto") {
+    this.guard();
+    requireInteger(x, "x", -2147483648, 2147483647);
+    requireInteger(y, "y", -2147483648, 2147483647);
+    requireInteger(width, "width", 1, 2147483647);
+    requireInteger(height, "height", 1, 2147483647);
+    requireInteger(pixelWidth, "pixelWidth", 0, 2147483647);
+    requireInteger(pixelHeight, "pixelHeight", 0, 2147483647);
+    requireInteger(sourceX, "sourceX", 0, 4294967295);
+    requireInteger(sourceY, "sourceY", 0, 4294967295);
+    requireInteger(sourceWidth, "sourceWidth", 1, 4294967295);
+    requireInteger(sourceHeight, "sourceHeight", 1, 4294967295);
+    if (x + width > 2147483647 || y + height > 2147483647) {
+      throw new RangeError("image destination coordinates and dimensions exceed i32 bounds");
+    }
+    return this.lib.bufferDrawImage(this.bufferPtr, image.ptr, x, y, width, height, pixelWidth, pixelHeight, sourceX, sourceY, sourceWidth, sourceHeight, protocol);
+  }
   drawPackedBuffer(dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells) {
     this.guard();
     this.lib.bufferDrawPackedBuffer(this.bufferPtr, toPointer(dataPtr), dataLen, posX, posY, terminalWidthCells, terminalHeightCells);
@@ -10832,8 +11132,8 @@ class TextBuffer {
   }
 }
 
-// ../../node_modules/.bun/bun-ffi-structs@0.2.4+1fb4c65d43e298b9/node_modules/bun-ffi-structs/dist/index.js
-var FFI_LOAD_ERROR = "bun-ffi-structs requires Bun or Node.js with node:ffi enabled (--experimental-ffi --allow-ffi).";
+// ../../node_modules/.bun/bun-ffi-structs@0.3.1+1fb4c65d43e298b9/node_modules/bun-ffi-structs/dist/index.js
+var FFI_LOAD_ERROR = "bun-ffi-structs pointer operations require Bun or Node.js 26.1+ with node:ffi enabled (--experimental-ffi).";
 var backend2 = await loadBackend2();
 function unavailable2(cause) {
   throw new Error(FFI_LOAD_ERROR, {
@@ -10875,7 +11175,8 @@ function createNodeBackend2(nodeFfi) {
   return {
     ptr(value) {
       if (ArrayBuffer.isView(value)) {
-        return nodeFfi.getRawPointer(value.buffer) + BigInt(value.byteOffset);
+        const pointer = nodeFfi.getRawPointer(value.buffer);
+        return value.byteOffset === 0 ? pointer : pointer + BigInt(value.byteOffset);
       }
       if (value instanceof ArrayBuffer) {
         return nodeFfi.getRawPointer(value);
@@ -10938,6 +11239,30 @@ var typeGetters = {
 function isObjectPointerDef(type) {
   return typeof type === "object" && type !== null && type.__type === "objectPointer";
 }
+function allocStruct(structDef, options) {
+  const buffer = new ArrayBuffer(structDef.size);
+  const view = new DataView(buffer);
+  const result = { buffer, view };
+  if (options?.lengths) {
+    const subBuffers = {};
+    for (const [arrayFieldName, length] of Object.entries(options.lengths)) {
+      const arrayMeta = structDef.arrayFields.get(arrayFieldName);
+      if (!arrayMeta) {
+        throw new Error(`Field '${arrayFieldName}' is not an array field with a lengthOf field`);
+      }
+      const subBuffer = new ArrayBuffer(length * arrayMeta.elementSize);
+      subBuffers[arrayFieldName] = subBuffer;
+      const pointer = length > 0 ? ptr2(subBuffer) : null;
+      pointerPacker(view, arrayMeta.arrayOffset, pointer);
+      retainPointerTarget(buffer, subBuffer);
+      arrayMeta.lengthPack(view, arrayMeta.lengthOffset, length);
+    }
+    if (Object.keys(subBuffers).length > 0) {
+      result.subBuffers = subBuffers;
+    }
+  }
+  return result;
+}
 function alignOffset(offset, align) {
   return offset + (align - 1) & ~(align - 1);
 }
@@ -10961,9 +11286,48 @@ function defineEnum(mapping, base = "u32") {
 function isEnum(type) {
   return typeof type === "object" && type.__type === "enum";
 }
+function hasPlainPrimitiveRuntimeOptions(options) {
+  return options.optional === true || options.unpackTransform !== undefined || options.packTransform !== undefined || options.lengthOf !== undefined || options.default !== undefined || options.validate !== undefined;
+}
 function isStruct(type) {
   return typeof type === "object" && type.__type === "struct";
 }
+var structInternals = new WeakMap;
+var freshPackBuffers = new WeakSet;
+function packInlineStruct(internals, view, baseOffset, obj, options) {
+  let mappedObj = internals.options?.mapValue ? internals.options.mapValue(obj) : obj;
+  if (internals.materializeArrayIterables)
+    mappedObj = internals.materializeArrayIterables(mappedObj);
+  for (const field of internals.layout) {
+    const value = mappedObj[field.name] ?? field.default;
+    if (!field.optional && value === undefined) {
+      fatalError(`Packing non-optional field '${field.name}' but value is undefined (and no default provided)`);
+    }
+    if (field.validate) {
+      for (const validateFn of field.validate) {
+        validateFn(value, field.name, {
+          hints: options?.validationHints,
+          input: mappedObj
+        });
+      }
+    }
+    field.pack(view, baseOffset + field.offset, value, mappedObj, options);
+  }
+}
+function unpackInlineStruct(internals, view, baseOffset) {
+  const result = internals.options?.default ? { ...internals.options.default } : {};
+  for (const field of internals.layout) {
+    if (!field.unpack)
+      continue;
+    try {
+      result[field.name] = field.unpack(view, baseOffset + field.offset);
+    } catch (error) {
+      console.error(`Error unpacking field '${field.name}' at offset ${field.offset}:`, error);
+      throw error;
+    }
+  }
+  return internals.options?.reduceValue ? internals.options.reduceValue(result) : result;
+}
 function primitivePackers(type) {
   let pack;
   let unpack;
@@ -11013,23 +11377,254 @@ function primitivePackers(type) {
       unpack = (view, off) => view.getFloat64(off, true);
       break;
     case "pointer":
-      pack = (view, off, val) => {
-        pointerSize === 8 ? view.setBigUint64(off, val ? BigInt(val) : 0n, true) : view.setUint32(off, val ? Number(val) : 0, true);
-      };
-      unpack = (view, off) => {
-        if (pointerSize === 8) {
-          const value = view.getBigUint64(off, true);
-          return isBun2 ? Number(value) : value;
-        }
-        return view.getUint32(off, true);
-      };
-      break;
-    default:
-      fatalError(`Unsupported primitive type: ${type}`);
+      if (pointerSize === 8 && isBun2) {
+        pack = (view, off, val) => {
+          if (!val) {
+            view.setUint32(off, 0, true);
+            view.setUint32(off + 4, 0, true);
+          } else if (typeof val === "number" && Number.isInteger(val)) {
+            view.setUint32(off, val, true);
+            view.setUint32(off + 4, Math.floor(val / 4294967296), true);
+          } else {
+            view.setBigUint64(off, BigInt(val), true);
+          }
+        };
+        unpack = (view, off) => view.getUint32(off, true) + view.getUint32(off + 4, true) * 4294967296;
+      } else {
+        pack = (view, off, val) => {
+          pointerSize === 8 ? view.setBigUint64(off, val ? BigInt(val) : 0n, true) : view.setUint32(off, val ? Number(val) : 0, true);
+        };
+        unpack = (view, off) => {
+          if (pointerSize === 8) {
+            const value = view.getBigUint64(off, true);
+            return isBun2 ? Number(value) : value;
+          }
+          return view.getUint32(off, true);
+        };
+      }
+      break;
+    default:
+      fatalError(`Unsupported primitive type: ${type}`);
   }
   return { pack, unpack };
 }
+function primitiveSetterSource(type, offset, value) {
+  const target = `baseOffset + ${offset}`;
+  switch (type) {
+    case "u8":
+      return `view.setUint8(${target}, ${value})`;
+    case "bool_u8":
+      return `view.setUint8(${target}, ${value} ? 1 : 0)`;
+    case "bool_u32":
+      return `view.setUint32(${target}, ${value} ? 1 : 0, true)`;
+    case "u16":
+      return `view.setUint16(${target}, ${value}, true)`;
+    case "i16":
+      return `view.setInt16(${target}, ${value}, true)`;
+    case "u32":
+      return `view.setUint32(${target}, ${value}, true)`;
+    case "i32":
+      return `view.setInt32(${target}, ${value}, true)`;
+    case "i64":
+      return `view.setBigInt64(${target}, BigInt(${value}), true)`;
+    case "u64":
+      return `view.setBigUint64(${target}, BigInt(${value}), true)`;
+    case "f32":
+      return `view.setFloat32(${target}, ${value}, true)`;
+    case "f64":
+      return `view.setFloat64(${target}, ${value}, true)`;
+  }
+}
+function primitiveGetterSource(type, offset) {
+  const target = `baseOffset + ${offset}`;
+  switch (type) {
+    case "u8":
+      return `view.getUint8(${target})`;
+    case "bool_u8":
+      return `Boolean(view.getUint8(${target}))`;
+    case "bool_u32":
+      return `Boolean(view.getUint32(${target}, true))`;
+    case "u16":
+      return `view.getUint16(${target}, true)`;
+    case "i16":
+      return `view.getInt16(${target}, true)`;
+    case "u32":
+      return `view.getUint32(${target}, true)`;
+    case "i32":
+      return `view.getInt32(${target}, true)`;
+    case "i64":
+      return `view.getBigInt64(${target}, true)`;
+    case "u64":
+      return `view.getBigUint64(${target}, true)`;
+    case "f32":
+      return `view.getFloat32(${target}, true)`;
+    case "f64":
+      return `view.getFloat64(${target}, true)`;
+    case "pointer":
+      if (pointerSize === 8 && isBun2) {
+        return `view.getUint32(${target}, true) + view.getUint32(${target} + 4, true) * 0x100000000`;
+      }
+      return pointerSize === 8 ? `view.getBigUint64(${target}, true)` : `view.getUint32(${target}, true)`;
+  }
+}
+function compilePlainPrimitivePackList(fields, totalSize) {
+  const writes = fields.map((field, index) => {
+    const value = `value${index}`;
+    const missing = `Packing non-optional field '${field.name}' at index `;
+    return `
+        const ${value} = obj[${JSON.stringify(field.name)}] ?? undefined
+        if (${value} === undefined) fatalError(${JSON.stringify(missing)} + index + ${JSON.stringify(" but value is undefined (and no default provided)")})
+        ${primitiveSetterSource(field.type, field.offset, value)}
+      `;
+  }).join(`
+`);
+  return new Function("fatalError", `return function packPlainPrimitiveList(objects) {
+      const buffer = new ArrayBuffer(${totalSize} * objects.length)
+      const view = new DataView(buffer)
+      for (let index = 0, baseOffset = 0; index < objects.length; index++, baseOffset += ${totalSize}) {
+        const obj = objects[index]
+        ${writes}
+      }
+      return buffer
+    }`)(fatalError);
+}
+function compilePlainPrimitivePack(fields, totalSize) {
+  const writes = fields.map((field, index) => {
+    const value = `value${index}`;
+    return `
+        const ${value} = obj[${JSON.stringify(field.name)}] ?? undefined
+        if (${value} === undefined) fatalError(${JSON.stringify(`Packing non-optional field '${field.name}' but value is undefined (and no default provided)`)})
+        ${primitiveSetterSource(field.type, field.offset, value)}
+      `;
+  }).join(`
+`);
+  return new Function("fatalError", `return function packPlainPrimitive(obj) {
+      const buffer = new ArrayBuffer(${totalSize})
+      const view = new DataView(buffer)
+      let baseOffset = 0
+      ${writes}
+      return buffer
+    }`)(fatalError);
+}
+function compilePlainPrimitivePackInto(fields) {
+  const writes = fields.map((field, index) => {
+    const value = `value${index}`;
+    return `
+        const ${value} = obj[${JSON.stringify(field.name)}] ?? undefined
+        if (${value} === undefined) {
+          console.warn(${JSON.stringify(`packInto missing value for non-optional field '${field.name}' at offset `)} + (baseOffset + ${field.offset}) + ${JSON.stringify(". Writing default or zero.")})
+        }
+        ${primitiveSetterSource(field.type, field.offset, value)}
+      `;
+  }).join(`
+`);
+  return new Function(`return function packPlainPrimitiveInto(obj, view, baseOffset) {
+      ${writes}
+    }`)();
+}
+function compilePlainPrimitivePackListInto(fields, totalSize) {
+  const writes = fields.map((field, index) => {
+    const value = `value${index}`;
+    return `
+        const ${value} = obj[${JSON.stringify(field.name)}] ?? undefined
+        if (${value} === undefined) {
+          console.warn(${JSON.stringify(`packInto missing value for non-optional field '${field.name}' at offset `)} + (baseOffset + ${field.offset}) + ${JSON.stringify(". Writing default or zero.")})
+        }
+        ${primitiveSetterSource(field.type, field.offset, value)}
+      `;
+  }).join(`
+`);
+  return new Function(`return function packPlainPrimitiveListInto(objects, view, initialOffset) {
+      for (let index = 0, baseOffset = initialOffset; index < objects.length; index++, baseOffset += ${totalSize}) {
+        const obj = objects[index]
+        ${writes}
+      }
+    }`)();
+}
+function compilePlainPrimitiveUnpackList(fields, totalSize) {
+  const reads = fields.map((field, index) => `
+        let value${index}
+        try {
+          value${index} = ${primitiveGetterSource(field.type, field.offset)}
+        } catch (error) {
+          console.error(${JSON.stringify(`Error unpacking field '${field.name}' at index `)} + index + ${JSON.stringify(", offset ")} + (baseOffset + ${field.offset}) + ":", error)
+          throw error
+        }
+      `).join(`
+`);
+  const properties = fields.map((field, index) => `${JSON.stringify(field.name)}: value${index}`).join(",");
+  return new Function(`return function unpackPlainPrimitiveList(view, count) {
+      const preallocated = Number.isSafeInteger(count) && count >= ${arrayPreallocationThreshold} && count <= ${maxArrayLength}
+      const results = preallocated ? new Array(count) : []
+      for (let index = 0, baseOffset = 0; index < count; index++, baseOffset += ${totalSize}) {
+        ${reads}
+        const value = { ${properties} }
+        if (preallocated) results[index] = value
+        else results.push(value)
+      }
+      return results
+    }`)();
+}
+function compileReducedPrimitiveUnpackList(fields, totalSize, options) {
+  const reads = fields.map((field, index) => `
+        let value${index}
+        try {
+          value${index} = ${primitiveGetterSource(field.type, field.offset)}
+        } catch (error) {
+          console.error(${JSON.stringify(`Error unpacking field '${field.name}' at index `)} + index + ${JSON.stringify(", offset ")} + (baseOffset + ${field.offset}) + ":", error)
+          throw error
+        }
+      `).join(`
+`);
+  const properties = fields.map((field, index) => `${JSON.stringify(field.name)}: value${index}`).join(",");
+  return new Function("options", `return function unpackReducedPrimitiveList(view, count) {
+      const preallocated = Number.isSafeInteger(count) && count >= ${arrayPreallocationThreshold} && count <= ${maxArrayLength}
+      const results = preallocated ? new Array(count) : []
+      for (let index = 0, baseOffset = 0; index < count; index++, baseOffset += ${totalSize}) {
+        ${reads}
+        const raw = { ${properties} }
+        const value = options.reduceValue ? options.reduceValue(raw) : raw
+        if (preallocated) results[index] = value
+        else results.push(value)
+      }
+      return results
+    }`)(options);
+}
+function compilePlainPrimitiveUnpack(fields) {
+  const reads = fields.map((field, index) => `
+        let value${index}
+        try {
+          value${index} = ${primitiveGetterSource(field.type, field.offset)}
+        } catch (error) {
+          console.error(${JSON.stringify(`Error unpacking field '${field.name}' at offset ${field.offset}:`)}, error)
+          throw error
+        }
+      `).join(`
+`);
+  const properties = fields.map((field, index) => `${JSON.stringify(field.name)}: value${index}`).join(",");
+  return new Function(`return function unpackPlainPrimitive(view) {
+      let baseOffset = 0
+      ${reads}
+      return { ${properties} }
+    }`)();
+}
+function compilePlainPrimitiveUnpackInto(fields) {
+  const reads = fields.map((field) => `
+        try {
+          target[${JSON.stringify(field.name)}] = ${primitiveGetterSource(field.type, field.offset)}
+        } catch (error) {
+          console.error(${JSON.stringify(`Error unpacking field '${field.name}' at offset ${field.offset}:`)}, error)
+          throw error
+        }
+      `).join(`
+`);
+  return new Function(`return function unpackPlainPrimitiveInto(view, target, baseOffset) {
+      ${reads}
+      return target
+    }`)();
+}
 var { pack: pointerPacker, unpack: pointerUnpacker } = primitivePackers("pointer");
+var foreignMemoryPointerUnpacker = pointerSize === 8 && isBun2 ? (view, off) => Number(view.getBigUint64(off, true)) : pointerUnpacker;
 var retainedPointerTargets = new WeakMap;
 function retainPointerTarget(owner, target) {
   const retained = retainedPointerTargets.get(owner);
@@ -11040,9 +11635,8 @@ function retainPointerTarget(owner, target) {
   }
 }
 function retainIfPointerTargets(owner, target) {
-  if (retainedPointerTargets.has(target)) {
+  if (retainedPointerTargets.has(target))
     retainPointerTarget(owner, target);
-  }
 }
 function isNullPointer(pointer) {
   return pointer == null || pointer === 0 || pointer === 0n;
@@ -11050,6 +11644,9 @@ function isNullPointer(pointer) {
 function toItemCount(length) {
   return typeof length === "bigint" ? Number(length) : length;
 }
+var arrayPreallocationThreshold = 256;
+var plainPrimitiveSpecializationThreshold = 256;
+var maxArrayLength = 4294967295;
 function packObjectArray(val) {
   const buffer = new ArrayBuffer(val.length * pointerSize);
   const bufferView = new DataView(buffer);
@@ -11065,10 +11662,15 @@ var decoder = new TextDecoder;
 function defineStruct(fields, structDefOptions) {
   let offset = 0;
   let maxAlign = 1;
+  let hasDirectInlinePack = false;
+  let directInlineUnpackSafe = !structDefOptions?.default && !structDefOptions?.reduceValue;
+  let plainPrimitiveFields = structDefOptions?.mapValue || structDefOptions?.default || structDefOptions?.reduceValue ? null : [];
+  let primitiveDecodeFields = structDefOptions?.reduceValue && !structDefOptions.default ? [] : null;
   const layout = [];
   const lengthOfFields = {};
   const lengthOfRequested = [];
   const arrayFieldsMetadata = {};
+  const arrayElementSizes = {};
   for (const [name, typeOrStruct, options = {}] of fields) {
     if (options.condition && !options.condition()) {
       continue;
@@ -11078,6 +11680,7 @@ function defineStruct(fields, structDefOptions) {
     let unpack;
     let needsLengthOf = false;
     let lengthOfDef = null;
+    let plainPrimitiveType = null;
     if (isPrimitiveType(typeOrStruct)) {
       size = typeSizes[typeOrStruct];
       align = typeAlignments[typeOrStruct];
@@ -11096,7 +11699,14 @@ function defineStruct(fields, structDefOptions) {
           pointerPacker(view, off, val);
         };
       }
+      if (plainPrimitiveFields) {
+        if (typeOrStruct === "pointer" || hasPlainPrimitiveRuntimeOptions(options))
+          plainPrimitiveFields = null;
+        else
+          plainPrimitiveType = typeOrStruct;
+      }
     } else if (typeof typeOrStruct === "string" && typeOrStruct === "cstring") {
+      plainPrimitiveFields = null;
       size = pointerSize;
       align = pointerSize;
       pack = (view, off, val) => {
@@ -11114,6 +11724,7 @@ function defineStruct(fields, structDefOptions) {
         return ptrVal;
       };
     } else if (typeof typeOrStruct === "string" && typeOrStruct === "char*") {
+      plainPrimitiveFields = null;
       size = pointerSize;
       align = pointerSize;
       pack = (view, off, val) => {
@@ -11132,6 +11743,8 @@ function defineStruct(fields, structDefOptions) {
       };
       needsLengthOf = true;
     } else if (isEnum(typeOrStruct)) {
+      plainPrimitiveFields = null;
+      directInlineUnpackSafe = false;
       const base = typeOrStruct.type;
       size = typeSizes[base];
       align = typeAlignments[base];
@@ -11145,7 +11758,9 @@ function defineStruct(fields, structDefOptions) {
         return typeOrStruct.from(raw);
       };
     } else if (isStruct(typeOrStruct)) {
+      plainPrimitiveFields = null;
       if (options.asPointer === true) {
+        directInlineUnpackSafe = false;
         size = pointerSize;
         align = pointerSize;
         pack = (view, off, val, obj, options2) => {
@@ -11163,19 +11778,33 @@ function defineStruct(fields, structDefOptions) {
       } else {
         size = typeOrStruct.size;
         align = typeOrStruct.align;
-        pack = (view, off, val, obj, options2) => {
-          const nestedBuf = typeOrStruct.pack(val, options2);
+        const internals = structInternals.get(typeOrStruct);
+        directInlineUnpackSafe &&= !!internals?.directInlineUnpackSafe;
+        hasDirectInlinePack ||= !!internals && !options.optional;
+        pack = (view, off, val, obj, packOptions) => {
+          const publicPack = typeOrStruct.pack;
+          if (internals && freshPackBuffers.has(view.buffer) && publicPack === internals.publicPack) {
+            packInlineStruct(internals, view, off, val, packOptions);
+            return;
+          }
+          const nestedBuf = Reflect.apply(publicPack, typeOrStruct, [val, packOptions]);
           const nestedView = new Uint8Array(nestedBuf);
-          const dView = new Uint8Array(view.buffer);
+          const dView = new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
           dView.set(nestedView, off);
           retainIfPointerTargets(view.buffer, nestedBuf);
         };
         unpack = (view, off) => {
-          const slice = view.buffer.slice(off, off + size);
+          const publicUnpack = Object.getOwnPropertyDescriptor(typeOrStruct, "unpack")?.value;
+          if (internals?.directInlineUnpackSafe && publicUnpack === internals.publicUnpack && !(view.buffer instanceof SharedArrayBuffer)) {
+            return unpackInlineStruct(internals, view, off);
+          }
+          const start = view.byteOffset + off;
+          const slice = view.buffer.slice(start, start + size);
           return typeOrStruct.unpack(slice);
         };
       }
     } else if (isObjectPointerDef(typeOrStruct)) {
+      plainPrimitiveFields = null;
       size = pointerSize;
       align = pointerSize;
       pack = (view, off, value) => {
@@ -11191,12 +11820,15 @@ function defineStruct(fields, structDefOptions) {
         return pointerUnpacker(view, off);
       };
     } else if (Array.isArray(typeOrStruct) && typeOrStruct.length === 1 && typeOrStruct[0] !== undefined) {
+      plainPrimitiveFields = null;
       const [def] = typeOrStruct;
       size = pointerSize;
       align = pointerSize;
       let arrayElementSize;
       if (isEnum(def)) {
+        directInlineUnpackSafe = false;
         arrayElementSize = typeSizes[def.type];
+        const { pack: enumPack } = primitivePackers(def.type);
         pack = (view, off, val, obj) => {
           if (!val || val.length === 0) {
             pointerPacker(view, off, null);
@@ -11206,7 +11838,7 @@ function defineStruct(fields, structDefOptions) {
           const bufferView = new DataView(buffer);
           for (let i = 0;i < val.length; i++) {
             const num = def.to(val[i]);
-            bufferView.setUint32(i * arrayElementSize, num, true);
+            enumPack(bufferView, i * arrayElementSize, num);
           }
           pointerPacker(view, off, ptr2(buffer));
           retainPointerTarget(view.buffer, buffer);
@@ -11215,7 +11847,9 @@ function defineStruct(fields, structDefOptions) {
         needsLengthOf = true;
         lengthOfDef = def;
       } else if (isStruct(def)) {
+        directInlineUnpackSafe = false;
         arrayElementSize = def.size;
+        const defInternals = structInternals.get(def);
         pack = (view, off, val, obj, options2) => {
           if (!val || val.length === 0) {
             pointerPacker(view, off, null);
@@ -11223,8 +11857,19 @@ function defineStruct(fields, structDefOptions) {
           }
           const buffer = new ArrayBuffer(val.length * arrayElementSize);
           const bufferView = new DataView(buffer);
-          for (let i = 0;i < val.length; i++) {
-            def.packInto(val[i], bufferView, i * arrayElementSize, options2);
+          if (defInternals?.hasDirectInlinePack) {
+            freshPackBuffers.add(buffer);
+            try {
+              for (let i = 0;i < val.length; i++) {
+                def.packInto(val[i], bufferView, i * arrayElementSize, options2);
+              }
+            } finally {
+              freshPackBuffers.delete(buffer);
+            }
+          } else {
+            for (let i = 0;i < val.length; i++) {
+              def.packInto(val[i], bufferView, i * arrayElementSize, options2);
+            }
           }
           pointerPacker(view, off, ptr2(buffer));
           retainPointerTarget(view.buffer, buffer);
@@ -11252,6 +11897,7 @@ function defineStruct(fields, structDefOptions) {
         needsLengthOf = true;
         lengthOfDef = def;
       } else if (isObjectPointerDef(def)) {
+        directInlineUnpackSafe = false;
         arrayElementSize = pointerSize;
         pack = (view, off, val) => {
           if (!val || val.length === 0) {
@@ -11268,21 +11914,23 @@ function defineStruct(fields, structDefOptions) {
       } else {
         throw new Error(`Unsupported array element type for ${name}: ${JSON.stringify(def)}`);
       }
-      const lengthOfField = Object.values(lengthOfFields).find((f) => f.lengthOf === name);
-      if (lengthOfField && isPrimitiveType(lengthOfField.type)) {
-        const { pack: lengthPack } = primitivePackers(lengthOfField.type);
-        arrayFieldsMetadata[name] = {
-          elementSize: arrayElementSize,
-          arrayOffset: offset,
-          lengthOffset: lengthOfField.offset,
-          lengthPack
-        };
-      }
+      arrayElementSizes[name] = arrayElementSize;
     } else {
       throw new Error(`Unsupported field type for ${name}: ${JSON.stringify(typeOrStruct)}`);
     }
     offset = alignOffset(offset, align);
+    if (plainPrimitiveFields && plainPrimitiveType) {
+      plainPrimitiveFields.push({ name, offset, type: plainPrimitiveType });
+    }
+    if (primitiveDecodeFields) {
+      if (isPrimitiveType(typeOrStruct) && !options.unpackTransform) {
+        primitiveDecodeFields.push({ name, offset, type: typeOrStruct });
+      } else {
+        primitiveDecodeFields = null;
+      }
+    }
     if (options.unpackTransform) {
+      directInlineUnpackSafe = false;
       const originalUnpack = unpack;
       unpack = (view, off) => options.unpackTransform(originalUnpack(view, off));
     }
@@ -11331,6 +11979,7 @@ function defineStruct(fields, structDefOptions) {
       default: options.default,
       pack,
       unpack,
+      unpackTransform: options.unpackTransform,
       type: typeOrStruct,
       lengthOf: options.lengthOf
     };
@@ -11347,6 +11996,19 @@ function defineStruct(fields, structDefOptions) {
     offset += size;
     maxAlign = Math.max(maxAlign, align);
   }
+  for (const [arrayName, lengthOfField] of Object.entries(lengthOfFields)) {
+    const arrayField = layout.find((field) => field.name === arrayName);
+    const elementSize = arrayElementSizes[arrayName];
+    if (!arrayField || elementSize === undefined || !isPrimitiveType(lengthOfField.type))
+      continue;
+    const { pack: lengthPack } = primitivePackers(lengthOfField.type);
+    arrayFieldsMetadata[arrayName] = {
+      elementSize,
+      arrayOffset: arrayField.offset,
+      lengthOffset: lengthOfField.offset,
+      lengthPack
+    };
+  }
   for (const { requester, def } of lengthOfRequested) {
     const lengthOfField = lengthOfFields[requester.name];
     if (!lengthOfField) {
@@ -11358,7 +12020,7 @@ function defineStruct(fields, structDefOptions) {
     if (def === "char*") {
       const relativeOffset = lengthOfField.offset - requester.offset;
       requester.unpack = (view, off) => {
-        const ptrAddress = pointerUnpacker(view, off);
+        const ptrAddress = foreignMemoryPointerUnpacker(view, off);
         const length = lengthOfField.unpack(view, off + relativeOffset);
         if (isNullPointer(ptrAddress)) {
           return null;
@@ -11375,10 +12037,9 @@ function defineStruct(fields, structDefOptions) {
       const { unpack: primitiveUnpack } = primitivePackers(def);
       const relativeOffset = lengthOfField.offset - requester.offset;
       requester.unpack = (view, off) => {
-        const result = [];
         const length = lengthOfField.unpack(view, off + relativeOffset);
         const itemCount = toItemCount(length);
-        const ptrAddress = pointerUnpacker(view, off);
+        const ptrAddress = foreignMemoryPointerUnpacker(view, off);
         if (isNullPointer(ptrAddress) && itemCount > 0) {
           throw new Error(`Array field ${requester.name} has null pointer but length ${length}.`);
         }
@@ -11387,19 +12048,26 @@ function defineStruct(fields, structDefOptions) {
         }
         const buffer = toArrayBuffer2(ptrAddress, 0, itemCount * elemSize);
         const bufferView = new DataView(buffer);
-        for (let i = 0;i < itemCount; i++) {
-          result.push(primitiveUnpack(bufferView, i * elemSize));
+        if (Number.isSafeInteger(itemCount) && itemCount >= arrayPreallocationThreshold && itemCount <= maxArrayLength) {
+          const result2 = new Array(itemCount);
+          for (let i = 0;i < itemCount; i++) {
+            result2[i] = primitiveUnpack(bufferView, i * elemSize);
+          }
+          return result2;
         }
+        const result = [];
+        for (let i = 0;i < itemCount; i++)
+          result.push(primitiveUnpack(bufferView, i * elemSize));
         return result;
       };
     } else {
-      const elemSize = def.type === "u32" ? 4 : 8;
+      const elemSize = typeSizes[def.type];
+      const { unpack: enumUnpack } = primitivePackers(def.type);
       const relativeOffset = lengthOfField.offset - requester.offset;
       requester.unpack = (view, off) => {
-        const result = [];
         const length = lengthOfField.unpack(view, off + relativeOffset);
         const itemCount = toItemCount(length);
-        const ptrAddress = pointerUnpacker(view, off);
+        const ptrAddress = foreignMemoryPointerUnpacker(view, off);
         if (isNullPointer(ptrAddress) && itemCount > 0) {
           throw new Error(`Array field ${requester.name} has null pointer but length ${length}.`);
         }
@@ -11408,12 +12076,23 @@ function defineStruct(fields, structDefOptions) {
         }
         const buffer = toArrayBuffer2(ptrAddress, 0, itemCount * elemSize);
         const bufferView = new DataView(buffer);
-        for (let i = 0;i < itemCount; i++) {
-          result.push(def.from(bufferView.getUint32(i * elemSize, true)));
+        if (Number.isSafeInteger(itemCount) && itemCount >= arrayPreallocationThreshold && itemCount <= maxArrayLength) {
+          const result2 = new Array(itemCount);
+          for (let i = 0;i < itemCount; i++) {
+            result2[i] = def.from(enumUnpack(bufferView, i * elemSize));
+          }
+          return result2;
         }
+        const result = [];
+        for (let i = 0;i < itemCount; i++)
+          result.push(def.from(enumUnpack(bufferView, i * elemSize)));
         return result;
       };
     }
+    if (requester.unpackTransform) {
+      const originalUnpack = requester.unpack;
+      requester.unpack = (view, off) => requester.unpackTransform(originalUnpack(view, off));
+    }
   }
   const totalSize = alignOffset(offset, maxAlign);
   const description = layout.map((f) => ({
@@ -11427,7 +12106,87 @@ function defineStruct(fields, structDefOptions) {
   }));
   const layoutByName = new Map(description.map((f) => [f.name, f]));
   const arrayFields = new Map(Object.entries(arrayFieldsMetadata));
-  return {
+  const iterableArrayFields = layout.filter((field) => Array.isArray(field.type));
+  if (plainPrimitiveFields?.length !== layout.length || plainPrimitiveFields.length === 0)
+    plainPrimitiveFields = null;
+  const supportsPackListInto = !!plainPrimitiveFields;
+  if (primitiveDecodeFields?.length !== layout.length || primitiveDecodeFields.length === 0) {
+    primitiveDecodeFields = null;
+  }
+  let plainPrimitivePackList;
+  let plainPrimitiveUnpackList;
+  let reducedPrimitiveUnpackList;
+  let plainPrimitivePack;
+  let plainPrimitivePackInto;
+  let plainPrimitivePackListInto;
+  let plainPrimitiveUnpack;
+  let plainPrimitiveUnpackInto;
+  let plainPrimitivePackListItems = 0;
+  let plainPrimitivePackListIntoItems = 0;
+  let plainPrimitiveUnpackListItems = 0;
+  let reducedPrimitiveUnpackListItems = 0;
+  let plainPrimitivePackCalls = 0;
+  let plainPrimitivePackIntoCalls = 0;
+  let plainPrimitiveUnpackCalls = 0;
+  let plainPrimitiveUnpackIntoCalls = 0;
+  const compilePlainPrimitive = (compile) => {
+    try {
+      return compile();
+    } catch (error) {
+      if (!(error instanceof EvalError))
+        throw error;
+      plainPrimitiveFields = null;
+      primitiveDecodeFields = null;
+      return;
+    }
+  };
+  const validateDecodeRange = (view, decodeOffset) => {
+    if (!Number.isSafeInteger(decodeOffset) || decodeOffset < 0) {
+      throw new RangeError(`Decode offset must be a non-negative safe integer, got ${decodeOffset}`);
+    }
+    if (decodeOffset > view.byteLength - totalSize) {
+      throw new RangeError(`DataView range (${view.byteLength} bytes) is too small for a struct at offset ${decodeOffset}`);
+    }
+  };
+  const decodeFieldsInto = (target, view, baseOffset) => {
+    if (structDefOptions?.default)
+      Object.assign(target, structDefOptions.default);
+    for (const field of layout) {
+      if (!field.unpack)
+        continue;
+      try {
+        target[field.name] = field.unpack(view, baseOffset + field.offset);
+      } catch (error) {
+        console.error(`Error unpacking field '${field.name}' at offset ${field.offset}:`, error);
+        throw error;
+      }
+    }
+  };
+  const unpackInto = (view, target, decodeOffset = 0) => {
+    validateDecodeRange(view, decodeOffset);
+    if (plainPrimitiveFields && (plainPrimitiveUnpackInto || ++plainPrimitiveUnpackIntoCalls >= plainPrimitiveSpecializationThreshold)) {
+      plainPrimitiveUnpackInto ??= compilePlainPrimitive(() => compilePlainPrimitiveUnpackInto(plainPrimitiveFields));
+      if (plainPrimitiveUnpackInto)
+        return plainPrimitiveUnpackInto(view, target, decodeOffset);
+    }
+    decodeFieldsInto(target, view, decodeOffset);
+    return target;
+  };
+  const materializeArrayIterables = iterableArrayFields.length === 0 ? null : (obj) => {
+    let normalized = obj;
+    for (const field of iterableArrayFields) {
+      const value = obj[field.name];
+      if (value == null || Array.isArray(value) || ArrayBuffer.isView(value))
+        continue;
+      if (typeof value[Symbol.iterator] !== "function")
+        continue;
+      if (normalized === obj)
+        normalized = { ...obj };
+      normalized[field.name] = Array.from(value);
+    }
+    return normalized;
+  };
+  const definition = {
     __type: "struct",
     size: totalSize,
     align: maxAlign,
@@ -11435,34 +12194,57 @@ function defineStruct(fields, structDefOptions) {
     layoutByName,
     arrayFields,
     pack(obj, options) {
+      if (plainPrimitiveFields && (plainPrimitivePack || ++plainPrimitivePackCalls >= plainPrimitiveSpecializationThreshold)) {
+        plainPrimitivePack ??= compilePlainPrimitive(() => compilePlainPrimitivePack(plainPrimitiveFields, totalSize));
+        if (plainPrimitivePack)
+          return plainPrimitivePack(obj);
+      }
       const buf = new ArrayBuffer(totalSize);
       const view = new DataView(buf);
       let mappedObj = obj;
       if (structDefOptions?.mapValue) {
         mappedObj = structDefOptions.mapValue(obj);
       }
-      for (const field of layout) {
-        const value = mappedObj[field.name] ?? field.default;
-        if (!field.optional && value === undefined) {
-          fatalError(`Packing non-optional field '${field.name}' but value is undefined (and no default provided)`);
-        }
-        if (field.validate) {
-          for (const validateFn of field.validate) {
-            validateFn(value, field.name, {
-              hints: options?.validationHints,
-              input: mappedObj
-            });
+      if (materializeArrayIterables)
+        mappedObj = materializeArrayIterables(mappedObj);
+      if (hasDirectInlinePack)
+        freshPackBuffers.add(buf);
+      try {
+        for (const field of layout) {
+          const value = mappedObj[field.name] ?? field.default;
+          if (!field.optional && value === undefined) {
+            fatalError(`Packing non-optional field '${field.name}' but value is undefined (and no default provided)`);
           }
+          if (field.validate) {
+            for (const validateFn of field.validate) {
+              validateFn(value, field.name, {
+                hints: options?.validationHints,
+                input: mappedObj
+              });
+            }
+          }
+          field.pack(view, field.offset, value, mappedObj, options);
         }
-        field.pack(view, field.offset, value, mappedObj, options);
+      } finally {
+        if (hasDirectInlinePack)
+          freshPackBuffers.delete(buf);
       }
       return view.buffer;
     },
     packInto(obj, view, offset2, options) {
+      if (plainPrimitiveFields && (plainPrimitivePackInto || ++plainPrimitivePackIntoCalls >= plainPrimitiveSpecializationThreshold)) {
+        plainPrimitivePackInto ??= compilePlainPrimitive(() => compilePlainPrimitivePackInto(plainPrimitiveFields));
+        if (plainPrimitivePackInto) {
+          plainPrimitivePackInto(obj, view, offset2);
+          return;
+        }
+      }
       let mappedObj = obj;
       if (structDefOptions?.mapValue) {
         mappedObj = structDefOptions.mapValue(obj);
       }
+      if (materializeArrayIterables)
+        mappedObj = materializeArrayIterables(mappedObj);
       for (const field of layout) {
         const value = mappedObj[field.name] ?? field.default;
         if (!field.optional && value === undefined) {
@@ -11484,6 +12266,11 @@ function defineStruct(fields, structDefOptions) {
         fatalError(`Buffer size (${buf.byteLength}) is smaller than struct size (${totalSize}) for unpacking.`);
       }
       const view = new DataView(buf);
+      if (plainPrimitiveFields && (plainPrimitiveUnpack || ++plainPrimitiveUnpackCalls >= plainPrimitiveSpecializationThreshold)) {
+        plainPrimitiveUnpack ??= compilePlainPrimitive(() => compilePlainPrimitiveUnpack(plainPrimitiveFields));
+        if (plainPrimitiveUnpack)
+          return plainPrimitiveUnpack(view);
+      }
       const result = structDefOptions?.default ? { ...structDefOptions.default } : {};
       for (const field of layout) {
         if (!field.unpack) {
@@ -11505,31 +12292,67 @@ function defineStruct(fields, structDefOptions) {
       if (objects.length === 0) {
         return new ArrayBuffer(0);
       }
+      if (plainPrimitiveFields) {
+        plainPrimitivePackListItems += objects.length;
+        if (plainPrimitivePackList || objects.length > 1 && plainPrimitivePackListItems >= plainPrimitiveSpecializationThreshold) {
+          plainPrimitivePackList ??= compilePlainPrimitive(() => compilePlainPrimitivePackList(plainPrimitiveFields, totalSize));
+          if (plainPrimitivePackList)
+            return plainPrimitivePackList(objects);
+        }
+      }
       const buffer = new ArrayBuffer(totalSize * objects.length);
       const view = new DataView(buffer);
-      for (let i = 0;i < objects.length; i++) {
-        let mappedObj = objects[i];
-        if (structDefOptions?.mapValue) {
-          mappedObj = structDefOptions.mapValue(objects[i]);
-        }
-        for (const field of layout) {
-          const value = mappedObj[field.name] ?? field.default;
-          if (!field.optional && value === undefined) {
-            fatalError(`Packing non-optional field '${field.name}' at index ${i} but value is undefined (and no default provided)`);
+      if (hasDirectInlinePack)
+        freshPackBuffers.add(buffer);
+      try {
+        for (let i = 0;i < objects.length; i++) {
+          let mappedObj = objects[i];
+          if (structDefOptions?.mapValue) {
+            mappedObj = structDefOptions.mapValue(objects[i]);
           }
-          if (field.validate) {
-            for (const validateFn of field.validate) {
-              validateFn(value, field.name, {
-                hints: options?.validationHints,
-                input: mappedObj
-              });
+          if (materializeArrayIterables)
+            mappedObj = materializeArrayIterables(mappedObj);
+          for (const field of layout) {
+            const value = mappedObj[field.name] ?? field.default;
+            if (!field.optional && value === undefined) {
+              fatalError(`Packing non-optional field '${field.name}' at index ${i} but value is undefined (and no default provided)`);
+            }
+            if (field.validate) {
+              for (const validateFn of field.validate) {
+                validateFn(value, field.name, {
+                  hints: options?.validationHints,
+                  input: mappedObj
+                });
+              }
             }
+            field.pack(view, i * totalSize + field.offset, value, mappedObj, options);
           }
-          field.pack(view, i * totalSize + field.offset, value, mappedObj, options);
         }
+      } finally {
+        if (hasDirectInlinePack)
+          freshPackBuffers.delete(buffer);
       }
       return buffer;
     },
+    packListInto(objects, view, offset2, options) {
+      if (objects.length === 0)
+        return;
+      if (!supportsPackListInto)
+        throw new Error("packListInto only supports required primitive fields");
+      if (plainPrimitiveFields) {
+        plainPrimitivePackListIntoItems += objects.length;
+        if (plainPrimitivePackListInto || objects.length > 1 && plainPrimitivePackListIntoItems >= plainPrimitiveSpecializationThreshold) {
+          plainPrimitivePackListInto ??= compilePlainPrimitive(() => compilePlainPrimitivePackListInto(plainPrimitiveFields, totalSize));
+          if (plainPrimitivePackListInto) {
+            plainPrimitivePackListInto(objects, view, offset2);
+            return;
+          }
+        }
+      }
+      for (let index = 0;index < objects.length; index += 1) {
+        definition.packInto(objects[index], view, offset2 + index * totalSize, options);
+      }
+    },
     unpackList(buf, count) {
       if (count === 0) {
         return [];
@@ -11539,7 +12362,24 @@ function defineStruct(fields, structDefOptions) {
         fatalError(`Buffer size (${buf.byteLength}) is smaller than expected size (${expectedSize}) for unpacking ${count} structs.`);
       }
       const view = new DataView(buf);
-      const results = [];
+      if (plainPrimitiveFields && Number.isSafeInteger(count) && count > 1) {
+        plainPrimitiveUnpackListItems += count;
+        if (plainPrimitiveUnpackList || plainPrimitiveUnpackListItems >= plainPrimitiveSpecializationThreshold) {
+          plainPrimitiveUnpackList ??= compilePlainPrimitive(() => compilePlainPrimitiveUnpackList(plainPrimitiveFields, totalSize));
+          if (plainPrimitiveUnpackList)
+            return plainPrimitiveUnpackList(view, count);
+        }
+      }
+      if (!plainPrimitiveFields && primitiveDecodeFields && Number.isSafeInteger(count) && count > 1) {
+        reducedPrimitiveUnpackListItems += count;
+        if (reducedPrimitiveUnpackList || reducedPrimitiveUnpackListItems >= plainPrimitiveSpecializationThreshold) {
+          reducedPrimitiveUnpackList ??= compilePlainPrimitive(() => compileReducedPrimitiveUnpackList(primitiveDecodeFields, totalSize, structDefOptions));
+          if (reducedPrimitiveUnpackList)
+            return reducedPrimitiveUnpackList(view, count);
+        }
+      }
+      const preallocated = Number.isSafeInteger(count) && count >= arrayPreallocationThreshold && count <= maxArrayLength;
+      const results = preallocated ? new Array(count) : [];
       for (let i = 0;i < count; i++) {
         const offset2 = i * totalSize;
         const result = structDefOptions?.default ? { ...structDefOptions.default } : {};
@@ -11555,9 +12395,16 @@ function defineStruct(fields, structDefOptions) {
           }
         }
         if (structDefOptions?.reduceValue) {
-          results.push(structDefOptions.reduceValue(result));
+          const value = structDefOptions.reduceValue(result);
+          if (preallocated)
+            results[i] = value;
+          else
+            results.push(value);
         } else {
-          results.push(result);
+          if (preallocated)
+            results[i] = result;
+          else
+            results.push(result);
         }
       }
       return results;
@@ -11566,6 +12413,18 @@ function defineStruct(fields, structDefOptions) {
       return description;
     }
   };
+  if (!structDefOptions?.reduceValue)
+    Object.assign(definition, { unpackInto });
+  structInternals.set(definition, {
+    layout,
+    options: structDefOptions,
+    publicPack: definition.pack,
+    publicUnpack: definition.unpack,
+    hasDirectInlinePack,
+    directInlineUnpackSafe,
+    materializeArrayIterables
+  });
+  return definition;
 }
 
 // src/zig-structs.ts
@@ -11636,6 +12495,7 @@ var VisualCursorStruct = defineStruct([
 var UnicodeMethodEnum = defineEnum({ wcwidth: 0, unicode: 1 }, "u8");
 var TerminalMultiplexerEnum = defineEnum({ none: 0, tmux: 1, zellij: 2, screen: 3, unknown: 4 }, "u8");
 var Osc52SupportEnum = defineEnum({ unknown: 0, supported: 1, unsupported: 2 }, "u8");
+var ImageProtocolEnum = defineEnum({ auto: 0, kitty: 1, sixel: 2, blocks: 3 }, "u8");
 var TerminalCapabilitiesStruct = defineStruct([
   ["kitty_keyboard", "bool_u8"],
   ["kitty_graphics", "bool_u8"],
@@ -11656,6 +12516,7 @@ var TerminalCapabilitiesStruct = defineStruct([
   ["explicit_cursor_positioning", "bool_u8"],
   ["remote", "bool_u8"],
   ["multiplexer", TerminalMultiplexerEnum],
+  ["image_protocol", ImageProtocolEnum],
   ["term_name", "char*"],
   ["term_name_len", "u64", { lengthOf: "term_name" }],
   ["term_version", "char*"],
@@ -11667,6 +12528,29 @@ var EncodedCharStruct = defineStruct([
   ["width", "u8"],
   ["char", "u32"]
 ]);
+var NativeImageInfoStruct = defineStruct([
+  ["width", "u32"],
+  ["height", "u32"],
+  ["sourceWidth", "u32"],
+  ["sourceHeight", "u32"],
+  ["format", "u32"],
+  ["colorStatus", "u32"],
+  ["orientation", "u32"],
+  ["hasAlpha", "u32"]
+]);
+var ImageDrawOptionsStruct = defineStruct([
+  ["x", "i32"],
+  ["y", "i32"],
+  ["width", "u32"],
+  ["height", "u32"],
+  ["pixelWidth", "u32"],
+  ["pixelHeight", "u32"],
+  ["sourceX", "u32"],
+  ["sourceY", "u32"],
+  ["sourceWidth", "u32"],
+  ["sourceHeight", "u32"],
+  ["protocol", "u32"]
+]);
 var LineInfoStruct = defineStruct([
   ["startCols", ["u32"]],
   ["startColsLen", "u32", { lengthOf: "startCols" }],
@@ -11849,6 +12733,15 @@ var AudioStreamStatsStruct = defineStruct([
   ["errorCode", "i32"],
   ["readyGeneration", "u32"]
 ]);
+var AudioCaptureStatsStruct = defineStruct([
+  ["framesReceived", "u64"],
+  ["framesRead", "u64"],
+  ["framesDropped", "u64"],
+  ["sampleRate", "u32"],
+  ["channels", "u32"],
+  ["bufferedFrames", "u32"],
+  ["capacityFrames", "u32"]
+]);
 var AudioStatsStruct = defineStruct([
   ["soundsLoaded", "u32"],
   ["voicesActive", "u32"],
@@ -11868,51 +12761,18 @@ registerEnvVar({
   type: "string",
   default: ""
 });
-function validateLinuxLibcOverride() {
-  const libc = process.env.OPENTUI_LIBC;
-  if (libc === undefined || libc === "" || libc === "glibc" || libc === "musl")
-    return;
-  throw new Error(`On Linux, OPENTUI_LIBC must be unset, empty, "glibc", or "musl", got "${libc}"`);
-}
-async function resolveNativePackage() {
-  if (process.platform === "darwin") {
-    if (process.arch === "x64")
-      return await import("@opentui/core-darwin-x64");
-    if (process.arch === "arm64")
-      return await import("@opentui/core-darwin-arm64");
-  }
-  if (process.platform === "linux") {
-    validateLinuxLibcOverride();
-    if (process.arch === "x64") {
-      if (process.env.OPENTUI_LIBC === "musl") {
-        return await import("@opentui/core-linux-x64-musl");
-      } else {
-        return await import("@opentui/core-linux-x64");
-      }
-    }
-    if (process.arch === "arm64") {
-      if (process.env.OPENTUI_LIBC === "musl") {
-        return await import("@opentui/core-linux-arm64-musl");
-      } else {
-        return await import("@opentui/core-linux-arm64");
-      }
-    }
+var targetLibPath;
+var targetLibError;
+try {
+  targetLibPath = await resolveNativeLibraryPath();
+  if (isBunfsPath(targetLibPath)) {
+    targetLibPath = targetLibPath.replace("../", "");
   }
-  if (process.platform === "win32") {
-    if (process.arch === "x64")
-      return await import("@opentui/core-win32-x64");
-    if (process.arch === "arm64")
-      return await import("@opentui/core-win32-arm64");
+  if (!existsSync3(targetLibPath)) {
+    throw new Error(`OpenTUI native library does not exist at ${JSON.stringify(targetLibPath)}`);
   }
-  throw new Error(`opentui is not supported on the current platform: ${process.platform}-${process.arch}`);
-}
-var nativePackage = await resolveNativePackage();
-var targetLibPath = nativePackage.default;
-if (isBunfsPath(targetLibPath)) {
-  targetLibPath = targetLibPath.replace("../", "");
-}
-if (!existsSync3(targetLibPath)) {
-  throw new Error(`opentui is not supported on the current platform: ${process.platform}-${process.arch}`);
+} catch (error) {
+  targetLibError = error instanceof Error ? error : new Error(String(error));
 }
 registerEnvVar({
   name: "OTUI_DEBUG_FFI",
@@ -11928,27 +12788,33 @@ registerEnvVar({
 });
 registerEnvVar({
   name: "OPENTUI_FORCE_WCWIDTH",
-  description: "Use wcwidth for character width calculations",
-  type: "boolean",
-  default: false
+  description: "Use wcwidth for character width calculations when the variable is present",
+  type: "string",
+  required: false
 });
 registerEnvVar({
   name: "OPENTUI_FORCE_UNICODE",
-  description: "Force Mode 2026 Unicode support in terminal capabilities",
-  type: "boolean",
-  default: false
+  description: "Force Mode 2026 Unicode support when the variable is present",
+  type: "string",
+  required: false
 });
 registerEnvVar({
   name: "OPENTUI_GRAPHICS",
-  description: "Enable Kitty graphics protocol detection",
-  type: "boolean",
-  default: true
+  description: "Control Kitty and Sixel graphics detection with the exact value true, 1, false, or 0",
+  type: "string",
+  required: false
+});
+registerEnvVar({
+  name: "OPENTUI_IMAGE_PROTOCOL",
+  description: "Override image rendering protocol: auto, kitty, sixel, or blocks",
+  type: "string",
+  default: "auto"
 });
 registerEnvVar({
   name: "OPENTUI_FORCE_NOZWJ",
-  description: "Use no_zwj width method (Unicode without ZWJ joining)",
-  type: "boolean",
-  default: false
+  description: "Use no_zwj width mode when the variable is present",
+  type: "string",
+  required: false
 });
 var CURSOR_STYLE_TO_ID = { block: 0, line: 1, underline: 2, default: 3 };
 var CURSOR_ID_TO_STYLE = ["block", "line", "underline", "default"];
@@ -11989,6 +12855,9 @@ function optionalRgbaPtr(value) {
 }
 function getOpenTUILib(libPath) {
   const resolvedLibPath = libPath || targetLibPath;
+  if (!resolvedLibPath) {
+    throw targetLibError ?? new Error(`OpenTUI is not supported on the current platform: ${process.platform}-${process.arch}`);
+  }
   const rawSymbols = dlopen(resolvedLibPath, {
     setLogCallback: {
       args: ["ptr"],
@@ -12262,6 +13131,10 @@ function getOpenTUILib(libPath) {
       args: ["u32", "u32", "u32", "ptr", "u32", "u8", "u32"],
       returns: "void"
     },
+    bufferDrawImage: {
+      args: ["u32", "u32", "ptr"],
+      returns: "u8"
+    },
     bufferDrawPackedBuffer: {
       args: ["u32", "ptr", "u32", "u32", "u32", "u32", "u32"],
       returns: "void"
@@ -12962,6 +13835,19 @@ function getOpenTUILib(libPath) {
       args: ["u32"],
       returns: "u32"
     },
+    imageInfo: { args: ["ptr", "u32", "ptr"], returns: "u32" },
+    imageDecode: { args: ["ptr", "u32", "ptr"], returns: "u32" },
+    imageCreateFromRgba: { args: ["ptr", "u64", "u32", "u32", "u32", "ptr"], returns: "u32" },
+    imageDestroy: { args: ["u32"], returns: "void" },
+    imageGetInfo: { args: ["u32", "ptr"], returns: "u32" },
+    imageGetPixelsPtr: { args: ["u32"], returns: "ptr" },
+    imageClone: { args: ["u32", "ptr"], returns: "u32" },
+    imageCopyPixels: { args: ["u32", "ptr", "u64", "u32", "u8"], returns: "u32" },
+    imageResize: { args: ["u32", "u32", "u32", "u32", "ptr"], returns: "u32" },
+    imageExtract: { args: ["u32", "u32", "u32", "u32", "u32", "ptr"], returns: "u32" },
+    imageExtend: { args: ["u32", "u32", "u32", "u32", "u32", "ptr", "ptr"], returns: "u32" },
+    imageTransform: { args: ["u32", "u32", "ptr"], returns: "u32" },
+    imageComposite: { args: ["u32", "u32", "i32", "i32", "u32", "u8", "ptr"], returns: "u32" },
     getTerminalCapabilities: {
       args: ["u32", "ptr"],
       returns: "void"
@@ -13214,6 +14100,50 @@ function getOpenTUILib(libPath) {
       args: ["u32"],
       returns: "void"
     },
+    audioRefreshCaptureDevices: {
+      args: ["u32"],
+      returns: "i32"
+    },
+    audioGetCaptureDeviceCount: {
+      args: ["u32"],
+      returns: "u32"
+    },
+    audioGetCaptureDeviceName: {
+      args: ["u32", "u32", "ptr", "u32"],
+      returns: "u32"
+    },
+    audioIsCaptureDeviceDefault: {
+      args: ["u32", "u32"],
+      returns: "bool"
+    },
+    audioSelectCaptureDevice: {
+      args: ["u32", "u32"],
+      returns: "i32"
+    },
+    audioClearCaptureDeviceSelection: {
+      args: ["u32"],
+      returns: "void"
+    },
+    audioStartCapture: {
+      args: ["u32", "ptr", "u32", "u32"],
+      returns: "i32"
+    },
+    audioStopCapture: {
+      args: ["u32"],
+      returns: "i32"
+    },
+    audioIsCaptureRunning: {
+      args: ["u32"],
+      returns: "bool"
+    },
+    audioReadCapture: {
+      args: ["u32", "ptr", "u32", "u32", "ptr"],
+      returns: "i32"
+    },
+    audioGetCaptureStats: {
+      args: ["u32", "ptr"],
+      returns: "i32"
+    },
     audioStart: {
       args: ["u32", "ptr"],
       returns: "i32"
@@ -13476,10 +14406,10 @@ function convertToDebugSymbols(symbols) {
           const medianWidth = Math.max(medHeader.length, ...allStats.map((s) => s.median.toFixed(2).length));
           const p90Width = Math.max(p90Header.length, ...allStats.map((s) => s.p90.toFixed(2).length));
           const p99Width = Math.max(p99Header.length, ...allStats.map((s) => s.p99.toFixed(2).length));
-          lines.push(`${nameHeader.padEnd(nameWidth)} | ${callsHeader.padStart(countWidth)} | ${totalHeader.padStart(totalWidth)} | ${avgHeader.padStart(avgWidth)} | ${minHeader.padStart(statWidthMin)} | ${maxHeader.padStart(statWidthMax)} | ${medHeader.padStart(medianWidth)} | ${p90Header.padStart(p90Width)} | ${p99Header.padStart(p99Width)}`);
+          lines.push(`${nameHeader.padEnd(nameWidth)} | ` + `${callsHeader.padStart(countWidth)} | ` + `${totalHeader.padStart(totalWidth)} | ` + `${avgHeader.padStart(avgWidth)} | ` + `${minHeader.padStart(statWidthMin)} | ` + `${maxHeader.padStart(statWidthMax)} | ` + `${medHeader.padStart(medianWidth)} | ` + `${p90Header.padStart(p90Width)} | ` + `${p99Header.padStart(p99Width)}`);
           lines.push(`${"-".repeat(nameWidth)}-+-${"-".repeat(countWidth)}-+-${"-".repeat(totalWidth)}-+-${"-".repeat(avgWidth)}-+-${"-".repeat(statWidthMin)}-+-${"-".repeat(statWidthMax)}-+-${"-".repeat(medianWidth)}-+-${"-".repeat(p90Width)}-+-${"-".repeat(p99Width)}`);
           allStats.forEach((stat) => {
-            lines.push(`${stat.name.padEnd(nameWidth)} | ${String(stat.count).padStart(countWidth)} | ${stat.total.toFixed(2).padStart(totalWidth)} | ${stat.average.toFixed(2).padStart(avgWidth)} | ${stat.min.toFixed(2).padStart(statWidthMin)} | ${stat.max.toFixed(2).padStart(statWidthMax)} | ${stat.median.toFixed(2).padStart(medianWidth)} | ${stat.p90.toFixed(2).padStart(p90Width)} | ${stat.p99.toFixed(2).padStart(p99Width)}`);
+            lines.push(`${stat.name.padEnd(nameWidth)} | ` + `${String(stat.count).padStart(countWidth)} | ` + `${stat.total.toFixed(2).padStart(totalWidth)} | ` + `${stat.average.toFixed(2).padStart(avgWidth)} | ` + `${stat.min.toFixed(2).padStart(statWidthMin)} | ` + `${stat.max.toFixed(2).padStart(statWidthMax)} | ` + `${stat.median.toFixed(2).padStart(medianWidth)} | ` + `${stat.p90.toFixed(2).padStart(p90Width)} | ` + `${stat.p99.toFixed(2).padStart(p99Width)}`);
           });
         }
         lines.push("-------------------------------------------------------------------------------------------------------------------------");
@@ -13516,6 +14446,46 @@ var NativeMeasureTargetKind = {
 
 class FFIRenderLib {
   opentui;
+  yogaLayout = new Float32Array(6);
+  yogaLayoutPtr = ptr(this.yogaLayout);
+  ffiStructStorage = {
+    logicalCursor: {
+      ...allocStruct(LogicalCursorStruct),
+      result: { row: 0, col: 0, offset: 0 }
+    },
+    visualCursor: {
+      ...allocStruct(VisualCursorStruct),
+      result: {
+        visualRow: 0,
+        visualCol: 0,
+        logicalRow: 0,
+        logicalCol: 0,
+        offset: 0
+      }
+    },
+    measureResult: {
+      ...allocStruct(MeasureResultStruct),
+      result: { lineCount: 0, widthColsMax: 0 }
+    },
+    audioStreamStats: {
+      ...allocStruct(AudioStreamStatsStruct),
+      result: {
+        bytesReceived: 0n,
+        framesDecoded: 0n,
+        framesPlayed: 0n,
+        state: 0,
+        sampleRate: 0,
+        channels: 0,
+        bufferedFrames: 0,
+        capacityFrames: 0,
+        underruns: 0,
+        errorCode: 0,
+        readyGeneration: 0
+      }
+    },
+    imageDrawOptions: allocStruct(ImageDrawOptionsStruct),
+    gridDrawOptions: allocStruct(GridDrawOptionsStruct)
+  };
   encoder = new TextEncoder;
   decoder = new TextDecoder;
   logCallbackWrapper = null;
@@ -13842,6 +14812,24 @@ class FFIRenderLib {
     const formatId = format === "bgra8unorm" ? 0 : 1;
     this.opentui.symbols.bufferDrawSuperSampleBuffer(buffer, x, y, pixelDataPtr, pixelDataLength, formatId, alignedBytesPerRow);
   }
+  bufferDrawImage(buffer, image, x, y, width, height, pixelWidth, pixelHeight, sourceX, sourceY, sourceWidth, sourceHeight, protocol) {
+    const protocolId = { auto: 0, kitty: 1, sixel: 2, blocks: 3 }[protocol];
+    const storage = this.ffiStructStorage.imageDrawOptions;
+    ImageDrawOptionsStruct.packInto({
+      x,
+      y,
+      width,
+      height,
+      pixelWidth,
+      pixelHeight,
+      sourceX,
+      sourceY,
+      sourceWidth,
+      sourceHeight,
+      protocol: protocolId
+    }, storage.view, 0);
+    return Boolean(this.opentui.symbols.bufferDrawImage(buffer, image, storage.buffer));
+  }
   bufferDrawPackedBuffer(buffer, dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells) {
     this.opentui.symbols.bufferDrawPackedBuffer(buffer, dataPtr, dataLen, posX, posY, terminalWidthCells, terminalHeightCells);
   }
@@ -13852,11 +14840,8 @@ class FFIRenderLib {
     this.opentui.symbols.bufferDrawGrayscaleBufferSupersampled(buffer, posX, posY, intensitiesPtr, srcWidth, srcHeight, optionalRgbaPtr(fg2), optionalRgbaPtr(bg2));
   }
   bufferDrawGrid(buffer, borderChars, borderFg, borderBg, columnOffsets, columnCount, rowOffsets, rowCount, options) {
-    const optionsBuffer = GridDrawOptionsStruct.pack({
-      drawInner: options.drawInner,
-      drawOuter: options.drawOuter
-    });
-    this.opentui.symbols.bufferDrawGrid(buffer, ptr(borderChars), rgbaPtr(borderFg), rgbaPtr(borderBg), ptr(columnOffsets), columnCount, ptr(rowOffsets), rowCount, ptr(optionsBuffer));
+    GridDrawOptionsStruct.packInto({ drawInner: options.drawInner, drawOuter: options.drawOuter }, this.ffiStructStorage.gridDrawOptions.view, 0);
+    this.opentui.symbols.bufferDrawGrid(buffer, ptr(borderChars), rgbaPtr(borderFg), rgbaPtr(borderBg), ptr(columnOffsets), columnCount, ptr(rowOffsets), rowCount, this.ffiStructStorage.gridDrawOptions.buffer);
   }
   bufferDrawBox(buffer, x, y, width, height, borderChars, packedOptions, borderColor, backgroundColor, titleColor, title, bottomTitle) {
     const titleBytes = title ? this.encoder.encode(title) : null;
@@ -14004,11 +14989,11 @@ class FFIRenderLib {
     this.opentui.symbols.dumpHitGrid(renderer);
   }
   dumpBuffers(renderer, timestamp) {
-    const ts = timestamp ?? Date.now();
+    const ts = BigInt(timestamp ?? Date.now());
     this.opentui.symbols.dumpBuffers(renderer, ts);
   }
   dumpOutputBuffer(renderer, timestamp) {
-    const ts = timestamp ?? Date.now();
+    const ts = BigInt(timestamp ?? Date.now());
     this.opentui.symbols.dumpOutputBuffer(renderer, ts);
   }
   restoreTerminalModes(renderer) {
@@ -14162,8 +15147,8 @@ class FFIRenderLib {
     return this.opentui.symbols.yogaNodeGetAlwaysFormsContainingBlock(node);
   }
   yogaNodeGetComputedLayout(node) {
-    const layout = new Float32Array(6);
-    this.opentui.symbols.yogaNodeGetComputedLayout(node, ptr(layout));
+    const layout = this.yogaLayout;
+    this.opentui.symbols.yogaNodeGetComputedLayout(node, this.yogaLayoutPtr);
     return {
       left: layout[0],
       top: layout[1],
@@ -14344,7 +15329,7 @@ class FFIRenderLib {
     if (len === 0) {
       return null;
     }
-    return outBuffer.slice(0, len);
+    return usesBunFFI ? outBuffer.slice(0, len) : trimNodeFFIOutputBytes(outBuffer, len);
   }
   createTextBufferView(textBuffer) {
     const viewPtr = this.opentui.symbols.createTextBufferView(textBuffer);
@@ -14481,14 +15466,12 @@ class FFIRenderLib {
     this.opentui.symbols.textBufferViewSetTruncate(view, ffiBool(truncate));
   }
   textBufferViewMeasureForDimensions(view, width, height) {
-    const resultBuffer = new ArrayBuffer(MeasureResultStruct.size);
-    const resultPtr = ptr(new Uint8Array(resultBuffer));
-    const success = this.opentui.symbols.textBufferViewMeasureForDimensions(view, width, height, resultPtr);
-    if (!success) {
+    const storage = this.ffiStructStorage.measureResult;
+    const success = this.opentui.symbols.textBufferViewMeasureForDimensions(view, width, height, storage.buffer);
+    if (!success)
       return null;
-    }
-    const result = MeasureResultStruct.unpack(resultBuffer);
-    return result;
+    const result = MeasureResultStruct.unpackInto(storage.view, storage.result);
+    return { lineCount: result.lineCount, widthColsMax: result.widthColsMax };
   }
   textBufferAddHighlightByCharRange(buffer, highlight) {
     const packedHighlight = HighlightStruct.pack(highlight);
@@ -14714,9 +15697,10 @@ class FFIRenderLib {
     this.opentui.symbols.editBufferSetCursorByOffset(buffer, offset);
   }
   editBufferGetCursorPosition(buffer) {
-    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
-    this.opentui.symbols.editBufferGetCursorPosition(buffer, ptr(cursorBuffer));
-    return LogicalCursorStruct.unpack(cursorBuffer);
+    const storage = this.ffiStructStorage.logicalCursor;
+    this.opentui.symbols.editBufferGetCursorPosition(buffer, storage.buffer);
+    const cursor = LogicalCursorStruct.unpackInto(storage.view, storage.result);
+    return { row: cursor.row, col: cursor.col, offset: cursor.offset };
   }
   editBufferGetId(buffer) {
     return this.opentui.symbols.editBufferGetId(buffer);
@@ -14760,26 +15744,30 @@ class FFIRenderLib {
     this.opentui.symbols.editBufferClear(buffer);
   }
   editBufferGetNextWordBoundary(buffer) {
-    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
-    this.opentui.symbols.editBufferGetNextWordBoundary(buffer, ptr(cursorBuffer));
-    return LogicalCursorStruct.unpack(cursorBuffer);
+    const storage = this.ffiStructStorage.logicalCursor;
+    this.opentui.symbols.editBufferGetNextWordBoundary(buffer, storage.buffer);
+    const cursor = LogicalCursorStruct.unpackInto(storage.view, storage.result);
+    return { row: cursor.row, col: cursor.col, offset: cursor.offset };
   }
   editBufferGetPrevWordBoundary(buffer) {
-    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
-    this.opentui.symbols.editBufferGetPrevWordBoundary(buffer, ptr(cursorBuffer));
-    return LogicalCursorStruct.unpack(cursorBuffer);
+    const storage = this.ffiStructStorage.logicalCursor;
+    this.opentui.symbols.editBufferGetPrevWordBoundary(buffer, storage.buffer);
+    const cursor = LogicalCursorStruct.unpackInto(storage.view, storage.result);
+    return { row: cursor.row, col: cursor.col, offset: cursor.offset };
   }
   editBufferGetEOL(buffer) {
-    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
-    this.opentui.symbols.editBufferGetEOL(buffer, ptr(cursorBuffer));
-    return LogicalCursorStruct.unpack(cursorBuffer);
+    const storage = this.ffiStructStorage.logicalCursor;
+    this.opentui.symbols.editBufferGetEOL(buffer, storage.buffer);
+    const cursor = LogicalCursorStruct.unpackInto(storage.view, storage.result);
+    return { row: cursor.row, col: cursor.col, offset: cursor.offset };
   }
   editBufferOffsetToPosition(buffer, offset) {
-    const cursorBuffer = new ArrayBuffer(LogicalCursorStruct.size);
-    const success = this.opentui.symbols.editBufferOffsetToPosition(buffer, offset, ptr(cursorBuffer));
+    const storage = this.ffiStructStorage.logicalCursor;
+    const success = this.opentui.symbols.editBufferOffsetToPosition(buffer, offset, storage.buffer);
     if (!success)
       return null;
-    return LogicalCursorStruct.unpack(cursorBuffer);
+    const cursor = LogicalCursorStruct.unpackInto(storage.view, storage.result);
+    return { row: cursor.row, col: cursor.col, offset: cursor.offset };
   }
   editBufferPositionToOffset(buffer, row, col) {
     return this.opentui.symbols.editBufferPositionToOffset(buffer, row, col);
@@ -14801,7 +15789,7 @@ class FFIRenderLib {
     const len = actualLen;
     if (len === 0)
       return null;
-    return outBuffer.slice(0, len);
+    return usesBunFFI ? outBuffer.slice(0, len) : trimNodeFFIOutputBytes(outBuffer, len);
   }
   editorViewSetSelection(view, start, end, bgColor, fgColor) {
     const bg2 = optionalRgbaPtr(bgColor);
@@ -14861,9 +15849,10 @@ class FFIRenderLib {
     return outBuffer.slice(0, len);
   }
   editorViewGetVisualCursor(view) {
-    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
-    this.opentui.symbols.editorViewGetVisualCursor(view, ptr(cursorBuffer));
-    return VisualCursorStruct.unpack(cursorBuffer);
+    const storage = this.ffiStructStorage.visualCursor;
+    this.opentui.symbols.editorViewGetVisualCursor(view, storage.buffer);
+    const cursor = VisualCursorStruct.unpackInto(storage.view, storage.result);
+    return { ...cursor };
   }
   editorViewMoveUpVisual(view) {
     this.opentui.symbols.editorViewMoveUpVisual(view);
@@ -14878,29 +15867,34 @@ class FFIRenderLib {
     this.opentui.symbols.editorViewSetCursorByOffset(view, offset);
   }
   editorViewGetNextWordBoundary(view) {
-    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
-    this.opentui.symbols.editorViewGetNextWordBoundary(view, ptr(cursorBuffer));
-    return VisualCursorStruct.unpack(cursorBuffer);
+    const storage = this.ffiStructStorage.visualCursor;
+    this.opentui.symbols.editorViewGetNextWordBoundary(view, storage.buffer);
+    const cursor = VisualCursorStruct.unpackInto(storage.view, storage.result);
+    return { ...cursor };
   }
   editorViewGetPrevWordBoundary(view) {
-    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
-    this.opentui.symbols.editorViewGetPrevWordBoundary(view, ptr(cursorBuffer));
-    return VisualCursorStruct.unpack(cursorBuffer);
+    const storage = this.ffiStructStorage.visualCursor;
+    this.opentui.symbols.editorViewGetPrevWordBoundary(view, storage.buffer);
+    const cursor = VisualCursorStruct.unpackInto(storage.view, storage.result);
+    return { ...cursor };
   }
   editorViewGetEOL(view) {
-    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
-    this.opentui.symbols.editorViewGetEOL(view, ptr(cursorBuffer));
-    return VisualCursorStruct.unpack(cursorBuffer);
+    const storage = this.ffiStructStorage.visualCursor;
+    this.opentui.symbols.editorViewGetEOL(view, storage.buffer);
+    const cursor = VisualCursorStruct.unpackInto(storage.view, storage.result);
+    return { ...cursor };
   }
   editorViewGetVisualSOL(view) {
-    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
-    this.opentui.symbols.editorViewGetVisualSOL(view, ptr(cursorBuffer));
-    return VisualCursorStruct.unpack(cursorBuffer);
+    const storage = this.ffiStructStorage.visualCursor;
+    this.opentui.symbols.editorViewGetVisualSOL(view, storage.buffer);
+    const cursor = VisualCursorStruct.unpackInto(storage.view, storage.result);
+    return { ...cursor };
   }
   editorViewGetVisualEOL(view) {
-    const cursorBuffer = new ArrayBuffer(VisualCursorStruct.size);
-    this.opentui.symbols.editorViewGetVisualEOL(view, ptr(cursorBuffer));
-    return VisualCursorStruct.unpack(cursorBuffer);
+    const storage = this.ffiStructStorage.visualCursor;
+    this.opentui.symbols.editorViewGetVisualEOL(view, storage.buffer);
+    const cursor = VisualCursorStruct.unpackInto(storage.view, storage.result);
+    return { ...cursor };
   }
   bufferPushScissorRect(buffer, x, y, width, height) {
     this.opentui.symbols.bufferPushScissorRect(buffer, x, y, width, height);
@@ -14948,6 +15942,7 @@ class FFIRenderLib {
       explicit_cursor_positioning: caps.explicit_cursor_positioning,
       remote: caps.remote,
       multiplexer: caps.multiplexer,
+      image_protocol: caps.image_protocol,
       terminal: {
         name: caps.term_name ?? "",
         version: caps.term_version ?? "",
@@ -15015,6 +16010,76 @@ class FFIRenderLib {
   audioClearPlaybackDeviceSelection(engine) {
     this.opentui.symbols.audioClearPlaybackDeviceSelection(engine);
   }
+  audioRefreshCaptureDevices(engine) {
+    return this.opentui.symbols.audioRefreshCaptureDevices(engine);
+  }
+  audioGetCaptureDeviceCount(engine) {
+    return this.opentui.symbols.audioGetCaptureDeviceCount(engine);
+  }
+  audioGetCaptureDeviceName(engine, index) {
+    const outBuffer = new Uint8Array(512);
+    const bytesWritten = toNumber(this.opentui.symbols.audioGetCaptureDeviceName(engine, index, outBuffer, outBuffer.length));
+    const safeBytesWritten = Math.max(0, Math.min(outBuffer.length, bytesWritten));
+    return this.decoder.decode(outBuffer.subarray(0, safeBytesWritten));
+  }
+  audioIsCaptureDeviceDefault(engine, index) {
+    return Boolean(this.opentui.symbols.audioIsCaptureDeviceDefault(engine, index));
+  }
+  audioSelectCaptureDevice(engine, index) {
+    return this.opentui.symbols.audioSelectCaptureDevice(engine, index);
+  }
+  audioClearCaptureDeviceSelection(engine) {
+    this.opentui.symbols.audioClearCaptureDeviceSelection(engine);
+  }
+  audioStartCapture(engine, options, channels, capacityFrames) {
+    let optionsBuffer;
+    try {
+      const noFixedSizedCallback = options?.noFixedSizedCallback;
+      optionsBuffer = AudioStartOptionsStruct.pack(options ?? {});
+      if (noFixedSizedCallback === undefined) {
+        const field = AudioStartOptionsStruct.layoutByName.get("noFixedSizedCallback");
+        if (!field)
+          return -1;
+        new DataView(optionsBuffer).setUint8(field.offset, 1);
+      }
+    } catch {
+      return -1;
+    }
+    return this.opentui.symbols.audioStartCapture(engine, optionsBuffer, channels, capacityFrames);
+  }
+  audioStopCapture(engine) {
+    return this.opentui.symbols.audioStopCapture(engine);
+  }
+  audioIsCaptureRunning(engine) {
+    return Boolean(this.opentui.symbols.audioIsCaptureRunning(engine));
+  }
+  audioReadCapture(engine, outBuffer, frameCount) {
+    const outFramesReadBuffer = new ArrayBuffer(4);
+    const sampleCapacity = toSafeFFIU32Length(outBuffer.length, "Audio capture output sample capacity");
+    const status = this.opentui.symbols.audioReadCapture(engine, outBuffer, sampleCapacity, frameCount, outFramesReadBuffer);
+    if (status !== 0)
+      return { status, framesRead: 0 };
+    return { status, framesRead: new Uint32Array(outFramesReadBuffer)[0] ?? 0 };
+  }
+  audioGetCaptureStats(engine) {
+    const statsBuffer = new ArrayBuffer(AudioCaptureStatsStruct.size);
+    const status = this.opentui.symbols.audioGetCaptureStats(engine, statsBuffer);
+    if (status !== 0)
+      return { status, stats: null };
+    const stats = AudioCaptureStatsStruct.unpack(statsBuffer);
+    return {
+      status,
+      stats: {
+        framesReceived: typeof stats.framesReceived === "bigint" ? stats.framesReceived : BigInt(stats.framesReceived),
+        framesRead: typeof stats.framesRead === "bigint" ? stats.framesRead : BigInt(stats.framesRead),
+        framesDropped: typeof stats.framesDropped === "bigint" ? stats.framesDropped : BigInt(stats.framesDropped),
+        sampleRate: stats.sampleRate,
+        channels: stats.channels,
+        bufferedFrames: stats.bufferedFrames,
+        capacityFrames: stats.capacityFrames
+      }
+    };
+  }
   audioStart(engine, options) {
     let optionsBuffer;
     try {
@@ -15063,18 +16128,20 @@ class FFIRenderLib {
     return this.opentui.symbols.audioSetStreamGroup(engine, streamId, groupId);
   }
   audioGetStreamStats(engine, streamId) {
-    const outBuffer = new ArrayBuffer(AudioStreamStatsStruct.size);
-    const status = this.opentui.symbols.audioGetStreamStats(engine, streamId, outBuffer);
+    const storage = this.ffiStructStorage.audioStreamStats;
+    const status = this.opentui.symbols.audioGetStreamStats(engine, streamId, storage.buffer);
     if (status !== 0)
       return null;
-    return AudioStreamStatsStruct.unpack(outBuffer);
+    const stats = AudioStreamStatsStruct.unpackInto(storage.view, storage.result);
+    return { ...stats };
   }
   audioCloseStream(engine, streamId, reason) {
-    const outBuffer = new ArrayBuffer(AudioStreamStatsStruct.size);
-    const status = this.opentui.symbols.audioCloseStream(engine, streamId, reason, outBuffer);
+    const storage = this.ffiStructStorage.audioStreamStats;
+    const status = this.opentui.symbols.audioCloseStream(engine, streamId, reason, storage.buffer);
     if (status !== 0)
       return { status, stats: null };
-    return { status, stats: AudioStreamStatsStruct.unpack(outBuffer) };
+    const stats = AudioStreamStatsStruct.unpackInto(storage.view, storage.result);
+    return { status, stats: { ...stats } };
   }
   audioLoad(engine, data) {
     const outBuffer = new ArrayBuffer(4);
@@ -15248,6 +16315,66 @@ class FFIRenderLib {
   syntaxStyleGetStyleCount(style) {
     return this.opentui.symbols.syntaxStyleGetStyleCount(style);
   }
+  imageHandleResult(status, output) {
+    return { status, handle: status === 0 && output[0] !== 0 ? output[0] : null };
+  }
+  imageInfo(data) {
+    const length = toSafeFFIU32Length(data.byteLength, "image data");
+    const output = new ArrayBuffer(NativeImageInfoStruct.size);
+    const status = this.opentui.symbols.imageInfo(data.byteLength === 0 ? null : data, length, output);
+    return { status, info: NativeImageInfoStruct.unpack(output) };
+  }
+  imageDecode(data) {
+    const length = toSafeFFIU32Length(data.byteLength, "image data");
+    const output = new Uint32Array(1);
+    return this.imageHandleResult(this.opentui.symbols.imageDecode(data.byteLength === 0 ? null : data, length, output), output);
+  }
+  imageCreateFromRgba(pixels, width, height, stride) {
+    const output = new Uint32Array(1);
+    const status = this.opentui.symbols.imageCreateFromRgba(pixels.byteLength === 0 ? null : pixels, BigInt(pixels.byteLength), width, height, stride, output);
+    return this.imageHandleResult(status, output);
+  }
+  imageDestroy(image) {
+    this.opentui.symbols.imageDestroy(image);
+  }
+  imageGetInfo(image) {
+    const output = new ArrayBuffer(NativeImageInfoStruct.size);
+    const status = this.opentui.symbols.imageGetInfo(image, output);
+    return { status, info: NativeImageInfoStruct.unpack(output) };
+  }
+  imageGetPixelsPtr(image) {
+    const pointer = this.opentui.symbols.imageGetPixelsPtr(image);
+    return pointer === null || pointer === 0 || pointer === 0n ? null : pointer;
+  }
+  imageClone(image) {
+    const output = new Uint32Array(1);
+    return this.imageHandleResult(this.opentui.symbols.imageClone(image, output), output);
+  }
+  imageCopyPixels(image, destination, stride, bgra) {
+    return this.opentui.symbols.imageCopyPixels(image, destination.byteLength === 0 ? null : destination, BigInt(destination.byteLength), stride, bgra ? 1 : 0);
+  }
+  imageResize(image, width, height, filter) {
+    const output = new Uint32Array(1);
+    return this.imageHandleResult(this.opentui.symbols.imageResize(image, width, height, filter, output), output);
+  }
+  imageExtract(image, left, top, width, height) {
+    const output = new Uint32Array(1);
+    return this.imageHandleResult(this.opentui.symbols.imageExtract(image, left, top, width, height, output), output);
+  }
+  imageExtend(image, top, right, bottom, left, background) {
+    if (!(background instanceof Uint8Array) || background.byteLength !== 4)
+      return { status: 7, handle: null };
+    const output = new Uint32Array(1);
+    return this.imageHandleResult(this.opentui.symbols.imageExtend(image, top, right, bottom, left, background, output), output);
+  }
+  imageTransform(image, operation) {
+    const output = new Uint32Array(1);
+    return this.imageHandleResult(this.opentui.symbols.imageTransform(image, operation, output), output);
+  }
+  imageComposite(base, overlay, left, top, blend, opacity) {
+    const output = new Uint32Array(1);
+    return this.imageHandleResult(this.opentui.symbols.imageComposite(base, overlay, left, top, blend, opacity, output), output);
+  }
   editorViewSetPlaceholderStyledText(view, chunks) {
     const nonEmptyChunks = chunks.filter((c) => c.text.length > 0);
     if (nonEmptyChunks.length === 0) {
@@ -16262,7 +17389,7 @@ var Yoga = {
 };
 var yoga_default = Yoga;
 
-export { toArrayBuffer, sleep, stringWidth2 as stringWidth, DEFAULT_FOREGROUND_RGB, DEFAULT_BACKGROUND_RGB, normalizeIndexedColorIndex, ansi256IndexToRgb, RGBA, normalizeColorValue, hexToRgb, rgbToHex, hsvToRgb, parseColor, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, ATTRIBUTE_BASE_BITS, ATTRIBUTE_BASE_MASK, getBaseAttributes, DebugOverlayCorner, TargetChannel, createTextAttributes, attributesWithLink, getLinkId, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, link, t, hastToStyledText, SystemClock, nonAlphanumericKeys, terminalNamedSingleStrokeKeys, parseKeypress, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseAlignItems, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, singleton, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, StdinParser, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extensionToFiletype, basenameToFiletype, extToFiletype, pathToFiletype, infoStringToFiletype, getTreeSitterClient, destroyTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, normalizeTerminalPalette, buildTerminalPaletteSignature, decodePasteBytes, stripAnsiSequences, ClipboardTarget, Clipboard, detectLinks, OptimizedBuffer, TextBuffer, SpanInfoStruct, NativeAudioStreamFormat, NativeAudioStreamState, NativeAudioStreamStateNames, NativeAudioStreamCloseReason, NativeAudioStreamState2 as NativeAudioStreamState1, NativeAudioStreamCloseReason2 as NativeAudioStreamCloseReason1, NativeAudioStreamFormat2 as NativeAudioStreamFormat1, LogLevel2 as LogLevel, NativeMeasureTargetKind, setRenderLibPath, resolveRenderLib, Align, BoxSizing, Dimension, Direction, Display, Edge, Errata, ExperimentalFeature, FlexDirection, Gutter, Justify, LogLevel as LogLevel1, MeasureMode, NodeType, Overflow, PositionType, Unit, Wrap, ALIGN_AUTO, ALIGN_FLEX_START, ALIGN_CENTER, ALIGN_FLEX_END, ALIGN_STRETCH, ALIGN_BASELINE, ALIGN_SPACE_BETWEEN, ALIGN_SPACE_AROUND, ALIGN_SPACE_EVENLY, BOX_SIZING_BORDER_BOX, BOX_SIZING_CONTENT_BOX, DIMENSION_WIDTH, DIMENSION_HEIGHT, DIRECTION_INHERIT, DIRECTION_LTR, DIRECTION_RTL, DISPLAY_FLEX, DISPLAY_NONE, DISPLAY_CONTENTS, EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, EDGE_BOTTOM, EDGE_START, EDGE_END, EDGE_HORIZONTAL, EDGE_VERTICAL, EDGE_ALL, ERRATA_NONE, ERRATA_STRETCH_FLEX_BASIS, ERRATA_ABSOLUTE_POSITION_WITHOUT_INSETS_EXCLUDES_PADDING, ERRATA_ABSOLUTE_PERCENT_AGAINST_INNER_SIZE, ERRATA_ALL, ERRATA_CLASSIC, EXPERIMENTAL_FEATURE_WEB_FLEX_BASIS, FLEX_DIRECTION_COLUMN, FLEX_DIRECTION_COLUMN_REVERSE, FLEX_DIRECTION_ROW, FLEX_DIRECTION_ROW_REVERSE, GUTTER_COLUMN, GUTTER_ROW, GUTTER_ALL, JUSTIFY_FLEX_START, JUSTIFY_CENTER, JUSTIFY_FLEX_END, JUSTIFY_SPACE_BETWEEN, JUSTIFY_SPACE_AROUND, JUSTIFY_SPACE_EVENLY, LOG_LEVEL_ERROR, LOG_LEVEL_WARN, LOG_LEVEL_INFO, LOG_LEVEL_DEBUG, LOG_LEVEL_VERBOSE, LOG_LEVEL_FATAL, MEASURE_MODE_UNDEFINED, MEASURE_MODE_EXACTLY, MEASURE_MODE_AT_MOST, NODE_TYPE_DEFAULT, NODE_TYPE_TEXT, OVERFLOW_VISIBLE, OVERFLOW_HIDDEN, OVERFLOW_SCROLL, POSITION_TYPE_STATIC, POSITION_TYPE_RELATIVE, POSITION_TYPE_ABSOLUTE, UNIT_UNDEFINED, UNIT_POINT, UNIT_PERCENT, UNIT_AUTO, WRAP_NO_WRAP, WRAP_WRAP, WRAP_WRAP_REVERSE, Config, Node, exports_yoga, yoga_default };
+export { toArrayBuffer, singleton, envRegistry, registerEnvVar, clearEnvCache, generateEnvMarkdown, generateEnvColored, env, sleep, stringWidth2 as stringWidth, resolveBundledFilePath, DEFAULT_FOREGROUND_RGB, DEFAULT_BACKGROUND_RGB, normalizeIndexedColorIndex, ansi256IndexToRgb, RGBA, normalizeColorValue, hexToRgb, rgbToHex, hsvToRgb, parseColor, isValidBorderStyle, parseBorderStyle, BorderChars, getBorderFromSides, getBorderSides, borderCharsToArray, BorderCharArrays, KeyEvent, PasteEvent, KeyHandler, InternalKeyHandler, fonts, measureText, getCharacterPositions, coordinateToCharacterIndex, renderFontToFrameBuffer, TextAttributes, ATTRIBUTE_BASE_BITS, ATTRIBUTE_BASE_MASK, getBaseAttributes, DebugOverlayCorner, TargetChannel, createTextAttributes, attributesWithLink, getLinkId, visualizeRenderableTree, isStyledText, StyledText, stringToStyledText, black, red, green, yellow, blue, magenta, cyan, white, brightBlack, brightRed, brightGreen, brightYellow, brightBlue, brightMagenta, brightCyan, brightWhite, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, bold, italic, underline, strikethrough, dim, reverse, blink, fg, bg, link, t, hastToStyledText, SystemClock, nonAlphanumericKeys, terminalNamedSingleStrokeKeys, parseKeypress, LinearScrollAccel, MacOSScrollAccel, parseAlign, parseAlignItems, parseBoxSizing, parseDimension, parseDirection, parseDisplay, parseEdge, parseFlexDirection, parseGutter, parseJustify, parseLogLevel, parseMeasureMode, parseOverflow, parsePositionType, parseUnit, parseWrap, MouseParser, Selection, convertGlobalToLocalSelection, ASCIIFontSelectionHelper, StdinParser, treeSitterToTextChunks, treeSitterToStyledText, addDefaultParsers, TreeSitterClient, DataPathsManager, getDataPaths, extensionToFiletype, basenameToFiletype, extToFiletype, pathToFiletype, infoStringToFiletype, getTreeSitterClient, destroyTreeSitterClient, ExtmarksController, createExtmarksController, TerminalPalette, createTerminalPalette, normalizeTerminalPalette, buildTerminalPaletteSignature, decodePasteBytes, stripAnsiSequences, ClipboardTarget, Clipboard, detectLinks, OptimizedBuffer, TextBuffer, SpanInfoStruct, NativeAudioStreamFormat, NativeAudioStreamState, NativeAudioStreamStateNames, NativeAudioStreamCloseReason, NativeAudioStreamState2 as NativeAudioStreamState1, NativeAudioStreamCloseReason2 as NativeAudioStreamCloseReason1, NativeAudioStreamFormat2 as NativeAudioStreamFormat1, LogLevel2 as LogLevel, NativeMeasureTargetKind, setRenderLibPath, resolveRenderLib, Align, BoxSizing, Dimension, Direction, Display, Edge, Errata, ExperimentalFeature, FlexDirection, Gutter, Justify, LogLevel as LogLevel1, MeasureMode, NodeType, Overflow, PositionType, Unit, Wrap, ALIGN_AUTO, ALIGN_FLEX_START, ALIGN_CENTER, ALIGN_FLEX_END, ALIGN_STRETCH, ALIGN_BASELINE, ALIGN_SPACE_BETWEEN, ALIGN_SPACE_AROUND, ALIGN_SPACE_EVENLY, BOX_SIZING_BORDER_BOX, BOX_SIZING_CONTENT_BOX, DIMENSION_WIDTH, DIMENSION_HEIGHT, DIRECTION_INHERIT, DIRECTION_LTR, DIRECTION_RTL, DISPLAY_FLEX, DISPLAY_NONE, DISPLAY_CONTENTS, EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, EDGE_BOTTOM, EDGE_START, EDGE_END, EDGE_HORIZONTAL, EDGE_VERTICAL, EDGE_ALL, ERRATA_NONE, ERRATA_STRETCH_FLEX_BASIS, ERRATA_ABSOLUTE_POSITION_WITHOUT_INSETS_EXCLUDES_PADDING, ERRATA_ABSOLUTE_PERCENT_AGAINST_INNER_SIZE, ERRATA_ALL, ERRATA_CLASSIC, EXPERIMENTAL_FEATURE_WEB_FLEX_BASIS, FLEX_DIRECTION_COLUMN, FLEX_DIRECTION_COLUMN_REVERSE, FLEX_DIRECTION_ROW, FLEX_DIRECTION_ROW_REVERSE, GUTTER_COLUMN, GUTTER_ROW, GUTTER_ALL, JUSTIFY_FLEX_START, JUSTIFY_CENTER, JUSTIFY_FLEX_END, JUSTIFY_SPACE_BETWEEN, JUSTIFY_SPACE_AROUND, JUSTIFY_SPACE_EVENLY, LOG_LEVEL_ERROR, LOG_LEVEL_WARN, LOG_LEVEL_INFO, LOG_LEVEL_DEBUG, LOG_LEVEL_VERBOSE, LOG_LEVEL_FATAL, MEASURE_MODE_UNDEFINED, MEASURE_MODE_EXACTLY, MEASURE_MODE_AT_MOST, NODE_TYPE_DEFAULT, NODE_TYPE_TEXT, OVERFLOW_VISIBLE, OVERFLOW_HIDDEN, OVERFLOW_SCROLL, POSITION_TYPE_STATIC, POSITION_TYPE_RELATIVE, POSITION_TYPE_ABSOLUTE, UNIT_UNDEFINED, UNIT_POINT, UNIT_PERCENT, UNIT_AUTO, WRAP_NO_WRAP, WRAP_WRAP, WRAP_WRAP_REVERSE, Config, Node, exports_yoga, yoga_default };
 
-//# debugId=ABFD53867F2F7F9C64756E2164756E21
-//# sourceMappingURL=index-za1krqsf.js.map
+//# debugId=5F4E42714FBFA7AA64756E2164756E21
+//# sourceMappingURL=chunk-node-savhj5rp.js.map