@nudojs/env 0.4.1 → 0.4.2-beta.0

package/dist/{chunk-6RZUMVN5.js → chunk-KRMQSDG3.js}

@@ -30,11 +30,32 @@ function undef() {
   return makeAbs({ k: "unknown" }, termLit(void 0), void 0, "exact");
 }
 function nullLit() {
-  return makeAbs({ k: "unknown" }, termLit(null), void 0, "exact");
+  return makeAbs(
+    { k: "brand", name: "null", shape: makeAbs({ k: "unknown" }, termLit(null), void 0, "exact") },
+    termLit(null),
+    void 0,
+    "exact"
+  );
 }
 function anyAbs() {
   return makeAbs({ k: "any" }, void 0, void 0, "path");
 }
+function dateAbs() {
+  return brandOf("Date", objAbs({
+    getTime: envFn([], num()),
+    valueOf: envFn([], num()),
+    toISOString: envFn([], str())
+  }));
+}
+function openObjBrand(name, index, entries = {}) {
+  const shape = {
+    k: "obj",
+    slots: slotsOf(entries),
+    open: true,
+    index
+  };
+  return makeAbs({ k: "brand", name, shape: makeAbs(shape, void 0, void 0, "exact") }, void 0, void 0, "path");
+}
 function arrOf(element) {
   return makeAbs({ k: "arr", element }, void 0, void 0, "exact");
 }
