tungsten 0.6.2 → 0.7.0

package/dist/pipeline/pipelineSplit.types.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipelineSplit.types.test.d.ts","sourceRoot":"","sources":["../../src/pipeline/pipelineSplit.types.test.ts"],"names":[],"mappings":"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"}

package/dist/pipeline/pipelineSplit.types.test.js

@@ -0,0 +1,440 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { contextStore } from './contextStore.js';
+import { pipeline } from './pipeline.js';
+import { splitPipeline } from './splitPipeline.js';
+/*
+ * Type tests for the split pipeline. tsc is the assertion - nothing here runs.
+ *
+ * serverInit -> routing -> serverPost -> clientInit -> routing -> clientPost
+ */
+class ApiClient {
+  constructor(reqRes) {
+    _defineProperty(this, "get", async path => Promise.resolve(path));
+    void reqRes;
+  }
+}
+class VersionManager {
+  constructor() {
+    _defineProperty(this, "version", 'v1');
+  }
+}
+const server = splitPipeline.server('express');
+const serverInit = server.serverInit(reqRes => {
+  // the server's stages always have the request
+  const typed = reqRes;
+  void typed;
+  return {
+    context: {
+      api: new ApiClient(reqRes)
+    },
+    networked: {
+      userId: 1
+    }
+  };
+});
+const serverPost = serverInit.serverPost((reqRes, init) => {
+  const typed = reqRes;
+  const api = init.context.api;
+  void typed;
+  void api;
+  return {
+    context: {
+      api,
+      counter: contextStore({
+        count: init.networked.userId
+      })
+    },
+    networked: {
+      counter: contextStore({
+        count: init.networked.userId
+      }, {
+        sync: 'afterRouting'
+      })
+    }
+  };
+});
+// clientInit is handed the networked data from serverPost, and makes a context of its own
+const clientInit = serverPost.clientInit(networked => {
+  const counter = networked.counter;
+  return {
+    context: {
+      api: new ApiClient(null),
+      versions: new VersionManager()
+    },
+    networked: {
+      userId: counter.count.get()
+    }
+  };
+});
+const app = clientInit.clientPost(init => ({
+  context: {
+    api: init.context.api,
+    versions: init.context.versions,
+    counter: contextStore({
+      count: init.networked.userId
+    })
+  }
+}));
+// ---- the components see either side's context -------------------------------
+export class Page extends app.SimpleComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "content", () => {
+      const context = this.tungsten.context;
+      // what both sides give
+      const api = context.api;
+      const count = context.counter.count.get();
+      void api;
+      void count;
+      // @ts-expect-error -- only the client gives it
+      void context.versions;
+      if ('versions' in context) {
+        const versions = context.versions;
+        void versions;
+      }
+      // @ts-expect-error -- the networked data is not the context
+      void context.userId;
+      return null;
+    });
+  }
+}
+export class CountView extends app.SimpleStoreComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "store", this.createStore(({
+      counter
+    }) => counter));
+    _defineProperty(this, "content", () => null);
+  }
+}
+// the networked data is the one on both sides: the last server stage's, carried in the page
+export class NetworkedCountView extends app.StatefulStoreComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "store", this.createStore((context, networked) => {
+      // @ts-expect-error -- serverPost's, not serverInit's
+      void networked.userId;
+      return networked.counter;
+    }));
+    _defineProperty(this, "state", {});
+    _defineProperty(this, "content", () => null);
+  }
+}
+// the routes see either side's Init
+app.routes((reqRes, init) => {
+  const api = init.context.api;
+  const userId = init.networked.userId;
+  void api;
+  void userId;
+  // @ts-expect-error -- only the client's
+  void init.context.versions;
+  return [];
+});
+// ---- the sides are independent -----------------------------------------------
+// the client's stages need not match the server's
+serverPost.clientInit(() => ({
+  context: {
+    other: 'yes'
+  }
+}));
+clientInit.clientPost(() => ({
+  context: {
+    other: 'yes'
+  }
+}));
+// clientPost is optional: the components then see clientInit's context
+export class NoClientPostPage extends clientInit.SimpleComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "content", () => {
+      const api = this.tungsten.context.api;
+      void api;
+      return null;
+    });
+  }
+}
+clientInit.routes(() => []);
+clientInit.clientPost(init => ({
+  context: {
+    api: init.context.api
+  },
+  // @ts-expect-error -- clientPost has no networked data to give
+  networked: {}
+}));
+// @ts-expect-error -- a stage gives { context, networked }, not the context bare
+serverPost.clientInit(() => ({
+  api: new ApiClient(null)
+}));
+// @ts-expect-error -- clientPost too
+clientInit.clientPost(() => ({
+  api: new ApiClient(null)
+}));
+// ---- the chain is whole before routes and components ------------------------
+// @ts-expect-error -- no routes before the client's stages
+void serverInit.routes;
+// @ts-expect-error -- nor components
+void serverPost.SimpleComponent;
+// ---- with no serverPost, clientInit has serverInit's networked data ---------
+const initOnly = serverInit.clientInit(networked => {
+  const userId = networked.userId;
+  return {
+    context: {
+      api: new ApiClient(null)
+    },
+    networked: {
+      userId
+    }
+  };
+});
+export class InitOnlyPage extends initOnly.SimpleComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "content", () => {
+      const api = this.tungsten.context.api;
+      void api;
+      return null;
+    });
+  }
+}
+// serverInit may make only a context: clientInit then has nothing
+server.serverInit(() => ({
+  context: {
+    a: 1
+  }
+})).clientInit(networked => {
+  // @ts-expect-error -- no networked data
+  void networked.userId;
+  return {
+    context: {
+      a: 2
+    }
+  };
+});
+// ---- all-routes data: a function for each side, before Post ------------------
+const withData = serverInit.serverAllRoutesData((reqRes, init) => {
+  // the server's, before SSR, with the request
+  const typed = reqRes;
+  void typed;
+  return {
+    theme: 'dark',
+    userId: init.networked.userId
+  };
+});
+const withDataClient = withData.serverPost((reqRes, init, allRoutesData) => ({
+  context: {
+    theme: allRoutesData.theme
+  }
+})).clientInit(() => ({
+  context: {
+    versions: new VersionManager()
+  }
+}));
+// @ts-expect-error -- the client's all-routes data comes first
+void withDataClient.routes;
+// @ts-expect-error -- which gives the server's type
+withDataClient.clientAllRoutesData(() => ({
+  theme: 1,
+  userId: 1
+}));
+// the client's, before each client navigation, with the client's Init, after clientPost in the chain
+const withDataApp = withDataClient.clientPost((init, allRoutesData) => ({
+  context: {
+    theme: allRoutesData.theme
+  }
+})).clientAllRoutesData(init => {
+  const versions = init.context.versions;
+  void versions;
+  return {
+    theme: 'light',
+    userId: 2
+  };
+});
+// @ts-expect-error -- clientPost comes before the client's all-routes data
+void withDataClient.clientAllRoutesData(() => ({
+  theme: '',
+  userId: 0
+})).clientPost;
+export class ThemedPage extends withDataApp.SimpleComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "content", () => {
+      const theme = this.tungsten.allRoutesData.theme;
+      const contextTheme = this.tungsten.context.theme;
+      void theme;
+      void contextTheme;
+      return null;
+    });
+  }
+}
+// the type by name, off the stage
+const globalData = {
+  theme: 'dark',
+  userId: 1
+};
+// @ts-expect-error -- as serverAllRoutesData returned it
+const wrongGlobalData = {
+  theme: 1,
+  userId: 1
+};
+void globalData;
+void wrongGlobalData;
+// clientInit's, whichever stage it returned
+const withDataVersions = stageOf().versions;
+const clientInitResult = stageOf();
+const clientVersions = clientInitResult.context.versions;
+const clientUserId = clientInitResult.networked.userId;
+// @ts-expect-error -- the client's, not serverPost's
+void stageOf().counter;
+// serverPost's and serverInit's
+const serverCounter = stageOf().counter;
+const serverApi = stageOf().api;
+// clientPost's context alone
+const postVersions = stageOf().versions;
+// the all-routes data stage: its data, with the context before it
+const dataTheme = stageOf().theme;
+const dataApi = stageOf().api;
+void withDataVersions;
+void clientVersions;
+void clientUserId;
+void serverCounter;
+void serverApi;
+void postVersions;
+void dataTheme;
+void dataApi;
+// an earlier stage's, by name, off the last one
+const namedClientInit = stageOf();
+const namedVersions = namedClientInit.context.versions;
+const namedUserId = namedClientInit.networked.userId;
+const namedServerApi = stageOf().api;
+const namedCounter = stageOf().counter;
+const namedServerData = stageOf().theme;
+const namedClientData = stageOf().theme;
+// @ts-expect-error -- a stage this chain did not take
+void stageOf();
+// @ts-expect-error -- nor one after it
+void stageOf();
+// a branch keeps its own chain's records
+const branchContext = stageOf();
+const branchApi = branchContext.api;
+// @ts-expect-error -- initOnly's clientInit made no versions
+void branchContext.versions;
+void namedVersions;
+void namedUserId;
+void namedServerApi;
+void namedCounter;
+void namedServerData;
+void namedClientData;
+void branchApi;
+// ---- clientAfterRouting: after each client routing, the components' context ---
+const afterRouting = app.clientAfterRouting((context, route, allRoutesData) => {
+  // clientPost's context, the matched route, the all-routes data
+  const versions = context.versions;
+  const key = route.key;
+  const location = route.location;
+  void versions;
+  void key;
+  void location;
+  void allRoutesData;
+  return {
+    context: {
+      versions,
+      page: route.key
+    }
+  };
+});
+export class AfterRoutingPage extends afterRouting.SimpleComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "content", () => {
+      const context = this.tungsten.context;
+      // either the server's last context or clientAfterRouting's
+      if ('page' in context) {
+        const page = context.page;
+        void page;
+      }
+      // @ts-expect-error -- clientPost's alone is no longer what components see
+      void context.theme;
+      return null;
+    });
+  }
+}
+const afterRoutingPage = stageOf().page;
+void afterRoutingPage;
+// with no clientPost, clientInit's context
+initOnly.clientAfterRouting(context => {
+  const api = context.api;
+  return {
+    context: {
+      api
+    }
+  };
+});
+// @ts-expect-error -- a stage gives { context }, not the context bare
+app.clientAfterRouting(context => context);
+// @ts-expect-error -- and after the client's all-routes data, when there is one
+void withDataClient.clientAfterRouting;
+// @ts-expect-error -- with no server all-routes data there is no client one
+void clientInit.clientAllRoutesData;
+// @ts-expect-error -- the server's is serialized into the page
+serverInit.serverAllRoutesData(() => ({
+  when: new Date()
+}));
+// ---- what cannot cross the network ------------------------------------------
+// @ts-expect-error -- the networked data is serialized into the page
+server.serverInit(reqRes => ({
+  networked: {
+    leaked: reqRes
+  }
+}));
+// @ts-expect-error -- and so is serverPost's
+serverInit.serverPost(reqRes => ({
+  networked: {
+    leaked: reqRes
+  }
+}));
+// @ts-expect-error -- as are the values of a networked store
+serverInit.serverPost(() => ({
+  networked: {
+    store: contextStore({
+      when: new Date()
+    })
+  }
+}));
+// the context is not
+server.serverInit(reqRes => ({
+  context: {
+    reqRes,
+    store: contextStore({
+      when: new Date()
+    })
+  }
+}));
+// ---- a stage gives { context, networked }, not the context bare --------------
+// @ts-expect-error -- serverInit
+server.serverInit(() => ({
+  api: new ApiClient(null)
+}));
+// @ts-expect-error -- nor beside them
+server.serverInit(() => ({
+  context: {},
+  api: new ApiClient(null)
+}));
+// @ts-expect-error -- serverPost
+serverInit.serverPost(() => ({
+  api: new ApiClient(null)
+}));
+// nothing at all is fine
+server.serverInit(() => undefined);
+// ---- the two pipelines do not mix -------------------------------------------
+// @ts-expect-error -- the split pipeline has no init
+void server.init;
+// @ts-expect-error -- nor post
+void serverInit.post;
+// @ts-expect-error -- and serverInit comes first
+void server.clientInit;
+// @ts-expect-error -- and the other has no serverInit
+void pipeline.server('express').serverInit;
+// @ts-expect-error -- and only names a server tungsten knows
+splitPipeline.server('koa');

