@teamscala/service-boot 0.23.541 → 0.23.543

package/package.json

@@ -4,6 +4,13 @@
 		"status": "generated",
 		"edit": "edit src/ — dependencies and exports derive from imports; everything else preserved"
 	},
+	"publishConfig": {
+		"registry": "https://registry.npmjs.org"
+	},
+	"repository": "https://github.com/teamgbg/service-boot",
+	"sideEffects": false,
+	"type": "module",
+	"version": "0.23.543",
 	"dependencies": {
 		"@orpc/openapi": "*",
 		"@orpc/server": "*",
@@ -227,6 +234,8 @@
 		"./register-registry-page-route/resolve-panel-page.ts": "./src/register-registry-page-route/resolve-panel-page.ts",
 		"./register-registry-page-route/resolve-request-graph": "./src/register-registry-page-route/resolve-request-graph.ts",
 		"./register-registry-page-route/resolve-request-graph.ts": "./src/register-registry-page-route/resolve-request-graph.ts",
+		"./register-registry-page-route/resolve-signed-in-org": "./src/register-registry-page-route/resolve-signed-in-org.ts",
+		"./register-registry-page-route/resolve-signed-in-org.ts": "./src/register-registry-page-route/resolve-signed-in-org.ts",
 		"./register-registry-page-route/run-content-gates": "./src/register-registry-page-route/run-content-gates.ts",
 		"./register-registry-page-route/run-content-gates.ts": "./src/register-registry-page-route/run-content-gates.ts",
 		"./register-registry-page-route/single-page-data": "./src/register-registry-page-route/single-page-data.ts",
@@ -300,12 +309,5 @@
 		"@teamscala/chat-completion": {
 			"optional": true
 		}
-	},
-	"publishConfig": {
-		"registry": "https://registry.npmjs.org"
-	},
-	"repository": "https://github.com/teamgbg/service-boot",
-	"sideEffects": false,
-	"type": "module",
-	"version": "0.23.541"
+	}
 }

package/src/build-client-assets/manifest.ts

@@ -4,6 +4,7 @@
  */
 
 import { join } from "node:path";
+import { createSafeFallback } from "@teamscala/safe-fallback/create-safe-fallback";
 import type { SourceMapUploadResult } from "./sourcemaps-upload.ts";
 
 export const MANIFEST_FILE = "asset-manifest.json";
