quickwin 3.0.0 → 3.0.2

package/lib/ffi/ctype.ts

@@ -1,371 +0,0 @@
-import { bufferPtr } from 'ffi'
-import * as os from 'os'
-
-// ============================================================
-// 语法词汇 —— struct/bind 共用的 C 类型描述。标量直接写规范 token 字符串（'i32'/'u32'），
-// 指针写 '<>ptr'（裸地址）或 '<NAME>ptr'（带名）；对象值一律带 '#' 声明键（见 §4）。
-// 只描述「C 声明怎么写」（unit/length/encoding 等意图）；内存布局与读写视图由
-// struct.ts 的 computeStructLayout/lower 单独 lower 成 layout IR。
-//
-// 叶子模块：刻意不依赖 win/std/text-codec，可被 struct 直接引用，
-// 避免「只用 struct」的调用方被动加载整个 bind 运行时。
-// 四段按依赖序：§1 kind 词汇表 → §2 指针布局与品牌 → §3 token 词表与白名单（normToken） → §4 值词汇。
-// ============================================================
-
-// ============================================================
-// §1 kind 词汇表 —— C_BASIC_TYPE 是唯一手写清单，下列集合全从它派生
-//   C_BasicType(12)  bind 签名 token / lower 后 IR 共用
-//   C_Number(10)    结构体字段的数字档
-//   C_Integer(8)    C_Number 去浮点 —— 位域存储单元只能是整数档
-//   Token(11+指针)  C_BasicType_Token / Arg·Ret JsTypeOfToken 的操作面（见 §3）
-// 排除项：'void' 无大小；裸 'ptr' 用户面禁写（须写 '<>ptr'），内部保留 ——
-// 唯一随架构变宽的标量档。lower 后所有指针归一为 kind 'ptr'，名字被擦掉。
-// ============================================================
-const C_BASIC_TYPE = [
-    'void', 'u8', 'i8', 'u16', 'i16', 'u32', 'i32',
-    'u64', 'i64', 'f32', 'f64', 'ptr',
-] as const
-
-export type C_BasicType = (typeof C_BASIC_TYPE)[number]
-export type C_BasicType_No_Void = Exclude<C_BasicType, 'void'>
-
-// '!' / '*' 形随 token 走（normToken 只剥运行时不理解的 '@'，运行时要执法的 '!'（0 检查）
-// 与 '*'（数组分派）保留在 token 上——token 即契约，callPacked 按尾缀执法，无独立 flag
-// 可丢）。'<N*>ptr' 数组位无需新词形：品牌段含 '*'，整 token 仍在 <${string}>ptr 模板内。
-export type C_BasicType_Token = Exclude<C_BasicType, 'ptr'> | `<${string}>ptr` | `<${string}>ptr!` | `<${string}>`
-export type C_BasicType_Token_No_Void = Exclude<C_BasicType_Token, 'void'>
-
-// 尾缀修饰：'!' = 非空担保（见 Arg/RetJsTypeOfToken 的 ! 分支与 callPacked 的运行时 0 检查），
-// '@Name' = 枚举值域标注（类型层启用前先由 Norm 归一剥掉）。两者语义正交但作用面不相交
-// （! 主品牌位、@ 主裸档整数位，@ 枚举不含 0 时已蕴含 !），故每 token 至多一个修饰。
-// 组 1 恒为名字（归一名），组 2 为修饰；槽宽/ABI 只看归一形式。
-// 名字形收紧为标识符（[A-Za-z_]\w*）∪ 空串（<>ptr 裸地址档），尾部可挂数组字形：
-// '*' = 零或多（<N*>ptr 入参连续数组位，元素形 = 单对象位 codec）。其余非标识符
-// 字符（'+'/'-'/'1' 开头等）不进词法 —— 与 <1abc>ptr/<X-y>ptr 同策略：正则不匹配、
-// 绑定时落通用 Unknown token，类型层不设专属禁分支（运行时兜底，无静默通过）。旧版
-// ([^<>\s]*) 通配曾使 <FOO+>ptr 被静默当品牌 'FOO+' 接受——语义字形必须结构可见。
-const PTR_TOKEN_RE = /^<([A-Za-z_]\w*|)>ptr(!|@[A-Za-z_]\w*)?$/
-
-export function isCPtrToken(t: string): t is `<${string}>ptr` | `${string}ptr!` | `${string}ptr@${string}` { return PTR_TOKEN_RE.test(t) }
-
-// '<N>' 裸品牌形 = 按值传参位（<N>ptr 传地址 / <N> 传值）。名字形同指针形（标识符，
-// 空名 <> 仅 ptr 档有），不带任何修饰 —— 按值位无 '!'（值不为 NULL）、无 '@'（值域由
-// codec 推导、不标枚举）、无 '*'（数组走 structArray encoder 的值域）：含修饰的形
-// 正则不匹配，落绑定时通用 Unknown token（与 '<X+>ptr' 同策略，运行时兜底）。
-const VAL_TOKEN_RE = /^<([A-Za-z_]\w*)>$/
-
-export function isCValToken(t: string): t is `<${string}>` { return VAL_TOKEN_RE.test(t) }
-export function valName<const N extends string>(t: `<${N}>`): N {
-    const m = VAL_TOKEN_RE.exec(t)
-    return (m?.[1] || "") as N
-}
-export function ptrName<const N extends string>(t: `<${N}>ptr` | `<${N}>ptr!`): N {
-    const m = PTR_TOKEN_RE.exec(t)
-    return (m?.[1] || "") as N
-}
-/**
- * @description `<${string}>ptr` / `<${string}>ptr!` -> 'ptr'。按值形 `<${string}>` 无
- * 标量槽等价物 —— 运行时 throw（返回位由 parseSig 拒、closure 入参位由 closure() 拒，
- * 正常路径不可达），返回类型同时 Exclude 掉按值形：消费方（readRet / dispatchClosure
- * 的 IA32_ARG_SIZE 索引）拿不到会误导编译期的标量误判。
- */
-export const cTokenToType = <const T extends string>(
-    t: T,
-): Exclude<T, `<${string}>ptr` | `<${string}>ptr!` | `<${string}>`> | 'ptr' => {
-    if (isCPtrToken(t)) return 'ptr'
-    if (isCValToken(t))
-        throw new Error(`ffi: cTokenToType: by-value token "${t}" has no scalar slot type`)
-    return t as Exclude<T, `<${string}>ptr` | `<${string}>ptr!` | `<${string}>`>
-}
-
-// C 的数字类型档：可作结构体字段 / bind 签名 token。排除项理由见 §1。
-export type C_Number = Exclude<C_BasicType, 'void' | 'ptr'>
-
-// 整数档：位域存储单元的合法类型（C 位域只能用整型）。
-export type C_Integer = Exclude<C_Number, 'f32' | 'f64'>
-
-export type Encoding = 'utf-8' | 'utf-16le'
-
-type First =
-    | '_' | 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm'
-    | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z'
-    | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M'
-    | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
-
-// ============================================================
-// §4 值词汇（SimpleValue）—— 字段值/数组元素的全部合法形态：
-//   token        'u32'（规范 token 词汇；'void'/裸 'ptr'/拼错 token 运行时拒绝 —— typedef 别名已移除）
-//   数组糖       'u32[4]'（仅 token 元素 —— 更复杂的元素写 '#' array 声明）
-//   位域糖       'u32:3'（unit 位归一后须为整数档）
-//   字符串糖     'u16[128]@utf-16le'（布局 unit[length] × 解释 @encoding 正交：
-//                size = typesize × length 由 unit/length 决定，encoding 只管怎么读写
-//                这些字节 —— 错配如 'u8[128]@utf-16le' 也语义自洽。与键侧 alignas 同
-//                用 '@' 但位置不同（键名尾 vs 值串尾），解析互不干扰。string 是唯一
-//                没有 '#' 声明形式的值 —— 糖与 C_String 三元组双射，一种概念一种写法）
-//   '#' 声明     struct/union（平铺字段 + '#pack'）、array（element+length）——
-//                对象值的唯一判别键是 '#'（多字段/聚合元素无法用糖表达，故保留）
-// '#' 必填（无「裸嵌套 map 默认 struct」）：漏写 '#' 时 union 不会静默翻转成 struct，
-// 类型层直接报错、运行时 throw。顶层 struct()/union() 例外 —— kind 由函数名表明，
-// 参数是平铺字段表（本身不含 '#'；DECL 常量直传时 '#' 须与函数名 kind 一致 —— 参数
-// 类型交叉 `{ '#'?: 'struct' }` / `{ '#'?: 'union' }` 编译期锁），'#'/`#pack` 由构造器
-// 写入声明（buildDecl）。
-// ============================================================
-
-// token 值面：规范 token（C_Number 档）∪ 指针形（含 '!' 非空尾缀）∪ '@枚举标注形'
-// （枚举名限 keyof EnumMap —— 未知枚举名在定义点就 ∉ SimpleValue 被拒，与拼错 token
-// 同一道闸）。'void' 除外 —— 无大小，不能作字段值。
-export type SimpleToken =
-    | C_Number
-    | `${C_Number}@${keyof EnumMap}`
-    | `<${string}>ptr`
-    | `${string}ptr!`
-    | `<${string}>ptr@${keyof EnumMap}`
-
-// 平铺字段表：struct()/union() 参数与 '#' 声明的字段部分（声明类型见下方 C_Struct/C_Union）。
-// 键侧词汇：'k@N' = alignas N（键尾 @+数字，字段名不含 '@'）；'$x' = 匿名槽（只收聚合）。
-// '#' 前缀键是指令位，与字段名（First 不含 '#'）天然无撞名。
-export type SimpleMember = {
-    [K: `${First}${string}`]: SimpleValue
-    [K: `$${string}`]: C_Struct | C_Union
-}
-
-// 用 interface（而非 `{'#': ...} & SimpleMember` 交叉别名）：交叉 + 循环别名（SimpleMember
-// ↔ SimpleValue ↔ 本类型）在展开时有解析顺序陷阱 —— 实测 C_Union 拿到的 SimpleMember
-// 丢失索引签名（`'a' extends keyof C_Union` = false，字段字面量被 excess check 拒绝），
-// 而 interface 成员惰性求值无此问题。索引签名与 SimpleMember 逐字同源，改一处须同步另一处。
-export interface C_Struct {
-    '#': 'struct'
-    '#pack'?: number
-    [K: `${First}${string}`]: SimpleValue
-    [K: `$${string}`]: C_Struct | C_Union
-}
-export interface C_Union {
-    '#': 'union'
-    '#pack'?: number
-    [K: `${First}${string}`]: SimpleValue
-    [K: `$${string}`]: C_Struct | C_Union
-}
-export type C_Array = { '#': 'array', element: SimpleValue, length: number }
-
-export type SimpleValue =
-    | SimpleToken
-    | `${SimpleToken}[${number}]`
-    | `${C_Number}:${number}`   // 位域糖：仅裸数字档（'@'/'!'/'<T>ptr' 尾缀在位域位词汇拒）
-    | `${'u8' | 'u16'}[${number}]@${Encoding}`   // 字符串糖（unit/length 布局 + encoding 解释）
-    | C_Struct | C_Union | C_Array
-
-
-export const PTR_SIZE = os.arch === 'x64' ? 8 : 4
-
-export const SizeAlign: Record<C_Number, number> = {
-    u8: 1, i8: 1,
-    u16: 2, i16: 2,
-    u32: 4, i32: 4,
-    u64: 8, i64: 8,
-    f32: 4, f64: 8,
-}
-
-// brand 属性用普通字符串键（phantom——运行时就是裸 number，属性不存在）：结构等价使
-// quickwin.d.ts 的 gui.HWND 能直接书写 `number & { readonly ptrBrand: "HWND" }`，
-// 与 Ptr<"HWND"> 双向可赋值、d.ts 零依赖 ctype；unique symbol 按声明位置定身份，
-// 反而使跨包的重复副本互不兼容。同构碰撞的防线由 `number &` 交叉保证（裸 number
-// 缺属性、纯对象缺 number，构造源只有 Ptr 本身或故意手写）。
-// `''` 判在左侧（右侧实例化，不作 naked 分布）：T=never 不再塌缩成 never（否则
-// `Ptr<never>` 不可构造，decode(… | Ptr<N>) 在 N=never 时直接堵死），含 '' 的并集
-// 不再拆分，宽 string 归一裸 number。字面品牌照旧走交叉 brand 分支。
-// 空品牌塌缩成 number 是有意设计：FFI 的 `<>ptr` 是 uintptr 双态位（WPARAM/LPARAM/
-// void*/LONG_PTR 在 C ABI 里既收地址又收整数），品牌化会把 sel、max、算术值这类
-// 合法实参拦成伪错误——裸档误用靠 NULL 迁移后的调用点纪律兜底，不做 tsc 强制。
-export type Ptr<T extends string> =
-    '' extends T ? number : number & { readonly ptrBrand: T }
-
-/** NULL 品牌零：0 的品牌形态 —— 全 FFI 层唯一的空指针字面量（对应 C 的 NULL 宏，
- *  运行时就是 0）。JS 的 null 不在指针值域：类型层禁收，运行时不做 null→0 转换
- *  （动态 null 在参数槽 / 写槽处 fail-loud 报错）。 */
-export type NULL = 0 & { readonly ptrBrand: 'NULL' }
-export const NULL = 0 as NULL
-
-/** 唯一指针类型：参数位 / 返回位 / struct 字段 / closure 双侧通用。
- *  C→JS 0 保真（readScalar 不做 0→null）；JS→C 空位写 NULL（写槽即 0）。
- *  传参前由 tsc 收窄掉空位（truthy / === NULL / === 0）。 */
-export type MaybePtr<T extends string> =
-    NULL | Ptr<T>
-
-// 用户 token 词表 → JS 类型。刻意不含 'ptr'：用户面禁写裸 ptr，Arg/Ret 的
-// `K & keyof` 索引到 never 自塌拒绝；IR 层 kind 含 'ptr' 的消费者（Entry）
-// 自行 `& { ptr: number }` 增量。
-export type C_TypeJsTypeMap = {
-    u8: number; i8: number; u16: number; i16: number
-    u32: number; i32: number; i64: bigint, u64: bigint
-    f32: number; f64: number
-}
-
-export type TokenArgJsTypeMap = C_TypeJsTypeMap
-export type TokenReturnJsTypeMap = C_TypeJsTypeMap & { void: void }
-
-/** token 枚举标注（'u32@Name' / '<>ptr@Name'）的值域表 —— 全局 interface 声明合并：
- *  预填由 tools/gen_enum_map.sh 从 quickwin_const.d.ts 提取（quickwin_enum_map.d.ts），
- *  用户在自己的 .d.ts 里直接扩展（interface EnumMap { MyEnum: import('...').MyEnum }）——
- *  勿用 declare module：用户 import specifier 形态五花八门，模块匹配不上；全局合并对
- *  「按枚举名索引」的 token 语义才成立。消费点（bind Arg/Ret、struct 字段）统一以
- *  `infer E extends keyof EnumMap` 收紧后直接索引本表 —— 值域类型不分参数/返回语境
- *  （拦异种枚举、域外字面量靠枚举类型自身的 nominal）；未知枚举名由词汇/分支约束
- *  挡在外面：struct 定义点 ∉ SimpleValue，bind 签名落链末 map[never] 塌 never
- *  （参数位）/ unknown（返回位——never 是 bottom 会被任意使用放行，反而危险）。 */
-declare global {
-    // 预填见 quickwin_enum_map.d.ts；此处空声明兜底（预填文件缺省时引用处仍可解析）。
-    interface EnumMap { }
-}
-
-// token → JS 类型（实参语境）。L = 布局名→JS 形；M/D 已固化（TokenArgJsTypeMap /
-// never —— 'void'/裸 'ptr'/拼错 token 经 map[K & keyof] 塌 never，参数位调用点全红
-// fail-loud）。分支链：'!' 在链首（非空担保 → Ptr<N> 排 NULL，带布局形照收）；
-// '@E' 枚举值域（模式用 `infer E extends keyof EnumMap` 收紧：未知枚举名分支失配、
-// 落链末 map[never] —— 与 struct 侧词汇定义点拒绝构成双层防线；nominal：拦异种枚举、
-// 拦裸 0/NULL；单值位标注，flags 组合位不标；不并 layout 形 —— codec 入参编码成
-// 地址必然落在枚举域外，留着就是绕过值域承诺的无检查后门）；裸 ptr 形收
-// MaybePtr | L[N]。'u32!'/'DWORD' 等不匹配任何已知形 → map[never] 塌 never
-// （非法形态宁可全红也不放行）。泛型未解析位（K = string —— closure/bindLib
-// 泛型体内）由 `string & keyof map` = 全键联合兜底成非 never —— 否则 BindFn 塌
-// (never)=>never 使内层强转失去可比性。
-export type ArgJsTypeOfToken<K extends string, L> =
-    // 非标识符名字形（'<X+>ptr'/'<X*>ptr'/'<1abc>ptr'）不设专属分支：落 '<N>ptr'
-    // 通配、运行时 Unknown token 兜底（'*' 已非 token 字形 —— 数组物化走
-    // structArray(def) encoder 的值域推导，token/引擎/类型层零数组概念）。
-    K extends `<${infer N}>ptr!` ? Ptr<N> | L[N & keyof L] :
-    K extends `<${string}>ptr@${infer E extends keyof EnumMap}` ? EnumMap[E] :
-    K extends `<${infer N}>ptr` ? MaybePtr<N> | L[N & keyof L] :
-    // '<N>' 按值位：值域 = 注册布局的 encode 入参形（对象直传），无 MaybePtr —— 按值
-    // 位不收 NULL / 地址（引擎按值语义编码，地址进位是必然错位）。未注册布局 →
-    // L[never] → 整位塌 never（与拼错 token 同策略）。
-    K extends `<${infer N}>` ? L[N & keyof L] :
-    K extends `${C_Number}@${infer E extends keyof EnumMap}` ? EnumMap[E] :
-    TokenArgJsTypeMap[K & keyof TokenArgJsTypeMap] extends never ? never
-    : TokenArgJsTypeMap[K & keyof TokenArgJsTypeMap]
-
-// token → JS 类型（返回语境）。D = 返回位布局表 decode 值域：该键有 decode →
-// D[N] | NULL（解码结果替换地址，空指针 0 保真为 NULL）；否则 MaybePtr<N>，
-// 与实参位同型（空品牌 <''> 归一裸 number，联合坍缩）。'!' 分支 = 「C 保证非零」
-// 的作者担保：去掉 NULL 分支（有 decode → D[N]，无 decode → Ptr<N>），运行时返回
-// 0 当场 throw 兜底标错；'@E' 分支 = 担保返回值在枚举值域（标错同担，值域校验按需
-// Phase 2）。非法 token（'i3z'/裸 'ptr'）经 map[never] 塌 unknown —— 返回位刻意不是
-// never：never 是 bottom 会被任意使用全放行，unknown 逼调用方显式收窄（与参数位
-// never 拦调用的不对称是设计）。
-export type RetJsTypeOfToken<K extends string, D> =
-    K extends `<${infer N}>ptr!`
-        ? (D[N & keyof D] extends never ? Ptr<N> : D[N & keyof D])
-        : K extends `<${string}>ptr@${infer E extends keyof EnumMap}`
-        ? EnumMap[E]
-        : K extends `<${infer N}>ptr`
-        ? (D[N & keyof D] extends never ? MaybePtr<N> : D[N & keyof D] | NULL)
-        : K extends `${C_Number}@${infer E extends keyof EnumMap}`
-        ? EnumMap[E]
-        : TokenReturnJsTypeMap[K & keyof TokenReturnJsTypeMap] extends never ? unknown
-        : TokenReturnJsTypeMap[K & keyof TokenReturnJsTypeMap]
-
-// token 归一：只收规范 token（C_BASIC_TYPE 去 'ptr' = C_Number ∪ 'void'，由 §1 唯一手写
-// 清单派生）与指针形；拼错 token、已移除的 typedef 别名（'DWORD'/'HANDLE'）一律 fail-loud。
-export function normToken(t: string): C_BasicType_Token {
-    if (isCPtrToken(t)) {
-        // 只剥 '@Name'（枚举标注是纯类型层语义，运行时不校验、不理解）；'!' 保留在
-        // token 上——运行时要执法的语义（0 检查）跟着 token 走到 callPacked，
-        // 无独立 flag 可被解构丢失。槽宽/ABI 判型走 isCPtrToken，带修饰不受影响。
-        const m = PTR_TOKEN_RE.exec(t)
-        const name = m?.[1] || ''
-        const mod = m?.[2]
-        // 剥 '@'（纯类型层语义）；'!' 形随 token 走。（'*' 等词法外字符不设专属分支：
-        // 不匹配正则，落末尾 Unknown token —— 与 '<X+>ptr' 同待遇。）
-        return (mod?.startsWith('@') ? `<${name}>ptr` : t) as C_BasicType_Token
-    }
-    // 按值形 '<N>' 无修饰可剥（见 VAL_TOKEN_RE 注释），原样归一。
-    if (isCValToken(t)) return t
-    // 整数档尾缀 '@Name'（枚举值域标注，与 ptr 位的 '@' 同源）：剥掉归一到原 token，
-    // 槽宽/ABI 只看归一形式。@ 后缀须为纯枚举名形 —— 'u32@WmMsg:3' 这类混进位域/数组
-    // 串的直接 throw，不静默吞成纯标量（布局会错）；名 ∈ EnumMap 的语义校验留给类型层
-    // （运行时不理解枚举名）。白名单 = C_BASIC_TYPE（§1 唯一手写清单）；'u32!' 等非
-    // ptr 位 '!' 尾缀、别名、拼错 token 不命中，落 throw（类型层先塌 never，这里
-    // 兜底动态传入）。
-    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 as readonly string[]).includes(base)) return base as C_BasicType_Token
-    throw new Error("Unknown token: " + t)
-}
-
-export function readScalar(dv: DataView, off: number, k: C_BasicType_No_Void): number | bigint | null {
-    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': {
-            // 有符号读（对齐 C 版 JS_NewInt64）：-1 哨兵等负值保真；用户态指针高位
-            // 为 0，有符号读与无符号同值。0 保真返回（即 NULL 品牌零，类型层
-            // MaybePtr = NULL | Ptr<N>，传参前收窄掉空位）。写回位模式见 writeScalar。
-            return PTR_SIZE === 8 ? Number(dv.getBigInt64(off, true)) : dv.getInt32(off, true)
-        }
-    }
-}
-
-// IR kind 词汇（C_BasicType_No_Void 含 'ptr'）——用户词表无 ptr 档，这里自行增量。
-type Entry =
-    { [K in C_BasicType_No_Void]: { k: K; v: (C_TypeJsTypeMap & { ptr: number })[K] } }[C_BasicType_No_Void];
-
-/** 内存写：按 sizeof 精确写，供 struct 字段编码用。小整数只占自己的字节，
- *  否则 `{a:u8,b:u8}` 这类紧凑布局会被 setUint32 越界覆盖相邻字段。 */
-export function writeScalar(dv: DataView, off: number, { k, v }: Entry): void {
-    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': {
-            // JS null/undefined 不是指针词汇（空位写 NULL）——fail-loud，不做 null→0 转换。
-            if ((v as unknown) == null) {
-                throw new Error('ffi: got null/undefined for a ptr slot; pass the imported NULL constant for empty')
-            }
-            // 读回的负值（LRESULT/句柄）再作参数回传时按二补位位模式写：asUintN /
-            // >>> 0 取模保真，否则 x64 传负 setBigUint64 直接 RangeError。
-            if (PTR_SIZE === 8) dv.setBigUint64(off, BigInt.asUintN(64, BigInt(v)), true)
-            else dv.setUint32(off, v >>> 0, true)
-            break
-        }
-    }
-}
-
-/** 槽写：供 bind 的参数槽/返回槽用。小整数扩展到 4 字节 —— 可变参数按 int 提升读，
- *  `i8 = -1` 必须给 `0xFFFFFFFF` 而非 `0x000000FF`。u32/i32/u64/i64/f32/f64/ptr
- *  槽宽 == sizeof，直接委托 writeScalar。 */
-export function writeSlot(dv: DataView, off: number, e: Entry): void {
-    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)
-}
-
-/** buffer + 品牌指针合一：一个引用既是 ArrayBuffer（喂 decode / encode(v, buf) 复用）
- *  又带 `.ptr` 直接喂 <N>ptr 形参 —— 替代旧 { buf, ptr } 结构包装。
- *  `ptr` 是构造时快照（与旧 StructAlloc 同性质：底层数据不可 detach/transfer）。
- *  品牌 N 由创建方声明：struct def 的 alloc()/encode() 返回值在类型层带 def 的 N（不可伪造）；
- *  直接 new 属自报品牌，仅限内部/原型场景 —— 生产路径一律走 def.alloc()。 */
-export class PtrArrayBuffer<N extends string> extends ArrayBuffer {
-    readonly ptr: Ptr<N>
-    constructor(byteLength: number) {
-        super(byteLength)
-        this.ptr = bufferPtr(this) as Ptr<N>
-    }
-}

package/lib/ffi/index.ts

@@ -1,6 +0,0 @@
-// FFI 公共入口：bind()/bindLib()/closure()（bind.ts）+ struct()/union()（struct.ts）。
-// 共享的 CType IR / 标量 kind / C 别名表在 ctype.ts（bind.ts 再透传其类型与函数）。
-// 仓库内调用点按需深引用（./bind.js / ./struct.js / ./ctype.js）以保留 tree-shaking；
-// 此 barrel 主要供外部/package 使用。
-export * from './bind.js'
-export * from './struct.js'