package/dist/pipeline/runPipeline.d.ts

@@ -0,0 +1,31 @@
+import type { BrandedContext, BrandedNetworkedData } from '../Brands.js';
+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';
+export type PipelineRouted = {
+    init: StageContext | undefined;
+    routes: RoutesWithSettings<any>;
+    allRoutesData: object;
+    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>;
+    context: (init: StageContext | undefined, post: StageContext | undefined) => object;
+    networked: (init: StageContext | undefined, post: StageContext | undefined) => object | undefined;
+};
+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: ClientRan["afterRouting"]) => InstancePipeline["afterRouting"];
+export declare function runPost(app: PipelineApp, reqRes: unknown, init: StageContext | undefined, allRoutesData: object): 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;
+}>;
+//# sourceMappingURL=runPipeline.d.ts.map

package/dist/pipeline/runPipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runPipeline.d.ts","sourceRoot":"","sources":["../../src/pipeline/runPipeline.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AACxE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAA;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAE9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAA;AACtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAe,WAAW,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAchG,MAAM,MAAM,cAAc,GAAG;IACzB,IAAI,EAAE,YAAY,GAAG,SAAS,CAAA;IAC9B,MAAM,EAAE,kBAAkB,CAAC,GAAG,CAAC,CAAA;IAC/B,aAAa,EAAE,MAAM,CAAA;IACrB,gBAAgB,EAAE,gBAAgB,CAAA;CACrC,CAAA;AAGD,MAAM,MAAM,YAAY,GAAG;IACvB,KAAK,EAAE,CACH,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EACnD,iBAAiB,EAAE,iBAAiB,GAAG,IAAI,EAAE,GAAG,EAAE,OAAO,KACxD,OAAO,CAAC,cAAc,CAAC,CAAA;IAC5B,IAAI,EAAE,CACF,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,GAAG,SAAS,EAAE,aAAa,EAAE,MAAM,KACvF,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAAA;IAEtC,OAAO,EAAE,CAAC,IAAI,EAAE,YAAY,GAAG,SAAS,EAAE,IAAI,EAAE,YAAY,GAAG,SAAS,KAAK,MAAM,CAAA;IAEnF,SAAS,EAAE,CACP,IAAI,EAAE,YAAY,GAAG,SAAS,EAAE,IAAI,EAAE,YAAY,GAAG,SAAS,KAC7D,MAAM,GAAG,SAAS,CAAA;CAC1B,CAAA;AAGD,wBAAgB,cAAc,CAC1B,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,GAAG,SAAS,EAAE,GAAG,EAAE,OAAO,2BAQlF;AAID,wBAAsB,iBAAiB,CACnC,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EACnD,iBAAiB,EAAE,iBAAiB,GAAG,IAAI,EAAE,GAAG,EAAE,OAAO,GAC1D,OAAO,CAAC,cAAc,CAAC,CAGzB;AAGD,wBAAsB,cAAc,CAChC,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EACnD,iBAAiB,EAAE,iBAAiB,GAAG,IAAI,EAAE,GAAG,EAAE,OAAO,EACzD,IAAI,EAAE,YAAY,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,GAAG,SAAS,GAC3F,OAAO,CAAC,cAAc,CAAC,CAUzB;AAID,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,GAAG,SAAS,KAAwB,cAAc,CAAA;AAChG,eAAO,MAAM,oBAAoB,GAAI,WAAW,MAAM,GAAG,SAAS,KACzC,oBAAoB,CAAA;AAG7C,eAAO,MAAM,eAAe,GACxB,KAAK,SAAS,CAAC,cAAc,CAAC,KAC/B,gBAAgB,CAAC,cAAc,CAIjC,CAAA;AAGD,wBAAsB,OAAO,CACzB,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,YAAY,GAAG,SAAS,EAAE,aAAa,EAAE,MAAM,GACzF,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAEnC;AAGD,eAAO,MAAM,eAAe,GAAI,MAAM,YAAY,GAAG,SAAS,EAAE,MAAM,YAAY,GAAG,SAAS,WACxE,CAAA;AAGtB,eAAO,MAAM,eAAe,EAAE,YAK7B,CAAA;AAID,wBAAsB,iBAAiB,CACnC,GAAG,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,GACxC,OAAO,CAAC,SAAS,GAAG;IAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC,CAWnD"}

