genoc 0.2.0 → 0.4.0

package/dist/utils/generator-helpers.d.ts

@@ -1,23 +1,33 @@
-import type { AnalyzedOperation } from '../analyzer/path-analyzer.js';
 import type { SchemaObject } from '../types/openapi.js';
-/**
- * Reserved type names used by the generated output's built-in classes,
- * functions, and types. User-defined schema names that collide with these
- * are automatically renamed with a suffix to prevent duplicate identifiers.
- */
-export declare const RESERVED_TYPE_NAMES: ReadonlySet<string>;
 /** Default module specifier generated code imports shared runtime classes from. */
 export declare const DEFAULT_RUNTIME_IMPORT_PATH = "genoc/runtime";
 /**
- * Sanitize a schema type name by converting dot-separated segments into
- * PascalCase. Names without dots pass through unchanged.
+ * Sanitize a schema type name into a valid TypeScript identifier.
+ *
+ * Any run of non-identifier characters (dots, brackets, backticks, hyphens,
+ * spaces, slashes, ...) splits the name into segments that are re-joined in
+ * PascalCase:
  *
- * "Api.Error" → "ApiError", "Simple" → "Simple"
+ *   "Api.Error"  → "ApiError"
+ *   "User[Dto]"  → "UserDto"
+ *   "my-schema"  → "MySchema"
+ *   "payment id" → "PaymentId"
+ *
+ * Names that are already valid identifiers pass through unchanged
+ * ("User", "my_schema", "mySchema", "$Foo", "Данные"). Results that would
+ * start with a digit ("2FA") get an "_" prefix, as do exact reserved words
+ * ("class" → "_class"). Names with no usable characters collapse to "_".
  */
 export declare function sanitizeTypeName(name: string): string;
 /**
- * Build a mapping of sanitized schema names → renamed names for any that
- * collide with reserved type names.
+ * Build a mapping of raw schema names → renamed names for any whose
+ * sanitized name collides with a reserved type name or with another
+ * schema's sanitized name (e.g. "User-Dto" and "User[Dto]" both → "UserDto").
+ *
+ * The map is keyed by the raw schema name (component keys are unique by
+ * construction), so callers resolve raw $ref segments / schema keys first
+ * and fall back to sanitizeTypeName for the common no-collision case.
+ * Numbered suffixes are used when the first renamed candidate also collides.
  */
 export declare function buildSchemaRenameMap(schemaNames: Iterable<string>, reserved: ReadonlySet<string>, suffix?: string): Map<string, string>;
 /**
@@ -25,19 +35,6 @@ export declare function buildSchemaRenameMap(schemaNames: Iterable<string>, rese
  * and colon-separated segments.
  */
 export declare function toPascalCase(str: string): string;
-/**
- * Build a PascalCase type-name prefix from an operation's method + path.
- * get + /api/v1/products → "GetApiV1Products"
- */
-export declare function getOperationTypePrefix(op: AnalyzedOperation): string;
-/**
- * Determine the success return type for an operation.
- */
-export declare function getSuccessType(op: AnalyzedOperation): string;
-/**
- * Determine the error type name for an operation.
- */
-export declare function getErrorType(op: AnalyzedOperation): string;
 /**
  * Generate the auto-generated header comment.
  */
@@ -73,3 +70,4 @@ export declare function buildFieldJsDocLines(schema: SchemaObject): string[];
  * ≥2 segments → multiline block with a blank ` *` line between segments.
  */
 export declare function buildTypeJsDoc(schema: SchemaObject): string;
+export declare function isBinaryContentType(ct: string): boolean;

package/dist/utils/generator-helpers.js

@@ -1,51 +1,156 @@
 /**
- * Reserved type names used by the generated output's built-in classes,
- * functions, and types. User-defined schema names that collide with these
- * are automatically renamed with a suffix to prevent duplicate identifiers.
+ * TypeScript/JavaScript reserved words, matched case-sensitively: a type
+ * named "Null" or "Class" is legal, only the exact lowercase keywords are.
  */
