@velajs/vela 1.19.0 → 1.19.1

package/dist/openapi/document.js

@@ -1,316 +0,0 @@
-import { ParamType } from "../constants.js";
-import { getRouteContributors } from "../http/route-contributor.js";
-import { getMetadata } from "../metadata.js";
-import { collectControllers } from "../module/graph.js";
-import { MetadataRegistry } from "../registry/metadata.registry.js";
-import { joinPaths, toOpenApiPath } from "../registry/paths.js";
-import { getApiDoc, getApiResponses, getApiTags } from "./decorators.js";
-import { isOptional, zodToJsonSchema } from "./zod-to-json-schema.js";
-/**
- * Tracks DTO classes referenced during document generation and registers
- * each under `components.schemas`. Handles name collisions by suffixing.
- */ let ComponentsRegistry = class ComponentsRegistry {
-    schemas = new Map();
-    classToKey = new WeakMap();
-    ref(dtoClass) {
-        const existing = this.classToKey.get(dtoClass);
-        if (existing) return {
-            $ref: `#/components/schemas/${existing}`
-        };
-        const baseName = dtoClass.name && dtoClass.name !== '' ? dtoClass.name : 'Schema';
-        let key = baseName;
-        let counter = 2;
-        while(this.schemas.has(key)){
-            key = `${baseName}${counter++}`;
-        }
-        this.classToKey.set(dtoClass, key);
-        const staticSchema = dtoClass.schema;
-        this.schemas.set(key, zodToJsonSchema(staticSchema));
-        return {
-            $ref: `#/components/schemas/${key}`
-        };
-    }
-    build() {
-        if (this.schemas.size === 0) return undefined;
-        return Object.fromEntries(this.schemas);
-    }
-};
-function isDtoClass(value) {
-    return typeof value === 'function' && value.schema != null;
-}
-function getParamSchema(param, paramtypes, registry) {
-    const metatype = param.metatype ?? paramtypes?.[param.index];
-    if (!metatype) return undefined;
-    if (isDtoClass(metatype)) {
-        return registry.ref(metatype);
-    }
-    const maybeSchema = metatype.schema;
-    if (maybeSchema) {
-        return zodToJsonSchema(maybeSchema);
-    }
-    return undefined;
-}
-function isParamOptional(param, paramtypes) {
-    const metatype = param.metatype ?? paramtypes?.[param.index];
-    if (metatype?.schema) {
-        return isOptional(metatype.schema);
-    }
-    return true;
-}
-function isLikelyJsonSchema(value) {
-    if (!value || typeof value !== 'object') return false;
-    const v = value;
-    if (typeof v.toJSONSchema === 'function') return false;
-    return 'type' in v || '$ref' in v || 'oneOf' in v || 'anyOf' in v || 'allOf' in v || 'enum' in v || 'const' in v;
-}
-function resolveResponseSchema(input, registry) {
-    if (input === undefined || input === null) return undefined;
-    if (isDtoClass(input)) {
-        return registry.ref(input);
-    }
-    if (isLikelyJsonSchema(input)) {
-        return {
-            ...input
-        };
-    }
-    if (typeof input === 'object' && typeof input.toJSONSchema === 'function') {
-        return zodToJsonSchema(input);
-    }
-    return undefined;
-}
-function buildOperation(controller, route, pathString, registry) {
-    const handlerName = route.handlerName;
-    const paramMetadata = MetadataRegistry.getParameters(controller).get(handlerName) ?? [];
-    const paramtypes = Reflect.getMetadata('design:paramtypes', controller.prototype, handlerName);
-    const parameters = [];
-    let requestBody;
-    const declaredPathParams = new Set();
-    const pathParamNames = [
-        ...pathString.matchAll(/\{([^}]+)\}/g)
-    ].map((m)=>m[1]);
-    for (const param of paramMetadata){
-        if (param.type === ParamType.PARAM && param.name) {
-            declaredPathParams.add(param.name);
-            parameters.push({
-                name: param.name,
-                in: 'path',
-                required: true,
-                schema: getParamSchema(param, paramtypes, registry) ?? {
-                    type: 'string'
-                }
-            });
-        } else if (param.type === ParamType.QUERY && param.name) {
-            parameters.push({
-                name: param.name,
-                in: 'query',
-                required: !isParamOptional(param, paramtypes),
-                schema: getParamSchema(param, paramtypes, registry) ?? {
-                    type: 'string'
-                }
-            });
-        } else if (param.type === ParamType.HEADERS && param.name) {
-            parameters.push({
-                name: param.name,
-                in: 'header',
-                required: !isParamOptional(param, paramtypes),
-                schema: getParamSchema(param, paramtypes, registry) ?? {
-                    type: 'string'
-                }
-            });
-        } else if (param.type === ParamType.BODY) {
-            const schema = getParamSchema(param, paramtypes, registry);
-            if (schema) {
-                requestBody = {
-                    required: !isParamOptional(param, paramtypes),
-                    content: {
-                        'application/json': {
-                            schema
-                        }
-                    }
-                };
-            }
-        }
-    }
-    for (const name of pathParamNames){
-        if (!declaredPathParams.has(name)) {
-            parameters.push({
-                name,
-                in: 'path',
-                required: true,
-                schema: {
-                    type: 'string'
-                }
-            });
-        }
-    }
-    const docMeta = getApiDoc(controller, handlerName);
-    const controllerTags = getApiTags(controller) ?? [];
-    const handlerTags = getApiTags(controller, handlerName) ?? [];
-    const docTags = docMeta?.tags ?? [];
-    const mergedTags = [
-        ...new Set([
-            ...controllerTags,
-            ...handlerTags,
-            ...docTags
-        ])
-    ];
-    const responses = {
-        '200': {
-            description: 'OK'
-        }
-    };
-    const apiResponses = getApiResponses(controller, handlerName) ?? [];
-    for (const entry of apiResponses){
-        const key = String(entry.status);
-        const resolved = {
-            description: entry.description
-        };
-        const schema = resolveResponseSchema(entry.schema, registry);
-        if (schema) {
-            resolved.content = {
-                'application/json': {
-                    schema
-                }
-            };
-        }
-        responses[key] = resolved;
-    }
-    const operation = {
-        responses
-    };
-    if (parameters.length > 0) operation.parameters = parameters;
-    if (requestBody) operation.requestBody = requestBody;
-    if (docMeta?.summary) operation.summary = docMeta.summary;
-    if (docMeta?.description) operation.description = docMeta.description;
-    const operationId = docMeta?.operationId ?? route.name;
-    if (operationId) operation.operationId = operationId;
-    if (docMeta?.deprecated) operation.deprecated = docMeta.deprecated;
-    if (mergedTags.length > 0) operation.tags = mergedTags;
-    return operation;
-}
-const VERB_WHITELIST = new Set([
-    'get',
-    'post',
-    'put',
-    'patch',
-    'delete',
-    'options',
-    'head'
-]);
-export function createOpenApiDocument(rootModule, options = {}) {
-    const paths = {};
-    const globalPrefix = options.globalPrefix ?? '';
-    const registry = new ComponentsRegistry();
-    const controllers = collectControllers(rootModule);
-    for (const controller of controllers){
-        const controllerPath = MetadataRegistry.getControllerPath(controller);
-        const routes = MetadataRegistry.getRoutes(controller);
-        for (const route of routes){
-            const method = route.method.toLowerCase();
-            if (!VERB_WHITELIST.has(method)) continue;
-            const rawPath = joinPaths(joinPaths(globalPrefix, controllerPath), route.path);
-            const pathString = toOpenApiPath(rawPath);
-            const operation = buildOperation(controller, route, pathString, registry);
-            const pathItem = paths[pathString] ?? {};
-            pathItem[method] = operation;
-            paths[pathString] = pathItem;
-        }
-    }
-    // Second pass: include contributor-generated routes (e.g. `@Crud()` via
-    // `@velajs/crud`'s registered RouteContributor). Silent when no contributor
-    // is registered or no controller carries claiming metadata, so consumers
-    // without contributor packages see no behavioral change.
-    for (const contributor of getRouteContributors()){
-        if (!contributor.buildOpenApiPaths) continue;
-        for (const controller of controllers){
-            const meta = getMetadata(contributor.claimsMetaKey, controller);
-            if (meta === undefined) continue;
-            const controllerPrefix = MetadataRegistry.getControllerPath(controller);
-            const contributedPaths = contributor.buildOpenApiPaths({
-                controller: controller,
-                meta,
-                globalPrefix,
-                controllerPrefix
-            });
-            for (const [pathKey, pathItem] of Object.entries(contributedPaths)){
-                // Verb-level merge: a hand-written `@Get('/')` on the same controller
-                // is preserved when the contributor adds `post`/`patch`/etc. on the
-                // same path key.
-                paths[pathKey] = {
-                    ...paths[pathKey] ?? {},
-                    ...pathItem
-                };
-            }
-        }
-    }
-    // Aggregate the document-root `tags` array. NestJS declares tag
-    // groups/descriptions/order via `DocumentBuilder().addTag(name, desc)`
-    // while its scanner auto-collects operation tags; we wire both halves
-    // here. Walk every operation's `tags` in first-seen order (stable: paths
-    // insertion order, then verb order), then merge with `options.tags`
-    // (caller-declared tags first — preserving their order + descriptions —
-    // followed by any purely-collected tag not already declared, as `{ name }`).
-    const seenTagNames = new Set();
-    const collectedTagNames = [];
-    for (const pathItem of Object.values(paths)){
-        for (const verb of VERB_WHITELIST){
-            const operation = pathItem[verb];
-            if (!operation?.tags) continue;
-            for (const tagName of operation.tags){
-                if (seenTagNames.has(tagName)) continue;
-                seenTagNames.add(tagName);
-                collectedTagNames.push(tagName);
-            }
-        }
-    }
-    const declaredTags = options.tags ?? [];
-    const declaredTagNames = new Set(declaredTags.map((t)=>t.name));
-    const tags = [
-        ...declaredTags,
-        ...collectedTagNames.filter((name)=>!declaredTagNames.has(name)).map((name)=>({
-                name
-            }))
-    ];
-    const document = {
-        openapi: '3.1.0',
-        info: {
-            title: options.info?.title ?? 'Vela API',
-            version: options.info?.version ?? '1.0.0',
-            ...options.info?.description ? {
-                description: options.info.description
-            } : {}
-        },
-        // servers sits between info and paths (OpenAPI convention). Omitted when
-        // the caller passes none, mirroring the components/tags handling below.
-        ...options.servers?.length ? {
-            servers: options.servers
-        } : {},
-        paths
-    };
-    // components.schemas (generated from DTOs) and components.securitySchemes
-    // (caller-supplied) share the same `components` object — attach it when
-    // either is present so neither clobbers the other.
-    const schemas = registry.build();
-    if (schemas || options.securitySchemes) {
-        document.components = {
-            ...schemas ? {
-                schemas
-            } : {},
-            ...options.securitySchemes ? {
-                securitySchemes: options.securitySchemes
-            } : {}
-        };
-    }
-    // Document-level default security requirements (each operation may override).
-    // Omitted entirely when the caller passes none.
-    if (options.security?.length) {
-        document.security = options.security;
-    }
-    // Only attach `tags` when non-empty. Emitting `tags: []` on a tag-less
-    // spec is the exact symptom the consumer reported, so omit the key
-    // entirely in that case (mirrors the `components` handling above).
-    if (tags.length > 0) {
-        document.tags = tags;
-    }
-    return document;
-}

