@nudojs/env 0.1.0

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@nudojs/env",
+  "version": "0.1.0",
+  "description": "ES standard, Web platform, and Node.js API type definitions for the Nudo inference engine",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    "./es": "./src/es.ts",
+    "./web": "./src/web.ts",
+    "./node": "./src/node.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nudojs/nudo.git",
+    "directory": "packages/env"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org"
+  },
+  "dependencies": {
+    "@nudojs/core": "workspace:*"
+  },
+  "scripts": {
+    "build": "tsup src/es.ts src/web.ts src/node.ts --format esm --dts"
+  }
+}

package/src/es.ts

@@ -0,0 +1,252 @@
+import { type TypeValue, type SigImpl, T } from "@nudojs/core";
+
+export type EnvDefinition = {
+  globals: Record<string, TypeValue>;
+  modules?: Record<string, Record<string, TypeValue>>;
+};
+
+function litNum(tv: TypeValue): number | undefined {
+  return tv.kind === "literal" && typeof tv.value === "number" ? tv.value : undefined;
+}
+
+function litStr(tv: TypeValue): string | undefined {
+  return tv.kind === "literal" && typeof tv.value === "string" ? tv.value : undefined;
+}
+
+function numImpl1(fn: (a: number) => number): SigImpl {
+  return (args) => {
+    const a = litNum(args[0]);
+    return a !== undefined ? T.literal(fn(a)) : undefined;
+  };
+}
+
+function numImpl2(fn: (a: number, b: number) => number): SigImpl {
+  return (args) => {
+    const a = litNum(args[0]);
+    const b = litNum(args[1]);
+    return a !== undefined && b !== undefined ? T.literal(fn(a, b)) : undefined;
+  };
+}
+
+function strToStrImpl(fn: (s: string) => string): SigImpl {
+  return (args) => {
+    const s = litStr(args[0]);
+    return s !== undefined ? T.literal(fn(s)) : undefined;
+  };
+}
+
+export function defineEnv(): EnvDefinition {
+  const voidFn = T.fnSig([T.unknown], T.undefined);
+
+  const consoleMethods: Record<string, TypeValue> = {};
+  for (const name of ["log", "error", "warn", "info", "debug", "trace", "dir", "table", "time", "timeEnd", "timeLog", "clear", "count", "countReset", "group", "groupCollapsed", "groupEnd", "assert"]) {
+    consoleMethods[name] = voidFn;
+  }
+
+  const jsonStringifyImpl: SigImpl = (args) => {
+    const v = args[0];
+    if (v.kind === "literal") {
+      try {
+        const result = JSON.stringify(v.value);
+        return result === undefined ? T.undefined : T.literal(result);
+      } catch { /* fallback */ }
+    }
+    return undefined;
+  };
+
+  const parseIntImpl: SigImpl = (args) => {
+    const s = litStr(args[0]);
+    const radix = args[1] !== undefined ? litNum(args[1]) : 10;
+    if (s !== undefined && radix !== undefined) {
+      const result = parseInt(s, radix);
+      return Number.isNaN(result) ? T.literal(NaN) : T.literal(result);
+    }
+    return undefined;
+  };
+
+  const parseFloatImpl: SigImpl = (args) => {
+    const s = litStr(args[0]);
+    if (s !== undefined) {
+      const result = parseFloat(s);
+      return T.literal(result);
+    }
+    return undefined;
+  };
+
+  const isNaNImpl: SigImpl = (args) => {
+    const v = args[0];
+    if (v.kind === "literal" && typeof v.value === "number") return T.literal(Number.isNaN(v.value));
+    return undefined;
+  };
+
+  const isFiniteImpl: SigImpl = (args) => {
+    const v = args[0];
+    if (v.kind === "literal" && typeof v.value === "number") return T.literal(Number.isFinite(v.value));
+    return undefined;
+  };
+
+  return {
+    globals: {
+      // --- JSON ---
+      JSON: T.object({
+        parse: T.fnSig([T.string], T.unknown, T.instanceOf("SyntaxError")),
+        stringify: T.fnSig([T.unknown], T.union(T.string, T.undefined), T.never, jsonStringifyImpl),
+      }),
+
+      // --- Math ---
+      Math: T.object({
+        abs: T.fnSig([T.number], T.number, T.never, numImpl1(Math.abs)),
+        ceil: T.fnSig([T.number], T.number, T.never, numImpl1(Math.ceil)),
+        floor: T.fnSig([T.number], T.number, T.never, numImpl1(Math.floor)),
+        round: T.fnSig([T.number], T.number, T.never, numImpl1(Math.round)),
+        trunc: T.fnSig([T.number], T.number, T.never, numImpl1(Math.trunc)),
+        sign: T.fnSig([T.number], T.number, T.never, numImpl1(Math.sign)),
+        max: T.fnSig([T.number, T.number], T.number, T.never, numImpl2(Math.max)),
+        min: T.fnSig([T.number, T.number], T.number, T.never, numImpl2(Math.min)),
+        pow: T.fnSig([T.number, T.number], T.number, T.never, numImpl2(Math.pow)),
+        sqrt: T.fnSig([T.number], T.number, T.never, numImpl1(Math.sqrt)),
+        cbrt: T.fnSig([T.number], T.number, T.never, numImpl1(Math.cbrt)),
+        log: T.fnSig([T.number], T.number, T.never, numImpl1(Math.log)),
+        log2: T.fnSig([T.number], T.number, T.never, numImpl1(Math.log2)),
+        log10: T.fnSig([T.number], T.number, T.never, numImpl1(Math.log10)),
+        exp: T.fnSig([T.number], T.number, T.never, numImpl1(Math.exp)),
+        random: T.fnSig([], T.number),
+        sin: T.fnSig([T.number], T.number, T.never, numImpl1(Math.sin)),
+        cos: T.fnSig([T.number], T.number, T.never, numImpl1(Math.cos)),
+        tan: T.fnSig([T.number], T.number, T.never, numImpl1(Math.tan)),
+        asin: T.fnSig([T.number], T.number, T.never, numImpl1(Math.asin)),
+        acos: T.fnSig([T.number], T.number, T.never, numImpl1(Math.acos)),
+        atan: T.fnSig([T.number], T.number, T.never, numImpl1(Math.atan)),
+        atan2: T.fnSig([T.number, T.number], T.number, T.never, numImpl2(Math.atan2)),
+        hypot: T.fnSig([T.number, T.number], T.number, T.never, numImpl2(Math.hypot)),
+        clz32: T.fnSig([T.number], T.number, T.never, numImpl1(Math.clz32)),
+        imul: T.fnSig([T.number, T.number], T.number, T.never, numImpl2(Math.imul)),
+        fround: T.fnSig([T.number], T.number, T.never, numImpl1(Math.fround)),
+        PI: T.number,
+        E: T.number,
+        LN2: T.number,
+        LN10: T.number,
+        LOG2E: T.number,
+        LOG10E: T.number,
+        SQRT2: T.number,
+        SQRT1_2: T.number,
+      }),
+
+      // --- Number ---
+      Number: T.object({
+        isFinite: T.fnSig([T.unknown], T.boolean, T.never, isFiniteImpl),
+        isInteger: T.fnSig([T.unknown], T.boolean, T.never, (args) => {
+          const v = args[0];
+          if (v.kind === "literal" && typeof v.value === "number") return T.literal(Number.isInteger(v.value));
+          return undefined;
+        }),
+        isNaN: T.fnSig([T.unknown], T.boolean, T.never, isNaNImpl),
+        isSafeInteger: T.fnSig([T.unknown], T.boolean, T.never, (args) => {
+          const v = args[0];
+          if (v.kind === "literal" && typeof v.value === "number") return T.literal(Number.isSafeInteger(v.value));
+          return undefined;
+        }),
+        parseFloat: T.fnSig([T.string], T.number, T.never, parseFloatImpl),
+        parseInt: T.fnSig([T.string], T.number, T.never, parseIntImpl),
+        MAX_SAFE_INTEGER: T.number,
+        MIN_SAFE_INTEGER: T.number,
+        MAX_VALUE: T.number,
+        MIN_VALUE: T.number,
+        POSITIVE_INFINITY: T.number,
+        NEGATIVE_INFINITY: T.number,
+        NaN: T.number,
+        EPSILON: T.number,
+      }),
+
+      // --- Boolean ---
+      Boolean: T.fnSig([T.unknown], T.boolean, T.never, (args) => {
+        const v = args[0];
+        if (v.kind === "literal") return T.literal(Boolean(v.value));
+        return undefined;
+      }),
+
+      // --- String ---
+      String: T.fnSig([T.unknown], T.string, T.never, (args) => {
+        const v = args[0];
+        if (v.kind === "literal" && v.value !== null && v.value !== undefined) return T.literal(String(v.value));
+        return undefined;
+      }),
+
+      // --- Array ---
+      Array: T.object({
+        isArray: T.fnSig([T.unknown], T.boolean, T.never, (args) => {
+          const v = args[0];
+          if (v.kind === "array" || v.kind === "tuple") return T.literal(true);
+          if (v.kind === "literal" || v.kind === "primitive" || v.kind === "object") return T.literal(false);
+          return undefined;
+        }),
+        from: T.fnSig([T.unknown], T.array(T.unknown)),
+        of: T.fnSig([T.unknown], T.array(T.unknown)),
+      }),
+
+      // --- console ---
+      console: T.object(consoleMethods),
+
+      // --- Global functions ---
+      parseInt: T.fnSig([T.string, T.number], T.number, T.never, parseIntImpl),
+      parseFloat: T.fnSig([T.string], T.number, T.never, parseFloatImpl),
+      isNaN: T.fnSig([T.unknown], T.boolean, T.never, isNaNImpl),
+      isFinite: T.fnSig([T.unknown], T.boolean, T.never, isFiniteImpl),
+      encodeURI: T.fnSig([T.string], T.string, T.never, strToStrImpl(encodeURI)),
+      decodeURI: T.fnSig([T.string], T.string, T.instanceOf("URIError"), strToStrImpl(decodeURI)),
+      encodeURIComponent: T.fnSig([T.string], T.string, T.never, strToStrImpl(encodeURIComponent)),
+      decodeURIComponent: T.fnSig([T.string], T.string, T.instanceOf("URIError"), strToStrImpl(decodeURIComponent)),
+
+      // --- Error constructors ---
+      Error: T.fnSig([T.string], T.instanceOf("Error")),
+      TypeError: T.fnSig([T.string], T.instanceOf("TypeError")),
+      RangeError: T.fnSig([T.string], T.instanceOf("RangeError")),
+      SyntaxError: T.fnSig([T.string], T.instanceOf("SyntaxError")),
+      ReferenceError: T.fnSig([T.string], T.instanceOf("ReferenceError")),
+      URIError: T.fnSig([T.string], T.instanceOf("URIError")),
+
+      // --- Promise ---
+      Promise: T.object({
+        resolve: T.fnSig([T.unknown], T.promise(T.unknown), T.never, (args) => T.promise(args[0])),
+        reject: T.fnSig([T.unknown], T.promise(T.never)),
+        all: T.fnSig([T.array(T.promise(T.unknown))], T.promise(T.array(T.unknown))),
+        allSettled: T.fnSig([T.array(T.promise(T.unknown))], T.promise(T.array(T.unknown))),
+        race: T.fnSig([T.array(T.promise(T.unknown))], T.promise(T.unknown)),
+        any: T.fnSig([T.array(T.promise(T.unknown))], T.promise(T.unknown)),
+      }),
+
+      // --- Date ---
+      Date: T.object({
+        now: T.fnSig([], T.number),
+        parse: T.fnSig([T.string], T.number),
+        UTC: T.fnSig([T.number, T.number], T.number),
+      }),
+
+      // --- Symbol ---
+      Symbol: T.fnSig([T.string], T.symbol),
+
+      // --- Reflect ---
+      Reflect: T.object({
+        apply: T.fnSig([T.unknown, T.unknown, T.array(T.unknown)], T.unknown),
+        construct: T.fnSig([T.unknown, T.array(T.unknown)], T.unknown),
+        defineProperty: T.fnSig([T.unknown, T.string, T.unknown], T.boolean),
+        deleteProperty: T.fnSig([T.unknown, T.string], T.boolean),
+        get: T.fnSig([T.unknown, T.string], T.unknown),
+        getOwnPropertyDescriptor: T.fnSig([T.unknown, T.string], T.union(T.unknown, T.undefined)),
+        getPrototypeOf: T.fnSig([T.unknown], T.union(T.unknown, T.null)),
+        has: T.fnSig([T.unknown, T.string], T.boolean),
+        isExtensible: T.fnSig([T.unknown], T.boolean),
+        ownKeys: T.fnSig([T.unknown], T.array(T.string)),
+        preventExtensions: T.fnSig([T.unknown], T.boolean),
+        set: T.fnSig([T.unknown, T.string, T.unknown], T.boolean),
+        setPrototypeOf: T.fnSig([T.unknown, T.unknown], T.boolean),
+      }),
+
+      // --- globalThis ---
+      globalThis: T.unknown,
+      undefined: T.undefined,
+      NaN: T.number,
+      Infinity: T.number,
+    },
+  };
+}

