quickwin 1.3.0 → 2.1.0

package/test/test_react_listview_link.js

@@ -1367,9 +1367,9 @@ var require_scheduler_development = __commonJS({
         }
         return first;
       }
-      function compare(a, b) {
-        var diff = a.sortIndex - b.sortIndex;
-        return 0 !== diff ? diff : a.id - b.id;
+      function compare(a, b6) {
+        var diff = a.sortIndex - b6.sortIndex;
+        return 0 !== diff ? diff : a.id - b6.id;
       }
       function advanceTimers(currentTime) {
         for (var timer = peek(timerQueue); null !== timer; ) {
@@ -1667,14 +1667,14 @@ var require_react_reconciler_development = __commonJS({
             throw Error("Unable to find node on an unmounted component.");
           return alternate !== fiber ? null : fiber;
         }
-        for (var a = fiber, b = alternate; ; ) {
+        for (var a = fiber, b6 = alternate; ; ) {
           var parentA = a.return;
           if (null === parentA) break;
           var parentB = parentA.alternate;
           if (null === parentB) {
-            b = parentA.return;
-            if (null !== b) {
-              a = b;
+            b6 = parentA.return;
+            if (null !== b6) {
+              a = b6;
               continue;
             }
             break;
@@ -1682,23 +1682,23 @@ var require_react_reconciler_development = __commonJS({
           if (parentA.child === parentB.child) {
             for (parentB = parentA.child; parentB; ) {
               if (parentB === a) return assertIsMounted(parentA), fiber;
-              if (parentB === b) return assertIsMounted(parentA), alternate;
+              if (parentB === b6) return assertIsMounted(parentA), alternate;
               parentB = parentB.sibling;
             }
             throw Error("Unable to find node on an unmounted component.");
           }
-          if (a.return !== b.return) a = parentA, b = parentB;
+          if (a.return !== b6.return) a = parentA, b6 = parentB;
           else {
             for (var didFindChild = false, _child = parentA.child; _child; ) {
               if (_child === a) {
                 didFindChild = true;
                 a = parentA;
-                b = parentB;
+                b6 = parentB;
                 break;
               }
-              if (_child === b) {
+              if (_child === b6) {
                 didFindChild = true;
-                b = parentA;
+                b6 = parentA;
                 a = parentB;
                 break;
               }
@@ -1709,12 +1709,12 @@ var require_react_reconciler_development = __commonJS({
                 if (_child === a) {
                   didFindChild = true;
                   a = parentB;
-                  b = parentA;
+                  b6 = parentA;
                   break;
                 }
-                if (_child === b) {
+                if (_child === b6) {
                   didFindChild = true;
-                  b = parentB;
+                  b6 = parentB;
                   a = parentA;
                   break;
                 }
@@ -1726,7 +1726,7 @@ var require_react_reconciler_development = __commonJS({
                 );
             }
           }
-          if (a.alternate !== b)
+          if (a.alternate !== b6)
             throw Error(
               "Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue."
             );
@@ -15071,10 +15071,10 @@ var require_react_reconciler_development = __commonJS({
           setCurrentUpdatePriority(previousPriority), ReactSharedInternals.T = prevTransition;
         }
       };
-      exports2.discreteUpdates = function(fn, a, b, c, d) {
+      exports2.discreteUpdates = function(fn, a, b6, c, d) {
         var prevTransition = ReactSharedInternals.T, previousPriority = getCurrentUpdatePriority();
         try {
-          return setCurrentUpdatePriority(2), ReactSharedInternals.T = null, fn(a, b, c, d);
+          return setCurrentUpdatePriority(2), ReactSharedInternals.T = null, fn(a, b6, c, d);
         } finally {
           setCurrentUpdatePriority(previousPriority), ReactSharedInternals.T = prevTransition, executionContext === NoContext && (workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS);
         }
@@ -15357,141 +15357,18 @@ var require_constants = __commonJS({
 var import_jsx_runtime16 = __toESM(require_jsx_runtime(), 1);
 var import_react18 = __toESM(require_react(), 1);
 import "../lib/polyfill.js";
-import * as std from "std";
+import * as std2 from "std";
 
 // _build/lib/react-qw/index.js
-import * as gui18 from "gui";
-
-// _build/lib/react-qw/reconciler.js
-var import_react_reconciler = __toESM(require_react_reconciler(), 1);
-var import_react = __toESM(require_react(), 1);
-var import_constants = __toESM(require_constants(), 1);
-import * as gui3 from "gui";
-import * as os from "os";
-
-// _build/lib/react-qw/props.js
-import * as gui from "gui";
-function applyProps(instance, newProps, _oldProps) {
-  const hwnd = instance.hwnd;
-  instance.props = newProps;
-  const textVal = "text" in newProps ? newProps.text : typeof newProps.children === "string" ? newProps.children : typeof newProps.children === "number" ? String(newProps.children) : void 0;
-  if (textVal !== void 0) {
-    let cursor = -1;
-    if (instance.type === "EDIT") {
-      const sel = gui.SendMessage(hwnd, 176, 0, 0);
-      cursor = sel >>> 16;
-    }
-    gui.SetWindowText(hwnd, textVal);
-    if (instance.type === "EDIT" && cursor >= 0) {
-      gui.SendMessage(hwnd, 177, cursor, cursor);
-    }
-  }
-  if ("disabled" in newProps) {
-    gui.EnableWindow(hwnd, !newProps.disabled);
-  }
-  if ("hidden" in newProps) {
-    gui.ShowWindow(
-      hwnd,
-      newProps.hidden ? 0 : 5
-      /* gui.ShowWindowCmd.SHOW */
-    );
-  }
-  if ("visible" in newProps) {
-    gui.ShowWindow(
-      hwnd,
-      newProps.visible ? 5 : 0
-      /* gui.ShowWindowCmd.HIDE */
-    );
-  }
-}
-
-// _build/lib/react-qw/layout.js
-var DEFAULT_W = 100;
-var DEFAULT_H = 30;
-function calculateFlexLayout(flex, parentW, parentH, children) {
-  const dir = flex.flexDirection || "column";
-  const gap = flex.gap ?? 0;
-  const justify = flex.justifyContent || "flex-start";
-  const align = flex.alignItems || "stretch";
-  const isRow = dir === "row";
-  const n = children.length;
-  const mainSize = isRow ? "w" : "h";
-  const crossSize = isRow ? "h" : "w";
-  const mainPos = isRow ? "x" : "y";
-  const crossPos = isRow ? "y" : "x";
-  const mainDim = isRow ? "width" : "height";
-  const crossDim = isRow ? "height" : "width";
-  const pt = flex.paddingTop ?? flex.padding ?? 0;
-  const pr = flex.paddingRight ?? flex.padding ?? 0;
-  const pb = flex.paddingBottom ?? flex.padding ?? 0;
-  const pl = flex.paddingLeft ?? flex.padding ?? 0;
-  const mainPadding = isRow ? pl + pr : pt + pb;
-  const crossPadding = isRow ? pt + pb : pl + pr;
-  const parentMain = (isRow ? parentW : parentH) - mainPadding;
-  const parentCross = (isRow ? parentH : parentW) - crossPadding;
-  const sizes = children.map((c) => ({
-    w: typeof c.style.width === "number" ? c.style.width : DEFAULT_W,
-    h: typeof c.style.height === "number" ? c.style.height : DEFAULT_H
-  }));
-  const flexGrows = children.map((c) => c.style.flexGrow ?? 0);
-  const totalGrow = flexGrows.reduce((s, g) => s + g, 0);
-  const baseMain = sizes.reduce((s, c) => s + c[mainSize], 0);
-  let freeGrow = parentMain - baseMain - Math.max(0, n - 1) * gap;
-  if (totalGrow > 0 && freeGrow > 0) {
-    for (let i = 0; i < n; i++) {
-      sizes[i][mainSize] += freeGrow * flexGrows[i] / totalGrow;
-    }
-  }
-  const totalMain = sizes.reduce((s, c) => s + c[mainSize], 0);
-  const free = parentMain - totalMain - Math.max(0, n - 1) * gap;
-  let offset = 0, extraGap = 0;
-  if (justify === "flex-end")
-    offset = free;
-  else if (justify === "center")
-    offset = Math.max(0, free / 2);
-  else if (justify === "space-between" && n > 1)
-    extraGap = free / (n - 1);
-  else if (justify === "space-around") {
-    extraGap = free / n;
-    offset = extraGap / 2;
-  } else if (justify === "space-evenly") {
-    extraGap = free / (n + 1);
-    offset = extraGap;
-  }
-  let cursor = offset;
-  return sizes.map((sz, i) => {
-    const childCrossBase = sz[crossSize];
-    const childAlign = children[i].style.alignSelf ?? "auto";
-    const effectiveAlign = childAlign === "auto" ? align : childAlign;
-    let childMain = sz[mainSize];
-    let childCross = childCrossBase;
-    const res = { x: 0, y: 0, width: 0, height: 0 };
-    res[mainPos] = cursor;
-    res[crossPos] = 0;
-    res[mainDim] = childMain;
-    res[crossDim] = childCross;
-    if (effectiveAlign === "stretch") {
-      const hasExplicitCross = typeof children[i].style[crossDim] === "number";
-      if (!hasExplicitCross) {
-        res[crossDim] = parentCross;
-        res[crossPos] = 0;
-      }
-    } else if (effectiveAlign === "flex-end") {
-      res[crossPos] = parentCross - childCross;
-    } else if (effectiveAlign === "center") {
-      res[crossPos] = Math.max(0, (parentCross - childCross) / 2);
-    }
-    cursor += childMain + gap + extraGap;
-    return res;
-  });
-}
+import * as gui17 from "gui";
 
-// _build/lib/text-measure.js
-import * as ffi2 from "ffi";
-import * as gui2 from "gui";
+// _build/lib/windows/user32.js
+import * as os3 from "os";
 
-// _build/lib/ffi-bind.js
+// _build/lib/ffi/bind.js
 import * as ffi from "ffi";
+import * as os2 from "os";
+import * as std from "std";
 import * as win from "win";
 
 // _build/lib/text-codec.js
@@ -15514,62 +15391,62 @@ function _normalizeLabel(label) {
 function _decodeUTF8(buf, fatal) {
   let out = "";
   for (let i = 0; i < buf.length; ) {
-    const b = buf[i++];
-    if (b < 128) {
-      out += String.fromCharCode(b);
+    const b6 = buf[i++];
+    if (b6 < 128) {
+      out += String.fromCharCode(b6);
       continue;
     }
-    if (b < 192) {
+    if (b6 < 192) {
       out += fatal ? (() => {
         throw new TypeError("unexpected continuation byte");
       })() : "\uFFFD";
       continue;
     }
     let c, min;
-    if (b < 224) {
+    if (b6 < 224) {
       if (i >= buf.length) {
         out += fatal ? (() => {
           throw new TypeError("incomplete utf-8");
         })() : "\uFFFD";
         break;
       }
-      const b2 = buf[i++];
-      if ((b2 & 192) !== 128) {
+      const b22 = buf[i++];
+      if ((b22 & 192) !== 128) {
         out += "\uFFFD";
         continue;
       }
-      c = (b & 31) << 6 | b2 & 63;
+      c = (b6 & 31) << 6 | b22 & 63;
       min = 128;
-    } else if (b < 240) {
+    } else if (b6 < 240) {
       if (i + 1 >= buf.length) {
         out += fatal ? (() => {
           throw new TypeError("incomplete utf-8");
         })() : "\uFFFD";
         break;
       }
-      const b2 = buf[i++];
-      const b3 = buf[i++];
-      if ((b2 & 192) !== 128 || (b3 & 192) !== 128) {
+      const b22 = buf[i++];
+      const b32 = buf[i++];
+      if ((b22 & 192) !== 128 || (b32 & 192) !== 128) {
         out += "\uFFFD";
         continue;
       }
-      c = (b & 15) << 12 | (b2 & 63) << 6 | b3 & 63;
+      c = (b6 & 15) << 12 | (b22 & 63) << 6 | b32 & 63;
       min = 2048;
-    } else if (b < 248) {
+    } else if (b6 < 248) {
       if (i + 2 >= buf.length) {
         out += fatal ? (() => {
           throw new TypeError("incomplete utf-8");
         })() : "\uFFFD";
         break;
       }
-      const b2 = buf[i++];
-      const b3 = buf[i++];
-      const b4 = buf[i++];
-      if ((b2 & 192) !== 128 || (b3 & 192) !== 128 || (b4 & 192) !== 128) {
+      const b22 = buf[i++];
+      const b32 = buf[i++];
+      const b42 = buf[i++];
+      if ((b22 & 192) !== 128 || (b32 & 192) !== 128 || (b42 & 192) !== 128) {
         out += "\uFFFD";
         continue;
       }
-      c = (b & 7) << 18 | (b2 & 63) << 12 | (b3 & 63) << 6 | b4 & 63;
+      c = (b6 & 7) << 18 | (b22 & 63) << 12 | (b32 & 63) << 6 | b42 & 63;
       min = 65536;
     } else {
       out += fatal ? (() => {
@@ -15707,65 +15584,166 @@ if (typeof globalThis.TextEncoder === "undefined") {
   globalThis.TextEncoder = TextEncoderImpl;
 }
 
-// _build/lib/ffi-bind.js
-var KIND_TO_FFI = {
-  void: ffi.FFI_TYPE_VOID,
-  u8: ffi.FFI_TYPE_UINT8,
-  i8: ffi.FFI_TYPE_SINT8,
-  u16: ffi.FFI_TYPE_UINT16,
-  i16: ffi.FFI_TYPE_SINT16,
-  u32: ffi.FFI_TYPE_UINT32,
-  i32: ffi.FFI_TYPE_SINT32,
-  u64: ffi.FFI_TYPE_UINT64,
-  i64: ffi.FFI_TYPE_SINT64,
-  f32: ffi.FFI_TYPE_FLOAT,
-  f64: ffi.FFI_TYPE_DOUBLE,
-  ptr: ffi.FFI_TYPE_POINTER,
-  wstr: ffi.FFI_TYPE_POINTER
+// _build/lib/ffi/ctype.js
+import { bufferPtr } from "ffi";
+import * as os from "os";
+var C_BASIC_TYPE = [
+  "void",
+  "u8",
+  "i8",
+  "u16",
+  "i16",
+  "u32",
+  "i32",
+  "u64",
+  "i64",
+  "f32",
+  "f64",
+  "ptr"
+];
+var PTR_TOKEN_RE = /^<([A-Za-z_]\w*|)>ptr(!|@[A-Za-z_]\w*)?$/;
+function isCPtrToken(t) {
+  return PTR_TOKEN_RE.test(t);
+}
+var VAL_TOKEN_RE = /^<([A-Za-z_]\w*)>$/;
+function isCValToken(t) {
+  return VAL_TOKEN_RE.test(t);
+}
+function valName(t) {
+  const m = VAL_TOKEN_RE.exec(t);
+  return m?.[1] || "";
+}
+function ptrName(t) {
+  const m = PTR_TOKEN_RE.exec(t);
+  return m?.[1] || "";
+}
+var cTokenToType = (t) => {
+  if (isCPtrToken(t))
+    return "ptr";
+  if (isCValToken(t))
+    throw new Error(`ffi: cTokenToType: by-value token "${t}" has no scalar slot type`);
+  return t;
 };
-var C_ALIAS = {
-  int: "i32",
-  long: "i32",
-  short: "i16",
-  char: "i8",
-  float: "f32",
-  double: "f64",
-  DWORD: "u32",
-  UINT: "u32",
-  ULONG: "u32",
-  LONG: "i32",
-  BOOL: "i32",
-  HRESULT: "i32",
-  SHORT: "i16",
-  USHORT: "u16",
-  BYTE: "u8",
-  LONG_PTR: "ptr",
-  ULONG_PTR: "ptr",
-  INT_PTR: "ptr",
-  UINT_PTR: "ptr",
-  DWORD_PTR: "ptr",
-  SIZE_T: "ptr",
-  WPARAM: "ptr",
-  LPARAM: "ptr",
-  HANDLE: "ptr",
-  HWND: "ptr",
-  HDC: "ptr",
-  HMODULE: "ptr",
-  HFONT: "ptr",
-  HBRUSH: "ptr",
-  HICON: "ptr",
-  HBITMAP: "ptr",
-  LPVOID: "ptr",
-  LPCVOID: "ptr",
-  LPCWSTR: "ptr",
-  PCWSTR: "ptr",
-  LPWSTR: "ptr"
+var PTR_SIZE = os.arch === "x64" ? 8 : 4;
+var SizeAlign = {
+  u8: 1,
+  i8: 1,
+  u16: 2,
+  i16: 2,
+  u32: 4,
+  i32: 4,
+  u64: 8,
+  i64: 8,
+  f32: 4,
+  f64: 8
+};
+var NULL = 0;
+function normToken(t) {
+  if (isCPtrToken(t)) {
+    const m = PTR_TOKEN_RE.exec(t);
+    const name = m?.[1] || "";
+    const mod = m?.[2];
+    return mod?.startsWith("@") ? `<${name}>ptr` : t;
+  }
+  if (isCValToken(t))
+    return t;
+  const at = t.indexOf("@");
+  const base = at >= 0 ? t.slice(0, at) : t;
+  const suffixOk = at < 0 || /^[A-Za-z_]\w*$/.test(t.slice(at + 1));
+  if (suffixOk && base !== "ptr" && C_BASIC_TYPE.includes(base))
+    return base;
+  throw new Error("Unknown token: " + t);
+}
+function readScalar(dv, off, k) {
+  switch (k) {
+    case "u8":
+      return dv.getUint8(off);
+    case "i8":
+      return dv.getInt8(off);
+    case "u16":
+      return dv.getUint16(off, true);
+    case "i16":
+      return dv.getInt16(off, true);
+    case "u32":
+      return dv.getUint32(off, true);
+    case "i32":
+      return dv.getInt32(off, true);
+    case "u64":
+      return dv.getBigUint64(off, true);
+    case "i64":
+      return dv.getBigInt64(off, true);
+    case "f32":
+      return dv.getFloat32(off, true);
+    case "f64":
+      return dv.getFloat64(off, true);
+    case "ptr": {
+      return PTR_SIZE === 8 ? Number(dv.getBigInt64(off, true)) : dv.getInt32(off, true);
+    }
+  }
+}
+function writeScalar(dv, off, { k, v }) {
+  switch (k) {
+    case "u8":
+      dv.setUint8(off, Number(v));
+      break;
+    case "i8":
+      dv.setInt8(off, Number(v));
+      break;
+    case "u16":
+      dv.setUint16(off, Number(v), true);
+      break;
+    case "i16":
+      dv.setInt16(off, Number(v), true);
+      break;
+    case "u32":
+      dv.setUint32(off, v >>> 0, true);
+      break;
+    case "i32":
+      dv.setUint32(off, v >>> 0, true);
+      break;
+    case "u64":
+      dv.setBigUint64(off, v, true);
+      break;
+    case "i64":
+      dv.setBigInt64(off, v, true);
+      break;
+    case "f32":
+      dv.setFloat32(off, v, true);
+      break;
+    case "f64":
+      dv.setFloat64(off, v, true);
+      break;
+    case "ptr": {
+      if (v == null) {
+        throw new Error("ffi: got null/undefined for a ptr slot; pass the imported NULL constant for empty");
+      }
+      if (PTR_SIZE === 8)
+        dv.setBigUint64(off, BigInt.asUintN(64, BigInt(v)), true);
+      else
+        dv.setUint32(off, v >>> 0, true);
+      break;
+    }
+  }
+}
+function writeSlot(dv, off, e) {
+  const { k, v } = e;
+  if (k === "u8" || k === "i8" || k === "u16" || k === "i16") {
+    dv.setUint32(off, Number(v) >>> 0, true);
+    return;
+  }
+  writeScalar(dv, off, e);
+}
+var PtrArrayBuffer = class extends ArrayBuffer {
+  ptr;
+  constructor(byteLength) {
+    super(byteLength);
+    this.ptr = bufferPtr(this);
+  }
 };
-function normKind(t) {
-  const k = C_ALIAS[t] ?? t;
-  if (!(k in KIND_TO_FFI))
-    throw new Error(`ffi-bind: invalid kind "${t}"`);
-  return k;
+
+// _build/lib/ffi/bind.js
+function valCodec(name, encoders) {
+  return encoders[name];
 }
 var _dllCache = /* @__PURE__ */ new Map();
 function loadDll(dll) {
@@ -15780,77 +15758,1011 @@ function loadDll(dll) {
 }
 function parseSig(sig) {
   const parts = sig.split(" -> ");
-  const ret = parts[1];
-  if (ret === void 0 || parts.length > 2) {
+  if (parts.length !== 2) {
     throw new Error(`ffi-bind: invalid signature "${sig}" (expected "arg1 arg2 -> ret")`);
   }
-  const retK = normKind(ret);
-  if (retK === "wstr")
-    throw new Error('ffi-bind: "wstr" cannot be a return type');
-  const tokens = (parts[0] ?? "") === "" ? [] : parts[0].split(" ");
-  const args = tokens.map((t) => normKind(t));
-  return { args, ret: retK };
+  const rawArgs = parts[0].split(" ").filter((t) => t !== "");
+  const argTokens = [];
+  for (const raw of rawArgs) {
+    const tok = normToken(raw);
+    if (tok === "void") {
+      throw new Error("Void can not in args");
+    }
+    argTokens.push(tok);
+  }
+  const retToken = normToken(parts[1]);
+  if (isCValToken(retToken))
+    throw new Error(`ffi-bind: "${sig}": by-value struct at the return position (<${valName(retToken)}>) is not supported \u2014 argument positions only; pass a struct out through an out-param slot instead (<N>ptr + caller buffer)`);
+  return {
+    argTokens,
+    retToken,
+    sig
+  };
 }
-function makeFn(proc, sig) {
-  const { args, ret } = parseSig(sig);
-  const argTypes = args.map((k) => KIND_TO_FFI[k]);
-  const retType = KIND_TO_FFI[ret];
-  return (...a) => {
-    const vals = args.map((k, i) => k === "wstr" ? new TextEncoder("utf-16le").encode(String(a[i]) + "\0").buffer : a[i]);
-    return ffi.ffiCall(proc, argTypes, vals, retType);
+function makeFn(proc, sig, encoders, decoders) {
+  const ps = parseSig(sig);
+  for (const t of ps.argTokens) {
+    if (!isCValToken(t))
+      continue;
+    const name = valName(t);
+    const codec = valCodec(name, encoders);
+    if (!codec || typeof codec.encode !== "function")
+      throw new Error(`ffi-bind: ${sig}: by-value position <${name}> has no registered layout (available: ${Object.keys(encoders).join(", ") || "none"})`);
+    if (typeof codec.size !== "number" || codec.size < 1)
+      throw new Error(`ffi-bind: ${sig}: by-value position <${name}> requires a struct layout with size >= 1 (got ${codec.size}; non-struct codecs expose no size)`);
+  }
+  return (...a) => callPacked(proc, ps, a, encoders, decoders);
+}
+var IA32_ARG_SIZE = {
+  u8: 4,
+  i8: 4,
+  u16: 4,
+  i16: 4,
+  u32: 4,
+  i32: 4,
+  u64: 8,
+  i64: 8,
+  f32: 4,
+  f64: 8,
+  ptr: PTR_SIZE
+};
+var X64_MIN_SLOTS = 4;
+function callPacked(proc, { argTokens, retToken, sig }, args, encoders, decoders) {
+  const is64 = os2.arch === "x64";
+  const getWidth = (t, is642) => {
+    if (isCValToken(t))
+      throw new Error(`ffi-bind: getWidth: by-value token "${t}" (dispatched by widthOf)`);
+    if (is642)
+      return 8;
+    if (isCPtrToken(t))
+      return PTR_SIZE;
+    return IA32_ARG_SIZE[t];
   };
+  const widthOf = (t) => {
+    if (isCValToken(t)) {
+      if (is64)
+        return 8;
+      const layout = valCodec(valName(t), encoders);
+      if (!layout)
+        throw new Error(`ffi-bind: <${valName(t)}> by-value position has no registered layout`);
+      const size = layout.size;
+      return size % 4 === 0 ? size : size + 4 - size % 4;
+    }
+    return getWidth(t, is64);
+  };
+  let total = 0;
+  for (const t of argTokens)
+    total += widthOf(t);
+  if (is64 && argTokens.length < X64_MIN_SLOTS)
+    total = X64_MIN_SLOTS * 8;
+  const argFrame = new ArrayBuffer(total);
+  const dv = new DataView(argFrame);
+  const held = [];
+  let off = 0;
+  for (let i = 0; i < argTokens.length; i++) {
+    const argToken = argTokens[i];
+    const nonnull = argToken.endsWith("!");
+    const arg = args[i];
+    if (isCPtrToken(argToken)) {
+      const name = ptrName(argToken);
+      if (typeof arg === "number") {
+        if (nonnull && arg === 0)
+          throw new Error(`ffi-bind: ${sig}: arg#${i + 1} <${name}>ptr! got 0 (null pointer forbidden here; the token marks this position non-null)`);
+        writeSlot(dv, off, { k: "ptr", v: arg });
+      } else {
+        if (arg === null || arg === void 0) {
+          throw new Error(`ffi-bind: <${name}>ptr got ${String(arg)}; pass the imported NULL constant for an empty pointer`);
+        }
+        const codec = encoders[name];
+        if (!codec) {
+          throw new Error(name === "" ? `ffi-bind: <>ptr expects number (NULL | Ptr), got ${typeof arg}; use <BYTE>ptr with a PtrArrayBuffer (new PtrArrayBuffer(n)), or ffi.bufferPtr(buf) for an address` : `ffi-bind: unknown layout "<${name}>ptr" (available: ${Object.keys(encoders).join(", ") || "none"})`);
+        }
+        if (!codec.encode) {
+          throw new Error(`ffi-bind: <${name}>ptr has no encoder (out-only codec)`);
+        }
+        const buf = codec.encode(arg);
+        held.push(buf);
+        const p = buf.ptr;
+        if (typeof p !== "number")
+          throw new Error("ffi-bind: codec.encode must return a PtrArrayBuffer, got plain ArrayBuffer");
+        if (nonnull && p === 0)
+          throw new Error(`ffi-bind: ${sig}: arg#${i + 1} <${name}>ptr! encode produced 0 (null pointer forbidden here)`);
+        writeSlot(dv, off, { k: "ptr", v: p });
+      }
+    } else if (isCValToken(argToken)) {
+      const name = valName(argToken);
+      const codec = valCodec(name, encoders);
+      if (!codec)
+        throw new Error(`ffi-bind: ${sig}: arg#${i + 1} <${name}> by-value position has no registered layout`);
+      if (arg === null || arg === void 0)
+        throw new Error(`ffi-bind: <${name}> value position got ${String(arg)}; pass a struct object (use <${name}>ptr to pass a pointer)`);
+      const size = codec.size;
+      if (!is64 || size <= 8 && (size & size - 1) === 0) {
+        codec.encode(arg, argFrame, off);
+      } else {
+        const buf = new ArrayBuffer(size + 15);
+        const base = ffi.bufferPtr(buf);
+        const pad = (16 - base % 16) % 16;
+        codec.encode(arg, buf, pad);
+        held.push(buf);
+        writeSlot(dv, off, { k: "ptr", v: base + pad });
+      }
+    } else {
+      writeSlot(dv, off, { k: argToken, v: arg });
+    }
+    off += widthOf(argToken);
+  }
+  const retBuf = new ArrayBuffer(8);
+  const retIsFp = retToken === "f32" || retToken === "f64";
+  ffi.ffiCall(proc, argFrame, retBuf, retIsFp ? 1 : 0);
+  const raw = readRet(cTokenToType(retToken), retBuf);
+  if (retToken.endsWith("!") && raw === 0)
+    throw new Error(`ffi-bind: ${sig}: return ${retToken} got 0 (the token promises C never returns null here)`);
+  if (isCPtrToken(retToken) && raw !== 0) {
+    const name = ptrName(retToken);
+    if (name !== "") {
+      const codec = decoders[name];
+      if (codec?.decode)
+        return codec.decode(raw);
+    }
+  }
+  return raw;
 }
-function bindLib(dll, map) {
-  const out = {};
-  const h = loadDll(dll);
-  for (const [name, sig] of Object.entries(map)) {
-    const proc = win.GetProcAddress(h, name);
-    if (!proc)
-      throw new Error(`ffi-bind: proc "${name}" not found in ${dll}`);
-    out[name] = makeFn(proc, sig);
+function readRet(ret, retBuf) {
+  if (ret === "void")
+    return void 0;
+  return readScalar(new DataView(retBuf), 0, ret);
+}
+var WCHAR = {
+  encode: (v) => {
+    const u8 = new TextEncoder("utf-16le").encode(v + "\0");
+    const out = new PtrArrayBuffer(u8.byteLength);
+    new Uint8Array(out).set(u8);
+    return out;
+  },
+  decode: (p) => {
+    if (typeof p === "number") {
+      let s2 = "";
+      let addr = p;
+      const start = addr;
+      for (; ; ) {
+        const lo = ffi.readByte(addr);
+        const hi = ffi.readByte(addr + 1);
+        if (lo === 0 && hi === 0)
+          return s2;
+        s2 += String.fromCharCode(lo | hi << 8);
+        addr += 2;
+        if (addr - start > 1 << 21) {
+          throw new Error("ffi-bind: WCHAR decode exceeded 4MiB without NUL");
+        }
+      }
+    }
+    const u8 = new Uint8Array(p);
+    const limit = u8.length & ~1;
+    let s = "";
+    for (let i = 0; i < limit; i += 2) {
+      const c = u8[i] | u8[i + 1] << 8;
+      if (c === 0)
+        return s;
+      s += String.fromCharCode(c);
+    }
+    return s;
+  },
+  alloc: (size = 256) => new PtrArrayBuffer(size * 2)
+};
+var BYTE = {
+  encode: (v) => {
+    if (!(v instanceof PtrArrayBuffer))
+      throw new Error("ffi-bind: <BYTE>ptr wants a PtrArrayBuffer (new PtrArrayBuffer(n) / BYTE.alloc / struct.encode), not a plain ArrayBuffer");
+    return v;
+  },
+  alloc: (byteLen) => new PtrArrayBuffer(byteLen)
+};
+var builtinCodecs = { WCHAR, BYTE };
+function bind(dll, name, sig, encoders, decoders) {
+  const proc = win.GetProcAddress(loadDll(dll), name);
+  if (!proc)
+    throw new Error(`ffi-bind: proc "${name}" not found in ${dll}`);
+  const effDec = decoders ?? encoders;
+  return makeFn(proc, sig, { ...builtinCodecs, ...encoders }, { ...builtinCodecs, ...effDec ?? {} });
+}
+var leakRegistry = new FinalizationRegistry((held) => {
+  std.printf('[ffi] closure leaked (GCed without dispose): sig="%s" ptr=0x%x\n', held.sig, held.ptr);
+});
+
+// _build/lib/ffi/struct.js
+import * as ffi2 from "ffi";
+function alignUp(v, a) {
+  return v + a - 1 & ~(a - 1);
+}
+var isCNumberToken = (t) => SizeAlign[t] !== void 0;
+function lower(v) {
+  if (typeof v === "string") {
+    const st = /^(u8|u16)\[(\d+)\]@(utf-8|utf-16le)$/.exec(v);
+    if (st) {
+      const length = Number(st[2]);
+      if (!Number.isInteger(length) || length < 1)
+        throw new Error(`ffi-struct: string length must be an integer >= 1, got ${length}`);
+      const s2 = st[1] === "u8" ? 1 : 2;
+      return { size: s2 * length, align: s2, type: { tag: "string", encoding: st[3] } };
+    }
+    const a = /^([^\[\]]+)\[(\d+)\]$/.exec(v);
+    if (a) {
+      const length = Number(a[2]);
+      if (!Number.isInteger(length) || length < 1)
+        throw new Error(`ffi-struct: array length must be an integer >= 1, got ${length}`);
+      const el = lower(a[1]);
+      if (el.type.tag === "bitfield")
+        throw new Error("ffi-struct: bitfields cannot be array elements");
+      return {
+        size: el.size * length,
+        align: el.align,
+        type: { tag: "array", elementType: el.type, elementSize: el.size }
+      };
+    }
+    const b6 = /^([A-Za-z_]\w*):(\d+)$/.exec(v);
+    if (b6) {
+      const rawUnit = b6[1];
+      const unit = normToken(rawUnit);
+      if (!isCNumberToken(unit) || unit === "f32" || unit === "f64")
+        throw new Error(`ffi-struct: bitfield unit must be an integer type, got "${rawUnit}"`);
+      const width = Number(b6[2]);
+      const s2 = SizeAlign[unit];
+      const cap = s2 * 8;
+      if (!Number.isInteger(width) || width < 1)
+        throw new Error(`ffi-struct: bitfield width must be an integer >= 1, got ${width}`);
+      if (width > cap)
+        throw new Error(`ffi-struct: bitfield width ${width} exceeds unit width ${cap}`);
+      return { size: s2, align: s2, type: { tag: "bitfield", unit, bit: 0, width } };
+    }
+    const k = normToken(v);
+    if (isCPtrToken(k))
+      return { size: PTR_SIZE, align: PTR_SIZE, type: { tag: "basic", kind: "ptr" } };
+    if (!isCNumberToken(k))
+      throw new Error(`ffi-struct: unknown kind "${v}"`);
+    const s = SizeAlign[k];
+    return { size: s, align: s, type: { tag: "basic", kind: k } };
   }
-  return out;
+  if (v && typeof v === "object") {
+    const o = v;
+    const tag = o["#"];
+    if (tag === void 0)
+      throw new Error(`ffi-struct: nested object value requires a '#' key ('struct' | 'union' | 'array')`);
+    if (tag === "array" && "#pack" in o)
+      throw new Error(`ffi-struct: '#pack' is only allowed on struct/union, got '${tag}'`);
+    if (tag === "array") {
+      const length = o["length"];
+      if (!Number.isInteger(length) || length < 1)
+        throw new Error(`ffi-struct: array length must be an integer >= 1, got ${String(length)}`);
+      const el = lower(o["element"]);
+      if (el.type.tag === "bitfield")
+        throw new Error("ffi-struct: bitfields cannot be array elements");
+      return {
+        size: el.size * length,
+        align: el.align,
+        type: { tag: "array", elementType: el.type, elementSize: el.size }
+      };
+    }
+    if (tag === "struct" || tag === "union") {
+      const l = computeStructLayout(v);
+      return { size: l.size, align: l.maxEffectiveAlign, type: { tag, fields: l.fields } };
+    }
+    throw new Error(`ffi-struct: unknown '#' declaration ${JSON.stringify(String(tag))}`);
+  }
+  throw new Error(`ffi-struct: invalid member value: ${String(v)}`);
+}
+function computeStructLayout(t) {
+  const isStruct = t["#"] === "struct";
+  const pack = t["#pack"] ?? 8;
+  let maxEffectiveAlign = 1;
+  let maxMemberSize = 0;
+  const fields = [];
+  let cursor = 0;
+  let unitBase = -1;
+  let unitBits = 0;
+  let unitSize = 0;
+  const flushUnit = () => {
+    if (unitBase < 0)
+      return;
+    cursor = alignUp(unitBase + Math.ceil(unitBits / 8), unitSize);
+    unitBase = -1;
+  };
+  for (const [rawName, v] of Object.entries(t)) {
+    if (rawName.startsWith("#"))
+      continue;
+    const m = /^([^@]+)@(\d+)$/.exec(rawName);
+    const name = m ? m[1] : rawName;
+    const alignas = m ? Number(m[2]) : 0;
+    const { size, align: natural, type } = lower(v);
+    const nonnull = typeof v === "string" && v.endsWith("!");
+    let align = natural;
+    if (pack > 0)
+      align = Math.min(pack, align);
+    if (alignas)
+      align = Math.max(align, alignas);
+    if (type.tag === "bitfield") {
+      if (name.startsWith("$"))
+        throw new Error("ffi-struct: bitfield members must be named");
+      if (!isStruct) {
+        fields.push({ name, offset: 0, size, type: { ...type, bit: 0 } });
+        maxEffectiveAlign = Math.max(maxEffectiveAlign, align);
+        maxMemberSize = Math.max(maxMemberSize, size);
+        continue;
+      }
+      const width = type.width;
+      if (unitBase < 0 || size !== unitSize || unitBits + width > unitSize * 8) {
+        if (unitBase >= 0)
+          flushUnit();
+        const offset2 = alignUp(cursor, align);
+        unitBase = offset2;
+        unitBits = 0;
+        unitSize = size;
+      }
+      fields.push({
+        name,
+        offset: unitBase,
+        // 单元基址（不是位域自己的地址）
+        size,
+        type: { ...type, bit: unitBits }
+      });
+      unitBits += width;
+      maxEffectiveAlign = Math.max(maxEffectiveAlign, align);
+      maxMemberSize = Math.max(maxMemberSize, size);
+      continue;
+    }
+    flushUnit();
+    const offset = alignUp(cursor, align);
+    if (!name.startsWith("$")) {
+      fields.push({ name, offset, size, type, ...nonnull ? { nonnull: true } : {} });
+    } else {
+      if (type.tag !== "struct" && type.tag !== "union")
+        throw new Error(`ffi-struct: anonymous member "${name}" must be a struct/union`);
+      for (const cf of type.fields)
+        fields.push({ ...cf, offset: cf.offset + offset });
+    }
+    if (isStruct)
+      cursor = offset + size;
+    maxEffectiveAlign = Math.max(maxEffectiveAlign, align);
+    maxMemberSize = Math.max(maxMemberSize, size);
+  }
+  flushUnit();
+  return {
+    size: isStruct ? alignUp(cursor, maxEffectiveAlign) : alignUp(maxMemberSize, maxEffectiveAlign),
+    maxEffectiveAlign,
+    fields
+  };
+}
+function readUnitRaw(dv, off, unit) {
+  const s = SizeAlign[unit];
+  if (s === 1)
+    return BigInt(dv.getUint8(off));
+  if (s === 2)
+    return BigInt(dv.getUint16(off, true));
+  if (s === 4)
+    return BigInt(dv.getUint32(off, true));
+  return dv.getBigUint64(off, true);
+}
+function writeUnitRaw(dv, off, unit, v) {
+  const s = SizeAlign[unit];
+  if (s === 1) {
+    dv.setUint8(off, Number(v & 0xffn));
+    return;
+  }
+  if (s === 2) {
+    dv.setUint16(off, Number(v & 0xffffn), true);
+    return;
+  }
+  if (s === 4) {
+    dv.setUint32(off, Number(v & 0xffffffffn), true);
+    return;
+  }
+  dv.setBigUint64(off, v & 0xffffffffffffffffn, true);
+}
+function readBitfield(dv, off, t) {
+  const w = BigInt(t.width);
+  let v = readUnitRaw(dv, off, t.unit) >> BigInt(t.bit) & (1n << w) - 1n;
+  if (t.unit[0] === "i" && v & 1n << w - 1n)
+    v -= 1n << w;
+  if (t.width > 53)
+    return v;
+  return Number(v);
+}
+function writeBitfield(dv, off, t, val) {
+  const w = BigInt(t.width);
+  const bit = BigInt(t.bit);
+  const widthMask = (1n << w) - 1n;
+  const posMask = widthMask << bit;
+  const raw = readUnitRaw(dv, off, t.unit);
+  const bits = (typeof val === "bigint" ? val : BigInt(Math.trunc(val))) & widthMask;
+  writeUnitRaw(dv, off, t.unit, raw & ~posMask | bits << bit);
+}
+var stringEncoders = {
+  "utf-8": new TextEncoder("utf-8"),
+  "utf-16le": new TextEncoder("utf-16le")
+};
+var stringDecoders = {
+  "utf-8": new TextDecoder("utf-8", { ignoreBOM: true }),
+  "utf-16le": new TextDecoder("utf-16le", { ignoreBOM: true })
+};
+function readString(dv, off, size, enc) {
+  const bytes = new Uint8Array(dv.buffer, dv.byteOffset + off, size);
+  const unit = enc === "utf-16le" ? 2 : 1;
+  let end = size;
+  for (let i = 0; i + unit <= size; i += unit) {
+    if (bytes[i] === 0 && (unit === 1 || bytes[i + 1] === 0)) {
+      end = i;
+      break;
+    }
+  }
+  return stringDecoders[enc].decode(bytes.subarray(0, end));
+}
+function writeString(dv, off, size, enc, v) {
+  const bytes = new Uint8Array(dv.buffer, dv.byteOffset + off, size);
+  bytes.fill(0);
+  const unit = enc === "utf-16le" ? 2 : 1;
+  const cap = size - unit;
+  if (cap <= 0)
+    return;
+  const src = stringEncoders[enc].encode(String(v ?? ""));
+  bytes.set(src.subarray(0, Math.min(src.length, cap)));
+}
+function readArray(dv, off, size, t) {
+  const count = t.elementSize > 0 ? size / t.elementSize : 0;
+  const out = [];
+  for (let i = 0; i < count; i++)
+    out.push(readElement(dv, off + i * t.elementSize, t.elementType, t.elementSize));
+  return out;
+}
+function writeArray(dv, off, size, t, v) {
+  const count = t.elementSize > 0 ? size / t.elementSize : 0;
+  const list = v ?? [];
+  for (let i = 0; i < count; i++)
+    writeElement(dv, off + i * t.elementSize, t.elementType, t.elementSize, list[i]);
+}
+function readElement(dv, off, t, size) {
+  switch (t.tag) {
+    case "basic":
+      return readScalar(dv, off, t.kind);
+    case "bitfield":
+      return readBitfield(dv, off, t);
+    case "string":
+      return readString(dv, off, size, t.encoding);
+    case "struct":
+    case "union":
+      return doDecode(dv, off, t.fields);
+    case "array":
+      return readArray(dv, off, size, t);
+  }
+}
+function writeElement(dv, off, t, size, val) {
+  switch (t.tag) {
+    // TODO: remove this any
+    case "basic":
+      writeScalar(dv, off, { k: t.kind, v: val });
+      break;
+    // 直传（不 Number()）：writeBitfield 的 val 是 number | bigint，
+    // 64 位单元走 bigint，先 Number() 会把 >2^53 的位域值截断。
+    case "bitfield":
+      writeBitfield(dv, off, t, val ?? 0);
+      break;
+    case "string":
+      writeString(dv, off, size, t.encoding, val);
+      break;
+    case "struct":
+    case "union":
+      doEncode(dv, off, t.fields, val ?? {});
+      break;
+    case "array":
+      writeArray(dv, off, size, t, val);
+      break;
+  }
+}
+function doDecode(dv, base, fields) {
+  const out = {};
+  for (const f of fields) {
+    const v = readElement(dv, base + f.offset, f.type, f.size);
+    if (f.nonnull && v === 0)
+      throw new Error(`ffi-struct: decode: '!' field "${f.name}" got 0 (C did not fill it, or decode was called on an unfilled slot)`);
+    out[f.name] = v;
+  }
+  return out;
+}
+function doEncode(dv, base, fields, v) {
+  for (const f of fields) {
+    if (v[f.name] === void 0)
+      continue;
+    writeElement(dv, base + f.offset, f.type, f.size, v[f.name]);
+  }
+}
+function createStruct(t) {
+  const { fields, size, maxEffectiveAlign } = computeStructLayout(t);
+  return {
+    __struct: t,
+    size,
+    structAlign: maxEffectiveAlign,
+    decode: (p) => {
+      if (typeof p === "number")
+        return doDecode(new DataView(ffi2.readBytes(p, size)), 0, fields);
+      return doDecode(new DataView(p), 0, fields);
+    },
+    alloc: ((n) => {
+      if (n !== void 0 && (!Number.isInteger(n) || n < 1))
+        throw new Error(`ffi-struct: alloc(n) requires an integer n >= 1 (PAB(0) never escapes \u2014 pass NULL for an empty pointer position)`);
+      return new PtrArrayBuffer(size * (n ?? 1));
+    }),
+    encode: ((v, buf, offset) => {
+      if (v === void 0 || v === null)
+        throw new Error(`ffi-struct: encode(v) requires an argument; use alloc() for a zeroed out-param slot`);
+      const out = buf ?? new PtrArrayBuffer(size);
+      doEncode(new DataView(out), offset ?? 0, fields, v);
+      return out;
+    }),
+    offsetOf: (name) => {
+      for (const f of fields)
+        if (f.name === name)
+          return f.offset;
+      throw new Error(`ffi-struct: no field "${name}"`);
+    }
+  };
+}
+function buildDecl(kind, member, pack) {
+  const decl = { "#": kind };
+  if (pack !== void 0)
+    decl["#pack"] = pack;
+  for (const [k, v] of Object.entries(member))
+    if (!k.startsWith("#"))
+      decl[k] = v;
+  return decl;
+}
+function structArray(def) {
+  const { fields, size } = computeStructLayout(def.__struct);
+  const readN = (dv, n) => {
+    const out = [];
+    for (let i = 0; i < n; i++)
+      out.push(doDecode(dv, i * size, fields));
+    return out;
+  };
+  return {
+    encode: (els) => {
+      if (!Array.isArray(els) || els.length === 0)
+        throw new Error(`ffi-struct: structArray(def).encode(els) requires a non-empty element array (pass NULL for an empty pointer position)`);
+      const out = def.alloc(els.length);
+      for (let i = 0; i < els.length; i++)
+        def.encode(els[i], out, i * def.size);
+      return out;
+    },
+    decode: ((p, count) => {
+      if (count !== void 0 && (!Number.isInteger(count) || count < 0))
+        throw new Error(`ffi-struct: structArray.decode(p, count) requires a non-negative integer count, got ${count}`);
+      if (typeof p === "number") {
+        if (count === void 0)
+          throw new Error(`ffi-struct: structArray.decode(address, count) requires an explicit count (a bare address carries no length)`);
+        if (count === 0)
+          return [];
+        return readN(new DataView(ffi2.readBytes(p, count * size)), count);
+      }
+      let n;
+      if (count !== void 0) {
+        n = count;
+        if (n * size > p.byteLength)
+          throw new Error(`ffi-struct: structArray.decode: count ${n} \xD7 size ${size} = ${n * size} exceeds buffer byteLength ${p.byteLength}`);
+      } else {
+        if (p.byteLength % size !== 0)
+          throw new Error(`ffi-struct: structArray.decode: byteLength ${p.byteLength} is not a multiple of size ${size} (mixed buffer? pass count explicitly)`);
+        n = p.byteLength / size;
+      }
+      if (n === 0)
+        return [];
+      return readN(new DataView(p), n);
+    })
+  };
+}
+function struct(a, b6, c) {
+  const isNamed = typeof a === "string";
+  const raw = isNamed ? b6 : a;
+  const opts = isNamed ? c : b6;
+  return createStruct(buildDecl("struct", raw, opts?.pack));
+}
+
+// _build/lib/windows/structs.js
+var RECT = /* @__PURE__ */ struct("RECT", {
+  left: "i32",
+  top: "i32",
+  right: "i32",
+  bottom: "i32"
+});
+var POINT = /* @__PURE__ */ struct("POINT", {
+  x: "i32",
+  y: "i32"
+});
+var SIZE = /* @__PURE__ */ struct("SIZE", {
+  cx: "i32",
+  cy: "i32"
+});
+var LOGFONTW = /* @__PURE__ */ struct("LOGFONTW", {
+  lfHeight: "i32",
+  lfWidth: "i32",
+  lfEscapement: "i32",
+  lfOrientation: "i32",
+  lfWeight: "i32",
+  lfItalic: "u8",
+  lfUnderline: "u8",
+  lfStrikeOut: "u8",
+  lfCharSet: "u8",
+  lfOutPrecision: "u8",
+  lfClipPrecision: "u8",
+  lfQuality: "u8",
+  lfPitchAndFamily: "u8",
+  lfFaceName: "u16[32]@utf-16le"
+});
+var OPENFILENAMEW = /* @__PURE__ */ struct("OPENFILENAMEW", {
+  lStructSize: "u32",
+  hwndOwner: "<HWND>ptr",
+  hInstance: "<HMODULE>ptr",
+  lpstrFilter: "<>ptr",
+  lpstrCustomFilter: "<>ptr",
+  nMaxCustFilter: "u32",
+  nFilterIndex: "u32",
+  lpstrFile: "<>ptr",
+  nMaxFile: "u32",
+  lpstrFileTitle: "<>ptr",
+  nMaxFileTitle: "u32",
+  lpstrInitialDir: "<>ptr",
+  lpstrTitle: "<>ptr",
+  Flags: "u32",
+  nFileOffset: "u16",
+  nFileExtension: "u16",
+  lpstrDefExt: "<>ptr",
+  lCustData: "<>ptr",
+  lpfnHook: "<>ptr",
+  lpTemplateName: "<>ptr",
+  pvReserved: "<>ptr",
+  dwReserved: "u32",
+  FlagsEx: "u32"
+});
+var BROWSEINFOW = /* @__PURE__ */ struct("BROWSEINFOW", {
+  hwndOwner: "<HWND>ptr",
+  pidlRoot: "<>ptr",
+  pszDisplayName: "<>ptr",
+  lpszTitle: "<>ptr",
+  ulFlags: "u32",
+  lpfn: "<>ptr",
+  lParam: "<>ptr",
+  iImage: "i32"
+});
+var NMHDR = /* @__PURE__ */ struct("NMHDR", {
+  hwndFrom: "<HWND>ptr",
+  idFrom: "<>ptr",
+  code: "i32"
+});
+var SYSTEMTIME = /* @__PURE__ */ struct("SYSTEMTIME", {
+  wYear: "u16",
+  wMonth: "u16",
+  wDayOfWeek: "u16",
+  wDay: "u16",
+  wHour: "u16",
+  wMinute: "u16",
+  wSecond: "u16",
+  wMilliseconds: "u16"
+});
+var NMDATETIMECHANGE = /* @__PURE__ */ struct("NMDATETIMECHANGE", {
+  hdr: NMHDR.__struct,
+  dwFlags: "u32",
+  st: SYSTEMTIME.__struct
+});
+var LITEM = /* @__PURE__ */ struct("LITEM", {
+  mask: "u32",
+  iLink: "i32",
+  state: "u32",
+  stateMask: "u32",
+  szID: "u16[48]@utf-16le",
+  szUrl: "u16[2084]@utf-16le"
+});
+var NMLINK = /* @__PURE__ */ struct("NMLINK", {
+  hdr: NMHDR.__struct,
+  item: LITEM.__struct
+});
+var NMCUSTOMDRAW = /* @__PURE__ */ struct("NMCUSTOMDRAW", {
+  hdr: NMHDR.__struct,
+  dwDrawStage: "u32",
+  hdc: "<HDC>ptr",
+  rc: "i32[4]",
+  dwItemSpec: "<>ptr",
+  uItemState: "u32",
+  lItemlParam: "<>ptr"
+});
+var NMLVCUSTOMDRAW = /* @__PURE__ */ struct("NMLVCUSTOMDRAW", {
+  hdr: NMHDR.__struct,
+  dwDrawStage: "u32",
+  hdc: "<HDC>ptr",
+  rc: "i32[4]",
+  dwItemSpec: "<>ptr",
+  uItemState: "u32",
+  lItemlParam: "<>ptr",
+  clrText: "u32",
+  clrTextBk: "u32",
+  iSubItem: "i32",
+  dwItemType: "u32"
+});
+var NMLISTVIEW = /* @__PURE__ */ struct("NMLISTVIEW", {
+  hdr: NMHDR.__struct,
+  iItem: "i32",
+  iSubItem: "i32",
+  uNewState: "u32",
+  uOldState: "u32",
+  uChanged: "u32",
+  ptAction: "i32[2]",
+  lParam: "<>ptr"
+});
+var TCITEMW = /* @__PURE__ */ struct("TCITEMW", {
+  mask: "u32",
+  dwState: "u32",
+  dwStateMask: "u32",
+  pszText: "<>ptr",
+  cchTextMax: "i32",
+  iImage: "i32",
+  lParam: "<>ptr"
+});
+var TVITEM = /* @__PURE__ */ struct("TVITEM", {
+  mask: "u32",
+  hItem: "<>ptr",
+  state: "u32",
+  stateMask: "u32",
+  pszText: "<>ptr",
+  cchTextMax: "i32",
+  iImage: "i32",
+  iSelectedImage: "i32",
+  cChildren: "i32",
+  lParam: "<>ptr"
+});
+var TVINSERTSTRUCT = /* @__PURE__ */ struct("TVINSERTSTRUCT", {
+  hParent: "<>ptr",
+  hInsertAfter: "<>ptr",
+  item: TVITEM.__struct
+});
+var LVHITTESTINFO = /* @__PURE__ */ struct("LVHITTESTINFO", {
+  pt: "i32[2]",
+  flags: "u32",
+  iItem: "i32",
+  iSubItem: "i32",
+  iGroup: "i32"
+});
+var LVITEMW = /* @__PURE__ */ struct("LVITEMW", {
+  mask: "u32",
+  iItem: "i32",
+  iSubItem: "i32",
+  state: "u32",
+  stateMask: "u32",
+  pszText: "<>ptr",
+  cchTextMax: "i32",
+  iImage: "i32",
+  lParam: "<>ptr",
+  iIndent: "i32",
+  iGroupId: "i32",
+  cColumns: "u32",
+  puColumns: "<>ptr",
+  piColFmt: "<>ptr",
+  iGroup: "i32"
+});
+var LVCOLUMNW = /* @__PURE__ */ struct("LVCOLUMNW", {
+  mask: "u32",
+  fmt: "i32",
+  cx: "i32",
+  pszText: "<>ptr",
+  cchTextMax: "i32",
+  iSubItem: "i32",
+  iImage: "i32",
+  iOrder: "i32",
+  cxMin: "i32",
+  cxDefault: "i32",
+  cxIdeal: "i32"
+});
+var MSG = /* @__PURE__ */ struct("MSG", {
+  hwnd: "<HWND>ptr",
+  message: "u32",
+  wParam: "<>ptr",
+  lParam: "<>ptr",
+  time: "u32",
+  pt: POINT.__struct
+});
+var PAINTSTRUCT = /* @__PURE__ */ struct("PAINTSTRUCT", {
+  hdc: "<HDC>ptr",
+  fErase: "i32",
+  rcPaint: RECT.__struct,
+  fRestore: "i32",
+  fIncUpdate: "i32",
+  rgbReserved: "u8[32]"
+});
+
+// _build/lib/windows/user32.js
+var b = (name, sig, encoders) => bind("user32.dll", name, sig, encoders);
+var _bProbe = b("GetDesktopWindow", " -> <HWND>ptr");
+var LONG_PTR_SYM = os3.arch === "x64" ? "PtrW" : "W";
+var SetWindowPos = /* @__PURE__ */ b("SetWindowPos", "<HWND>ptr <>ptr@SetWindowPosHwnd i32 i32 i32 i32 u32 -> i32");
+var SetWindowText = /* @__PURE__ */ b("SetWindowTextW", "<HWND>ptr <WCHAR>ptr -> i32");
+var GetWindowLongPtr = /* @__PURE__ */ b("GetWindowLong" + LONG_PTR_SYM, "<HWND>ptr i32@Gwlp -> <>ptr");
+var SetWindowLongPtr = /* @__PURE__ */ b("SetWindowLong" + LONG_PTR_SYM, "<HWND>ptr i32@Gwlp <>ptr -> <>ptr");
+var EnableWindow = /* @__PURE__ */ b("EnableWindow", "<HWND>ptr i32 -> i32");
+var SetParent = /* @__PURE__ */ b("SetParent", "<HWND>ptr <HWND>ptr -> <HWND>ptr");
+var DefWindowProc = /* @__PURE__ */ b("DefWindowProcW", "<HWND>ptr u32@AnyMsg <>ptr <>ptr -> <>ptr");
+var CallWindowProc = /* @__PURE__ */ b("CallWindowProcW", "<>ptr <HWND>ptr u32@AnyMsg <>ptr <>ptr -> <>ptr");
+var GetDC = /* @__PURE__ */ b("GetDC", "<HWND>ptr -> <HDC>ptr");
+var ReleaseDC = /* @__PURE__ */ b("ReleaseDC", "<HWND>ptr <HDC>ptr! -> i32");
+var DrawText = /* @__PURE__ */ b("DrawTextW", "<HDC>ptr! <WCHAR>ptr i32 <RECT>ptr i32 -> i32");
+var InvalidateRect = /* @__PURE__ */ b("InvalidateRect", "<HWND>ptr <RECT>ptr i32 -> i32", { RECT });
+var SetCursor = /* @__PURE__ */ b("SetCursor", "<HCURSOR>ptr -> <HCURSOR>ptr");
+var LoadCursor = /* @__PURE__ */ b("LoadCursorW", "<HMODULE>ptr <>ptr -> <HCURSOR>ptr");
+var GetCursorPos = /* @__PURE__ */ b("GetCursorPos", "<POINT>ptr -> i32");
+var ScreenToClient = /* @__PURE__ */ b("ScreenToClient", "<HWND>ptr <POINT>ptr -> i32");
+var ShowScrollBar = /* @__PURE__ */ b("ShowScrollBar", "<HWND>ptr u32 i32 -> i32");
+var GetSystemMetrics = /* @__PURE__ */ b("GetSystemMetrics", "i32 -> i32");
+
+// _build/lib/react-qw/reconciler.js
+var import_react_reconciler = __toESM(require_react_reconciler(), 1);
+var import_react = __toESM(require_react(), 1);
+var import_constants = __toESM(require_constants(), 1);
+import * as gui3 from "gui";
+import * as os4 from "os";
+
+// _build/lib/windows/gdi32.js
+var b2 = (name, sig, encoders) => bind("gdi32.dll", name, sig, encoders);
+var POINTArr = structArray(POINT);
+var DeleteObject = /* @__PURE__ */ b2("DeleteObject", "<HGDIOBJ>ptr -> i32");
+var GetDeviceCaps = /* @__PURE__ */ b2("GetDeviceCaps", "<HDC>ptr! i32@DeviceCap -> i32");
+var CreateFontIndirect = /* @__PURE__ */ b2("CreateFontIndirectW", "<LOGFONTW>ptr -> <HGDIOBJ>ptr", { LOGFONTW });
+var SelectObject = /* @__PURE__ */ b2("SelectObject", "<HDC>ptr! <HGDIOBJ>ptr -> <HGDIOBJ>ptr");
+var GetObject = /* @__PURE__ */ b2("GetObjectW", "<HGDIOBJ>ptr i32 <BYTE>ptr -> i32");
+
+// _build/lib/react-qw/props.js
+import * as gui from "gui";
+function applyProps(instance, newProps, _oldProps) {
+  const hwnd = instance.hwnd;
+  instance.props = newProps;
+  if (hwnd === null)
+    return;
+  const textVal = "text" in newProps ? newProps.text : typeof newProps.children === "string" ? newProps.children : typeof newProps.children === "number" ? String(newProps.children) : void 0;
+  if (textVal !== void 0) {
+    let cursor = -1;
+    if (instance.type === "EDIT") {
+      const sel = gui.SendMessage(hwnd, 176, 0, 0);
+      cursor = sel >>> 16;
+    }
+    SetWindowText(hwnd, textVal);
+    if (instance.type === "EDIT" && cursor >= 0) {
+      gui.SendMessage(hwnd, 177, cursor, cursor);
+    }
+  }
+  if ("disabled" in newProps) {
+    EnableWindow(hwnd, !newProps.disabled ? 1 : 0);
+  }
+  if ("hidden" in newProps) {
+    gui.ShowWindow(
+      hwnd,
+      newProps.hidden ? 0 : 5
+      /* gui.ShowWindowCmd.SHOW */
+    );
+  }
+  if ("visible" in newProps) {
+    gui.ShowWindow(
+      hwnd,
+      newProps.visible ? 5 : 0
+      /* gui.ShowWindowCmd.HIDE */
+    );
+  }
+}
+
+// _build/lib/react-qw/layout.js
+var DEFAULT_W = 100;
+var DEFAULT_H = 30;
+function calculateFlexLayout(flex, parentW, parentH, children) {
+  const dir = flex.flexDirection || "column";
+  const gap = flex.gap ?? 0;
+  const justify = flex.justifyContent || "flex-start";
+  const align = flex.alignItems || "stretch";
+  const isRow = dir === "row";
+  const n = children.length;
+  const mainSize = isRow ? "w" : "h";
+  const crossSize = isRow ? "h" : "w";
+  const mainPos = isRow ? "x" : "y";
+  const crossPos = isRow ? "y" : "x";
+  const mainDim = isRow ? "width" : "height";
+  const crossDim = isRow ? "height" : "width";
+  const pt = flex.paddingTop ?? flex.padding ?? 0;
+  const pr = flex.paddingRight ?? flex.padding ?? 0;
+  const pb = flex.paddingBottom ?? flex.padding ?? 0;
+  const pl = flex.paddingLeft ?? flex.padding ?? 0;
+  const mainPadding = isRow ? pl + pr : pt + pb;
+  const crossPadding = isRow ? pt + pb : pl + pr;
+  const parentMain = (isRow ? parentW : parentH) - mainPadding;
+  const parentCross = (isRow ? parentH : parentW) - crossPadding;
+  const sizes = children.map((c) => ({
+    w: typeof c.style.width === "number" ? c.style.width : DEFAULT_W,
+    h: typeof c.style.height === "number" ? c.style.height : DEFAULT_H
+  }));
+  const flexGrows = children.map((c) => c.style.flexGrow ?? 0);
+  const totalGrow = flexGrows.reduce((s, g) => s + g, 0);
+  const baseMain = sizes.reduce((s, c) => s + c[mainSize], 0);
+  let freeGrow = parentMain - baseMain - Math.max(0, n - 1) * gap;
+  if (totalGrow > 0 && freeGrow > 0) {
+    for (let i = 0; i < n; i++) {
+      sizes[i][mainSize] += freeGrow * flexGrows[i] / totalGrow;
+    }
+  }
+  const totalMain = sizes.reduce((s, c) => s + c[mainSize], 0);
+  const free = parentMain - totalMain - Math.max(0, n - 1) * gap;
+  let offset = 0, extraGap = 0;
+  if (justify === "flex-end")
+    offset = free;
+  else if (justify === "center")
+    offset = Math.max(0, free / 2);
+  else if (justify === "space-between" && n > 1)
+    extraGap = free / (n - 1);
+  else if (justify === "space-around") {
+    extraGap = free / n;
+    offset = extraGap / 2;
+  } else if (justify === "space-evenly") {
+    extraGap = free / (n + 1);
+    offset = extraGap;
+  }
+  let cursor = offset;
+  return sizes.map((sz, i) => {
+    const childCrossBase = sz[crossSize];
+    const childAlign = children[i].style.alignSelf ?? "auto";
+    const effectiveAlign = childAlign === "auto" ? align : childAlign;
+    let childMain = sz[mainSize];
+    let childCross = childCrossBase;
+    const res = { x: 0, y: 0, width: 0, height: 0 };
+    res[mainPos] = cursor;
+    res[crossPos] = 0;
+    res[mainDim] = childMain;
+    res[crossDim] = childCross;
+    if (effectiveAlign === "stretch") {
+      const hasExplicitCross = typeof children[i].style[crossDim] === "number";
+      if (!hasExplicitCross) {
+        res[crossDim] = parentCross;
+        res[crossPos] = 0;
+      }
+    } else if (effectiveAlign === "flex-end") {
+      res[crossPos] = parentCross - childCross;
+    } else if (effectiveAlign === "center") {
+      res[crossPos] = Math.max(0, (parentCross - childCross) / 2);
+    }
+    cursor += childMain + gap + extraGap;
+    return res;
+  });
 }
 
 // _build/lib/text-measure.js
-var user32 = bindLib("user32.dll", {
-  DrawTextW: "ptr wstr i32 ptr i32 -> i32",
-  GetDC: "ptr -> ptr",
-  ReleaseDC: "ptr ptr -> i32"
-});
-var gdi32 = bindLib("gdi32.dll", {
-  SelectObject: "ptr ptr -> ptr"
-});
+import * as gui2 from "gui";
 function measureText(hdc, text, maxWidth) {
-  const rect = new ArrayBuffer(16);
-  const dv = new DataView(rect);
-  dv.setInt32(8, maxWidth, true);
-  user32.DrawTextW(
+  const r = RECT.encode({ right: maxWidth });
+  DrawText(
     hdc,
     text,
     -1,
-    rect,
+    r.ptr,
     1024
     /* gui.DrawTextFlag.CALCRECT */
   );
-  return { width: dv.getInt32(8, true), height: dv.getInt32(12, true) };
+  const { right, bottom } = RECT.decode(r);
+  return { width: right, height: bottom };
 }
 function getButtonIdealSize(hwnd) {
-  const size = new ArrayBuffer(8);
-  gui2.SendMessage(hwnd, 5633, 0, ffi2.bufferPtr(size));
-  const dv = new DataView(size);
-  return { width: dv.getInt32(0, true), height: dv.getInt32(4, true) };
+  const size = SIZE.alloc();
+  gui2.SendMessage(hwnd, 5633, 0, size.ptr);
+  const { cx, cy } = SIZE.decode(size);
+  return { width: cx, height: cy };
 }
 function measureTextForHwnd(hwnd, text) {
-  const hdc = user32.GetDC(hwnd);
+  const hdc = GetDC(hwnd);
   if (!hdc)
     return { width: 0, height: 0 };
   const hFont = gui2.SendMessage(hwnd, 49, 0, 0);
-  const oldFont = hFont ? gdi32.SelectObject(hdc, hFont) : 0;
+  const oldFont = hFont ? SelectObject(hdc, hFont) : NULL;
   const result = measureText(hdc, text, 0);
   if (hFont)
-    gdi32.SelectObject(hdc, oldFont);
-  user32.ReleaseDC(hwnd, hdc);
+    SelectObject(hdc, oldFont);
+  ReleaseDC(hwnd, hdc);
   const wr = gui2.GetWindowRect(hwnd);
   const cr = gui2.GetClientRect(hwnd);
   if (wr && cr) {
@@ -15862,14 +16774,20 @@ function measureTextForHwnd(hwnd, text) {
 
 // _build/lib/react-qw/reconciler.js
 var dpiFont = gui3.CreateSystemDpiFont();
-var scaleFactor = gui3.GetScaleFactor();
+var scaleFactor = (() => {
+  const hdc = GetDC(NULL);
+  const dpi = hdc ? GetDeviceCaps(hdc, 88) : 96;
+  if (hdc)
+    ReleaseDC(NULL, hdc);
+  return dpi / 96;
+})();
 var DELAYED_CONTROLS = /* @__PURE__ */ new Set(["SysListView32", "SysTreeView32", "LISTBOX", "COMBOBOX", "msctls_trackbar32", "SysDateTimePick32", "SysLink"]);
 function isDelayedControl(winClass) {
   return DELAYED_CONTROLS.has(winClass);
 }
 function setupWindowProc(instance, hwnd) {
   instance.hwnd = hwnd;
-  const oldProc = gui3.GetWindowLongPtr(
+  const oldProc = GetWindowLongPtr(
     hwnd,
     -4
     /* gui.Gwlp.WNDPROC */
@@ -15878,11 +16796,11 @@ function setupWindowProc(instance, hwnd) {
   gui3.SetWindowProc(hwnd, (hwnd2, msg, wParam, lParam) => {
     const ev = instance.props.onEvent;
     if (!ev)
-      return gui3.CallWindowProc(oldProc, hwnd2, msg, wParam, lParam);
+      return CallWindowProc(oldProc, hwnd2, msg, wParam, lParam);
     if (typeof ev === "object") {
-      return ev.fn({ hwnd: hwnd2, msg, wParam, lParam, callOldWndProc: () => gui3.CallWindowProc(oldProc, hwnd2, msg, wParam, lParam) });
+      return ev.fn({ hwnd: hwnd2, msg, wParam, lParam, callOldWndProc: () => CallWindowProc(oldProc, hwnd2, msg, wParam, lParam) });
     }
-    const result = gui3.CallWindowProc(oldProc, hwnd2, msg, wParam, lParam);
+    const result = CallWindowProc(oldProc, hwnd2, msg, wParam, lParam);
     const override = ev({ hwnd: hwnd2, msg, wParam, lParam });
     return typeof override === "number" && Number.isInteger(override) ? override : result;
   });
@@ -15952,7 +16870,7 @@ function runFlexLayout(inst) {
     if (lr && lr.x === r.x && lr.y === r.y && lr.w === r.width && lr.h === r.height)
       continue;
     console.log("flex: set", child.type, child.hwnd, "to", r.x, r.y, r.width, r.height);
-    gui3.SetWindowPos(
+    SetWindowPos(
       child.hwnd,
       0,
       (r.x + pl) * scaleFactor,
@@ -15962,7 +16880,7 @@ function runFlexLayout(inst) {
       64
       /* gui.SetWindowPosFlag.SWP_SHOWWINDOW */
     );
-    gui3.InvalidateRect(child.hwnd, null, true);
+    InvalidateRect(child.hwnd, NULL, 1);
     child.lastRect = { x: r.x, y: r.y, w: r.width, h: r.height };
   }
   for (const c of children)
@@ -16008,7 +16926,7 @@ var hostConfig = {
     if (child.hwnd === null) {
       ensureChildWindow(child, parent.hwnd);
     } else {
-      gui3.SetParent(child.hwnd, parent.hwnd);
+      SetParent(child.hwnd, parent.hwnd ?? NULL);
     }
     if (false)
       console.log("[reconciler] appendInitialChild parent:", parent.hwnd, "child:", child.hwnd);
@@ -16018,7 +16936,7 @@ var hostConfig = {
     if (child.hwnd === null) {
       ensureChildWindow(child, parent.hwnd);
     } else {
-      gui3.SetParent(child.hwnd, parent.hwnd);
+      SetParent(child.hwnd, parent.hwnd ?? NULL);
     }
     if (false)
       console.log("[reconciler] appendChild parent:", parent.hwnd, "child:", child.hwnd);
@@ -16028,7 +16946,7 @@ var hostConfig = {
     if (child.hwnd === null) {
       ensureChildWindow(child, container);
     } else {
-      gui3.SetParent(child.hwnd, container);
+      SetParent(child.hwnd, container);
     }
     const rootInst = instancesByHwnd.get(container);
     if (rootInst)
@@ -16040,7 +16958,7 @@ var hostConfig = {
     if (child.hwnd === null) {
       ensureChildWindow(child, parent.hwnd);
     } else {
-      gui3.SetParent(child.hwnd, parent.hwnd);
+      SetParent(child.hwnd, parent.hwnd ?? NULL);
     }
     if (false)
       console.log("[reconciler] insertBefore parent:", parent.hwnd, "child:", child.hwnd, "before:", beforeChild.hwnd);
@@ -16052,7 +16970,7 @@ var hostConfig = {
     if (child.hwnd === null) {
       ensureChildWindow(child, container);
     } else {
-      gui3.SetParent(child.hwnd, container);
+      SetParent(child.hwnd, container);
     }
     const rootInst = instancesByHwnd.get(container);
     if (!rootInst)
@@ -16109,7 +17027,7 @@ var hostConfig = {
   resetTextContent(_instance) {
   },
   commitTextUpdate(instance, _oldText, newText) {
-    gui3.SetWindowText(instance.hwnd, newText);
+    SetWindowText(instance.hwnd, newText);
   },
   hideInstance(instance) {
     if (instance.hwnd !== null)
@@ -16163,10 +17081,10 @@ var hostConfig = {
   clearContainer(_container) {
   },
   scheduleTimeout(fn, delay) {
-    return os.setTimeout(fn, delay);
+    return os4.setTimeout(fn, delay);
   },
   cancelTimeout(id) {
-    os.clearTimeout?.(id);
+    os4.clearTimeout?.(id);
   },
   noTimeout: -1,
   supportsMutation: true,
@@ -16333,298 +17251,23 @@ var ComboBox = (0, import_react4.forwardRef)(({ items, selectedIndex: controlled
 var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
 var import_react5 = __toESM(require_react(), 1);
 import * as gui6 from "gui";
-import * as ffi4 from "ffi";
-
-// _build/lib/ffi-struct.js
-import * as os2 from "os";
-var PTR = os2.arch === "x64" ? 8 : 4;
-var AS = {
-  u8: [1, 1],
-  i8: [1, 1],
-  u16: [2, 2],
-  i16: [2, 2],
-  u32: [4, 4],
-  i32: [4, 4],
-  u64: [8, 8],
-  i64: [8, 8],
-  f32: [4, 4],
-  f64: [8, 8],
-  ptr: [PTR, PTR],
-  wstr: [2, 2]
-  // 仅定长数组元素用（wchar）
-};
-function alignUp(v, a) {
-  return v + a - 1 & ~(a - 1);
-}
-function parseField(f) {
-  const arr = /^(.+)\[(\d+)\]$/.exec(f);
-  if (arr) {
-    const b2 = normKind(arr[1]);
-    if (b2 === "void")
-      throw new Error(`ffi-struct: "void" cannot be an array base`);
-    return { base: b2, count: Number(arr[2]) };
-  }
-  const b = normKind(f);
-  if (b === "void" || b === "wstr")
-    throw new Error(`ffi-struct: invalid scalar field type "${f}"`);
-  return { base: b, count: 1 };
-}
-function layout(def) {
-  const fields = [];
-  let cursor = 0;
-  let maxAlign = 1;
-  for (const key of Object.keys(def)) {
-    const v = def[key];
-    let a;
-    let w;
-    if (typeof v === "string") {
-      const { base, count } = parseField(v);
-      const [align, elem] = AS[base];
-      a = align;
-      w = count >= 1 ? elem * count : elem;
-      fields.push({ name: key, base, count, offset: 0 });
-    } else {
-      const child = v;
-      a = child.structAlign;
-      w = child.size;
-      fields.push({ name: key, base: "u8", count: 0, offset: 0, child });
-    }
-    const off = alignUp(cursor, a);
-    const f = fields[fields.length - 1];
-    f.offset = off;
-    cursor = off + w;
-    if (a > maxAlign)
-      maxAlign = a;
-  }
-  return { fields, size: alignUp(cursor, maxAlign), structAlign: maxAlign };
-}
-var _layoutCache = /* @__PURE__ */ new WeakMap();
-function buildLayout(def) {
-  let hit = _layoutCache.get(def);
-  if (hit)
-    return hit;
-  hit = layout(def);
-  _layoutCache.set(def, hit);
-  return hit;
-}
-function readScalar(dv, off, k) {
-  switch (k) {
-    case "u8":
-      return dv.getUint8(off);
-    case "i8":
-      return dv.getInt8(off);
-    case "u16":
-      return dv.getUint16(off, true);
-    case "i16":
-      return dv.getInt16(off, true);
-    case "u32":
-      return dv.getUint32(off, true);
-    case "i32":
-      return dv.getInt32(off, true);
-    case "u64":
-      return Number(dv.getBigUint64(off, true));
-    case "i64":
-      return Number(dv.getBigInt64(off, true));
-    case "f32":
-      return dv.getFloat32(off, true);
-    case "f64":
-      return dv.getFloat64(off, true);
-    case "ptr":
-      return readPtr(dv, off);
-    case "wstr":
-      return dv.getUint16(off, true);
-  }
-}
-function readPtr(dv, off) {
-  if (PTR === 8)
-    return Number(dv.getBigUint64(off, true));
-  return dv.getUint32(off, true);
-}
-function writeScalar(dv, off, k, val) {
-  switch (k) {
-    case "u8":
-      dv.setUint8(off, val);
-      break;
-    case "i8":
-      dv.setInt8(off, val);
-      break;
-    case "u16":
-      dv.setUint16(off, val, true);
-      break;
-    case "i16":
-      dv.setInt16(off, val, true);
-      break;
-    case "u32":
-      dv.setUint32(off, val >>> 0, true);
-      break;
-    case "i32":
-      dv.setInt32(off, val | 0, true);
-      break;
-    case "u64":
-      dv.setBigUint64(off, BigInt(Math.trunc(val)), true);
-      break;
-    case "i64":
-      dv.setBigInt64(off, BigInt(Math.trunc(val)), true);
-      break;
-    case "f32":
-      dv.setFloat32(off, val, true);
-      break;
-    case "f64":
-      dv.setFloat64(off, val, true);
-      break;
-    case "ptr":
-      writePtr(dv, off, val);
-      break;
-    case "wstr":
-      dv.setUint16(off, val, true);
-      break;
-  }
-}
-function writePtr(dv, off, val) {
-  if (PTR === 8)
-    dv.setBigUint64(off, BigInt(Math.trunc(val)), true);
-  else
-    dv.setUint32(off, val >>> 0, true);
-}
-function readField(dv, base, f) {
-  const off = base + f.offset;
-  if (f.child)
-    return readInto(f.child, dv.buffer, off);
-  if (f.count > 1) {
-    if (f.base === "wstr") {
-      const arr = new Uint16Array(dv.buffer, dv.byteOffset + off, f.count);
-      let end = 0;
-      while (end < arr.length && arr[end] !== 0)
-        end++;
-      let s = "";
-      for (let i = 0; i < end; i++)
-        s += String.fromCharCode(arr[i]);
-      return s;
-    }
-    const out = [];
-    const step = AS[f.base][1];
-    for (let i = 0; i < f.count; i++)
-      out.push(readScalar(dv, off + i * step, f.base));
-    return out;
-  }
-  return readScalar(dv, off, f.base);
-}
-function writeField(dv, base, f, v) {
-  const off = base + f.offset;
-  if (f.child) {
-    writeInto(f.child, v, dv.buffer, off);
-    return;
-  }
-  if (f.count > 1) {
-    if (f.base === "wstr") {
-      const s = String(v ?? "");
-      const arr = new Uint16Array(dv.buffer, dv.byteOffset + off, f.count);
-      for (let i = 0; i < arr.length; i++)
-        arr[i] = 0;
-      const n = Math.min(s.length, f.count - 1);
-      for (let i = 0; i < n; i++)
-        arr[i] = s.charCodeAt(i);
-      return;
-    }
-    const step = AS[f.base][1];
-    const list = v ?? [];
-    for (let i = 0; i < f.count; i++)
-      writeScalar(dv, off + i * step, f.base, list[i] ?? 0);
-    return;
-  }
-  writeScalar(dv, off, f.base, Number(v));
-}
-function doSize(def) {
-  return buildLayout(def).size;
-}
-function readInto(child, buf, offset) {
-  const r = child;
-  return r.read(buf, offset);
-}
-function doRead(_def, fields, buf, offset) {
-  const out = {};
-  const dv = new DataView(buf);
-  for (const f of fields)
-    out[f.name] = readField(dv, offset, f);
-  return out;
-}
-function doWrite(def, fields, v, buf, offset = 0) {
-  buf = buf ?? new ArrayBuffer(doSize(def));
-  const dv = new DataView(buf);
-  for (const f of fields)
-    writeField(dv, offset, f, v[f.name]);
-  return buf;
-}
-function writeInto(child, v, buf, offset) {
-  const w = child;
-  w.write(v, buf, offset);
-}
-function struct(def) {
-  const { fields, size, structAlign } = buildLayout(def);
-  return {
-    __fields: def,
-    size,
-    structAlign,
-    read: (buf, offset = 0) => doRead(def, fields, buf, offset),
-    write: (v, buf, offset = 0) => doWrite(def, fields, v, buf, offset),
-    offsetOf: (name) => {
-      for (const f of fields)
-        if (f.name === name)
-          return f.offset;
-      throw new Error(`ffi-struct: no field "${String(name)}"`);
-    }
-  };
-}
 
 // _build/lib/react-qw/nmhdr.js
-import * as os3 from "os";
-import * as ffi3 from "ffi";
-var IS64 = os3.arch === "x64";
-var PTR_SIZE = IS64 ? 8 : 4;
-var NMHDR = struct({ hwndFrom: "ptr", idFrom: "ptr", code: "i32" });
-var NMHDR_SIZE = NMHDR.size;
-var NMHDR_CODE = NMHDR.offsetOf("code");
-function readI32At(ptr, offset) {
-  return ffi3.readByte(ptr + offset) | ffi3.readByte(ptr + offset + 1) << 8 | ffi3.readByte(ptr + offset + 2) << 16 | ffi3.readByte(ptr + offset + 3) << 24;
-}
-function readU16At(ptr, offset) {
-  return ffi3.readByte(ptr + offset) | ffi3.readByte(ptr + offset + 1) << 8;
-}
 function nmCode(lParam) {
-  return readI32At(lParam, NMHDR_CODE);
+  return NMHDR.decode(lParam).code;
 }
 
 // _build/lib/react-qw/components/DateTimePicker.js
-var SYSTEMTIME = struct({
-  wYear: "u16",
-  wMonth: "u16",
-  wDayOfWeek: "u16",
-  wDay: "u16",
-  wHour: "u16",
-  wMinute: "u16",
-  wSecond: "u16",
-  wMilliseconds: "u16"
-});
-var NMDATETIMECHANGE = struct({
-  hdr: NMHDR,
-  dwFlags: "u32",
-  st: SYSTEMTIME
-});
-function bufPtr(buf) {
-  return ffi4.bufferPtr(buf);
-}
 function dateToSysTimeBuf(d) {
-  const buf = new ArrayBuffer(16);
-  const dv = new DataView(buf);
-  dv.setUint16(0, d.getFullYear(), true);
-  dv.setUint16(2, d.getMonth() + 1, true);
-  dv.setUint16(4, 0, true);
-  dv.setUint16(6, d.getDate(), true);
-  dv.setUint16(8, d.getHours(), true);
-  dv.setUint16(10, d.getMinutes(), true);
-  dv.setUint16(12, d.getSeconds(), true);
-  dv.setUint16(14, d.getMilliseconds(), true);
-  return buf;
+  return SYSTEMTIME.encode({
+    wYear: d.getFullYear(),
+    wMonth: d.getMonth() + 1,
+    wDay: d.getDate(),
+    wHour: d.getHours(),
+    wMinute: d.getMinutes(),
+    wSecond: d.getSeconds(),
+    wMilliseconds: d.getMilliseconds()
+  });
 }
 var DateTimePicker = (0, import_react5.forwardRef)(function DateTimePicker2({ value, onChange, defaultValue, format = "short", allowNone, updown, style }, ref) {
   const [internalDate, setInternalDate] = (0, import_react5.useState)(defaultValue ?? null);
@@ -16649,7 +17292,7 @@ var DateTimePicker = (0, import_react5.forwardRef)(function DateTimePicker2({ va
     const d = effectiveDate;
     if (d) {
       const buf = dateToSysTimeBuf(d);
-      gui6.SendMessage(h, 4098, 0, bufPtr(buf));
+      gui6.SendMessage(h, 4098, 0, buf.ptr);
     } else {
       gui6.SendMessage(h, 4098, 1, 0);
     }
@@ -16658,7 +17301,7 @@ var DateTimePicker = (0, import_react5.forwardRef)(function DateTimePicker2({ va
     const h = dpRef.current;
     if (!h)
       return;
-    gui6.InvalidateRect(h, null, true);
+    InvalidateRect(h, NULL, 1);
     const cr = gui6.GetClientRect(h);
     if (cr) {
       const w = cr.right - cr.left;
@@ -16670,20 +17313,13 @@ var DateTimePicker = (0, import_react5.forwardRef)(function DateTimePicker2({ va
     if (e.msg === 78) {
       const code = nmCode(e.lParam);
       if (code === -759) {
-        const st = NMDATETIMECHANGE.offsetOf("st");
-        const dwFlags = readI32At(e.lParam, NMDATETIMECHANGE.offsetOf("dwFlags"));
+        const { dwFlags, st } = NMDATETIMECHANGE.decode(e.lParam);
         if (dwFlags === 1) {
           if (!isControlled)
             setInternalDate(null);
           onChangeRef.current?.(null);
         } else {
-          const year = readU16At(e.lParam, st + 0);
-          const month = readU16At(e.lParam, st + 2);
-          const day = readU16At(e.lParam, st + 6);
-          const hour = readU16At(e.lParam, st + 8);
-          const min = readU16At(e.lParam, st + 10);
-          const sec = readU16At(e.lParam, st + 12);
-          const d = new Date(year, month - 1, day, hour, min, sec);
+          const d = new Date(st.wYear, st.wMonth - 1, st.wDay, st.wHour, st.wMinute, st.wSecond);
           if (!isControlled)
             setInternalDate(d);
           onChangeRef.current?.(d);
@@ -16699,14 +17335,6 @@ var DateTimePicker = (0, import_react5.forwardRef)(function DateTimePicker2({ va
 var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
 var import_react6 = __toESM(require_react(), 1);
 import * as gui7 from "gui";
-import * as ffi5 from "ffi";
-function textToUtf16(s) {
-  const buf = new ArrayBuffer((s.length + 1) * 2);
-  const dv = new DataView(buf);
-  for (let i = 0; i < s.length; i++)
-    dv.setUint16(i * 2, s.charCodeAt(i), true);
-  return buf;
-}
 var Input = (0, import_react6.forwardRef)(({ value: controlledValue, defaultValue = "", onChange, placeholder, password, multiline, readonly, number, disabled, style }, ref) => {
   const [internalValue, setInternalValue] = (0, import_react6.useState)(defaultValue);
   const isControlled = controlledValue !== void 0;
@@ -16725,8 +17353,8 @@ var Input = (0, import_react6.forwardRef)(({ value: controlledValue, defaultValu
     const h = inputRef.current;
     if (!h || !placeholder)
       return;
-    const buf = textToUtf16(placeholder);
-    gui7.SendMessage(h, 5377, 1, ffi5.bufferPtr(buf));
+    const buf = WCHAR.encode(placeholder);
+    gui7.SendMessage(h, 5377, 1, buf.ptr);
   }, [placeholder]);
   return (0, import_jsx_runtime5.jsx)("w", { type: "EDIT", text: displayValue, ws, style, disabled, ref: (h) => {
     inputRef.current = h;
@@ -16750,20 +17378,6 @@ var Input = (0, import_react6.forwardRef)(({ value: controlledValue, defaultValu
 // _build/lib/react-qw/components/Link.js
 var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1);
 var import_react7 = __toESM(require_react(), 1);
-import * as gui8 from "gui";
-import * as ffi6 from "ffi";
-function readUtf16(ptr, offset, maxWords) {
-  const chars = [];
-  for (let i = 0; i < maxWords; i++) {
-    const lo = ffi6.readByte(ptr + offset + i * 2);
-    const hi = ffi6.readByte(ptr + offset + i * 2 + 1);
-    const code = hi << 8 | lo;
-    if (code === 0)
-      break;
-    chars.push(String.fromCharCode(code));
-  }
-  return chars.join("");
-}
 var Link = (0, import_react7.forwardRef)(function Link2({ href, children, onClick, style }, ref) {
   const displayText = children != null ? String(children) : href ?? "";
   const linkText = href ? `<A HREF="${href}">${displayText}</A>` : displayText;
@@ -16774,14 +17388,13 @@ var Link = (0, import_react7.forwardRef)(function Link2({ href, children, onClic
     const h = linkRef.current;
     if (!h)
       return;
-    gui8.InvalidateRect(h, null, true);
+    InvalidateRect(h, NULL, 1);
   }, [linkText]);
   return (0, import_jsx_runtime6.jsx)("w", { type: "STATIC", ws: 268435456 | 33554432, style: { ...style, flexDirection: "column", alignItems: "stretch" }, ref, onEvent: (e) => {
     if (e.msg === 78) {
       const code = nmCode(e.lParam);
       if (code === -2 || code === -4) {
-        const url = readUtf16(e.lParam, NMHDR_SIZE + 112, 2048);
-        onClickRef.current?.(url);
+        onClickRef.current?.(NMLINK.decode(e.lParam).item.szUrl);
       }
     }
   }, children: (0, import_jsx_runtime6.jsx)("w", { type: "SysLink", ws: 268435456 | 65536, text: linkText, style: { flexGrow: 1 }, ref: (h) => {
@@ -16792,7 +17405,7 @@ var Link = (0, import_react7.forwardRef)(function Link2({ href, children, onClic
 // _build/lib/react-qw/components/ListBox.js
 var import_jsx_runtime7 = __toESM(require_jsx_runtime(), 1);
 var import_react8 = __toESM(require_react(), 1);
-import * as gui9 from "gui";
+import * as gui8 from "gui";
 var ListBox = (0, import_react8.forwardRef)(({ items, selectedIndex: controlledIndex, defaultSelectedIndex = -1, onChange, style, sort, scrollToBottom }, ref) => {
   const [internalIndex, setInternalIndex] = (0, import_react8.useState)(defaultSelectedIndex);
   const isControlled = controlledIndex !== void 0;
@@ -16804,18 +17417,18 @@ var ListBox = (0, import_react8.forwardRef)(({ items, selectedIndex: controlledI
     const h = lbRef.current;
     if (!h)
       return;
-    gui9.SendMessage(h, 388, 0, 0);
+    gui8.SendMessage(h, 388, 0, 0);
     for (const item of items)
-      gui9.SendMessage(h, 384, 0, item);
+      gui8.SendMessage(h, 384, 0, item);
     if (sel >= 0 && sel < items.length)
-      gui9.SendMessage(h, 390, sel, 0);
+      gui8.SendMessage(h, 390, sel, 0);
     if (scrollToBottom && items.length > 0)
-      gui9.SendMessage(h, 407, items.length - 1, 0);
+      gui8.SendMessage(h, 407, items.length - 1, 0);
   }, [items]);
   (0, import_react8.useEffect)(() => {
     const h = lbRef.current;
     if (h)
-      gui9.SendMessage(h, 390, sel, 0);
+      gui8.SendMessage(h, 390, sel, 0);
   }, [sel]);
   return (0, import_jsx_runtime7.jsx)("w", { type: "STATIC", ws: 268435456 | 33554432, style: { ...style, flexDirection: "column", alignItems: "stretch" }, onEvent: (e) => {
     if (e.msg !== 273)
@@ -16825,7 +17438,7 @@ var ListBox = (0, import_react8.forwardRef)(({ items, selectedIndex: controlledI
       const h = lbRef.current;
       if (!h)
         return;
-      const newSel = gui9.SendMessage(h, 392, 0, 0);
+      const newSel = gui8.SendMessage(h, 392, 0, 0);
       if (newSel !== sel && newSel >= 0) {
         if (!isControlled)
           setInternalIndex(newSel);
@@ -16840,150 +17453,30 @@ var ListBox = (0, import_react8.forwardRef)(({ items, selectedIndex: controlledI
 // _build/lib/react-qw/components/ListView.js
 var import_jsx_runtime8 = __toESM(require_jsx_runtime(), 1);
 var import_react9 = __toESM(require_react(), 1);
-import * as gui10 from "gui";
-import * as ffi7 from "ffi";
-import * as win2 from "win";
+import * as gui9 from "gui";
+import * as ffi3 from "ffi";
 function makeColorBlock(size, bgra) {
   const n = size * size;
   const buf = new ArrayBuffer(n * 4);
-  const b = new Uint8Array(buf);
+  const b6 = new Uint8Array(buf);
   for (let i = 0; i < n; i++) {
-    b[i * 4] = bgra & 255;
-    b[i * 4 + 1] = bgra >> 8 & 255;
-    b[i * 4 + 2] = bgra >> 16 & 255;
-    b[i * 4 + 3] = 255;
+    b6[i * 4] = bgra & 255;
+    b6[i * 4 + 1] = bgra >> 8 & 255;
+    b6[i * 4 + 2] = bgra >> 16 & 255;
+    b6[i * 4 + 3] = 255;
   }
   return buf;
 }
-function textToUtf162(s) {
-  const buf = new ArrayBuffer((s.length + 1) * 2);
-  const dv = new DataView(buf);
-  for (let i = 0; i < s.length; i++)
-    dv.setUint16(i * 2, s.charCodeAt(i), true);
-  return buf;
-}
-function readI32(ptr, offset) {
-  return ffi7.readByte(ptr + offset) | ffi7.readByte(ptr + offset + 1) << 8 | ffi7.readByte(ptr + offset + 2) << 16 | ffi7.readByte(ptr + offset + 3) << 24;
-}
-function readU32(ptr, offset) {
-  return ffi7.readByte(ptr + offset) | ffi7.readByte(ptr + offset + 1) << 8 | ffi7.readByte(ptr + offset + 2) << 16 | ffi7.readByte(ptr + offset + 3) << 24 >>> 0;
-}
-function readU64(ptr, offset) {
-  const lo = readU32(ptr, offset);
-  const hi = readU32(ptr, offset + 4);
-  return lo + hi * 4294967296;
-}
 function writeU32(ptr, offset, v) {
-  ffi7.writeByte(ptr + offset, v & 255);
-  ffi7.writeByte(ptr + offset + 1, v >> 8 & 255);
-  ffi7.writeByte(ptr + offset + 2, v >> 16 & 255);
-  ffi7.writeByte(ptr + offset + 3, v >> 24 & 255);
-}
-function bufPtr2(buf) {
-  return ffi7.bufferPtr(buf);
+  ffi3.writeByte(ptr + offset, v & 255);
+  ffi3.writeByte(ptr + offset + 1, v >> 8 & 255);
+  ffi3.writeByte(ptr + offset + 2, v >> 16 & 255);
+  ffi3.writeByte(ptr + offset + 3, v >> 24 & 255);
 }
 var LV_WS = 268435456 | 8388608 | 2097152 | 1048576 | 1 | 4;
-var NMCUSTOMDRAW = struct({
-  hdr: NMHDR,
-  dwDrawStage: "u32",
-  hdc: "ptr",
-  rc: "i32[4]",
-  dwItemSpec: "ptr",
-  uItemState: "u32",
-  lItemlParam: "ptr"
-});
-var NMLVCUSTOMDRAW = struct({
-  hdr: NMHDR,
-  dwDrawStage: "u32",
-  hdc: "ptr",
-  rc: "i32[4]",
-  dwItemSpec: "ptr",
-  uItemState: "u32",
-  lItemlParam: "ptr",
-  clrText: "u32",
-  clrTextBk: "u32",
-  iSubItem: "i32",
-  dwItemType: "u32"
-});
-var NMLISTVIEW = struct({
-  hdr: NMHDR,
-  iItem: "i32",
-  iSubItem: "i32",
-  uNewState: "u32",
-  uOldState: "u32",
-  uChanged: "u32",
-  ptAction: "i32[2]",
-  lParam: "ptr"
-});
-var CD_STAGE = NMCUSTOMDRAW.offsetOf("dwDrawStage");
-var CD_HDC = NMCUSTOMDRAW.offsetOf("hdc");
-var CD_ITEM = NMCUSTOMDRAW.offsetOf("dwItemSpec");
 var CD_CLRTEXT = NMLVCUSTOMDRAW.offsetOf("clrText");
 var CD_CLRTEXTBK = NMLVCUSTOMDRAW.offsetOf("clrTextBk");
-var CD_SUBITEM = NMLVCUSTOMDRAW.offsetOf("iSubItem");
-var NMIA_ITEM = NMLISTVIEW.offsetOf("iItem");
-var NMIA_SUBITEM = NMLISTVIEW.offsetOf("iSubItem");
-var NMLV_UNEW = NMLISTVIEW.offsetOf("uNewState");
-var NMLV_UOLD = NMLISTVIEW.offsetOf("uOldState");
-var LVITEMW = struct({
-  mask: "u32",
-  iItem: "i32",
-  iSubItem: "i32",
-  state: "u32",
-  stateMask: "u32",
-  pszText: "ptr",
-  cchTextMax: "i32",
-  iImage: "i32",
-  lParam: "ptr",
-  iIndent: "i32",
-  iGroupId: "i32",
-  cColumns: "u32",
-  puColumns: "ptr",
-  piColFmt: "ptr",
-  iGroup: "i32"
-});
-var LVCOLUMNW = struct({
-  mask: "u32",
-  fmt: "i32",
-  cx: "i32",
-  pszText: "ptr",
-  cchTextMax: "i32",
-  iSubItem: "i32",
-  iImage: "i32",
-  iOrder: "i32",
-  cxMin: "i32",
-  cxDefault: "i32",
-  cxIdeal: "i32"
-});
 var fontCache = /* @__PURE__ */ new Map();
-var gdi322 = null;
-var createFontIndirectW = null;
-var selectObjectFn = null;
-var getObjectW = null;
-function ensureGdi() {
-  if (gdi322 !== null)
-    return;
-  gdi322 = win2.LoadLibrary("gdi32.dll");
-  if (!gdi322)
-    return;
-  createFontIndirectW = win2.GetProcAddress(gdi322, "CreateFontIndirectW");
-  selectObjectFn = win2.GetProcAddress(gdi322, "SelectObject");
-  getObjectW = win2.GetProcAddress(gdi322, "GetObjectW");
-}
-var user322 = null;
-var loadCursorW = null;
-var setCursorFn = null;
-var screenToClient = null;
-function ensureUser32() {
-  if (user322 !== null)
-    return;
-  user322 = win2.LoadLibrary("user32.dll");
-  if (!user322)
-    return;
-  loadCursorW = win2.GetProcAddress(user322, "LoadCursorW");
-  setCursorFn = win2.GetProcAddress(user322, "SetCursor");
-  screenToClient = win2.GetProcAddress(user322, "ScreenToClient");
-}
 function getCellFont(hwnd, style) {
   const key = (style.bold ? "b" : "") + (style.italic ? "i" : "") + (style.underline ? "u" : "");
   if (key === "")
@@ -16991,39 +17484,37 @@ function getCellFont(hwnd, style) {
   const cached = fontCache.get(key);
   if (cached !== void 0)
     return cached === 0 ? null : cached;
-  ensureGdi();
-  if (!createFontIndirectW || !getObjectW || !hwnd)
+  if (!hwnd)
     return null;
-  const lf = new ArrayBuffer(92);
-  const dv = new DataView(lf);
-  const cur = gui10.SendMessage(hwnd, 49, 0, 0);
+  let base = { lfHeight: -13 };
+  const cur = gui9.SendMessage(hwnd, 49, 0, 0);
   if (cur) {
-    const got = ffi7.ffiCall(getObjectW, [ffi7.FFI_TYPE_POINTER, ffi7.FFI_TYPE_SINT32, ffi7.FFI_TYPE_POINTER], [cur, 92, lf], ffi7.FFI_TYPE_SINT32);
-    if (!got)
+    const lf = LOGFONTW.alloc();
+    if (!GetObject(cur, LOGFONTW.size, lf))
       return null;
-  } else {
-    dv.setInt32(0, -13, true);
+    base = LOGFONTW.decode(lf);
   }
-  if (style.bold)
-    dv.setInt32(16, 700, true);
-  if (style.italic)
-    dv.setUint8(20, 1);
-  if (style.underline)
-    dv.setUint8(21, 1);
-  const h = ffi7.ffiCall(createFontIndirectW, [ffi7.FFI_TYPE_POINTER], [lf], ffi7.FFI_TYPE_POINTER);
+  const h = CreateFontIndirect({
+    ...base,
+    ...style.bold ? {
+      lfWeight: 700
+      /* gui.FontWeight.BOLD */
+    } : {},
+    ...style.italic ? { lfItalic: 1 } : {},
+    ...style.underline ? { lfUnderline: 1 } : {}
+  });
   fontCache.set(key, h ? h : 0);
   return h ? h : null;
 }
 function handleCustomDraw(lParam, columns2, data2, hwnd) {
-  const stage = readU32(lParam, CD_STAGE);
+  const { dwDrawStage: stage } = NMCUSTOMDRAW.decode(lParam);
   if (stage === 1)
     return 32;
   if (stage === 65537)
     return 32;
   if (stage === 196609) {
-    const colIndex = readI32(lParam, CD_SUBITEM);
-    const row = readI32(lParam, CD_ITEM);
-    const style = resolveCellStyle(columns2, data2, row, colIndex);
+    const cd = NMLVCUSTOMDRAW.decode(lParam);
+    const style = resolveCellStyle(columns2, data2, cd.dwItemSpec, cd.iSubItem);
     if (!style)
       return 0;
     if (style.color !== void 0)
@@ -17031,12 +17522,9 @@ function handleCustomDraw(lParam, columns2, data2, hwnd) {
     if (style.background !== void 0)
       writeU32(lParam, CD_CLRTEXTBK, style.background);
     const hfont = getCellFont(hwnd, style);
-    if (hfont && selectObjectFn) {
-      const hdc = PTR_SIZE === 8 ? readU64(lParam, CD_HDC) : readU32(lParam, CD_HDC);
-      if (hdc) {
-        ffi7.ffiCall(selectObjectFn, [ffi7.FFI_TYPE_POINTER, ffi7.FFI_TYPE_POINTER], [hdc, hfont], ffi7.FFI_TYPE_POINTER);
-        return 2;
-      }
+    if (hfont && cd.hdc) {
+      SelectObject(cd.hdc, hfont);
+      return 2;
     }
   }
   return 0;
@@ -17067,14 +17555,14 @@ function resolveCellStyle(columns2, data2, row, colIndex) {
   return style || void 0;
 }
 function makeLVItem(i, sub, text, image) {
-  const textBuf = textToUtf162(text);
-  const b = LVITEMW.write({
+  const textBuf = WCHAR.encode(text);
+  const b6 = LVITEMW.encode({
     mask: 1 | (image !== void 0 ? 2 : 0),
     iItem: i,
     iSubItem: sub,
     state: 0,
     stateMask: 0,
-    pszText: bufPtr2(textBuf),
+    pszText: textBuf.ptr,
     cchTextMax: 0,
     iImage: image ?? 0,
     lParam: 0,
@@ -17085,8 +17573,8 @@ function makeLVItem(i, sub, text, image) {
     piColFmt: 0,
     iGroup: 0
   });
-  b.__textBuf = textBuf;
-  return b;
+  b6.__textBuf = textBuf;
+  return b6;
 }
 var ListView = (0, import_react9.forwardRef)(function ListViewInner({ columns: columns2, data: data2, style, icons: icons2, iconSize, getIcon }, ref) {
   const lvRef = (0, import_react9.useRef)(null);
@@ -17098,36 +17586,36 @@ var ListView = (0, import_react9.forwardRef)(function ListViewInner({ columns: c
     const il = iconListRef.current;
     iconListRef.current = 0;
     if (il) {
-      gui10.SendMessage(h, 4099, 1, 0);
-      gui10.ImageListDestroy(il);
+      gui9.SendMessage(h, 4099, 1, 0);
+      gui9.ImageListDestroy(il);
     }
     if (!icons2 || icons2.length === 0)
       return;
     const size = iconSize ?? 32;
-    const img = gui10.ImageListCreate(size, size, 32, icons2.length, 1);
+    const img = gui9.ImageListCreate(size, size, 32, icons2.length, 1);
     if (!img)
       return;
     for (const p of icons2) {
-      const hbm = gui10.CreateBitmapFromPixels(size, size, p);
+      const hbm = gui9.CreateBitmapFromPixels(size, size, p);
       if (hbm) {
-        gui10.ImageListAdd(img, hbm);
-        gui10.DeleteObject(hbm);
+        gui9.ImageListAdd(img, hbm);
+        DeleteObject(hbm);
       }
     }
-    gui10.SendMessage(h, 4099, 1, img);
+    gui9.SendMessage(h, 4099, 1, img);
     iconListRef.current = img;
   }, [icons2, iconSize]);
   (0, import_react9.useEffect)(() => {
     const h = lvRef.current;
     if (!h)
       return;
-    const hdr = gui10.SendMessage(h, 4127, 0, 0);
+    const hdr = gui9.SendMessage(h, 4127, 0, 0);
     if (hdr) {
-      let n2 = gui10.SendMessage(hdr, 4608, 0, 0);
+      let n2 = gui9.SendMessage(hdr, 4608, 0, 0);
       for (let k = n2 - 1; k >= 0; k--)
-        gui10.SendMessage(h, 4124, k, 0);
+        gui9.SendMessage(h, 4124, k, 0);
     }
-    gui10.SendMessage(
+    gui9.SendMessage(
       h,
       4150,
       0,
@@ -17136,12 +17624,12 @@ var ListView = (0, import_react9.forwardRef)(function ListViewInner({ columns: c
     );
     const n = columns2.length;
     for (let j = 0; j < n; j++) {
-      const titleBuf = textToUtf162(columns2[j].name);
-      const lvc = LVCOLUMNW.write({
+      const titleBuf = WCHAR.encode(columns2[j].name);
+      const lvc = LVCOLUMNW.encode({
         mask: 4 | 2 | 1,
         fmt: alignToFmt(columns2[j].align),
         cx: columns2[j].width ?? 100,
-        pszText: bufPtr2(titleBuf),
+        pszText: titleBuf.ptr,
         cchTextMax: 0,
         iSubItem: j,
         iImage: 0,
@@ -17151,28 +17639,28 @@ var ListView = (0, import_react9.forwardRef)(function ListViewInner({ columns: c
         cxIdeal: 0
       });
       lvc.__titleBuf = titleBuf;
-      gui10.SendMessage(h, 4193, j, bufPtr2(lvc));
+      gui9.SendMessage(h, 4193, j, lvc.ptr);
     }
   }, [columns2]);
   (0, import_react9.useEffect)(() => {
     const h = lvRef.current;
     if (!h)
       return;
-    gui10.SendMessage(h, 4105, 0, 0);
+    gui9.SendMessage(h, 4105, 0, 0);
     const nCols = columns2.length;
     for (let i = 0; i < data2.length; i++) {
       const record = data2[i];
       const img = getIcon ? getIcon(record, i) : void 0;
       const itemBuf = makeLVItem(i, 0, cellText(record, columns2[0], i), img);
-      gui10.SendMessage(h, 4173, 0, bufPtr2(itemBuf));
+      gui9.SendMessage(h, 4173, 0, itemBuf.ptr);
       for (let j = 1; j < nCols; j++) {
         const subBuf = makeLVItem(i, j, cellText(record, columns2[j], i));
-        gui10.SendMessage(h, 4172, 0, bufPtr2(subBuf));
+        gui9.SendMessage(h, 4172, 0, subBuf.ptr);
       }
     }
     for (let j = 0; j < columns2.length; j++) {
       if (columns2[j].width == null) {
-        gui10.SendMessage(
+        gui9.SendMessage(
           h,
           4126,
           j,
@@ -17189,14 +17677,12 @@ var ListView = (0, import_react9.forwardRef)(function ListViewInner({ columns: c
         return handleCustomDraw(e.lParam, columns2, data2, lvRef.current);
       }
       if (code === -100) {
-        const uNewState = readU32(e.lParam, NMLV_UNEW);
-        const uOldState = readU32(e.lParam, NMLV_UOLD);
+        const { uNewState, uOldState } = NMLISTVIEW.decode(e.lParam);
         if ((uNewState & 2) !== (uOldState & 2))
           return 1;
       }
       if (code === -2) {
-        const iItem = readI32(e.lParam, NMIA_ITEM);
-        const iSubItem = readI32(e.lParam, NMIA_SUBITEM);
+        const { iItem, iSubItem } = NMLISTVIEW.decode(e.lParam);
         const col = columns2[iSubItem];
         const record = data2[iItem];
         if (col?.onCellClick && record !== void 0)
@@ -17214,33 +17700,20 @@ var ListView = (0, import_react9.forwardRef)(function ListViewInner({ columns: c
     const h = lvRef.current;
     if (!h)
       return;
-    ensureUser32();
-    if (!loadCursorW || !setCursorFn || !screenToClient)
-      return;
-    const sp = gui10.GetCursorPos();
-    if (!sp)
+    const pt = POINT.alloc();
+    if (!GetCursorPos(pt.ptr))
       return;
-    const sbuf = new ArrayBuffer(8);
-    const sdv = new DataView(sbuf);
-    sdv.setInt32(0, sp[0], true);
-    sdv.setInt32(4, sp[1], true);
-    ffi7.ffiCall(screenToClient, [ffi7.FFI_TYPE_POINTER, ffi7.FFI_TYPE_POINTER], [h, sbuf], ffi7.FFI_TYPE_SINT32);
-    const lvhi = new ArrayBuffer(24);
-    const lvd = new DataView(lvhi);
-    lvd.setInt32(0, sdv.getInt32(0, true), true);
-    lvd.setInt32(4, sdv.getInt32(4, true), true);
-    lvd.setInt32(12, -1, true);
-    lvd.setInt32(16, -1, true);
-    const lvhiPtr = bufPtr2(lvhi);
-    gui10.SendMessage(h, 4153, 0, lvhiPtr);
-    const iItem = readI32(lvhiPtr, 12);
-    const iSubItem = readI32(lvhiPtr, 16);
+    ScreenToClient(h, pt.ptr);
+    const { x: sx, y: sy } = POINT.decode(pt);
+    const hit = LVHITTESTINFO.encode({ pt: [sx, sy], iItem: -1, iSubItem: -1 });
+    gui9.SendMessage(h, 4153, 0, hit.ptr);
+    const { iItem, iSubItem } = LVHITTESTINFO.decode(hit);
     const style2 = resolveCellStyle(columns2, data2, iItem, iSubItem);
     if (!style2 || style2.cursor === void 0)
       return;
-    const hc = ffi7.ffiCall(loadCursorW, [ffi7.FFI_TYPE_POINTER, ffi7.FFI_TYPE_POINTER], [0, style2.cursor], ffi7.FFI_TYPE_POINTER);
+    const hc = LoadCursor(NULL, style2.cursor);
     if (hc) {
-      ffi7.ffiCall(setCursorFn, [ffi7.FFI_TYPE_POINTER], [hc], ffi7.FFI_TYPE_POINTER);
+      SetCursor(hc);
       return 1;
     }
     return;
@@ -17250,7 +17723,7 @@ var ListView = (0, import_react9.forwardRef)(function ListViewInner({ columns: c
 // _build/lib/react-qw/components/ProgressBar.js
 var import_jsx_runtime9 = __toESM(require_jsx_runtime(), 1);
 var import_react10 = __toESM(require_react(), 1);
-import * as gui11 from "gui";
+import * as gui10 from "gui";
 var ProgressBar = (0, import_react10.forwardRef)(({ value = 0, max = 100, style, smooth }, ref) => {
   const pbRef = (0, import_react10.useRef)(null);
   const ws = 268435456 | 8388608 | (smooth ? 1 : 0);
@@ -17258,8 +17731,8 @@ var ProgressBar = (0, import_react10.forwardRef)(({ value = 0, max = 100, style,
     const h = pbRef.current;
     if (!h)
       return;
-    gui11.SendMessage(h, 1030, 0, max);
-    gui11.SendMessage(h, 1026, Math.min(value, max), 0);
+    gui10.SendMessage(h, 1030, 0, max);
+    gui10.SendMessage(h, 1026, Math.min(value, max), 0);
   }, [value, max]);
   return (0, import_jsx_runtime9.jsx)("w", { type: "msctls_progress32", ws, style, ref: (h) => {
     pbRef.current = h;
@@ -17273,7 +17746,7 @@ var ProgressBar = (0, import_react10.forwardRef)(({ value = 0, max = 100, style,
 // _build/lib/react-qw/components/RadioButton.js
 var import_jsx_runtime10 = __toESM(require_jsx_runtime(), 1);
 var import_react11 = __toESM(require_react(), 1);
-import * as gui12 from "gui";
+import * as gui11 from "gui";
 var RadioButton = (0, import_react11.forwardRef)(({ checked: controlledChecked, defaultChecked = false, onChange, label, style, disabled }, ref) => {
   const [internalChecked, setInternalChecked] = (0, import_react11.useState)(defaultChecked);
   const isControlled = controlledChecked !== void 0;
@@ -17283,7 +17756,7 @@ var RadioButton = (0, import_react11.forwardRef)(({ checked: controlledChecked,
     const h = rbRef.current;
     if (!h)
       return;
-    gui12.SendMessage(h, 241, displayChecked ? 1 : 0, 0);
+    gui11.SendMessage(h, 241, displayChecked ? 1 : 0, 0);
   }, [displayChecked]);
   return (0, import_jsx_runtime10.jsx)("w", { type: "BUTTON", text: label ?? "", ws: 268435456 | 9, style, disabled, ref: (h) => {
     rbRef.current = h;
@@ -17293,7 +17766,7 @@ var RadioButton = (0, import_react11.forwardRef)(({ checked: controlledChecked,
       ref.current = h;
   }, onEvent: (e) => {
     if (e.msg === 514) {
-      const newChecked = gui12.SendMessage(e.hwnd, 240, 0, 0) !== 0;
+      const newChecked = gui11.SendMessage(e.hwnd, 240, 0, 0) !== 0;
       if (newChecked !== displayChecked) {
         if (!isControlled)
           setInternalChecked(newChecked);
@@ -17306,24 +17779,27 @@ var RadioButton = (0, import_react11.forwardRef)(({ checked: controlledChecked,
 // _build/lib/react-qw/components/ScrollView.js
 var import_jsx_runtime11 = __toESM(require_jsx_runtime(), 1);
 var import_react12 = __toESM(require_react(), 1);
-import * as gui13 from "gui";
+import * as gui12 from "gui";
 var ScrollView = (0, import_react12.forwardRef)(({ children, style, contentWidth, contentHeight }, ref) => {
   const svRef = (0, import_react12.useRef)(null);
   const contentRef = (0, import_react12.useRef)(null);
   const scrollXRef = (0, import_react12.useRef)(0);
   const scrollYRef = (0, import_react12.useRef)(0);
   function updateScroll(sv, content) {
-    const svRect = gui13.GetClientRect(sv);
+    const svRect = gui12.GetClientRect(sv);
     if (!svRect)
       return;
     const svW = svRect.right - svRect.left;
     const svH = svRect.bottom - svRect.top;
-    const scale = gui13.GetScaleFactor();
+    const hdc = GetDC(NULL);
+    const scale = hdc ? GetDeviceCaps(hdc, 88) / 96 : 1;
+    if (hdc)
+      ReleaseDC(NULL, hdc);
     const natW = Math.round((contentWidth ?? svW / scale) * scale);
     const natH = Math.round((contentHeight ?? svH / scale) * scale);
     scrollXRef.current = Math.max(0, Math.min(scrollXRef.current, natW - svW));
     scrollYRef.current = Math.max(0, Math.min(scrollYRef.current, natH - svH));
-    gui13.SetWindowPos(
+    SetWindowPos(
       content,
       0,
       -scrollXRef.current,
@@ -17335,18 +17811,18 @@ var ScrollView = (0, import_react12.forwardRef)(({ children, style, contentWidth
     );
     forceFlexLayout(content);
     if (natW > svW) {
-      gui13.SetScrollInfo(sv, 0, { min: 0, max: natW - 1, page: svW, pos: scrollXRef.current }, true);
-      gui13.ShowScrollBar(sv, 0, true);
+      gui12.SetScrollInfo(sv, 0, { min: 0, max: natW - 1, page: svW, pos: scrollXRef.current }, true);
+      ShowScrollBar(sv, 0, 1);
     } else {
       scrollXRef.current = 0;
-      gui13.ShowScrollBar(sv, 0, false);
+      ShowScrollBar(sv, 0, 0);
     }
     if (natH > svH) {
-      gui13.SetScrollInfo(sv, 1, { min: 0, max: natH - 1, page: svH, pos: scrollYRef.current }, true);
-      gui13.ShowScrollBar(sv, 1, true);
+      gui12.SetScrollInfo(sv, 1, { min: 0, max: natH - 1, page: svH, pos: scrollYRef.current }, true);
+      ShowScrollBar(sv, 1, 1);
     } else {
       scrollYRef.current = 0;
-      gui13.ShowScrollBar(sv, 1, false);
+      ShowScrollBar(sv, 1, 0);
     }
   }
   (0, import_react12.useLayoutEffect)(() => {
@@ -17362,7 +17838,7 @@ var ScrollView = (0, import_react12.forwardRef)(({ children, style, contentWidth
     } else {
       scrollXRef.current = newPos;
     }
-    gui13.SetWindowPos(
+    SetWindowPos(
       content,
       0,
       -scrollXRef.current,
@@ -17372,14 +17848,14 @@ var ScrollView = (0, import_react12.forwardRef)(({ children, style, contentWidth
       1 | 4
       /* gui.SetWindowPosFlag.SWP_NOZORDER */
     );
-    gui13.SetScrollInfo(sv, bar, { pos: newPos }, true);
+    gui12.SetScrollInfo(sv, bar, { pos: newPos }, true);
   }
   function handleScroll(e, bar) {
     const sv = svRef.current;
     const content = contentRef.current;
     if (!sv || !content)
       return;
-    const info = gui13.GetScrollInfo(sv, bar);
+    const info = gui12.GetScrollInfo(sv, bar);
     const maxPos = info.max - info.page + 1;
     const code = e.wParam & 65535;
     const ref_ = bar === 1 ? scrollYRef : scrollXRef;
@@ -17413,7 +17889,7 @@ var ScrollView = (0, import_react12.forwardRef)(({ children, style, contentWidth
     if (!isHorz && contentHeight === void 0)
       return;
     const bar = isHorz ? 0 : 1;
-    const info = gui13.GetScrollInfo(sv, bar);
+    const info = gui12.GetScrollInfo(sv, bar);
     const maxPos = info.max - info.page + 1;
     const ref_ = isHorz ? scrollXRef : scrollYRef;
     let newPos = ref_.current + dy;
@@ -17430,7 +17906,7 @@ var ScrollView = (0, import_react12.forwardRef)(({ children, style, contentWidth
   }, onEvent: {
     fn: (e) => {
       if (e.msg === 132 || e.msg === 161) {
-        return gui13.DefWindowProc(e.hwnd, e.msg, e.wParam, e.lParam);
+        return DefWindowProc(e.hwnd, e.msg, e.wParam, e.lParam);
       }
       if (e.msg === 277) {
         handleScroll(
@@ -17462,7 +17938,7 @@ var ScrollView = (0, import_react12.forwardRef)(({ children, style, contentWidth
 // _build/lib/react-qw/components/Slider.js
 var import_jsx_runtime12 = __toESM(require_jsx_runtime(), 1);
 var import_react13 = __toESM(require_react(), 1);
-import * as gui14 from "gui";
+import * as gui13 from "gui";
 var Slider = (0, import_react13.forwardRef)(({ value, onChange, min = 0, max = 100, vertical = false, disabled, style }, ref) => {
   const wrapperRef = (0, import_react13.useRef)(null);
   const sliderRef = (0, import_react13.useRef)(null);
@@ -17471,14 +17947,14 @@ var Slider = (0, import_react13.forwardRef)(({ value, onChange, min = 0, max = 1
     if (!h)
       return;
     const lParam = min & 65535 | (max & 65535) << 16;
-    gui14.SendMessage(h, 1030, 0, lParam);
-    gui14.SendMessage(h, 1029, 1, value);
+    gui13.SendMessage(h, 1030, 0, lParam);
+    gui13.SendMessage(h, 1029, 1, value);
   }, [min, max]);
   (0, import_react13.useEffect)(() => {
     const h = sliderRef.current;
     if (!h)
       return;
-    gui14.SendMessage(h, 1029, 1, value);
+    gui13.SendMessage(h, 1029, 1, value);
   }, [value]);
   const tbStyle = 268435456 | 65536 | 1 | (vertical ? 2 : 0);
   return (0, import_jsx_runtime12.jsx)("w", { type: "STATIC", ws: 268435456 | 33554432, style, ref: (h) => {
@@ -17489,13 +17965,13 @@ var Slider = (0, import_react13.forwardRef)(({ value, onChange, min = 0, max = 1
       ref.current = h;
   }, onEvent: (e) => {
     if (e.msg === 132 || e.msg === 161) {
-      return gui14.DefWindowProc(e.hwnd, e.msg, e.wParam, e.lParam);
+      return DefWindowProc(e.hwnd, e.msg, e.wParam, e.lParam);
     }
     if (e.msg === 276 || e.msg === 277) {
       const h = sliderRef.current;
       if (!h)
         return 0;
-      const pos = gui14.SendMessage(h, 1024, 0, 0);
+      const pos = gui13.SendMessage(h, 1024, 0, 0);
       onChange?.(pos);
       return 0;
     }
@@ -17508,24 +17984,7 @@ var Slider = (0, import_react13.forwardRef)(({ value, onChange, min = 0, max = 1
 // _build/lib/react-qw/components/Tab.js
 var import_jsx_runtime13 = __toESM(require_jsx_runtime(), 1);
 var import_react14 = __toESM(require_react(), 1);
-import * as gui15 from "gui";
-import * as ffi8 from "ffi";
-var TCITEMW = struct({
-  mask: "u32",
-  dwState: "u32",
-  dwStateMask: "u32",
-  pszText: "ptr",
-  cchTextMax: "i32",
-  iImage: "i32",
-  lParam: "ptr"
-});
-function textToUtf163(s) {
-  const buf = new ArrayBuffer((s.length + 1) * 2);
-  const dv = new DataView(buf);
-  for (let i = 0; i < s.length; i++)
-    dv.setUint16(i * 2, s.charCodeAt(i), true);
-  return buf;
-}
+import * as gui14 from "gui";
 var Tab = (0, import_react14.forwardRef)(({ tabs, selectedIndex: controlledIndex, defaultSelectedIndex = 0, onChange, style }, ref) => {
   const [internalIndex, setInternalIndex] = (0, import_react14.useState)(defaultSelectedIndex);
   const isControlled = controlledIndex !== void 0;
@@ -17535,27 +17994,27 @@ var Tab = (0, import_react14.forwardRef)(({ tabs, selectedIndex: controlledIndex
     const h = tabHwnd.current;
     if (!h)
       return;
-    gui15.SendMessage(h, 4873, 0, 0);
+    gui14.SendMessage(h, 4873, 0, 0);
     for (let i = 0; i < tabs.length; i++) {
-      const titleBuf = textToUtf163(tabs[i].title);
-      const tci = TCITEMW.write({
+      const titleBuf = WCHAR.encode(tabs[i].title);
+      const tci = TCITEMW.encode({
         mask: 1,
         dwState: 0,
         dwStateMask: 0,
-        pszText: ffi8.bufferPtr(titleBuf),
+        pszText: titleBuf.ptr,
         cchTextMax: tabs[i].title.length + 1,
         iImage: 0,
         lParam: 0
       });
-      const tciPtr = ffi8.bufferPtr(tci);
-      gui15.SendMessage(h, 4926, i, tciPtr);
+      const tciPtr = tci.ptr;
+      gui14.SendMessage(h, 4926, i, tciPtr);
     }
-    gui15.SendMessage(h, 4876, sel, 0);
+    gui14.SendMessage(h, 4876, sel, 0);
   }, [tabs]);
   (0, import_react14.useEffect)(() => {
     const h = tabHwnd.current;
     if (h)
-      gui15.SendMessage(h, 4876, sel, 0);
+      gui14.SendMessage(h, 4876, sel, 0);
   }, [sel]);
   return (0, import_jsx_runtime13.jsxs)("w", { type: "STATIC", ws: 268435456 | 33554432, style: { ...style, flexDirection: "column", alignItems: "stretch" }, ref, onEvent: (e) => {
     if (e.msg === 78) {
@@ -17564,7 +18023,7 @@ var Tab = (0, import_react14.forwardRef)(({ tabs, selectedIndex: controlledIndex
         return;
       const code = nmCode(e.lParam);
       if (code === -552 || code === -2) {
-        const newSel = gui15.SendMessage(h, 4875, 0, 0);
+        const newSel = gui14.SendMessage(h, 4875, 0, 0);
         if (newSel !== sel) {
           if (!isControlled)
             setInternalIndex(newSel);
@@ -17577,54 +18036,17 @@ var Tab = (0, import_react14.forwardRef)(({ tabs, selectedIndex: controlledIndex
 
 // _build/lib/react-qw/components/Tooltip.js
 var import_react15 = __toESM(require_react(), 1);
-import * as gui16 from "gui";
-import * as ffi9 from "ffi";
-var TTTOOLINFOW = struct({
-  cbSize: "u32",
-  uFlags: "u32",
-  hwnd: "ptr",
-  uId: "ptr",
-  rect: "i32[4]",
-  hinst: "ptr",
-  lpszText: "ptr",
-  lParam: "ptr",
-  lpReserved: "ptr"
-  // WinXP+ 追加字段（系统 sizeof 含之）
-});
+import * as gui15 from "gui";
 
 // _build/lib/react-qw/components/TreeView.js
 var import_jsx_runtime14 = __toESM(require_jsx_runtime(), 1);
 var import_react16 = __toESM(require_react(), 1);
-import * as gui17 from "gui";
-import * as ffi10 from "ffi";
-var TVITEM = struct({
-  mask: "u32",
-  hItem: "ptr",
-  state: "u32",
-  stateMask: "u32",
-  pszText: "ptr",
-  cchTextMax: "i32",
-  iImage: "i32",
-  iSelectedImage: "i32",
-  cChildren: "i32",
-  lParam: "ptr"
-});
-var TVINSERTSTRUCT = struct({ hParent: "ptr", hInsertAfter: "ptr", item: TVITEM });
-function textToUtf164(s) {
-  const buf = new ArrayBuffer((s.length + 1) * 2);
-  const dv = new DataView(buf);
-  for (let i = 0; i < s.length; i++)
-    dv.setUint16(i * 2, s.charCodeAt(i), true);
-  return buf;
-}
-function bufPtr3(buf) {
-  return ffi10.bufferPtr(buf);
-}
+import * as gui16 from "gui";
 function buildTvItem(textPtr, cChildren) {
   let mask = 1;
   if (cChildren > 0)
     mask |= 64;
-  return TVITEM.write({
+  return TVITEM.encode({
     mask,
     hItem: 0,
     state: 0,
@@ -17640,24 +18062,24 @@ function buildTvItem(textPtr, cChildren) {
 function insertItems(hTree, nodes, parentHandle, hItemMap, keyMap) {
   for (const node of nodes) {
     const cChildren = node.children && node.children.length > 0 ? 1 : 0;
-    const textBuf = textToUtf164(node.label);
-    const itemBuf = buildTvItem(bufPtr3(textBuf), cChildren);
-    const item = TVITEM.read(itemBuf);
-    const tvins = TVINSERTSTRUCT.write({ hParent: parentHandle, hInsertAfter: -65536, item });
-    const hItem = gui17.SendMessage(hTree, 4402, 0, bufPtr3(tvins));
+    const textBuf = WCHAR.encode(node.label);
+    const itemBuf = buildTvItem(textBuf.ptr, cChildren);
+    const item = TVITEM.decode(itemBuf);
+    const tvins = TVINSERTSTRUCT.encode({ hParent: parentHandle, hInsertAfter: -65536, item });
+    const hItem = gui16.SendMessage(hTree, 4402, 0, tvins.ptr);
     hItemMap.set(hItem, node);
     if (node.key)
       keyMap.set(node.key, hItem);
     if (node.children && node.children.length > 0) {
       insertItems(hTree, node.children, hItem, hItemMap, keyMap);
-      gui17.SendMessage(hTree, 4354, 2, hItem);
+      gui16.SendMessage(hTree, 4354, 2, hItem);
     }
   }
 }
 function deleteAllItems(hTree) {
-  const n = gui17.SendMessage(hTree, 4357, 0, 0);
+  const n = gui16.SendMessage(hTree, 4357, 0, 0);
   if (n > 0)
-    gui17.SendMessage(
+    gui16.SendMessage(
       hTree,
       4353,
       1,
@@ -17689,7 +18111,7 @@ var TreeView = (0, import_react16.forwardRef)(function TreeViewInner({ data: dat
     const h = tvRef.current;
     if (!h)
       return;
-    gui17.SendMessage(
+    gui16.SendMessage(
       h,
       4396,
       0,
@@ -17705,7 +18127,7 @@ var TreeView = (0, import_react16.forwardRef)(function TreeViewInner({ data: dat
       return;
     const hItem = keyMapRef.current.get(selKey);
     if (hItem !== void 0)
-      gui17.SendMessage(h, 4363, 9, hItem);
+      gui16.SendMessage(h, 4363, 9, hItem);
   }, [selKey]);
   return (0, import_jsx_runtime14.jsx)("w", { type: "STATIC", ws: 268435456 | 33554432, style: { ...style, flexDirection: "column", alignItems: "stretch" }, ref, onEvent: (e) => {
     if (e.msg === 78) {
@@ -17714,7 +18136,7 @@ var TreeView = (0, import_react16.forwardRef)(function TreeViewInner({ data: dat
         const h = tvRef.current;
         if (!h)
           return;
-        const hCaret = gui17.SendMessage(h, 4362, 9, 0);
+        const hCaret = gui16.SendMessage(h, 4362, 9, 0);
         const node = hItemMapRef.current.get(hCaret) ?? null;
         const key = node?.key ?? null;
         if (!isControlled)
@@ -17730,153 +18152,63 @@ var TreeView = (0, import_react16.forwardRef)(function TreeViewInner({ data: dat
 // _build/lib/react-qw/components/PathPicker.js
 var import_jsx_runtime15 = __toESM(require_jsx_runtime(), 1);
 var import_react17 = __toESM(require_react(), 1);
-import * as ffi11 from "ffi";
-import * as win3 from "win";
 
-// _build/lib/win-common-structs.js
-var OPENFILENAMEW = struct({
-  lStructSize: "u32",
-  hwndOwner: "ptr",
-  hInstance: "ptr",
-  lpstrFilter: "ptr",
-  lpstrCustomFilter: "ptr",
-  nMaxCustFilter: "u32",
-  nFilterIndex: "u32",
-  lpstrFile: "ptr",
-  nMaxFile: "u32",
-  lpstrFileTitle: "ptr",
-  nMaxFileTitle: "u32",
-  lpstrInitialDir: "ptr",
-  lpstrTitle: "ptr",
-  Flags: "u32",
-  nFileOffset: "u16",
-  nFileExtension: "u16",
-  lpstrDefExt: "ptr",
-  lCustData: "ptr",
-  lpfnHook: "ptr",
-  lpTemplateName: "ptr",
-  pvReserved: "ptr",
-  dwReserved: "u32",
-  FlagsEx: "u32"
-});
-var BROWSEINFOW = struct({
-  hwndOwner: "ptr",
-  pidlRoot: "ptr",
-  pszDisplayName: "ptr",
-  lpszTitle: "ptr",
-  ulFlags: "u32",
-  lpfn: "ptr",
-  lParam: "ptr",
-  iImage: "i32"
-});
+// _build/lib/windows/comdlg32.js
+var b3 = (name, sig) => bind("comdlg32.dll", name, sig);
+var GetOpenFileName = /* @__PURE__ */ b3("GetOpenFileNameW", "<OPENFILENAMEW>ptr -> u32");
+
+// _build/lib/windows/shell32.js
+var b4 = (name, sig) => bind("shell32.dll", name, sig);
+var SHBrowseForFolder = /* @__PURE__ */ b4("SHBrowseForFolderW", "<BROWSEINFOW>ptr -> <>ptr");
+var SHGetPathFromIDList = /* @__PURE__ */ b4("SHGetPathFromIDListW", "<>ptr <BYTE>ptr -> u32");
+
+// _build/lib/windows/ole32.js
+var b5 = (name, sig) => bind("ole32.dll", name, sig);
+var CoTaskMemFree = /* @__PURE__ */ b5("CoTaskMemFree", "<>ptr -> void");
 
 // _build/lib/react-qw/components/PathPicker.js
-var FFI_PTR = ffi11.FFI_TYPE_POINTER;
-var FFI_U32 = ffi11.FFI_TYPE_UINT32;
-var _GetOpenFileNameW = 0;
-var _SHBrowseForFolderW = 0;
-var _SHGetPathFromIDListW = 0;
-var _CoTaskMemFree = 0;
-function ensureDlls() {
-  if (_GetOpenFileNameW)
-    return true;
-  const comdlg32 = win3.LoadLibrary("comdlg32.dll");
-  const shell32 = win3.LoadLibrary("shell32.dll");
-  const ole32 = win3.LoadLibrary("ole32.dll");
-  if (!comdlg32 || !shell32 || !ole32)
-    return false;
-  const load = (lib, name) => win3.GetProcAddress(lib, name) || 0;
-  _GetOpenFileNameW = load(comdlg32, "GetOpenFileNameW");
-  _SHBrowseForFolderW = load(shell32, "SHBrowseForFolderW");
-  _SHGetPathFromIDListW = load(shell32, "SHGetPathFromIDListW");
-  _CoTaskMemFree = load(ole32, "CoTaskMemFree");
-  return !!_GetOpenFileNameW && !!_SHBrowseForFolderW && !!_SHGetPathFromIDListW && !!_CoTaskMemFree;
-}
-function strToWide(s) {
-  return new TextEncoder("utf-16le").encode(s + "\0").buffer;
-}
-var _decoder = new TextDecoder("utf-16le");
-function wideToStr(buf, offset = 0) {
-  const str = _decoder.decode(new Uint8Array(buf, offset));
-  const nullIdx = str.indexOf("\0");
-  return nullIdx >= 0 ? str.substring(0, nullIdx) : str;
-}
 function openFileDialog(owner, filter, title, multiple) {
-  if (!ensureDlls())
-    return null;
-  const fileBuf = new ArrayBuffer(260 * 2);
-  const filterWide = strToWide(filter);
-  const titleWide = title ? strToWide(title) : null;
+  const fileBuf = WCHAR.alloc(260);
+  const filterWide = WCHAR.encode(filter);
+  const titleWide = title ? WCHAR.encode(title) : null;
   let flags = 4096 | 2048 | 8;
   if (multiple)
     flags |= 512;
   flags |= 524288;
-  const ofn = OPENFILENAMEW.write({
+  const ofn = OPENFILENAMEW.encode({
     lStructSize: OPENFILENAMEW.size,
     hwndOwner: owner,
-    hInstance: 0,
-    lpstrFilter: ffi11.bufferPtr(filterWide),
-    lpstrCustomFilter: 0,
-    nMaxCustFilter: 0,
-    nFilterIndex: 0,
-    lpstrFile: ffi11.bufferPtr(fileBuf),
+    lpstrFilter: filterWide.ptr,
+    lpstrFile: fileBuf.ptr,
     nMaxFile: 260,
-    lpstrFileTitle: 0,
-    nMaxFileTitle: 0,
-    lpstrInitialDir: 0,
-    lpstrTitle: titleWide ? ffi11.bufferPtr(titleWide) : 0,
-    Flags: flags,
-    nFileOffset: 0,
-    nFileExtension: 0,
-    lpstrDefExt: 0,
-    lCustData: 0,
-    lpfnHook: 0,
-    lpTemplateName: 0,
-    pvReserved: 0,
-    dwReserved: 0,
-    FlagsEx: 0
+    lpstrTitle: titleWide?.ptr ?? 0,
+    Flags: flags
   });
-  const ret = ffi11.ffiCall(_GetOpenFileNameW, [FFI_PTR], [ofn], FFI_U32);
+  const ret = GetOpenFileName(ofn.ptr);
   if (!ret)
     return null;
   if (!multiple) {
-    return wideToStr(fileBuf);
+    return WCHAR.decode(fileBuf);
   }
-  const dir = wideToStr(fileBuf);
-  let pos = (dir.length + 1) * 2;
-  const files = [];
-  while (pos < fileBuf.byteLength) {
-    const f = wideToStr(fileBuf, pos);
-    if (f.length === 0)
-      break;
-    files.push(dir + "\\" + f);
-    pos += (f.length + 1) * 2;
-  }
-  if (files.length === 0)
-    return [dir];
-  return files;
+  const strs = new TextDecoder("utf-16le").decode(new Uint8Array(fileBuf)).split("\0");
+  const dir = strs[0] ?? "";
+  const files = strs.slice(1).filter((f) => f.length > 0).map((f) => dir + "\\" + f);
+  return files.length > 0 ? files : [dir];
 }
 function openFolderDialog(owner, title) {
-  if (!ensureDlls())
-    return null;
-  const titleWide = title ? strToWide(title) : null;
-  const bi = BROWSEINFOW.write({
+  const titleWide = title ? WCHAR.encode(title) : null;
+  const bi = BROWSEINFOW.encode({
     hwndOwner: owner,
-    pidlRoot: 0,
-    pszDisplayName: 0,
-    lpszTitle: titleWide ? ffi11.bufferPtr(titleWide) : 0,
-    ulFlags: 65,
-    lpfn: 0,
-    lParam: 0,
-    iImage: 0
+    lpszTitle: titleWide?.ptr ?? 0,
+    ulFlags: 65
   });
-  const pidl = ffi11.ffiCall(_SHBrowseForFolderW, [FFI_PTR], [bi], FFI_PTR);
+  const pidl = SHBrowseForFolder(bi.ptr);
   if (!pidl)
     return null;
-  const pathBuf = new ArrayBuffer(260 * 2);
-  const ok = ffi11.ffiCall(_SHGetPathFromIDListW, [ffi11.FFI_TYPE_POINTER, FFI_PTR], [pidl, pathBuf], FFI_U32);
-  ffi11.ffiCall(_CoTaskMemFree, [ffi11.FFI_TYPE_POINTER], [pidl], ffi11.FFI_TYPE_VOID);
-  return ok ? wideToStr(pathBuf) : null;
+  const pathBuf = WCHAR.alloc(260);
+  const ok = SHGetPathFromIDList(pidl, pathBuf);
+  CoTaskMemFree(pidl);
+  return ok ? WCHAR.decode(pathBuf) : null;
 }
 var PathPicker = (0, import_react17.forwardRef)((props, ref) => {
   const { type = "file", filter = "All Files\0*.*\0\0", title, disabled, style } = props;
@@ -17927,7 +18259,7 @@ var rootMap = /* @__PURE__ */ new Map();
 function ensureDefaultClass() {
   if (defaultClassRegistered)
     return DEFAULT_CLASS;
-  gui18.RegisterClass(DEFAULT_CLASS, (hwnd, msg, wParam, lParam) => {
+  gui17.RegisterClass(DEFAULT_CLASS, (hwnd, msg, wParam, lParam) => {
     const entry = rootMap.get(hwnd);
     if (msg === 2 && entry) {
       rootMap.delete(hwnd);
@@ -17940,7 +18272,7 @@ function ensureDefaultClass() {
       return result;
     if (msg === 5)
       forceFlexLayout(hwnd);
-    return gui18.DefWindowProc(hwnd, msg, wParam, lParam);
+    return DefWindowProc(hwnd, msg, wParam, lParam);
   });
   defaultClassRegistered = true;
   return DEFAULT_CLASS;
@@ -17953,19 +18285,19 @@ function createRoot(container) {
     const ws = (cfg.ws ?? 0) | 13565952;
     const w = (cfg.width ?? 800) * scaleFactor;
     const h = (cfg.height ?? 600) * scaleFactor;
-    const [sw, sh] = gui18.GetScreenSize();
+    const [sw, sh] = [GetSystemMetrics(0), GetSystemMetrics(1)];
     const x = cfg.x === void 0 ? (sw - w) / 2 | 0 : cfg.x === -2147483648 ? -2147483648 : cfg.x * scaleFactor;
     const y = cfg.y === void 0 ? (sh - h) / 2 | 0 : cfg.y === -2147483648 ? -2147483648 : cfg.y * scaleFactor;
-    const hwin = gui18.CreateWindow(className, cfg.text || "", ws, x, y, w, h, null, null);
+    const hwin = gui17.CreateWindow(className, cfg.text || "", ws, x, y, w, h, null, null);
     if (!hwin)
       throw new Error("CreateWindow failed");
     hwnd = hwin;
     if (!cfg.noShowWindow)
-      gui18.ShowWindow(hwnd);
+      gui17.ShowWindow(hwnd);
   } else {
     hwnd = container;
   }
-  const root = reconciler_default.createContainer(hwnd, 0, null, false, null, "", noop, noop, noop, noop);
+  const root = reconciler_default.createContainer(hwnd, 0, null, false, null, "", (error, info) => console.log("[React uncaught]", error, error.stack, info.componentStack), (error, info) => console.log("[React caught]", error, error.stack, info.componentStack), (error, info) => console.log("[React recoverable]", error, error.stack, info.componentStack), noop);
   const rootInst = { hwnd, type: "_root", props: { type: "_root", style: { flexDirection: "column", alignItems: "stretch" } }, children: [] };
   instancesByHwnd.set(hwnd, rootInst);
   if (typeof container === "object")
@@ -18036,7 +18368,7 @@ createRoot({
   onEvent: (e) => {
     if (e.msg === 16) {
       console.log("test_react_listview_link done clicks=" + clicks);
-      std.exit(0);
+      std2.exit(0);
     }
   }
 }).render((0, import_jsx_runtime16.jsx)(App, {}));