tungsten 0.7.0 → 0.7.2

package/dist/.build-complete

@@ -1 +1 @@
-1790592400641
+1791130589286

package/dist/FrameworkConfig.d.ts

@@ -43,6 +43,7 @@ export type FrameworkConfigBase = {
     suppressEnvOverwriteWarnings?: boolean;
     hmr?: boolean | 'reload';
     csr?: boolean;
+    serverSideRouting?: boolean;
     defaultCacheControl?: CacheControl;
     registration?: Registration;
 };
@@ -96,6 +97,7 @@ export type FrameworkConfigCompleteBase = {
     warnOnFrameworkChange: boolean;
     hmr: boolean | 'reload';
     csr: boolean;
+    serverSideRouting?: boolean;
     defaultCacheControl?: CacheControl;
     registration?: Registration;
 };

package/dist/Instance/Instance.js

@@ -3,15 +3,10 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { isClient } from '../isClient.js';
 import { routing } from "../Servers/routing.js";
-import { RoutingRedirect } from '../routing/RoutingRedirect.js';
+import { redirectOf } from '../routing/redirectOf.js';
 import { routeKeyToUrl, urlToLocation } from '../routing/routeUrl.js';
 import { isProd } from '../isProd.js';
-import { WebRedirect } from '../routing/WebRedirect.js';
-import { RouteRedirectComponent } from "../components/RouteRedirectComponent.js";
-import { WebRedirectComponent } from "../components/WebRedirectComponent.js";
 import { isServer } from '../isServer.js';
-import { ContentNodeIsClassComponent } from '../ContentNode.js';
-import { $props, $type } from '../contentNodeSymbols.js';
 import { errorOut } from '../appOutput.js';
 import { makeTungstenErrorInfo } from '../routing/TungstenErrorInfo.js';
 import { toRoutes } from '../routing/routesArray.js';