-export const RESERVED_TYPE_NAMES = new Set([
-    // Classes in contracts.ts
-    'StreamResponse',
-    'ErrorResponse',
-    'ApiError',
-    'UnspecifiedApiError',
-    'DefaultApiError',
-    'RequesterFailError',
-    // Types / functions in client.ts
-    'Requester',
-    'isDefinedError',
-    'decorateWithErrors',
-    'ApiClient',
-    // Interface in contracts.ts (when file uploads present)
-    'FileInput',
+const RESERVED_WORDS = new Set([
+    'abstract',
+    'any',
+    'as',
+    'asserts',
+    'assert',
+    'async',
+    'await',
+    'boolean',
+    'break',
+    'case',
+    'catch',
+    'class',
+    'continue',
+    'const',
+    'constructor',
+    'debugger',
+    'declare',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'from',
+    'function',
+    'get',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'infer',
+    'instanceof',
+    'interface',
+    'is',
+    'keyof',
+    'let',
+    'module',
+    'namespace',
+    'never',
+    'new',
+    'null',
+    'number',
+    'object',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'readonly',
+    'require',
+    'return',
+    'satisfies',
+    'set',
+    'static',
+    'string',
+    'super',
+    'switch',
+    'symbol',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'type',
+    'typeof',
+    'undefined',
+    'unique',
+    'unknown',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield',
 ]);
+function isReservedTypeName(name) {
+    return RESERVED_WORDS.has(name);
+}
 /** Default module specifier generated code imports shared runtime classes from. */
 export const DEFAULT_RUNTIME_IMPORT_PATH = 'genoc/runtime';
 /**
- * Sanitize a schema type name by converting dot-separated segments into
- * PascalCase. Names without dots pass through unchanged.
+ * Sanitize a schema type name into a valid TypeScript identifier.
+ *
+ * Any run of non-identifier characters (dots, brackets, backticks, hyphens,
+ * spaces, slashes, ...) splits the name into segments that are re-joined in
+ * PascalCase:
+ *
+ *   "Api.Error"  → "ApiError"
+ *   "User[Dto]"  → "UserDto"
+ *   "my-schema"  → "MySchema"
+ *   "payment id" → "PaymentId"
  *
- * "Api.Error" → "ApiError", "Simple" → "Simple"
+ * Names that are already valid identifiers pass through unchanged
+ * ("User", "my_schema", "mySchema", "$Foo", "Данные"). Results that would
+ * start with a digit ("2FA") get an "_" prefix, as do exact reserved words
+ * ("class" → "_class"). Names with no usable characters collapse to "_".
  */
 export function sanitizeTypeName(name) {
-    if (!name.includes('.'))
+    if (!name)
+        return '_';
+    // Exact reserved words keep their casing and get an "_" prefix
+    // ("class" → "_class"), while "Null" / "Class" are legal and pass through.
+    if (isReservedTypeName(name))
+        return `_${name}`;
+    const isValidIdentifier = /^[\p{ID_Start}$_][\p{ID_Continue}$]*$/u.test(name);
+    if (isValidIdentifier)
         return name;
-    return name
-        .split('.')
+    const segments = name.match(/[\p{ID_Continue}$]+/gu) ?? [];
+    const result = segments
         .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
         .join('');
+    // Covers empty results, ASCII digits, and non-ASCII digits (Nd but not
+    // ID_Start, e.g. Arabic-Indic) alike: anything not starting with a valid
+    // identifier start character gets the "_" prefix.
+    if (!/^[\p{ID_Start}$_]/u.test(result))
+        return `_${result}`;
+    if (isReservedTypeName(result))
+        return `_${result}`;
+    return result;
 }
 /**
- * Build a mapping of sanitized schema names → renamed names for any that
- * collide with reserved type names.
+ * Build a mapping of raw schema names → renamed names for any whose
+ * sanitized name collides with a reserved type name or with another
+ * schema's sanitized name (e.g. "User-Dto" and "User[Dto]" both → "UserDto").
+ *
+ * The map is keyed by the raw schema name (component keys are unique by
+ * construction), so callers resolve raw $ref segments / schema keys first
+ * and fall back to sanitizeTypeName for the common no-collision case.
+ * Numbered suffixes are used when the first renamed candidate also collides.
  */
 export function buildSchemaRenameMap(schemaNames, reserved, suffix = 'Model') {
     const renameMap = new Map();
+    const used = new Set(reserved);
     for (const name of schemaNames) {
         const sanitized = sanitizeTypeName(name);
-        if (reserved.has(sanitized)) {
-            renameMap.set(sanitized, `${sanitized}${suffix}`);
+        if (!used.has(sanitized)) {
+            used.add(sanitized);
+            continue;
+        }
+        let candidate = `${sanitized}${suffix}`;
+        let counter = 2;
+        while (used.has(candidate)) {
+            candidate = `${sanitized}${suffix}${counter}`;
+            counter += 1;
         }
+        used.add(candidate);
+        renameMap.set(name, candidate);
     }
     return renameMap;
 }
@@ -61,54 +166,6 @@ export function toPascalCase(str) {
         .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
         .join('');
 }
-/**
- * Build a PascalCase type-name prefix from an operation's method + path.
- * get + /api/v1/products → "GetApiV1Products"
- */
-export function getOperationTypePrefix(op) {
-    const methodPascal = op.method.charAt(0).toUpperCase() + op.method.slice(1).toLowerCase();
-    const segments = op.path
-        .split('/')
-        .filter((s) => s.length > 0)
-        .map((s) => {
-        const cleaned = s.replace(/[{}]/g, '');
-        return toPascalCase(cleaned);
-    });
-    return methodPascal + segments.join('');
-}
-/**
- * Determine the success return type for an operation.
- */
-export function getSuccessType(op) {
-    const successResponses = op.responses.filter((r) => r.isSuccess);
-    if (successResponses.length === 0) {
-        return 'unknown';
-    }
-    const noContent = successResponses.find((r) => r.tsType === 'void');
-    const hasOnlyNoContent = noContent && successResponses.every((r) => r.tsType === 'void');
-    if (hasOnlyNoContent) {
-        return 'void';
-    }
-    const withSchema = successResponses.filter((r) => r.tsType !== 'void');
-    if (withSchema.length === 0) {
-        return 'void';
-    }
-    const prefix = getOperationTypePrefix(op);
-    const types = withSchema.map(() => `${prefix}Response`);
-    const unique = [...new Set(types)];
-    return unique.join(' | ');
-}
-/**
- * Determine the error type name for an operation.
- */
-export function getErrorType(op) {
-    const prefix = getOperationTypePrefix(op);
-    const errorResponses = op.responses.filter((r) => !r.isSuccess && r.statusCode !== 'default');
-    if (errorResponses.length === 0) {
-        return 'never';
-    }
-    return `${prefix}Errors`;
-}
 /**
  * Generate the auto-generated header comment.
  */
@@ -190,3 +247,14 @@ export function buildTypeJsDoc(schema) {
         return `/** ${lines[0]} */`;
     return `/**\n${lines.map((line) => ` * ${line}`).join('\n *\n')}\n */`;
 }
+export function isBinaryContentType(ct) {
+    if (ct === 'application/octet-stream')
+        return true;
+    if (ct.startsWith('image/'))
+        return true;
+    if (ct.startsWith('video/'))
+        return true;
+    if (ct.startsWith('audio/'))
+        return true;
+    return false;
+}

package/dist/utils/operation-naming.d.ts

@@ -0,0 +1,84 @@
+import type { AnalyzedOperation } from '../analyzer/path-analyzer.js';
+/**
+ * Canonical runtime class list in the contracts re-export order. Membership
+ * source of truth for every runtime class name the generators emit.
+ */
+export declare const RUNTIME_CLASS_NAMES: readonly ["ApiError", "UnspecifiedApiError", "DefaultApiError", "RequesterFailError", "StreamResponse", "ErrorResponse"];
+/**
+ * client.ts value imports from contracts.js in site emission order.
+ * `DefaultApiError` is conditional (only when an operation has a default
+ * error response), so it is appended by the client generator, not listed here.
+ */
+export declare const CLIENT_BASE_VALUE_IMPORTS: readonly ["ApiError", "UnspecifiedApiError", "ErrorResponse", "StreamResponse", "RequesterFailError"];
+/** Fixed client-file surface names (values and types client.ts declares). */
+export declare const CLIENT_SURFACE_NAMES: readonly ["Requester", "isDefinedError", "decorateWithErrors", "ApiClient", "createClient"];
+/**
+ * Reserved type names used by the generated output's built-in classes,
+ * functions, and types. User-defined schema names that collide with these
+ * are automatically renamed with a suffix to prevent duplicate identifiers.
+ *
+ * Derived — never hand-edited: add new fixed names to the owning constant
+ * (`RUNTIME_CLASS_NAMES` / `CLIENT_SURFACE_NAMES`) or, for contracts-only
+ * interfaces like `FileInput`, extend the derivation below.
+ */
+export declare const RESERVED_TYPE_NAMES: ReadonlySet<string>;
+/**
+ * Build a PascalCase type-name prefix from an operation's method + path.
+ * get + /api/v1/products → "GetApiV1Products"
+ *
+ * Returns the deduped prefix assigned by analyzePaths when available
+ * (distinct routes folding to the same identifier get numbered suffixes),
+ * otherwise computes it from the operation directly.
+ */
+export declare function getOperationTypePrefix(op: AnalyzedOperation): string;
+/**
+ * Determine the success return type for an operation.
+ */
+export declare function getSuccessType(op: AnalyzedOperation): string;
+/**
+ * Determine the error type name for an operation.
+ */
+export declare function getErrorType(op: AnalyzedOperation): string;
+/** Name of one per-status error type (`{prefix}Error{status}`). */
+export interface StatusErrorName {
+    status: string;
+    name: string;
+}
+/**
+ * Inventory of every operation-derived type name the contracts file emits
+ * for one operation. A field is present exactly when the contracts loop
+ * emits that type — presence and naming are decided here and nowhere else.
+ *
+ * The client file imports a subset of this inventory (`clientImportedNames`);
+ * the asymmetry is deliberate: e.g. 204-only operations emit
+ * `{prefix}Response = void` which the client does not import.
+ */
+export interface OperationEmissions {
+    query?: string;
+    headers?: string;
+    body?: string;
+    response?: string;
+    statusErrors: StatusErrorName[];
+    defaultError?: string;
+    errorsUnion?: string;
+}
+/**
+ * Derive the emission inventory for an operation. Pure function of the
+ * AnalyzedOperation — no mapper or resolver state participates in naming
+ * or presence decisions.
+ */
+export declare function operationEmissions(op: AnalyzedOperation): OperationEmissions;
+/**
+ * Type names the client file imports from contracts for one operation.
+ *
+ * Deliberately a subset of the emission inventory: the client names the
+ * response type only when the success type is a named type — 204-only
+ * operations emit `{prefix}Response = void` in contracts, but the client
+ * method returns `void` without ever naming the type.
+ */
+export declare function clientImportedNames(op: AnalyzedOperation): string[];
+/**
+ * Value imports for the client file: the fixed base list plus
+ * `DefaultApiError` when any operation has a default error response.
+ */
+export declare function clientValueImports(operations: AnalyzedOperation[]): string[];

package/dist/utils/operation-naming.js

@@ -0,0 +1,178 @@
+import { sanitizeTypeName, toPascalCase } from './generator-helpers.js';
+/**
+ * Canonical runtime class list in the contracts re-export order. Membership
+ * source of truth for every runtime class name the generators emit.
+ */
+export const RUNTIME_CLASS_NAMES = [
+    'ApiError',
+    'UnspecifiedApiError',
+    'DefaultApiError',
+    'RequesterFailError',
+    'StreamResponse',
+    'ErrorResponse',
+];
+/**
+ * client.ts value imports from contracts.js in site emission order.
+ * `DefaultApiError` is conditional (only when an operation has a default
+ * error response), so it is appended by the client generator, not listed here.
+ */
+export const CLIENT_BASE_VALUE_IMPORTS = [
+    'ApiError',
+    'UnspecifiedApiError',
+    'ErrorResponse',
+    'StreamResponse',
+    'RequesterFailError',
+];
+/** Fixed client-file surface names (values and types client.ts declares). */
+export const CLIENT_SURFACE_NAMES = [
+    'Requester',
+    'isDefinedError',
+    'decorateWithErrors',
+    'ApiClient',
+    'createClient',
+];
+/**
+ * Reserved type names used by the generated output's built-in classes,
+ * functions, and types. User-defined schema names that collide with these
+ * are automatically renamed with a suffix to prevent duplicate identifiers.
+ *
+ * Derived — never hand-edited: add new fixed names to the owning constant
+ * (`RUNTIME_CLASS_NAMES` / `CLIENT_SURFACE_NAMES`) or, for contracts-only
+ * interfaces like `FileInput`, extend the derivation below.
+ */
+export const RESERVED_TYPE_NAMES = new Set([
+    ...RUNTIME_CLASS_NAMES,
+    ...CLIENT_SURFACE_NAMES,
+    'FileInput',
+]);
+/**
+ * Build a PascalCase type-name prefix from an operation's method + path.
+ * get + /api/v1/products → "GetApiV1Products"
+ *
+ * Returns the deduped prefix assigned by analyzePaths when available
+ * (distinct routes folding to the same identifier get numbered suffixes),
+ * otherwise computes it from the operation directly.
+ */
+export function getOperationTypePrefix(op) {
+    if (op.typePrefix)
+        return op.typePrefix;
+    return computeOperationTypePrefix(op);
+}
+function computeOperationTypePrefix(op) {
+    const methodPascal = op.method.charAt(0).toUpperCase() + op.method.slice(1).toLowerCase();
+    const segments = op.path
+        .split('/')
+        .filter((s) => s.length > 0)
+        .map((s) => {
+        const cleaned = s.replace(/[{}]/g, '');
+        return sanitizeTypeName(toPascalCase(cleaned));
+    });
+    return methodPascal + segments.join('');
+}
+/**
+ * Classify a response as void by its finished type text. The finished type
+ * is `'void'` exactly for schema-less, non-binary 2xx responses — the same
+ * condition the analyzer records as `isVoid`.
+ */
+function isVoidResponse(r) {
+    return r.finishedType === 'void';
+}
+/**
+ * Determine the success return type for an operation.
+ */
+export function getSuccessType(op) {
+    const successResponses = op.responses.filter((r) => r.isSuccess);
+    if (successResponses.length === 0) {
+        return 'unknown';
+    }
+    const noContent = successResponses.find((r) => isVoidResponse(r));
+    const hasOnlyNoContent = noContent && successResponses.every((r) => isVoidResponse(r));
+    if (hasOnlyNoContent) {
+        return 'void';
+    }
+    const withSchema = successResponses.filter((r) => !isVoidResponse(r));
+    if (withSchema.length === 0) {
+        return 'void';
+    }
+    const prefix = getOperationTypePrefix(op);
+    const types = withSchema.map(() => `${prefix}Response`);
+    const unique = [...new Set(types)];
+    return unique.join(' | ');
+}
+/**
+ * Determine the error type name for an operation.
+ */
+export function getErrorType(op) {
+    const prefix = getOperationTypePrefix(op);
+    const errorResponses = op.responses.filter((r) => !r.isSuccess && r.statusCode !== 'default');
+    if (errorResponses.length === 0) {
+        return 'never';
+    }
+    return `${prefix}Errors`;
+}
+/**
+ * Derive the emission inventory for an operation. Pure function of the
+ * AnalyzedOperation — no mapper or resolver state participates in naming
+ * or presence decisions.
+ */
+export function operationEmissions(op) {
+    const prefix = getOperationTypePrefix(op);
+    const errorResponses = op.responses.filter((r) => !r.isSuccess && r.statusCode !== 'default');
+    const statusErrors = errorResponses.map((r) => ({
+        status: r.statusCode,
+        name: `${prefix}Error${r.statusCode}`,
+    }));
+    return {
+        query: op.queryParams.length > 0 ? `${prefix}Query` : undefined,
+        headers: op.headerParams.length > 0 ? `${prefix}Headers` : undefined,
+        body: op.requestBody?.hasSchema ? `${prefix}Body` : undefined,
+        response: op.responses.some((r) => r.isSuccess) ? `${prefix}Response` : undefined,
+        statusErrors,
+        defaultError: op.responses.some((r) => !r.isSuccess && r.statusCode === 'default')
+            ? `${prefix}DefaultError`
+            : undefined,
+        errorsUnion: statusErrors.length > 0 ? `${prefix}Errors` : undefined,
+    };
+}
+/**
+ * Type names the client file imports from contracts for one operation.
+ *
+ * Deliberately a subset of the emission inventory: the client names the
+ * response type only when the success type is a named type — 204-only
+ * operations emit `{prefix}Response = void` in contracts, but the client
+ * method returns `void` without ever naming the type.
+ */
+export function clientImportedNames(op) {
+    const emissions = operationEmissions(op);
+    const names = [];
+    if (emissions.query !== undefined)
+        names.push(emissions.query);
+    if (emissions.headers !== undefined)
+        names.push(emissions.headers);
+    if (emissions.body !== undefined)
+        names.push(emissions.body);
+    if (emissions.response !== undefined) {
+        const successType = getSuccessType(op);
+        if (successType !== 'void' && successType !== 'unknown' && /^[A-Z]/.test(successType)) {
+            names.push(successType);
+        }
+    }
+    for (const statusError of emissions.statusErrors) {
+        names.push(statusError.name);
+    }
+    if (emissions.errorsUnion !== undefined)
+        names.push(emissions.errorsUnion);
+    if (emissions.defaultError !== undefined)
+        names.push(emissions.defaultError);
+    return names;
+}
+/**
+ * Value imports for the client file: the fixed base list plus
+ * `DefaultApiError` when any operation has a default error response.
+ */
+export function clientValueImports(operations) {
+    const needsDefaultApiError = operations.some((op) => operationEmissions(op).defaultError !== undefined);
+    return needsDefaultApiError
+        ? [...CLIENT_BASE_VALUE_IMPORTS, 'DefaultApiError']
+        : [...CLIENT_BASE_VALUE_IMPORTS];
+}

package/dist/utils/proxy.d.ts

@@ -0,0 +1,6 @@
+export type LoadOptions = {
+    proxy?: string;
+};
+export declare function assertValidProxyUrl(url: string): void;
+export declare function hasProxyEnv(): boolean;
+export declare function fetchSpec(url: string, opts?: LoadOptions): Promise<Response>;

package/dist/utils/proxy.js

@@ -0,0 +1,81 @@
+const SUPPORTED_PROXY_PROTOCOLS = new Set(['http:', 'https:']);
+/** Security: never echo credentials — user:pass@ becomes ***@ in any echoed value. */
+function redactCredentials(proxyUrl) {
+    try {
+        const url = new URL(proxyUrl);
+        if (url.username || url.password) {
+            url.username = '***';
+            url.password = '';
+        }
+        return url.toString();
+    }
+    catch {
+        return proxyUrl;
+    }
+}
+const MAX_CAUSE_DEPTH = 5;
+/**
+ * undici's fetch() nests the meaningful error up to 3 levels deep via `cause`
+ * (e.g. "fetch failed" → "Request was cancelled." → "Proxy response (502) !== 200...").
+ * Flatten the chain so the deepest message (proxy status, ECONNREFUSED, ...) is user-visible.
+ */
+function describeFetchError(err) {
+    const messages = [];
+    let current = err;
+    for (let depth = 0; depth <= MAX_CAUSE_DEPTH && current instanceof Error; depth++) {
+        if (!messages.includes(current.message)) {
+            messages.push(current.message);
+        }
+        current = current.cause;
+    }
+    return messages.join(': ');
+}
+export function assertValidProxyUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new Error(`Invalid proxy URL "${redactCredentials(url)}": only http:// and https:// proxies are supported`);
+    }
+    if (!SUPPORTED_PROXY_PROTOCOLS.has(parsed.protocol)) {
+        throw new Error(`Invalid proxy URL "${redactCredentials(url)}": only http:// and https:// proxies are supported (got scheme "${parsed.protocol.replace(/:$/, '')}:")`);
+    }
+}
+export function hasProxyEnv() {
+    return Boolean(process.env.HTTP_PROXY ||
+        process.env.http_proxy ||
+        process.env.HTTPS_PROXY ||
+        process.env.https_proxy);
+}
+export async function fetchSpec(url, opts) {
+    if (opts?.proxy) {
+        assertValidProxyUrl(opts.proxy);
+        const redacted = redactCredentials(opts.proxy);
+        try {
+            const { fetch: undiciFetch, ProxyAgent } = await import('undici');
+            return (await undiciFetch(url, {
+                dispatcher: new ProxyAgent(opts.proxy),
+            }));
+        }
+        catch (err) {
+            throw new Error(`Failed to fetch spec from URL via proxy ${redacted}: ${describeFetchError(err)}`, {
+                cause: err,
+            });
+        }
+    }
+    if (hasProxyEnv()) {
+        try {
+            const { fetch: undiciFetch, EnvHttpProxyAgent } = await import('undici');
+            return (await undiciFetch(url, {
+                dispatcher: new EnvHttpProxyAgent(),
+            }));
+        }
+        catch (err) {
+            throw new Error(`Failed to fetch spec from URL via proxy env: ${describeFetchError(err)}`, {
+                cause: err,
+            });
+        }
+    }
+    return fetch(url);
+}