@kubb/agent 5.0.0-alpha.70 → 5.0.0-alpha.72

package/.output/nitro.json

@@ -1,5 +1,5 @@
 {
-  "date": "2026-04-26T17:18:01.844Z",
+  "date": "2026-04-28T10:47:37.936Z",
   "preset": "node-server",
   "framework": {
     "name": "nitro",

package/.output/server/chunks/nitro/nitro.mjs

@@ -18,7 +18,7 @@ import { deflateSync } from 'fflate';
 import { x } from 'tinyexec';
 import { access, rm, readFile as readFile$1, readdir as readdir$1, mkdir, writeFile as writeFile$1 } from 'node:fs/promises';
 import { styleText } from 'node:util';
-import { createJiti } from 'jiti';
+import { unrun } from 'unrun';
 import { mergeDeep } from 'remeda';
 import WebSocket from 'ws';
 
@@ -5917,13 +5917,92 @@ async function clean(path) {
     force: true
   });
 }
+const reservedWords = /* @__PURE__ */ new Set([
+  "abstract",
+  "arguments",
+  "boolean",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "eval",
+  "export",
+  "extends",
+  "false",
+  "final",
+  "finally",
+  "float",
+  "for",
+  "function",
+  "goto",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "instanceof",
+  "int",
+  "interface",
+  "let",
+  "long",
+  "native",
+  "new",
+  "null",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "short",
+  "static",
+  "super",
+  "switch",
+  "synchronized",
+  "this",
+  "throw",
+  "throws",
+  "transient",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "volatile",
+  "while",
+  "with",
+  "yield",
+  "Array",
+  "Date",
+  "hasOwnProperty",
+  "Infinity",
+  "isFinite",
+  "isNaN",
+  "isPrototypeOf",
+  "length",
+  "Math",
+  "name",
+  "NaN",
+  "Number",
+  "Object",
+  "prototype",
+  "String",
+  "toString",
+  "undefined",
+  "valueOf"
+]);
 function isValidVarName(name) {
-  try {
-    new Function(`var ${name}`);
-  } catch {
-    return false;
-  }
-  return true;
+  if (!name || reservedWords.has(name)) return false;
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
 }
 var URLPath = (_b = class {
   constructor(path, options = {}) {
@@ -6279,7 +6358,7 @@ const fsStorage = createStorage(() => ({
     await clean(resolve(base));
   }
 }));
-var version$1 = "5.0.0-alpha.70";
+var version$1 = "5.0.0-alpha.72";
 function getDiagnosticInfo() {
   return {
     nodeVersion: version$2,
@@ -6696,7 +6775,7 @@ const memoryStorage = createStorage(() => {
   };
 });
 
-var version = "5.0.0-alpha.70";
+var version = "5.0.0-alpha.72";
 
 function isCommandMessage(msg) {
   return msg.type === "command";
@@ -6843,17 +6922,20 @@ async function generate({ config, hooks }) {
   }
 }
 
-const tsLoader = async (configFile) => {
-  const jiti = createJiti(globalThis._importMeta_.url, {
+const unrunInputOptions = {
+  transform: {
     jsx: {
       runtime: "automatic",
       importSource: "@kubb/renderer-jsx"
-    },
-    sourceMaps: true,
-    interopDefault: true
+    }
+  }
+};
+const tsLoader = async (configFile) => {
+  const { module } = await unrun({
+    path: configFile,
+    inputOptions: unrunInputOptions
   });
-  const mod = await jiti.import(configFile, { default: true });
-  return mod;
+  return module;
 };
 async function getCosmiConfig(configPath) {
   var _a;

package/.output/server/chunks/routes/api/health.get.mjs

@@ -19,7 +19,7 @@ import 'fflate';
 import 'tinyexec';
 import 'node:fs/promises';
 import 'node:util';
-import 'jiti';
+import 'unrun';
 import 'remeda';
 import 'ws';
 

package/.output/server/index.mjs

@@ -19,7 +19,7 @@ import 'fflate';
 import 'tinyexec';
 import 'node:fs/promises';
 import 'node:util';
-import 'jiti';
+import 'unrun';
 import 'remeda';
 import 'ws';
 //# sourceMappingURL=index.mjs.map

package/.output/server/node_modules/@rolldown/binding-linux-x64-gnu/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@rolldown/binding-linux-x64-gnu",
+  "version": "1.0.0-rc.17",
+  "cpu": [
+    "x64"
+  ],
+  "main": "rolldown-binding.linux-x64-gnu.node",
+  "files": [
+    "rolldown-binding.linux-x64-gnu.node"
+  ],
+  "description": "Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.",
+  "keywords": [
+    "bundler",
+    "esbuild",
+    "parcel",
+    "rolldown",
+    "rollup",
+    "webpack"
+  ],
+  "homepage": "https://rolldown.rs/",
+  "license": "MIT",
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rolldown/rolldown.git",
+    "directory": "packages/rolldown"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "os": [
+    "linux"
+  ],
+  "libc": [
+    "glibc"
+  ]
+}

package/.output/server/node_modules/@rolldown/pluginutils/dist/filter/composable-filters.js

@@ -0,0 +1,256 @@
+import { cleanUrl, extractQueryWithoutFragment } from "../utils.js";
+class And {
+    kind;
+    args;
+    constructor(...args) {
+        if (args.length === 0) {
+            throw new Error('`And` expects at least one operand');
+        }
+        this.args = args;
+        this.kind = 'and';
+    }
+}
+class Or {
+    kind;
+    args;
+    constructor(...args) {
+        if (args.length === 0) {
+            throw new Error('`Or` expects at least one operand');
+        }
+        this.args = args;
+        this.kind = 'or';
+    }
+}
+class Not {
+    kind;
+    expr;
+    constructor(expr) {
+        this.expr = expr;
+        this.kind = 'not';
+    }
+}
+class Id {
+    kind;
+    pattern;
+    params;
+    constructor(pattern, params) {
+        this.pattern = pattern;
+        this.kind = 'id';
+        this.params = params ?? {
+            cleanUrl: false,
+        };
+    }
+}
+class ImporterId {
+    kind;
+    pattern;
+    params;
+    constructor(pattern, params) {
+        this.pattern = pattern;
+        this.kind = 'importerId';
+        this.params = params ?? {
+            cleanUrl: false,
+        };
+    }
+}
+class ModuleType {
+    kind;
+    pattern;
+    constructor(pattern) {
+        this.pattern = pattern;
+        this.kind = 'moduleType';
+    }
+}
+class Code {
+    kind;
+    pattern;
+    constructor(expr) {
+        this.pattern = expr;
+        this.kind = 'code';
+    }
+}
+class Query {
+    kind;
+    key;
+    pattern;
+    constructor(key, pattern) {
+        this.pattern = pattern;
+        this.key = key;
+        this.kind = 'query';
+    }
+}
+class Include {
+    kind;
+    expr;
+    constructor(expr) {
+        this.expr = expr;
+        this.kind = 'include';
+    }
+}
+class Exclude {
+    kind;
+    expr;
+    constructor(expr) {
+        this.expr = expr;
+        this.kind = 'exclude';
+    }
+}
+export function and(...args) {
+    return new And(...args);
+}
+export function or(...args) {
+    return new Or(...args);
+}
+export function not(expr) {
+    return new Not(expr);
+}
+export function id(pattern, params) {
+    return new Id(pattern, params);
+}
+export function importerId(pattern, params) {
+    return new ImporterId(pattern, params);
+}
+export function moduleType(pattern) {
+    return new ModuleType(pattern);
+}
+export function code(pattern) {
+    return new Code(pattern);
+}
+/*
+ * There are three kinds of conditions are supported:
+ * 1. `boolean`: if the value is `true`, the key must exist and be truthy. if the value is `false`, the key must not exist or be falsy.
+ * 2. `string`: the key must exist and be equal to the value.
+ * 3. `RegExp`: the key must exist and match the value.
+ */
+export function query(key, pattern) {
+    return new Query(key, pattern);
+}
+export function include(expr) {
+    return new Include(expr);
+}
+export function exclude(expr) {
+    return new Exclude(expr);
+}
+/**
+ * convert a queryObject to FilterExpression like
+ * ```js
+ *   and(query(k1, v1), query(k2, v2))
+ * ```
+ * @param queryFilterObject The query filter object needs to be matched.
+ * @returns a `And` FilterExpression
+ */
+export function queries(queryFilter) {
+    let arr = Object.entries(queryFilter).map(([key, value]) => {
+        return new Query(key, value);
+    });
+    return and(...arr);
+}
+export function interpreter(exprs, code, id, moduleType, importerId) {
+    let arr = [];
+    if (Array.isArray(exprs)) {
+        arr = exprs;
+    }
+    else {
+        arr = [exprs];
+    }
+    return interpreterImpl(arr, code, id, moduleType, importerId);
+}
+export function interpreterImpl(expr, code, id, moduleType, importerId, ctx = {}) {
+    let hasInclude = false;
+    for (const e of expr) {
+        switch (e.kind) {
+            case 'include': {
+                hasInclude = true;
+                if (exprInterpreter(e.expr, code, id, moduleType, importerId, ctx)) {
+                    return true;
+                }
+                break;
+            }
+            case 'exclude': {
+                if (exprInterpreter(e.expr, code, id, moduleType, importerId, ctx)) {
+                    return false;
+                }
+                break;
+            }
+        }
+    }
+    return !hasInclude;
+}
+export function exprInterpreter(expr, code, id, moduleType, importerId, ctx = {}) {
+    switch (expr.kind) {
+        case 'and': {
+            return expr.args.every((e) => exprInterpreter(e, code, id, moduleType, importerId, ctx));
+        }
+        case 'or': {
+            return expr.args.some((e) => exprInterpreter(e, code, id, moduleType, importerId, ctx));
+        }
+        case 'not': {
+            return !exprInterpreter(expr.expr, code, id, moduleType, importerId, ctx);
+        }
+        case 'id': {
+            if (id === undefined) {
+                throw new Error('`id` is required for `id` expression');
+            }
+            let idToMatch = id;
+            if (expr.params.cleanUrl) {
+                idToMatch = cleanUrl(idToMatch);
+            }
+            return typeof expr.pattern === 'string'
+                ? idToMatch === expr.pattern
+                : expr.pattern.test(idToMatch);
+        }
+        case 'importerId': {
+            if (importerId === undefined) {
+                return false; // Entry files have no importer, so no match
+            }
+            let importerIdToMatch = importerId;
+            if (expr.params.cleanUrl) {
+                importerIdToMatch = cleanUrl(importerIdToMatch);
+            }
+            return typeof expr.pattern === 'string'
+                ? importerIdToMatch === expr.pattern
+                : expr.pattern.test(importerIdToMatch);
+        }
+        case 'moduleType': {
+            if (moduleType === undefined) {
+                throw new Error('`moduleType` is required for `moduleType` expression');
+            }
+            return moduleType === expr.pattern;
+        }
+        case 'code': {
+            if (code === undefined) {
+                throw new Error('`code` is required for `code` expression');
+            }
+            return typeof expr.pattern === 'string'
+                ? code.includes(expr.pattern)
+                : expr.pattern.test(code);
+        }
+        case 'query': {
+            if (id === undefined) {
+                throw new Error('`id` is required for `Query` expression');
+            }
+            if (!ctx.urlSearchParamsCache) {
+                let queryString = extractQueryWithoutFragment(id);
+                ctx.urlSearchParamsCache = new URLSearchParams(queryString);
+            }
+            let urlParams = ctx.urlSearchParamsCache;
+            if (typeof expr.pattern === 'boolean') {
+                if (expr.pattern) {
+                    return urlParams.has(expr.key);
+                }
+                else {
+                    return !urlParams.has(expr.key);
+                }
+            }
+            else if (typeof expr.pattern === 'string') {
+                return urlParams.get(expr.key) === expr.pattern;
+            }
+            else {
+                return expr.pattern.test(urlParams.get(expr.key) ?? '');
+            }
+        }
+        default: {
+            throw new Error(`Expression ${JSON.stringify(expr)} is not expected.`);
+        }
+    }
+}

package/.output/server/node_modules/@rolldown/pluginutils/dist/filter/filter-vite-plugins.js

@@ -0,0 +1,75 @@
+/**
+ * Filters out Vite plugins that have `apply: 'serve'` set.
+ *
+ * Since Rolldown operates in build mode, plugins marked with `apply: 'serve'`
+ * are intended only for Vite's dev server and should be excluded from the build process.
+ *
+ * @param plugins - Array of plugins (can include nested arrays)
+ * @returns Filtered array with serve-only plugins removed
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'rolldown';
+ * import { filterVitePlugins } from '@rolldown/pluginutils';
+ * import viteReact from '@vitejs/plugin-react';
+ *
+ * export default defineConfig({
+ *   plugins: filterVitePlugins([
+ *     viteReact(),
+ *     {
+ *       name: 'dev-only',
+ *       apply: 'serve', // This will be filtered out
+ *       // ...
+ *     }
+ *   ])
+ * });
+ * ```
+ */
+export function filterVitePlugins(plugins) {
+    if (!plugins) {
+        return [];
+    }
+    const pluginArray = Array.isArray(plugins) ? plugins : [plugins];
+    const result = [];
+    for (const plugin of pluginArray) {
+        // Skip falsy values
+        if (!plugin) {
+            continue;
+        }
+        // Handle nested arrays recursively
+        if (Array.isArray(plugin)) {
+            result.push(...filterVitePlugins(plugin));
+            continue;
+        }
+        // Check if plugin has apply property
+        const pluginWithApply = plugin;
+        if ('apply' in pluginWithApply) {
+            const applyValue = pluginWithApply.apply;
+            // If apply is a function, call it with build mode
+            if (typeof applyValue === 'function') {
+                try {
+                    const shouldApply = applyValue({}, // config object
+                    { command: 'build', mode: 'production' });
+                    if (shouldApply) {
+                        result.push(plugin);
+                    }
+                }
+                catch {
+                    // If function throws, include the plugin to be safe
+                    result.push(plugin);
+                }
+            } // If apply is 'serve', skip this plugin
+            else if (applyValue === 'serve') {
+                continue;
+            } // If apply is 'build' or anything else, include it
+            else {
+                result.push(plugin);
+            }
+        }
+        else {
+            // No apply property, include the plugin
+            result.push(plugin);
+        }
+    }
+    return result;
+}

package/.output/server/node_modules/@rolldown/pluginutils/dist/filter/index.js

@@ -0,0 +1,3 @@
+export * from "./composable-filters.js";
+export * from "./filter-vite-plugins.js";
+export * from "./simple-filters.js";

package/.output/server/node_modules/@rolldown/pluginutils/dist/filter/simple-filters.js

@@ -0,0 +1,70 @@
+/**
+ * Constructs a RegExp that matches the exact string specified.
+ *
+ * This is useful for plugin hook filters.
+ *
+ * @param str the string to match.
+ * @param flags flags for the RegExp.
+ *
+ * @example
+ * ```ts
+ * import { exactRegex } from '@rolldown/pluginutils';
+ * const plugin = {
+ *   name: 'plugin',
+ *   resolveId: {
+ *     filter: { id: exactRegex('foo') },
+ *     handler(id) {} // will only be called for `foo`
+ *   }
+ * }
+ * ```
+ */
+export function exactRegex(str, flags) {
+    return new RegExp(`^${escapeRegex(str)}$`, flags);
+}
+/**
+ * Constructs a RegExp that matches a value that has the specified prefix.
+ *
+ * This is useful for plugin hook filters.
+ *
+ * @param str the string to match.
+ * @param flags flags for the RegExp.
+ *
+ * @example
+ * ```ts
+ * import { prefixRegex } from '@rolldown/pluginutils';
+ * const plugin = {
+ *   name: 'plugin',
+ *   resolveId: {
+ *     filter: { id: prefixRegex('foo') },
+ *     handler(id) {} // will only be called for IDs starting with `foo`
+ *   }
+ * }
+ * ```
+ */
+export function prefixRegex(str, flags) {
+    return new RegExp(`^${escapeRegex(str)}`, flags);
+}
+const escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g;
+function escapeRegex(str) {
+    return str.replace(escapeRegexRE, '\\$&');
+}
+export function makeIdFiltersToMatchWithQuery(input) {
+    if (!Array.isArray(input)) {
+        return makeIdFilterToMatchWithQuery(
+        // Array.isArray cannot narrow the type
+        // https://github.com/microsoft/TypeScript/issues/17002
+        input);
+    }
+    return input.map((i) => makeIdFilterToMatchWithQuery(i));
+}
+function makeIdFilterToMatchWithQuery(input) {
+    if (typeof input === 'string') {
+        return `${input}{?*,}`;
+    }
+    return makeRegexIdFilterToMatchWithQuery(input);
+}
+function makeRegexIdFilterToMatchWithQuery(input) {
+    return new RegExp(
+    // replace `$` with `(?:\?.*)?$` (ignore `\$`)
+    input.source.replace(/(?<!\\)\$/g, '(?:\\?.*)?$'), input.flags);
+}

package/.output/server/node_modules/@rolldown/pluginutils/dist/index.js

@@ -0,0 +1 @@
+export * from "./filter/index.js";

package/.output/server/node_modules/@rolldown/pluginutils/dist/utils.js

@@ -0,0 +1,17 @@
+const postfixRE = /[?#].*$/;
+export function cleanUrl(url) {
+    return url.replace(postfixRE, '');
+}
+export function extractQueryWithoutFragment(url) {
+    const questionMarkIndex = url.indexOf('?');
+    if (questionMarkIndex === -1) {
+        return '';
+    }
+    const fragmentIndex = url.indexOf('#', questionMarkIndex); // Search for # after ?
+    if (fragmentIndex === -1) {
+        return url.substring(questionMarkIndex);
+    }
+    else {
+        return url.substring(questionMarkIndex, fragmentIndex);
+    }
+}

package/.output/server/node_modules/@rolldown/pluginutils/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@rolldown/pluginutils",
+  "version": "1.0.0-rc.17",
+  "homepage": "https://rolldown.rs/",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rolldown/rolldown.git",
+    "directory": "packages/pluginutils"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./filter": "./dist/filter/index.js",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/picomatch": "^4.0.0",
+    "picomatch": "^4.0.2",
+    "typescript": "^6.0.0",
+    "vitest": "^4.0.15"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest --typecheck",
+    "publint": "publint ."
+  }
+}

package/.output/server/node_modules/remeda/dist/isDeepEqual.js

@@ -1,2 +1,2 @@
-import{purry as e}from"./purry.js";function t(...t){return e(n,t)}function n(e,t){if(e===t||Object.is(e,t))return!0;if(typeof e!=`object`||typeof t!=`object`||e===null||t===null||Object.getPrototypeOf(e)!==Object.getPrototypeOf(t))return!1;if(Array.isArray(e))return r(e,t);if(e instanceof Map)return i(e,t);if(e instanceof Set)return a(e,t);if(e instanceof Date)return e.getTime()===t.getTime();if(e instanceof RegExp)return e.toString()===t.toString();if(Object.keys(e).length!==Object.keys(t).length)return!1;for(let[r,i]of Object.entries(e))if(!(r in t)||!n(i,t[r]))return!1;return!0}function r(e,t){if(e.length!==t.length)return!1;for(let[r,i]of e.entries())if(!n(i,t[r]))return!1;return!0}function i(e,t){if(e.size!==t.size)return!1;for(let[r,i]of e.entries())if(!t.has(r)||!n(i,t.get(r)))return!1;return!0}function a(e,t){if(e.size!==t.size)return!1;let r=[...t];for(let t of e){let e=!1;for(let[i,a]of r.entries())if(n(t,a)){e=!0,r.splice(i,1);break}if(!e)return!1}return!0}export{t as isDeepEqual};
+import{purry as e}from"./purry.js";function t(...t){return e(n,t)}function n(e,t){if(e===t||Object.is(e,t))return!0;if(typeof e!=`object`||typeof t!=`object`||e===null||t===null||!r(e,t))return!1;if(Array.isArray(e))return i(e,t);if(e instanceof Map)return a(e,t);if(e instanceof Set)return o(e,t);if(e instanceof Date)return e.getTime()===t.getTime();if(e instanceof RegExp)return e.toString()===t.toString();if(Object.keys(e).length!==Object.keys(t).length)return!1;for(let[r,i]of Object.entries(e))if(!(r in t)||!n(i,t[r]))return!1;return!0}function r(e,t){let n=Object.getPrototypeOf(e),r=Object.getPrototypeOf(t);return n===r?!0:n===null?r===Object.prototype:n===Object.prototype&&r===null}function i(e,t){if(e.length!==t.length)return!1;for(let[r,i]of e.entries())if(!n(i,t[r]))return!1;return!0}function a(e,t){if(e.size!==t.size)return!1;for(let[r,i]of e.entries())if(!t.has(r)||!n(i,t.get(r)))return!1;return!0}function o(e,t){if(e.size!==t.size)return!1;let r=[...t];for(let t of e){let e=!1;for(let[i,a]of r.entries())if(n(t,a)){e=!0,r.splice(i,1);break}if(!e)return!1}return!0}export{t as isDeepEqual};
 //# sourceMappingURL=isDeepEqual.js.map