eser 4.0.6 → 4.0.8

package/eser.js

@@ -55,89 +55,108 @@ var init_types = __esm({
 });
 
 // pkg/@eser/standards/runtime/detect.ts
-var detectRuntime, getRuntimeVersion, isDeno, isNode, isBun, isWorkerd, isBrowser, isServer, isEdge;
+var globalRef, isWorkerdEnv, isBrowserEnv, detectRuntime, versionGetters, getRuntimeVersion, isDeno, isNode, isBun, isWorkerd, isBrowser, SERVER_RUNTIMES, isServer, isEdge;
 var init_detect = __esm({
   "pkg/@eser/standards/runtime/detect.ts"() {
+    globalRef = globalThis;
+    isWorkerdEnv = () => typeof globalRef.caches !== "undefined" && typeof globalRef.Request !== "undefined" && typeof globalRef.Response !== "undefined" && typeof globalRef.window === "undefined" && typeof globalRef.document === "undefined";
+    isBrowserEnv = () => typeof globalRef.window !== "undefined" || typeof globalRef.document !== "undefined";
     detectRuntime = () => {
-      if (typeof globalThis !== "undefined") {
-        if (typeof globalThis.Bun !== "undefined") {
-          return "bun";
-        }
-        if (typeof globalThis.Deno !== "undefined") {
-          return "deno";
-        }
-        const proc = globalThis.process;
-        if (proc?.versions?.node && !proc?.versions?.bun) {
-          return "node";
-        }
-        const g = globalThis;
-        if (typeof g.caches !== "undefined" && typeof g.Request !== "undefined" && typeof g.Response !== "undefined" && typeof g.window === "undefined" && typeof g.document === "undefined") {
-          return "workerd";
-        }
-        if (typeof g.window !== "undefined" || typeof g.document !== "undefined") {
-          return "browser";
-        }
-      }
+      if (typeof globalThis === "undefined") return "unknown";
+      if (typeof globalRef.Bun !== "undefined") return "bun";
+      if (typeof globalRef.Deno !== "undefined") return "deno";
+      const proc = globalRef.process;
+      if (proc?.versions?.node && !proc?.versions?.bun) return "node";
+      if (isWorkerdEnv()) return "workerd";
+      if (isBrowserEnv()) return "browser";
       return "unknown";
     };
-    getRuntimeVersion = () => {
-      const runtime2 = detectRuntime();
-      switch (runtime2) {
-        case "deno": {
-          return globalThis.Deno?.version?.deno ?? "unknown";
-        }
-        case "bun": {
-          return globalThis.Bun?.version ?? "unknown";
-        }
-        case "node": {
-          return globalThis.process?.versions?.node ?? "unknown";
-        }
-        case "workerd": {
-          return "unknown";
-        }
-        case "browser": {
-          return globalThis.navigator?.userAgent ?? "unknown";
-        }
-        default: {
-          return "unknown";
-        }
-      }
+    versionGetters = {
+      deno: () => globalRef.Deno?.version?.deno ?? "unknown",
+      bun: () => globalRef.Bun?.version ?? "unknown",
+      node: () => globalRef.process?.versions?.node ?? "unknown",
+      workerd: () => "unknown",
+      browser: () => globalRef.navigator?.userAgent ?? "unknown",
+      unknown: () => "unknown"
     };
+    getRuntimeVersion = () => versionGetters[detectRuntime()]();
     isDeno = () => detectRuntime() === "deno";
     isNode = () => detectRuntime() === "node";
     isBun = () => detectRuntime() === "bun";
     isWorkerd = () => detectRuntime() === "workerd";
     isBrowser = () => detectRuntime() === "browser";
-    isServer = () => {
-      const rt = detectRuntime();
-      return rt === "deno" || rt === "node" || rt === "bun";
+    SERVER_RUNTIMES = /* @__PURE__ */ new Set([
+      "deno",
+      "node",
+      "bun"
+    ]);
+    isServer = () => SERVER_RUNTIMES.has(detectRuntime());
+    isEdge = () => detectRuntime() === "workerd";
+  }
+});
+
+// pkg/@eser/standards/runtime/helpers.ts
+var getEnvVar, getFirstEnvVar, tryRequire, getProcess, getNavigator;
+var init_helpers = __esm({
+  "pkg/@eser/standards/runtime/helpers.ts"() {
+    getEnvVar = (key) => {
+      if (typeof Deno !== "undefined" && Deno.env?.get) {
+        return Deno.env.get(key);
+      }
+      const proc = globalThis.process;
+      if (proc?.env) {
+        return proc.env[key];
+      }
+      return void 0;
+    };
+    getFirstEnvVar = (...keys) => {
+      for (const key of keys) {
+        const value2 = getEnvVar(key);
+        if (value2 !== void 0) {
+          return value2;
+        }
+      }
+      return void 0;
+    };
+    tryRequire = (moduleName) => {
+      try {
+        const requireFn = globalThis.require;
+        if (requireFn instanceof Function) {
+          return requireFn(moduleName);
+        }
+      } catch {
+      }
+      return void 0;
     };
-    isEdge = () => {
-      const rt = detectRuntime();
-      return rt === "workerd";
+    getProcess = () => {
+      return globalThis.process;
+    };
+    getNavigator = () => {
+      return globalThis.navigator;
     };
   }
 });
 
 // pkg/@eser/standards/runtime/platform.ts
-var getPlatform, getArch, getHomedir, getTmpdir, getPlatformInfo;
+var PLATFORM_MAP, getPlatform, ARCH_MAP, getArch, getHomedir, getTmpdir, getPlatformInfo;
 var init_platform = __esm({
   "pkg/@eser/standards/runtime/platform.ts"() {
+    init_helpers();
+    PLATFORM_MAP = {
+      darwin: "darwin",
+      linux: "linux",
+      windows: "windows",
+      win32: "windows"
+    };
     getPlatform = () => {
       if (typeof Deno !== "undefined" && Deno.build?.os) {
-        const os = Deno.build.os;
-        if (os === "darwin") return "darwin";
-        if (os === "linux") return "linux";
-        if (os === "windows") return "windows";
+        return PLATFORM_MAP[Deno.build.os] ?? "linux";
       }
-      const proc = globalThis.process;
+      const proc = getProcess();
       if (proc?.platform) {
-        const platform = proc.platform;
-        if (platform === "darwin") return "darwin";
-        if (platform === "linux") return "linux";
-        if (platform === "win32") return "windows";
+        return PLATFORM_MAP[proc.platform] ?? "linux";
       }
-      const nav = globalThis.navigator;
+      const nav = getNavigator();
       if (nav?.userAgent) {
         const ua = nav.userAgent.toLowerCase();
         if (ua.includes("mac")) return "darwin";
@@ -146,19 +165,21 @@ var init_platform = __esm({
       }
       return "linux";
     };
+    ARCH_MAP = {
+      x86_64: "amd64",
+      x64: "amd64",
+      aarch64: "arm64",
+      arm64: "arm64"
+    };
     getArch = () => {
       if (typeof Deno !== "undefined" && Deno.build?.arch) {
-        const arch = Deno.build.arch;
-        if (arch === "x86_64") return "amd64";
-        if (arch === "aarch64") return "arm64";
+        return ARCH_MAP[Deno.build.arch] ?? "amd64";
       }
-      const proc = globalThis.process;
+      const proc = getProcess();
       if (proc?.arch) {
-        const arch = proc.arch;
-        if (arch === "x64") return "amd64";
-        if (arch === "arm64") return "arm64";
+        return ARCH_MAP[proc.arch] ?? "amd64";
       }
-      const nav = globalThis.navigator;
+      const nav = getNavigator();
       if (nav?.userAgent) {
         const ua = nav.userAgent.toLowerCase();
         if (ua.includes("arm64") || ua.includes("aarch64")) return "arm64";
@@ -166,50 +187,22 @@ var init_platform = __esm({
       return "amd64";
     };
     getHomedir = () => {
-      if (typeof Deno !== "undefined" && Deno.env?.get) {
-        const home = Deno.env.get("HOME") ?? Deno.env.get("USERPROFILE");
-        if (home) return home;
-      }
-      const proc = globalThis.process;
-      if (proc?.env) {
-        const home = proc.env.HOME ?? proc.env.USERPROFILE;
-        if (home) return home;
-      }
-      try {
-        const os = globalThis.require?.("os");
-        if (os?.homedir) {
-          return os.homedir();
-        }
-      } catch {
-      }
-      const platform = getPlatform();
-      if (platform === "windows") {
-        return "C:\\Users\\Default";
+      const home = getFirstEnvVar("HOME", "USERPROFILE");
+      if (home) return home;
+      const os = tryRequire("os");
+      if (os?.homedir) {
+        return os.homedir();
       }
-      return "/home";
+      return getPlatform() === "windows" ? "C:\\Users\\Default" : "/home";
     };
     getTmpdir = () => {
-      if (typeof Deno !== "undefined" && Deno.env?.get) {
-        const tmp = Deno.env.get("TMPDIR") ?? Deno.env.get("TMP") ?? Deno.env.get("TEMP");
-        if (tmp) return tmp;
-      }
-      const proc = globalThis.process;
-      if (proc?.env) {
-        const tmp = proc.env.TMPDIR ?? proc.env.TMP ?? proc.env.TEMP;
-        if (tmp) return tmp;
-      }
-      try {
-        const os = globalThis.require?.("os");
-        if (os?.tmpdir) {
-          return os.tmpdir();
-        }
-      } catch {
+      const tmp = getFirstEnvVar("TMPDIR", "TMP", "TEMP");
+      if (tmp) return tmp;
+      const os = tryRequire("os");
+      if (os?.tmpdir) {
+        return os.tmpdir();
       }
-      const platform = getPlatform();
-      if (platform === "windows") {
-        return "C:\\Windows\\Temp";
-      }
-      return "/tmp";
+      return getPlatform() === "windows" ? "C:\\Windows\\Temp" : "/tmp";
     };
     getPlatformInfo = () => {
       return {
@@ -222,520 +215,89 @@ var init_platform = __esm({
   }
 });
 
-// pkg/@eser/standards/runtime/capabilities.ts
-var FULL_CAPABILITIES, DENO_CAPABILITIES, NODE_CAPABILITIES, BUN_CAPABILITIES, WORKERD_CAPABILITIES, BROWSER_CAPABILITIES, UNKNOWN_CAPABILITIES, getCapabilities, hasCapability;
-var init_capabilities = __esm({
-  "pkg/@eser/standards/runtime/capabilities.ts"() {
-    FULL_CAPABILITIES = {
-      fs: true,
-      fsSync: true,
-      exec: true,
-      process: true,
-      env: true,
-      stdin: true,
-      stdout: true,
-      kv: false
-    };
-    DENO_CAPABILITIES = {
-      fs: true,
-      fsSync: true,
-      exec: true,
-      process: true,
-      env: true,
-      stdin: true,
-      stdout: true,
-      kv: true
-    };
-    NODE_CAPABILITIES = {
-      fs: true,
-      fsSync: true,
-      exec: true,
-      process: true,
-      env: true,
-      stdin: true,
-      stdout: true,
-      kv: false
-    };
-    BUN_CAPABILITIES = {
-      fs: true,
-      fsSync: true,
-      exec: true,
-      process: true,
-      env: true,
-      stdin: true,
-      stdout: true,
-      kv: false
-    };
-    WORKERD_CAPABILITIES = {
-      fs: false,
-      fsSync: false,
-      exec: false,
-      process: false,
-      env: true,
-      stdin: false,
-      stdout: false,
-      kv: true
-    };
-    BROWSER_CAPABILITIES = {
-      fs: false,
-      fsSync: false,
-      exec: false,
-      process: false,
-      env: false,
-      stdin: false,
-      stdout: false,
-      kv: false
-    };
-    UNKNOWN_CAPABILITIES = {
-      fs: false,
-      fsSync: false,
-      exec: false,
-      process: false,
-      env: false,
-      stdin: false,
-      stdout: false,
-      kv: false
-    };
-    getCapabilities = (runtime2) => {
-      switch (runtime2) {
-        case "deno":
-          return DENO_CAPABILITIES;
-        case "node":
-          return NODE_CAPABILITIES;
-        case "bun":
-          return BUN_CAPABILITIES;
-        case "workerd":
-          return WORKERD_CAPABILITIES;
-        case "browser":
-          return BROWSER_CAPABILITIES;
-        default:
-          return UNKNOWN_CAPABILITIES;
-      }
-    };
-    hasCapability = (runtime2, capability) => {
-      return getCapabilities(runtime2)[capability];
-    };
+// deno:https://jsr.io/@std/internal/1.0.12/_os.ts
+function checkWindows() {
+  const global = globalThis;
+  const os = global.Deno?.build?.os;
+  return typeof os === "string" ? os === "windows" : global.navigator?.platform?.startsWith("Win") ?? global.process?.platform?.startsWith("win") ?? false;
+}
+var init_os = __esm({
+  "deno:https://jsr.io/@std/internal/1.0.12/_os.ts"() {
   }
 });
 
-// pkg/@eser/standards/runtime/polyfills/path.ts
-var POSIX_SEP, POSIX_DELIMITER, normalizeSlashes, join, resolve, dirname, basename, extname, normalize, isAbsolute, relative, parse, format, posixPath;
-var init_path = __esm({
-  "pkg/@eser/standards/runtime/polyfills/path.ts"() {
-    POSIX_SEP = "/";
-    POSIX_DELIMITER = ":";
-    normalizeSlashes = (path) => {
-      return path.replace(/\\/g, "/").replace(/\/+/g, "/");
-    };
-    join = (...paths) => {
-      if (paths.length === 0) return ".";
-      const joined = paths.filter((p) => p.length > 0).join(POSIX_SEP);
-      if (joined.length === 0) return ".";
-      return normalize(joined);
-    };
-    resolve = (...paths) => {
-      let resolvedPath = "";
-      let resolvedAbsolute = false;
-      for (let i = paths.length - 1; i >= 0 && !resolvedAbsolute; i--) {
-        const segment = paths[i];
-        if (segment === void 0 || segment.length === 0) continue;
-        resolvedPath = `${segment}/${resolvedPath}`;
-        resolvedAbsolute = isAbsolute(segment);
-      }
-      resolvedPath = normalizeSlashes(resolvedPath);
-      if (resolvedPath.length > 1 && resolvedPath.endsWith("/")) {
-        resolvedPath = resolvedPath.slice(0, -1);
-      }
-      return normalize(resolvedPath) ?? ".";
-    };
-    dirname = (path) => {
-      if (path.length === 0) return ".";
-      path = normalizeSlashes(path);
-      while (path.length > 1 && path.endsWith("/")) {
-        path = path.slice(0, -1);
-      }
-      const lastSlash = path.lastIndexOf("/");
-      if (lastSlash === -1) return ".";
-      if (lastSlash === 0) return "/";
-      return path.slice(0, lastSlash);
-    };
-    basename = (path, suffix) => {
-      if (path.length === 0) return "";
-      path = normalizeSlashes(path);
-      while (path.length > 1 && path.endsWith("/")) {
-        path = path.slice(0, -1);
-      }
-      const lastSlash = path.lastIndexOf("/");
-      let base = lastSlash === -1 ? path : path.slice(lastSlash + 1);
-      if (suffix && base.endsWith(suffix)) {
-        base = base.slice(0, -suffix.length);
-      }
-      return base;
-    };
-    extname = (path) => {
-      const base = basename(path);
-      const lastDot = base.lastIndexOf(".");
-      if (lastDot <= 0 || lastDot === base.length - 1) {
-        return "";
+// deno:https://jsr.io/@std/internal/1.0.12/os.ts
+var isWindows;
+var init_os2 = __esm({
+  "deno:https://jsr.io/@std/internal/1.0.12/os.ts"() {
+    init_os();
+    isWindows = checkWindows();
+  }
+});
+
+// deno:https://jsr.io/@std/path/1.1.4/_common/assert_path.ts
+function assertPath(path) {
+  if (typeof path !== "string") {
+    throw new TypeError(`Path must be a string, received "${JSON.stringify(path)}"`);
+  }
+}
+var init_assert_path = __esm({
+  "deno:https://jsr.io/@std/path/1.1.4/_common/assert_path.ts"() {
+  }
+});
+
+// deno:https://jsr.io/@std/path/1.1.4/_common/basename.ts
+function stripSuffix(name, suffix) {
+  if (suffix.length >= name.length) {
+    return name;
+  }
+  const lenDiff = name.length - suffix.length;
+  for (let i = suffix.length - 1; i >= 0; --i) {
+    if (name.charCodeAt(lenDiff + i) !== suffix.charCodeAt(i)) {
+      return name;
+    }
+  }
+  return name.slice(0, -suffix.length);
+}
+function lastPathSegment(path, isSep, start = 0) {
+  let matchedNonSeparator = false;
+  let end = path.length;
+  for (let i = path.length - 1; i >= start; --i) {
+    if (isSep(path.charCodeAt(i))) {
+      if (matchedNonSeparator) {
+        start = i + 1;
+        break;
       }
-      return base.slice(lastDot);
-    };
-    normalize = (path) => {
-      if (path.length === 0) return ".";
-      path = normalizeSlashes(path);
-      const isAbs = path.startsWith("/");
-      const trailingSlash = path.endsWith("/");
-      const segments = path.split("/").filter((s) => s.length > 0);
-      const result = [];
-      for (const segment of segments) {
-        if (segment === ".") {
-          continue;
-        }
-        if (segment === "..") {
-          if (result.length > 0 && result[result.length - 1] !== "..") {
-            result.pop();
-          } else if (!isAbs) {
-            result.push("..");
-          }
-        } else {
-          result.push(segment);
-        }
-      }
-      let normalized = result.join("/");
-      if (isAbs) {
-        normalized = `/${normalized}`;
-      }
-      if (trailingSlash && normalized.length > 1) {
-        normalized += "/";
-      }
-      return normalized ?? ".";
-    };
-    isAbsolute = (path) => {
-      if (path.length === 0) return false;
-      if (path.startsWith("/")) return true;
-      if (path.length >= 3 && /^[a-zA-Z]:[/\\]/.test(path)) {
-        return true;
-      }
-      return false;
-    };
-    relative = (from, to) => {
-      if (from === to) return "";
-      from = resolve(from);
-      to = resolve(to);
-      if (from === to) return "";
-      const fromParts = from.split("/").filter((p) => p.length > 0);
-      const toParts = to.split("/").filter((p) => p.length > 0);
-      let commonLength = 0;
-      const minLength = Math.min(fromParts.length, toParts.length);
-      for (let i = 0; i < minLength; i++) {
-        if (fromParts[i] !== toParts[i]) break;
-        commonLength++;
-      }
-      const upCount = fromParts.length - commonLength;
-      const remaining = toParts.slice(commonLength);
-      const result = [
-        ...Array(upCount).fill(".."),
-        ...remaining
-      ];
-      return result.join("/") ?? ".";
-    };
-    parse = (path) => {
-      if (path.length === 0) {
-        return {
-          root: "",
-          dir: "",
-          base: "",
-          ext: "",
-          name: ""
-        };
-      }
-      path = normalizeSlashes(path);
-      let root = "";
-      let dir = "";
-      const base = basename(path);
-      const ext = extname(path);
-      const name = ext ? base.slice(0, -ext.length) : base;
-      if (path.startsWith("/")) {
-        root = "/";
-      } else if (/^[a-zA-Z]:[/\\]/.test(path)) {
-        root = path.slice(0, 3);
-      }
-      dir = dirname(path);
-      if (dir === ".") {
-        dir = "";
-      }
-      return {
-        root,
-        dir,
-        base,
-        ext,
-        name
-      };
-    };
-    format = (pathObject) => {
-      const { root = "", dir, base, ext = "", name = "" } = pathObject;
-      const finalBase = base ?? name + ext;
-      if (dir) {
-        if (dir === root) {
-          return `${dir}${finalBase}`;
-        }
-        return `${dir}/${finalBase}`;
-      }
-      return `${root}${finalBase}`;
-    };
-    posixPath = {
-      join,
-      resolve,
-      dirname,
-      basename,
-      extname,
-      normalize,
-      isAbsolute,
-      relative,
-      parse,
-      format,
-      sep: POSIX_SEP,
-      delimiter: POSIX_DELIMITER
-    };
+    } else if (!matchedNonSeparator) {
+      matchedNonSeparator = true;
+      end = i + 1;
+    }
+  }
+  return path.slice(start, end);
+}
+function assertArgs(path, suffix) {
+  assertPath(path);
+  if (path.length === 0) return path;
+  if (typeof suffix !== "string") {
+    throw new TypeError(`Suffix must be a string, received "${JSON.stringify(suffix)}"`);
+  }
+}
+var init_basename = __esm({
+  "deno:https://jsr.io/@std/path/1.1.4/_common/basename.ts"() {
+    init_assert_path();
   }
 });
 
-// pkg/@eser/standards/runtime/file-search.ts
-var searchFileHierarchy;
-var init_file_search = __esm({
-  "pkg/@eser/standards/runtime/file-search.ts"() {
-    init_mod2();
-    searchFileHierarchy = async (startDir, filenames, options = {}) => {
-      const { searchParents = false } = options;
-      let dir = startDir;
-      while (true) {
-        for (const name of filenames) {
-          const filepath = runtime.path.join(dir, name);
-          const exists = await runtime.fs.exists(filepath);
-          if (exists) {
-            const stat3 = await runtime.fs.stat(filepath);
-            if (stat3.isFile) {
-              return filepath;
-            }
-          }
-        }
-        if (!searchParents) {
-          break;
-        }
-        const parent = runtime.path.dirname(dir);
-        if (parent === dir) {
-          break;
-        }
-        dir = parent;
-      }
-      return void 0;
-    };
-  }
-});
-
-// pkg/@eser/standards/runtime/adapters/workerd.ts
-var createWorkerdFs, createWorkerdPath, createWorkerdExec, envStorage, createWorkerdEnv, populateEnvFromContext, clearEnv, createWorkerdProcess, createWorkerdRuntime;
-var init_workerd = __esm({
-  "pkg/@eser/standards/runtime/adapters/workerd.ts"() {
-    init_types();
-    init_capabilities();
-    init_path();
-    createWorkerdFs = () => {
-      const throwNotAvailable = () => {
-        throw new RuntimeCapabilityError("fs", "workerd");
-      };
-      return {
-        readFile: throwNotAvailable,
-        readTextFile: throwNotAvailable,
-        writeFile: throwNotAvailable,
-        writeTextFile: throwNotAvailable,
-        exists: throwNotAvailable,
-        stat: throwNotAvailable,
-        lstat: throwNotAvailable,
-        mkdir: throwNotAvailable,
-        remove: throwNotAvailable,
-        readDir: () => {
-          throw new RuntimeCapabilityError("fs", "workerd");
-        },
-        copyFile: throwNotAvailable,
-        rename: throwNotAvailable,
-        makeTempDir: throwNotAvailable
-      };
-    };
-    createWorkerdPath = () => {
-      return posixPath;
-    };
-    createWorkerdExec = () => {
-      const throwNotAvailable = () => {
-        throw new RuntimeCapabilityError("exec", "workerd");
-      };
-      return {
-        spawn: throwNotAvailable,
-        exec: throwNotAvailable,
-        execJson: throwNotAvailable,
-        spawnChild: throwNotAvailable
-      };
-    };
-    envStorage = /* @__PURE__ */ new Map();
-    createWorkerdEnv = () => {
-      return {
-        get(key) {
-          return envStorage.get(key);
-        },
-        set(key, value2) {
-          envStorage.set(key, value2);
-        },
-        delete(key) {
-          envStorage.delete(key);
-        },
-        has(key) {
-          return envStorage.has(key);
-        },
-        toObject() {
-          return Object.fromEntries(envStorage);
-        }
-      };
-    };
-    populateEnvFromContext = (env) => {
-      for (const [key, value2] of Object.entries(env)) {
-        if (typeof value2 === "string") {
-          envStorage.set(key, value2);
-        }
-      }
-    };
-    clearEnv = () => {
-      envStorage.clear();
-    };
-    createWorkerdProcess = () => {
-      const throwNotAvailable = () => {
-        throw new RuntimeCapabilityError("process", "workerd");
-      };
-      return {
-        exit: throwNotAvailable,
-        cwd: throwNotAvailable,
-        chdir: throwNotAvailable,
-        hostname: throwNotAvailable,
-        execPath: throwNotAvailable,
-        get args() {
-          throw new RuntimeCapabilityError("process", "workerd");
-        },
-        get pid() {
-          throw new RuntimeCapabilityError("process", "workerd");
-        },
-        get stdin() {
-          throw new RuntimeCapabilityError("process", "workerd");
-        },
-        get stdout() {
-          throw new RuntimeCapabilityError("process", "workerd");
-        },
-        get stderr() {
-          throw new RuntimeCapabilityError("process", "workerd");
-        }
-      };
-    };
-    createWorkerdRuntime = () => {
-      const fs = createWorkerdFs();
-      const path = createWorkerdPath();
-      const exec2 = createWorkerdExec();
-      const env = createWorkerdEnv();
-      const process = createWorkerdProcess();
-      return {
-        name: "workerd",
-        version: "unknown",
-        capabilities: WORKERD_CAPABILITIES,
-        fs,
-        path,
-        exec: exec2,
-        env,
-        process
-      };
-    };
-  }
-});
-
-// deno:https://jsr.io/@std/internal/1.0.12/_os.ts
-function checkWindows() {
-  const global = globalThis;
-  const os = global.Deno?.build?.os;
-  return typeof os === "string" ? os === "windows" : global.navigator?.platform?.startsWith("Win") ?? global.process?.platform?.startsWith("win") ?? false;
-}
-var init_os = __esm({
-  "deno:https://jsr.io/@std/internal/1.0.12/_os.ts"() {
-  }
-});
-
-// deno:https://jsr.io/@std/internal/1.0.12/os.ts
-var isWindows;
-var init_os2 = __esm({
-  "deno:https://jsr.io/@std/internal/1.0.12/os.ts"() {
-    init_os();
-    isWindows = checkWindows();
-  }
-});
-
-// deno:https://jsr.io/@std/path/1.1.4/_common/assert_path.ts
-function assertPath(path) {
-  if (typeof path !== "string") {
-    throw new TypeError(`Path must be a string, received "${JSON.stringify(path)}"`);
-  }
-}
-var init_assert_path = __esm({
-  "deno:https://jsr.io/@std/path/1.1.4/_common/assert_path.ts"() {
-  }
-});
-
-// deno:https://jsr.io/@std/path/1.1.4/_common/basename.ts
-function stripSuffix(name, suffix) {
-  if (suffix.length >= name.length) {
-    return name;
-  }
-  const lenDiff = name.length - suffix.length;
-  for (let i = suffix.length - 1; i >= 0; --i) {
-    if (name.charCodeAt(lenDiff + i) !== suffix.charCodeAt(i)) {
-      return name;
-    }
-  }
-  return name.slice(0, -suffix.length);
-}
-function lastPathSegment(path, isSep, start = 0) {
-  let matchedNonSeparator = false;
-  let end = path.length;
-  for (let i = path.length - 1; i >= start; --i) {
-    if (isSep(path.charCodeAt(i))) {
-      if (matchedNonSeparator) {
-        start = i + 1;
-        break;
-      }
-    } else if (!matchedNonSeparator) {
-      matchedNonSeparator = true;
-      end = i + 1;
-    }
-  }
-  return path.slice(start, end);
-}
-function assertArgs(path, suffix) {
-  assertPath(path);
-  if (path.length === 0) return path;
-  if (typeof suffix !== "string") {
-    throw new TypeError(`Suffix must be a string, received "${JSON.stringify(suffix)}"`);
-  }
-}
-var init_basename = __esm({
-  "deno:https://jsr.io/@std/path/1.1.4/_common/basename.ts"() {
-    init_assert_path();
-  }
-});
-
-// deno:https://jsr.io/@std/path/1.1.4/_common/from_file_url.ts
-function assertArg(url) {
-  url = url instanceof URL ? url : new URL(url);
-  if (url.protocol !== "file:") {
-    throw new TypeError(`URL must be a file URL: received "${url.protocol}"`);
-  }
-  return url;
-}
-var init_from_file_url = __esm({
-  "deno:https://jsr.io/@std/path/1.1.4/_common/from_file_url.ts"() {
+// deno:https://jsr.io/@std/path/1.1.4/_common/from_file_url.ts
+function assertArg(url) {
+  url = url instanceof URL ? url : new URL(url);
+  if (url.protocol !== "file:") {
+    throw new TypeError(`URL must be a file URL: received "${url.protocol}"`);
+  }
+  return url;
+}
+var init_from_file_url = __esm({
+  "deno:https://jsr.io/@std/path/1.1.4/_common/from_file_url.ts"() {
   }
 });
 
@@ -796,7 +358,7 @@ var init_util = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/basename.ts
-function basename2(path, suffix = "") {
+function basename(path, suffix = "") {
   if (path instanceof URL) {
     path = fromFileUrl(path);
   }
@@ -846,7 +408,7 @@ var init_from_file_url3 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/basename.ts
-function basename3(path, suffix = "") {
+function basename2(path, suffix = "") {
   if (path instanceof URL) {
     path = fromFileUrl2(path);
   }
@@ -873,8 +435,8 @@ var init_basename3 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/basename.ts
-function basename4(path, suffix = "") {
-  return isWindows ? basename3(path, suffix) : basename2(path, suffix);
+function basename3(path, suffix = "") {
+  return isWindows ? basename2(path, suffix) : basename(path, suffix);
 }
 var init_basename4 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/basename.ts"() {
@@ -907,7 +469,7 @@ var init_dirname = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/dirname.ts
-function dirname2(path) {
+function dirname(path) {
   if (path instanceof URL) {
     path = fromFileUrl(path);
   }
@@ -939,7 +501,7 @@ var init_dirname2 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/dirname.ts
-function dirname3(path) {
+function dirname2(path) {
   if (path instanceof URL) {
     path = fromFileUrl2(path);
   }
@@ -1016,8 +578,8 @@ var init_dirname3 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/dirname.ts
-function dirname4(path) {
-  return isWindows ? dirname3(path) : dirname2(path);
+function dirname3(path) {
+  return isWindows ? dirname2(path) : dirname(path);
 }
 var init_dirname4 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/dirname.ts"() {
@@ -1028,7 +590,7 @@ var init_dirname4 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/extname.ts
-function extname2(path) {
+function extname(path) {
   if (path instanceof URL) {
     path = fromFileUrl(path);
   }
@@ -1075,7 +637,7 @@ var init_extname = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/extname.ts
-function extname3(path) {
+function extname2(path) {
   if (path instanceof URL) {
     path = fromFileUrl2(path);
   }
@@ -1126,8 +688,8 @@ var init_extname2 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/extname.ts
-function extname4(path) {
-  return isWindows ? extname3(path) : extname2(path);
+function extname3(path) {
+  return isWindows ? extname2(path) : extname(path);
 }
 var init_extname3 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/extname.ts"() {
@@ -1157,7 +719,7 @@ var init_format = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/format.ts
-function format2(pathObject) {
+function format(pathObject) {
   assertArg3(pathObject);
   return _format("/", pathObject);
 }
@@ -1168,7 +730,7 @@ var init_format2 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/format.ts
-function format3(pathObject) {
+function format2(pathObject) {
   assertArg3(pathObject);
   return _format("\\", pathObject);
 }
@@ -1179,8 +741,8 @@ var init_format3 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/format.ts
-function format4(pathObject) {
-  return isWindows ? format3(pathObject) : format2(pathObject);
+function format3(pathObject) {
+  return isWindows ? format2(pathObject) : format(pathObject);
 }
 var init_format4 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/format.ts"() {
@@ -1203,7 +765,7 @@ var init_from_file_url4 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/is_absolute.ts
-function isAbsolute2(path) {
+function isAbsolute(path) {
   assertPath(path);
   return path.length > 0 && isPosixPathSeparator(path.charCodeAt(0));
 }
@@ -1215,7 +777,7 @@ var init_is_absolute = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/is_absolute.ts
-function isAbsolute3(path) {
+function isAbsolute2(path) {
   assertPath(path);
   const len = path.length;
   if (len === 0) return false;
@@ -1238,8 +800,8 @@ var init_is_absolute2 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/is_absolute.ts
-function isAbsolute4(path) {
-  return isWindows ? isAbsolute3(path) : isAbsolute2(path);
+function isAbsolute3(path) {
+  return isWindows ? isAbsolute2(path) : isAbsolute(path);
 }
 var init_is_absolute3 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/is_absolute.ts"() {
@@ -1322,7 +884,7 @@ var init_normalize_string = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/normalize.ts
-function normalize2(path) {
+function normalize(path) {
   if (path instanceof URL) {
     path = fromFileUrl(path);
   }
@@ -1345,7 +907,7 @@ var init_normalize2 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/join.ts
-function join2(path, ...paths) {
+function join(path, ...paths) {
   if (path === void 0) return ".";
   if (path instanceof URL) {
     path = fromFileUrl(path);
@@ -1356,7 +918,7 @@ function join2(path, ...paths) {
   ] : paths;
   paths.forEach((path2) => assertPath(path2));
   const joined = paths.filter((path2) => path2.length > 0).join("/");
-  return joined === "" ? "." : normalize2(joined);
+  return joined === "" ? "." : normalize(joined);
 }
 var init_join = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/posix/join.ts"() {
@@ -1367,7 +929,7 @@ var init_join = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/normalize.ts
-function normalize3(path) {
+function normalize2(path) {
   if (path instanceof URL) {
     path = fromFileUrl2(path);
   }
@@ -1456,7 +1018,7 @@ var init_normalize3 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/join.ts
-function join3(path, ...paths) {
+function join2(path, ...paths) {
   if (path instanceof URL) {
     path = fromFileUrl2(path);
   }
@@ -1492,7 +1054,7 @@ function join3(path, ...paths) {
     }
     if (slashCount >= 2) joined = `\\${joined.slice(slashCount)}`;
   }
-  return normalize3(joined);
+  return normalize2(joined);
 }
 var init_join2 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/windows/join.ts"() {
@@ -1504,8 +1066,8 @@ var init_join2 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/join.ts
-function join4(path, ...paths) {
-  return isWindows ? join3(path, ...paths) : join2(path, ...paths);
+function join3(path, ...paths) {
+  return isWindows ? join2(path, ...paths) : join(path, ...paths);
 }
 var init_join3 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/join.ts"() {
@@ -1516,8 +1078,8 @@ var init_join3 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/normalize.ts
-function normalize4(path) {
-  return isWindows ? normalize3(path) : normalize2(path);
+function normalize3(path) {
+  return isWindows ? normalize2(path) : normalize(path);
 }
 var init_normalize4 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/normalize.ts"() {
@@ -1528,7 +1090,7 @@ var init_normalize4 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/parse.ts
-function parse2(path) {
+function parse(path) {
   assertPath(path);
   const ret = {
     root: "",
@@ -1608,7 +1170,7 @@ var init_parse = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/parse.ts
-function parse3(path) {
+function parse2(path) {
   assertPath(path);
   const ret = {
     root: "",
@@ -1724,8 +1286,8 @@ var init_parse2 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/parse.ts
-function parse4(path) {
-  return isWindows ? parse3(path) : parse2(path);
+function parse3(path) {
+  return isWindows ? parse2(path) : parse(path);
 }
 var init_parse3 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/parse.ts"() {
@@ -1736,7 +1298,7 @@ var init_parse3 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/resolve.ts
-function resolve2(...pathSegments) {
+function resolve(...pathSegments) {
   let resolvedPath = "";
   let resolvedAbsolute = false;
   for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
@@ -1784,10 +1346,10 @@ var init_relative = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/relative.ts
-function relative2(from, to) {
+function relative(from, to) {
   assertArgs2(from, to);
-  from = resolve2(from);
-  to = resolve2(to);
+  from = resolve(from);
+  to = resolve(to);
   if (from === to) return "";
   let fromStart = 1;
   const fromEnd = from.length;
@@ -1849,7 +1411,7 @@ var init_relative2 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/resolve.ts
-function resolve3(...pathSegments) {
+function resolve2(...pathSegments) {
   let resolvedDevice = "";
   let resolvedTail = "";
   let resolvedAbsolute = false;
@@ -1952,10 +1514,10 @@ var init_resolve2 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/relative.ts
-function relative3(from, to) {
+function relative2(from, to) {
   assertArgs2(from, to);
-  const fromOrig = resolve3(from);
-  const toOrig = resolve3(to);
+  const fromOrig = resolve2(from);
+  const toOrig = resolve2(to);
   if (fromOrig === toOrig) return "";
   from = fromOrig.toLowerCase();
   to = toOrig.toLowerCase();
@@ -2032,8 +1594,8 @@ var init_relative3 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/relative.ts
-function relative4(from, to) {
-  return isWindows ? relative3(from, to) : relative2(from, to);
+function relative3(from, to) {
+  return isWindows ? relative2(from, to) : relative(from, to);
 }
 var init_relative4 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/relative.ts"() {
@@ -2044,8 +1606,8 @@ var init_relative4 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/resolve.ts
-function resolve4(...pathSegments) {
-  return isWindows ? resolve3(...pathSegments) : resolve2(...pathSegments);
+function resolve3(...pathSegments) {
+  return isWindows ? resolve2(...pathSegments) : resolve(...pathSegments);
 }
 var init_resolve3 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/resolve.ts"() {
@@ -2440,11 +2002,11 @@ function normalizeGlob(glob, options = {}) {
     throw new Error(`Glob contains invalid characters: "${glob}"`);
   }
   if (!globstar) {
-    return normalize2(glob);
+    return normalize(glob);
   }
   const s = SEPARATOR_PATTERN2.source;
   const badParentPattern = new RegExp(`(?<=(${s}|^)\\*\\*${s})\\.\\.(?=${s}|$)`, "g");
-  return normalize2(glob.replace(badParentPattern, "\0")).replace(/\0/g, "..");
+  return normalize(glob.replace(badParentPattern, "\0")).replace(/\0/g, "..");
 }
 var init_normalize_glob = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/posix/normalize_glob.ts"() {
@@ -2457,7 +2019,7 @@ var init_normalize_glob = __esm({
 function joinGlobs(globs, options = {}) {
   const { globstar = false } = options;
   if (!globstar || globs.length === 0) {
-    return join2(...globs);
+    return join(...globs);
   }
   let joined;
   for (const glob of globs) {
@@ -2496,11 +2058,11 @@ function normalizeGlob2(glob, options = {}) {
     throw new Error(`Glob contains invalid characters: "${glob}"`);
   }
   if (!globstar) {
-    return normalize3(glob);
+    return normalize2(glob);
   }
   const s = SEPARATOR_PATTERN3.source;
   const badParentPattern = new RegExp(`(?<=(${s}|^)\\*\\*${s})\\.\\.(?=${s}|$)`, "g");
-  return normalize3(glob.replace(badParentPattern, "\0")).replace(/\0/g, "..");
+  return normalize2(glob.replace(badParentPattern, "\0")).replace(/\0/g, "..");
 }
 var init_normalize_glob2 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/windows/normalize_glob.ts"() {
@@ -2513,7 +2075,7 @@ var init_normalize_glob2 = __esm({
 function joinGlobs2(globs, options = {}) {
   const { globstar = false } = options;
   if (!globstar || globs.length === 0) {
-    return join3(...globs);
+    return join2(...globs);
   }
   let joined;
   for (const glob of globs) {
@@ -2583,184 +2145,541 @@ var init_mod = __esm({
   }
 });
 
+// pkg/@eser/standards/runtime/adapters/shared.ts
+var mapStdioToNode, getStdioModes, getNodeStdioArray;
+var init_shared = __esm({
+  "pkg/@eser/standards/runtime/adapters/shared.ts"() {
+    mapStdioToNode = (mode) => {
+      if (mode === "inherit") return "inherit";
+      if (mode === "piped") return "pipe";
+      return "ignore";
+    };
+    getStdioModes = (options) => ({
+      stdin: options?.stdin ?? "null",
+      stdout: options?.stdout ?? "piped",
+      stderr: options?.stderr ?? "piped"
+    });
+    getNodeStdioArray = (options) => {
+      const modes = getStdioModes(options);
+      return [
+        mapStdioToNode(modes.stdin),
+        mapStdioToNode(modes.stdout),
+        mapStdioToNode(modes.stderr)
+      ];
+    };
+  }
+});
+
 // pkg/@eser/standards/runtime/adapters/deno.ts
-var createDenoFs, createDenoPath, createDenoExec, createDenoEnv, createDenoProcess, createDenoRuntime;
+var DENO_CAPABILITIES, createDenoFs, createDenoPath, createDenoExec, createDenoEnv, createDenoProcess, createDenoRuntime;
 var init_deno = __esm({
   "pkg/@eser/standards/runtime/adapters/deno.ts"() {
     init_mod();
     init_types();
-    init_capabilities();
-    createDenoFs = () => {
-      const mapFileInfo = (info) => ({
-        isFile: info.isFile,
-        isDirectory: info.isDirectory,
-        isSymlink: info.isSymlink,
-        size: info.size,
-        mtime: info.mtime,
-        atime: info.atime,
-        birthtime: info.birthtime
+    init_shared();
+    DENO_CAPABILITIES = {
+      fs: true,
+      fsSync: true,
+      exec: true,
+      process: true,
+      env: true,
+      stdin: true,
+      stdout: true,
+      kv: true
+    };
+    createDenoFs = () => {
+      const mapFileInfo = (info) => ({
+        isFile: info.isFile,
+        isDirectory: info.isDirectory,
+        isSymlink: info.isSymlink,
+        size: info.size,
+        mtime: info.mtime,
+        atime: info.atime,
+        birthtime: info.birthtime
+      });
+      return {
+        async readFile(path, options) {
+          try {
+            return await Deno.readFile(path, {
+              signal: options?.signal
+            });
+          } catch (error) {
+            if (error instanceof Deno.errors.NotFound) {
+              throw new NotFoundError(path);
+            }
+            throw error;
+          }
+        },
+        async readTextFile(path, options) {
+          try {
+            return await Deno.readTextFile(path, {
+              signal: options?.signal
+            });
+          } catch (error) {
+            if (error instanceof Deno.errors.NotFound) {
+              throw new NotFoundError(path);
+            }
+            throw error;
+          }
+        },
+        async writeFile(path, data, options) {
+          await Deno.writeFile(path, data, {
+            signal: options?.signal,
+            mode: options?.mode,
+            create: options?.create ?? true,
+            append: options?.append ?? false
+          });
+        },
+        async writeTextFile(path, data, options) {
+          await Deno.writeTextFile(path, data, {
+            signal: options?.signal,
+            mode: options?.mode,
+            create: options?.create ?? true,
+            append: options?.append ?? false
+          });
+        },
+        async exists(path) {
+          try {
+            await Deno.stat(path);
+            return true;
+          } catch (error) {
+            if (error instanceof Deno.errors.NotFound) {
+              return false;
+            }
+            throw error;
+          }
+        },
+        async stat(path) {
+          try {
+            const info = await Deno.stat(path);
+            return mapFileInfo(info);
+          } catch (error) {
+            if (error instanceof Deno.errors.NotFound) {
+              throw new NotFoundError(path);
+            }
+            throw error;
+          }
+        },
+        async lstat(path) {
+          try {
+            const info = await Deno.lstat(path);
+            return mapFileInfo(info);
+          } catch (error) {
+            if (error instanceof Deno.errors.NotFound) {
+              throw new NotFoundError(path);
+            }
+            throw error;
+          }
+        },
+        async mkdir(path, options) {
+          await Deno.mkdir(path, {
+            recursive: options?.recursive ?? false,
+            mode: options?.mode
+          });
+        },
+        async remove(path, options) {
+          try {
+            await Deno.remove(path, {
+              recursive: options?.recursive ?? false
+            });
+          } catch (error) {
+            if (error instanceof Deno.errors.NotFound) {
+              throw new NotFoundError(path);
+            }
+            throw error;
+          }
+        },
+        async *readDir(path) {
+          try {
+            for await (const entry of Deno.readDir(path)) {
+              yield {
+                name: entry.name,
+                isFile: entry.isFile,
+                isDirectory: entry.isDirectory,
+                isSymlink: entry.isSymlink
+              };
+            }
+          } catch (error) {
+            if (error instanceof Deno.errors.NotFound) {
+              throw new NotFoundError(path);
+            }
+            throw error;
+          }
+        },
+        async copyFile(from, to) {
+          await Deno.copyFile(from, to);
+        },
+        async rename(from, to) {
+          await Deno.rename(from, to);
+        },
+        async makeTempDir(options) {
+          return await Deno.makeTempDir({
+            dir: options?.dir,
+            prefix: options?.prefix,
+            suffix: options?.suffix
+          });
+        }
+      };
+    };
+    createDenoPath = () => {
+      return {
+        join: join3,
+        resolve: resolve3,
+        dirname: dirname3,
+        basename: basename3,
+        extname: extname3,
+        normalize: normalize3,
+        isAbsolute: isAbsolute3,
+        relative: relative3,
+        parse: parse3,
+        format: format3,
+        sep: SEPARATOR,
+        delimiter: DELIMITER
+      };
+    };
+    createDenoExec = () => {
+      return {
+        async spawn(cmd, args = [], options) {
+          const modes = getStdioModes(options);
+          const command = new Deno.Command(cmd, {
+            args,
+            cwd: options?.cwd,
+            env: options?.env,
+            stdin: modes.stdin,
+            stdout: modes.stdout,
+            stderr: modes.stderr,
+            signal: options?.signal
+          });
+          const result = await command.output();
+          return {
+            success: result.success,
+            code: result.code,
+            stdout: modes.stdout === "piped" ? result.stdout : new Uint8Array(),
+            stderr: modes.stderr === "piped" ? result.stderr : new Uint8Array()
+          };
+        },
+        async exec(cmd, args = [], options) {
+          const result = await this.spawn(cmd, args, options);
+          if (!result.success) {
+            const stderr = new TextDecoder().decode(result.stderr);
+            throw new ProcessError(cmd, result.code, stderr);
+          }
+          return new TextDecoder().decode(result.stdout).trim();
+        },
+        async execJson(cmd, args = [], options) {
+          const output = await this.exec(cmd, args, options);
+          return JSON.parse(output);
+        },
+        spawnChild(cmd, args = [], options) {
+          const modes = getStdioModes(options);
+          const command = new Deno.Command(cmd, {
+            args,
+            cwd: options?.cwd,
+            env: options?.env,
+            stdin: modes.stdin,
+            stdout: modes.stdout,
+            stderr: modes.stderr,
+            signal: options?.signal
+          });
+          const process = command.spawn();
+          const collectStream = (stream, mode) => {
+            if (mode !== "piped" || !stream) {
+              return Promise.resolve(new Uint8Array());
+            }
+            return new Response(stream).arrayBuffer().then((b) => new Uint8Array(b));
+          };
+          return {
+            pid: process.pid,
+            stdin: modes.stdin === "piped" ? process.stdin : null,
+            stdout: modes.stdout === "piped" ? process.stdout : null,
+            stderr: modes.stderr === "piped" ? process.stderr : null,
+            status: process.status.then((status) => ({
+              success: status.success,
+              code: status.code,
+              signal: status.signal ?? void 0
+            })),
+            output: async () => {
+              const stdoutStream = modes.stdout === "piped" ? process.stdout : null;
+              const stderrStream = modes.stderr === "piped" ? process.stderr : null;
+              const [status, stdout, stderr] = await Promise.all([
+                process.status,
+                collectStream(stdoutStream, modes.stdout),
+                collectStream(stderrStream, modes.stderr)
+              ]);
+              return {
+                success: status.success,
+                code: status.code,
+                stdout,
+                stderr
+              };
+            },
+            kill: (signal) => {
+              process.kill(signal);
+            }
+          };
+        }
+      };
+    };
+    createDenoEnv = () => {
+      return {
+        get(key) {
+          return Deno.env.get(key);
+        },
+        set(key, value2) {
+          Deno.env.set(key, value2);
+        },
+        delete(key) {
+          Deno.env.delete(key);
+        },
+        has(key) {
+          return Deno.env.get(key) !== void 0;
+        },
+        toObject() {
+          return Deno.env.toObject();
+        }
+      };
+    };
+    createDenoProcess = () => {
+      return {
+        exit(code2) {
+          Deno.exit(code2);
+        },
+        cwd() {
+          return Deno.cwd();
+        },
+        chdir(path) {
+          Deno.chdir(path);
+        },
+        hostname() {
+          return Deno.hostname();
+        },
+        execPath() {
+          return Deno.execPath();
+        },
+        args: Deno.args,
+        pid: Deno.pid,
+        stdin: Deno.stdin.readable,
+        stdout: Deno.stdout.writable,
+        stderr: Deno.stderr.writable
+      };
+    };
+    createDenoRuntime = () => {
+      const fs = createDenoFs();
+      const path = createDenoPath();
+      const exec2 = createDenoExec();
+      const env = createDenoEnv();
+      const process = createDenoProcess();
+      return {
+        name: "deno",
+        version: Deno.version.deno,
+        capabilities: DENO_CAPABILITIES,
+        fs,
+        path,
+        exec: exec2,
+        env,
+        process
+      };
+    };
+  }
+});
+
+// pkg/@eser/standards/runtime/adapters/node.ts
+import * as nodeFsPromises from "node:fs/promises";
+import * as nodePath from "node:path";
+import * as nodeOs from "node:os";
+import * as nodeChildProcess from "node:child_process";
+import nodeProcess from "node:process";
+import { Buffer as Buffer2 } from "node:buffer";
+import { Readable, Writable } from "node:stream";
+var NODE_CAPABILITIES, createNodeFs, createNodePath, createNodeExec, createNodeEnv, createNodeProcess, createNodeRuntime;
+var init_node = __esm({
+  "pkg/@eser/standards/runtime/adapters/node.ts"() {
+    init_types();
+    init_shared();
+    NODE_CAPABILITIES = {
+      fs: true,
+      fsSync: true,
+      exec: true,
+      process: true,
+      env: true,
+      stdin: true,
+      stdout: true,
+      kv: false
+    };
+    createNodeFs = () => {
+      const mapStats = (stats) => ({
+        isFile: stats.isFile(),
+        isDirectory: stats.isDirectory(),
+        isSymlink: stats.isSymbolicLink(),
+        size: stats.size,
+        mtime: stats.mtime,
+        atime: stats.atime,
+        birthtime: stats.birthtime
       });
+      const handleError = (error, path) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+          throw new NotFoundError(path);
+        }
+        throw error;
+      };
       return {
         async readFile(path, options) {
           try {
-            return await Deno.readFile(path, {
+            const buffer = await nodeFsPromises.readFile(path, {
               signal: options?.signal
             });
+            return new Uint8Array(buffer);
           } catch (error) {
-            if (error instanceof Deno.errors.NotFound) {
-              throw new NotFoundError(path);
-            }
-            throw error;
+            return handleError(error, path);
           }
         },
         async readTextFile(path, options) {
           try {
-            return await Deno.readTextFile(path, {
+            return await nodeFsPromises.readFile(path, {
+              encoding: "utf-8",
               signal: options?.signal
             });
           } catch (error) {
-            if (error instanceof Deno.errors.NotFound) {
-              throw new NotFoundError(path);
-            }
-            throw error;
+            return handleError(error, path);
           }
         },
         async writeFile(path, data, options) {
-          await Deno.writeFile(path, data, {
+          const flag = options?.append ? "a" : "w";
+          await nodeFsPromises.writeFile(path, data, {
             signal: options?.signal,
             mode: options?.mode,
-            create: options?.create ?? true,
-            append: options?.append ?? false
+            flag
           });
         },
         async writeTextFile(path, data, options) {
-          await Deno.writeTextFile(path, data, {
+          const flag = options?.append ? "a" : "w";
+          await nodeFsPromises.writeFile(path, data, {
+            encoding: "utf-8",
             signal: options?.signal,
             mode: options?.mode,
-            create: options?.create ?? true,
-            append: options?.append ?? false
+            flag
           });
         },
         async exists(path) {
           try {
-            await Deno.stat(path);
+            await nodeFsPromises.access(path);
             return true;
-          } catch (error) {
-            if (error instanceof Deno.errors.NotFound) {
-              return false;
-            }
-            throw error;
+          } catch {
+            return false;
           }
         },
         async stat(path) {
           try {
-            const info = await Deno.stat(path);
-            return mapFileInfo(info);
+            const stats = await nodeFsPromises.stat(path);
+            return mapStats(stats);
           } catch (error) {
-            if (error instanceof Deno.errors.NotFound) {
-              throw new NotFoundError(path);
-            }
-            throw error;
+            return handleError(error, path);
           }
         },
         async lstat(path) {
           try {
-            const info = await Deno.lstat(path);
-            return mapFileInfo(info);
+            const stats = await nodeFsPromises.lstat(path);
+            return mapStats(stats);
           } catch (error) {
-            if (error instanceof Deno.errors.NotFound) {
-              throw new NotFoundError(path);
-            }
-            throw error;
+            return handleError(error, path);
           }
         },
         async mkdir(path, options) {
-          await Deno.mkdir(path, {
+          await nodeFsPromises.mkdir(path, {
             recursive: options?.recursive ?? false,
             mode: options?.mode
           });
         },
         async remove(path, options) {
           try {
-            await Deno.remove(path, {
-              recursive: options?.recursive ?? false
+            await nodeFsPromises.rm(path, {
+              recursive: options?.recursive ?? false,
+              force: false
             });
           } catch (error) {
-            if (error instanceof Deno.errors.NotFound) {
-              throw new NotFoundError(path);
-            }
-            throw error;
+            handleError(error, path);
           }
         },
         async *readDir(path) {
           try {
-            for await (const entry of Deno.readDir(path)) {
+            const entries = await nodeFsPromises.readdir(path, {
+              withFileTypes: true
+            });
+            for (const entry of entries) {
               yield {
                 name: entry.name,
-                isFile: entry.isFile,
-                isDirectory: entry.isDirectory,
-                isSymlink: entry.isSymlink
+                isFile: entry.isFile(),
+                isDirectory: entry.isDirectory(),
+                isSymlink: entry.isSymbolicLink()
               };
             }
           } catch (error) {
-            if (error instanceof Deno.errors.NotFound) {
-              throw new NotFoundError(path);
-            }
-            throw error;
+            handleError(error, path);
           }
         },
         async copyFile(from, to) {
-          await Deno.copyFile(from, to);
+          await nodeFsPromises.copyFile(from, to);
         },
         async rename(from, to) {
-          await Deno.rename(from, to);
+          await nodeFsPromises.rename(from, to);
         },
         async makeTempDir(options) {
-          return await Deno.makeTempDir({
-            dir: options?.dir,
-            prefix: options?.prefix,
-            suffix: options?.suffix
-          });
+          const dir = options?.dir ?? nodeOs.tmpdir();
+          const prefix = options?.prefix ?? "";
+          const suffix = options?.suffix ?? "";
+          const tempPath = await nodeFsPromises.mkdtemp(nodePath.join(dir, prefix));
+          if (suffix) {
+            const newPath = tempPath + suffix;
+            await nodeFsPromises.rename(tempPath, newPath);
+            return newPath;
+          }
+          return tempPath;
         }
       };
     };
-    createDenoPath = () => {
+    createNodePath = () => {
       return {
-        join: join4,
-        resolve: resolve4,
-        dirname: dirname4,
-        basename: basename4,
-        extname: extname4,
-        normalize: normalize4,
-        isAbsolute: isAbsolute4,
-        relative: relative4,
-        parse: parse4,
-        format: format4,
-        sep: SEPARATOR,
-        delimiter: DELIMITER
+        join: nodePath.join,
+        resolve: nodePath.resolve,
+        dirname: nodePath.dirname,
+        basename: nodePath.basename,
+        extname: nodePath.extname,
+        normalize: nodePath.normalize,
+        isAbsolute: nodePath.isAbsolute,
+        relative: nodePath.relative,
+        parse: nodePath.parse,
+        format: nodePath.format,
+        sep: nodePath.sep,
+        delimiter: nodePath.delimiter
       };
     };
-    createDenoExec = () => {
+    createNodeExec = () => {
       return {
-        async spawn(cmd, args = [], options) {
-          const stdoutMode = options?.stdout ?? "piped";
-          const stderrMode = options?.stderr ?? "piped";
-          const command = new Deno.Command(cmd, {
-            args,
-            cwd: options?.cwd,
-            env: options?.env,
-            stdin: options?.stdin ?? "null",
-            stdout: stdoutMode,
-            stderr: stderrMode,
-            signal: options?.signal
+        spawn(cmd, args = [], options) {
+          return new Promise((resolve7, reject) => {
+            const proc = nodeChildProcess.spawn(cmd, args, {
+              cwd: options?.cwd,
+              env: options?.env ? {
+                ...nodeProcess.env,
+                ...options.env
+              } : void 0,
+              stdio: getNodeStdioArray(options),
+              signal: options?.signal
+            });
+            const stdoutChunks = [];
+            const stderrChunks = [];
+            proc.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
+            proc.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
+            proc.on("error", reject);
+            proc.on("close", (code2) => {
+              resolve7({
+                success: code2 === 0,
+                code: code2 ?? 1,
+                stdout: new Uint8Array(Buffer2.concat(stdoutChunks)),
+                stderr: new Uint8Array(Buffer2.concat(stderrChunks))
+              });
+            });
           });
-          const result = await command.output();
-          return {
-            success: result.success,
-            code: result.code,
-            stdout: stdoutMode === "piped" ? result.stdout : new Uint8Array(),
-            stderr: stderrMode === "piped" ? result.stderr : new Uint8Array()
-          };
         },
         async exec(cmd, args = [], options) {
           const result = await this.spawn(cmd, args, options);
@@ -2775,103 +2694,110 @@ var init_deno = __esm({
           return JSON.parse(output);
         },
         spawnChild(cmd, args = [], options) {
-          const stdinMode = options?.stdin ?? "null";
-          const stdoutMode = options?.stdout ?? "piped";
-          const stderrMode = options?.stderr ?? "piped";
-          const command = new Deno.Command(cmd, {
-            args,
+          const proc = nodeChildProcess.spawn(cmd, args, {
             cwd: options?.cwd,
-            env: options?.env,
-            stdin: stdinMode,
-            stdout: stdoutMode,
-            stderr: stderrMode,
+            env: options?.env ? {
+              ...nodeProcess.env,
+              ...options.env
+            } : void 0,
+            stdio: getNodeStdioArray(options),
             signal: options?.signal
           });
-          const process = command.spawn();
+          const stdoutChunks = [];
+          const stderrChunks = [];
+          proc.stdout?.on("data", (chunk) => stdoutChunks.push(chunk));
+          proc.stderr?.on("data", (chunk) => stderrChunks.push(chunk));
+          const statusPromise = new Promise((resolve7, reject) => {
+            proc.on("error", reject);
+            proc.on("close", (code2, signal) => {
+              resolve7({
+                success: code2 === 0,
+                code: code2 ?? 1,
+                signal: signal ?? void 0
+              });
+            });
+          });
           return {
-            pid: process.pid,
-            // Only access streams if they were configured as "piped"
-            stdin: stdinMode === "piped" ? process.stdin : null,
-            stdout: stdoutMode === "piped" ? process.stdout : null,
-            stderr: stderrMode === "piped" ? process.stderr : null,
-            status: process.status.then((status) => ({
-              success: status.success,
-              code: status.code,
-              signal: status.signal ?? void 0
-            })),
+            pid: proc.pid,
+            stdin: proc.stdin ? Writable.toWeb(proc.stdin) : null,
+            stdout: proc.stdout ? Readable.toWeb(proc.stdout) : null,
+            stderr: proc.stderr ? Readable.toWeb(proc.stderr) : null,
+            status: statusPromise,
             output: async () => {
-              const [status, stdout, stderr] = await Promise.all([
-                process.status,
-                stdoutMode === "piped" ? new Response(process.stdout).arrayBuffer().then((b) => new Uint8Array(b)) : Promise.resolve(new Uint8Array()),
-                stderrMode === "piped" ? new Response(process.stderr).arrayBuffer().then((b) => new Uint8Array(b)) : Promise.resolve(new Uint8Array())
-              ]);
+              const status = await statusPromise;
               return {
                 success: status.success,
                 code: status.code,
-                stdout,
-                stderr
+                stdout: new Uint8Array(Buffer2.concat(stdoutChunks)),
+                stderr: new Uint8Array(Buffer2.concat(stderrChunks))
               };
             },
             kill: (signal) => {
-              process.kill(signal);
+              proc.kill(signal);
             }
           };
         }
       };
     };
-    createDenoEnv = () => {
+    createNodeEnv = () => {
       return {
         get(key) {
-          return Deno.env.get(key);
+          return nodeProcess.env[key];
         },
         set(key, value2) {
-          Deno.env.set(key, value2);
+          nodeProcess.env[key] = value2;
         },
         delete(key) {
-          Deno.env.delete(key);
+          delete nodeProcess.env[key];
         },
         has(key) {
-          return Deno.env.get(key) !== void 0;
+          return key in nodeProcess.env;
         },
         toObject() {
-          return Deno.env.toObject();
+          const result = {};
+          for (const [key, value2] of Object.entries(nodeProcess.env)) {
+            if (value2 !== void 0) {
+              result[key] = value2;
+            }
+          }
+          return result;
         }
       };
     };
-    createDenoProcess = () => {
+    createNodeProcess = () => {
       return {
         exit(code2) {
-          Deno.exit(code2);
+          nodeProcess.exit(code2);
         },
         cwd() {
-          return Deno.cwd();
+          return nodeProcess.cwd();
         },
         chdir(path) {
-          Deno.chdir(path);
+          nodeProcess.chdir(path);
         },
         hostname() {
-          return Deno.hostname();
+          return nodeOs.hostname();
         },
         execPath() {
-          return Deno.execPath();
+          return nodeProcess.execPath;
         },
-        args: Deno.args,
-        pid: Deno.pid,
-        stdin: Deno.stdin.readable,
-        stdout: Deno.stdout.writable,
-        stderr: Deno.stderr.writable
+        args: nodeProcess.argv.slice(2),
+        pid: nodeProcess.pid,
+        stdin: Readable.toWeb(nodeProcess.stdin),
+        stdout: Writable.toWeb(nodeProcess.stdout),
+        stderr: Writable.toWeb(nodeProcess.stderr)
       };
     };
-    createDenoRuntime = () => {
-      const fs = createDenoFs();
-      const path = createDenoPath();
-      const exec2 = createDenoExec();
-      const env = createDenoEnv();
-      const process = createDenoProcess();
+    createNodeRuntime = () => {
+      const fs = createNodeFs();
+      const path = createNodePath();
+      const exec2 = createNodeExec();
+      const env = createNodeEnv();
+      const process = createNodeProcess();
       return {
-        name: "deno",
-        version: Deno.version.deno,
-        capabilities: DENO_CAPABILITIES,
+        name: "node",
+        version: nodeProcess.versions.node,
+        capabilities: NODE_CAPABILITIES,
         fs,
         path,
         exec: exec2,
@@ -2882,20 +2808,28 @@ var init_deno = __esm({
   }
 });
 
-// pkg/@eser/standards/runtime/adapters/node.ts
-import * as nodeFsPromises from "node:fs/promises";
-import * as nodePath from "node:path";
-import * as nodeOs from "node:os";
-import * as nodeChildProcess from "node:child_process";
-import nodeProcess from "node:process";
-import { Buffer as Buffer2 } from "node:buffer";
-import { Readable, Writable } from "node:stream";
-var createNodeFs, createNodePath, createNodeExec, createNodeEnv, createNodeProcess, createNodeRuntime;
-var init_node = __esm({
-  "pkg/@eser/standards/runtime/adapters/node.ts"() {
+// pkg/@eser/standards/runtime/adapters/bun.ts
+import * as nodeFsPromises2 from "node:fs/promises";
+import * as nodePath2 from "node:path";
+import * as nodeOs2 from "node:os";
+import nodeProcess2 from "node:process";
+import { Readable as Readable2, Writable as Writable2 } from "node:stream";
+var BUN_CAPABILITIES, createBunFs, createBunPath, readStream, createBunExec, createBunEnv, createBunProcess, createBunRuntime;
+var init_bun = __esm({
+  "pkg/@eser/standards/runtime/adapters/bun.ts"() {
     init_types();
-    init_capabilities();
-    createNodeFs = () => {
+    init_shared();
+    BUN_CAPABILITIES = {
+      fs: true,
+      fsSync: true,
+      exec: true,
+      process: true,
+      env: true,
+      stdin: true,
+      stdout: true,
+      kv: false
+    };
+    createBunFs = () => {
       const mapStats = (stats) => ({
         isFile: stats.isFile(),
         isDirectory: stats.isDirectory(),
@@ -2914,7 +2848,7 @@ var init_node = __esm({
       return {
         async readFile(path, options) {
           try {
-            const buffer = await nodeFsPromises.readFile(path, {
+            const buffer = await nodeFsPromises2.readFile(path, {
               signal: options?.signal
             });
             return new Uint8Array(buffer);
@@ -2924,7 +2858,7 @@ var init_node = __esm({
         },
         async readTextFile(path, options) {
           try {
-            return await nodeFsPromises.readFile(path, {
+            return await nodeFsPromises2.readFile(path, {
               encoding: "utf-8",
               signal: options?.signal
             });
@@ -2934,7 +2868,7 @@ var init_node = __esm({
         },
         async writeFile(path, data, options) {
           const flag = options?.append ? "a" : "w";
-          await nodeFsPromises.writeFile(path, data, {
+          await nodeFsPromises2.writeFile(path, data, {
             signal: options?.signal,
             mode: options?.mode,
             flag
@@ -2942,7 +2876,7 @@ var init_node = __esm({
         },
         async writeTextFile(path, data, options) {
           const flag = options?.append ? "a" : "w";
-          await nodeFsPromises.writeFile(path, data, {
+          await nodeFsPromises2.writeFile(path, data, {
             encoding: "utf-8",
             signal: options?.signal,
             mode: options?.mode,
@@ -2951,7 +2885,7 @@ var init_node = __esm({
         },
         async exists(path) {
           try {
-            await nodeFsPromises.access(path);
+            await nodeFsPromises2.access(path);
             return true;
           } catch {
             return false;
@@ -2959,7 +2893,7 @@ var init_node = __esm({
         },
         async stat(path) {
           try {
-            const stats = await nodeFsPromises.stat(path);
+            const stats = await nodeFsPromises2.stat(path);
             return mapStats(stats);
           } catch (error) {
             return handleError(error, path);
@@ -2967,21 +2901,21 @@ var init_node = __esm({
         },
         async lstat(path) {
           try {
-            const stats = await nodeFsPromises.lstat(path);
+            const stats = await nodeFsPromises2.lstat(path);
             return mapStats(stats);
           } catch (error) {
             return handleError(error, path);
           }
         },
         async mkdir(path, options) {
-          await nodeFsPromises.mkdir(path, {
+          await nodeFsPromises2.mkdir(path, {
             recursive: options?.recursive ?? false,
             mode: options?.mode
           });
         },
         async remove(path, options) {
           try {
-            await nodeFsPromises.rm(path, {
+            await nodeFsPromises2.rm(path, {
               recursive: options?.recursive ?? false,
               force: false
             });
@@ -2991,7 +2925,7 @@ var init_node = __esm({
         },
         async *readDir(path) {
           try {
-            const entries = await nodeFsPromises.readdir(path, {
+            const entries = await nodeFsPromises2.readdir(path, {
               withFileTypes: true
             });
             for (const entry of entries) {
@@ -3007,78 +2941,88 @@ var init_node = __esm({
           }
         },
         async copyFile(from, to) {
-          await nodeFsPromises.copyFile(from, to);
+          await nodeFsPromises2.copyFile(from, to);
         },
         async rename(from, to) {
-          await nodeFsPromises.rename(from, to);
+          await nodeFsPromises2.rename(from, to);
         },
         async makeTempDir(options) {
-          const dir = options?.dir ?? nodeOs.tmpdir();
+          const dir = options?.dir ?? nodeOs2.tmpdir();
           const prefix = options?.prefix ?? "";
           const suffix = options?.suffix ?? "";
-          const tempPath = await nodeFsPromises.mkdtemp(nodePath.join(dir, prefix));
+          const tempPath = await nodeFsPromises2.mkdtemp(nodePath2.join(dir, prefix));
           if (suffix) {
             const newPath = tempPath + suffix;
-            await nodeFsPromises.rename(tempPath, newPath);
+            await nodeFsPromises2.rename(tempPath, newPath);
             return newPath;
           }
           return tempPath;
         }
       };
     };
-    createNodePath = () => {
+    createBunPath = () => {
       return {
-        join: nodePath.join,
-        resolve: nodePath.resolve,
-        dirname: nodePath.dirname,
-        basename: nodePath.basename,
-        extname: nodePath.extname,
-        normalize: nodePath.normalize,
-        isAbsolute: nodePath.isAbsolute,
-        relative: nodePath.relative,
-        parse: nodePath.parse,
-        format: nodePath.format,
-        sep: nodePath.sep,
-        delimiter: nodePath.delimiter
+        join: nodePath2.join,
+        resolve: nodePath2.resolve,
+        dirname: nodePath2.dirname,
+        basename: nodePath2.basename,
+        extname: nodePath2.extname,
+        normalize: nodePath2.normalize,
+        isAbsolute: nodePath2.isAbsolute,
+        relative: nodePath2.relative,
+        parse: nodePath2.parse,
+        format: nodePath2.format,
+        sep: nodePath2.sep,
+        delimiter: nodePath2.delimiter
       };
     };
-    createNodeExec = () => {
+    readStream = async (stream) => {
+      if (!stream) return new Uint8Array(0);
+      const chunks = [];
+      const reader = stream.getReader();
+      try {
+        while (true) {
+          const { done, value: value2 } = await reader.read();
+          if (done) break;
+          chunks.push(value2);
+        }
+      } finally {
+        reader.releaseLock();
+      }
+      const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+      const result = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+      }
+      return result;
+    };
+    createBunExec = () => {
       return {
-        spawn(cmd, args = [], options) {
-          return new Promise((resolve7, reject) => {
-            const proc = nodeChildProcess.spawn(cmd, args, {
-              cwd: options?.cwd,
-              env: options?.env ? {
-                ...nodeProcess.env,
-                ...options.env
-              } : void 0,
-              stdio: [
-                options?.stdin === "inherit" ? "inherit" : options?.stdin === "piped" ? "pipe" : "ignore",
-                options?.stdout === "inherit" ? "inherit" : options?.stdout === "null" ? "ignore" : "pipe",
-                options?.stderr === "inherit" ? "inherit" : options?.stderr === "null" ? "ignore" : "pipe"
-              ],
-              signal: options?.signal
-            });
-            const stdoutChunks = [];
-            const stderrChunks = [];
-            proc.stdout?.on("data", (chunk) => {
-              stdoutChunks.push(chunk);
-            });
-            proc.stderr?.on("data", (chunk) => {
-              stderrChunks.push(chunk);
-            });
-            proc.on("error", reject);
-            proc.on("close", (code2) => {
-              const stdout = new Uint8Array(Buffer2.concat(stdoutChunks));
-              const stderr = new Uint8Array(Buffer2.concat(stderrChunks));
-              resolve7({
-                success: code2 === 0,
-                code: code2 ?? 1,
-                stdout,
-                stderr
-              });
-            });
+        async spawn(cmd, args = [], options) {
+          const [stdinMode, stdoutMode, stderrMode] = getNodeStdioArray(options);
+          const proc = Bun.spawn([
+            cmd,
+            ...args
+          ], {
+            cwd: options?.cwd,
+            env: options?.env,
+            stdin: stdinMode,
+            stdout: stdoutMode,
+            stderr: stderrMode
           });
+          const [exitCode, stdout, stderr] = await Promise.all([
+            proc.exited,
+            readStream(proc.stdout),
+            readStream(proc.stderr)
+          ]);
+          return {
+            success: exitCode === 0,
+            code: exitCode,
+            stdout,
+            stderr
+          };
         },
         async exec(cmd, args = [], options) {
           const result = await this.spawn(cmd, args, options);
@@ -3093,59 +3037,39 @@ var init_node = __esm({
           return JSON.parse(output);
         },
         spawnChild(cmd, args = [], options) {
-          const mapStdio = (value2) => {
-            if (value2 === "inherit") {
-              return "inherit";
-            }
-            if (value2 === "piped") {
-              return "pipe";
-            }
-            return "ignore";
-          };
-          const proc = nodeChildProcess.spawn(cmd, args, {
+          const [stdinMode, stdoutMode, stderrMode] = getNodeStdioArray(options);
+          const proc = Bun.spawn([
+            cmd,
+            ...args
+          ], {
             cwd: options?.cwd,
-            env: options?.env ? {
-              ...nodeProcess.env,
-              ...options.env
-            } : void 0,
-            stdio: [
-              mapStdio(options?.stdin),
-              mapStdio(options?.stdout ?? "piped"),
-              mapStdio(options?.stderr ?? "piped")
-            ],
-            signal: options?.signal
-          });
-          const stdoutChunks = [];
-          const stderrChunks = [];
-          proc.stdout?.on("data", (chunk) => {
-            stdoutChunks.push(chunk);
-          });
-          proc.stderr?.on("data", (chunk) => {
-            stderrChunks.push(chunk);
-          });
-          const statusPromise = new Promise((resolve7, reject) => {
-            proc.on("error", reject);
-            proc.on("close", (code2, signal) => {
-              resolve7({
-                success: code2 === 0,
-                code: code2 ?? 1,
-                signal: signal ?? void 0
-              });
-            });
+            env: options?.env,
+            stdin: stdinMode,
+            stdout: stdoutMode,
+            stderr: stderrMode
           });
+          const statusPromise = proc.exited.then((code2) => ({
+            success: code2 === 0,
+            code: code2,
+            signal: void 0
+          }));
           return {
             pid: proc.pid,
-            stdin: proc.stdin ? Writable.toWeb(proc.stdin) : null,
-            stdout: proc.stdout ? Readable.toWeb(proc.stdout) : null,
-            stderr: proc.stderr ? Readable.toWeb(proc.stderr) : null,
+            stdin: proc.stdin,
+            stdout: proc.stdout,
+            stderr: proc.stderr,
             status: statusPromise,
             output: async () => {
-              const status = await statusPromise;
+              const [status, stdout, stderr] = await Promise.all([
+                statusPromise,
+                readStream(proc.stdout),
+                readStream(proc.stderr)
+              ]);
               return {
                 success: status.success,
                 code: status.code,
-                stdout: new Uint8Array(Buffer2.concat(stdoutChunks)),
-                stderr: new Uint8Array(Buffer2.concat(stderrChunks))
+                stdout,
+                stderr
               };
             },
             kill: (signal) => {
@@ -3155,23 +3079,23 @@ var init_node = __esm({
         }
       };
     };
-    createNodeEnv = () => {
+    createBunEnv = () => {
       return {
         get(key) {
-          return nodeProcess.env[key];
+          return nodeProcess2.env[key];
         },
         set(key, value2) {
-          nodeProcess.env[key] = value2;
+          nodeProcess2.env[key] = value2;
         },
         delete(key) {
-          delete nodeProcess.env[key];
+          delete nodeProcess2.env[key];
         },
         has(key) {
-          return key in nodeProcess.env;
+          return key in nodeProcess2.env;
         },
         toObject() {
           const result = {};
-          for (const [key, value2] of Object.entries(nodeProcess.env)) {
+          for (const [key, value2] of Object.entries(nodeProcess2.env)) {
             if (value2 !== void 0) {
               result[key] = value2;
             }
@@ -3180,40 +3104,40 @@ var init_node = __esm({
         }
       };
     };
-    createNodeProcess = () => {
+    createBunProcess = () => {
       return {
         exit(code2) {
-          nodeProcess.exit(code2);
+          nodeProcess2.exit(code2);
         },
         cwd() {
-          return nodeProcess.cwd();
+          return nodeProcess2.cwd();
         },
         chdir(path) {
-          nodeProcess.chdir(path);
+          nodeProcess2.chdir(path);
         },
         hostname() {
-          return nodeOs.hostname();
+          return nodeOs2.hostname();
         },
         execPath() {
-          return nodeProcess.execPath;
+          return nodeProcess2.execPath;
         },
-        args: nodeProcess.argv.slice(2),
-        pid: nodeProcess.pid,
-        stdin: Readable.toWeb(nodeProcess.stdin),
-        stdout: Writable.toWeb(nodeProcess.stdout),
-        stderr: Writable.toWeb(nodeProcess.stderr)
+        args: nodeProcess2.argv.slice(2),
+        pid: nodeProcess2.pid,
+        stdin: Readable2.toWeb(nodeProcess2.stdin),
+        stdout: Writable2.toWeb(nodeProcess2.stdout),
+        stderr: Writable2.toWeb(nodeProcess2.stderr)
       };
     };
-    createNodeRuntime = () => {
-      const fs = createNodeFs();
-      const path = createNodePath();
-      const exec2 = createNodeExec();
-      const env = createNodeEnv();
-      const process = createNodeProcess();
+    createBunRuntime = () => {
+      const fs = createBunFs();
+      const path = createBunPath();
+      const exec2 = createBunExec();
+      const env = createBunEnv();
+      const process = createBunProcess();
       return {
-        name: "node",
-        version: nodeProcess.versions.node,
-        capabilities: NODE_CAPABILITIES,
+        name: "bun",
+        version: Bun.version,
+        capabilities: BUN_CAPABILITIES,
         fs,
         path,
         exec: exec2,
@@ -3224,324 +3148,307 @@ var init_node = __esm({
   }
 });
 
-// pkg/@eser/standards/runtime/adapters/bun.ts
-import * as nodeFsPromises2 from "node:fs/promises";
-import * as nodePath2 from "node:path";
-import * as nodeOs2 from "node:os";
-import nodeProcess2 from "node:process";
-import { Readable as Readable2, Writable as Writable2 } from "node:stream";
-var createBunFs, createBunPath, readStream, createBunExec, createBunEnv, createBunProcess, createBunRuntime;
-var init_bun = __esm({
-  "pkg/@eser/standards/runtime/adapters/bun.ts"() {
-    init_types();
-    init_capabilities();
-    createBunFs = () => {
-      const mapStats = (stats) => ({
-        isFile: stats.isFile(),
-        isDirectory: stats.isDirectory(),
-        isSymlink: stats.isSymbolicLink(),
-        size: stats.size,
-        mtime: stats.mtime,
-        atime: stats.atime,
-        birthtime: stats.birthtime
-      });
-      const handleError = (error, path) => {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-          throw new NotFoundError(path);
+// pkg/@eser/standards/runtime/polyfills/path.ts
+var POSIX_SEP, POSIX_DELIMITER, normalizeSlashes, join6, resolve6, dirname6, basename6, extname6, normalize6, isAbsolute6, relative6, parse6, format6, posixPath;
+var init_path = __esm({
+  "pkg/@eser/standards/runtime/polyfills/path.ts"() {
+    POSIX_SEP = "/";
+    POSIX_DELIMITER = ":";
+    normalizeSlashes = (path) => {
+      return path.replace(/\\/g, "/").replace(/\/+/g, "/");
+    };
+    join6 = (...paths) => {
+      if (paths.length === 0) return ".";
+      const joined = paths.filter((p) => p.length > 0).join(POSIX_SEP);
+      if (joined.length === 0) return ".";
+      return normalize6(joined);
+    };
+    resolve6 = (...paths) => {
+      let resolvedPath = "";
+      let resolvedAbsolute = false;
+      for (let i = paths.length - 1; i >= 0 && !resolvedAbsolute; i--) {
+        const segment = paths[i];
+        if (segment === void 0 || segment.length === 0) continue;
+        resolvedPath = `${segment}/${resolvedPath}`;
+        resolvedAbsolute = isAbsolute6(segment);
+      }
+      resolvedPath = normalizeSlashes(resolvedPath);
+      if (resolvedPath.length > 1 && resolvedPath.endsWith("/")) {
+        resolvedPath = resolvedPath.slice(0, -1);
+      }
+      return normalize6(resolvedPath) ?? ".";
+    };
+    dirname6 = (path) => {
+      if (path.length === 0) return ".";
+      path = normalizeSlashes(path);
+      while (path.length > 1 && path.endsWith("/")) {
+        path = path.slice(0, -1);
+      }
+      const lastSlash = path.lastIndexOf("/");
+      if (lastSlash === -1) return ".";
+      if (lastSlash === 0) return "/";
+      return path.slice(0, lastSlash);
+    };
+    basename6 = (path, suffix) => {
+      if (path.length === 0) return "";
+      path = normalizeSlashes(path);
+      while (path.length > 1 && path.endsWith("/")) {
+        path = path.slice(0, -1);
+      }
+      const lastSlash = path.lastIndexOf("/");
+      let base = lastSlash === -1 ? path : path.slice(lastSlash + 1);
+      if (suffix && base.endsWith(suffix)) {
+        base = base.slice(0, -suffix.length);
+      }
+      return base;
+    };
+    extname6 = (path) => {
+      const base = basename6(path);
+      const lastDot = base.lastIndexOf(".");
+      if (lastDot <= 0 || lastDot === base.length - 1) {
+        return "";
+      }
+      return base.slice(lastDot);
+    };
+    normalize6 = (path) => {
+      if (path.length === 0) return ".";
+      path = normalizeSlashes(path);
+      const isAbs = path.startsWith("/");
+      const trailingSlash = path.endsWith("/");
+      const segments = path.split("/").filter((s) => s.length > 0);
+      const result = [];
+      for (const segment of segments) {
+        if (segment === ".") {
+          continue;
         }
-        throw error;
-      };
-      return {
-        async readFile(path, options) {
-          try {
-            const buffer = await nodeFsPromises2.readFile(path, {
-              signal: options?.signal
-            });
-            return new Uint8Array(buffer);
-          } catch (error) {
-            return handleError(error, path);
-          }
-        },
-        async readTextFile(path, options) {
-          try {
-            return await nodeFsPromises2.readFile(path, {
-              encoding: "utf-8",
-              signal: options?.signal
-            });
-          } catch (error) {
-            return handleError(error, path);
-          }
-        },
-        async writeFile(path, data, options) {
-          const flag = options?.append ? "a" : "w";
-          await nodeFsPromises2.writeFile(path, data, {
-            signal: options?.signal,
-            mode: options?.mode,
-            flag
-          });
-        },
-        async writeTextFile(path, data, options) {
-          const flag = options?.append ? "a" : "w";
-          await nodeFsPromises2.writeFile(path, data, {
-            encoding: "utf-8",
-            signal: options?.signal,
-            mode: options?.mode,
-            flag
-          });
-        },
-        async exists(path) {
-          try {
-            await nodeFsPromises2.access(path);
-            return true;
-          } catch {
-            return false;
-          }
-        },
-        async stat(path) {
-          try {
-            const stats = await nodeFsPromises2.stat(path);
-            return mapStats(stats);
-          } catch (error) {
-            return handleError(error, path);
-          }
-        },
-        async lstat(path) {
-          try {
-            const stats = await nodeFsPromises2.lstat(path);
-            return mapStats(stats);
-          } catch (error) {
-            return handleError(error, path);
-          }
-        },
-        async mkdir(path, options) {
-          await nodeFsPromises2.mkdir(path, {
-            recursive: options?.recursive ?? false,
-            mode: options?.mode
-          });
-        },
-        async remove(path, options) {
-          try {
-            await nodeFsPromises2.rm(path, {
-              recursive: options?.recursive ?? false,
-              force: false
-            });
-          } catch (error) {
-            handleError(error, path);
-          }
-        },
-        async *readDir(path) {
-          try {
-            const entries = await nodeFsPromises2.readdir(path, {
-              withFileTypes: true
-            });
-            for (const entry of entries) {
-              yield {
-                name: entry.name,
-                isFile: entry.isFile(),
-                isDirectory: entry.isDirectory(),
-                isSymlink: entry.isSymbolicLink()
-              };
-            }
-          } catch (error) {
-            handleError(error, path);
-          }
-        },
-        async copyFile(from, to) {
-          await nodeFsPromises2.copyFile(from, to);
-        },
-        async rename(from, to) {
-          await nodeFsPromises2.rename(from, to);
-        },
-        async makeTempDir(options) {
-          const dir = options?.dir ?? nodeOs2.tmpdir();
-          const prefix = options?.prefix ?? "";
-          const suffix = options?.suffix ?? "";
-          const tempPath = await nodeFsPromises2.mkdtemp(nodePath2.join(dir, prefix));
-          if (suffix) {
-            const newPath = tempPath + suffix;
-            await nodeFsPromises2.rename(tempPath, newPath);
-            return newPath;
+        if (segment === "..") {
+          if (result.length > 0 && result[result.length - 1] !== "..") {
+            result.pop();
+          } else if (!isAbs) {
+            result.push("..");
           }
-          return tempPath;
+        } else {
+          result.push(segment);
         }
-      };
+      }
+      let normalized = result.join("/");
+      if (isAbs) {
+        normalized = `/${normalized}`;
+      }
+      if (trailingSlash && normalized.length > 1) {
+        normalized += "/";
+      }
+      return normalized ?? ".";
+    };
+    isAbsolute6 = (path) => {
+      if (path.length === 0) return false;
+      if (path.startsWith("/")) return true;
+      if (path.length >= 3 && /^[a-zA-Z]:[/\\]/.test(path)) {
+        return true;
+      }
+      return false;
     };
-    createBunPath = () => {
+    relative6 = (from, to) => {
+      if (from === to) return "";
+      from = resolve6(from);
+      to = resolve6(to);
+      if (from === to) return "";
+      const fromParts = from.split("/").filter((p) => p.length > 0);
+      const toParts = to.split("/").filter((p) => p.length > 0);
+      let commonLength = 0;
+      const minLength = Math.min(fromParts.length, toParts.length);
+      for (let i = 0; i < minLength; i++) {
+        if (fromParts[i] !== toParts[i]) break;
+        commonLength++;
+      }
+      const upCount = fromParts.length - commonLength;
+      const remaining = toParts.slice(commonLength);
+      const result = [
+        ...Array(upCount).fill(".."),
+        ...remaining
+      ];
+      return result.join("/") ?? ".";
+    };
+    parse6 = (path) => {
+      if (path.length === 0) {
+        return {
+          root: "",
+          dir: "",
+          base: "",
+          ext: "",
+          name: ""
+        };
+      }
+      path = normalizeSlashes(path);
+      let root = "";
+      let dir = "";
+      const base = basename6(path);
+      const ext = extname6(path);
+      const name = ext ? base.slice(0, -ext.length) : base;
+      if (path.startsWith("/")) {
+        root = "/";
+      } else if (/^[a-zA-Z]:[/\\]/.test(path)) {
+        root = path.slice(0, 3);
+      }
+      dir = dirname6(path);
+      if (dir === ".") {
+        dir = "";
+      }
       return {
-        join: nodePath2.join,
-        resolve: nodePath2.resolve,
-        dirname: nodePath2.dirname,
-        basename: nodePath2.basename,
-        extname: nodePath2.extname,
-        normalize: nodePath2.normalize,
-        isAbsolute: nodePath2.isAbsolute,
-        relative: nodePath2.relative,
-        parse: nodePath2.parse,
-        format: nodePath2.format,
-        sep: nodePath2.sep,
-        delimiter: nodePath2.delimiter
+        root,
+        dir,
+        base,
+        ext,
+        name
       };
     };
-    readStream = async (stream) => {
-      if (!stream) return new Uint8Array(0);
-      const chunks = [];
-      const reader = stream.getReader();
-      try {
-        while (true) {
-          const { done, value: value2 } = await reader.read();
-          if (done) break;
-          chunks.push(value2);
+    format6 = (pathObject) => {
+      const { root = "", dir, base, ext = "", name = "" } = pathObject;
+      const finalBase = base ?? name + ext;
+      if (dir) {
+        if (dir === root) {
+          return `${dir}${finalBase}`;
         }
-      } finally {
-        reader.releaseLock();
-      }
-      const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
-      const result = new Uint8Array(totalLength);
-      let offset = 0;
-      for (const chunk of chunks) {
-        result.set(chunk, offset);
-        offset += chunk.length;
+        return `${dir}/${finalBase}`;
       }
-      return result;
+      return `${root}${finalBase}`;
     };
-    createBunExec = () => {
+    posixPath = {
+      join: join6,
+      resolve: resolve6,
+      dirname: dirname6,
+      basename: basename6,
+      extname: extname6,
+      normalize: normalize6,
+      isAbsolute: isAbsolute6,
+      relative: relative6,
+      parse: parse6,
+      format: format6,
+      sep: POSIX_SEP,
+      delimiter: POSIX_DELIMITER
+    };
+  }
+});
+
+// pkg/@eser/standards/runtime/adapters/workerd.ts
+var WORKERD_CAPABILITIES, createWorkerdFs, createWorkerdPath, createWorkerdExec, envStorage, createWorkerdEnv, populateEnvFromContext, clearEnv, createWorkerdProcess, createWorkerdRuntime;
+var init_workerd = __esm({
+  "pkg/@eser/standards/runtime/adapters/workerd.ts"() {
+    init_types();
+    init_path();
+    WORKERD_CAPABILITIES = {
+      fs: false,
+      fsSync: false,
+      exec: false,
+      process: false,
+      env: true,
+      stdin: false,
+      stdout: false,
+      kv: true
+    };
+    createWorkerdFs = () => {
+      const throwNotAvailable = () => {
+        throw new RuntimeCapabilityError("fs", "workerd");
+      };
       return {
-        async spawn(cmd, args = [], options) {
-          const proc = Bun.spawn([
-            cmd,
-            ...args
-          ], {
-            cwd: options?.cwd,
-            env: options?.env,
-            stdin: options?.stdin === "inherit" ? "inherit" : options?.stdin === "piped" ? "pipe" : "ignore",
-            stdout: options?.stdout === "inherit" ? "inherit" : options?.stdout === "null" ? "ignore" : "pipe",
-            stderr: options?.stderr === "inherit" ? "inherit" : options?.stderr === "null" ? "ignore" : "pipe"
-          });
-          const [exitCode, stdout, stderr] = await Promise.all([
-            proc.exited,
-            readStream(proc.stdout),
-            readStream(proc.stderr)
-          ]);
-          return {
-            success: exitCode === 0,
-            code: exitCode,
-            stdout,
-            stderr
-          };
-        },
-        async exec(cmd, args = [], options) {
-          const result = await this.spawn(cmd, args, options);
-          if (!result.success) {
-            const stderr = new TextDecoder().decode(result.stderr);
-            throw new ProcessError(cmd, result.code, stderr);
-          }
-          return new TextDecoder().decode(result.stdout).trim();
-        },
-        async execJson(cmd, args = [], options) {
-          const output = await this.exec(cmd, args, options);
-          return JSON.parse(output);
+        readFile: throwNotAvailable,
+        readTextFile: throwNotAvailable,
+        writeFile: throwNotAvailable,
+        writeTextFile: throwNotAvailable,
+        exists: throwNotAvailable,
+        stat: throwNotAvailable,
+        lstat: throwNotAvailable,
+        mkdir: throwNotAvailable,
+        remove: throwNotAvailable,
+        readDir: () => {
+          throw new RuntimeCapabilityError("fs", "workerd");
         },
-        spawnChild(cmd, args = [], options) {
-          const proc = Bun.spawn([
-            cmd,
-            ...args
-          ], {
-            cwd: options?.cwd,
-            env: options?.env,
-            stdin: options?.stdin === "inherit" ? "inherit" : options?.stdin === "piped" ? "pipe" : "ignore",
-            stdout: options?.stdout === "inherit" ? "inherit" : options?.stdout === "null" ? "ignore" : "pipe",
-            stderr: options?.stderr === "inherit" ? "inherit" : options?.stderr === "null" ? "ignore" : "pipe"
-          });
-          const statusPromise = proc.exited.then((code2) => ({
-            success: code2 === 0,
-            code: code2,
-            signal: void 0
-          }));
-          return {
-            pid: proc.pid,
-            stdin: proc.stdin,
-            stdout: proc.stdout,
-            stderr: proc.stderr,
-            status: statusPromise,
-            output: async () => {
-              const [status, stdout, stderr] = await Promise.all([
-                statusPromise,
-                readStream(proc.stdout),
-                readStream(proc.stderr)
-              ]);
-              return {
-                success: status.success,
-                code: status.code,
-                stdout,
-                stderr
-              };
-            },
-            kill: (signal) => {
-              proc.kill(signal);
-            }
-          };
-        }
+        copyFile: throwNotAvailable,
+        rename: throwNotAvailable,
+        makeTempDir: throwNotAvailable
       };
     };
-    createBunEnv = () => {
+    createWorkerdPath = () => {
+      return posixPath;
+    };
+    createWorkerdExec = () => {
+      const throwNotAvailable = () => {
+        throw new RuntimeCapabilityError("exec", "workerd");
+      };
+      return {
+        spawn: throwNotAvailable,
+        exec: throwNotAvailable,
+        execJson: throwNotAvailable,
+        spawnChild: throwNotAvailable
+      };
+    };
+    envStorage = /* @__PURE__ */ new Map();
+    createWorkerdEnv = () => {
       return {
         get(key) {
-          return nodeProcess2.env[key];
+          return envStorage.get(key);
         },
         set(key, value2) {
-          nodeProcess2.env[key] = value2;
+          envStorage.set(key, value2);
         },
         delete(key) {
-          delete nodeProcess2.env[key];
+          envStorage.delete(key);
         },
         has(key) {
-          return key in nodeProcess2.env;
+          return envStorage.has(key);
         },
         toObject() {
-          const result = {};
-          for (const [key, value2] of Object.entries(nodeProcess2.env)) {
-            if (value2 !== void 0) {
-              result[key] = value2;
-            }
-          }
-          return result;
+          return Object.fromEntries(envStorage);
         }
       };
     };
-    createBunProcess = () => {
+    populateEnvFromContext = (env) => {
+      for (const [key, value2] of Object.entries(env)) {
+        if (value2 !== null && value2 !== void 0 && value2.constructor === String) {
+          envStorage.set(key, value2);
+        }
+      }
+    };
+    clearEnv = () => {
+      envStorage.clear();
+    };
+    createWorkerdProcess = () => {
+      const throwNotAvailable = () => {
+        throw new RuntimeCapabilityError("process", "workerd");
+      };
       return {
-        exit(code2) {
-          nodeProcess2.exit(code2);
-        },
-        cwd() {
-          return nodeProcess2.cwd();
+        exit: throwNotAvailable,
+        cwd: throwNotAvailable,
+        chdir: throwNotAvailable,
+        hostname: throwNotAvailable,
+        execPath: throwNotAvailable,
+        get args() {
+          throw new RuntimeCapabilityError("process", "workerd");
         },
-        chdir(path) {
-          nodeProcess2.chdir(path);
+        get pid() {
+          throw new RuntimeCapabilityError("process", "workerd");
         },
-        hostname() {
-          return nodeOs2.hostname();
+        get stdin() {
+          throw new RuntimeCapabilityError("process", "workerd");
         },
-        execPath() {
-          return nodeProcess2.execPath;
+        get stdout() {
+          throw new RuntimeCapabilityError("process", "workerd");
         },
-        args: nodeProcess2.argv.slice(2),
-        pid: nodeProcess2.pid,
-        stdin: Readable2.toWeb(nodeProcess2.stdin),
-        stdout: Writable2.toWeb(nodeProcess2.stdout),
-        stderr: Writable2.toWeb(nodeProcess2.stderr)
+        get stderr() {
+          throw new RuntimeCapabilityError("process", "workerd");
+        }
       };
     };
-    createBunRuntime = () => {
-      const fs = createBunFs();
-      const path = createBunPath();
-      const exec2 = createBunExec();
-      const env = createBunEnv();
-      const process = createBunProcess();
+    createWorkerdRuntime = () => {
+      const fs = createWorkerdFs();
+      const path = createWorkerdPath();
+      const exec2 = createWorkerdExec();
+      const env = createWorkerdEnv();
+      const process = createWorkerdProcess();
       return {
-        name: "bun",
-        version: Bun.version,
-        capabilities: BUN_CAPABILITIES,
+        name: "workerd",
+        version: "unknown",
+        capabilities: WORKERD_CAPABILITIES,
         fs,
         path,
         exec: exec2,
@@ -3552,6 +3459,103 @@ var init_bun = __esm({
   }
 });
 
+// pkg/@eser/standards/runtime/capabilities.ts
+var FULL_CAPABILITIES, BROWSER_CAPABILITIES, UNKNOWN_CAPABILITIES, getCapabilities, hasCapability;
+var init_capabilities = __esm({
+  "pkg/@eser/standards/runtime/capabilities.ts"() {
+    init_deno();
+    init_node();
+    init_bun();
+    init_workerd();
+    init_deno();
+    init_node();
+    init_bun();
+    init_workerd();
+    FULL_CAPABILITIES = {
+      fs: true,
+      fsSync: true,
+      exec: true,
+      process: true,
+      env: true,
+      stdin: true,
+      stdout: true,
+      kv: false
+    };
+    BROWSER_CAPABILITIES = {
+      fs: false,
+      fsSync: false,
+      exec: false,
+      process: false,
+      env: false,
+      stdin: false,
+      stdout: false,
+      kv: false
+    };
+    UNKNOWN_CAPABILITIES = {
+      fs: false,
+      fsSync: false,
+      exec: false,
+      process: false,
+      env: false,
+      stdin: false,
+      stdout: false,
+      kv: false
+    };
+    getCapabilities = (runtime2) => {
+      switch (runtime2) {
+        case "deno":
+          return DENO_CAPABILITIES;
+        case "node":
+          return NODE_CAPABILITIES;
+        case "bun":
+          return BUN_CAPABILITIES;
+        case "workerd":
+          return WORKERD_CAPABILITIES;
+        case "browser":
+          return BROWSER_CAPABILITIES;
+        default:
+          return UNKNOWN_CAPABILITIES;
+      }
+    };
+    hasCapability = (runtime2, capability) => {
+      return getCapabilities(runtime2)[capability];
+    };
+  }
+});
+
+// pkg/@eser/standards/runtime/file-search.ts
+var searchFileHierarchy;
+var init_file_search = __esm({
+  "pkg/@eser/standards/runtime/file-search.ts"() {
+    init_mod2();
+    searchFileHierarchy = async (startDir, filenames, options = {}) => {
+      const { searchParents = false } = options;
+      let dir = startDir;
+      while (true) {
+        for (const name of filenames) {
+          const filepath = runtime.path.join(dir, name);
+          const exists = await runtime.fs.exists(filepath);
+          if (exists) {
+            const stat3 = await runtime.fs.stat(filepath);
+            if (stat3.isFile) {
+              return filepath;
+            }
+          }
+        }
+        if (!searchParents) {
+          break;
+        }
+        const parent = runtime.path.dirname(dir);
+        if (parent === dir) {
+          break;
+        }
+        dir = parent;
+      }
+      return void 0;
+    };
+  }
+});
+
 // pkg/@eser/standards/runtime/mod.ts
 var mod_exports2 = {};
 __export(mod_exports2, {
@@ -3589,7 +3593,7 @@ __export(mod_exports2, {
   runtime: () => runtime,
   searchFileHierarchy: () => searchFileHierarchy
 });
-var createMinimalRuntime, createRuntime, runtime;
+var createThrowFn, createStubFs, createStubExec, createStubProcess, createStubEnv, createMinimalRuntime, runtimeFactories, overrideKeys, hasOverrides, mergeRuntime, createRuntime, runtime;
 var init_mod2 = __esm({
   "pkg/@eser/standards/runtime/mod.ts"() {
     init_types();
@@ -3607,111 +3611,116 @@ var init_mod2 = __esm({
     init_node();
     init_bun();
     init_workerd();
-    createMinimalRuntime = (name, capabilities = UNKNOWN_CAPABILITIES) => {
-      const throwFs = () => {
-        throw new RuntimeCapabilityError("fs", name);
+    createThrowFn = (capability, runtimeName) => {
+      return () => {
+        throw new RuntimeCapabilityError(capability, runtimeName);
       };
-      const throwExec = () => {
-        throw new RuntimeCapabilityError("exec", name);
+    };
+    createStubFs = (runtimeName) => {
+      const throwFs = createThrowFn("fs", runtimeName);
+      return {
+        readFile: throwFs,
+        readTextFile: throwFs,
+        writeFile: throwFs,
+        writeTextFile: throwFs,
+        exists: throwFs,
+        stat: throwFs,
+        lstat: throwFs,
+        mkdir: throwFs,
+        remove: throwFs,
+        readDir: throwFs,
+        copyFile: throwFs,
+        rename: throwFs,
+        makeTempDir: throwFs
       };
-      const throwProcess = () => {
-        throw new RuntimeCapabilityError("process", name);
+    };
+    createStubExec = (runtimeName) => {
+      const throwExec = createThrowFn("exec", runtimeName);
+      return {
+        spawn: throwExec,
+        exec: throwExec,
+        execJson: throwExec,
+        spawnChild: throwExec
       };
+    };
+    createStubProcess = (runtimeName) => {
+      const throwProcess = createThrowFn("process", runtimeName);
       return {
-        name,
-        version: "unknown",
-        capabilities,
-        fs: {
-          readFile: throwFs,
-          readTextFile: throwFs,
-          writeFile: throwFs,
-          writeTextFile: throwFs,
-          exists: throwFs,
-          stat: throwFs,
-          lstat: throwFs,
-          mkdir: throwFs,
-          remove: throwFs,
-          readDir: () => {
-            throw new RuntimeCapabilityError("fs", name);
-          },
-          copyFile: throwFs,
-          rename: throwFs,
-          makeTempDir: throwFs
+        exit: throwProcess,
+        cwd: throwProcess,
+        chdir: throwProcess,
+        hostname: throwProcess,
+        execPath: throwProcess,
+        get args() {
+          throw new RuntimeCapabilityError("process", runtimeName);
+        },
+        get pid() {
+          throw new RuntimeCapabilityError("process", runtimeName);
         },
-        path: posixPath,
-        exec: {
-          spawn: throwExec,
-          exec: throwExec,
-          execJson: throwExec,
-          spawnChild: throwExec
+        get stdin() {
+          throw new RuntimeCapabilityError("process", runtimeName);
         },
-        env: {
-          get: () => void 0,
-          set: () => {
-          },
-          delete: () => {
-          },
-          has: () => false,
-          toObject: () => ({})
+        get stdout() {
+          throw new RuntimeCapabilityError("process", runtimeName);
         },
-        process: {
-          exit: throwProcess,
-          cwd: throwProcess,
-          chdir: throwProcess,
-          hostname: throwProcess,
-          execPath: throwProcess,
-          get args() {
-            throw new RuntimeCapabilityError("process", name);
-          },
-          get pid() {
-            throw new RuntimeCapabilityError("process", name);
-          },
-          get stdin() {
-            throw new RuntimeCapabilityError("process", name);
-          },
-          get stdout() {
-            throw new RuntimeCapabilityError("process", name);
-          },
-          get stderr() {
-            throw new RuntimeCapabilityError("process", name);
-          }
+        get stderr() {
+          throw new RuntimeCapabilityError("process", runtimeName);
         }
       };
     };
+    createStubEnv = () => ({
+      get: () => void 0,
+      set: () => {
+      },
+      delete: () => {
+      },
+      has: () => false,
+      toObject: () => ({})
+    });
+    createMinimalRuntime = (name, capabilities = UNKNOWN_CAPABILITIES) => ({
+      name,
+      version: "unknown",
+      capabilities,
+      fs: createStubFs(name),
+      path: posixPath,
+      exec: createStubExec(name),
+      env: createStubEnv(),
+      process: createStubProcess(name)
+    });
+    runtimeFactories = {
+      deno: createDenoRuntime,
+      node: createNodeRuntime,
+      bun: createBunRuntime,
+      workerd: createWorkerdRuntime
+    };
+    overrideKeys = [
+      "fs",
+      "exec",
+      "env",
+      "path",
+      "process"
+    ];
+    hasOverrides = (options) => options !== void 0 && overrideKeys.some((key) => options[key] !== void 0);
+    mergeRuntime = (base, options, capabilities) => ({
+      name: base.name,
+      version: base.version,
+      capabilities,
+      fs: options.fs ?? base.fs,
+      path: options.path ?? base.path,
+      exec: options.exec ?? base.exec,
+      env: options.env ?? base.env,
+      process: options.process ?? base.process
+    });
     createRuntime = (options) => {
       const runtimeName = detectRuntime();
       const capabilities = {
         ...getCapabilities(runtimeName),
         ...options?.capabilities
       };
-      let baseRuntime;
-      switch (runtimeName) {
-        case "deno":
-          baseRuntime = createDenoRuntime();
-          break;
-        case "node":
-          baseRuntime = createNodeRuntime();
-          break;
-        case "bun":
-          baseRuntime = createBunRuntime();
-          break;
-        case "workerd":
-          baseRuntime = createWorkerdRuntime();
-          break;
-        default:
-          baseRuntime = createMinimalRuntime(runtimeName, capabilities);
-      }
-      if (options?.fs || options?.exec || options?.env || options?.path || options?.process) {
-        return {
-          name: baseRuntime.name,
-          version: baseRuntime.version,
-          capabilities,
-          fs: options.fs ?? baseRuntime.fs,
-          path: options.path ?? baseRuntime.path,
-          exec: options.exec ?? baseRuntime.exec,
-          env: options.env ?? baseRuntime.env,
-          process: options.process ?? baseRuntime.process
-        };
+      const factory = runtimeFactories[runtimeName];
+      const baseRuntime = factory?.() ?? createMinimalRuntime(runtimeName, capabilities);
+      if (options !== void 0 && hasOverrides(options)) {
+        return mergeRuntime(baseRuntime, options, capabilities);
       }
       return baseRuntime;
     };
@@ -5872,8 +5881,8 @@ var init_to_path_string = __esm({
 // deno:https://jsr.io/@std/fs/1.0.21/_create_walk_entry.ts
 async function createWalkEntry(path) {
   path = toPathString(path);
-  path = normalize4(path);
-  const name = basename4(path);
+  path = normalize3(path);
+  const name = basename3(path);
   const info = await Deno.stat(path);
   return {
     path,
@@ -5920,7 +5929,7 @@ async function* walk(root, options) {
     return;
   }
   for await (const entry of Deno.readDir(root)) {
-    let path = join4(root, entry.name);
+    let path = join3(root, entry.name);
     let { isSymlink, isDirectory } = entry;
     if (isSymlink) {
       if (!followSymlinks) {
@@ -7212,7 +7221,7 @@ var init_loader = __esm({
       }
     };
     getFileFormat = (filepath) => {
-      const ext = extname2(filepath);
+      const ext = extname(filepath);
       if (ext === ".json") {
         return FileFormats.Json;
       }
@@ -7291,12 +7300,125 @@ var init_mod7 = __esm({
   }
 });
 
+// pkg/@eser/fp/get.ts
+var get;
+var init_get = __esm({
+  "pkg/@eser/fp/get.ts"() {
+    get = (object, path, defaultValue) => {
+      if (object === null || object === void 0) {
+        return defaultValue;
+      }
+      const length = path.length;
+      if (length === 0) {
+        return object;
+      }
+      let current = object;
+      for (let i = 0; i < length; i++) {
+        if (current === null || current === void 0) {
+          return defaultValue;
+        }
+        const key = path[i];
+        current = current[key];
+      }
+      return current === void 0 ? defaultValue : current;
+    };
+  }
+});
+
+// pkg/@eser/fp/deep-merge.ts
+var DEEP_MERGE_DEFAULT_MAX_DEPTH, DeepMergeError, deepMerge2;
+var init_deep_merge2 = __esm({
+  "pkg/@eser/fp/deep-merge.ts"() {
+    DEEP_MERGE_DEFAULT_MAX_DEPTH = 100;
+    DeepMergeError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "DeepMergeError";
+      }
+    };
+    deepMerge2 = (instance, other, options) => {
+      const maxDepth = options?.maxDepth ?? DEEP_MERGE_DEFAULT_MAX_DEPTH;
+      const seenInstance = /* @__PURE__ */ new WeakSet();
+      const seenOther = /* @__PURE__ */ new WeakSet();
+      const mergeRecursive = (inst, oth, currentDepth) => {
+        if (!(inst instanceof Object)) {
+          return inst;
+        }
+        if (seenInstance.has(inst)) {
+          throw new DeepMergeError("Circular reference detected in first argument: cannot deep merge objects with circular references");
+        }
+        if (oth instanceof Object && seenOther.has(oth)) {
+          throw new DeepMergeError("Circular reference detected in second argument: cannot deep merge objects with circular references");
+        }
+        if (currentDepth > maxDepth) {
+          throw new DeepMergeError(`Maximum recursion depth exceeded (${maxDepth}). Objects are too deeply nested or contain circular references.`);
+        }
+        seenInstance.add(inst);
+        if (oth instanceof Object) {
+          seenOther.add(oth);
+        }
+        try {
+          const Type = inst.constructor;
+          const result = new Type();
+          const instKeys = Object.keys(inst);
+          const processedKeys = /* @__PURE__ */ new Set();
+          for (let i = 0, len = instKeys.length; i < len; i++) {
+            const itemKey = instKeys[i];
+            const recordValue = inst[itemKey];
+            const otherKeyExists = oth !== void 0 && itemKey in oth;
+            const otherValue = oth?.[itemKey];
+            processedKeys.add(itemKey);
+            if (recordValue instanceof Object && recordValue.constructor !== Array) {
+              let mergedValue;
+              if (otherKeyExists && otherValue instanceof Object && otherValue.constructor !== Array) {
+                mergedValue = mergeRecursive(recordValue, otherValue, currentDepth + 1);
+              } else if (otherKeyExists) {
+                mergedValue = otherValue;
+              } else {
+                mergedValue = mergeRecursive(recordValue, {}, currentDepth + 1);
+              }
+              result[itemKey] = mergedValue;
+            } else {
+              result[itemKey] = otherKeyExists ? otherValue : recordValue;
+            }
+          }
+          if (oth === void 0) {
+            return result;
+          }
+          const otherKeys = Object.keys(oth);
+          for (let i = 0, len = otherKeys.length; i < len; i++) {
+            const itemKey = otherKeys[i];
+            if (processedKeys.has(itemKey)) {
+              continue;
+            }
+            const otherValue = oth[itemKey];
+            if (otherValue instanceof Object && otherValue.constructor !== Array) {
+              result[itemKey] = mergeRecursive({}, otherValue, currentDepth + 1);
+            } else {
+              result[itemKey] = otherValue;
+            }
+          }
+          return result;
+        } finally {
+          seenInstance.delete(inst);
+          if (oth instanceof Object) {
+            seenOther.delete(oth);
+          }
+        }
+      };
+      return mergeRecursive(instance, other, 0);
+    };
+  }
+});
+
 // pkg/@eser/codebase/package/loader.ts
 var PackageLoadError, tryLoadConfigFile, findConfigFiles, getPropertyByPath, extractField, mergeFieldMappings, sortByPriority, load, tryLoad, getFilesWithField, getBaseDir;
 var init_loader2 = __esm({
   "pkg/@eser/codebase/package/loader.ts"() {
     init_mod4();
     init_mod7();
+    init_get();
+    init_deep_merge2();
     init_mod2();
     init_types3();
     PackageLoadError = class extends Error {
@@ -7334,7 +7456,7 @@ var init_loader2 = __esm({
     findConfigFiles = async (baseDir, includeFiles) => {
       const results = [];
       for (const fileType of includeFiles) {
-        const filepath = join2(baseDir, fileType);
+        const filepath = join(baseDir, fileType);
         const loaded = await tryLoadConfigFile(filepath, fileType);
         if (loaded) {
           results.push(loaded);
@@ -7343,15 +7465,7 @@ var init_loader2 = __esm({
       return results;
     };
     getPropertyByPath = (obj, path) => {
-      const parts = path.split(".");
-      let current = obj;
-      for (const part of parts) {
-        if (current === null || current === void 0 || typeof current !== "object") {
-          return void 0;
-        }
-        current = current[part];
-      }
-      return current;
+      return get(obj, path.split("."));
     };
     extractField = (fieldName, loadedFiles, fieldMappings) => {
       let primaryValue;
@@ -7391,16 +7505,7 @@ var init_loader2 = __esm({
       if (customMappings === void 0) {
         return DEFAULT_FIELD_MAPPINGS;
       }
-      const merged = {
-        ...DEFAULT_FIELD_MAPPINGS
-      };
-      for (const [field, mapping] of Object.entries(customMappings)) {
-        merged[field] = {
-          ...merged[field],
-          ...mapping
-        };
-      }
-      return merged;
+      return deepMerge2(DEFAULT_FIELD_MAPPINGS, customMappings);
     };
     sortByPriority = (files) => {
       return [
@@ -7411,14 +7516,14 @@ var init_loader2 = __esm({
       const { baseDir = ".", includeFiles = CONFIG_FILE_PRIORITY, fieldMappings, searchParents = false } = options;
       const mergedMappings = mergeFieldMappings(fieldMappings);
       const sortedFiles = sortByPriority(includeFiles);
-      let searchDir = resolve2(baseDir);
+      let searchDir = resolve(baseDir);
       let loadedFiles = [];
       while (true) {
         loadedFiles = await findConfigFiles(searchDir, sortedFiles);
         if (loadedFiles.length > 0 || !searchParents) {
           break;
         }
-        const parent = dirname2(searchDir);
+        const parent = dirname(searchDir);
         if (parent === searchDir) {
           break;
         }
@@ -7622,7 +7727,7 @@ var init_writer = __esm({
 function split(path) {
   const s = SEPARATOR_PATTERN.source;
   const segments = path.replace(new RegExp(`^${s}|${s}$`, "g"), "").split(SEPARATOR_PATTERN);
-  const isAbsolute_ = isAbsolute4(path);
+  const isAbsolute_ = isAbsolute3(path);
   const split2 = {
     segments,
     isAbsolute: isAbsolute_,
@@ -7652,8 +7757,8 @@ async function* expandGlob(glob, options) {
     globstar,
     caseInsensitive
   };
-  const absRoot = isGlobAbsolute ? root : resolve4(root);
-  const resolveFromRoot = (path) => resolve4(absRoot, path);
+  const absRoot = isGlobAbsolute ? root : resolve3(root);
+  const resolveFromRoot = (path) => resolve3(absRoot, path);
   const excludePatterns = exclude.map(resolveFromRoot).map((s) => globToRegExp3(s, globOptions));
   const shouldInclude = (path) => !excludePatterns.some((p) => p.test(path));
   let fixedRoot = isGlobAbsolute ? winRoot ?? "/" : absRoot;
@@ -7776,7 +7881,7 @@ var init_workspace = __esm({
         });
       } catch (e) {
         if (e instanceof PackageLoadError) {
-          console.log(`No package config file found in ${resolve2(path)}`);
+          console.log(`No package config file found in ${resolve(path)}`);
           runtime.process.exit(1);
         }
         throw e;
@@ -7785,7 +7890,7 @@ var init_workspace = __esm({
     expandWorkspacePaths = async (root, patterns) => {
       const paths = [];
       for (const pattern of patterns) {
-        const fullPattern = join2(root, pattern);
+        const fullPattern = join(root, pattern);
         if (pattern.includes("*") || pattern.includes("?")) {
           for await (const entry of expandGlob(fullPattern, {
             includeDirs: true
@@ -7894,10 +7999,10 @@ var init_workspace_discovery = __esm({
       return [];
     };
     resolveModulePath = (specifier, basePath) => {
-      if (isAbsolute2(specifier)) {
+      if (isAbsolute(specifier)) {
         return specifier;
       }
-      return resolve2(basePath, specifier);
+      return resolve(basePath, specifier);
     };
     getPackageFiles = async (packagePath) => {
       const files = [];
@@ -7912,8 +8017,8 @@ var init_workspace_discovery = __esm({
           /\.git/
         ]
       })) {
-        const relativePath = relative2(packagePath, entry.path);
-        const fileName = basename2(relativePath);
+        const relativePath = relative(packagePath, entry.path);
+        const fileName = basename(relativePath);
         if (fileName.endsWith("_test.ts") || fileName.endsWith("_bench.ts")) {
           continue;
         }
@@ -8104,7 +8209,7 @@ var init_check_mod_exports = __esm({
       const packages = await discoverPackages(root);
       const missingExports = [];
       for (const pkg of packages) {
-        const modPath = join2(pkg.path, "mod.ts");
+        const modPath = join(pkg.path, "mod.ts");
         let modContent;
         try {
           modContent = await runtime.fs.readTextFile(modPath);
@@ -8117,7 +8222,7 @@ var init_check_mod_exports = __esm({
         ].map((e) => normalizePath(e)));
         const files = await getPackageFiles(pkg.path);
         for (const file of files) {
-          const fileName = basename2(file);
+          const fileName = basename(file);
           if (!shouldBeExported(fileName)) {
             continue;
           }
@@ -8203,7 +8308,7 @@ var init_check_export_names = __esm({
         if (cleanSegment.length === 0) {
           continue;
         }
-        const ext = extname2(cleanSegment);
+        const ext = extname(cleanSegment);
         if (ext.length > 0) {
           cleanSegment = cleanSegment.slice(0, -ext.length);
         }
@@ -8479,7 +8584,7 @@ var init_check_licenses = __esm({
     validateLicenses = async (options = {}) => {
       const { fix = false } = options;
       const baseUrl = new URL(".", import.meta.url);
-      const defaultRoot = join2(fromFileUrl(baseUrl.href), "..");
+      const defaultRoot = join(fromFileUrl(baseUrl.href), "..");
       const root = options.root ?? defaultRoot;
       const issues = [];
       let checked = 0;
@@ -8587,11 +8692,18 @@ var init_licenses = __esm({
   }
 });
 
+// pkg/@eser/fp/group-by.ts
+var init_group_by = __esm({
+  "pkg/@eser/fp/group-by.ts"() {
+  }
+});
+
 // pkg/@eser/codebase/check-package-configs.ts
 var deepEqual, getFieldValue, isNpmJsrSpec, fromNpmJsrToDeno, convertPkgDepToDenoImport, isWorkspaceDep, checkDependencies, checkPackage, checkPackageConfigs;
 var init_check_package_configs = __esm({
   async "pkg/@eser/codebase/check-package-configs.ts"() {
     init_colors();
+    init_group_by();
     init_mod2();
     init_mod8();
     init_types3();
@@ -9117,27 +9229,18 @@ var buildParseOptions = (flags) => {
     default: defaultValues
   };
 };
+var isString = (value2) => value2 !== null && value2 !== void 0 && value2.constructor === String;
+var coercers = {
+  boolean: (value2) => Boolean(value2),
+  number: (value2) => isString(value2) ? Number(value2) : value2,
+  string: (value2) => String(value2),
+  "string[]": (value2) => Array.isArray(value2) ? value2.map(String) : [
+    String(value2)
+  ]
+};
 var coerceValue = (value2, type) => {
-  if (value2 === void 0) {
-    return void 0;
-  }
-  switch (type) {
-    case "boolean":
-      return Boolean(value2);
-    case "number":
-      return typeof value2 === "string" ? Number(value2) : value2;
-    case "string":
-      return String(value2);
-    case "string[]":
-      if (Array.isArray(value2)) {
-        return value2.map(String);
-      }
-      return value2 !== void 0 ? [
-        String(value2)
-      ] : [];
-    default:
-      return value2;
-  }
+  if (value2 === void 0) return void 0;
+  return coercers[type]?.(value2) ?? value2;
 };
 var extractFlags = (parsed, flags) => {
   const result = {};
@@ -9161,75 +9264,80 @@ var validateRequiredFlags = (flags, definitions) => {
 };
 
 // pkg/@eser/shell/args/help.ts
-var padRight = (str2, len) => {
-  return str2 + " ".repeat(Math.max(0, len - str2.length));
-};
+var padRight = (str2, len) => str2 + " ".repeat(Math.max(0, len - str2.length));
 var formatFlag = (flag) => {
-  let name = `--${flag.name}`;
-  if (flag.short !== void 0) {
-    name = `-${flag.short}, ${name}`;
-  }
-  if (flag.type !== "boolean") {
-    name += ` <${flag.type}>`;
+  const short = flag.short !== void 0 ? `-${flag.short}, ` : "";
+  const typeSuffix = flag.type !== "boolean" ? ` <${flag.type}>` : "";
+  return `${short}--${flag.name}${typeSuffix}`;
+};
+var generateTitle = (meta, fullName) => {
+  const title = meta.description !== void 0 ? `${fullName} - ${meta.description}` : fullName;
+  return [
+    title,
+    ""
+  ];
+};
+var generateUsage = (meta, fullName) => {
+  if (meta.usage !== void 0) {
+    return [
+      "Usage:",
+      `  ${meta.usage}`,
+      ""
+    ];
   }
-  return name;
+  const commands2 = meta.children.length > 0 ? " <command>" : "";
+  const options = meta.flags.length > 0 ? " [options]" : "";
+  return [
+    "Usage:",
+    `  ${fullName}${commands2}${options}`,
+    ""
+  ];
+};
+var generateCommands = (children) => {
+  if (children.length === 0) return [];
+  const maxLen = Math.max(...children.map((c) => c.name.length));
+  const lines = children.map((c) => `  ${padRight(c.name, maxLen + 2)}${c.description ?? ""}`);
+  return [
+    "Commands:",
+    ...lines,
+    ""
+  ];
+};
+var generateOptions = (flags) => {
+  if (flags.length === 0) return [];
+  const formatted = flags.map((f) => ({
+    flag: formatFlag(f),
+    desc: f.description
+  }));
+  const maxLen = Math.max(...formatted.map((f) => f.flag.length));
+  const lines = formatted.map(({ flag, desc }) => `  ${padRight(flag, maxLen + 2)}${desc}`);
+  return [
+    "Options:",
+    ...lines,
+    ""
+  ];
+};
+var generateExamples = (examples) => {
+  if (!examples?.length) return [];
+  return [
+    "Examples:",
+    ...examples.map((e) => `  ${e}`),
+    ""
+  ];
 };
 var generateHelp = (meta, commandPath) => {
-  const lines = [];
   const fullName = commandPath.join(" ");
-  if (meta.description !== void 0) {
-    lines.push(`${fullName} - ${meta.description}`);
-  } else {
-    lines.push(fullName);
-  }
-  lines.push("");
-  if (meta.usage !== void 0) {
-    lines.push("Usage:");
-    lines.push(`  ${meta.usage}`);
-  } else {
-    let usage = fullName;
-    if (meta.children.length > 0) {
-      usage += " <command>";
-    }
-    if (meta.flags.length > 0) {
-      usage += " [options]";
-    }
-    lines.push("Usage:");
-    lines.push(`  ${usage}`);
-  }
-  lines.push("");
-  if (meta.children.length > 0) {
-    lines.push("Commands:");
-    const maxLen = Math.max(...meta.children.map((c) => c.name.length));
-    for (const child of meta.children) {
-      const desc = child.description ?? "";
-      lines.push(`  ${padRight(child.name, maxLen + 2)}${desc}`);
-    }
-    lines.push("");
-  }
-  if (meta.flags.length > 0) {
-    lines.push("Options:");
-    const formatted = meta.flags.map((f) => ({
-      flag: formatFlag(f),
-      desc: f.description
-    }));
-    const maxLen = Math.max(...formatted.map((f) => f.flag.length));
-    for (const { flag, desc } of formatted) {
-      lines.push(`  ${padRight(flag, maxLen + 2)}${desc}`);
-    }
-    lines.push("");
-  }
-  if (meta.examples !== void 0 && meta.examples.length > 0) {
-    lines.push("Examples:");
-    for (const example of meta.examples) {
-      lines.push(`  ${example}`);
-    }
-    lines.push("");
-  }
+  const sections = [
+    ...generateTitle(meta, fullName),
+    ...generateUsage(meta, fullName),
+    ...generateCommands(meta.children),
+    ...generateOptions(meta.flags),
+    ...generateExamples(meta.examples)
+  ];
   if (meta.children.length > 0) {
-    lines.push(`Run '${fullName} <command> --help' for more information on a command.`);
+    sections.push(`Run '${fullName} <command> --help' for more information on a command.`);
   }
-  return lines.join("\n");
+  return sections.join("\n");
 };
 
 // pkg/@eser/shell/completions/generators/bash.ts
@@ -9835,7 +9943,7 @@ var CONFIG_FILENAMES = [
 ];
 var loadProjectConfig = async (dir) => {
   for (const filename of CONFIG_FILENAMES) {
-    const filepath = join4(dir, filename);
+    const filepath = join3(dir, filename);
     try {
       const content = await runtime.fs.readTextFile(filepath);
       const config = parse7(content);
@@ -10887,12 +10995,12 @@ var UntarStream = class {
 init_mod();
 var extractTarball = async (stream, targetDir, options = {}) => {
   const { stripComponents = 0, subpath } = options;
-  const normalizedSubpath = subpath !== void 0 ? normalize4(subpath).replace(/^\/+/, "") : void 0;
+  const normalizedSubpath = subpath !== void 0 ? normalize3(subpath).replace(/^\/+/, "") : void 0;
   const decompressed = stream.pipeThrough(new DecompressionStream("gzip"));
   const untarStream = decompressed.pipeThrough(new UntarStream());
   for await (const entry of untarStream) {
-    const entryPath = normalize4(entry.path);
-    if (entryPath.startsWith("..") || isAbsolute4(entryPath)) {
+    const entryPath = normalize3(entry.path);
+    if (entryPath.startsWith("..") || isAbsolute3(entryPath)) {
       if (entry.readable !== void 0) {
         await entry.readable.cancel();
       }
@@ -10922,8 +11030,8 @@ var extractTarball = async (stream, targetDir, options = {}) => {
         continue;
       }
     }
-    const outputPath = normalizedSubpath !== void 0 ? join4(targetDir, strippedPath.slice(normalizedSubpath.length).replace(/^\/+/, "")) : join4(targetDir, strippedPath);
-    await ensureDir(dirname4(outputPath));
+    const outputPath = normalizedSubpath !== void 0 ? join3(targetDir, strippedPath.slice(normalizedSubpath.length).replace(/^\/+/, "")) : join3(targetDir, strippedPath);
+    await ensureDir(dirname3(outputPath));
     if (entry.readable !== void 0) {
       const file = await Deno.create(outputPath);
       await entry.readable.pipeTo(file.writable);
@@ -11046,7 +11154,7 @@ var CONFIG_FILENAMES2 = [
 ];
 var loadTemplateConfig = async (dir) => {
   for (const filename of CONFIG_FILENAMES2) {
-    const filepath = join4(dir, filename);
+    const filepath = join3(dir, filename);
     try {
       const content = await runtime.fs.readTextFile(filepath);
       const config = parse7(content);
@@ -11128,7 +11236,7 @@ ${errors.join("\n")}`);
 };
 var getConfigFilePath = async (dir) => {
   for (const filename of CONFIG_FILENAMES2) {
-    const filepath = join4(dir, filename);
+    const filepath = join3(dir, filename);
     try {
       await runtime.fs.stat(filepath);
       return filepath;
@@ -11181,7 +11289,7 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".webm"
 ]);
 var isBinaryFile = (filepath) => {
-  const ext = extname4(filepath).toLowerCase();
+  const ext = extname3(filepath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext);
 };
 var shouldIgnore = (relativePath, ignorePatterns) => {
@@ -11224,7 +11332,7 @@ var processTemplate = async (dir, options) => {
   for await (const entry of walk(dir, {
     includeDirs: true
   })) {
-    const relativePath = relative4(dir, entry.path);
+    const relativePath = relative3(dir, entry.path);
     if (relativePath === "") {
       continue;
     }
@@ -11240,8 +11348,8 @@ var processTemplate = async (dir, options) => {
     }
   }
   for (const filepath of filesToProcess) {
-    const filename = basename4(filepath);
-    const dirPath = dirname4(filepath);
+    const filename = basename3(filepath);
+    const dirPath = dirname3(filepath);
     if (!isBinaryFile(filepath)) {
       try {
         const content = await runtime.fs.readTextFile(filepath);
@@ -11257,7 +11365,7 @@ var processTemplate = async (dir, options) => {
     }
     if (hasVariables(filename)) {
       const newFilename = substituteVariables(filename, variables);
-      const newPath = join4(dirPath, newFilename);
+      const newPath = join3(dirPath, newFilename);
       if (newPath !== filepath) {
         await Deno.rename(filepath, newPath);
       }
@@ -11265,10 +11373,10 @@ var processTemplate = async (dir, options) => {
   }
   dirsToRename.sort((a, b) => b.split(SEPARATOR).length - a.split(SEPARATOR).length);
   for (const dirPath of dirsToRename) {
-    const dirname7 = basename4(dirPath);
-    const parentDir = dirname4(dirPath);
+    const dirname7 = basename3(dirPath);
+    const parentDir = dirname3(dirPath);
     const newDirname = substituteVariables(dirname7, variables);
-    const newPath = join4(parentDir, newDirname);
+    const newPath = join3(parentDir, newDirname);
     if (newPath !== dirPath) {
       await Deno.rename(dirPath, newPath);
     }
@@ -11287,7 +11395,7 @@ var removeConfigFile = async (filepath) => {
 // pkg/@eser/codebase/scaffolding/scaffold.ts
 var scaffold = async (options) => {
   const { specifier, targetDir, variables: providedVariables = {}, force = false, skipPostInstall = false, interactive = false } = options;
-  const absoluteTargetDir = isAbsolute4(targetDir) ? targetDir : join4(runtime.process.cwd(), targetDir);
+  const absoluteTargetDir = isAbsolute3(targetDir) ? targetDir : join3(runtime.process.cwd(), targetDir);
   try {
     const entries = [];
     for await (const entry of Deno.readDir(absoluteTargetDir)) {
@@ -11695,22 +11803,22 @@ var getRcFilePath = (shell) => {
   const home = getHomeDir();
   switch (shell) {
     case "zsh":
-      return join4(home, ".zshrc");
+      return join3(home, ".zshrc");
     case "bash":
-      return join4(home, ".bashrc");
+      return join3(home, ".bashrc");
     case "fish":
-      return join4(home, ".config", "fish", "config.fish");
+      return join3(home, ".config", "fish", "config.fish");
   }
 };
 var getCompletionsFilePath = (shell, appName) => {
   const home = getHomeDir();
   switch (shell) {
     case "zsh":
-      return join4(home, ".zshrc");
+      return join3(home, ".zshrc");
     case "bash":
-      return join4(home, ".bashrc");
+      return join3(home, ".bashrc");
     case "fish":
-      return join4(home, ".config", "fish", "completions", `${appName}.fish`);
+      return join3(home, ".config", "fish", "completions", `${appName}.fish`);
   }
 };
 var getCompletionEvalLine = (shell, appName) => {
@@ -11768,7 +11876,7 @@ var addCompletions = async (shell) => {
   try {
     if (config.completionType === "file") {
       const fishPath = config.completionsFile;
-      const dir = dirname4(fishPath);
+      const dir = dirname3(fishPath);
       try {
         await runtime2.fs.mkdir(dir, {
           recursive: true
@@ -12080,7 +12188,7 @@ var systemCommand = new Command("system").description("Commands related with thi
 // pkg/@eser/cli/package.json
 var package_default = {
   name: "@eser/cli",
-  version: "4.0.6",
+  version: "4.0.8",
   type: "module",
   exports: "./main.ts",
   bin: {