package/src/node.ts

@@ -0,0 +1,386 @@
+import { type TypeValue, type SigImpl, T } from "@nudojs/core";
+import { type EnvDefinition, defineEnv as defineEsEnv } from "./es.ts";
+import nodePath from "node:path";
+
+export type { EnvDefinition };
+
+function litStr(tv: TypeValue): string | undefined {
+  return tv.kind === "literal" && typeof tv.value === "string" ? tv.value : undefined;
+}
+
+function allLitStr(args: TypeValue[]): string[] | undefined {
+  const result: string[] = [];
+  for (const a of args) {
+    const s = litStr(a);
+    if (s === undefined) return undefined;
+    result.push(s);
+  }
+  return result;
+}
+
+export function defineEnv(): EnvDefinition {
+  const esEnv = defineEsEnv();
+
+  const BufferInstance = T.instanceOf("Buffer", {
+    toString: T.fnSig([T.string], T.string),
+    toJSON: T.fnSig([], T.object({ type: T.string, data: T.array(T.number) })),
+    length: T.number,
+    slice: T.fnSig([T.number, T.number], T.instanceOf("Buffer")),
+    copy: T.fnSig([T.unknown, T.number, T.number, T.number], T.number),
+    write: T.fnSig([T.string, T.number, T.number, T.string], T.number),
+    readUInt8: T.fnSig([T.number], T.number),
+    readUInt16BE: T.fnSig([T.number], T.number),
+    readUInt16LE: T.fnSig([T.number], T.number),
+    readUInt32BE: T.fnSig([T.number], T.number),
+    readUInt32LE: T.fnSig([T.number], T.number),
+    readInt8: T.fnSig([T.number], T.number),
+    readInt16BE: T.fnSig([T.number], T.number),
+    readInt16LE: T.fnSig([T.number], T.number),
+    readInt32BE: T.fnSig([T.number], T.number),
+    readInt32LE: T.fnSig([T.number], T.number),
+    includes: T.fnSig([T.union(T.string, T.number)], T.boolean),
+    indexOf: T.fnSig([T.union(T.string, T.number)], T.number),
+    fill: T.fnSig([T.union(T.string, T.number)], T.instanceOf("Buffer")),
+    equals: T.fnSig([T.instanceOf("Buffer")], T.boolean),
+    compare: T.fnSig([T.instanceOf("Buffer")], T.number),
+    subarray: T.fnSig([T.number, T.number], T.instanceOf("Buffer")),
+  });
+
+  // --- fs module ---
+  const fsModule: Record<string, TypeValue> = {
+    readFileSync: T.fnSig([T.string, T.union(T.string, T.object({}))], T.union(T.string, BufferInstance)),
+    writeFileSync: T.fnSig([T.string, T.union(T.string, BufferInstance)], T.undefined),
+    appendFileSync: T.fnSig([T.string, T.union(T.string, BufferInstance)], T.undefined),
+    existsSync: T.fnSig([T.string], T.boolean),
+    mkdirSync: T.fnSig([T.string, T.unknown], T.union(T.string, T.undefined)),
+    rmdirSync: T.fnSig([T.string], T.undefined),
+    rmSync: T.fnSig([T.string, T.unknown], T.undefined),
+    unlinkSync: T.fnSig([T.string], T.undefined),
+    renameSync: T.fnSig([T.string, T.string], T.undefined),
+    copyFileSync: T.fnSig([T.string, T.string], T.undefined),
+    statSync: T.fnSig([T.string], T.object({
+      isFile: T.fnSig([], T.boolean),
+      isDirectory: T.fnSig([], T.boolean),
+      isSymbolicLink: T.fnSig([], T.boolean),
+      size: T.number,
+      mtime: T.unknown,
+      ctime: T.unknown,
+      atime: T.unknown,
+      birthtime: T.unknown,
+      mode: T.number,
+      uid: T.number,
+      gid: T.number,
+    })),
+    readdirSync: T.fnSig([T.string, T.unknown], T.array(T.union(T.string, T.unknown))),
+    realpathSync: T.fnSig([T.string], T.string),
+    readlinkSync: T.fnSig([T.string], T.string),
+    symlinkSync: T.fnSig([T.string, T.string], T.undefined),
+    chmodSync: T.fnSig([T.string, T.number], T.undefined),
+    chownSync: T.fnSig([T.string, T.number, T.number], T.undefined),
+    accessSync: T.fnSig([T.string, T.number], T.undefined),
+    readFile: T.fnSig([T.string, T.unknown], T.promise(T.union(T.string, BufferInstance))),
+    writeFile: T.fnSig([T.string, T.union(T.string, BufferInstance)], T.promise(T.undefined)),
+    mkdir: T.fnSig([T.string, T.unknown], T.promise(T.union(T.string, T.undefined))),
+    rm: T.fnSig([T.string, T.unknown], T.promise(T.undefined)),
+    stat: T.fnSig([T.string], T.promise(T.unknown)),
+    readdir: T.fnSig([T.string, T.unknown], T.promise(T.array(T.unknown))),
+    access: T.fnSig([T.string, T.number], T.promise(T.undefined)),
+  };
+
+  // --- path module ---
+  const strImpl1 = (fn: (a: string) => string): SigImpl => (args) => {
+    const a = litStr(args[0]);
+    return a !== undefined ? T.literal(fn(a)) : undefined;
+  };
+
+  const pathModule: Record<string, TypeValue> = {
+    join: T.fnSig([T.string, T.string], T.string, T.never, (args) => {
+      const strs = allLitStr(args);
+      return strs ? T.literal(nodePath.join(...strs)) : undefined;
+    }),
+    resolve: T.fnSig([T.string], T.string, T.never, (args) => {
+      const strs = allLitStr(args);
+      return strs ? T.literal(nodePath.resolve(...strs)) : undefined;
+    }),
+    dirname: T.fnSig([T.string], T.string, T.never, strImpl1(nodePath.dirname)),
+    basename: T.fnSig([T.string, T.string], T.string, T.never, (args) => {
+      const p = litStr(args[0]);
+      if (p === undefined) return undefined;
+      const ext = args[1] !== undefined ? litStr(args[1]) : undefined;
+      return T.literal(ext !== undefined ? nodePath.basename(p, ext) : nodePath.basename(p));
+    }),
+    extname: T.fnSig([T.string], T.string, T.never, strImpl1(nodePath.extname)),
+    relative: T.fnSig([T.string, T.string], T.string, T.never, (args) => {
+      const from = litStr(args[0]);
+      const to = litStr(args[1]);
+      return from !== undefined && to !== undefined ? T.literal(nodePath.relative(from, to)) : undefined;
+    }),
+    normalize: T.fnSig([T.string], T.string, T.never, strImpl1(nodePath.normalize)),
+    isAbsolute: T.fnSig([T.string], T.boolean, T.never, (args) => {
+      const p = litStr(args[0]);
+      return p !== undefined ? T.literal(nodePath.isAbsolute(p)) : undefined;
+    }),
+    parse: T.fnSig([T.string], T.object({
+      root: T.string,
+      dir: T.string,
+      base: T.string,
+      ext: T.string,
+      name: T.string,
+    }), T.never, (args) => {
+      const p = litStr(args[0]);
+      if (p === undefined) return undefined;
+      const parsed = nodePath.parse(p);
+      return T.object({
+        root: T.literal(parsed.root),
+        dir: T.literal(parsed.dir),
+        base: T.literal(parsed.base),
+        ext: T.literal(parsed.ext),
+        name: T.literal(parsed.name),
+      });
+    }),
+    format: T.fnSig([T.object({})], T.string),
+    sep: T.string,
+    delimiter: T.string,
+    posix: T.unknown,
+    win32: T.unknown,
+  };
+
+  // --- os module ---
+  const osModule: Record<string, TypeValue> = {
+    platform: T.fnSig([], T.string),
+    arch: T.fnSig([], T.string),
+    type: T.fnSig([], T.string),
+    release: T.fnSig([], T.string),
+    hostname: T.fnSig([], T.string),
+    homedir: T.fnSig([], T.string),
+    tmpdir: T.fnSig([], T.string),
+    cpus: T.fnSig([], T.array(T.object({
+      model: T.string,
+      speed: T.number,
+    }))),
+    totalmem: T.fnSig([], T.number),
+    freemem: T.fnSig([], T.number),
+    uptime: T.fnSig([], T.number),
+    loadavg: T.fnSig([], T.tuple([T.number, T.number, T.number])),
+    networkInterfaces: T.fnSig([], T.unknown),
+    userInfo: T.fnSig([], T.object({
+      username: T.string,
+      uid: T.number,
+      gid: T.number,
+      shell: T.union(T.string, T.null),
+      homedir: T.string,
+    })),
+    EOL: T.string,
+  };
+
+  // --- url module ---
+  const nodeUrlObj = T.object({
+    href: T.string,
+    origin: T.string,
+    protocol: T.string,
+    username: T.string,
+    password: T.string,
+    host: T.string,
+    hostname: T.string,
+    port: T.string,
+    pathname: T.string,
+    search: T.string,
+    hash: T.string,
+    toString: T.fnSig([], T.string),
+    toJSON: T.fnSig([], T.string),
+  });
+
+  const urlModule: Record<string, TypeValue> = {
+    URL: T.fnSig([T.string, T.string], nodeUrlObj, T.instanceOf("TypeError"), (args) => {
+      const href = litStr(args[0]);
+      const base = args[1] !== undefined ? litStr(args[1]) : undefined;
+      if (href === undefined) return undefined;
+      try {
+        const url = base !== undefined ? new URL(href, base) : new URL(href);
+        return T.object({
+          href: T.literal(url.href),
+          origin: T.literal(url.origin),
+          protocol: T.literal(url.protocol),
+          username: T.literal(url.username),
+          password: T.literal(url.password),
+          host: T.literal(url.host),
+          hostname: T.literal(url.hostname),
+          port: T.literal(url.port),
+          pathname: T.literal(url.pathname),
+          search: T.literal(url.search),
+          hash: T.literal(url.hash),
+          toString: T.fnSig([], T.string, T.never, () => T.literal(url.href)),
+          toJSON: T.fnSig([], T.string, T.never, () => T.literal(url.href)),
+        });
+      } catch { return undefined; }
+    }),
+    URLSearchParams: T.fnSig([T.unknown], T.object({
+      get: T.fnSig([T.string], T.union(T.string, T.null)),
+      has: T.fnSig([T.string], T.boolean),
+      set: T.fnSig([T.string, T.string], T.undefined),
+      append: T.fnSig([T.string, T.string], T.undefined),
+      delete: T.fnSig([T.string], T.undefined),
+      toString: T.fnSig([], T.string),
+    })),
+    fileURLToPath: T.fnSig([T.string], T.string, T.never, strImpl1((s) => {
+      try { return new URL(s).pathname; } catch { return s; }
+    })),
+    pathToFileURL: T.fnSig([T.string], T.object({ href: T.string }), T.never, (args) => {
+      const p = litStr(args[0]);
+      if (p === undefined) return undefined;
+      try {
+        const href = `file://${p.startsWith("/") ? "" : "/"}${p}`;
+        return T.object({ href: T.literal(href) });
+      } catch { return undefined; }
+    }),
+    format: T.fnSig([T.unknown], T.string),
+  };
+
+  // --- crypto module ---
+  const cryptoModule: Record<string, TypeValue> = {
+    randomBytes: T.fnSig([T.number], BufferInstance),
+    randomUUID: T.fnSig([], T.string),
+    randomInt: T.fnSig([T.number, T.number], T.number),
+    createHash: T.fnSig([T.string], T.object({
+      update: T.fnSig([T.union(T.string, BufferInstance)], T.unknown),
+      digest: T.fnSig([T.string], T.union(T.string, BufferInstance)),
+    })),
+    createHmac: T.fnSig([T.string, T.union(T.string, BufferInstance)], T.object({
+      update: T.fnSig([T.union(T.string, BufferInstance)], T.unknown),
+      digest: T.fnSig([T.string], T.union(T.string, BufferInstance)),
+    })),
+    createCipheriv: T.fnSig([T.string, T.unknown, T.unknown], T.unknown),
+    createDecipheriv: T.fnSig([T.string, T.unknown, T.unknown], T.unknown),
+    pbkdf2Sync: T.fnSig([T.string, T.string, T.number, T.number, T.string], BufferInstance),
+    scryptSync: T.fnSig([T.string, T.string, T.number], BufferInstance),
+    timingSafeEqual: T.fnSig([BufferInstance, BufferInstance], T.boolean),
+  };
+
+  // --- child_process module ---
+  const childProcessModule: Record<string, TypeValue> = {
+    execSync: T.fnSig([T.string, T.unknown], T.union(T.string, BufferInstance)),
+    execFileSync: T.fnSig([T.string, T.array(T.string), T.unknown], T.union(T.string, BufferInstance)),
+    spawnSync: T.fnSig([T.string, T.array(T.string), T.unknown], T.object({
+      status: T.union(T.number, T.null),
+      stdout: T.union(T.string, BufferInstance),
+      stderr: T.union(T.string, BufferInstance),
+      error: T.union(T.instanceOf("Error"), T.undefined),
+    })),
+    exec: T.fnSig([T.string, T.unknown], T.unknown),
+    spawn: T.fnSig([T.string, T.array(T.string), T.unknown], T.unknown),
+    fork: T.fnSig([T.string, T.array(T.string), T.unknown], T.unknown),
+  };
+
+  // --- util module ---
+  const utilModule: Record<string, TypeValue> = {
+    promisify: T.fnSig([T.unknown], T.unknown),
+    inspect: T.fnSig([T.unknown, T.unknown], T.string),
+    format: T.fnSig([T.string], T.string),
+    types: T.object({
+      isDate: T.fnSig([T.unknown], T.boolean),
+      isRegExp: T.fnSig([T.unknown], T.boolean),
+      isPromise: T.fnSig([T.unknown], T.boolean),
+      isArrayBuffer: T.fnSig([T.unknown], T.boolean),
+      isTypedArray: T.fnSig([T.unknown], T.boolean),
+    }),
+    TextEncoder: T.fnSig([], T.object({
+      encode: T.fnSig([T.string], T.unknown),
+    })),
+    TextDecoder: T.fnSig([T.string], T.object({
+      decode: T.fnSig([T.unknown], T.string),
+    })),
+  };
+
+  const nodeGlobals: Record<string, TypeValue> = {
+    process: T.object({
+      env: T.object({}),
+      argv: T.array(T.string),
+      argv0: T.string,
+      execArgv: T.array(T.string),
+      execPath: T.string,
+      cwd: T.fnSig([], T.string),
+      chdir: T.fnSig([T.string], T.undefined),
+      exit: T.fnSig([T.number], T.never),
+      pid: T.number,
+      ppid: T.number,
+      platform: T.string,
+      arch: T.string,
+      version: T.string,
+      versions: T.object({}),
+      stdout: T.object({ write: T.fnSig([T.string], T.boolean) }),
+      stderr: T.object({ write: T.fnSig([T.string], T.boolean) }),
+      stdin: T.object({ on: T.fnSig([T.string, T.unknown], T.unknown) }),
+      hrtime: T.object({
+        bigint: T.fnSig([], T.bigint),
+      }),
+      memoryUsage: T.fnSig([], T.object({
+        rss: T.number,
+        heapTotal: T.number,
+        heapUsed: T.number,
+        external: T.number,
+        arrayBuffers: T.number,
+      })),
+      cpuUsage: T.fnSig([], T.object({ user: T.number, system: T.number })),
+      uptime: T.fnSig([], T.number),
+      nextTick: T.fnSig([T.unknown], T.undefined),
+      on: T.fnSig([T.string, T.unknown], T.unknown),
+      once: T.fnSig([T.string, T.unknown], T.unknown),
+      off: T.fnSig([T.string, T.unknown], T.unknown),
+      emit: T.fnSig([T.string], T.boolean),
+    }),
+
+    Buffer: T.object({
+      from: T.fnSig([T.union(T.string, T.array(T.number))], BufferInstance),
+      alloc: T.fnSig([T.number], BufferInstance),
+      allocUnsafe: T.fnSig([T.number], BufferInstance),
+      isBuffer: T.fnSig([T.unknown], T.boolean),
+      byteLength: T.fnSig([T.union(T.string, BufferInstance)], T.number),
+      concat: T.fnSig([T.array(BufferInstance)], BufferInstance),
+      compare: T.fnSig([BufferInstance, BufferInstance], T.number),
+    }),
+
+    __dirname: T.string,
+    __filename: T.string,
+
+    setTimeout: T.fnSig([T.unknown, T.number], T.unknown),
+    setInterval: T.fnSig([T.unknown, T.number], T.unknown),
+    setImmediate: T.fnSig([T.unknown], T.unknown),
+    clearTimeout: T.fnSig([T.unknown], T.undefined),
+    clearInterval: T.fnSig([T.unknown], T.undefined),
+    clearImmediate: T.fnSig([T.unknown], T.undefined),
+    queueMicrotask: T.fnSig([T.unknown], T.undefined),
+
+    structuredClone: T.fnSig([T.unknown], T.unknown),
+  };
+
+  const modules: Record<string, Record<string, TypeValue>> = {
+    fs: fsModule,
+    "node:fs": fsModule,
+    "node:fs/promises": {
+      readFile: fsModule.readFile,
+      writeFile: fsModule.writeFile,
+      mkdir: fsModule.mkdir,
+      rm: fsModule.rm,
+      stat: fsModule.stat,
+      readdir: fsModule.readdir,
+      access: fsModule.access,
+    },
+    path: pathModule,
+    "node:path": pathModule,
+    os: osModule,
+    "node:os": osModule,
+    url: urlModule,
+    "node:url": urlModule,
+    crypto: cryptoModule,
+    "node:crypto": cryptoModule,
+    child_process: childProcessModule,
+    "node:child_process": childProcessModule,
+    util: utilModule,
+    "node:util": utilModule,
+  };
+
+  return {
+    globals: { ...esEnv.globals, ...nodeGlobals },
+    modules,
+  };
+}

