@jay-framework/production-server 0.25.5 → 0.26.0

package/dist/serve-index-D5MDxOoW.d.ts

@@ -0,0 +1,559 @@
+import * as _jay_framework_ssr_runtime from '@jay-framework/ssr-runtime';
+import { JayHtmlHeadMeta, JayHtmlScript, DevServerPagePart, HeadlessInstanceComponent, ForEachHeadlessInstance, ActionRegistry } from '@jay-framework/stack-server-runtime';
+import { HeadTag } from '@jay-framework/fullstack-component';
+
+interface RouteManifest {
+    version: string;
+    projectRoot: string;
+    sharedManifest: Record<string, string>;
+    routes: RouteEntry[];
+    actions: ActionEntry[];
+    plugins: PluginEntry[];
+    /**
+     * Site-level JSON-LD (Organization + WebSite) head tags, generated once at build from
+     * `.jay` `site` config and injected into every served page's `<head>` (DL#213). Empty/absent
+     * when `site.name` is not configured.
+     */
+    siteHeadTags?: HeadTag[];
+    /**
+     * Compiled error pages keyed by status token (`"404"`, `"502"`, `"5xx"`, …) (DL#218).
+     * Resolved by status (exact → family), never by URL — kept out of `routes[]` so they are
+     * non-navigable and excluded from sitemap/llms.txt/robots/internal-link validation.
+     */
+    errorPages?: Record<string, ErrorPageEntry>;
+}
+/**
+ * A compiled error page (DL#218). Mirrors the per-route compiled refs of a single-instance
+ * route, minus URL/param machinery: an error page is resolved by status, not by matching a URL.
+ */
+interface ErrorPageEntry {
+    /** Status token this page serves — exact (`"404"`, `"502"`) or family (`"4xx"`, `"5xx"`). */
+    token: string;
+    /** Per-page server element path (relative to backend dir). */
+    serverElementPath: string;
+    /** Per-page CSS file path (relative to frontend dir). */
+    routeCssPath?: string;
+    /** Per-page hydrate script path (relative to frontend dir). */
+    routeHydratePath?: string;
+    /** Per-page client bundle path (relative to frontend dir). */
+    routeClientBundlePath?: string;
+    /** External @import URLs extracted from CSS at build time. */
+    cssImports?: string[];
+    /** Head metadata from the error page's jay-html <head>. */
+    headMeta?: JayHtmlHeadMeta;
+    /** Passthrough `<script jay-script="allow">` tags from the template. */
+    scripts?: JayHtmlScript[];
+    /** Shared chunk package names this page's hydrate/client bundle imports (DL#177). */
+    sharedDeps?: string[];
+    /** trackBy map threaded to the client hydration entry. */
+    trackByMap?: Record<string, string>;
+    /**
+     * Optional pre-rendered slow (static chrome) ViewState. Unused in v1 — an error page is a
+     * pass-through of the injected `error` ViewState (DL#218 Q6); its static chrome renders
+     * from the template without slow data. The renderer merges `slowCache?.slowViewState ?? {}`.
+     */
+    slowCache?: CacheEntry;
+}
+interface RouteSegment {
+    type: 'static' | 'param' | 'optional' | 'catchAll' | 'optionalCatchAll';
+    value: string;
+}
+interface RouteEntry {
+    pattern: string;
+    segments: RouteSegment[];
+    serverModule: string;
+    trackByMap?: Record<string, string>;
+    contracts?: string[];
+    componentExport?: string;
+    /** Per-route server element path (DL#144). Shared across all instances. */
+    serverElementPath?: string;
+    /** Per-route CSS file path (DL#144). Extracted from route-level server element compilation. */
+    routeCssPath?: string;
+    /** Per-route hydrate script path (DL#144). Shared across all instances. */
+    routeHydratePath?: string;
+    /** Per-route client bundle path (DL#144). Entry that imports route hydrate script. */
+    routeClientBundlePath?: string;
+    /** External @import URLs extracted from CSS at build time (DL#146). Used for preload hints. */
+    cssImports?: string[];
+    /** Head metadata from jay-html <head> (title, meta tags). */
+    headMeta?: JayHtmlHeadMeta;
+    /** Passthrough `<script jay-script="allow">` tags from the jay-html template (DL#149 Phase 2). */
+    scripts?: JayHtmlScript[];
+    /** True when page has static <meta name="robots" content="noindex"> */
+    noIndex?: boolean;
+    isPlugin?: boolean;
+    pluginName?: string;
+    /** Shared chunk package names this route's hydrate script imports (DL#177). */
+    sharedDeps?: string[];
+    /** When true, dev-server tooling route (future: excluded from production builds). */
+    devOnly?: boolean;
+}
+/**
+ * A resolved instance of a route (Design Log #227). Synthesized by the store from the route and
+ * the params — only `params` is per-instance information; the rest is route-level.
+ */
+interface InstanceEntry {
+    params: Record<string, string>;
+    cachePath: string;
+    serverElementPath: string;
+    clientBundlePath: string;
+    clientCssPath?: string;
+}
+/** An instance as listed by `ArtifactStore.listInstances` (sitemap, llms.txt, …). */
+interface InstanceRef {
+    params: Record<string, string>;
+    cachePath: string;
+}
+interface CacheEntry {
+    slowViewState: object;
+    carryForward: object;
+    /** Epoch ms at which the slow data was rendered (Design Log #226). */
+    renderedAt?: number;
+    /** Freshness lifetime in seconds; undefined = never stale (#226). */
+    ttl?: number;
+    /** Absolute age in seconds up to which stale data is served immediately (#226). */
+    grace?: number;
+    /** Route pattern and params of the instance — makes the cache item its own index entry (#227). */
+    route?: string;
+    params?: Record<string, string>;
+}
+interface ActionEntry {
+    serverModule: string;
+    packageName?: string;
+    isPlugin: boolean;
+    actionNames: string[];
+}
+interface PluginEntry {
+    name: string;
+    packageName: string;
+}
+interface BuildMetadata {
+    version: string;
+    sourceHash: string;
+    buildTimestamp: string;
+    nodeVersion: string;
+    instanceCount: number;
+}
+interface BuildOptions {
+    version: string;
+    projectRoot: string;
+    pagesRoot: string;
+    buildRoot: string;
+    concurrency: number;
+    tsConfigFilePath: string;
+    minify?: boolean;
+    /** Site base URL for sitemap generation (e.g. "https://example.com"). */
+    siteBaseUrl?: string;
+    /** Site identity for Organization + WebSite JSON-LD generation (DL#213). */
+    site?: {
+        name?: string;
+        baseUrl?: string;
+        logo?: string;
+        description?: string;
+        sameAs?: string[];
+    };
+}
+interface ServerElementModule {
+    renderToStream: (vs: object, ctx: _jay_framework_ssr_runtime.ServerRenderContext) => void;
+}
+interface PageModule {
+    [key: string]: any;
+}
+
+interface PagePartsConfigEntry {
+    modulePath: string;
+    exportName: string;
+    source: 'local' | 'npm';
+    structural?: boolean;
+}
+interface PagePartsConfig {
+    parts: Array<PagePartsConfigEntry & {
+        key?: string;
+        contractInfo?: {
+            contractName: string;
+            metadata?: Record<string, unknown>;
+        };
+        headlessProps?: Record<string, string>;
+    }>;
+    instanceComponents: Array<PagePartsConfigEntry & {
+        contractName: string;
+        propNames: string[];
+        structuralTags?: Array<{
+            name: string;
+            phase?: string;
+        }>;
+    }>;
+    forEachInstances: Array<{
+        contractName: string;
+        forEachPath: string;
+        trackBy: string;
+        propBindings: Record<string, string>;
+        coordinateSuffix: string;
+    }>;
+    discoveredInstances?: any[];
+}
+interface ProductionPageParts {
+    parts: DevServerPagePart[];
+    headlessContracts: any[];
+    headlessInstanceComponents: HeadlessInstanceComponent[];
+    discoveredInstances: any[];
+    forEachInstances: ForEachHeadlessInstance[];
+    keyedPartModules: any[];
+    headlessModuleInfos: any[];
+}
+declare function loadPagePartsFromConfig(configPath: string, artifacts: ArtifactStore): Promise<ProductionPageParts>;
+
+/** Thrown by `readCacheData` when an instance has no stored data (Design Log #227). */
+declare class CacheNotFoundError extends Error {
+    readonly cachePath: string;
+    constructor(cachePath: string);
+}
+interface ListInstancesOptions {
+    /** Bypass the listing cache and re-read from the backing store. */
+    fresh?: boolean;
+}
+/**
+ * Interface for reading (and, optionally, updating) build artifacts at serve time (DL#143).
+ * FilesystemArtifactStore is the default implementation.
+ * BaaS deployments provide a custom implementation that fetches from cloud storage.
+ *
+ * Instances (Design Log #227): the manifest holds route structure only. A store resolves and
+ * enumerates the instances of a route itself; an instance's cache item is its own index entry, so
+ * writing one creates the instance and removing one deletes it — callers never touch a list.
+ */
+interface ArtifactStore {
+    readManifest(): Promise<RouteManifest>;
+    /** Throws {@link CacheNotFoundError} when the instance has no stored data. */
+    readCacheData(relativePath: string): Promise<CacheEntry>;
+    readPagePartsConfig(relativePath: string): Promise<PagePartsConfig>;
+    loadServerElement(relativePath: string): Promise<ServerElementModule>;
+    loadModule(modulePath: string, local?: boolean): Promise<any>;
+    getAssetPath(relativePath: string): string;
+    getBuildDir(): string;
+    /** Resolve the instance of `route` for `params`; `undefined` when it does not exist. */
+    getInstance(route: RouteEntry, params: Record<string, string>): Promise<InstanceEntry | undefined>;
+    /**
+     * Enumerate the instances of a route (sitemap, llms.txt, rebuild-all). Stores page through
+     * their backend and may serve a TTL-cached listing; `{ fresh: true }` re-reads.
+     */
+    listInstances(route: RouteEntry, options?: ListInstancesOptions): AsyncIterable<InstanceRef>;
+    /**
+     * Upsert an instance's data at its derived path and keep the store's instance index consistent
+     * (Design Log #226/#227). Absent → the store is read-only: refresh / render-on-miss are disabled.
+     */
+    writeCacheData?(route: RouteEntry, params: Record<string, string>, entry: CacheEntry): Promise<void>;
+    /** Remove an instance's data and index membership. */
+    removeInstance?(route: RouteEntry, params: Record<string, string>): Promise<void>;
+    /** Re-read an entry bypassing any local copy (shared stores: another server may have refreshed it). */
+    readCacheDataFresh?(relativePath: string): Promise<CacheEntry>;
+}
+/** The JSON stored for an instance: data + freshness + its own index fields. */
+declare function serializeCacheEntry(route: Pick<RouteEntry, 'pattern'>, params: Record<string, string>, entry: CacheEntry): string;
+/** Parse stored cache JSON into a CacheEntry. */
+declare function parseCacheEntry(json: string): CacheEntry;
+interface FilesystemArtifactStoreOptions {
+    /** Lifetime of cached instance listings (default 10 min). */
+    listTtlMs?: number;
+    /** Clock, for tests. */
+    now?: () => number;
+}
+declare class FilesystemArtifactStore implements ArtifactStore {
+    private basePath;
+    private manifestCache?;
+    private metadataMtime?;
+    private moduleCache;
+    private readonly listCache;
+    constructor(basePath: string, options?: FilesystemArtifactStoreOptions);
+    readManifest(): Promise<RouteManifest>;
+    readCacheData(relativePath: string): Promise<CacheEntry>;
+    readPagePartsConfig(relativePath: string): Promise<PagePartsConfig>;
+    loadServerElement(relativePath: string): Promise<ServerElementModule>;
+    getAssetPath(relativePath: string): string;
+    getBuildDir(): string;
+    getInstance(route: RouteEntry, params: Record<string, string>): Promise<InstanceEntry | undefined>;
+    listInstances(route: RouteEntry, options?: ListInstancesOptions): AsyncIterable<InstanceRef>;
+    writeCacheData(route: RouteEntry, params: Record<string, string>, entry: CacheEntry): Promise<void>;
+    removeInstance(route: RouteEntry, params: Record<string, string>): Promise<void>;
+    loadModule(modulePath: string, local?: boolean): Promise<any>;
+    /** Scan a route's directory for `*.cache.json` and read each instance's params. */
+    private scanInstances;
+}
+
+/** A route whose segments match a request path (before the instance is resolved). */
+interface RouteMatch {
+    route: RouteEntry;
+    params: Record<string, string>;
+    pathname: string;
+}
+/** A matched route with its resolved instance. */
+interface MatchResult {
+    route: RouteEntry;
+    instance: InstanceEntry;
+    params: Record<string, string>;
+    pathname: string;
+}
+/**
+ * Every route whose segments match `pathname`, in manifest (specificity) order, with the extracted
+ * params. The instance is resolved separately through the store (`getInstance`), so a route can
+ * match without an instance existing — that is the render-on-miss case (Design Log #227).
+ */
+declare function matchRoutes(manifest: RouteManifest, pathname: string): Generator<RouteMatch>;
+
+/**
+ * In-memory negative cache for render-on-miss (Design Log #227).
+ *
+ * Remembers that slow render answered a real 404 for `(route, params)` so repeated requests for the
+ * same unknown instance cost nothing. Only genuine 404s are added — never errors or timeouts.
+ * Per server instance; entries expire after `ttlMs` and the oldest are evicted beyond `maxEntries`.
+ */
+declare class NegativeCache {
+    private readonly ttlMs;
+    private readonly maxEntries;
+    private readonly entries;
+    constructor(ttlMs?: number, maxEntries?: number);
+    has(key: string, now: number): boolean;
+    add(key: string, now: number): void;
+    /** Forget a key (e.g. when the instance turned out to exist). */
+    delete(key: string): void;
+    get size(): number;
+}
+
+/**
+ * Outcome of running the slow phase for one instance (Design Log #226/#227).
+ *
+ * - `rendered` — a fresh cache entry (with `renderedAt` / `ttl` / `grace`). Nothing is persisted here.
+ * - `notFound` — slow render answered a deterministic client error (404, 410, 400, 422, …): the item
+ *   cannot be rendered for these params, exactly like the build, which skips them.
+ * - `redirect` — slow render returned a redirect (e.g. a renamed slug): served as that redirect.
+ * - `error` — anything else (5xx, 401/403/408/429, thrown): transient, never negative-cached.
+ */
+type RenderInstanceOutcome = {
+    kind: 'rendered';
+    entry: CacheEntry;
+} | {
+    kind: 'notFound';
+} | {
+    kind: 'redirect';
+    status: number;
+    location: string;
+} | {
+    kind: 'error';
+    reason: string;
+};
+type RenderInstanceFn = (route: RouteEntry, params: Record<string, string>, artifacts: ArtifactStore, now: number) => Promise<RenderInstanceOutcome>;
+
+/** Result of asking for a background refresh of an existing instance. */
+type RefreshStart = 
+/** A refresh is running (started now, or joined an in-flight one). `done` never rejects. */
+{
+    kind: 'started' | 'joined';
+    done: Promise<CacheEntry | undefined>;
+}
+/** All slow-render slots are taken by other instances — nothing started, nothing queued. */
+ | {
+    kind: 'busy';
+}
+/** Refresh is not possible right now: store is read-only, or the instance is in failure backoff. */
+ | {
+    kind: 'skipped';
+};
+/** Result of render-on-miss for an instance that does not exist yet (Design Log #227). */
+type MissOutcome = {
+    kind: 'rendered';
+    instance: InstanceEntry;
+}
+/** The item does not exist (slow render answered a deterministic 4xx, e.g. 404). */
+ | {
+    kind: 'notFound';
+}
+/** Slow render redirected (e.g. renamed slug): respond with this redirect. */
+ | {
+    kind: 'redirect';
+    status: number;
+    location: string;
+}
+/** Could not render now: no free slot, timeout, error, or backoff. Respond 503 + Retry-After. */
+ | {
+    kind: 'unavailable';
+    retryAfterSeconds: number;
+};
+interface InstanceRendererOptions {
+    /** Max concurrent slow renders (refresh + miss). Env `JAY_SLOW_RENDER_CONCURRENCY`, default 5. */
+    concurrency?: number;
+    /** Max wait of a render-on-miss. Env `JAY_MISS_TIMEOUT_MS`, default 8000. */
+    missTimeoutMs?: number;
+    retryAfterSeconds?: number;
+    negativeCache?: NegativeCache;
+    now?: () => number;
+    /** Slow-render function (tests inject fakes). */
+    render?: RenderInstanceFn;
+}
+/**
+ * Runs the slow phase for single instances in production (Design Log #226 / #227).
+ *
+ * - **Single-flight**: all concurrent requests for one instance (same route + params → same key)
+ *   share one slow render, one slot and one write; followers never take a slot.
+ * - **Fixed slots, no queue**: at most `concurrency` renders run at once. When all slots are taken
+ *   by other instances a refresh answers `busy` (the caller serves the old data) and a miss answers
+ *   `unavailable` (the caller responds 503). Nothing is ever queued.
+ * - **Backoff**: a failed render puts the instance into exponential backoff.
+ * - **Negative cache**: a deterministic 4xx (404, 410, 400, 422, …) and redirects are remembered
+ *   (10 min); transient errors (401/403/408/429, 5xx, thrown) never are.
+ *
+ * Persisting goes through the {@link ArtifactStore} (`writeCacheData` / `removeInstance`), so the
+ * same code serves the filesystem and shared stores.
+ */
+declare class InstanceRenderer {
+    private readonly store;
+    private readonly concurrency;
+    private readonly missTimeoutMs;
+    private readonly retryAfterSeconds;
+    private readonly negativeCache;
+    private readonly now;
+    private readonly render;
+    private readonly flights;
+    private readonly backoff;
+    private readonly redirects;
+    private slotsInUse;
+    private busyCount;
+    constructor(store: ArtifactStore, options?: InstanceRendererOptions);
+    /** True when the store can persist rendered instances (otherwise refresh / render-on-miss are off). */
+    get canWrite(): boolean;
+    /** Monitoring counters. */
+    stats(): {
+        slotsInUse: number;
+        inFlight: number;
+        busy: number;
+        negativeEntries: number;
+    };
+    /**
+     * Refresh an existing instance in the background. Never waits for a slot and never throws.
+     * Callers may await `done` (only for `started` / `joined`) up to their own budget.
+     */
+    refresh(route: RouteEntry, params: Record<string, string>): RefreshStart;
+    /**
+     * Serve an instance that does not exist yet: render it once for all concurrent requests,
+     * persist it, and return the synthesized instance. A real 404 is negative-cached.
+     */
+    renderMissing(route: RouteEntry, params: Record<string, string>): Promise<MissOutcome>;
+    /** True when `(route, params)` is remembered as non-existent. */
+    isKnownMissing(route: RouteEntry, params: Record<string, string>): boolean;
+    private unavailable;
+    private inBackoff;
+    private startFlight;
+    private runFlight;
+    private rememberRedirect;
+    private recordFailure;
+    private toEntry;
+    private withTimeout;
+}
+
+type ResolveResult = {
+    kind: 'matched';
+    match: MatchResult;
+}
+/** No route/instance matches (and none could be rendered): respond with the 404 page. */
+ | {
+    kind: 'notFound';
+}
+/** The slow render of an unknown instance redirected: respond with this redirect. */
+ | {
+    kind: 'redirect';
+    status: number;
+    location: string;
+}
+/**
+ * An unknown instance could not be rendered right now (no free slow-render slot, timeout, error):
+ * respond `503` with `Retry-After`. Never cached — we cannot tell whether the item exists.
+ */
+ | {
+    kind: 'unavailable';
+    retryAfterSeconds: number;
+};
+/**
+ * Resolve a request path to a route + instance (Design Log #227).
+ *
+ * For each route whose segments match (in specificity order) the store resolves the instance. A
+ * matching route without an instance is rendered on demand through the {@link InstanceRenderer}
+ * (single-flight, shared slow-render slots, negative cache). A real 404 falls through to the next
+ * matching route, exactly like "no instance" did before; no renderer means build-time-only
+ * instances (the previous behavior).
+ */
+declare function resolveRequest(manifest: RouteManifest, pathname: string, store: ArtifactStore, renderer?: InstanceRenderer): Promise<ResolveResult>;
+
+/** Default lifetime of cached instance listings: 10 minutes (Design Log #227, A3). */
+declare const DEFAULT_LIST_TTL_MS: number;
+/**
+ * Small stale-while-revalidate cache for expensive, rarely-needed reads such as instance listings
+ * (Design Log #227). Within `ttlMs` the cached value is returned; past it the stale value is
+ * returned immediately while one background reload runs (single-flight). `fresh: true` awaits a
+ * reload. A failed background reload keeps the previous value.
+ */
+declare class SwrCache<V> {
+    private readonly ttlMs;
+    private readonly now;
+    private readonly entries;
+    private readonly inflight;
+    constructor(ttlMs?: number, now?: () => number);
+    get(key: string, load: () => Promise<V>, fresh?: boolean): Promise<V>;
+    /** Forget a key so the next `get` reloads (e.g. after a local write). */
+    invalidate(key: string): void;
+    private reload;
+}
+
+/**
+ * Instance identity (Design Log #227): an instance of a route is identified by its params, and its
+ * data lives at a deterministic path derived from `(route pattern, params)`. Build, rebuild,
+ * refresh and render-on-miss all derive the path through this one module, so they agree.
+ */
+/** Stable JSON of params (keys sorted) — the canonical form hashed into the instance id. */
+declare function canonicalParams(params: Record<string, string>): string;
+/** Key for maps/sets of instances of one route: `<pattern>:<canonical params>`. */
+declare function instanceKey(routePattern: string, params: Record<string, string>): string;
+/** Directory (relative to the backend dir) holding a route's instance files and page-parts.json. */
+declare function routeInstanceDir(routePattern: string): string;
+/** Path (relative to the backend dir) of an instance's cache data. */
+declare function deriveCachePath(routePattern: string, params: Record<string, string>): string;
+/**
+ * The instance entry for `(route, params)`. Everything except `params`/`cachePath` is route-level
+ * (server element, client bundle, CSS), so nothing per-instance is stored beyond the data itself.
+ */
+declare function synthesizeInstance(route: Pick<RouteEntry, 'pattern' | 'serverElementPath' | 'routeClientBundlePath' | 'routeCssPath'>, params: Record<string, string>): InstanceEntry;
+declare function toInstanceRef(route: Pick<RouteEntry, 'pattern'>, params: Record<string, string>): InstanceRef;
+
+declare function fetchPageRequest(match: MatchResult, manifest: RouteManifest, requestUrl: URL, artifacts: ArtifactStore, staticBaseUrl: string, cookies?: Record<string, string>, renderer?: InstanceRenderer): Promise<Response>;
+
+declare function isActionRequest(pathname: string): boolean;
+declare function fetchActionRequest(request: Request, registry?: ActionRegistry): Promise<Response>;
+declare function registerActionsFromManifest(actions: Array<{
+    serverModule: string;
+    isPlugin: boolean;
+    actionNames: string[];
+    packageName?: string;
+}>, buildDir: string, registry?: ActionRegistry): Promise<void>;
+/**
+ * Register actions from pre-imported modules (DL#143).
+ * Used by BaaS entry.mjs where action modules are bundled by esbuild.
+ */
+declare function registerActionsFromModules(modules: Array<{
+    module: Record<string, unknown>;
+    name: string;
+}>, registry?: ActionRegistry): Promise<void>;
+
+declare function fetchStaticFile(pathname: string, frontendDir: string): Promise<Response | null>;
+
+interface PreImportedPlugin {
+    name: string;
+    init: {
+        _serverInit: () => Promise<any>;
+    };
+}
+/**
+ * Initialize services from pre-imported plugin modules (DL#143).
+ * Used by BaaS entry.mjs where plugins are bundled by esbuild
+ * and cannot be discovered from the filesystem at runtime.
+ */
+declare function initializeServicesFromModules(plugins: PreImportedPlugin[], label: string): Promise<void>;
+declare function initializeServices(buildDir: string, projectRoot: string, label: string): Promise<void>;
+
+export { type ArtifactStore as A, type BuildMetadata as B, type CacheEntry as C, DEFAULT_LIST_TTL_MS as D, type ErrorPageEntry as E, FilesystemArtifactStore as F, parseCacheEntry as G, registerActionsFromManifest as H, type InstanceEntry as I, registerActionsFromModules as J, resolveRequest as K, type ListInstancesOptions as L, type MatchResult as M, routeInstanceDir as N, serializeCacheEntry as O, type PageModule as P, synthesizeInstance as Q, type RouteManifest as R, type ServerElementModule as S, toInstanceRef as T, type RouteEntry as a, type ActionEntry as b, type BuildOptions as c, CacheNotFoundError as d, type InstanceRef as e, InstanceRenderer as f, type InstanceRendererOptions as g, type MissOutcome as h, type PluginEntry as i, type PreImportedPlugin as j, type RefreshStart as k, type ResolveResult as l, type RouteMatch as m, type RouteSegment as n, SwrCache as o, canonicalParams as p, deriveCachePath as q, fetchActionRequest as r, fetchPageRequest as s, fetchStaticFile as t, initializeServices as u, initializeServicesFromModules as v, instanceKey as w, isActionRequest as x, loadPagePartsFromConfig as y, matchRoutes as z };

