@ykdz/template 0.0.38 → 0.0.41

package/node_modules/@ykdz/template-builtin-presets/templates/ts-cli/test/integration/command.test.ts

@@ -5,79 +5,138 @@ import { describe, expect, it } from "vitest";
 import { cliCommandIdentity } from "../../src/cli-command-identity.ts";
 import { runCli, type CliRuntime } from "../../src/main.ts";
 
-const require = createRequire(import.meta.url);
-const packageManifest = require("../../package.json") as unknown;
-const identity = cliCommandIdentity(packageManifest);
+const identity = cliCommandIdentity(
+  createRequire(import.meta.url)("../../package.json"),
+);
 
-function testRuntime(args: readonly string[]): {
-  readonly runtime: CliRuntime;
-  readonly stdout: () => string;
-  readonly stderr: () => string;
-} {
+function testRuntime(args: readonly string[]) {
   let stdout = "";
   let stderr = "";
-  return {
-    runtime: {
-      argv: ["node", identity.commandName, ...args],
-      streams: {
-        stdin: {},
-        stdout: { write: (chunk) => (stdout += chunk) },
-        stderr: { write: (chunk) => (stderr += chunk) },
-      },
-      cwd: "/workspace",
-      env: { MODE: "test" },
-      tty: { stdin: false, stdout: false, stderr: false },
-      identity,
+  const runtime: CliRuntime = {
+    argv: ["node", identity.commandName, ...args],
+    identity,
+    write: ({ destination, chunk }) => {
+      if (destination === "stdout") stdout += chunk;
+      else stderr += chunk;
     },
-    stdout: () => stdout,
-    stderr: () => stderr,
   };
+  return { runtime, stdout: () => stdout, stderr: () => stderr };
 }
 
-describe("CLI command control", () => {
-  it("parses greet and writes business output to the injected stream", async () => {
-    const output = testRuntime(["greet", "  Ada Lovelace  "]);
-
-    await expect(runCli(output.runtime)).resolves.toBe(0);
-    expect(output.stdout()).toBe("Hello, Ada Lovelace\n");
+describe("CLI 契约", () => {
+  it("查询成功默认返回结构化数据，也支持中文文本", async () => {
+    const output = testRuntime(["lookup", "ada"]);
+    expect(await runCli(output.runtime)).toBe(0);
+    expect(JSON.parse(output.stdout())).toEqual({
+      schemaVersion: "1",
+      command: "lookup",
+      kind: "data",
+      variant: "found",
+      data: { name: "ada", title: "Ada Lovelace" },
+    });
     expect(output.stderr()).toBe("");
+    const human = testRuntime(["lookup", "ada", "--output-format", "text"]);
+    expect(await runCli(human.runtime)).toBe(0);
+    expect(human.stdout()).toContain("找到记录");
+    expect(human.stdout()).toContain("Ada Lovelace");
   });
 
-  it("renders the version derived from the package manifest", async () => {
-    const output = testRuntime(["--version"]);
-
-    await expect(runCli(output.runtime)).resolves.toBe(0);
-    expect(output.stdout()).toBe(`${identity.version}\n`);
-    expect(output.stderr()).toBe("");
-  });
-
-  it("renders Commander help without exiting the process", async () => {
-    const output = testRuntime(["--help"]);
-
-    await expect(runCli(output.runtime)).resolves.toBe(0);
-    expect(output.stdout()).toContain(
-      `Usage: ${identity.commandName} [options] [command]`,
-    );
-    expect(output.stdout()).toContain("greet <name>");
-    expect(output.stderr()).toBe("");
+  it("未找到记录是已声明失败，非法名称是用法错误", async () => {
+    const missing = testRuntime(["lookup", "missing"]);
+    expect(await runCli(missing.runtime)).toBe(1);
+    expect(missing.stdout()).toBe("");
+    expect(JSON.parse(missing.stderr())).toMatchObject({
+      kind: "failure",
+      variant: "notFound",
+      data: { name: "missing" },
+    });
+    for (const args of [["lookup"], ["lookup", "   "]]) {
+      const invalid = testRuntime([...args, "--output-format", "text"]);
+      expect(await runCli(invalid.runtime)).toBe(2);
+      expect(invalid.stdout()).toBe("");
+      expect(JSON.parse(invalid.stderr())).toMatchObject({
+        kind: "usageFailure",
+      });
+    }
   });
 
-  it("reports missing arguments as Commander usage errors", async () => {
-    const output = testRuntime(["greet"]);
-
-    await expect(runCli(output.runtime)).resolves.toBe(1);
-    expect(output.stdout()).toBe("");
-    expect(output.stderr()).toContain(
-      "error: missing required argument 'name'",
+  it("帮助和版本使用 manifest 身份，schema 导出完整契约", async () => {
+    const version = testRuntime(["--version"]);
+    expect(await runCli(version.runtime)).toBe(0);
+    expect(version.stdout()).toBe(
+      `${identity.commandName} ${identity.version}\n`,
     );
-    expect(output.stderr()).toContain(`Usage: ${identity.commandName} greet`);
+    const help = testRuntime(["--help"]);
+    expect(await runCli(help.runtime)).toBe(0);
+    expect(help.stdout()).toContain(identity.commandName);
+    expect(help.stdout()).toContain("lookup");
+    expect(help.stdout()).toContain("schema");
+    const schema = testRuntime(["schema"]);
+    expect(await runCli(schema.runtime)).toBe(0);
+    const humanSchema = testRuntime(["schema", "--output-format", "text"]);
+    expect(await runCli(humanSchema.runtime)).toBe(0);
+    expect(humanSchema.stdout()).toContain("CLI 契约");
+    expect(humanSchema.stdout()).toContain('"commands"');
+    const manifest = JSON.parse(schema.stdout()).data.manifest;
+    expect(manifest).toMatchObject({
+      commands: {
+        lookup: {
+          input: {
+            inputSchema: {
+              properties: { name: { pattern: "^[a-z]+$" } },
+              required: ["name"],
+            },
+          },
+          success: { variants: { found: { exitCode: 0 } } },
+          failures: { notFound: { exitCode: 1 } },
+        },
+        schema: { success: { variants: { exported: { exitCode: 0 } } } },
+      },
+      controls: {
+        output: {
+          defaultFormat: "structured",
+          formats: ["structured", "text"],
+        },
+      },
+      usageFailure: { exitCode: 2 },
+    });
   });
 
-  it("adapts business validation into a testable command error", async () => {
-    const output = testRuntime(["greet", "   "]);
-
-    await expect(runCli(output.runtime)).resolves.toBe(1);
-    expect(output.stdout()).toBe("");
-    expect(output.stderr()).toContain("error: Name must not be empty");
+  it("等待输出完成，仅 stdout EPIPE 安静成功", async () => {
+    const output = testRuntime(["lookup", "ada"]);
+    expect(
+      await runCli({
+        ...output.runtime,
+        write: async () => {
+          throw Object.assign(new Error("pipe"), { code: "EPIPE" });
+        },
+      }),
+    ).toBe(0);
+    expect(
+      await runCli({
+        ...output.runtime,
+        write: async () => {
+          throw new Error("disk");
+        },
+      }),
+    ).toBe(70);
+    const failure = testRuntime(["lookup", "missing"]);
+    expect(
+      await runCli({
+        ...failure.runtime,
+        write: async () => {
+          throw Object.assign(new Error("pipe"), { code: "EPIPE" });
+        },
+      }),
+    ).toBe(70);
+    const argv = ["node", identity.commandName];
+    Object.defineProperty(argv, "slice", {
+      value() {
+        throw new Error("内部细节");
+      },
+    });
+    expect(await runCli({ ...output.runtime, argv })).toBe(70);
+    expect(output.stderr()).toContain("命令执行失败");
+    expect(output.stderr()).not.toContain("内部细节");
   });
 });

package/node_modules/@ykdz/template-core/dist/dependency-catalog.d.ts

@@ -28,7 +28,6 @@ export declare function renderCargoLockForPackage(options: {
 }): string;
 export declare function selectTemplateCargoDependencyVersions(dependencies: readonly string[], catalog?: TemplateCargoDependencyVersions): TemplateCargoDependencyVersions;
 export declare function renderCargoDependencyTomlEntries(dependencies: readonly string[], catalog?: TemplateCargoDependencyVersions): string[];
-export declare function collectGeneratedManifestCatalogDependencies(manifests: readonly GeneratedPackageManifestDependencies[]): string[];
 export declare function collectGeneratedManifestCatalogReferences(manifests: readonly GeneratedPackageManifestDependencies[]): string[];
 export declare function pnpmWorkspaceYamlWithCatalogDependencies(workspaceYaml: string, dependencies: readonly string[], templateCatalog?: TemplateDependencyCatalog): string;
 export declare function renderGeneratedPnpmWorkspaceYaml(options: GeneratedDependencyCatalogOptions): string;

package/node_modules/@ykdz/template-core/dist/dependency-catalog.js

@@ -127,25 +127,6 @@ export function renderCargoDependencyTomlEntries(dependencies, catalog = loadTem
         return `${renderTomlKey(dependency)} = ${JSON.stringify(version)}`;
     });
 }
-export function collectGeneratedManifestCatalogDependencies(manifests) {
-    const dependencies = new Set();
-    for (const manifest of manifests) {
-        for (const dependencyMap of [
-            manifest.dependencies,
-            manifest.devDependencies,
-            manifest.optionalDependencies,
-            manifest.peerDependencies,
-        ]) {
-            for (const [dependency, specifier] of Object.entries(dependencyMap ?? {})) {
-                if (specifier !== "catalog:") {
-                    throw new Error(`Generated manifest dependency ${dependency} must use catalog:, got ${specifier}`);
-                }
-                dependencies.add(dependency);
-            }
-        }
-    }
-    return [...dependencies].toSorted();
-}
 export function collectGeneratedManifestCatalogReferences(manifests) {
     const dependencies = new Set();
     for (const manifest of manifests) {

package/node_modules/@ykdz/template-core/dist/pnpm-workspace.yaml

@@ -21,9 +21,11 @@ overrides:
   "vue>typescript": "-"
 
 catalog:
+  "@ykdz/cli-contract": 0.2.1
+  "@valibot/to-json-schema": ^1.8.0
   "@devcontainers/cli": 0.89.0
   "@hono/node-server": ^2.0.12
-  "@playwright/test": ^1.62.1
+  "@playwright/test": 1.64.0
   "@tailwindcss/vite": ^4.3.3
   "@types/node": ^24.13.3
   "@types/web-bluetooth": ^0.0.21
@@ -31,7 +33,6 @@ catalog:
   "@vikejs/hono": ^0.2.1
   "@vue/devtools-api": ^8.1.5
   "@vue/tsconfig": ^0.9.1
-  commander: ^15.0.0
   drizzle-kit: 1.0.0-rc.5-ab785fc
   drizzle-orm: 1.0.0-rc.5-ab785fc
   execa: ^10.0.1

package/node_modules/@ykdz/template-core/dist/project-blueprint.d.ts

@@ -1,3 +1,4 @@
+import * as v from "valibot";
 /**
  * The durable, preset-agnostic topology used by local template follow-up
  * operations. Preset provenance deliberately belongs in Generation Record.
@@ -40,6 +41,20 @@ export type BlueprintValidationResult = {
     readonly ok: false;
     readonly issues: readonly BlueprintValidationIssue[];
 };
+declare function packageDefinitionMessage(issue: v.BaseIssue<unknown>): string;
+export declare const projectBlueprintSchema: v.StrictObjectSchema<{
+    readonly schemaVersion: v.LiteralSchema<3, (issue: v.LiteralIssue) => string>;
+    readonly packages: v.ArraySchema<v.StrictObjectSchema<{
+        readonly name: v.StringSchema<"Package name must be a string">;
+        readonly path: v.StringSchema<"Package Path must be a string">;
+        readonly role: v.PicklistSchema<readonly ["cli-tool", "runtime-service", "shared-library", "native-package"], "Package Role must be cli-tool, runtime-service, shared-library, or native-package">;
+        readonly packageDefinitionId: v.StringSchema<"Package Definition ID must use the package-<sha256> format">;
+    }, typeof packageDefinitionMessage>, "Package Definitions must be an array">;
+    readonly packageLinkIntents: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+        readonly consumerPackagePath: v.StringSchema<"Package Link Intent consumer Package Path must be a string">;
+        readonly providerPackagePath: v.StringSchema<"Package Link Intent provider Package Path must be a string">;
+    }, (issue: v.StrictObjectIssue) => "Package Link Intent must be an object" | "Unknown Blueprint v3 field">, "Package Link Intents must be an array">, undefined>;
+}, (issue: v.StrictObjectIssue) => "Local Template Metadata must be an object" | "Unknown Blueprint v3 field">;
 /** Canonical npm package-name predicate shared by Blueprint and input preparation. */
 export declare function isValidNewNpmPackageName(value: string): boolean;
 export type NewPackagePathValidation = {

package/node_modules/@ykdz/template-core/dist/project-blueprint.js

@@ -42,7 +42,7 @@ const packageLinkIntentSchema = v.strictObject({
 }, (issue) => issue.path?.at(-1)?.origin === "key" && issue.input !== undefined
     ? unknownBlueprintField
     : "Package Link Intent must be an object");
-const projectBlueprintSchema = v.strictObject({
+export const projectBlueprintSchema = v.strictObject({
     schemaVersion: v.literal(3, (issue) => `Unsupported Local Template Metadata schema version ${String(issue.input)}; expected 3`),
     packages: v.array(packageDefinitionSchema, "Package Definitions must be an array"),
     packageLinkIntents: v.optional(v.array(packageLinkIntentSchema, "Package Link Intents must be an array")),

package/node_modules/@ykdz/template-core/dist/project-github.d.ts

@@ -1,52 +1,4 @@
-import { type CiDiagnosticArtifactDeclaration } from "./ci-diagnostic-artifact.ts";
 import type { DeploymentEnvironmentNeed } from "./module-graph.ts";
-export type CiCapability = {
-    readonly workflowName: "Check";
-    readonly jobName: "check";
-    readonly jobDisplayName: "Root Check";
-    readonly runner: "ubuntu-latest";
-    readonly timeoutMinutes: 30;
-};
-export type CiEnvironmentPreparation = {
-    readonly nodeFromPackageMetadata: boolean;
-    readonly packageManagerFromPackageMetadata: boolean;
-    readonly pnpmStoreCache: boolean;
-};
-export type PnpmTaskLayer = {
-    readonly installCommand: "pnpm install --frozen-lockfile";
-    readonly checkCommand: "pnpm run check";
-};
-export type CiCheckMatrixEntry = {
-    readonly capability: "root" | "deployment";
-    readonly jobDisplayName: "Root Check" | "Deployment Check";
-    readonly taskEntrypoint: "pnpm run check" | "pnpm run check:deployment";
-    readonly timeoutMinutes: 30 | 45;
-    readonly requiresDocker: boolean;
-};
-export type ProjectCheckWorkflowPlan = {
-    readonly workflowName: "Check";
-    readonly triggers: {
-        readonly pullRequest: true;
-        readonly pushBranches: readonly ["main"];
-    };
-    readonly permissions: {
-        readonly contents: "read";
-    };
-    readonly concurrency: {
-        readonly group: "${{ github.workflow }}-${{ github.ref }}";
-        readonly cancelInProgress: true;
-    };
-    readonly rootCheck: CiCapability;
-    readonly matrix: {
-        readonly failFast: false;
-        readonly include: readonly CiCheckMatrixEntry[];
-    } | undefined;
-    readonly environmentPreparation: CiEnvironmentPreparation;
-    readonly taskLayer: PnpmTaskLayer;
-    /** Actual Package Boundaries allowed to own retained native diagnostics. */
-    readonly packagePaths: readonly string[];
-    readonly diagnosticArtifacts: readonly CiDiagnosticArtifactDeclaration[];
-};
 export type DependencyEcosystem = "npm" | "cargo" | "github-actions" | "docker" | "devcontainers" | "rust-toolchain";
 export type DependabotDirectory = `/${string}`;
 export type DependencyMaintenancePolicy = {
@@ -60,16 +12,6 @@ export type ProjectCheckWorkflowDiagnosticOptions = {
     readonly packagePaths: readonly string[];
     readonly diagnosticArtifacts?: readonly unknown[] | undefined;
 };
-type ProjectCheckWorkflowOptions = ProjectCheckWorkflowDiagnosticOptions & {
-    readonly deploymentCheck?: {
-        readonly environmentNeeds: readonly DeploymentEnvironmentNeed[];
-    } | undefined;
-    readonly capability?: CiCapability | undefined;
-    readonly environmentPreparation?: Partial<CiEnvironmentPreparation> | undefined;
-    readonly taskLayer?: PnpmTaskLayer | undefined;
-};
-/** Capability facts for the Foundation-owned GitHub Actions Template Source. */
-export declare function projectCheckWorkflowPlan(options: ProjectCheckWorkflowOptions): ProjectCheckWorkflowPlan;
 /** Selects a complete Foundation-owned workflow Template Source. */
 export declare function projectCheckWorkflowTemplateSource(options: ProjectCheckWorkflowDiagnosticOptions & {
     readonly deploymentCheck?: {
@@ -81,4 +23,3 @@ export declare function projectCheckWorkflowTemplateReplacements(options: Projec
 export declare function projectDependabotConfig(policy: DependencyMaintenancePolicy): string;
 /** Limited substitution for the Foundation-owned Dependabot Template Source. */
 export declare function projectDependabotTemplateReplacements(policy: DependencyMaintenancePolicy): Record<string, string>;
-export {};

package/node_modules/@ykdz/template-core/dist/project-github.js

@@ -5,73 +5,6 @@ function validatedDiagnosticArtifacts(options) {
         declarations: options.artifacts,
     });
 }
-const defaultCiCapability = {
-    workflowName: "Check",
-    jobName: "check",
-    jobDisplayName: "Root Check",
-    runner: "ubuntu-latest",
-    timeoutMinutes: 30,
-};
-const pnpmTaskLayer = {
-    installCommand: "pnpm install --frozen-lockfile",
-    checkCommand: "pnpm run check",
-};
-/** Capability facts for the Foundation-owned GitHub Actions Template Source. */
-export function projectCheckWorkflowPlan(options) {
-    const capability = options.capability ?? defaultCiCapability;
-    const environmentPreparation = {
-        nodeFromPackageMetadata: true,
-        packageManagerFromPackageMetadata: true,
-        pnpmStoreCache: true,
-        ...options.environmentPreparation,
-    };
-    const taskLayer = options.taskLayer ?? pnpmTaskLayer;
-    const hasDeploymentTask = options.deploymentCheck !== undefined;
-    const needsDocker = (options.deploymentCheck?.environmentNeeds ?? []).some((need) => need.kind === "docker-engine");
-    if (hasDeploymentTask && !needsDocker) {
-        throw new Error("Deployment Check requires a Docker environment need");
-    }
-    const packagePaths = [...options.packagePaths];
-    const diagnosticArtifacts = validatedDiagnosticArtifacts({
-        packagePaths,
-        artifacts: options.diagnosticArtifacts ?? [],
-    });
-    return {
-        workflowName: capability.workflowName,
-        triggers: { pullRequest: true, pushBranches: ["main"] },
-        permissions: { contents: "read" },
-        concurrency: {
-            group: "${{ github.workflow }}-${{ github.ref }}",
-            cancelInProgress: true,
-        },
-        rootCheck: capability,
-        matrix: hasDeploymentTask
-            ? {
-                failFast: false,
-                include: [
-                    {
-                        capability: "root",
-                        jobDisplayName: capability.jobDisplayName,
-                        taskEntrypoint: taskLayer.checkCommand,
-                        timeoutMinutes: capability.timeoutMinutes,
-                        requiresDocker: false,
-                    },
-                    {
-                        capability: "deployment",
-                        jobDisplayName: "Deployment Check",
-                        taskEntrypoint: "pnpm run check:deployment",
-                        timeoutMinutes: 45,
-                        requiresDocker: true,
-                    },
-                ],
-            }
-            : undefined,
-        environmentPreparation,
-        taskLayer,
-        packagePaths,
-        diagnosticArtifacts,
-    };
-}
 /** Selects a complete Foundation-owned workflow Template Source. */
 export function projectCheckWorkflowTemplateSource(options) {
     const hasDeploymentTask = options.deploymentCheck !== undefined;

package/node_modules/undici-types/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Matteo Collina and Undici contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/undici-types/README.md

@@ -0,0 +1,6 @@
+# undici-types
+
+This package is a dual-publish of the [undici](https://www.npmjs.com/package/undici) library types. The `undici` package **still contains types**. This package is for users who _only_ need undici types (such as for `@types/node`). It is published alongside every release of `undici`, so you can always use the same version.
+
+- [GitHub nodejs/undici](https://github.com/nodejs/undici)
+- [Undici Documentation](https://undici.nodejs.org/#/)

package/node_modules/undici-types/agent.d.ts

@@ -0,0 +1,32 @@
+import { URL } from 'node:url'
+import Pool from './pool'
+import Dispatcher from './dispatcher'
+import TClientStats from './client-stats'
+import TPoolStats from './pool-stats'
+
+export default Agent
+
+declare class Agent extends Dispatcher {
+  constructor (opts?: Agent.Options)
+  /** `true` after `dispatcher.close()` has been called. */
+  closed: boolean
+  /** `true` after `dispatcher.destroyed()` has been called or `dispatcher.close()` has been called and the dispatcher shutdown has completed. */
+  destroyed: boolean
+  /** Dispatches a request. */
+  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean
+  /** Aggregate stats for a Agent by origin. */
+  readonly stats: Record<string, TClientStats | TPoolStats>
+}
+
+declare namespace Agent {
+  export interface Options extends Pool.Options {
+    /** Default: `(origin, opts) => new Pool(origin, opts)`. */
+    factory?(origin: string | URL, opts: Object): Dispatcher;
+
+    interceptors?: { Agent?: readonly Dispatcher.DispatchInterceptor[] } & Pool.Options['interceptors']
+    maxOrigins?: number
+  }
+
+  export interface DispatchOptions extends Dispatcher.DispatchOptions {
+  }
+}

package/node_modules/undici-types/api.d.ts

@@ -0,0 +1,43 @@
+import { URL, UrlObject } from 'node:url'
+import { Duplex } from 'node:stream'
+import Dispatcher from './dispatcher'
+
+/** Performs an HTTP request. */
+declare function request<TOpaque = null> (
+  url: string | URL | UrlObject,
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions<TOpaque>, 'origin' | 'path' | 'method'> & Partial<Pick<Dispatcher.RequestOptions, 'method'>>,
+): Promise<Dispatcher.ResponseData<TOpaque>>
+
+/** A faster version of `request`. */
+declare function stream<TOpaque = null> (
+  url: string | URL | UrlObject,
+  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.RequestOptions<TOpaque>, 'origin' | 'path'>,
+  factory: Dispatcher.StreamFactory<TOpaque>
+): Promise<Dispatcher.StreamData<TOpaque>>
+
+/** For easy use with `stream.pipeline`. */
+declare function pipeline<TOpaque = null> (
+  url: string | URL | UrlObject,
+  options: { dispatcher?: Dispatcher } & Omit<Dispatcher.PipelineOptions<TOpaque>, 'origin' | 'path'>,
+  handler: Dispatcher.PipelineHandler<TOpaque>
+): Duplex
+
+/** Starts two-way communications with the requested resource. */
+declare function connect<TOpaque = null> (
+  url: string | URL | UrlObject,
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.ConnectOptions<TOpaque>, 'origin' | 'path'>
+): Promise<Dispatcher.ConnectData<TOpaque>>
+
+/** Upgrade to a different protocol. */
+declare function upgrade (
+  url: string | URL | UrlObject,
+  options?: { dispatcher?: Dispatcher } & Omit<Dispatcher.UpgradeOptions, 'origin' | 'path'>
+): Promise<Dispatcher.UpgradeData>
+
+export {
+  request,
+  stream,
+  pipeline,
+  connect,
+  upgrade
+}

package/node_modules/undici-types/balanced-pool.d.ts

@@ -0,0 +1,30 @@
+import Pool from './pool'
+import Dispatcher from './dispatcher'
+import { URL } from 'node:url'
+
+export default BalancedPool
+
+type BalancedPoolConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
+
+declare class BalancedPool extends Dispatcher {
+  constructor (url: string | string[] | URL | URL[], options?: Pool.Options)
+
+  addUpstream (upstream: string | URL): BalancedPool
+  removeUpstream (upstream: string | URL): BalancedPool
+  getUpstream (upstream: string | URL): Pool | undefined
+  upstreams: Array<string>
+
+  /** `true` after `pool.close()` has been called. */
+  closed: boolean
+  /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
+  destroyed: boolean
+
+  // Override dispatcher APIs.
+  override connect (
+    options: BalancedPoolConnectOptions
+  ): Promise<Dispatcher.ConnectData>
+  override connect (
+    options: BalancedPoolConnectOptions,
+    callback: (err: Error | null, data: Dispatcher.ConnectData) => void
+  ): void
+}