@jay-framework/production-server 0.25.5 → 0.26.0

package/dist/init-services-CItlWIEg.js

@@ -0,0 +1,1448 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import fs from "node:fs/promises";
+import path from "node:path";
+import { makePassthroughInstanceComponent, DevSlowlyChangingPhase, slowRenderInstances, resolveFreshness, mergeFreshness, resolveErrorPageToken, buildErrorViewState, headMetaToHeadTags, mergeHeadTags, serializeHeadTags, serializeScripts, getClientInitData, DEFAULT_GRACE_SECONDS, renderFastChangingData, actionRegistry, needsSameOriginCheck, crossOriginErrorResponse, isCrossOriginRequest, isSecureRequest, parseCookies, setClientInitData } from "@jay-framework/stack-server-runtime";
+import { getLogger } from "@jay-framework/logger";
+import { deepMergeViewStates } from "@jay-framework/view-state-merge";
+import { asyncSwapScript } from "@jay-framework/ssr-runtime";
+import crypto from "node:crypto";
+import { isJayAction, isJayStreamAction } from "@jay-framework/fullstack-component";
+async function generateSitemap(manifest, store, baseUrl, outputPath) {
+  const base = baseUrl.replace(/\/$/, "");
+  const urls = [];
+  for (const route of manifest.routes) {
+    if (route.devOnly) continue;
+    if (route.noIndex) continue;
+    let count = 0;
+    for await (const instance of store.listInstances(route)) {
+      count++;
+      const urlPath = buildUrlFromManifest(route.pattern, instance.params);
+      urls.push(`${base}${urlPath}`);
+    }
+    if (count === 0) {
+      const hasDynamic = route.segments.some((s) => s.type !== "static");
+      if (!hasDynamic) {
+        const urlPath = route.pattern === "/" ? "/" : route.pattern;
+        urls.push(`${base}${urlPath}`);
+      }
+    }
+  }
+  const tmpPath = outputPath + ".tmp";
+  const handle = await fs.open(tmpPath, "w");
+  try {
+    await handle.write('<?xml version="1.0" encoding="UTF-8"?>\n');
+    await handle.write('<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n');
+    for (const url of urls) {
+      await handle.write(`  <url><loc>${escapeXml(url)}</loc></url>
+`);
+    }
+    await handle.write("</urlset>\n");
+  } finally {
+    await handle.close();
+  }
+  await fs.rename(tmpPath, outputPath);
+  return urls.length;
+}
+function buildUrlFromManifest(pattern, params) {
+  return pattern.replace(/\[\[(\w+)\]\]/g, (_, name) => params[name] || "").replace(/\[\.\.\.(\w+)\]/g, (_, name) => params[name] || "").replace(/\[(\w+)\]/g, (_, name) => params[name] || "").replace(/\/\/+/g, "/").replace(/\/$/, "") || "/";
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function canonicalParams(params) {
+  const sorted = Object.keys(params).sort().reduce(
+    (acc, key) => {
+      acc[key] = params[key];
+      return acc;
+    },
+    {}
+  );
+  return JSON.stringify(sorted);
+}
+function instanceKey(routePattern, params) {
+  return `${routePattern}:${canonicalParams(params)}`;
+}
+function hashParams(params) {
+  const json = canonicalParams(params);
+  if (json === "{}") return "";
+  return "_" + crypto.createHash("md5").update(json).digest("hex").substring(0, 8);
+}
+function routeDirOf(routePattern) {
+  return routePattern.replace(/^\//, "") || "index";
+}
+function instanceIdOf(params) {
+  return `page${hashParams(params)}`;
+}
+function routeInstanceDir(routePattern) {
+  return `pre-rendered/${routeDirOf(routePattern)}`;
+}
+function deriveCachePath(routePattern, params) {
+  return `${routeInstanceDir(routePattern)}/${instanceIdOf(params)}.cache.json`;
+}
+function pagePartsConfigPath(routePattern) {
+  return `${routeInstanceDir(routePattern)}/page-parts.json`;
+}
+function synthesizeInstance(route, params) {
+  return {
+    params,
+    cachePath: deriveCachePath(route.pattern, params),
+    serverElementPath: route.serverElementPath ?? "",
+    clientBundlePath: route.routeClientBundlePath ?? "",
+    clientCssPath: route.routeCssPath
+  };
+}
+function toInstanceRef(route, params) {
+  return { params, cachePath: deriveCachePath(route.pattern, params) };
+}
+const DEFAULT_LIST_TTL_MS = 10 * 6e4;
+class SwrCache {
+  constructor(ttlMs = DEFAULT_LIST_TTL_MS, now = Date.now) {
+    __publicField(this, "entries", /* @__PURE__ */ new Map());
+    __publicField(this, "inflight", /* @__PURE__ */ new Map());
+    this.ttlMs = ttlMs;
+    this.now = now;
+  }
+  async get(key, load, fresh = false) {
+    const entry = this.entries.get(key);
+    if (!entry || fresh) return this.reload(key, load);
+    if (this.now() - entry.loadedAt >= this.ttlMs) {
+      this.reload(key, load).catch(() => void 0);
+    }
+    return entry.value;
+  }
+  /** Forget a key so the next `get` reloads (e.g. after a local write). */
+  invalidate(key) {
+    this.entries.delete(key);
+  }
+  reload(key, load) {
+    const existing = this.inflight.get(key);
+    if (existing) return existing;
+    const promise = load().then((value) => {
+      this.entries.set(key, { value, loadedAt: this.now() });
+      return value;
+    }).finally(() => {
+      this.inflight.delete(key);
+    });
+    this.inflight.set(key, promise);
+    return promise;
+  }
+}
+class CacheNotFoundError extends Error {
+  constructor(cachePath) {
+    super(`Cache data not found: ${cachePath}`);
+    this.cachePath = cachePath;
+    this.name = "CacheNotFoundError";
+  }
+}
+function serializeCacheEntry(route, params, entry) {
+  return JSON.stringify({
+    slowViewState: entry.slowViewState,
+    carryForward: entry.carryForward,
+    ...entry.renderedAt !== void 0 && { renderedAt: entry.renderedAt },
+    ...entry.ttl !== void 0 && { ttl: entry.ttl },
+    ...entry.grace !== void 0 && { grace: entry.grace },
+    route: route.pattern,
+    params
+  });
+}
+function parseCacheEntry(json) {
+  const cacheData = JSON.parse(json);
+  return {
+    slowViewState: cacheData.slowViewState || {},
+    carryForward: cacheData.carryForward || {},
+    ...cacheData.renderedAt !== void 0 && { renderedAt: cacheData.renderedAt },
+    ...cacheData.ttl !== void 0 && { ttl: cacheData.ttl },
+    ...cacheData.grace !== void 0 && { grace: cacheData.grace },
+    ...cacheData.route !== void 0 && { route: cacheData.route },
+    ...cacheData.params !== void 0 && { params: cacheData.params }
+  };
+}
+class FilesystemArtifactStore {
+  constructor(basePath, options = {}) {
+    __publicField(this, "manifestCache");
+    __publicField(this, "metadataMtime");
+    __publicField(this, "moduleCache", /* @__PURE__ */ new Map());
+    __publicField(this, "listCache");
+    this.basePath = basePath;
+    this.listCache = new SwrCache(
+      options.listTtlMs ?? DEFAULT_LIST_TTL_MS,
+      options.now ?? Date.now
+    );
+  }
+  async readManifest() {
+    const metadataPath = path.join(this.basePath, "build-metadata.json");
+    const manifestPath = path.join(this.basePath, "route-manifest.json");
+    try {
+      const metaStat = await fs.stat(metadataPath);
+      if (this.manifestCache && this.metadataMtime === metaStat.mtimeMs) {
+        return this.manifestCache.manifest;
+      }
+      this.metadataMtime = metaStat.mtimeMs;
+    } catch {
+    }
+    const manifest = JSON.parse(await fs.readFile(manifestPath, "utf-8"));
+    const manifestStat = await fs.stat(manifestPath);
+    this.manifestCache = { manifest, mtime: manifestStat.mtimeMs };
+    return manifest;
+  }
+  async readCacheData(relativePath) {
+    const fullPath = path.join(this.basePath, relativePath);
+    let content;
+    try {
+      content = await fs.readFile(fullPath, "utf-8");
+    } catch (err) {
+      if (err?.code === "ENOENT") throw new CacheNotFoundError(relativePath);
+      throw err;
+    }
+    return parseCacheEntry(content);
+  }
+  async readPagePartsConfig(relativePath) {
+    return JSON.parse(await fs.readFile(path.join(this.basePath, relativePath), "utf-8"));
+  }
+  async loadServerElement(relativePath) {
+    return this.loadModule(relativePath);
+  }
+  getAssetPath(relativePath) {
+    return path.join(this.basePath, relativePath);
+  }
+  getBuildDir() {
+    return this.basePath;
+  }
+  async getInstance(route, params) {
+    const cachePath = deriveCachePath(route.pattern, params);
+    try {
+      await fs.stat(path.join(this.basePath, cachePath));
+    } catch (err) {
+      if (err?.code === "ENOENT") return void 0;
+      throw err;
+    }
+    return synthesizeInstance(route, params);
+  }
+  async *listInstances(route, options) {
+    const refs = await this.listCache.get(
+      route.pattern,
+      () => this.scanInstances(route),
+      options?.fresh === true
+    );
+    for (const ref of refs) yield ref;
+  }
+  async writeCacheData(route, params, entry) {
+    const cachePath = deriveCachePath(route.pattern, params);
+    const fullPath = path.join(this.basePath, cachePath);
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    const tmpPath = `${fullPath}.${process.pid}.${Date.now().toString(36)}.tmp`;
+    await fs.writeFile(tmpPath, serializeCacheEntry(route, params, entry), "utf-8");
+    await fs.rename(tmpPath, fullPath);
+    this.listCache.invalidate(route.pattern);
+  }
+  async removeInstance(route, params) {
+    const fullPath = path.join(this.basePath, deriveCachePath(route.pattern, params));
+    try {
+      await fs.unlink(fullPath);
+    } catch (err) {
+      if (err?.code !== "ENOENT") throw err;
+    }
+    this.listCache.invalidate(route.pattern);
+  }
+  async loadModule(modulePath, local) {
+    if (local !== false) {
+      const fullPath = path.isAbsolute(modulePath) ? modulePath : path.join(this.basePath, modulePath);
+      try {
+        const stat = await fs.stat(fullPath);
+        const cached = this.moduleCache.get(modulePath);
+        if (cached && stat.mtimeMs === cached.mtime) {
+          return cached.module;
+        }
+        const mod = await import(fullPath + "?t=" + stat.mtimeMs);
+        this.moduleCache.set(modulePath, { module: mod, mtime: stat.mtimeMs });
+        return mod;
+      } catch {
+        if (local) throw new Error(`Local module not found: ${fullPath}`);
+      }
+    }
+    return import(modulePath);
+  }
+  /** Scan a route's directory for `*.cache.json` and read each instance's params. */
+  async scanInstances(route) {
+    const dir = routeInstanceDir(route.pattern);
+    let files;
+    try {
+      files = await fs.readdir(path.join(this.basePath, dir));
+    } catch (err) {
+      if (err?.code === "ENOENT") return [];
+      throw err;
+    }
+    const refs = [];
+    for (const file of files.filter((f) => f.endsWith(".cache.json")).sort()) {
+      try {
+        const content = await fs.readFile(path.join(this.basePath, dir, file), "utf-8");
+        const { params, route: storedRoute } = JSON.parse(content);
+        if (!params || storedRoute !== void 0 && storedRoute !== route.pattern)
+          continue;
+        refs.push({ params, cachePath: `${dir}/${file}` });
+      } catch {
+      }
+    }
+    return refs;
+  }
+}
+function* matchRoutes(manifest, pathname) {
+  const urlSegments = pathname.split("/").filter((s) => s.length > 0);
+  for (const route of manifest.routes) {
+    const params = matchSegments(route.segments, urlSegments);
+    if (params) {
+      yield { route, params, pathname };
+    }
+  }
+}
+function matchSegments(routeSegments, urlSegments) {
+  const params = {};
+  let urlIdx = 0;
+  for (let i = 0; i < routeSegments.length; i++) {
+    const seg = routeSegments[i];
+    if (seg.type === "static") {
+      if (urlIdx >= urlSegments.length || urlSegments[urlIdx] !== seg.value) {
+        return void 0;
+      }
+      urlIdx++;
+    } else if (seg.type === "param") {
+      if (urlIdx >= urlSegments.length) return void 0;
+      params[seg.value] = urlSegments[urlIdx];
+      urlIdx++;
+    } else if (seg.type === "optional") {
+      if (urlIdx < urlSegments.length) {
+        params[seg.value] = urlSegments[urlIdx];
+        urlIdx++;
+      }
+    } else if (seg.type === "catchAll") {
+      if (urlIdx >= urlSegments.length) return void 0;
+      params[seg.value] = urlSegments.slice(urlIdx).join("/");
+      urlIdx = urlSegments.length;
+    } else if (seg.type === "optionalCatchAll") {
+      if (urlIdx < urlSegments.length) {
+        params[seg.value] = urlSegments.slice(urlIdx).join("/");
+        urlIdx = urlSegments.length;
+      }
+    }
+  }
+  if (urlIdx !== urlSegments.length) return void 0;
+  return params;
+}
+async function resolveRequest(manifest, pathname, store, renderer) {
+  for (const { route, params } of matchRoutes(manifest, pathname)) {
+    const existing = await store.getInstance(route, params);
+    if (existing) {
+      return { kind: "matched", match: { route, instance: existing, params, pathname } };
+    }
+    if (!renderer) continue;
+    const outcome = await renderer.renderMissing(route, params);
+    if (outcome.kind === "rendered") {
+      return {
+        kind: "matched",
+        match: { route, instance: outcome.instance, params, pathname }
+      };
+    }
+    if (outcome.kind === "redirect") {
+      return { kind: "redirect", status: outcome.status, location: outcome.location };
+    }
+    if (outcome.kind === "unavailable") {
+      return { kind: "unavailable", retryAfterSeconds: outcome.retryAfterSeconds };
+    }
+  }
+  return { kind: "notFound" };
+}
+const DEFAULT_NEGATIVE_TTL_MS = 10 * 6e4;
+const DEFAULT_NEGATIVE_MAX_ENTRIES = 1e4;
+class NegativeCache {
+  constructor(ttlMs = DEFAULT_NEGATIVE_TTL_MS, maxEntries = DEFAULT_NEGATIVE_MAX_ENTRIES) {
+    // Map iteration order is insertion order — re-inserting on hit/add keeps it LRU-ordered.
+    __publicField(this, "entries", /* @__PURE__ */ new Map());
+    this.ttlMs = ttlMs;
+    this.maxEntries = maxEntries;
+  }
+  has(key, now) {
+    const expiresAt = this.entries.get(key);
+    if (expiresAt === void 0) return false;
+    if (expiresAt <= now) {
+      this.entries.delete(key);
+      return false;
+    }
+    this.entries.delete(key);
+    this.entries.set(key, expiresAt);
+    return true;
+  }
+  add(key, now) {
+    this.entries.delete(key);
+    this.entries.set(key, now + this.ttlMs);
+    while (this.entries.size > this.maxEntries) {
+      const oldest = this.entries.keys().next().value;
+      this.entries.delete(oldest);
+    }
+  }
+  /** Forget a key (e.g. when the instance turned out to exist). */
+  delete(key) {
+    this.entries.delete(key);
+  }
+  get size() {
+    return this.entries.size;
+  }
+}
+async function loadPagePartsFromConfig(configPath, artifacts) {
+  const config = await artifacts.readPagePartsConfig(configPath);
+  async function importModule(entry) {
+    if (!entry.modulePath) {
+      throw new Error(
+        `Empty modulePath in page-parts.json for "${entry.exportName}" (source: ${entry.source}). Rebuild required.`
+      );
+    }
+    return artifacts.loadModule(entry.modulePath, entry.source === "local");
+  }
+  const parts = [];
+  for (const entry of config.parts) {
+    const mod = await importModule(entry);
+    parts.push({
+      compDefinition: mod[entry.exportName] ?? mod.default,
+      key: entry.key,
+      clientImport: "",
+      clientPart: "",
+      contractInfo: entry.contractInfo,
+      headlessProps: entry.headlessProps
+    });
+  }
+  const headlessInstanceComponents = [];
+  for (const entry of config.instanceComponents) {
+    const serveTimeContract = {
+      props: entry.propNames.map((name) => ({ name }))
+    };
+    if (entry.structural) {
+      headlessInstanceComponents.push({
+        contractName: entry.contractName,
+        compDefinition: makePassthroughInstanceComponent(entry.structuralTags ?? []),
+        contract: serveTimeContract
+      });
+      continue;
+    }
+    const mod = await importModule(entry);
+    headlessInstanceComponents.push({
+      contractName: entry.contractName,
+      compDefinition: mod[entry.exportName] ?? mod.default,
+      contract: serveTimeContract
+    });
+  }
+  return {
+    parts,
+    headlessContracts: [],
+    headlessInstanceComponents,
+    discoveredInstances: config.discoveredInstances ?? [],
+    forEachInstances: config.forEachInstances,
+    keyedPartModules: [],
+    headlessModuleInfos: []
+  };
+}
+const pagePartsCache = /* @__PURE__ */ new Map();
+async function getPageParts(route, artifacts) {
+  const cached = pagePartsCache.get(route.pattern);
+  if (cached) return cached;
+  const parts = await loadPagePartsFromConfig(pagePartsConfigPath(route.pattern), artifacts);
+  pagePartsCache.set(route.pattern, parts);
+  return parts;
+}
+const TRANSIENT_CLIENT_ERRORS = /* @__PURE__ */ new Set([401, 403, 408, 429]);
+const renderInstance = async (route, params, artifacts, now) => {
+  let pageParts;
+  try {
+    pageParts = await getPageParts(route, artifacts);
+  } catch (err) {
+    return { kind: "error", reason: `Failed to load page parts: ${err?.message ?? err}` };
+  }
+  const pageUrl = buildUrlFromManifest(route.pattern, params);
+  const slowPhase = new DevSlowlyChangingPhase();
+  let slowResult;
+  try {
+    slowResult = await slowPhase.runSlowlyForPage(
+      params,
+      { language: "en", url: pageUrl },
+      pageParts.parts,
+      pageParts.discoveredInstances,
+      pageParts.headlessInstanceComponents
+    );
+  } catch (err) {
+    return { kind: "error", reason: `Slow render threw: ${err?.message ?? err}` };
+  }
+  if (slowResult.kind !== "PhaseOutput") {
+    if (slowResult.kind === "ClientError" && !TRANSIENT_CLIENT_ERRORS.has(slowResult.status)) {
+      return { kind: "notFound" };
+    }
+    if (slowResult.kind === "Redirect") {
+      return {
+        kind: "redirect",
+        status: slowResult.status,
+        location: slowResult.location
+      };
+    }
+    const detail = `${slowResult.status ?? ""} ${slowResult.message ?? ""}`;
+    return {
+      kind: "error",
+      reason: `Slow render returned ${slowResult.kind} ${detail}`.trim()
+    };
+  }
+  const slowViewState = slowResult.rendered;
+  const carryForward = slowResult.carryForward;
+  let instanceFreshness = {};
+  try {
+    if (pageParts.discoveredInstances && pageParts.discoveredInstances.length > 0 && pageParts.headlessInstanceComponents.length > 0) {
+      const instanceSlowResult = await slowRenderInstances(
+        pageParts.discoveredInstances,
+        pageParts.headlessInstanceComponents,
+        {
+          pageViewState: slowViewState,
+          pageParams: params,
+          pageProps: { language: "en", url: pageUrl }
+        }
+      );
+      if (instanceSlowResult) {
+        instanceFreshness = instanceSlowResult.freshness;
+        const existingInstances = carryForward.__instances || {
+          discovered: [],
+          carryForwards: {}
+        };
+        carryForward.__instances = {
+          discovered: [
+            ...existingInstances.discovered,
+            ...instanceSlowResult.instancePhaseData.discovered
+          ],
+          carryForwards: {
+            ...existingInstances.carryForwards,
+            ...instanceSlowResult.instancePhaseData.carryForwards
+          },
+          slowViewStates: {
+            ...existingInstances.slowViewStates || {},
+            ...instanceSlowResult.instancePhaseData.slowViewStates
+          }
+        };
+      }
+    }
+  } catch (err) {
+    return { kind: "error", reason: `Instance slow render threw: ${err?.message ?? err}` };
+  }
+  if (pageParts.forEachInstances && pageParts.forEachInstances.length > 0) {
+    const existingInstances = carryForward.__instances || {
+      discovered: [],
+      carryForwards: {}
+    };
+    existingInstances.forEachInstances = pageParts.forEachInstances;
+    carryForward.__instances = existingInstances;
+  }
+  const freshness = resolveFreshness(
+    mergeFreshness([{ ttl: slowResult.ttl, grace: slowResult.grace }, instanceFreshness])
+  );
+  return {
+    kind: "rendered",
+    entry: {
+      slowViewState,
+      carryForward,
+      renderedAt: now,
+      ...freshness.ttl !== void 0 && { ttl: freshness.ttl },
+      ...freshness.grace !== void 0 && { grace: freshness.grace }
+    }
+  };
+};
+const DEFAULT_SLOW_RENDER_CONCURRENCY = 5;
+const DEFAULT_MISS_TIMEOUT_MS = 8e3;
+const DEFAULT_RETRY_AFTER_SECONDS = 2;
+const BACKOFF_BASE_MS = 5e3;
+const BACKOFF_CAP_MS = 5 * 6e4;
+const REDIRECT_TTL_MS = 10 * 6e4;
+const REDIRECT_MAX_ENTRIES = 1e3;
+function envNumber(name, fallback) {
+  const raw = typeof process !== "undefined" ? process.env?.[name] : void 0;
+  const value = raw === void 0 ? NaN : Number(raw);
+  return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+class InstanceRenderer {
+  constructor(store, options = {}) {
+    __publicField(this, "concurrency");
+    __publicField(this, "missTimeoutMs");
+    __publicField(this, "retryAfterSeconds");
+    __publicField(this, "negativeCache");
+    __publicField(this, "now");
+    __publicField(this, "render");
+    __publicField(this, "flights", /* @__PURE__ */ new Map());
+    __publicField(this, "backoff", /* @__PURE__ */ new Map());
+    __publicField(this, "redirects", /* @__PURE__ */ new Map());
+    __publicField(this, "slotsInUse", 0);
+    __publicField(this, "busyCount", 0);
+    this.store = store;
+    this.concurrency = options.concurrency ?? envNumber("JAY_SLOW_RENDER_CONCURRENCY", DEFAULT_SLOW_RENDER_CONCURRENCY);
+    this.missTimeoutMs = options.missTimeoutMs ?? envNumber("JAY_MISS_TIMEOUT_MS", DEFAULT_MISS_TIMEOUT_MS);
+    this.retryAfterSeconds = options.retryAfterSeconds ?? DEFAULT_RETRY_AFTER_SECONDS;
+    this.negativeCache = options.negativeCache ?? new NegativeCache();
+    this.now = options.now ?? Date.now;
+    this.render = options.render ?? renderInstance;
+  }
+  /** True when the store can persist rendered instances (otherwise refresh / render-on-miss are off). */
+  get canWrite() {
+    return typeof this.store.writeCacheData === "function";
+  }
+  /** Monitoring counters. */
+  stats() {
+    return {
+      slotsInUse: this.slotsInUse,
+      inFlight: this.flights.size,
+      busy: this.busyCount,
+      negativeEntries: this.negativeCache.size
+    };
+  }
+  /**
+   * 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, params) {
+    if (!this.canWrite) return { kind: "skipped" };
+    const key = instanceKey(route.pattern, params);
+    const inFlight = this.flights.get(key);
+    if (inFlight) return { kind: "joined", done: this.toEntry(inFlight) };
+    if (this.inBackoff(key)) return { kind: "skipped" };
+    if (this.slotsInUse >= this.concurrency) {
+      this.busyCount++;
+      return { kind: "busy" };
+    }
+    return { kind: "started", done: this.toEntry(this.startFlight(key, route, params, true)) };
+  }
+  /**
+   * 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.
+   */
+  async renderMissing(route, params) {
+    const key = instanceKey(route.pattern, params);
+    if (this.negativeCache.has(key, this.now())) return { kind: "notFound" };
+    const known = this.redirects.get(key);
+    if (known && known.expiresAt > this.now()) {
+      return { kind: "redirect", status: known.status, location: known.location };
+    }
+    if (!this.canWrite) return { kind: "notFound" };
+    let flight = this.flights.get(key);
+    if (!flight) {
+      if (this.inBackoff(key) || this.slotsInUse >= this.concurrency) {
+        if (this.slotsInUse >= this.concurrency) this.busyCount++;
+        return this.unavailable();
+      }
+      flight = this.startFlight(key, route, params, false);
+    }
+    const result = await this.withTimeout(flight, this.missTimeoutMs);
+    if (result === void 0) return this.unavailable();
+    if (result.kind === "rendered") {
+      return { kind: "rendered", instance: synthesizeInstance(route, params) };
+    }
+    if (result.kind === "notFound") return { kind: "notFound" };
+    if (result.kind === "redirect") {
+      return { kind: "redirect", status: result.status, location: result.location };
+    }
+    return this.unavailable();
+  }
+  /** True when `(route, params)` is remembered as non-existent. */
+  isKnownMissing(route, params) {
+    return this.negativeCache.has(instanceKey(route.pattern, params), this.now());
+  }
+  unavailable() {
+    return { kind: "unavailable", retryAfterSeconds: this.retryAfterSeconds };
+  }
+  inBackoff(key) {
+    const backoff = this.backoff.get(key);
+    return backoff !== void 0 && backoff.nextAttemptAt > this.now();
+  }
+  startFlight(key, route, params, existing) {
+    this.slotsInUse++;
+    const flight = this.runFlight(key, route, params, existing).finally(() => {
+      this.slotsInUse--;
+      this.flights.delete(key);
+    });
+    this.flights.set(key, flight);
+    return flight;
+  }
+  async runFlight(key, route, params, existing) {
+    const logger = getLogger();
+    try {
+      const outcome = await this.render(route, params, this.store, this.now());
+      if (outcome.kind === "rendered") {
+        await this.store.writeCacheData(route, params, outcome.entry);
+        this.backoff.delete(key);
+        this.negativeCache.delete(key);
+        return { kind: "rendered", entry: outcome.entry };
+      }
+      if (outcome.kind === "notFound") {
+        this.backoff.delete(key);
+        this.negativeCache.add(key, this.now());
+        if (existing) await this.store.removeInstance?.(route, params);
+        return { kind: "notFound" };
+      }
+      if (outcome.kind === "redirect") {
+        if (!existing) {
+          this.backoff.delete(key);
+          this.rememberRedirect(key, outcome.status, outcome.location);
+          return { kind: "redirect", status: outcome.status, location: outcome.location };
+        }
+        this.recordFailure(key);
+        logger.warn(`[Refresh] ${key}: slow render now redirects to ${outcome.location}`);
+        return { kind: "error" };
+      }
+      this.recordFailure(key);
+      logger.warn(`[Refresh] ${key}: ${outcome.reason}`);
+      return { kind: "error" };
+    } catch (err) {
+      this.recordFailure(key);
+      logger.warn(`[Refresh] ${key}: ${err?.message ?? err}`);
+      return { kind: "error" };
+    }
+  }
+  rememberRedirect(key, status, location) {
+    this.redirects.delete(key);
+    this.redirects.set(key, { status, location, expiresAt: this.now() + REDIRECT_TTL_MS });
+    while (this.redirects.size > REDIRECT_MAX_ENTRIES) {
+      this.redirects.delete(this.redirects.keys().next().value);
+    }
+  }
+  recordFailure(key) {
+    const failures = (this.backoff.get(key)?.failures ?? 0) + 1;
+    const delay = Math.min(BACKOFF_BASE_MS * 2 ** (failures - 1), BACKOFF_CAP_MS);
+    this.backoff.set(key, { failures, nextAttemptAt: this.now() + delay });
+  }
+  toEntry(flight) {
+    return flight.then((result) => result.kind === "rendered" ? result.entry : void 0);
+  }
+  async withTimeout(promise, ms) {
+    let timer;
+    const timeout = new Promise((resolve) => {
+      timer = setTimeout(() => resolve(void 0), ms);
+    });
+    try {
+      return await Promise.race([promise, timeout]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+}
+function buildImportMap(sharedManifest, publicBasePath, sharedDir = "shared") {
+  const imports = {};
+  for (const [pkgName, hashedFile] of Object.entries(sharedManifest)) {
+    imports[pkgName] = `${publicBasePath}${sharedDir}/${hashedFile}`;
+  }
+  return imports;
+}
+async function renderErrorPage(manifest, artifacts, staticBaseUrl, info) {
+  const plainText = () => new Response(info.message || info.title || "Error", {
+    status: info.status,
+    headers: { "Content-Type": "text/plain; charset=utf-8" }
+  });
+  const errorPages = manifest.errorPages;
+  if (!errorPages) return plainText();
+  const token = resolveErrorPageToken(Object.keys(errorPages), info.status);
+  if (!token) return plainText();
+  const entry = errorPages[token];
+  try {
+    return await streamErrorPage(entry, manifest, artifacts, staticBaseUrl, info);
+  } catch (err) {
+    getLogger().error(
+      `[Server] Error page "${token}" render failed (${info.status} ${info.url}): ${err?.message}`
+    );
+    return plainText();
+  }
+}
+async function streamErrorPage(entry, manifest, artifacts, staticBaseUrl, info) {
+  const slowViewState = entry.slowCache?.slowViewState ?? {};
+  const fullViewState = buildErrorViewState(info, slowViewState);
+  const headTagSources = [];
+  if (manifest.siteHeadTags && manifest.siteHeadTags.length > 0)
+    headTagSources.push(manifest.siteHeadTags);
+  const templateHeadTags = headMetaToHeadTags(entry.headMeta, fullViewState);
+  const headTags = headTagSources.length > 0 || templateHeadTags.length > 0 ? mergeHeadTags(headTagSources, templateHeadTags) : [];
+  const hasCustomTitle = headTags.some((t) => t.tag?.toLowerCase() === "title");
+  const titleTag = hasCustomTitle ? "" : `    <title>${info.status} Error</title>
+`;
+  const preconnectTags = headTags.filter(
+    (t) => t.tag === "link" && t.attrs?.rel === "preconnect"
+  );
+  const otherHeadTags = headTags.filter(
+    (t) => !(t.tag === "link" && t.attrs?.rel === "preconnect")
+  );
+  const preconnectHtml = preconnectTags.length > 0 ? serializeHeadTags(preconnectTags) + "\n" : "";
+  const headTagsHtml = otherHeadTags.length > 0 ? serializeHeadTags(otherHeadTags) + "\n" : "";
+  const headScriptsHtml = serializeScripts(entry.scripts, "head");
+  const bodyScriptsHtml = serializeScripts(entry.scripts, "body");
+  const serverElement = await artifacts.loadServerElement(entry.serverElementPath);
+  const asyncPromises = [];
+  const importMap = buildImportMap(manifest.sharedManifest, staticBaseUrl);
+  if (entry.routeHydratePath) {
+    importMap["jay-route-hydrate"] = `${staticBaseUrl}${entry.routeHydratePath}`;
+  }
+  const clientBundleUrl = entry.routeClientBundlePath ? `${staticBaseUrl}${entry.routeClientBundlePath}` : "";
+  const sharedPreloads = entry.sharedDeps ? entry.sharedDeps.map((dep) => importMap[dep]).filter(Boolean) : Object.values(importMap);
+  const preloadUrls = clientBundleUrl ? [...sharedPreloads, clientBundleUrl] : [];
+  const modulePreloads = preloadUrls.map((url) => `    <link rel="modulepreload" href="${url}" />`).join("\n");
+  const cssUrl = entry.routeCssPath ? `${staticBaseUrl}${entry.routeCssPath}` : "";
+  const cssPreload = cssUrl ? `    <link rel="preload" href="${cssUrl}" as="style" />` : "";
+  const cssLink = cssUrl ? `    <link rel="stylesheet" href="${cssUrl}" />` : "";
+  const cssImportPreloads = (entry.cssImports ?? []).map((url) => `    <link rel="preload" href="${url}" as="style" />`).join("\n");
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const write = (s) => controller.enqueue(encoder.encode(s));
+      const headParts = [headTagsHtml, modulePreloads, cssLink, headScriptsHtml].filter(Boolean).join("\n");
+      write(`<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+${titleTag}${[preconnectHtml, cssPreload, cssImportPreloads].filter(Boolean).map((l) => l + "\n").join(
+        ""
+      )}    <script type="importmap">${JSON.stringify({ imports: importMap })}<\/script>
+${headParts}
+  </head>
+  <body>
+    <div id="target">`);
+      serverElement.renderToStream(fullViewState, {
+        write: (chunk) => write(chunk),
+        onAsync: (promise, id, templates) => {
+          asyncPromises.push(
+            promise.then(
+              (val) => asyncSwapScript(id, templates.resolved(val)),
+              (err) => asyncSwapScript(id, templates.rejected(err))
+            )
+          );
+        }
+      });
+      write("</div>");
+      const asyncScripts = (await Promise.all(asyncPromises)).filter((s) => s).join("");
+      if (asyncScripts) write(asyncScripts);
+      if (clientBundleUrl) {
+        const clientInitData = getClientInitData();
+        const initArgs = `${JSON.stringify({})}, ${JSON.stringify(fullViewState)}, ${JSON.stringify({})}, ${JSON.stringify(clientInitData)}`;
+        write(`
+    <script type="module">
+      import { init } from '${clientBundleUrl}';
+      await init(${initArgs});
+    <\/script>`);
+      }
+      if (bodyScriptsHtml) write("\n    " + bodyScriptsHtml);
+      write(`
+  </body>
+</html>`);
+      controller.close();
+    }
+  });
+  return new Response(stream, {
+    status: info.status,
+    headers: { "Content-Type": "text/html; charset=utf-8" }
+  });
+}
+const FRESHNESS_HEADER = "jay-freshness";
+function hasFreshnessContract(entry) {
+  return entry.ttl !== void 0 && entry.renderedAt !== void 0;
+}
+function ageMs(entry, now) {
+  return entry.renderedAt === void 0 ? 0 : Math.max(0, now - entry.renderedAt);
+}
+function classify(entry, now) {
+  if (!hasFreshnessContract(entry)) return "fresh";
+  const ttl = entry.ttl;
+  const ageSec = ageMs(entry, now) / 1e3;
+  if (ageSec < ttl) return "fresh";
+  const grace = Math.max(entry.grace ?? DEFAULT_GRACE_SECONDS, ttl);
+  return ageSec < grace ? "stale" : "expired";
+}
+function findKey(headers, name) {
+  const lower = name.toLowerCase();
+  return Object.keys(headers).find((key) => key.toLowerCase() === lower);
+}
+function remove(headers, name) {
+  const key = findKey(headers, name);
+  if (key !== void 0) delete headers[key];
+}
+function set(headers, name, value) {
+  remove(headers, name);
+  headers[name] = value;
+}
+function clampCacheControl(value, remainingSeconds) {
+  const directives = value.split(",").map((d) => d.trim()).filter(Boolean);
+  const kept = [];
+  for (const directive of directives) {
+    const [rawName, rawArg] = directive.split("=");
+    const name = rawName.trim().toLowerCase();
+    if (name === "stale-while-revalidate" || name === "stale-if-error") continue;
+    if ((name === "max-age" || name === "s-maxage") && rawArg !== void 0) {
+      const current = Number(rawArg.trim().replace(/^"|"$/g, ""));
+      const clamped = Number.isFinite(current) ? Math.min(current, remainingSeconds) : remainingSeconds;
+      kept.push(`${name}=${clamped}`);
+      continue;
+    }
+    kept.push(directive);
+  }
+  return kept.join(", ");
+}
+function withRenderedAt(etag, renderedAt) {
+  const match = /^(W\/)?"(.*)"$/.exec(etag.trim());
+  if (!match) return etag;
+  return `${match[1] ?? ""}"${match[2]}-${renderedAt}"`;
+}
+function applyFreshness(headers, entry, state, now, options = {}) {
+  if (!hasFreshnessContract(entry)) return headers;
+  const result = { ...headers };
+  const age = ageMs(entry, now);
+  if (state === "stale" || state === "expired") {
+    set(result, "Cache-Control", "no-store");
+    remove(result, "Expires");
+  } else {
+    const cacheControlKey = findKey(result, "Cache-Control");
+    if (cacheControlKey !== void 0) {
+      const remainingSeconds = Math.max(0, Math.floor(entry.ttl - age / 1e3));
+      result[cacheControlKey] = clampCacheControl(result[cacheControlKey], remainingSeconds);
+    }
+  }
+  const etagKey = findKey(result, "ETag");
+  if (etagKey !== void 0) {
+    result[etagKey] = withRenderedAt(result[etagKey], entry.renderedAt);
+  }
+  if (options.freshnessHeader !== false) {
+    set(result, FRESHNESS_HEADER, `${state}, ${Math.round(age)}ms`);
+  }
+  return result;
+}
+function staleWaitMs() {
+  const value = Number(process.env.JAY_STALE_WAIT_MS);
+  return Number.isFinite(value) && value >= 0 && process.env.JAY_STALE_WAIT_MS !== void 0 ? value : 2e3;
+}
+function freshnessHeaderEnabled() {
+  return process.env.JAY_FRESHNESS_HEADER !== "off";
+}
+async function waitFor(promise, ms) {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(void 0), ms);
+  });
+  try {
+    return await Promise.race([promise, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function resolveEntry(cached, match, renderer) {
+  const now = Date.now();
+  const state = classify(cached, now);
+  if (state === "fresh" || !renderer) return { entry: cached, state };
+  const refresh = renderer.refresh(match.route, match.params);
+  if (state === "expired" && (refresh.kind === "started" || refresh.kind === "joined")) {
+    const renewed = await waitFor(refresh.done, staleWaitMs());
+    if (renewed) return { entry: renewed, state: "fresh" };
+  }
+  return { entry: cached, state };
+}
+async function fetchPageRequest(match, manifest, requestUrl, artifacts, staticBaseUrl, cookies = {}, renderer) {
+  const { route, instance } = match;
+  const t0 = Date.now();
+  let tCache = 0, tParts = 0;
+  const [storedEntry, pageParts] = await Promise.all([
+    artifacts.readCacheData(instance.cachePath).then((r) => {
+      tCache = Date.now() - t0;
+      return r;
+    }),
+    getPageParts(route, artifacts).then((r) => {
+      tParts = Date.now() - t0;
+      return r;
+    })
+  ]);
+  const tBeforeResolve = Date.now();
+  const { entry: cached, state: freshnessState } = await resolveEntry(
+    storedEntry,
+    match,
+    renderer
+  );
+  const tData = Date.now();
+  const query = Object.fromEntries(requestUrl.searchParams.entries());
+  const cf = cached.carryForward;
+  const fastResult = await renderFastChangingData(
+    match.params,
+    { params: match.params, query },
+    cached.carryForward,
+    pageParts.parts,
+    cf.__instances,
+    pageParts.forEachInstances,
+    pageParts.headlessInstanceComponents,
+    cached.slowViewState,
+    query,
+    cookies
+  );
+  const tFast = Date.now();
+  if (fastResult.kind === "Redirect") {
+    return new Response(null, {
+      status: fastResult.status,
+      headers: { Location: fastResult.location }
+    });
+  }
+  if (fastResult.kind === "ServerError" || fastResult.kind === "ClientError") {
+    return renderErrorPage(manifest, artifacts, staticBaseUrl, {
+      status: fastResult.status,
+      url: requestUrl.pathname,
+      title: fastResult.title,
+      message: fastResult.message,
+      code: fastResult.code,
+      details: fastResult.details
+    });
+  }
+  const fastViewState = fastResult.rendered || {};
+  const fastCarryForward = fastResult.carryForward || {};
+  const instanceSlowVS = cf.__instances?.slowViewStates;
+  const fullSlowViewState = instanceSlowVS && Object.keys(instanceSlowVS).length > 0 ? { ...cached.slowViewState, __headlessInstances: instanceSlowVS } : cached.slowViewState;
+  const fullViewState = deepMergeViewStates(
+    fullSlowViewState,
+    fastViewState,
+    route.trackByMap || {}
+  );
+  fullViewState.__jay = {
+    params: match.params,
+    url: { path: requestUrl.pathname }
+  };
+  const headTagSources = [];
+  if (manifest.siteHeadTags && manifest.siteHeadTags.length > 0)
+    headTagSources.push(manifest.siteHeadTags);
+  const slowHeadTags = cf.__slowHeadTags;
+  if (slowHeadTags) headTagSources.push(...slowHeadTags);
+  if (fastResult.headTags) headTagSources.push(fastResult.headTags);
+  const templateHeadTags = headMetaToHeadTags(route.headMeta, fullViewState);
+  const headTags = headTagSources.length > 0 || templateHeadTags.length > 0 ? mergeHeadTags(headTagSources, templateHeadTags) : [];
+  const hasCustomTitle = headTags.some((t) => t.tag?.toLowerCase() === "title");
+  const titleTag = hasCustomTitle ? "" : "    <title>Vite + TS</title>\n";
+  const preconnectTags = headTags.filter(
+    (t) => t.tag === "link" && t.attrs?.rel === "preconnect"
+  );
+  const otherHeadTags = headTags.filter(
+    (t) => !(t.tag === "link" && t.attrs?.rel === "preconnect")
+  );
+  const preconnectHtml = preconnectTags.length > 0 ? serializeHeadTags(preconnectTags) + "\n" : "";
+  const headTagsHtml = otherHeadTags.length > 0 ? serializeHeadTags(otherHeadTags) + "\n" : "";
+  const headScriptsHtml = serializeScripts(route.scripts, "head");
+  const bodyScriptsHtml = serializeScripts(route.scripts, "body");
+  const serverElementPath = route.serverElementPath || instance.serverElementPath;
+  const tLoadStart = Date.now();
+  const serverElement = await artifacts.loadServerElement(serverElementPath);
+  const tLoad = Date.now();
+  const asyncPromises = [];
+  const importMap = buildImportMap(manifest.sharedManifest, staticBaseUrl);
+  if (route.routeHydratePath) {
+    importMap["jay-route-hydrate"] = `${staticBaseUrl}${route.routeHydratePath}`;
+  }
+  const clientBundleUrl = route.routeClientBundlePath ? `${staticBaseUrl}${route.routeClientBundlePath}` : `${staticBaseUrl}${instance.clientBundlePath}`;
+  const sharedPreloads = route.sharedDeps ? route.sharedDeps.map((dep) => importMap[dep]).filter(Boolean) : Object.values(importMap);
+  const preloadUrls = [...sharedPreloads, clientBundleUrl];
+  const modulePreloads = preloadUrls.map((url) => `    <link rel="modulepreload" href="${url}" />`).join("\n");
+  const cssUrl = instance.clientCssPath ? `${staticBaseUrl}${instance.clientCssPath}` : "";
+  const cssPreload = cssUrl ? `    <link rel="preload" href="${cssUrl}" as="style" />` : "";
+  const cssLink = cssUrl ? `    <link rel="stylesheet" href="${cssUrl}" />` : "";
+  const cssImportPreloads = (route.cssImports ?? []).map((url) => `    <link rel="preload" href="${url}" as="style" />`).join("\n");
+  const encoder = new TextEncoder();
+  const responseHeaders = applyFreshness(
+    fastResult.responseHeaders || {},
+    cached,
+    freshnessState,
+    Date.now(),
+    { freshnessHeader: freshnessHeaderEnabled() }
+  );
+  const freshnessLog = responseHeaders[FRESHNESS_HEADER];
+  const stream = new ReadableStream({
+    async start(controller) {
+      const write = (s) => controller.enqueue(encoder.encode(s));
+      const headParts = [headTagsHtml, modulePreloads, cssLink, headScriptsHtml].filter(Boolean).join("\n");
+      write(`<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+${titleTag}${[preconnectHtml, cssPreload, cssImportPreloads].filter(Boolean).map((l) => l + "\n").join(
+        ""
+      )}    <script type="importmap">${JSON.stringify({ imports: importMap })}<\/script>
+${headParts}
+  </head>
+  <body>
+    <div id="target">`);
+      const tSsrStart = Date.now();
+      serverElement.renderToStream(fullViewState, {
+        write: (chunk) => write(chunk),
+        onAsync: (promise, id, templates) => {
+          asyncPromises.push(
+            promise.then(
+              (val) => asyncSwapScript(id, templates.resolved(val)),
+              (err) => asyncSwapScript(id, templates.rejected(err))
+            )
+          );
+        }
+      });
+      const tSsr = Date.now();
+      write("</div>");
+      const asyncScripts = (await Promise.all(asyncPromises)).filter((s) => s).join("");
+      if (asyncScripts) write(asyncScripts);
+      const clientInitData = getClientInitData();
+      const initArgs = route.routeClientBundlePath ? `${JSON.stringify(fullSlowViewState)}, ${JSON.stringify(fastViewState)}, ${JSON.stringify(fastCarryForward)}, ${JSON.stringify(clientInitData)}` : `${JSON.stringify(fastViewState)}, ${JSON.stringify(fastCarryForward)}, ${JSON.stringify(clientInitData)}`;
+      const tTotal = Date.now() - t0;
+      const tLoadMs = tLoad - tLoadStart;
+      const serverTiming = {
+        cache: tCache,
+        parts: tParts,
+        refresh: tData - tBeforeResolve,
+        fast: tFast - tData,
+        load: tLoadMs,
+        ssr: tSsr - tSsrStart,
+        total: tTotal
+      };
+      write(`
+    <script>console.log('[jay] server: cache=${serverTiming.cache}ms parts=${serverTiming.parts}ms refresh=${serverTiming.refresh}ms fast=${serverTiming.fast}ms load=${serverTiming.load}ms ssr=${serverTiming.ssr}ms total=${serverTiming.total}ms${freshnessLog ? ` freshness=${freshnessLog}` : ""}')<\/script>
+    <script type="module">
+      import { init } from '${clientBundleUrl}';
+      const _t=performance.now();
+      await init(${initArgs});
+      console.log('[jay] hydrate: '+(performance.now()-_t).toFixed(1)+'ms');
+    <\/script>${bodyScriptsHtml ? "\n    " + bodyScriptsHtml : ""}
+  </body>
+</html>`);
+      controller.close();
+      const timingParts = [
+        `cache: ${tCache}ms`,
+        `parts: ${tParts}ms`,
+        `refresh: ${serverTiming.refresh}ms`,
+        `fast: ${serverTiming.fast}ms`,
+        `load: ${tLoadMs}ms`,
+        `ssr: ${serverTiming.ssr}ms`
+      ];
+      if (freshnessLog) timingParts.push(`${freshnessLog}`);
+      console.log(`GET ${match.pathname} [${timingParts.join(" | ")}] ${tTotal}ms`);
+    }
+  });
+  return new Response(stream, {
+    headers: { "Content-Type": "text/html; charset=utf-8", ...responseHeaders }
+  });
+}
+const ACTION_PREFIX = "/_jay/actions/";
+function isActionRequest(pathname) {
+  return pathname.startsWith(ACTION_PREFIX);
+}
+async function fetchActionRequest(request, registry = actionRegistry) {
+  const url = new URL(request.url);
+  const actionName = url.pathname.slice(ACTION_PREFIX.length);
+  if (!actionName) {
+    return jsonResponse(400, {
+      success: false,
+      error: {
+        code: "MISSING_ACTION_NAME",
+        message: "Action name is required",
+        isActionError: false
+      }
+    });
+  }
+  const action = registry.get(actionName);
+  if (!action) {
+    return jsonResponse(404, {
+      success: false,
+      error: {
+        code: "ACTION_NOT_FOUND",
+        message: `Action '${actionName}' is not registered`,
+        isActionError: false
+      }
+    });
+  }
+  const requestMethod = request.method.toUpperCase();
+  if (requestMethod !== action.method) {
+    return jsonResponse(405, {
+      success: false,
+      error: {
+        code: "METHOD_NOT_ALLOWED",
+        message: `Action '${actionName}' expects ${action.method}, got ${requestMethod}`,
+        isActionError: false
+      }
+    });
+  }
+  if (needsSameOriginCheck(action) && isCrossOrigin(request, url)) {
+    return jsonResponse(403, crossOriginErrorResponse(actionName));
+  }
+  let input;
+  try {
+    if (requestMethod === "GET") {
+      const inputParam = url.searchParams.get("_input");
+      if (inputParam) {
+        input = JSON.parse(inputParam);
+      } else {
+        input = Object.fromEntries(url.searchParams.entries());
+        delete input._input;
+      }
+    } else {
+      const text = await request.text();
+      input = text ? JSON.parse(text) : {};
+    }
+  } catch {
+    return jsonResponse(400, {
+      success: false,
+      error: {
+        code: "INVALID_INPUT",
+        message: "Failed to parse request input",
+        isActionError: false
+      }
+    });
+  }
+  const incoming = action.needsRequest ? readIncomingRequest(request, url) : void 0;
+  const perUserHeaders = action.needsRequest ? { "Cache-Control": registry.getCacheHeaders(actionName) } : {};
+  if (registry.isStreaming(actionName)) {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+      async start(controller) {
+        try {
+          const generator = registry.executeStream(actionName, input, incoming);
+          for await (const chunk of generator) {
+            controller.enqueue(encoder.encode(JSON.stringify({ chunk }) + "\n"));
+          }
+          controller.enqueue(encoder.encode(JSON.stringify({ done: true }) + "\n"));
+        } catch (err) {
+          controller.enqueue(
+            encoder.encode(JSON.stringify({ error: err.message }) + "\n")
+          );
+        }
+        controller.close();
+      }
+    });
+    return new Response(stream, {
+      headers: { "Content-Type": "application/x-ndjson", ...perUserHeaders }
+    });
+  }
+  const result = await registry.execute(actionName, input, incoming);
+  if (result.success) {
+    const headers = new Headers(perUserHeaders);
+    if (requestMethod === "GET") {
+      const cacheHeaders = registry.getCacheHeaders(actionName);
+      if (cacheHeaders) {
+        headers.set("Cache-Control", cacheHeaders);
+      }
+    }
+    for (const setCookie of result.setCookies ?? []) {
+      headers.append("Set-Cookie", setCookie);
+    }
+    return jsonResponse(200, { success: true, data: result.data }, headers);
+  } else {
+    const statusCode = getStatusCode(result.error.code, result.error.isActionError);
+    return jsonResponse(
+      statusCode,
+      { success: false, error: result.error },
+      new Headers(perUserHeaders)
+    );
+  }
+}
+function isCrossOrigin(request, url) {
+  return isCrossOriginRequest({
+    secFetchSite: request.headers.get("sec-fetch-site"),
+    origin: request.headers.get("origin"),
+    requestOrigin: url.origin
+  });
+}
+function readIncomingRequest(request, url) {
+  return {
+    cookies: parseCookies(request.headers.get("cookie")),
+    secure: isSecureRequest(url.protocol, request.headers.get("x-forwarded-proto"))
+  };
+}
+function jsonResponse(status, body, extraHeaders = new Headers()) {
+  extraHeaders.set("Content-Type", "application/json");
+  return new Response(JSON.stringify(body), { status, headers: extraHeaders });
+}
+async function registerActionsFromManifest(actions, buildDir, registry = actionRegistry) {
+  const logger = getLogger();
+  let count = 0;
+  for (const entry of actions) {
+    try {
+      const modulePath = entry.isPlugin ? entry.packageName : `${buildDir}/${entry.serverModule}`;
+      const mod = await import(modulePath);
+      for (const [, exported] of Object.entries(mod)) {
+        if (isJayAction(exported)) {
+          registry.register(exported);
+          count++;
+        } else if (isJayStreamAction(exported)) {
+          registry.registerStream(exported);
+          count++;
+        }
+      }
+    } catch (err) {
+      logger.error(
+        `[Server] Failed to load action module ${entry.serverModule}: ${err.message}`
+      );
+    }
+  }
+  logger.info(`[Server] Registered ${count} actions`);
+}
+async function registerActionsFromModules(modules, registry = actionRegistry) {
+  const logger = getLogger();
+  let count = 0;
+  for (const { module, name } of modules) {
+    for (const [, exported] of Object.entries(module)) {
+      if (isJayAction(exported)) {
+        registry.register(exported);
+        count++;
+      } else if (isJayStreamAction(exported)) {
+        registry.registerStream(exported);
+        count++;
+      }
+    }
+  }
+  logger.info(`[Server] Registered ${count} actions from pre-imported modules`);
+}
+function getStatusCode(code, isActionError) {
+  if (isActionError) return 422;
+  switch (code) {
+    case "ACTION_NOT_FOUND":
+      return 404;
+    case "INVALID_INPUT":
+    case "VALIDATION_ERROR":
+      return 400;
+    case "UNAUTHORIZED":
+      return 401;
+    case "FORBIDDEN":
+      return 403;
+    default:
+      return 500;
+  }
+}
+const MIME_TYPES = {
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".html": "text/html",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2",
+  ".woff": "font/woff",
+  ".ttf": "font/ttf",
+  ".webp": "image/webp",
+  ".xml": "application/xml",
+  ".txt": "text/plain",
+  // Agent-readiness resources (DL#217): SKILL.md + packaged skill archives.
+  ".md": "text/markdown",
+  ".gz": "application/gzip",
+  // `.tar.gz` resolves via its last extension `.gz`
+  ".tar": "application/x-tar"
+};
+async function fetchStaticFile(pathname, frontendDir) {
+  const normalizedBase = path.resolve(frontendDir);
+  for (const candidate of [path.join(frontendDir, pathname)]) {
+    const normalizedFile = path.resolve(candidate);
+    if (!normalizedFile.startsWith(normalizedBase)) continue;
+    try {
+      const content = await fs.readFile(candidate);
+      const ext = path.extname(candidate);
+      const contentType = MIME_TYPES[ext] || "application/octet-stream";
+      const isHashed = /[-][a-zA-Z0-9_-]{6,}\./.test(path.basename(candidate));
+      const cacheControl = isHashed ? "public, max-age=31536000, immutable" : "public, max-age=3600";
+      const headers = {
+        "Content-Type": contentType,
+        "Content-Length": String(content.length),
+        "Cache-Control": cacheControl
+      };
+      if (pathname.startsWith("/.well-known/")) {
+        headers["Access-Control-Allow-Origin"] = "*";
+      }
+      return new Response(new Uint8Array(content), { headers });
+    } catch {
+    }
+  }
+  return null;
+}
+async function initializeServicesFromModules(plugins, label) {
+  const logger = getLogger();
+  for (const plugin of plugins) {
+    try {
+      if (plugin.init?._serverInit) {
+        logger.info(`[${label}] Running plugin init: ${plugin.name}`);
+        const data = await plugin.init._serverInit();
+        if (data) setClientInitData(plugin.name, data);
+      }
+    } catch (err) {
+      logger.warn(`[${label}] Plugin init failed: ${plugin.name}: ${err.message}`);
+    }
+  }
+}
+async function initializeServices(buildDir, projectRoot, label) {
+  const logger = getLogger();
+  const { discoverPluginsWithInit, sortPluginsByDependencies } = await import("@jay-framework/stack-server-runtime");
+  try {
+    const pluginsWithInit = sortPluginsByDependencies(
+      await discoverPluginsWithInit({ projectRoot })
+    );
+    for (const pluginInit of pluginsWithInit) {
+      try {
+        let modulePath;
+        if (pluginInit.isLocal) {
+          const pluginDirName = path.basename(pluginInit.pluginPath);
+          const initModule = pluginInit.initModule || "index";
+          modulePath = path.join(
+            buildDir,
+            "server",
+            "plugins",
+            pluginDirName,
+            initModule + ".js"
+          );
+        } else {
+          modulePath = pluginInit.packageName;
+        }
+        const pluginModule = await import(modulePath);
+        const init = pluginModule.init || pluginModule[pluginInit.initExport || "init"];
+        if (init?._serverInit) {
+          logger.info(`[${label}] Running plugin init: ${pluginInit.name}`);
+          const data = await init._serverInit();
+          if (data) setClientInitData(pluginInit.name, data);
+        }
+      } catch (err) {
+        logger.warn(`[${label}] Plugin init failed: ${pluginInit.name}: ${err.message}`);
+      }
+    }
+  } catch {
+  }
+  const initModulePath = path.join(buildDir, "server", "init.js");
+  try {
+    const initModule = await import(initModulePath);
+    const init = initModule.init || initModule.default;
+    if (init?._serverInit) {
+      logger.info(`[${label}] Running server init...`);
+      const data = await init._serverInit();
+      if (data) setClientInitData("project", data);
+    }
+  } catch {
+  }
+}
+export {
+  CacheNotFoundError as C,
+  DEFAULT_LIST_TTL_MS as D,
+  FilesystemArtifactStore as F,
+  InstanceRenderer as I,
+  SwrCache as S,
+  fetchPageRequest as a,
+  fetchStaticFile as b,
+  canonicalParams as c,
+  deriveCachePath as d,
+  initializeServicesFromModules as e,
+  fetchActionRequest as f,
+  instanceKey as g,
+  isActionRequest as h,
+  initializeServices as i,
+  registerActionsFromModules as j,
+  resolveRequest as k,
+  routeInstanceDir as l,
+  matchRoutes as m,
+  synthesizeInstance as n,
+  buildUrlFromManifest as o,
+  parseCacheEntry as p,
+  renderErrorPage as q,
+  registerActionsFromManifest as r,
+  serializeCacheEntry as s,
+  toInstanceRef as t,
+  renderInstance as u,
+  generateSitemap as v,
+  loadPagePartsFromConfig as w
+};