bun-plugin-stx 0.2.410 → 0.2.412

package/dist/{chunk-51r5j16q.js → chunk-g7br5ehx.js}

@@ -1113,7 +1113,7 @@ function routerSource() {
   //     whole fix \u2014 the click then goes to the network, where navigate does
   //     the reload properly.
   function readPrefetchResponse(r,wantsFragment){
-    if(r.redirected)return Promise.resolve(null);
+    if(r.redirected||r.headers.get('X-STX-Location'))return Promise.resolve(null);
     if(isBuildSkew(r.headers.get('X-STX-Build')||''))return Promise.resolve(null);
     var isFrag=wantsFragment&&r.headers.get('X-STX-Fragment')==='true';
     var layout=r.headers.get('X-STX-Layout')||'';
@@ -1642,6 +1642,18 @@ function routerSource() {
   // swap() through pendingCtx, the same way pendingContainerAttrs is.
   var navCtxNext=null;
   var pendingCtx=null;
+  // The page belongs to another origin: the server says so with
+  // X-STX-Location (it cannot redirect a router fetch there, because a
+  // cross-origin redirect of a request carrying X-STX-Router fails CORS), or
+  // a plain fetch was redirected off-origin. Either way the browser goes
+  // there itself; a fragment from another origin is never swapped in.
+  function leaveOrigin(r){
+    var away=r.headers.get('X-STX-Location');
+    if(!away&&r.redirected&&r.url&&new URL(r.url,location.href).origin!==location.origin)away=r.url;
+    if(!away)return false;
+    location.href=away;
+    return true;
+  }
   function routerFetch(url,headers){
     var init={headers:headers};
     if(navAbort)init.signal=navAbort.signal;
@@ -1733,10 +1745,11 @@ function routerSource() {
         // Layout changed \u2014 fetch full page and do full document swap
         log('[router] cache hit but layout changed \u2014 fetching full page');
         return routerFetch(url,{'Accept':'text/html'}).then(function(r){
+          if(leaveOrigin(r))return null;
           if(!r.ok)throw httpError(r.status);
           return r.text();
         }).then(function(html){
-          if(stale())return false;
+          if(html===null||stale())return false;
           log('[router] full page fetched from cache path, len:',html.length);
           pendingLayoutDecl={layout:layoutCache[targetPath]||'',group:layoutGroupCache[targetPath]||''};
           return swapWith(html,targetPath);
@@ -1761,6 +1774,7 @@ else {
       var wantsFragment=shouldUseFragmentResponse();
       return routerFetch(url,wantsFragment?{'X-STX-Router':'true','Accept':'text/html'}:{'Accept':'text/html'}).then(function(r){
         if(stale())return null;
+        if(leaveOrigin(r))return null;
         if(!r.ok)throw httpError(r.status);
         // A route guard answered with a redirect and fetch followed it
         // transparently, so r.ok is the DESTINATION's 200 and this markup
@@ -1794,6 +1808,7 @@ else {
           log('[router] layout change \u2014 fetching full page for document swap');
           return routerFetch(url,{'Accept':'text/html'}).then(function(fullRes){
             log('[router] full page fetched:',fullRes.status,'ok:',fullRes.ok);
+            if(leaveOrigin(fullRes))return null;
             if(!fullRes.ok)throw httpError(fullRes.status);
             return fullRes.text().then(function(html){
               log('[router] full page html length:',html.length);

package/dist/domain-routes.d.ts

@@ -14,12 +14,23 @@ export declare function matchDomain(host: string, route: DomainRoute): Record<st
  * the root).
  */
 export declare function resolveDomainRoute(host: string, pathname: string, routes: DomainRoute[]): string | null;
+/**
+ * Where a request for another page on a routed host belongs, or null to
+ * answer it in place.
+ *
+ * Only for a route that names `elsewhere`, only for a host that matches it,
+ * only for paths other than the root, and only for page requests: `isAsset`
+ * is the server's own test for scripts, styles, `/api` and `public/` files,
+ * which stay where the page at the root can load them.
+ */
+export declare function resolveDomainElsewhere(host: string, pathname: string, search: string, routes: DomainRoute[], isAsset: (pathname: string) => boolean): string | null;
 /** One line for boot output: `{username}.example.com/ → /{username}`. */
 export declare function describeDomainRoutes(routes: DomainRoute[]): string;
 export declare interface DomainRoute {
   pattern: string
   labels: Label[]
   to: string
+  elsewhere?: string
   literals: number
 }
 /**
@@ -45,6 +56,21 @@ export declare interface DomainRoute {
  * site's own, answered as it would be on the main domain, so one page can be
  * given a domain without the rest of the site breaking under it.
  *
+ * Unless the route says where the rest of the site lives:
+ *
+ * ```ts
+ * domains: {
+ *   '{username}.example.com': { to: '/{username}', elsewhere: 'https://example.com' },
+ * }
+ * ```
+ *
+ * Then a request for any other PAGE on that host is redirected there
+ * (`chris.example.com/pricing` → `example.com/pricing`), while its assets,
+ * `/api` and `public/` files are still answered in place, because the page
+ * at its root needs them. A browser keeps a session per origin: without
+ * this, signing in from a profile's own domain signs in to that domain, and
+ * the visitor ends up using the whole app under someone else's name.
+ *
  * A pattern is a hostname whose labels are either literal or `{name}`, which
  * matches exactly one DNS label (`{username}.example.com` matches
  * `chris.example.com`, not `a.b.example.com` and not the bare apex). Literal
@@ -59,4 +85,4 @@ export declare interface DomainRoute {
  */
 /** One label of a compiled pattern. */
 declare type Label = { literal: string } | { param: string }
-export type DomainRoutesOption = Record<string, string>;
+export type DomainRoutesOption = Record<string, string | { to: string, elsewhere?: string }>;

package/dist/serve.d.ts

@@ -1,5 +1,5 @@
 import { serve as bunServe } from 'bun';
-import { compileDomainRoutes, describeDomainRoutes, requestHost, resolveDomainRoute } from './domain-routes';
+import { compileDomainRoutes, describeDomainRoutes, requestHost, resolveDomainElsewhere, resolveDomainRoute } from './domain-routes';
 import type { DomainRoutesOption } from './domain-routes';
 import type { MiddlewareContext, MiddlewareHandler, MiddlewareRequest, PageMiddleware, PrepareMiddlewareRequest } from './page-middleware';
 export type { DomainRoute, DomainRoutesOption } from './domain-routes';
@@ -392,4 +392,4 @@ export declare interface ServeOptions {
 declare type CssEngine = Pick<typeof import('@stacksjs/ts-css/engine'), 'CSSGenerator' | 'config'>;
 /** The Bun server `serve()` started - handed to `onRequest` beside each request. */
 export type ServeServer = ReturnType<typeof bunServe>;
-export { compileDomainRoutes, describeDomainRoutes, matchDomain, requestHost, resolveDomainRoute } from './domain-routes';
+export { compileDomainRoutes, describeDomainRoutes, matchDomain, requestHost, resolveDomainElsewhere, resolveDomainRoute } from './domain-routes';

package/dist/serve.js

@@ -8728,9 +8728,22 @@ var LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
 var PARAM = /^\{([A-Za-z_]\w*)\}$/;
 function compileDomainRoutes(input, warn = () => {}) {
   const routes = [];
-  for (const [rawPattern, rawTo] of Object.entries(input ?? {})) {
+  for (const [rawPattern, target] of Object.entries(input ?? {})) {
     const pattern = String(rawPattern).trim().toLowerCase().replace(/\.$/, "");
+    const rawTo = typeof target === "object" && target ? target.to : target;
     const to = String(rawTo ?? "").trim();
+    let elsewhere;
+    if (typeof target === "object" && target?.elsewhere) {
+      try {
+        const url = new URL(String(target.elsewhere));
+        if (url.protocol === "https:" || url.protocol === "http:")
+          elsewhere = url.origin;
+      } catch {}
+      if (!elsewhere) {
+        warn(`[stx] domain route "${rawPattern}" ignored: elsewhere "${target.elsewhere}" is not an http(s) origin`);
+        continue;
+      }
+    }
     const parts = pattern.split(".");
     if (parts.length < 2 || !to.startsWith("/")) {
       warn(`[stx] domain route "${rawPattern}" -> "${rawTo}" ignored: a route is a hostname with a dot and a path starting with "/"`);
@@ -8755,7 +8768,7 @@ function compileDomainRoutes(input, warn = () => {}) {
       warn(`[stx] domain route "${rawPattern}" -> "${rawTo}" ignored: ${!valid ? "a label is neither a hostname label nor {name}" : `the path uses {${missing.join("}, {")}} which the hostname does not capture`}`);
       continue;
     }
-    routes.push({ pattern, labels, to, literals: labels.filter((label) => ("literal" in label)).length });
+    routes.push({ pattern, labels, to, ...elsewhere ? { elsewhere } : {}, literals: labels.filter((label) => ("literal" in label)).length });
   }
   return routes.sort((a, b) => b.literals - a.literals || b.labels.length - a.labels.length);
 }
@@ -8796,8 +8809,20 @@ function resolveDomainRoute(host, pathname, routes) {
   }
   return null;
 }
+function resolveDomainElsewhere(host, pathname, search, routes, isAsset) {
+  if (!routes.length || pathname === "/" || pathname === "" || pathname === "/index")
+    return null;
+  for (const route of routes) {
+    if (!matchDomain(host, route))
+      continue;
+    if (!route.elsewhere || isAsset(pathname))
+      return null;
+    return `${route.elsewhere}${pathname}${search}`;
+  }
+  return null;
+}
 function describeDomainRoutes(routes) {
-  return routes.map((route) => `${route.pattern}/ \u2192 ${route.to}`).join(", ");
+  return routes.map((route) => `${route.pattern}/ \u2192 ${route.to}${route.elsewhere ? ` (other pages: ${route.elsewhere})` : ""}`).join(", ");
 }
 // src/page-middleware.ts
 var DEFAULT_PRIORITY = 10;
@@ -9904,7 +9929,7 @@ function __stxOverlay(errs){
     rebuildDiscoveredPagePaths(kept);
     await indexPageMiddleware(kept);
     try {
-      const { Router } = await import("./chunk-51r5j16q.js");
+      const { Router } = await import("./chunk-g7br5ehx.js");
       const pagesDirs = patterns.map((p) => p.replace(/\/$/, "")).filter(Boolean);
       const router = new Router(process19.cwd(), { pagesDirs, stateDir: stateDirName(), exclude: options.exclude });
       if (!options.quiet)
@@ -10577,6 +10602,13 @@ ${block}`;
                 const headers = new Headers(req.headers);
                 headers.set("x-stx-domain-route", requestHost(req));
                 req = new Request(original, { headers, method: req.method, body: req.body, redirect: req.redirect, duplex: "half" });
+              } else if (req.method === "GET" || req.method === "HEAD") {
+                const location = resolveDomainElsewhere(requestHost(req), original.pathname, original.search, domainRoutes, (pathname) => pathname.startsWith("/api/") || pathname.startsWith("/_stx/") || pathname.startsWith("/.well-known/") || isStaticAssetPath(pathname) || publicFileExists(pathname, publicDir));
+                if (location) {
+                  if (req.headers.get(SPA_NAV_HEADER) === "true")
+                    return new Response(null, { status: 200, headers: { "X-STX-Location": location, "Cache-Control": "no-store", Vary: SPA_NAV_HEADER } });
+                  return new Response(null, { status: 301, headers: { Location: location } });
+                }
               }
             }
             const url = new URL(req.url);
@@ -11468,6 +11500,7 @@ export {
   resolveServeOpenUrl,
   resolveImageWarmupBindBudget,
   resolveDomainRoute,
+  resolveDomainElsewhere,
   requestHost,
   render404Page,
   publicFileExists,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bun-plugin-stx",
   "type": "module",
-  "version": "0.2.410",
+  "version": "0.2.412",
   "description": "A Bun plugin that allows for using Laravel Blade-like syntax.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",
@@ -74,7 +74,7 @@
     "typecheck": "bun tsc --noEmit"
   },
   "dependencies": {
-    "@stacksjs/stx": "0.2.410",
-    "stx-router": "0.2.410"
+    "@stacksjs/stx": "0.2.412",
+    "stx-router": "0.2.412"
   }
 }