tungsten 0.3.2 → 0.3.4

package/dist/stateTracking.js

@@ -0,0 +1,83 @@
+/**
+ * A monotonic clock for state writes, so a component can ask "has anything inside this
+ * object changed since I last rendered?".
+ *
+ * Needed because deep state is mutated in place: when a child's prop is the same array
+ * the parent already had, comparing before against after tells you nothing -- both sides
+ * are the one mutated object. Each proxy stamps the object it mutated with the current
+ * tick, and the props comparison walks down looking for a stamp newer than the child's
+ * last render.
+ *
+ * The stamp is stored under $changed on the object itself rather than in a side table
+ * keyed by identity, so it can be read straight back through the proxy -- the raw target
+ * is not always the object a caller holds, since adoption copies state shallowly.
+ * Symbols are invisible to Object.keys and JSON, so the stamp does not leak into user data.
+ *
+ * Stamps are deliberately not propagated to ancestors: a write would then have to touch
+ * every object above it. The cost is moved to update time, where the walk can stop at the
+ * first changed node it finds.
+ *
+ * No imports here on purpose -- the proxy handlers depend on this, so it must stay a leaf.
+ */
+export const $changed = Symbol('changed');
+/**
+ * Set `__TW_TRACE = true` in a console (or before load) to log the props-skip decisions.
+ * Off by default and cheap when off -- one global read per event.
+ */
+let tracingCached = null;
+/**
+ * Re-reads the global. Called once per update rather than per node: the global lookup is
+ * cheap in isolation but showed up as 12% of a 50k-row update when it ran for every dom
+ * node, which is the instrumentation distorting what it measures. Toggling __TW_TRACE from
+ * a console therefore takes effect on the next update rather than immediately.
+ */
+export function refreshTracing() {
+  tracingCached = Reflect.get(globalThis, '__TW_TRACE') === true;
+  return tracingCached;
+}
+export function tracing() {
+  return tracingCached ?? refreshTracing();
+}
+let lastTraceAt = null;
+/**
+ * Each line carries the time since page load and the time since the previous traced event,
+ * so a stall shows up as a large `+delta` on the line that follows it -- no need to diff
+ * timestamps by hand. The delta is reset whenever tracing is switched back on.
+ */
+export function trace(...args) {
+  if (!tracing()) {
+    lastTraceAt = null;
+    return;
+  }
+  const now = performance.now();
+  const delta = lastTraceAt === null ? 0 : now - lastTraceAt;
+  lastTraceAt = now;
+  console.log(`[tungsten ${now.toFixed(1)}ms +${delta.toFixed(1)}]`, ...args);
+}
+let clock = 0;
+const lastRender = new WeakMap();
+/** current tick; read when recording a render */
+export function stateClock() {
+  return clock;
+}
+/** called by the state proxies whenever the given object is mutated */
+export function markChanged(target) {
+  Reflect.set(target, $changed, ++clock);
+  // commented out: args are built on every state write even when tracing is off
+  //trace('changed', Array.isArray(target) ? `array(len ${target.length})` : 'object', '-> tick', clock)
+}
+/** tick at which this object was last mutated; 0 means never */
+export function changedAt(value) {
+  const stamp = Reflect.get(value, $changed);
+  return typeof stamp === 'number' ? stamp : 0;
+}
+/** record that a component has rendered with the state as it currently stands */
+export function markRendered(element) {
+  lastRender.set(element, clock);
+  // commented out: args are built on every render even when tracing is off
+  //trace('rendered', element.constructor.name, 'baseline tick', clock)
+}
+/** tick at which this component last rendered, or undefined if it never has */
+export function renderedAt(element) {
+  return lastRender.get(element);
+}