package/src/web.ts

@@ -0,0 +1,316 @@
+import { type TypeValue, type SigImpl, T } from "@nudojs/core";
+import { type EnvDefinition, defineEnv as defineEsEnv } from "./es.ts";
+
+export type { EnvDefinition };
+
+function litStr(tv: TypeValue): string | undefined {
+  return tv.kind === "literal" && typeof tv.value === "string" ? tv.value : undefined;
+}
+
+function makeURLObj(url: URL): TypeValue {
+  return T.object({
+    href: T.literal(url.href),
+    origin: T.literal(url.origin),
+    protocol: T.literal(url.protocol),
+    username: T.literal(url.username),
+    password: T.literal(url.password),
+    host: T.literal(url.host),
+    hostname: T.literal(url.hostname),
+    port: T.literal(url.port),
+    pathname: T.literal(url.pathname),
+    search: T.literal(url.search),
+    searchParams: T.object({
+      append: T.fnSig([T.string, T.string], T.undefined),
+      delete: T.fnSig([T.string], T.undefined),
+      get: T.fnSig([T.string], T.union(T.string, T.null)),
+      getAll: T.fnSig([T.string], T.array(T.string)),
+      has: T.fnSig([T.string], T.boolean),
+      set: T.fnSig([T.string, T.string], T.undefined),
+      sort: T.fnSig([], T.undefined),
+      toString: T.fnSig([], T.string, T.never, () => T.literal(url.searchParams.toString())),
+      entries: T.fnSig([], T.unknown),
+      keys: T.fnSig([], T.unknown),
+      values: T.fnSig([], T.unknown),
+      forEach: T.fnSig([T.unknown], T.undefined),
+      size: T.literal(url.searchParams.size),
+    }),
+    hash: T.literal(url.hash),
+    toString: T.fnSig([], T.string, T.never, () => T.literal(url.href)),
+    toJSON: T.fnSig([], T.string, T.never, () => T.literal(url.href)),
+  });
+}
+
+export function defineEnv(): EnvDefinition {
+  const esEnv = defineEsEnv();
+
+  const Headers = T.object({
+    append: T.fnSig([T.string, T.string], T.undefined),
+    delete: T.fnSig([T.string], T.undefined),
+    get: T.fnSig([T.string], T.union(T.string, T.null)),
+    has: T.fnSig([T.string], T.boolean),
+    set: T.fnSig([T.string, T.string], T.undefined),
+    forEach: T.fnSig([T.unknown], T.undefined),
+    entries: T.fnSig([], T.unknown),
+    keys: T.fnSig([], T.unknown),
+    values: T.fnSig([], T.unknown),
+  });
+
+  const Body = {
+    json: T.fnSig([], T.promise(T.unknown)),
+    text: T.fnSig([], T.promise(T.string)),
+    arrayBuffer: T.fnSig([], T.promise(T.unknown)),
+    blob: T.fnSig([], T.promise(T.unknown)),
+    formData: T.fnSig([], T.promise(T.unknown)),
+    clone: T.fnSig([], T.unknown),
+    ok: T.boolean,
+    status: T.number,
+    statusText: T.string,
+    headers: Headers,
+    url: T.string,
+    redirected: T.boolean,
+    type: T.string,
+    bodyUsed: T.boolean,
+  };
+
+  const Response = T.object(Body);
+
+  const Request = T.object({
+    ...Body,
+    method: T.string,
+    url: T.string,
+    headers: Headers,
+    body: T.union(T.unknown, T.null),
+    mode: T.string,
+    credentials: T.string,
+    cache: T.string,
+    redirect: T.string,
+    referrer: T.string,
+    integrity: T.string,
+    signal: T.unknown,
+    clone: T.fnSig([], T.unknown),
+  });
+
+  const URLSearchParams = T.object({
+    append: T.fnSig([T.string, T.string], T.undefined),
+    delete: T.fnSig([T.string], T.undefined),
+    get: T.fnSig([T.string], T.union(T.string, T.null)),
+    getAll: T.fnSig([T.string], T.array(T.string)),
+    has: T.fnSig([T.string], T.boolean),
+    set: T.fnSig([T.string, T.string], T.undefined),
+    sort: T.fnSig([], T.undefined),
+    toString: T.fnSig([], T.string),
+    entries: T.fnSig([], T.unknown),
+    keys: T.fnSig([], T.unknown),
+    values: T.fnSig([], T.unknown),
+    forEach: T.fnSig([T.unknown], T.undefined),
+    size: T.number,
+  });
+
+  const URLObj = T.object({
+    href: T.string,
+    origin: T.string,
+    protocol: T.string,
+    username: T.string,
+    password: T.string,
+    host: T.string,
+    hostname: T.string,
+    port: T.string,
+    pathname: T.string,
+    search: T.string,
+    searchParams: URLSearchParams,
+    hash: T.string,
+    toString: T.fnSig([], T.string),
+    toJSON: T.fnSig([], T.string),
+  });
+
+  const AbortController = T.object({
+    signal: T.unknown,
+    abort: T.fnSig([], T.undefined),
+  });
+
+  const Storage = T.object({
+    getItem: T.fnSig([T.string], T.union(T.string, T.null)),
+    setItem: T.fnSig([T.string, T.string], T.undefined),
+    removeItem: T.fnSig([T.string], T.undefined),
+    clear: T.fnSig([], T.undefined),
+    key: T.fnSig([T.number], T.union(T.string, T.null)),
+    length: T.number,
+  });
+
+  const EventTarget = T.object({
+    addEventListener: T.fnSig([T.string, T.unknown], T.undefined),
+    removeEventListener: T.fnSig([T.string, T.unknown], T.undefined),
+    dispatchEvent: T.fnSig([T.unknown], T.boolean),
+  });
+
+  const webGlobals: Record<string, TypeValue> = {
+    // --- Fetch API ---
+    fetch: T.fnSig([T.union(T.string, Request)], T.promise(Response)),
+    Request: T.fnSig([T.string, T.unknown], Request),
+    Response: T.object({
+      json: T.fnSig([T.unknown], Response),
+      redirect: T.fnSig([T.string, T.number], Response),
+      error: T.fnSig([], Response),
+    }),
+    Headers: T.fnSig([T.unknown], Headers),
+
+    // --- URL ---
+    URL: T.fnSig([T.string, T.string], URLObj, T.instanceOf("TypeError"), (args) => {
+      const href = litStr(args[0]);
+      const base = args[1] !== undefined ? litStr(args[1]) : undefined;
+      if (href === undefined) return undefined;
+      try {
+        const url = base !== undefined ? new URL(href, base) : new URL(href);
+        return makeURLObj(url);
+      } catch { return undefined; }
+    }),
+    URLSearchParams: T.fnSig([T.unknown], URLSearchParams),
+
+    // --- Timers ---
+    setTimeout: T.fnSig([T.unknown, T.number], T.number),
+    setInterval: T.fnSig([T.unknown, T.number], T.number),
+    clearTimeout: T.fnSig([T.number], T.undefined),
+    clearInterval: T.fnSig([T.number], T.undefined),
+    queueMicrotask: T.fnSig([T.unknown], T.undefined),
+    requestAnimationFrame: T.fnSig([T.unknown], T.number),
+    cancelAnimationFrame: T.fnSig([T.number], T.undefined),
+
+    // --- Abort ---
+    AbortController: T.fnSig([], AbortController),
+    AbortSignal: T.object({
+      abort: T.fnSig([], T.unknown),
+      timeout: T.fnSig([T.number], T.unknown),
+    }),
+
+    // --- Encoding ---
+    atob: T.fnSig([T.string], T.string, T.never, (args) => {
+      const s = litStr(args[0]);
+      if (s === undefined) return undefined;
+      try { return T.literal(atob(s)); } catch { return undefined; }
+    }),
+    btoa: T.fnSig([T.string], T.string, T.never, (args) => {
+      const s = litStr(args[0]);
+      if (s === undefined) return undefined;
+      try { return T.literal(btoa(s)); } catch { return undefined; }
+    }),
+    TextEncoder: T.fnSig([], T.object({
+      encode: T.fnSig([T.string], T.unknown),
+      encodeInto: T.fnSig([T.string, T.unknown], T.unknown),
+    })),
+    TextDecoder: T.fnSig([T.string], T.object({
+      decode: T.fnSig([T.unknown], T.string),
+      encoding: T.string,
+      fatal: T.boolean,
+      ignoreBOM: T.boolean,
+    })),
+
+    // --- Storage ---
+    localStorage: Storage,
+    sessionStorage: Storage,
+
+    // --- DOM (minimal) ---
+    document: T.object({
+      getElementById: T.fnSig([T.string], T.union(T.unknown, T.null)),
+      querySelector: T.fnSig([T.string], T.union(T.unknown, T.null)),
+      querySelectorAll: T.fnSig([T.string], T.unknown),
+      createElement: T.fnSig([T.string], T.unknown),
+      createTextNode: T.fnSig([T.string], T.unknown),
+      body: T.unknown,
+      head: T.unknown,
+      documentElement: T.unknown,
+      title: T.string,
+      cookie: T.string,
+      readyState: T.string,
+      addEventListener: T.fnSig([T.string, T.unknown], T.undefined),
+      removeEventListener: T.fnSig([T.string, T.unknown], T.undefined),
+    }),
+
+    // --- Window ---
+    window: T.unknown,
+    self: T.unknown,
+    navigator: T.object({
+      userAgent: T.string,
+      language: T.string,
+      languages: T.array(T.string),
+      onLine: T.boolean,
+      platform: T.string,
+      clipboard: T.object({
+        readText: T.fnSig([], T.promise(T.string)),
+        writeText: T.fnSig([T.string], T.promise(T.undefined)),
+      }),
+    }),
+    location: T.object({
+      href: T.string,
+      origin: T.string,
+      protocol: T.string,
+      host: T.string,
+      hostname: T.string,
+      port: T.string,
+      pathname: T.string,
+      search: T.string,
+      hash: T.string,
+      assign: T.fnSig([T.string], T.undefined),
+      replace: T.fnSig([T.string], T.undefined),
+      reload: T.fnSig([], T.undefined),
+    }),
+    history: T.object({
+      length: T.number,
+      state: T.unknown,
+      back: T.fnSig([], T.undefined),
+      forward: T.fnSig([], T.undefined),
+      go: T.fnSig([T.number], T.undefined),
+      pushState: T.fnSig([T.unknown, T.string, T.string], T.undefined),
+      replaceState: T.fnSig([T.unknown, T.string, T.string], T.undefined),
+    }),
+
+    // --- Events ---
+    EventTarget: T.fnSig([], EventTarget),
+    Event: T.fnSig([T.string, T.unknown], T.object({
+      type: T.string,
+      target: T.union(T.unknown, T.null),
+      currentTarget: T.union(T.unknown, T.null),
+      bubbles: T.boolean,
+      cancelable: T.boolean,
+      defaultPrevented: T.boolean,
+      preventDefault: T.fnSig([], T.undefined),
+      stopPropagation: T.fnSig([], T.undefined),
+      stopImmediatePropagation: T.fnSig([], T.undefined),
+    })),
+    CustomEvent: T.fnSig([T.string, T.unknown], T.unknown),
+
+    // --- Structured clone ---
+    structuredClone: T.fnSig([T.unknown], T.unknown),
+
+    // --- Performance ---
+    performance: T.object({
+      now: T.fnSig([], T.number),
+      mark: T.fnSig([T.string], T.undefined),
+      measure: T.fnSig([T.string, T.string, T.string], T.unknown),
+      getEntriesByName: T.fnSig([T.string], T.array(T.unknown)),
+      getEntriesByType: T.fnSig([T.string], T.array(T.unknown)),
+      clearMarks: T.fnSig([], T.undefined),
+      clearMeasures: T.fnSig([], T.undefined),
+      timeOrigin: T.number,
+    }),
+
+    // --- Crypto ---
+    crypto: T.object({
+      randomUUID: T.fnSig([], T.string),
+      getRandomValues: T.fnSig([T.unknown], T.unknown),
+      subtle: T.object({
+        digest: T.fnSig([T.string, T.unknown], T.promise(T.unknown)),
+        encrypt: T.fnSig([T.unknown, T.unknown, T.unknown], T.promise(T.unknown)),
+        decrypt: T.fnSig([T.unknown, T.unknown, T.unknown], T.promise(T.unknown)),
+        sign: T.fnSig([T.unknown, T.unknown, T.unknown], T.promise(T.unknown)),
+        verify: T.fnSig([T.unknown, T.unknown, T.unknown, T.unknown], T.promise(T.boolean)),
+        generateKey: T.fnSig([T.unknown, T.boolean, T.array(T.string)], T.promise(T.unknown)),
+        importKey: T.fnSig([T.string, T.unknown, T.unknown, T.boolean, T.array(T.string)], T.promise(T.unknown)),
+        exportKey: T.fnSig([T.string, T.unknown], T.promise(T.unknown)),
+      }),
+    }),
+  };
+
+  return {
+    globals: { ...esEnv.globals, ...webGlobals },
+  };
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"],
+  "references": [
+    { "path": "../core" }
+  ]
+}