@nudojs/env 0.1.0 → 0.2.1

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# @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/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nudo Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-VBTQ36SR.js

@@ -0,0 +1,227 @@
+// src/es.ts
+import { T } from "@nudojs/core";
+function litNum(tv) {
+  return tv.kind === "literal" && typeof tv.value === "number" ? tv.value : void 0;
+}
+function litStr(tv) {
+  return tv.kind === "literal" && typeof tv.value === "string" ? tv.value : void 0;
+}
+function numImpl1(fn) {
+  return (args) => {
+    const a = litNum(args[0]);
+    return a !== void 0 ? T.literal(fn(a)) : void 0;
+  };
+}
+function numImpl2(fn) {
+  return (args) => {
+    const a = litNum(args[0]);
+    const b = litNum(args[1]);
+    return a !== void 0 && b !== void 0 ? T.literal(fn(a, b)) : void 0;
+  };
+}
+function strToStrImpl(fn) {
+  return (args) => {
+    const s = litStr(args[0]);
+    return s !== void 0 ? T.literal(fn(s)) : void 0;
+  };
+}
+function defineEnv() {
+  const voidFn = T.fnSig([T.unknown], T.undefined);
+  const consoleMethods = {};
+  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 = (args) => {
+    const v = args[0];
+    if (v.kind === "literal") {
+      try {
+        const result = JSON.stringify(v.value);
+        return result === void 0 ? T.undefined : T.literal(result);
+      } catch {
+      }
+    }
+    return void 0;
+  };
+  const parseIntImpl = (args) => {
+    const s = litStr(args[0]);
+    const radix = args[1] !== void 0 ? litNum(args[1]) : 10;
+    if (s !== void 0 && radix !== void 0) {
+      const result = parseInt(s, radix);
+      return Number.isNaN(result) ? T.literal(NaN) : T.literal(result);
+    }
+    return void 0;
+  };
+  const parseFloatImpl = (args) => {
+    const s = litStr(args[0]);
+    if (s !== void 0) {
+      const result = parseFloat(s);
+      return T.literal(result);
+    }
+    return void 0;
+  };
+  const isNaNImpl = (args) => {
+    const v = args[0];
+    if (v.kind === "literal" && typeof v.value === "number") return T.literal(Number.isNaN(v.value));
+    return void 0;
+  };
+  const isFiniteImpl = (args) => {
+    const v = args[0];
+    if (v.kind === "literal" && typeof v.value === "number") return T.literal(Number.isFinite(v.value));
+    return void 0;
+  };
+  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 void 0;
+        }),
+        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 void 0;
+        }),
+        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 void 0;
+      }),
+      // --- String ---
+      String: T.fnSig([T.unknown], T.string, T.never, (args) => {
+        const v = args[0];
+        if (v.kind === "literal" && v.value !== null && v.value !== void 0) return T.literal(String(v.value));
+        return void 0;
+      }),
+      // --- 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 void 0;
+        }),
+        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
+    }
+  };
+}
+
+export {
+  defineEnv
+};

package/dist/es.d.ts

@@ -0,0 +1,9 @@
+import { TypeValue } from '@nudojs/core';
+
+type EnvDefinition = {
+    globals: Record<string, TypeValue>;
+    modules?: Record<string, Record<string, TypeValue>>;
+};
+declare function defineEnv(): EnvDefinition;
+
+export { type EnvDefinition, defineEnv };

package/dist/es.js

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

package/dist/node.d.ts

@@ -0,0 +1,6 @@
+import { EnvDefinition } from './es.js';
+import '@nudojs/core';
+
+declare function defineEnv(): EnvDefinition;
+
+export { EnvDefinition, defineEnv };

package/dist/node.js