package/dist/openapi/index.d.ts

@@ -1,7 +0,0 @@
-export { createOpenApiDocument } from './document';
-export { ApiDoc, ApiTags, ApiResponse, API_DOC_METADATA, API_TAGS_METADATA, API_RESPONSES_METADATA, } from './decorators';
-export { zodToJsonSchema } from './zod-to-json-schema';
-export { renderScalarUi } from './scalar-ui';
-export { renderSwaggerUi } from './swagger-ui';
-export { renderRedocUi } from './redoc-ui';
-export type { ApiDocMetadata, ApiResponseEntry, ApiResponseOptions, CreateOpenApiDocumentOptions, HttpVerb, JsonSchema, MountOpenApiOptions, OpenApiUi, OpenApiDocument, OpenApiInfo, OpenApiOperation, OpenApiParameter, OpenApiPathItem, OpenApiRequestBody, OpenApiResponse, } from './types';

package/dist/openapi/index.js

@@ -1,6 +0,0 @@
-export { createOpenApiDocument } from "./document.js";
-export { ApiDoc, ApiTags, ApiResponse, API_DOC_METADATA, API_TAGS_METADATA, API_RESPONSES_METADATA } from "./decorators.js";
-export { zodToJsonSchema } from "./zod-to-json-schema.js";
-export { renderScalarUi } from "./scalar-ui.js";
-export { renderSwaggerUi } from "./swagger-ui.js";
-export { renderRedocUi } from "./redoc-ui.js";

