@daloyjs/core 1.0.0-beta.4 → 1.0.0-beta.6

package/dist/mcp.js

@@ -0,0 +1,419 @@
+/**
+ * Latest MCP protocol version DaloyJS negotiates by default.
+ *
+ * @see https://modelcontextprotocol.io/specification/2025-11-25
+ * @since 1.0.0
+ */
+export const MCP_PROTOCOL_VERSION = "2025-11-25";
+/**
+ * Protocol revisions accepted by {@link createMcpHandler} unless the caller
+ * provides an explicit `protocolVersions` list.
+ *
+ * @since 1.0.0
+ */
+export const MCP_PROTOCOL_VERSIONS = Object.freeze([
+    "2024-11-05",
+    "2025-03-26",
+    "2025-06-18",
+    "2025-11-25",
+]);
+/**
+ * Default maximum accepted JSON-RPC request body for a DaloyJS MCP endpoint.
+ * The cap is intentionally small because MCP calls should carry parameters,
+ * not bulk uploads. Raise it per endpoint when a real tool needs larger input.
+ *
+ * @since 1.0.0
+ */
+export const MCP_DEFAULT_MAX_BODY_BYTES = 1 << 18;
+const PARSE_ERROR = -32700;
+const INVALID_REQUEST = -32600;
+const METHOD_NOT_FOUND = -32601;
+const INVALID_PARAMS = -32602;
+const INTERNAL_ERROR = -32603;
+const MCP_JSON_RESPONSE_SCHEMA = {
+    "~standard": {
+        version: 1,
+        vendor: "daloyjs",
+        validate: (value) => ({ value }),
+    },
+};
+/**
+ * Caller-correctable MCP tool/resource/prompt error.
+ *
+ * Throw this when the model supplied bad arguments, referenced a missing
+ * domain object, or otherwise made a recoverable call. Tool errors become
+ * `{ isError: true }` tool results; resource and prompt errors become
+ * JSON-RPC invalid-params errors. Unexpected errors are treated as internal
+ * server failures and are redacted in production.
+ *
+ * @since 1.0.0
+ */
+export class McpToolError extends Error {
+    /**
+     * Create a recoverable MCP handler error.
+     *
+     * @param message - Safe, caller-visible explanation.
+     */
+    constructor(message) {
+        super(message);
+        this.name = "McpToolError";
+    }
+}
+function isJsonRpcId(value) {
+    return value === null || typeof value === "string" || typeof value === "number";
+}
+function jsonResponse(body, status, extraHeaders) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: {
+            "content-type": "application/json; charset=utf-8",
+            "cache-control": "no-store",
+            ...(extraHeaders ?? {}),
+        },
+    });
+}
+function rpcResult(id, result, extraHeaders) {
+    return jsonResponse({ jsonrpc: "2.0", id, result }, 200, extraHeaders);
+}
+function rpcError(id, code, message, data, status, extraHeaders) {
+    const error = { code, message };
+    if (data !== undefined)
+        error.data = data;
+    return jsonResponse({ jsonrpc: "2.0", id, error }, status, extraHeaders);
+}
+function safeInternalErrorData(error, expose) {
+    if (!expose)
+        return undefined;
+    return { detail: error instanceof Error ? error.message : String(error) };
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function publicTool(tool) {
+    const { handler: _handler, ...rest } = tool;
+    return rest;
+}
+function publicResource(resource) {
+    const { read: _read, ...rest } = resource;
+    return rest;
+}
+function publicPrompt(prompt) {
+    const { get: _get, ...rest } = prompt;
+    return rest;
+}
+function normalizeToolResult(value) {
+    return typeof value === "string" ? { content: [{ type: "text", text: value }] } : value;
+}
+function selectedProtocolVersion(requested, supported, preferred) {
+    return supported.has(requested) ? requested : preferred;
+}
+/**
+ * Create a dependency-free MCP Streamable HTTP endpoint handler.
+ *
+ * The handler implements the server side of MCP over one HTTP endpoint:
+ * `initialize`, `ping`, `tools/list`, `tools/call`, `resources/list`,
+ * `resources/read`, `prompts/list`, and `prompts/get`. It accepts JSON-RPC
+ * requests over `POST`, acknowledges notifications with `202`, validates the
+ * `MCP-Protocol-Version` header, bounds request bodies, and returns JSON-RPC
+ * errors for malformed input.
+ *
+ * It intentionally does not spawn stdio servers, manage OAuth metadata, keep
+ * durable sessions, or open server-initiated SSE streams. Use DaloyJS
+ * middleware for authentication and authorization, and run this on a dedicated
+ * Daloy app when your MCP server has a different trust boundary than your REST
+ * API.
+ *
+ * @param options - Server identity, capabilities, limits, and response headers.
+ * @returns A Fetch-compatible request handler suitable for {@link mcpRoutes}
+ *   or for direct use in any web-standard runtime.
+ *
+ * @example
+ * ```ts
+ * const mcp = createMcpHandler({
+ *   serverInfo: { name: "inventory-mcp", version: "1.0.0" },
+ *   tools: [
+ *     {
+ *       name: "inventory_lookup",
+ *       description: "Look up inventory by SKU.",
+ *       inputSchema: {
+ *         type: "object",
+ *         properties: { sku: { type: "string" } },
+ *         required: ["sku"],
+ *         additionalProperties: false,
+ *       },
+ *       handler: async ({ sku }) => `SKU ${sku} has 42 units.`,
+ *     },
+ *   ],
+ * });
+ * ```
+ *
+ * @since 1.0.0
+ */
+export function createMcpHandler(options) {
+    if (options.serverInfo.name.trim().length === 0) {
+        throw new TypeError("MCP serverInfo.name is required.");
+    }
+    if (options.serverInfo.version.trim().length === 0) {
+        throw new TypeError("MCP serverInfo.version is required.");
+    }
+    const protocolVersions = options.protocolVersions ?? MCP_PROTOCOL_VERSIONS;
+    if (protocolVersions.length === 0) {
+        throw new TypeError("MCP protocolVersions must contain at least one version.");
+    }
+    const preferred = options.preferredProtocolVersion ?? MCP_PROTOCOL_VERSION;
+    const supported = new Set(protocolVersions);
+    if (!supported.has(preferred)) {
+        throw new TypeError("MCP preferredProtocolVersion must be listed in protocolVersions.");
+    }
+    const maxBodyBytes = options.maxBodyBytes ?? MCP_DEFAULT_MAX_BODY_BYTES;
+    if (!Number.isSafeInteger(maxBodyBytes) || maxBodyBytes < 1) {
+        throw new TypeError("MCP maxBodyBytes must be a positive safe integer.");
+    }
+    const tools = options.tools ?? [];
+    const resources = options.resources ?? [];
+    const prompts = options.prompts ?? [];
+    const toolMap = new Map(tools.map((tool) => [tool.name, tool]));
+    const resourceMap = new Map(resources.map((resource) => [resource.uri, resource]));
+    const promptMap = new Map(prompts.map((prompt) => [prompt.name, prompt]));
+    if (toolMap.size !== tools.length)
+        throw new TypeError("MCP tool names must be unique.");
+    if (resourceMap.size !== resources.length)
+        throw new TypeError("MCP resource URIs must be unique.");
+    if (promptMap.size !== prompts.length)
+        throw new TypeError("MCP prompt names must be unique.");
+    const exposeInternalErrors = options.exposeInternalErrors ??
+        (typeof process === "object" && process.env?.NODE_ENV !== "production");
+    const headers = options.headers;
+    async function handleRpcRequest(message, request) {
+        const id = (message.id ?? null);
+        const method = message.method;
+        const params = asRecord(message.params);
+        const protocolVersion = selectedProtocolVersion(typeof params.protocolVersion === "string"
+            ? params.protocolVersion
+            : (request.headers.get("mcp-protocol-version") ?? ""), supported, preferred);
+        const ctx = { request, protocolVersion, id, method };
+        switch (method) {
+            case "initialize":
+                return rpcResult(id, {
+                    protocolVersion,
+                    capabilities: {
+                        ...(tools.length > 0 ? { tools: {} } : {}),
+                        ...(resources.length > 0 ? { resources: {} } : {}),
+                        ...(prompts.length > 0 ? { prompts: {} } : {}),
+                    },
+                    serverInfo: options.serverInfo,
+                    ...(options.instructions ? { instructions: options.instructions } : {}),
+                }, headers);
+            case "ping":
+                return rpcResult(id, {}, headers);
+            case "tools/list":
+                return rpcResult(id, { tools: tools.map(publicTool) }, headers);
+            case "tools/call": {
+                const name = typeof params.name === "string" ? params.name : "";
+                const tool = toolMap.get(name);
+                if (!tool) {
+                    return rpcError(id, INVALID_PARAMS, `Unknown tool: ${name || "<missing>"}`, undefined, 200, headers);
+                }
+                try {
+                    const result = await tool.handler(asRecord(params.arguments), ctx);
+                    return rpcResult(id, normalizeToolResult(result), headers);
+                }
+                catch (error) {
+                    if (error instanceof McpToolError) {
+                        return rpcResult(id, { content: [{ type: "text", text: error.message }], isError: true }, headers);
+                    }
+                    return rpcError(id, INTERNAL_ERROR, "Tool execution failed.", safeInternalErrorData(error, exposeInternalErrors), 200, headers);
+                }
+            }
+            case "resources/list":
+                return rpcResult(id, { resources: resources.map(publicResource) }, headers);
+            case "resources/read": {
+                const uri = typeof params.uri === "string" ? params.uri : "";
+                const resource = resourceMap.get(uri);
+                if (!resource) {
+                    return rpcError(id, INVALID_PARAMS, `Unknown resource: ${uri || "<missing>"}`, undefined, 200, headers);
+                }
+                try {
+                    const read = await resource.read(ctx);
+                    return rpcResult(id, { contents: Array.isArray(read) ? read : [read] }, headers);
+                }
+                catch (error) {
+                    const message = error instanceof McpToolError ? error.message : "Resource read failed.";
+                    const data = error instanceof McpToolError
+                        ? undefined
+                        : safeInternalErrorData(error, exposeInternalErrors);
+                    return rpcError(id, error instanceof McpToolError ? INVALID_PARAMS : INTERNAL_ERROR, message, data, 200, headers);
+                }
+            }
+            case "prompts/list":
+                return rpcResult(id, { prompts: prompts.map(publicPrompt) }, headers);
+            case "prompts/get": {
+                const name = typeof params.name === "string" ? params.name : "";
+                const prompt = promptMap.get(name);
+                if (!prompt) {
+                    return rpcError(id, INVALID_PARAMS, `Unknown prompt: ${name || "<missing>"}`, undefined, 200, headers);
+                }
+                try {
+                    return rpcResult(id, await prompt.get(asRecord(params.arguments), ctx), headers);
+                }
+                catch (error) {
+                    const message = error instanceof McpToolError ? error.message : "Prompt rendering failed.";
+                    const data = error instanceof McpToolError
+                        ? undefined
+                        : safeInternalErrorData(error, exposeInternalErrors);
+                    return rpcError(id, error instanceof McpToolError ? INVALID_PARAMS : INTERNAL_ERROR, message, data, 200, headers);
+                }
+            }
+            default:
+                return rpcError(id, METHOD_NOT_FOUND, `Method not found: ${method}`, undefined, 200, headers);
+        }
+    }
+    return async function handleMcpRequest(request) {
+        if (request.method === "OPTIONS") {
+            return new Response(null, {
+                status: 204,
+                headers: { allow: "GET, POST, OPTIONS", ...(headers ?? {}) },
+            });
+        }
+        if (request.method === "GET") {
+            return jsonResponse({
+                transport: "streamable-http",
+                protocolVersions,
+                capabilities: {
+                    tools: tools.map((tool) => tool.name),
+                    resources: resources.map((resource) => resource.uri),
+                    prompts: prompts.map((prompt) => prompt.name),
+                },
+                hint: "Send JSON-RPC 2.0 over HTTP POST to this endpoint.",
+            }, 405, { allow: "POST, OPTIONS", ...(headers ?? {}) });
+        }
+        if (request.method !== "POST") {
+            return jsonResponse({ error: "MCP Streamable HTTP endpoints accept POST requests." }, 405, {
+                allow: "POST, OPTIONS",
+                ...(headers ?? {}),
+            });
+        }
+        const contentType = request.headers.get("content-type") ?? "";
+        if (!contentType.toLowerCase().includes("application/json")) {
+            return rpcError(null, INVALID_REQUEST, "MCP POST requests must use application/json.", undefined, 415, headers);
+        }
+        const protocolHeader = request.headers.get("mcp-protocol-version");
+        if (protocolHeader && !supported.has(protocolHeader)) {
+            return rpcError(null, INVALID_REQUEST, `Unsupported MCP-Protocol-Version: ${protocolHeader}`, { supported: protocolVersions }, 400, headers);
+        }
+        const declaredLength = Number(request.headers.get("content-length") ?? "");
+        if (Number.isFinite(declaredLength) && declaredLength > maxBodyBytes) {
+            return rpcError(null, INVALID_REQUEST, "Request body too large.", undefined, 413, headers);
+        }
+        const body = await request.arrayBuffer();
+        if (body.byteLength > maxBodyBytes) {
+            return rpcError(null, INVALID_REQUEST, "Request body too large.", undefined, 413, headers);
+        }
+        let raw;
+        try {
+            raw = new TextDecoder("utf-8", { fatal: true }).decode(body);
+        }
+        catch {
+            return rpcError(null, PARSE_ERROR, "Request body must be valid UTF-8.", undefined, 400, headers);
+        }
+        let message;
+        try {
+            message = JSON.parse(raw);
+        }
+        catch {
+            return rpcError(null, PARSE_ERROR, "Invalid JSON in request body.", undefined, 400, headers);
+        }
+        if (Array.isArray(message)) {
+            return rpcError(null, INVALID_REQUEST, "JSON-RPC batch requests are not supported.", undefined, 400, headers);
+        }
+        if (!message || typeof message !== "object" || message.jsonrpc !== "2.0") {
+            return rpcError(null, INVALID_REQUEST, "Request must be a JSON-RPC 2.0 message.", undefined, 400, headers);
+        }
+        if (message.id !== undefined && !isJsonRpcId(message.id)) {
+            return rpcError(null, INVALID_REQUEST, "JSON-RPC id must be a string, number, or null.", undefined, 400, headers);
+        }
+        if (message.method === undefined) {
+            if (!("result" in message) && !("error" in message)) {
+                return rpcError(null, INVALID_REQUEST, "JSON-RPC message is missing `method`, `result`, or `error`.", undefined, 400, headers);
+            }
+            return new Response(null, { status: 202, headers });
+        }
+        if (typeof message.method !== "string") {
+            return rpcError(null, INVALID_REQUEST, "JSON-RPC method must be a string.", undefined, 400, headers);
+        }
+        if (message.id === undefined) {
+            return new Response(null, { status: 202, headers });
+        }
+        try {
+            return await handleRpcRequest(message, request);
+        }
+        catch (error) {
+            return rpcError(message.id, INTERNAL_ERROR, "Internal server error.", safeInternalErrorData(error, exposeInternalErrors), 200, headers);
+        }
+    };
+}
+/**
+ * Build the Daloy route definitions for a Streamable HTTP MCP endpoint.
+ *
+ * Register each returned route on the Daloy app that should host MCP. A
+ * separate app is often the cleanest production shape: the REST API can keep
+ * its public contract and auth policy, while the MCP server can use its own
+ * bearer token, rate limit, network allowlist, and tool set.
+ *
+ * @param path - Public MCP endpoint path, usually `"/mcp"`.
+ * @param handler - Handler returned by {@link createMcpHandler}.
+ * @returns Route definitions for `POST`, `GET`, and `OPTIONS` on the same
+ *   path. `POST` is the actual MCP transport; `GET` gives a human-readable
+ *   405 hint because this helper does not open server-initiated SSE streams;
+ *   `OPTIONS` supports preflight when CORS middleware is installed.
+ *
+ * @example
+ * ```ts
+ * const app = new App();
+ * const mcp = createMcpHandler({ serverInfo, tools });
+ *
+ * for (const route of mcpRoutes("/mcp", mcp)) {
+ *   app.route(route);
+ * }
+ * ```
+ *
+ * @since 1.0.0
+ */
+export function mcpRoutes(path, handler) {
+    const responses = {
+        200: { description: "MCP JSON-RPC response", body: MCP_JSON_RESPONSE_SCHEMA },
+        202: { description: "MCP notification accepted", body: MCP_JSON_RESPONSE_SCHEMA },
+        204: { description: "CORS preflight accepted" },
+        400: { description: "Invalid MCP request" },
+        405: { description: "Unsupported MCP transport method" },
+        413: { description: "MCP request body too large" },
+    };
+    return [
+        {
+            method: "POST",
+            path,
+            operationId: "mcpPost",
+            summary: "MCP Streamable HTTP endpoint",
+            responses,
+            handler: ({ request }) => handler(request),
+        },
+        {
+            method: "GET",
+            path,
+            operationId: "mcpGet",
+            summary: "MCP Streamable HTTP discovery hint",
+            responses,
+            handler: ({ request }) => handler(request),
+        },
+        {
+            method: "OPTIONS",
+            path,
+            operationId: "mcpOptions",
+            summary: "MCP Streamable HTTP preflight",
+            responses,
+            handler: ({ request }) => handler(request),
+        },
+    ];
+}

package/dist/sbom.cdx.json

@@ -1,15 +1,15 @@
 {
   "bomFormat": "CycloneDX",
   "specVersion": "1.5",
-  "serialNumber": "urn:uuid:609085f8-6098-51c0-9dce-7717eb9fb590",
+  "serialNumber": "urn:uuid:a88e3a69-b278-5771-a67e-40fb774e004e",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-06-26T13:41:51.513Z",
+    "timestamp": "2026-07-01T22:47:12.881Z",
     "tools": [
       {
         "vendor": "DaloyJS",
         "name": "daloy-generate-sbom",
-        "version": "1.0.0-beta.4"
+        "version": "1.0.0-beta.6"
       }
     ],
     "authors": [
@@ -19,11 +19,11 @@
     ],
     "component": {
       "type": "library",
-      "bom-ref": "pkg:npm/@daloyjs/core@1.0.0-beta.4",
+      "bom-ref": "pkg:npm/@daloyjs/core@1.0.0-beta.6",
       "name": "@daloyjs/core",
-      "version": "1.0.0-beta.4",
+      "version": "1.0.0-beta.6",
       "description": "DaloyJS is a runtime-portable, contract-first TypeScript web framework with built-in OpenAPI (Hey API), typed client generation, large-scale maintainability, and security-first defaults. Hono-grade portability, Elysia-grade DX, FastAPI-grade docs, Fastify-grade ops — distributed via pnpm.",
-      "purl": "pkg:npm/@daloyjs/core@1.0.0-beta.4",
+      "purl": "pkg:npm/@daloyjs/core@1.0.0-beta.6",
       "licenses": [
         {
           "license": {
@@ -46,9 +46,9 @@
         }
       ],
       "swid": {
-        "tagId": "swidtag--daloyjs-core-1.0.0-beta.4",
+        "tagId": "swidtag--daloyjs-core-1.0.0-beta.6",
         "name": "@daloyjs/core",
-        "version": "1.0.0-beta.4",
+        "version": "1.0.0-beta.6",
         "tagVersion": 0,
         "patch": false
       }
@@ -57,7 +57,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "pkg:npm/@daloyjs/core@1.0.0-beta.4",
+      "ref": "pkg:npm/@daloyjs/core@1.0.0-beta.6",
       "dependsOn": []
     }
   ]

package/dist/sbom.spdx.json

@@ -2,10 +2,10 @@
   "spdxVersion": "SPDX-2.3",
   "dataLicense": "CC0-1.0",
   "SPDXID": "SPDXRef-DOCUMENT",
-  "name": "@daloyjs/core-1.0.0-beta.4",
-  "documentNamespace": "https://github.com/daloyjs/daloy/sbom/@daloyjs/core-1.0.0-beta.4-609085f8-6098-51c0-9dce-7717eb9fb590",
+  "name": "@daloyjs/core-1.0.0-beta.6",
+  "documentNamespace": "https://github.com/daloyjs/daloy/sbom/@daloyjs/core-1.0.0-beta.6-a88e3a69-b278-5771-a67e-40fb774e004e",
   "creationInfo": {
-    "created": "2026-06-26T13:41:51.513Z",
+    "created": "2026-07-01T22:47:12.881Z",
     "creators": [
       "Tool: daloy-generate-sbom",
       "Organization: DaloyJS"
@@ -16,7 +16,7 @@
     {
       "SPDXID": "SPDXRef-Package--daloyjs-core",
       "name": "@daloyjs/core",
-      "versionInfo": "1.0.0-beta.4",
+      "versionInfo": "1.0.0-beta.6",
       "downloadLocation": "https://github.com/daloyjs/daloy",
       "filesAnalyzed": false,
       "licenseConcluded": "MIT",
@@ -27,7 +27,7 @@
         {
           "referenceCategory": "PACKAGE-MANAGER",
           "referenceType": "purl",
-          "referenceLocator": "pkg:npm/@daloyjs/core@1.0.0-beta.4"
+          "referenceLocator": "pkg:npm/@daloyjs/core@1.0.0-beta.6"
         }
       ]
     }

package/dist/tenancy.d.ts

@@ -5,9 +5,9 @@
  * once per request, validates and normalizes it, and exposes it on
  * `ctx.state.tenant` for handlers and downstream middleware. It is the
  * single source of truth for "who is this request for" so the per-tenant
- * isolation knobs on the rest of the framework (`rateLimit` `keyGenerator`,
- * `concurrencyLimit` / `idempotency` / `responseCache` `scope`) can all key
- * off the same resolved value via {@link tenantScope}.
+ * isolation knobs on the rest of the framework (`rateLimit` /
+ * `responseCache` `keyGenerator`, `concurrencyLimit` / `idempotency` `scope`)
+ * can all key off the same resolved value via {@link tenantScope}.
  *
  * Secure-by-default posture:
  *
@@ -227,10 +227,19 @@ export interface TenantScopeOptions {
  * or poison another tenant's:
  *
  * ```ts
- * rateLimit({ windowMs: 60_000, max: 100, keyGenerator: tenantScope() });
- * concurrencyLimit({ maxConcurrent: 20, scope: tenantScope() });
- * idempotency({ scope: tenantScope() });    // CWE-524 cross-tenant cache defense
- * responseCache({ ttlMs: 30_000, scope: tenantScope() });
+ * const scope = tenantScope();
+ * rateLimit({ windowMs: 60_000, max: 100, keyGenerator: scope });
+ * concurrencyLimit({ maxConcurrent: 20, scope });
+ * idempotency({ scope });    // CWE-524 cross-tenant cache defense
+ * // responseCache's keyGenerator REPLACES the whole key and it takes
+ * // ttlSeconds, so fold the tenant in alongside the path yourself:
+ * responseCache({
+ *   ttlSeconds: 30,
+ *   keyGenerator: (ctx) => {
+ *     const u = new URL(ctx.request.url);
+ *     return `${scope(ctx)}:${ctx.request.method} ${u.pathname}${u.search}`;
+ *   },
+ * });
  * ```
  *
  * The `tenant:` prefix keeps these keys from colliding with other key spaces

package/dist/tenancy.js

@@ -5,9 +5,9 @@
  * once per request, validates and normalizes it, and exposes it on
  * `ctx.state.tenant` for handlers and downstream middleware. It is the
  * single source of truth for "who is this request for" so the per-tenant
- * isolation knobs on the rest of the framework (`rateLimit` `keyGenerator`,
- * `concurrencyLimit` / `idempotency` / `responseCache` `scope`) can all key
- * off the same resolved value via {@link tenantScope}.
+ * isolation knobs on the rest of the framework (`rateLimit` /
+ * `responseCache` `keyGenerator`, `concurrencyLimit` / `idempotency` `scope`)
+ * can all key off the same resolved value via {@link tenantScope}.
  *
  * Secure-by-default posture:
  *
@@ -270,10 +270,19 @@ export function tenancy(opts) {
  * or poison another tenant's:
  *
  * ```ts
- * rateLimit({ windowMs: 60_000, max: 100, keyGenerator: tenantScope() });
- * concurrencyLimit({ maxConcurrent: 20, scope: tenantScope() });
- * idempotency({ scope: tenantScope() });    // CWE-524 cross-tenant cache defense
- * responseCache({ ttlMs: 30_000, scope: tenantScope() });
+ * const scope = tenantScope();
+ * rateLimit({ windowMs: 60_000, max: 100, keyGenerator: scope });
+ * concurrencyLimit({ maxConcurrent: 20, scope });
+ * idempotency({ scope });    // CWE-524 cross-tenant cache defense
+ * // responseCache's keyGenerator REPLACES the whole key and it takes
+ * // ttlSeconds, so fold the tenant in alongside the path yourself:
+ * responseCache({
+ *   ttlSeconds: 30,
+ *   keyGenerator: (ctx) => {
+ *     const u = new URL(ctx.request.url);
+ *     return `${scope(ctx)}:${ctx.request.method} ${u.pathname}${u.search}`;
+ *   },
+ * });
  * ```
  *
  * The `tenant:` prefix keeps these keys from colliding with other key spaces

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daloyjs/core",
-  "version": "1.0.0-beta.4",
+  "version": "1.0.0-beta.6",
   "description": "DaloyJS is a runtime-portable, contract-first TypeScript web framework with built-in OpenAPI (Hey API), typed client generation, large-scale maintainability, and security-first defaults. Hono-grade portability, Elysia-grade DX, FastAPI-grade docs, Fastify-grade ops — distributed via pnpm.",
   "type": "module",
   "publishConfig": {
@@ -20,6 +20,7 @@
     "framework",
     "http",
     "openapi",
+    "mcp",
     "hey-api",
     "contract-first",
     "typescript",
@@ -37,7 +38,7 @@
     "daloy": "bin/daloy.mjs"
   },
   "engines": {
-    "node": ">=24.0.0",
+    "node": "^24.0.0 || >=26.0.0",
     "pnpm": ">=11.0.0"
   },
   "exports": {
@@ -85,6 +86,10 @@
       "types": "./dist/openapi-diff.d.ts",
       "import": "./dist/openapi-diff.js"
     },
+    "./mcp": {
+      "types": "./dist/mcp.d.ts",
+      "import": "./dist/mcp.js"
+    },
     "./asyncapi": {
       "types": "./dist/asyncapi.d.ts",
       "import": "./dist/asyncapi.js"
@@ -227,9 +232,9 @@
     }
   },
   "devDependencies": {
-    "@hey-api/openapi-ts": "^0.97.1",
-    "@types/node": "^25.7.0",
-    "fast-check": "^3.23.2",
+    "@hey-api/openapi-ts": "^0.99.0",
+    "@types/node": "^26.0.1",
+    "fast-check": "^4.8.0",
     "prettier": "^3.8.3",
     "tsx": "^4.22.3",
     "typescript": "^6.0.3",
@@ -240,6 +245,7 @@
     "dev": "tsc -w -p tsconfig.json",
     "example": "node --import tsx examples/basic.ts",
     "bench": "node --import tsx bench/router.bench.ts",
+    "bench:serverless": "node --import tsx bench/serverless-cold-path.bench.ts",
     "test": "node --import tsx --test tests/**/*.test.ts",
     "test:red-team": "node --import tsx --test tests/red-team-attacks.test.ts tests/red-team-attacks-2.test.ts tests/red-team-attacks-3.test.ts tests/red-team-attacks-4.test.ts tests/red-team-attacks-5.test.ts tests/red-team-attacks-6.test.ts tests/red-team-attacks-7.test.ts tests/red-team-attacks-8.test.ts tests/red-team-attacks-9.test.ts tests/red-team-attacks-10.test.ts",
     "red-team:live": "node --import tsx red-team-live/run.ts",