@codexsploitx/schemaapi 1.0.5 → 1.0.6

package/dist/schemaapi.cjs.js

@@ -1,13 +1,1724 @@
 'use strict';
 
-function createContract(schema) {
+var zod = require('zod');
+
+class SchemaApiError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "SchemaApiError";
+    }
+}
+function buildErrorPayload(error) {
+    if (error instanceof SchemaApiError) {
+        return {
+            error: error.message,
+            message: error.message,
+            status: error.code,
+        };
+    }
+    const typedError = error;
+    const status = typeof typedError.status === "number"
+        ? typedError.status
+        : typeof typedError.code === "number"
+            ? typedError.code
+            : 500;
+    const message = typeof typedError.message === "string"
+        ? typedError.message
+        : "Internal Server Error";
     return {
+        error: message,
+        message,
+        status,
+    };
+}
+function extractRouteParams(route) {
+    return route
+        .split("/")
+        .filter((segment) => segment.startsWith(":"))
+        .map((segment) => segment.slice(1))
+        .filter((name) => name.length > 0);
+}
+function getBaseSchema(schema) {
+    let current = schema;
+    while (current._def &&
+        current._def?.innerType) {
+        const def = current._def;
+        current = def.innerType;
+    }
+    return current;
+}
+function getObjectShape(schema) {
+    if (!schema) {
+        return null;
+    }
+    const base = getBaseSchema(schema);
+    if (base instanceof zod.ZodObject) {
+        const objectSchema = base;
+        return objectSchema.shape;
+    }
+    return null;
+}
+function getTypeName(schema) {
+    const base = getBaseSchema(schema);
+    const def = base._def;
+    if (!def || typeof def !== "object") {
+        return undefined;
+    }
+    const record = def;
+    const value = record["typeName"] || record["type"];
+    if (typeof value === "string") {
+        return value;
+    }
+    return undefined;
+}
+function isOptional(schema) {
+    return schema.isOptional();
+}
+function createContract(schema) {
+    const api = {
         handle(endpoint, handler) {
-            return handler;
+            const [method, route] = endpoint.split(" ");
+            const routeSchema = schema[route];
+            if (!routeSchema) {
+                throw new SchemaApiError(404, `Route ${route} not defined in contract`);
+            }
+            const methodSchema = routeSchema[method];
+            if (!methodSchema) {
+                throw new SchemaApiError(405, `Method ${method} not defined for route ${route}`);
+            }
+            const dynamicParams = extractRouteParams(route);
+            if (dynamicParams.length > 0) {
+                const paramsShape = getObjectShape(methodSchema.params);
+                if (!paramsShape) {
+                    throw new Error(`Route ${route} has dynamic params but no params schema is defined`);
+                }
+                dynamicParams.forEach((name) => {
+                    if (!(name in paramsShape)) {
+                        throw new Error(`Dynamic path param :${name} in ${route} is not defined in params`);
+                    }
+                });
+            }
+            return async (ctx) => {
+                const context = ctx;
+                const media = methodSchema.media;
+                if (media && media.kind === "upload") {
+                    const rawHeaders = (context.headers ??
+                        {});
+                    const headers = {};
+                    Object.keys(rawHeaders).forEach((key) => {
+                        const value = rawHeaders[key];
+                        if (typeof value === "string") {
+                            headers[key.toLowerCase()] = value;
+                        }
+                    });
+                    const contentTypeHeader = headers["content-type"];
+                    if (media.contentTypes && media.contentTypes.length > 0) {
+                        const matches = !!contentTypeHeader &&
+                            media.contentTypes.some((expected) => {
+                                if (expected.endsWith("/*")) {
+                                    const prefix = expected.slice(0, -1);
+                                    return contentTypeHeader.startsWith(prefix);
+                                }
+                                return (contentTypeHeader === expected ||
+                                    contentTypeHeader.startsWith(`${expected};`));
+                            });
+                        if (!matches) {
+                            throw new SchemaApiError(415, "Unsupported Media Type");
+                        }
+                    }
+                    if (media.maxSize && media.maxSize > 0) {
+                        const lengthHeader = headers["content-length"];
+                        if (lengthHeader !== undefined) {
+                            const parsed = Number(lengthHeader);
+                            if (!Number.isNaN(parsed) && parsed > media.maxSize) {
+                                throw new SchemaApiError(413, "Payload Too Large");
+                            }
+                        }
+                    }
+                }
+                if (methodSchema.roles && methodSchema.roles.length > 0) {
+                    const userRole = context.user?.role;
+                    if (!userRole || !methodSchema.roles.includes(userRole)) {
+                        throw new SchemaApiError(403, "Forbidden");
+                    }
+                }
+                try {
+                    if (methodSchema.params && context.params !== undefined) {
+                        context.params = methodSchema.params.parse(context.params);
+                    }
+                    if (methodSchema.query && context.query !== undefined) {
+                        context.query = methodSchema.query.parse(context.query);
+                    }
+                    if (methodSchema.body && context.body !== undefined) {
+                        context.body = methodSchema.body.parse(context.body);
+                    }
+                    if (methodSchema.headers && context.headers !== undefined) {
+                        context.headers = methodSchema.headers.parse(context.headers);
+                    }
+                }
+                catch (error) {
+                    if (error instanceof zod.z.ZodError) {
+                        throw new SchemaApiError(400, `Validation Error: ${JSON.stringify(error.flatten())}`);
+                    }
+                    throw error;
+                }
+                let result;
+                try {
+                    result = await handler(context);
+                }
+                catch (error) {
+                    if (error instanceof SchemaApiError) {
+                        const code = error.code;
+                        const errorsConfig = (methodSchema.errors ??
+                            {});
+                        const allowedStatuses = Object.keys(errorsConfig);
+                        if (code >= 400 && code !== 400 && code !== 500) {
+                            if (!allowedStatuses.includes(String(code))) {
+                                throw new SchemaApiError(code, `${code} is not defined in contract.errors`);
+                            }
+                        }
+                        throw error;
+                    }
+                    throw error;
+                }
+                if (methodSchema.response) {
+                    try {
+                        return methodSchema.response.parse(result);
+                    }
+                    catch (error) {
+                        if (error instanceof zod.z.ZodError) {
+                            throw new SchemaApiError(500, `Response Validation Error: ${JSON.stringify(error.flatten())}`);
+                        }
+                        throw error;
+                    }
+                }
+                return result;
+            };
+        },
+        compareWith(other) {
+            const breaking = [];
+            const oldSchema = other.schema;
+            const newSchema = schema;
+            Object.keys(oldSchema).forEach((route) => {
+                if (!(route in newSchema)) {
+                    breaking.push(`Route removed: ${route}`);
+                    return;
+                }
+                const oldRoute = oldSchema[route];
+                const newRoute = newSchema[route];
+                Object.keys(oldRoute).forEach((method) => {
+                    const oldMethod = oldRoute[method];
+                    const newMethod = newRoute[method];
+                    const pathId = `${method} ${route}`;
+                    if (!newMethod) {
+                        breaking.push(`Method removed: ${pathId}`);
+                        return;
+                    }
+                    // Check Response (Output)
+                    const oldResponseShape = getObjectShape(oldMethod.response);
+                    const newResponseShape = getObjectShape(newMethod.response);
+                    if (oldResponseShape && newResponseShape) {
+                        Object.keys(oldResponseShape).forEach((field) => {
+                            if (!(field in newResponseShape)) {
+                                breaking.push(`Response field removed: ${field} in ${pathId}`);
+                                return;
+                            }
+                            const oldField = oldResponseShape[field];
+                            const newField = newResponseShape[field];
+                            const oldType = getTypeName(oldField);
+                            const newType = getTypeName(newField);
+                            if (oldType && newType && oldType !== newType) {
+                                breaking.push(`Response field type changed: ${field} in ${pathId}`);
+                            }
+                        });
+                    }
+                    // Check Request Body (Input)
+                    const oldBodyShape = getObjectShape(oldMethod.body);
+                    const newBodyShape = getObjectShape(newMethod.body);
+                    if (newBodyShape) {
+                        Object.keys(newBodyShape).forEach((field) => {
+                            const newField = newBodyShape[field];
+                            const oldField = oldBodyShape ? oldBodyShape[field] : undefined;
+                            if (!oldField) {
+                                // New field added. Check if required.
+                                if (!newField.isOptional()) {
+                                    breaking.push(`New required request body field: ${field} in ${pathId}`);
+                                }
+                            }
+                            else {
+                                // Field exists in both. Check type change.
+                                const oldType = getTypeName(oldField);
+                                const newType = getTypeName(newField);
+                                if (oldType && newType && oldType !== newType) {
+                                    breaking.push(`Request body field type changed: ${field} in ${pathId}`);
+                                }
+                                // Check if became required (was optional)
+                                if (oldField.isOptional() && !newField.isOptional()) {
+                                    breaking.push(`Request body field became required: ${field} in ${pathId}`);
+                                }
+                            }
+                        });
+                    }
+                    // Check Query Params (Input)
+                    const oldQueryShape = getObjectShape(oldMethod.query);
+                    const newQueryShape = getObjectShape(newMethod.query);
+                    if (newQueryShape) {
+                        Object.keys(newQueryShape).forEach((field) => {
+                            const newField = newQueryShape[field];
+                            const oldField = oldQueryShape ? oldQueryShape[field] : undefined;
+                            if (!oldField) {
+                                if (!newField.isOptional()) {
+                                    breaking.push(`New required query param: ${field} in ${pathId}`);
+                                }
+                            }
+                            else {
+                                const oldType = getTypeName(oldField);
+                                const newType = getTypeName(newField);
+                                if (oldType && newType && oldType !== newType) {
+                                    breaking.push(`Query param type changed: ${field} in ${pathId}`);
+                                }
+                            }
+                        });
+                    }
+                    // Check Path Params (Input)
+                    const oldParamsShape = getObjectShape(oldMethod.params);
+                    const newParamsShape = getObjectShape(newMethod.params);
+                    if (newParamsShape) {
+                        Object.keys(newParamsShape).forEach((field) => {
+                            const newField = newParamsShape[field];
+                            const oldField = oldParamsShape ? oldParamsShape[field] : undefined;
+                            if (oldField) {
+                                const oldType = getTypeName(oldField);
+                                const newType = getTypeName(newField);
+                                if (oldType && newType && oldType !== newType) {
+                                    breaking.push(`Path param type changed: ${field} in ${pathId}`);
+                                }
+                            }
+                        });
+                    }
+                    const oldErrors = (oldMethod.errors ?? {});
+                    const newErrors = (newMethod.errors ?? {});
+                    Object.keys(oldErrors).forEach((status) => {
+                        if (!(status in newErrors)) {
+                            breaking.push(`Status code removed: ${status} in ${pathId}`);
+                        }
+                        else {
+                            const oldError = oldErrors[status];
+                            const newError = newErrors[status];
+                            if (oldError !== newError) {
+                                breaking.push(`Error code changed for status ${status} in ${pathId}`);
+                            }
+                        }
+                    });
+                    const oldRoles = (oldMethod.roles ?? []);
+                    const newRoles = (newMethod.roles ?? []);
+                    oldRoles.forEach((role) => {
+                        if (!newRoles.includes(role)) {
+                            breaking.push(`Role removed: ${role} in ${pathId}`);
+                        }
+                    });
+                });
+            });
+            return { breakingChanges: breaking };
+        },
+        docs() {
+            const routesDocs = [];
+            const current = schema;
+            Object.keys(current).forEach((route) => {
+                const routeDef = current[route];
+                Object.keys(routeDef).forEach((method) => {
+                    const methodDef = routeDef[method];
+                    const doc = {
+                        method,
+                        path: route,
+                        roles: methodDef.roles ? [...methodDef.roles] : undefined,
+                        media: methodDef.media,
+                        errors: methodDef.errors
+                            ? Object.keys(methodDef.errors).map((status) => ({
+                                status,
+                                code: String(methodDef.errors?.[status]),
+                            }))
+                            : undefined,
+                    };
+                    const fillFields = (source, assign) => {
+                        if (!source) {
+                            return;
+                        }
+                        const shape = getObjectShape(source);
+                        if (!shape) {
+                            return;
+                        }
+                        const fields = Object.keys(shape).map((name) => {
+                            const fieldSchema = shape[name];
+                            const typeName = getTypeName(fieldSchema);
+                            const optional = isOptional(fieldSchema);
+                            return {
+                                name,
+                                type: typeName,
+                                optional,
+                            };
+                        });
+                        assign(fields);
+                    };
+                    fillFields(methodDef.params, (fields) => {
+                        doc.params = fields;
+                    });
+                    fillFields(methodDef.query, (fields) => {
+                        doc.query = fields;
+                    });
+                    fillFields(methodDef.body, (fields) => {
+                        doc.body = fields;
+                    });
+                    fillFields(methodDef.headers, (fields) => {
+                        doc.headers = fields;
+                    });
+                    routesDocs.push(doc);
+                });
+            });
+            return { routes: routesDocs };
         },
         schema,
     };
+    return api;
+}
+
+// Definimos tipos básicos para simular la estructura del cliente
+// En una implementación real, estos tipos se inferirían recursivamente del esquema T
+function createClient(contract, config) {
+    const { baseUrl, fetch: customFetch } = config;
+    const fetchFn = customFetch || globalThis.fetch;
+    return new Proxy({}, {
+        get(_target, resource) {
+            return new Proxy({}, {
+                get(_target, operation) {
+                    // operation podría ser 'get', 'post', 'put', 'delete', 'ws', etc.
+                    // resource sería 'users', 'posts', etc.
+                    return async (params = {}) => {
+                        const method = operation.toUpperCase();
+                        let path = `/${resource}`;
+                        // Si hay params.id, asumimos que va en la URL
+                        if (params.id) {
+                            path += `/${params.id}`;
+                        }
+                        // Manejo de WebSocket
+                        if (method === "WS") {
+                            const wsUrlStr = baseUrl.replace(/^http/, "ws");
+                            const url = new URL(`${wsUrlStr}${path}`);
+                            // Agregar query params
+                            Object.keys(params).forEach(key => {
+                                if (key !== 'id' && key !== 'headers' && key !== 'body') {
+                                    url.searchParams.append(key, String(params[key]));
+                                }
+                            });
+                            const globalWithWebSocket = globalThis;
+                            const WebSocketCtor = config.WebSocket || globalWithWebSocket.WebSocket;
+                            if (!WebSocketCtor) {
+                                throw new Error("WebSocket implementation not found. Please provide it in config.");
+                            }
+                            return new WebSocketCtor(url.toString());
+                        }
+                        const url = new URL(`${baseUrl}${path}`);
+                        // Agregar query params si existen (excluyendo id y body)
+                        Object.keys(params).forEach(key => {
+                            if (key !== 'id' && key !== 'body' && key !== 'headers') {
+                                url.searchParams.append(key, String(params[key]));
+                            }
+                        });
+                        const headers = {
+                            "Content-Type": "application/json",
+                            ...(params.headers || {})
+                        };
+                        const response = await fetchFn(url.toString(), {
+                            method,
+                            headers,
+                            body: params.body ? JSON.stringify(params.body) : undefined,
+                        });
+                        if (!response.ok) {
+                            throw new Error(`Request failed: ${response.status} ${response.statusText}`);
+                        }
+                        return response.json();
+                    };
+                }
+            });
+        }
+    });
+}
+
+function generateSDK(contract, options) {
+    return createClient(contract, {
+        baseUrl: options.baseUrl,
+        fetch: options.fetch,
+    });
+}
+
+function handleContract$6(app, contract, handlers) {
+    const schema = contract.schema;
+    Object.keys(schema).forEach((route) => {
+        const methods = schema[route];
+        Object.keys(methods).forEach((method) => {
+            const endpoint = `${method} ${route}`;
+            const implementation = handlers[endpoint];
+            const methodSchema = methods[method];
+            if (!implementation) {
+                return;
+            }
+            const wrapped = contract.handle(endpoint, implementation);
+            const httpMethod = method.toLowerCase();
+            const register = app[httpMethod];
+            if (!register) {
+                return;
+            }
+            register(route, async (req, res, next) => {
+                try {
+                    const context = {
+                        params: req.params || {},
+                        query: req.query || {},
+                        body: req.body,
+                        headers: req.headers || {},
+                        user: req.user,
+                    };
+                    const result = await wrapped(context);
+                    const media = methodSchema?.media;
+                    if (media && media.kind === "download") {
+                        const download = result;
+                        const data = download &&
+                            typeof download === "object" &&
+                            "data" in download
+                            ? download.data
+                            : download;
+                        const contentType = download &&
+                            typeof download === "object" &&
+                            "contentType" in download
+                            ? download.contentType
+                            : "application/octet-stream";
+                        const filename = download &&
+                            typeof download === "object" &&
+                            "filename" in download
+                            ? download.filename
+                            : undefined;
+                        if (typeof res.setHeader === "function") {
+                            res.setHeader("Content-Type", contentType);
+                            if (filename) {
+                                res.setHeader("Content-Disposition", `attachment; filename="${filename}"`);
+                            }
+                        }
+                        if (typeof res.send === "function") {
+                            res.send(data);
+                            return;
+                        }
+                    }
+                    res.json(result);
+                }
+                catch (error) {
+                    next(error);
+                }
+            });
+        });
+    });
+}
+
+var express = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    handleContract: handleContract$6
+});
+
+// Helper para obtener NextResponse (asumiendo que el usuario lo tiene disponible o lo importamos dinámicamente si fuera un paquete real)
+// Aquí simularemos una respuesta JSON estándar
+function jsonResponse(data, status = 200) {
+    return new Response(JSON.stringify(data), {
+        status,
+        headers: { "Content-Type": "application/json" },
+    });
+}
+function handleContract$5(contract, handlers) {
+    // Retorna un handler compatible con Route Handlers de Next.js (App Router)
+    // Uso: export const { GET, POST, PUT, DELETE } = adapters.next.handleContract(contract, handlers);
+    // en app/api/[...route]/route.ts
+    const dispatcher = async (req, { params }) => {
+        const url = new URL(req.url);
+        // En App Router [...route], params.route es un array. Pero aquí asumimos que el usuario mapea rutas específicas o catch-all.
+        // Si es catch-all, necesitamos reconstruir la ruta.
+        // Simplificación: Iteramos sobre el contrato para encontrar la ruta que coincida.
+        // Esto es ineficiente O(N) por request, pero funciona para validación.
+        // Una implementación más robusta usaría un router interno.
+        const method = req.method;
+        const path = url.pathname; // Ojo: esto incluye el prefijo /api si está ahí.
+        // Intentar hacer match con las rutas del contrato
+        const schema = contract.schema;
+        for (const routePattern of Object.keys(schema)) {
+            // Convertir /users/:id a regex simple
+            const regexPattern = routePattern.replace(/:[a-zA-Z0-9_]+/g, "([^/]+)");
+            const regex = new RegExp(`^.*${regexPattern}$`); // ^.* para permitir prefijos como /api
+            const match = path.match(regex);
+            if (match) {
+                // Verificar método
+                const routeMethods = schema[routePattern];
+                if (routeMethods[method]) {
+                    const endpoint = `${method} ${routePattern}`;
+                    const implementation = handlers[endpoint];
+                    const methodSchema = routeMethods[method];
+                    if (!implementation)
+                        return jsonResponse({ error: "Not Implemented" }, 501);
+                    const contextParams = params || {};
+                    const wrapped = contract.handle(endpoint, implementation);
+                    try {
+                        // Parse body safely
+                        let body = undefined;
+                        if (method !== 'GET' && method !== 'HEAD') {
+                            try {
+                                body = await req.json();
+                            }
+                            catch { }
+                        }
+                        const context = {
+                            params: contextParams,
+                            query: Object.fromEntries(url.searchParams.entries()),
+                            body,
+                            headers: Object.fromEntries(req.headers.entries()),
+                        };
+                        const result = await wrapped(context);
+                        const media = methodSchema?.media;
+                        if (media && media.kind === "download") {
+                            const download = result;
+                            const hasData = download &&
+                                typeof download === "object" &&
+                                Object.prototype.hasOwnProperty.call(download, "data");
+                            const data = hasData
+                                ? download.data
+                                : download;
+                            const contentType = download &&
+                                typeof download === "object" &&
+                                "contentType" in download &&
+                                typeof download.contentType ===
+                                    "string"
+                                ? download.contentType
+                                : "application/octet-stream";
+                            const filename = download &&
+                                typeof download === "object" &&
+                                "filename" in download &&
+                                typeof download.filename ===
+                                    "string"
+                                ? download.filename
+                                : undefined;
+                            const headers = {
+                                "Content-Type": String(contentType),
+                            };
+                            if (filename) {
+                                headers["Content-Disposition"] =
+                                    `attachment; filename="${filename}"`;
+                            }
+                            return new Response(data, {
+                                status: 200,
+                                headers,
+                            });
+                        }
+                        return jsonResponse(result);
+                    }
+                    catch (err) {
+                        const payload = buildErrorPayload(err);
+                        return jsonResponse(payload, payload.status);
+                    }
+                }
+            }
+        }
+        return jsonResponse({ error: "Not Found" }, 404);
+    };
+    return {
+        GET: dispatcher,
+        POST: dispatcher,
+        PUT: dispatcher,
+        DELETE: dispatcher,
+        PATCH: dispatcher,
+    };
+}
+
+var next = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    handleContract: handleContract$5
+});
+
+function handleContract$4(fastify, contract, handlers) {
+    const schema = contract.schema;
+    Object.keys(schema).forEach((route) => {
+        const methods = schema[route];
+        Object.keys(methods).forEach((method) => {
+            const endpoint = `${method} ${route}`;
+            const implementation = handlers[endpoint];
+            const methodSchema = methods[method];
+            if (!implementation) {
+                return;
+            }
+            const wrapped = contract.handle(endpoint, implementation);
+            fastify.route({
+                method: method,
+                url: route, // Fastify soporta /:id sintaxis
+                handler: async (request, reply) => {
+                    try {
+                        const context = {
+                            params: request.params || {},
+                            query: request.query || {},
+                            body: request.body,
+                            headers: request.headers || {},
+                            user: request.user,
+                        };
+                        const result = await wrapped(context);
+                        const media = methodSchema?.media;
+                        if (media && media.kind === "download") {
+                            const download = result;
+                            const data = download &&
+                                typeof download === "object" &&
+                                "data" in download
+                                ? download.data
+                                : download;
+                            const contentType = download &&
+                                typeof download === "object" &&
+                                "contentType" in download
+                                ? download.contentType
+                                : "application/octet-stream";
+                            const filename = download &&
+                                typeof download === "object" &&
+                                "filename" in download
+                                ? download.filename
+                                : undefined;
+                            if (typeof reply.header === "function") {
+                                reply.header("Content-Type", contentType);
+                                if (filename) {
+                                    reply.header("Content-Disposition", `attachment; filename="${filename}"`);
+                                }
+                            }
+                            reply.send(data);
+                            return;
+                        }
+                        reply.send(result);
+                    }
+                    catch (error) {
+                        const payload = buildErrorPayload(error);
+                        reply.status(payload.status).send(payload);
+                    }
+                },
+            });
+        });
+    });
+}
+
+var fastify = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    handleContract: handleContract$4
+});
+
+const SchemaApiModule = {
+    register(app, contract, handlers) {
+        const adapter = app.getHttpAdapter();
+        const schema = contract.schema;
+        Object.keys(schema).forEach((route) => {
+            const methods = schema[route];
+            Object.keys(methods).forEach((method) => {
+                const endpoint = `${method} ${route}`;
+                const implementation = handlers[endpoint];
+                if (!implementation) {
+                    return;
+                }
+                const wrapped = contract.handle(endpoint, implementation);
+                const methodLower = method.toLowerCase();
+                if (typeof adapter[methodLower] === "function") {
+                    adapter[methodLower](route, async (req, res, _next) => {
+                        try {
+                            // Intentamos normalizar request/response independientemente del driver (Express/Fastify)
+                            // Nota: Esto asume Express por defecto para req.params/query/body.
+                            // En Fastify, req.params/query/body también existen en el objeto Request estándar de Fastify.
+                            const context = {
+                                params: req.params || {},
+                                query: req.query || {},
+                                body: req.body,
+                                headers: req.headers || {},
+                                user: req.user,
+                            };
+                            const result = await wrapped(context);
+                            // Responder
+                            if (typeof res.send === "function") {
+                                // Express / Fastify
+                                res.send(result);
+                            }
+                            else if (typeof res.json === "function") {
+                                // Express alternative
+                                res.json(result);
+                            }
+                            else {
+                                // Fallback simple
+                                res.end(JSON.stringify(result));
+                            }
+                        }
+                        catch (error) {
+                            const typedError = error;
+                            if (res.status)
+                                res.status(typedError.status || 500);
+                            else if (res.code)
+                                res.code(typedError.status || 500); // Fastify
+                            if (res.send)
+                                res.send({ error: typedError.message });
+                            else
+                                res.end(JSON.stringify({ error: typedError.message }));
+                        }
+                    });
+                }
+            });
+        });
+    },
+};
+
+var nest = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    SchemaApiModule: SchemaApiModule
+});
+
+function handleContract$3(router, contract, handlers) {
+    const schema = contract.schema;
+    Object.keys(schema).forEach((route) => {
+        const methods = schema[route];
+        Object.keys(methods).forEach((method) => {
+            const endpoint = `${method} ${route}`;
+            const implementation = handlers[endpoint];
+            const methodSchema = methods[method];
+            if (!implementation) {
+                return;
+            }
+            const wrapped = contract.handle(endpoint, implementation);
+            // Koa Router register
+            router.register(route, [method], async (ctx, _next) => {
+                try {
+                    const context = {
+                        params: ctx.params || {},
+                        query: ctx.query || {},
+                        body: ctx.request.body, // requires koa-bodyparser or koa-body
+                        headers: ctx.headers || {},
+                        user: ctx.state?.user, // common pattern
+                    };
+                    const result = await wrapped(context);
+                    const media = methodSchema?.media;
+                    if (media && media.kind === "download") {
+                        const download = result;
+                        const data = download &&
+                            typeof download === "object" &&
+                            "data" in download
+                            ? download.data
+                            : download;
+                        const contentType = download &&
+                            typeof download === "object" &&
+                            "contentType" in download
+                            ? download.contentType
+                            : "application/octet-stream";
+                        const filename = download &&
+                            typeof download === "object" &&
+                            "filename" in download
+                            ? download.filename
+                            : undefined;
+                        ctx.body = data;
+                        ctx.type = contentType;
+                        if (filename) {
+                            ctx.set("Content-Disposition", `attachment; filename="${filename}"`);
+                        }
+                    }
+                    else {
+                        ctx.body = result;
+                    }
+                }
+                catch (error) {
+                    const payload = buildErrorPayload(error);
+                    ctx.status = payload.status;
+                    ctx.body = payload;
+                }
+            });
+        });
+    });
+}
+
+var koa = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    handleContract: handleContract$3
+});
+
+function handleContract$2(server, contract, handlers) {
+    const schema = contract.schema;
+    Object.keys(schema).forEach((route) => {
+        const methods = schema[route];
+        // Convertir ruta express-style :param a hapi-style {param}
+        const hapiRoute = route.replace(/:([a-zA-Z0-9_]+)/g, "{$1}");
+        Object.keys(methods).forEach((method) => {
+            const endpoint = `${method} ${route}`;
+            const implementation = handlers[endpoint];
+            const methodSchema = methods[method];
+            if (!implementation) {
+                return;
+            }
+            const wrapped = contract.handle(endpoint, implementation);
+            server.route({
+                method: method,
+                path: hapiRoute,
+                handler: async (request, h) => {
+                    try {
+                        const context = {
+                            params: request.params || {},
+                            query: request.query || {},
+                            body: request.payload,
+                            headers: request.headers || {},
+                            user: request.auth?.credentials, // Common Hapi auth pattern
+                        };
+                        const result = await wrapped(context);
+                        const media = methodSchema?.media;
+                        if (media && media.kind === "download") {
+                            const download = result;
+                            const data = download &&
+                                typeof download === "object" &&
+                                "data" in download
+                                ? download.data
+                                : download;
+                            const contentType = download &&
+                                typeof download === "object" &&
+                                "contentType" in download
+                                ? download.contentType
+                                : "application/octet-stream";
+                            const filename = download &&
+                                typeof download === "object" &&
+                                "filename" in download
+                                ? download.filename
+                                : undefined;
+                            const response = h.response(data);
+                            response.type(contentType);
+                            if (filename) {
+                                response.header("Content-Disposition", `attachment; filename="${filename}"`);
+                            }
+                            return response;
+                        }
+                        return result;
+                    }
+                    catch (error) {
+                        const payload = buildErrorPayload(error);
+                        const response = h.response(payload);
+                        response.code(payload.status);
+                        return response;
+                    }
+                },
+            });
+        });
+    });
+}
+
+var hapi = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    handleContract: handleContract$2
+});
+
+function createRouteHandlers(contract, handlers, routePattern) {
+    const schema = contract.schema;
+    const methods = schema[routePattern];
+    if (!methods) {
+        const notFound = () => {
+            throw new Response("Not Found in Contract", { status: 404 });
+        };
+        return { loader: notFound, action: notFound };
+    }
+    const handleRequest = async (request, params) => {
+        const method = request.method;
+        const endpoint = `${method} ${routePattern}`;
+        const implementation = handlers[endpoint];
+        const methodSchema = methods && methods[method];
+        if (!implementation) {
+            throw new Response("Method Not Implemented", { status: 501 });
+        }
+        const wrapped = contract.handle(endpoint, implementation);
+        try {
+            let body = undefined;
+            // Parse body only for non-GET/HEAD methods
+            if (method !== "GET" && method !== "HEAD") {
+                try {
+                    body = await request.json();
+                }
+                catch {
+                    // Si falla json, tal vez es FormData? Remix usa mucho FormData.
+                    // Por simplicidad, aquí asumimos JSON como el estándar de SchemaApi.
+                    // Si se requiere FormData, se debería procesar antes o aquí.
+                }
+            }
+            const url = new URL(request.url);
+            const context = {
+                params: params || {},
+                query: Object.fromEntries(url.searchParams.entries()),
+                body,
+                headers: Object.fromEntries(request.headers.entries()),
+            };
+            const result = await wrapped(context);
+            const media = methodSchema?.media;
+            if (media && media.kind === "download") {
+                const download = result;
+                const hasData = download &&
+                    typeof download === "object" &&
+                    Object.prototype.hasOwnProperty.call(download, "data");
+                const data = hasData
+                    ? download.data
+                    : download;
+                const contentType = download &&
+                    typeof download === "object" &&
+                    "contentType" in download &&
+                    typeof download.contentType ===
+                        "string"
+                    ? download.contentType
+                    : "application/octet-stream";
+                const filename = download &&
+                    typeof download === "object" &&
+                    "filename" in download &&
+                    typeof download.filename === "string"
+                    ? download.filename
+                    : undefined;
+                const headers = {
+                    "Content-Type": String(contentType),
+                };
+                if (filename) {
+                    headers["Content-Disposition"] = `attachment; filename="${filename}"`;
+                }
+                return new Response(data, {
+                    headers,
+                });
+            }
+            return new Response(JSON.stringify(result), {
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+        catch (err) {
+            const payload = buildErrorPayload(err);
+            return new Response(JSON.stringify(payload), {
+                status: payload.status,
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+    };
+    const loader = async (args) => {
+        if (methods["GET"]) {
+            return handleRequest(args.request, args.params);
+        }
+        // Si no hay GET definido pero se llama al loader
+        throw new Response("Method Not Allowed", { status: 405 });
+    };
+    const action = async (args) => {
+        const method = args.request.method;
+        if (methods[method]) {
+            return handleRequest(args.request, args.params);
+        }
+        throw new Response("Method Not Allowed", { status: 405 });
+    };
+    return { loader, action };
+}
+
+var remix = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    createRouteHandlers: createRouteHandlers
+});
+
+function handleContract$1(contract, handlers) {
+    // Retorna una función (req: Request) => Promise<Response> compatible con Deno.serve
+    return async (req) => {
+        const url = new URL(req.url);
+        const path = url.pathname;
+        const method = req.method;
+        const schema = contract.schema;
+        for (const routePattern of Object.keys(schema)) {
+            // Regex simple para matching: /users/:id -> /users/([^/]+)
+            // Agregamos ^ y $ para match exacto
+            const regexPattern = routePattern.replace(/:[a-zA-Z0-9_]+/g, "([^/]+)");
+            const regex = new RegExp(`^${regexPattern}$`);
+            const match = path.match(regex);
+            if (match) {
+                const routeMethods = schema[routePattern];
+                if (routeMethods[method]) {
+                    const endpoint = `${method} ${routePattern}`;
+                    const implementation = handlers[endpoint];
+                    const methodSchema = routeMethods[method];
+                    if (!implementation) {
+                        return new Response("Not Implemented", { status: 501 });
+                    }
+                    // Extraer params
+                    // Necesitamos saber los nombres de los parámetros para mapearlos
+                    // routePattern: /users/:id/posts/:postId
+                    // match: [..., "123", "456"]
+                    const paramNames = (routePattern.match(/:[a-zA-Z0-9_]+/g) || []).map((p) => p.substring(1));
+                    const params = {};
+                    paramNames.forEach((name, index) => {
+                        params[name] = match[index + 1];
+                    });
+                    const wrapped = contract.handle(endpoint, implementation);
+                    try {
+                        let body = undefined;
+                        if (method !== "GET" && method !== "HEAD") {
+                            try {
+                                body = await req.json();
+                            }
+                            catch { }
+                        }
+                        const context = {
+                            params,
+                            query: Object.fromEntries(url.searchParams.entries()),
+                            body,
+                            headers: Object.fromEntries(req.headers.entries()),
+                        };
+                        const result = await wrapped(context);
+                        const media = methodSchema?.media;
+                        if (media && media.kind === "download") {
+                            const download = result;
+                            const data = download &&
+                                typeof download === "object" &&
+                                "data" in download
+                                ? download.data
+                                : download;
+                            const contentType = download &&
+                                typeof download === "object" &&
+                                "contentType" in download
+                                ? download.contentType
+                                : "application/octet-stream";
+                            const filename = download &&
+                                typeof download === "object" &&
+                                "filename" in download
+                                ? download.filename
+                                : undefined;
+                            const headers = {
+                                "Content-Type": String(contentType),
+                            };
+                            if (filename) {
+                                headers["Content-Disposition"] = `attachment; filename="${filename}"`;
+                            }
+                            return new Response(data, {
+                                headers,
+                            });
+                        }
+                        return new Response(JSON.stringify(result), {
+                            headers: { "Content-Type": "application/json" },
+                        });
+                    }
+                    catch (err) {
+                        const payload = buildErrorPayload(err);
+                        return new Response(JSON.stringify(payload), {
+                            status: payload.status,
+                            headers: { "Content-Type": "application/json" },
+                        });
+                    }
+                }
+            }
+        }
+        return new Response("Not Found", { status: 404 });
+    };
+}
+
+var deno = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    handleContract: handleContract$1
+});
+
+function handleContract(wss, contract, handlers) {
+    const schema = contract.schema;
+    wss.on("connection", async (ws, req) => {
+        const url = req.url ? new URL(req.url, "http://localhost") : null;
+        if (!url) {
+            ws.close(1002, "Invalid URL");
+            return;
+        }
+        const path = url.pathname;
+        let matched = false;
+        for (const routePattern of Object.keys(schema)) {
+            const methods = schema[routePattern];
+            const wsDef = methods["WS"];
+            if (!wsDef)
+                continue;
+            // Match path
+            const regexPattern = routePattern.replace(/:[a-zA-Z0-9_]+/g, "([^/]+)");
+            const regex = new RegExp(`^${regexPattern}$`);
+            const match = path.match(regex);
+            if (match) {
+                matched = true;
+                const implementation = handlers[`WS ${routePattern}`];
+                if (!implementation) {
+                    ws.close(1011, "Handler not found");
+                    return;
+                }
+                // Extract params
+                const paramNames = (routePattern.match(/:[a-zA-Z0-9_]+/g) || []).map((p) => p.substring(1));
+                const params = {};
+                paramNames.forEach((name, index) => {
+                    params[name] = match[index + 1];
+                });
+                const query = Object.fromEntries(url.searchParams.entries());
+                const context = {
+                    params,
+                    query,
+                    headers: req.headers,
+                    ws,
+                    send: (data) => {
+                        if (wsDef.serverMessages) {
+                            try {
+                                wsDef.serverMessages.parse(data);
+                            }
+                            catch (e) {
+                                console.error("Server message validation failed", e);
+                            }
+                        }
+                        ws.send(JSON.stringify(data));
+                    },
+                    onMessage: (cb) => {
+                        ws.on("message", (raw) => {
+                            try {
+                                const json = JSON.parse(raw.toString());
+                                if (wsDef.clientMessages) {
+                                    try {
+                                        const parsed = wsDef.clientMessages.parse(json);
+                                        cb(parsed);
+                                    }
+                                    catch (e) {
+                                        console.error("Client message validation failed", e);
+                                        ws.send(JSON.stringify({
+                                            error: "Invalid Message Schema",
+                                            details: e,
+                                        }));
+                                    }
+                                }
+                                else {
+                                    cb(json);
+                                }
+                            }
+                            catch (e) {
+                                console.error("Invalid JSON", e);
+                            }
+                        });
+                    },
+                };
+                try {
+                    await implementation(context);
+                }
+                catch (e) {
+                    console.error("Error in WS handler", e);
+                    ws.close(1011, "Internal Error");
+                }
+                break;
+            }
+        }
+        if (!matched) {
+            ws.close(4404, "Not Found");
+        }
+    });
+    return wss;
+}
+
+var ws = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    handleContract: handleContract
+});
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    deno: deno,
+    express: express,
+    fastify: fastify,
+    hapi: hapi,
+    koa: koa,
+    nest: nest,
+    next: next,
+    remix: remix,
+    ws: ws
+});
+
+function renderDocsJSON(docs) {
+    return JSON.stringify(docs, null, 2);
+}
+function renderDocsText(docs) {
+    const lines = [];
+    lines.push("SchemaApi Contract");
+    lines.push("================================");
+    docs.routes.forEach((route) => {
+        lines.push("");
+        lines.push(`${route.method} ${route.path}`);
+        lines.push("-".repeat((route.method + route.path).length + 1));
+        if (route.roles && route.roles.length > 0) {
+            lines.push(`roles: ${route.roles.join(", ")}`);
+        }
+        if (route.media) {
+            const mediaParts = [];
+            if (route.media.kind) {
+                mediaParts.push(`kind=${route.media.kind}`);
+            }
+            if (route.media.contentTypes && route.media.contentTypes.length > 0) {
+                mediaParts.push(`types=[${route.media.contentTypes.join(", ")}]`);
+            }
+            if (route.media.maxSize) {
+                mediaParts.push(`maxSize=${route.media.maxSize}`);
+            }
+            lines.push(`media: ${mediaParts.join(" ")}`);
+        }
+        const renderSection = (name, fields) => {
+            if (!fields || fields.length === 0) {
+                return;
+            }
+            lines.push(``);
+            lines.push(`${name}:`);
+            fields.forEach((f) => {
+                const flag = f.optional ? "optional" : "required";
+                const typeName = f.type ? f.type : "unknown";
+                lines.push(`  - ${f.name}: ${typeName} (${flag})`);
+            });
+        };
+        renderSection("params", route.params);
+        renderSection("query", route.query);
+        renderSection("body", route.body);
+        renderSection("headers", route.headers);
+        if (route.errors && route.errors.length > 0) {
+            lines.push("");
+            lines.push("errors:");
+            route.errors.forEach((e) => {
+                lines.push(`  - ${e.status}: ${e.code}`);
+            });
+        }
+    });
+    return lines.join("\n");
+}
+function getThemeBackground(theme) {
+    if (theme === "dark") {
+        return "#020617";
+    }
+    if (theme === "light") {
+        return "#f9fafb";
+    }
+    return "#0b1120";
+}
+function getThemeForeground(theme) {
+    if (theme === "dark") {
+        return "#e5e7eb";
+    }
+    if (theme === "light") {
+        return "#111827";
+    }
+    return "#e5e7eb";
+}
+function renderDocsHTML(docs, options) {
+    const title = options?.title ?? "SchemaApi Docs";
+    const bg = getThemeBackground(options?.theme);
+    const fg = getThemeForeground(options?.theme);
+    const escape = (value) => {
+        if (value === undefined || value === null) {
+            return "";
+        }
+        return String(value)
+            .replace(/&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/>/g, "&gt;")
+            .replace(/"/g, "&quot;");
+    };
+    const renderFieldsTable = (caption, fields) => {
+        if (!fields || fields.length === 0) {
+            return "";
+        }
+        const rows = fields
+            .map((f) => {
+            const typeName = f.type ? f.type : "unknown";
+            const badge = f.optional ? "optional" : "required";
+            return `<tr>
+  <td class="field-name">${escape(f.name)}</td>
+  <td class="field-type">${escape(typeName)}</td>
+  <td class="field-badge ${badge}">${badge}</td>
+</tr>`;
+        })
+            .join("\n");
+        return `<section class="block">
+  <div class="block-title">${escape(caption)}</div>
+  <table class="fields">
+    <thead>
+      <tr>
+        <th>name</th>
+        <th>type</th>
+        <th>required</th>
+      </tr>
+    </thead>
+    <tbody>
+${rows}
+    </tbody>
+  </table>
+</section>`;
+    };
+    const renderRoute = (route) => {
+        const method = escape(route.method);
+        const path = escape(route.path);
+        const roles = route.roles && route.roles.length > 0
+            ? `<div class="pill-group">
+${route.roles
+                .map((r) => `<span class="pill pill-role">role: ${escape(r)}</span>`)
+                .join("\n")}
+</div>`
+            : "";
+        const media = route.media
+            ? (() => {
+                const parts = [];
+                if (route.media?.kind) {
+                    parts.push(`kind=${escape(route.media.kind)}`);
+                }
+                if (route.media?.contentTypes && route.media.contentTypes.length) {
+                    parts.push(`types=[${route.media.contentTypes
+                        .map((t) => escape(t))
+                        .join(", ")}]`);
+                }
+                if (route.media?.maxSize) {
+                    parts.push(`maxSize=${escape(route.media.maxSize)}`);
+                }
+                return `<div class="pill-group">
+  <span class="pill pill-media">media ${parts.join(" · ")}</span>
+</div>`;
+            })()
+            : "";
+        const errors = route.errors && route.errors.length > 0
+            ? `<section class="block">
+  <div class="block-title">errors</div>
+  <table class="fields">
+    <thead>
+      <tr>
+        <th>status</th>
+        <th>code</th>
+      </tr>
+    </thead>
+    <tbody>
+${route.errors
+                .map((e) => `<tr>
+  <td class="field-status">${escape(e.status)}</td>
+  <td class="field-error-code">${escape(e.code)}</td>
+</tr>`)
+                .join("\n")}
+    </tbody>
+  </table>
+</section>`
+            : "";
+        const params = renderFieldsTable("params", route.params);
+        const query = renderFieldsTable("query", route.query);
+        const body = renderFieldsTable("body", route.body);
+        const headers = renderFieldsTable("headers", route.headers);
+        return `<article class="route-card route-${method.toLowerCase()}">
+  <header class="route-header">
+    <span class="method method-${method.toLowerCase()}">${method}</span>
+    <span class="path">${path}</span>
+  </header>
+  <div class="route-meta">
+    ${roles}
+    ${media}
+  </div>
+  <div class="route-content">
+    ${params}
+    ${query}
+    ${body}
+    ${headers}
+    ${errors}
+  </div>
+</article>`;
+    };
+    const routesHtml = docs.routes.map((r) => renderRoute(r)).join("\n");
+    return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <title>${escape(title)}</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <style>
+    :root {
+      --bg: ${bg};
+      --fg: ${fg};
+      --accent: #38bdf8;
+      --accent-soft: rgba(56, 189, 248, 0.12);
+      --card-bg: rgba(15, 23, 42, 0.9);
+      --border-subtle: rgba(148, 163, 184, 0.35);
+      --badge-get: #22c55e;
+      --badge-post: #3b82f6;
+      --badge-put: #eab308;
+      --badge-delete: #ef4444;
+      --badge-other: #a855f7;
+      --font-sans: system-ui, -apple-system, BlinkMacSystemFont, "SF Pro Text",
+        "Inter", sans-serif;
+      --font-mono: ui-monospace, Menlo, Monaco, Consolas, "Liberation Mono",
+        "Courier New", monospace;
+    }
+
+    * {
+      box-sizing: border-box;
+    }
+
+    body {
+      margin: 0;
+      padding: 2.5rem 1.5rem 3rem;
+      background: radial-gradient(circle at top left, #0f172a 0, var(--bg) 45%),
+        radial-gradient(circle at bottom right, #020617 0, var(--bg) 55%);
+      color: var(--fg);
+      font-family: var(--font-sans);
+      -webkit-font-smoothing: antialiased;
+    }
+
+    .shell {
+      max-width: 1120px;
+      margin: 0 auto;
+    }
+
+    .masthead {
+      display: flex;
+      flex-direction: column;
+      gap: 0.75rem;
+      margin-bottom: 2rem;
+    }
+
+    .brand {
+      display: inline-flex;
+      align-items: center;
+      gap: 0.5rem;
+      font-family: var(--font-mono);
+      font-size: 0.9rem;
+      letter-spacing: 0.12em;
+      text-transform: uppercase;
+      color: #9ca3af;
+    }
+
+    .brand-mark {
+      width: 0.65rem;
+      height: 0.65rem;
+      border-radius: 999px;
+      background: radial-gradient(circle at 30% 30%, #e5e7eb, #38bdf8);
+      box-shadow: 0 0 0 4px rgba(56, 189, 248, 0.2);
+    }
+
+    .title {
+      font-size: 1.9rem;
+      font-weight: 600;
+      letter-spacing: -0.03em;
+    }
+
+    .subtitle {
+      font-size: 0.95rem;
+      color: #9ca3af;
+      max-width: 520px;
+    }
+
+    .routes-grid {
+      display: grid;
+      grid-template-columns: minmax(0, 1fr);
+      gap: 1rem;
+    }
+
+    @media (min-width: 900px) {
+      .routes-grid {
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+      }
+    }
+
+    .route-card {
+      border-radius: 1rem;
+      padding: 1rem 1.1rem 1.1rem;
+      background: rgba(15, 23, 42, 0.92);
+      border: 1px solid var(--border-subtle);
+      box-shadow: 0 18px 55px rgba(15, 23, 42, 0.8);
+      display: flex;
+      flex-direction: column;
+      gap: 0.75rem;
+    }
+
+    .route-header {
+      display: flex;
+      align-items: center;
+      gap: 0.75rem;
+      font-family: var(--font-mono);
+      font-size: 0.85rem;
+      letter-spacing: 0.06em;
+      text-transform: uppercase;
+    }
+
+    .method {
+      padding: 0.15rem 0.55rem;
+      border-radius: 999px;
+      border: 1px solid rgba(148, 163, 184, 0.5);
+      background: rgba(15, 23, 42, 0.8);
+    }
+
+    .method-get {
+      border-color: rgba(34, 197, 94, 0.6);
+      color: #bbf7d0;
+      background: rgba(34, 197, 94, 0.08);
+    }
+
+    .method-post {
+      border-color: rgba(59, 130, 246, 0.6);
+      color: #bfdbfe;
+      background: rgba(59, 130, 246, 0.08);
+    }
+
+    .method-put {
+      border-color: rgba(234, 179, 8, 0.6);
+      color: #fef9c3;
+      background: rgba(234, 179, 8, 0.08);
+    }
+
+    .method-delete {
+      border-color: rgba(239, 68, 68, 0.6);
+      color: #fee2e2;
+      background: rgba(239, 68, 68, 0.08);
+    }
+
+    .method-patch {
+      border-color: rgba(168, 85, 247, 0.6);
+      color: #ede9fe;
+      background: rgba(168, 85, 247, 0.08);
+    }
+
+    .path {
+      padding: 0.1rem 0.65rem;
+      border-radius: 999px;
+      background: radial-gradient(circle at 0% 0%, #0f172a, #020617);
+      border: 1px solid rgba(148, 163, 184, 0.5);
+      color: #e5e7eb;
+    }
+
+    .route-meta {
+      display: flex;
+      flex-direction: column;
+      gap: 0.25rem;
+    }
+
+    .pill-group {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 0.25rem;
+    }
+
+    .pill {
+      font-family: var(--font-mono);
+      font-size: 0.7rem;
+      padding: 0.1rem 0.45rem;
+      border-radius: 999px;
+      border: 1px solid rgba(148, 163, 184, 0.4);
+      background: rgba(15, 23, 42, 0.9);
+      color: #9ca3af;
+    }
+
+    .pill-role {
+      border-color: rgba(52, 211, 153, 0.5);
+      color: #a7f3d0;
+    }
+
+    .pill-media {
+      border-color: rgba(56, 189, 248, 0.6);
+      color: #bae6fd;
+      background: rgba(15, 23, 42, 0.9);
+    }
+
+    .route-content {
+      display: flex;
+      flex-direction: column;
+      gap: 0.6rem;
+      margin-top: 0.2rem;
+    }
+
+    .block {
+      border-radius: 0.75rem;
+      border: 1px solid rgba(31, 41, 55, 0.9);
+      background: radial-gradient(circle at top left, #020617, #020617);
+      padding: 0.6rem 0.7rem 0.55rem;
+    }
+
+    .block-title {
+      font-family: var(--font-mono);
+      font-size: 0.65rem;
+      letter-spacing: 0.2em;
+      text-transform: uppercase;
+      color: #6b7280;
+      margin-bottom: 0.35rem;
+    }
+
+    table.fields {
+      width: 100%;
+      border-collapse: collapse;
+      font-size: 0.8rem;
+      font-family: var(--font-mono);
+    }
+
+    table.fields th {
+      text-align: left;
+      font-weight: 500;
+      color: #9ca3af;
+      padding-bottom: 0.2rem;
+    }
+
+    table.fields td {
+      padding: 0.12rem 0;
+    }
+
+    .field-name {
+      color: #e5e7eb;
+    }
+
+    .field-type {
+      color: #a5b4fc;
+    }
+
+    .field-badge {
+      font-size: 0.7rem;
+      padding: 0 0.4rem;
+      border-radius: 999px;
+      border: 1px solid rgba(148, 163, 184, 0.4);
+      color: #9ca3af;
+    }
+
+    .field-badge.required {
+      border-color: rgba(248, 113, 113, 0.6);
+      color: #fecaca;
+    }
+
+    .field-badge.optional {
+      border-color: rgba(59, 130, 246, 0.6);
+      color: #bfdbfe;
+    }
+
+    .field-status {
+      color: #f97316;
+    }
+
+    .field-error-code {
+      color: #fca5a5;
+    }
+  </style>
+</head>
+<body>
+  <div class="shell">
+    <header class="masthead">
+      <div class="brand">
+        <span class="brand-mark"></span>
+        <span>SCHEMAAPI · CONTRACT DOCS</span>
+      </div>
+      <h1 class="title">${escape(title)}</h1>
+      <p class="subtitle">
+        Contratos de API descritos directamente desde el runtime. Sin Swagger, sin
+        YAML. Solo SchemaApi como única fuente de verdad.
+      </p>
+    </header>
+    <main class="routes-grid">
+${routesHtml}
+    </main>
+  </div>
+</body>
+</html>`;
+}
+function renderDocs(docs, options) {
+    if (options.format === "json") {
+        return renderDocsJSON(docs);
+    }
+    if (options.format === "html") {
+        return renderDocsHTML(docs, options);
+    }
+    return renderDocsText(docs);
 }
 
+exports.SchemaApiError = SchemaApiError;
+exports.adapters = index;
+exports.buildErrorPayload = buildErrorPayload;
+exports.createClient = createClient;
 exports.createContract = createContract;
+exports.generateSDK = generateSDK;
+exports.renderDocs = renderDocs;
+exports.renderDocsHTML = renderDocsHTML;
+exports.renderDocsJSON = renderDocsJSON;
+exports.renderDocsText = renderDocsText;
 //# sourceMappingURL=schemaapi.cjs.js.map