package/dist/openapi/redoc-ui.d.ts

@@ -1 +0,0 @@
-export declare function renderRedocUi(specUrl: string, title?: string): string;

package/dist/openapi/redoc-ui.js

@@ -1,19 +0,0 @@
-// Minimal HTML shell that bootstraps ReDoc from a CDN. Served as a static
-// string so it works on every edge runtime with no Node or bundler deps —
-// ReDoc itself is loaded from a CDN at runtime.
-export function renderRedocUi(specUrl, title) {
-    const safeUrl = specUrl.replace(/"/g, '"');
-    const safeTitle = (title ?? 'API Reference').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-    return `<!doctype html>
-<html>
-  <head>
-    <title>${safeTitle}</title>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-  </head>
-  <body>
-    <redoc spec-url="${safeUrl}"></redoc>
-    <script src="https://cdn.jsdelivr.net/npm/redoc/bundles/redoc.standalone.js"></script>
-  </body>
-</html>`;
-}

package/dist/openapi/scalar-ui.d.ts

@@ -1 +0,0 @@
-export declare function renderScalarUi(jsonUrl: string, title?: string): string;

package/dist/openapi/scalar-ui.js

@@ -1,19 +0,0 @@
-// Minimal HTML shell that bootstraps Scalar's hosted API-reference UI.
-// Served as a static string so it works on every edge runtime with no
-// Node or bundler deps. Scalar itself is loaded from a CDN at runtime.
-export function renderScalarUi(jsonUrl, title) {
-    const safeUrl = jsonUrl.replace(/"/g, '"');
-    const safeTitle = (title ?? 'API Reference').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-    return `<!doctype html>
-<html>
-  <head>
-    <title>${safeTitle}</title>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-  </head>
-  <body>
-    <script id="api-reference" data-url="${safeUrl}"></script>
-    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
-  </body>
-</html>`;
-}

package/dist/openapi/swagger-ui.d.ts

@@ -1 +0,0 @@
-export declare function renderSwaggerUi(specUrl: string, title?: string): string;

package/dist/openapi/swagger-ui.js

@@ -1,23 +0,0 @@
-// Minimal HTML shell that bootstraps Swagger UI from a CDN. Served as a
-// static string so it works on every edge runtime with no Node or bundler
-// deps — Swagger UI itself is loaded from a CDN at runtime.
-export function renderSwaggerUi(specUrl, title) {
-    const safeUrl = specUrl.replace(/"/g, '"');
-    const safeTitle = (title ?? 'API Reference').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-    return `<!doctype html>
-<html>
-  <head>
-    <title>${safeTitle}</title>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/swagger-ui-dist/swagger-ui.css" />
-  </head>
-  <body>
-    <div id="swagger-ui"></div>
-    <script src="https://cdn.jsdelivr.net/npm/swagger-ui-dist/swagger-ui-bundle.js"></script>
-    <script>
-      window.ui = SwaggerUIBundle({ url: "${safeUrl}", dom_id: '#swagger-ui' });
-    </script>
-  </body>
-</html>`;
-}

package/dist/openapi/types.d.ts

@@ -1,182 +0,0 @@
-export interface OpenApiInfo {
-    title: string;
-    version: string;
-    description?: string;
-}
-export interface JsonSchema {
-    type?: string | string[];
-    format?: string;
-    enum?: Array<string | number | boolean | null>;
-    const?: unknown;
-    description?: string;
-    nullable?: boolean;
-    default?: unknown;
-    items?: JsonSchema;
-    properties?: Record<string, JsonSchema>;
-    required?: string[];
-    additionalProperties?: boolean | JsonSchema;
-    oneOf?: JsonSchema[];
-    anyOf?: JsonSchema[];
-    allOf?: JsonSchema[];
-    minimum?: number;
-    maximum?: number;
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-    $ref?: string;
-    [key: string]: unknown;
-}
-export interface OpenApiParameter {
-    name: string;
-    in: 'path' | 'query' | 'header' | 'cookie';
-    required?: boolean;
-    description?: string;
-    schema?: JsonSchema;
-}
-export interface OpenApiRequestBody {
-    description?: string;
-    required?: boolean;
-    content?: Record<string, {
-        schema: JsonSchema;
-    }>;
-}
-export interface OpenApiResponse {
-    description: string;
-    content?: Record<string, {
-        schema: JsonSchema;
-    }>;
-}
-/**
- * A single security requirement: maps a securityScheme name to the scopes it
- * requires (empty array for apiKey/http schemes). An operation- or document-
- * level array is an OR of these objects. Kept as a plain record so callers can
- * build them inline (`{ cookieAuth: [] }`).
- */
-export type OpenApiSecurityRequirement = Record<string, string[]>;
-export interface OpenApiOperation {
-    summary?: string;
-    description?: string;
-    operationId?: string;
-    deprecated?: boolean;
-    tags?: string[];
-    parameters?: OpenApiParameter[];
-    requestBody?: OpenApiRequestBody;
-    responses: Record<string, OpenApiResponse>;
-    /** Per-operation security requirements (overrides the document-level array). */
-    security?: OpenApiSecurityRequirement[];
-}
-/** An OpenAPI Server Object. Kept loose so callers can add `variables`. */
-export interface OpenApiServer {
-    url: string;
-    description?: string;
-    variables?: Record<string, {
-        enum?: string[];
-        default: string;
-        description?: string;
-    }>;
-    [key: string]: unknown;
-}
-/**
- * An OpenAPI Security Scheme Object (apiKey / http / oauth2 / openIdConnect /
- * mutualTLS). Index signature keeps it open so any valid scheme shape passes
- * without fighting the types (mirrors JsonSchema above).
- */
-export interface OpenApiSecurityScheme {
-    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect' | 'mutualTLS';
-    description?: string;
-    name?: string;
-    in?: 'query' | 'header' | 'cookie';
-    scheme?: string;
-    bearerFormat?: string;
-    flows?: Record<string, unknown>;
-    openIdConnectUrl?: string;
-    [key: string]: unknown;
-}
-export type HttpVerb = 'get' | 'post' | 'put' | 'patch' | 'delete' | 'options' | 'head';
-export type OpenApiPathItem = {
-    [verb in HttpVerb]?: OpenApiOperation;
-};
-export interface OpenApiDocument {
-    openapi: '3.1.0';
-    info: OpenApiInfo;
-    servers?: OpenApiServer[];
-    paths: Record<string, OpenApiPathItem>;
-    components?: {
-        schemas?: Record<string, JsonSchema>;
-        securitySchemes?: Record<string, OpenApiSecurityScheme>;
-    };
-    security?: OpenApiSecurityRequirement[];
-    tags?: Array<{
-        name: string;
-        description?: string;
-    }>;
-}
-export interface ApiDocMetadata {
-    summary?: string;
-    description?: string;
-    operationId?: string;
-    deprecated?: boolean;
-    tags?: string[];
-}
-export interface ApiResponseOptions {
-    description: string;
-    /** Zod schema, DTO class (from createZodDto), or raw JSON Schema. */
-    schema?: unknown;
-}
-export interface ApiResponseEntry extends ApiResponseOptions {
-    status: number | string;
-}
-export interface CreateOpenApiDocumentOptions {
-    info?: Partial<OpenApiInfo>;
-    globalPrefix?: string;
-    /**
-     * Declare top-level tag groups with descriptions and an explicit order
-     * (mirrors NestJS `DocumentBuilder().addTag(name, description)`). Tags
-     * actually used by operations but NOT declared here are still emitted —
-     * appended after the declared ones in first-seen order. Declared tags
-     * with no operations are kept (lets you pre-declare ordering/description).
-     */
-    tags?: Array<{
-        name: string;
-        description?: string;
-    }>;
-    /**
-     * Top-level `servers` array (base URLs the API is served from). Emitted
-     * verbatim between `info` and `paths` when non-empty; omitted otherwise.
-     */
-    servers?: OpenApiServer[];
-    /**
-     * Named security schemes, emitted under `components.securitySchemes` (merged
-     * with generated `components.schemas`). Reference them from `security`.
-     */
-    securitySchemes?: Record<string, OpenApiSecurityScheme>;
-    /**
-     * Document-level default security requirements (applies to every operation
-     * unless the operation overrides it). Emitted verbatim when non-empty.
-     */
-    security?: OpenApiSecurityRequirement[];
-}
-export type OpenApiUi = 'swagger' | 'scalar' | 'redoc';
-export interface MountOpenApiOptions {
-    /** Pre-built OpenAPI document to serve. */
-    document: OpenApiDocument;
-    /** OpenAPI JSON spec path. @default '/openapi.json' */
-    specPath?: string;
-    /**
-     * UI(s) to mount. 'all' mounts swagger + scalar + redoc.
-     * @default 'scalar'
-     */
-    ui?: OpenApiUi | OpenApiUi[] | 'all';
-    /** Swagger UI path. @default '/docs' */
-    swaggerPath?: string;
-    /** Scalar path. @default '/scalar' */
-    scalarPath?: string;
-    /** ReDoc path. @default '/redoc' */
-    redocPath?: string;
-    /** Page title for the UIs. */
-    title?: string;
-    /** @deprecated use `specPath`. Back-compat alias; if set, overrides specPath default. */
-    path?: string;
-    /** @deprecated single-UI path override; applies to the single `ui` when a string. */
-    uiPath?: string;
-}

package/dist/openapi/types.js

@@ -1,4 +0,0 @@
-// Minimal OpenAPI 3.1 subset Vela emits. Kept intentionally loose (index
-// signatures on schemas, open tags array) so users can extend without
-// fighting the types. Covers what createOpenApiDocument actually produces.
-export { };

package/dist/openapi/zod-to-json-schema.d.ts

@@ -1,4 +0,0 @@
-import type { JsonSchema } from './types';
-export declare function zodToJsonSchema(schema: unknown): JsonSchema;
-export declare function isOptional(schema: unknown): boolean;
-export declare function isNullable(schema: unknown): boolean;

package/dist/openapi/zod-to-json-schema.js

@@ -1,57 +0,0 @@
-// Zod v4 exposes `schema.toJSONSchema()` on every schema instance — an
-// authoritative, zero-cost converter. We delegate to it when present and
-// strip the `$schema` meta so the result embeds cleanly into OpenAPI
-// components. For non-Zod schemas (anything that doesn't expose the
-// method) we return an empty (permissive) schema.
-function stripOpenApiIncompatible(schema) {
-    const out = {
-        ...schema
-    };
-    delete out.$schema;
-    // Zod v4 emits `additionalProperties: false` by default; users rarely
-    // want that constraint in their published OpenAPI doc, so leave it in
-    // — it's a faithful reflection of the schema. No change here.
-    if (Array.isArray(out.properties)) {
-    // shouldn't happen, but guard
-    } else if (out.properties && typeof out.properties === 'object') {
-        const props = out.properties;
-        const cleaned = {};
-        for (const [key, val] of Object.entries(props)){
-            cleaned[key] = stripOpenApiIncompatible(val);
-        }
-        out.properties = cleaned;
-    }
-    if (out.items && typeof out.items === 'object') {
-        out.items = stripOpenApiIncompatible(out.items);
-    }
-    return out;
-}
-export function zodToJsonSchema(schema) {
-    if (!schema || typeof schema !== 'object') return {};
-    const maybe = schema.toJSONSchema;
-    if (typeof maybe === 'function') {
-        try {
-            const result = maybe.call(schema);
-            if (result && typeof result === 'object') {
-                return stripOpenApiIncompatible(result);
-            }
-        } catch  {
-        // Zod may refuse to convert certain schemas; fall through.
-        }
-    }
-    return {};
-}
-// Zod v4 and v3 both name constructors `ZodOptional` / `ZodDefault` /
-// `ZodNullable`. Checking the constructor name is cheap and avoids
-// depending on internal `_def` shape.
-function ctorName(schema) {
-    if (!schema || typeof schema !== 'object') return undefined;
-    return schema.constructor?.name;
-}
-export function isOptional(schema) {
-    const name = ctorName(schema);
-    return name === 'ZodOptional' || name === 'ZodDefault';
-}
-export function isNullable(schema) {
-    return ctorName(schema) === 'ZodNullable';
-}

package/dist/pipeline/app-providers.d.ts

@@ -1,10 +0,0 @@
-import type { Container } from '../container/container';
-import type { RouteManager } from '../http/route.manager';
-import type { ModuleLoader } from '../module/module-loader';
-/**
- * Bind every APP_* provider registered in the container as a global
- * component on the RouteManager. The single source of truth for app-level
- * pipeline configuration — used by both VelaFactory.create and
- * @velajs/testing's TestingModuleBuilder.compile.
- */
-export declare function bindAppProviders(routeManager: RouteManager, container: Container, loader: ModuleLoader): void;