@opentui/core 0.4.5 → 0.5.0

package/{chunk-node-q0cwyvm9.js → chunk-node-savhj5rp.js}

@@ -229,6 +229,7 @@ function createUnsupportedBackend(cause) {
   };
 }
 var isBun = typeof process !== "undefined" && typeof process.versions === "object" && process.versions !== null && typeof process.versions.bun === "string";
+var usesBunFFI = isBun;
 var requireModule = createRequire(import.meta.url);
 var backend = loadBackend();
 function loadBackend() {
@@ -254,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);
@@ -419,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) {
@@ -427,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;
 }
@@ -693,7 +770,7 @@ 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) {
+    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;
@@ -709,6 +786,9 @@ function parseEnvValue(config) {
   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}`);
   }
@@ -778,6 +858,9 @@ No environment variables registered.
     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*
@@ -809,6 +892,9 @@ No environment variables registered.
     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
@@ -909,7 +995,11 @@ async function resolveBundledFilePath(key, loadBundledFile, fallbackPath, metaUr
     }
     return await loadBundledFilePath(loadBundledFile, metaUrl, options.loadBundledFileFallback ?? false) ?? path;
   }
-  return normalizeLoadedFilePath((await loadBundledFile()).default, metaUrl);
+  const loaded = (await loadBundledFile()).default;
+  if (typeof loaded !== "string") {
+    return resolveFallbackFilePath(fallbackPath, metaUrl);
+  }
+  return normalizeLoadedFilePath(loaded, metaUrl);
 }
 function resolveFallbackFilePath(fallbackPath, metaUrl) {
   const path = typeof fallbackPath === "function" ? fallbackPath() : fallbackPath;
@@ -6356,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);
 }
@@ -6478,6 +6593,8 @@ class StdinParser {
   timeoutId = null;
   destroyed = false;
   pendingSinceMs = null;
+  pendingTimeoutPaused = false;
+  suspendedPixelResolutionPrefixLength = 0;
   forceFlush = false;
   justFlushedEsc = false;
   state = { tag: "ground" };
@@ -6506,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();
   }
@@ -6580,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());
@@ -6636,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();
@@ -7463,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;
@@ -7485,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" };
   }
@@ -7541,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;
@@ -7570,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" };
@@ -10448,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) {
@@ -10686,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);
@@ -10955,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, {
@@ -10998,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);
@@ -11061,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);
 }
@@ -11084,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;
@@ -11136,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);
-      };
+      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);
@@ -11163,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;
@@ -11173,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);
@@ -11188,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;
@@ -11201,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];
@@ -11219,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) => {
@@ -11237,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) => {
@@ -11255,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];
@@ -11268,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) => {
@@ -11286,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) => {
@@ -11314,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);
@@ -11329,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);
@@ -11338,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);
@@ -11346,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);
@@ -11375,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) {
@@ -11391,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));
     }
@@ -11454,6 +11979,7 @@ function defineStruct(fields, structDefOptions) {
       default: options.default,
       pack,
       unpack,
+      unpackTransform: options.unpackTransform,
       type: typeOrStruct,
       lengthOf: options.lengthOf
     };
@@ -11470,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) {
@@ -11481,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;
@@ -11498,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}.`);
         }
@@ -11510,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}.`);
         }
@@ -11531,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) => ({
@@ -11550,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,
@@ -11558,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) {
@@ -11607,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) {
@@ -11628,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 [];
@@ -11662,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 } : {};
@@ -11678,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;
@@ -11689,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
@@ -11759,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"],
@@ -11779,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*"],
@@ -11790,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" }],
@@ -11972,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"],
@@ -12018,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"];
@@ -12355,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"
@@ -13055,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"
@@ -13307,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"
@@ -13609,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;
@@ -13935,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);
   }
@@ -13945,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;
@@ -14097,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) {
@@ -14255,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],
@@ -14437,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);
@@ -14574,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);
@@ -14807,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);
@@ -14853,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);
@@ -14894,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);
@@ -14954,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);
@@ -14971,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);
@@ -15041,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 ?? "",
@@ -15108,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 {
@@ -15156,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);
@@ -15341,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) {
@@ -16357,5 +17391,5 @@ var yoga_default = Yoga;
 
 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=F036A274BA18217764756E2164756E21
-//# sourceMappingURL=chunk-node-q0cwyvm9.js.map
+//# debugId=5F4E42714FBFA7AA64756E2164756E21
+//# sourceMappingURL=chunk-node-savhj5rp.js.map