tungsten 0.7.1 → 0.8.0

package/dist/Servers/ProdServer.js

@@ -8,7 +8,7 @@ import { staticFolder, assetsFolder, packageNameCapitalized, publicFolder, compo
 import { rootToHtml as renderRootToHtml } from '../render/rootToHtml.js';
 import { contentToHtml as renderContentToHtml } from '../render/contentToHtml.js';
 import { Instance } from '../Instance/Instance.js';
-import { cliOut, cliWarn, cliLog, cliNews, cliDebug } from '../cliOutput.js';
+import { cliOut, cliWarn, cliLog, cliNews, cliDebug, cliError } from '../cliOutput.js';
 import { TungstenError } from '../TungstenError.js';
 import { makeInstanceConfigFromFrameworkConfig } from '../makeInstanceConfigFromFrameworkConfig.js';
 //import { addRequireResolveHooks } from '../reRouting/addRequireResolveHooks.js'
@@ -19,7 +19,7 @@ import { cacheVersioned } from './cacheVersioned.js';
 import { $cacheControl, cacheControlHeader, pageCacheControl } from '../cacheControl.js';
 import { routing } from "./routing.js";
 import { globalDataFunc } from '../routing/registerGlobalData.js';
-import { TungstenServer } from "./TungstenServer.js";
+import { appRoutesFor, runnerOf, TungstenServer } from "./TungstenServer.js";
 import { portError } from './portError.js';
 import { initStores } from './initStores.js';
 import { createContext } from '../context/registerContext.js';
@@ -28,8 +28,9 @@ import { makeTungstenErrorInfo } from '../routing/TungstenErrorInfo.js';
 import { responseStatus } from '../routing/MatchedRouteInfo.js';
 import { toRoutes } from '../routing/routesArray.js';
 import { listenVerified, newBootId, registerBootProbe } from './listenVerified.js';
-import { PipelineRequestHandler } from '../pipeline/PipelineRequestHandler.js';
 import { sendStub, stubInstance } from './stubInstance.js';
+import { runStep } from '../pipeline/runPipeline.js';
+import { MatchedRoute } from '../routing/MatchedRoute.js';
 function debug(...texts) {
   // console.log(...texts)
 }
@@ -58,8 +59,8 @@ export class ProdServer extends TungstenServer {
     _defineProperty(this, "apiRoutes", void 0);
     _defineProperty(this, "server", void 0);
     _defineProperty(this, "bootId", newBootId());
-    // pages: the classic handleRequest, or the pipeline's (config.registration)
-    _defineProperty(this, "requestHandler", void 0);
+    // config.registration 'pipeline': the routes module's app
+    _defineProperty(this, "pipelineApp", void 0);
     // private addServerMiddleware = (serverMiddleware: ServerMiddlewareInfo): void => {
     //     const [middlewareFile, middlewareExportName, middlewarePath] = serverMiddleware
     //     const fullFilePath = 'file://' + join(this.compilationInfo.codeLocation, middlewareFile)
@@ -98,8 +99,126 @@ export class ProdServer extends TungstenServer {
       // // else
       // res.sendStatus(404)
     });
+    // pages under config.registration 'pipeline'
+    _defineProperty(this, "handleRequestPipeline", async (req, res) => {
+      if (this.staticFileRegex.test(req.url)) {
+        cliLog(`Requested asset file ${req.url} was not found`);
+        res.status(404).end();
+        return;
+      }
+      const location = req.url;
+      const reqRes = {
+        req,
+        res
+      };
+      const instanceConfig = makeInstanceConfigFromFrameworkConfig(this.config);
+      const fileVersions = this.compilationInfo.fileVersions;
+      const app = this.pipelineApp;
+      // what the request reached, for the error page and the log
+      const progress = {};
+      try {
+        if (app === null) {
+          throwError('ProdServer', `config.registration is 'pipeline', but no pipeline app given`);
+        }
+        if (this.framework.frameworkModules === undefined) {
+          throwError('ProdServer.handleRequestPipeline()', 'framework.frameworkModules unset');
+        }
+        const Root = this.RootComponentOrNull ?? MatchedRoute;
+        if (this.config.serverSideRouting === false) {
+          const appRoutes = appRoutesFor(app, undefined, false);
+          const instance = stubInstance(location, instanceConfig, reqRes, appRoutes);
+          const html = await this.renderPipelinePage(this.stubRoot(), instance);
+          sendStub(reqRes, this.config.defaultCacheControl, html);
+          return;
+        }
+        const serverDataLoading = {
+          value: false
+        };
+        const runner = runnerOf(app);
+        const {
+          init,
+          routes,
+          allRoutesData,
+          matchedRouteInfo,
+          recoveredFrom
+        } = await runner.route(app, reqRes, location, serverDataLoading, false, progress);
+        if (this.handleRedirects(res, matchedRouteInfo, instanceConfig, allRoutesData)) return;
+        const recovered = recoveredFrom !== undefined;
+        if (recovered) {
+          const failed = (progress.failedSteps ?? []).join(', ');
+          cliLog(`handleRequestPipeline() recovered from an error in ${failed}`, recoveredFrom);
+        }
+        const post = await runStep(progress, 'Post', () => runner.post(app, reqRes, init, allRoutesData));
+        const instance = this.pipelineInstance({
+          location,
+          reqRes,
+          instanceConfig,
+          fileVersions,
+          appRoutes: appRoutesFor(app, init, false),
+          routes,
+          matchedRouteInfo,
+          serverDataLoading,
+          allRoutesData,
+          context: runner.context(init, post),
+          networked: runner.networked(init, post)
+        });
+        const html = await runStep(progress, 'render', () => this.renderPipelinePage(Root, instance));
+        // a goto() during the render has already answered with a redirect
+        if (instance.redirected !== undefined) return;
+        res.setHeader('Content-Type', 'text/html');
+        // a recovered page shows a passing failure, which no cache should keep
+        if (recovered) res.setHeader('Cache-Control', 'no-store');
+        // server middleware ran first, and a Cache-Control it set stands
+        if (res.getHeader('Cache-Control') === undefined) {
+          const key = instance.matchedRouteInfo.key;
+          const byKey = routes;
+          const cacheControl = pageCacheControl(key !== null && Object.hasOwn(routes, key) ? byKey[key] : undefined, routes[$cacheControl], this.config.defaultCacheControl, reqRes);
+          if (cacheControl !== undefined) {
+            res.setHeader('Cache-Control', cacheControlHeader(cacheControl));
+          }
+        }
+        res.status(responseStatus(instance.matchedRouteInfo));
+        res.send(html);
+      } catch (e) {
+        const failed = progress.failedSteps;
+        const steps = failed === undefined ? '' : ` (failed in ${failed.join(', ')})`;
+        cliLog(`handleRequestPipeline() error${steps}`, e);
+        // too late for an error page once a redirect has gone out
+        if (res.headersSent) return;
+        // the error's own message stays on the server
+        const errorPage = this.pipelineErrorPage(app ?? undefined, progress, e, {
+          location,
+          reqRes,
+          instanceConfig,
+          fileVersions
+        }, 'server error');
+        let html;
+        if (errorPage !== undefined) {
+          const {
+            ErrorPage,
+            instance,
+            errorInfo
+          } = errorPage;
+          try {
+            html = await this.renderPipelinePage(ErrorPage, instance, errorInfo);
+          } catch (renderError) {
+            cliError('Error rendering the app\'s error page, falling back to the default one');
+            cliLog(renderError);
+          }
+        }
+        res.setHeader('Content-Type', 'text/html');
+        res.status(500);
+        res.send(html ?? this.errorPage());
+      }
+    });
+    _defineProperty(this, "renderPipelinePage", async (Root, instance, props) => {
+      if (this.framework.clientImportAliases === undefined) {
+        throwError('ProdServer', 'framework.clientImportAliases is undefined');
+      }
+      return renderRootToHtml(this.compilationInfo, this.framework.clientImportAliases, Root, instance, this.config, this.config.siteBasePath, undefined, false, props);
+    });
     _defineProperty(this, "handleRequest", async (req, res) => {
-      if (/\.(css|scss|sass|js|jsx|png|jpg|jpeg|svg|ico|txt)$/.test(req.url)) {
+      if (this.staticFileRegex.test(req.url)) {
         cliLog(`Requested asset file ${req.url} was not found`);
         res.status(404).end();
         return;
@@ -159,10 +278,12 @@ export class ProdServer extends TungstenServer {
         const networkedData = createNetworkedData(reqRes, context);
         capturedNetworkedData = networkedData;
         const routes = toRoutes(typeof appRoutes === 'function' ? appRoutes(reqRes, context, networkedData) : appRoutes, false);
-        const [globalData, matchedRouteInfo] = await Promise.all([globalDataFunc.value !== undefined ? globalDataFunc.value(reqRes, context, networkedData).then(globalData => {
-          capturedGlobalData = globalData;
-          return globalData;
-        }) : {}, routing(location, routes, context, networkedData, serverDataLoading)]);
+        const [globalData, matchedRouteInfo] = await Promise.all([globalDataFunc.value !== undefined ? globalDataFunc.value(reqRes, context, networkedData, location).then(data => {
+          capturedGlobalData = data;
+          return data;
+        }) : {},
+        // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+        routing(location, routes, context, networkedData, serverDataLoading)]);
         //instance.matchedRouteInfo = 
         //cliTodo('Can we move redirect handling to base class?')
         // // 2025-03-14 copied this code here from Dev server,
@@ -181,7 +302,7 @@ export class ProdServer extends TungstenServer {
         //     res.redirect(code, to)
         //     return
         // }
-        const redirected = this.handleRedirects(res, matchedRouteInfo);
+        const redirected = this.handleRedirects(res, matchedRouteInfo, instanceConfig, globalData);
         if (redirected) return; // end early
         const {
           internalStore,
@@ -228,6 +349,8 @@ export class ProdServer extends TungstenServer {
         if (res.headersSent) return;
         const errorRouteHtml = await this.tryRenderErrorRoute(req, res, capturedGlobalData, capturedContext, capturedNetworkedData, e);
         res.setHeader('Content-Type', 'text/html');
+        // a failure, which no cache should keep - as the pipeline path's recovered pages
+        res.setHeader('Cache-Control', 'no-store');
         res.status(500);
         res.send(errorRouteHtml ?? this.errorPage());
       }
@@ -409,29 +532,8 @@ export class ProdServer extends TungstenServer {
       this.app.use(apiPath, express.json());
       this.app.use(apiPath, this.handleRequestApi);
     }
-    this.requestHandler = _config.registration === 'pipeline' ? new PipelineRequestHandler({
-      dev: false,
-      config: _config,
-      instanceConfig: () => makeInstanceConfigFromFrameworkConfig(this.config),
-      fileVersions: this.compilationInfo.fileVersions,
-      loadApp: async () => {
-        if (pipelineApp === null) {
-          throwError('ProdServer', `config.registration is 'pipeline', but no pipeline app was given`);
-        }
-        return Promise.resolve({
-          Root: this.RootComponentOrNull,
-          app: pipelineApp
-        });
-      },
-      render: async (Root, instance) => {
-        if (this.framework.clientImportAliases === undefined) {
-          throwError('ProdServer', 'framework.clientImportAliases is undefined');
-        }
-        return renderRootToHtml(this.compilationInfo, this.framework.clientImportAliases, Root, instance, this.config, this.config.siteBasePath);
-      },
-      errorPage: () => this.errorPage()
-    }).handle : this.handleRequest;
-    this.app.use(this.requestHandler);
+    this.pipelineApp = pipelineApp;
+    this.app.use(_config.registration === 'pipeline' ? this.handleRequestPipeline : this.handleRequest);
   }
   // private async handlePost(req: express.Request, res: express.Response): Promise<void> {
   //     throw new TungstenError(`Err - Dev server received a post request. Not supported yet.`)

package/dist/Servers/TungstenServer.d.ts

@@ -1,9 +1,42 @@
 import type { Response as ExpressResponse } from 'express';
+import type { AnyComponentType } from '../AnyComponentType.js';
+import type { InstanceConfig } from '../Instance/InstanceConfig.js';
+import type { PipelineApp, StageContext } from '../pipeline/pipelineDefinition.js';
+import type { RequestProgress } from '../pipeline/runPipeline.js';
+import type { ReqRes } from '../ReqRes.js';
+import type { AppRoutes } from '../routing/AppRoutes.js';
 import type { MatchedRouteInfo } from '../routing/MatchedRouteInfo.js';
+import type { Routes } from '../routing/Routes.js';
+import type { TungstenErrorInfo } from '../routing/TungstenErrorInfo.js';
+import type { ServerDataLoading } from '../Store/ServerDataLoading.js';
+import { Instance } from '../Instance/Instance.js';
+export type PipelinePage = {
+    location: string;
+    reqRes: ReqRes;
+    instanceConfig: InstanceConfig;
+    fileVersions: Record<string, string> | undefined;
+    appRoutes: AppRoutes<any>;
+    routes: Routes<any>;
+    matchedRouteInfo: MatchedRouteInfo;
+    serverDataLoading: ServerDataLoading;
+    allRoutesData: unknown;
+    context: object;
+    networked: object | undefined;
+};
+export type PipelineErrorPage = {
+    ErrorPage: AnyComponentType;
+    instance: Instance;
+    errorInfo: TungstenErrorInfo;
+};
 export declare class TungstenServer {
+    protected staticFileRegex: RegExp;
     protected makeOrigin(proto: string, host: string, port: number): string;
     protected arrivedAt(host: string, proto: string): string;
     protected hostOfOrigin(origin: string): string | null;
-    protected handleRedirects(res: ExpressResponse, matchedRouteInfo: MatchedRouteInfo): boolean;
+    protected handleRedirects(res: ExpressResponse, matchedRouteInfo: MatchedRouteInfo, config: Pick<InstanceConfig, 'siteBasePath' | 'staticSite'>, allRoutesData?: unknown): boolean;
+    protected pipelineInstance(page: PipelinePage): Instance;
+    protected pipelineErrorPage(app: PipelineApp | undefined, progress: RequestProgress, error: unknown, page: Pick<PipelinePage, 'location' | 'reqRes' | 'instanceConfig' | 'fileVersions'>, message?: string): PipelineErrorPage | undefined;
 }
+export declare const runnerOf: (app: PipelineApp) => import("../pipeline/runPipeline.js").ServerRunner;
+export declare const appRoutesFor: (app: PipelineApp, init: StageContext | undefined, dev: boolean) => AppRoutes<any>;
 //# sourceMappingURL=TungstenServer.d.ts.map

package/dist/Servers/TungstenServer.js

@@ -1,14 +1,24 @@
-import { ContentNodeIsClassComponent } from '../ContentNode.js';
+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 { Instance } from '../Instance/Instance.js';
+import { isProd } from '../isProd.js';
+import { NetworkedTransport } from '../pipeline/networkedTransport.js';
+import { pipelineRoutes, symmetricServer } from '../pipeline/runPipeline.js';
+import { splitServer } from '../pipeline/runSplitPipeline.js';
+import { redirectOf } from '../routing/redirectOf.js';
+import { routeKeyToUrl } from '../routing/routeUrl.js';
 import { RoutingRedirect } from '../routing/RoutingRedirect.js';
-import { cliTodo } from '../cliOutput.js';
-import { RouteRedirectComponent } from "../components/RouteRedirectComponent.js";
-import { WebRedirectComponent } from "../components/WebRedirectComponent.js";
-import { $props, $type } from '../contentNodeSymbols.js';
+import { makeTungstenErrorInfo } from '../routing/TungstenErrorInfo.js';
 import { WebRedirect } from '../routing/WebRedirect.js';
+import { initStores } from './initStores.js';
 function debug(...texts) {
   // console.log(...texts)
 }
 export class TungstenServer {
+  constructor() {
+    _defineProperty(this, "staticFileRegex", /\.(css|scss|sass|js|jsx|png|jpg|jpeg|svg|ico|txt)$/);
+  }
   // URL drops the port when it is the scheme's default, so http://x:80 -> http://x, https://x:443
   // -> https://x, and anything else keeps it. Throws on a host it cannot parse
   makeOrigin(proto, host, port) {
@@ -29,41 +39,83 @@ export class TungstenServer {
       return null;
     }
   }
-  handleRedirects(res, matchedRouteInfo) {
-    // handle any redirect issued during routing
-    if (matchedRouteInfo.data instanceof RoutingRedirect) {
-      const redirect = matchedRouteInfo.data;
-      res.redirect(redirect.code, redirect.to);
-      return true;
-    } else if (matchedRouteInfo.data instanceof WebRedirect) {
-      const redirect = matchedRouteInfo.data;
-      res.redirect(redirect.code, redirect.to);
-      return true;
-    }
-    // console.log('content', matchedRouteInfo.content)
-    // console.log('is func', typeof matchedRouteInfo.content !== 'function')
-    // console.log('ContentNodeIsClassComponent', ContentNodeIsClassComponent(matchedRouteInfo.content as any))
-    // console.log('instanceof', (matchedRouteInfo as any).content[$type] instanceof RedirectComponent)
-    // console.log('prototype instanceof', (matchedRouteInfo as any).content[$type].prototype instanceof RedirectComponent)
-    // console.log('__tungstenRedirect', (matchedRouteInfo as any).content[$type].__tungstenRedirect)
-    // console.log('$type', (matchedRouteInfo as any).content[$type])
-    //console.log('content[$type]', matchedRouteInfo.content[$type])
-    //console.log('instanceof', matchedRouteInfo.content instanceof RedirectComponent)
-    if (typeof matchedRouteInfo.content !== 'function' && ContentNodeIsClassComponent(matchedRouteInfo.content)) {
-      if (matchedRouteInfo.content[$type] === RouteRedirectComponent || matchedRouteInfo.content[$type].prototype instanceof RouteRedirectComponent) {
-        cliTodo('consider type of RedirectComponent props');
-        const code = matchedRouteInfo.content[$props].code || 302;
-        const to = matchedRouteInfo.content[$props].to;
-        res.redirect(code, to);
-        return true;
-      } else if (matchedRouteInfo.content[$type] === WebRedirectComponent || matchedRouteInfo.content[$type].prototype instanceof WebRedirectComponent) {
-        cliTodo('consider type of RedirectComponent props');
-        const code = matchedRouteInfo.content[$props].code || 302;
-        const to = matchedRouteInfo.content[$props].to;
-        res.redirect(code, to);
-        return true;
-      }
-    }
-    return false;
+  // config: the instance's, so a route redirect goes where the instance's goto() would.
+  // allRoutesData: the pipeline's, whose redirect wins over the route's
+  handleRedirects(res, matchedRouteInfo, config, allRoutesData) {
+    const redirection = redirectOf(matchedRouteInfo, allRoutesData);
+    if (redirection === undefined) return false;
+    const url = 'route' in redirection ? routeKeyToUrl(redirection.route, config.siteBasePath, isProd && config.staticSite) : redirection.url;
+    res.redirect(redirection.code ?? 302, url);
+    return true;
   }
-}
+  // a pipeline page's instance, from what its stages made
+  pipelineInstance(page) {
+    const {
+      location,
+      reqRes,
+      matchedRouteInfo,
+      serverDataLoading,
+      routes
+    } = page;
+    // processHead writes it into the page; the stores synced after routing are read now
+    const transport = new NetworkedTransport(page.networked);
+    transport.snapshotAfterRouting();
+    // the framework brands what it builds
+    const context = page.context; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+    const globalData = page.allRoutesData; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+    const networkedData = transport; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+    const {
+      internalStore,
+      stores,
+      storeSubscriptions
+    } = initStores(location, reqRes, globalData, matchedRouteInfo, serverDataLoading, context, networkedData);
+    const instance = new Instance(location, page.instanceConfig, reqRes, page.appRoutes, routes, internalStore, stores, storeSubscriptions, globalData, matchedRouteInfo);
+    instance.fileVersions = page.fileVersions;
+    instance.context = context;
+    instance.networkedData = networkedData;
+    instance.pipelineNetworked = page.networked ?? {};
+    return instance;
+  }
+  // The app's error page, the whole document, with what Init made - Post never ran - and the
+  // all-routes data if it came. Undefined when there is none, or Init never finished.
+  // message: shown in place of the error's own, which may hold what the browser should not see
+  pipelineErrorPage(app, progress, error, page, message) {
+    const ErrorPage = app?.errorPage;
+    if (app === undefined || ErrorPage === undefined) return undefined;
+    if (progress.init === undefined) return undefined;
+    const runner = runnerOf(app);
+    const init = progress.init.value;
+    const data = progress.allRoutesData;
+    const redirect = data instanceof RoutingRedirect || data instanceof WebRedirect;
+    const errorInfo = message === undefined ? makeTungstenErrorInfo(error) : {
+      error,
+      message
+    };
+    const routes = {}; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion -- nothing routes from the error page
+    const instance = this.pipelineInstance({
+      ...page,
+      appRoutes: routes,
+      routes,
+      serverDataLoading: {
+        value: false
+      },
+      matchedRouteInfo: {
+        key: null,
+        params: {},
+        content: null
+      },
+      allRoutesData: redirect ? undefined : data,
+      context: runner.context(init, undefined),
+      networked: runner.networked(init, undefined)
+    });
+    instance.errorInfo = errorInfo;
+    return {
+      ErrorPage,
+      instance,
+      errorInfo
+    };
+  }
+}
+export const runnerOf = app => app.split === true ? splitServer : symmetricServer;
+// what the instance calls for its routes: the pipeline's, with this request's Init
+export const appRoutesFor = (app, init, dev) => reqRes => pipelineRoutes(app, reqRes, init, dev);

package/dist/Servers/loadEnvsDev.js

@@ -81,8 +81,8 @@ buildCodeFolder) {
       // eslint-disable-line @stylistic/max-len
       '\n' + coreResult.problems + '\nenv: ' + JSONstringify(tempEnv, null, 4));
     }
-    global.tungstenPrivateEnv = coreResult.value;
-    //console.log('global.tungstenPrivateEnv', global.tungstenPrivateEnv)
+    globalThis.tungstenPrivateEnv = coreResult.value;
+    //console.log('globalThis.tungstenPrivateEnv', globalThis.tungstenPrivateEnv)
     if (_firstLoad) cliOut('tungsten private env loaded and passed schema validation'); // save this so that we can show all messages about loading .env files first
   }
   if ('publicEnvSchema' in envSchemas) {
@@ -103,8 +103,8 @@ buildCodeFolder) {
       // eslint-disable-line @stylistic/max-len
       '\n' + coreResult.problems + '\npublic env: ' + JSONstringify(tempPublicEnv, null, 4));
     }
-    global.tungstenPublicEnv = coreResult.value;
-    //console.log('global.tungstenPublicEnv', global.tungstenPublicEnv)
+    globalThis.tungstenPublicEnv = coreResult.value;
+    //console.log('globalThis.tungstenPublicEnv', globalThis.tungstenPublicEnv)
     if (_firstLoad) cliOut('tungsten public env loaded and passed schema validation'); // save this so that we can show all messages about loading .env files first
   }
 }

package/dist/Servers/watchedServerMiddleware.d.ts

@@ -0,0 +1,10 @@
+import { type RequestHandler } from 'express';
+import type { ModuleNamespace } from '../importModule.js';
+export type WatchedServerMiddleware = {
+    handler: RequestHandler;
+    ready: Promise<void>;
+    close: () => Promise<void>;
+};
+export declare function watchedServerMiddleware(load: () => Promise<readonly RequestHandler[]>, watched: string, ignored: string[]): WatchedServerMiddleware;
+export declare function middlewaresExport(module: ModuleNamespace, exportName: string, file: string): readonly RequestHandler[];
+//# sourceMappingURL=watchedServerMiddleware.d.ts.map

package/dist/Servers/watchedServerMiddleware.js

@@ -0,0 +1,45 @@
+import express from 'express';
+import chokidar from 'chokidar';
+import { throwError } from '../throwError.js';
+export function watchedServerMiddleware(load, watched, ignored) {
+  let current = null;
+  const watcher = chokidar.watch(watched, {
+    ignored,
+    ignoreInitial: true
+  });
+  // any change may be in the middleware's imports, so the next request loads it afresh
+  watcher.on('all', () => {
+    current = null;
+  });
+  const ready = new Promise(resolve => watcher.once('ready', () => resolve()));
+  const loaded = () => current ??= load().then(middlewares => express.Router().use([...middlewares]));
+  const handler = (req, res, next) => {
+    const attempt = loaded();
+    void attempt.then(router => {
+      router(req, res, next);
+    }, e => {
+      // a failed load isn't kept: the next request tries again
+      if (current === attempt) current = null;
+      next(e);
+    });
+  };
+  return {
+    handler,
+    ready,
+    close: () => watcher.close()
+  };
+}
+// the middleware export of a server middleware module, checked
+export function middlewaresExport(module, exportName, file) {
+  if (!(exportName in module)) {
+    throwError('serverMiddleware', `export ${exportName} not found in ${file}`);
+  }
+  const middlewares = module[exportName];
+  if (!Array.isArray(middlewares) || middlewares.length === 0) {
+    throwError('serverMiddleware', `${exportName} in ${file} must be a non-empty array of middleware`);
+  }
+  if (!middlewares.every(m => typeof m === 'function')) {
+    throwError('serverMiddleware', `every entry of ${exportName} in ${file} must be a function`);
+  }
+  return middlewares; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion -- checked above
+}

package/dist/TungstenApp.js

@@ -1,7 +1,8 @@
 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); }
-/// WIP
+/// Unused
+/// probably fails due to recursive dependency
 import { cliLog } from './cliOutput.js';
 import { Framework } from './Framework.js';
 import { throwError } from './throwError.js';

package/dist/_client/cjsHelpers.d.ts

@@ -7,5 +7,5 @@ declare global {
         }>;
     }
 }
