tungsten 0.7.2 → 0.8.0

package/dist/hydrate/stubRouting.js

@@ -4,14 +4,16 @@ 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) {
+// URL leaves the page, and gives null. allRoutesData: the pipeline's, beside each routing, whose
+// redirect wins over the route's
+export async function stubRouting(location, route, instanceConfig, allRoutesData) {
   for (let hops = 0; hops <= 10; hops++) {
-    const matchedRouteInfo = await route(location);
-    const redirection = redirectOf(matchedRouteInfo);
+    const [matchedRouteInfo, data] = await Promise.all([route(location), allRoutesData?.(location)]);
+    const redirection = redirectOf(matchedRouteInfo, data);
     if (redirection === undefined) return {
       location,
-      matchedRouteInfo
+      matchedRouteInfo,
+      allRoutesData: data
     };
     if ('url' in redirection) {
       window.location.replace(redirection.url);

package/dist/indexInner.d.ts

@@ -63,6 +63,7 @@ export { splitPipeline } from './pipeline/splitPipeline.js';
 export type { PipelineServerAllRoutesData } from './pipeline/splitPipeline.js';
 export { contextStore } from './pipeline/contextStore.js';
 export { hydratePipeline } from './pipeline/hydratePipeline.js';
+export { routesWith, routesListWith, makeRouteWith } from './routing/builder.js';
 export { registeredRouting } from './routing/routingRegistry.js';
 export { type Context, type ContextClass, type ContextClasses, registerContext, } from './context/registerContext.js';
 export { registerNetworkedData, type NetworkedData } from './routing/routingRegistry.js';

package/dist/indexInner.js

@@ -85,6 +85,7 @@ export { contextStore } from './pipeline/contextStore.js';
 // the generated client.js calls this in place of hydrate() under 'pipeline'
 export { hydratePipeline } from './pipeline/hydratePipeline.js';
 // the generated client/routes.js reads this; not meant for app code
+export { routesWith, routesListWith, makeRouteWith } from './routing/builder.js';
 export { registeredRouting } from './routing/routingRegistry.js';
 // Context and NetworkedData are the interfaces an app augments, from its classes or its routing
 export { registerContext } from './context/registerContext.js';

package/dist/json.d.ts

@@ -1,4 +1,6 @@
+import type { Json } from './Json.type.js';
 type Replacer = (this: unknown, key: string, value: unknown) => unknown;
+type Reviver = (this: unknown, key: string, value: unknown) => unknown;
 type AllowList = (string | number)[] | null;
 type Space = string | number;
 type IfAny<T, Then> = 0 extends (1 & T) ? Then : never;
@@ -8,5 +10,7 @@ export declare function JSONstringify(value: object, replacer?: AllowList, space
 export declare function JSONstringify(value: string | number | boolean | null, replacer?: AllowList, space?: Space): string;
 export declare function JSONstringify(value: string | number | boolean | null | object, replacer?: AllowList, space?: Space): string;
 export declare function JSONstringify(value: unknown, replacer?: Replacer | AllowList, space?: Space): string | undefined;
+export declare function JSONparse(text: string): Json;
+export declare function JSONparse(text: string, reviver: Reviver): unknown;
 export {};
 //# sourceMappingURL=json.d.ts.map

package/dist/json.js

@@ -5,4 +5,7 @@ export function JSONstringify(value, replacer, space) {
   /* eslint-disable no-restricted-properties -- the typed wrapper */
   return typeof replacer === 'function' ? JSON.stringify(value, replacer, space) : JSON.stringify(value, replacer, space);
   /* eslint-enable no-restricted-properties */
+}
+export function JSONparse(text, reviver) {
+  return JSON.parse(text, reviver); // eslint-disable-line no-restricted-properties -- the typed wrapper
 }

package/dist/makeFinalConfig.js

@@ -1,6 +1,8 @@
 import { defaultConfig } from './defaultConfig.js';
 export function makeFinalConfig(userConfig, overrides = null) {
-  const finalConfig = structuredClone(defaultConfig);
+  const finalConfig = {
+    ...structuredClone(defaultConfig)
+  };
   for (const key in userConfig) {
     //if (Object.prototype.hasOwnProperty.call(userConfig, key)) { // github co-pilot suggestion, unsure if needed
     finalConfig[key] = userConfig[key]; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion

package/dist/mutatingFunctions.d.ts

@@ -1,9 +1,9 @@
-export declare const arrayMutatingFunctions: readonly ["push", "pop", "shift", "unshift", "sort", "splice", "reverse", "fill", "copyWithin"];
+export declare const arrayMutatingFunctions: readonly ['push', 'pop', 'shift', 'unshift', 'sort', 'splice', 'reverse', 'fill', 'copyWithin'];
 type ArrayMutatingFunctions = typeof arrayMutatingFunctions[number];
 export declare const arrayMutatingFunctionInsertsFrom: Partial<Record<ArrayMutatingFunctions, number>>;
-export declare const mapMutatingFunctions: readonly ["set", "delete", "clear"];
+export declare const mapMutatingFunctions: readonly ['set', 'delete', 'clear'];
 type MapMutatingFunctions = typeof mapMutatingFunctions[number];
-export declare const setMutatingFunctions: readonly ["add", "delete", "clear"];
+export declare const setMutatingFunctions: readonly ['add', 'delete', 'clear'];
 type SetMutatingFunctions = typeof setMutatingFunctions[number];
 export declare function KeyIsArrayMutatingFunction(key: string): key is ArrayMutatingFunctions;
 export declare function KeyIsMapMutatingFunction(key: string): key is MapMutatingFunctions;

package/dist/pipeline/hydratePipeline.js

@@ -29,17 +29,48 @@ export async function hydratePipeline(app, RootComponent, instanceConfig, fileVe
   const routes = pipelineRoutes(app, null, init, isDev);
   const routeContext = routingContext(ran.routingContext);
   const networkedData = routingNetworkedData(ran.routingNetworkedData);
+  // the server's error page: the app's error page alone, with what clientInit made - the server
+  // ran no Post - and, with no shell around it, navigation from it loads pages from the server
+  if (typeof __tungsten_error_info__ !== 'undefined' && app.errorPage !== undefined) {
+    const noRoute = {
+      key: null,
+      params: {},
+      content: null
+    };
+    const globalData = __tungsten_global_data__;
+    const {
+      internalStore,
+      stores,
+      storeSubscriptions
+    } = initStores(location, null, globalData, noRoute, null, routeContext, networkedData);
+    const instance = new Instance(location, {
+      ...instanceConfig,
+      clientSideNav: false
+    }, null, appRoutesFor(app, init), routes, internalStore, stores, storeSubscriptions, globalData, noRoute);
+    instance.fileVersions = fileVersions;
+    instance.context = routeContext;
+    instance.networkedData = networkedData;
+    instance.pipelineNetworked = ran.networked;
+    instance.errorInfo = {
+      error: undefined,
+      message: __tungsten_error_info__.message
+    };
+    const ErrorPage = app.errorPage; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion -- .errorPage() typed it
+    await hydrateDocument(instance, ErrorPage, instance.errorInfo);
+    return;
+  }
   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)]);
+    const fetchData = ran.allRoutesData;
+    const routed = await stubRouting(location, to => routing(to, routes, routeContext, networkedData), instanceConfig, fetchData && (async to => fetchData(to)));
     if (routed === null) return;
     ({
       location,
       matchedRouteInfo
     } = routed);
-    allRoutesData = fetched; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion -- the framework brands what it builds
+    allRoutesData = routed.allRoutesData; // 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);
@@ -62,14 +93,19 @@ export async function hydratePipeline(app, RootComponent, instanceConfig, fileVe
     routingContext: routeContext,
     routingNetworkedData: networkedData,
     allRoutesData: allRoutesDataFor(ran.allRoutesData),
+    allRoutesDataFallback: fallbackFor(ran.allRoutesDataFallback),
     afterRouting
   };
-  if (isDev) setCurrentInstance(instance);
   if (instanceConfig.serverSideRouting !== false && typeof __tungsten_route_data__ !== 'undefined') {
     instance.routeData = __tungsten_route_data__;
   }
+  await hydrateDocument(instance, RootComponent ?? MatchedRoute);
+}
+// the page's document, from its root component
+async function hydrateDocument(instance, RootComponent, props = {}) {
+  if (isDev) setCurrentInstance(instance);
   const meta = makeDefaultHydrateMeta();
-  await hydrateRootComponent(instance, RootComponent ?? MatchedRoute, new DomPointer(document, 1), meta);
+  await hydrateRootComponent(instance, RootComponent, new DomPointer(document, 1), meta, props);
   instance.hydrationComplete = true;
   if (isDev) renderHydrationMismatchBanner(meta.mismatches);
   if (isDev) renderDocInitErrorBanner();
@@ -79,5 +115,10 @@ const appRoutesFor = (app, init) => reqRes => pipelineRoutes(app, reqRes, init,
 const allRoutesDataFor = run => {
   if (run === undefined) return undefined;
   // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- the framework brands what it builds
-  return async () => await run();
+  return async location => await run(location);
+};
+const fallbackFor = run => {
+  if (run === undefined) return undefined;
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- the framework brands what it builds
+  return async (location, error) => await run(location, error);
 };

package/dist/pipeline/pipeline.d.ts

@@ -1,6 +1,8 @@
 import type { ComponentStore, ConstructPackage, TungstenComponentPropsBase, TungstenComponentSignalsConstraint, TungstenComponentStateConstraint } from '../Components.jsx';
 import type { ComponentHelpers } from '../componentHelpers.js';
+import type { TungstenErrorInfo } from '../routing/TungstenErrorInfo.js';
 import type { RoutesWithSettings } from '../routing/Routes.js';
+import type { DataRedirect } from '../routing/DataRedirect.js';
 import type { NoDuplicatePaths, RoutesArray } from '../routing/routesArray.js';
 import type { Serializable } from '../routing/Serializable.js';
 import type { ReadonlyTrueStore } from '../Store/makeStore.js';
@@ -78,26 +80,39 @@ export type PipelineStageResult<X, Name extends keyof StagesOf<X> = never> = Rec
 export type PipelineStageContext<X, Name extends keyof StagesOf<X> = never> = RecordOf<X, Name> extends StageRecord<any, infer C> ? (C extends object ? C : Nothing) : never;
 type Process<Req, Previous, X, G = never> = (reqRes: Req | null, previous: Previous, allRoutesData: G) => MaybePromise<X>;
 export type SerializableData<G> = G extends object ? Serializable<G> : never;
-export type AllRoutesDataProcess<Req, I, G> = (reqRes: Req | null, init: I) => MaybePromise<G & SerializableData<NoInfer<G>>>;
+export type AllRoutesDataProcess<Req, I, G> = (reqRes: Req | null, init: I, location: string) => MaybePromise<(G & SerializableData<NoInfer<G>>) | DataRedirect>;
+export type AllRoutesDataFallback<Req, I, G> = NoInfer<G> | ((reqRes: Req | null, init: I, location: string, error: unknown) => MaybePromise<NoInfer<G> | DataRedirect>);
 type RoutesFunction<Req, I, G extends object | undefined> = (reqRes: Req | null, init: I) => RoutesWithSettings<G> | RoutesArray<G> | [];
+type HasErrorRoute<Rs> = Rs extends readonly unknown[] ? (number extends Rs['length'] ? true : ('error' extends PathOf<Rs[number]> ? true : false)) : ('error' extends keyof Rs ? true : false);
+type PathOf<E> = E extends {
+    path: infer P;
+} ? P : never;
+type ReturnedRoutes<R> = R extends (...args: never[]) => infer Rs ? Rs : R;
+export type RequireErrorRoute<R> = true extends HasErrorRoute<ReturnedRoutes<R>> ? unknown : 'A pipeline needs an \'error\' route: a failed request renders it.';
 type Routes<Req, I, Ctx, N, G extends object | undefined> = {
-    <const R extends RoutesFunction<Req, I, G>>(routes: R & NoDuplicatePaths<R>): PipelineApp<R, DeliveredContext<Ctx>, N, G>;
-    <const R extends RoutesFunction<Req, I, G>>(options: RoutesOptions, routes: R & NoDuplicatePaths<R>): PipelineApp<R, DeliveredContext<Ctx>, N, G>;
+    <const R extends RoutesFunction<Req, I, G>>(routes: R & NoDuplicatePaths<R> & RequireErrorRoute<R>): PipelineApp<R, DeliveredContext<Ctx>, N, G>;
+    <const R extends RoutesFunction<Req, I, G>>(options: RoutesOptions, routes: R & NoDuplicatePaths<R> & RequireErrorRoute<R>): PipelineApp<R, DeliveredContext<Ctx>, N, G>;
 };
-export type PostStage<Req, I, Ctx, N, G extends object | undefined> = PipelineComponents<Ctx, N, G> & {
+export type ErrorPageComponent<ECtx, EN, G extends object | undefined> = PipelineSimpleComponent<ECtx, EN, G | undefined, TungstenErrorInfo>;
+export type ErrorPageClass<ECtx, EN, G extends object | undefined> = abstract new (pkg: ConstructPackage<TungstenErrorInfo, undefined>) => ErrorPageComponent<ECtx, EN, G>;
+export type RoutesStage<Req, I, Ctx, N, G extends object | undefined, ECtx, EN> = PipelineComponents<Ctx, N, G> & {
+    ErrorComponent: ErrorPageClass<ECtx, EN, G> & Statics<typeof PipelineSimpleComponent>;
     routes: Routes<Req, I, Ctx, N, G>;
 };
+export type PostStage<Req, I, Ctx, N, G extends object | undefined, ECtx = I, EN = Nothing> = RoutesStage<Req, I, Ctx, N, G, ECtx, EN> & {
+    errorPage: (page: ErrorPageClass<ECtx, EN, G>) => RoutesStage<Req, I, Ctx, N, G, ECtx, EN>;
+};
 export type DataStage<Req, I, G extends object | undefined> = PostStage<Req, I, I, Nothing, G> & {
     post: <P extends StageContext, This>(this: This, process: Process<Req, I, P, G>) => PostStage<Req, I, P, Nothing, G> & StageMark<This, 'post', P, P>;
 };
 export type InitStage<Req, I> = DataStage<Req, I, undefined> & {
-    allRoutesData: <G extends object, This>(this: This, process: AllRoutesDataProcess<Req, I, G>) => DataStage<Req, I, G> & StageMark<This, 'allRoutesData', G, I>;
+    allRoutesData: <G extends object, This>(this: This, process: AllRoutesDataProcess<Req, I, G>, fallback?: AllRoutesDataFallback<Req, I, G>) => DataStage<Req, I, G> & StageMark<This, 'allRoutesData', G, I>;
 };
 export type ServerStage<Req> = InitStage<Req, undefined> & {
     init: <I extends StageContext | undefined, This>(this: This, process: Process<Req, undefined, I>) => InitStage<Req, I> & StageMark<This, 'init', I, I>;
 };
 export declare const loosely: <T>(process: unknown) => T;
-export declare function postStage<Req, I, Ctx, N, G extends object | undefined>(definition: PipelineDefinition): PostStage<Req, I, Ctx, N, G>;
+export declare function postStage<Req, I, Ctx, N, G extends object | undefined, ECtx = I, EN = Nothing>(definition: PipelineDefinition): PostStage<Req, I, Ctx, N, G, ECtx, EN>;
 export declare function checkServer(builder: string, lib: ServerKind): void;
 export type PipelineBuilder = {
     server: <Kind extends ServerKind>(kind: Kind) => ServerStage<ServerRequests[Kind]>;

package/dist/pipeline/pipeline.js

@@ -62,12 +62,22 @@ function makeApp(definition, args) {
     [$pipelineApp]: true
   };
 }
-export function postStage(definition) {
+function routesStage(definition) {
   return {
     ...pipelineComponents,
+    ErrorComponent: PipelineSimpleComponent,
     routes: (...args) => makeApp(definition, args)
   };
 }
+export function postStage(definition) {
+  return {
+    ...routesStage(definition),
+    errorPage: page => routesStage({
+      ...definition,
+      errorPage: loosely(page)
+    })
+  };
+}
 function dataStage(definition) {
   return {
     ...postStage(definition),
@@ -80,9 +90,10 @@ function dataStage(definition) {
 function initStage(definition) {
   return {
     ...dataStage(definition),
-    allRoutesData: process => dataStage({
+    allRoutesData: (process, fallback) => dataStage({
       ...definition,
-      allRoutesData: loosely(process)
+      allRoutesData: loosely(process),
+      allRoutesDataFallback: loosely(fallback)
     })
   };
 }

package/dist/pipeline/pipelineDefinition.d.ts

@@ -1,3 +1,4 @@
+import type { AnyComponentType } from '../AnyComponentType.js';
 import type { RouteCacheControl } from '../cacheControl.js';
 import type { ReqRes } from '../ReqRes.js';
 import type { MatchedRouteInfo } from '../routing/MatchedRouteInfo.js';
@@ -18,7 +19,7 @@ export type SplitResult = {
 export type RegisteredServerInit = (reqRes: unknown) => MaybePromise<SplitResult | undefined>;
 export type RegisteredServerPost = (reqRes: unknown, init: SplitResult | undefined, allRoutesData: AllRoutesDataConstraint) => MaybePromise<SplitResult | undefined>;
 export type RegisteredClientInit = (networked: object) => MaybePromise<SplitResult | undefined>;
-export type RegisteredClientAllRoutesData = (init: SplitResult | undefined) => MaybePromise<object>;
+export type RegisteredClientAllRoutesData = (init: SplitResult | undefined, location: string) => MaybePromise<object>;
 export type RegisteredClientPost = (init: SplitResult | undefined, allRoutesData: AllRoutesDataConstraint) => MaybePromise<SplitResult | undefined>;
 export type ClientRoute = {
     key: RouteKey | null;
@@ -33,7 +34,8 @@ export type ClientStarted = {
     init: StageContext | undefined;
     routingContext: object;
     routingNetworkedData: object;
-    allRoutesData: (() => MaybePromise<object>) | undefined;
+    allRoutesData: ((location: string) => MaybePromise<object>) | undefined;
+    allRoutesDataFallback: ((location: string, error: unknown) => Promise<object>) | undefined;
     networked: object;
     post: (allRoutesData: AllRoutesDataConstraint) => Promise<ClientPosted>;
 };
@@ -42,7 +44,10 @@ export type ClientPosted = {
     afterRouting: ((route: ClientRoute, allRoutesData: AllRoutesDataConstraint) => Promise<object>) | undefined;
 };
 export type RegisteredRoutes = (reqRes: unknown, init: StageContext | undefined) => unknown;
-export type RegisteredAllRoutesData = (reqRes: unknown, init: StageContext | undefined) => MaybePromise<object>;
+export type RegisteredAllRoutesData = (reqRes: unknown, init: StageContext | undefined, location: string) => MaybePromise<object>;
+export type RegisteredAllRoutesDataFallback = object | ((reqRes: unknown, init: StageContext | undefined, location: string, error: unknown) => MaybePromise<object>);
+export type RegisteredClientAllRoutesDataFallback = object | ((init: SplitResult | undefined, location: string, error: unknown) => MaybePromise<object>);
+export declare const isFallbackFunction: <F extends object>(fallback: F) => fallback is Extract<F, (...args: never[]) => unknown>;
 export type RoutesOptions = {
     cacheControl?: RouteCacheControl;
 };
@@ -52,13 +57,16 @@ export type PipelineDefinition = {
     client: ClientRun;
     init?: RegisteredStage;
     allRoutesData?: RegisteredAllRoutesData;
+    allRoutesDataFallback?: RegisteredAllRoutesDataFallback | undefined;
     post?: RegisteredStage;
     serverInit?: RegisteredServerInit;
     serverPost?: RegisteredServerPost;
     clientInit?: RegisteredClientInit;
     clientAllRoutesData?: RegisteredClientAllRoutesData;
+    clientAllRoutesDataFallback?: RegisteredClientAllRoutesDataFallback | undefined;
     clientPost?: RegisteredClientPost;
     clientAfterRouting?: RegisteredClientAfterRouting;
+    errorPage?: AnyComponentType;
 };
 export declare const $pipelineApp: unique symbol;
 declare const $appTypes: unique symbol;

package/dist/pipeline/pipelineDefinition.js

@@ -4,6 +4,8 @@ export const clientRoute = (matched, location) => ({
   data: matched.data,
   location
 });
+// a fallback is a G, which is serializable, or a function making one
+export const isFallbackFunction = fallback => typeof fallback === 'function';
 export const $pipelineApp = Symbol('tungsten pipeline app');
 export const isPipelineApp = value => typeof value === 'object' && value !== null && $pipelineApp in value;
 // the routes function as the runners call it

package/dist/pipeline/runPipeline.d.ts

@@ -3,27 +3,37 @@ import type { MatchedRouteInfo } from '../routing/MatchedRouteInfo.js';
 import type { RoutesWithSettings } from '../routing/Routes.js';
 import type { ServerDataLoading } from '../Store/ServerDataLoading.js';
 import type { InstancePipeline } from '../Instance/Instance.js';
-import type { AllRoutesDataConstraint, ClientPosted, ClientStarted, PipelineApp, StageContext } from './pipelineDefinition.js';
+import type { AllRoutesDataConstraint, ClientPosted, ClientStarted, PipelineApp, RegisteredAllRoutesDataFallback, StageContext } from './pipelineDefinition.js';
 export type PipelineRouted = {
     init: StageContext | undefined;
     routes: RoutesWithSettings<any>;
     allRoutesData: AllRoutesDataConstraint;
     matchedRouteInfo: MatchedRouteInfo;
+    recoveredFrom?: unknown;
+};
+export type RequestProgress = {
+    init?: {
+        value: StageContext | undefined;
+    };
+    allRoutesData?: unknown;
+    failedSteps?: string[];
 };
 export type ServerRunner = {
-    route: (app: PipelineApp, reqRes: unknown, location: string, serverDataLoading: ServerDataLoading | null, dev: boolean) => Promise<PipelineRouted>;
+    route: (app: PipelineApp, reqRes: unknown, location: string, serverDataLoading: ServerDataLoading | null, dev: boolean, progress?: RequestProgress) => Promise<PipelineRouted>;
     post: (app: PipelineApp, reqRes: unknown, init: StageContext | undefined, allRoutesData: AllRoutesDataConstraint) => Promise<StageContext | undefined>;
     context: (init: StageContext | undefined, post: StageContext | undefined) => object;
     networked: (init: StageContext | undefined, post: StageContext | undefined) => object | undefined;
 };
+export declare function runStep<T>(progress: RequestProgress, step: string, run: () => T | Promise<T>): Promise<T>;
 export declare function pipelineRoutes(app: PipelineApp, reqRes: unknown, init: StageContext | undefined, dev: boolean): RoutesWithSettings<any>;
-export declare function routeWithPipeline(app: PipelineApp, reqRes: unknown, location: string, serverDataLoading: ServerDataLoading | null, dev: boolean): Promise<PipelineRouted>;
-export declare function routeAfterInit(app: PipelineApp, reqRes: unknown, location: string, serverDataLoading: ServerDataLoading | null, dev: boolean, init: StageContext | undefined, context: object | undefined, networked: object | undefined): Promise<PipelineRouted>;
 export declare const routingContext: (context: object | undefined) => BrandedContext;
 export declare const routingNetworkedData: (networked: object | undefined) => BrandedNetworkedData;
-export declare const afterRoutingFor: (run: ClientPosted["afterRouting"]) => InstancePipeline["afterRouting"];
+export declare function routeWithPipeline(app: PipelineApp, reqRes: unknown, location: string, serverDataLoading: ServerDataLoading | null, dev: boolean, progress?: RequestProgress): Promise<PipelineRouted>;
+export declare function routeAfterInit(app: PipelineApp, reqRes: unknown, location: string, serverDataLoading: ServerDataLoading | null, dev: boolean, init: StageContext | undefined, context: object | undefined, networked: object | undefined, progress?: RequestProgress): Promise<PipelineRouted>;
+export declare function fromFallback(fallback: RegisteredAllRoutesDataFallback, reqRes: unknown, init: StageContext | undefined, location: string, error: unknown): Promise<object>;
 export declare function runPost(app: PipelineApp, reqRes: unknown, init: StageContext | undefined, allRoutesData: AllRoutesDataConstraint): Promise<StageContext | undefined>;
 export declare const pipelineContext: (init: StageContext | undefined, post: StageContext | undefined) => object;
 export declare const symmetricServer: ServerRunner;
 export declare function runClientPipeline(app: PipelineApp): Promise<ClientStarted>;
+export declare const afterRoutingFor: (run: ClientPosted['afterRouting']) => InstancePipeline['afterRouting'];
 //# sourceMappingURL=runPipeline.d.ts.map

package/dist/pipeline/runPipeline.js

@@ -1,8 +1,23 @@
 import { $cacheControl } from '../cacheControl.js';
 import { routing } from "../Servers/routing.js";
 import { toRoutes } from '../routing/routesArray.js';
-import { appRoutesFunction } from './pipelineDefinition.js';
-// the routes as the router reads them, with the routes options where the object form's settings go
+import { makeTungstenErrorInfo } from '../routing/TungstenErrorInfo.js';
+import { appRoutesFunction, isFallbackFunction } from './pipelineDefinition.js';
+import { settleRouting } from './settleRouting.js';
+// ---- steps ------------------------------------------------------------------
+// Runs one step of a request. If it throws, the step's name is added to progress.failedSteps and
+// the error goes on as before
+export async function runStep(progress, step, run) {
+  try {
+    return await run();
+  } catch (e) {
+    (progress.failedSteps ??= []).push(step);
+    throw e;
+  }
+}
+// ---- routes -----------------------------------------------------------------
+// The app's routes as the router reads them. The routes function gets Init's result; the routes
+// options (cacheControl) go where the object form keeps its settings
 export function pipelineRoutes(app, reqRes, init, dev) {
   // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- typed by the stage
   const returned = appRoutesFunction(app)(reqRes, init);
@@ -13,59 +28,86 @@ export function pipelineRoutes(app, reqRes, init, dev) {
     [$cacheControl]: cacheControl
   } : routes;
 }
-// Init, then the routes; the all-routes data beside routing, as the classic global data runs.
-// Route data functions see Init's context
-export async function routeWithPipeline(app, reqRes, location, serverDataLoading, dev) {
-  const init = await app.init?.(reqRes, undefined);
-  return routeAfterInit(app, reqRes, location, serverDataLoading, dev, init, init, undefined);
+// the context and networked data as the route data functions receive them, branded
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+export const routingContext = context => context ?? {};
+export const routingNetworkedData = networked => networked ?? {}; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+// ---- on the server ----------------------------------------------------------
+// Init, then routing. Here Init's result is the context the route data functions get
+export async function routeWithPipeline(app, reqRes, location, serverDataLoading, dev, progress = {}) {
+  const init = await runStep(progress, 'Init', () => app.init?.(reqRes, undefined));
+  progress.init = {
+    value: init
+  };
+  return routeAfterInit(app, reqRes, location, serverDataLoading, dev, init, init, undefined, progress);
 }
-// the route data functions are handed the context and networked data Init made
-export async function routeAfterInit(app, reqRes, location, serverDataLoading, dev, init, context, networked) {
+// Routing, with the all-routes data fetched at the same time, as the classic global data is. Both
+// pipelines use it: `context` and `networked` are what the route data functions get (the split
+// pipeline passes Init's two halves)
+export async function routeAfterInit(app, reqRes, location, serverDataLoading, dev, init, context, networked, progress = {}) {
   const routes = pipelineRoutes(app, reqRes, init, dev);
-  const [allRoutesData, matchedRouteInfo] = await Promise.all([app.allRoutesData?.(reqRes, init), routing(location, routes, routingContext(context), routingNetworkedData(networked), serverDataLoading)]);
+  const getAllRoutesData = app.allRoutesData;
+  const fallback = app.allRoutesDataFallback;
+  // what arrived, for the error page if a later step fails
+  const arrived = data => {
+    progress.allRoutesData = data;
+    return data;
+  };
+  const settled = await settleRouting(routes, async () => runStep(progress, 'routing', async () => routing(location, routes, routingContext(context), routingNetworkedData(networked), serverDataLoading)), getAllRoutesData && (async () => runStep(progress, 'all-routes data', async () => arrived(await getAllRoutesData(reqRes, init, location)))), fallback && (async error => runStep(progress, 'all-routes data fallback', async () => arrived(await fromFallback(fallback, reqRes, init, location, error)))), dev ? makeTungstenErrorInfo : serverErrorInfo);
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- the stage typed it
+  const allRoutesData = settled.allRoutesData;
   return {
     init,
     routes,
-    allRoutesData,
-    matchedRouteInfo
+    ...settled,
+    allRoutesData
   };
 }
-// the framework brands what it builds
-// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-export const routingContext = context => context ?? {};
-export const routingNetworkedData = networked => networked ?? {}; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
-// the split pipeline's clientAfterRouting, as the instance calls it after each client routing
-export const afterRoutingFor = run => {
-  if (run === undefined) return undefined;
-  return async (route, allRoutesData) => await run(route, allRoutesData); // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
-};
-// after routing, and not at all for a redirect
+// in prod the error route is handed a generic message: the error's own stays on the server
+const serverErrorInfo = error => ({
+  error,
+  message: 'server error'
+});
+// the app's fallback for a failed all-routes data: a value as given, or what its function makes of
+// what the all-routes data function was handed, and the error
+export async function fromFallback(fallback, reqRes, init, location, error) {
+  return isFallbackFunction(fallback) ? fallback(reqRes, init, location, error) : fallback;
+}
+// Post, after routing. Not run for a redirect
 export async function runPost(app, reqRes, init, allRoutesData) {
   return app.post?.(reqRes, init, allRoutesData);
 }
-// what this.tungsten.context reads: the last stage's context
+// the components' context: Post's, or Init's when there is no Post
 export const pipelineContext = (init, post) => post ?? init ?? {};
-// what the request handler runs, beside the split pipeline's
+// the pipeline's ServerRunner; it writes no networked data into the page
 export const symmetricServer = {
   route: routeWithPipeline,
   post: runPost,
   context: pipelineContext,
   networked: () => undefined
 };
-// The browser's run, for hydration: the same stages, with null for the request. Post's all-routes
-// data is the one hydration hands it
+// ---- in the browser ---------------------------------------------------------
+// For hydration: the same stages, with null for the request. Post waits for the all-routes data
+// hydration hands it; the all-routes data function is kept to run again before each navigation
 export async function runClientPipeline(app) {
   const init = await app.init?.(null, undefined);
-  const registered = app.allRoutesData;
+  const getAllRoutesData = app.allRoutesData;
+  const fallback = app.allRoutesDataFallback;
   return {
     init,
     routingContext: init ?? {},
     routingNetworkedData: {},
-    allRoutesData: registered && (() => registered(null, init)),
+    allRoutesData: getAllRoutesData && (location => getAllRoutesData(null, init, location)),
+    allRoutesDataFallback: fallback && (async (location, error) => fromFallback(fallback, null, init, location, error)),
     networked: {},
     post: async allRoutesData => ({
       context: pipelineContext(init, await app.post?.(null, init, allRoutesData)),
       afterRouting: undefined
     })
   };
-}
+}
+// the split pipeline's clientAfterRouting, in the form the instance calls after each navigation
+export const afterRoutingFor = run => {
+  if (run === undefined) return undefined;
+  return async (route, allRoutesData) => await run(route, allRoutesData); // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+};

package/dist/pipeline/runSplitPipeline.d.ts

@@ -1,7 +1,7 @@
 import type { ServerDataLoading } from '../Store/ServerDataLoading.js';
 import type { AllRoutesDataConstraint, ClientStarted, PipelineApp, SplitResult } from './pipelineDefinition.js';
-import type { PipelineRouted, ServerRunner } from './runPipeline.js';
-export declare function routeWithSplitPipeline(app: PipelineApp, reqRes: unknown, location: string, serverDataLoading: ServerDataLoading | null, dev: boolean): Promise<PipelineRouted>;
+import type { PipelineRouted, RequestProgress, ServerRunner } from './runPipeline.js';
+export declare function routeWithSplitPipeline(app: PipelineApp, reqRes: unknown, location: string, serverDataLoading: ServerDataLoading | null, dev: boolean, progress?: RequestProgress): Promise<PipelineRouted>;
 export declare function runServerPost(app: PipelineApp, reqRes: unknown, init: object | undefined, allRoutesData: AllRoutesDataConstraint): Promise<SplitResult | undefined>;
 export declare const splitContext: (init: object | undefined, post: object | undefined) => object;
 export declare const splitNetworked: (init: object | undefined, post: object | undefined) => object | undefined;

package/dist/pipeline/runSplitPipeline.js

@@ -1,5 +1,6 @@
 import { fromTransport } from './networkedTransport.js';
-import { routeAfterInit } from './runPipeline.js';
+import { isFallbackFunction } from './pipelineDefinition.js';
+import { routeAfterInit, runStep } from './runPipeline.js';
 /*
  * Runs a split pipeline app: serverInit -> routing -> serverPost on the server, clientInit ->
  * routing -> clientPost in the browser. The route data functions are handed Init's context and
@@ -7,9 +8,12 @@ import { routeAfterInit } from './runPipeline.js';
  */
 // The stages' results. The app holds them loosely, as the builder typed them
 const asSplit = stage => stage;
-export async function routeWithSplitPipeline(app, reqRes, location, serverDataLoading, dev) {
-  const init = await app.serverInit?.(reqRes);
-  return routeAfterInit(app, reqRes, location, serverDataLoading, dev, init, init?.context, init?.networked);
+export async function routeWithSplitPipeline(app, reqRes, location, serverDataLoading, dev, progress = {}) {
+  const init = await runStep(progress, 'serverInit', () => app.serverInit?.(reqRes));
+  progress.init = {
+    value: init
+  };
+  return routeAfterInit(app, reqRes, location, serverDataLoading, dev, init, init?.context, init?.networked, progress);
 }
 // after routing, and not at all for a redirect
 export async function runServerPost(app, reqRes, init, allRoutesData) {
@@ -33,11 +37,13 @@ export async function runSplitClient(app, fromPage) {
   const networked = fromTransport(fromPage) ?? {};
   const init = await app.clientInit?.(networked);
   const registered = app.clientAllRoutesData;
+  const fallback = app.clientAllRoutesDataFallback;
   return {
     init,
     routingContext: init?.context ?? {},
     routingNetworkedData: init?.networked ?? {},
-    allRoutesData: registered && (() => registered(init)),
+    allRoutesData: registered && (location => registered(init, location)),
+    allRoutesDataFallback: fallback && (async (location, error) => isFallbackFunction(fallback) ? fallback(init, location, error) : fallback),
     networked,
     post: async allRoutesData => {
       const context = splitContext(init, await app.clientPost?.(init, allRoutesData));

package/dist/pipeline/settleRouting.d.ts

@@ -0,0 +1,10 @@
+import type { MatchedRouteInfo } from '../routing/MatchedRouteInfo.js';
+import type { Routes } from '../routing/Routes.js';
+import type { TungstenErrorInfo } from '../routing/TungstenErrorInfo.js';
+export type Settled = {
+    allRoutesData: unknown;
+    matchedRouteInfo: MatchedRouteInfo;
+    recoveredFrom?: unknown;
+};
+export declare function settleRouting(routes: Routes<any>, route: () => Promise<MatchedRouteInfo>, loadData: (() => Promise<unknown>) | undefined, fallback: ((error: unknown) => Promise<unknown>) | undefined, errorInfo: (error: unknown) => TungstenErrorInfo): Promise<Settled>;
+//# sourceMappingURL=settleRouting.d.ts.map