@bananacool467/authtics-host 0.2.6 → 0.2.8

package/dist/renderEngine.js

@@ -1,15 +1,22 @@
 import path from "node:path";
 import fs from "node:fs";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import * as esbuild from "esbuild";
 import React from "react";
 import { renderToString } from "react-dom/server";
-import { tempFileForTsx, writeTempFile, readTempFile, ensureTempDirs, } from "./rendererTempFiles.js";
+import { tempFileForTsx, clientBundleForTsx, serverBundleForTsx, ssgHtmlForTsx, getBuildStyle, getBuildTrigger, writeTempFile, readTempFile, ensureTempDirs, } from "./rendererTempFiles.js";
 import { createRequire } from "node:module";
 const customRequire = createRequire(import.meta.url);
 import { WebSocketServer } from "ws";
-export function handleSrtwsConnection(server, PageComponent) {
+let srtwsServer = null;
+export function deleteSrtwsServer() {
+    if (srtwsServer)
+        srtwsServer.close();
+    srtwsServer = null;
+}
+export function handleSrtwsConnection(server, tsxPath, config, reqUrl, reqDAT, rmvFileHandler, fileHandler) {
     const wss = new WebSocketServer({ noServer: true });
+    srtwsServer = wss;
     server.on("upgrade", (req, socket, head) => {
         if (req.url === "/__authtics_srtws__") {
             wss.handleUpgrade(req, socket, head, (ws) => {
@@ -18,8 +25,8 @@ export function handleSrtwsConnection(server, PageComponent) {
         }
     });
     wss.on("connection", (ws) => {
-        const renderAndSend = () => {
-            const pageHtml = renderToString(React.createElement(PageComponent));
+        const renderAndSend = async () => {
+            const pageHtml = await renderPage(tsxPath, reqUrl, config.devMode, config.compilerType, config.hotReload, config.autoPage, config.autoPageDir, config.appDir, fileHandler, rmvFileHandler, reqDAT, config.dat, 'csr', config.patchForSsr);
             ws.send(JSON.stringify({ type: "DOM", html: pageHtml }));
         };
         ws.on("message", () => {
@@ -27,7 +34,7 @@ export function handleSrtwsConnection(server, PageComponent) {
                 renderAndSend();
             }
             catch (err) {
-                console.error("[authtics] SRTWS error:", err);
+                console.error("[HostJS] SRTWS error:", err);
             }
         });
     });
@@ -55,12 +62,22 @@ const SRTWS_CLIENT_SCRIPT = `<script>
   const ws = new WebSocket(protocol + window.location.host + '/__authtics_srtws__');
 
   ws.onmessage = function(event) {
-    const msg = JSON.parse(event.data);
-    if (msg.type === 'DOM') {
-      const root = document.getElementById('root');
-      if (root) root.innerHTML = msg.html;
-    }
-  };
+  const msg = JSON.parse(event.data);
+  if (msg.type === 'DOM') {
+    document.documentElement.innerHTML = msg.html;
+    const scripts = document.documentElement.querySelectorAll('script');
+    
+    scripts.forEach(oldScript => {
+      const newScript = document.createElement('script');
+      Array.from(oldScript.attributes).forEach(attr => {
+        newScript.setAttribute(attr.name, attr.value);
+      });
+      newScript.textContent = oldScript.textContent;
+      oldScript.parentNode.replaceChild(newScript, oldScript);
+    });
+  }
+};
+
 
   ws.onopen = function() {
     ws.send(JSON.stringify({}));
@@ -78,7 +95,6 @@ const nodeStubPlugin = {
         }));
         build.onLoad({ filter: /.*/, namespace: 'browser-node-stub' }, () => ({
             contents: `
-        // Node.js built-in stub for browser builds
         const stub = new Proxy({}, { get: () => () => undefined });
         export default stub;
       `,
@@ -86,9 +102,11 @@ const nodeStubPlugin = {
         }));
     },
 };
-async function buildWithEsbuild(virtualContent, resolveDir, platform, patchForSsr = false) {
+async function buildWithEsbuild(virtualContent, resolveDir, platform, patchForServer = false, options = {}) {
     const toFwdSlash = (p) => p.split(path.sep).join('/');
     const isNode = platform === 'node';
+    const sourceMaps = options.sourceMaps === true;
+    const outfile = path.resolve(options.outfile ?? path.join(resolveDir, `virtual-entry-${platform}.js`));
     const result = await esbuild.build({
         stdin: {
             contents: virtualContent,
@@ -97,14 +115,16 @@ async function buildWithEsbuild(virtualContent, resolveDir, platform, patchForSs
         },
         bundle: true,
         write: false,
+        outfile,
         format: isNode ? 'cjs' : 'iife',
         platform,
         jsx: 'automatic',
-        sourcemap: false,
         target: isNode ? ['node18'] : ['es2020'],
-        minify: true,
+        sourcemap: sourceMaps ? "external" : false,
+        sourcesContent: sourceMaps,
+        minify: options.minify ?? !sourceMaps,
         treeShaking: true,
-        banner: (isNode && patchForSsr) ? {
+        banner: (isNode && patchForServer) ? {
             js: `if (typeof globalThis.window === "undefined") {
     const noop = () => {};
 
@@ -195,7 +215,15 @@ async function buildWithEsbuild(virtualContent, resolveDir, platform, patchForSs
                 toFwdSlash(path.join(__dirname, 'rendererTempFiles.js'))
             ],
     });
-    return result.outputFiles[0].text;
+    const jsFile = result.outputFiles.find((file) => path.resolve(file.path) === outfile);
+    const mapFile = result.outputFiles.find((file) => path.resolve(file.path) === `${outfile}.map`);
+    if (!jsFile) {
+        throw new Error(`esbuild did not produce ${outfile}`);
+    }
+    const code = mapFile && options.sourceMapUrl
+        ? `${jsFile.text}\n//# sourceMappingURL=${options.sourceMapUrl}\n`
+        : jsFile.text;
+    return { code, map: mapFile?.text };
 }
 export function findFileUpwards(startDir, relativePath) {
     let dir = path.resolve(startDir);
@@ -227,6 +255,73 @@ function resolveTemplate(appDir, autoPageDir, autoPaging) {
     }
     return nextToCli;
 }
+let htmlPanelBundleCache;
+async function getHtmlPanelClientBundle() {
+    if (!devPanelPath) {
+        throw new Error("[HostJS] DevPanel is not available.");
+    }
+    const mtimeMs = fs.statSync(devPanelPath).mtimeMs;
+    if (htmlPanelBundleCache?.path === devPanelPath &&
+        htmlPanelBundleCache.mtimeMs === mtimeMs) {
+        return htmlPanelBundleCache.bundle;
+    }
+    const clientEntry = `
+    import React from "react";
+    import { hydrateRoot } from "react-dom/client";
+    import DevPanel from ${JSON.stringify(devPanelPath)};
+
+    const panelRoot = document.getElementById("authtics-dev-panel-root");
+    if (panelRoot) {
+      hydrateRoot(panelRoot, React.createElement(DevPanel));
+    }
+  `;
+    const bundle = buildWithEsbuild(clientEntry, path.dirname(devPanelPath), "browser", false, { sourceMaps: false, minify: true }).then(({ code }) => code);
+    htmlPanelBundleCache = {
+        path: devPanelPath,
+        mtimeMs,
+        bundle,
+    };
+    return bundle;
+}
+export async function handleHTML(rawHtml, actuallyShowPanel, configDAT, userDAT, hotReload = false) {
+    const datMatches = configDAT === undefined ||
+        configDAT === userDAT ||
+        (Array.isArray(configDAT) && configDAT.includes(userDAT ?? ""));
+    const usesDevPanel = actuallyShowPanel &&
+        devPanelPath !== null &&
+        datMatches;
+    const configScript = `<script>window.__authtics_config__=` +
+        JSON.stringify({
+            datRestricted: configDAT !== undefined,
+            devMode: usesDevPanel,
+        }) +
+        `;</script>`;
+    let panelContainer = "";
+    let panelClientScript = "";
+    if (usesDevPanel && devPanelPath) {
+        const panelModule = await import(pathToFileURL(devPanelPath).href);
+        const Panel = (panelModule.default ?? panelModule.DevPanel);
+        const panelHtml = renderToString(React.createElement(Panel));
+        panelContainer =
+            `<div id="authtics-dev-panel-root">${panelHtml}</div>`;
+        const clientCode = await getHtmlPanelClientBundle();
+        const safeClientCode = clientCode.replace(/<\/script/gi, "<\\/script");
+        panelClientScript = `<script>${safeClientCode}</script>`;
+    }
+    const injection = [
+        panelContainer,
+        configScript,
+        panelClientScript,
+        hotReload ? HMR_SCRIPT : "",
+    ]
+        .filter(Boolean)
+        .join("\n");
+    const bodyClose = /<\/body\s*>/i;
+    if (bodyClose.test(rawHtml)) {
+        return rawHtml.replace(bodyClose, `${injection}\n$&`);
+    }
+    return `${rawHtml}\n${injection}`;
+}
 function buildHtml(opts) {
     const { pageHtml, clientCode, devPanelContainer, templatePath, hotReload, fileName, datRestricted, devMode, renderMode } = opts;
     const configScript = `<script>window.__authtics_config__={datRestricted:${datRestricted ? 'true' : 'false'},devMode:${devMode !== false ? 'true' : 'false'}};</script>`;
@@ -260,11 +355,18 @@ function buildHtml(opts) {
   </body>
 </html>`;
 }
-function isCacheValid(tsxPath, tempPath, serverCjsPath, templatePath, devPanelPath) {
-    if (!fs.existsSync(tempPath) || !fs.existsSync(serverCjsPath))
+function isCacheValid(tsxPath, tempPath, serverCjsPath, templatePath, devPanelPath, clientBundlePath, serverBundleRequired = true, requiredArtifacts = [], checkArtifactFreshness = true) {
+    if (!fs.existsSync(tempPath) || (serverBundleRequired && !fs.existsSync(serverCjsPath)))
+        return false;
+    if (clientBundlePath && !fs.existsSync(clientBundlePath))
+        return false;
+    if (requiredArtifacts.some((artifactPath) => !fs.existsSync(artifactPath)))
         return false;
     try {
         const cacheMtime = fs.statSync(tempPath).mtimeMs;
+        if (checkArtifactFreshness &&
+            requiredArtifacts.some((artifactPath) => fs.statSync(artifactPath).mtimeMs < cacheMtime))
+            return false;
         if (fs.statSync(tsxPath).mtimeMs > cacheMtime)
             return false;
         if (templatePath && fs.existsSync(templatePath) && fs.statSync(templatePath).mtimeMs > cacheMtime)
@@ -277,51 +379,89 @@ function isCacheValid(tsxPath, tempPath, serverCjsPath, templatePath, devPanelPa
         return false;
     }
 }
-const HMR_SCRIPT = `<script>(function(){
-  var reloading=false;
-  window.addEventListener('beforeunload', function() {
-    reloading = true;
-  });
+const HMR_SCRIPT = `<script>
+(function () {
+  var es = null;
+  var disposed = false;
+  var reloading = false;
 
-  var es=new EventSource('/hmr');
-  es.onmessage=function(e){
-    if(e.data==='reload'&&!reloading){
-      reloading=true;
+  function connect() {
+    if (disposed || reloading || es) return;
+
+    es = new EventSource('/hmr');
+
+    es.onopen = function () { };
+
+    es.onmessage = function (event) {
+      if (event.data !== 'reload' || disposed || reloading) return;
+
+      reloading = true;
+
+      es.onmessage = null;
+      es.onerror = null;
       es.close();
+      es = null;
+
       window.location.reload();
+    };
+
+    es.onerror = function () {
+      if (disposed || reloading) return;
+    };
+  }
+
+  function dispose() {
+    if (disposed) return;
+
+    disposed = true;
+
+    if (es) {
+      es.onmessage = null;
+      es.onerror = null;
+      es.close();
+      es = null;
     }
-  };
-  es.onerror=function(){
-    if(!reloading){
-      setTimeout(function(){
-        if(!reloading){
-          reloading=true;
-          window.location.reload();
-        }
-      },1500);
-    }
-  };
-})();</script>`;
-export async function renderPage(tsxPath, reqUrl, showPanel = true, compiler = 'esbuild', hotReload = false, autoPaging = true, autoPageDir, appDir, fileHandler, rmvFileHandler, reqDAT, configDAT, renderMode = 'ssr', patchForSsr = false) {
+  }
+  window.addEventListener('pagehide', dispose, { once: true });
+  window.addEventListener('unload', dispose, { once: true });
+
+  connect();
+})();
+</script>`;
+export async function renderPage(tsxPath, reqUrl, showPanel = true, compiler = 'esbuild', hotReload = false, autoPaging = true, autoPageDir, appDir, fileHandler, rmvFileHandler, reqDAT, configDAT, renderMode = 'ssr', patchForServer = false, prebuildOnly = false) {
     ensureTempDirs();
     if (!fs.existsSync(tsxPath)) {
         throw new Error(`renderPage: source file not found: ${tsxPath}`);
     }
-    let usesDevPanel = showPanel && devPanelPath !== null;
-    if (usesDevPanel) {
-        let datMatched = configDAT === undefined;
-        if (configDAT && configDAT === reqDAT)
-            datMatched = true;
-        if (configDAT && Array.isArray(configDAT) && configDAT.includes(reqDAT ?? ""))
-            datMatched = true;
-        if (!datMatched)
-            usesDevPanel = false;
-    }
+    const datMatches = configDAT === undefined ||
+        configDAT === reqDAT ||
+        (Array.isArray(configDAT) && configDAT.includes(reqDAT ?? ""));
+    const usesDevPanel = showPanel &&
+        devPanelPath !== null &&
+        datMatches;
+    const enableDiagnostics = usesDevPanel;
     const templatePath = resolveTemplate(appDir, autoPageDir, autoPaging);
-    const tempPath = tempFileForTsx(tsxPath);
-    const serverCjsPath = tempPath.replace(/\.json$/, ".server.cjs");
-    const ssgHtmlPath = tempPath.replace(/\.json$/, ".ssg.html");
-    if (renderMode === 'ssg' && isCacheValid(tsxPath, ssgHtmlPath, serverCjsPath, templatePath, devPanelPath)) {
+    const cacheVariant = [
+        usesDevPanel ? "panel" : "normal",
+        enableDiagnostics ? "mapped" : "fast",
+        compiler,
+    ].join("-");
+    const tempPath = tempFileForTsx(tsxPath, cacheVariant);
+    const separateClientBundle = getBuildStyle() === "super";
+    const clientBundlePath = clientBundleForTsx(tsxPath, cacheVariant);
+    const serverCjsPath = serverBundleForTsx(tsxPath, cacheVariant, tempPath);
+    const ssgHtmlPath = ssgHtmlForTsx(tsxPath, cacheVariant, tempPath);
+    const requiredClientBundlePath = separateClientBundle ? clientBundlePath : undefined;
+    const serverCodeDisabled = renderMode === 'csr' || renderMode === 'srtws';
+    const clientJsUrl = `/${path.basename(tempPath).replace(".json", ".js").replace(".tsx_", ".").toLowerCase()}`;
+    const clientMapUrl = `${clientJsUrl}.map`;
+    const clientMapPath = `${clientBundlePath}.map`;
+    const serverMapPath = `${serverCjsPath}.map`;
+    const requiredMapArtifacts = enableDiagnostics && renderMode !== "srtws"
+        ? [clientMapPath, ...(!serverCodeDisabled ? [serverMapPath] : [])]
+        : [];
+    if (renderMode === 'ssg' &&
+        isCacheValid(tsxPath, ssgHtmlPath, serverCjsPath, templatePath, devPanelPath, requiredClientBundlePath, !serverCodeDisabled, requiredMapArtifacts, false)) {
         try {
             return fs.readFileSync(ssgHtmlPath, "utf-8");
         }
@@ -329,19 +469,38 @@ export async function renderPage(tsxPath, reqUrl, showPanel = true, compiler = '
         }
     }
     let clientCode;
+    let clientMap;
     let serverCode;
+    let serverMap;
     let freshWrite = false;
-    if (isCacheValid(tsxPath, tempPath, serverCjsPath, templatePath, devPanelPath) && autoPaging) {
+    if (isCacheValid(tsxPath, tempPath, serverCjsPath, templatePath, devPanelPath, requiredClientBundlePath, !serverCodeDisabled, requiredMapArtifacts) &&
+        (autoPaging || getBuildTrigger() === "prebuilt")) {
         try {
             const parsed = JSON.parse(readTempFile(tempPath));
-            clientCode = parsed.clientCode;
-            serverCode = fs.readFileSync(serverCjsPath, "utf-8");
+            if (separateClientBundle) {
+                const expectedBundleRef = path.relative(process.cwd(), clientBundlePath);
+                clientCode = parsed.clientBundle === expectedBundleRef
+                    ? fs.readFileSync(clientBundlePath, "utf-8")
+                    : undefined;
+            }
+            else {
+                clientCode = parsed.clientCode;
+            }
+            if (enableDiagnostics && renderMode !== "srtws") {
+                clientMap = fs.readFileSync(clientMapPath, "utf-8");
+                if (!serverCodeDisabled)
+                    serverMap = fs.readFileSync(serverMapPath, "utf-8");
+            }
+            serverCode = serverCodeDisabled ? undefined : fs.readFileSync(serverCjsPath, "utf-8");
         }
         catch {
+            clientCode = undefined;
+            clientMap = undefined;
+            serverCode = undefined;
+            serverMap = undefined;
         }
     }
-    const isCsr = renderMode === 'csr';
-    if (!clientCode || (!serverCode && !isCsr)) {
+    if (clientCode === undefined || (clientCode === "" && renderMode !== "srtws") || (!serverCode && !serverCodeDisabled)) {
         const virtualServer = `
       ${usesDevPanel ? `import DevPanel from ${JSON.stringify(devPanelPath)};` : ""}
       import Page from ${JSON.stringify(tsxPath)};
@@ -366,26 +525,64 @@ export async function renderPage(tsxPath, reqUrl, showPanel = true, compiler = '
       }
     `;
         if (compiler === 'esbuild') {
-            if (!isCsr)
-                serverCode = await buildWithEsbuild(virtualServer, process.cwd(), 'node', patchForSsr);
+            if (!serverCodeDisabled) {
+                const builtServer = await buildWithEsbuild(virtualServer, process.cwd(), 'node', patchForServer, {
+                    sourceMaps: enableDiagnostics,
+                    minify: !enableDiagnostics,
+                    outfile: serverCjsPath,
+                    sourceMapUrl: path.basename(serverMapPath),
+                });
+                serverCode = builtServer.code;
+                serverMap = builtServer.map;
+            }
             if (renderMode !== 'srtws') {
-                clientCode = await buildWithEsbuild(virtualClient, process.cwd(), 'browser');
+                const built = await buildWithEsbuild(virtualClient, process.cwd(), 'browser', patchForServer, {
+                    sourceMaps: enableDiagnostics,
+                    minify: !enableDiagnostics,
+                    outfile: clientBundlePath,
+                    sourceMapUrl: clientMapUrl,
+                });
+                clientCode = built.code;
+                clientMap = built.map;
             }
             else {
                 clientCode = "";
             }
         }
         if (serverCode)
-            await fs.promises.writeFile(serverCjsPath, serverCode || "", "utf-8");
-        writeTempFile(tempPath, JSON.stringify({ clientCode }));
+            await fs.promises.writeFile(serverCjsPath, serverCode, "utf-8");
+        if (separateClientBundle) {
+            await fs.promises.writeFile(clientBundlePath, clientCode ?? "", "utf-8");
+            writeTempFile(tempPath, JSON.stringify({
+                clientBundle: path.relative(process.cwd(), clientBundlePath),
+            }));
+        }
+        else {
+            writeTempFile(tempPath, JSON.stringify({ clientCode }));
+        }
+        if (serverMap)
+            await fs.promises.writeFile(serverMapPath, serverMap, "utf-8");
+        if (clientMap)
+            await fs.promises.writeFile(clientMapPath, clientMap, "utf-8");
+        if (requiredMapArtifacts.includes(clientMapPath) && !clientMap) {
+            throw new Error(`[HostJS] Source-map build did not produce ${clientMapPath}`);
+        }
+        if (requiredMapArtifacts.includes(serverMapPath) && !serverMap) {
+            throw new Error(`[HostJS] Source-map build did not produce ${serverMapPath}`);
+        }
         freshWrite = true;
     }
-    fileHandler ? fileHandler(clientCode || "", `/${path.basename(tempPath).replace(".json", ".js").replace(".tsx_", ".").toLowerCase()}`) : null;
+    if (clientCode !== undefined)
+        fileHandler?.(clientCode, clientJsUrl);
+    if (clientMap !== undefined)
+        fileHandler?.(clientMap, clientMapUrl);
+    if (prebuildOnly && renderMode !== 'ssg')
+        return "";
     let pageHtml = "";
     let devPanelContainer = usesDevPanel
         ? `<div id="authtics-dev-panel-root"></div>`
         : "";
-    if (!isCsr) {
+    if (!serverCodeDisabled) {
         const absoluteServerPath = path.resolve(serverCjsPath);
         delete customRequire.cache[absoluteServerPath];
         const serverModule = customRequire(absoluteServerPath);

package/dist/rendererTempFiles.d.ts

@@ -1,5 +1,14 @@
+import type { BuildStyle, BuildTrigger } from "./config.js";
+export declare function setBuildStyle(style: BuildStyle, projectRoot?: string): void;
+export declare function getBuildStyle(): BuildStyle;
+export declare function setBuildTrigger(trigger: BuildTrigger): void;
+export declare function getBuildTrigger(): BuildTrigger;
+export declare function getBuildOutputRoot(): string;
 export declare function ensureTempDirs(): void;
-export declare function tempFileForTsx(tsxPath: string): string;
+export declare function tempFileForTsx(tsxPath: string, variant?: string): string;
+export declare function clientBundleForTsx(tsxPath: string, variant?: string): string;
+export declare function serverBundleForTsx(tsxPath: string, variant?: string, tempPath?: string): string;
+export declare function ssgHtmlForTsx(tsxPath: string, variant?: string, tempPath?: string): string;
 export declare function tempFileForDev(): string;
 export declare function isTempUpToDate(tsxPath: string, tempPath: string): boolean;
 export declare function writeTempFile(tempPath: string, content: string): void;

package/dist/rendererTempFiles.js

@@ -1,25 +1,100 @@
 import fs from "node:fs";
 import path from "node:path";
-const AUTHTICS_DIR = path.join(process.cwd(), ".authtics_host");
-const DEV_CACHE_DIR = path.join(AUTHTICS_DIR, "dev-cache");
-const CACHE_DIR = path.join(AUTHTICS_DIR, "cache");
+let activeBuildStyle = "default";
+let activeBuildTrigger = "default";
+let activeProjectRoot = process.cwd();
+function hostjsDir() {
+    return path.join(activeProjectRoot, ".hostjs");
+}
+function legacyDir() {
+    return path.join(activeProjectRoot, ".authtics_host");
+}
+function artifactName(tsxPath, variant = "normal") {
+    const base = path.basename(tsxPath);
+    const hash = simpleHash(`${tsxPath}:${variant}`);
+    return `${base}_${hash}`;
+}
+export function setBuildStyle(style, projectRoot = process.cwd()) {
+    if (style !== "default" && style !== "super") {
+        throw new Error('[HostJS] Invalid buildStyle. Expected "default" or "super".');
+    }
+    activeBuildStyle = style;
+    activeProjectRoot = path.resolve(projectRoot);
+    ensureTempDirs();
+}
+export function getBuildStyle() {
+    return activeBuildStyle;
+}
+export function setBuildTrigger(trigger) {
+    if (trigger !== "default" && trigger !== "prebuilt") {
+        throw new Error('[HostJS] Invalid buildTrigger. Expected "default" or "prebuilt".');
+    }
+    activeBuildTrigger = trigger;
+}
+export function getBuildTrigger() {
+    return activeBuildTrigger;
+}
+export function getBuildOutputRoot() {
+    return activeBuildStyle === "super" ? hostjsDir() : legacyDir();
+}
 export function ensureTempDirs() {
-    if (!fs.existsSync(AUTHTICS_DIR))
-        fs.mkdirSync(AUTHTICS_DIR, { recursive: true });
-    if (!fs.existsSync(CACHE_DIR))
-        fs.mkdirSync(CACHE_DIR, { recursive: true });
-    if (!fs.existsSync(DEV_CACHE_DIR))
-        fs.mkdirSync(DEV_CACHE_DIR, { recursive: true });
-}
-export function tempFileForTsx(tsxPath) {
+    if (activeBuildStyle === "default") {
+        fs.mkdirSync(legacyDir(), { recursive: true });
+        fs.mkdirSync(path.join(legacyDir(), "cache"), { recursive: true });
+        fs.mkdirSync(path.join(legacyDir(), "dev-cache"), { recursive: true });
+        return;
+    }
+    const dirs = [
+        path.join(hostjsDir(), "cache", "bundler", "client-production"),
+        path.join(hostjsDir(), "cache", "bundler", "server-production"),
+        path.join(hostjsDir(), "cache", "bundler", "edge-server-production"),
+        path.join(hostjsDir(), "diagnostics"),
+        path.join(hostjsDir(), "server", "app"),
+        path.join(hostjsDir(), "server", "pages"),
+        path.join(hostjsDir(), "server", "chunks"),
+        path.join(hostjsDir(), "server", "route-cache"),
+        path.join(hostjsDir(), "types", "app"),
+        path.join(hostjsDir(), "dev"),
+        path.join(hostjsDir(), "trace"),
+        path.join(hostjsDir(), "trace-build"),
+    ];
+    for (const dir of dirs)
+        fs.mkdirSync(dir, { recursive: true });
+}
+export function tempFileForTsx(tsxPath, variant = "normal") {
     ensureTempDirs();
-    const base = path.basename(tsxPath);
-    const hash = simpleHash(tsxPath);
-    return path.join(CACHE_DIR, `${base}_${hash}.json`);
+    const name = artifactName(tsxPath, variant);
+    const dir = activeBuildStyle === "super"
+        ? path.join(hostjsDir(), "server", "route-cache")
+        : path.join(legacyDir(), "cache");
+    return path.join(dir, `${name}.json`);
+}
+export function clientBundleForTsx(tsxPath, variant = "normal") {
+    ensureTempDirs();
+    if (activeBuildStyle === "default") {
+        return tempFileForTsx(tsxPath, variant).replace(/\.json$/, ".client.js");
+    }
+    return path.join(hostjsDir(), "cache", "bundler", "client-production", `${artifactName(tsxPath, variant)}.js`);
+}
+export function serverBundleForTsx(tsxPath, variant = "normal", tempPath) {
+    ensureTempDirs();
+    if (activeBuildStyle === "default") {
+        return (tempPath ?? tempFileForTsx(tsxPath, variant)).replace(/\.json$/, ".server.cjs");
+    }
+    return path.join(hostjsDir(), "cache", "bundler", "server-production", `${artifactName(tsxPath, variant)}.server.cjs`);
+}
+export function ssgHtmlForTsx(tsxPath, variant = "normal", tempPath) {
+    ensureTempDirs();
+    if (activeBuildStyle === "default") {
+        return (tempPath ?? tempFileForTsx(tsxPath, variant)).replace(/\.json$/, ".ssg.html");
+    }
+    return path.join(hostjsDir(), "server", "route-cache", `${artifactName(tsxPath, variant)}.ssg.html`);
 }
 export function tempFileForDev() {
     ensureTempDirs();
-    return path.join(DEV_CACHE_DIR, "page.cache.json");
+    return activeBuildStyle === "super"
+        ? path.join(hostjsDir(), "dev", "page.cache.json")
+        : path.join(legacyDir(), "dev-cache", "page.cache.json");
 }
 export function isTempUpToDate(tsxPath, tempPath) {
     try {
@@ -32,14 +107,23 @@ export function isTempUpToDate(tsxPath, tempPath) {
     }
 }
 export function writeTempFile(tempPath, content) {
+    fs.mkdirSync(path.dirname(tempPath), { recursive: true });
     fs.writeFileSync(tempPath, content, "utf-8");
 }
 export function readTempFile(tempPath) {
     return fs.readFileSync(tempPath, "utf-8");
 }
 export function clearCache() {
-    if (fs.existsSync(CACHE_DIR)) {
-        fs.rmSync(CACHE_DIR, { recursive: true, force: true });
+    if (activeBuildStyle === "default") {
+        fs.rmSync(path.join(legacyDir(), "cache"), { recursive: true, force: true });
+    }
+    else {
+        for (const dir of [
+            path.join(hostjsDir(), "cache", "bundler"),
+            path.join(hostjsDir(), "server", "route-cache"),
+        ]) {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
     }
     ensureTempDirs();
 }

package/dist/superBuildOutput.d.ts

@@ -0,0 +1,9 @@
+import type { AuthticsConfig } from "./config.js";
+export type HostJSRouteKind = "page" | "api" | "static";
+export interface HostJSRouteRecord {
+    pathname: string;
+    kind: HostJSRouteKind;
+    source: string;
+}
+export declare function refreshSuperRouteManifest(projectRoot: string, config: AuthticsConfig, pagesDir?: string, publicDir?: string): void;
+export declare function initializeSuperBuildOutput(projectRoot: string, config: AuthticsConfig, pagesDir?: string, publicDir?: string): void;