@theokit/http 0.5.3 → 0.6.0

package/dist/index.d.ts

@@ -1,8 +1,9 @@
 import { z } from 'zod';
-import { D as DiContainer, M as MiddlewareConsumerImpl } from './middleware-consumer-ljxK1fU_.js';
-export { a as MiddlewareConfigProxy, b as MiddlewareFn, N as NestMiddleware, R as ResolvedMiddleware, m as middlewareMatchesPath, r as resolveOrNew, c as runMiddleware } from './middleware-consumer-ljxK1fU_.js';
+import { D as DiContainer, M as MiddlewareConsumerImpl } from './middleware-consumer-DcaksawH.js';
+export { a as MiddlewareConfigProxy, b as MiddlewareFn, N as NestMiddleware, R as ResolvedMiddleware, m as middlewareMatchesPath, r as resolveOrNew, c as runMiddleware } from './middleware-consumer-DcaksawH.js';
 import { S as ServerHandle } from './types-CGthbcon.js';
 export { ReadinessCheck, TheoApp, TheoAppOptions } from './app.js';
+import * as ReactTypes from 'react';
 
 interface ControllerOptions {
     host?: string;
@@ -354,6 +355,63 @@ declare function joinPath(prefix: string, path: string): string;
  */
 declare function walkControllerMetadata(ControllerClass: Function): WalkResult[];
 
+/**
+ * SWC-powered module loader for controller files with parameter decorators.
+ *
+ * esbuild (used by tsx/Vite SSR) fundamentally cannot parse TypeScript
+ * parameter decorators (`@Body()`, `@Param()`, `@Query()`). This loader
+ * uses @swc/core to transform controller files with full decorator support
+ * (legacyDecorator + decoratorMetadata), then imports them via a temp .mjs
+ * file written in the SAME directory (preserving relative import resolution).
+ *
+ * Pattern: follows Next.js's approach (read tsconfig → configure SWC)
+ * but scoped to the http-decorators package, not the framework core.
+ *
+ * @see references/next.js/packages/next/src/build/swc/options.ts
+ */
+
+interface SwcCore {
+    transformSync: (src: string, opts: unknown) => {
+        code: string;
+    };
+}
+/**
+ * Transform TypeScript controller SOURCE (with parameter decorators) into
+ * ESM code, emitting the `design:paramtypes` / decorator metadata that esbuild
+ * cannot produce. Pure code→code — no file I/O, no module load — so it is
+ * reusable both by {@link loadControllerWithSwc} (which then temp-writes +
+ * imports) and by a build-tool transform hook that returns `{ code }` directly.
+ *
+ * The `@swc/core` loader is injectable (`loadSwc`) for testability; it defaults
+ * to the cached singleton.
+ *
+ * @throws HttpDecoratorsConfigError when @swc/core is unavailable.
+ */
+declare function transformControllerSource(source: string, filename: string, loadSwc?: () => Promise<SwcCore | null>): Promise<string>;
+/**
+ * Load a TypeScript controller file using @swc/core for decorator support.
+ *
+ * Strategy:
+ *   1. Read source .ts file
+ *   2. Transform via {@link transformControllerSource} (legacyDecorator + metadata)
+ *   3. Write temp .mjs in SAME directory (relative imports resolve correctly)
+ *   4. Dynamic import() the .mjs — transitive .ts imports go through
+ *      tsx/Vite's global hook (they don't have parameter decorators)
+ *   5. Cleanup temp file
+ */
+declare function loadControllerWithSwc(absoluteFilePath: string): Promise<Record<string, unknown>>;
+/**
+ * Scan a glob pattern for controller files and load them all via SWC.
+ * Returns an array of controller class constructors found.
+ */
+declare function loadControllersFromGlob(rootDir: string, pattern: string): Promise<Function[]>;
+/**
+ * Check if a function has @Controller metadata.
+ * Uses Symbol.for() global registry key — same Symbol instance across
+ * module boundaries (SWC-loaded controllers share the global registry).
+ */
+declare function isControllerClass(fn: Function): boolean;
+
 interface RouteRegistration {
     verb: HttpVerb;
     fullPath: string;
@@ -377,6 +435,25 @@ interface CreateDecoratorServerOptions {
     container?: DiContainer;
     configure?: (consumer: MiddlewareConsumerImpl) => void;
 }
+/**
+ * A pure Web-Standard controller handler: callable as `(request) => Response | null`
+ * plus a non-executing `matches(method, pathname)` route probe (so a host can gate
+ * — e.g. CSRF — before dispatch runs a handler).
+ */
+interface DecoratorHandler {
+    (request: Request): Promise<Response | null>;
+    /** True when a controller route owns `method` + `pathname` (no handler executed). */
+    matches(method: string, pathname: string): boolean;
+}
+/**
+ * Build a pure Web-Standard request handler from decorated controller classes,
+ * WITHOUT binding a network listener. Returns a {@link DecoratorHandler} whose
+ * call returns `null` when no controller route matched — the caller decides the
+ * miss (a standalone server answers 404; a host middleware falls through to its
+ * own routing). This is the reusable dispatch seam consumed by the framework's
+ * controller dispatch (#122) so it never re-implements match/bind/validate.
+ */
+declare function createDecoratorHandler(controllersOrOpts: Function[] | CreateDecoratorServerOptions): DecoratorHandler;
 declare function createDecoratorServer(controllersOrOpts: Function[] | CreateDecoratorServerOptions): ServerHandle;
 
 /**
@@ -998,10 +1075,10 @@ type InferResponse<D> = D extends {
     response: infer R;
 } ? R : unknown;
 interface TypedClient<M extends RouteMap> {
-    get<P extends string & keyof M>(path: P, opts?: {
+    get<P extends string>(path: P, opts?: {
         query?: Record<string, string>;
         headers?: Record<string, string>;
-    }): Promise<InferResponse<M[`GET ${P}`] extends never ? M[P] : M[`GET ${P}`]>>;
+    }): Promise<InferResponse<M[`GET ${P}`]>>;
     post<P extends string>(path: P, body?: InferBody<M[`POST ${P}`]>, opts?: {
         headers?: Record<string, string>;
     }): Promise<InferResponse<M[`POST ${P}`]>>;
@@ -1091,4 +1168,202 @@ declare function isSafePath(pathname: string): boolean;
  */
 declare function createStaticHandler(options?: StaticOptions): (request: Request) => Promise<Response | null>;
 
-export { All, type ArgumentsHost, BadGatewayException, BadRequestException, Body, CATCH_EXCEPTIONS, CONTROLLER_PREFIX, type CanActivate, Catch, ConflictException, Controller, type ControllerMeta, type ControllerOptions, Delete, DiContainer, type ExceptionFilter, type ExecutionContext, ForbiddenException, GatewayTimeoutException, Get, GoneException, Head, Header, Headers, HostParam, HttpCode, HttpDecoratorsConfigError, HttpException, type HttpExceptionOptions, HttpStatus, type HttpStatusCode, type HttpVerb, HttpVersionNotSupportedException, ImATeapotException, type Interceptor, InternalServerErrorException, Ip, type MetadataKey, MethodNotAllowedException, MiddlewareConsumerImpl, NotAcceptableException, NotFoundException, NotImplementedException, Options, Param, type ParamEntry, type ParamSource, Patch, PayloadTooLargeException, Post, PreconditionFailedException, Put, Query, ROUTE_HEADERS, ROUTE_METHODS, ROUTE_PARAMS, ROUTE_REDIRECT, ROUTE_STATUS, Redirect, type RedirectMeta, Reflector, Req, RequestTimeoutException, Res, type RouteDefinition, type RouteMap, type RouteMethodEntry, type RouteRegistration, ServiceUnavailableException, Session, SetMetadata, SkipThrottle, type StaticOptions, Throttle, type ThrottleOptions, TooManyRequestsException, type TypedClient, TypedClientError, USE_FILTERS, USE_GUARDS, USE_INTERCEPTORS, UnauthorizedException, UnprocessableEntityException, UnsupportedMediaTypeException, UseFilters, UseGuards, UseInterceptors, type WalkResult, contract, createDecorator, createDecoratorServer, createExecutionContext, createStaticHandler, createTypedClient, getMeta, getMimeType, getThrottleOptions, isSafePath, isThrottleSkipped, joinPath, registerControllers, resolveDtoSchema, runExceptionFilters, runInterceptors, setMeta, walkControllerMetadata };
+interface TheoRequestContext {
+    /** The raw Web Standard Request object. */
+    request: Request;
+    /** URL pathname (e.g., '/api/tasks'). */
+    pathname: string;
+    /** HTTP method (e.g., 'GET', 'POST'). */
+    method: string;
+    /** Route params extracted from URL (e.g., { id: '42' }). */
+    params: Record<string, string>;
+    /** Matched controller or agent class name (if resolved). */
+    handler?: string;
+    /** Request start time (ms). */
+    startedAt: number;
+}
+/**
+ * Get the current request context.
+ *
+ * @throws Error if called outside a request (e.g., at module load time).
+ *
+ * @example
+ * ```typescript
+ * import { getRequestContext } from '@theokit/http'
+ *
+ * class AuthGuard {
+ *   canActivate() {
+ *     const { request } = getRequestContext()
+ *     return request.headers.get('authorization') !== null
+ *   }
+ * }
+ * ```
+ */
+declare function getRequestContext(): TheoRequestContext;
+/**
+ * Try to get the current request context, or null if not in a request.
+ * Useful for code that may run both inside and outside requests.
+ */
+declare function tryGetRequestContext(): TheoRequestContext | null;
+
+/**
+ * Error digestion — converts any thrown value into a stable hash + context.
+ *
+ * Inspired by Next.js `create-error-handler.tsx`. Produces a deterministic
+ * digest ID suitable for logging and client-safe error references without
+ * leaking stack traces in production.
+ *
+ * Uses djb2 hash (sync, no crypto dependency) per ADR D3.
+ */
+interface ErrorContext {
+    route?: string;
+    phase?: 'guard' | 'interceptor' | 'handler' | 'filter' | 'agent';
+    source?: string;
+}
+interface DigestedError {
+    digest: string;
+    message: string;
+    status: number;
+    context: ErrorContext;
+    stack?: string;
+}
+/**
+ * Converts any thrown value into a structured {@link DigestedError}.
+ *
+ * - Sync (never async) — safe to call inside catch blocks.
+ * - Stack trace stripped when `process.env.NODE_ENV === 'production'`.
+ * - Preserves {@link HttpException} status codes.
+ * - Handles non-Error throws (string, number, object).
+ */
+declare function digestError(err: unknown, context?: ErrorContext): DigestedError;
+
+/**
+ * Component tree composition — recursive wrapping of file-convention
+ * components (layout, page, loading, error, not-found) into a React
+ * element tree with Suspense and error boundaries.
+ *
+ * Inspired by Next.js `create-component-tree.tsx`.
+ *
+ * React is loaded via dynamic `import('react')` because it is an
+ * optional peerDep of @theokit/http (EC-2).
+ */
+
+interface RouteTree {
+    layout?: ReactTypes.ComponentType<{
+        children: ReactTypes.ReactNode;
+    }>;
+    page?: ReactTypes.ComponentType;
+    loading?: ReactTypes.ComponentType;
+    error?: ReactTypes.ComponentType;
+    notFound?: ReactTypes.ComponentType;
+    children?: Record<string, RouteTree>;
+}
+/**
+ * Composes a {@link RouteTree} into a nested React element tree.
+ *
+ * Wrapping order (outermost → innermost):
+ *   layout → ErrorBoundary(error) → Suspense(loading) → page
+ *
+ * Returns `null` when no `page` component is found in the tree.
+ *
+ * @param tree - The route tree describing file conventions found.
+ * @returns A React element or `null`.
+ */
+declare function composeComponentTree(tree: RouteTree): Promise<ReactTypes.ReactElement | null>;
+
+/**
+ * Streaming SSR — renders a React element tree to a `ReadableStream<Uint8Array>`.
+ *
+ * Inspired by Next.js `stream-ops.ts`. Uses Web Standard `renderToReadableStream`
+ * (works on Node 18+, Bun, Deno). Falls back to `renderToString` wrapped in a
+ * ReadableStream when `renderToReadableStream` is not available (React 17 — EC-4).
+ *
+ * React is loaded via dynamic `import('react-dom/server')` because react-dom
+ * is an optional peerDep of @theokit/http (ADR D2).
+ */
+
+interface StreamRenderOptions {
+    /** React element to render */
+    root: ReactTypes.ReactElement;
+    /** Whether to wait for all Suspense to resolve (default: false — stream immediately) */
+    waitForAll?: boolean;
+}
+interface StreamRenderResult {
+    /** The HTML stream */
+    stream: ReadableStream<Uint8Array>;
+    /** Promise that resolves when all content has been flushed */
+    allReady: Promise<void>;
+}
+/**
+ * Renders a React element to a `ReadableStream<Uint8Array>` (Web Standard).
+ *
+ * 1. Tries `renderToReadableStream` first (React 18+ — Web Standard API).
+ * 2. Falls back to `renderToString` wrapped in a ReadableStream when
+ *    `renderToReadableStream` is not available (React 17 compat — EC-4).
+ * 3. Prepends `<!DOCTYPE html>` to the stream.
+ *
+ * **EC-7 — Streaming error handling:** In streaming mode, errors thrown inside
+ * Suspense boundaries are caught by React's streaming error handler and result
+ * in a client-side error boundary activation (the shell is already sent). In
+ * string mode (`renderToString`), errors throw synchronously before any bytes
+ * are sent, allowing a full 500 error page. Choose streaming when you want
+ * progressive rendering; choose string mode when you want atomic error handling.
+ */
+declare function renderToStream(options: StreamRenderOptions): Promise<StreamRenderResult>;
+/**
+ * Converts a {@link StreamRenderResult} into a Web Standard `Response`.
+ *
+ * Convenience wrapper for use in request handlers:
+ * ```ts
+ * const result = await renderToStream({ root: <App /> })
+ * return streamToResponse(result)
+ * ```
+ */
+declare function streamToResponse(result: StreamRenderResult): Response;
+
+interface RevalidationSignal {
+    kind: 'tag' | 'path';
+    value: string;
+    timestamp: number;
+}
+/**
+ * Signal that a cache tag should be revalidated.
+ *
+ * Safe to call from any request handler (controller, agent, action).
+ * Signals are accumulated per-request and consumed by the cache engine.
+ *
+ * @example
+ * ```typescript
+ * import { revalidateTag } from '@theokit/http'
+ *
+ * @Post()
+ * async createTask(@Body(schema) body) {
+ *   const task = await db.tasks.create(body)
+ *   revalidateTag('tasks')  // invalidate cached task lists
+ *   return task
+ * }
+ * ```
+ */
+declare function revalidateTag(tag: string): void;
+/**
+ * Signal that a cached path should be revalidated.
+ *
+ * @example
+ * ```typescript
+ * import { revalidatePath } from '@theokit/http'
+ *
+ * @Delete(':id')
+ * async removeTask(@Param('id') id: string) {
+ *   await db.tasks.delete(id)
+ *   revalidatePath('/api/tasks')
+ * }
+ * ```
+ */
+declare function revalidatePath(path: string): void;
+/**
+ * Get all revalidation signals collected during the current request.
+ * Called by the cache engine after the handler completes.
+ */
+declare function getRevalidationSignals(): RevalidationSignal[];
+
+export { All, type ArgumentsHost, BadGatewayException, BadRequestException, Body, CATCH_EXCEPTIONS, CONTROLLER_PREFIX, type CanActivate, Catch, ConflictException, Controller, type ControllerMeta, type ControllerOptions, type DecoratorHandler, Delete, DiContainer, type DigestedError, type ErrorContext, type ExceptionFilter, type ExecutionContext, ForbiddenException, GatewayTimeoutException, Get, GoneException, Head, Header, Headers, HostParam, HttpCode, HttpDecoratorsConfigError, HttpException, type HttpExceptionOptions, HttpStatus, type HttpStatusCode, type HttpVerb, HttpVersionNotSupportedException, ImATeapotException, type Interceptor, InternalServerErrorException, Ip, type MetadataKey, MethodNotAllowedException, MiddlewareConsumerImpl, NotAcceptableException, NotFoundException, NotImplementedException, Options, Param, type ParamEntry, type ParamSource, Patch, PayloadTooLargeException, Post, PreconditionFailedException, Put, Query, ROUTE_HEADERS, ROUTE_METHODS, ROUTE_PARAMS, ROUTE_REDIRECT, ROUTE_STATUS, Redirect, type RedirectMeta, Reflector, Req, RequestTimeoutException, Res, type RevalidationSignal, type RouteDefinition, type RouteMap, type RouteMethodEntry, type RouteRegistration, type RouteTree, ServiceUnavailableException, Session, SetMetadata, SkipThrottle, type StaticOptions, type StreamRenderOptions, type StreamRenderResult, type SwcCore, type TheoRequestContext, Throttle, type ThrottleOptions, TooManyRequestsException, type TypedClient, TypedClientError, USE_FILTERS, USE_GUARDS, USE_INTERCEPTORS, UnauthorizedException, UnprocessableEntityException, UnsupportedMediaTypeException, UseFilters, UseGuards, UseInterceptors, type WalkResult, composeComponentTree, contract, createDecorator, createDecoratorHandler, createDecoratorServer, createExecutionContext, createStaticHandler, createTypedClient, digestError, getMeta, getMimeType, getRequestContext, getRevalidationSignals, getThrottleOptions, isControllerClass, isSafePath, isThrottleSkipped, joinPath, loadControllerWithSwc, loadControllersFromGlob, registerControllers, renderToStream, resolveDtoSchema, revalidatePath, revalidateTag, runExceptionFilters, runInterceptors, setMeta, streamToResponse, transformControllerSource, tryGetRequestContext, walkControllerMetadata };

package/dist/index.js

@@ -2,29 +2,37 @@ import {
   TheoApp,
   createStaticHandler,
   getMimeType,
-  isSafePath
-} from "./chunk-H7V4WQAM.js";
+  getRequestContext,
+  isSafePath,
+  renderToStream,
+  streamToResponse,
+  tryGetRequestContext
+} from "./chunk-GQ2UH554.js";
 import {
   MiddlewareConsumerImpl,
+  isControllerClass,
+  loadControllerWithSwc,
+  loadControllersFromGlob,
   middlewareMatchesPath,
-  runMiddleware
-} from "./chunk-I2ADDC6C.js";
+  runMiddleware,
+  transformControllerSource
+} from "./chunk-RC4V75DI.js";
 import {
   HttpDecoratorsConfigError,
   createExecutionContext,
   joinPath,
   resolveDtoSchema,
   walkControllerMetadata
-} from "./chunk-5T6NAG62.js";
+} from "./chunk-QGB5YC4T.js";
 import {
   createNodeAdapter
-} from "./chunk-IHUNGY64.js";
+} from "./chunk-HLW7YKZE.js";
 import {
   runInterceptors
-} from "./chunk-UVV6THUP.js";
+} from "./chunk-ELCXHPAD.js";
 import {
   runExceptionFilters
-} from "./chunk-474GXFYG.js";
+} from "./chunk-6W4T4DPJ.js";
 import {
   BadGatewayException,
   BadRequestException,
@@ -61,13 +69,13 @@ import {
   UnsupportedMediaTypeException,
   getMeta,
   setMeta
-} from "./chunk-AVSB6444.js";
+} from "./chunk-3PGQVQWG.js";
 import {
   resolveOrNew
-} from "./chunk-XPFP4PQO.js";
+} from "./chunk-MQAJWR3K.js";
 import {
   __name
-} from "./chunk-Z56OUB3Z.js";
+} from "./chunk-7QVYU63E.js";
 
 // src/decorators/controller.ts
 function inferPrefix(className) {
@@ -415,7 +423,7 @@ __name(registerControllers, "registerControllers");
 
 // src/bridge/create-server.ts
 import "reflect-metadata";
-function createDecoratorServer(controllersOrOpts) {
+function createDecoratorHandler(controllersOrOpts) {
   const { controllers, container, configure } = Array.isArray(controllersOrOpts) ? {
     controllers: controllersOrOpts,
     container: void 0,
@@ -448,9 +456,25 @@ function createDecoratorServer(controllersOrOpts) {
     if (aP !== bP) return aP ? 1 : -1;
     return 0;
   });
-  const adapter = createNodeAdapter();
   const handler = /* @__PURE__ */ __name((request) => handleRequest(routes, request, container, middlewareEntries), "handler");
-  return adapter.createServer(handler);
+  handler.matches = (method, pathname) => findRoute(routes, method.toUpperCase(), pathname) !== null;
+  return handler;
+}
+__name(createDecoratorHandler, "createDecoratorHandler");
+function createDecoratorServer(controllersOrOpts) {
+  const handle = createDecoratorHandler(controllersOrOpts);
+  const adapter = createNodeAdapter();
+  return adapter.createServer(async (request) => {
+    const res = await handle(request);
+    if (res) return res;
+    const { pathname } = new URL(request.url);
+    return jsonResponse(404, {
+      error: {
+        code: "NOT_FOUND",
+        message: `No route for ${request.method.toUpperCase()} ${pathname}`
+      }
+    });
+  });
 }
 __name(createDecoratorServer, "createDecoratorServer");
 async function handleRequest(routes, request, container, middlewareEntries = []) {
@@ -458,14 +482,7 @@ async function handleRequest(routes, request, container, middlewareEntries = [])
   const method = request.method.toUpperCase();
   const pathname = url.pathname;
   const match = findRoute(routes, method, pathname);
-  if (!match) {
-    return jsonResponse(404, {
-      error: {
-        code: "NOT_FOUND",
-        message: `No route for ${method} ${pathname}`
-      }
-    });
-  }
+  if (!match) return null;
   const { walk, instance, params } = match;
   try {
     const mwResponse = await runMiddleware(middlewareEntries, request, pathname);
@@ -491,6 +508,7 @@ async function handleRequest(routes, request, container, middlewareEntries = [])
     }
     const handlerFn = instance[walk.propertyKey];
     const result = await runInterceptors(walk.interceptors, () => handlerFn.apply(instance, args), request, container);
+    if (result instanceof Response) return result;
     return buildResponse(result, walk, method);
   } catch (err) {
     return runExceptionFilters(err, walk.filters, request, container);
@@ -690,6 +708,152 @@ function contract(routes) {
   return routes;
 }
 __name(contract, "contract");
+
+// src/error-digest.ts
+function djb2(input) {
+  let hash = 5381;
+  for (let i = 0; i < input.length; i++) {
+    hash = (hash << 5) + hash + input.charCodeAt(i) | 0;
+  }
+  return (hash >>> 0).toString(16);
+}
+__name(djb2, "djb2");
+function digestError(err, context = {}) {
+  const message = extractMessage(err);
+  const status = extractStatus(err);
+  const rawStack = extractStack(err);
+  const digest = djb2(message);
+  const isProduction = process.env.NODE_ENV === "production";
+  return {
+    digest,
+    message,
+    status,
+    context,
+    ...rawStack && !isProduction ? {
+      stack: rawStack
+    } : {}
+  };
+}
+__name(digestError, "digestError");
+function extractMessage(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  if (typeof err === "string") {
+    return err;
+  }
+  if (typeof err === "number") {
+    return String(err);
+  }
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return "Unknown error";
+  }
+}
+__name(extractMessage, "extractMessage");
+function extractStatus(err) {
+  if (err instanceof HttpException) {
+    return err.statusCode;
+  }
+  return 500;
+}
+__name(extractStatus, "extractStatus");
+function extractStack(err) {
+  if (err instanceof Error) {
+    return err.stack;
+  }
+  return void 0;
+}
+__name(extractStack, "extractStack");
+
+// src/component-tree.ts
+function createErrorBoundary(React, FallbackComponent) {
+  return class ErrorBoundary extends React.Component {
+    static {
+      __name(this, "ErrorBoundary");
+    }
+    constructor(props) {
+      super(props);
+      this.state = {
+        hasError: false
+      };
+    }
+    static getDerivedStateFromError() {
+      return {
+        hasError: true
+      };
+    }
+    render() {
+      if (this.state.hasError) {
+        return React.createElement(FallbackComponent);
+      }
+      return React.createElement(React.Fragment, null, this.props.children);
+    }
+  };
+}
+__name(createErrorBoundary, "createErrorBoundary");
+async function composeComponentTree(tree) {
+  const React = await import("react");
+  return composeNode(React, tree);
+}
+__name(composeComponentTree, "composeComponentTree");
+function composeNode(React, node) {
+  const { layout: Layout, page: Page, loading: Loading, error: ErrorFallback } = node;
+  if (!Page) {
+    return null;
+  }
+  let element = React.createElement(Page);
+  if (Loading) {
+    element = React.createElement(React.Suspense, {
+      fallback: React.createElement(Loading)
+    }, element);
+  }
+  if (ErrorFallback) {
+    const Boundary = createErrorBoundary(React, ErrorFallback);
+    element = React.createElement(Boundary, null, element);
+  }
+  if (Layout) {
+    element = React.createElement(Layout, null, element);
+  }
+  return element;
+}
+__name(composeNode, "composeNode");
+
+// src/cache-signal.ts
+function revalidateTag(tag) {
+  collectSignal({
+    kind: "tag",
+    value: tag,
+    timestamp: Date.now()
+  });
+}
+__name(revalidateTag, "revalidateTag");
+function revalidatePath(path) {
+  collectSignal({
+    kind: "path",
+    value: path,
+    timestamp: Date.now()
+  });
+}
+__name(revalidatePath, "revalidatePath");
+function getRevalidationSignals() {
+  const ctx = tryGetRequestContext();
+  if (!ctx) return [];
+  return ctx._revalidationSignals ?? [];
+}
+__name(getRevalidationSignals, "getRevalidationSignals");
+function collectSignal(signal) {
+  const ctx = tryGetRequestContext();
+  if (!ctx) {
+    console.warn("[theokit] revalidateTag/revalidatePath called outside a request context. Signal ignored.");
+    return;
+  }
+  const extended = ctx;
+  extended._revalidationSignals ??= [];
+  extended._revalidationSignals.push(signal);
+}
+__name(collectSignal, "collectSignal");
 export {
   All,
   BadGatewayException,
@@ -757,26 +921,40 @@ export {
   UseFilters,
   UseGuards,
   UseInterceptors,
+  composeComponentTree,
   contract,
   createDecorator,
+  createDecoratorHandler,
   createDecoratorServer,
   createExecutionContext,
   createStaticHandler,
   createTypedClient,
+  digestError,
   getMeta,
   getMimeType,
+  getRequestContext,
+  getRevalidationSignals,
   getThrottleOptions,
+  isControllerClass,
   isSafePath,
   isThrottleSkipped,
   joinPath,
+  loadControllerWithSwc,
+  loadControllersFromGlob,
   middlewareMatchesPath,
   registerControllers,
+  renderToStream,
   resolveDtoSchema,
   resolveOrNew,
+  revalidatePath,
+  revalidateTag,
   runExceptionFilters,
   runInterceptors,
   runMiddleware,
   setMeta,
+  streamToResponse,
+  transformControllerSource,
+  tryGetRequestContext,
   walkControllerMetadata
 };
 //# sourceMappingURL=index.js.map