@@ -22,23 +23,60 @@ export interface FailedBuildManifest {
 
 export type ManifestFile = AssetManifest | FailedBuildManifest;
 
-export async function readManifest(outDir: string): Promise<AssetManifest | null> {
+export type ManifestState =
+	| { state: "assets"; manifest: AssetManifest }
+	| { state: "build-failed"; manifest: FailedBuildManifest }
+	| { state: "absent" };
+
+const manifestRead = createSafeFallback<ManifestState>({
+	name: "service-boot:asset-manifest-read",
+	onFailure: "fail-closed-warn",
+	degradedResult: { state: "absent" },
+});
+
+export async function readManifestState(outDir: string): Promise<ManifestState> {
 	const path = join(outDir, MANIFEST_FILE);
-	if (!(await Bun.file(path).exists())) return null;
-	try {
-		const parsed = (await Bun.file(path).json()) as ManifestFile;
-		if ("buildFailed" in parsed) return null;
-		if (parsed.stylesPath && parsed.hydratePath) {
-			return {
+	if (!(await Bun.file(path).exists())) return { state: "absent" };
+	const parsed = await manifestRead.call(
+		() => Bun.file(path).json() as Promise<ManifestFile>,
+	);
+	if ("buildFailed" in parsed) return { state: "build-failed", manifest: parsed };
+	if (parsed.stylesPath && parsed.hydratePath) {
+		return {
+			state: "assets",
+			manifest: {
 				stylesPath: parsed.stylesPath,
 				hydratePath: parsed.hydratePath,
 				sourceMaps: parsed.sourceMaps,
-			};
-		}
-		return null;
-	} catch {
-		return null;
+			},
+		};
 	}
+	return { state: "absent" };
+}
+
+export function verifyManifestState(
+	state: ManifestState,
+	outDir: string,
+): { ok: true; manifest: AssetManifest } | { ok: false; reason: string } {
+	if (state.state === "build-failed") {
+		return {
+			ok: false,
+			reason:
+				`the client build recorded its own failure at ${state.manifest.buildFailedAt}: ${state.manifest.buildFailedReason} ` +
+				`(asset manifest ${join(outDir, MANIFEST_FILE)}) — the artifact records a failed build, so nothing it names is servable; ` +
+				`fix the build the reason names and restart`,
+		};
+	}
+	if (state.state === "assets") return { ok: true, manifest: state.manifest };
+	return {
+		ok: false,
+		reason: `no readable asset manifest at ${join(outDir, MANIFEST_FILE)} — the client build never ran or its output is gone`,
+	};
+}
+
+export async function readManifest(outDir: string): Promise<AssetManifest | null> {
+	const verdict = verifyManifestState(await readManifestState(outDir), outDir);
+	return verdict.ok ? verdict.manifest : null;
 }
 
 export async function writeManifest(
@@ -55,13 +93,9 @@ export async function verifyClientBuildAssets(
 	cwd = process.cwd(),
 ): Promise<{ ok: true } | { ok: false; reason: string }> {
 	const outDir = join(cwd, "dist", "client");
-	const manifest = await readManifest(outDir);
-	if (!manifest || !manifest.stylesPath || !manifest.hydratePath) {
-		return {
-			ok: false,
-			reason: `no readable asset manifest at ${join(outDir, MANIFEST_FILE)} — the client build never ran or its output is gone`,
-		};
-	}
+	const verdict = verifyManifestState(await readManifestState(outDir), outDir);
+	if (!verdict.ok) return verdict;
+	const manifest = verdict.manifest;
 	for (const [label, url] of [
 		["stylesheet", manifest.stylesPath],
 		["hydrate bundle", manifest.hydratePath],

package/src/module-not-found.ts

@@ -20,3 +20,13 @@ export function isModuleNotFound(err: unknown, requestedPath: string): boolean {
 		msg.includes(`Cannot find package '${bare}'`)
 	);
 }
+
+export function isExportsSubpathMiss(err: unknown): boolean {
+	if ((err as { code?: string })?.code === "ERR_PACKAGE_PATH_NOT_EXPORTED") {
+		return true;
+	}
+	const msg =
+		(err as { message?: string })?.message ??
+		(typeof err === "string" ? err : String(err));
+	return msg.includes('is not defined by "exports"');
+}

package/src/mount-server-packages.ts

@@ -3,20 +3,6 @@
  * @status handwritten
  */
 
-/**
- * Speculatively import every server_package's mount module so Bun compiles
- * the module graphs into its cache NOW, overlapping the (CPU-bound)
- * compilation with whatever I/O the caller runs next. When mountServerPackages
- * later imports the same paths they hit the cache (instant).
- *
- * Same pattern as create-boot-pipeline's speculative preloads — the
- * cross-internet DB I/O in the gate chain (~3.4s) is dead time the compiler
- * can use. Best-effort + non-fatal: a failed import here (wrong candidate
- * path, transient resolution race) is silently swallowed because
- * mountServerPackages will re-attempt with full error surfacing; the preload
- * only warms the cache, never gates boot.
- */
-
 import type { ServiceInstallConfig } from "./load-service-install-row";
 import { getAppLogger } from "@teamscala/logger/app-loggers";
 import { BootFatalError } from "@teamscala/os/errors/boot-error";
@@ -27,15 +13,12 @@ import {
 	type MountRegistry,
 } from "@teamscala/os/runtime-contracts/mount-context";
 import type { Hono } from "hono";
-import { isModuleNotFound } from "./module-not-found";
+import { isExportsSubpathMiss, isModuleNotFound } from "./module-not-found";
 
 type ServerPackageMount = (ctx: MountContext) => Promise<void> | void;
 
-/** Candidate import paths tried for each server_package, in priority order.
- *  Shared by preloadServerPackages (cache-warming) and mountServerPackages
- *  (resolution) so the candidate set has ONE source of truth. */
 function mountCandidates(pkg: string): string[] {
-	return [`${pkg}/mount.ts`, `${pkg}/boot/mount.ts`, pkg];
+	return [`${pkg}/mount`, `${pkg}/boot/mount`, pkg];
 }
 
 export async function preloadServerPackages(packages: string[]): Promise<void> {
@@ -81,7 +64,7 @@ export async function mountServerPackages(
 					loaded = true;
 					break;
 				} catch (err) {
-					if (isModuleNotFound(err, candidate)) {
+					if (isModuleNotFound(err, candidate) || isExportsSubpathMiss(err)) {
 						lastNotFound = err;
 						continue;
 					}
@@ -112,6 +95,10 @@ export async function mountServerPackages(
 				log.info(
 					`[scala-install:${serviceSlug}] Mounted server_package: ${pkg} (via ${resolved})`,
 				);
+			} else {
+				log.warn(
+					`[scala-install:${serviceSlug}] server_package ${pkg} resolved at ${resolved} but exports no mount function — nothing registered`,
+				);
 			}
 		} catch (err) {
 			if (err instanceof BootFatalError) throw err;

package/src/orpc-contract-rows.json

@@ -295,6 +295,25 @@
       "suite_type": "function_call",
       "slug": "quiz-gate:gate-declares-the-one-view-entry-marker"
     },
+    {
+      "args": [
+        {
+          "state": "absent"
+        },
+        "/srv/app/dist/client"
+      ],
+      "note": "Bug 01a14918-f66b companion: the misdiagnosis reason is RESERVED for a manifest that is genuinely absent (or a carrying shape with no paths), never for a tombstone the build wrote.",
+      "label": "an actually-absent manifest is the only case 'never ran or its output is gone' describes",
+      "expect": {
+        "ok": false,
+        "reason": "no readable asset manifest at /srv/app/dist/client/asset-manifest.json — the client build never ran or its output is gone"
+      },
+      "export": "verifyManifestState",
+      "module": "src/build-client-assets/manifest.ts",
+      "package": "@teamscala/service-boot",
+      "suite_type": "function_call",
+      "slug": "service-boot:absent-manifest-verdict-reserves-never-ran"
+    },
     {
       "args": [
         "@teamscala/cli-session"
@@ -4178,6 +4197,30 @@
       "package": "@teamscala/service-boot",
       "suite_type": "function_call",
       "slug": "service-boot:to-capability-slug-strips-the-language-and-tier-suffix-from-a-prod-deployable-scala-projects-ts-prod"
+    },
+    {
+      "args": [
+        {
+          "state": "build-failed",
+          "manifest": {
+            "buildFailed": true,
+            "buildFailedAt": "2026-10-17T08:18:00.000Z",
+            "buildFailedReason": "hydrate build failed: Could not resolve \"@teamscala/ui-foundation/list/block\""
+          }
+        },
+        "/srv/app/dist/client"
+      ],
+      "note": "Bug 01a14918-f66b (Build and release desk, delivery 01a1492e): the boot surfaces carried 'the client build never ran or its output is gone' where the artifact records buildFailedReason+buildFailedAt. The verdict is a pure function of the parsed manifest state, so the misdiagnosis for a tombstone is unmakeable.",
+      "label": "a failed-build tombstone verdict quotes the recorded reason, never the misdiagnosis",
+      "expect": {
+        "ok": false,
+        "reason": "the client build recorded its own failure at 2026-10-17T08:18:00.000Z: hydrate build failed: Could not resolve \"@teamscala/ui-foundation/list/block\" (asset manifest /srv/app/dist/client/asset-manifest.json) — the artifact records a failed build, so nothing it names is servable; fix the build the reason names and restart"
+      },
+      "export": "verifyManifestState",
+      "module": "src/build-client-assets/manifest.ts",
+      "package": "@teamscala/service-boot",
+      "suite_type": "function_call",
+      "slug": "service-boot:tombstone-manifest-verdict-quotes-the-recorded-failure"
     }
   ]
 }

package/src/orpc-contract-rows.test.ts

@@ -1,6 +1,6 @@
 /**
  * @status generated — ts_function_contract_runner template (scala-test-suites
- * templates/ts_function_contract_runner.pkl @1.16.1) over @teamscala/service-boot's
+ * templates/ts_function_contract_runner.pkl @1.16.3) over @teamscala/service-boot's
  * test_vector rows: one `it` per function_call row (args -> value or
  * expect_error) and one per fs_flow row (ordered steps in a temp
  * workspace). This runner carries NO facts: every case is the registry
@@ -111,7 +111,7 @@ const ROOT = (() => {
 	throw new Error("no package.json above " + import.meta.dir + " — a contract suite renders inside a package");
 })();
 
-type Vector = Record<string, unknown> & { suite_type: string; slug: string };
+type Vector = Record<string, unknown> & { suite_type: string; slug: string; module: string; export: string; env?: Record<string, string>; args?: unknown[]; fixtures?: { stubs?: Stub[] } };
 
 let ACTIVE_RECORDERS: Record<string, { args: unknown[] }[]> = {};
 function declareRecorder(name: string): void {
@@ -133,7 +133,7 @@ async function decodeValue(value: unknown): Promise<unknown> {
 			? ((await import(spec.module)) as Record<string, unknown>)[spec.class]
 			: (globalThis as Record<string, unknown>)[spec.class];
 		if (typeof ctor !== "function") throw new Error("unconstructible error class: " + spec.class);
-		return new ctor(...(spec.args ?? []));
+		return Reflect.construct(ctor, spec.args ?? []);
 	}
 	if (value !== null && typeof value === "object" && "$abort" in (value as object)) {
 		const spec = (value as { $abort: { afterMs?: unknown } }).$abort;
@@ -157,7 +157,7 @@ async function decodeValue(value: unknown): Promise<unknown> {
 		if (typeof value === "object" && value !== null && "$map" in (value as object)) {
 			const spec = (value as { $map: { entries?: unknown[] } }).$map;
 			if (spec === null || typeof spec !== "object" || (spec.entries !== undefined && !Array.isArray(spec.entries))) throw new Error("$map needs {entries?} — an array of [key, value] pairs, or nothing for the empty map a subject is handed when it has nothing to say");
-			const pairs: unknown[][] = [];
+			const pairs: [unknown, unknown][] = [];
 			for (const [i, entry] of ((spec.entries ?? []) as unknown[]).entries()) {
 				if (!Array.isArray(entry) || entry.length !== 2) throw new Error("$map entry " + i + " is " + JSON.stringify(entry) + " — a map entry is a [key, value] pair, and a pair of another length is a typo, not a value");
 				pairs.push([await decodeValue(entry[0]), await decodeValue(entry[1])]);
@@ -851,6 +851,34 @@ function isHook(spec: unknown): boolean {
 	return spec !== null && typeof spec === "object" && !Array.isArray(spec) && (spec as Record<string, unknown>).hook !== undefined;
 }
 
+function hookResultText(value: unknown, seen: Set<object>): string {
+	if (value === null) return "null";
+	const kind = typeof value;
+	if (kind === "string") return JSON.stringify(value);
+	if (kind === "number") return Number.isFinite(value) ? String(value) : "null";
+	if (kind === "bigint") return String(value);
+	if (kind === "symbol") return String(value);
+	if (kind === "function") return "[function " + (value as { name?: string }).name + "]";
+	const asObject = value as object;
+	if (seen.has(asObject)) return "[cyclic]";
+	seen.add(asObject);
+	let text: string;
+	if (Array.isArray(value)) {
+		text = "[" + Array.from(value as unknown[], (entry) => (entry === undefined || typeof entry === "function" || typeof entry === "symbol" ? "null" : hookResultText(entry, seen))).join(",") + "]";
+	} else if (typeof (value as { toJSON?: (this: unknown) => unknown }).toJSON === "function") {
+		text = hookResultText((value as { toJSON: (this: unknown) => unknown }).toJSON.call(value), seen);
+	} else {
+		const members: string[] = [];
+		for (const [key, inner] of Object.entries(value as Record<string, unknown>)) {
+			if (inner === undefined || typeof inner === "function" || typeof inner === "symbol") continue;
+			members.push(JSON.stringify(key) + ":" + hookResultText(inner, seen));
+		}
+		text = "{" + members.join(",") + "}";
+	}
+	seen.delete(asObject);
+	return text;
+}
+
 function assertHookResult(slug: string, latest: unknown, spec: Record<string, unknown>): void {
 	if (latest === null || typeof latest !== "object") throw new Error("row " + slug + " outcome hook did not hold: the hook returned " + JSON.stringify(latest) + ", which carries no field to read");
 	const value = latest as Record<string, unknown>;
@@ -858,11 +886,14 @@ function assertHookResult(slug: string, latest: unknown, spec: Record<string, un
 		if (!(field in value)) throw new Error("row " + slug + " outcome hook did not hold: the hook returned no field " + field + ", so a claim over it asserts nothing");
 		expect(value[field]).toEqual(want);
 	}
-	const text = JSON.stringify(value) ?? "";
-	for (const needle of (spec.contains ?? []) as string[]) {
+	const contains = (spec.contains ?? []) as string[];
+	const absent = (spec.absent ?? []) as string[];
+	if (contains.length === 0 && absent.length === 0) return;
+	const text = hookResultText(value, new Set());
+	for (const needle of contains) {
 		if (!text.includes(needle)) throw new Error("row " + slug + " outcome hook did not hold: the hook's result does not contain " + JSON.stringify(needle));
 	}
-	for (const needle of (spec.absent ?? []) as string[]) {
+	for (const needle of absent) {
 		if (text.includes(needle)) throw new Error("row " + slug + " outcome hook did not hold: the hook's result still carries " + JSON.stringify(needle));
 	}
 }
@@ -893,189 +924,6 @@ function isRenderRow(spec: unknown, args: unknown[] | undefined): boolean {
 	return isRender(spec) || (args !== undefined && args.some(hasMarker));
 }
 
-function buildElements(React: typeof import("react"), value: unknown, slug: string): unknown {
-	if (Array.isArray(value)) return value.map((item, index) => {
-		const builtItem = buildElements(React, item, slug);
-		if (builtItem !== null && typeof builtItem === "object" && (builtItem as Record<string, unknown>).$$typeof !== undefined) return React.cloneElement(builtItem, { key: String(index) });
-		return builtItem;
-	});
-	if (value !== null && typeof value === "object") {
-		const record = value as Record<string, unknown>;
-		if (Object.keys(record).includes(ELEMENT_MARKER)) {
-			if (typeof record[ELEMENT_MARKER] !== "string") throw new Error("row " + slug + " is malformed: " + ELEMENT_MARKER + " takes the error message string, got " + JSON.stringify(record[ELEMENT_MARKER]));
-			const message = record[ELEMENT_MARKER] as string;
-			return React.createElement(function Thrower(): never {
-				throw new Error(message);
-			});
-		}
-		const built: Record<string, unknown> = {};
-		for (const key of Object.keys(record)) {
-			if (key.startsWith("$")) throw new Error("row " + slug + " is malformed: element marker " + key + " is not declared — a marker this runner does not know is a child that would render as inert data");
-			built[key] = buildElements(React, record[key], slug);
-		}
-		return built;
-	}
-	return value;
-}
-
-function assertRenderSpec(slug: string, container: HTMLElement, spec: Record<string, unknown>): void {
-	const text = container.textContent ?? "";
-	const bad: (verb: string, detail: string) => never = (verb, detail) => {
-		throw new Error("row " + slug + " outcome " + verb + " did not hold: " + detail);
-	};
-	for (const needle of (spec.contains ?? []) as string[]) {
-		if (!text.includes(needle)) bad("contains", "the rendered text has no " + JSON.stringify(needle));
-	}
-	for (const needle of (spec.absent ?? []) as string[]) {
-		if (text.includes(needle)) bad("absent", "the rendered text still carries " + JSON.stringify(needle));
-	}
-	for (const selector of (spec.selector_present ?? []) as string[]) {
-		if (container.querySelector(selector) === null) bad("selector_present", "no element matches " + selector);
-	}
-	for (const selector of (spec.selector_absent ?? []) as string[]) {
-		if (container.querySelector(selector) !== null) bad("selector_absent", selector + " is present");
-	}
-	for (const [selector, claims] of Object.entries((spec.attr_equals ?? {}) as Record<string, Record<string, string>>)) {
-		const el = container.querySelector(selector);
-		if (el === null) bad("attr_equals", selector + " matches no element, so an attribute claim over it asserts nothing");
-		for (const [attr, want] of Object.entries(claims)) {
-			const got = el.getAttribute(attr);
-			if (got !== String(want)) bad("attr_equals", selector + " carries " + attr + "=" + JSON.stringify(got) + ", the row declares " + JSON.stringify(String(want)));
-		}
-	}
-	for (const [selector, claims] of Object.entries((spec.attr_contains ?? {}) as Record<string, Record<string, string[]>>)) {
-		const el = container.querySelector(selector);
-		if (el === null) bad("attr_contains", selector + " matches no element, so an attribute claim over it asserts nothing");
-		for (const [attr, needles] of Object.entries(claims)) {
-			const got = el.getAttribute(attr) ?? "";
-			for (const needle of needles) {
-				if (!got.includes(needle)) bad("attr_contains", selector + " carries " + attr + "=" + JSON.stringify(got) + ", which does not carry " + JSON.stringify(needle));
-			}
-		}
-	}
-}
-
-async function renderRow(row: Vector): Promise<void> {
-	if (!globalThis.document) {
-		const { GlobalRegistrator } = await import("@happy-dom/global-registrator");
-		await GlobalRegistrator.register({ url: "http://localhost" });
-	}
-	const restore = applyEnv(row.env);
-	try {
-		await withStubs(row, async () => {
-			(globalThis as Record<string, unknown>).IS_REACT_ACT_ENVIRONMENT = true;
-			const React = await import("react");
-			const { createRoot } = await import("react-dom/client");
-			const act = (React as unknown as { act: (run: () => Promise<void>) => Promise<void> }).act;
-			const Component = await loadExport(row.module, row.export);
-			if (typeof Component !== "function") throw new Error("export " + row.export + " in " + row.module + " is not a component — a render row needs a callable component export");
-			const decoded = await Promise.all(((row.args ?? []) as unknown[]).map(decodeValue));
-			const props = decoded.length === 0 ? {} : buildElements(React, decoded[0], row.slug);
-			const host = document.createElement("div");
-			document.body.appendChild(host);
-			const root = createRoot(host);
-			let caught: unknown;
-			try {
-				await act(async () => {
-					root.render(React.createElement(Component as never, props as Record<string, unknown>));
-				});
-			} catch (err) {
-				caught = err;
-			}
-			if (row.expect_error !== undefined) {
-				if (caught === undefined) throw new Error("row " + row.slug + " expected the render to throw " + JSON.stringify(row.expect_error) + ", and it returned a tree");
-				const message = caught instanceof Error ? caught.message : String(caught);
-				if (!message.includes(String(row.expect_error))) throw new Error("row " + row.slug + " outcome expect_error did not hold: the render threw " + JSON.stringify(message));
-				await act(async () => { root.unmount(); });
-				host.remove();
-				return;
-			}
-			if (caught !== undefined) throw caught instanceof Error ? caught : new Error(String(caught));
-			const clickSelectors = ((row.expect as Record<string, unknown>).render as Record<string, unknown>).click;
-			if (clickSelectors !== undefined) {
-				for (const selector of (Array.isArray(clickSelectors) ? clickSelectors : [clickSelectors]) as string[]) {
-					const target = host.querySelector(selector);
-					if (target === null) throw new Error("row " + row.slug + " outcome click did not hold: no element matches " + selector);
-					await act(async () => {
-						target.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
-					});
-				}
-			}
-			assertRenderSpec(row.slug, host, (row.expect as Record<string, unknown>).render as Record<string, unknown>);
-			await act(async () => { root.unmount(); });
-			host.remove();
-		});
-
-	} finally {
-		restore();
-	}
-}
-async function hookRow(row: Vector): Promise<void> {
-	if (!globalThis.document) {
-		const { GlobalRegistrator } = await import("@happy-dom/global-registrator");
-		await GlobalRegistrator.register({ url: "http://localhost" });
-	}
-	const restore = applyEnv(row.env);
-	try {
-		await withStubs(row, async () => {
-			(globalThis as Record<string, unknown>).IS_REACT_ACT_ENVIRONMENT = true;
-			const React = await import("react");
-			const { createRoot } = await import("react-dom/client");
-			const act = (React as unknown as { act: (run: () => Promise<void>) => Promise<void> }).act;
-			const hook = await loadExport(row.module, row.export);
-			if (typeof hook !== "function") throw new Error("export " + row.export + " in " + row.module + " is not a hook — a hook row mounts the export and drives what it returns");
-			const decoded = await Promise.all(((row.args ?? []) as unknown[]).map(decodeValue));
-			if (decoded.length > 1) throw new Error("a hook row takes at most one arg — the options object the hook is mounted with");
-			const options = decoded.length === 0 ? {} : decoded[0];
-			let latest: unknown = undefined;
-			const held: { value: unknown } = { value: undefined };
-			ACTIVE_HOOK = held;
-			function Probe(): null {
-				latest = (hook as (o: unknown) => unknown)(options);
-				held.value = latest;
-				return null;
-			}
-			const spec = ((row.expect as Record<string, unknown>).hook) as Record<string, unknown>;
-			const providerName = spec.provider as string | undefined;
-			let wrapped: unknown = React.createElement(Probe);
-			if (providerName !== undefined) {
-				const provider = await loadExport(row.module, providerName);
-				if (typeof provider !== "function") throw new Error("row " + row.slug + " names hook.provider " + providerName + ", which " + row.module + " does not export as a component — a wrapper the module does not export leaves the hook mounted in nothing");
-				const providerProps = await Promise.all(((spec.provider_args ?? []) as unknown[]).map(decodeValue));
-				wrapped = React.createElement(provider as (props: unknown) => unknown, (providerProps.length === 0 ? null : providerProps[0]) as never, React.createElement(Probe));
-			}
-			const root = createRoot(document.createElement("div"));
-			await act(async () => { root.render(wrapped); });
-			for (const [j, entry] of ((spec.act ?? []) as Record<string, unknown>[]).entries()) {
-				const returned = latest as Record<string, unknown> | null | undefined;
-				const fn = returned === null || returned === undefined ? undefined : returned[entry.call as string];
-				if (typeof fn !== "function") throw new Error("row " + row.slug + " outcome hook did not hold: the hook returned no callable " + entry.call + " at act[" + j + "] — a callback the row drives is one the hook itself returns");
-				const actArgs = await Promise.all(((entry.args ?? []) as unknown[]).map(decodeValue));
-				let raised: unknown;
-				let failed = false;
-				try {
-					await act(async () => { await (fn as (...a: unknown[]) => unknown)(...actArgs); });
-				} catch (err) {
-					raised = err;
-					failed = true;
-				}
-				if (entry.expect_error === undefined) {
-					if (failed) throw raised;
-				} else {
-					if (!failed) throw new Error("row " + row.slug + " declares expect_error " + JSON.stringify(String(entry.expect_error)) + " on act[" + j + "] and " + entry.call + " RESOLVED — an act whose failure is the claim must be answered by a rejection");
-					const message = String((raised as Error)?.message ?? raised);
-					if (!message.includes(String(entry.expect_error))) throw new Error("row " + row.slug + " act[" + j + "] " + entry.call + " rejected with " + JSON.stringify(message) + ", which does not carry " + JSON.stringify(String(entry.expect_error)));
-				}
-			}
-			assertHookResult(row.slug, latest, spec.result as Record<string, unknown>);
-			await act(async () => { root.unmount(); });
-			ACTIVE_HOOK = null;
-		});
-	} finally {
-		ACTIVE_HOOK = null;
-		restore();
-	}
-}
 function runFsFlow(row: Vector): Promise<void> {
 	return (async () => {
 		const workspace = await mkdtemp(join(tmpdir(), "contract-"));
@@ -1205,7 +1053,7 @@ function stubReturn(slug: string, group: Stub[], call: Call): unknown {
 }
 
 async function reactCreateElement(): Promise<(tag: string, attrs: Record<string, unknown>) => unknown> {
-	const react = (await import("react")) as { createElement?: unknown };
+	const react = (await import(String("react"))) as { createElement?: unknown };
 	if (typeof react.createElement !== "function") throw new Error("a fixture element stub needs react.createElement, and this package does not resolve react — the arm mocks a COMPONENT, so the runtime that draws one is part of the stub");
 	return react.createElement as (tag: string, attrs: Record<string, unknown>) => unknown;
 }
@@ -1431,8 +1279,6 @@ function runRow(row: Vector): Promise<void> | void {
 	assertWellFormed(row);
 	ACTIVE_RECORDERS = {};
 	if (SELECTED === undefined && (hasFixtures(row) || hasHoist(row))) return runIsolated(row);
-	if (isRenderRow(row.expect, row.args as unknown[] | undefined)) return renderRow(row);
-	if (isHook(row.expect)) return hookRow(row);
 	if (row.suite_type === "fs_flow") return runFsFlow(row);
 	if (row.template !== undefined && row.template !== null) {
 		if (row.args !== undefined && row.args !== null) throw new Error("row " + row.slug + " declares both args and template — a tagged-template subject takes its statement as template, and two ways to say the same call is a row whose intent is unreadable");

package/src/register-page-server-client.ts

@@ -8,6 +8,45 @@ import { join } from "node:path";
 import { getAppLogger } from "@teamscala/logger/app-loggers";
 import { toCapabilitySlug } from "./capability-slug.ts";
 
+function orpcRouterFatalMessage(input: {
+	serviceSlug: string;
+	declaredModelCount: number;
+	declaredModelSample: string;
+	routerPath: string;
+	routerPresent: boolean;
+	loadError: unknown;
+}): string {
+	if (input.routerPresent) {
+		const detail =
+			input.loadError !== undefined
+				? input.loadError instanceof Error
+					? `${input.loadError.message}\n${input.loadError.stack ?? ""}`
+					: String(input.loadError)
+				: "getAppRouter() returned no router and recorded no error";
+		return (
+			`[scala-install:${input.serviceSlug}] service_schema declares ${input.declaredModelCount} ` +
+				`model(s) (${input.declaredModelSample}) and the generated ORPC router EXISTS at ` +
+				`${input.routerPath} but failed to load. The import failure, logged as a warning ` +
+				`above, was:\n${detail}\n` +
+				`Every data-backed page would 500 with MissingLoaderModelCapabilityError while ` +
+				`/health reported 200. This is a package-resolution or broken-artifact fault, NOT a ` +
+				`missing-bundle fault: fix the failing import the error above names (the missing ` +
+				`package, its version window, or the generated artifact) and restart — never patch ` +
+				`the image by hand.`
+		);
+	}
+	return (
+		`[scala-install:${input.serviceSlug}] service_schema declares ${input.declaredModelCount} ` +
+			`model(s) (${input.declaredModelSample}) but no generated ORPC router is present at ` +
+			`${input.routerPath}. Every data-backed page would 500 with ` +
+			`MissingLoaderModelCapabilityError while /health reported 200. This is a BUILD fault: ` +
+			`the codegen_output emission for the ORPC router ` +
+			`(prisma/generated/orpc/routers/index.ts) is missing from the bundle — check that ` +
+			`the service's codegen_output rows are active and their outputs land in the image. ` +
+			`Rebuild via scala-pack; never patch the image by hand.`
+	);
+}
+
 export async function registerPageServerClient(
 	serviceSlug: string,
 ): Promise<void> {
@@ -26,11 +65,13 @@ export async function registerPageServerClient(
 			"prisma/generated/orpc/routers/index.ts",
 		);
 		let appRouter: Record<string, unknown> | null = null;
+		let routerLoadError: unknown;
 		if (existsSync(routerPath)) {
 			try {
 				const { getAppRouter } = await import("@teamscala/orpc/app-router");
 				appRouter = ((await getAppRouter()) as Record<string, unknown>) ?? null;
 			} catch (err) {
+				routerLoadError = err;
 				log.warn(
 					`[scala-install:${serviceSlug}] appRouter load failed — data-backed pages will 500: ${err instanceof Error ? `${err.message}\n${err.stack ?? ""}` : String(err)}`,
 				);
@@ -70,14 +111,14 @@ export async function registerPageServerClient(
 		})();
 		if (declaredModels.length > 0 && !appRouter) {
 			throw new Error(
-				`[scala-install:${serviceSlug}] service_schema declares ${declaredModels.length} ` +
-					`model(s) (${declaredModels.slice(0, 5).join(", ")}${declaredModels.length > 5 ? ", …" : ""}) ` +
-					`but no generated ORPC router is present at ${routerPath}. Every data-backed page ` +
-					`would 500 with MissingLoaderModelCapabilityError while /health reported 200. ` +
-					`This is a BUILD fault: the codegen_output emission for the ORPC router ` +
-					`(prisma/generated/orpc/routers/index.ts) is missing from the bundle — check that ` +
-					`the service's codegen_output rows are active and their outputs land in the image. ` +
-					`Rebuild via scala-pack; never patch the image by hand.`,
+				orpcRouterFatalMessage({
+					serviceSlug,
+					declaredModelCount: declaredModels.length,
+					declaredModelSample: `${declaredModels.slice(0, 5).join(", ")}${declaredModels.length > 5 ? ", …" : ""}`,
+					routerPath,
+					routerPresent: existsSync(routerPath),
+					loadError: routerLoadError,
+				}),
 			);
 		}
 

package/src/register-registry-page-route/resolve-signed-in-org.ts

@@ -0,0 +1,18 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ */
+
+export async function resolveSignedInOrgId(
+	headers: Headers,
+): Promise<string | null> {
+	const { getSession } = await import("@teamscala/auth/get-session.ts");
+	const session = await getSession(headers);
+	if (!session?.user) return null;
+	const { queryRowsUnsafe } = await import("@teamscala/db/query-rows");
+	const rows = (await queryRowsUnsafe(
+		'SELECT fn_resolve_user_org_id($1) AS "resolved"',
+		session.user.id,
+	)) as Array<{ resolved: { orgId: string | null } | null }>;
+	return rows[0]?.resolved?.orgId ?? null;
+}

package/src/register-registry-page-route.ts

@@ -17,6 +17,7 @@ import type { Hono } from "hono";
 import { bindPageHandler } from "./bind-page-handler.ts";
 import { selectServiceRoutes } from "./select-service-routes.ts";
 import { resolveRequestGraph } from "./register-registry-page-route/resolve-request-graph.ts";
+import { resolveSignedInOrgId } from "./register-registry-page-route/resolve-signed-in-org.ts";
 import { stampSessionContext } from "./register-registry-page-route/stamp-session-context.ts";
 import { runContentGatesForPage } from "./register-registry-page-route/run-content-gates.ts";
 import {
@@ -281,6 +282,10 @@ export async function registerRegistryPageRoute(
 		});
 
 		app.get(pattern, async (c) => {
+			if (routeConfig.org_home_redirect) {
+				const homeOrgId = await resolveSignedInOrgId(c.req.raw.headers);
+				if (homeOrgId) return c.redirect(`/${homeOrgId}`, 302);
+			}
 			const routeOrgId = c.req.param("orgId");
 			return bindPageHandler(
 				c,

package/src/build-client-assets/manifest.test.ts

@@ -1,87 +0,0 @@
-// @system codegen
-// @status generated
-// @edit change the suite in the owned-suites band, then re-run codegen. Hand-edits are overwritten.
-//
-// This suite's assertions are OWNED by the codegen band: the band module
-// carries them verbatim, this file is the emission, and hand edits here are
-// overwritten on the next run. The rationale each assertion carries moved
-// with it into the band.
-
-import { mkdir, mkdtemp, rm } from "node:fs/promises";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { writeManifest, verifyClientBuildAssets } from "./manifest.ts";
-
-let dir: string;
-
-beforeEach(async () => {
-	dir = await mkdtemp(join(tmpdir(), "verify-client-build-"));
-	await mkdir(join(dir, "dist", "client"), { recursive: true });
-});
-
-afterEach(async () => {
-	await rm(dir, { recursive: true, force: true });
-});
-
-async function writeAssetFiles(styles: string, hydrate: string): Promise<void> {
-	await Bun.file(join(dir, "dist", "client", styles.replace(/^\/assets\//, ""))).write("body{}");
-	await Bun.file(join(dir, "dist", "client", hydrate.replace(/^\/assets\//, ""))).write("export{}");
-}
-
-describe("verifyClientBuildAssets", () => {
-	test("a manifest whose files both exist verifies", async () => {
-		await writeManifest(join(dir, "dist", "client"), {
-			stylesPath: "/assets/styles-abc.css",
-			hydratePath: "/assets/hydrate-abc.js",
-		});
-		await writeAssetFiles("/assets/styles-abc.css", "/assets/hydrate-abc.js");
-		expect(await verifyClientBuildAssets(dir)).toEqual({ ok: true });
-	});
-
-	test("an absent manifest refuses — the client build never ran", async () => {
-		const result = await verifyClientBuildAssets(dir);
-		expect(result.ok).toBe(false);
-		if (!result.ok) expect(result.reason).toContain("never ran or its output is gone");
-	});
-
-	test("the first-boot tombstone shape (unhashed paths, no files) refuses", async () => {
-		await writeManifest(join(dir, "dist", "client"), {
-			stylesPath: "/assets/styles.css",
-			hydratePath: "/assets/hydrate.js",
-		});
-		const result = await verifyClientBuildAssets(dir);
-		expect(result.ok).toBe(false);
-		if (!result.ok) expect(result.reason).toContain("unbuilt assets");
-	});
-
-	test("a path-less tombstone (the shape build-client-assets now writes) refuses as unbuilt", async () => {
-		await writeManifest(join(dir, "dist", "client"), {
-			inputFingerprint: "failed:2026-09-01T00:00:00.000Z",
-			buildFailed: true,
-			buildFailedReason: "hydrate build failed: something",
-			buildFailedAt: "2026-09-01T00:00:00.000Z",
-		} as never);
-		const result = await verifyClientBuildAssets(dir);
-		expect(result.ok).toBe(false);
-		if (!result.ok) expect(result.reason).toContain("never ran or its output is gone");
-	});
-
-	test("a manifest naming a file that was deleted refuses (stale-bundle shape)", async () => {
-		await writeManifest(join(dir, "dist", "client"), {
-			stylesPath: "/assets/styles-abc.css",
-			hydratePath: "/assets/hydrate-abc.js",
-		});
-		await writeAssetFiles("/assets/styles-abc.css", "/assets/hydrate-abc.js");
-		await rm(join(dir, "dist", "client", "hydrate-abc.js"));
-		const result = await verifyClientBuildAssets(dir);
-		expect(result.ok).toBe(false);
-		if (!result.ok) expect(result.reason).toContain("hydrate bundle");
-	});
-
-	test("an unreadable manifest refuses", async () => {
-		await Bun.file(join(dir, "dist", "client", "asset-manifest.json")).write("{broken");
-		const result = await verifyClientBuildAssets(dir);
-		expect(result.ok).toBe(false);
-	});
-});