@@ -403,6 +424,8 @@ function defineEnv() {
 export {
   undef,
   nullLit,
+  dateAbs,
+  openObjBrand,
   arrOf,
   tupleOf,
   unionOf,

package/dist/es.js

@@ -1,6 +1,6 @@
 import {
   defineEnv
-} from "./chunk-6RZUMVN5.js";
+} from "./chunk-KRMQSDG3.js";
 export {
   defineEnv
 };

package/dist/node.js

@@ -1,17 +1,19 @@
 import {
   arrOf,
   brandOf,
+  dateAbs,
   defineEnv,
   envFn,
   envFnVariadic,
   nullLit,
   objAbs,
+  openObjBrand,
   prim,
   promiseOf,
   tupleOf,
   undef,
   unionOf
-} from "./chunk-6RZUMVN5.js";
+} from "./chunk-KRMQSDG3.js";
 
 // src/node.ts
 import {
@@ -39,7 +41,9 @@ function defineEnv2() {
   const BufferInstance = brandOf(
     "Buffer",
     objAbs({
-      toString: envFn([prim.str()], prim.str()),
+      toString: envFn([prim.str(), prim.num(), prim.num()], prim.str(), void 0, {
+        params: ["encoding?", "start?", "end?"]
+      }),
       toJSON: envFn(
         [],
         objAbs({ type: prim.str(), data: arrOf(prim.num()) })
@@ -47,7 +51,7 @@ function defineEnv2() {
       length: prim.num(),
       slice: envFn([prim.num(), prim.num()], brandOf("Buffer")),
       copy: envFn(
-        [prim.unknown, prim.num(), prim.num(), prim.num()],
+        [brandOf("Buffer"), prim.num(), prim.num(), prim.num()],
         prim.num()
       ),
       write: envFn(
@@ -73,10 +77,138 @@ function defineEnv2() {
     })
   );
   const bufferBrand = BufferInstance;
+  const errOrNull = unionOf(brandOf("Error"), nullLit());
+  const dateOr = dateAbs();
+  const encodingOptions = objAbs({
+    encoding: { value: prim.str(), optional: true },
+    flag: { value: prim.str(), optional: true }
+  });
+  const encodingOptionsArg = unionOf(prim.str(), encodingOptions);
+  const statOptions = objAbs({
+    bigint: { value: prim.bool(), optional: true },
+    throwIfNoEntry: { value: prim.bool(), optional: true }
+  });
+  const mkdirOptions = objAbs({
+    recursive: { value: prim.bool(), optional: true },
+    mode: { value: prim.num(), optional: true }
+  });
+  const rmOptions = objAbs({
+    recursive: { value: prim.bool(), optional: true },
+    force: { value: prim.bool(), optional: true },
+    maxRetries: { value: prim.num(), optional: true },
+    retryDelay: { value: prim.num(), optional: true }
+  });
+  const readdirOptions = objAbs({
+    encoding: { value: prim.str(), optional: true },
+    withFileTypes: { value: prim.bool(), optional: true },
+    recursive: { value: prim.bool(), optional: true }
+  });
+  const inspectOptions = objAbs({
+    showHidden: { value: prim.bool(), optional: true },
+    depth: { value: prim.num(), optional: true },
+    colors: { value: prim.bool(), optional: true },
+    customInspect: { value: prim.bool(), optional: true },
+    maxArrayLength: { value: prim.num(), optional: true },
+    breakLength: { value: prim.num(), optional: true },
+    compact: { value: prim.bool(), optional: true },
+    sorted: { value: prim.bool(), optional: true }
+  });
+  const querystringOptions = objAbs({
+    maxKeys: { value: prim.num(), optional: true }
+  });
+  const anyParam = prim.any();
+  const callbackFnBrand = brandOf(
+    "CallbackFn",
+    envFnVariadic(anyParam, undef(), { restName: "...args" })
+  );
+  const streamOptions = objAbs({
+    highWaterMark: { value: prim.num(), optional: true },
+    objectMode: { value: prim.bool(), optional: true },
+    encoding: { value: prim.str(), optional: true },
+    autoDestroy: { value: prim.bool(), optional: true },
+    emitClose: { value: prim.bool(), optional: true }
+  });
+  const streamIoMethods = {
+    on: envFn([prim.str(), callbackFnBrand], brandOf("Stream")),
+    once: envFn([prim.str(), callbackFnBrand], brandOf("Stream")),
+    off: envFn([prim.str(), callbackFnBrand], brandOf("Stream")),
+    emit: envFn([prim.str(), anyParam], prim.bool(), void 0, {
+      params: ["event", "...args"]
+    }),
+    pipe: envFn([brandOf("Writable")], brandOf("Writable")),
+    destroy: envFn([errOrNull], undef(), void 0, { params: ["error?"] }),
+    read: envFn([prim.num()], unionOf(prim.str(), bufferBrand, nullLit())),
+    write: envFn([unionOf(prim.str(), bufferBrand)], prim.bool()),
+    end: envFn([unionOf(prim.str(), bufferBrand), callbackFnBrand], undef(), void 0, {
+      params: ["chunk?", "callback?"]
+    }),
+    pause: envFn([], brandOf("Stream")),
+    resume: envFn([], brandOf("Stream")),
+    setEncoding: envFn([prim.str()], brandOf("Stream"))
+  };
+  const chunk = unionOf(prim.str(), bufferBrand);
+  const streamCallback = envFn([errOrNull], undef(), void 0, { params: ["error?"] });
+  const transformHook = envFn(
+    [chunk, prim.str(), envFn([errOrNull, chunk], undef(), void 0, { params: ["error?", "data?"] })],
+    undef(),
+    void 0,
+    { params: ["chunk", "encoding", "callback"] }
+  );
+  const writeHook = envFn(
+    [chunk, prim.str(), envFn([errOrNull], undef(), void 0, { params: ["error?"] })],
+    undef(),
+    void 0,
+    { params: ["chunk", "encoding", "callback"] }
+  );
+  const readHook = envFn([prim.num()], undef(), void 0, { params: ["size"] });
+  const finalHook = envFn([streamCallback], undef(), void 0, { params: ["callback"] });
+  const flushHook = envFn([streamCallback], undef(), void 0, { params: ["callback"] });
+  const streamBaseSlots = {
+    highWaterMark: { value: prim.num(), optional: true },
+    objectMode: { value: prim.bool(), optional: true },
+    encoding: { value: prim.str(), optional: true },
+    autoDestroy: { value: prim.bool(), optional: true },
+    emitClose: { value: prim.bool(), optional: true }
+  };
+  const streamHooks = {
+    transform: { value: transformHook, optional: true },
+    flush: { value: flushHook, optional: true },
+    read: { value: readHook, optional: true },
+    write: { value: writeHook, optional: true },
+    final: { value: finalHook, optional: true },
+    construct: { value: streamCallback, optional: true },
+    destroy: { value: envFn([errOrNull, streamCallback], undef(), void 0, { params: ["error", "callback"] }), optional: true }
+  };
+  const eventEmitterOptions = objAbs({
+    captureRejections: { value: prim.bool(), optional: true }
+  });
+  const promiseFnBrand = brandOf(
+    "PromiseFn",
+    envFnVariadic(anyParam, promiseOf(anyParam), { restName: "...args" })
+  );
+  const anyValueBrand = brandOf("Value");
+  const platformPathMethods = () => ({
+    join: envFnVariadic(prim.str(), prim.str(), {
+      restName: "...paths"
+    }),
+    resolve: envFnVariadic(prim.str(), prim.str(), {
+      restName: "...paths"
+    }),
+    dirname: envFn([prim.str()], prim.str()),
+    basename: envFn([prim.str(), prim.str()], prim.str(), void 0, {
+      params: ["path", "ext?"]
+    }),
+    extname: envFn([prim.str()], prim.str()),
+    normalize: envFn([prim.str()], prim.str()),
+    isAbsolute: envFn([prim.str()], prim.bool()),
+    relative: envFn([prim.str(), prim.str()], prim.str()),
+    sep: prim.str(),
+    delimiter: prim.str()
+  });
   const fsModule = {
     // encoding 字面量 → string；否则 string|Buffer（TS 重载近似）
     readFileSync: envFn(
-      [prim.str(), unionOf(prim.str(), objAbs({}))],
+      [prim.str(), encodingOptionsArg],
       unionOf(prim.str(), bufferBrand),
       (args) => {
         const enc = args[1];
@@ -88,42 +220,81 @@ function defineEnv2() {
           return prim.str();
         }
         return unionOf(prim.str(), bufferBrand);
-      }
+      },
+      { params: ["path", "options?"] }
     ),
     writeFileSync: envFn(
-      [prim.str(), unionOf(prim.str(), bufferBrand)],
-      undef()
+      [prim.str(), unionOf(prim.str(), bufferBrand), encodingOptionsArg],
+      undef(),
+      void 0,
+      { params: ["path", "data", "options?"] }
     ),
     appendFileSync: envFn(
-      [prim.str(), unionOf(prim.str(), bufferBrand)],
-      undef()
+      [prim.str(), unionOf(prim.str(), bufferBrand), encodingOptionsArg],
+      undef(),
+      void 0,
+      { params: ["path", "data", "options?"] }
     ),
     existsSync: envFn([prim.str()], prim.bool()),
-    mkdirSync: envFn([prim.str(), prim.unknown], unionOf(prim.str(), undef())),
+    mkdirSync: envFn(
+      [prim.str(), mkdirOptions],
+      unionOf(prim.str(), undef()),
+      void 0,
+      { params: ["path", "options?"] }
+    ),
     rmdirSync: envFn([prim.str()], undef()),
-    rmSync: envFn([prim.str(), prim.unknown], undef()),
+    rmSync: envFn(
+      [prim.str(), rmOptions],
+      undef(),
+      void 0,
+      { params: ["path", "options?"] }
+    ),
     unlinkSync: envFn([prim.str()], undef()),
     renameSync: envFn([prim.str(), prim.str()], undef()),
     copyFileSync: envFn([prim.str(), prim.str()], undef()),
     statSync: envFn(
-      [prim.str()],
+      [prim.str(), statOptions],
       objAbs({
         isFile: envFn([], prim.bool()),
         isDirectory: envFn([], prim.bool()),
         isSymbolicLink: envFn([], prim.bool()),
+        isBlockDevice: envFn([], prim.bool()),
+        isCharacterDevice: envFn([], prim.bool()),
+        isFIFO: envFn([], prim.bool()),
+        isSocket: envFn([], prim.bool()),
         size: prim.num(),
-        mtime: prim.unknown,
-        ctime: prim.unknown,
-        atime: prim.unknown,
-        birthtime: prim.unknown,
+        mtime: dateOr,
+        ctime: dateOr,
+        atime: dateOr,
+        birthtime: dateOr,
+        mtimeMs: prim.num(),
+        ctimeMs: prim.num(),
+        atimeMs: prim.num(),
+        birthtimeMs: prim.num(),
         mode: prim.num(),
         uid: prim.num(),
-        gid: prim.num()
-      })
+        gid: prim.num(),
+        ino: prim.num(),
+        dev: prim.num(),
+        nlink: prim.num()
+      }),
+      void 0,
+      { params: ["path", "options?"] }
     ),
     readdirSync: envFn(
-      [prim.str(), prim.unknown],
-      arrOf(unionOf(prim.str(), prim.unknown))
+      [prim.str(), readdirOptions],
+      // brand 名避免 `string | Dirent[]` 的结合歧义（真实是 (string|Dirent)[]）
+      brandOf(
+        "Array<string | Dirent>",
+        arrOf(unionOf(prim.str(), brandOf("Dirent", objAbs({
+          name: prim.str(),
+          isFile: envFn([], prim.bool()),
+          isDirectory: envFn([], prim.bool()),
+          isSymbolicLink: envFn([], prim.bool())
+        }))))
+      ),
+      void 0,
+      { params: ["path", "options?"] }
     ),
     realpathSync: envFn([prim.str()], prim.str()),
     readlinkSync: envFn([prim.str()], prim.str()),
@@ -134,97 +305,97 @@ function defineEnv2() {
     // Callback-style async on `fs` / `node:fs` (Node actual API).
     // Promise APIs live only under fs.promises / node:fs/promises.
     readFile: envFn(
-      [prim.str(), prim.unknown, prim.unknown],
+      [prim.str(), encodingOptionsArg, callbackFnBrand],
       undef(),
       void 0,
       { params: ["path", "options?", "callback"] }
     ),
     writeFile: envFn(
-      [prim.str(), unionOf(prim.str(), bufferBrand), prim.unknown],
+      [prim.str(), unionOf(prim.str(), bufferBrand), encodingOptionsArg, callbackFnBrand],
       undef(),
       void 0,
-      { params: ["path", "data", "callback"] }
+      { params: ["path", "data", "options?", "callback"] }
     ),
     mkdir: envFn(
-      [prim.str(), prim.unknown, prim.unknown],
+      [prim.str(), mkdirOptions, callbackFnBrand],
       undef(),
       void 0,
       { params: ["path", "options?", "callback"] }
     ),
     rm: envFn(
-      [prim.str(), prim.unknown, prim.unknown],
+      [prim.str(), rmOptions, callbackFnBrand],
       undef(),
       void 0,
       { params: ["path", "options?", "callback"] }
     ),
     stat: envFn(
-      [prim.str(), prim.unknown, prim.unknown],
+      [prim.str(), statOptions, callbackFnBrand],
       undef(),
       void 0,
       { params: ["path", "options?", "callback"] }
     ),
     readdir: envFn(
-      [prim.str(), prim.unknown, prim.unknown],
+      [prim.str(), readdirOptions, callbackFnBrand],
       undef(),
       void 0,
       { params: ["path", "options?", "callback"] }
     ),
     access: envFn(
-      [prim.str(), prim.unknown, prim.unknown],
+      [prim.str(), prim.num(), callbackFnBrand],
       undef(),
       void 0,
       { params: ["path", "mode?", "callback"] }
     ),
     appendFile: envFn(
-      [prim.str(), unionOf(prim.str(), bufferBrand), prim.unknown],
+      [prim.str(), unionOf(prim.str(), bufferBrand), encodingOptionsArg, callbackFnBrand],
       undef(),
       void 0,
-      { params: ["path", "data", "callback"] }
+      { params: ["path", "data", "options?", "callback"] }
     ),
     unlink: envFn(
-      [prim.str(), prim.unknown, prim.unknown],
+      [prim.str(), callbackFnBrand],
       undef(),
       void 0,
-      { params: ["path", "options?", "callback"] }
+      { params: ["path", "callback"] }
     ),
     rename: envFn(
-      [prim.str(), prim.str(), prim.unknown],
+      [prim.str(), prim.str(), callbackFnBrand],
       undef(),
       void 0,
       { params: ["oldPath", "newPath", "callback"] }
     ),
     copyFile: envFn(
-      [prim.str(), prim.str(), prim.unknown],
+      [prim.str(), prim.str(), callbackFnBrand],
       undef(),
       void 0,
       { params: ["src", "dest", "callback"] }
     ),
     realpath: envFn(
-      [prim.str(), prim.unknown, prim.unknown],
+      [prim.str(), encodingOptionsArg, callbackFnBrand],
       undef(),
       void 0,
       { params: ["path", "options?", "callback"] }
     ),
     readlink: envFn(
-      [prim.str(), prim.unknown, prim.unknown],
+      [prim.str(), encodingOptionsArg, callbackFnBrand],
       undef(),
       void 0,
       { params: ["path", "options?", "callback"] }
     ),
     symlink: envFn(
-      [prim.str(), prim.str(), prim.unknown, prim.unknown],
+      [prim.str(), prim.str(), prim.str(), callbackFnBrand],
       undef(),
       void 0,
       { params: ["target", "path", "type?", "callback"] }
     ),
     chmod: envFn(
-      [prim.str(), prim.num(), prim.unknown],
+      [prim.str(), prim.num(), callbackFnBrand],
       undef(),
       void 0,
       { params: ["path", "mode", "callback"] }
     ),
     open: envFn(
-      [prim.str(), prim.unknown, prim.unknown],
+      [prim.str(), unionOf(prim.str(), prim.num()), callbackFnBrand],
       undef(),
       void 0,
       { params: ["path", "flags?", "callback"] }
@@ -232,36 +403,77 @@ function defineEnv2() {
   };
   const fsPromisesModule = {
     readFile: envFn(
-      [prim.str(), prim.unknown],
-      promiseOf(unionOf(prim.str(), bufferBrand))
+      [prim.str(), encodingOptionsArg],
+      promiseOf(unionOf(prim.str(), bufferBrand)),
+      void 0,
+      { params: ["path", "options?"] }
     ),
     writeFile: envFn(
-      [prim.str(), unionOf(prim.str(), bufferBrand)],
-      promiseOf(undef())
+      [prim.str(), unionOf(prim.str(), bufferBrand), encodingOptionsArg],
+      promiseOf(undef()),
+      void 0,
+      { params: ["path", "data", "options?"] }
     ),
     mkdir: envFn(
-      [prim.str(), prim.unknown],
-      promiseOf(unionOf(prim.str(), undef()))
+      [prim.str(), mkdirOptions],
+      promiseOf(unionOf(prim.str(), undef())),
+      void 0,
+      { params: ["path", "options?"] }
+    ),
+    rm: envFn(
+      [prim.str(), rmOptions],
+      promiseOf(undef()),
+      void 0,
+      { params: ["path", "options?"] }
+    ),
+    stat: envFn(
+      [prim.str(), statOptions],
+      promiseOf(objAbs({
+        isFile: envFn([], prim.bool()),
+        isDirectory: envFn([], prim.bool()),
+        isSymbolicLink: envFn([], prim.bool()),
+        size: prim.num(),
+        mtime: dateOr,
+        ctime: dateOr,
+        atime: dateOr,
+        birthtime: dateOr,
+        mode: prim.num(),
+        uid: prim.num(),
+        gid: prim.num()
+      })),
+      void 0,
+      { params: ["path", "options?"] }
     ),
-    rm: envFn([prim.str(), prim.unknown], promiseOf(undef())),
-    stat: envFn([prim.str()], promiseOf(prim.unknown)),
     readdir: envFn(
-      [prim.str(), prim.unknown],
-      promiseOf(arrOf(prim.unknown))
+      [prim.str(), readdirOptions],
+      promiseOf(brandOf(
+        "Array<string | Dirent>",
+        arrOf(unionOf(prim.str(), brandOf("Dirent")))
+      )),
+      void 0,
+      { params: ["path", "options?"] }
     ),
     access: envFn([prim.str(), prim.num()], promiseOf(undef())),
     appendFile: envFn(
-      [prim.str(), unionOf(prim.str(), bufferBrand)],
-      promiseOf(undef())
+      [prim.str(), unionOf(prim.str(), bufferBrand), encodingOptionsArg],
+      promiseOf(undef()),
+      void 0,
+      { params: ["path", "data", "options?"] }
     ),
     unlink: envFn([prim.str()], promiseOf(undef())),
     rename: envFn([prim.str(), prim.str()], promiseOf(undef())),
     copyFile: envFn([prim.str(), prim.str()], promiseOf(undef())),
-    realpath: envFn([prim.str()], promiseOf(prim.str())),
-    readlink: envFn([prim.str()], promiseOf(prim.str())),
-    symlink: envFn([prim.str(), prim.str()], promiseOf(undef())),
+    realpath: envFn([prim.str(), encodingOptionsArg], promiseOf(prim.str()), void 0, {
+      params: ["path", "options?"]
+    }),
+    readlink: envFn([prim.str(), encodingOptionsArg], promiseOf(prim.str()), void 0, {
+      params: ["path", "options?"]
+    }),
+    symlink: envFn([prim.str(), prim.str(), prim.str()], promiseOf(undef()), void 0, {
+      params: ["target", "path", "type?"]
+    }),
     chmod: envFn([prim.str(), prim.num()], promiseOf(undef())),
-    open: envFn([prim.str(), prim.str()], promiseOf(prim.unknown))
+    open: envFn([prim.str(), prim.str()], promiseOf(brandOf("FileHandle")))
   };
   const strImpl1Abs = (fn) => (args) => {
     const a = absStr(args[0]);
@@ -332,11 +544,21 @@ function defineEnv2() {
         });
       }
     ),
-    format: envFn([objAbs({})], prim.str()),
+    format: envFn(
+      [objAbs({
+        root: { value: prim.str(), optional: true },
+        dir: { value: prim.str(), optional: true },
+        base: { value: prim.str(), optional: true },
+        name: { value: prim.str(), optional: true },
+        ext: { value: prim.str(), optional: true }
+      })],
+      prim.str()
+    ),
+    // 常量：平台相关字面量在 defineEnv 时可具体化
     sep: prim.str(),
     delimiter: prim.str(),
-    posix: prim.unknown,
-    win32: prim.unknown
+    posix: brandOf("path.PlatformPath", objAbs(platformPathMethods())),
+    win32: brandOf("path.PlatformPath", objAbs(platformPathMethods()))
   };
   const osModule = {
     platform: envFn([], prim.str()),
@@ -354,7 +576,20 @@ function defineEnv2() {
     freemem: envFn([], prim.num()),
     uptime: envFn([], prim.num()),
     loadavg: envFn([], tupleOf([prim.num(), prim.num(), prim.num()])),
-    networkInterfaces: envFn([], prim.unknown),
+    networkInterfaces: envFn(
+      [],
+      openObjBrand(
+        "Record<string, NetworkInterfaceInfo[]>",
+        { key: prim.str(), value: arrOf(objAbs({
+          address: prim.str(),
+          netmask: prim.str(),
+          family: prim.str(),
+          mac: prim.str(),
+          internal: prim.bool(),
+          cidr: unionOf(prim.str(), nullLit())
+        })) }
+      )
+    ),
     userInfo: envFn(
       [],
       objAbs({
@@ -415,15 +650,23 @@ function defineEnv2() {
       { params: ["href", "base?"] }
     ),
     URLSearchParams: envFn(
-      [prim.unknown],
+      [unionOf(
+        prim.str(),
+        openObjBrand("Record<string, string>", { key: prim.str(), value: prim.str() }),
+        arrOf(arrOf(prim.str()))
+      )],
       objAbs({
         get: envFn([prim.str()], unionOf(prim.str(), nullLit())),
+        getAll: envFn([prim.str()], arrOf(prim.str())),
         has: envFn([prim.str()], prim.bool()),
         set: envFn([prim.str(), prim.str()], undef()),
         append: envFn([prim.str(), prim.str()], undef()),
         delete: envFn([prim.str()], undef()),
-        toString: envFn([], prim.str())
-      })
+        toString: envFn([], prim.str()),
+        size: prim.num()
+      }),
+      void 0,
+      { params: ["init?"] }
     ),
     fileURLToPath: envFn([prim.str()], prim.str(), strImpl1Abs((s) => {
       try {
@@ -446,39 +689,58 @@ function defineEnv2() {
         }
       }
     ),
-    format: envFn([prim.unknown], prim.str())
+    format: envFn(
+      [objAbs({
+        auth: { value: unionOf(prim.str(), nullLit()), optional: true },
+        hash: { value: unionOf(prim.str(), nullLit()), optional: true },
+        host: { value: unionOf(prim.str(), nullLit()), optional: true },
+        hostname: { value: unionOf(prim.str(), nullLit()), optional: true },
+        href: { value: unionOf(prim.str(), nullLit()), optional: true },
+        pathname: { value: unionOf(prim.str(), nullLit()), optional: true },
+        protocol: { value: unionOf(prim.str(), nullLit()), optional: true },
+        search: { value: unionOf(prim.str(), nullLit()), optional: true },
+        port: { value: unionOf(prim.str(), prim.num(), nullLit()), optional: true }
+      })],
+      prim.str()
+    )
   };
   const cryptoModule = {
     randomBytes: envFn([prim.num()], bufferBrand),
     randomUUID: envFn([], prim.str()),
     randomInt: envFn([prim.num(), prim.num()], prim.num()),
+    // Hash/HMAC 实例：update 链式返回自身 brand（不是 unknown）
     createHash: envFn(
       [prim.str()],
-      objAbs({
-        update: envFn([unionOf(prim.str(), bufferBrand)], prim.unknown),
+      brandOf("Hash", objAbs({
+        update: envFn([unionOf(prim.str(), bufferBrand)], brandOf("Hash")),
         digest: envFn(
           [prim.str()],
-          unionOf(prim.str(), bufferBrand)
-        )
-      })
+          unionOf(prim.str(), bufferBrand),
+          void 0,
+          { params: ["encoding?"] }
+        ),
+        copy: envFn([], brandOf("Hash"))
+      }))
     ),
     createHmac: envFn(
       [prim.str(), unionOf(prim.str(), bufferBrand)],
-      objAbs({
-        update: envFn([unionOf(prim.str(), bufferBrand)], prim.unknown),
+      brandOf("Hmac", objAbs({
+        update: envFn([unionOf(prim.str(), bufferBrand)], brandOf("Hmac")),
         digest: envFn(
           [prim.str()],
-          unionOf(prim.str(), bufferBrand)
+          unionOf(prim.str(), bufferBrand),
+          void 0,
+          { params: ["encoding?"] }
         )
-      })
+      }))
     ),
     createCipheriv: envFn(
-      [prim.str(), prim.unknown, prim.unknown],
-      prim.unknown
+      [prim.str(), unionOf(prim.str(), bufferBrand), unionOf(prim.str(), bufferBrand)],
+      brandOf("Cipher")
     ),
     createDecipheriv: envFn(
-      [prim.str(), prim.unknown, prim.unknown],
-      prim.unknown
+      [prim.str(), unionOf(prim.str(), bufferBrand), unionOf(prim.str(), bufferBrand)],
+      brandOf("Decipher")
     ),
     pbkdf2Sync: envFn(
       [prim.str(), prim.str(), prim.num(), prim.num(), prim.str()],
@@ -487,126 +749,230 @@ function defineEnv2() {
     scryptSync: envFn([prim.str(), prim.str(), prim.num()], bufferBrand),
     timingSafeEqual: envFn([bufferBrand, bufferBrand], prim.bool())
   };
+  const spawnOptions = objAbs({
+    cwd: { value: prim.str(), optional: true },
+    env: { value: openObjBrand("Record<string, string | undefined>", { key: prim.str(), value: unionOf(prim.str(), undef()) }), optional: true },
+    stdio: { value: unionOf(prim.str(), arrOf(prim.str())), optional: true },
+    shell: { value: unionOf(prim.bool(), prim.str()), optional: true },
+    timeout: { value: prim.num(), optional: true },
+    killSignal: { value: unionOf(prim.str(), prim.num()), optional: true }
+  });
+  const childProcessInstance = brandOf(
+    "ChildProcess",
+    objAbs({
+      pid: prim.num(),
+      connected: prim.bool(),
+      killed: prim.bool(),
+      exitCode: unionOf(prim.num(), nullLit()),
+      signalCode: unionOf(prim.str(), nullLit()),
+      stdin: brandOf("Writable", objAbs(streamIoMethods)),
+      stdout: brandOf("Readable", objAbs(streamIoMethods)),
+      stderr: brandOf("Readable", objAbs(streamIoMethods)),
+      on: envFn([prim.str(), callbackFnBrand], brandOf("ChildProcess")),
+      once: envFn([prim.str(), callbackFnBrand], brandOf("ChildProcess")),
+      off: envFn([prim.str(), callbackFnBrand], brandOf("ChildProcess")),
+      kill: envFn([unionOf(prim.str(), prim.num())], prim.bool(), void 0, {
+        params: ["signal?"]
+      }),
+      ref: envFn([], brandOf("ChildProcess")),
+      unref: envFn([], brandOf("ChildProcess"))
+    })
+  );
   const childProcessModule = {
     execSync: envFn(
-      [prim.str(), prim.unknown],
-      unionOf(prim.str(), bufferBrand)
+      [prim.str(), objAbs({
+        encoding: { value: prim.str(), optional: true },
+        timeout: { value: prim.num(), optional: true },
+        maxBuffer: { value: prim.num(), optional: true },
+        cwd: { value: prim.str(), optional: true }
+      })],
+      unionOf(prim.str(), bufferBrand),
+      void 0,
+      { params: ["command", "options?"] }
     ),
     execFileSync: envFn(
-      [prim.str(), arrOf(prim.str()), prim.unknown],
-      unionOf(prim.str(), bufferBrand)
+      [prim.str(), arrOf(prim.str()), objAbs({
+        encoding: { value: prim.str(), optional: true },
+        timeout: { value: prim.num(), optional: true },
+        maxBuffer: { value: prim.num(), optional: true },
+        cwd: { value: prim.str(), optional: true }
+      })],
+      unionOf(prim.str(), bufferBrand),
+      void 0,
+      { params: ["file", "args", "options?"] }
     ),
     spawnSync: envFn(
-      [prim.str(), arrOf(prim.str()), prim.unknown],
+      [prim.str(), arrOf(prim.str()), objAbs({
+        encoding: { value: prim.str(), optional: true },
+        timeout: { value: prim.num(), optional: true },
+        maxBuffer: { value: prim.num(), optional: true },
+        cwd: { value: prim.str(), optional: true }
+      })],
       objAbs({
         status: unionOf(prim.num(), nullLit()),
         stdout: unionOf(prim.str(), bufferBrand),
         stderr: unionOf(prim.str(), bufferBrand),
         error: unionOf(brandOf("Error"), undef())
-      })
+      }),
+      void 0,
+      { params: ["command", "args", "options?"] }
     ),
-    exec: envFn([prim.str(), prim.unknown], prim.unknown),
-    spawn: envFn([prim.str(), arrOf(prim.str()), prim.unknown], prim.unknown),
-    fork: envFn([prim.str(), arrOf(prim.str()), prim.unknown], prim.unknown)
+    exec: envFn([prim.str(), callbackFnBrand], childProcessInstance, void 0, {
+      params: ["command", "callback?"]
+    }),
+    execFile: envFn([prim.str(), arrOf(prim.str()), callbackFnBrand], childProcessInstance, void 0, {
+      params: ["file", "args?", "callback?"]
+    }),
+    spawn: envFn([prim.str(), arrOf(prim.str()), spawnOptions], childProcessInstance, void 0, {
+      params: ["command", "args", "options?"]
+    }),
+    fork: envFn([prim.str(), arrOf(prim.str()), spawnOptions], childProcessInstance, void 0, {
+      params: ["modulePath", "args", "options?"]
+    })
   };
   const utilModule = {
-    // Signature-level: promisify preserves fn-ness only as unknown (no generic).
-    promisify: envFn([prim.unknown], prim.unknown, void 0, { name: "util.promisify" }),
-    inspect: envFn([prim.unknown, prim.unknown], prim.str()),
-    format: envFnVariadic(prim.unknown, prim.str(), {
-      // util.format() with zero args is valid in Node.
+    // HOF：callback 风格 fn → promise 风格 fn。真实 arity 由调用点决定，
+    // 用角色 brand 表达（format 干净，不假装具体参数表）。
+    promisify: envFn([callbackFnBrand], promiseFnBrand, void 0, {
+      name: "util.promisify"
+    }),
+    // value 无约束（产品 any）；options 具体化
+    inspect: envFn(
+      [anyParam, inspectOptions],
+      prim.str(),
+      void 0,
+      { params: ["value", "options?"], name: "util.inspect" }
+    ),
+    // util.format() with zero args is valid in Node；混参无约束
+    format: envFnVariadic(anyParam, prim.str(), {
       restName: "...args",
       name: "util.format"
     }),
-    callbackify: envFn([prim.unknown], prim.unknown),
-    deprecate: envFn([prim.unknown, prim.str()], prim.unknown),
-    inherits: envFn([prim.unknown, prim.unknown], undef()),
-    isDeepStrictEqual: envFn([prim.unknown, prim.unknown], prim.bool()),
+    // HOF 与 promisify 对偶：promise fn → callback fn
+    callbackify: envFn([promiseFnBrand], callbackFnBrand),
+    deprecate: envFn([anyParam, prim.str()], anyValueBrand),
+    inherits: envFn([brandOf("Function"), brandOf("Function")], undef()),
+    isDeepStrictEqual: envFn([anyValueBrand, anyValueBrand], prim.bool()),
     types: objAbs({
-      isDate: envFn([prim.unknown], prim.bool()),
-      isRegExp: envFn([prim.unknown], prim.bool()),
-      isPromise: envFn([prim.unknown], prim.bool()),
-      isArrayBuffer: envFn([prim.unknown], prim.bool()),
-      isTypedArray: envFn([prim.unknown], prim.bool()),
-      isNativeError: envFn([prim.unknown], prim.bool()),
-      isAsyncFunction: envFn([prim.unknown], prim.bool()),
-      isGeneratorFunction: envFn([prim.unknown], prim.bool())
+      // 谓词收任意值（产品 any）；返回精确 bool
+      isDate: envFn([anyParam], prim.bool()),
+      isRegExp: envFn([anyParam], prim.bool()),
+      isPromise: envFn([anyParam], prim.bool()),
+      isArrayBuffer: envFn([anyParam], prim.bool()),
+      isTypedArray: envFn([anyParam], prim.bool()),
+      isNativeError: envFn([anyParam], prim.bool()),
+      isAsyncFunction: envFn([anyParam], prim.bool()),
+      isGeneratorFunction: envFn([anyParam], prim.bool())
     }),
     TextEncoder: envFn(
       [],
-      objAbs({ encode: envFn([prim.str()], prim.unknown) })
+      objAbs({
+        encode: envFn([prim.str()], brandOf("Uint8Array", objAbs({
+          length: prim.num(),
+          buffer: brandOf("ArrayBuffer")
+        }))),
+        encoding: prim.str()
+      })
     ),
     TextDecoder: envFn(
       [prim.str()],
-      objAbs({ decode: envFn([prim.unknown], prim.str()) })
+      objAbs({
+        decode: envFn([brandOf("Uint8Array", objAbs({ length: prim.num() }))], prim.str()),
+        encoding: prim.str()
+      }),
+      void 0,
+      { params: ["encoding?"] }
     )
   };
   const eventEmitterShape = objAbs({
-    on: envFn([prim.str(), prim.unknown], prim.unknown),
-    once: envFn([prim.str(), prim.unknown], prim.unknown),
-    off: envFn([prim.str(), prim.unknown], prim.unknown),
-    emit: envFn([prim.str()], prim.bool()),
-    addListener: envFn([prim.str(), prim.unknown], prim.unknown),
-    removeListener: envFn([prim.str(), prim.unknown], prim.unknown),
-    removeAllListeners: envFn([prim.str()], prim.unknown),
-    listeners: envFn([prim.str()], arrOf(prim.unknown)),
+    on: envFn([prim.str(), callbackFnBrand], brandOf("EventEmitter")),
+    once: envFn([prim.str(), callbackFnBrand], brandOf("EventEmitter")),
+    off: envFn([prim.str(), callbackFnBrand], brandOf("EventEmitter")),
+    emit: envFn([prim.str(), anyParam], prim.bool(), void 0, {
+      params: ["event", "...args"]
+    }),
+    addListener: envFn([prim.str(), callbackFnBrand], brandOf("EventEmitter")),
+    removeListener: envFn([prim.str(), callbackFnBrand], brandOf("EventEmitter")),
+    removeAllListeners: envFn([prim.str()], brandOf("EventEmitter")),
+    listeners: envFn([prim.str()], arrOf(callbackFnBrand)),
     listenerCount: envFn([prim.str()], prim.num()),
     eventNames: envFn([], arrOf(prim.str()))
   });
   const eventEmitterInstance = brandOf("EventEmitter", eventEmitterShape);
-  const EventEmitterCtor = envFn([prim.unknown], eventEmitterInstance, void 0, {
+  const EventEmitterCtor = envFn([eventEmitterOptions], eventEmitterInstance, void 0, {
     params: ["options?"]
   });
   const eventsModule = {
     EventEmitter: EventEmitterCtor,
+    // 事件实参依赖事件类型 — 用 EventArgs brand 留口，不假装具体元组
     once: envFn(
-      [prim.unknown, prim.str()],
-      promiseOf(arrOf(prim.unknown))
+      [eventEmitterInstance, prim.str()],
+      promiseOf(brandOf("EventArgs", arrOf(anyParam))),
+      void 0,
+      { params: ["emitter", "event"] }
     ),
-    on: envFn([prim.unknown, prim.str()], prim.unknown),
-    listenerCount: envFn([prim.unknown, prim.str()], prim.num())
-  };
-  const streamIoMethods = {
-    on: envFn([prim.str(), prim.unknown], prim.unknown),
-    once: envFn([prim.str(), prim.unknown], prim.unknown),
-    off: envFn([prim.str(), prim.unknown], prim.unknown),
-    emit: envFn([prim.str()], prim.bool()),
-    pipe: envFn([prim.unknown], prim.unknown),
-    destroy: envFn([prim.unknown], undef()),
-    read: envFn([prim.num()], prim.unknown),
-    write: envFn([unionOf(prim.str(), bufferBrand)], prim.bool()),
-    end: envFn([prim.unknown], undef()),
-    pause: envFn([], prim.unknown),
-    resume: envFn([], prim.unknown),
-    setEncoding: envFn([prim.str()], prim.unknown)
+    // AsyncIterator 由事件流驱动（limitations §2 机器回调边界）
+    on: envFn(
+      [eventEmitterInstance, prim.str()],
+      brandOf(
+        "AsyncIterator",
+        objAbs({
+          next: envFn([], promiseOf(objAbs({
+            value: arrOf(anyParam),
+            done: prim.bool()
+          }))),
+          return: envFn([], promiseOf(objAbs({
+            value: arrOf(anyParam),
+            done: prim.bool()
+          })))
+        })
+      ),
+      void 0,
+      { params: ["emitter", "event"] }
+    ),
+    listenerCount: envFn([eventEmitterInstance, prim.str()], prim.num())
   };
-  const streamCtor = (brandName) => envFn([prim.unknown], brandOf(brandName, objAbs(streamIoMethods)), void 0, {
-    params: ["options?"]
-  });
+  const streamCtor = (brandName) => envFn(
+    [objAbs({ ...streamBaseSlots, ...streamHooks })],
+    brandOf(brandName, objAbs(streamIoMethods)),
+    void 0,
+    { params: ["options?"] }
+  );
   const streamModule = {
     Readable: streamCtor("Readable"),
     Writable: streamCtor("Writable"),
     Duplex: streamCtor("Duplex"),
     Transform: streamCtor("Transform"),
-    pipeline: envFnVariadic(prim.unknown, promiseOf(undef()), {
+    pipeline: envFnVariadic(brandOf("Stream"), promiseOf(undef()), {
       restName: "...streams"
     }),
-    finished: envFn([prim.unknown], promiseOf(undef()))
+    finished: envFn([brandOf("Stream"), callbackFnBrand], promiseOf(undef()), void 0, {
+      params: ["stream", "callback?"]
+    }),
+    promises: objAbs({
+      pipeline: envFnVariadic(brandOf("Stream"), promiseOf(undef()), {
+        restName: "...streams"
+      }),
+      finished: envFn([brandOf("Stream")], promiseOf(undef()))
+    })
   };
-  const parsedQueryString = brandOf(
+  const parsedQueryString = openObjBrand(
     "ParsedQueryString",
-    objAbs({})
+    { key: prim.str(), value: unionOf(prim.str(), arrOf(prim.str())) }
   );
   const querystringModule = {
-    // sep/eq/options optional — required arity 1; labels+types render `sep?: string` etc.
+    // sep/eq/options optional — required arity 1; labels+types render typed options
     parse: envFn(
-      [prim.str(), prim.str(), prim.str(), prim.unknown],
+      [prim.str(), prim.str(), prim.str(), querystringOptions],
       parsedQueryString,
       void 0,
       { params: ["str", "sep?", "eq?", "options?"] }
     ),
     stringify: envFn(
-      [prim.unknown, prim.str(), prim.str(), prim.unknown],
+      [openObjBrand(
+        "StringifyInput",
+        { key: prim.str(), value: unionOf(prim.str(), prim.num(), prim.bool(), arrOf(unionOf(prim.str(), prim.num(), prim.bool()))) }
+      ), prim.str(), prim.str(), querystringOptions],
       prim.str(),
       void 0,
       { params: ["obj", "sep?", "eq?", "options?"] }
@@ -614,26 +980,70 @@ function defineEnv2() {
     escape: envFn([prim.str()], prim.str()),
     unescape: envFn([prim.str()], prim.str())
   };
+  const assertMessageArg = unionOf(prim.str(), brandOf("Error"));
+  const assertModule = {
+    ok: envFn(
+      [anyParam, assertMessageArg],
+      undef(),
+      void 0,
+      { params: ["value", "message?"] }
+    ),
+    strictEqual: envFn(
+      [anyParam, anyParam, assertMessageArg],
+      undef(),
+      void 0,
+      { params: ["actual", "expected", "message?"] }
+    ),
+    deepStrictEqual: envFn(
+      [anyParam, anyParam, assertMessageArg],
+      undef(),
+      void 0,
+      { params: ["actual", "expected", "message?"] }
+    ),
+    notStrictEqual: envFn(
+      [anyParam, anyParam, assertMessageArg],
+      undef(),
+      void 0,
+      { params: ["actual", "expected", "message?"] }
+    ),
+    match: envFn(
+      [prim.str(), brandOf("RegExp"), assertMessageArg],
+      undef(),
+      void 0,
+      { params: ["value", "regexp", "message?"] }
+    ),
+    fail: envFn([assertMessageArg], prim.never, void 0, {
+      params: ["message?"]
+    })
+  };
   const nodeGlobals = {
     process: objAbs({
-      env: objAbs({}),
+      // Record<string, string | undefined> 语义：开放键 + string|undefined 值
+      env: openObjBrand(
+        "Record<string, string | undefined>",
+        { key: prim.str(), value: unionOf(prim.str(), undef()) }
+      ),
       argv: arrOf(prim.str()),
       argv0: prim.str(),
       execArgv: arrOf(prim.str()),
       execPath: prim.str(),
       cwd: envFn([], prim.str()),
       chdir: envFn([prim.str()], undef()),
-      exit: envFn([prim.num()], prim.never),
+      exit: envFn([prim.num()], prim.never, void 0, { params: ["code?"] }),
+      exitCode: unionOf(prim.num(), undef()),
       pid: prim.num(),
       ppid: prim.num(),
       platform: prim.str(),
       arch: prim.str(),
       version: prim.str(),
-      versions: objAbs({}),
+      versions: openObjBrand(
+        "Record<string, string>",
+        { key: prim.str(), value: prim.str() }
+      ),
       stdout: objAbs({ write: envFn([prim.str()], prim.bool()) }),
       stderr: objAbs({ write: envFn([prim.str()], prim.bool()) }),
       stdin: objAbs({
-        on: envFn([prim.str(), prim.unknown], prim.unknown)
+        on: envFn([prim.str(), callbackFnBrand], brandOf("EventEmitter"))
       }),
       hrtime: objAbs({ bigint: envFn([], brandOf("bigint")) }),
       memoryUsage: envFn(
@@ -651,17 +1061,27 @@ function defineEnv2() {
         objAbs({ user: prim.num(), system: prim.num() })
       ),
       uptime: envFn([], prim.num()),
-      nextTick: envFn([prim.unknown], undef()),
-      on: envFn([prim.str(), prim.unknown], prim.unknown),
-      once: envFn([prim.str(), prim.unknown], prim.unknown),
-      off: envFn([prim.str(), prim.unknown], prim.unknown),
-      emit: envFn([prim.str()], prim.bool())
+      // 额外转发实参由 callback 形参吸收（CallbackFn brand 内部 variadic）
+      nextTick: envFn([callbackFnBrand], undef(), void 0, {
+        params: ["callback"]
+      }),
+      on: envFn([prim.str(), callbackFnBrand], brandOf("EventEmitter")),
+      once: envFn([prim.str(), callbackFnBrand], brandOf("EventEmitter")),
+      off: envFn([prim.str(), callbackFnBrand], brandOf("EventEmitter")),
+      emit: envFn([prim.str(), anyParam], prim.bool(), void 0, {
+        params: ["event", "...args"]
+      })
     }),
     Buffer: objAbs({
-      from: envFn([unionOf(prim.str(), arrOf(prim.num()))], bufferBrand),
-      alloc: envFn([prim.num()], bufferBrand),
+      from: envFn([unionOf(prim.str(), arrOf(prim.num()), bufferBrand)], bufferBrand),
+      alloc: envFn(
+        [prim.num(), unionOf(prim.str(), prim.num(), bufferBrand), prim.str()],
+        bufferBrand,
+        void 0,
+        { params: ["size", "fill?", "encoding?"] }
+      ),
       allocUnsafe: envFn([prim.num()], bufferBrand),
-      isBuffer: envFn([prim.unknown], prim.bool()),
+      isBuffer: envFn([anyParam], prim.bool()),
       byteLength: envFn(
         [unionOf(prim.str(), bufferBrand)],
         prim.num()
@@ -671,14 +1091,20 @@ function defineEnv2() {
     }),
     __dirname: prim.str(),
     __filename: prim.str(),
-    setTimeout: envFn([prim.unknown, prim.num()], prim.unknown),
-    setInterval: envFn([prim.unknown, prim.num()], prim.unknown),
-    setImmediate: envFn([prim.unknown], prim.unknown),
-    clearTimeout: envFn([prim.unknown], undef()),
-    clearInterval: envFn([prim.unknown], undef()),
-    clearImmediate: envFn([prim.unknown], undef()),
-    queueMicrotask: envFn([prim.unknown], undef()),
-    structuredClone: envFn([prim.unknown], prim.unknown)
+    setTimeout: envFn([callbackFnBrand, prim.num(), anyParam], brandOf("Timeout"), void 0, {
+      params: ["callback", "ms", "...args"]
+    }),
+    setInterval: envFn([callbackFnBrand, prim.num(), anyParam], brandOf("Timeout"), void 0, {
+      params: ["callback", "ms", "...args"]
+    }),
+    setImmediate: envFn([callbackFnBrand, anyParam], brandOf("Immediate"), void 0, {
+      params: ["callback", "...args"]
+    }),
+    clearTimeout: envFn([brandOf("Timeout")], undef()),
+    clearInterval: envFn([brandOf("Timeout")], undef()),
+    clearImmediate: envFn([brandOf("Immediate")], undef()),
+    queueMicrotask: envFn([callbackFnBrand], undef()),
+    structuredClone: envFn([anyParam], anyValueBrand)
   };
   const modules = {
     fs: fsModule,
@@ -702,7 +1128,9 @@ function defineEnv2() {
     stream: streamModule,
     "node:stream": streamModule,
     querystring: querystringModule,
-    "node:querystring": querystringModule
+    "node:querystring": querystringModule,
+    assert: assertModule,
+    "node:assert": assertModule
   };
   return {
     globals: { ...esEnv.globals, ...nodeGlobals },

package/dist/web.js

@@ -8,7 +8,7 @@ import {
   promiseOf,
   undef,
   unionOf
-} from "./chunk-6RZUMVN5.js";
+} from "./chunk-KRMQSDG3.js";
 
 // src/web.ts
 import { litValue, strLit, numLit } from "@nudojs/core";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nudojs/env",
-  "version": "0.4.1",
+  "version": "0.4.2-beta.0",
   "engines": {
     "node": ">=20"
   },
@@ -35,7 +35,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@nudojs/core": "2.1.0"
+    "@nudojs/core": "3.0.0-beta.0"
   },
   "scripts": {
     "build": "tsup src/es.ts src/web.ts src/node.ts --format esm --dts"