@rangojs/router 0.0.0-experimental.7 → 0.0.0-experimental.8ff1c5d

package/dist/vite/index.js

@@ -719,7 +719,7 @@ import { resolve } from "node:path";
 // package.json
 var package_default = {
   name: "@rangojs/router",
-  version: "0.0.0-experimental.7",
+  version: "0.0.0-experimental.8ff1c5d",
   type: "module",
   description: "Django-inspired RSC router with composable URL patterns",
   author: "Ivo Todorov",
@@ -821,15 +821,6 @@ var package_default = {
     "./build": {
       types: "./src/build/index.ts",
       import: "./src/build/index.ts"
-    },
-    "./host": {
-      "react-server": "./src/host/index.ts",
-      types: "./src/host/index.ts",
-      default: "./src/host/index.ts"
-    },
-    "./host/testing": {
-      types: "./src/host/testing.ts",
-      default: "./src/host/testing.ts"
     }
   },
   files: [
@@ -1066,45 +1057,13 @@ function createRouterDiscoveryPlugin(entryPath) {
   async function discoverRouters(rscEnv) {
     await rscEnv.runner.import(entryPath);
     const serverMod = await rscEnv.runner.import("@rangojs/router/server");
-    let registry = serverMod.RouterRegistry;
+    const registry = serverMod.RouterRegistry;
     if (!registry || registry.size === 0) {
-      try {
-        const hostMod = await rscEnv.runner.import("@rangojs/router/host");
-        const hostRegistry = hostMod.HostRouterRegistry;
-        if (hostRegistry && hostRegistry.size > 0) {
-          console.log(
-            `[rsc-router] Found ${hostRegistry.size} host router(s), resolving lazy handlers...`
-          );
-          for (const [, entry] of hostRegistry) {
-            for (const route of entry.routes) {
-              if (typeof route.handler === "function") {
-                try {
-                  await route.handler();
-                } catch {
-                }
-              }
-            }
-            if (entry.fallback && typeof entry.fallback.handler === "function") {
-              try {
-                await entry.fallback.handler();
-              } catch {
-              }
-            }
-          }
-          const freshServerMod = await rscEnv.runner.import("@rangojs/router/server");
-          const freshRegistry = freshServerMod.RouterRegistry;
-          if (freshRegistry && freshRegistry.size > 0) {
-            Object.assign(serverMod, freshServerMod);
-            registry = freshRegistry;
-          }
-        }
-      } catch {
-      }
-      if (!registry || registry.size === 0) {
-        throw new Error(
-          `[rsc-router] No routers found in registry after importing ${entryPath}`
-        );
-      }
+      console.warn(
+        "[rsc-router] No routers found in registry after importing",
+        entryPath
+      );
+      return serverMod;
     }
     const buildMod = await rscEnv.runner.import("@rangojs/router/build");
     const generateManifest = buildMod.generateManifest;
@@ -1203,11 +1162,7 @@ function createRouterDiscoveryPlugin(entryPath) {
         }
         await discoverRouters(rscEnv);
       } catch (err) {
-        delete globalThis.__rscRouterDiscoveryActive;
-        if (tempServer) {
-          await tempServer.close();
-        }
-        throw new Error(
+        console.warn(
           `[rsc-router] Build-time router discovery failed: ${err.message}`
         );
       } finally {
@@ -1539,7 +1494,6 @@ async function rscRouter(options) {
   }
   return plugins;
 }
-var rango = rscRouter;
 function createCjsToEsmPlugin() {
   return {
     name: "@rangojs/router:cjs-to-esm",
@@ -1598,6 +1552,5 @@ export {
   exposeHandleId,
   exposeLoaderId,
   exposeLocationStateId,
-  rango,
   rscRouter
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rangojs/router",
-  "version": "0.0.0-experimental.7",
+  "version": "0.0.0-experimental.8ff1c5d",
   "type": "module",
   "description": "Django-inspired RSC router with composable URL patterns",
   "author": "Ivo Todorov",
@@ -102,15 +102,6 @@
     "./build": {
       "types": "./src/build/index.ts",
       "import": "./src/build/index.ts"
-    },
-    "./host": {
-      "react-server": "./src/host/index.ts",
-      "types": "./src/host/index.ts",
-      "default": "./src/host/index.ts"
-    },
-    "./host/testing": {
-      "types": "./src/host/testing.ts",
-      "default": "./src/host/testing.ts"
     }
   },
   "files": [

package/src/vite/index.ts

@@ -356,59 +356,14 @@ function createRouterDiscoveryPlugin(entryPath: string): Plugin {
 
     // Import the router package to access the registry
     const serverMod = await rscEnv.runner.import("@rangojs/router/server");
-    let registry: Map<string, any> = serverMod.RouterRegistry;
+    const registry: Map<string, any> = serverMod.RouterRegistry;
 
     if (!registry || registry.size === 0) {
-      // No RSC routers found directly. Check for host routers with lazy handlers
-      // that need to be resolved to trigger sub-app createRouter() calls.
-      try {
-        const hostMod = await rscEnv.runner.import("@rangojs/router/host");
-        const hostRegistry: Map<string, any> | undefined = hostMod.HostRouterRegistry;
-
-        if (hostRegistry && hostRegistry.size > 0) {
-          console.log(
-            `[rsc-router] Found ${hostRegistry.size} host router(s), resolving lazy handlers...`
-          );
-
-          for (const [, entry] of hostRegistry) {
-            for (const route of entry.routes) {
-              if (typeof route.handler === 'function') {
-                try {
-                  await route.handler();
-                } catch {
-                  // Lazy handler may fail in temp server context, that's OK
-                }
-              }
-            }
-            if (entry.fallback && typeof entry.fallback.handler === 'function') {
-              try {
-                await entry.fallback.handler();
-              } catch {
-                // Fallback handler may fail in temp server context
-              }
-            }
-          }
-
-          // Re-read RouterRegistry - sub-app createRouter() calls should have populated it
-          const freshServerMod = await rscEnv.runner.import("@rangojs/router/server");
-          const freshRegistry: Map<string, any> = freshServerMod.RouterRegistry;
-
-          if (freshRegistry && freshRegistry.size > 0) {
-            // Update references so the manifest generation below uses the fresh data
-            Object.assign(serverMod, freshServerMod);
-            registry = freshRegistry;
-          }
-        }
-      } catch {
-        // @rangojs/router/host not available or import failed, skip
-      }
-
-      // If still no routers after host router resolution, fail
-      if (!registry || registry.size === 0) {
-        throw new Error(
-          `[rsc-router] No routers found in registry after importing ${entryPath}`
-        );
-      }
+      console.warn(
+        "[rsc-router] No routers found in registry after importing",
+        entryPath
+      );
+      return serverMod;
     }
 
     // Import build utilities for manifest generation
@@ -545,12 +500,7 @@ function createRouterDiscoveryPlugin(entryPath: string): Plugin {
 
         await discoverRouters(rscEnv);
       } catch (err: any) {
-        // Clean up before re-throwing so the temp server doesn't leak
-        delete (globalThis as any).__rscRouterDiscoveryActive;
-        if (tempServer) {
-          await tempServer.close();
-        }
-        throw new Error(
+        console.warn(
           `[rsc-router] Build-time router discovery failed: ${err.message}`
         );
       } finally {
@@ -1037,9 +987,6 @@ export async function rscRouter(
   return plugins;
 }
 
-/** Alias for backwards compatibility */
-export const rango = rscRouter;
-
 /**
  * Transform CJS vendor files from @vitejs/plugin-rsc to ESM for browser compatibility.
  * The react-server-dom vendor files are shipped as CJS which doesn't work in browsers.

package/src/host/cookie-handler.ts

@@ -1,159 +0,0 @@
-/**
- * Cookie Override Handler
- *
- * Manages cookie-based host override for development environments.
- */
-
-import type { HostOverrideConfig } from './types.js';
-import { matchPattern, parseRequest } from './pattern-matcher.js';
-import {
-  HostOverrideNotAllowedError,
-  InvalidHostnameError,
-  HostValidationError,
-} from './errors.js';
-
-/**
- * Parse cookies from request
- */
-export function parseCookies(request: Request): Record<string, string> {
-  const cookieHeader = request.headers.get('cookie');
-  if (!cookieHeader) {
-    return {};
-  }
-
-  const cookies: Record<string, string> = {};
-  const pairs = cookieHeader.split(';');
-
-  for (const pair of pairs) {
-    const [key, value] = pair.trim().split('=');
-    if (key && value) {
-      cookies[key] = decodeURIComponent(value);
-    }
-  }
-
-  return cookies;
-}
-
-/**
- * Get cookie value from request
- */
-export function getCookie(request: Request, name: string): string | undefined {
-  const cookies = parseCookies(request);
-  return cookies[name];
-}
-
-/**
- * Create Set-Cookie header to delete a cookie
- */
-export function createDeleteCookieHeader(name: string): string {
-  return `${name}=; Max-Age=0; Path=/; Secure; HttpOnly`;
-}
-
-/**
- * Create error response with cookie deletion
- */
-export function createCookieErrorResponse(
-  cookieName: string,
-  message: string
-): Response {
-  return new Response(
-    JSON.stringify({
-      error: message,
-      message: `The ${cookieName} cookie has been cleared`,
-    }),
-    {
-      status: 400,
-      headers: {
-        'Content-Type': 'application/json',
-        'Set-Cookie': createDeleteCookieHeader(cookieName),
-      },
-    }
-  );
-}
-
-/**
- * Check if current host is allowed to use override
- */
-export function isHostAllowed(
-  request: Request,
-  allowedHosts: string[]
-): boolean {
-  const { hostname, pathname, parts } = parseRequest(request);
-
-  for (const pattern of allowedHosts) {
-    if (matchPattern(pattern, hostname, pathname, parts)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Handle cookie override logic
- *
- * Returns overridden hostname if valid, original hostname if no override.
- * Throws errors for invalid overrides.
- */
-export function handleCookieOverride(
-  request: Request,
-  config: HostOverrideConfig | undefined,
-  context: any
-): string {
-  if (!config) {
-    const { hostname } = parseRequest(request);
-    return hostname;
-  }
-
-  const { cookieName, allowedHosts, validate } = config;
-  const cookieValue = getCookie(request, cookieName);
-  const { hostname: originalHostname } = parseRequest(request);
-
-  // No cookie - return original hostname
-  if (!cookieValue) {
-    return originalHostname;
-  }
-
-  // Check if current host is allowed
-  const allowed = isHostAllowed(request, allowedHosts);
-
-  // If not allowed, throw error
-  if (!allowed) {
-    throw new HostOverrideNotAllowedError(originalHostname, cookieName, {
-      cause: { cookieValue, currentHost: originalHostname },
-    });
-  }
-
-  // If allowed and has custom validation, run it
-  if (validate) {
-    try {
-      const validatedHostname = validate(request, cookieValue, context);
-      return validatedHostname;
-    } catch (error) {
-      // Wrap in HostValidationError
-      const message = error instanceof Error ? error.message : String(error);
-      throw new HostValidationError(message, error);
-    }
-  }
-
-  // Default validation - verify it's a valid hostname using URL constructor
-  try {
-    // Try to construct a URL with the hostname to validate it
-    const testUrl = new URL(`https://${cookieValue}`);
-
-    // Ensure the hostname matches what we provided (URL constructor normalizes it)
-    if (testUrl.hostname !== cookieValue) {
-      throw new InvalidHostnameError(cookieValue, {
-        cause: { original: cookieValue, normalized: testUrl.hostname },
-      });
-    }
-  } catch (error) {
-    // If URL constructor failed, throw InvalidHostnameError with cause
-    if (error instanceof InvalidHostnameError) {
-      throw error;
-    }
-    throw new InvalidHostnameError(cookieValue, { cause: error });
-  }
-
-  return cookieValue;
-}

package/src/host/errors.ts

@@ -1,97 +0,0 @@
-/**
- * Custom Error Classes for Host Router
- *
- * All host router errors extend HostRouterError for easy instance checking.
- */
-
-/**
- * Error options with cause
- */
-interface ErrorOptions {
-  cause?: unknown;
-}
-
-/**
- * Base error class for all host router errors
- */
-export class HostRouterError extends Error {
-  cause?: unknown;
-
-  constructor(message: string, options?: ErrorOptions) {
-    super(message);
-    if (options?.cause) {
-      this.cause = options.cause;
-    }
-    this.name = 'HostRouterError';
-    Object.setPrototypeOf(this, HostRouterError.prototype);
-  }
-}
-
-/**
- * Error thrown when pattern validation fails
- */
-export class InvalidPatternError extends HostRouterError {
-  constructor(pattern: string, reason: string, options?: ErrorOptions) {
-    super(`Invalid pattern "${pattern}": ${reason}`, options);
-    this.name = 'InvalidPatternError';
-    Object.setPrototypeOf(this, InvalidPatternError.prototype);
-  }
-}
-
-/**
- * Error thrown when cookie override is not allowed
- */
-export class HostOverrideNotAllowedError extends HostRouterError {
-  constructor(currentHost: string, cookieName: string, options?: ErrorOptions) {
-    super(
-      `Host override not allowed on "${currentHost}" (cookie: ${cookieName})`,
-      options
-    );
-    this.name = 'HostOverrideNotAllowedError';
-    Object.setPrototypeOf(this, HostOverrideNotAllowedError.prototype);
-  }
-}
-
-/**
- * Error thrown when cookie hostname is invalid
- */
-export class InvalidHostnameError extends HostRouterError {
-  constructor(hostname: string, options?: ErrorOptions) {
-    super(`Invalid hostname format: "${hostname}"`, options);
-    this.name = 'InvalidHostnameError';
-    Object.setPrototypeOf(this, InvalidHostnameError.prototype);
-  }
-}
-
-/**
- * Error thrown when custom validation fails
- */
-export class HostValidationError extends HostRouterError {
-  constructor(message: string, cause?: unknown) {
-    super(message, { cause });
-    this.name = 'HostValidationError';
-    Object.setPrototypeOf(this, HostValidationError.prototype);
-  }
-}
-
-/**
- * Error thrown when no route matches
- */
-export class NoRouteMatchError extends HostRouterError {
-  constructor(hostname: string, pathname: string, options?: ErrorOptions) {
-    super(`No route matched for ${hostname}${pathname}`, options);
-    this.name = 'NoRouteMatchError';
-    Object.setPrototypeOf(this, NoRouteMatchError.prototype);
-  }
-}
-
-/**
- * Error thrown when handler type is invalid
- */
-export class InvalidHandlerError extends HostRouterError {
-  constructor(handler: unknown, options?: ErrorOptions) {
-    super(`Invalid handler type: ${typeof handler}`, options);
-    this.name = 'InvalidHandlerError';
-    Object.setPrototypeOf(this, InvalidHandlerError.prototype);
-  }
-}

package/src/host/index.ts

@@ -1,56 +0,0 @@
-/**
- * Host Router
- *
- * A routing system for managing multi-application hosting based on
- * domain/subdomain patterns with support for cookie-based host override
- * for development environments.
- *
- * @example
- * ```ts
- * import { createHostRouter } from '@rangojs/router/host';
- *
- * const router = createHostRouter();
- *
- * router.host(['.']).map(() => import('./apps/main'));
- * router.host(['admin.*']).map(() => import('./apps/admin'));
- *
- * export default {
- *   fetch(request) {
- *     return router.match(request);
- *   }
- * };
- * ```
- */
-
-// Core router
-export { createHostRouter } from './router.js';
-
-// Host router registry for build-time discovery
-export { HostRouterRegistry, type HostRouterRegistryEntry } from './router.js';
-
-// Utilities
-export { defineHosts } from './utils.js';
-
-// Errors
-export {
-  HostRouterError,
-  InvalidPatternError,
-  HostOverrideNotAllowedError,
-  InvalidHostnameError,
-  HostValidationError,
-  NoRouteMatchError,
-  InvalidHandlerError,
-} from './errors.js';
-
-// Types
-export type {
-  HostRouter,
-  HostRouteBuilder,
-  HostRouterOptions,
-  Handler,
-  LazyHandler,
-  Middleware,
-  HostPattern,
-  HostMatchResult,
-  HostOverrideConfig,
-} from './types.js';

package/src/host/pattern-matcher.ts

@@ -1,214 +0,0 @@
-/**
- * Pattern Matching Engine
- *
- * Handles matching of hostnames and paths against various patterns:
- * - `.` or `*` - any apex domain
- * - `**` - any domain (apex + subdomains)
- * - `*.` - any single-level subdomain
- * - `**.` - any multi-level subdomain
- * - `example.com` - exact domain
- * - `*.com` - any apex .com domain
- * - `*.example.com` - subdomain of example.com
- * - `**.example.com` - any depth subdomain
- * - `admin.*` - admin subdomain of any apex
- * - `example.com/admin` - specific domain with path prefix
- */
-
-import { InvalidPatternError } from './errors.js';
-
-/**
- * Normalize a pattern by removing trailing slashes from paths
- */
-export function normalizePattern(pattern: string): string {
-  // If pattern has a path component, remove trailing slash
-  const slashIndex = pattern.indexOf('/');
-  if (slashIndex !== -1) {
-    const domain = pattern.slice(0, slashIndex);
-    const path = pattern.slice(slashIndex).replace(/\/$/, '');
-    return domain + path;
-  }
-  return pattern;
-}
-
-/**
- * Parse hostname and path from request URL
- */
-export function parseRequest(request: Request): {
-  hostname: string;
-  pathname: string;
-  parts: string[];
-} {
-  const url = new URL(request.url);
-  const hostname = url.hostname;
-  const pathname = url.pathname;
-  const parts = hostname.split('.');
-
-  return { hostname, pathname, parts };
-}
-
-/**
- * Count subdomain levels (0 for apex, 1+ for subdomains)
- */
-function getSubdomainLevel(parts: string[]): number {
-  // Apex domain has 2 parts (example.com)
-  // Single subdomain has 3 parts (www.example.com)
-  // Multi-level has 4+ parts (a.b.example.com)
-  return Math.max(0, parts.length - 2);
-}
-
-/**
- * Check if hostname is an apex domain (no subdomains)
- */
-function isApexDomain(parts: string[]): boolean {
-  return parts.length === 2;
-}
-
-/**
- * Match a single pattern against hostname and path
- */
-export function matchPattern(
-  pattern: string,
-  hostname: string,
-  pathname: string,
-  parts: string[]
-): boolean {
-  const normalized = normalizePattern(pattern);
-
-  // Check if pattern has path component
-  const slashIndex = normalized.indexOf('/');
-  const hasPath = slashIndex !== -1;
-  const domainPattern = hasPath ? normalized.slice(0, slashIndex) : normalized;
-  const pathPattern = hasPath ? normalized.slice(slashIndex) : null;
-
-  // First match domain
-  const domainMatch = matchDomainPattern(domainPattern, hostname, parts);
-  if (!domainMatch) {
-    return false;
-  }
-
-  // Then match path (prefix match)
-  if (pathPattern) {
-    return pathname === pathPattern || pathname.startsWith(pathPattern + '/');
-  }
-
-  return true;
-}
-
-/**
- * Match domain pattern against hostname
- */
-function matchDomainPattern(
-  pattern: string,
-  hostname: string,
-  parts: string[]
-): boolean {
-  // Exact match
-  if (pattern === hostname) {
-    return true;
-  }
-
-  // `.` or `*` - any apex domain
-  if (pattern === '.' || pattern === '*') {
-    return isApexDomain(parts);
-  }
-
-  // `**` - any domain (apex + all subdomains)
-  if (pattern === '**') {
-    return true;
-  }
-
-  // `*.` - any single-level subdomain
-  if (pattern === '*.') {
-    return getSubdomainLevel(parts) === 1;
-  }
-
-  // `**.` - any multi-level subdomain (2+ levels)
-  if (pattern === '**.') {
-    return getSubdomainLevel(parts) >= 2;
-  }
-
-  // `*.tld` - any apex domain with specific TLD (e.g., *.com)
-  if (pattern.startsWith('*.') && !pattern.includes('.', 2)) {
-    const tld = pattern.slice(2);
-    return isApexDomain(parts) && hostname.endsWith('.' + tld);
-  }
-
-  // `*.example.com` - single subdomain of specific domain
-  if (pattern.startsWith('*.')) {
-    const baseDomain = pattern.slice(2);
-    if (hostname.endsWith('.' + baseDomain)) {
-      // Count parts: if pattern is *.example.com (3 parts),
-      // hostname should have exactly 4 parts (www.example.com)
-      const patternParts = baseDomain.split('.');
-      return parts.length === patternParts.length + 1;
-    }
-    return false;
-  }
-
-  // `**.example.com` - any depth subdomain of specific domain
-  if (pattern.startsWith('**.')) {
-    const baseDomain = pattern.slice(3);
-    if (hostname.endsWith('.' + baseDomain)) {
-      const patternParts = baseDomain.split('.');
-      // Must have more parts than the base domain (i.e., has subdomains)
-      return parts.length > patternParts.length;
-    }
-    return false;
-  }
-
-  // `subdomain.*` - specific subdomain of any apex domain
-  // e.g., admin.* matches admin.example.com, admin.google.com
-  if (pattern.endsWith('.*')) {
-    const subdomain = pattern.slice(0, -2);
-    // Must be single-level subdomain (3 parts total)
-    if (parts.length === 3 && parts[0] === subdomain) {
-      return true;
-    }
-    return false;
-  }
-
-  // `subdomain.**` - specific subdomain of any domain (including multi-level)
-  // e.g., admin.** matches admin.example.com, admin.sub.example.com
-  if (pattern.endsWith('.**')) {
-    const subdomain = pattern.slice(0, -3);
-    if (parts.length >= 3 && parts[0] === subdomain) {
-      return true;
-    }
-    return false;
-  }
-
-  // `subdomain.` - specific subdomain of any apex domain (no wildcard)
-  // e.g., admin. matches admin.example.com, admin.google.com
-  if (pattern.endsWith('.') && !pattern.includes('*')) {
-    const subdomain = pattern.slice(0, -1);
-    // Must be exactly 3 parts (subdomain.domain.tld)
-    if (parts.length === 3 && parts[0] === subdomain) {
-      return true;
-    }
-    return false;
-  }
-
-  return false;
-}
-
-/**
- * Validate pattern format
- */
-export function validatePattern(pattern: string): void {
-  if (!pattern || typeof pattern !== 'string') {
-    throw new InvalidPatternError(
-      pattern,
-      'Pattern must be a non-empty string',
-      { cause: { type: typeof pattern, value: pattern } }
-    );
-  }
-
-  // Check for invalid characters (spaces, etc.)
-  if (/\s/.test(pattern)) {
-    throw new InvalidPatternError(pattern, 'contains whitespace', {
-      cause: { pattern },
-    });
-  }
-
-  // Additional validation can be added here
-}

package/src/host/router.ts

@@ -1,330 +0,0 @@
-/**
- * Host Router Implementation
- *
- * Main router that handles host-based routing with middleware and cookie override.
- */
-
-import type {
-  HostRouter,
-  HostRouteBuilder,
-  HostRouterOptions,
-  Handler,
-  LazyHandler,
-  Middleware,
-  HostPattern,
-  RouteEntry,
-  HostMatchResult,
-} from './types.js';
-import {
-  matchPattern,
-  parseRequest,
-  normalizePattern,
-  validatePattern,
-} from './pattern-matcher.js';
-import {
-  handleCookieOverride,
-  createCookieErrorResponse,
-} from './cookie-handler.js';
-import {
-  HostRouterError,
-  NoRouteMatchError,
-  InvalidHandlerError,
-} from './errors.js';
-
-/**
- * Registry entry for a host router instance.
- * Stores references to the live routes array and fallback, so the discovery
- * plugin can iterate handlers registered after createHostRouter() returns.
- */
-export interface HostRouterRegistryEntry {
-  routes: RouteEntry[];
-  fallback: RouteEntry | null;
-}
-
-/**
- * Global registry for host routers (parallel to RouterRegistry for RSC routers).
- * Populated by createHostRouter() so the build-time discovery plugin can find
- * host routers and resolve their lazy handlers to trigger sub-app createRouter() calls.
- */
-export const HostRouterRegistry: Map<string, HostRouterRegistryEntry> = new Map();
-
-let hostRouterAutoId = 0;
-
-/**
- * Create a host router
- */
-export function createHostRouter(options: HostRouterOptions = {}): HostRouter {
-  const routes: RouteEntry[] = [];
-  const globalMiddleware: Middleware[] = [];
-  let fallbackRoute: RouteEntry | null = null;
-
-  const { debug = false, hostOverride } = options;
-
-  function log(message: string, ...args: any[]): void {
-    if (debug) {
-      console.log(`[HostRouter] ${message}`, ...args);
-    }
-  }
-
-  /**
-   * Create a route builder for chaining
-   */
-  function createRouteBuilder(
-    patterns: string[],
-    isFallback = false
-  ): HostRouteBuilder {
-    const middleware: Middleware[] = [];
-
-    return {
-      use(...mw: Middleware[]): HostRouteBuilder {
-        middleware.push(...mw);
-        return this;
-      },
-
-      map(handler: Handler | LazyHandler): HostRouter {
-        const entry: RouteEntry = {
-          patterns,
-          middleware,
-          handler,
-          isFallback,
-        };
-
-        if (isFallback) {
-          fallbackRoute = entry;
-        } else {
-          routes.push(entry);
-        }
-
-        log(
-          `Registered ${isFallback ? 'fallback' : 'route'}:`,
-          patterns.join(', ')
-        );
-
-        return router;
-      },
-    };
-  }
-
-  /**
-   * Find matching route for hostname and path
-   */
-  function findMatchingRoute(
-    hostname: string,
-    pathname: string
-  ): RouteEntry | null {
-    const parts = hostname.split('.');
-
-    for (const route of routes) {
-      for (const pattern of route.patterns) {
-        if (matchPattern(pattern, hostname, pathname, parts)) {
-          log(`Matched pattern: "${pattern}"`);
-          return route;
-        }
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Execute middleware chain
-   */
-  async function executeMiddleware(
-    middleware: Middleware[],
-    request: Request,
-    context: any,
-    finalHandler: () => Promise<Response>
-  ): Promise<Response> {
-    let index = 0;
-
-    async function next(): Promise<Response> {
-      if (index >= middleware.length) {
-        return finalHandler();
-      }
-
-      const mw = middleware[index++];
-      if (!mw) {
-        return finalHandler();
-      }
-
-      return mw(request, context, next);
-    }
-
-    return next();
-  }
-
-  /**
-   * Execute handler (lazy or direct)
-   */
-  async function executeHandler(
-    handler: Handler | LazyHandler,
-    request: Request,
-    context: any
-  ): Promise<Response> {
-    // Check if it's a lazy handler (function that returns promise)
-    if (typeof handler === 'function') {
-      const result = handler(request, context);
-
-      // If it returns a promise with default export
-      if (result && typeof result === 'object' && 'then' in result) {
-        const module = await result;
-        if (
-          typeof module === 'object' &&
-          module !== null &&
-          'default' in module
-        ) {
-          const defaultExport = (module as { default: Handler | HostRouter })
-            .default;
-
-          // If default export is a router with match method
-          if (
-            typeof defaultExport === 'object' &&
-            defaultExport !== null &&
-            'match' in defaultExport
-          ) {
-            return (defaultExport as HostRouter).match(request, context);
-          }
-
-          // Otherwise treat as handler
-          return (defaultExport as Handler)(request, context);
-        }
-        // If promise resolves to Response
-        return result as Promise<Response>;
-      }
-
-      // Direct handler
-      return result as Response | Promise<Response>;
-    }
-
-    throw new InvalidHandlerError(handler, {
-      cause: { handlerType: typeof handler },
-    });
-  }
-
-  /**
-   * Router instance
-   */
-  const router: HostRouter = {
-    host(patterns: HostPattern): HostRouteBuilder {
-      const patternsArray = Array.isArray(patterns) ? patterns : [patterns];
-
-      // Validate and normalize patterns
-      const normalized = patternsArray.map((p) => {
-        validatePattern(p);
-        return normalizePattern(p);
-      });
-
-      return createRouteBuilder(normalized, false);
-    },
-
-    use(...middleware: Middleware[]): HostRouter {
-      globalMiddleware.push(...middleware);
-      log(`Registered global middleware (${middleware.length})`);
-      return router;
-    },
-
-    fallback(): HostRouteBuilder {
-      return createRouteBuilder([], true);
-    },
-
-    test(hostname: string): HostMatchResult | null {
-      const parts = hostname.split('.');
-      const pathname = '/';
-
-      for (const route of routes) {
-        for (const pattern of route.patterns) {
-          if (matchPattern(pattern, hostname, pathname, parts)) {
-            return {
-              pattern,
-              handler: route.handler,
-            };
-          }
-        }
-      }
-
-      return null;
-    },
-
-    async match(request: Request, context: any = {}): Promise<Response> {
-      log(`Request: ${request.url}`);
-
-      let effectiveHostname: string;
-
-      try {
-        // Handle cookie override (may throw HostRouterError)
-        effectiveHostname = handleCookieOverride(
-          request,
-          hostOverride,
-          context
-        );
-      } catch (error) {
-        // If it's a HostRouterError from cookie override
-        if (error instanceof HostRouterError) {
-          log(`Cookie override error: ${error.message}`);
-
-          // If fallback exists, use it
-          if (fallbackRoute) {
-            context.error = error;
-            const allMiddleware = [
-              ...globalMiddleware,
-              ...fallbackRoute.middleware,
-            ];
-
-            return executeMiddleware(allMiddleware, request, context, () =>
-              executeHandler(fallbackRoute!.handler, request, context)
-            );
-          }
-
-          // Otherwise return error response with cookie deletion
-          if (hostOverride) {
-            return createCookieErrorResponse(
-              hostOverride.cookieName,
-              error.message
-            );
-          }
-        }
-
-        // Re-throw non-HostRouterErrors
-        throw error;
-      }
-
-      const { pathname } = parseRequest(request);
-
-      if (effectiveHostname !== parseRequest(request).hostname) {
-        log(`Cookie override: ${effectiveHostname}`);
-      }
-
-      // Find matching route
-      const matchedRoute = findMatchingRoute(effectiveHostname, pathname);
-
-      if (!matchedRoute) {
-        log(`No route matched`);
-        throw new NoRouteMatchError(effectiveHostname, pathname, {
-          cause: {
-            hostname: effectiveHostname,
-            pathname,
-          },
-        });
-      }
-
-      // Combine global and route-specific middleware
-      const allMiddleware = [...globalMiddleware, ...matchedRoute.middleware];
-
-      // Execute middleware chain and handler
-      return executeMiddleware(allMiddleware, request, context, () =>
-        executeHandler(matchedRoute.handler, request, context)
-      );
-    },
-  };
-
-  // Register in the global HostRouterRegistry for build-time discovery.
-  // The routes array and fallbackRoute ref are live - they reflect routes
-  // added via .host().map() after this point.
-  const registryId = `host-router-${hostRouterAutoId++}`;
-  HostRouterRegistry.set(registryId, {
-    get routes() { return routes; },
-    get fallback() { return fallbackRoute; },
-  });
-
-  return router;
-}

package/src/host/testing.ts

@@ -1,79 +0,0 @@
-/**
- * Testing Utilities for Host Router
- *
- * Helper functions for testing host routing.
- */
-
-import { matchPattern } from './pattern-matcher.js';
-
-export interface CreateTestRequestOptions {
-  host: string;
-  path?: string;
-  method?: string;
-  cookies?: Record<string, string>;
-  headers?: Record<string, string>;
-}
-
-/**
- * Create a test request with specific host and cookies
- *
- * @example
- * ```ts
- * const request = createTestRequest({
- *   host: 'admin.example.com',
- *   path: '/dashboard',
- *   cookies: { 'x-requested-host': 'api.example.com' }
- * });
- * ```
- */
-export function createTestRequest(options: CreateTestRequestOptions): Request {
-  const {
-    host,
-    path = '/',
-    method = 'GET',
-    cookies = {},
-    headers = {},
-  } = options;
-
-  const url = `http://${host}${path}`;
-  const requestHeaders = new Headers(headers);
-
-  // Add cookies if provided
-  if (Object.keys(cookies).length > 0) {
-    const cookieString = Object.entries(cookies)
-      .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
-      .join('; ');
-    requestHeaders.set('cookie', cookieString);
-  }
-
-  return new Request(url, {
-    method,
-    headers: requestHeaders,
-  });
-}
-
-/**
- * Test if a pattern matches a hostname
- *
- * @example
- * ```ts
- * expect(testPattern('admin.*', 'admin.example.com')).toBe(true);
- * expect(testPattern(['*', 'www.*'], 'example.com')).toBe(true);
- * ```
- */
-export function testPattern(
-  pattern: string | string[],
-  hostname: string
-): boolean {
-  const patterns = Array.isArray(pattern) ? pattern : [pattern];
-  const parts = hostname.split('.');
-  const pathname = '/';
-
-  for (const p of patterns) {
-    if (matchPattern(p, hostname, pathname, parts)) {
-      return true;
-    }
-  }
-
-  return false;
-}

package/src/host/types.ts

@@ -1,138 +0,0 @@
-/**
- * Host Router Types
- *
- * Type definitions for the host-based routing system.
- */
-
-/**
- * Handler function that processes a request and returns a response
- */
-export type Handler = (
-  request: Request,
-  context: any
-) => Response | Promise<Response>;
-
-/**
- * Lazy handler that dynamically imports a module with a default handler or router
- */
-export type LazyHandler = () => Promise<{ default: Handler | HostRouter }>;
-
-/**
- * Middleware function that can intercept and modify requests/responses
- */
-export type Middleware = (
-  request: Request,
-  context: any,
-  next: () => Promise<Response>
-) => Promise<Response>;
-
-/**
- * Host pattern - can be a string or array of strings
- */
-export type HostPattern = string | string[];
-
-/**
- * Result from testing a hostname against patterns
- */
-export interface HostMatchResult {
-  pattern: string;
-  handler: Handler | LazyHandler;
-}
-
-/**
- * Host route builder for chaining middleware and handler
- */
-export interface HostRouteBuilder {
-  /**
-   * Add middleware to this host pattern
-   */
-  use(...middleware: Middleware[]): HostRouteBuilder;
-
-  /**
-   * Map to a handler or lazy import
-   */
-  map(handler: Handler | LazyHandler): HostRouter;
-}
-
-/**
- * Main host router interface
- */
-export interface HostRouter {
-  /**
-   * Register a host pattern
-   */
-  host(patterns: HostPattern): HostRouteBuilder;
-
-  /**
-   * Register global middleware
-   */
-  use(...middleware: Middleware[]): HostRouter;
-
-  /**
-   * Match an incoming request
-   */
-  match(request: Request, context?: any): Promise<Response>;
-
-  /**
-   * Register fallback handler for allowed hosts without valid cookie
-   */
-  fallback(): HostRouteBuilder;
-
-  /**
-   * Test which handler would match a hostname
-   */
-  test(hostname: string): HostMatchResult | null;
-}
-
-/**
- * Host override configuration
- */
-export interface HostOverrideConfig {
-  /**
-   * Cookie name to read for host override
-   */
-  cookieName: string;
-
-  /**
-   * Hosts that are allowed to use override
-   */
-  allowedHosts: string[];
-
-  /**
-   * Optional validation function
-   */
-  validate?: (request: Request, cookieValue: string, context: any) => string;
-}
-
-/**
- * Host router options
- */
-export interface HostRouterOptions {
-  /**
-   * Enable debug logging
-   */
-  debug?: boolean;
-
-  /**
-   * Cookie-based host override configuration
-   */
-  hostOverride?: HostOverrideConfig;
-}
-
-/**
- * Internal route entry
- */
-export interface RouteEntry {
-  patterns: string[];
-  middleware: Middleware[];
-  handler: Handler | LazyHandler;
-  isFallback?: boolean;
-}
-
-/**
- * Pattern match result (internal)
- */
-export interface PatternMatchResult {
-  matched: boolean;
-  routeEntry?: RouteEntry;
-}

package/src/host/utils.ts

@@ -1,25 +0,0 @@
-/**
- * Host Router Utilities
- *
- * Helper functions for type-safe pattern definitions.
- */
-
-/**
- * Define hosts with type safety
- *
- * @example
- * ```ts
- * const hosts = defineHosts({
- *   admin: 'admin.*',
- *   api: 'api.*',
- *   app: ['*', 'www.*']
- * });
- *
- * router.host(hosts.admin).map(...); // Type-safe!
- * ```
- */
-export function defineHosts<T extends Record<string, string | string[]>>(
-  hosts: T
-): Readonly<T> {
-  return Object.freeze(hosts);
-}