@kubb/agent 0.0.0-canary-20260217115709

package/.output/server/node_modules/@kubb/react-fabric/package.json

@@ -0,0 +1,140 @@
+{
+  "name": "@kubb/react-fabric",
+  "version": "0.12.11",
+  "description": "React integration for Kubb's fabric - JSX runtime and component-based code generation with React reconciler for building type-safe generators",
+  "keywords": [
+    "react",
+    "jsx",
+    "jsx-runtime",
+    "react-reconciler",
+    "component-generation",
+    "codegen",
+    "code-generator",
+    "typescript",
+    "file-generation",
+    "plugin-system",
+    "plugins",
+    "fabric",
+    "kubb"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kubb-labs/fabric.git",
+    "directory": "packages/react-fabric"
+  },
+  "license": "MIT",
+  "author": "stijnvanhulle",
+  "sideEffects": [
+    "./dist/globals.js",
+    "./dist/globals.cjs"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./globals": {
+      "import": "./dist/globals.js",
+      "require": "./dist/globals.cjs"
+    },
+    "./jsx-dev-runtime": {
+      "import": "./dist/jsx-dev-runtime.js",
+      "require": "./dist/jsx-dev-runtime.cjs"
+    },
+    "./jsx-runtime": {
+      "import": "./dist/jsx-runtime.js",
+      "require": "./dist/jsx-runtime.cjs"
+    },
+    "./parsers": {
+      "import": "./dist/parsers.js",
+      "require": "./dist/parsers.cjs"
+    },
+    "./plugins": {
+      "import": "./dist/plugins.js",
+      "require": "./dist/plugins.cjs"
+    },
+    "./types": {
+      "import": "./dist/types.js",
+      "require": "./dist/types.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.cts",
+  "typesVersions": {
+    "*": {
+      "globals": [
+        "./dist/globals.d.ts"
+      ],
+      "jsx-dev-runtime": [
+        "./dist/jsx-runtime.d.ts"
+      ],
+      "jsx-runtime": [
+        "./dist/jsx-runtime.d.ts"
+      ],
+      "parsers": [
+        "./dist/parsers.d.ts"
+      ],
+      "plugins": [
+        "./dist/plugins.d.ts"
+      ],
+      "types": [
+        "./dist/types.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "*.d.ts",
+    "*.d.cts",
+    "!*.map",
+    "!/**/**.test.**",
+    "!/**/__tests__/**"
+  ],
+  "size-limit": [
+    {
+      "path": "./dist/*.js",
+      "limit": "510 KiB",
+      "gzip": true
+    }
+  ],
+  "dependencies": {
+    "execa": "^9.6.1",
+    "natural-orderby": "^5.0.0",
+    "react-devtools-core": "6.1.5",
+    "remeda": "^2.33.5",
+    "signal-exit": "^4.1.0",
+    "ws": "8.18.0",
+    "@kubb/fabric-core": "0.12.11"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.13",
+    "@types/react-reconciler": "0.32.0",
+    "@types/ws": "^8.18.1",
+    "react": "19.2.3",
+    "react-reconciler": "0.33.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsdown && size-limit",
+    "start": "tsdown --watch ./src",
+    "clean": "npx rimraf ./dist",
+    "lint": "pnpm biome lint .",
+    "lint:fix": "pnpm biome lint --fix --unsafe .",
+    "release": "pnpm publish --no-git-check",
+    "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check -tag canary",
+    "start:devtools": "npx react-devtools",
+    "test": "vitest --passWithNoTests",
+    "test:devtools": "node ./dist/runner.cjs",
+    "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"
+  }
+}

package/.output/server/node_modules/@sec-ant/readable-stream/dist/ponyfill/asyncIterator.js

@@ -0,0 +1,89 @@
+const a = Object.getPrototypeOf(
+  Object.getPrototypeOf(
+    /* istanbul ignore next */
+    async function* () {
+    }
+  ).prototype
+);
+class c {
+  #t;
+  #n;
+  #r = !1;
+  #e = void 0;
+  constructor(e, t) {
+    this.#t = e, this.#n = t;
+  }
+  next() {
+    const e = () => this.#s();
+    return this.#e = this.#e ? this.#e.then(e, e) : e(), this.#e;
+  }
+  return(e) {
+    const t = () => this.#i(e);
+    return this.#e ? this.#e.then(t, t) : t();
+  }
+  async #s() {
+    if (this.#r)
+      return {
+        done: !0,
+        value: void 0
+      };
+    let e;
+    try {
+      e = await this.#t.read();
+    } catch (t) {
+      throw this.#e = void 0, this.#r = !0, this.#t.releaseLock(), t;
+    }
+    return e.done && (this.#e = void 0, this.#r = !0, this.#t.releaseLock()), e;
+  }
+  async #i(e) {
+    if (this.#r)
+      return {
+        done: !0,
+        value: e
+      };
+    if (this.#r = !0, !this.#n) {
+      const t = this.#t.cancel(e);
+      return this.#t.releaseLock(), await t, {
+        done: !0,
+        value: e
+      };
+    }
+    return this.#t.releaseLock(), {
+      done: !0,
+      value: e
+    };
+  }
+}
+const n = Symbol();
+function i() {
+  return this[n].next();
+}
+Object.defineProperty(i, "name", { value: "next" });
+function o(r) {
+  return this[n].return(r);
+}
+Object.defineProperty(o, "name", { value: "return" });
+const u = Object.create(a, {
+  next: {
+    enumerable: !0,
+    configurable: !0,
+    writable: !0,
+    value: i
+  },
+  return: {
+    enumerable: !0,
+    configurable: !0,
+    writable: !0,
+    value: o
+  }
+});
+function h({ preventCancel: r = !1 } = {}) {
+  const e = this.getReader(), t = new c(
+    e,
+    r
+  ), s = Object.create(u);
+  return s[n] = t, s;
+}
+export {
+  h as asyncIterator
+};

package/.output/server/node_modules/@sec-ant/readable-stream/dist/ponyfill/fromAnyIterable.js

@@ -0,0 +1,34 @@
+function c(n) {
+  const t = a(n);
+  return new ReadableStream(
+    {
+      async pull(e) {
+        const { value: r, done: o } = await t.next();
+        o ? e.close() : e.enqueue(r);
+      },
+      async cancel(e) {
+        if (typeof t.return == "function" && typeof await t.return(e) != "object")
+          throw new TypeError("return() fulfills with a non-object.");
+        return e;
+      }
+    },
+    new CountQueuingStrategy({
+      highWaterMark: 0
+    })
+  );
+}
+function a(n) {
+  let t = n[Symbol.asyncIterator]?.bind(n);
+  if (t === void 0) {
+    const r = n[Symbol.iterator](), o = {
+      [Symbol.iterator]: () => r
+    };
+    t = async function* () {
+      return yield* o;
+    };
+  }
+  return t();
+}
+export {
+  c as fromAnyIterable
+};

package/.output/server/node_modules/@sec-ant/readable-stream/dist/ponyfill/index.js

@@ -0,0 +1,6 @@
+import { asyncIterator as e } from "./asyncIterator.js";
+import { fromAnyIterable as a } from "./fromAnyIterable.js";
+export {
+  e as asyncIterator,
+  a as fromAnyIterable
+};

package/.output/server/node_modules/@sec-ant/readable-stream/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@sec-ant/readable-stream",
+  "description": "A tiny, zero-dependency yet spec-compliant asynchronous iterator polyfill/ponyfill for ReadableStreams.",
+  "private": false,
+  "version": "0.4.1",
+  "type": "module",
+  "files": [
+    "./dist"
+  ],
+  "main": "./dist/index/index.js",
+  "module": "./dist/index/index.js",
+  "exports": {
+    ".": "./dist/index/index.js",
+    "./asyncIterator": "./dist/index/asyncIterator.js",
+    "./fromAnyIterable": "./dist/index/fromAnyIterable.js",
+    "./ponyfill": "./dist/ponyfill/index.js",
+    "./ponyfill/asyncIterator": "./dist/ponyfill/asyncIterator.js",
+    "./ponyfill/fromAnyIterable": "./dist/ponyfill/fromAnyIterable.js",
+    "./polyfill": "./dist/polyfill/index.js",
+    "./polyfill/asyncIterator": "./dist/polyfill/asyncIterator.js",
+    "./polyfill/fromAnyIterable": "./dist/polyfill/fromAnyIterable.js",
+    "./async-iterator": {
+      "types": "./dist/types/async-iterator.d.ts"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Sec-ant/readable-stream.git"
+  },
+  "homepage": "https://github.com/Sec-ant/readable-stream",
+  "bugs": {
+    "url": "https://github.com/Sec-ant/readable-stream/issues",
+    "email": "zezhengwu@proton.me"
+  },
+  "keywords": [
+    "stream",
+    "web-streams",
+    "readablestream",
+    "async",
+    "asynchronous",
+    "iterator",
+    "iteration",
+    "async-iterator",
+    "polyfill",
+    "esm",
+    "from-iterable"
+  ],
+  "author": {
+    "name": "Ze-Zheng Wu"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "install:ci": "npm ci && npx playwright install --with-deps",
+    "install:codesandbox": "npm ci && ./scripts/prepare.sh",
+    "update-hooks": "simple-git-hooks",
+    "changeset": "changeset",
+    "bump": "changeset version 2>/dev/null | grep . && npm i; exit 0",
+    "type-check": "tsc --noEmit --emitDeclarationOnly false",
+    "format:prettier": "prettier . --write",
+    "format:biome": "biome format . --write",
+    "format": "conc \"npm:format:prettier\" \"npm:format:biome\"",
+    "check:biome": "biome check --apply .",
+    "check": "conc \"npm:format:prettier\" \"npm:check:biome\"",
+    "prebuild": "npm run check && npm run type-check",
+    "build": "vite build",
+    "copy": "copy-files-from-to",
+    "postbuild": "tsc && npm run copy",
+    "test:chromium": "vitest run --browser.name=chromium",
+    "test:firefox": "vitest run --browser.name=firefox",
+    "test": "npm run test:chromium && npm run test:firefox",
+    "test:coverage": "vitest run --coverage",
+    "test:ui": "vitest --ui --coverage",
+    "prepublishOnly": "npm run build",
+    "bump-biome:latest": "npm i -DE @biomejs/biome@latest",
+    "bump-biome:nightly": "npm i -DE @biomejs/biome@nightly"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "1.6.1",
+    "@changesets/cli": "^2.27.1",
+    "@commitlint/cli": "^19.1.0",
+    "@commitlint/config-conventional": "^19.1.0",
+    "@vitest/browser": "^1.3.1",
+    "@vitest/coverage-istanbul": "^1.3.1",
+    "@vitest/ui": "^1.3.1",
+    "concurrently": "^8.2.2",
+    "copy-files-from-to": "^3.9.1",
+    "lint-staged": "^15.2.2",
+    "playwright": "^1.42.1",
+    "prettier": "^3.2.5",
+    "simple-git-hooks": "^2.10.0",
+    "typescript": "^5.4.2",
+    "vite": "^5.1.6",
+    "vitest": "^1.3.1"
+  }
+}

package/.output/server/node_modules/@sindresorhus/merge-streams/index.js

@@ -0,0 +1,265 @@
+import {on, once} from 'node:events';
+import {PassThrough as PassThroughStream, getDefaultHighWaterMark} from 'node:stream';
+import {finished} from 'node:stream/promises';
+
+export default function mergeStreams(streams) {
+	if (!Array.isArray(streams)) {
+		throw new TypeError(`Expected an array, got \`${typeof streams}\`.`);
+	}
+
+	for (const stream of streams) {
+		validateStream(stream);
+	}
+
+	const objectMode = streams.some(({readableObjectMode}) => readableObjectMode);
+	const highWaterMark = getHighWaterMark(streams, objectMode);
+	const passThroughStream = new MergedStream({
+		objectMode,
+		writableHighWaterMark: highWaterMark,
+		readableHighWaterMark: highWaterMark,
+	});
+
+	for (const stream of streams) {
+		passThroughStream.add(stream);
+	}
+
+	return passThroughStream;
+}
+
+const getHighWaterMark = (streams, objectMode) => {
+	if (streams.length === 0) {
+		return getDefaultHighWaterMark(objectMode);
+	}
+
+	const highWaterMarks = streams
+		.filter(({readableObjectMode}) => readableObjectMode === objectMode)
+		.map(({readableHighWaterMark}) => readableHighWaterMark);
+	return Math.max(...highWaterMarks);
+};
+
+class MergedStream extends PassThroughStream {
+	#streams = new Set([]);
+	#ended = new Set([]);
+	#aborted = new Set([]);
+	#onFinished;
+	#unpipeEvent = Symbol('unpipe');
+	#streamPromises = new WeakMap();
+
+	add(stream) {
+		validateStream(stream);
+
+		if (this.#streams.has(stream)) {
+			return;
+		}
+
+		this.#streams.add(stream);
+
+		this.#onFinished ??= onMergedStreamFinished(this, this.#streams, this.#unpipeEvent);
+		const streamPromise = endWhenStreamsDone({
+			passThroughStream: this,
+			stream,
+			streams: this.#streams,
+			ended: this.#ended,
+			aborted: this.#aborted,
+			onFinished: this.#onFinished,
+			unpipeEvent: this.#unpipeEvent,
+		});
+		this.#streamPromises.set(stream, streamPromise);
+
+		stream.pipe(this, {end: false});
+	}
+
+	async remove(stream) {
+		validateStream(stream);
+
+		if (!this.#streams.has(stream)) {
+			return false;
+		}
+
+		const streamPromise = this.#streamPromises.get(stream);
+		if (streamPromise === undefined) {
+			return false;
+		}
+
+		this.#streamPromises.delete(stream);
+
+		stream.unpipe(this);
+		await streamPromise;
+		return true;
+	}
+}
+
+const onMergedStreamFinished = async (passThroughStream, streams, unpipeEvent) => {
+	updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_COUNT);
+	const controller = new AbortController();
+
+	try {
+		await Promise.race([
+			onMergedStreamEnd(passThroughStream, controller),
+			onInputStreamsUnpipe(passThroughStream, streams, unpipeEvent, controller),
+		]);
+	} finally {
+		controller.abort();
+		updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_COUNT);
+	}
+};
+
+const onMergedStreamEnd = async (passThroughStream, {signal}) => {
+	try {
+		await finished(passThroughStream, {signal, cleanup: true});
+	} catch (error) {
+		errorOrAbortStream(passThroughStream, error);
+		throw error;
+	}
+};
+
+const onInputStreamsUnpipe = async (passThroughStream, streams, unpipeEvent, {signal}) => {
+	for await (const [unpipedStream] of on(passThroughStream, 'unpipe', {signal})) {
+		if (streams.has(unpipedStream)) {
+			unpipedStream.emit(unpipeEvent);
+		}
+	}
+};
+
+const validateStream = stream => {
+	if (typeof stream?.pipe !== 'function') {
+		throw new TypeError(`Expected a readable stream, got: \`${typeof stream}\`.`);
+	}
+};
+
+const endWhenStreamsDone = async ({passThroughStream, stream, streams, ended, aborted, onFinished, unpipeEvent}) => {
+	updateMaxListeners(passThroughStream, PASSTHROUGH_LISTENERS_PER_STREAM);
+	const controller = new AbortController();
+
+	try {
+		await Promise.race([
+			afterMergedStreamFinished(onFinished, stream, controller),
+			onInputStreamEnd({
+				passThroughStream,
+				stream,
+				streams,
+				ended,
+				aborted,
+				controller,
+			}),
+			onInputStreamUnpipe({
+				stream,
+				streams,
+				ended,
+				aborted,
+				unpipeEvent,
+				controller,
+			}),
+		]);
+	} finally {
+		controller.abort();
+		updateMaxListeners(passThroughStream, -PASSTHROUGH_LISTENERS_PER_STREAM);
+	}
+
+	if (streams.size > 0 && streams.size === ended.size + aborted.size) {
+		if (ended.size === 0 && aborted.size > 0) {
+			abortStream(passThroughStream);
+		} else {
+			endStream(passThroughStream);
+		}
+	}
+};
+
+const afterMergedStreamFinished = async (onFinished, stream, {signal}) => {
+	try {
+		await onFinished;
+		if (!signal.aborted) {
+			abortStream(stream);
+		}
+	} catch (error) {
+		if (!signal.aborted) {
+			errorOrAbortStream(stream, error);
+		}
+	}
+};
+
+const onInputStreamEnd = async ({passThroughStream, stream, streams, ended, aborted, controller: {signal}}) => {
+	try {
+		await finished(stream, {
+			signal,
+			cleanup: true,
+			readable: true,
+			writable: false,
+		});
+		if (streams.has(stream)) {
+			ended.add(stream);
+		}
+	} catch (error) {
+		if (signal.aborted || !streams.has(stream)) {
+			return;
+		}
+
+		if (isAbortError(error)) {
+			aborted.add(stream);
+		} else {
+			errorStream(passThroughStream, error);
+		}
+	}
+};
+
+const onInputStreamUnpipe = async ({stream, streams, ended, aborted, unpipeEvent, controller: {signal}}) => {
+	await once(stream, unpipeEvent, {signal});
+
+	if (!stream.readable) {
+		return once(signal, 'abort', {signal});
+	}
+
+	streams.delete(stream);
+	ended.delete(stream);
+	aborted.delete(stream);
+};
+
+const endStream = stream => {
+	if (stream.writable) {
+		stream.end();
+	}
+};
+
+const errorOrAbortStream = (stream, error) => {
+	if (isAbortError(error)) {
+		abortStream(stream);
+	} else {
+		errorStream(stream, error);
+	}
+};
+
+// This is the error thrown by `finished()` on `stream.destroy()`
+const isAbortError = error => error?.code === 'ERR_STREAM_PREMATURE_CLOSE';
+
+const abortStream = stream => {
+	if (stream.readable || stream.writable) {
+		stream.destroy();
+	}
+};
+
+// `stream.destroy(error)` crashes the process with `uncaughtException` if no `error` event listener exists on `stream`.
+// We take care of error handling on user behalf, so we do not want this to happen.
+const errorStream = (stream, error) => {
+	if (!stream.destroyed) {
+		stream.once('error', noop);
+		stream.destroy(error);
+	}
+};
+
+const noop = () => {};
+
+const updateMaxListeners = (passThroughStream, increment) => {
+	const maxListeners = passThroughStream.getMaxListeners();
+	if (maxListeners !== 0 && maxListeners !== Number.POSITIVE_INFINITY) {
+		passThroughStream.setMaxListeners(maxListeners + increment);
+	}
+};
+
+// Number of times `passThroughStream.on()` is called regardless of streams:
+//  - once due to `finished(passThroughStream)`
+//  - once due to `on(passThroughStream)`
+const PASSTHROUGH_LISTENERS_COUNT = 2;
+
+// Number of times `passThroughStream.on()` is called per stream:
+//  - once due to `stream.pipe(passThroughStream)`
+const PASSTHROUGH_LISTENERS_PER_STREAM = 1;

package/.output/server/node_modules/@sindresorhus/merge-streams/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@sindresorhus/merge-streams",
+  "version": "4.0.0",
+  "description": "Merge multiple streams into a unified stream",
+  "license": "MIT",
+  "repository": "sindresorhus/merge-streams",
+  "funding": "https://github.com/sponsors/sindresorhus",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "https://sindresorhus.com"
+  },
+  "type": "module",
+  "exports": {
+    "types": "./index.d.ts",
+    "default": "./index.js"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "xo && c8 ava && tsd"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "keywords": [
+    "merge",
+    "stream",
+    "streams",
+    "readable",
+    "passthrough",
+    "interleave",
+    "interleaved",
+    "unify",
+    "unified"
+  ],
+  "devDependencies": {
+    "@types/node": "^20.8.9",
+    "ava": "^6.1.0",
+    "c8": "^9.1.0",
+    "tempfile": "^5.0.0",
+    "tsd": "^0.31.0",
+    "typescript": "^5.2.2",
+    "xo": "^0.58.0"
+  }
+}