@@ -0,0 +1,372 @@
+import {
+  defineEnv
+} from "./chunk-VBTQ36SR.js";
+
+// src/node.ts
+import { T } from "@nudojs/core";
+import nodePath from "path";
+function litStr(tv) {
+  return tv.kind === "literal" && typeof tv.value === "string" ? tv.value : void 0;
+}
+function allLitStr(args) {
+  const result = [];
+  for (const a of args) {
+    const s = litStr(a);
+    if (s === void 0) return void 0;
+    result.push(s);
+  }
+  return result;
+}
+function defineEnv2() {
+  const esEnv = defineEnv();
+  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"))
+  });
+  const fsModule = {
+    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))
+  };
+  const strImpl1 = (fn) => (args) => {
+    const a = litStr(args[0]);
+    return a !== void 0 ? T.literal(fn(a)) : void 0;
+  };
+  const pathModule = {
+    join: T.fnSig([T.string, T.string], T.string, T.never, (args) => {
+      const strs = allLitStr(args);
+      return strs ? T.literal(nodePath.join(...strs)) : void 0;
+    }),
+    resolve: T.fnSig([T.string], T.string, T.never, (args) => {
+      const strs = allLitStr(args);
+      return strs ? T.literal(nodePath.resolve(...strs)) : void 0;
+    }),
+    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 === void 0) return void 0;
+      const ext = args[1] !== void 0 ? litStr(args[1]) : void 0;
+      return T.literal(ext !== void 0 ? 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 !== void 0 && to !== void 0 ? T.literal(nodePath.relative(from, to)) : void 0;
+    }),
+    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 !== void 0 ? T.literal(nodePath.isAbsolute(p)) : void 0;
+    }),
+    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 === void 0) return void 0;
+      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
+  };
+  const osModule = {
+    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
+  };
+  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 = {
+    URL: T.fnSig([T.string, T.string], nodeUrlObj, T.instanceOf("TypeError"), (args) => {
+      const href = litStr(args[0]);
+      const base = args[1] !== void 0 ? litStr(args[1]) : void 0;
+      if (href === void 0) return void 0;
+      try {
+        const url = base !== void 0 ? 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 void 0;
+      }
+    }),
+    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 === void 0) return void 0;
+      try {
+        const href = `file://${p.startsWith("/") ? "" : "/"}${p}`;
+        return T.object({ href: T.literal(href) });
+      } catch {
+        return void 0;
+      }
+    }),
+    format: T.fnSig([T.unknown], T.string)
+  };
+  const cryptoModule = {
+    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)
+  };
+  const childProcessModule = {
+    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)
+  };
+  const utilModule = {
+    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 = {
+    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 = {
+    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
+  };
+}
+export {
+  defineEnv2 as defineEnv
+};

package/dist/web.d.ts

@@ -0,0 +1,6 @@
+import { EnvDefinition } from './es.js';
+import '@nudojs/core';
+
+declare function defineEnv(): EnvDefinition;
+
+export { EnvDefinition, defineEnv };

package/dist/web.js

@@ -0,0 +1,306 @@
+import {
+  defineEnv
+} from "./chunk-VBTQ36SR.js";
+
+// src/web.ts
+import { T } from "@nudojs/core";
+function litStr(tv) {
+  return tv.kind === "literal" && typeof tv.value === "string" ? tv.value : void 0;
+}
+function makeURLObj(url) {
+  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))
+  });
+}
+function defineEnv2() {
+  const esEnv = defineEnv();
+  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 = {
+    // --- 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] !== void 0 ? litStr(args[1]) : void 0;
+      if (href === void 0) return void 0;
+      try {
+        const url = base !== void 0 ? new URL(href, base) : new URL(href);
+        return makeURLObj(url);
+      } catch {
+        return void 0;
+      }
+    }),
+    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 === void 0) return void 0;
+      try {
+        return T.literal(atob(s));
+      } catch {
+        return void 0;
+      }
+    }),
+    btoa: T.fnSig([T.string], T.string, T.never, (args) => {
+      const s = litStr(args[0]);
+      if (s === void 0) return void 0;
+      try {
+        return T.literal(btoa(s));
+      } catch {
+        return void 0;
+      }
+    }),
+    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 }
+  };
+}
+export {
+  defineEnv2 as defineEnv
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nudojs/env",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "ES standard, Web platform, and Node.js API type definitions for the Nudo inference engine",
   "type": "module",
   "license": "MIT",
@@ -20,9 +20,9 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@nudojs/core": "workspace:*"
+    "@nudojs/core": "0.3.0"
   },
   "scripts": {
     "build": "tsup src/es.ts src/web.ts src/node.ts --format esm --dts"
   }
-}
+}