@jay-framework/production-server 0.25.4 → 0.26.0

package/dist/init-services-CG_wDJmY.js

@@ -1,761 +0,0 @@
-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 { resolveErrorPageToken, buildErrorViewState, headMetaToHeadTags, mergeHeadTags, serializeHeadTags, serializeScripts, getClientInitData, makePassthroughInstanceComponent, renderFastChangingData, actionRegistry, setClientInitData } from "@jay-framework/stack-server-runtime";
-import { deepMergeViewStates } from "@jay-framework/view-state-merge";
-import { asyncSwapScript } from "@jay-framework/ssr-runtime";
-import { getLogger } from "@jay-framework/logger";
-import { isJayAction, isJayStreamAction } from "@jay-framework/fullstack-component";
-class FilesystemArtifactStore {
-  constructor(basePath) {
-    __publicField(this, "manifestCache");
-    __publicField(this, "metadataMtime");
-    __publicField(this, "moduleCache", /* @__PURE__ */ new Map());
-    this.basePath = basePath;
-  }
-  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);
-    const cacheData = JSON.parse(await fs.readFile(fullPath, "utf-8"));
-    return {
-      slowViewState: cacheData.slowViewState || {},
-      carryForward: cacheData.carryForward || {}
-    };
-  }
-  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 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);
-  }
-}
-function matchRequest(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) {
-      const instance = findInstance(route, params);
-      if (instance) {
-        return { route, instance, params, pathname };
-      }
-    }
-  }
-  return void 0;
-}
-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;
-}
-function findInstance(route, params) {
-  const paramNames = new Set(
-    route.segments.filter((s) => s.type !== "static").map((s) => s.value)
-  );
-  return route.instances.find((instance) => {
-    for (const name of paramNames) {
-      const urlVal = params[name];
-      const instVal = instance.params[name];
-      if (urlVal === void 0 && instVal === void 0) continue;
-      if (urlVal !== instVal) return false;
-    }
-    return true;
-  });
-}
-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" }
-  });
-}
-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: [],
-    forEachInstances: config.forEachInstances,
-    keyedPartModules: [],
-    headlessModuleInfos: []
-  };
-}
-const pagePartsCache = /* @__PURE__ */ new Map();
-async function getPageParts(route, artifacts, cachePath) {
-  const cacheKey = route.pattern;
-  const cached = pagePartsCache.get(cacheKey);
-  if (cached) return cached;
-  const routeDir = path.dirname(cachePath);
-  const configRelPath = path.join(routeDir, "page-parts.json");
-  const parts = await loadPagePartsFromConfig(configRelPath, artifacts);
-  pagePartsCache.set(cacheKey, parts);
-  return parts;
-}
-async function fetchPageRequest(match, manifest, requestUrl, artifacts, staticBaseUrl, cookies = {}) {
-  const { route, instance } = match;
-  const t0 = Date.now();
-  let tCache = 0, tParts = 0;
-  const [cached, pageParts] = await Promise.all([
-    artifacts.readCacheData(instance.cachePath).then((r) => {
-      tCache = Date.now() - t0;
-      return r;
-    }),
-    getPageParts(route, artifacts, instance.cachePath).then((r) => {
-      tParts = Date.now() - t0;
-      return r;
-    })
-  ]);
-  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 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,
-        fast: tFast - tData,
-        load: tLoadMs,
-        ssr: tSsr - tSsrStart,
-        total: tTotal
-      };
-      write(`
-    <script>console.log('[jay] server: cache=${serverTiming.cache}ms parts=${serverTiming.parts}ms fast=${serverTiming.fast}ms load=${serverTiming.load}ms ssr=${serverTiming.ssr}ms total=${serverTiming.total}ms')<\/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`,
-        `fast: ${serverTiming.fast}ms`,
-        `load: ${tLoadMs}ms`,
-        `ssr: ${serverTiming.ssr}ms`
-      ];
-      console.log(`GET ${match.pathname} [${timingParts.join(" | ")}] ${tTotal}ms`);
-    }
-  });
-  const responseHeaders = fastResult.responseHeaders || {};
-  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
-      }
-    });
-  }
-  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
-      }
-    });
-  }
-  if (registry.isStreaming(actionName)) {
-    const encoder = new TextEncoder();
-    const stream = new ReadableStream({
-      async start(controller) {
-        try {
-          const generator = registry.executeStream(actionName, input);
-          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" }
-    });
-  }
-  const result = await registry.execute(actionName, input);
-  if (result.success) {
-    const headers = {};
-    if (requestMethod === "GET") {
-      const cacheHeaders = registry.getCacheHeaders(actionName);
-      if (cacheHeaders) {
-        headers["Cache-Control"] = cacheHeaders;
-      }
-    }
-    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 });
-  }
-}
-function jsonResponse(status, body, extraHeaders = {}) {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { "Content-Type": "application/json", ...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 {
-  FilesystemArtifactStore as F,
-  fetchPageRequest as a,
-  fetchStaticFile as b,
-  initializeServicesFromModules as c,
-  isActionRequest as d,
-  registerActionsFromModules as e,
-  fetchActionRequest as f,
-  renderErrorPage as g,
-  initializeServices as i,
-  loadPagePartsFromConfig as l,
-  matchRequest as m,
-  registerActionsFromManifest as r
-};