bun-plugin-stx 0.2.309 → 0.2.310

package/dist/{chunk-ahmasn2t.js → chunk-zt4e86p1.js}

@@ -1468,8 +1468,10 @@ else {
   // Before the swap: add each sheet the page does not have yet, as
   // media="print" so it downloads without restyling the page still on screen.
   // Returns a promise for them to finish (load OR error, capped at
-  // cssLoadTimeout so a slow or missing sheet never stalls navigation), or null
-  // when nothing new is needed and the swap can go ahead in the same turn.
+  // cssLoadTimeout so a slow sheet never stalls navigation), or null when
+  // nothing new is needed and the swap can go ahead in the same turn. The
+  // promise resolves false when a sheet failed outright, and the caller then
+  // navigates in full rather than swap in markup that has no styles.
   function preloadGeneratedCss(hrefs,base){
     var pending=[];
     hrefs.forEach(function(href){
@@ -1490,14 +1492,34 @@ else {
       link.setAttribute('data-stx-css-pending','');
       link.__stxCssReady=new Promise(function(resolve){
         var timer=setTimeout(finish,o.cssLoadTimeout);
-        function finish(){clearTimeout(timer);link.onload=null;link.onerror=null;link.__stxCssReady=null;resolve()}
-        link.onload=finish;
-        link.onerror=finish;
+        function finish(failed){
+          clearTimeout(timer);link.onload=null;link.onerror=null;link.__stxCssReady=null;
+          // A sheet that failed (a 5xx, a dropped connection) is gone for good:
+          // swapping anyway painted the page with only the utilities the
+          // previous page happened to share, which reads as a broken layout.
+          // Drop the dead <link> so a retry fetches it again, and report it.
+          if(failed===true&&link.parentNode)link.parentNode.removeChild(link);
+          resolve(failed!==true);
+        }
+        link.onload=function(){finish(false)};
+        link.onerror=function(){finish(true)};
       });
       pending.push(link.__stxCssReady);
       document.head.appendChild(link);
     });
-    return pending.length?Promise.all(pending):null;
+    return pending.length?Promise.all(pending).then(function(results){return results.every(function(ok){return ok!==false})}):null;
+  }
+
+  // Swap once the destination's sheets are in, or hand the navigation to the
+  // browser when one could not be fetched \u2014 a full load retries the sheet.
+  function afterCss(ready,url,swapNow){
+    if(!ready)return swapNow();
+    return ready.then(function(ok){
+      if(ok)return swapNow();
+      log('[router] stylesheet failed to load \u2014 full navigation to:',url);
+      location.href=url;
+      return false;
+    });
   }
 
   // At the swap: make the destination's sheets live and move them to the end
@@ -1772,7 +1794,7 @@ else {
       // jumps. Cleanup waits with it so the outgoing page stays live meanwhile.
       // With nothing new to load this runs in the same turn, as it always did.
       var fragCssReady=preloadGeneratedCss(fragmentCssHrefs(html),location.href);
-      return fragCssReady?fragCssReady.then(startFragSwap):startFragSwap();
+      return afterCss(fragCssReady,url,startFragSwap);
     }
 
     // Full document mode: parse with DOMParser and extract container content
@@ -2214,7 +2236,7 @@ else {
       });
     }
     var docCssReady=preloadGeneratedCss(docCssHrefs,docCssBase);
-    return docCssReady?docCssReady.then(startSwap):startSwap();
+    return afterCss(docCssReady,url,startSwap);
   }
 
   // \u2500\u2500 Link interception \u2500\u2500

package/dist/serve.d.ts

@@ -11,6 +11,18 @@ export declare function extractServerScriptsFromTemplate(content: string): {
   serverScripts: string[]
   templateContent: string
 };
