@codexsploitx/schemaapi 1.0.5 → 1.0.6

package/dist/schemaapi.umd.js

@@ -1,19 +1,1728 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.SchemaApi = {}));
-})(this, (function (exports) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('zod')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'zod'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.SchemaApi = {}, global.zod));
+})(this, (function (exports, zod) { 'use strict';
 
-    function createContract(schema) {
+    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.umd.js.map