eser 4.0.8 → 4.0.10

package/eser.js

@@ -215,91 +215,435 @@ var init_platform = __esm({
   }
 });
 
-// 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"() {
+// 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 "";
+      }
+      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
+    };
   }
 });
 
-// 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;
+// 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;
       }
-    } 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();
+      return void 0;
+    };
   }
 });
 
-// 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"() {
-  }
-});
+// 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 {
+        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 (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: 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/posix/from_file_url.ts
 function fromFileUrl(url) {
@@ -358,7 +702,7 @@ var init_util = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/basename.ts
-function basename(path, suffix = "") {
+function basename2(path, suffix = "") {
   if (path instanceof URL) {
     path = fromFileUrl(path);
   }
@@ -408,7 +752,7 @@ var init_from_file_url3 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/basename.ts
-function basename2(path, suffix = "") {
+function basename3(path, suffix = "") {
   if (path instanceof URL) {
     path = fromFileUrl2(path);
   }
@@ -435,8 +779,8 @@ var init_basename3 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/basename.ts
-function basename3(path, suffix = "") {
-  return isWindows ? basename2(path, suffix) : basename(path, suffix);
+function basename4(path, suffix = "") {
+  return isWindows ? basename3(path, suffix) : basename2(path, suffix);
 }
 var init_basename4 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/basename.ts"() {
@@ -469,7 +813,7 @@ var init_dirname = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/dirname.ts
-function dirname(path) {
+function dirname2(path) {
   if (path instanceof URL) {
     path = fromFileUrl(path);
   }
@@ -501,7 +845,7 @@ var init_dirname2 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/dirname.ts
-function dirname2(path) {
+function dirname3(path) {
   if (path instanceof URL) {
     path = fromFileUrl2(path);
   }
@@ -578,8 +922,8 @@ var init_dirname3 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/dirname.ts
-function dirname3(path) {
-  return isWindows ? dirname2(path) : dirname(path);
+function dirname4(path) {
+  return isWindows ? dirname3(path) : dirname2(path);
 }
 var init_dirname4 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/dirname.ts"() {
@@ -590,7 +934,7 @@ var init_dirname4 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/extname.ts
-function extname(path) {
+function extname2(path) {
   if (path instanceof URL) {
     path = fromFileUrl(path);
   }
@@ -637,7 +981,7 @@ var init_extname = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/extname.ts
-function extname2(path) {
+function extname3(path) {
   if (path instanceof URL) {
     path = fromFileUrl2(path);
   }
@@ -688,8 +1032,8 @@ var init_extname2 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/extname.ts
-function extname3(path) {
-  return isWindows ? extname2(path) : extname(path);
+function extname4(path) {
+  return isWindows ? extname3(path) : extname2(path);
 }
 var init_extname3 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/extname.ts"() {
@@ -719,7 +1063,7 @@ var init_format = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/format.ts
-function format(pathObject) {
+function format2(pathObject) {
   assertArg3(pathObject);
   return _format("/", pathObject);
 }
@@ -730,7 +1074,7 @@ var init_format2 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/format.ts
-function format2(pathObject) {
+function format3(pathObject) {
   assertArg3(pathObject);
   return _format("\\", pathObject);
 }
@@ -741,8 +1085,8 @@ var init_format3 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/format.ts
-function format3(pathObject) {
-  return isWindows ? format2(pathObject) : format(pathObject);
+function format4(pathObject) {
+  return isWindows ? format3(pathObject) : format2(pathObject);
 }
 var init_format4 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/format.ts"() {
@@ -765,7 +1109,7 @@ var init_from_file_url4 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/is_absolute.ts
-function isAbsolute(path) {
+function isAbsolute2(path) {
   assertPath(path);
   return path.length > 0 && isPosixPathSeparator(path.charCodeAt(0));
 }
@@ -777,7 +1121,7 @@ var init_is_absolute = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/is_absolute.ts
-function isAbsolute2(path) {
+function isAbsolute3(path) {
   assertPath(path);
   const len = path.length;
   if (len === 0) return false;
@@ -800,8 +1144,8 @@ var init_is_absolute2 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/is_absolute.ts
-function isAbsolute3(path) {
-  return isWindows ? isAbsolute2(path) : isAbsolute(path);
+function isAbsolute4(path) {
+  return isWindows ? isAbsolute3(path) : isAbsolute2(path);
 }
 var init_is_absolute3 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/is_absolute.ts"() {
@@ -884,7 +1228,7 @@ var init_normalize_string = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/normalize.ts
-function normalize(path) {
+function normalize2(path) {
   if (path instanceof URL) {
     path = fromFileUrl(path);
   }
@@ -907,7 +1251,7 @@ var init_normalize2 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/join.ts
-function join(path, ...paths) {
+function join2(path, ...paths) {
   if (path === void 0) return ".";
   if (path instanceof URL) {
     path = fromFileUrl(path);
@@ -918,7 +1262,7 @@ function join(path, ...paths) {
   ] : paths;
   paths.forEach((path2) => assertPath(path2));
   const joined = paths.filter((path2) => path2.length > 0).join("/");
-  return joined === "" ? "." : normalize(joined);
+  return joined === "" ? "." : normalize2(joined);
 }
 var init_join = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/posix/join.ts"() {
@@ -929,7 +1273,7 @@ var init_join = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/normalize.ts
-function normalize2(path) {
+function normalize3(path) {
   if (path instanceof URL) {
     path = fromFileUrl2(path);
   }
@@ -1018,7 +1362,7 @@ var init_normalize3 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/join.ts
-function join2(path, ...paths) {
+function join3(path, ...paths) {
   if (path instanceof URL) {
     path = fromFileUrl2(path);
   }
@@ -1054,7 +1398,7 @@ function join2(path, ...paths) {
     }
     if (slashCount >= 2) joined = `\\${joined.slice(slashCount)}`;
   }
-  return normalize2(joined);
+  return normalize3(joined);
 }
 var init_join2 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/windows/join.ts"() {
@@ -1066,8 +1410,8 @@ var init_join2 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/join.ts
-function join3(path, ...paths) {
-  return isWindows ? join2(path, ...paths) : join(path, ...paths);
+function join4(path, ...paths) {
+  return isWindows ? join3(path, ...paths) : join2(path, ...paths);
 }
 var init_join3 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/join.ts"() {
@@ -1078,8 +1422,8 @@ var init_join3 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/normalize.ts
-function normalize3(path) {
-  return isWindows ? normalize2(path) : normalize(path);
+function normalize4(path) {
+  return isWindows ? normalize3(path) : normalize2(path);
 }
 var init_normalize4 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/normalize.ts"() {
@@ -1090,7 +1434,7 @@ var init_normalize4 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/parse.ts
-function parse(path) {
+function parse2(path) {
   assertPath(path);
   const ret = {
     root: "",
@@ -1170,7 +1514,7 @@ var init_parse = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/parse.ts
-function parse2(path) {
+function parse3(path) {
   assertPath(path);
   const ret = {
     root: "",
@@ -1286,8 +1630,8 @@ var init_parse2 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/parse.ts
-function parse3(path) {
-  return isWindows ? parse2(path) : parse(path);
+function parse4(path) {
+  return isWindows ? parse3(path) : parse2(path);
 }
 var init_parse3 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/parse.ts"() {
@@ -1298,7 +1642,7 @@ var init_parse3 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/resolve.ts
-function resolve(...pathSegments) {
+function resolve2(...pathSegments) {
   let resolvedPath = "";
   let resolvedAbsolute = false;
   for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
@@ -1346,10 +1690,10 @@ var init_relative = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/posix/relative.ts
-function relative(from, to) {
+function relative2(from, to) {
   assertArgs2(from, to);
-  from = resolve(from);
-  to = resolve(to);
+  from = resolve2(from);
+  to = resolve2(to);
   if (from === to) return "";
   let fromStart = 1;
   const fromEnd = from.length;
@@ -1411,7 +1755,7 @@ var init_relative2 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/resolve.ts
-function resolve2(...pathSegments) {
+function resolve3(...pathSegments) {
   let resolvedDevice = "";
   let resolvedTail = "";
   let resolvedAbsolute = false;
@@ -1514,10 +1858,10 @@ var init_resolve2 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/windows/relative.ts
-function relative2(from, to) {
+function relative3(from, to) {
   assertArgs2(from, to);
-  const fromOrig = resolve2(from);
-  const toOrig = resolve2(to);
+  const fromOrig = resolve3(from);
+  const toOrig = resolve3(to);
   if (fromOrig === toOrig) return "";
   from = fromOrig.toLowerCase();
   to = toOrig.toLowerCase();
@@ -1594,8 +1938,8 @@ var init_relative3 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/relative.ts
-function relative3(from, to) {
-  return isWindows ? relative2(from, to) : relative(from, to);
+function relative4(from, to) {
+  return isWindows ? relative3(from, to) : relative2(from, to);
 }
 var init_relative4 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/relative.ts"() {
@@ -1606,8 +1950,8 @@ var init_relative4 = __esm({
 });
 
 // deno:https://jsr.io/@std/path/1.1.4/resolve.ts
-function resolve3(...pathSegments) {
-  return isWindows ? resolve2(...pathSegments) : resolve(...pathSegments);
+function resolve4(...pathSegments) {
+  return isWindows ? resolve3(...pathSegments) : resolve2(...pathSegments);
 }
 var init_resolve3 = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/resolve.ts"() {
@@ -2002,11 +2346,11 @@ function normalizeGlob(glob, options = {}) {
     throw new Error(`Glob contains invalid characters: "${glob}"`);
   }
   if (!globstar) {
-    return normalize(glob);
+    return normalize2(glob);
   }
   const s = SEPARATOR_PATTERN2.source;
   const badParentPattern = new RegExp(`(?<=(${s}|^)\\*\\*${s})\\.\\.(?=${s}|$)`, "g");
-  return normalize(glob.replace(badParentPattern, "\0")).replace(/\0/g, "..");
+  return normalize2(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"() {
@@ -2019,7 +2363,7 @@ var init_normalize_glob = __esm({
 function joinGlobs(globs, options = {}) {
   const { globstar = false } = options;
   if (!globstar || globs.length === 0) {
-    return join(...globs);
+    return join2(...globs);
   }
   let joined;
   for (const glob of globs) {
@@ -2058,11 +2402,11 @@ function normalizeGlob2(glob, options = {}) {
     throw new Error(`Glob contains invalid characters: "${glob}"`);
   }
   if (!globstar) {
-    return normalize2(glob);
+    return normalize3(glob);
   }
   const s = SEPARATOR_PATTERN3.source;
   const badParentPattern = new RegExp(`(?<=(${s}|^)\\*\\*${s})\\.\\.(?=${s}|$)`, "g");
-  return normalize2(glob.replace(badParentPattern, "\0")).replace(/\0/g, "..");
+  return normalize3(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"() {
@@ -2075,7 +2419,7 @@ var init_normalize_glob2 = __esm({
 function joinGlobs2(globs, options = {}) {
   const { globstar = false } = options;
   if (!globstar || globs.length === 0) {
-    return join2(...globs);
+    return join3(...globs);
   }
   let joined;
   for (const glob of globs) {
@@ -2123,380 +2467,61 @@ var init_normalize_glob3 = __esm({
 var init_mod = __esm({
   "deno:https://jsr.io/@std/path/1.1.4/mod.ts"() {
     init_basename4();
-    init_constants2();
-    init_dirname4();
-    init_extname3();
-    init_format4();
-    init_from_file_url4();
-    init_is_absolute3();
-    init_join3();
-    init_normalize4();
-    init_parse3();
-    init_relative4();
-    init_resolve3();
-    init_to_file_url4();
-    init_to_namespaced_path3();
-    init_common2();
-    init_types2();
-    init_glob_to_regexp3();
-    init_is_glob();
-    init_join_globs3();
-    init_normalize_glob3();
-  }
-});
-
-// 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 DENO_CAPABILITIES, createDenoFs, createDenoPath, createDenoExec, createDenoEnv, createDenoProcess, createDenoRuntime;
-var init_deno = __esm({
-  "pkg/@eser/standards/runtime/adapters/deno.ts"() {
-    init_mod();
-    init_types();
-    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
-      };
+    init_constants2();
+    init_dirname4();
+    init_extname3();
+    init_format4();
+    init_from_file_url4();
+    init_is_absolute3();
+    init_join3();
+    init_normalize4();
+    init_parse3();
+    init_relative4();
+    init_resolve3();
+    init_to_file_url4();
+    init_to_namespaced_path3();
+    init_common2();
+    init_types2();
+    init_glob_to_regexp3();
+    init_is_glob();
+    init_join_globs3();
+    init_normalize_glob3();
+  }
+});
+
+// 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";
     };
-    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
-      };
+    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/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"() {
+// pkg/@eser/standards/runtime/adapters/deno.ts
+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_shared();
-    NODE_CAPABILITIES = {
+    DENO_CAPABILITIES = {
       fs: true,
       fsSync: true,
       exec: true,
@@ -2504,182 +2529,178 @@ var init_node = __esm({
       env: true,
       stdin: true,
       stdout: true,
-      kv: false
+      kv: true
     };
-    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
+    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
       });
-      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 {
-            const buffer = await nodeFsPromises.readFile(path, {
+            return await Deno.readFile(path, {
               signal: options?.signal
             });
-            return new Uint8Array(buffer);
           } catch (error) {
-            return handleError(error, path);
+            if (error instanceof Deno.errors.NotFound) {
+              throw new NotFoundError(path);
+            }
+            throw error;
           }
         },
         async readTextFile(path, options) {
           try {
-            return await nodeFsPromises.readFile(path, {
-              encoding: "utf-8",
+            return await Deno.readTextFile(path, {
               signal: options?.signal
             });
           } catch (error) {
-            return handleError(error, path);
+            if (error instanceof Deno.errors.NotFound) {
+              throw new NotFoundError(path);
+            }
+            throw error;
           }
         },
         async writeFile(path, data, options) {
-          const flag = options?.append ? "a" : "w";
-          await nodeFsPromises.writeFile(path, data, {
+          await Deno.writeFile(path, data, {
             signal: options?.signal,
             mode: options?.mode,
-            flag
+            create: options?.create ?? true,
+            append: options?.append ?? false
           });
         },
         async writeTextFile(path, data, options) {
-          const flag = options?.append ? "a" : "w";
-          await nodeFsPromises.writeFile(path, data, {
-            encoding: "utf-8",
+          await Deno.writeTextFile(path, data, {
             signal: options?.signal,
             mode: options?.mode,
-            flag
+            create: options?.create ?? true,
+            append: options?.append ?? false
           });
         },
         async exists(path) {
           try {
-            await nodeFsPromises.access(path);
+            await Deno.stat(path);
             return true;
-          } catch {
-            return false;
+          } catch (error) {
+            if (error instanceof Deno.errors.NotFound) {
+              return false;
+            }
+            throw error;
           }
         },
         async stat(path) {
           try {
-            const stats = await nodeFsPromises.stat(path);
-            return mapStats(stats);
+            const info = await Deno.stat(path);
+            return mapFileInfo(info);
           } catch (error) {
-            return handleError(error, path);
+            if (error instanceof Deno.errors.NotFound) {
+              throw new NotFoundError(path);
+            }
+            throw error;
           }
         },
         async lstat(path) {
           try {
-            const stats = await nodeFsPromises.lstat(path);
-            return mapStats(stats);
+            const info = await Deno.lstat(path);
+            return mapFileInfo(info);
           } catch (error) {
-            return handleError(error, path);
+            if (error instanceof Deno.errors.NotFound) {
+              throw new NotFoundError(path);
+            }
+            throw error;
           }
         },
         async mkdir(path, options) {
-          await nodeFsPromises.mkdir(path, {
+          await Deno.mkdir(path, {
             recursive: options?.recursive ?? false,
             mode: options?.mode
           });
         },
         async remove(path, options) {
           try {
-            await nodeFsPromises.rm(path, {
-              recursive: options?.recursive ?? false,
-              force: false
+            await Deno.remove(path, {
+              recursive: options?.recursive ?? false
             });
           } catch (error) {
-            handleError(error, path);
+            if (error instanceof Deno.errors.NotFound) {
+              throw new NotFoundError(path);
+            }
+            throw error;
           }
         },
         async *readDir(path) {
           try {
-            const entries = await nodeFsPromises.readdir(path, {
-              withFileTypes: true
-            });
-            for (const entry of entries) {
+            for await (const entry of Deno.readDir(path)) {
               yield {
                 name: entry.name,
-                isFile: entry.isFile(),
-                isDirectory: entry.isDirectory(),
-                isSymlink: entry.isSymbolicLink()
+                isFile: entry.isFile,
+                isDirectory: entry.isDirectory,
+                isSymlink: entry.isSymlink
               };
             }
           } catch (error) {
-            handleError(error, path);
+            if (error instanceof Deno.errors.NotFound) {
+              throw new NotFoundError(path);
+            }
+            throw error;
           }
         },
         async copyFile(from, to) {
-          await nodeFsPromises.copyFile(from, to);
+          await Deno.copyFile(from, to);
         },
         async rename(from, to) {
-          await nodeFsPromises.rename(from, to);
+          await Deno.rename(from, to);
         },
         async makeTempDir(options) {
-          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;
+          return await Deno.makeTempDir({
+            dir: options?.dir,
+            prefix: options?.prefix,
+            suffix: options?.suffix
+          });
         }
       };
     };
-    createNodePath = () => {
+    createDenoPath = () => {
       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: join4,
+        resolve: resolve4,
+        dirname: dirname4,
+        basename: basename4,
+        extname: extname4,
+        normalize: normalize4,
+        isAbsolute: isAbsolute4,
+        relative: relative4,
+        parse: parse4,
+        format: format4,
+        sep: SEPARATOR,
+        delimiter: DELIMITER
       };
     };
-    createNodeExec = () => {
+    createDenoExec = () => {
       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: 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))
-              });
-            });
+        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);
@@ -2694,110 +2715,108 @@ var init_node = __esm({
           return JSON.parse(output);
         },
         spawnChild(cmd, args = [], options) {
-          const proc = nodeChildProcess.spawn(cmd, args, {
+          const modes = getStdioModes(options);
+          const command = new Deno.Command(cmd, {
+            args,
             cwd: options?.cwd,
-            env: options?.env ? {
-              ...nodeProcess.env,
-              ...options.env
-            } : void 0,
-            stdio: getNodeStdioArray(options),
+            env: options?.env,
+            stdin: modes.stdin,
+            stdout: modes.stdout,
+            stderr: modes.stderr,
             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
-              });
-            });
-          });
+          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: 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,
+            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 status = await statusPromise;
+              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: new Uint8Array(Buffer2.concat(stdoutChunks)),
-                stderr: new Uint8Array(Buffer2.concat(stderrChunks))
+                stdout,
+                stderr
               };
             },
             kill: (signal) => {
-              proc.kill(signal);
+              process.kill(signal);
             }
           };
         }
       };
     };
-    createNodeEnv = () => {
+    createDenoEnv = () => {
       return {
         get(key) {
-          return nodeProcess.env[key];
+          return Deno.env.get(key);
         },
         set(key, value2) {
-          nodeProcess.env[key] = value2;
+          Deno.env.set(key, value2);
         },
         delete(key) {
-          delete nodeProcess.env[key];
+          Deno.env.delete(key);
         },
         has(key) {
-          return key in nodeProcess.env;
+          return Deno.env.get(key) !== void 0;
         },
         toObject() {
-          const result = {};
-          for (const [key, value2] of Object.entries(nodeProcess.env)) {
-            if (value2 !== void 0) {
-              result[key] = value2;
-            }
-          }
-          return result;
+          return Deno.env.toObject();
         }
       };
     };
-    createNodeProcess = () => {
+    createDenoProcess = () => {
       return {
         exit(code2) {
-          nodeProcess.exit(code2);
+          Deno.exit(code2);
         },
         cwd() {
-          return nodeProcess.cwd();
+          return Deno.cwd();
         },
         chdir(path) {
-          nodeProcess.chdir(path);
+          Deno.chdir(path);
         },
         hostname() {
-          return nodeOs.hostname();
+          return Deno.hostname();
         },
         execPath() {
-          return nodeProcess.execPath;
+          return Deno.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: Deno.args,
+        pid: Deno.pid,
+        stdin: Deno.stdin.readable,
+        stdout: Deno.stdout.writable,
+        stderr: Deno.stderr.writable
       };
     };
-    createNodeRuntime = () => {
-      const fs = createNodeFs();
-      const path = createNodePath();
-      const exec2 = createNodeExec();
-      const env = createNodeEnv();
-      const process = createNodeProcess();
+    createDenoRuntime = () => {
+      const fs = createDenoFs();
+      const path = createDenoPath();
+      const exec2 = createDenoExec();
+      const env = createDenoEnv();
+      const process = createDenoProcess();
       return {
-        name: "node",
-        version: nodeProcess.versions.node,
-        capabilities: NODE_CAPABILITIES,
+        name: "deno",
+        version: Deno.version.deno,
+        capabilities: DENO_CAPABILITIES,
         fs,
         path,
         exec: exec2,
@@ -2808,18 +2827,20 @@ 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 BUN_CAPABILITIES, createBunFs, createBunPath, readStream, createBunExec, createBunEnv, createBunProcess, createBunRuntime;
-var init_bun = __esm({
-  "pkg/@eser/standards/runtime/adapters/bun.ts"() {
+// 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();
-    BUN_CAPABILITIES = {
+    NODE_CAPABILITIES = {
       fs: true,
       fsSync: true,
       exec: true,
@@ -2829,7 +2850,7 @@ var init_bun = __esm({
       stdout: true,
       kv: false
     };
-    createBunFs = () => {
+    createNodeFs = () => {
       const mapStats = (stats) => ({
         isFile: stats.isFile(),
         isDirectory: stats.isDirectory(),
@@ -2848,7 +2869,7 @@ var init_bun = __esm({
       return {
         async readFile(path, options) {
           try {
-            const buffer = await nodeFsPromises2.readFile(path, {
+            const buffer = await nodeFsPromises.readFile(path, {
               signal: options?.signal
             });
             return new Uint8Array(buffer);
@@ -2858,7 +2879,7 @@ var init_bun = __esm({
         },
         async readTextFile(path, options) {
           try {
-            return await nodeFsPromises2.readFile(path, {
+            return await nodeFsPromises.readFile(path, {
               encoding: "utf-8",
               signal: options?.signal
             });
@@ -2868,7 +2889,7 @@ var init_bun = __esm({
         },
         async writeFile(path, data, options) {
           const flag = options?.append ? "a" : "w";
-          await nodeFsPromises2.writeFile(path, data, {
+          await nodeFsPromises.writeFile(path, data, {
             signal: options?.signal,
             mode: options?.mode,
             flag
@@ -2876,7 +2897,7 @@ var init_bun = __esm({
         },
         async writeTextFile(path, data, options) {
           const flag = options?.append ? "a" : "w";
-          await nodeFsPromises2.writeFile(path, data, {
+          await nodeFsPromises.writeFile(path, data, {
             encoding: "utf-8",
             signal: options?.signal,
             mode: options?.mode,
@@ -2885,7 +2906,7 @@ var init_bun = __esm({
         },
         async exists(path) {
           try {
-            await nodeFsPromises2.access(path);
+            await nodeFsPromises.access(path);
             return true;
           } catch {
             return false;
@@ -2893,7 +2914,7 @@ var init_bun = __esm({
         },
         async stat(path) {
           try {
-            const stats = await nodeFsPromises2.stat(path);
+            const stats = await nodeFsPromises.stat(path);
             return mapStats(stats);
           } catch (error) {
             return handleError(error, path);
@@ -2901,21 +2922,21 @@ var init_bun = __esm({
         },
         async lstat(path) {
           try {
-            const stats = await nodeFsPromises2.lstat(path);
+            const stats = await nodeFsPromises.lstat(path);
             return mapStats(stats);
           } catch (error) {
             return handleError(error, path);
           }
         },
         async mkdir(path, options) {
-          await nodeFsPromises2.mkdir(path, {
+          await nodeFsPromises.mkdir(path, {
             recursive: options?.recursive ?? false,
             mode: options?.mode
           });
         },
         async remove(path, options) {
           try {
-            await nodeFsPromises2.rm(path, {
+            await nodeFsPromises.rm(path, {
               recursive: options?.recursive ?? false,
               force: false
             });
@@ -2925,7 +2946,7 @@ var init_bun = __esm({
         },
         async *readDir(path) {
           try {
-            const entries = await nodeFsPromises2.readdir(path, {
+            const entries = await nodeFsPromises.readdir(path, {
               withFileTypes: true
             });
             for (const entry of entries) {
@@ -2941,88 +2962,68 @@ var init_bun = __esm({
           }
         },
         async copyFile(from, to) {
-          await nodeFsPromises2.copyFile(from, to);
+          await nodeFsPromises.copyFile(from, to);
         },
         async rename(from, to) {
-          await nodeFsPromises2.rename(from, to);
+          await nodeFsPromises.rename(from, to);
         },
         async makeTempDir(options) {
-          const dir = options?.dir ?? nodeOs2.tmpdir();
+          const dir = options?.dir ?? nodeOs.tmpdir();
           const prefix = options?.prefix ?? "";
           const suffix = options?.suffix ?? "";
-          const tempPath = await nodeFsPromises2.mkdtemp(nodePath2.join(dir, prefix));
+          const tempPath = await nodeFsPromises.mkdtemp(nodePath.join(dir, prefix));
           if (suffix) {
             const newPath = tempPath + suffix;
-            await nodeFsPromises2.rename(tempPath, newPath);
+            await nodeFsPromises.rename(tempPath, newPath);
             return newPath;
           }
           return tempPath;
         }
       };
     };
-    createBunPath = () => {
+    createNodePath = () => {
       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
+        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
       };
     };
-    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 = () => {
+    createNodeExec = () => {
       return {
-        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
+        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 [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);
@@ -3037,39 +3038,42 @@ var init_bun = __esm({
           return JSON.parse(output);
         },
         spawnChild(cmd, args = [], options) {
-          const [stdinMode, stdoutMode, stderrMode] = getNodeStdioArray(options);
-          const proc = Bun.spawn([
-            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 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
+              });
+            });
           });
-          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,
+            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([
-                statusPromise,
-                readStream(proc.stdout),
-                readStream(proc.stderr)
-              ]);
+              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) => {
@@ -3079,23 +3083,23 @@ var init_bun = __esm({
         }
       };
     };
-    createBunEnv = () => {
+    createNodeEnv = () => {
       return {
         get(key) {
-          return nodeProcess2.env[key];
+          return nodeProcess.env[key];
         },
         set(key, value2) {
-          nodeProcess2.env[key] = value2;
+          nodeProcess.env[key] = value2;
         },
         delete(key) {
-          delete nodeProcess2.env[key];
+          delete nodeProcess.env[key];
         },
         has(key) {
-          return key in nodeProcess2.env;
+          return key in nodeProcess.env;
         },
         toObject() {
           const result = {};
-          for (const [key, value2] of Object.entries(nodeProcess2.env)) {
+          for (const [key, value2] of Object.entries(nodeProcess.env)) {
             if (value2 !== void 0) {
               result[key] = value2;
             }
@@ -3104,40 +3108,40 @@ var init_bun = __esm({
         }
       };
     };
-    createBunProcess = () => {
+    createNodeProcess = () => {
       return {
         exit(code2) {
-          nodeProcess2.exit(code2);
+          nodeProcess.exit(code2);
         },
         cwd() {
-          return nodeProcess2.cwd();
+          return nodeProcess.cwd();
         },
         chdir(path) {
-          nodeProcess2.chdir(path);
+          nodeProcess.chdir(path);
         },
         hostname() {
-          return nodeOs2.hostname();
+          return nodeOs.hostname();
         },
         execPath() {
-          return nodeProcess2.execPath;
+          return nodeProcess.execPath;
         },
-        args: nodeProcess2.argv.slice(2),
-        pid: nodeProcess2.pid,
-        stdin: Readable2.toWeb(nodeProcess2.stdin),
-        stdout: Writable2.toWeb(nodeProcess2.stdout),
-        stderr: Writable2.toWeb(nodeProcess2.stderr)
+        args: nodeProcess.argv.slice(2),
+        pid: nodeProcess.pid,
+        stdin: Readable.toWeb(nodeProcess.stdin),
+        stdout: Writable.toWeb(nodeProcess.stdout),
+        stderr: Writable.toWeb(nodeProcess.stderr)
       };
     };
-    createBunRuntime = () => {
-      const fs = createBunFs();
-      const path = createBunPath();
-      const exec2 = createBunExec();
-      const env = createBunEnv();
-      const process = createBunProcess();
+    createNodeRuntime = () => {
+      const fs = createNodeFs();
+      const path = createNodePath();
+      const exec2 = createNodeExec();
+      const env = createNodeEnv();
+      const process = createNodeProcess();
       return {
-        name: "bun",
-        version: Bun.version,
-        capabilities: BUN_CAPABILITIES,
+        name: "node",
+        version: nodeProcess.versions.node,
+        capabilities: NODE_CAPABILITIES,
         fs,
         path,
         exec: exec2,
@@ -3148,307 +3152,336 @@ var init_bun = __esm({
   }
 });
 
-// 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);
+// 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_shared();
+    BUN_CAPABILITIES = {
+      fs: true,
+      fsSync: true,
+      exec: true,
+      process: true,
+      env: true,
+      stdin: true,
+      stdout: true,
+      kv: false
     };
-    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;
+    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);
         }
-        if (segment === "..") {
-          if (result.length > 0 && result[result.length - 1] !== "..") {
-            result.pop();
-          } else if (!isAbs) {
-            result.push("..");
+        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;
           }
-        } else {
-          result.push(segment);
+        },
+        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;
+          }
+          return tempPath;
         }
-      }
-      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;
-    };
-    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 = "";
-      }
+    createBunPath = () => {
       return {
-        root,
-        dir,
-        base,
-        ext,
-        name
+        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
       };
     };
-    format6 = (pathObject) => {
-      const { root = "", dir, base, ext = "", name = "" } = pathObject;
-      const finalBase = base ?? name + ext;
-      if (dir) {
-        if (dir === root) {
-          return `${dir}${finalBase}`;
+    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);
         }
-        return `${dir}/${finalBase}`;
+      } finally {
+        reader.releaseLock();
       }
-      return `${root}${finalBase}`;
-    };
-    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
+      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;
     };
-    createWorkerdFs = () => {
-      const throwNotAvailable = () => {
-        throw new RuntimeCapabilityError("fs", "workerd");
-      };
+    createBunExec = () => {
       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");
+        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);
+          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);
         },
-        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
+        spawnChild(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 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);
+            }
+          };
+        }
       };
     };
-    envStorage = /* @__PURE__ */ new Map();
-    createWorkerdEnv = () => {
+    createBunEnv = () => {
       return {
         get(key) {
-          return envStorage.get(key);
+          return nodeProcess2.env[key];
         },
         set(key, value2) {
-          envStorage.set(key, value2);
+          nodeProcess2.env[key] = value2;
         },
         delete(key) {
-          envStorage.delete(key);
+          delete nodeProcess2.env[key];
         },
         has(key) {
-          return envStorage.has(key);
+          return key in nodeProcess2.env;
         },
         toObject() {
-          return Object.fromEntries(envStorage);
+          const result = {};
+          for (const [key, value2] of Object.entries(nodeProcess2.env)) {
+            if (value2 !== void 0) {
+              result[key] = value2;
+            }
+          }
+          return result;
         }
       };
     };
-    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");
-      };
+    createBunProcess = () => {
       return {
-        exit: throwNotAvailable,
-        cwd: throwNotAvailable,
-        chdir: throwNotAvailable,
-        hostname: throwNotAvailable,
-        execPath: throwNotAvailable,
-        get args() {
-          throw new RuntimeCapabilityError("process", "workerd");
+        exit(code2) {
+          nodeProcess2.exit(code2);
         },
-        get pid() {
-          throw new RuntimeCapabilityError("process", "workerd");
+        cwd() {
+          return nodeProcess2.cwd();
         },
-        get stdin() {
-          throw new RuntimeCapabilityError("process", "workerd");
+        chdir(path) {
+          nodeProcess2.chdir(path);
         },
-        get stdout() {
-          throw new RuntimeCapabilityError("process", "workerd");
+        hostname() {
+          return nodeOs2.hostname();
         },
-        get stderr() {
-          throw new RuntimeCapabilityError("process", "workerd");
-        }
+        execPath() {
+          return nodeProcess2.execPath;
+        },
+        args: nodeProcess2.argv.slice(2),
+        pid: nodeProcess2.pid,
+        stdin: Readable2.toWeb(nodeProcess2.stdin),
+        stdout: Writable2.toWeb(nodeProcess2.stdout),
+        stderr: Writable2.toWeb(nodeProcess2.stderr)
       };
     };
-    createWorkerdRuntime = () => {
-      const fs = createWorkerdFs();
-      const path = createWorkerdPath();
-      const exec2 = createWorkerdExec();
-      const env = createWorkerdEnv();
-      const process = createWorkerdProcess();
+    createBunRuntime = () => {
+      const fs = createBunFs();
+      const path = createBunPath();
+      const exec2 = createBunExec();
+      const env = createBunEnv();
+      const process = createBunProcess();
       return {
-        name: "workerd",
-        version: "unknown",
-        capabilities: WORKERD_CAPABILITIES,
+        name: "bun",
+        version: Bun.version,
+        capabilities: BUN_CAPABILITIES,
         fs,
         path,
         exec: exec2,
@@ -3459,28 +3492,12 @@ var init_workerd = __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
-    };
+// pkg/@eser/standards/runtime/adapters/browser.ts
+var BROWSER_CAPABILITIES, createThrowFn, createBrowserFs, createBrowserExec, createBrowserProcess, createBrowserEnv, createBrowserRuntime;
+var init_browser = __esm({
+  "pkg/@eser/standards/runtime/adapters/browser.ts"() {
+    init_types();
+    init_path();
     BROWSER_CAPABILITIES = {
       fs: false,
       fsSync: false,
@@ -3491,68 +3508,82 @@ var init_capabilities = __esm({
       stdout: false,
       kv: false
     };
-    UNKNOWN_CAPABILITIES = {
-      fs: false,
-      fsSync: false,
-      exec: false,
-      process: false,
-      env: false,
-      stdin: false,
-      stdout: false,
-      kv: false
+    createThrowFn = (capability) => {
+      return () => {
+        throw new RuntimeCapabilityError(capability, "browser");
+      };
     };
-    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;
-      }
+    createBrowserFs = () => {
+      const throwFs = createThrowFn("fs");
+      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
+      };
     };
-    hasCapability = (runtime2, capability) => {
-      return getCapabilities(runtime2)[capability];
+    createBrowserExec = () => {
+      const throwExec = createThrowFn("exec");
+      return {
+        spawn: throwExec,
+        exec: throwExec,
+        execJson: throwExec,
+        spawnChild: throwExec
+      };
     };
-  }
-});
-
-// 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;
+    createBrowserProcess = () => {
+      const throwProcess = createThrowFn("process");
+      return {
+        exit: throwProcess,
+        cwd: throwProcess,
+        chdir: throwProcess,
+        hostname: throwProcess,
+        execPath: throwProcess,
+        get args() {
+          throw new RuntimeCapabilityError("process", "browser");
+        },
+        get pid() {
+          throw new RuntimeCapabilityError("process", "browser");
+        },
+        get stdin() {
+          throw new RuntimeCapabilityError("process", "browser");
+        },
+        get stdout() {
+          throw new RuntimeCapabilityError("process", "browser");
+        },
+        get stderr() {
+          throw new RuntimeCapabilityError("process", "browser");
         }
-        dir = parent;
-      }
-      return void 0;
+      };
     };
+    createBrowserEnv = () => ({
+      get: () => void 0,
+      set: () => {
+      },
+      delete: () => {
+      },
+      has: () => false,
+      toObject: () => ({})
+    });
+    createBrowserRuntime = () => ({
+      name: "browser",
+      version: globalThis.navigator?.userAgent ?? "unknown",
+      capabilities: BROWSER_CAPABILITIES,
+      fs: createBrowserFs(),
+      path: posixPath,
+      exec: createBrowserExec(),
+      env: createBrowserEnv(),
+      process: createBrowserProcess()
+    });
   }
 });
 
@@ -3560,27 +3591,18 @@ var init_file_search = __esm({
 var mod_exports2 = {};
 __export(mod_exports2, {
   AlreadyExistsError: () => AlreadyExistsError,
-  BROWSER_CAPABILITIES: () => BROWSER_CAPABILITIES,
-  BUN_CAPABILITIES: () => BUN_CAPABILITIES,
-  DENO_CAPABILITIES: () => DENO_CAPABILITIES,
-  FULL_CAPABILITIES: () => FULL_CAPABILITIES,
-  NODE_CAPABILITIES: () => NODE_CAPABILITIES,
   NotFoundError: () => NotFoundError,
   ProcessError: () => ProcessError,
   RuntimeCapabilityError: () => RuntimeCapabilityError,
-  UNKNOWN_CAPABILITIES: () => UNKNOWN_CAPABILITIES,
-  WORKERD_CAPABILITIES: () => WORKERD_CAPABILITIES,
   clearWorkerdEnv: () => clearEnv,
   createRuntime: () => createRuntime,
   detectRuntime: () => detectRuntime,
   getArch: () => getArch,
-  getCapabilities: () => getCapabilities,
   getHomedir: () => getHomedir,
   getPlatform: () => getPlatform,
   getPlatformInfo: () => getPlatformInfo,
   getRuntimeVersion: () => getRuntimeVersion,
   getTmpdir: () => getTmpdir,
-  hasCapability: () => hasCapability,
   isBrowser: () => isBrowser,
   isBun: () => isBun,
   isDeno: () => isDeno,
@@ -3593,31 +3615,30 @@ __export(mod_exports2, {
   runtime: () => runtime,
   searchFileHierarchy: () => searchFileHierarchy
 });
-var createThrowFn, createStubFs, createStubExec, createStubProcess, createStubEnv, createMinimalRuntime, runtimeFactories, overrideKeys, hasOverrides, mergeRuntime, createRuntime, runtime;
+var createThrowFn2, createStubFs, createStubExec, createStubProcess, createStubEnv, createMinimalRuntime, runtimeFactories, overrideKeys, hasOverrides, mergeRuntime, createRuntime, runtime;
 var init_mod2 = __esm({
   "pkg/@eser/standards/runtime/mod.ts"() {
     init_types();
     init_detect();
     init_platform();
-    init_capabilities();
     init_path();
     init_file_search();
     init_workerd();
     init_types();
     init_detect();
-    init_capabilities();
     init_path();
     init_deno();
     init_node();
     init_bun();
     init_workerd();
-    createThrowFn = (capability, runtimeName) => {
+    init_browser();
+    createThrowFn2 = (capability, runtimeName) => {
       return () => {
         throw new RuntimeCapabilityError(capability, runtimeName);
       };
     };
     createStubFs = (runtimeName) => {
-      const throwFs = createThrowFn("fs", runtimeName);
+      const throwFs = createThrowFn2("fs", runtimeName);
       return {
         readFile: throwFs,
         readTextFile: throwFs,
@@ -3635,7 +3656,7 @@ var init_mod2 = __esm({
       };
     };
     createStubExec = (runtimeName) => {
-      const throwExec = createThrowFn("exec", runtimeName);
+      const throwExec = createThrowFn2("exec", runtimeName);
       return {
         spawn: throwExec,
         exec: throwExec,
@@ -3644,7 +3665,7 @@ var init_mod2 = __esm({
       };
     };
     createStubProcess = (runtimeName) => {
-      const throwProcess = createThrowFn("process", runtimeName);
+      const throwProcess = createThrowFn2("process", runtimeName);
       return {
         exit: throwProcess,
         cwd: throwProcess,
@@ -3677,10 +3698,19 @@ var init_mod2 = __esm({
       has: () => false,
       toObject: () => ({})
     });
-    createMinimalRuntime = (name, capabilities = UNKNOWN_CAPABILITIES) => ({
+    createMinimalRuntime = (name) => ({
       name,
       version: "unknown",
-      capabilities,
+      capabilities: {
+        fs: false,
+        fsSync: false,
+        exec: false,
+        process: false,
+        env: false,
+        stdin: false,
+        stdout: false,
+        kv: false
+      },
       fs: createStubFs(name),
       path: posixPath,
       exec: createStubExec(name),
@@ -3691,7 +3721,8 @@ var init_mod2 = __esm({
       deno: createDenoRuntime,
       node: createNodeRuntime,
       bun: createBunRuntime,
-      workerd: createWorkerdRuntime
+      workerd: createWorkerdRuntime,
+      browser: createBrowserRuntime
     };
     overrideKeys = [
       "fs",
@@ -3713,15 +3744,21 @@ var init_mod2 = __esm({
     });
     createRuntime = (options) => {
       const runtimeName = detectRuntime();
-      const capabilities = {
-        ...getCapabilities(runtimeName),
-        ...options?.capabilities
-      };
       const factory = runtimeFactories[runtimeName];
-      const baseRuntime = factory?.() ?? createMinimalRuntime(runtimeName, capabilities);
+      const baseRuntime = factory?.() ?? createMinimalRuntime(runtimeName);
+      const capabilities = options?.capabilities ? {
+        ...baseRuntime.capabilities,
+        ...options.capabilities
+      } : baseRuntime.capabilities;
       if (options !== void 0 && hasOverrides(options)) {
         return mergeRuntime(baseRuntime, options, capabilities);
       }
+      if (options?.capabilities) {
+        return {
+          ...baseRuntime,
+          capabilities
+        };
+      }
       return baseRuntime;
     };
     runtime = createRuntime();
@@ -5881,8 +5918,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 = normalize3(path);
-  const name = basename3(path);
+  path = normalize4(path);
+  const name = basename4(path);
   const info = await Deno.stat(path);
   return {
     path,
@@ -5929,7 +5966,7 @@ async function* walk(root, options) {
     return;
   }
   for await (const entry of Deno.readDir(root)) {
-    let path = join3(root, entry.name);
+    let path = join4(root, entry.name);
     let { isSymlink, isDirectory } = entry;
     if (isSymlink) {
       if (!followSymlinks) {
@@ -7221,7 +7258,7 @@ var init_loader = __esm({
       }
     };
     getFileFormat = (filepath) => {
-      const ext = extname(filepath);
+      const ext = extname2(filepath);
       if (ext === ".json") {
         return FileFormats.Json;
       }
@@ -7456,7 +7493,7 @@ var init_loader2 = __esm({
     findConfigFiles = async (baseDir, includeFiles) => {
       const results = [];
       for (const fileType of includeFiles) {
-        const filepath = join(baseDir, fileType);
+        const filepath = join2(baseDir, fileType);
         const loaded = await tryLoadConfigFile(filepath, fileType);
         if (loaded) {
           results.push(loaded);
@@ -7516,14 +7553,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 = resolve(baseDir);
+      let searchDir = resolve2(baseDir);
       let loadedFiles = [];
       while (true) {
         loadedFiles = await findConfigFiles(searchDir, sortedFiles);
         if (loadedFiles.length > 0 || !searchParents) {
           break;
         }
-        const parent = dirname(searchDir);
+        const parent = dirname2(searchDir);
         if (parent === searchDir) {
           break;
         }
@@ -7727,7 +7764,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_ = isAbsolute3(path);
+  const isAbsolute_ = isAbsolute4(path);
   const split2 = {
     segments,
     isAbsolute: isAbsolute_,
@@ -7757,8 +7794,8 @@ async function* expandGlob(glob, options) {
     globstar,
     caseInsensitive
   };
-  const absRoot = isGlobAbsolute ? root : resolve3(root);
-  const resolveFromRoot = (path) => resolve3(absRoot, path);
+  const absRoot = isGlobAbsolute ? root : resolve4(root);
+  const resolveFromRoot = (path) => resolve4(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;
@@ -7881,7 +7918,7 @@ var init_workspace = __esm({
         });
       } catch (e) {
         if (e instanceof PackageLoadError) {
-          console.log(`No package config file found in ${resolve(path)}`);
+          console.log(`No package config file found in ${resolve2(path)}`);
           runtime.process.exit(1);
         }
         throw e;
@@ -7890,7 +7927,7 @@ var init_workspace = __esm({
     expandWorkspacePaths = async (root, patterns) => {
       const paths = [];
       for (const pattern of patterns) {
-        const fullPattern = join(root, pattern);
+        const fullPattern = join2(root, pattern);
         if (pattern.includes("*") || pattern.includes("?")) {
           for await (const entry of expandGlob(fullPattern, {
             includeDirs: true
@@ -7999,10 +8036,10 @@ var init_workspace_discovery = __esm({
       return [];
     };
     resolveModulePath = (specifier, basePath) => {
-      if (isAbsolute(specifier)) {
+      if (isAbsolute2(specifier)) {
         return specifier;
       }
-      return resolve(basePath, specifier);
+      return resolve2(basePath, specifier);
     };
     getPackageFiles = async (packagePath) => {
       const files = [];
@@ -8017,8 +8054,8 @@ var init_workspace_discovery = __esm({
           /\.git/
         ]
       })) {
-        const relativePath = relative(packagePath, entry.path);
-        const fileName = basename(relativePath);
+        const relativePath = relative2(packagePath, entry.path);
+        const fileName = basename2(relativePath);
         if (fileName.endsWith("_test.ts") || fileName.endsWith("_bench.ts")) {
           continue;
         }
@@ -8209,7 +8246,7 @@ var init_check_mod_exports = __esm({
       const packages = await discoverPackages(root);
       const missingExports = [];
       for (const pkg of packages) {
-        const modPath = join(pkg.path, "mod.ts");
+        const modPath = join2(pkg.path, "mod.ts");
         let modContent;
         try {
           modContent = await runtime.fs.readTextFile(modPath);
@@ -8222,7 +8259,7 @@ var init_check_mod_exports = __esm({
         ].map((e) => normalizePath(e)));
         const files = await getPackageFiles(pkg.path);
         for (const file of files) {
-          const fileName = basename(file);
+          const fileName = basename2(file);
           if (!shouldBeExported(fileName)) {
             continue;
           }
@@ -8308,7 +8345,7 @@ var init_check_export_names = __esm({
         if (cleanSegment.length === 0) {
           continue;
         }
-        const ext = extname(cleanSegment);
+        const ext = extname2(cleanSegment);
         if (ext.length > 0) {
           cleanSegment = cleanSegment.slice(0, -ext.length);
         }
@@ -8584,7 +8621,7 @@ var init_check_licenses = __esm({
     validateLicenses = async (options = {}) => {
       const { fix = false } = options;
       const baseUrl = new URL(".", import.meta.url);
-      const defaultRoot = join(fromFileUrl(baseUrl.href), "..");
+      const defaultRoot = join2(fromFileUrl(baseUrl.href), "..");
       const root = options.root ?? defaultRoot;
       const issues = [];
       let checked = 0;
@@ -9943,7 +9980,7 @@ var CONFIG_FILENAMES = [
 ];
 var loadProjectConfig = async (dir) => {
   for (const filename of CONFIG_FILENAMES) {
-    const filepath = join3(dir, filename);
+    const filepath = join4(dir, filename);
     try {
       const content = await runtime.fs.readTextFile(filepath);
       const config = parse7(content);
@@ -10995,12 +11032,12 @@ var UntarStream = class {
 init_mod();
 var extractTarball = async (stream, targetDir, options = {}) => {
   const { stripComponents = 0, subpath } = options;
-  const normalizedSubpath = subpath !== void 0 ? normalize3(subpath).replace(/^\/+/, "") : void 0;
+  const normalizedSubpath = subpath !== void 0 ? normalize4(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 = normalize3(entry.path);
-    if (entryPath.startsWith("..") || isAbsolute3(entryPath)) {
+    const entryPath = normalize4(entry.path);
+    if (entryPath.startsWith("..") || isAbsolute4(entryPath)) {
       if (entry.readable !== void 0) {
         await entry.readable.cancel();
       }
@@ -11030,8 +11067,8 @@ var extractTarball = async (stream, targetDir, options = {}) => {
         continue;
       }
     }
-    const outputPath = normalizedSubpath !== void 0 ? join3(targetDir, strippedPath.slice(normalizedSubpath.length).replace(/^\/+/, "")) : join3(targetDir, strippedPath);
-    await ensureDir(dirname3(outputPath));
+    const outputPath = normalizedSubpath !== void 0 ? join4(targetDir, strippedPath.slice(normalizedSubpath.length).replace(/^\/+/, "")) : join4(targetDir, strippedPath);
+    await ensureDir(dirname4(outputPath));
     if (entry.readable !== void 0) {
       const file = await Deno.create(outputPath);
       await entry.readable.pipeTo(file.writable);
@@ -11154,7 +11191,7 @@ var CONFIG_FILENAMES2 = [
 ];
 var loadTemplateConfig = async (dir) => {
   for (const filename of CONFIG_FILENAMES2) {
-    const filepath = join3(dir, filename);
+    const filepath = join4(dir, filename);
     try {
       const content = await runtime.fs.readTextFile(filepath);
       const config = parse7(content);
@@ -11236,7 +11273,7 @@ ${errors.join("\n")}`);
 };
 var getConfigFilePath = async (dir) => {
   for (const filename of CONFIG_FILENAMES2) {
-    const filepath = join3(dir, filename);
+    const filepath = join4(dir, filename);
     try {
       await runtime.fs.stat(filepath);
       return filepath;
@@ -11289,7 +11326,7 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".webm"
 ]);
 var isBinaryFile = (filepath) => {
-  const ext = extname3(filepath).toLowerCase();
+  const ext = extname4(filepath).toLowerCase();
   return BINARY_EXTENSIONS.has(ext);
 };
 var shouldIgnore = (relativePath, ignorePatterns) => {
@@ -11332,7 +11369,7 @@ var processTemplate = async (dir, options) => {
   for await (const entry of walk(dir, {
     includeDirs: true
   })) {
-    const relativePath = relative3(dir, entry.path);
+    const relativePath = relative4(dir, entry.path);
     if (relativePath === "") {
       continue;
     }
@@ -11348,8 +11385,8 @@ var processTemplate = async (dir, options) => {
     }
   }
   for (const filepath of filesToProcess) {
-    const filename = basename3(filepath);
-    const dirPath = dirname3(filepath);
+    const filename = basename4(filepath);
+    const dirPath = dirname4(filepath);
     if (!isBinaryFile(filepath)) {
       try {
         const content = await runtime.fs.readTextFile(filepath);
@@ -11365,7 +11402,7 @@ var processTemplate = async (dir, options) => {
     }
     if (hasVariables(filename)) {
       const newFilename = substituteVariables(filename, variables);
-      const newPath = join3(dirPath, newFilename);
+      const newPath = join4(dirPath, newFilename);
       if (newPath !== filepath) {
         await Deno.rename(filepath, newPath);
       }
@@ -11373,10 +11410,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 = basename3(dirPath);
-    const parentDir = dirname3(dirPath);
+    const dirname7 = basename4(dirPath);
+    const parentDir = dirname4(dirPath);
     const newDirname = substituteVariables(dirname7, variables);
-    const newPath = join3(parentDir, newDirname);
+    const newPath = join4(parentDir, newDirname);
     if (newPath !== dirPath) {
       await Deno.rename(dirPath, newPath);
     }
@@ -11395,7 +11432,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 = isAbsolute3(targetDir) ? targetDir : join3(runtime.process.cwd(), targetDir);
+  const absoluteTargetDir = isAbsolute4(targetDir) ? targetDir : join4(runtime.process.cwd(), targetDir);
   try {
     const entries = [];
     for await (const entry of Deno.readDir(absoluteTargetDir)) {
@@ -11803,22 +11840,22 @@ var getRcFilePath = (shell) => {
   const home = getHomeDir();
   switch (shell) {
     case "zsh":
-      return join3(home, ".zshrc");
+      return join4(home, ".zshrc");
     case "bash":
-      return join3(home, ".bashrc");
+      return join4(home, ".bashrc");
     case "fish":
-      return join3(home, ".config", "fish", "config.fish");
+      return join4(home, ".config", "fish", "config.fish");
   }
 };
 var getCompletionsFilePath = (shell, appName) => {
   const home = getHomeDir();
   switch (shell) {
     case "zsh":
-      return join3(home, ".zshrc");
+      return join4(home, ".zshrc");
     case "bash":
-      return join3(home, ".bashrc");
+      return join4(home, ".bashrc");
     case "fish":
-      return join3(home, ".config", "fish", "completions", `${appName}.fish`);
+      return join4(home, ".config", "fish", "completions", `${appName}.fish`);
   }
 };
 var getCompletionEvalLine = (shell, appName) => {
@@ -11876,7 +11913,7 @@ var addCompletions = async (shell) => {
   try {
     if (config.completionType === "file") {
       const fishPath = config.completionsFile;
-      const dir = dirname3(fishPath);
+      const dir = dirname4(fishPath);
       try {
         await runtime2.fs.mkdir(dir, {
           recursive: true
@@ -12188,7 +12225,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.8",
+  version: "4.0.10",
   type: "module",
   exports: "./main.ts",
   bin: {