package/dist/serve-index.d.ts

@@ -1,4 +1,4 @@
-export { A as ArtifactStore, C as CacheEntry, F as FilesystemArtifactStore, I as InstanceEntry, M as MatchResult, e as PreImportedPlugin, a as RouteEntry, R as RouteManifest, S as ServerElementModule, g as fetchActionRequest, h as fetchPageRequest, i as fetchStaticFile, j as initializeServices, k as initializeServicesFromModules, l as isActionRequest, n as matchRequest, r as registerActionsFromManifest, o as registerActionsFromModules } from './serve-index-C28bP6tW.js';
+export { A as ArtifactStore, C as CacheEntry, d as CacheNotFoundError, D as DEFAULT_LIST_TTL_MS, F as FilesystemArtifactStore, I as InstanceEntry, e as InstanceRef, f as InstanceRenderer, g as InstanceRendererOptions, L as ListInstancesOptions, M as MatchResult, h as MissOutcome, j as PreImportedPlugin, k as RefreshStart, l as ResolveResult, a as RouteEntry, R as RouteManifest, m as RouteMatch, S as ServerElementModule, o as SwrCache, p as canonicalParams, q as deriveCachePath, r as fetchActionRequest, s as fetchPageRequest, t as fetchStaticFile, u as initializeServices, v as initializeServicesFromModules, w as instanceKey, x as isActionRequest, z as matchRoutes, G as parseCacheEntry, H as registerActionsFromManifest, J as registerActionsFromModules, K as resolveRequest, N as routeInstanceDir, O as serializeCacheEntry, Q as synthesizeInstance, T as toInstanceRef } from './serve-index-D5MDxOoW.js';
 import '@jay-framework/ssr-runtime';
 import '@jay-framework/stack-server-runtime';
 import '@jay-framework/fullstack-component';

