@nudojs/env 0.2.1 → 0.2.2

package/dist/node.js

@@ -44,7 +44,18 @@ function defineEnv2() {
     subarray: T.fnSig([T.number, T.number], T.instanceOf("Buffer"))
   });
   const fsModule = {
-    readFileSync: T.fnSig([T.string, T.union(T.string, T.object({}))], T.union(T.string, BufferInstance)),
+    readFileSync: T.fnSig(
+      [T.string, T.union(T.string, T.object({}))],
+      T.union(T.string, BufferInstance),
+      T.never,
+      (args) => {
+        const enc = args[1];
+        if (!enc) return T.union(T.string, BufferInstance);
+        if (enc.kind === "literal" && typeof enc.value === "string") return T.string;
+        if (enc.kind === "primitive" && enc.type === "string") return T.string;
+        return 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),

package/package.json

@@ -1,14 +1,26 @@
 {
   "name": "@nudojs/env",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "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"
+    "./es": {
+      "types": "./dist/es.d.ts",
+      "default": "./dist/es.js"
+    },
+    "./web": {
+      "types": "./dist/web.d.ts",
+      "default": "./dist/web.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "default": "./dist/node.js"
+    }
   },
+  "files": [
+    "dist"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nudojs/nudo.git",
@@ -20,7 +32,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@nudojs/core": "0.3.0"
+    "@nudojs/core": "0.3.1"
   },
   "scripts": {
     "build": "tsup src/es.ts src/web.ts src/node.ts --format esm --dts"

package/CHANGELOG.md

@@ -1,17 +0,0 @@
-# @nudojs/env
-
-## 0.2.1
-
-### Patch Changes
-
-- Updated dependencies [5786fa5]
-- Updated dependencies [5786fa5]
-  - @nudojs/core@0.3.0
-
-## 0.2.0
-
-### Minor Changes
-
-- 0fd0718: Merge the three environment packages into one: `@nudojs/env-es`, `@nudojs/env-web`, `@nudojs/env-node` are replaced by a single `@nudojs/env` package with subpath exports `@nudojs/env/es`, `@nudojs/env/web`, `@nudojs/env/node`.
-
-  Move agent-facing tools from the standalone MCP server into the language server: `@nudojs/mcp` is removed. `@nudojs/lsp` now exposes `nudo.whatIf`, `nudo.suggestCase`, `nudo.trace`, `nudo.selectCase`, and `nudo.getActiveCases` via `workspace/executeCommand` (custom-request aliases `nudo/whatIf` etc. included), adds pull-mode diagnostics, and works on files that are not open in the editor (disk fallback). `nudo.whatIf` now actually applies the given type bindings — previously they were ignored. AI agents connect through any LSP↔MCP bridge (cclsp, mcpls, agent-lsp) or a native LSP client; an installable agent skill ships at `packages/lsp/agent-skill/SKILL.md`.

package/src/es.ts

@@ -1,252 +0,0 @@
-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

@@ -1,386 +0,0 @@
-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

@@ -1,316 +0,0 @@
-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

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