@@ -131,35 +126,13 @@ export class Instance {
         //console.log('matchedRouteInfo', location, matchedRouteInfo)
         //console.log('matched route info', this.matchedRouteInfo)
         if (i !== navigationIndex.get()) return; // another nav has taken over
-        // data here is the result of the route data function
-        if (matchedRouteInfo.data instanceof RoutingRedirect) {
-          const redirect = matchedRouteInfo.data;
+        // A redirect to a URL leaves the app: on the server redirect() writes an HTTP redirect;
+        // in the browser it replaces the location
+        const redirection = redirectOf(matchedRouteInfo);
+        if (redirection !== undefined) {
           // awaited, so goto() settles when the navigation it started has
-          await this.goto(redirect.to);
+          if ('route' in redirection) await this.goto(redirection.route);else this.redirect(redirection.url, redirection.code);
           return;
-        } else if (matchedRouteInfo.data instanceof WebRedirect) {
-          // A WebRedirect names a URL rather than a route, so it leaves the
-          // application — exactly as a WebRedirectComponent returned as
-          // content does below. On the server redirect() writes an HTTP
-          // redirect; in the browser it replaces the location.
-          const redirect = matchedRouteInfo.data;
-          this.redirect(redirect.to, redirect.code);
-          return;
-        }
-        // handle Redirect components
-        // if (
-        //     matchedRouteInfo.content instanceof RedirectComponent
-        //     //&& matchedRouteInfo.content.__tungstenComponentType === 'redirect'
-        // ) {
-        if (typeof matchedRouteInfo.content !== 'function' && ContentNodeIsClassComponent(matchedRouteInfo.content)) {
-          if (matchedRouteInfo.content[$type] === RouteRedirectComponent || matchedRouteInfo.content[$type].prototype instanceof RouteRedirectComponent) {
-            await this.goto(matchedRouteInfo.content[$props].to);
-            return;
-          } else if (matchedRouteInfo.content[$type] === WebRedirectComponent || matchedRouteInfo.content[$type].prototype instanceof WebRedirectComponent) {
-            //console.log('Content is a WebRedirectComponent - perform a hard redirect')
-            this.redirect(matchedRouteInfo.content[$props].to);
-            return;
-          }
         }
         // after routing, before the render: the components' context for the new route
         const afterRouting = pipeline?.afterRouting;

package/dist/Instance/InstanceConfig.d.ts

@@ -8,5 +8,6 @@ export type InstanceConfig = {
     csr: boolean;
     sourceDir?: string;
     registration?: 'pipeline';
+    serverSideRouting?: false;
 };
 //# sourceMappingURL=InstanceConfig.d.ts.map

package/dist/Servers/DevServer.js

@@ -31,9 +31,11 @@ import { TungstenServer } from "./TungstenServer.js";
 import { portError } from './portError.js';
 import { loadEnvsDev } from './loadEnvsDev.js';
 import { initStores } from './initStores.js';
+import { sendStub, stubInstance } from './stubInstance.js';
 import { createContext } from '../context/registerContext.js';
 import { makeTungstenErrorInfo } from '../routing/TungstenErrorInfo.js';
 import { MatchedRoute } from '../routing/MatchedRoute.js';
+import { responseStatus } from '../routing/MatchedRouteInfo.js';
 import { toRoutes } from '../routing/routesArray.js';
 import { resetRegistrations } from './resetRegistrations.js';
 import { PipelineRequestHandler } from '../pipeline/PipelineRequestHandler.js';
@@ -303,6 +305,13 @@ export class DevServer extends TungstenServer {
         const serverDataLoading = {
           value: false
         };
+        // the app's modules load, which registers its stores; none of its functions run
+        if (this.config.serverSideRouting === false && this.config.useRootComponent) {
+          const [appRoutes, Root] = await Promise.all([getRoutesDev(this.compilationInfo, this.config, iteration), getComponentDev(join(this.compilationInfo.buildCodeLocation, this.config.rootComponent), this.config.rootComponent, iteration)]);
+          const instance = stubInstance(location, instanceConfig, reqRes, appRoutes);
+          sendStub(reqRes, undefined, await renderRootToHtmlDev(this.compilationInfo, this.framework.clientImportAliases, Root, instance, this.config, global.tungstenPublicEnv, ''));
+          return;
+        }
         //const routingPromise = getRoutesDev(this.compilationInfo, this.config, load).then(
         const routingPromise = getRoutesDev(this.compilationInfo, this.config, iteration).then(async appRoutes => {
           capturedContext = createContext('server', reqRes);
@@ -425,7 +434,7 @@ export class DevServer extends TungstenServer {
         if (instance.redirected !== undefined) return;
         //debug('html', html)
         res.setHeader('Content-Type', 'text/html');
-        res.status(instance.matchedRouteInfo.key === '404' ? 404 : 200);
+        res.status(responseStatus(instance.matchedRouteInfo));
         res.send(html);
       } catch (e) {
         cliLog('error in TungstenServer handleRequest', e);

package/dist/Servers/ProdServer.d.ts

@@ -27,6 +27,7 @@ export declare class ProdServer extends TungstenServer {
     private handleRequestApi;
     handleRequest: (req: express.Request, res: express.Response) => Promise<void>;
     private tryRenderErrorRoute;
+    private stubRoot;
     errorPage: () => string;
     start(portOverride?: number | null, mute?: boolean): Promise<string>;
     stop(): Promise<void>;

package/dist/Servers/ProdServer.js

@@ -25,9 +25,11 @@ import { initStores } from './initStores.js';
 import { createContext } from '../context/registerContext.js';
 import { createNetworkedData } from '../routing/routingRegistry.js';
 import { makeTungstenErrorInfo } from '../routing/TungstenErrorInfo.js';
+import { responseStatus } from '../routing/MatchedRouteInfo.js';
 import { toRoutes } from '../routing/routesArray.js';
 import { listenVerified, newBootId, registerBootProbe } from './listenVerified.js';
 import { PipelineRequestHandler } from '../pipeline/PipelineRequestHandler.js';
+import { sendStub, stubInstance } from './stubInstance.js';
 function debug(...texts) {
   // console.log(...texts)
 }
@@ -122,6 +124,15 @@ export class ProdServer extends TungstenServer {
         if (this.framework.clientImportAliases === undefined) {
           throwError('ProdServer.handleRequest()', 'framework.clientImportAliases is undefined');
         }
+        if (this.config.serverSideRouting === false) {
+          const reqRes = {
+            req,
+            res
+          };
+          const instance = stubInstance(location, instanceConfig, reqRes, this.appRoutes);
+          sendStub(reqRes, this.config.defaultCacheControl, await renderRootToHtml(this.compilationInfo, this.framework.clientImportAliases, this.stubRoot(), instance, this.config, this.config.siteBasePath));
+          return;
+        }
         // const appRoutes: AppRoutes = await getRoutes(this.compilationInfo, this.config)
         // let RootComponentClass: AnyComponentType
         // if (this.config.useRootComponent) {
@@ -209,7 +220,7 @@ export class ProdServer extends TungstenServer {
           const cacheControl = pageCacheControl(key !== null && Object.hasOwn(routes, key) ? byKey[key] : undefined, routes[$cacheControl], this.config.defaultCacheControl, reqRes);
           if (cacheControl !== undefined) res.setHeader('Cache-Control', cacheControlHeader(cacheControl));
         }
-        res.status(instance.matchedRouteInfo.key === '404' ? 404 : 200);
+        res.status(responseStatus(instance.matchedRouteInfo));
         res.send(html);
       } catch (e) {
         cliLog('handleRequest() error', e);
@@ -285,6 +296,12 @@ export class ProdServer extends TungstenServer {
         return null;
       }
     });
+    _defineProperty(this, "stubRoot", () => {
+      if (this.RootComponentOrNull === null) {
+        throwError('ProdServer', 'config.serverSideRouting is false, which needs a root component');
+      }
+      return this.RootComponentOrNull;
+    });
     _defineProperty(this, "errorPage", () => {
       return `<!DOCTYPE html>
 <html>

package/dist/Servers/routing.js

@@ -46,11 +46,15 @@ export async function routing(location, routes, context, networkedData, serverDa
     params: {},
     content: defaultRoute.content
   };
-  if (_404Route) return {
-    key: '404',
-    params: {},
-    content: _404Route.content
-  };
+  if (_404Route) {
+    const matched = {
+      key: '404',
+      params: {},
+      content: _404Route.content
+    };
+    if ('code' in _404Route && typeof _404Route.code === 'number') matched.code = _404Route.code;
+    return matched;
+  }
   if (errorRoute) {
     return {
       key: 'error',

package/dist/Servers/stubInstance.d.ts

@@ -0,0 +1,8 @@
+import type { CacheControl } from '../cacheControl.js';
+import type { InstanceConfig } from '../Instance/InstanceConfig.js';
+import type { ReqRes } from '../ReqRes.js';
+import type { AppRoutes } from '../routing/AppRoutes.js';
+import { Instance } from '../Instance/Instance.js';
+export declare function stubInstance(location: string, instanceConfig: InstanceConfig, reqRes: ReqRes, appRoutes: AppRoutes<any>): Instance;
+export declare function sendStub(reqRes: ReqRes, cacheControl: CacheControl | undefined, html: string): void;
+//# sourceMappingURL=stubInstance.d.ts.map

package/dist/Servers/stubInstance.js

@@ -0,0 +1,40 @@
+import { cacheControlHeader, pageCacheControl } from '../cacheControl.js';
+import { Instance } from '../Instance/Instance.js';
+import { initStores } from './initStores.js';
+// config.serverSideRouting false: the instance for a page the server makes no data for and does not
+// route. The render stops at the root's head and body (contentTreeToRenderingTree)
+export function stubInstance(location, instanceConfig, reqRes, appRoutes) {
+  const matchedRouteInfo = {
+    key: null,
+    params: {},
+    content: null
+  };
+  const globalData = {};
+  const context = {};
+  const networkedData = {};
+  const {
+    internalStore,
+    stores,
+    storeSubscriptions
+  } = initStores(location, reqRes, globalData, matchedRouteInfo, {
+    value: false
+  }, context, networkedData);
+  const noRoutes = {}; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion -- never routed
+  const instance = new Instance(location, instanceConfig, reqRes, appRoutes, noRoutes, internalStore, stores, storeSubscriptions, globalData, matchedRouteInfo);
+  instance.context = context;
+  instance.networkedData = networkedData;
+  return instance;
+}
+// the same page for every location: no route, so no 404. cacheControl: the config's, in prod
+export function sendStub(reqRes, cacheControl, html) {
+  const {
+    res
+  } = reqRes;
+  res.setHeader('Content-Type', 'text/html');
+  if (res.getHeader('Cache-Control') === undefined) {
+    const chosen = pageCacheControl(undefined, undefined, cacheControl, reqRes);
+    if (chosen !== undefined) res.setHeader('Cache-Control', cacheControlHeader(chosen));
+  }
+  res.status(200);
+  res.send(html);
+}

package/dist/build/createInstanceConfigFile.js

@@ -23,7 +23,7 @@ export async function createInstanceConfigFile(config, mode, buildLocation, file
     // to
     `export default { prod: ${(mode === 'prod').toString()}, useRootComponent: ${config.useRootComponent.toString()}, siteBasePath: "${siteBasePath}", clientSideNav: ${config.clientSideNav.toString()}, staticSite: ${config.staticSite.toString()}, csr: ${config.csr.toString()}` // eslint-disable-line @stylistic/max-len
     // client.ts hydrates by it
-    + (config.registration === 'pipeline' ? ', registration: "pipeline"' : '') + ' };\n'
+    + (config.registration === 'pipeline' ? ', registration: "pipeline"' : '') + (config.serverSideRouting === false ? ', serverSideRouting: false' : '') + ' };\n'
     // not config: the instance holds it. Always exported, as client.ts imports it by name
     + `export const fileVersions = ${JSONstringify(fileVersions) ?? 'undefined'};\n`
     // a constant rollup folds, so the prod bundle holds one of client.ts's hydrate paths

package/dist/componentHelpers.d.ts

@@ -8,8 +8,9 @@ export type ComponentHelpers = {
     readonly routes: Routes;
     readonly context: Context;
     readonly globalData: GlobalData;
-    readonly allRoutesData: GlobalData;
+    readonly allRoutesData: GlobalData | undefined;
     readonly networkedData: NetworkedData;
+    readonly networked: object;
     readonly instance: Instance;
 };
 export declare function makeComponentHelpers(component: {

package/dist/componentHelpers.js

@@ -20,6 +20,9 @@ export function makeComponentHelpers(component) {
     get networkedData() {
       return component.__instance.networkedData;
     },
+    get networked() {
+      return component.__instance.pipelineNetworked;
+    },
     // a getter, not a captured value: the helpers are made once, on first use
     get instance() {
       return component.__instance;

package/dist/frameworkConfigSchema.d.ts

@@ -45,6 +45,7 @@ export declare const frameworkConfigValidator: v.VariantSchema<"useRootComponent
     readonly warnOnFrameworkChange: v.ExactOptionalSchema<v.BooleanSchema<undefined>, undefined>;
     readonly hmr: v.ExactOptionalSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.LiteralSchema<"reload", undefined>], undefined>, undefined>;
     readonly csr: v.ExactOptionalSchema<v.BooleanSchema<undefined>, undefined>;
+    readonly serverSideRouting: v.ExactOptionalSchema<v.BooleanSchema<undefined>, undefined>;
     readonly defaultCacheControl: v.ExactOptionalSchema<v.UnionSchema<[v.PicklistSchema<["no-store", "private-check", "public-check"], undefined>, v.ObjectSchema<{
         readonly privacy: v.PicklistSchema<["private", "public"], undefined>;
         readonly maxAge: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
@@ -53,6 +54,7 @@ export declare const frameworkConfigValidator: v.VariantSchema<"useRootComponent
     readonly registration: v.ExactOptionalSchema<v.PicklistSchema<["register", "pipeline"], undefined>, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly useRootComponent: v.LiteralSchema<false, undefined>;
+    readonly serverSideRouting: v.ExactOptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
     readonly codeDir: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
     readonly copy: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;
     readonly copyExclude: v.ExactOptionalSchema<v.StringSchema<undefined>, undefined>;

package/dist/frameworkConfigSchema.js

@@ -62,6 +62,7 @@ const frameworkConfigBaseEntries = {
   warnOnFrameworkChange: v.exactOptional(v.boolean()),
   hmr: v.exactOptional(v.union([v.boolean(), v.literal('reload')])),
   csr: v.exactOptional(v.boolean()),
+  serverSideRouting: v.exactOptional(v.boolean()),
   defaultCacheControl: v.exactOptional(cacheControlSchema),
   registration: v.exactOptional(v.picklist(['register', 'pipeline']))
 };
@@ -72,7 +73,9 @@ const frameworkConfigWithRootComponentSchema = v.object({
 });
 const frameworkConfigWithoutRootComponentSchema = v.object({
   ...frameworkConfigBaseEntries,
-  useRootComponent: v.literal(false)
+  useRootComponent: v.literal(false),
+  // the stub page's html/head/body come from the root component
+  serverSideRouting: v.exactOptional(v.literal(true))
 });
 // variant, not union: a plain union reports one issue at the union itself ("Expected Object but
 // received Object"), where this picks the branch by useRootComponent and reports its actual fields

package/dist/hydrate/hydrate.js

@@ -38,6 +38,10 @@ import { renderHydrationMismatchBanner } from './renderHydrationMismatchBanner.j
 import { setCurrentInstance } from '../hmr/instanceRegistry.js';
 import { createContext } from '../context/registerContext.js';
 import { renderDocInitErrorBanner } from '../docInit.js';
+import { globalDataFunc } from '../routing/registerGlobalData.js';
+import { createNetworkedData } from '../routing/routingRegistry.js';
+import { routing } from "../Servers/routing.js";
+import { stubRouting } from './stubRouting.js';
 // side-effect only: pulls applyHmrModule.js (and its clean, non-dynamic-import dependencies)
 // into the framework's traced dependency graph so it gets copied to .packages/ and is servable
 // to the browser. It is invoked from a raw, untraced inline script (processHead.ts) instead of
@@ -63,14 +67,29 @@ export async function hydrate(appRoutes, RootComponent, instanceConfig, fileVers
   // happens next (a read of its value throws below). Rendered again at the end, for the count.
   if (isDev) renderDocInitErrorBanner();
   //console.log('hydration global data ', __tungsten_global_data__)
-  const location = urlToLocation(window.location, instanceConfig.siteBasePath, isProd && instanceConfig.staticSite);
+  let location = urlToLocation(window.location, instanceConfig.siteBasePath, isProd && instanceConfig.staticSite);
   // one for the page: navigation keeps this instance, and so this context
   const context = createContext('client', null);
-  // carried over from the server's render, not rebuilt: the client has no request to build from
-  const networkedData = __tungsten_networked_data__;
+  const stub = instanceConfig.serverSideRouting === false;
+  // carried over from the server's render, not rebuilt: the client has no request to build from.
+  // A stub page carries none, so the client makes its own
+  const networkedData = stub ? createNetworkedData(null, context) : __tungsten_networked_data__;
   const routes = toRoutes(typeof appRoutes === 'function' ? appRoutes(null, context, networkedData) : appRoutes, isDev);
-  const matchedRouteInfo = hydrationRouting(__tungsten_matched_route_info__, routes);
-  const globalData = __tungsten_global_data__;
+  let matchedRouteInfo;
+  let globalData;
+  if (stub) {
+    // as a client navigation fetches: the global data beside routing
+    const [fetched, routed] = await Promise.all([globalDataFunc.value?.(null, context, networkedData) ?? {}, stubRouting(location, to => routing(to, routes, context, networkedData), instanceConfig)]);
+    if (routed === null) return;
+    ({
+      location,
+      matchedRouteInfo
+    } = routed);
+    globalData = fetched;
+  } else {
+    matchedRouteInfo = hydrationRouting(__tungsten_matched_route_info__, routes);
+    globalData = __tungsten_global_data__;
+  }
   const {
     internalStore,
     stores,
@@ -87,7 +106,7 @@ export async function hydrate(appRoutes, RootComponent, instanceConfig, fileVers
   //     instance.routerData = __tungsten_router_data__
   // }
   // save the route data
-  if (typeof __tungsten_route_data__ !== 'undefined') {
+  if (!stub && typeof __tungsten_route_data__ !== 'undefined') {
     instance.routeData = __tungsten_route_data__;
   }
   const domPointer = new DomPointer(document, 1);
@@ -530,12 +549,14 @@ parentElement, domPointer, instance, meta) {
     const outerSelectValue = meta.selectValue;
     if (node[$type] === 'select') meta.selectValue = node[$props].value;
     let renderedChildren = $contentNull;
-    if (node[$type] === 'body' && instance.config.csr) {
-      // CSR: body shipped empty on purpose, nothing to hydrate against - create fresh.
+    // CSR: body shipped empty on purpose, nothing to hydrate against - create fresh. A stub
+    // page (serverSideRouting false) ships the head without the app's children too
+    const fresh = node[$type] === 'body' && instance.config.csr || node[$type] === 'head' && instance.config.serverSideRouting === false;
+    if (fresh) {
       if (parentElement === null) {
-        throwError('hydrateNodeSingle', 'CSR hydration reached <body> with no owning component');
+        throwError('hydrateNodeSingle', `CSR hydration reached <${node[$type]}> with no owning component`);
       }
-      const childDomPointer = new DomPointer(domNode);
+      const childDomPointer = new DomPointer(domNode, node[$type] === 'head' ? appHeadChildrenStart(domNode) : 0);
       renderedChildren = await applyUpdate({
         tungstenElement: parentElement,
         instance,

package/dist/hydrate/stubRouting.d.ts

@@ -0,0 +1,8 @@
+import type { InstanceConfig } from '../Instance/InstanceConfig.js';
+import type { MatchedRouteInfo } from '../routing/MatchedRouteInfo.js';
+export type StubRouted = {
+    location: string;
+    matchedRouteInfo: MatchedRouteInfo;
+};
+export declare function stubRouting(location: string, route: (location: string) => Promise<MatchedRouteInfo>, instanceConfig: InstanceConfig): Promise<StubRouted | null>;
+//# sourceMappingURL=stubRouting.d.ts.map

package/dist/hydrate/stubRouting.js

@@ -0,0 +1,25 @@
+import { isProd } from '../isProd.js';
+import { redirectOf } from '../routing/redirectOf.js';
+import { routeKeyToUrl } from '../routing/routeUrl.js';
+import { TungstenError } from '../TungstenError.js';
+// config.serverSideRouting false: the page's first routing is the client's, with its route data. A
+// redirect to a route routes again, the address bar replaced, before anything is built; one to a
+// URL leaves the page, and gives null
+export async function stubRouting(location, route, instanceConfig) {
+  for (let hops = 0; hops <= 10; hops++) {
+    const matchedRouteInfo = await route(location);
+    const redirection = redirectOf(matchedRouteInfo);
+    if (redirection === undefined) return {
+      location,
+      matchedRouteInfo
+    };
+    if ('url' in redirection) {
+      window.location.replace(redirection.url);
+      return null;
+    }
+    location = redirection.route;
+    const url = routeKeyToUrl(redirection.route, instanceConfig.siteBasePath, isProd && instanceConfig.staticSite);
+    window.history.replaceState(null, '', url);
+  }
+  throw new TungstenError(`Routing '${location}' redirected more than 10 times`);
+}

package/dist/makeFinalConfig.js

@@ -12,5 +12,7 @@ export function makeFinalConfig(userConfig, overrides = null) {
     if (value === undefined) continue;
     finalConfig[key] = value; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
   }
+  // no server data means nothing for the body: the client builds it
+  if (finalConfig.serverSideRouting === false) finalConfig.csr = true;
   return finalConfig;
 }

package/dist/makeInstanceConfigFromFrameworkConfig.js

@@ -10,5 +10,6 @@ export function makeInstanceConfigFromFrameworkConfig(frameworkConfig, dev = fal
   };
   if ('sourceDir' in frameworkConfig) c.sourceDir = frameworkConfig.sourceDir;
   if (frameworkConfig.registration === 'pipeline') c.registration = 'pipeline';
+  if (frameworkConfig.serverSideRouting === false) c.serverSideRouting = false;
   return c;
 }

package/dist/pipeline/PipelineRequestHandler.js

@@ -5,7 +5,9 @@ import { $cacheControl, cacheControlHeader, pageCacheControl } from '../cacheCon
 import { cliLog } from '../cliOutput.js';
 import { Instance } from '../Instance/Instance.js';
 import { MatchedRoute } from '../routing/MatchedRoute.js';
+import { responseStatus } from '../routing/MatchedRouteInfo.js';
 import { initStores } from '../Servers/initStores.js';
+import { sendStub, stubInstance } from '../Servers/stubInstance.js';
 import { TungstenServer } from "../Servers/TungstenServer.js";
 import { NetworkedTransport } from './networkedTransport.js';
 import { pipelineRoutes, symmetricServer } from './runPipeline.js';
@@ -40,6 +42,12 @@ export class PipelineRequestHandler extends TungstenServer {
         const serverDataLoading = {
           value: false
         };
+        if (config.serverSideRouting === false) {
+          const instance = stubInstance(location, this.options.instanceConfig(), reqRes, appRoutesFor(app, undefined, dev));
+          const html = await this.options.render(Root ?? MatchedRoute, instance);
+          sendStub(reqRes, dev ? undefined : config.defaultCacheControl, html);
+          return;
+        }
         const runner = app.split === true ? splitServer : symmetricServer;
         const {
           init,
@@ -78,7 +86,7 @@ export class PipelineRequestHandler extends TungstenServer {
           const cacheControl = pageCacheControl(key !== null && Object.hasOwn(routes, key) ? byKey[key] : undefined, routes[$cacheControl], config.defaultCacheControl, reqRes);
           if (cacheControl !== undefined) res.setHeader('Cache-Control', cacheControlHeader(cacheControl));
         }
-        res.status(instance.matchedRouteInfo.key === '404' ? 404 : 200);
+        res.status(responseStatus(instance.matchedRouteInfo));
         res.send(html);
       } catch (e) {
         cliLog('pipeline handleRequest() error', e);

package/dist/pipeline/hydratePipeline.js

@@ -1,4 +1,6 @@
 import { DomPointer } from '../DomPointer.js';
+import { stubRouting } from '../hydrate/stubRouting.js';
+import { routing } from "../Servers/routing.js";
 import { renderDocInitErrorBanner } from '../docInit.js';
 import { setCurrentInstance } from '../hmr/instanceRegistry.js';
 import { hydrateRootComponent, hydrationRouting, makeDefaultHydrateMeta } from "../hydrate/hydrate.js";
@@ -21,16 +23,31 @@ export async function hydratePipeline(app, RootComponent, instanceConfig, fileVe
   if (!isPipelineApp(app)) {
     throw new TungstenError(`config.registration is 'pipeline', but the routes module exports no pipeline app under` + ` config.routesLocation's name: export the result of the pipeline's .routes().`);
   }
-  const location = urlToLocation(window.location, instanceConfig.siteBasePath, isProd && instanceConfig.staticSite);
-  const allRoutesData = __tungsten_global_data__;
-  const ran = await app.client(app, allRoutesData, __tungsten_networked_data__);
+  let location = urlToLocation(window.location, instanceConfig.siteBasePath, isProd && instanceConfig.staticSite);
+  const ran = await app.client(app, __tungsten_networked_data__);
   const init = ran.init;
   const routes = pipelineRoutes(app, null, init, isDev);
-  const matchedRouteInfo = hydrationRouting(__tungsten_matched_route_info__, routes);
-  const afterRouting = afterRoutingFor(ran.afterRouting);
-  const brandedContext = afterRouting === undefined ? ran.context // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion -- the framework brands what it builds
-  : await afterRouting(clientRoute(matchedRouteInfo, location), allRoutesData);
+  const routeContext = routingContext(ran.routingContext);
   const networkedData = routingNetworkedData(ran.routingNetworkedData);
+  let allRoutesData;
+  let matchedRouteInfo;
+  if (instanceConfig.serverSideRouting === false) {
+    // a stub page: the client's own all-routes data, beside its first routing, as a navigation's
+    const [fetched, routed] = await Promise.all([ran.allRoutesData?.(), stubRouting(location, to => routing(to, routes, routeContext, networkedData), instanceConfig)]);
+    if (routed === null) return;
+    ({
+      location,
+      matchedRouteInfo
+    } = routed);
+    allRoutesData = fetched; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion -- the framework brands what it builds
+  } else {
+    allRoutesData = __tungsten_global_data__;
+    matchedRouteInfo = hydrationRouting(__tungsten_matched_route_info__, routes);
+  }
+  const posted = await ran.post(allRoutesData);
+  const afterRouting = afterRoutingFor(posted.afterRouting);
+  const brandedContext = afterRouting === undefined ? posted.context // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion -- the framework brands what it builds
+  : await afterRouting(clientRoute(matchedRouteInfo, location), allRoutesData);
   const {
     internalStore,
     stores,
@@ -42,13 +59,15 @@ export async function hydratePipeline(app, RootComponent, instanceConfig, fileVe
   instance.networkedData = networkedData;
   instance.pipelineNetworked = ran.networked;
   instance.pipeline = {
-    routingContext: routingContext(ran.routingContext),
+    routingContext: routeContext,
     routingNetworkedData: networkedData,
     allRoutesData: allRoutesDataFor(ran.allRoutesData),
     afterRouting
   };
   if (isDev) setCurrentInstance(instance);
-  if (typeof __tungsten_route_data__ !== 'undefined') instance.routeData = __tungsten_route_data__;
+  if (instanceConfig.serverSideRouting !== false && typeof __tungsten_route_data__ !== 'undefined') {
+    instance.routeData = __tungsten_route_data__;
+  }
   const meta = makeDefaultHydrateMeta();
   await hydrateRootComponent(instance, RootComponent ?? MatchedRoute, new DomPointer(document, 1), meta);
   instance.hydrationComplete = true;