package/dist/serve-index.js

@@ -1,13 +1,26 @@
-import { F, f, a, b, i, c, d, m, r, e } from "./init-services-CG_wDJmY.js";
+import { C, D, F, I, S, c, d, f, a, b, i, e, g, h, m, p, r, j, k, l, s, n, t } from "./init-services-CItlWIEg.js";
 export {
+  C as CacheNotFoundError,
+  D as DEFAULT_LIST_TTL_MS,
   F as FilesystemArtifactStore,
+  I as InstanceRenderer,
+  S as SwrCache,
+  c as canonicalParams,
+  d as deriveCachePath,
   f as fetchActionRequest,
   a as fetchPageRequest,
   b as fetchStaticFile,
   i as initializeServices,
-  c as initializeServicesFromModules,
-  d as isActionRequest,
-  m as matchRequest,
+  e as initializeServicesFromModules,
+  g as instanceKey,
+  h as isActionRequest,
+  m as matchRoutes,
+  p as parseCacheEntry,
   r as registerActionsFromManifest,
-  e as registerActionsFromModules
+  j as registerActionsFromModules,
+  k as resolveRequest,
+  l as routeInstanceDir,
+  s as serializeCacheEntry,
+  n as synthesizeInstance,
+  t as toInstanceRef
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jay-framework/production-server",
-  "version": "0.25.5",
+  "version": "0.26.0",
   "license": "Apache-2.0",
   "type": "module",
   "main": "dist/index.js",
@@ -30,18 +30,18 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@jay-framework/fullstack-component": "^0.25.5",
-    "@jay-framework/logger": "^0.25.5",
-    "@jay-framework/ssr-runtime": "^0.25.5",
-    "@jay-framework/stack-server-runtime": "^0.25.5",
-    "@jay-framework/view-state-merge": "^0.25.5"
+    "@jay-framework/fullstack-component": "^0.26.0",
+    "@jay-framework/logger": "^0.26.0",
+    "@jay-framework/ssr-runtime": "^0.26.0",
+    "@jay-framework/stack-server-runtime": "^0.26.0",
+    "@jay-framework/view-state-merge": "^0.26.0"
   },
   "devDependencies": {
-    "@jay-framework/dev-environment": "^0.25.5",
+    "@jay-framework/dev-environment": "^0.26.0",
     "@types/node": "^22.15.21",
     "rimraf": "^5.0.5",
     "tsup": "^8.0.1",
     "typescript": "^5.3.3",
-    "vitest": "^1.2.1"
+    "vitest": "^4.1.11"
   }
 }