@kubb/agent 5.0.0-beta.17 → 5.0.0-beta.19

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

@@ -4428,13 +4428,15 @@ function sendToBetterStack(level, tag, message, ctx) {
     if (level === "error") {
       client.error(fullMessage, context).then(() => client.flush()).catch(() => {
       });
-    } else if (level === "warn") {
+      return;
+    }
+    if (level === "warn") {
       client.warn(fullMessage, context).then(() => client.flush()).catch(() => {
       });
-    } else {
-      client.info(fullMessage, context).then(() => client.flush()).catch(() => {
-      });
+      return;
     }
+    client.info(fullMessage, context).then(() => client.flush()).catch(() => {
+    });
   } catch (_e) {
   }
 }
@@ -4833,14 +4835,12 @@ async function _walk(node, visitor, recurse, limit, parent) {
   for (const child of children) await _walk(child, visitor, recurse, limit, node);
 }
 function transform(node, options) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q;
   const { depth, parent, ...visitor } = options;
   const recurse = (depth != null ? depth : visitorDepths.deep) === visitorDepths.deep;
   switch (node.kind) {
     case "Input": {
-      let input = node;
-      const replaced = (_a = visitor.input) == null ? void 0 : _a.call(visitor, input, { parent });
-      if (replaced) input = replaced;
+      const input = (_b = (_a = visitor.input) == null ? void 0 : _a.call(visitor, node, { parent })) != null ? _b : node;
       return {
         ...input,
         schemas: input.schemas.map((s) => transform(s, {
@@ -4853,16 +4853,10 @@ function transform(node, options) {
         }))
       };
     }
-    case "Output": {
-      let output = node;
-      const replaced = (_b = visitor.output) == null ? void 0 : _b.call(visitor, output, { parent });
-      if (replaced) output = replaced;
-      return output;
-    }
+    case "Output":
+      return (_d = (_c = visitor.output) == null ? void 0 : _c.call(visitor, node, { parent })) != null ? _d : node;
     case "Operation": {
-      let op = node;
-      const replaced = (_c = visitor.operation) == null ? void 0 : _c.call(visitor, op, { parent });
-      if (replaced) op = replaced;
+      const op = (_f = (_e = visitor.operation) == null ? void 0 : _e.call(visitor, node, { parent })) != null ? _f : node;
       return {
         ...op,
         parameters: op.parameters.map((p) => transform(p, {
@@ -4871,7 +4865,7 @@ function transform(node, options) {
         })),
         requestBody: op.requestBody ? {
           ...op.requestBody,
-          content: (_d = op.requestBody.content) == null ? void 0 : _d.map((c) => ({
+          content: (_g = op.requestBody.content) == null ? void 0 : _g.map((c) => ({
             ...c,
             schema: c.schema ? transform(c.schema, {
               ...options,
@@ -4886,9 +4880,7 @@ function transform(node, options) {
       };
     }
     case "Schema": {
-      let schema = node;
-      const replaced = (_e = visitor.schema) == null ? void 0 : _e.call(visitor, schema, { parent });
-      if (replaced) schema = replaced;
+      const schema = (_i = (_h = visitor.schema) == null ? void 0 : _h.call(visitor, node, { parent })) != null ? _i : node;
       const childOptions = {
         ...options,
         parent: schema
@@ -4896,15 +4888,13 @@ function transform(node, options) {
       return {
         ...schema,
         ..."properties" in schema && recurse ? { properties: schema.properties.map((p) => transform(p, childOptions)) } : {},
-        ..."items" in schema && recurse ? { items: (_f = schema.items) == null ? void 0 : _f.map((i) => transform(i, childOptions)) } : {},
-        ..."members" in schema && recurse ? { members: (_g = schema.members) == null ? void 0 : _g.map((m) => transform(m, childOptions)) } : {},
+        ..."items" in schema && recurse ? { items: (_j = schema.items) == null ? void 0 : _j.map((i) => transform(i, childOptions)) } : {},
+        ..."members" in schema && recurse ? { members: (_k = schema.members) == null ? void 0 : _k.map((m) => transform(m, childOptions)) } : {},
         ..."additionalProperties" in schema && recurse && schema.additionalProperties && schema.additionalProperties !== true ? { additionalProperties: transform(schema.additionalProperties, childOptions) } : {}
       };
     }
     case "Property": {
-      let prop = node;
-      const replaced = (_h = visitor.property) == null ? void 0 : _h.call(visitor, prop, { parent });
-      if (replaced) prop = replaced;
+      const prop = (_m = (_l = visitor.property) == null ? void 0 : _l.call(visitor, node, { parent })) != null ? _m : node;
       return createProperty({
         ...prop,
         schema: transform(prop.schema, {
@@ -4914,9 +4904,7 @@ function transform(node, options) {
       });
     }
     case "Parameter": {
-      let param = node;
-      const replaced = (_i = visitor.parameter) == null ? void 0 : _i.call(visitor, param, { parent });
-      if (replaced) param = replaced;
+      const param = (_o = (_n = visitor.parameter) == null ? void 0 : _n.call(visitor, node, { parent })) != null ? _o : node;
       return createParameter({
         ...param,
         schema: transform(param.schema, {
@@ -4926,9 +4914,7 @@ function transform(node, options) {
       });
     }
     case "Response": {
-      let response = node;
-      const replaced = (_j = visitor.response) == null ? void 0 : _j.call(visitor, response, { parent });
-      if (replaced) response = replaced;
+      const response = (_q = (_p = visitor.response) == null ? void 0 : _p.call(visitor, node, { parent })) != null ? _q : node;
       return {
         ...response,
         schema: transform(response.schema, {
@@ -5145,7 +5131,15 @@ function collectReferencedSchemaNames(node, out = /* @__PURE__ */ new Set()) {
   for (const name of collectSchemaRefs(node)) out.add(name);
   return out;
 }
+const usedSchemaNamesCache = /* @__PURE__ */ new WeakMap();
 function collectUsedSchemaNames(operations, schemas) {
+  let byOps = usedSchemaNamesCache.get(operations);
+  if (!byOps) {
+    byOps = /* @__PURE__ */ new WeakMap();
+    usedSchemaNamesCache.set(operations, byOps);
+  }
+  const cached = byOps.get(schemas);
+  if (cached) return cached;
   const schemaMap = /* @__PURE__ */ new Map();
   for (const schema of schemas) if (schema.name) schemaMap.set(schema.name, schema);
   const result = /* @__PURE__ */ new Set();
@@ -5161,6 +5155,7 @@ function collectUsedSchemaNames(operations, schemas) {
     depth: "shallow",
     schema: (node) => node
   })) visitSchema(schema);
+  byOps.set(schemas, result);
   return result;
 }
 function syncOptionality(schema, required) {
@@ -5298,12 +5293,12 @@ function matchesSchemaPattern(node, type, pattern) {
   }
 }
 function defaultResolver(name, type) {
-  let resolvedName = camelCase(name);
-  if (type === "file" || type === "function") resolvedName = camelCase(name, { isFile: type === "file" });
-  if (type === "type") resolvedName = pascalCase(name);
-  return resolvedName;
+  if (type === "file" || type === "function") return camelCase(name, { isFile: type === "file" });
+  if (type === "type") return pascalCase(name);
+  return camelCase(name);
 }
-function defaultResolveOptions(node, { options, exclude = [], include, override = [] }) {
+const resolveOptionsCache = /* @__PURE__ */ new WeakMap();
+function computeOptions(node, options, exclude, include, override) {
   var _a2, _b2;
   if (isOperationNode(node)) {
     if (exclude.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
@@ -5328,19 +5323,34 @@ function defaultResolveOptions(node, { options, exclude = [], include, override
   }
   return options;
 }
+function defaultResolveOptions(node, { options, exclude = [], include, override = [] }) {
+  const optionsKey = options;
+  let byOptions = resolveOptionsCache.get(optionsKey);
+  if (!byOptions) {
+    byOptions = /* @__PURE__ */ new WeakMap();
+    resolveOptionsCache.set(optionsKey, byOptions);
+  }
+  const cached = byOptions.get(node);
+  if (cached !== void 0) return cached.value;
+  const result = computeOptions(node, options, exclude, include, override);
+  byOptions.set(node, { value: result });
+  return result;
+}
 function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }, { root, output, group }) {
-  var _a2;
   if ((pathMode != null ? pathMode : getMode(path$1.resolve(root, output.path))) === "single") return path$1.resolve(root, output.path);
-  let result;
-  if (group && (groupPath || tag)) {
-    const groupValue = group.type === "path" ? groupPath : tag;
-    const defaultName = group.type === "tag" ? ({ group: g }) => `${camelCase(g)}Controller` : ({ group: g }) => {
-      const segment = g.split("/").filter((s) => s !== "" && s !== "." && s !== "..")[0];
-      return segment ? camelCase(segment) : "";
-    };
-    const resolveName = (_a2 = group.name) != null ? _a2 : defaultName;
-    result = path$1.resolve(root, output.path, resolveName({ group: groupValue }), baseName);
-  } else result = path$1.resolve(root, output.path, baseName);
+  const result = (() => {
+    var _a2;
+    if (group && (groupPath || tag)) {
+      const groupValue = group.type === "path" ? groupPath : tag;
+      const defaultName = group.type === "tag" ? ({ group: g }) => `${camelCase(g)}Controller` : ({ group: g }) => {
+        const segment = g.split("/").filter((s) => s !== "" && s !== "." && s !== "..")[0];
+        return segment ? camelCase(segment) : "";
+      };
+      const resolveName = (_a2 = group.name) != null ? _a2 : defaultName;
+      return path$1.resolve(root, output.path, resolveName({ group: groupValue }), baseName);
+    }
+    return path$1.resolve(root, output.path, baseName);
+  })();
   const outputDir = path$1.resolve(root, output.path);
   const outputDirWithSep = outputDir.endsWith(path$1.sep) ? outputDir : `${outputDir}${path$1.sep}`;
   if (result !== outputDir && !result.startsWith(outputDirWithSep)) throw new Error(`[Kubb] Resolved path "${result}" is outside the output directory "${outputDir}". This may indicate a path traversal attempt in the OpenAPI specification or a misconfigured group.name function.`);
@@ -5366,12 +5376,16 @@ function defaultResolveFile({ name, extname: extname2, tag, path: groupPath }, c
 }
 function buildDefaultBanner({ title, description, version, config }) {
   try {
-    let source = "";
-    if (Array.isArray(config.input)) {
-      const first = config.input[0];
-      if (first && "path" in first) source = path$1.basename(first.path);
-    } else if (config.input && "path" in config.input) source = path$1.basename(config.input.path);
-    else if (config.input && "data" in config.input) source = "text content";
+    const source = (() => {
+      if (Array.isArray(config.input)) {
+        const first = config.input[0];
+        if (first && "path" in first) return path$1.basename(first.path);
+        return "";
+      }
+      if (config.input && "path" in config.input) return path$1.basename(config.input.path);
+      if (config.input && "data" in config.input) return "text content";
+      return "";
+    })();
     let banner = "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n";
     if (config.output.defaultBanner === "simple") {
       banner += "*/\n";
@@ -5505,6 +5519,9 @@ var FileManager = (_a$1 = class {
   dispose() {
     this.clear();
   }
+  [Symbol.dispose]() {
+    this.dispose();
+  }
   /**
   * All stored files, sorted by path length (shorter paths first).
   */
@@ -5697,7 +5714,11 @@ var PluginDriver = (_b$1 = class {
     if (gen.schema) {
       const schemaHandler = async (node, ctx) => {
         if (ctx.plugin.name !== pluginName) return;
-        await applyHookResult(await gen.schema(node, ctx), this, resolveRenderer());
+        await applyHookResult({
+          result: await gen.schema(node, ctx),
+          driver: this,
+          rendererFactory: resolveRenderer()
+        });
       };
       this.hooks.on("kubb:generate:schema", schemaHandler);
       __privateMethod$1(this, _PluginDriver_instances, trackHookListener_fn).call(this, "kubb:generate:schema", schemaHandler);
@@ -5705,7 +5726,11 @@ var PluginDriver = (_b$1 = class {
     if (gen.operation) {
       const operationHandler = async (node, ctx) => {
         if (ctx.plugin.name !== pluginName) return;
-        await applyHookResult(await gen.operation(node, ctx), this, resolveRenderer());
+        await applyHookResult({
+          result: await gen.operation(node, ctx),
+          driver: this,
+          rendererFactory: resolveRenderer()
+        });
       };
       this.hooks.on("kubb:generate:operation", operationHandler);
       __privateMethod$1(this, _PluginDriver_instances, trackHookListener_fn).call(this, "kubb:generate:operation", operationHandler);
@@ -5713,7 +5738,11 @@ var PluginDriver = (_b$1 = class {
     if (gen.operations) {
       const operationsHandler = async (nodes, ctx) => {
         if (ctx.plugin.name !== pluginName) return;
-        await applyHookResult(await gen.operations(nodes, ctx), this, resolveRenderer());
+        await applyHookResult({
+          result: await gen.operations(nodes, ctx),
+          driver: this,
+          rendererFactory: resolveRenderer()
+        });
       };
       this.hooks.on("kubb:generate:operations", operationsHandler);
       __privateMethod$1(this, _PluginDriver_instances, trackHookListener_fn).call(this, "kubb:generate:operations", operationsHandler);
@@ -5746,6 +5775,9 @@ var PluginDriver = (_b$1 = class {
     this.inputNode = void 0;
     this.inputStreamNode = void 0;
   }
+  [Symbol.dispose]() {
+    this.dispose();
+  }
   /**
   * Merges `partial` with the plugin's default resolver and stores the result.
   * Also mirrors it onto `plugin.resolver` so callers using `getPlugin(name).resolver`
@@ -5787,8 +5819,9 @@ var PluginDriver = (_b$1 = class {
         driver.fileManager.upsert(...files);
       },
       get inputNode() {
-        var _a2, _b2;
-        return (_b2 = driver.inputNode) != null ? _b2 : {
+        var _a2;
+        if (driver.inputNode) return driver.inputNode;
+        return {
           kind: "Input",
           schemas: [],
           operations: [],
@@ -5866,7 +5899,7 @@ normalizePlugin_fn = function(hookPlugin) {
   __privateGet$1(this, _defaultResolvers).set(pluginName, resolver);
   return resolver;
 }, _b$1);
-async function applyHookResult(result, driver, rendererFactory) {
+function applyHookResult({ result, driver, rendererFactory }) {
   if (!result) return;
   if (Array.isArray(result)) {
     driver.fileManager.upsert(...result);
@@ -5874,6 +5907,18 @@ async function applyHookResult(result, driver, rendererFactory) {
   }
   if (!rendererFactory) return;
   const renderer = rendererFactory();
+  if (renderer.stream) {
+    for (const file of renderer.stream(result)) driver.fileManager.upsert(file);
+    renderer.unmount();
+    return;
+  }
+  return applyAsyncRender({
+    renderer,
+    result,
+    driver
+  });
+}
+async function applyAsyncRender({ renderer, result, driver }) {
   await renderer.render(result);
   driver.fileManager.upsert(...renderer.files);
   renderer.unmount();
@@ -5890,7 +5935,7 @@ var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read fr
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-var _emitter, _a, _options, _URLPath_instances, transformParam_fn, eachParam_fn, _b;
+var _emitter, _AsyncEventEmitter_instances, emitAll_fn, _a, _options, _URLPath_instances, transformParam_fn, eachParam_fn, _b;
 var BuildError = class extends Error {
   constructor(message, options) {
     super(message, { cause: options.cause });
@@ -5908,6 +5953,7 @@ var AsyncEventEmitter = (_a = class {
   * @default 10
   */
   constructor(maxListener = 10) {
+    __privateAdd(this, _AsyncEventEmitter_instances);
     __privateAdd(this, _emitter, new EventEmitter());
     __privateGet(this, _emitter).setMaxListeners(maxListener);
   }
@@ -5920,20 +5966,10 @@ var AsyncEventEmitter = (_a = class {
   * await emitter.emit('build', 'petstore')
   * ```
   */
-  async emit(eventName, ...eventArgs) {
+  emit(eventName, ...eventArgs) {
     const listeners = __privateGet(this, _emitter).listeners(eventName);
     if (listeners.length === 0) return;
-    for (const listener of listeners) try {
-      await listener(...eventArgs);
-    } catch (err) {
-      let serializedArgs;
-      try {
-        serializedArgs = JSON.stringify(eventArgs);
-      } catch {
-        serializedArgs = String(eventArgs);
-      }
-      throw new Error(`Error in async listener for "${eventName}" with eventArgs ${serializedArgs}`, { cause: toError(err) });
-    }
+    return __privateMethod(this, _AsyncEventEmitter_instances, emitAll_fn).call(this, eventName, listeners, eventArgs);
   }
   /**
   * Registers a persistent listener for `eventName`.
@@ -5995,7 +6031,19 @@ var AsyncEventEmitter = (_a = class {
   removeAll() {
     __privateGet(this, _emitter).removeAllListeners();
   }
-}, _emitter = new WeakMap(), _a);
+}, _emitter = new WeakMap(), _AsyncEventEmitter_instances = new WeakSet(), emitAll_fn = async function(eventName, listeners, eventArgs) {
+  for (const listener of listeners) try {
+    await listener(...eventArgs);
+  } catch (err) {
+    let serializedArgs;
+    try {
+      serializedArgs = JSON.stringify(eventArgs);
+    } catch {
+      serializedArgs = String(eventArgs);
+    }
+    throw new Error(`Error in async listener for "${eventName}" with eventArgs ${serializedArgs}`, { cause: toError(err) });
+  }
+}, _a);
 function getElapsedMs(hrStart) {
   const [seconds, nanoseconds] = process.hrtime(hrStart);
   const ms = seconds * 1e3 + nanoseconds / 1e6;
@@ -6046,6 +6094,9 @@ async function clean(path) {
     force: true
   });
 }
+function isPromise(result) {
+  return result !== null && result !== void 0 && typeof result["then"] === "function";
+}
 const reservedWords = /* @__PURE__ */ new Set([
   "abstract",
   "arguments",
@@ -6268,36 +6319,37 @@ eachParam_fn = function(fn) {
     fn(raw, __privateMethod(this, _URLPath_instances, transformParam_fn).call(this, raw));
   }
 }, _b);
-var version$1 = "5.0.0-beta.17";
+var version$1 = "5.0.0-beta.19";
 function createStorage(build2) {
   return (options) => build2(options != null ? options : {});
 }
 function joinSources(file) {
-  return file.sources.map((item) => extractStringsFromNodes(item.nodes)).filter(Boolean).join("\n\n");
+  const sources = file.sources;
+  if (sources.length === 0) return "";
+  const parts = [];
+  for (const source of sources) {
+    const s = extractStringsFromNodes(source.nodes);
+    if (s) parts.push(s);
+  }
+  return parts.join("\n\n");
 }
 var FileProcessor = class {
   constructor() {
     __publicField(this, "events", new AsyncEventEmitter());
   }
-  async parse(file, { parsers, extension } = {}) {
+  parse(file, { parsers, extension } = {}) {
     const parseExtName = (extension == null ? void 0 : extension[file.extname]) || void 0;
     if (!parsers || !file.extname) return joinSources(file);
     const parser = parsers.get(file.extname);
     if (!parser) return joinSources(file);
     return parser.parse(file, { extname: parseExtName });
   }
-  /**
-  * Streams parsed files one at a time as each is processed.
-  *
-  * Unlike `run()`, files are yielded immediately after parsing rather than batched.
-  * Storage writes can begin as soon as the first file is ready, keeping peak
-  * memory proportional to one file at a time instead of the full batch.
-  */
-  async *stream(files, options = {}) {
+  *stream(files, options = {}) {
     const total = files.length;
+    if (total === 0) return;
     let processed = 0;
     for (const file of files) {
-      const source = await this.parse(file, options);
+      const source = this.parse(file, options);
       processed++;
       yield {
         file,
@@ -6310,7 +6362,7 @@ var FileProcessor = class {
   }
   async run(files, options = {}) {
     await this.events.emit("start", files);
-    for await (const { file, source, processed, total, percentage } of this.stream(files, options)) await this.events.emit("update", {
+    for (const { file, source, processed, total, percentage } of this.stream(files, options)) await this.events.emit("update", {
       file,
       source,
       processed,
@@ -6368,6 +6420,64 @@ const fsStorage = createStorage(() => ({
     await clean(resolve(base));
   }
 }));
+function _usingCtx() {
+  var r = "function" == typeof SuppressedError ? SuppressedError : function(r2, e2) {
+    var n2 = Error();
+    return n2.name = "SuppressedError", n2.error = r2, n2.suppressed = e2, n2;
+  };
+  var e = {};
+  var n = [];
+  function using(r2, e2) {
+    if (null != e2) {
+      if (Object(e2) !== e2) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+      if (r2) var o = e2[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+      if (void 0 === o && (o = e2[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r2)) var t = o;
+      if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+      t && (o = function o2() {
+        try {
+          t.call(e2);
+        } catch (r3) {
+          return Promise.reject(r3);
+        }
+      }), n.push({
+        v: e2,
+        d: o,
+        a: r2
+      });
+    } else r2 && n.push({
+      d: e2,
+      a: r2
+    });
+    return e2;
+  }
+  return {
+    e,
+    u: using.bind(null, false),
+    a: using.bind(null, true),
+    d: function d() {
+      var o;
+      var t = this.e;
+      var s = 0;
+      function next() {
+        for (; o = n.pop(); ) try {
+          if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+          if (o.d) {
+            var r2 = o.d.call(o.v);
+            if (o.a) return s |= 2, Promise.resolve(r2).then(next, err);
+          } else s |= 1;
+        } catch (r3) {
+          return err(r3);
+        }
+        if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+        if (t !== e) throw t;
+      }
+      function err(n2) {
+        return t = t !== e ? new r(n2, t) : n2, next();
+      }
+      return next();
+    }
+  };
+}
 function createSourcesView(storage) {
   const paths = /* @__PURE__ */ new Set();
   return createStorage(() => ({
@@ -6488,18 +6598,9 @@ async function setup(userConfig, options = {}) {
             `  \u2022 Operations: ${operationCount}`
           ]
         });
-      } else {
-        driver.inputNode = await config.adapter.parse(source);
-        await hooks.emit("kubb:debug", {
-          date: /* @__PURE__ */ new Date(),
-          logs: [
-            `\u2713 Adapter '${config.adapter.name}' resolved InputNode`,
-            `  \u2022 Schemas: ${driver.inputNode.schemas.length}`,
-            `  \u2022 Operations: ${driver.inputNode.operations.length}`
-          ]
-        });
       }
-    } else {
+    }
+    if (!driver.inputStreamNode) {
       driver.inputNode = await config.adapter.parse(source);
       await hooks.emit("kubb:debug", {
         date: /* @__PURE__ */ new Date(),
@@ -6516,19 +6617,26 @@ async function setup(userConfig, options = {}) {
     hooks,
     driver,
     storage,
-    dispose: () => {
-      driver.dispose();
-      for (const [event, handler] of middlewareListeners) hooks.off(event, handler);
-    }
+    dispose,
+    [Symbol.dispose]: dispose
   };
+  function dispose() {
+    driver.dispose();
+    for (const [event, handler] of middlewareListeners) hooks.off(event, handler);
+  }
 }
-async function runPluginStreamHooks(inputStreamNode, entries, driver, hooks, config, pluginTimings, failedPlugins, flushPendingFiles) {
+async function runPluginStreamHooks({ entries, driver, pluginTimings, failedPlugins }) {
+  const inputStreamNode = driver.inputStreamNode;
   function resolveRendererFor(gen, state) {
     var _a2, _b2;
     return gen.renderer === null ? void 0 : (_b2 = (_a2 = gen.renderer) != null ? _a2 : state.plugin.renderer) != null ? _b2 : state.generatorContext.config.renderer;
   }
   const states = entries.map(({ plugin, context, hrStart }) => {
     var _a2;
+    const { exclude, include, override } = plugin.options;
+    const hasExclude = Array.isArray(exclude) && exclude.length > 0;
+    const hasInclude = Array.isArray(include) && include.length > 0;
+    const hasOverride = Array.isArray(override) && override.length > 0;
     return {
       plugin,
       generatorContext: {
@@ -6538,72 +6646,82 @@ async function runPluginStreamHooks(inputStreamNode, entries, driver, hooks, con
       generators: (_a2 = plugin.generators) != null ? _a2 : [],
       hrStart,
       failed: false,
-      error: void 0
+      error: void 0,
+      optionsAreStatic: !hasExclude && !hasInclude && !hasOverride
     };
   });
-  let schemasProcessed = 0;
-  for await (const node of inputStreamNode.schemas) {
-    for (const state of states) {
-      if (state.failed) continue;
-      try {
-        const { plugin, generatorContext, generators } = state;
-        const { exclude, include, override } = plugin.options;
-        const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-        const options = generatorContext.resolver.resolveOptions(transformedNode, {
-          options: plugin.options,
-          exclude,
-          include,
-          override
+  async function dispatchSchema(state, node) {
+    if (state.failed) return;
+    try {
+      const { plugin, generatorContext, generators } = state;
+      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
+      const { exclude, include, override } = plugin.options;
+      const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
+        options: plugin.options,
+        exclude,
+        include,
+        override
+      });
+      if (options === null) return;
+      const ctx = {
+        ...generatorContext,
+        options
+      };
+      for (const gen of generators) {
+        if (!gen.schema) continue;
+        const raw = gen.schema(transformedNode, ctx);
+        const applied = applyHookResult({
+          result: isPromise(raw) ? await raw : raw,
+          driver,
+          rendererFactory: resolveRendererFor(gen, state)
         });
-        if (options === null) continue;
-        const ctx = {
-          ...generatorContext,
-          options
-        };
-        for (const gen of generators) {
-          if (!gen.schema) continue;
-          await applyHookResult(await gen.schema(transformedNode, ctx), driver, resolveRendererFor(gen, state));
-        }
-        await driver.hooks.emit("kubb:generate:schema", transformedNode, ctx);
-      } catch (caughtError) {
-        state.failed = true;
-        state.error = caughtError;
+        if (isPromise(applied)) await applied;
       }
+      await driver.hooks.emit("kubb:generate:schema", transformedNode, ctx);
+    } catch (caughtError) {
+      state.failed = true;
+      state.error = caughtError;
     }
-    schemasProcessed++;
-    if (schemasProcessed % 50 === 0) await flushPendingFiles();
   }
-  const collectedOperations = [];
-  for await (const node of inputStreamNode.operations) {
-    collectedOperations.push(node);
-    for (const state of states) {
-      if (state.failed) continue;
-      try {
-        const { plugin, generatorContext, generators } = state;
-        const { exclude, include, override } = plugin.options;
-        const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-        const options = generatorContext.resolver.resolveOptions(transformedNode, {
-          options: plugin.options,
-          exclude,
-          include,
-          override
+  async function dispatchOperation(state, node) {
+    if (state.failed) return;
+    try {
+      const { plugin, generatorContext, generators } = state;
+      const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
+      const { exclude, include, override } = plugin.options;
+      const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
+        options: plugin.options,
+        exclude,
+        include,
+        override
+      });
+      if (options === null) return;
+      const ctx = {
+        ...generatorContext,
+        options
+      };
+      for (const gen of generators) {
+        if (!gen.operation) continue;
+        const raw = gen.operation(transformedNode, ctx);
+        const applied = applyHookResult({
+          result: isPromise(raw) ? await raw : raw,
+          driver,
+          rendererFactory: resolveRendererFor(gen, state)
         });
-        if (options === null) continue;
-        const ctx = {
-          ...generatorContext,
-          options
-        };
-        for (const gen of generators) {
-          if (!gen.operation) continue;
-          await applyHookResult(await gen.operation(transformedNode, ctx), driver, resolveRendererFor(gen, state));
-        }
-        await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
-      } catch (caughtError) {
-        state.failed = true;
-        state.error = caughtError;
+        if (isPromise(applied)) await applied;
       }
+      await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
+    } catch (caughtError) {
+      state.failed = true;
+      state.error = caughtError;
     }
   }
+  for await (const node of inputStreamNode.schemas) await Promise.all(states.map((state) => dispatchSchema(state, node)));
+  const collectedOperations = [];
+  for await (const node of inputStreamNode.operations) {
+    collectedOperations.push(node);
+    await Promise.all(states.map((state) => dispatchOperation(state, node)));
+  }
   for (const state of states) {
     if (!state.failed) try {
       const { plugin, generatorContext, generators } = state;
@@ -6613,7 +6731,11 @@ async function runPluginStreamHooks(inputStreamNode, entries, driver, hooks, con
       };
       for (const gen of generators) {
         if (!gen.operations) continue;
-        await applyHookResult(await gen.operations(collectedOperations, ctx), driver, resolveRendererFor(gen, state));
+        await applyHookResult({
+          result: await gen.operations(collectedOperations, ctx),
+          driver,
+          rendererFactory: resolveRendererFor(gen, state)
+        });
       }
       await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
     } catch (caughtError) {
@@ -6622,12 +6744,12 @@ async function runPluginStreamHooks(inputStreamNode, entries, driver, hooks, con
     }
     const duration = getElapsedMs(state.hrStart);
     pluginTimings.set(state.plugin.name, duration);
-    await hooks.emit("kubb:plugin:end", {
+    await driver.hooks.emit("kubb:plugin:end", {
       plugin: state.plugin,
       duration,
       success: !state.failed,
       ...state.failed && state.error ? { error: state.error } : {},
-      config,
+      config: driver.config,
       get files() {
         return driver.fileManager.files;
       },
@@ -6637,12 +6759,11 @@ async function runPluginStreamHooks(inputStreamNode, entries, driver, hooks, con
       plugin: state.plugin,
       error: state.error
     });
-    await hooks.emit("kubb:debug", {
+    await driver.hooks.emit("kubb:debug", {
       date: /* @__PURE__ */ new Date(),
       logs: [state.failed ? "\u2717 Plugin start failed" : `\u2713 Plugin started successfully (${formatMs(duration)})`]
     });
   }
-  await flushPendingFiles();
 }
 async function runPluginAstHooks(plugin, context) {
   var _a2, _b2, _c;
@@ -6668,13 +6789,15 @@ async function runPluginAstHooks(plugin, context) {
   ]);
   const hasOperationBasedIncludes = (_b2 = include == null ? void 0 : include.some(({ type }) => operationFilterTypes.has(type))) != null ? _b2 : false;
   const hasSchemaNameIncludes = (_c = include == null ? void 0 : include.some(({ type }) => type === "schemaName")) != null ? _c : false;
-  let allowedSchemaNames;
-  if (hasOperationBasedIncludes && !hasSchemaNameIncludes) allowedSchemaNames = collectUsedSchemaNames(inputNode.operations.filter((op) => resolver.resolveOptions(op, {
-    options: plugin.options,
-    exclude,
-    include,
-    override
-  }) !== null), inputNode.schemas);
+  const allowedSchemaNames = (() => {
+    if (!hasOperationBasedIncludes || hasSchemaNameIncludes) return void 0;
+    return collectUsedSchemaNames(inputNode.operations.filter((op) => resolver.resolveOptions(op, {
+      options: plugin.options,
+      exclude,
+      include,
+      override
+    }) !== null), inputNode.schemas);
+  })();
   await walk(inputNode, {
     depth: "shallow",
     async schema(node) {
@@ -6691,7 +6814,13 @@ async function runPluginAstHooks(plugin, context) {
         ...generatorContext,
         options
       };
-      await Promise.all(generators.filter((gen) => gen.schema).map((gen) => Promise.resolve(gen.schema(transformedNode, ctx)).then((result) => applyHookResult(result, driver, resolveRenderer(gen)))));
+      await Promise.all(generators.filter((gen) => gen.schema).map(async (gen) => {
+        return applyHookResult({
+          result: await gen.schema(transformedNode, ctx),
+          driver,
+          rendererFactory: resolveRenderer(gen)
+        });
+      }));
       await driver.hooks.emit("kubb:generate:schema", transformedNode, ctx);
     },
     async operation(node) {
@@ -6702,15 +6831,20 @@ async function runPluginAstHooks(plugin, context) {
         include,
         override
       });
-      if (options !== null) {
-        collectedOperations.push(transformedNode);
-        const ctx = {
-          ...generatorContext,
-          options
-        };
-        await Promise.all(generators.filter((gen) => gen.operation).map((gen) => Promise.resolve(gen.operation(transformedNode, ctx)).then((result) => applyHookResult(result, driver, resolveRenderer(gen)))));
-        await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
-      }
+      if (options === null) return;
+      collectedOperations.push(transformedNode);
+      const ctx = {
+        ...generatorContext,
+        options
+      };
+      await Promise.all(generators.filter((gen) => gen.operation).map(async (gen) => {
+        return applyHookResult({
+          result: await gen.operation(transformedNode, ctx),
+          driver,
+          rendererFactory: resolveRenderer(gen)
+        });
+      }));
+      await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
     }
   });
   if (collectedOperations.length > 0) {
@@ -6720,85 +6854,130 @@ async function runPluginAstHooks(plugin, context) {
     };
     for (const gen of generators) {
       if (!gen.operations) continue;
-      await applyHookResult(await gen.operations(collectedOperations, ctx), driver, resolveRenderer(gen));
+      await applyHookResult({
+        result: await gen.operations(collectedOperations, ctx),
+        driver,
+        rendererFactory: resolveRenderer(gen)
+      });
     }
     await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
   }
 }
 async function safeBuild(setupResult) {
   var _a2, _b2, _c, _d;
-  const { driver, hooks, storage } = setupResult;
-  const failedPlugins = /* @__PURE__ */ new Set();
-  const pluginTimings = /* @__PURE__ */ new Map();
-  const config = driver.config;
-  const writtenPaths = /* @__PURE__ */ new Set();
-  const parsersMap = /* @__PURE__ */ new Map();
-  for (const parser of config.parsers) if (parser.extNames) for (const extname of parser.extNames) parsersMap.set(extname, parser);
-  const fileProcessor = new FileProcessor();
-  async function flushPendingFiles(snapshot) {
-    const files = driver.fileManager.files.filter((f) => !writtenPaths.has(f.path) && (!snapshot || !snapshot.has(f.path)));
-    if (files.length === 0) return;
-    await hooks.emit("kubb:debug", {
-      date: /* @__PURE__ */ new Date(),
-      logs: [`Writing ${files.length} files...`]
-    });
-    await hooks.emit("kubb:files:processing:start", { files });
-    const stream = fileProcessor.stream(files, {
-      parsers: parsersMap,
-      extension: config.output.extension
-    });
-    for await (const { file, source, processed, total, percentage } of stream) {
-      await hooks.emit("kubb:file:processing:update", {
-        file,
-        source,
-        processed,
-        total,
-        percentage,
-        config
+  try {
+    var _usingCtx$1 = _usingCtx();
+    _usingCtx$1.u(setupResult);
+    const { driver, hooks, storage } = setupResult;
+    const failedPlugins = /* @__PURE__ */ new Set();
+    const pluginTimings = /* @__PURE__ */ new Map();
+    const config = driver.config;
+    const writtenPaths = /* @__PURE__ */ new Set();
+    const parsersMap = /* @__PURE__ */ new Map();
+    for (const parser of config.parsers) if (parser.extNames) for (const extname of parser.extNames) parsersMap.set(extname, parser);
+    const fileProcessor = new FileProcessor();
+    async function flushPendingFiles() {
+      const files = driver.fileManager.files.filter((f) => !writtenPaths.has(f.path));
+      if (files.length === 0) return;
+      await hooks.emit("kubb:debug", {
+        date: /* @__PURE__ */ new Date(),
+        logs: [`Writing ${files.length} files...`]
+      });
+      await hooks.emit("kubb:files:processing:start", { files });
+      const stream = fileProcessor.stream(files, {
+        parsers: parsersMap,
+        extension: config.output.extension
+      });
+      for (const { file, source, processed, total, percentage } of stream) {
+        await hooks.emit("kubb:file:processing:update", {
+          file,
+          source,
+          processed,
+          total,
+          percentage,
+          config
+        });
+        if (source) await storage.setItem(file.path, source);
+        writtenPaths.add(file.path);
+      }
+      await hooks.emit("kubb:files:processing:end", { files });
+      await hooks.emit("kubb:debug", {
+        date: /* @__PURE__ */ new Date(),
+        logs: [`\u2713 File write process completed for ${files.length} files`]
       });
-      if (source) await storage.setItem(file.path, source);
-      writtenPaths.add(file.path);
     }
-    await hooks.emit("kubb:files:processing:end", { files });
-    await hooks.emit("kubb:debug", {
-      date: /* @__PURE__ */ new Date(),
-      logs: [`\u2713 File write process completed for ${files.length} files`]
-    });
-  }
-  try {
-    await driver.emitSetupHooks();
-    if (driver.adapter && (driver.inputNode || driver.inputStreamNode)) await hooks.emit("kubb:build:start", {
-      config,
-      adapter: driver.adapter,
-      inputNode: (_b2 = driver.inputNode) != null ? _b2 : {
-        kind: "Input",
-        schemas: [],
-        operations: [],
-        meta: (_a2 = driver.inputStreamNode) == null ? void 0 : _a2.meta
-      },
-      getPlugin: driver.getPlugin.bind(driver),
-      get files() {
-        return driver.fileManager.files;
-      },
-      upsertFile: (...files2) => driver.fileManager.upsert(...files2)
-    });
-    const inputStreamNode = driver.inputStreamNode;
-    if (inputStreamNode) {
-      const streamPluginEntries = [];
-      for (const plugin of driver.plugins.values()) {
+    try {
+      await driver.emitSetupHooks();
+      if (driver.adapter && (driver.inputNode || driver.inputStreamNode)) await hooks.emit("kubb:build:start", {
+        config,
+        adapter: driver.adapter,
+        inputNode: (_b2 = driver.inputNode) != null ? _b2 : {
+          kind: "Input",
+          schemas: [],
+          operations: [],
+          meta: (_a2 = driver.inputStreamNode) == null ? void 0 : _a2.meta
+        },
+        getPlugin: driver.getPlugin.bind(driver),
+        get files() {
+          return driver.fileManager.files;
+        },
+        upsertFile: (...files2) => driver.fileManager.upsert(...files2)
+      });
+      if (driver.inputStreamNode) {
+        const streamPluginEntries = [];
+        for (const plugin of driver.plugins.values()) {
+          const context = driver.getContext(plugin);
+          const hrStart = process.hrtime();
+          await hooks.emit("kubb:plugin:start", { plugin });
+          await hooks.emit("kubb:debug", {
+            date: /* @__PURE__ */ new Date(),
+            logs: ["Starting plugin...", `  \u2022 Plugin Name: ${plugin.name}`]
+          });
+          if (((_c = plugin.generators) == null ? void 0 : _c.length) || driver.hasRegisteredGenerators(plugin.name)) {
+            streamPluginEntries.push({
+              plugin,
+              context,
+              hrStart
+            });
+            continue;
+          }
+          const duration = getElapsedMs(hrStart);
+          pluginTimings.set(plugin.name, duration);
+          await hooks.emit("kubb:plugin:end", {
+            plugin,
+            duration,
+            success: true,
+            config,
+            get files() {
+              return driver.fileManager.files;
+            },
+            upsertFile: (...files2) => driver.fileManager.upsert(...files2)
+          });
+          await hooks.emit("kubb:debug", {
+            date: /* @__PURE__ */ new Date(),
+            logs: [`\u2713 Plugin started successfully (${formatMs(duration)})`]
+          });
+        }
+        if (streamPluginEntries.length > 0) {
+          await runPluginStreamHooks({
+            entries: streamPluginEntries,
+            driver,
+            pluginTimings,
+            failedPlugins
+          });
+          await flushPendingFiles();
+        }
+      } else for (const plugin of driver.plugins.values()) {
         const context = driver.getContext(plugin);
         const hrStart = process.hrtime();
-        await hooks.emit("kubb:plugin:start", { plugin });
-        await hooks.emit("kubb:debug", {
-          date: /* @__PURE__ */ new Date(),
-          logs: ["Starting plugin...", `  \u2022 Plugin Name: ${plugin.name}`]
-        });
-        if (((_c = plugin.generators) == null ? void 0 : _c.length) || driver.hasRegisteredGenerators(plugin.name)) streamPluginEntries.push({
-          plugin,
-          context,
-          hrStart
-        });
-        else {
+        try {
+          const timestamp = /* @__PURE__ */ new Date();
+          await hooks.emit("kubb:plugin:start", { plugin });
+          await hooks.emit("kubb:debug", {
+            date: timestamp,
+            logs: ["Starting plugin...", `  \u2022 Plugin Name: ${plugin.name}`]
+          });
+          if (((_d = plugin.generators) == null ? void 0 : _d.length) || driver.hasRegisteredGenerators(plugin.name)) await runPluginAstHooks(plugin, context);
           const duration = getElapsedMs(hrStart);
           pluginTimings.set(plugin.name, duration);
           await hooks.emit("kubb:plugin:end", {
@@ -6815,100 +6994,73 @@ async function safeBuild(setupResult) {
             date: /* @__PURE__ */ new Date(),
             logs: [`\u2713 Plugin started successfully (${formatMs(duration)})`]
           });
+        } catch (caughtError) {
+          const error = caughtError;
+          const errorTimestamp = /* @__PURE__ */ new Date();
+          const duration = getElapsedMs(hrStart);
+          await hooks.emit("kubb:plugin:end", {
+            plugin,
+            duration,
+            success: false,
+            error,
+            config,
+            get files() {
+              return driver.fileManager.files;
+            },
+            upsertFile: (...files2) => driver.fileManager.upsert(...files2)
+          });
+          await hooks.emit("kubb:debug", {
+            date: errorTimestamp,
+            logs: [
+              "\u2717 Plugin start failed",
+              `  \u2022 Plugin Name: ${plugin.name}`,
+              `  \u2022 Error: ${error.constructor.name} - ${error.message}`,
+              "  \u2022 Stack Trace:",
+              error.stack || "No stack trace available"
+            ]
+          });
+          failedPlugins.add({
+            plugin,
+            error
+          });
         }
+        await flushPendingFiles();
       }
-      if (streamPluginEntries.length > 0) await runPluginStreamHooks(inputStreamNode, streamPluginEntries, driver, hooks, config, pluginTimings, failedPlugins, flushPendingFiles);
-    } else for (const plugin of driver.plugins.values()) {
-      const context = driver.getContext(plugin);
-      const hrStart = process.hrtime();
-      try {
-        const timestamp = /* @__PURE__ */ new Date();
-        await hooks.emit("kubb:plugin:start", { plugin });
-        await hooks.emit("kubb:debug", {
-          date: timestamp,
-          logs: ["Starting plugin...", `  \u2022 Plugin Name: ${plugin.name}`]
-        });
-        if (((_d = plugin.generators) == null ? void 0 : _d.length) || driver.hasRegisteredGenerators(plugin.name)) await runPluginAstHooks(plugin, context);
-        const duration = getElapsedMs(hrStart);
-        pluginTimings.set(plugin.name, duration);
-        await hooks.emit("kubb:plugin:end", {
-          plugin,
-          duration,
-          success: true,
-          config,
-          get files() {
-            return driver.fileManager.files;
-          },
-          upsertFile: (...files2) => driver.fileManager.upsert(...files2)
-        });
-        await hooks.emit("kubb:debug", {
-          date: /* @__PURE__ */ new Date(),
-          logs: [`\u2713 Plugin started successfully (${formatMs(duration)})`]
-        });
-      } catch (caughtError) {
-        const error = caughtError;
-        const errorTimestamp = /* @__PURE__ */ new Date();
-        const duration = getElapsedMs(hrStart);
-        await hooks.emit("kubb:plugin:end", {
-          plugin,
-          duration,
-          success: false,
-          error,
-          config,
-          get files() {
-            return driver.fileManager.files;
-          },
-          upsertFile: (...files2) => driver.fileManager.upsert(...files2)
-        });
-        await hooks.emit("kubb:debug", {
-          date: errorTimestamp,
-          logs: [
-            "\u2717 Plugin start failed",
-            `  \u2022 Plugin Name: ${plugin.name}`,
-            `  \u2022 Error: ${error.constructor.name} - ${error.message}`,
-            "  \u2022 Stack Trace:",
-            error.stack || "No stack trace available"
-          ]
-        });
-        failedPlugins.add({
-          plugin,
-          error
-        });
-      }
+      await hooks.emit("kubb:plugins:end", {
+        config,
+        get files() {
+          return driver.fileManager.files;
+        },
+        upsertFile: (...files2) => driver.fileManager.upsert(...files2)
+      });
       await flushPendingFiles();
+      const files = driver.fileManager.files;
+      await hooks.emit("kubb:build:end", {
+        files,
+        config,
+        outputDir: resolve(config.root, config.output.path)
+      });
+      return {
+        failedPlugins,
+        files,
+        driver,
+        pluginTimings,
+        storage
+      };
+    } catch (error) {
+      return {
+        failedPlugins,
+        files: [],
+        driver,
+        pluginTimings,
+        error,
+        storage
+      };
     }
-    await hooks.emit("kubb:plugins:end", {
-      config,
-      get files() {
-        return driver.fileManager.files;
-      },
-      upsertFile: (...files2) => driver.fileManager.upsert(...files2)
-    });
-    await flushPendingFiles();
-    const files = driver.fileManager.files;
-    await hooks.emit("kubb:build:end", {
-      files,
-      config,
-      outputDir: resolve(config.root, config.output.path)
-    });
-    return {
-      failedPlugins,
-      files,
-      driver,
-      pluginTimings,
-      storage
-    };
-  } catch (error) {
-    return {
-      failedPlugins,
-      files: [],
-      driver,
-      pluginTimings,
-      error,
-      storage
-    };
+  } catch (_) {
+    _usingCtx$1.e = _;
   } finally {
-    setupResult.dispose();
+    _usingCtx$1.d();
   }
 }
 async function build(setupResult) {
@@ -7020,7 +7172,7 @@ const memoryStorage = createStorage(() => {
   };
 });
 
-var version = "5.0.0-beta.17";
+var version = "5.0.0-beta.19";
 
 function isCommandMessage(msg) {
   return msg.type === "command";
@@ -7031,9 +7183,6 @@ function isPongMessage(msg) {
 function isDisconnectMessage(msg) {
   return msg.type === "disconnect";
 }
-function isPublishCommandMessage(msg) {
-  return msg.type === "command" && msg.command === "publish";
-}
 
 function getStorage() {
   return useStorage("kubb");
@@ -7279,44 +7428,6 @@ async function mergePlugins(diskPlugins, studioPlugins) {
   return [...mergedDisk, ...studioOnly];
 }
 
-async function publish({ command, outputPath, root, hooks }) {
-  var _a, _b, _c, _d;
-  const resolvedOutputPath = path$1.isAbsolute(outputPath) ? outputPath : path$1.resolve(root, outputPath);
-  const [cmd, ...args] = tokenize(command);
-  if (!cmd) {
-    throw new Error(`[plugin-publish] Invalid publish command: "${command}"`);
-  }
-  const commandWithArgs = args.length ? `${cmd} ${args.join(" ")}` : cmd;
-  await hooks.emit("kubb:info", { message: `[publish] Running "${commandWithArgs}" in "${resolvedOutputPath}"` });
-  const startTime = Date.now();
-  let exitCode = null;
-  try {
-    const proc = x(cmd, args, {
-      nodeOptions: { cwd: resolvedOutputPath }
-    });
-    for await (const line of proc) {
-      if (line.trim()) {
-        await hooks.emit("kubb:info", { message: line.trim() });
-      }
-    }
-    const result = await proc;
-    exitCode = (_a = result.exitCode) != null ? _a : null;
-  } catch (err) {
-    const message = (_d = (_c = (_b = err == null ? void 0 : err.stderr) == null ? void 0 : _b.trim()) != null ? _c : err == null ? void 0 : err.message) != null ? _d : String(err);
-    const error = new Error(`[publish] Failed to run "${commandWithArgs}": ${message}`);
-    error.cause = err;
-    await hooks.emit("kubb:error", { error });
-    throw error;
-  }
-  if (exitCode !== 0) {
-    const error = new Error(`[publish] "${commandWithArgs}" exited with code ${exitCode}`);
-    await hooks.emit("kubb:error", { error });
-    throw error;
-  }
-  const duration = Date.now() - startTime;
-  await hooks.emit("kubb:success", { message: `[publish] Published successfully in ${duration}ms` });
-}
-
 function setupHookListener(hooks, root) {
   hooks.on("kubb:hook:start", async (ctx) => {
     const { id, command, args } = ctx;
@@ -7387,11 +7498,11 @@ function sendAgentMessage(ws, message) {
     throw new Error("Failed to send message to Kubb Studio", { cause: error });
   }
 }
-function setupEventsStream(ws, hooks, getSource) {
+function setupEventsStream(ws, hooks) {
   function sendDataMessage(payload) {
     sendAgentMessage(ws, {
       type: "data",
-      payload: { ...payload, source: getSource == null ? void 0 : getSource() }
+      payload
     });
   }
   hooks.on("kubb:plugin:start", (ctx) => {
@@ -7506,7 +7617,6 @@ async function connectToStudio(options) {
     resolvedConfigPath,
     allowAll,
     allowWrite,
-    allowPublish,
     root,
     retryInterval,
     heartbeatInterval = 3e4,
@@ -7514,7 +7624,6 @@ async function connectToStudio(options) {
     nitro
   } = options;
   const hooks = new AsyncEventEmitter();
-  let currentSource;
   async function reconnect() {
     logger.info(`Retrying connection in ${formatMs$1(retryInterval)} to Kubb Studio ...`);
     setTimeout(() => connectToStudio({ ...options, initialSession: void 0 }), retryInterval);
@@ -7529,7 +7638,6 @@ async function connectToStudio(options) {
     const maskedSessionId = maskString(sessionId);
     const effectiveAllowAll = isSandbox ? false : allowAll;
     const effectiveWrite = isSandbox ? false : allowWrite;
-    const effectivePublish = isSandbox ? false : allowPublish;
     let serverDisconnected = false;
     let heartbeatTimer;
     async function cleanup(reason = "cleanup") {
@@ -7541,6 +7649,7 @@ async function connectToStudio(options) {
         ws.removeEventListener("open", onOpen);
         ws.removeEventListener("close", onClose);
         ws.removeEventListener("error", onError);
+        ws.removeEventListener("message", onMessage);
       } catch (_error) {
       }
     }
@@ -7573,9 +7682,9 @@ async function connectToStudio(options) {
       });
     });
     heartbeatTimer = setInterval(() => sendAgentMessage(ws, { type: "ping" }), heartbeatInterval);
-    setupEventsStream(ws, hooks, () => currentSource);
-    ws.addEventListener("message", async (message) => {
-      var _a2, _b, _c, _d, _e, _f;
+    setupEventsStream(ws, hooks);
+    const onMessage = async (message) => {
+      var _a2, _b, _c, _d;
       try {
         const data = JSON.parse(message.data);
         logger.info(`[${maskedSessionId}] Received "${data.type}" from Studio`);
@@ -7597,7 +7706,6 @@ async function connectToStudio(options) {
         }
         if (isCommandMessage(data)) {
           if (data.command === "generate") {
-            currentSource = "generate";
             const config = await loadConfig(resolvedConfigPath);
             const storedConfig = data.payload ? null : await getLatestStudioConfigFromStorage({ sessionId }).catch(() => null);
             const patch = (_b = (_a2 = data.payload) != null ? _a2 : storedConfig) != null ? _b : void 0;
@@ -7620,7 +7728,7 @@ async function connectToStudio(options) {
             }
             const generationHooks = new AsyncEventEmitter();
             setupHookListener(generationHooks, root);
-            setupEventsStream(ws, generationHooks, () => currentSource);
+            setupEventsStream(ws, generationHooks);
             await generate({
               config: {
                 ...config,
@@ -7639,7 +7747,6 @@ async function connectToStudio(options) {
               hooks: generationHooks
             });
             logger.success(`[${maskedSessionId}] Completed "${data.type}" from Studio`);
-            currentSource = void 0;
             return;
           }
           if (data.command === "connect") {
@@ -7651,8 +7758,7 @@ async function connectToStudio(options) {
                 configPath,
                 permissions: {
                   allowAll: effectiveAllowAll,
-                  allowWrite: effectiveWrite,
-                  allowPublish: effectivePublish
+                  allowWrite: effectiveWrite
                 },
                 config: {
                   plugins: config.plugins.map((plugin) => ({
@@ -7665,30 +7771,13 @@ async function connectToStudio(options) {
             logger.success(`[${maskedSessionId}] Completed "${data.type}" from Studio`);
             return;
           }
-          if (isPublishCommandMessage(data)) {
-            if (!effectivePublish) {
-              logger.warn(`[${maskedSessionId}] Publish command rejected \u2014 KUBB_AGENT_ALLOW_PUBLISH is not enabled`);
-              return;
-            }
-            currentSource = "publish";
-            const config = await loadConfig(resolvedConfigPath);
-            const resolvedCommand = (_e = (_d = data.payload.command) != null ? _d : process.env.KUBB_AGENT_PUBLISH_COMMAND) != null ? _e : "npm publish";
-            await publish({
-              command: resolvedCommand,
-              outputPath: config.output.path,
-              root,
-              hooks
-            });
-            logger.success(`[${maskedSessionId}] Completed "${data.command}" from Studio`);
-            currentSource = void 0;
-            return;
-          }
         }
         logger.warn(`[${maskedSessionId}] Unknown message type from Kubb Studio: ${message.data}`);
       } catch (error) {
-        logger.error(`[${maskedSessionId}] [unhandledRejection] ${(_f = error == null ? void 0 : error.message) != null ? _f : error}`);
+        logger.error(`[${maskedSessionId}] [unhandledRejection] ${(_d = error == null ? void 0 : error.message) != null ? _d : error}`);
       }
-    });
+    };
+    ws.addEventListener("message", onMessage);
   } catch (error) {
     throw new Error(`[unhandledRejection] ${(_a = error == null ? void 0 : error.message) != null ? _a : error}`, {
       cause: error
@@ -7718,7 +7807,6 @@ function resolveStudioRuntimeConfig(env = process$1.env, cwd = process$1.cwd())
     root,
     allowAll,
     allowWrite: allowAll || parseBooleanEnv(env.KUBB_AGENT_ALLOW_WRITE),
-    allowPublish: allowAll || parseBooleanEnv(env.KUBB_AGENT_ALLOW_PUBLISH),
     poolSize: parsePositiveIntegerEnv(env.KUBB_AGENT_POOL_SIZE, agentDefaults.poolSize),
     hasSecret: Boolean(env.KUBB_AGENT_SECRET)
   };
@@ -7728,7 +7816,7 @@ function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 const _zcw7I4pYH8OiCfaDcjy_x7I6IH1tLDQR3W_yRZgP6E = defineNitroPlugin(async (nitro) => {
-  const { studioUrl, token, configPath, resolvedConfigPath, retryInterval, heartbeatInterval, root, allowAll, allowWrite, allowPublish, poolSize, hasSecret } = resolveStudioRuntimeConfig(process$1.env);
+  const { studioUrl, token, configPath, resolvedConfigPath, retryInterval, heartbeatInterval, root, allowAll, allowWrite, poolSize, hasSecret } = resolveStudioRuntimeConfig(process$1.env);
   if (!token) {
     logger.warn("KUBB_AGENT_TOKEN not set", "cannot authenticate with studio");
     return null;
@@ -7747,7 +7835,6 @@ const _zcw7I4pYH8OiCfaDcjy_x7I6IH1tLDQR3W_yRZgP6E = defineNitroPlugin(async (nit
       resolvedConfigPath,
       allowAll,
       allowWrite,
-      allowPublish,
       root,
       retryInterval,
       heartbeatInterval,