tungsten 0.7.2 → 0.8.0

package/dist/pipeline/settleRouting.js

@@ -0,0 +1,54 @@
+import { redirectOf } from '../routing/redirectOf.js';
+// stands in for routing's result when the all-routes data redirects, which wins over it
+const notRouted = {
+  key: null,
+  params: {},
+  content: null
+};
+const reasonOf = result => result.status === 'rejected' ? result.reason : undefined;
+// Routing and the all-routes data, settled together, so a failure in one cannot hide the other's
+// redirect. A failure recovers to the app's 'error' route: a routing failure always, as the
+// all-routes data is there for Post; a failed all-routes data when the app gave a fallback, which
+// stands in for it. With neither, or with no 'error' route, the failure is thrown
+export async function settleRouting(routes, route, loadData, fallback, errorInfo) {
+  const [data, routed] = await Promise.allSettled([Promise.resolve(loadData?.()), route()]);
+  let allRoutesData;
+  if (data.status === 'fulfilled') {
+    allRoutesData = data.value;
+  } else if (fallback !== undefined) {
+    allRoutesData = await fallback(data.reason);
+  } else {
+    throw data.reason;
+  }
+  if (redirectOf(notRouted, allRoutesData) !== undefined) {
+    return {
+      allRoutesData,
+      matchedRouteInfo: notRouted
+    };
+  }
+  if (routed.status === 'fulfilled') {
+    const matchedRouteInfo = routed.value;
+    // a route's redirect goes ahead over a recovered all-routes data
+    if (data.status === 'fulfilled' || redirectOf(matchedRouteInfo) !== undefined) {
+      return {
+        allRoutesData,
+        matchedRouteInfo
+      };
+    }
+  }
+  // the all-routes data's failure first: it is the one recovered from
+  const error = data.status === 'rejected' ? data.reason : reasonOf(routed);
+  const errorRoute = routes.error;
+  if (errorRoute === undefined) throw error;
+  return {
+    allRoutesData,
+    matchedRouteInfo: {
+      key: 'error',
+      params: {},
+      content: errorRoute.content,
+      code: 500,
+      data: errorInfo(error)
+    },
+    recoveredFrom: error
+  };
+}

package/dist/pipeline/splitPipeline.d.ts

@@ -1,6 +1,7 @@
 import type { JsonValue } from 'sxy-types';
 import type { Serializable } from '../routing/Serializable.js';
 import type { TrueStore } from '../Store/makeStore.js';
