tungsten 0.7.0 → 0.7.2

package/dist/testing/pipeline/createTestPacketApp.js

@@ -0,0 +1,45 @@
+import { isPipelineApp } from '../../pipeline/pipelineDefinition.js';
+import { routingNetworkedData } from '../../pipeline/runPipeline.js';
+import { routing } from "../../Servers/routing.js";
+import { toRoutes } from '../../routing/routesArray.js';
+import { waitForEnvIfLoading } from '../loadEnv.js';
+import { mountPipelineTestApp, pipelineTestTarget } from './pipelineTestApp.js';
+/**
+ * createTestPipelineApp() with the pipeline's result in place of the pipeline: the component is
+ * handed the packet's context, networked data and all-routes data as they are, with no stages run.
+ * There are no routes; the location still reaches the instance.
+ */
+export async function createTestPacketApp(packet,
+// Props is inferred from both the class and `props`, so literal props are typed by the component
+RootComponent, ...args) {
+  await waitForEnvIfLoading();
+  const options = args[0];
+  if (isPipelineApp(packet) || typeof packet === 'object' && 'routes' in packet) {
+    throw new Error('createTestPacketApp() takes what a pipeline makes, { context, networked,' + ' allRoutesData }: for a pipeline or app, use createTestPipelineApp().');
+  }
+  const target = pipelineTestTarget(options, 'createTestPacketApp()');
+  const given = packet; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion -- the constraint above
+  const location = options?.location ?? '/';
+  const context = given.context ?? {}; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion -- the framework brands what it builds
+  const allRoutesData = given.allRoutesData; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion -- as above
+  const networkedData = routingNetworkedData(undefined);
+  const routes = toRoutes([], true);
+  const matchedRouteInfo = await routing(location, routes, context, networkedData);
+  return mountPipelineTestApp(target, {
+    location,
+    routes,
+    matchedRouteInfo,
+    allRoutesData,
+    context,
+    networkedData,
+    appRoutes: () => routes,
+    networked: given.networked ?? {},
+    // a navigation keeps the packet's all-routes data
+    pipeline: {
+      routingContext: context,
+      routingNetworkedData: networkedData,
+      allRoutesData: undefined,
+      afterRouting: undefined
+    }
+  }, RootComponent, options);
+}

package/dist/testing/pipeline/createTestPipelineApp.d.ts

