@websublime/vite-plugin-open-api-server 0.24.0-next.1 → 0.24.0-next.11

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import { Plugin, ViteDevServer } from 'vite';
-import { Logger, HandlerFn, AnySeedFn } from '@websublime/vite-plugin-open-api-core';
+import { Logger, SpecInfo, OpenApiServer, WebSocketHub, HandlerFn, AnySeedFn } from '@websublime/vite-plugin-open-api-core';
 export { HandlerContext, HandlerDefinition, HandlerFn, HandlerReturn, SecurityContext, SeedContext, SeedDefinition, SeedFn, SeedHelper, defineHandlers, defineSeeds } from '@websublime/vite-plugin-open-api-core';
+import { OpenAPIV3_1 } from '@scalar/openapi-types';
+import { Hono } from 'hono';
 import { App } from 'vue';
 
 /**
@@ -19,7 +21,7 @@ import { App } from 'vue';
  * Used across Tasks 1.2–1.4 for typed error handling.
  * Matches TECHNICAL-SPECIFICATION-V2.md Appendix B.
  */
-type ValidationErrorCode = 'SPEC_ID_MISSING' | 'SPEC_ID_DUPLICATE' | 'PROXY_PATH_MISSING' | 'PROXY_PATH_TOO_BROAD' | 'PROXY_PATH_DUPLICATE' | 'PROXY_PATH_OVERLAP' | 'SPEC_NOT_FOUND' | 'SPECS_EMPTY';
+type ValidationErrorCode = 'SPEC_ID_MISSING' | 'SPEC_ID_DUPLICATE' | 'PROXY_PATH_MISSING' | 'PROXY_PATH_TOO_BROAD' | 'PROXY_PATH_DUPLICATE' | 'PROXY_PATH_OVERLAP' | 'PROXY_PATH_PREFIX_COLLISION' | 'SPEC_NOT_FOUND' | 'SPECS_EMPTY';
 /**
  * Typed validation error for configuration issues.
  *
@@ -42,6 +44,16 @@ declare class ValidationError extends Error {
     readonly code: ValidationErrorCode;
     constructor(code: ValidationErrorCode, message: string);
 }
+/**
+ * How a proxy path was determined.
+ *
+ * - `'explicit'` — set directly in SpecConfig.proxyPath
+ * - `'auto'` — auto-derived from the OpenAPI document's servers[0].url
+ *
+ * Used by both DeriveProxyPathResult and ResolvedSpecConfig to ensure
+ * the two sources of this value stay in sync.
+ */
+type ProxyPathSource = 'auto' | 'explicit';
 /**
  * Configuration for a single OpenAPI spec instance
  *
@@ -175,18 +187,18 @@ interface OpenApiServerOptions {
  */
 interface ResolvedSpecConfig {
     spec: string;
-    /** Guaranteed to be set after orchestrator resolution */
+    /** Empty string until orchestrator resolution; guaranteed non-empty after `createOrchestrator()` */
     id: string;
-    /** Guaranteed to be set after orchestrator resolution */
+    /** Empty string until orchestrator resolution; guaranteed non-empty after `createOrchestrator()` */
     proxyPath: string;
     /**
      * How proxyPath was determined — used for banner display.
      *
-     * Set during static option resolution. The orchestrator (Task 1.7)
-     * will pass this to the multi-spec banner so it can show
-     * "(auto-derived)" vs "(explicit)" next to each proxy path.
+     * Written back by the orchestrator after document processing.
+     * Used by the startup banner to display `(auto-derived)` vs
+     * `(explicit)` next to each proxy path.
      */
-    proxyPathSource: 'auto' | 'explicit';
+    proxyPathSource: ProxyPathSource;
     handlersDir: string;
     seedsDir: string;
     idFields: Record<string, string>;
@@ -208,19 +220,380 @@ interface ResolvedOptions {
     silent: boolean;
     logger?: Logger;
 }
+/**
+ * Validate that specs array is non-empty and each entry has a valid spec field.
+ *
+ * @param specs - Array of spec configurations to validate
+ * @throws {ValidationError} SPECS_EMPTY if specs array is missing or empty
+ * @throws {ValidationError} SPEC_NOT_FOUND if a spec entry has empty spec field
+ */
+declare function validateSpecs(specs: SpecConfig[]): void;
+/**
+ * Resolve options with defaults.
+ *
+ * Note: spec ID and proxyPath resolution requires processing the OpenAPI document
+ * first, so they are resolved later in the orchestrator.
+ * This function only resolves static defaults.
+ *
+ * @param options - User-provided options
+ * @returns Resolved options with all defaults applied
+ */
+declare function resolveOptions(options: OpenApiServerOptions): ResolvedOptions;
 
 /**
  * Vite Plugin Implementation
  *
- * What: Main Vite plugin for OpenAPI mock server
- * How: Uses configureServer hook to start mock server and configure proxy
- * Why: Integrates OpenAPI mock server seamlessly into Vite dev workflow
+ * What: Main Vite plugin for OpenAPI mock server (multi-spec)
+ * How: Uses orchestrator to create N spec instances, configures multi-proxy
+ * Why: Integrates multiple OpenAPI mock servers seamlessly into Vite dev workflow
  *
  * @module plugin
  */
 
+/**
+ * Create the OpenAPI Server Vite plugin
+ *
+ * This plugin starts mock servers based on OpenAPI specifications
+ * and configures Vite to proxy API requests to them. Supports
+ * multiple specs via the orchestrator pattern.
+ *
+ * @example
+ * ```typescript
+ * // vite.config.ts
+ * import { defineConfig } from 'vite';
+ * import vue from '@vitejs/plugin-vue';
+ * import { openApiServer } from '@websublime/vite-plugin-open-api-server';
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     vue(),
+ *     openApiServer({
+ *       specs: [
+ *         { spec: './openapi/petstore.yaml', proxyPath: '/api/pets' },
+ *         { spec: './openapi/inventory.yaml', proxyPath: '/api/inventory' },
+ *       ],
+ *       port: 4000,
+ *     }),
+ *   ],
+ * });
+ * ```
+ *
+ * @param options - Plugin configuration options
+ * @returns Vite plugin
+ */
 declare function openApiServer(options: OpenApiServerOptions): Plugin;
 
+/**
+ * Spec ID Derivation
+ *
+ * What: Functions to derive and validate spec identifiers
+ * How: Slugifies explicit IDs or auto-derives from OpenAPI info.title
+ * Why: Each spec instance needs a unique, URL-safe identifier for routing,
+ *      DevTools grouping, logging, and default directory names
+ *
+ * @module spec-id
+ */
+
+/**
+ * Slugify a string for use as a spec identifier
+ *
+ * Rules:
+ * - Lowercase
+ * - Replace spaces and special chars with hyphens
+ * - Remove consecutive hyphens
+ * - Trim leading/trailing hyphens
+ *
+ * @example
+ * slugify("Swagger Petstore") → "swagger-petstore"
+ * slugify("Billing API v2")   → "billing-api-v2"
+ * slugify("café")             → "cafe"
+ */
+declare function slugify(input: string): string;
+/**
+ * Derive a spec ID from the processed OpenAPI document
+ *
+ * Priority:
+ * 1. Explicit id from config (if non-empty)
+ * 2. Slugified info.title from the processed document
+ *
+ * @param explicitId - ID from SpecConfig.id (may be empty)
+ * @param document - Processed OpenAPI document
+ * @returns Stable, URL-safe spec identifier
+ * @throws {ValidationError} SPEC_ID_MISSING if no ID can be derived (missing title and no explicit id)
+ */
+declare function deriveSpecId(explicitId: string, document: OpenAPIV3_1.Document): string;
+/**
+ * Validate spec IDs are unique across all specs
+ *
+ * Collects all duplicated IDs and reports them in a single error.
+ *
+ * @param ids - Array of resolved spec IDs
+ * @throws {ValidationError} SPEC_ID_DUPLICATE if duplicate IDs found
+ */
+declare function validateUniqueIds(ids: string[]): void;
+
+/**
+ * Proxy Path Auto-Detection
+ *
+ * What: Functions to derive and validate proxy paths for spec instances
+ * How: Extracts path from explicit config or auto-derives from servers[0].url
+ * Why: Each spec instance needs a unique, non-overlapping proxy path for
+ *      Vite proxy configuration and request routing
+ *
+ * @module proxy-path
+ */
+
+/**
+ * Result of proxy path derivation
+ *
+ * Includes the normalized path and how it was determined,
+ * so the startup banner can display "(auto-derived)" vs "(explicit)".
+ */
+interface DeriveProxyPathResult {
+    /** Normalized proxy path (e.g., "/api/v3") */
+    proxyPath: string;
+    /** How the path was determined */
+    proxyPathSource: ProxyPathSource;
+}
+/**
+ * Derive the proxy path from config or OpenAPI document's servers field
+ *
+ * Priority:
+ * 1. Explicit proxyPath from config (if non-empty after trimming)
+ * 2. Path portion of servers[0].url
+ *
+ * Full URLs (e.g., "https://api.example.com/api/v3") have their path
+ * extracted via the URL constructor. Relative paths (e.g., "/api/v3")
+ * are used directly.
+ *
+ * @param explicitPath - proxyPath from SpecConfig (may be empty)
+ * @param document - Processed OpenAPI document
+ * @param specId - Spec ID for error messages
+ * @returns Normalized proxy path with source indication
+ * @throws {ValidationError} PROXY_PATH_MISSING if path cannot be derived
+ * @throws {ValidationError} PROXY_PATH_TOO_BROAD if path resolves to "/" (e.g., "/", ".", "..")
+ *
+ * @example
+ * // Explicit path
+ * deriveProxyPath('/api/v3', document, 'petstore')
+ * // → { proxyPath: '/api/v3', proxyPathSource: 'explicit' }
+ *
+ * @example
+ * // Auto-derived from servers[0].url = "https://api.example.com/api/v3"
+ * deriveProxyPath('', document, 'petstore')
+ * // → { proxyPath: '/api/v3', proxyPathSource: 'auto' }
+ */
+declare function deriveProxyPath(explicitPath: string, document: OpenAPIV3_1.Document, specId: string): DeriveProxyPathResult;
+/**
+ * Normalize and validate a proxy path
+ *
+ * Rules:
+ * - Strip query strings and fragments
+ * - Ensure leading slash
+ * - Collapse consecutive slashes
+ * - Resolve dot segments ("." and ".." per RFC 3986 §5.2.4)
+ * - Remove trailing slash
+ * - Reject "/" as too broad (would capture all requests, including dot-segments that resolve to "/")
+ *
+ * @param path - Raw path string to normalize
+ * @param specId - Spec ID for error messages
+ * @returns Normalized path (e.g., "/api/v3")
+ * @throws {ValidationError} PROXY_PATH_TOO_BROAD if path resolves to "/" (e.g., "/", ".", "..")
+ *
+ * @example
+ * normalizeProxyPath('api/v3', 'petstore')   → '/api/v3'
+ * normalizeProxyPath('/api/v3/', 'petstore') → '/api/v3'
+ */
+declare function normalizeProxyPath(path: string, specId: string): string;
+/**
+ * Validate proxy paths are unique and non-overlapping
+ *
+ * Checks for:
+ * 1. Duplicate paths — two specs with the same proxyPath
+ * 2. Overlapping paths — one path is a prefix of another at a segment boundary
+ *    (e.g., "/api" and "/api/v1") which would cause routing ambiguity
+ * 3. String-prefix collisions — one path is a raw string prefix of another
+ *    without a segment boundary (e.g., "/api" and "/api2"). Vite's internal
+ *    proxy matching uses plain `url.startsWith(context)` with no segment
+ *    awareness, so "/api" would incorrectly capture "/api2/users" requests.
+ *
+ * @remarks
+ * Entries with an empty or falsy `proxyPath` are silently skipped. These
+ * represent specs whose proxy path has not yet been resolved (e.g., during
+ * early option resolution before the OpenAPI document is processed). Callers
+ * should expect unresolved entries to be excluded from uniqueness checks
+ * rather than triggering false-positive errors.
+ *
+ * @param specs - Array of spec entries with id and proxyPath.
+ *   Entries with empty/falsy proxyPath are skipped (unresolved).
+ * @throws {ValidationError} PROXY_PATH_DUPLICATE if duplicate paths found
+ * @throws {ValidationError} PROXY_PATH_OVERLAP if overlapping paths found (segment boundary)
+ * @throws {ValidationError} PROXY_PATH_PREFIX_COLLISION if one path is a raw string prefix
+ *   of another without a segment boundary (e.g., "/api" and "/api2")
+ *
+ * @example
+ * // Throws PROXY_PATH_DUPLICATE
+ * validateUniqueProxyPaths([
+ *   { id: 'petstore', proxyPath: '/api/v3' },
+ *   { id: 'inventory', proxyPath: '/api/v3' },
+ * ]);
+ *
+ * @example
+ * // Throws PROXY_PATH_OVERLAP
+ * validateUniqueProxyPaths([
+ *   { id: 'petstore', proxyPath: '/api' },
+ *   { id: 'inventory', proxyPath: '/api/v1' },
+ * ]);
+ *
+ * @example
+ * // Throws PROXY_PATH_PREFIX_COLLISION
+ * validateUniqueProxyPaths([
+ *   { id: 'petstore', proxyPath: '/api' },
+ *   { id: 'inventory', proxyPath: '/api2' },
+ * ]);
+ */
+declare function validateUniqueProxyPaths(specs: Array<{
+    id: string;
+    proxyPath: string;
+}>): void;
+
+/**
+ * Multi-Spec Orchestrator
+ *
+ * What: Central orchestrator that creates N spec instances and mounts them on a single Hono app
+ * How: Three phases — process specs, validate uniqueness, build main Hono app with dispatch middleware
+ * Why: Enables multiple OpenAPI specs to run on a single server with isolated stores and handlers
+ *
+ * @module orchestrator
+ */
+
+/**
+ * Deterministic color palette for spec identification in DevTools.
+ *
+ * Colors are assigned by index: spec 0 gets green, spec 1 gets blue, etc.
+ * Wraps around for >8 specs.
+ */
+declare const SPEC_COLORS: readonly string[];
+/**
+ * Resolved spec instance with all runtime data.
+ *
+ * Created during Phase 1 of orchestration. Each instance owns
+ * an isolated core `OpenApiServer` with its own store, registry,
+ * handlers, seeds, and timeline.
+ */
+interface SpecInstance {
+    /** Unique spec identifier (explicit or auto-derived from info.title) */
+    id: string;
+    /** Spec metadata for DevTools display and WebSocket protocol */
+    info: SpecInfo;
+    /** Core server instance (isolated Hono app, store, registry, etc.) */
+    server: OpenApiServer;
+    /** Resolved configuration for this spec */
+    config: ResolvedSpecConfig;
+}
+/**
+ * Orchestrator result — returned by `createOrchestrator()`.
+ *
+ * Provides access to the main Hono app (all specs mounted),
+ * individual spec instances, aggregated metadata, and lifecycle methods.
+ */
+interface OrchestratorResult {
+    /**
+     * Main Hono app with all specs mounted via X-Spec-Id dispatch.
+     *
+     * **Note**: Consumers using this property directly must have `hono`
+     * as a dependency. The `start()`/`stop()` lifecycle methods do not
+     * require direct interaction with this Hono instance.
+     */
+    app: Hono;
+    /** All spec instances (in config order) */
+    instances: SpecInstance[];
+    /** Spec metadata array for WebSocket `connected` event */
+    specsInfo: SpecInfo[];
+    /**
+     * Shared WebSocket hub for the orchestrator.
+     *
+     * Created via `createMultiSpecWebSocketHub()` with:
+     * - `autoConnect: false` to suppress default connected events
+     * - Enhanced `addClient()` that sends specs metadata
+     * - Broadcast interception that adds `specId` to all events
+     * - Multi-spec command handler for spec-scoped routing
+     */
+    wsHub: WebSocketHub;
+    /** Start the shared HTTP server on the configured port */
+    start(): Promise<void>;
+    /** Stop the HTTP server and clean up resources */
+    stop(): Promise<void>;
+    /** Actual bound port after start() resolves (0 before start or after stop) */
+    readonly port: number;
+}
+/**
+ * Create the multi-spec orchestrator.
+ *
+ * Flow:
+ * 1. **Phase 1 — Process specs**: For each spec config, load handlers/seeds,
+ *    create a core `OpenApiServer` instance, derive ID and proxy path.
+ * 2. **Phase 2 — Validate uniqueness**: Ensure all spec IDs and proxy paths
+ *    are unique and non-overlapping.
+ * 3. **Phase 3 — Build main app**: Create a single Hono app with CORS,
+ *    DevTools, Internal API, and X-Spec-Id dispatch middleware.
+ *
+ * **Note**: This function populates the resolved values (id, proxyPath,
+ * proxyPathSource, handlersDir, seedsDir) on each `options.specs[i]` object.
+ * Since `instances[i].config` is the same object reference, consumers should
+ * access resolved values through `instances[i].config` (the authoritative view).
+ *
+ * @param options - Resolved plugin options (from `resolveOptions()`)
+ * @param vite - Vite dev server instance (for ssrLoadModule)
+ * @param cwd - Project root directory
+ * @returns Orchestrator result with app, instances, and lifecycle methods
+ */
+declare function createOrchestrator(options: ResolvedOptions, vite: ViteDevServer, cwd: string): Promise<OrchestratorResult>;
+
+/**
+ * Multi-Path Proxy Configuration
+ *
+ * What: Configures Vite proxy for multiple OpenAPI spec instances
+ * How: Generates one proxy entry per spec with path rewriting and X-Spec-Id header,
+ *      plus shared service proxies for DevTools, Internal API, and WebSocket
+ * Why: Enables each spec's API requests to be routed through Vite to the shared server
+ *
+ * @module multi-proxy
+ */
+
+/**
+ * Shared service proxy path prefixes.
+ *
+ * These constants are the single source of truth for the reserved proxy paths
+ * used by the DevTools iframe, internal API, and WebSocket connections.
+ * Both `configureMultiProxy()` and the virtual DevTools tab module in
+ * `plugin.ts` reference these to prevent divergence.
+ */
+declare const DEVTOOLS_PROXY_PATH = "/_devtools";
+declare const API_PROXY_PATH = "/_api";
+declare const WS_PROXY_PATH = "/_ws";
+/**
+ * Configure Vite proxy for multiple spec instances and shared services.
+ *
+ * Generates:
+ * 1. **Per-spec proxy entries** — one per spec, with path rewriting (prefix
+ *    stripping) and an `X-Spec-Id` header so the shared Hono server can
+ *    route to the correct spec instance.
+ * 2. **Shared service proxies** — spec-agnostic entries for `/_devtools`,
+ *    `/_api`, and `/_ws` that forward to the same server without path
+ *    rewriting or spec headers.
+ *
+ * Uses `startsWith`/`slice` for path rewriting instead of the regex approach
+ * described in the tech spec (Section 5.7). Literal prefix matching is safer
+ * because it correctly handles regex metacharacters in proxy paths (e.g.,
+ * `/api.v3` matches literally, not as `/api<any>v3`).
+ *
+ * @param vite - Vite dev server instance
+ * @param instances - Resolved spec instances from the orchestrator
+ * @param port - Shared server port
+ */
+declare function configureMultiProxy(vite: ViteDevServer, instances: SpecInstance[], port: number): void;
+
 /**
  * Handler Loading
  *
@@ -349,14 +722,12 @@ declare function getSeedFiles(seedsDir: string, cwd?: string): Promise<string[]>
 /**
  * Hot Reload
  *
- * What: File watcher for hot reloading handlers and seeds
- * How: Uses chokidar to watch for file changes
- * Why: Enables rapid development iteration without server restart
+ * What: File watcher for hot reloading handlers and seeds with per-spec isolation
+ * How: Uses chokidar to watch for file changes, one watcher per spec instance
+ * Why: Enables rapid development iteration without server restart; per-spec
+ *       isolation ensures handler/seed changes in one spec don't affect others
  *
  * @module hot-reload
- *
- * TODO: Full implementation in Task 3.3
- * This module provides placeholder/basic functionality for Task 3.1
  */
 
 /**
@@ -419,6 +790,14 @@ interface FileWatcher {
  * @returns Promise resolving to file watcher instance
  */
 declare function createFileWatcher(options: FileWatcherOptions): Promise<FileWatcher>;
+/**
+ * Debounced function with cancel support
+ */
+interface DebouncedFunction<T extends (...args: unknown[]) => unknown> {
+    (...args: Parameters<T>): void;
+    /** Cancel any pending debounce timer and queued execution */
+    cancel(): void;
+}
 /**
  * Debounce a function with async execution guard
  *
@@ -432,9 +811,50 @@ declare function createFileWatcher(options: FileWatcherOptions): Promise<FileWat
  *
  * @param fn - Function to debounce (can be sync or async)
  * @param delay - Debounce delay in milliseconds
- * @returns Debounced function
+ * @returns Debounced function with cancel() method
  */
-declare function debounce<T extends (...args: unknown[]) => unknown>(fn: T, delay: number): (...args: Parameters<T>) => void;
+declare function debounce<T extends (...args: unknown[]) => unknown>(fn: T, delay: number): DebouncedFunction<T>;
+/**
+ * Create file watchers for all spec instances
+ *
+ * Each spec gets independent watchers for its handlers and seeds directories.
+ * Changes to one spec's files only trigger reload for that spec instance.
+ *
+ * @param instances - All spec instances to watch
+ * @param vite - Vite dev server (for ssrLoadModule / module invalidation)
+ * @param cwd - Project root directory
+ * @param options - Resolved plugin options
+ * @returns Promise resolving to array of file watchers (one per spec)
+ */
+declare function createPerSpecFileWatchers(instances: SpecInstance[], vite: ViteDevServer, cwd: string, options: ResolvedOptions): Promise<FileWatcher[]>;
+/**
+ * Reload handlers for a specific spec instance
+ *
+ * Loads fresh handlers from disk via Vite's ssrLoadModule, updates
+ * the spec's server, broadcasts a WebSocket event, and logs the result.
+ *
+ * @param instance - The spec instance to reload handlers for
+ * @param vite - Vite dev server
+ * @param cwd - Project root directory
+ * @param options - Resolved plugin options
+ */
+declare function reloadSpecHandlers(instance: SpecInstance, vite: ViteDevServer, cwd: string, options: ResolvedOptions): Promise<void>;
+/**
+ * Reload seeds for a specific spec instance
+ *
+ * Loads fresh seeds from disk, clears the spec's store, and re-executes
+ * seeds. Broadcasts a WebSocket event and logs the result.
+ *
+ * Note: This operation is not fully atomic — there's a brief window between
+ * clearing the store and repopulating it where requests may see empty data.
+ * For development tooling, this tradeoff is acceptable.
+ *
+ * @param instance - The spec instance to reload seeds for
+ * @param vite - Vite dev server
+ * @param cwd - Project root directory
+ * @param options - Resolved plugin options
+ */
+declare function reloadSpecSeeds(instance: SpecInstance, vite: ViteDevServer, cwd: string, options: ResolvedOptions): Promise<void>;
 
 /**
  * Vue DevTools Integration
@@ -452,7 +872,7 @@ declare function debounce<T extends (...args: unknown[]) => unknown>(fn: T, dela
 interface RegisterDevToolsOptions {
     /**
      * The port where the OpenAPI server is running
-     * @default 3000
+     * @default 4000
      */
     port?: number;
     /**
@@ -494,7 +914,7 @@ interface RegisterDevToolsOptions {
  *
  * // Register OpenAPI Server DevTools
  * if (import.meta.env.DEV) {
- *   await registerDevTools(app, { port: 3000 });
+ *   await registerDevTools(app);
  * }
  *
  * app.mount('#app');
@@ -510,11 +930,11 @@ declare function registerDevTools(app: App, options?: RegisterDevToolsOptions):
  * When running in a browser, protocol and host are automatically derived from
  * window.location if not explicitly provided.
  *
- * @param port - Server port (default: 3000)
+ * @param port - Server port (default: 4000, matching OpenApiServerOptions.port)
  * @param host - Server host (default: 'localhost' or window.location.hostname)
  * @param protocol - Protocol to use (default: 'http' or window.location.protocol)
  * @returns DevTools SPA URL
  */
 declare function getDevToolsUrl(port?: number, host?: string, protocol?: 'http' | 'https'): string;
 
-export { type FileWatcher, type FileWatcherOptions, type LoadHandlersResult, type LoadSeedsResult, type OpenApiServerOptions, type RegisterDevToolsOptions, type ResolvedOptions, type ResolvedSpecConfig, type SpecConfig, ValidationError, type ValidationErrorCode, createFileWatcher, debounce, getDevToolsUrl, getHandlerFiles, getSeedFiles, loadHandlers, loadSeeds, openApiServer, registerDevTools };
+export { API_PROXY_PATH, DEVTOOLS_PROXY_PATH, type DebouncedFunction, type DeriveProxyPathResult, type FileWatcher, type FileWatcherOptions, type LoadHandlersResult, type LoadSeedsResult, type OpenApiServerOptions, type OrchestratorResult, type ProxyPathSource, type RegisterDevToolsOptions, type ResolvedOptions, type ResolvedSpecConfig, SPEC_COLORS, type SpecConfig, type SpecInstance, ValidationError, type ValidationErrorCode, WS_PROXY_PATH, configureMultiProxy, createFileWatcher, createOrchestrator, createPerSpecFileWatchers, debounce, deriveProxyPath, deriveSpecId, getDevToolsUrl, getHandlerFiles, getSeedFiles, loadHandlers, loadSeeds, normalizeProxyPath, openApiServer, registerDevTools, reloadSpecHandlers, reloadSpecSeeds, resolveOptions, slugify, validateSpecs, validateUniqueIds, validateUniqueProxyPaths };