+import type { DataRedirect } from '../routing/DataRedirect.js';
 import type { Nothing, PostStage, SerializableData, StageMark } from './pipeline.js';
 import type { ClientRoute, MaybePromise, ServerKind, ServerRequests } from './pipelineDefinition.js';
 type ContextOf<X> = X extends {
@@ -23,17 +24,19 @@ type ClientPostSplit<X> = X extends object ? {
     [K in keyof X]: K extends 'context' ? X[K] & object : never;
 } : X;
 type ServerInitProcess<Req, SI> = (reqRes: Req) => MaybePromise<SI & SerializableSplit<NoInfer<SI>>>;
-type ServerAllRoutesDataProcess<Req, SI, G> = (reqRes: Req, init: SI) => MaybePromise<G & SerializableData<NoInfer<G>>>;
+type ServerAllRoutesDataProcess<Req, SI, G> = (reqRes: Req, init: SI, location: string) => MaybePromise<(G & SerializableData<NoInfer<G>>) | DataRedirect>;
+type ServerAllRoutesDataFallback<Req, SI, G> = NoInfer<G> | ((reqRes: Req, init: SI, location: string, error: unknown) => MaybePromise<NoInfer<G> | DataRedirect>);
 type ServerPostProcess<Req, SI, SP, G> = (reqRes: Req, init: SI, allRoutesData: G) => MaybePromise<SP & SerializableSplit<NoInfer<SP>>>;
 type ClientInitProcess<N, CI> = (networked: N) => MaybePromise<CI & ClientSplit<NoInfer<CI>>>;
-type ClientAllRoutesDataProcess<CI, G> = (init: CI) => MaybePromise<G>;
+type ClientAllRoutesDataProcess<CI, G> = (init: CI, location: string) => MaybePromise<G | DataRedirect>;
+type ClientAllRoutesDataFallback<CI, G> = NoInfer<G> | ((init: CI, location: string, error: unknown) => MaybePromise<NoInfer<G> | DataRedirect>);
 type ClientPostProcess<CI, CP, G> = (init: CI, allRoutesData: G) => MaybePromise<CP & ClientPostSplit<NoInfer<CP>>>;
 type ClientAfterRoutingProcess<PC, CA, G> = (context: PC, route: ClientRoute, allRoutesData: G) => MaybePromise<CA & ClientPostSplit<NoInfer<CA>>>;
-export type SplitFinalStage<Req, SI, CI, G extends object | undefined, ServerCtx, N, PC> = PostStage<Req, SI | CI, ServerCtx | PC, N, G> & {
-    clientAfterRouting: <CA extends object, This>(this: This, process: ClientAfterRoutingProcess<PC, CA, G>) => PostStage<Req, SI | CI, ServerCtx | ContextOf<CA>, N, G> & StageMark<This, 'clientAfterRouting', CA, ContextOf<CA>>;
+export type SplitFinalStage<Req, SI, CI, G extends object | undefined, ServerCtx, N, PC> = PostStage<Req, SI | CI, ServerCtx | PC, N, G, ContextOf<SI> | ContextOf<CI>, NetworkedOf<SI>> & {
+    clientAfterRouting: <CA extends object, This>(this: This, process: ClientAfterRoutingProcess<PC, CA, G>) => PostStage<Req, SI | CI, ServerCtx | ContextOf<CA>, N, G, ContextOf<SI> | ContextOf<CI>, NetworkedOf<SI>> & StageMark<This, 'clientAfterRouting', CA, ContextOf<CA>>;
 };
 export type ClientDataStage<Req, SI, CI, G extends object | undefined, ServerCtx, N, PC> = {
-    clientAllRoutesData: <This>(this: This, process: ClientAllRoutesDataProcess<CI, G>) => SplitFinalStage<Req, SI, CI, G, ServerCtx, N, PC> & StageMark<This, 'clientAllRoutesData', G, PC>;
+    clientAllRoutesData: <This>(this: This, process: ClientAllRoutesDataProcess<CI, G>, fallback?: ClientAllRoutesDataFallback<CI, G>) => SplitFinalStage<Req, SI, CI, G, ServerCtx, N, PC> & StageMark<This, 'clientAllRoutesData', G, PC>;
 };
 type AfterClientPost<Req, SI, CI, G extends object | undefined, D extends boolean, ServerCtx, N, PC> = D extends true ? ClientDataStage<Req, SI, CI, G, ServerCtx, N, PC> : SplitFinalStage<Req, SI, CI, G, ServerCtx, N, PC>;
 export type ClientPostStage<Req, SI, CI, G extends object | undefined, D extends boolean, ServerCtx, N> = AfterClientPost<Req, SI, CI, G, D, ServerCtx, N, ContextOf<CI>> & {
@@ -49,7 +52,7 @@ export type PipelineServerAllRoutesData<X extends {
     serverPost: (process: never) => unknown;
 }> = Parameters<Parameters<X['serverPost']>[0]>[2];
 export type SplitInitStage<Req, SI> = SplitDataStage<Req, SI, undefined, false> & {
-    serverAllRoutesData: <G extends object, This>(this: This, process: ServerAllRoutesDataProcess<Req, SI, G>) => SplitDataStage<Req, SI, G, true> & StageMark<This, 'serverAllRoutesData', G, ContextOf<SI>>;
+    serverAllRoutesData: <G extends object, This>(this: This, process: ServerAllRoutesDataProcess<Req, SI, G>, fallback?: ServerAllRoutesDataFallback<Req, SI, G>) => SplitDataStage<Req, SI, G, true> & StageMark<This, 'serverAllRoutesData', G, ContextOf<SI>>;
 };
 export type SplitServerStage<Req> = {
     serverInit: <SI extends object | undefined, This>(this: This, process: ServerInitProcess<Req, SI>) => SplitInitStage<Req, SI> & StageMark<This, 'serverInit', SI, ContextOf<SI>>;

package/dist/pipeline/splitPipeline.js

@@ -13,9 +13,10 @@ function splitFinalStage(definition) {
 function afterClientPost(definition) {
   return {
     ...splitFinalStage(definition),
-    clientAllRoutesData: clientData => splitFinalStage({
+    clientAllRoutesData: (clientData, fallback) => splitFinalStage({
       ...definition,
-      clientAllRoutesData: loosely(clientData)
+      clientAllRoutesData: loosely(clientData),
+      clientAllRoutesDataFallback: loosely(fallback)
     })
   };
 }
@@ -49,9 +50,10 @@ function splitDataStage(definition) {
 function splitInitStage(definition) {
   return {
     ...splitDataStage(definition),
-    serverAllRoutesData: process => splitDataStage({
+    serverAllRoutesData: (process, fallback) => splitDataStage({
       ...definition,
-      allRoutesData: loosely(process)
+      allRoutesData: loosely(process),
+      allRoutesDataFallback: loosely(fallback)
     })
   };
 }

package/dist/postcssPlugins/TransformCssNames.d.ts

@@ -4,12 +4,12 @@ type Opts = {
     moduleName: string;
     outNames: CssNames;
 };
-export declare const TransformCssNames: {
-    (opts: Opts): {
-        postcssPlugin: string;
-        Once(root: Root): void;
-    };
-    postcss: boolean;
+export declare function TransformCssNames(opts: Opts): {
+    postcssPlugin: string;
+    Once(root: Root): void;
 };
+export declare namespace TransformCssNames {
+    var postcss: boolean;
+}
 export {};
 //# sourceMappingURL=TransformCssNames.d.ts.map

package/dist/render/contentTreeToRenderingTree.js

@@ -57,9 +57,7 @@ export async function contentTreeToRenderingTree(node, parentComponent, instance
       return {
         [$type]: node[$type],
         [$key]: node[$key],
-        [$props]: {
-          ...rest
-        }
+        [$props]: rest
       };
     }
     //renderingNode node

package/dist/render/instantiateClassComponent.d.ts

@@ -1,5 +1,5 @@
 import type { ContentNodeClassComponent } from '../ContentNode.js';
 import type { TungstenElement } from '../TungstenElement.js';
 import type { Instance } from '../Instance/Instance.js';
-export declare function instantiateClassComponent(node: ContentNodeClassComponent, parentComponent: (TungstenElement | null) | undefined, instance: Instance): Promise<import("../Components.jsx").TungstenBaseComponent<any, any>>;
+export declare function instantiateClassComponent(node: ContentNodeClassComponent, parentComponent: TungstenElement | null | undefined, instance: Instance): Promise<import("../Components.jsx").TungstenBaseComponent<any, any>>;
 //# sourceMappingURL=instantiateClassComponent.d.ts.map

package/dist/render/processHead.js

@@ -7,6 +7,18 @@ import { $props, $type } from '../contentNodeSymbols.js';
 function versioned(href, version) {
   return version === undefined ? href : `${href}?v=${version}`;
 }
+// the error route's data is a TungstenErrorInfo, as the framework makes it
+const errorMessageOf = data => {
+  if (typeof data !== 'object' || data === null || !('message' in data)) return undefined;
+  return typeof data.message === 'string' ? data.message : undefined;
+};
+const errorOf = data => typeof data === 'object' && data !== null && 'error' in data ? data.error : undefined;
+const errorForPage = error => error instanceof Error ? {
+  ...error,
+  name: error.name,
+  message: error.message,
+  stack: error.stack
+} : error;
 // process the tree returned by the root component
 // doing things like ensuring there is are html and head elements,
 // and adding necessary style and script tags.
@@ -111,7 +123,26 @@ export function processHead(headNode, headData) {
     content: _,
     ...networkMatchedRoundInfo
   } = instance.matchedRouteInfo; // @typescript-eslint/no-unused-vars
+  // the error route's data holds what was thrown: in prod the message only, as below; in dev all
+  // of it, with what an Error keeps non-enumerable
+  if (networkMatchedRoundInfo.key === 'error') {
+    const data = networkMatchedRoundInfo.data;
+    networkMatchedRoundInfo.data = dev ? {
+      message: errorMessageOf(data),
+      error: errorForPage(errorOf(data))
+    } : {
+      message: errorMessageOf(data)
+    };
+  }
+  const errorInfo = instance.errorInfo;
   let varsScriptContent = `var __tungsten_prod__=${String(!dev)};` + `var __tungsten_global_data__=${serializeJavascript(instance.globalData)};`
+  // in prod the message only: what was thrown may hold what the browser should not see
+  + (errorInfo === undefined ? '' : `var __tungsten_error_info__=${serializeJavascript(dev ? {
+    message: errorInfo.message,
+    error: errorForPage(errorInfo.error)
+  } : {
+    message: errorInfo.message
+  })};`)
   // the networked store crosses to the client as data - hydrate reads it, never rebuilds it
   + `var __tungsten_networked_data__=${serializeJavascript(instance.networkedData)};` + `var __tungsten_matched_route_info__=${serializeJavascript(networkMatchedRoundInfo)};`;
   // route Data

package/dist/render/processProps.d.ts

@@ -1,3 +1,8 @@
 import type { TungstenComponentGenericProps } from '../Components.jsx';
-export declare function processProps(props: TungstenComponentGenericProps): TungstenComponentGenericProps;
+export declare function processProps(givenProps: TungstenComponentGenericProps): {
+    [x: string]: unknown;
+    children?: import("../ContentNode.js").ContentNode;
+    routeParams?: import("../indexInner.js").RouteParams;
+    routeData?: import("../indexInner.js").RouteData;
+};
 //# sourceMappingURL=processProps.d.ts.map

package/dist/render/processProps.js

@@ -11,10 +11,12 @@ import { StringIsHtmlEvent } from '../htmlEvents.js';
 // about which props are attributes at all.
 const omitProps = ['ref', '__zoneHtml', '__opaque', 'dangerouslySetInnerHTML'];
 //// !!!! We need to handle bind here
-export function processProps(props) {
-  props = objectFilter(props, key => {
-    return !omitProps.includes(key) && !StringIsHtmlEvent(key);
-  });
+export function processProps(givenProps) {
+  const props = {
+    ...objectFilter(givenProps, key => {
+      return !omitProps.includes(key) && !StringIsHtmlEvent(key);
+    })
+  };
   // if ('className' in props) {
   //     if ('class' in props) {
   //         props.class = `${props.class} ${props.className}`

package/dist/render/rootToHtml.d.ts

@@ -5,5 +5,5 @@ import type { ImportAliases } from '../build/ImportAliases.js';
 import type { SiteBasePath } from './HeadData.js';
 import type { AnyComponentType } from '../AnyComponentType.js';
 import type { Instance } from '../Instance/Instance.js';
-export declare function rootToHtml(compilationInfo: CompilationInfo, clientImportAliases: ImportAliases, RootComponentClass: AnyComponentType, instance: Instance, config: FrameworkConfigComplete, siteBasePathOverride: SiteBasePath, tungstenPublicEnv?: TungstenEnvOrUndefined, dev?: boolean): Promise<string>;
+export declare function rootToHtml(compilationInfo: CompilationInfo, clientImportAliases: ImportAliases, RootComponentClass: AnyComponentType, instance: Instance, config: FrameworkConfigComplete, siteBasePathOverride: SiteBasePath, tungstenPublicEnv?: TungstenEnvOrUndefined, dev?: boolean, rootProps?: object): Promise<string>;
 //# sourceMappingURL=rootToHtml.d.ts.map

package/dist/render/rootToHtml.js

@@ -1,10 +1,10 @@
 import { $props, $type } from '../contentNodeSymbols.js';
 import { contentToHtml } from './contentToHtml.js';
-export async function rootToHtml(compilationInfo, clientImportAliases, RootComponentClass, instance, config, siteBasePathOverride, tungstenPublicEnv = undefined, dev = false) {
+export async function rootToHtml(compilationInfo, clientImportAliases, RootComponentClass, instance, config, siteBasePathOverride, tungstenPublicEnv = undefined, dev = false, rootProps = {}) {
   const rootNode = {
     [$type]: RootComponentClass,
     // TypeScript needs some help to understand that { type: AnyComponentType }
-    [$props]: {} // is equivalent to { type: ClassComponentTypeAny } | { type: FunctionComponentTypeAny } (type names simplified here)
+    [$props]: rootProps // is equivalent to { type: ClassComponentTypeAny } | { type: FunctionComponentTypeAny } (type names simplified here)
   };
   return contentToHtml(compilationInfo, clientImportAliases, rootNode, instance, config, siteBasePathOverride, tungstenPublicEnv, dev);
 }

package/dist/render/rootToHtmlDev.d.ts

@@ -5,5 +5,5 @@ import type { Instance } from '../Instance/Instance.js';
 import type { SiteBasePath } from './HeadData.js';
 import type { TungstenEnvOrUndefined } from '../env/types.js';
 import type { FrameworkConfigComplete } from '../FrameworkConfig.js';
-export declare function rootToHtmlDev(compilationInfo: CompilationInfo, clientImportAliases: ImportAliases, RootComponentClass: AnyComponentType, instance: Instance, config: FrameworkConfigComplete, tungstenPrivateEnv: TungstenEnvOrUndefined, siteBasePathOverride: SiteBasePath): Promise<string>;
+export declare function rootToHtmlDev(compilationInfo: CompilationInfo, clientImportAliases: ImportAliases, RootComponentClass: AnyComponentType, instance: Instance, config: FrameworkConfigComplete, tungstenPrivateEnv: TungstenEnvOrUndefined, siteBasePathOverride: SiteBasePath, rootProps?: object): Promise<string>;
 //# sourceMappingURL=rootToHtmlDev.d.ts.map

package/dist/render/rootToHtmlDev.js

@@ -1,4 +1,4 @@
 import { rootToHtml } from './rootToHtml.js';
-export async function rootToHtmlDev(compilationInfo, clientImportAliases, RootComponentClass, instance, config, tungstenPrivateEnv, siteBasePathOverride) {
-  return await rootToHtml(compilationInfo, clientImportAliases, RootComponentClass, instance, config, siteBasePathOverride, tungstenPrivateEnv, true);
+export async function rootToHtmlDev(compilationInfo, clientImportAliases, RootComponentClass, instance, config, tungstenPrivateEnv, siteBasePathOverride, rootProps = {}) {
+  return await rootToHtml(compilationInfo, clientImportAliases, RootComponentClass, instance, config, siteBasePathOverride, tungstenPrivateEnv, true, rootProps);
 }

package/dist/routing/DataRedirect.d.ts

@@ -0,0 +1,4 @@
+import type { RoutingRedirect } from './RoutingRedirect.js';
+import type { WebRedirect } from './WebRedirect.js';
+export type DataRedirect = RoutingRedirect | WebRedirect;
+//# sourceMappingURL=DataRedirect.d.ts.map

package/dist/routing/DataRedirect.js

@@ -0,0 +1 @@
+export {};

package/dist/routing/Group.d.ts

@@ -7,6 +7,6 @@ export type GroupProps = {
     data?: RouteDataFunction<any, any>;
 };
 export declare class Group extends TungstenSimpleComponent<GroupProps> {
-    content: () => string | number | boolean | import("../ContentNode.js").ContentNodeHtml | import("../ContentNode.js").ContentNodeClassComponent | import("../ContentNode.js").ContentNodeFunctionComponent | import("../ContentNode.js").ContentNodeFragment | import("../ContentNode.js").ContentNodeArray | null;
+    content: () => string | number | boolean | import("../ContentNode.js").ContentNodeArray | import("../ContentNode.js").ContentNodeClassComponent | import("../ContentNode.js").ContentNodeFragment | import("../ContentNode.js").ContentNodeFunctionComponent | import("../ContentNode.js").ContentNodeHtml | null;
 }
 //# sourceMappingURL=Group.d.ts.map

package/dist/routing/MatchedRoute.d.ts

@@ -9,6 +9,6 @@ export type MatchedRouteProps = {
 };
 export declare class MatchedRoute extends TungstenSimpleInternalStoreComponent<MatchedRouteProps> {
     init: () => void;
-    content: () => string | number | boolean | import("../ContentNode.js").ContentNodeHtml | import("../ContentNode.js").ContentNodeClassComponent | import("../ContentNode.js").ContentNodeFunctionComponent | import("../ContentNode.js").ContentNodeFragment | import("../ContentNode.js").ContentNodeArray | null | undefined;
+    content: () => ContentNode;
 }
 //# sourceMappingURL=MatchedRoute.d.ts.map

package/dist/routing/MatchedRoute.js

@@ -21,9 +21,15 @@ export class MatchedRoute extends TungstenSimpleInternalStoreComponent {
         return content(data, params, this.props, this.__instance.globalData, this.__instance.location);
       } else {
         if (ContentNodeIsComponent(content)) {
-          content[$routeParams] = params;
-          content[$routeData] = data;
-          content[$props] = this.props;
+          // the routes hold this node across renders and requests, so it is not written to
+          return {
+            ...content,
+            [$routeParams]: params,
+            [$routeData]: data,
+            [$props]: {
+              ...this.props
+            }
+          };
         }
         return content;
       }

package/dist/routing/builder.d.ts

@@ -31,7 +31,28 @@ export type FluentRoutesToRoutes<T extends readonly FluentRoute[]> = {
 } & {};
 export declare function routes<const T extends readonly FluentRoute[]>(...frs: T): FluentRoutesToRoutes<T>;
 export declare function routesWith<Rule extends object>(): <const T extends readonly (FluentRoute & Rule)[]>(...frs: T) => FluentRoutesToRoutes<T>;
-export declare function routesWithList<Rule extends object>(): <const T extends readonly (FluentDefaultRoute | Fluent404Route | FluentErrorRoute | (NormalFluentRoute & Rule))[]>(routes: [...T]) => T;
+export declare function routesListWith<Rule extends object>(): <const T extends readonly (Fluent404Route | FluentDefaultRoute | FluentErrorRoute | (NormalFluentRoute & Rule))[]>(routes: [...T]) => T;
+export declare function makeRouteWith<Rule extends object>(): {
+    <P extends RouteKey, D, M extends Meta = FrameworkRouteFields>(r: {
+        path: P;
+        data: RouteDataFunction<ParamsFromPath<P>, D>;
+        content: RouteContentFunction<ParamsFromPath<P>, D>;
+    } & Rule & M): Expand<{
+        path: P;
+    } & Rule & M & {
+        data: RouteDataFunction<ParamsFromPath<P>, D>;
+        content: RouteContentFunction<ParamsFromPath<P>, D>;
+    }>;
+    <P extends RouteKey, const C extends ContentNode, M extends Meta = FrameworkRouteFields>(r: {
+        path: P;
+        data?: never;
+        content: C;
+    } & Rule & M): Expand<{
+        path: P;
+    } & Rule & M & {
+        content: C;
+    }>;
+};
 type FrameworkRouteFields = Omit<Endpoint<any, any>, 'data' | 'content'>;
 type Meta = Record<string, unknown> & FrameworkRouteFields;
 declare const $invalidKeyError: unique symbol;
@@ -42,7 +63,7 @@ type MustNotIncludePathDataContent<T extends Record<string, unknown>> = 'path' e
 } : 'content' extends keyof T ? {
     [$invalidKeyError]: 'meta may not contain key \'content\'';
 } : T;
-export declare function chainedRoute<P extends RouteKey, M extends Meta = {}>(path: P, meta?: M & MustNotIncludePathDataContent<M>): {
+export declare function chainedRoute<P extends RouteKey, M extends Meta = FrameworkRouteFields>(path: P, meta?: M & MustNotIncludePathDataContent<M>): {
     meta<M2 extends Meta>(meta: M2 & MustNotIncludePathDataContent<M2>): {
         data<D>(dataFunc: RouteDataFunction<ParamsFromPath<P>, D>): {
             content<C extends RouteContentFunction<ParamsFromPath<P>, D> | ContentNode>(content: C): Expand<{
@@ -72,8 +93,7 @@ export declare function chainedRoute<P extends RouteKey, M extends Meta = {}>(pa
         content: C;
     }>;
 };
-export declare function route<P extends RouteKey, D, M extends Meta = {}>(// eslint-disable-line @typescript-eslint/no-empty-object-type
-r: {
+export declare function route<P extends RouteKey, D, M extends Meta = FrameworkRouteFields>(r: {
     path: P;
     data: RouteDataFunction<ParamsFromPath<P>, D>;
     content: RouteContentFunction<ParamsFromPath<P>, D>;
@@ -83,8 +103,7 @@ r: {
     data: RouteDataFunction<ParamsFromPath<P>, D>;
     content: RouteContentFunction<ParamsFromPath<P>, D>;
 }>;
-export declare function route<P extends RouteKey, const C extends ContentNode, M extends Meta = {}>(// eslint-disable-line @typescript-eslint/no-empty-object-type
-r: {
+export declare function route<P extends RouteKey, const C extends ContentNode, M extends Meta = FrameworkRouteFields>(r: {
     path: P;
     data?: never;
     content: C;
@@ -93,8 +112,8 @@ r: {
 } & M & {
     content: C;
 }>;
-export declare function defaultRoute(r: FluentDefaultRoute): FluentDefaultRoute;
-export declare function _404Route(r: FluentErrorRoute): FluentErrorRoute;
-export declare function errorRoute(r: FluentErrorRoute): FluentErrorRoute;
+export declare function defaultRoute<const R extends FluentDefaultRoute>(r: R): R;
+export declare function _404Route<const R extends Fluent404Route>(r: R): R;
+export declare function errorRoute<const R extends FluentErrorRoute>(r: R): R;
 export {};
 //# sourceMappingURL=builder.d.ts.map

package/dist/routing/builder.js

@@ -28,11 +28,18 @@ export function routesWith() {
   };
 }
 // the array routes form, as given: routesFromArray() keys it and finds a path given twice
-export function routesWithList() {
-  return function routeList(routes) {
+export function routesListWith() {
+  return function routesList(routes) {
     return routes;
   };
 }
+// route(), with the rule checked on each route rather than on the whole list
+export function makeRouteWith() {
+  function route(r) {
+    return r;
+  }
+  return route;
+}
 // export function routeLegacy<P extends RouteKey>(path: P) {
 //     const r: { path: P } = { path }
 //     return {

package/dist/routing/redirectOf.d.ts

@@ -3,9 +3,10 @@ import type { RedirectCode } from './RedirectCode.js';
 import type { RouteKey } from './RouteTypes.js';
 export type Redirection = {
     route: RouteKey;
+    code?: RedirectCode | undefined;
 } | {
     url: string;
-    code?: RedirectCode;
+    code?: RedirectCode | undefined;
 };
-export declare function redirectOf(matched: MatchedRouteInfo): Redirection | undefined;
+export declare function redirectOf(matched: MatchedRouteInfo, allRoutesData?: unknown): Redirection | undefined;
 //# sourceMappingURL=redirectOf.d.ts.map

package/dist/routing/redirectOf.js

@@ -4,29 +4,36 @@ import { ContentNodeIsClassComponent } from '../ContentNode.js';
 import { $props, $type } from '../contentNodeSymbols.js';
 import { RoutingRedirect } from './RoutingRedirect.js';
 import { WebRedirect } from './WebRedirect.js';
-export function redirectOf(matched) {
-  const {
-    data
-  } = matched;
+export function redirectOf(matched, allRoutesData) {
+  return dataRedirect(allRoutesData) ?? dataRedirect(matched.data) ?? contentRedirect(matched);
+}
+const dataRedirect = data => {
   if (data instanceof RoutingRedirect) return {
-    route: data.to
+    route: data.to,
+    code: data.code
   };
   if (data instanceof WebRedirect) return {
     url: data.to,
     code: data.code
   };
+  return undefined;
+};
+const contentRedirect = matched => {
   const content = matched.content;
   if (typeof content === 'function' || !ContentNodeIsClassComponent(content)) return undefined;
   const type = content[$type];
+  const props = content[$props]; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
   if (type === RouteRedirectComponent || type.prototype instanceof RouteRedirectComponent) {
     return {
-      route: content[$props].to
+      route: props.to,
+      code: props.code
     }; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
   }
   if (type === WebRedirectComponent || type.prototype instanceof WebRedirectComponent) {
     return {
-      url: content[$props].to
-    }; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+      url: props.to,
+      code: props.code
+    };
   }
   return undefined;
-}
+};

package/dist/routing/registerGlobalData.d.ts

@@ -1,17 +1,18 @@
 import type { BrandedContext, BrandedGlobalData, BrandedNetworkedData } from '../Brands.js';
 import type { ReqRes } from '../ReqRes.js';
 import type { Context } from '../context/registerContext.js';
+import type { DataRedirect } from './DataRedirect.js';
 import type { NetworkedData } from './routingRegistry.js';
 import type { Serializable } from './Serializable.js';
 import type { Fixed } from './registrationTypes.js';
 export interface GlobalData {
 }
-export type GlobalDataFunction<C = Context, NS = NetworkedData, G extends object = GlobalData> = (reqRes: ReqRes | null, context: C, networkedStore: NS) => Promise<G>;
-export type BrandedGlobalDataFunction = (reqRes: ReqRes | null, context: BrandedContext, networkedStore: BrandedNetworkedData) => Promise<BrandedGlobalData>;
+export type GlobalDataFunction<C = Context, NS = NetworkedData, G extends object = GlobalData> = (reqRes: ReqRes | null, context: C, networkedStore: NS, location: string) => Promise<G | DataRedirect>;
+export type BrandedGlobalDataFunction = (reqRes: ReqRes | null, context: BrandedContext, networkedStore: BrandedNetworkedData, location: string) => Promise<BrandedGlobalData>;
 export declare const globalDataFunc: {
     value: BrandedGlobalDataFunction | undefined;
 };
-export declare function registerGlobalData<G extends object>(func: GlobalDataFunction<Context, NetworkedData, G> & ((reqRes: ReqRes | null, context: Context, networkedData: NetworkedData) => Promise<Serializable<NoInfer<G>>>)): Fixed<{
+export declare function registerGlobalData<G extends object>(func: GlobalDataFunction<Context, NetworkedData, G> & ((reqRes: ReqRes | null, context: Context, networkedData: NetworkedData, location: string) => Promise<Serializable<NoInfer<G>> | DataRedirect>)): Fixed<{
     globalData: G;
 }>;
 //# sourceMappingURL=registerGlobalData.d.ts.map

package/dist/routing/registerRouting.d.ts

@@ -1,6 +1,7 @@
 import type { ReqRes } from '../ReqRes.js';
 import type { RoutesWithSettings } from './Routes.js';
 import type { GlobalDataFunction } from './registerGlobalData.js';
+import type { DataRedirect } from './DataRedirect.js';
 import type { AppPath } from '../components/makeTypedLink.js';
 import type { Serializable } from './Serializable.js';
 import type { KeyedRoutes } from './routesArray.js';
@@ -32,5 +33,5 @@ export type ContextType<R extends Fixed<{
 export type NetworkedDataType<R extends Fixed<{
     networkedStore: unknown;
 }>> = R[typeof $routing]['networkedStore'];
-export declare function registerRouting<RsS extends RoutesWithSettings<G>, G extends object = object, ContextSchema extends object | undefined = undefined, NetworkedStoreSchema extends object | undefined = undefined>(routesFunction: RoutesFunctionGeneric<G, ContextSchema, NetworkedStoreSchema, RsS>, globalDataFunction: GlobalDataFunction<NoInfer<ContextSchema>, NoInfer<NetworkedStoreSchema>, G> & ((reqRes: ReqRes | null, context: NoInfer<ContextSchema>, store: NoInfer<NetworkedStoreSchema>) => Promise<Serializable<NoInfer<G>>>), context?: ContextInitializer<ContextSchema>, networkedStoreSchema?: NetworkedStoreInitializer<NetworkedStoreSchema> & SerializableStore<NoInfer<NetworkedStoreSchema>>): Routing<RsS, G, ContextSchema, NetworkedStoreSchema>;
+export declare function registerRouting<RsS extends RoutesWithSettings<G>, G extends object = object, ContextSchema extends object | undefined = undefined, NetworkedStoreSchema extends object | undefined = undefined>(routesFunction: RoutesFunctionGeneric<G, ContextSchema, NetworkedStoreSchema, RsS>, globalDataFunction: GlobalDataFunction<NoInfer<ContextSchema>, NoInfer<NetworkedStoreSchema>, G> & ((reqRes: ReqRes | null, context: NoInfer<ContextSchema>, store: NoInfer<NetworkedStoreSchema>, location: string) => Promise<Serializable<NoInfer<G>> | DataRedirect>), context?: ContextInitializer<ContextSchema>, networkedStoreSchema?: NetworkedStoreInitializer<NetworkedStoreSchema> & SerializableStore<NoInfer<NetworkedStoreSchema>>): Routing<RsS, G, ContextSchema, NetworkedStoreSchema>;
 //# sourceMappingURL=registerRouting.d.ts.map

package/dist/routing/resolveAppRoutes.js

@@ -1,6 +1,11 @@
 import { TungstenError } from '../TungstenError.js';
 import { routesLocationParts } from '../routesLocationParts.js';
 import { registeredRouting } from './routingRegistry.js';
+// an export we know nothing about; past this shape check it's taken as AppRoutes
+function IsAppRoutesShaped(value) {
+  if (typeof value === 'function' || Array.isArray(value)) return true;
+  return typeof value === 'object' && value !== null && Object.keys(value).some(key => key.startsWith('/'));
+}
 // routes come from registerRouting() or from routesLocation's named export. The module has already
 // been imported by the caller, which is what runs the registerRouting() call
 export function resolveAppRoutes(module, routesLocation, mode) {
@@ -16,7 +21,11 @@ export function resolveAppRoutes(module, routesLocation, mode) {
   }
   if (registered !== undefined) return registered;
   if (isExported) {
-    return module[routeExport]; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+    const routes = module[routeExport];
+    if (!IsAppRoutesShaped(routes)) {
+      throw new TungstenError(`${routesFile}'s export ${routeExport} is not routes: expected a routes function,` + ` an array of routes, or an object keyed by paths ('/...').`);
+    }
+    return routes;
   }
   if (routeExport === undefined) {
     throw new TungstenError(`No routes. config.routesLocation names the file ${routesFile} without an export name,` + ` so routes must come from registerRouting(), but ${routesFile} did not call it.`);

package/dist/routing/routesArray.d.ts

@@ -1,6 +1,7 @@
 import type { ErrorRouteType } from './ErrorRouteType.js';
 import type { Routes, RoutesWithSettings } from './Routes.js';
 import type { Endpoint, Path } from './RouteTypes.js';
+import type { Mutual } from '../../types/helpers.js';
 export type RouteEntry<G extends object | undefined = object> = (Endpoint<any, any, G> & {
     path: Path | 'default' | '404';
 }) | (ErrorRouteType & {
@@ -12,10 +13,10 @@ export declare const toRoutes: <Rs extends object>(routes: Rs | RoutesArray<any>
 export type KeyedRoutes<Rs> = Rs extends RoutesArray<any> ? {
     [Entry in Rs[number] as Entry['path']]: Omit<Entry, 'path'>;
 } : Rs;
-type IsOnePath<P extends PropertyKey> = Record<never, never> extends Record<P, 1> ? false : true;
+type Found<P, Seen> = Seen extends unknown ? (Mutual<P, Seen> extends true ? P : never) : never;
 type DuplicatePath<T, Seen = never> = T extends readonly [infer H, ...infer Rest] ? H extends {
     path: infer P extends PropertyKey;
-} ? IsOnePath<P> extends false ? DuplicatePath<Rest, Seen> : P extends Seen ? P : DuplicatePath<Rest, Seen | P> : DuplicatePath<Rest, Seen> : never;
+} ? [Found<P, Seen>] extends [never] ? DuplicatePath<Rest, Seen | P> : P : DuplicatePath<Rest, Seen> : never;
 type ReturnedRoutes<R> = R extends (...args: never[]) => infer Rs ? Rs : R;
 type GivenTwice<P extends string> = `The routes give the path '${P}' twice. Each path can have one route.`;
 export type NoDuplicatePaths<R> = [DuplicatePath<ReturnedRoutes<R>>] extends [never] ? unknown : GivenTwice<DuplicatePath<ReturnedRoutes<R>> & string>;

package/dist/routing/routingBuilder.d.ts

@@ -1,10 +1,11 @@
 import type { ReqRes, ReqResOrNull } from '../ReqRes.js';
 import type { RoutesWithSettings } from './Routes.js';
 import type { ContextClasses } from '../context/registerContext.js';
+import type { DataRedirect } from './DataRedirect.js';
 import type { Routing, RoutesFunctionGeneric, Serializable } from './registerRouting.js';
 import type { Fixed } from './registrationTypes.js';
 type NetworkedStoreClass<C, ND> = (new (reqRes: ReqResOrNull, context: C) => ND) & (new (reqRes: ReqResOrNull, context: C) => Serializable<NoInfer<ND>>);
-type GetGlobalData<C, ND, G extends object> = ((reqRes: ReqRes | null, context: C, networkedData: ND) => Promise<G>) & ((reqRes: ReqRes | null, context: C, networkedData: ND) => Promise<Serializable<NoInfer<G>>>);
+type GetGlobalData<C, ND, G extends object> = ((reqRes: ReqRes | null, context: C, networkedData: ND, location: string) => Promise<G | DataRedirect>) & ((reqRes: ReqRes | null, context: C, networkedData: ND, location: string) => Promise<Serializable<NoInfer<G>> | DataRedirect>);
 type RoutesMethod<C, ND, G extends object> = {
     routes: <Rs extends RoutesWithSettings<G>>(getRoutes: RoutesFunctionGeneric<G, C, ND, Rs>) => Routing<Rs, G, C, ND>;
 };

package/dist/staticGen/staticGen.js

@@ -30,18 +30,10 @@ export async function staticGen(framework) {
   // only the paths are read here, with no request - nothing reads the networked store
   const networkedData = {};
   // ! unsure about this
-  // the routes proper, without RoutesSettings, whose symbol keys iteration never meets
-  const appRoutes = getRoutes === null ? {
-    '/': {
-      content: 'Code for static rendering SPA TBC'
-    },
-    404: {
-      content: '404 TBC'
-    }
-  }
-  // only the paths are read here, with no request; each page is then fetched from the prod
+  // the routes proper, without RoutesSettings, whose symbol keys iteration never meets.
+  // Only the paths are read here, with no request; each page is then fetched from the prod
   // server, whose request makes its context
-  : toRoutes(typeof getRoutes === 'function' ? getRoutes(null, {}, networkedData) : getRoutes, false);
+  const appRoutes = toRoutes(typeof getRoutes === 'function' ? getRoutes(null, {}, networkedData) : getRoutes, false);
   const buildLocation = framework.compilationInfo.location;
   const server = await framework.createProdServer();
   const serverLocation = await server.start(null, true); // port, mute