@@ -0,0 +1,70 @@
+import type { ConstructPackage, TungstenBaseComponent, TungstenComponentPropsBase } from '../../Components.jsx';
+import type { AllRoutesDataConstraint, PipelineApp } from '../../pipeline/pipelineDefinition.js';
+import type { TestApp } from '../createTestApp.js';
+import type { PipelineTestAppOptions } from './pipelineTestApp.js';
+type StageForApp<App> = {
+    routes: (routes: () => []) => App;
+};
+type AppOf<A> = A extends PipelineApp<any, any, any, any> ? A : A extends StageForApp<infer App> ? App : never;
+type AppTypes<A> = AppOf<A> extends PipelineApp<any, infer Ctx, infer N, infer G extends AllRoutesDataConstraint> ? {
+    context: Ctx;
+    networked: N & object;
+    allRoutesData: G;
+} : never;
+export type PipelineAppForComponent<C> = C extends {
+    readonly tungsten: {
+        readonly context: infer Ctx;
+        readonly networked: infer N;
+        readonly allRoutesData: infer G;
+    };
+} ? PipelineApp<any, Ctx, N, G> : 'invalid component';
+export type PipelineForComponent<C> = PipelineAppForComponent<C> extends infer App ? App extends PipelineApp<any, any, any, any> ? StageForApp<App> : App : never;
+type ComponentReads<C> = C extends {
+    readonly tungsten: {
+        readonly context: infer Ctx;
+        readonly networked: infer N;
+        readonly allRoutesData: infer G;
+    };
+} ? {
+    context: Ctx;
+    networked: N;
+    allRoutesData: G;
+} : never;
+type DifferingKeys<Made, Read> = {
+    [K in keyof Made & keyof Read]: [Made[K]] extends [Read[K]] ? never : K;
+}[keyof Made & keyof Read];
+type Mismatch<Made, Read> = [DifferingKeys<Made, Read>] extends [never] ? unknown : DifferingKeys<Made, Read> extends infer Ks extends keyof Made & keyof Read ? {
+    'pipeline does not provide required data:': {
+        [K in Ks]: Read[K];
+    };
+    'pipeline provided:': {
+        [K in Ks]: Made[K];
+    };
+} : never;
+export type AppCheck<A, C> = [AppOf<A>] extends [never] ? A extends {
+    clientAllRoutesData: unknown;
+} ? {
+    'add .clientAllRoutesData(): the server makes all-routes data, so the client must': true;
+} : {
+    'not a .routes() app, or a stage .routes() can follow': true;
+} : [ComponentReads<C>] extends [never] ? {
+    'not a tungsten component': true;
+} : Mismatch<AppTypes<A>, ComponentReads<C>>;
+export declare const toApp: (pipelineOrApp: unknown) => PipelineApp;
+export type TestPipelineAppOptions<Props extends object, A = PipelineApp> = PipelineTestAppOptions<Props> & {
+    allRoutesData?: AppTypes<A>['allRoutesData'];
+    networked?: AppTypes<A>['networked'];
+};
+export type TestPipelineApp<Component extends TungstenBaseComponent> = TestApp<Component>;
+export type CreateTestPipelineAppArgs<Props extends object, A = PipelineApp> = object extends Props ? [options?: TestPipelineAppOptions<Props, A>] : [options: TestPipelineAppOptions<Props, A> & {
+    props: Props;
+}];
+/**
+ * createTestApp() for an app built with pipeline() or splitPipeline(): the app's browser stages
+ * run - Init, the all-routes data, Post - and the location is routed against its routes, so the
+ * test sees the context, stores and route the app's own page would. The app is a .routes()
+ * result: the app's own export, a smaller set of routes on the same pipeline, or another pipeline.
+ */
+export declare function createTestPipelineApp<Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>, A extends object, RouteData = undefined>(pipelineOrApp: A & AppCheck<A, Component>, RootComponent: new (pkg: ConstructPackage<Props, RouteData>) => Component, ...args: CreateTestPipelineAppArgs<Props, A>): Promise<TestPipelineApp<Component>>;
+export {};
+//# sourceMappingURL=createTestPipelineApp.d.ts.map

package/dist/testing/pipeline/createTestPipelineApp.js