+/** The params as a script-safe object literal. */
+export declare function serializeRouteParams(params: Record<string, string>): string;
+/** Put one request's params into a cached dynamic-route shell. */
+export declare function fillRouteParams(html: string, params: Record<string, string>): string;
+/**
+ * Whether a page's server scripts read its route params — `params`, or a
+ * segment by its bare name (`[id].stx` binds `id`). Such a page renders per
+ * record and must not share one cached render across them. Deliberately
+ * coarse: a comment or an unrelated local spelled the same only costs the
+ * cache, never correctness.
+ */
+export declare function serverScriptsReadParams(serverScripts: string[], paramNames: string[]): boolean;
 /**
  * A token to mint for this request, or null to leave it alone.
  *
@@ -199,6 +211,12 @@ export declare function serve(options: ServeOptions): Promise<void>;
  * own templates, including a framework's templates vendored into it.
  */
 export declare function projectUsesImageBuiltins(root: string): Promise<boolean>;
+/**
+ * Stands in for a dynamic route's params in a cached shell. Not valid
+ * JavaScript on its own, so a shell that escaped without being filled fails
+ * loudly instead of running with somebody else's params.
+ */
+export declare const ROUTE_PARAMS_PLACEHOLDER: '__STX_ROUTE_PARAMS__';
 /**
  * The cookie name a double-submit CSRF check reads.
  *

package/dist/serve.js

@@ -8851,6 +8851,19 @@ function extractServerScriptsFromTemplate(content) {
   retained.push(content.slice(retainedFrom));
   return { serverScripts, templateContent: retained.join("") };
 }
+var ROUTE_PARAMS_PLACEHOLDER = "__STX_ROUTE_PARAMS__";
+function serializeRouteParams(params) {
+  return JSON.stringify(params).replace(/</g, "\\u003C").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function fillRouteParams(html, params) {
+  const serialized = serializeRouteParams(params);
+  return html.replace(ROUTE_PARAMS_PLACEHOLDER, () => serialized);
+}
+function serverScriptsReadParams(serverScripts, paramNames) {
+  const names = ["params", ...paramNames].map((name) => name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  const pattern = new RegExp(`(?:^|[^\\w$.])(?:${names.join("|")})(?![\\w$])`);
+  return serverScripts.some((script) => pattern.test(script));
+}
 var CSRF_COOKIE = "X-CSRF-Token";
 function csrfTokenToMint(req, cookies) {
   const method = (req.method || "GET").toUpperCase();
@@ -9713,7 +9726,7 @@ function __stxOverlay(errs){
     pageMiddlewarePatterns.length = 0;
     await Promise.all(files.map((f) => detectPageMiddleware(f)));
     try {
-      const { Router } = await import("./chunk-ahmasn2t.js");
+      const { Router } = await import("./chunk-zt4e86p1.js");
       const pagesDirs = patterns.map((p) => p.replace(/\/$/, "")).filter(Boolean);
       const router = new Router(process19.cwd(), { pagesDirs, stateDir: stateDirName() });
       if (!options.quiet)
@@ -10114,12 +10127,6 @@ function __stxOverlay(errs){
     if (reqCtx)
       reqCtx.responseStatus = extractPageResponseStatus(content) ?? 200;
     const { serverScripts: dynServerScripts, templateContent } = extractServerScriptsFromTemplate(content);
-    const context = {
-      __filename: filePath,
-      __dirname: nodePath.dirname(filePath),
-      __route: routePath,
-      __stx_runtime_head: {}
-    };
     const paramsObj = {};
     for (let i = 0;i < paramNames.length; i++) {
       let value = paramValues[i] ?? "";
@@ -10128,12 +10135,31 @@ function __stxOverlay(errs){
       } catch {}
       paramsObj[paramNames[i]] = value;
     }
+    const isMutating = !!reqCtx && reqCtx.method !== "GET" && reqCtx.method !== "HEAD";
+    const skipCacheHint = /(?:^|[^\w$])__stx_skip_cache\s*=\s*true/.test(content);
+    const cacheShell = ENABLE_HTML_CACHE && RENDER_CACHE_VARY === "source" && paramNames.length > 0 && !isMutating && !skipCacheHint && !serverScriptsReadParams(dynServerScripts, paramNames);
+    if (reqCtx)
+      reqCtx.params = paramsObj;
+    if (cacheShell) {
+      const cachedEntry = htmlCache.get(filePath);
+      if (cachedEntry && await templateSignatureFresh(cachedEntry.signature)) {
+        if (reqCtx) {
+          reqCtx.responseStatus = cachedEntry.status;
+          reqCtx.responseHeaders = cachedEntry.headers;
+        }
+        return fillRouteParams(cachedEntry.html, paramsObj);
+      }
+    }
+    const context = {
+      __filename: filePath,
+      __dirname: nodePath.dirname(filePath),
+      __route: routePath,
+      __stx_runtime_head: {}
+    };
     for (const name of paramNames) {
       context[name] = paramsObj[name];
     }
     context.params = paramsObj;
-    if (reqCtx)
-      reqCtx.params = paramsObj;
     const { processDirectives, extractVariables, defaultConfig: defaultConfig4, injectRouterScript: injectRouter } = await stxModule;
     injectServeLocaleContext(context);
     injectServeRequestContext(context, reqCtx);
@@ -10172,7 +10198,7 @@ function __stxOverlay(errs){
     output = await processDirectives(output, context, filePath, config5, dependencies);
     applyRecordedResponse(context, reqCtx);
     if (paramNames.length > 0) {
-      const serializedParams = JSON.stringify(paramsObj).replace(/</g, "\\u003C").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+      const serializedParams = cacheShell ? ROUTE_PARAMS_PLACEHOLDER : serializeRouteParams(paramsObj);
       const paramsScript = `<script data-stx-route-params>(function(){var p=${serializedParams};window.__stx_rp=p;if(window.stx){window.stx._rp=p;if(window.stx.setRouteParams)window.stx.setRouteParams(p)}})()</script>`;
       if (output.includes("</head>")) {
         output = output.replace("</head>", `${paramsScript}
@@ -10191,7 +10217,14 @@ ${output}`;
         return match;
       return "";
     });
-    return output;
+    if (!cacheShell)
+      return output;
+    const recordedResponse = readResponseStatus(context) !== undefined || !!readResponseHeaders(context);
+    if (!context.__stx_skip_cache && !recordedResponse && isRenderableCacheCandidate(output) && placeholdersAreReady) {
+      const signature = await buildTemplateSignature(filePath, dependencies);
+      htmlCache.set(filePath, { html: output, signature, status: reqCtx?.responseStatus ?? 200, headers: reqCtx?.responseHeaders });
+    }
+    return fillRouteParams(output, paramsObj);
   }
   const startTime = performance.now();
   await discoverFiles();
@@ -11148,7 +11181,9 @@ export {
   usableErrorPage,
   staticCacheControl,
   sharedScriptCacheControl,
+  serverScriptsReadParams,
   serve,
+  serializeRouteParams,
   routeSpecificity,
   responseTakesCsrfCookie,
   resolveServeOpenUrl,
@@ -11159,6 +11194,7 @@ export {
   isRenderableCacheCandidate,
   isRenderFailure,
   isProductionServe,
+  fillRouteParams,
   extractServerScriptsFromTemplate,
   csrfTokenToMint,
   csrfCookieHeader,
@@ -11166,5 +11202,6 @@ export {
   buildDynamicRouteRegexes,
   boundedCache,
   SHARED_SCRIPT_PATH,
+  ROUTE_PARAMS_PLACEHOLDER,
   CSRF_COOKIE
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bun-plugin-stx",
   "type": "module",
-  "version": "0.2.309",
+  "version": "0.2.310",
   "description": "A Bun plugin that allows for using Laravel Blade-like syntax.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",