@jay-framework/stack-server-build 0.24.2

package/dist/index.d.ts

@@ -0,0 +1,664 @@
+import { ViteDevServer } from 'vite';
+import { JayRoute } from '@jay-framework/stack-route-scanner';
+import { WithValidations, JayHtmlHeadMeta, JsonSchemaProperty } from '@jay-framework/compiler-shared';
+export { JsonSchemaProperty } from '@jay-framework/compiler-shared';
+import { Contract, HeadlessContractInfo, DiscoveredHeadlessInstance, ForEachHeadlessInstance, JayHtmlScript } from '@jay-framework/compiler-jay-html';
+import { AnyJayStackComponentDefinition, HeadTag } from '@jay-framework/fullstack-component';
+import { JayRollupConfig } from '@jay-framework/rollup-plugin';
+import { TrackByMap } from '@jay-framework/view-state-merge';
+import { PluginClientInitInfo, ActionRegistry, ViteSSRLoader as ViteSSRLoader$1, PluginAgentKitResult, PluginSetupPrompt, PluginSetupResult } from '@jay-framework/stack-server-runtime';
+export * from '@jay-framework/stack-server-runtime';
+export { PluginAgentKitContext, PluginAgentKitHandler, PluginAgentKitResult, PluginSetupContext, PluginSetupHandler, PluginSetupPrompt, PluginSetupResult } from '@jay-framework/stack-server-runtime';
+
+interface DevServerPagePart {
+    compDefinition: AnyJayStackComponentDefinition;
+    key?: string;
+    clientImport: string;
+    clientPart: string;
+    /** Contract metadata for dynamic contract components */
+    contractInfo?: {
+        contractName: string;
+        metadata?: Record<string, unknown>;
+    };
+    /** Static props from YAML body in the headless script tag (DL#156) */
+    headlessProps?: Record<string, string>;
+}
+/**
+ * Instance-only headless component (no key attribute).
+ * Used for server-side phase orchestration of `<jay:xxx>` instances.
+ */
+interface HeadlessInstanceComponent {
+    /** Contract name from the script tag (e.g., "product-card") */
+    contractName: string;
+    /** Component definition for calling slowlyRender/fastRender */
+    compDefinition: AnyJayStackComponentDefinition;
+    /** Parsed contract (for phase detection in slow render Pass 2) */
+    contract: Contract;
+}
+interface LoadedPageParts {
+    parts: DevServerPagePart[];
+    /** TrackBy map for server-side merge (slow → fast) */
+    serverTrackByMap?: Record<string, string>;
+    /** TrackBy map for client-side merge (fast → interactive) */
+    clientTrackByMap?: Record<string, string>;
+    /** NPM package names used on this page (for filtering plugin inits) */
+    usedPackages: Set<string>;
+    /** Headless contracts for slow rendering (already loaded by parseJayFile) */
+    headlessContracts: HeadlessContractInfo[];
+    /** Instance-only headless components (no key) for server-side phase orchestration */
+    headlessInstanceComponents: HeadlessInstanceComponent[];
+    /** Discovered <jay:xxx> instances from the jay-html (DL#109) */
+    discoveredInstances: DiscoveredHeadlessInstance[];
+    /** Discovered forEach <jay:xxx> instances from the jay-html (DL#109) */
+    forEachInstances: ForEachHeadlessInstance[];
+    /** Absolute paths to linked CSS files (from <link rel="stylesheet">) for dev-server watching */
+    linkedCssFiles: string[];
+    /** Absolute paths to headfull FS component jay-html files for dev-server watching */
+    linkedComponentFiles: string[];
+    /** Script tags with jay-script="allow" to include in SSR output */
+    scripts?: JayHtmlScript[];
+}
+interface LoadPagePartsOptions {
+    /**
+     * Path to pre-rendered jay-html file to use instead of the original.
+     * When provided, this file (with slow-phase bindings resolved) is read.
+     * Import resolution still uses the original jay-html's directory.
+     */
+    preRenderedPath?: string;
+    /**
+     * Pre-loaded jay-html content to use instead of reading from disk.
+     * When provided (e.g., from SlowRenderCache with cache tag already stripped),
+     * this content is used directly, avoiding an extra file read.
+     */
+    preRenderedContent?: string;
+}
+declare function loadPageParts(vite: ViteDevServer, route: JayRoute, pagesBase: string, projectBase: string, jayRollupConfig: JayRollupConfig, options?: LoadPagePartsOptions): Promise<WithValidations<LoadedPageParts>>;
+
+/**
+ * Generate JS code to reconstruct Promise.resolve()/Promise.reject() for async ViewState properties.
+ * JSON.stringify drops Promise objects, so this emits assignments that recreate them from tracked outcomes.
+ */
+declare function generatePromiseReconstruction(outcomes: Array<{
+    id: string;
+    status: 'resolved' | 'rejected';
+    value: any;
+}>): string;
+/**
+ * Information needed to generate client init script for the project.
+ */
+interface ProjectClientInitInfo {
+    /** Import path for the init module */
+    importPath: string;
+    /** Export name for the JayInit constant (default: 'init') */
+    initExport?: string;
+}
+/**
+ * Options for client script generation.
+ */
+interface GenerateClientScriptOptions {
+    /** Enable automation integration (default: true in dev mode) */
+    enableAutomation?: boolean;
+    /**
+     * Slow ViewState that was baked into the pre-rendered jay-html.
+     * When provided, this is merged with fastViewState for the automation API
+     * so that AI/automation tools can see the complete page state.
+     */
+    slowViewState?: object;
+    /** Route pattern (e.g., /products/kitan{/:category}) for freeze entries */
+    routePattern?: string;
+}
+/**
+ * Shared fragments generated by buildScriptFragments().
+ * Used by both generateClientScript() and generateHydrationScript().
+ */
+interface ScriptFragments {
+    partImports: string;
+    compositeParts: string;
+    pluginClientInitImports: string;
+    projectInitImport: string;
+    clientInitExecution: string;
+    automationImport: string;
+    slowViewStateDecl: string;
+}
+/**
+ * Build the shared script fragments used by both client and hydration scripts.
+ */
+declare function buildScriptFragments(parts: DevServerPagePart[], clientInitData: Record<string, Record<string, any>>, projectInit: ProjectClientInitInfo | undefined, pluginInits: PluginClientInitInfo[], options: GenerateClientScriptOptions): ScriptFragments;
+/**
+ * Generate the automation wrapping code.
+ * @param mode - 'client' appends to DOM; 'hydrate' skips appendChild (DOM already present)
+ */
+declare function buildAutomationWrap(options: GenerateClientScriptOptions, mode: 'client' | 'hydrate'): string;
+/**
+ * Resolve all top-level Promise values in a ViewState object.
+ * Returns the ViewState with Promises replaced by their resolved values,
+ * plus a list of outcomes for reconstructing Promise.resolve()/Promise.reject()
+ * in the client script.
+ */
+declare function resolveViewStatePromises(viewState: object): Promise<{
+    resolved: object;
+    outcomes: Array<{
+        id: string;
+        status: 'resolved' | 'rejected';
+        value: any;
+    }>;
+}>;
+declare function generateClientScript(defaultViewState: object, fastCarryForward: object, parts: DevServerPagePart[], jayHtmlPath: string, trackByMap?: TrackByMap, clientInitData?: Record<string, Record<string, any>>, projectInit?: ProjectClientInitInfo, pluginInits?: PluginClientInitInfo[], options?: GenerateClientScriptOptions): Promise<string>;
+
+/**
+ * Invalidate the cached server element module for a jay-html file.
+ * Called when the source file changes (via file watcher).
+ */
+declare function invalidateServerElementCache(jayHtmlPath: string): void;
+/**
+ * Invalidate all cached server element modules.
+ */
+declare function clearServerElementCache(): void;
+declare function headMetaToHeadTags(headMeta: JayHtmlHeadMeta | undefined, viewState?: object): HeadTag[];
+/**
+ * Generate a complete SSR HTML page with server-rendered content and hydration script.
+ *
+ * Flow:
+ * 1. Load (or reuse cached) server element module
+ * 2. Execute renderToStream() to produce HTML
+ * 3. Build hydration script (uses ?jay-hydrate query for hydrate target)
+ * 4. Return full HTML page string
+ */
+declare function generateSSRPageHtml(vite: ViteDevServer, jayHtmlContent: string, jayHtmlFilename: string, jayHtmlDir: string, viewState: object, jayHtmlImportPath: string, parts: DevServerPagePart[], carryForward: object, trackByMap: TrackByMap, clientInitData: Record<string, Record<string, any>>, buildFolder: string, projectRoot: string, routeDir: string, tsConfigFilePath?: string, projectInit?: ProjectClientInitInfo, pluginInits?: PluginClientInitInfo[], options?: GenerateClientScriptOptions, 
+/** Source directory for headfull FS file resolution when jayHtmlDir is pre-rendered */
+sourceDir?: string, 
+/** Head tags to inject into <head> during SSR (Design Log #127) */
+headTags?: HeadTag[], 
+/** Script tags with jay-script="allow" (DL#149) */
+scripts?: JayHtmlScript[]): Promise<string>;
+/**
+ * Generate a frozen page — pure SSR HTML with no client scripts (DL#127).
+ *
+ * Uses the same server element module as generateSSRPageHtml, but:
+ * - No hydration script
+ * - No Vite client
+ * - No component runtime
+ * - Just rendered HTML + CSS
+ *
+ * @param format - 'page' for full HTML document, 'fragment' for body-only (shadow DOM)
+ */
+declare function generateFrozenPageHtml(vite: ViteDevServer, jayHtmlContent: string, jayHtmlFilename: string, jayHtmlDir: string, viewState: object, buildFolder: string, projectRoot: string, routeDir: string, tsConfigFilePath?: string, sourceDir?: string, format?: 'page' | 'fragment', freezeName?: string): Promise<string>;
+
+/**
+ * Action metadata loaded from .jay-action files.
+ *
+ * Uses the compiler's parseAction to parse .jay-action YAML into JayType,
+ * then converts JayType → JSON Schema for consumers (AI agent tool builders).
+ *
+ * Actions without .jay-action files are not exposed to AI agents.
+ */
+
+/**
+ * Input schema for an action (JSON Schema object type).
+ */
+interface ActionSchema {
+    type: 'object';
+    properties: Record<string, JsonSchemaProperty>;
+    required?: string[];
+}
+/**
+ * Metadata loaded from a .jay-action file.
+ */
+interface ActionMetadata {
+    /** Action name (must match the export name in plugin code) */
+    name: string;
+    /** Human-readable description of what the action does */
+    description: string;
+    /** JSON Schema for the action's input parameters */
+    inputSchema: ActionSchema;
+    /** JSON Schema for the action's output (optional) */
+    outputSchema?: JsonSchemaProperty;
+}
+/**
+ * Parses a .jay-action YAML string into ActionMetadata.
+ * Uses the compiler's parseAction to produce JayType, then converts to JSON Schema.
+ */
+declare function parseActionMetadata(yamlContent: string, fileName: string): ActionMetadata | null;
+/**
+ * Loads action metadata from a .jay-action file on disk.
+ */
+declare function loadActionMetadata(filePath: string): ActionMetadata | null;
+/**
+ * Resolves the absolute path of a .jay-action file relative to a plugin directory.
+ */
+declare function resolveActionMetadataPath(actionPath: string, pluginDir: string): string;
+
+/**
+ * Action discovery and auto-registration for Jay Stack.
+ *
+ * Scans project and plugin directories to discover and register actions
+ * automatically on server startup.
+ */
+
+/**
+ * Vite server interface for SSR module loading.
+ * Using a minimal interface to avoid direct Vite dependency.
+ */
+interface ViteSSRLoader {
+    ssrLoadModule: (url: string) => Promise<Record<string, any>>;
+}
+/**
+ * Options for action discovery.
+ */
+interface ActionDiscoveryOptions {
+    /** Project root directory */
+    projectRoot: string;
+    /** Custom actions directory (default: src/actions) */
+    actionsDir?: string;
+    /** Registry to register actions in (default: global actionRegistry) */
+    registry?: ActionRegistry;
+    /** Whether to log discovery progress */
+    verbose?: boolean;
+    /** Vite server for SSR module loading (required in dev for TypeScript files) */
+    viteServer?: ViteSSRLoader;
+}
+/**
+ * Result of action discovery.
+ */
+interface ActionDiscoveryResult {
+    /** Number of actions discovered and registered */
+    actionCount: number;
+    /** Names of registered actions */
+    actionNames: string[];
+    /** Paths of scanned action files */
+    scannedFiles: string[];
+}
+/**
+ * Discovers and registers actions from the project's actions directory.
+ *
+ * Scans `src/actions/*.actions.ts` for exported actions and registers them.
+ *
+ * @param options - Discovery options
+ * @returns Result with discovered action information
+ *
+ * @example
+ * ```typescript
+ * // In dev-server startup
+ * const result = await discoverAndRegisterActions({
+ *     projectRoot: process.cwd(),
+ *     verbose: true,
+ * });
+ * console.log(`Registered ${result.actionCount} actions`);
+ * ```
+ */
+declare function discoverAndRegisterActions(options: ActionDiscoveryOptions): Promise<ActionDiscoveryResult>;
+/**
+ * Options for discovering plugin actions.
+ */
+interface PluginActionDiscoveryOptions {
+    /** Project root directory */
+    projectRoot: string;
+    /** Registry to register actions in (default: global actionRegistry) */
+    registry?: ActionRegistry;
+    /** Whether to log discovery progress */
+    verbose?: boolean;
+    /** Vite server for SSR module loading (required in dev for TypeScript files) */
+    viteServer?: ViteSSRLoader;
+}
+/**
+ * Discovers and registers actions from all plugins in a project.
+ *
+ * Scans both local plugins (src/plugins/) and installed NPM plugins.
+ *
+ * @param options - Discovery options
+ * @returns Array of registered action names
+ */
+declare function discoverAllPluginActions(options: PluginActionDiscoveryOptions): Promise<string[]>;
+/**
+ * Discovers actions from a single plugin's plugin.yaml file.
+ *
+ * Reads plugin.yaml, finds the `actions` array, and imports those
+ * named exports from the plugin's module.
+ *
+ * @param pluginPath - Path to the plugin directory (containing plugin.yaml)
+ * @param projectRoot - Project root for resolving imports
+ * @param registry - Registry to register actions in
+ * @param verbose - Whether to log progress
+ * @returns Array of registered action names
+ */
+declare function discoverPluginActions(pluginPath: string, projectRoot: string, registry?: ActionRegistry, verbose?: boolean, viteServer?: ViteSSRLoader): Promise<string[]>;
+
+/**
+ * Contract Materializer
+ *
+ * Materializes dynamic contracts to disk for agent discovery.
+ * Also creates an index file listing both static and dynamic contracts.
+ *
+ * @see Design Log #80 - Materializing Dynamic Contracts for Agentic Page Generation
+ */
+
+/** Action metadata entry in plugins-index.yaml */
+interface ActionIndexEntry {
+    name: string;
+    description: string;
+    /** Path to the .jay-action file (relative to project root) */
+    path: string;
+}
+/** Contract entry within a plugin in plugins-index.yaml */
+interface PluginContractEntry {
+    name: string;
+    description?: string;
+    type: 'static' | 'dynamic';
+    path: string;
+    metadata?: Record<string, unknown>;
+}
+/** Service entry in plugins-index.yaml (DL#125) */
+interface ServiceIndexEntry {
+    name: string;
+    marker: string;
+    description?: string;
+    doc?: string;
+}
+/** Context entry in plugins-index.yaml (DL#125) */
+interface ContextIndexEntry {
+    name: string;
+    marker: string;
+    description?: string;
+    doc?: string;
+}
+/** Route entry in plugins-index.yaml (DL#130) */
+interface RouteIndexEntry {
+    path: string;
+    description?: string;
+}
+/** CLI command entry in plugins-index.yaml (DL#142) */
+interface CommandIndexEntry {
+    name: string;
+    description?: string;
+}
+/** Entry for plugins-index.yaml (Design Log #85) */
+interface PluginsIndexEntry {
+    name: string;
+    path: string;
+    contracts: PluginContractEntry[];
+    /** Actions with .jay-action metadata (exposed to AI agents) */
+    actions?: ActionIndexEntry[];
+    /** Server-side services provided by this plugin (DL#125) */
+    services?: ServiceIndexEntry[];
+    /** Client-side contexts provided by this plugin (DL#125) */
+    contexts?: ContextIndexEntry[];
+    /** Plugin-provided routes (DL#130) */
+    routes?: RouteIndexEntry[];
+    /** CLI commands (DL#142) */
+    commands?: CommandIndexEntry[];
+}
+interface PluginsIndex {
+    plugins: PluginsIndexEntry[];
+}
+interface MaterializeContractsOptions {
+    projectRoot: string;
+    outputDir?: string;
+    force?: boolean;
+    dynamicOnly?: boolean;
+    pluginFilter?: string;
+    verbose?: boolean;
+    /** Optional Vite server for TypeScript support */
+    viteServer?: ViteSSRLoader$1;
+}
+interface MaterializeResult {
+    pluginsIndex: PluginsIndex;
+    staticCount: number;
+    dynamicCount: number;
+    outputDir: string;
+}
+/**
+ * Materializes all contracts (static references + dynamic generated) to disk.
+ *
+ * @param options - Materialization options
+ * @param services - Map of service markers to service instances (from init.ts)
+ */
+declare function materializeContracts(options: MaterializeContractsOptions, services?: Map<symbol, unknown>): Promise<MaterializeResult>;
+/**
+ * Lists contracts without writing files (for --list mode)
+ */
+declare function listContracts(options: MaterializeContractsOptions): Promise<PluginsIndex>;
+
+/**
+ * Plugin CLI Commands (Design Log #142)
+ *
+ * Plugins expose CLI commands via `commands` in plugin.yaml.
+ * Each command has a `makeCliCommand` handler and an optional `.jay-command` metadata file.
+ * Run via `jay-stack run <plugin>/<command>`.
+ */
+
+interface CommandMetadata {
+    name: string;
+    description?: string;
+    inputSchema?: Record<string, string>;
+}
+interface DiscoveredCommand {
+    pluginName: string;
+    pluginPath: string;
+    packageName: string;
+    isLocal: boolean;
+    commandName: string;
+    handlerExport: string;
+    pluginModule?: string;
+    metadata?: CommandMetadata;
+    metadataPath?: string;
+}
+interface CommandFlag {
+    flag: string;
+    description: string;
+    required: boolean;
+    type: 'string' | 'boolean' | 'number';
+}
+declare function discoverPluginCommands(options: {
+    projectRoot: string;
+    verbose?: boolean;
+    pluginFilter?: string;
+}): Promise<DiscoveredCommand[]>;
+declare function commandSchemaToFlags(inputSchema: Record<string, string>): CommandFlag[];
+declare function parseInputFromFlags(rawOptions: Record<string, any>, schema: Record<string, string>): Record<string, any>;
+declare function executePluginCommand(command: DiscoveredCommand, input: Record<string, any>, viteServer?: ViteSSRLoader$1): Promise<{
+    success: boolean;
+}>;
+
+/**
+ * Plugin Setup and Agent-Kit (Design Log #87)
+ *
+ * Two separate concerns:
+ *   - **Setup** (jay-stack setup): Config creation + credential/service validation
+ *   - **Agent-kit** (jay-stack agent-kit): Generate discovery data using live services
+ *
+ * Setup flow:
+ *   1. Scan plugins for `setup` in plugin.yaml
+ *   2. Run init for all plugins (dependency-ordered)
+ *   3. For each target plugin: load setup handler → call it → report result
+ *
+ * Agent-kit flow (called by agent-kit after materializing contracts):
+ *   1. Scan plugins for `agentkit` in plugin.yaml
+ *   2. Services are already initialized (agent-kit does this for contract materialization)
+ *   3. For each plugin: load agent-kit handler → call it → report result
+ */
+
+/**
+ * Thrown by non-interactive prompt when an answer is missing.
+ * The CLI catches this and prints structured output for agents.
+ */
+declare class SetupNeedsAnswerError extends Error {
+    readonly plugin: string;
+    readonly key: string;
+    readonly type: 'input' | 'confirm' | 'select';
+    readonly promptMessage: string;
+    readonly choices?: Array<{
+        name: string;
+        value: string;
+    }>;
+    constructor(plugin: string, key: string, type: 'input' | 'confirm' | 'select', promptMessage: string, choices?: Array<{
+        name: string;
+        value: string;
+    }>);
+}
+/**
+ * Information about a discovered plugin with a setup handler.
+ */
+interface PluginWithSetup {
+    /** Plugin name from plugin.yaml */
+    name: string;
+    /** Plugin path (directory containing plugin.yaml) */
+    pluginPath: string;
+    /** Package name for NPM plugins, or path for local plugins */
+    packageName: string;
+    /** Whether this is a local plugin */
+    isLocal: boolean;
+    /** Setup handler export name or relative path */
+    setupHandler: string;
+    /** Setup description from plugin.yaml */
+    setupDescription?: string;
+    /** Dependencies from package.json (for ordering) */
+    dependencies: string[];
+}
+/**
+ * Information about a discovered plugin with an agent-kit handler.
+ */
+interface PluginWithAgentKit {
+    /** Plugin name from plugin.yaml */
+    name: string;
+    /** Plugin path (directory containing plugin.yaml) */
+    pluginPath: string;
+    /** Package name for NPM plugins, or path for local plugins */
+    packageName: string;
+    /** Whether this is a local plugin */
+    isLocal: boolean;
+    /** Agent-kit handler export name */
+    agentKitHandler: string;
+    /** Dependencies from package.json (for ordering) */
+    dependencies: string[];
+}
+/**
+ * Discovers all plugins that have a `setup` handler in plugin.yaml.
+ */
+declare function discoverPluginsWithSetup(options: {
+    projectRoot: string;
+    verbose?: boolean;
+    pluginFilter?: string;
+}): Promise<PluginWithSetup[]>;
+/**
+ * Discovers all plugins that have an `agentkit` handler in plugin.yaml.
+ */
+declare function discoverPluginsWithAgentKit(options: {
+    projectRoot: string;
+    verbose?: boolean;
+    pluginFilter?: string;
+}): Promise<PluginWithAgentKit[]>;
+/**
+ * Loads and executes a plugin's setup handler.
+ */
+declare function executePluginSetup(plugin: PluginWithSetup, options: {
+    projectRoot: string;
+    configDir: string;
+    force: boolean;
+    interactive: boolean;
+    prompt: PluginSetupPrompt;
+    initError?: Error;
+    viteServer?: ViteSSRLoader$1;
+    verbose?: boolean;
+}): Promise<PluginSetupResult>;
+/**
+ * Loads and executes a plugin's agent-kit handler.
+ */
+declare function executePluginAgentKit(plugin: PluginWithAgentKit, options: {
+    projectRoot: string;
+    force: boolean;
+    initError?: Error;
+    viteServer?: ViteSSRLoader$1;
+    verbose?: boolean;
+}): Promise<PluginAgentKitResult>;
+
+/**
+ * Cache entry for pre-rendered jay-html
+ */
+interface SlowRenderCacheEntry {
+    /** Path to the pre-rendered jay-html file on disk */
+    preRenderedPath: string;
+    /** Pre-rendered jay-html content with cache metadata tag stripped */
+    preRenderedContent: string;
+    /** Slow ViewState that was baked into the jay-html */
+    slowViewState: object;
+    /** CarryForward data from slow rendering (passed to fast phase) */
+    carryForward: object;
+    /** Source jay-html path (for debugging) */
+    sourcePath: string;
+}
+/**
+ * Filesystem-based cache for pre-rendered jay-html files.
+ *
+ * Cache metadata (slowViewState, carryForward) is embedded in the pre-rendered
+ * file as a `<script type="application/jay-cache">` tag. This means:
+ * - Cache survives dev server restart
+ * - The filesystem is the single source of truth
+ * - No in-memory map needed for cache entries
+ *
+ * On read, the script tag is extracted and stripped before returning content.
+ */
+declare class SlowRenderCache {
+    /** Maps source jay-html path → set of pre-rendered file paths (for invalidation) */
+    private pathToFiles;
+    private readonly cacheDir;
+    private readonly pagesRoot;
+    /**
+     * @param cacheDir - Directory where pre-rendered jay-html files are stored
+     * @param pagesRoot - Root directory of the pages (for relative path calculation)
+     */
+    constructor(cacheDir: string, pagesRoot: string);
+    /**
+     * Get a cached pre-rendered jay-html entry by reading from disk.
+     * Returns undefined if the cache file doesn't exist or has no metadata tag.
+     */
+    get(jayHtmlPath: string, params: Record<string, string>, routeDir?: string): Promise<SlowRenderCacheEntry | undefined>;
+    /**
+     * Store a pre-rendered jay-html entry.
+     * Embeds metadata as a <script> tag and writes to disk.
+     * Returns the full cache entry with stripped content.
+     */
+    set(jayHtmlPath: string, params: Record<string, string>, preRenderedJayHtml: string, slowViewState: object, carryForward: object, routeDir?: string): Promise<SlowRenderCacheEntry>;
+    /**
+     * Check if a pre-rendered entry exists for the given path and params
+     */
+    has(jayHtmlPath: string, params: Record<string, string>, routeDir?: string): Promise<boolean>;
+    /**
+     * Invalidate all cached entries for a given jay-html source path.
+     * Deletes cached files from disk.
+     */
+    invalidate(jayHtmlPath: string): Promise<void>;
+    /**
+     * Invalidate all entries that depend on a changed file.
+     * The changedPath could be:
+     * - A jay-html file itself
+     * - A component file (page.ts)
+     * - Any other dependency
+     *
+     * @param changedPath - Absolute path to the changed file
+     * @param resolveDependencies - Optional function to resolve which jay-html files depend on the changed file
+     */
+    invalidateByDependency(changedPath: string, resolveDependencies?: (changedPath: string) => string[]): Promise<void>;
+    /**
+     * Clear all cached entries and delete cached files from disk
+     */
+    clear(): Promise<void>;
+    /**
+     * Get all cached jay-html paths (for debugging/monitoring)
+     */
+    getCachedPaths(): string[];
+    /**
+     * Compute the cache file path for a given jay-html path and params.
+     */
+    private computeCachePath;
+    /**
+     * Track a pre-rendered file path for invalidation.
+     */
+    private trackFile;
+    /**
+     * Scan the cache directory for files matching a route and delete them.
+     * Handles the startup case where pathToFiles is not populated from a previous session.
+     */
+    private scanAndDeleteCacheFiles;
+}
+
+export { type ActionDiscoveryOptions, type ActionDiscoveryResult, type ActionIndexEntry, type ActionMetadata, type ActionSchema, type CommandFlag, type CommandIndexEntry, type CommandMetadata, type ContextIndexEntry, type DevServerPagePart, type DiscoveredCommand, type GenerateClientScriptOptions, type HeadlessInstanceComponent, type LoadPagePartsOptions, type LoadedPageParts, type MaterializeContractsOptions, type MaterializeResult, type PluginActionDiscoveryOptions, type PluginContractEntry, type PluginWithAgentKit, type PluginWithSetup, type PluginsIndex, type PluginsIndexEntry, type ProjectClientInitInfo, type RouteIndexEntry, type ScriptFragments, type ServiceIndexEntry, SetupNeedsAnswerError, SlowRenderCache, type SlowRenderCacheEntry, type ViteSSRLoader, buildAutomationWrap, buildScriptFragments, clearServerElementCache, commandSchemaToFlags, discoverAllPluginActions, discoverAndRegisterActions, discoverPluginActions, discoverPluginCommands, discoverPluginsWithAgentKit, discoverPluginsWithSetup, executePluginAgentKit, executePluginCommand, executePluginSetup, generateClientScript, generateFrozenPageHtml, generatePromiseReconstruction, generateSSRPageHtml, headMetaToHeadTags, invalidateServerElementCache, listContracts, loadActionMetadata, loadPageParts, materializeContracts, parseActionMetadata, parseInputFromFlags, resolveActionMetadataPath, resolveViewStatePromises };