@@ -0,0 +1,90 @@
+import { clientRoute, isPipelineApp } from '../../pipeline/pipelineDefinition.js';
+import { JSONstringify } from '../../json.js';
+import { routing } from "../../Servers/routing.js";
+import { fromTransport, NetworkedTransport } from '../../pipeline/networkedTransport.js';
+import { afterRoutingFor, pipelineContext, pipelineRoutes, routingContext, routingNetworkedData } from '../../pipeline/runPipeline.js';
+import { splitContext } from '../../pipeline/runSplitPipeline.js';
+import { waitForEnvIfLoading } from '../loadEnv.js';
+import { mountPipelineTestApp, pipelineTestTarget } from './pipelineTestApp.js';
+// the app, or the stage ended with empty routes
+export const toApp = pipelineOrApp => isPipelineApp(pipelineOrApp) ? pipelineOrApp : pipelineOrApp.routes(() => []); // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion -- the harnesses' constraint: a stage
+// the symmetric pipeline's stages, with null for the request
+async function runSymmetric(app, allRoutesData) {
+  const init = await app.init?.(null, undefined);
+  const data = allRoutesData ?? (await app.allRoutesData?.(null, init));
+  const post = await app.post?.(null, init, data);
+  const rerun = app.allRoutesData;
+  return {
+    init,
+    context: pipelineContext(init, post),
+    routingContext: init,
+    routingNetworkedData: undefined,
+    networked: {},
+    allRoutesData: data,
+    rerunAllRoutesData: rerun && (async () => rerun(null, init)),
+    afterRouting: undefined
+  };
+}
+async function runSplit(app, allRoutesData, served) {
+  const page = JSON.parse(JSONstringify(new NetworkedTransport(served))); // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion -- toJSON gives an object
+  const networked = fromTransport(page) ?? {};
+  const init = await app.clientInit?.(networked);
+  const data = allRoutesData ?? (await app.clientAllRoutesData?.(init));
+  const post = await app.clientPost?.(init, data);
+  const context = splitContext(init, post);
+  const rerun = app.clientAllRoutesData;
+  const afterRouting = app.clientAfterRouting;
+  return {
+    init,
+    context,
+    routingContext: init?.context,
+    routingNetworkedData: init?.networked,
+    networked,
+    allRoutesData: data,
+    rerunAllRoutesData: rerun && (async () => rerun(init)),
+    afterRouting: afterRouting && (async (route, allRoutes) => splitContext(await afterRouting(context, route, allRoutes), undefined))
+  };
+}
+/**
+ * createTestApp() for an app built with pipeline() or splitPipeline(): the app's browser stages
+ * run - Init, the all-routes data, Post - and the location is routed against its routes, so the
+ * test sees the context, stores and route the app's own page would. The app is a .routes()
+ * result: the app's own export, a smaller set of routes on the same pipeline, or another pipeline.
+ */
+export async function createTestPipelineApp(pipelineOrApp,
+// Props is inferred from both the class and `props`, so literal props are typed by the component
+RootComponent, ...args) {
+  await waitForEnvIfLoading();
+  const options = args[0];
+  const target = pipelineTestTarget(options, 'createTestPipelineApp()');
+  const app = toApp(pipelineOrApp);
+  const stages = app.split === true ? await runSplit(app, options?.allRoutesData, options?.networked ?? {}) : await runSymmetric(app, options?.allRoutesData);
+  const location = options?.location ?? '/';
+  const allRoutesData = stages.allRoutesData; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion -- the framework brands what it builds
+  const routeContext = routingContext(stages.routingContext);
+  const networkedData = routingNetworkedData(stages.routingNetworkedData);
+  // dev, so a path given twice fails the test
+  const routes = pipelineRoutes(app, null, stages.init, true);
+  const matchedRouteInfo = await routing(location, routes, routeContext, networkedData);
+  const afterRouting = afterRoutingFor(stages.afterRouting);
+  const context = afterRouting === undefined ? stages.context // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion -- as above
+  : await afterRouting(clientRoute(matchedRouteInfo, location), allRoutesData);
+  const rerun = stages.rerunAllRoutesData;
+  return mountPipelineTestApp(target, {
+    location,
+    routes,
+    matchedRouteInfo,
+    allRoutesData,
+    context,
+    networkedData,
+    appRoutes: reqRes => pipelineRoutes(app, reqRes, stages.init, true),
+    networked: stages.networked,
+    pipeline: {
+      routingContext: routeContext,
+      routingNetworkedData: networkedData,
+      allRoutesData: rerun && (async () => await rerun()),
+      // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion -- as above
+      afterRouting
+    }
+  }, RootComponent, options);
+}

package/dist/testing/pipeline/hostPipeline.d.ts