-export declare function loadDeps(deps: string[]): Promise<Record<string, JsonValue | Module>>;
+export declare function loadDeps(deps: string[]): Promise<Record<string, Module | JsonValue>>;
 //# sourceMappingURL=cjsHelpers.d.ts.map

package/dist/_client/hmr.js

@@ -36,7 +36,7 @@ es.addEventListener('css', () => {
 es.addEventListener('js', ev => {
   let payload;
   try {
-    payload = JSON.parse(ev.data);
+    payload = JSON.parse(ev.data); // eslint-disable-line no-restricted-properties -- served verbatim: it can't import json.ts
   } catch {
     fullReload('bad payload');
     return;

package/dist/_client/liveReloadSource.js

@@ -2,7 +2,7 @@
 // into the app's .client folder by createClientFiles and served from there, outside the traced
 // module graph - see the note atop hmr.ts for why that matters.
 function bootIdOf(data) {
-  const payload = JSON.parse(data);
+  const payload = JSON.parse(data); // eslint-disable-line no-restricted-properties -- served verbatim: it can't import json.ts
   if (typeof payload !== 'object' || payload === null || !('bootId' in payload)) return undefined;
   return typeof payload.bootId === 'string' ? payload.bootId : undefined;
 }

package/dist/_testing/errorRoute.d.ts

@@ -0,0 +1,8 @@
+export declare const errorEndpoint: {
+    content: () => null;
+};
+export declare const errorRoute: {
+    readonly content: () => null;
+    readonly path: 'error';
+};
+//# sourceMappingURL=errorRoute.d.ts.map

package/dist/_testing/errorRoute.js

@@ -0,0 +1,9 @@
+// A pipeline needs an 'error' route. For a test with no failure to show: `errorRoute` in the
+// array form, `error: errorEndpoint` in the object form
+export const errorEndpoint = {
+  content: () => null
+};
+export const errorRoute = {
+  path: 'error',
+  ...errorEndpoint
+};

package/dist/appBuilder.d.ts

@@ -5,6 +5,7 @@ import type { MatchedRouteInfo } from './routing/MatchedRouteInfo.js';
 import type { RoutesWithSettings } from './routing/Routes.js';
 import type { NoDuplicatePaths, RoutesArray } from './routing/routesArray.js';
 import type { Serializable } from './routing/Serializable.js';
+import type { DataRedirect } from './routing/DataRedirect.js';
 import type { TrueStore } from './Store/makeStore.js';
 import type { Instance } from './Instance/Instance.js';
 import { TungstenBaseSimpleStoreComponent, TungstenBaseStatefulStoreComponent, TungstenSignalsComponent, TungstenSimpleComponent, TungstenStatefulComponent } from './Components.jsx';
@@ -45,7 +46,7 @@ type ContextArg<C> = (new (reqRes: ReqResOrNull) => C) | {
     server: new (reqRes: ReqRes) => C;
 };
 type NetworkedDataArg<C, ND> = (new (reqRes: ReqResOrNull, context: C) => ND) & (new (reqRes: ReqResOrNull, context: C) => Serializable<NoInfer<ND>>);
-type GlobalDataArg<C, ND, G> = ((reqRes: ReqResOrNull, context: C, networkedData: ND) => Promise<G>) & ((reqRes: ReqResOrNull, context: C, networkedData: ND) => Promise<Serializable<NoInfer<G>>>);
+type GlobalDataArg<C, ND, G> = ((reqRes: ReqResOrNull, context: C, networkedData: ND, location: string) => Promise<G | DataRedirect>) & ((reqRes: ReqResOrNull, context: C, networkedData: ND, location: string) => Promise<Serializable<NoInfer<G>> | DataRedirect>);
 type StoreArg<C, ND, G, St> = new (reqRes: ReqResOrNull, context: C, networkedData: ND, globalData: G, matchedRouteInfo: MatchedRouteInfo) => St;
 type RoutesArg<C, ND, G extends object> = RoutesWithSettings<G> | RoutesArray<G> | ((reqRes: ReqResOrNull, context: C, networkedData: ND) => RoutesWithSettings<G> | RoutesArray<G> | []);
 export type AppStage<C extends object, ND extends object, G extends object, St extends object | undefined> = {

package/dist/babelPlugins/BabelTransformComponentStyles.js

@@ -21,6 +21,7 @@ import { CssNames } from '../CssNames.js';
 import { watch } from '../watch.js';
 import slash from '../slash.js';
 import { fixImportsInSassErrorMessage } from './fixImportsInSassErrorMessage.js';
+import { StyleCompileError } from './StyleCompileError.js';
 import { throwError } from '../throwError.js';
 import { tallied } from '../timeProfiler.js';
 import { makeComponentStylesCache } from '../build/componentStylesCache.js';
@@ -111,8 +112,9 @@ function sassScssToCss(data, fullFile, fullSourceFile, importBase, syntax) {
     if (foundImportError) {
       errorOut(`Tungsten uses modified import resolution for SASS. Relative imports must start with ./ or ../`);
     }
-    e.message = message;
-    throw e;
+    throw new StyleCompileError(message, {
+      cause: e
+    });
   }
   const {
     css
@@ -283,7 +285,7 @@ export function MakeBabelTransformComponentStyles(opts) {
     // a single part and every module name collapsed to its bare filename —
     // platform-dependent class names, and two components sharing a filename
     // scoped identically.
-    const parts = relFilePath.split('/');
+    const parts = [...relFilePath.split('/')];
     if (name === 'index') {
       parts.pop();
     } else {

package/dist/babelPlugins/BabelTransformPackageImports.js

@@ -717,7 +717,9 @@ export function MakeBabelTransformPackageImports(opts) {
         reexports
       } = lexerParse(code);
       //console.log('lexInner exports', exports)
-      const exportsMap = mapToObject(exports, value => [value, true]);
+      const exportsMap = {
+        ...mapToObject(exports, value => [value, true])
+      };
       //console.log('lexInner exports map', exportsMap)
       for (const re of reexports) {
         try {

package/dist/babelPlugins/StyleCompileError.d.ts

@@ -0,0 +1,4 @@
+export declare class StyleCompileError extends Error {
+    name: string;
+}
+//# sourceMappingURL=StyleCompileError.d.ts.map

package/dist/babelPlugins/StyleCompileError.js

@@ -0,0 +1,11 @@
+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); }
+// a component's styles failed to compile: the message names the file, line and problem, so the
+// report prints it alone - the stack is the compiler's, not the app's
+export class StyleCompileError extends Error {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "name", 'StyleCompileError');
+  }
+}