@jay-framework/production-server 0.17.4 → 0.18.0

package/dist/init-services-BKVwxzYb.js

@@ -0,0 +1,796 @@
+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);
+  return value;
+};
+import fs from "node:fs/promises";
+import path from "node:path";
+import { renderFastChangingData, mergeHeadTags, serializeHeadTags, getClientInitData, actionRegistry, setClientInitData } from "@jay-framework/stack-server-runtime";
+import { deepMergeViewStates } from "@jay-framework/view-state-merge";
+import { asyncSwapScript } from "@jay-framework/ssr-runtime";
+import { createRequire } from "node:module";
+import { getLogger } from "@jay-framework/logger";
+import { parseJayFile, JAY_IMPORT_RESOLVER, injectHeadfullFSTemplates, assignCoordinatesToJayHtml, discoverHeadlessInstances } from "@jay-framework/compiler-jay-html";
+import { checkValidationErrors } from "@jay-framework/compiler-shared";
+import { isJayAction, isJayStreamAction } from "@jay-framework/fullstack-component";
+const require2 = createRequire(import.meta.url);
+async function loadProductionPageParts(route, pageModule, jayHtmlContent, projectRoot, tsConfigFilePath, serverBuildDir) {
+  const exportName = route.componentExport || "page";
+  const compDefinition = pageModule[exportName] ?? pageModule.default;
+  const parts = compDefinition ? [{ compDefinition, clientImport: "", clientPart: "" }] : [];
+  const dirName = path.dirname(route.jayHtmlPath);
+  const fileName = path.basename(route.jayHtmlPath);
+  const jayHtmlWithValidations = await parseJayFile(
+    jayHtmlContent,
+    fileName,
+    dirName,
+    { relativePath: tsConfigFilePath },
+    JAY_IMPORT_RESOLVER,
+    projectRoot
+  );
+  const jayHtml = checkValidationErrors(jayHtmlWithValidations);
+  const headlessInstanceComponents = [];
+  const keyedPartModules = [];
+  const headlessModuleInfos = [];
+  const headlessImports = jayHtml.headlessImports ?? [];
+  getLogger().info(
+    `[Build] headlessImports for ${fileName}: ${headlessImports.length}, keys: ${Object.keys(jayHtml).join(",")}`
+  );
+  for (const headlessImport of headlessImports) {
+    const module = headlessImport.codeLink.module;
+    const name = headlessImport.codeLink.names[0].name;
+    const isLocalModule = module[0] === "." || module[0] === "/";
+    let modulePath;
+    if (isLocalModule) {
+      const sourcePath = path.resolve(dirName, module);
+      if (serverBuildDir) {
+        const relativeToSrc = path.relative(path.join(projectRoot, "src"), sourcePath);
+        let compiledPath = path.join(serverBuildDir, relativeToSrc);
+        compiledPath = compiledPath.replace(/\.ts$/, ".js");
+        if (!compiledPath.endsWith(".js")) {
+          const indexPath = path.join(compiledPath, "index.js");
+          try {
+            await fs.access(indexPath);
+            compiledPath = indexPath;
+          } catch {
+            compiledPath += ".js";
+          }
+        }
+        modulePath = compiledPath;
+      } else {
+        modulePath = sourcePath;
+      }
+    } else {
+      modulePath = module;
+    }
+    const resolvedModulePath = isLocalModule ? modulePath : require2.resolve(module, { paths: [dirName] });
+    const headlessModule = await import(resolvedModulePath);
+    const headlessCompDef = headlessModule[name];
+    if (headlessImport.key) {
+      const clientModulePath = isLocalModule ? path.resolve(dirName, module) : `${module}/client`;
+      const ci = headlessImport.contract ? { contractName: headlessImport.contract.name, metadata: headlessImport.metadata } : void 0;
+      parts.push({
+        key: headlessImport.key,
+        compDefinition: headlessCompDef,
+        clientImport: "",
+        clientPart: "",
+        contractInfo: ci
+      });
+      keyedPartModules.push({
+        key: headlessImport.key,
+        modulePath: clientModulePath,
+        exportName: name
+      });
+      headlessModuleInfos.push({
+        modulePath,
+        exportName: name,
+        isLocal: isLocalModule,
+        key: headlessImport.key,
+        contractInfo: ci
+      });
+    }
+    if (!headlessImport.key && headlessImport.contract) {
+      headlessInstanceComponents.push({
+        contractName: headlessImport.contractName,
+        compDefinition: headlessCompDef,
+        contract: headlessImport.contract
+      });
+      headlessModuleInfos.push({
+        modulePath,
+        exportName: name,
+        isLocal: isLocalModule,
+        contractName: headlessImport.contractName,
+        propNames: headlessImport.contract.props?.map((p) => p.name) ?? []
+      });
+    }
+  }
+  const headlessContracts = (jayHtml.headlessImports ?? []).filter((hi) => hi.contract && hi.key).map((hi) => ({
+    key: hi.key,
+    contract: hi.contract,
+    contractPath: hi.contractPath
+  }));
+  const jayHtmlForDiscovery = injectHeadfullFSTemplates(
+    jayHtmlContent,
+    dirName,
+    JAY_IMPORT_RESOLVER
+  );
+  let discoveredInstances = [];
+  let forEachInstances = [];
+  if (headlessInstanceComponents.length > 0) {
+    const contractNames = new Set(headlessInstanceComponents.map((c) => c.contractName));
+    const withCoords = assignCoordinatesToJayHtml(jayHtmlForDiscovery, contractNames);
+    const discovery = discoverHeadlessInstances(withCoords);
+    discoveredInstances = discovery.instances;
+    forEachInstances = discovery.forEachInstances;
+  }
+  return {
+    parts,
+    headlessContracts,
+    headlessInstanceComponents,
+    discoveredInstances,
+    forEachInstances,
+    keyedPartModules,
+    headlessModuleInfos,
+    serverTrackByMap: jayHtml.serverTrackByMap,
+    clientTrackByMap: jayHtml.clientTrackByMap
+  };
+}
+function buildPagePartsConfig(pageParts, pageServerModule, pageExportName, buildDir, pageIsPlugin = false) {
+  const parts = [];
+  if (pageServerModule) {
+    parts.push({
+      modulePath: pageServerModule,
+      exportName: pageExportName,
+      source: pageIsPlugin ? "npm" : "local"
+    });
+  }
+  for (const info of pageParts.headlessModuleInfos) {
+    if (info.key) {
+      parts.push({
+        modulePath: info.isLocal ? path.relative(buildDir, info.modulePath) : info.modulePath,
+        exportName: info.exportName,
+        source: info.isLocal ? "local" : "npm",
+        key: info.key,
+        contractInfo: info.contractInfo
+      });
+    }
+  }
+  const instanceComponents = [];
+  for (const info of pageParts.headlessModuleInfos) {
+    if (info.contractName) {
+      instanceComponents.push({
+        modulePath: info.isLocal ? path.relative(buildDir, info.modulePath) : info.modulePath,
+        exportName: info.exportName,
+        source: info.isLocal ? "local" : "npm",
+        contractName: info.contractName,
+        propNames: info.propNames ?? []
+      });
+    }
+  }
+  return {
+    parts,
+    instanceComponents,
+    forEachInstances: pageParts.forEachInstances.map((fi) => ({
+      contractName: fi.contractName,
+      forEachPath: fi.forEachPath,
+      trackBy: fi.trackBy,
+      propBindings: fi.propBindings,
+      coordinateSuffix: fi.coordinateSuffix
+    }))
+  };
+}
+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
+    });
+  }
+  const headlessInstanceComponents = [];
+  for (const entry of config.instanceComponents) {
+    const mod = await importModule(entry);
+    const serveTimeContract = {
+      props: entry.propNames.map((name) => ({ name }))
+    };
+    headlessInstanceComponents.push({
+      contractName: entry.contractName,
+      compDefinition: mod[entry.exportName] ?? mod.default,
+      contract: serveTimeContract
+    });
+  }
+  return {
+    parts,
+    headlessContracts: [],
+    headlessInstanceComponents,
+    discoveredInstances: [],
+    forEachInstances: config.forEachInstances,
+    keyedPartModules: [],
+    headlessModuleInfos: []
+  };
+}
+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;
+}
+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 fastResult = await renderFastChangingData(
+    match.params,
+    { params: match.params, query },
+    cached.carryForward,
+    pageParts.parts,
+    cached.carryForward.__instances,
+    pageParts.forEachInstances,
+    pageParts.headlessInstanceComponents,
+    cached.slowViewState,
+    query,
+    cookies
+  );
+  const tFast = Date.now();
+  if (fastResult.kind === "Redirect3xx") {
+    return new Response(null, {
+      status: fastResult.status,
+      headers: { Location: fastResult.location }
+    });
+  }
+  if (fastResult.kind === "ServerError5xx" || fastResult.kind === "ClientError4xx") {
+    return new Response(fastResult.message || "Error", {
+      status: fastResult.status
+    });
+  }
+  const fastViewState = fastResult.rendered || {};
+  const fastCarryForward = fastResult.carryForward || {};
+  const headTagSources = [];
+  const slowHeadTags = cached.carryForward.__slowHeadTags;
+  if (slowHeadTags)
+    headTagSources.push(...slowHeadTags);
+  const fastHeadTags = fastResult.headTags;
+  if (fastHeadTags)
+    headTagSources.push(fastHeadTags);
+  const headTags = headTagSources.length > 0 ? mergeHeadTags(headTagSources) : [];
+  const headTagsHtml = headTags.length > 0 ? serializeHeadTags(headTags) + "\n" : "";
+  const fullViewState = deepMergeViewStates(
+    cached.slowViewState,
+    fastViewState,
+    route.trackByMap || {}
+  );
+  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 modulePreloads = Object.values(importMap).map((url) => `    <link rel="modulepreload" href="${url}" />`).join("\n");
+  const cssLink = instance.clientCssPath ? `    <link rel="stylesheet" href="${staticBaseUrl}${instance.clientCssPath}" />` : "";
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const write = (s) => controller.enqueue(encoder.encode(s));
+      const headParts = [headTagsHtml, modulePreloads, cssLink].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" />
+    <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 clientBundleUrl = route.routeClientBundlePath ? `${staticBaseUrl}${route.routeClientBundlePath}` : `${staticBaseUrl}${instance.clientBundlePath}`;
+      const initArgs = route.routeClientBundlePath ? `${JSON.stringify(cached.slowViewState)}, ${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,
+        data: tData - t0,
+        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>
+  </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"
+};
+async function fetchStaticFile(pathname, frontendDir) {
+  const normalizedBase = path.resolve(frontendDir);
+  for (const candidate of [
+    path.join(frontendDir, pathname),
+    path.join(frontendDir, "public", 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";
+      return new Response(content, {
+        headers: {
+          "Content-Type": contentType,
+          "Content-Length": String(content.length),
+          "Cache-Control": cacheControl
+        }
+      });
+    } 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,
+  fetchActionRequest as a,
+  registerActionsFromModules as b,
+  fetchStaticFile as c,
+  initializeServices as d,
+  initializeServicesFromModules as e,
+  fetchPageRequest as f,
+  buildPagePartsConfig as g,
+  isActionRequest as i,
+  loadProductionPageParts as l,
+  matchRequest as m,
+  registerActionsFromManifest as r
+};