@@ -0,0 +1,25 @@
+import type { TungstenBaseComponent, TungstenComponentClass, TungstenComponentPropsBase } from '../../Components.jsx';
+import type { ContentNodeElement } from '../../ContentNode.js';
+import type { AppDataOptions, DontResolve, Hosted, HostedResolved, Resolve, ResolveOption, RouteOptions } from '../host.js';
+export type { ComponentApi, Hosted, HostedResolved, HostedRoute, HostStoreOptions, Navigation, StateSetter, } from '../host.js';
+export type HostPipelineOptions = RouteOptions & ResolveOption & AppDataOptions;
+export type HostPipelineResolveOptions = RouteOptions & AppDataOptions & Resolve;
+export type HostPipelineDontResolveOptions = RouteOptions & AppDataOptions & DontResolve;
+type AnyClassComponent = TungstenBaseComponent<any, any>;
+/** host() for a pipeline component: its data comes from the context, so there is no store option */
+export declare function hostPipeline<Props extends TungstenComponentPropsBase, Component extends AnyClassComponent>(ComponentType: TungstenComponentClass<Props, Component>, props?: Props, options?: HostPipelineResolveOptions): Promise<HostedResolved<Component>>;
+export declare function hostPipeline<Props extends TungstenComponentPropsBase, Component extends AnyClassComponent>(ComponentType: TungstenComponentClass<Props, Component>, props?: Props, options?: HostPipelineDontResolveOptions): Promise<Hosted<Component>>;
+export declare function hostPipeline<Props extends TungstenComponentPropsBase, Component extends AnyClassComponent>(ComponentType: TungstenComponentClass<Props, Component>, props?: Props, options?: HostPipelineOptions): Promise<HostedResolved<Component> | Hosted<Component>>;
+export declare namespace hostPipeline {
+    var generic: typeof hostPipelineGeneric;
+    var jsx: typeof hostPipelineJsx;
+}
+/** host.generic() with hostPipeline()'s options */
+export declare function hostPipelineGeneric<Props extends TungstenComponentPropsBase, Component extends AnyClassComponent>(ComponentType: TungstenComponentClass<Props, Component>, options?: HostPipelineResolveOptions): (props: Props) => Promise<HostedResolved<Component>>;
+export declare function hostPipelineGeneric<Props extends TungstenComponentPropsBase, Component extends AnyClassComponent>(ComponentType: TungstenComponentClass<Props, Component>, options: HostPipelineDontResolveOptions): (props: Props) => Promise<Hosted<Component>>;
+export declare function hostPipelineGeneric<Props extends TungstenComponentPropsBase, Component extends AnyClassComponent>(ComponentType: TungstenComponentClass<Props, Component>, options?: HostPipelineOptions): (props: Props) => Promise<Hosted<Component> | HostedResolved<Component>>;
+/** host.jsx() with hostPipeline()'s options */
+export declare function hostPipelineJsx<Component extends AnyClassComponent = AnyClassComponent>(element: ContentNodeElement, options?: HostPipelineResolveOptions): Promise<HostedResolved<Component>>;
+export declare function hostPipelineJsx<Component extends AnyClassComponent = AnyClassComponent>(element: ContentNodeElement, options: HostPipelineDontResolveOptions): Promise<Hosted<Component>>;
+export declare function hostPipelineJsx<Component extends AnyClassComponent = AnyClassComponent>(element: ContentNodeElement, options?: HostPipelineOptions): Promise<Hosted<Component> | HostedResolved<Component>>;
+//# sourceMappingURL=hostPipeline.d.ts.map

package/dist/testing/pipeline/hostPipeline.js

@@ -0,0 +1,18 @@
+import { host, hostJsx } from '../host.js';
+// host()'s implementation signature, which its overloads hide
+const hostImplementation = host;
+// Implementation
+export async function hostPipeline(ComponentType, props, options) {
+  return hostImplementation(ComponentType, props, options);
+}
+// implementation
+export function hostPipelineGeneric(ComponentType, options) {
+  return async props => hostImplementation(ComponentType, props, options);
+}
+// implementation
+export async function hostPipelineJsx(element, options) {
+  return hostJsx(element, options); // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion -- the overloads above type them
+}
+// the variants hang off hostPipeline() too, as host()'s do
+hostPipeline.generic = hostPipelineGeneric;
+hostPipeline.jsx = hostPipelineJsx;

package/dist/testing/{hydrateTestPipelineApp.d.ts → pipeline/hydrateTestPipelineApp.d.ts}