package/dist/staticGen/staticGen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"staticGen.d.ts","sourceRoot":"","sources":["../../src/staticGen/staticGen.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAiBhD,wBAAsB,SAAS,CAAC,SAAS,EAAE,SAAS,iBA2LnD"}
+{"version":3,"file":"staticGen.d.ts","sourceRoot":"","sources":["../../src/staticGen/staticGen.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAiBhD,wBAAsB,SAAS,CAAC,SAAS,EAAE,SAAS,iBA6MnD"}

package/dist/staticGen/staticGen.js

@@ -2,7 +2,7 @@ import { existsSync, promises as fsPromises } from 'fs';
 import { join, dirname } from 'path';
 import fsExtra from 'fs-extra';
 //import type { SxyFrameworkConfigComplete } from '../FrameworkConfig.js'
-import { staticSiteFolder, staticFolder, assetsFolder, publicFolder, bundleFolder, componentCssFolder } from "../settings.js";
+import { staticSiteFolder, staticFolder, assetsFolder, publicFolder, bundleFolder, componentCssFolder, frameworkCssFolder } from "../settings.js";
 import { getAppRoutes } from "./getAppRoutes.js";
 import { cliError, cliWarn } from "../cliOutput.js";
 import { matchPath } from "../routing/matchPath.js";
@@ -36,119 +36,129 @@ export async function staticGen(framework) {
   const buildLocation = framework.compilationInfo.location;
   const server = await framework.createProdServer();
   const serverLocation = await server.start(null, true); // port, mute
-  // ensure the target folder exists
-  await fsPromises.mkdir(join(projectDir, staticSiteFolder), {
-    recursive: true
-  });
-  const rewriteMap = {};
-  // if ( ! Array.isArray(appRoutes) ) {
-  //     appRoutes = Object.entries(appRoutes).map( ([path, route]) => { 
-  //         route.path = path as keyof typeof appRoutes
-  //         return route
-  //     } )
-  // }
-  // for default and 404 routes we need to identify which one is in use, and then make sure the app renders it
-  // appRoutes = appRoutes.map( route => {
-  //     if (route.path === 'default') {
-  //         route.path === '/__default'
-  //         cliWarn(`Static site gen turning default route into __default.html. It is possible that this could conflict with a real route.`)
-  //     } else if (route.path === '404') {
-  //         route.path === '/404'
-  //         cliWarn(`Static site gen turning 404 route into __404.html. It is possible that this could conflict with a real route.`)
-  //     } 
-  //     return route
-  // })
-  const dynamicRoutes = [];
-  const finalRoutes = objectFilter(appRoutes, (path, route) => {
-    if (!path.startsWith('/')) {
-      //cliWarn(`Static gen skipping route ${route.path}, because it does not start with /, and is not default or 404`)
-      cliWarn(`Static gen skipping route ${path}, because it does not start with /`);
-      return false;
+  // the server is only here to render the pages from - leaving it up holds the event loop
+  // open, which is what forced the caller to hard-exit (and abort mid-teardown) instead
+  try {
+    // ensure the target folder exists
+    await fsPromises.mkdir(join(projectDir, staticSiteFolder), {
+      recursive: true
+    });
+    const rewriteMap = {};
+    // if ( ! Array.isArray(appRoutes) ) {
+    //     appRoutes = Object.entries(appRoutes).map( ([path, route]) => {
+    //         route.path = path as keyof typeof appRoutes
+    //         return route
+    //     } )
+    // }
+    // for default and 404 routes we need to identify which one is in use, and then make sure the app renders it
+    // appRoutes = appRoutes.map( route => {
+    //     if (route.path === 'default') {
+    //         route.path === '/__default'
+    //         cliWarn(`Static site gen turning default route into __default.html. It is possible that this could conflict with a real route.`)
+    //     } else if (route.path === '404') {
+    //         route.path === '/404'
+    //         cliWarn(`Static site gen turning 404 route into __404.html. It is possible that this could conflict with a real route.`)
+    //     }
+    //     return route
+    // })
+    const dynamicRoutes = [];
+    const finalRoutes = objectFilter(appRoutes, (path, route) => {
+      if (!path.startsWith('/')) {
+        //cliWarn(`Static gen skipping route ${route.path}, because it does not start with /, and is not default or 404`)
+        cliWarn(`Static gen skipping route ${path}, because it does not start with /`);
+        return false;
+      }
+      if (path.includes(':')) {
+        // separate these out
+        dynamicRoutes.push([path, route]);
+        return false;
+      }
+      return true;
+    });
+    if (count(finalRoutes) === 0) {
+      cliWarn('Found no valid route!');
     }
-    if (path.includes(':')) {
-      // separate these out
-      dynamicRoutes.push([path, route]);
-      return false;
+    for (const [path, route] of Object.entries(finalRoutes)) {
+      // we need to develop the rewrite map over time, because we discover links during processing
+      rewriteMap[path] = pathToLink(path, siteBasePath);
     }
-    return true;
-  });
-  if (count(finalRoutes) === 0) {
-    cliWarn('Found no valid route!');
-  }
-  for (const [path, route] of Object.entries(finalRoutes)) {
-    // we need to develop the rewrite map over time, because we discover links during processing
-    rewriteMap[path] = pathToLink(path, siteBasePath);
-  }
-  //console.log('rewriteMap', rewriteMap)
-  async function renderPath(path, siteBasePath) {
-    const url = serverLocation + path;
-    let links;
-    try {
-      console.log('get URL', url);
-      const response = await fetch(url);
-      // fetch, unlike axios, resolves on non-2xx - so check explicitly, or we'd
-      // write error pages out as static HTML
-      if (!response.ok) throwError('renderPath', `Get request to ${url} returned an invalid status: ${response.status}`);
-      let result = await response.text();
-      links = findLinks(result);
-      const newPaths = [];
-      for (const link of links) {
-        if (!StringIsPath(link)) throwError('renderRoute', `Found a link '${link}' that did not start with /`);
-        if (!(link in rewriteMap)) {
-          for (const [path, dynamicRoute] of dynamicRoutes) {
-            if (RouteKeyIsPath(path)) {
-              if (matchPath(path, link)) {
-                //console.log('link', link)
-                //console.log('in?', link in rewriteMap)
-                //console.log(`link ${link} matched dynamic route ${dynamicRoute.path}`)
-                newPaths.push(link);
-                rewriteMap[link] = pathToLink(link, siteBasePath);
+    //console.log('rewriteMap', rewriteMap)
+    const renderPath = async (path, siteBasePath) => {
+      const url = serverLocation + path;
+      let links;
+      try {
+        console.log('get URL', url);
+        const response = await fetch(url);
+        // fetch, unlike axios, resolves on non-2xx - so check explicitly, or we'd
+        // write error pages out as static HTML
+        if (!response.ok) throwError('renderPath', `Get request to ${url} returned an invalid status: ${response.status}`);
+        let result = await response.text();
+        links = findLinks(result);
+        const newPaths = [];
+        for (const link of links) {
+          if (link.startsWith('#')) continue; // ignore anchors/hash links
+          if (!StringIsPath(link)) {
+            throwError('renderRoute', `Found a link '${link}' that did not start with /`);
+          }
+          if (!(link in rewriteMap)) {
+            for (const [path, dynamicRoute] of dynamicRoutes) {
+              if (RouteKeyIsPath(path)) {
+                if (matchPath(path, link)) {
+                  //console.log('link', link)
+                  //console.log('in?', link in rewriteMap)
+                  //console.log(`link ${link} matched dynamic route ${dynamicRoute.path}`)
+                  newPaths.push(link);
+                  rewriteMap[link] = pathToLink(link, siteBasePath);
+                }
+              } else {
+                // default
+                // 404
               }
-            } else {
-              // default
-              // 404
             }
           }
         }
+        result = rewriteLinks(result, rewriteMap);
+        //const pageFileName = rewriteMap[path]
+        const pageFileName = pathToFileName(path);
+        const dest = join(projectDir, staticSiteFolder, pageFileName);
+        const dir = dirname(dest);
+        // ensure the target folder exists
+        // some duplication of effort here - oh well
+        await fsPromises.mkdir(dir, {
+          recursive: true
+        });
+        await fsPromises.writeFile(join(projectDir, staticSiteFolder, pageFileName), result);
+        // we can update the rewrite map here
+        // for (const route of appRoutes) { // we need to develop the rewrite map over time, because we discover links during processing
+        //     const path = route.path
+        //     rewriteMap[path] = pathToFileName(path)
+        // }
+        // awaited - otherwise staticGen() can return before these pages are written
+        for (const link of newPaths) {
+          await renderPath(link, siteBasePath);
+        }
+      } catch (e) {
+        const stack = typeof e === 'object' && e !== null && 'stack' in e ? e.stack : '';
+        cliError(`Static site gen - error generating path ${path} (full location ${url}): ${String(e)} ${String(stack)}`);
       }
-      result = rewriteLinks(result, rewriteMap);
-      //const pageFileName = rewriteMap[path]
-      const pageFileName = pathToFileName(path);
-      const dest = join(projectDir, staticSiteFolder, pageFileName);
-      const dir = dirname(dest);
-      // ensure the target folder exists
-      // some duplication of effort here - oh well
-      await fsPromises.mkdir(dir, {
-        recursive: true
-      });
-      await fsPromises.writeFile(join(projectDir, staticSiteFolder, pageFileName), result);
-      // we can update the rewrite map here
-      // for (const route of appRoutes) { // we need to develop the rewrite map over time, because we discover links during processing
-      //     const path = route.path
-      //     rewriteMap[path] = pathToFileName(path)
-      // }
-      for (const link of newPaths) {
-        renderPath(link, siteBasePath);
-      }
-    } catch (e) {
-      const stack = typeof e === 'object' && e !== null && 'stack' in e ? e.stack : '';
-      cliError(`Static site gen - error generating path ${path} (full location ${url}): ${String(e)} ${String(stack)}`);
+    };
+    for (const [path, route] of Object.entries(finalRoutes)) {
+      await renderPath(path, siteBasePath);
     }
+    console.log('rewriteMap', rewriteMap);
+    const copyPromises = [fsExtra.copy(join(buildLocation, staticFolder), join(projectDir, staticSiteFolder)),
+    // assets folder
+    existsSync(join(buildLocation, assetsFolder)) ? fsExtra.copy(join(buildLocation, assetsFolder), join(projectDir, staticSiteFolder, 'assets')) : null,
+    // public files
+    existsSync(join(buildLocation, publicFolder)) ? fsExtra.copy(join(buildLocation, publicFolder), join(projectDir, staticSiteFolder)) : null,
+    // copy in the bundle
+    fsExtra.copy(join(projectDir, bundleFolder), join(projectDir, staticSiteFolder, 'bundle')),
+    // copy the client.js to clientWithEnv.js, because the framework looks for this file instead.
+    //fsExtra.copy(join(projectDir, bundleFolder, 'client.js'), join(projectDir, bundleFolder, 'clientWithEnv.js')),
+    // copy in the css
+    fsExtra.copy(join(buildLocation, componentCssFolder), join(projectDir, staticSiteFolder, componentCssFolder)), ...(existsSync(join(buildLocation, frameworkCssFolder)) ? [fsExtra.copy(join(buildLocation, frameworkCssFolder), join(projectDir, staticSiteFolder, frameworkCssFolder))] : [])];
+    await Promise.all(copyPromises);
+  } finally {
+    await server.stop();
   }
-  for (const [path, route] of Object.entries(finalRoutes)) {
-    await renderPath(path, siteBasePath);
-  }
-  console.log('rewriteMap', rewriteMap);
-  const copyPromises = [fsExtra.copy(join(buildLocation, staticFolder), join(projectDir, staticSiteFolder)),
-  // assets folder
-  existsSync(join(buildLocation, assetsFolder)) ? fsExtra.copy(join(buildLocation, assetsFolder), join(projectDir, staticSiteFolder, 'assets')) : null,
-  // public files
-  existsSync(join(buildLocation, publicFolder)) ? fsExtra.copy(join(buildLocation, publicFolder), join(projectDir, staticSiteFolder)) : null,
-  // copy in the bundle
-  fsExtra.copy(join(projectDir, bundleFolder), join(projectDir, staticSiteFolder, 'bundle')),
-  // copy the client.js to clientWithEnv.js, because the framework looks for this file instead.
-  //fsExtra.copy(join(projectDir, bundleFolder, 'client.js'), join(projectDir, bundleFolder, 'clientWithEnv.js')),
-  // copy in the css
-  fsExtra.copy(join(buildLocation, componentCssFolder), join(projectDir, staticSiteFolder, componentCssFolder))];
-  await Promise.all(copyPromises);
 }

package/dist/style/styleContentSxy.js

@@ -121,6 +121,27 @@ function processItem(element, styles, usage) {
   }
   newClassName = newClassName.trim();
   if (newClassName !== '') element[$props].className = newClassName;
+  // Any other *ClassName prop (e.g. messageClassName, handed to a child component to apply
+  // to one of its own elements) gets the same local-stylesheet lookup applied in place, so a
+  // classname threaded down through props can still be scoped against this component's own
+  // stylesheet, even though the child's own render tree is outside this walk - see
+  // styleContentSxy() above.
+  for (const key in element[$props]) {
+    if (key === 'className' || !key.endsWith('ClassName')) continue;
+    const value = element[$props][key];
+    if (value === undefined || value === null) continue;
+    if (typeof value !== 'string') {
+      throw new TungstenError(`styleContentSxy() error: ${ContentNodeElementIsHtml(element) ? element[$type] : getComponentName(element)}` + ` ${key} prop should be a string. Received ${typeof value}`);
+    }
+    let newValue = value;
+    for (const cn of value.split(' ')) {
+      if (cn in styles.classes) {
+        newValue += ` ${styles.classes[cn]}`;
+        usage?.usedClasses.add(cn);
+      }
+    }
+    if (newValue !== value) element[$props][key] = newValue;
+  }
   debug('element after mods', tagName, element);
   // apply this to both fragment and elements
   if (element[$props].children !== undefined) {

package/dist/testing/hydrateTestApp.d.ts

@@ -0,0 +1,38 @@
+import type { ConstructPackage, TungstenBaseComponent, TungstenComponentPropsBase } from '../Components.jsx';
+import type { TaggedAttributeMismatch } from '../hydrate/renderHydrationMismatchBanner.js';
+import type { TestAppOptions } from './index.js';
+export type HydrateTestAppOptions<Props extends object> = TestAppOptions<Props> & {
+    serverProps?: Props;
+    csr?: boolean;
+};
+type HydrateTestAppArgs<Props extends object> = object extends Props ? [options?: HydrateTestAppOptions<Props>] : keyof Props extends never ? [options?: HydrateTestAppOptions<Props>] : [options: HydrateTestAppOptions<Props> & {
+    props: Props;
+}];
+export type HydrateTestApp<Component extends TungstenBaseComponent> = {
+    readonly document: Document;
+    readonly container: HTMLElement;
+    readonly component: Component;
+    readonly html: string;
+    readonly mismatches: readonly TaggedAttributeMismatch[];
+    resolved(): Promise<void>;
+    setProps(props: Component['props']): Promise<void>;
+    unmount(): Promise<void>;
+};
+/**
+ * The hydration round trip createTestApp() deliberately doesn't cover: render a component to
+ * HTML the way a real server would, parse it with a real HTML parser, hydrate a fresh client
+ * instance against the result, and hand back the live, hydrated component - still fully usable
+ * via setProps()/resolved(), exactly like createTestApp()'s result.
+ *
+ * By default `props` renders on both sides, so a passing test proves an ordinary page hydrates
+ * clean (`mismatches` empty). Pass `serverProps` to diverge the two passes on purpose and assert
+ * on the resulting `mismatches` - the case a one-off "does the reconciler still agree with real
+ * served pages" script never could, because nothing fed it markup that didn't already match.
+ *
+ * A structural mismatch (a different tag, a different number of children) is not something
+ * reconcileHydratedAttributes() can fix - hydrateRootComponent() throws, exactly as the real
+ * client hydrator does, so a caller reproducing that class of bug should assert on the rejection.
+ */
+export declare function hydrateTestApp<Props extends TungstenComponentPropsBase, Component extends TungstenBaseComponent<any, any>, RouteData = undefined>(RootComponent: new (pkg: ConstructPackage<NoInfer<Props>, RouteData>) => Component, ...args: HydrateTestAppArgs<Props>): Promise<HydrateTestApp<Component>>;
+export {};
+//# sourceMappingURL=hydrateTestApp.d.ts.map

package/dist/testing/hydrateTestApp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydrateTestApp.d.ts","sourceRoot":"","sources":["../../src/testing/hydrateTestApp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,gBAAgB,EAChB,qBAAqB,EACrB,0BAA0B,EAC7B,MAAM,mBAAmB,CAAA;AAO1B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6CAA6C,CAAA;AAa1F,OAAO,KAAK,EAAE,cAAc,EAAqB,MAAM,YAAY,CAAA;AAEnE,MAAM,MAAM,qBAAqB,CAAC,KAAK,SAAS,MAAM,IAAI,cAAc,CAAC,KAAK,CAAC,GAAG;IAM9E,WAAW,CAAC,EAAE,KAAK,CAAA;IAEnB,GAAG,CAAC,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,KAAK,kBAAkB,CAAC,KAAK,SAAS,MAAM,IAAI,MAAM,SAAS,KAAK,GAC9D,CAAC,OAAO,CAAC,EAAE,qBAAqB,CAAC,KAAK,CAAC,CAAC,GACxC,MAAM,KAAK,SAAS,KAAK,GACrB,CAAC,OAAO,CAAC,EAAE,qBAAqB,CAAC,KAAK,CAAC,CAAC,GACxC,CAAC,OAAO,EAAE,qBAAqB,CAAC,KAAK,CAAC,GAAG;IAAE,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC,CAAA;AAEpE,MAAM,MAAM,cAAc,CAAC,SAAS,SAAS,qBAAqB,IAAI;IAClE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAA;IAC/B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;IAG7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IAIrB,QAAQ,CAAC,UAAU,EAAE,SAAS,uBAAuB,EAAE,CAAA;IAEvD,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAClD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3B,CAAA;AAkGD;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,cAAc,CAChC,KAAK,SAAS,0BAA0B,EACxC,SAAS,SAAS,qBAAqB,CAAC,GAAG,EAAE,GAAG,CAAC,EACjD,SAAS,GAAG,SAAS,EAErB,aAAa,EAAE,KAAK,GAAG,EAAE,gBAAgB,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,KAAK,SAAS,EAClF,GAAG,IAAI,EAAE,kBAAkB,CAAC,KAAK,CAAC,GACnC,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CA6HpC"}

package/dist/testing/hydrateTestApp.js

@@ -0,0 +1,242 @@
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+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); }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+import { $props, $type } from "../contentNodeSymbols.js";
+import { Instance } from "../Instance/Instance.js";
+import { hydrateRootComponent } from "../hydrate/hydrate.js";
+import { contentTreeToRenderingTree } from "../render/contentTreeToRenderingTree.js";
+import { renderingNodeToHtml } from "../render/renderingTreeToHtml.js";
+import { initStores } from "../Servers/initStores.js";
+import { deleteNodeIfRendered } from "../update/integrateUpdateVdom.js";
+import { UpdateScheduler } from "../update/UpdateScheduler.js";
+import { DomPointer } from "../DomPointer.js";
+import { ensureTestEnvLoaded } from "./ensureTestEnvLoaded.js";
+// hydrate.tsx references several DOM globals directly (Node.COMMENT_NODE, `instanceof Text`, the
+// bare `document`) the way real browser code always can - happy-dom only puts these on its own
+// Window, not on Node.js's global scope. Every hand-written hydration test before this harness
+// bridged them manually; a caller of hydrateTestApp() shouldn't need to know that hydrate() was
+// written assuming a real browser to begin with.
+function bridgeHappyDomGlobals(document) {
+  const window = document.defaultView;
+  if (window === null) return;
+  const globals = globalThis; // eslint-disable-line no-type-assertion/no-type-assertion -- bridging happy-dom's globals onto the global scope
+  globals.Node = window.Node;
+  globals.Text = window.Text;
+  globals.Comment = window.Comment;
+  globals.Element = window.Element;
+  globals.HTMLElement = window.HTMLElement;
+  globals.Document = window.Document;
+  globals.document = document;
+  globals.window = window;
+}
+var _instance = /*#__PURE__*/new WeakMap();
+var _scheduler = /*#__PURE__*/new WeakMap();
+var _ownsContainer = /*#__PURE__*/new WeakMap();
+var _unmounted = /*#__PURE__*/new WeakMap();
+class HydrateTestAppImplementation {
+  constructor(document, container, component, instance, scheduler, ownsContainer, html, mismatches) {
+    _defineProperty(this, "document", void 0);
+    _defineProperty(this, "container", void 0);
+    _defineProperty(this, "component", void 0);
+    _defineProperty(this, "html", void 0);
+    _defineProperty(this, "mismatches", void 0);
+    _classPrivateFieldInitSpec(this, _instance, void 0);
+    _classPrivateFieldInitSpec(this, _scheduler, void 0);
+    _classPrivateFieldInitSpec(this, _ownsContainer, void 0);
+    _classPrivateFieldInitSpec(this, _unmounted, false);
+    _defineProperty(this, "resolved", async () => {
+      await _classPrivateFieldGet(_scheduler, this).resolved();
+    });
+    _defineProperty(this, "setProps", async props => {
+      if (_classPrivateFieldGet(_unmounted, this)) throw new Error('Cannot set props on an unmounted Tungsten HydrateTestApp.');
+      this.component.props = props;
+      _classPrivateFieldGet(_instance, this).queueUpdate(this.component);
+      await this.resolved();
+    });
+    _defineProperty(this, "unmount", async () => {
+      if (_classPrivateFieldGet(_unmounted, this)) return;
+      _classPrivateFieldSet(_unmounted, this, true);
+      _classPrivateFieldGet(_scheduler, this).cancelPending();
+      let cleanupError;
+      try {
+        this.component.__delete();
+        deleteNodeIfRendered(this.component.__currentContent);
+        this.component.__deleted();
+        _classPrivateFieldGet(_instance, this).disposeRegisteredComponents();
+        await _classPrivateFieldGet(_scheduler, this).resolved();
+      } catch (error) {
+        cleanupError = error;
+        try {
+          _classPrivateFieldGet(_instance, this).disposeRegisteredComponents();
+        } catch {
+          // Preserve the first cleanup failure.
+        }
+      } finally {
+        _classPrivateFieldGet(_scheduler, this).dispose();
+        if (_classPrivateFieldGet(_ownsContainer, this)) this.container.remove();else while (this.container.firstChild !== null) this.container.removeChild(this.container.firstChild);
+      }
+      if (cleanupError !== undefined) throw cleanupError;
+    });
+    this.document = document;
+    this.container = container;
+    this.component = component;
+    _classPrivateFieldSet(_instance, this, instance);
+    _classPrivateFieldSet(_scheduler, this, scheduler);
+    _classPrivateFieldSet(_ownsContainer, this, ownsContainer);
+    this.html = html;
+    this.mismatches = mismatches;
+  }
+}
+/**
+ * The hydration round trip createTestApp() deliberately doesn't cover: render a component to
+ * HTML the way a real server would, parse it with a real HTML parser, hydrate a fresh client
+ * instance against the result, and hand back the live, hydrated component - still fully usable
+ * via setProps()/resolved(), exactly like createTestApp()'s result.
+ *
+ * By default `props` renders on both sides, so a passing test proves an ordinary page hydrates
+ * clean (`mismatches` empty). Pass `serverProps` to diverge the two passes on purpose and assert
+ * on the resulting `mismatches` - the case a one-off "does the reconciler still agree with real
+ * served pages" script never could, because nothing fed it markup that didn't already match.
+ *
+ * A structural mismatch (a different tag, a different number of children) is not something
+ * reconcileHydratedAttributes() can fix - hydrateRootComponent() throws, exactly as the real
+ * client hydrator does, so a caller reproducing that class of bug should assert on the rejection.
+ */
+export async function hydrateTestApp(RootComponent, ...args) {
+  await ensureTestEnvLoaded();
+  const options = args[0]; // eslint-disable-line no-type-assertion/no-type-assertion
+  const suppliedDocument = options?.document ?? globalThis.document; // eslint-disable-line no-type-assertion/no-type-assertion
+  if (suppliedDocument === undefined) {
+    // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+    throw new Error('hydrateTestApp() 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 HydrateTestApp container must belong to options.document.');
+  }
+  if (container.childNodes.length > 0) {
+    throw new Error('The HydrateTestApp container must be empty before hydrating.');
+  }
+  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 clientProps = options?.props ?? {}; // eslint-disable-line no-type-assertion/no-type-assertion
+  const serverProps = options?.serverProps ?? clientProps;
+  const location = options?.location ?? '/';
+  const globalData = options?.globalData ?? {}; // eslint-disable-line no-type-assertion/no-type-assertion
+  const matchedRouteInfo = {
+    key: null,
+    params: options?.routeParams ?? {},
+    content: null,
+    ...(options !== undefined && 'routeData' in options ? {
+      data: options.routeData
+    } : {})
+  };
+  const instanceConfig = {
+    prod: false,
+    useRootComponent: true,
+    clientSideNav: false,
+    siteBasePath: '/',
+    staticSite: false,
+    csr: options?.csr ?? false
+  };
+  const emptyRoutes = {}; // eslint-disable-line no-type-assertion/no-type-assertion -- not exercised by hydration tests
+  // eslint-disable-next-line no-type-assertion/no-type-assertion -- rootToHtml.ts builds a root content node the same way
+  const componentNode = {
+    [$type]: RootComponent,
+    [$props]: serverProps
+  };
+  // Server pass: a throwaway Instance whose only job is producing the HTML a real server would
+  // have sent for `serverProps`. Never returned, never touched again once `html` is captured.
+  const ssrScheduler = new UpdateScheduler();
+  let html;
+  try {
+    const {
+      internalStore,
+      stores,
+      storeSubscriptions
+    } = initStores(location, null, globalData, matchedRouteInfo);
+    const ssrInstance = new Instance(location, instanceConfig, null, emptyRoutes, emptyRoutes,
+    // eslint-disable-line no-type-assertion/no-type-assertion
+    internalStore, stores, storeSubscriptions, globalData, matchedRouteInfo, {
+      document,
+      window: document.defaultView,
+      scheduler: ssrScheduler,
+      navigation: false
+    });
+    for (const override of options?.stores ?? []) {
+      const store = override.registration.getStore(ssrInstance.stores);
+      await override.initialize(store);
+    }
+    const renderingTree = await contentTreeToRenderingTree(componentNode, null, ssrInstance, false);
+    const headData = {
+      found: false,
+      instance: ssrInstance,
+      clientImportAliases: {},
+      importAliases: {},
+      compilationLocation: '',
+      dev: false,
+      tungstenPublicEnv: undefined,
+      siteBasePath: '',
+      hmr: true,
+      csr: instanceConfig.csr
+    };
+    html = await renderingNodeToHtml(renderingTree, false, headData, null);
+  } finally {
+    ssrScheduler.dispose();
+  }
+  // A real HTML parser - the same algorithm a browser runs before hydrate() ever sees the page
+  // - not a comparison against the string above, so browser parsing quirks (an auto-closed <p>,
+  // an inserted <tbody>) surface exactly as they would in production.
+  container.innerHTML = html;
+  bridgeHappyDomGlobals(document);
+  const scheduler = new UpdateScheduler();
+  const {
+    internalStore,
+    stores,
+    storeSubscriptions
+  } = initStores(location, null, globalData, matchedRouteInfo);
+  const runtimeContext = {
+    document,
+    window: document.defaultView,
+    scheduler,
+    navigation: false
+  };
+  const instance = new Instance(location, instanceConfig, null, emptyRoutes, emptyRoutes,
+  // eslint-disable-line no-type-assertion/no-type-assertion
+  internalStore, stores, storeSubscriptions, globalData, matchedRouteInfo, runtimeContext);
+  try {
+    for (const override of options?.stores ?? []) {
+      const store = override.registration.getStore(instance.stores);
+      await override.initialize(store);
+    }
+    const meta = {
+      insideForm: false,
+      mismatches: []
+    };
+    const domPointer = new DomPointer(container, 0);
+    const component = await hydrateRootComponent(instance, RootComponent, domPointer, meta, clientProps, options?.routeParams, options?.routeData);
+    return new HydrateTestAppImplementation(document, container, component, instance, scheduler, ownsContainer, html, meta.mismatches);
+  } 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;
+  }
+}