package/dist/pipeline/runPipeline.js

@@ -0,0 +1,71 @@
+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
+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);
+  const routes = toRoutes(returned, dev);
+  const cacheControl = app.routesOptions.cacheControl;
+  return cacheControl !== undefined ? {
+    ...routes,
+    [$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 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)]);
+  return {
+    init,
+    routes,
+    allRoutesData,
+    matchedRouteInfo
+  };
+}
+// 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
+export async function runPost(app, reqRes, init, allRoutesData) {
+  return app.post?.(reqRes, init, allRoutesData);
+}
+// what this.tungsten.context reads: the last stage's context
+export const pipelineContext = (init, post) => post ?? init ?? {};
+// what the request handler runs, beside the split pipeline's
+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. The all-routes data
+// is the server's, from the page
+export async function runClientPipeline(app, allRoutesData) {
+  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
+  };
+}

package/dist/pipeline/runSplitPipeline.d.ts

@@ -0,0 +1,10 @@
+import type { ServerDataLoading } from '../Store/ServerDataLoading.js';
+import type { ClientRan, 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 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>;
+//# sourceMappingURL=runSplitPipeline.d.ts.map

package/dist/pipeline/runSplitPipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runSplitPipeline.d.ts","sourceRoot":"","sources":["../../src/pipeline/runSplitPipeline.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAA;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAClF,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAepE,wBAAsB,sBAAsB,CACxC,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EACnD,iBAAiB,EAAE,iBAAiB,GAAG,IAAI,EAAE,GAAG,EAAE,OAAO,GAC1D,OAAO,CAAC,cAAc,CAAC,CAKzB;AAGD,wBAAsB,aAAa,CAC/B,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,aAAa,EAAE,MAAM,GACnF,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAElC;AAGD,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,GAAG,SAAS,EAAE,MAAM,MAAM,GAAG,SAAS,WACvC,CAAA;AAGxC,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,GAAG,SAAS,EAAE,MAAM,MAAM,GAAG,SAAS,uBAC7C,CAAA;AAEpC,eAAO,MAAM,WAAW,EAAE,YAKzB,CAAA;AAID,wBAAsB,cAAc,CAChC,GAAG,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAC3D,OAAO,CAAC,SAAS,CAAC,CAiBpB"}

package/dist/pipeline/runSplitPipeline.js

@@ -0,0 +1,48 @@
+import { fromTransport } from './networkedTransport.js';
+import { routeAfterInit } 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
+ * networked data; the components, the last stage's context
+ */
+// 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);
+}
+// after routing, and not at all for a redirect
+export async function runServerPost(app, reqRes, init, allRoutesData) {
+  return app.serverPost?.(reqRes, asSplit(init), allRoutesData);
+}
+// what this.tungsten.context reads: the last stage's context
+export const splitContext = (init, post) => asSplit(post ?? init)?.context ?? {};
+// what goes into the page: the last server stage's networked data
+export const splitNetworked = (init, post) => asSplit(post ?? init)?.networked;
+export const splitServer = {
+  route: routeWithSplitPipeline,
+  post: runServerPost,
+  context: splitContext,
+  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) {
+  // 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))
+  };
+}