@@ -1,8 +1,8 @@
-import type { ConstructPackage, TungstenBaseComponent, TungstenComponentPropsBase } from '../Components.jsx';
-import type { ReqRes } from '../ReqRes.js';
-import type { PipelineApp } from '../pipeline/pipelineDefinition.js';
-import type { TestStoreOverride } from './createTestApp.js';
-import type { HydrateTestApp } from './hydrateTestApp.js';
+import type { ConstructPackage, TungstenBaseComponent, TungstenComponentPropsBase } from '../../Components.jsx';
+import type { ReqRes } from '../../ReqRes.js';
+import type { TestStoreOverride } from '../createTestApp.js';
+import type { AppCheck } from './createTestPipelineApp.js';
+import type { HydrateTestApp } from '../hydrateTestApp.js';
 export type HydrateTestPipelineAppOptions<Props extends object> = {
     document?: Document;
     props?: Props;
@@ -25,6 +25,6 @@ type HydrateTestPipelineAppArgs<Props extends object> = object extends Props ? [
  * hydrates the parsed HTML. So a component whose markup depends on a context only one side makes
  * shows up in `mismatches`, or throws on a structural difference.
  */
-export declare function hydrateTestPipelineApp<Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>, RouteData = undefined>(app: PipelineApp<any>, RootComponent: new (pkg: ConstructPackage<Props, RouteData>) => Component, ...args: HydrateTestPipelineAppArgs<Props>): Promise<HydrateTestPipelineApp<Component>>;
+export declare function hydrateTestPipelineApp<Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>, A extends object, RouteData = undefined>(pipelineOrApp: A & AppCheck<A, Component>, RootComponent: new (pkg: ConstructPackage<Props, RouteData>) => Component, ...args: HydrateTestPipelineAppArgs<Props>): Promise<HydrateTestPipelineApp<Component>>;
 export {};
 //# sourceMappingURL=hydrateTestPipelineApp.d.ts.map

package/dist/testing/{hydrateTestPipelineApp.js → pipeline/hydrateTestPipelineApp.js}

@@ -1,18 +1,19 @@
-import { $props, $type } from '../contentNodeSymbols.js';
-import { DomPointer } from '../DomPointer.js';
-import { hydrateRootComponent, hydrationRouting, makeDefaultHydrateMeta } from "../hydrate/hydrate.js";
-import { Instance } from '../Instance/Instance.js';
-import { JSONstringify } from '../json.js';
-import { NetworkedTransport } from '../pipeline/networkedTransport.js';
-import { afterRoutingFor, pipelineRoutes, routingContext, routingNetworkedData, symmetricServer } from '../pipeline/runPipeline.js';
-import { clientRoute } from '../pipeline/pipelineDefinition.js';
-import { splitServer } from '../pipeline/runSplitPipeline.js';
-import { contentTreeToRenderingTree } from '../render/contentTreeToRenderingTree.js';
-import { renderingNodeToHtml } from '../render/renderingTreeToHtml.js';
-import { initStores } from '../Servers/initStores.js';
-import { UpdateScheduler } from '../update/UpdateScheduler.js';
-import { bridgeHappyDomGlobals, HydrateTestAppImplementation, requireClient } from './hydrateTestApp.js';
-import { waitForEnvIfLoading } from './loadEnv.js';
+import { $props, $type } from '../../contentNodeSymbols.js';
+import { DomPointer } from '../../DomPointer.js';
+import { hydrateRootComponent, hydrationRouting, makeDefaultHydrateMeta } from "../../hydrate/hydrate.js";
+import { Instance } from '../../Instance/Instance.js';
+import { JSONstringify } from '../../json.js';
+import { NetworkedTransport } from '../../pipeline/networkedTransport.js';
+import { afterRoutingFor, pipelineRoutes, routingContext, routingNetworkedData, symmetricServer } from '../../pipeline/runPipeline.js';
+import { clientRoute } from '../../pipeline/pipelineDefinition.js';
+import { splitServer } from '../../pipeline/runSplitPipeline.js';
+import { contentTreeToRenderingTree } from '../../render/contentTreeToRenderingTree.js';
+import { renderingNodeToHtml } from '../../render/renderingTreeToHtml.js';
+import { initStores } from '../../Servers/initStores.js';
+import { UpdateScheduler } from '../../update/UpdateScheduler.js';
+import { bridgeHappyDomGlobals, HydrateTestAppImplementation, requireClient } from '../hydrateTestApp.js';
+import { toApp } from './createTestPipelineApp.js';
+import { waitForEnvIfLoading } from '../loadEnv.js';
 // the framework brands what it builds
 // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
 const asGlobalData = data => data;
@@ -31,9 +32,10 @@ const appRoutesFor = (app, init) => reqRes => pipelineRoutes(app, reqRes, init,
  * hydrates the parsed HTML. So a component whose markup depends on a context only one side makes
  * shows up in `mismatches`, or throws on a structural difference.
  */
-export async function hydrateTestPipelineApp(app, RootComponent, ...args) {
+export async function hydrateTestPipelineApp(pipelineOrApp, RootComponent, ...args) {
   requireClient('hydrateTestPipelineApp()');
   await waitForEnvIfLoading();
+  const app = toApp(pipelineOrApp);
   const options = args[0];
   const suppliedDocument = options?.document ?? globalThis.document;
   if (suppliedDocument === undefined) {
@@ -131,7 +133,7 @@ export async function hydrateTestPipelineApp(app, RootComponent, ...args) {
   container.innerHTML = html;
   bridgeHappyDomGlobals(document);
   // Client pass: the app's own client run, with the page's data, as hydratePipeline() runs it
-  const ran = await app.client(app, serverGlobalData, fromPage);
+  const ran = await app.client(app, fromPage);
   const routes = pipelineRoutes(app, null, ran.init, true);
   const {
     key,
@@ -145,8 +147,9 @@ export async function hydrateTestPipelineApp(app, RootComponent, ...args) {
       data
     } : {})
   }, routes);
-  const afterRouting = afterRoutingFor(ran.afterRouting);
-  const context = afterRouting === undefined ? asContext(ran.context) : await afterRouting(clientRoute(matchedRouteInfo, location), serverGlobalData);
+  const posted = await ran.post(serverGlobalData);
+  const afterRouting = afterRoutingFor(posted.afterRouting);
+  const context = afterRouting === undefined ? asContext(posted.context) : await afterRouting(clientRoute(matchedRouteInfo, location), serverGlobalData);
   const networkedData = routingNetworkedData(ran.routingNetworkedData);
   const scheduler = new UpdateScheduler();
   const {

package/dist/testing/pipeline/index.d.ts

@@ -0,0 +1,5 @@
+export { type AppCheck, type CreateTestPipelineAppArgs, type TestPipelineApp, type TestPipelineAppOptions, createTestPipelineApp, } from './createTestPipelineApp.js';
+export { type CreateTestPacketAppArgs, type PacketForComponent, type TestPacketAppOptions, createTestPacketApp, } from './createTestPacketApp.js';
+export { type HydrateTestPipelineApp, type HydrateTestPipelineAppOptions, hydrateTestPipelineApp, } from './hydrateTestPipelineApp.js';
+export { type HostPipelineDontResolveOptions, type HostPipelineOptions, type HostPipelineResolveOptions, type HostStoreOptions, type Hosted, type HostedResolved, type HostedRoute, hostPipeline, hostPipelineGeneric, hostPipelineJsx, } from './hostPipeline.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/pipeline/index.js

@@ -0,0 +1,4 @@
+export { createTestPipelineApp } from './createTestPipelineApp.js';
+export { createTestPacketApp } from './createTestPacketApp.js';
+export { hydrateTestPipelineApp } from './hydrateTestPipelineApp.js';
+export { hostPipeline, hostPipelineGeneric, hostPipelineJsx } from './hostPipeline.js';

package/dist/testing/pipeline/pipelineTestApp.d.ts

@@ -0,0 +1,34 @@
+import type { ConstructPackage, TungstenBaseComponent } from '../../Components.jsx';
+import type { AsGlobalData, BrandedContext, BrandedNetworkedData } from '../../Brands.js';
+import type { InstancePipeline } from '../../Instance/Instance.js';
+import type { AppRoutes } from '../../routing/AppRoutes.js';
+import type { MatchedRouteInfo } from '../../routing/MatchedRouteInfo.js';
+import type { RoutesWithSettings } from '../../routing/Routes.js';
+import { type TestApp, type TestStoreOverride } from '../createTestApp.js';
+export type PipelineTestAppOptions<Props extends object> = {
+    document?: Document;
+    props?: Props;
+    container?: HTMLElement;
+    location?: string;
+    stores?: readonly TestStoreOverride<any>[];
+    fileVersions?: Record<string, string>;
+};
+export type PipelineTestTarget = {
+    document: Document;
+    container: HTMLElement;
+    ownsContainer: boolean;
+};
+export type PipelineTestData = {
+    location: string;
+    routes: RoutesWithSettings<any>;
+    appRoutes: AppRoutes<any>;
+    matchedRouteInfo: MatchedRouteInfo;
+    allRoutesData: AsGlobalData;
+    context: BrandedContext;
+    networkedData: BrandedNetworkedData;
+    networked: object;
+    pipeline: InstancePipeline;
+};
+export declare function pipelineTestTarget(options: PipelineTestAppOptions<object> | undefined, name: string): PipelineTestTarget;
+export declare function mountPipelineTestApp<Props extends object, Component extends TungstenBaseComponent, RouteData>(target: PipelineTestTarget, data: PipelineTestData, RootComponent: new (pkg: ConstructPackage<Props, RouteData>) => Component, options: PipelineTestAppOptions<Props> | undefined): Promise<TestApp<Component>>;
+//# sourceMappingURL=pipelineTestApp.d.ts.map

package/dist/testing/pipeline/pipelineTestApp.js

@@ -0,0 +1,100 @@
+import { Instance } from '../../Instance/Instance.js';
+import { initStores } from '../../Servers/initStores.js';
+import { createTungstenRootComponent } from '../../update/integrateUpdateVdom.js';
+import { UpdateScheduler } from '../../update/UpdateScheduler.js';
+import { TestAppImplementation } from '../createTestApp.js';
+// checked before anything runs
+export function pipelineTestTarget(options, name) {
+  const suppliedDocument = options?.document ?? globalThis.document;
+  if (suppliedDocument === undefined) {
+    // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+    throw new Error(`${name} requires options.document when no global document is available.`);
+  }
+  const document = suppliedDocument;
+  const ownsContainer = options?.container === undefined;
+  const container = options?.container ?? document.createElement('div');
+  if (container.ownerDocument !== document) {
+    throw new Error('The TestApp container must belong to options.document.');
+  }
+  if (container.childNodes.length > 0) {
+    throw new Error('The TestApp container must be empty before mounting.');
+  }
+  return {
+    document,
+    container,
+    ownsContainer
+  };
+}
+export async function mountPipelineTestApp(target, data, RootComponent, options) {
+  const {
+    document,
+    container,
+    ownsContainer
+  } = target;
+  const {
+    location,
+    allRoutesData,
+    matchedRouteInfo,
+    context,
+    networkedData
+  } = data;
+  if (ownsContainer) {
+    if (document.body === null) {
+      // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+      throw new Error('The supplied document must have a body element.');
+    }
+    document.body.appendChild(container);
+  }
+  const scheduler = new UpdateScheduler();
+  const runtimeContext = {
+    document,
+    window: document.defaultView,
+    scheduler,
+    navigation: false
+  };
+  const {
+    internalStore,
+    stores,
+    storeSubscriptions
+  } = initStores(location, null, allRoutesData, matchedRouteInfo, null, context, networkedData);
+  const instanceConfig = {
+    prod: false,
+    useRootComponent: true,
+    clientSideNav: true,
+    siteBasePath: '/',
+    staticSite: false,
+    csr: false
+  };
+  const instance = new Instance(location, instanceConfig, null, data.appRoutes, data.routes, internalStore, stores, storeSubscriptions, allRoutesData, matchedRouteInfo, runtimeContext);
+  instance.fileVersions = options?.fileVersions;
+  instance.context = context;
+  instance.networkedData = networkedData;
+  instance.pipelineNetworked = data.networked;
+  instance.pipeline = data.pipeline;
+  try {
+    for (const override of options?.stores ?? []) {
+      const store = override.registration.getStore(instance.stores);
+      await override.initialize(store);
+    }
+    const props = options?.props ?? {};
+    const root = await createTungstenRootComponent(RootComponent, props, matchedRouteInfo.params, matchedRouteInfo.data, instance, container);
+    const testApp = new TestAppImplementation(document, container, root.component, instance, scheduler, root, ownsContainer);
+    try {
+      await testApp.resolved();
+      return testApp;
+    } catch (error) {
+      await testApp.unmount();
+      throw error;
+    }
+  } catch (error) {
+    try {
+      instance.disposeRegisteredComponents();
+    } catch {
+      // Preserve the mount failure.
+    }
+    scheduler.dispose();
+    while (container.firstChild !== null) container.removeChild(container.firstChild);
+    if (ownsContainer) container.remove();
+    throw error;
+  }
+}

package/dist/testing/pipeline/testPipelineRoute.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=testPipelineRoute.d.ts.map

package/dist/testing/pipeline/testPipelineRoute.js

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

package/dist/testing/resolveContent.d.ts

@@ -12,5 +12,7 @@ import type { ContentNode } from '../ContentNode.js';
  * by name and by prop as well as by what it put on the page.
  */
 export declare function resolveContent(content: ContentNode, parentComponent: AnyComponent | null, instance: Instance, constructed?: Constructed): Promise<ContentNode>;
+/** On a component node resolveContent resolved: the children it was passed, its own now output */
+export declare const $passedChildren: unique symbol;
 export type Constructed = (component: object) => void;
 //# sourceMappingURL=resolveContent.d.ts.map

package/dist/testing/resolveContent.js

@@ -32,8 +32,16 @@ constructed) {
   if (!ContentNodeElementIsComponent(content)) {
     return withChildren(content, await resolveContent(content[$props].children, parentComponent, instance, constructed));
   }
-  return withChildren(content, await rendered(content, parentComponent, instance, constructed));
+  const output = await rendered(content, parentComponent, instance, constructed);
+  const resolved = withChildren(content, output);
+  // non-enumerable, so a resolved node still deep-equals one written by hand
+  Object.defineProperty(resolved, $passedChildren, {
+    value: content[$props].children
+  });
+  return resolved;
 }
+/** On a component node resolveContent resolved: the children it was passed, its own now output */
+export const $passedChildren = Symbol('passedChildren');
 // what the component put on the page, resolved in its turn.
 // As render/componentNodeToRenderingTree: a component the app renders on the client alone never
 // runs its content here, so its placeholder stands for it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tungsten",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "",
   "type": "module",
   "bin": {
@@ -13,16 +13,20 @@
     "./library": "./dist/components/library/index.js",
     "./react-zone": "./dist/zones/react.js",
     "./testing": "./dist/testing/index.js",
+    "./testing/pipeline": "./dist/testing/pipeline/index.js",
     "./jsx-runtime": "./dist/jsx-runtime.js",
     "./*": "./dist/*",
     "./types/*": "./types/*"
   },
   "files": [
     "dist",
+    "!dist/**/*.d.*ts.map",
     "!dist/**/*.sxyt.*",
+    "!dist/**/*.test.*",
     "vendor",
     "types",
-    "readme.md"
+    "readme.md",
+    "AGENTS.md"
   ],
   "keywords": [],
   "author": "",
@@ -51,6 +55,7 @@
     "chalk-extensions": "^2.0.24",
     "chokidar": "^3.6.0",
     "cjs-module-lexer": "^1.4.3",
+    "css-select": "^7.0.0",
     "csstype": "^3.2.3",
     "deep-eql": "^4.1.4",
     "dotenv": "^16.6.1",
@@ -120,13 +125,13 @@
   },
   "scripts": {
     "__build": "pnpm clean && pnpm build-prep && pnpm build-watch",
-    "build": "run-s -c clean build-prep build-watch",
-    "build-tscmon": "rimraf dist && tscmon --on-first-success \"pnpm build-babel\"",
+    "build-old": "run-s -c clean build-prep build-watch",
+    "build": "rimraf dist && tscmon --on-first-success \"pnpm build-babel\"",
     "clean": "rimraf intermed dist",
     "build-prep": "pnpm build-ts-once",
     "build-watch": "run-p build-ts build-babel",
     "build-quick": "pnpm build-watch",
-    "build-once": "rimraf intermed dist && pnpm build-ts-once && pnpm build-babel-once && pnpm build-component-styles",
+    "build-once": "rimraf dist && pnpm build-ts-once && pnpm build-babel-once && pnpm build-component-styles",
     "build-component-styles": "node scripts/buildComponentStyles.ts",
     "build-vendor": "node scripts/bundleVendor.ts",
     "build-once-nd": "rimraf intermed dist.building && pnpm build-ts-once && pnpm build-babel-staged && node scripts/syncDist.ts && node scripts/writeBuildMarker.ts",