tungsten 0.7.0 → 0.7.2

package/dist/pipeline/pipeline.d.ts

@@ -10,38 +10,40 @@ type Props = TungstenComponentPropsBase;
 type State = TungstenComponentStateConstraint;
 type Signals = TungstenComponentSignalsConstraint;
 export type Nothing = Record<never, never>;
-export type PipelineHelpers<Ctx, G extends object> = Omit<ComponentHelpers, 'context' | 'allRoutesData'> & {
-    readonly context: Ctx extends object ? Ctx : Nothing;
+export type DeliveredContext<Ctx> = Ctx extends object ? Ctx : Nothing;
+export type PipelineHelpers<Ctx, N, G extends object | undefined> = Omit<ComponentHelpers, 'context' | 'allRoutesData' | 'networked'> & {
+    readonly context: DeliveredContext<Ctx>;
+    readonly networked: N & object;
     readonly allRoutesData: G;
 };
-export declare abstract class PipelineSimpleComponent<Ctx, G extends object, P extends Props = Props, RD = undefined> extends TungstenSimpleComponent<P, RD> {
-    get tungsten(): PipelineHelpers<Ctx, G>;
+export declare abstract class PipelineSimpleComponent<Ctx, N, G extends object | undefined, P extends Props = Props, RD = undefined> extends TungstenSimpleComponent<P, RD> {
+    get tungsten(): PipelineHelpers<Ctx, N, G>;
 }
-export declare abstract class PipelineStatefulComponent<Ctx, G extends object, P extends Props, S extends State, RD = undefined> extends TungstenStatefulComponent<P, S, RD> {
-    get tungsten(): PipelineHelpers<Ctx, G>;
+export declare abstract class PipelineStatefulComponent<Ctx, N, G extends object | undefined, P extends Props, S extends State, RD = undefined> extends TungstenStatefulComponent<P, S, RD> {
+    get tungsten(): PipelineHelpers<Ctx, N, G>;
 }
-export declare abstract class PipelineSignalsComponent<Ctx, G extends object, P extends Props, Sg extends Signals, RD = undefined> extends TungstenSignalsComponent<P, Sg, RD> {
-    get tungsten(): PipelineHelpers<Ctx, G>;
+export declare abstract class PipelineSignalsComponent<Ctx, N, G extends object | undefined, P extends Props, Sg extends Signals, RD = undefined> extends TungstenSignalsComponent<P, Sg, RD> {
+    get tungsten(): PipelineHelpers<Ctx, N, G>;
 }
-type SelectStore<Ctx, G extends object, N, Schema extends object> = (context: PipelineHelpers<Ctx, G>['context'], networked: N) => ReadonlyTrueStore<Schema>;
-export declare abstract class PipelineSimpleStoreComponent<Ctx, G extends object, N, St extends object, P extends Props = Props, RD = undefined> extends TungstenBaseSimpleStoreComponent<P, RD, St> {
-    get tungsten(): PipelineHelpers<Ctx, G>;
-    protected createStore<Schema extends object>(select: SelectStore<Ctx, G, N, Schema>): ComponentStore<Schema>;
+type SelectStore<Ctx, N, G extends object | undefined, Schema extends object> = (context: PipelineHelpers<Ctx, N, G>['context'], networked: N) => ReadonlyTrueStore<Schema>;
+export declare abstract class PipelineSimpleStoreComponent<Ctx, N, G extends object | undefined, St extends object, P extends Props = Props, RD = undefined> extends TungstenBaseSimpleStoreComponent<P, RD, St> {
+    get tungsten(): PipelineHelpers<Ctx, N, G>;
+    protected createStore<Schema extends object>(select: SelectStore<Ctx, N, G, Schema>): ComponentStore<Schema>;
 }
-export declare abstract class PipelineStatefulStoreComponent<Ctx, G extends object, N, St extends object, P extends Props, S extends State, RD = undefined> extends TungstenBaseStatefulStoreComponent<P, S, RD, St> {
-    get tungsten(): PipelineHelpers<Ctx, G>;
-    protected createStore<Schema extends object>(select: SelectStore<Ctx, G, N, Schema>): ComponentStore<Schema>;
+export declare abstract class PipelineStatefulStoreComponent<Ctx, N, G extends object | undefined, St extends object, P extends Props, S extends State, RD = undefined> extends TungstenBaseStatefulStoreComponent<P, S, RD, St> {
+    get tungsten(): PipelineHelpers<Ctx, N, G>;
+    protected createStore<Schema extends object>(select: SelectStore<Ctx, N, G, Schema>): ComponentStore<Schema>;
 }
 type Statics<T> = Omit<T, 'prototype'>;
-export type PipelineComponents<Ctx, G extends object, N = Nothing> = {
-    SimpleComponent: (abstract new <P extends Props = Props, RD = undefined>(pkg: ConstructPackage<P, RD>) => PipelineSimpleComponent<Ctx, G, P, RD>) & Statics<typeof PipelineSimpleComponent>;
-    StatefulComponent: (abstract new <P extends Props = Props, S extends State = State, RD = undefined>(pkg: ConstructPackage<P, RD>) => PipelineStatefulComponent<Ctx, G, P, S, RD>) & Statics<typeof PipelineStatefulComponent>;
-    SignalsComponent: (abstract new <P extends Props = Props, Sg extends Signals = Signals, RD = undefined>(pkg: ConstructPackage<P, RD>) => PipelineSignalsComponent<Ctx, G, P, Sg, RD>) & Statics<typeof PipelineSignalsComponent>;
-    SimpleStoreComponent: (abstract new <St extends object, P extends Props = Props, RD = undefined>(pkg: ConstructPackage<P, RD>) => PipelineSimpleStoreComponent<Ctx, G, N, St, P, RD>) & Statics<typeof PipelineSimpleStoreComponent>;
-    StatefulStoreComponent: (abstract new <St extends object, P extends Props = Props, S extends State = State, RD = undefined>(pkg: ConstructPackage<P, RD>) => PipelineStatefulStoreComponent<Ctx, G, N, St, P, S, RD>) & Statics<typeof PipelineStatefulStoreComponent>;
+export type PipelineComponents<Ctx, N, G extends object | undefined> = {
+    SimpleComponent: (abstract new <P extends Props = Props, RD = undefined>(pkg: ConstructPackage<P, RD>) => PipelineSimpleComponent<Ctx, N, G, P, RD>) & Statics<typeof PipelineSimpleComponent>;
+    StatefulComponent: (abstract new <P extends Props = Props, S extends State = State, RD = undefined>(pkg: ConstructPackage<P, RD>) => PipelineStatefulComponent<Ctx, N, G, P, S, RD>) & Statics<typeof PipelineStatefulComponent>;
+    SignalsComponent: (abstract new <P extends Props = Props, Sg extends Signals = Signals, RD = undefined>(pkg: ConstructPackage<P, RD>) => PipelineSignalsComponent<Ctx, N, G, P, Sg, RD>) & Statics<typeof PipelineSignalsComponent>;
+    SimpleStoreComponent: (abstract new <St extends object, P extends Props = Props, RD = undefined>(pkg: ConstructPackage<P, RD>) => PipelineSimpleStoreComponent<Ctx, N, G, St, P, RD>) & Statics<typeof PipelineSimpleStoreComponent>;
+    StatefulStoreComponent: (abstract new <St extends object, P extends Props = Props, S extends State = State, RD = undefined>(pkg: ConstructPackage<P, RD>) => PipelineStatefulStoreComponent<Ctx, N, G, St, P, S, RD>) & Statics<typeof PipelineStatefulStoreComponent>;
 };
 type StageTypes<X> = X extends {
-    SimpleStoreComponent: abstract new (...args: any) => PipelineSimpleStoreComponent<infer Ctx, any, infer N, any, any, any>;
+    SimpleStoreComponent: abstract new (...args: any) => PipelineSimpleStoreComponent<infer Ctx, infer N, any, any, any, any>;
 } ? {
     context: Ctx extends object ? Ctx : Nothing;
     networked: N;
@@ -50,7 +52,7 @@ export type PipelineContext<X> = StageTypes<X>['context'];
 export type PipelineNetworked<X> = StageTypes<X>['networked'];
 export type PipelineResult<X> = StageTypes<X>;
 export type PipelineInit<X> = X extends {
-    routes: Routes<any, infer I, any>;
+    routes: Routes<any, infer I, any, any, any>;
 } ? I : never;
 declare const $stage: unique symbol;
 type StageRecord<Result, Ctx> = {
@@ -77,25 +79,25 @@ export type PipelineStageContext<X, Name extends keyof StagesOf<X> = never> = Re
 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>>>;
-type RoutesFunction<Req, I, G extends object> = (reqRes: Req | null, init: I) => RoutesWithSettings<G> | RoutesArray<G> | [];
-type Routes<Req, I, G extends object> = {
-    <const R extends RoutesFunction<Req, I, G>>(routes: R & NoDuplicatePaths<R>): PipelineApp<R>;
-    <const R extends RoutesFunction<Req, I, G>>(options: RoutesOptions, routes: R & NoDuplicatePaths<R>): PipelineApp<R>;
+type RoutesFunction<Req, I, G extends object | undefined> = (reqRes: Req | null, init: I) => RoutesWithSettings<G> | RoutesArray<G> | [];
+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>;
 };
-export type PostStage<Req, I, G extends object, Ctx, N = Nothing> = PipelineComponents<Ctx, G, N> & {
-    routes: Routes<Req, I, G>;
+export type PostStage<Req, I, Ctx, N, G extends object | undefined> = PipelineComponents<Ctx, N, G> & {
+    routes: Routes<Req, I, Ctx, N, G>;
 };
-export type DataStage<Req, I, G extends object> = PostStage<Req, I, G, I> & {
-    post: <P extends StageContext, This>(this: This, process: Process<Req, I, P, G>) => PostStage<Req, I, G, P> & StageMark<This, 'post', P, P>;
+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, Nothing> & {
+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>;
 };
 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, G extends object, Ctx, N = Nothing>(definition: PipelineDefinition): PostStage<Req, I, G, Ctx, N>;
+export declare function postStage<Req, I, Ctx, N, G extends object | undefined>(definition: PipelineDefinition): PostStage<Req, I, Ctx, N, G>;
 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

@@ -19,16 +19,17 @@ export class PipelineSignalsComponent extends TungstenSignalsComponent {
     return pipelineHelpers(super.tungsten);
   }
 }
-const pipelineNetworked = instance =>
-// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- typed by the stage
-instance.pipelineNetworked;
 // The app makes its store components: `store = this.createStore(context => context.store)`
 export class PipelineSimpleStoreComponent extends TungstenBaseSimpleStoreComponent {
   get tungsten() {
     return pipelineHelpers(super.tungsten);
   }
   createStore(select) {
-    return this.__proxyStore(select(this.tungsten.context, pipelineNetworked(this.__instance)));
+    const {
+      context,
+      networked
+    } = this.tungsten;
+    return this.__proxyStore(select(context, networked));
   }
 }
 export class PipelineStatefulStoreComponent extends TungstenBaseStatefulStoreComponent {
@@ -36,7 +37,11 @@ export class PipelineStatefulStoreComponent extends TungstenBaseStatefulStoreCom
     return pipelineHelpers(super.tungsten);
   }
   createStore(select) {
-    return this.__proxyStore(select(this.tungsten.context, pipelineNetworked(this.__instance)));
+    const {
+      context,
+      networked
+    } = this.tungsten;
+    return this.__proxyStore(select(context, networked));
   }
 }
 const pipelineComponents = {

package/dist/pipeline/pipelineDefinition.d.ts

@@ -9,16 +9,17 @@ export type ServerRequests = {
 export type ServerKind = keyof ServerRequests;
 export type StageContext = object;
 export type MaybePromise<T> = T | Promise<T>;
-export type RegisteredStage = (reqRes: unknown, previous: StageContext | undefined, allRoutesData?: object) => MaybePromise<StageContext | undefined>;
+export type AllRoutesDataConstraint = object | undefined;
+export type RegisteredStage = (reqRes: unknown, previous: StageContext | undefined, allRoutesData?: AllRoutesDataConstraint) => MaybePromise<StageContext | undefined>;
 export type SplitResult = {
     context?: object;
     networked?: object;
 };
 export type RegisteredServerInit = (reqRes: unknown) => MaybePromise<SplitResult | undefined>;
-export type RegisteredServerPost = (reqRes: unknown, init: SplitResult | undefined, allRoutesData: object) => 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 RegisteredClientPost = (init: SplitResult | undefined, allRoutesData: object) => MaybePromise<SplitResult | undefined>;
+export type RegisteredClientPost = (init: SplitResult | undefined, allRoutesData: AllRoutesDataConstraint) => MaybePromise<SplitResult | undefined>;
 export type ClientRoute = {
     key: RouteKey | null;
     params: Record<string, string>;
@@ -26,16 +27,19 @@ export type ClientRoute = {
     location: string;
 };
 export declare const clientRoute: (matched: MatchedRouteInfo, location: string) => ClientRoute;
-export type RegisteredClientAfterRouting = (context: object, route: ClientRoute, allRoutesData: object) => MaybePromise<SplitResult | undefined>;
-export type ClientRun = (app: PipelineApp, allRoutesData: object, fromPage: unknown) => Promise<ClientRan>;
-export type ClientRan = {
+export type RegisteredClientAfterRouting = (context: object, route: ClientRoute, allRoutesData: AllRoutesDataConstraint) => MaybePromise<SplitResult | undefined>;
+export type ClientRun = (app: PipelineApp, fromPage: unknown) => Promise<ClientStarted>;
+export type ClientStarted = {
     init: StageContext | undefined;
-    context: object;
     routingContext: object;
     routingNetworkedData: object;
     allRoutesData: (() => MaybePromise<object>) | undefined;
     networked: object;
-    afterRouting: ((route: ClientRoute, allRoutesData: object) => Promise<object>) | undefined;
+    post: (allRoutesData: AllRoutesDataConstraint) => Promise<ClientPosted>;
+};
+export type ClientPosted = {
+    context: object;
+    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>;
@@ -57,11 +61,18 @@ export type PipelineDefinition = {
     clientAfterRouting?: RegisteredClientAfterRouting;
 };
 export declare const $pipelineApp: unique symbol;
-export type PipelineApp<R = unknown> = PipelineDefinition & {
+declare const $appTypes: unique symbol;
+export type PipelineApp<R = unknown, Ctx = unknown, N = unknown, G = unknown> = PipelineDefinition & {
     readonly [$pipelineApp]: true;
     readonly routes: R;
     readonly routesOptions: RoutesOptions;
+    readonly [$appTypes]?: {
+        context: Ctx;
+        networked: N;
+        allRoutesData: G;
+    };
 };
 export declare const isPipelineApp: (value: unknown) => value is PipelineApp;
 export declare const appRoutesFunction: (app: PipelineApp) => RegisteredRoutes;
+export {};
 //# sourceMappingURL=pipelineDefinition.d.ts.map

package/dist/pipeline/runPipeline.d.ts

@@ -3,16 +3,16 @@ 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 { ClientRan, PipelineApp, StageContext } from './pipelineDefinition.js';
+import type { AllRoutesDataConstraint, ClientPosted, ClientStarted, PipelineApp, StageContext } from './pipelineDefinition.js';
 export type PipelineRouted = {
     init: StageContext | undefined;
     routes: RoutesWithSettings<any>;
-    allRoutesData: object;
+    allRoutesData: AllRoutesDataConstraint;
     matchedRouteInfo: MatchedRouteInfo;
 };
 export type ServerRunner = {
     route: (app: PipelineApp, reqRes: unknown, location: string, serverDataLoading: ServerDataLoading | null, dev: boolean) => Promise<PipelineRouted>;
-    post: (app: PipelineApp, reqRes: unknown, init: StageContext | undefined, allRoutesData: object) => Promise<StageContext | undefined>;
+    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;
 };
@@ -21,11 +21,9 @@ export declare function routeWithPipeline(app: PipelineApp, reqRes: unknown, loc
 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: ClientRan["afterRouting"]) => InstancePipeline["afterRouting"];
-export declare function runPost(app: PipelineApp, reqRes: unknown, init: StageContext | undefined, allRoutesData: object): Promise<StageContext | undefined>;
+export declare const afterRoutingFor: (run: ClientPosted["afterRouting"]) => InstancePipeline["afterRouting"];
+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, allRoutesData: object): Promise<ClientRan & {
-    post: object | undefined;
-}>;
+export declare function runClientPipeline(app: PipelineApp): Promise<ClientStarted>;
 //# sourceMappingURL=runPipeline.d.ts.map

package/dist/pipeline/runPipeline.js

@@ -22,7 +22,7 @@ export async function routeWithPipeline(app, reqRes, location, serverDataLoading
 // 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) {
   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 [allRoutesData, matchedRouteInfo] = await Promise.all([app.allRoutesData?.(reqRes, init), routing(location, routes, routingContext(context), routingNetworkedData(networked), serverDataLoading)]);
   return {
     init,
     routes,
@@ -52,20 +52,20 @@ export const symmetricServer = {
   context: pipelineContext,
   networked: () => undefined
 };
-// The browser's run, for hydration: the same stages, with null for the request. The all-routes data
-// is the server's, from the page
-export async function runClientPipeline(app, allRoutesData) {
+// 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
+export async function runClientPipeline(app) {
   const init = await app.init?.(null, undefined);
-  const post = await app.post?.(null, init, allRoutesData);
   const registered = app.allRoutesData;
   return {
     init,
-    post,
-    context: pipelineContext(init, post),
     routingContext: init ?? {},
     routingNetworkedData: {},
     allRoutesData: registered && (() => registered(null, init)),
     networked: {},
-    afterRouting: undefined
+    post: async allRoutesData => ({
+      context: pipelineContext(init, await app.post?.(null, init, allRoutesData)),
+      afterRouting: undefined
+    })
   };
 }

package/dist/pipeline/runSplitPipeline.d.ts

@@ -1,10 +1,10 @@
 import type { ServerDataLoading } from '../Store/ServerDataLoading.js';
-import type { ClientRan, PipelineApp, SplitResult } from './pipelineDefinition.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>;
-export declare function runServerPost(app: PipelineApp, reqRes: unknown, init: object | undefined, allRoutesData: object): Promise<SplitResult | undefined>;
+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;
 export declare const splitServer: ServerRunner;
-export declare function runSplitClient(app: PipelineApp, allRoutesData: object, fromPage: unknown): Promise<ClientRan>;
+export declare function runSplitClient(app: PipelineApp, fromPage: unknown): Promise<ClientStarted>;
 //# sourceMappingURL=runSplitPipeline.d.ts.map

package/dist/pipeline/runSplitPipeline.js

@@ -26,23 +26,27 @@ export const splitServer = {
   networked: splitNetworked
 };
 // The browser's run, for hydration: clientInit from the networked data in the page, its stores
-// rebuilt, then clientPost with the server's all-routes data. Each navigation's is the client's own
-export async function runSplitClient(app, allRoutesData, fromPage) {
+// rebuilt, then clientPost with the all-routes data hydration hands it. Each navigation's is the
+// client's own
+export async function runSplitClient(app, fromPage) {
   // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- the request handler wrote it
   const networked = fromTransport(fromPage) ?? {};
   const init = await app.clientInit?.(networked);
-  const post = await app.clientPost?.(init, allRoutesData);
-  const context = splitContext(init, post);
   const registered = app.clientAllRoutesData;
-  const afterRouting = app.clientAfterRouting;
   return {
     init,
-    context,
     routingContext: init?.context ?? {},
     routingNetworkedData: init?.networked ?? {},
     allRoutesData: registered && (() => registered(init)),
     networked,
-    // clientPost's context in each time, the components' out
-    afterRouting: afterRouting && (async (route, data) => splitContext(await afterRouting(context, route, data), undefined))
+    post: async allRoutesData => {
+      const context = splitContext(init, await app.clientPost?.(init, allRoutesData));
+      const afterRouting = app.clientAfterRouting;
+      return {
+        context,
+        // clientPost's context in each time, the components' out
+        afterRouting: afterRouting && (async (route, data) => splitContext(await afterRouting(context, route, data), undefined))
+      };
+    }
   };
 }

package/dist/pipeline/splitPipeline.d.ts

@@ -29,26 +29,26 @@ type ClientInitProcess<N, CI> = (networked: N) => MaybePromise<CI & ClientSplit<
 type ClientAllRoutesDataProcess<CI, G> = (init: CI) => MaybePromise<G>;
 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, ServerCtx, N, PC> = PostStage<Req, SI | CI, G, ServerCtx | PC, N> & {
-    clientAfterRouting: <CA extends object, This>(this: This, process: ClientAfterRoutingProcess<PC, CA, G>) => PostStage<Req, SI | CI, G, ServerCtx | ContextOf<CA>, N> & 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> & {
+    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 ClientDataStage<Req, SI, CI, G extends object, ServerCtx, N, PC> = {
+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>;
 };
-type AfterClientPost<Req, SI, CI, G extends object, 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, D extends boolean, ServerCtx, N> = AfterClientPost<Req, SI, CI, G, D, ServerCtx, N, ContextOf<CI>> & {
+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>> & {
     clientPost: <CP extends object, This>(this: This, process: ClientPostProcess<CI, CP, G>) => AfterClientPost<Req, SI, CI, G, D, ServerCtx, N, ContextOf<CP>> & StageMark<This, 'clientPost', CP, ContextOf<CP>>;
 };
-export type ClientInitStage<Req, SI, G extends object, D extends boolean, N, ServerCtx> = {
+export type ClientInitStage<Req, SI, G extends object | undefined, D extends boolean, N, ServerCtx> = {
     clientInit: <CI extends object | undefined, This>(this: This, process: ClientInitProcess<N, CI>) => ClientPostStage<Req, SI, CI, G, D, ServerCtx, N> & StageMark<This, 'clientInit', CI, ContextOf<CI>>;
 };
-export type SplitDataStage<Req, SI, G extends object, D extends boolean> = ClientInitStage<Req, SI, G, D, NetworkedOf<SI>, ContextOf<SI>> & {
+export type SplitDataStage<Req, SI, G extends object | undefined, D extends boolean> = ClientInitStage<Req, SI, G, D, NetworkedOf<SI>, ContextOf<SI>> & {
     serverPost: <SP extends object, This>(this: This, process: ServerPostProcess<Req, SI, SP, G>) => ClientInitStage<Req, SI, G, D, NetworkedOf<SP>, ContextOf<SP>> & StageMark<This, 'serverPost', SP, ContextOf<SP>>;
 };
 export type PipelineServerAllRoutesData<X extends {
     serverPost: (process: never) => unknown;
 }> = Parameters<Parameters<X['serverPost']>[0]>[2];
-export type SplitInitStage<Req, SI> = SplitDataStage<Req, SI, Nothing, false> & {
+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>>;
 };
 export type SplitServerStage<Req> = {

package/dist/render/contentTreeToRenderingTree.js

@@ -38,7 +38,10 @@ export async function contentTreeToRenderingTree(node, parentComponent, instance
       children,
       ...rest
     } = node[$props];
-    if (validChildren(children)) {
+    // config.serverSideRouting false: the client builds what is inside, with the data it
+    // fetches
+    const stub = instance.config.serverSideRouting === false && (node[$type] === 'head' || node[$type] === 'body');
+    if (!stub && validChildren(children)) {
       debug('children', node[$props].children);
       const noEscape = node[$type] === 'script' || node[$type] === 'style' || '__noEscape' in node[$props] && node[$props].__noEscape !== false;
       //console.log(node[$type], node[$props], 'noEscape', noEscape)

package/dist/routing/MatchedRouteInfo.d.ts

@@ -7,5 +7,7 @@ export type MatchedRouteInfo = {
     params: Record<string, string>;
     content: ContentNode | RouteContentFunction<any, any>;
     data?: unknown | RoutingRedirect;
+    code?: number;
 };
+export declare const responseStatus: (matched: MatchedRouteInfo) => number;
 //# sourceMappingURL=MatchedRouteInfo.d.ts.map

package/dist/routing/MatchedRouteInfo.js

@@ -1 +1 @@
-export {};
+export const responseStatus = matched => matched.code ?? (matched.key === '404' ? 404 : 200);

package/dist/routing/RouteContentFunction.d.ts

@@ -1,5 +1,5 @@
 import type { ContentNode } from '../ContentNode.js';
 import type { MatchedRouteProps } from './MatchedRoute.js';
-export type RouteContentFunction<RouteParams extends object = object, RouteData = unknown, G extends object = object, ND = {}> = (routeData: RouteData, routeParams: RouteParams, props: MatchedRouteProps, globalData: G, location: string) => ContentNode;
+export type RouteContentFunction<RouteParams extends object = object, RouteData = unknown, G extends object | undefined = object, ND = {}> = (routeData: RouteData, routeParams: RouteParams, props: MatchedRouteProps, globalData: G, location: string) => ContentNode;
 export declare function ContentIsRouteContentFunction(content: ContentNode | RouteContentFunction): content is RouteContentFunction;
 //# sourceMappingURL=RouteContentFunction.d.ts.map

package/dist/routing/RouteTypes.d.ts

@@ -2,7 +2,7 @@ import type { RouteDataFunction } from './RouteDataFunction.type.js';
 import type { ContentNode } from '../ContentNode.js';
 import type { RouteContentFunction } from './RouteContentFunction.js';
 import type { RouteCacheControl } from '../cacheControl.js';
-export type Endpoint<Params extends object, DataType, G extends object = object> = {
+export type Endpoint<Params extends object, DataType, G extends object | undefined = object> = {
     data?: RouteDataFunction<Params, DataType>;
     content: ContentNode | RouteContentFunction<Params, DataType, G>;
     cacheControl?: RouteCacheControl;

package/dist/routing/Routes.d.ts

@@ -10,16 +10,19 @@ export type MinimumRoutes = {
 export type RoutesSettings = {
     [$cacheControl]?: RouteCacheControl;
 };
-export type Routes<G extends object = object> = {
+export type Routes<G extends object | undefined = object> = {
     [key in Path]: Endpoint<any, any, G>;
 } & {
     error?: ErrorRouteType;
 } & ({
     default: Endpoint<any, any, G>;
 } | {
-    404: Endpoint<any, any, G>;
+    404: NotFoundEndpoint<G>;
 });
-export type RoutesWithSettings<G extends object = object> = Routes<G> & RoutesSettings;
+export type NotFoundEndpoint<G extends object | undefined = object> = Endpoint<any, any, G> & {
+    code?: number;
+};
+export type RoutesWithSettings<G extends object | undefined = object> = Routes<G> & RoutesSettings;
 export type CustomRoutes<Route extends Endpoint<any, any, G>, G extends object & Serializable<G> = object> = {
     [key in Path]: Route;
 } & {
@@ -27,6 +30,8 @@ export type CustomRoutes<Route extends Endpoint<any, any, G>, G extends object &
 } & ({
     default: Route;
 } | {
-    404: Route;
+    404: Route & {
+        code?: number;
+    };
 }) & RoutesSettings;
 //# sourceMappingURL=Routes.d.ts.map

package/dist/routing/builder.d.ts

@@ -19,7 +19,7 @@ export type FluentDefaultRoute = {
 };
 export type Fluent404Route = {
     path: '404';
-    code: 404;
+    code?: number;
     content: ContentNode;
 };
 export type FluentErrorRoute = {
@@ -31,6 +31,7 @@ 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;
 type FrameworkRouteFields = Omit<Endpoint<any, any>, 'data' | 'content'>;
 type Meta = Record<string, unknown> & FrameworkRouteFields;
 declare const $invalidKeyError: unique symbol;

package/dist/routing/builder.js

@@ -27,6 +27,12 @@ export function routesWith() {
     return routes; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
   };
 }
+// the array routes form, as given: routesFromArray() keys it and finds a path given twice
+export function routesWithList() {
+  return function routeList(routes) {
+    return routes;
+  };
+}
 // export function routeLegacy<P extends RouteKey>(path: P) {
 //     const r: { path: P } = { path }
 //     return {

package/dist/routing/redirectOf.d.ts

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

package/dist/routing/redirectOf.js

@@ -0,0 +1,32 @@
+import { RouteRedirectComponent } from "../components/RouteRedirectComponent.js";
+import { WebRedirectComponent } from "../components/WebRedirectComponent.js";
+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;
+  if (data instanceof RoutingRedirect) return {
+    route: data.to
+  };
+  if (data instanceof WebRedirect) return {
+    url: data.to,
+    code: data.code
+  };
+  const content = matched.content;
+  if (typeof content === 'function' || !ContentNodeIsClassComponent(content)) return undefined;
+  const type = content[$type];
+  if (type === RouteRedirectComponent || type.prototype instanceof RouteRedirectComponent) {
+    return {
+      route: content[$props].to
+    }; // 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
+  }
+  return undefined;
+}

package/dist/routing/routesArray.d.ts

@@ -1,12 +1,12 @@
 import type { ErrorRouteType } from './ErrorRouteType.js';
 import type { Routes, RoutesWithSettings } from './Routes.js';
 import type { Endpoint, Path } from './RouteTypes.js';
-export type RouteEntry<G extends object = object> = (Endpoint<any, any, G> & {
+export type RouteEntry<G extends object | undefined = object> = (Endpoint<any, any, G> & {
     path: Path | 'default' | '404';
 }) | (ErrorRouteType & {
     path: 'error';
 });
-export type RoutesArray<G extends object = object> = readonly RouteEntry<G>[];
+export type RoutesArray<G extends object | undefined = object> = readonly RouteEntry<G>[];
 export declare function routesFromArray(entries: RoutesArray<any>, dev: boolean): Routes<any>;
 export declare const toRoutes: <Rs extends object>(routes: Rs | RoutesArray<any>, dev: boolean) => Rs | RoutesWithSettings<any>;
 export type KeyedRoutes<Rs> = Rs extends RoutesArray<any> ? {

package/dist/routing/routingBuilder.js

@@ -7,7 +7,6 @@ function makeStages(pending) {
       ...pending,
       context: contextInitializer
     }),
-    // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion -- C is erased at the registry, which holds the class unparameterised
     networkedData: networkedDataInitializer => makeStages({
       ...pending,
       networkedStore: networkedDataInitializer

package/dist/testing/contentToString.d.ts

@@ -0,0 +1,13 @@
+import type { ContentNode } from '../ContentNode.js';
+export type ContentToStringOptions = {
+    /** A resolved component's passed children in full, where otherwise children={...} */
+    children?: boolean;
+    /** Fragments as `<>`…`</>`, where otherwise their content stands in their place */
+    fragments?: boolean;
+};
+/**
+ * The tree as JSX. A component host() resolved has its output under it, marked ⤵, and the children
+ * it was passed as a prop; one unresolved holds its passed children, as written.
+ */
+export declare function contentToString(content: ContentNode, options?: ContentToStringOptions): string;
+//# sourceMappingURL=contentToString.d.ts.map