@teamscala/service-boot 0.23.539 → 0.23.541

package/package.json

@@ -19,6 +19,7 @@
 		"@teamscala/content-gate-token": "*",
 		"@teamscala/data-resolvers": "*",
 		"@teamscala/db": "*",
+		"@teamscala/db-org-branding": "*",
 		"@teamscala/document-signing": "*",
 		"@teamscala/email-client": "*",
 		"@teamscala/encryption": "*",
@@ -35,6 +36,7 @@
 		"@teamscala/orpc-openapi": "*",
 		"@teamscala/orpc-ws": "*",
 		"@teamscala/os": "*",
+		"@teamscala/process-spawn": "*",
 		"@teamscala/publish-registry": "*",
 		"@teamscala/puck-boundary": "*",
 		"@teamscala/puck-tree": "*",
@@ -101,6 +103,8 @@
 		"./auth/sign-out.ts": "./src/auth/sign-out.ts",
 		"./bind-page-handler": "./src/bind-page-handler.ts",
 		"./bind-page-handler.ts": "./src/bind-page-handler.ts",
+		"./boot-shell": "./src/boot-shell.ts",
+		"./boot-shell.ts": "./src/boot-shell.ts",
 		"./build-client-assets": "./src/build-client-assets.ts",
 		"./build-client-assets.ts": "./src/build-client-assets.ts",
 		"./build-client-assets/build-lock": "./src/build-client-assets/build-lock.ts",
@@ -303,5 +307,5 @@
 	"repository": "https://github.com/teamgbg/service-boot",
 	"sideEffects": false,
 	"type": "module",
-	"version": "0.23.539"
+	"version": "0.23.541"
 }

package/src/apply-logger-config.test.ts

@@ -1,15 +1,15 @@
 /**
  * @status generated — ts-api-smoke template (scala-test-suites
- * templates/ts_api_smoke.pkl @1.3.0) over the exports map of @teamscala/service-boot.
- * ./apply-logger-config declares 1 runtime export(s) and 3 declared behaviour vector(s);
+ * templates/ts_api_smoke.pkl @1.5.0) over the exports map of @teamscala/service-boot.
+ * ./apply-logger-config declares 1 runtime export(s) and 4 declared behaviour vector(s);
  * this suite asserts the import resolves, the runtime surface matches
  * exactly, and every export carries its declared kind. Regenerate from
- * inputs/server-service-boot-ts/api_smoke.json (scala-test-suites) — hand edits are
+ * inputs/bun-server-service-boot/api_smoke.json (scala-test-suites) — hand edits are
  * overwritten.
  */
 
 import { describe, expect, it } from "bun:test";
-import { mock } from "bun:test";
+const { mock } = await import("bun:test");
 const __setMinLevel: string[] = [];
 const __fileSinks: Record<string, unknown>[] = [];
 mock.module("@teamscala/logger/creator", () => ({ setMinLevel: (level: string) => { __setMinLevel.push(level); } }));
@@ -30,17 +30,22 @@ describe("apply-logger-config exports-map smoke", () => {
 	});
 	it("a declared min level reaches the logger creator", async () => {
 		__setMinLevel.length = 0;
-		applyLoggerConfig({ minLevel: "debug" });
+		applyLoggerConfig({ minLevel: "debug" })
 		expect(__setMinLevel).toEqual(["debug"]);
 	});
 	it("an undeclared min level leaves the creator untouched", async () => {
 		__setMinLevel.length = 0;
-		applyLoggerConfig({});
+		applyLoggerConfig({})
 		expect(__setMinLevel).toEqual([]);
 	});
 	it("the file sink is configured from the boot row's own values", async () => {
 		__fileSinks.length = 0;
-		applyLoggerConfig({ logDir: "/var/log/scala", maxFileSize: 10, maxFiles: 3 });
-		expect(__fileSinks).toEqual([{ logDir: "/var/log/scala", maxFileSize: 10, maxFiles: 3 }]);
+		applyLoggerConfig({ logDir: "/var/log/scala", maxFileSize: 10, maxFiles: 3 })
+		expect(__fileSinks).toEqual([{"logDir": "/var/log/scala", "maxFileSize": 10, "maxFiles": 3}]);
+	});
+	it("a row logDir carrying a host placeholder is resolved before it reaches the file sink", async () => {
+		__fileSinks.length = 0;
+		applyLoggerConfig({ logDir: "${HOME}/.local/share/oxmgr/logs" })
+		expect(__fileSinks).toEqual([{ logDir: `${process.env.HOME}/.local/share/oxmgr/logs`, maxFileSize: undefined, maxFiles: undefined }]);
 	});
 });

package/src/attach-portal-members.test.ts

@@ -6,6 +6,8 @@
 // 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 * as __scalaReal_teamscala_db_query_rows from "@teamscala/db/query-rows";
+import * as __scalaReal_teamscala_auth_get_session from "@teamscala/auth/get-session";
 
 import { describe, expect, mock, test } from "bun:test";
 import { Hono } from "hono";
@@ -19,10 +21,12 @@ let failMemberQuery = false;
 const queryCalls: QueryRowsCall[] = [];
 
 mock.module("@teamscala/auth/get-session", () => ({
+	...__scalaReal_teamscala_auth_get_session,
 	getSession: async () => session,
 }));
 
 mock.module("@teamscala/db/query-rows", () => ({
+	...__scalaReal_teamscala_db_query_rows,
 	queryRows: (strings: TemplateStringsArray, ...values: unknown[]) => {
 		const sql = strings.join("?");
 		queryCalls.push({ sql, values });

package/src/boot-shell.test.ts

@@ -0,0 +1,57 @@
+/**
+ * @status generated — ts-api-smoke template (scala-test-suites
+ * templates/ts_api_smoke.pkl @1.5.0) over the exports map of @teamscala/service-boot.
+ * ./boot-shell declares 1 runtime export(s) and 3 declared behaviour vector(s);
+ * this suite asserts the import resolves, the runtime surface matches
+ * exactly, and every export carries its declared kind. Regenerate from
+ * inputs/bun-server-service-boot/api_smoke.json (scala-test-suites) — hand edits are
+ * overwritten.
+ */
+
+import { describe, expect, it } from "bun:test";
+const { Hono } = await import("hono");
+const { swapApp } = await import("./mutable-app-ref");
+const { __resetReadinessGateForTest, setReady } = await import("./readiness-gate");
+const { __resetPhase2StateForTest, markFullAppDegraded } = await import("./two-phase-readiness");
+
+const mod = await import("./boot-shell");
+
+const { createBootShellApp } = mod;
+
+describe("boot-shell exports-map smoke", () => {
+	it("the runtime export set is exactly the declared surface", () => {
+		expect(Object.keys(mod).sort()).toEqual([
+			"createBootShellApp",
+		]);
+	});
+	it("createBootShellApp is a function", () => {
+		expect(typeof mod["createBootShellApp"]).toBe("function");
+	});
+	it("answers 503 starting on every path while the mount chain runs", async () => {
+		__resetReadinessGateForTest();
+		__resetPhase2StateForTest();
+		const shell = createBootShellApp("boot-shell-test"); const health = await shell.request("/health"); const page = await shell.request("/any/unmounted/path")
+		expect(health.status).toBe(503);
+		expect(await health.json()).toEqual({ status: "starting" });
+		expect(page.status).toBe(503);
+		expect(await page.json()).toEqual({ status: "starting" });
+	});
+	it("delegates to the swapped-in minimal app once ready", async () => {
+		__resetReadinessGateForTest();
+		__resetPhase2StateForTest();
+		swapApp(new Hono().get("/delegated", () => new Response("mounted")), "minimal");
+		setReady();
+		const res = await createBootShellApp("boot-shell-test").request("/delegated")
+		expect(res.status).toBe(200);
+		expect(await res.text()).toBe("mounted");
+	});
+	it("health reports degraded once the boot finished with a failed client build", async () => {
+		__resetReadinessGateForTest();
+		__resetPhase2StateForTest();
+		setReady();
+		markFullAppDegraded("client build is not servable: boot-shell-test");
+		const res = await createBootShellApp("boot-shell-test").request("/health")
+		expect(res.status).toBe(200);
+		expect(await res.json()).toEqual({ status: "degraded", reason: "client build is not servable: boot-shell-test" });
+	});
+});

package/src/boot-shell.ts

@@ -0,0 +1,20 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ */
+
+import type { Hono } from "hono";
+import { Hono } from "hono";
+import { createRequestErrorHandler } from "./hono-error-handler.ts";
+import { getApp } from "./mutable-app-ref.ts";
+import { readinessGate } from "./readiness-gate.ts";
+import { healthHandler } from "./two-phase-readiness.ts";
+
+export function createBootShellApp(serviceSlug: string): Hono {
+	const app = new Hono();
+	app.onError(createRequestErrorHandler(`service-boot:boot-shell:${serviceSlug}`));
+	app.use("*", readinessGate);
+	app.get("/health", healthHandler);
+	app.all("*", (c) => getApp().fetch(c.req.raw, c.env));
+	return app;
+}

package/src/build-client-assets/sourcemaps-upload.test.ts

@@ -6,13 +6,14 @@
 // 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 { mkdtemp, mkdir, readdir, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterAll, afterEach, describe, expect, test } from "bun:test";
+import { afterAll, afterEach, beforeEach, describe, expect, test } from "bun:test";
 import {
 	releaseFromHydratePath,
+	sentryTarget,
+	sourceMapArtifactName,
 	sourceMapsCacheDir,
 	uploadCachedSourceMaps,
 	uploadSourceMaps,
@@ -33,21 +34,37 @@ async function seedMaps(outDir: string, names: string[]): Promise<void> {
 	}
 }
 
+// Full five-method surface: mock.module installs PROCESS-WIDE, so a partial
+// double breaks every suite that imports the logger later (measured 2026-09-30).
 const noopLog = {
+	debug: () => {},
 	info: () => {},
 	warn: () => {},
 	error: () => {},
+	child: () => noopLog,
 } as unknown as ReturnType<typeof import("@teamscala/logger/app-loggers").getAppLogger>;
 
+// The uploader's gate is the DSN the client already reports to, and temps
+// authenticates that endpoint with the DSN PUBLIC KEY — never an API token —
+// so the suite seeds SENTRY_DSN (and clears it) rather than the retired
+// SENTRY_AUTH_TOKEN / SENTRY_URL pair the GlitchTip-era uploader read.
+const UPLOAD_DSN = "https://0123456789abcdef0123456789abcdef@temps.test/12";
+
 afterAll(async () => {
 	for (const d of dirs) await rm(d, { recursive: true, force: true });
 });
 
+beforeEach(() => {
+	delete process.env.SENTRY_DSN;
+	delete process.env.SENTRY_ORG;
+});
+
 afterEach(() => {
 	delete process.env.SENTRY_DSN;
+	delete process.env.SENTRY_ORG;
 });
 
-describe("uploadSourceMaps — skip path (absent env)", () => {
+describe("uploadSourceMaps — skip path (absent SENTRY_DSN)", () => {
 	const currentOutputs = new Set(["hydrate-abc123.js", "chunk-xyz789.js"]);
 	test("maps STILL leave the served root and are retained in the cache", async () => {
 		const cwd = await makeDir();
@@ -80,20 +97,48 @@ describe("uploadSourceMaps — skip path (absent env)", () => {
 
 describe("uploadCachedSourceMaps — the fingerprint-skip retry path", () => {
 	test("no cached maps → failed, naming the release and the reason", async () => {
-		process.env.SENTRY_DSN = "https://cred@glitchtip.test/scala";
+		process.env.SENTRY_DSN = UPLOAD_DSN;
 		const cwd = await makeDir();
 		const result = await uploadCachedSourceMaps(cwd, "deadbeef", noopLog);
 		expect(result.status).toBe("failed");
 		expect(result.failures[0]).toContain("deadbeef");
 	});
 
-	test("absent env → skipped without any upload attempt", async () => {
+	test("absent SENTRY_DSN → skipped without any upload attempt", async () => {
 		const cwd = await makeDir();
 		const result = await uploadCachedSourceMaps(cwd, "abc123", noopLog);
 		expect(result.status).toBe("skipped");
 	});
 });
 
+describe("sourceMapArtifactName — the name temps stores and is looked up by", () => {
+	test("names the SERVED JS path, with .map NOT appended", () => {
+		// temps stores the multipart `name` field verbatim as source_maps.file_path
+		// and matches a frame's abs_path against it (normalized to ~/<path>); it
+		// never appends ".map", so a .map-suffixed name could not symbolicate.
+		expect(sourceMapArtifactName("hydrate-abc123.js.map")).toBe("~/assets/hydrate-abc123.js");
+		expect(sourceMapArtifactName("chunk-xyz789.js.map")).toBe("~/assets/chunk-xyz789.js");
+	});
+});
+
+describe("sentryTarget — one DSN, never a second host/token/project triple", () => {
+	test("derives origin, credential and project from the DSN", () => {
+		expect(sentryTarget(UPLOAD_DSN)).toEqual({
+			origin: "https://temps.test",
+			credential: "0123456789abcdef0123456789abcdef",
+			project: "12",
+		});
+	});
+
+	test("a malformed DSN yields null rather than a partial target", () => {
+		expect(sentryTarget("")).toBeNull();
+		expect(sentryTarget(undefined)).toBeNull();
+		expect(sentryTarget("https://temps.test/12")).toBeNull();
+		expect(sentryTarget("https://key@temps.test")).toBeNull();
+		expect(sentryTarget("https://key@temps.test/")).toBeNull();
+	});
+});
+
 describe("releaseFromHydratePath", () => {
 	test("extracts the bare content hash from a manifest hydratePath", () => {
 		expect(releaseFromHydratePath("/assets/hydrate-9df3aab732.js")).toBe("9df3aab732");
@@ -109,4 +154,4 @@ describe("releaseFromHydratePath", () => {
 		expect(releaseFromHydratePath("/assets/hydrate-9DF3AAB732.js")).toBeNull();
 		expect(releaseFromHydratePath("/assets/hydrate-9df3aab73 2.js")).toBeNull();
 	});
-});
+});

package/src/error-page-logo.test.ts

@@ -1,10 +1,10 @@
 /**
  * @status generated — ts-api-smoke template (scala-test-suites
- * templates/ts_api_smoke.pkl @1.3.0) over the exports map of @teamscala/service-boot.
- * ./error-page-logo declares 2 runtime export(s) and 6 declared behaviour vector(s);
+ * templates/ts_api_smoke.pkl @1.5.0) over the exports map of @teamscala/service-boot.
+ * ./error-page-logo declares 2 runtime export(s) and 10 declared behaviour vector(s);
  * this suite asserts the import resolves, the runtime surface matches
  * exactly, and every export carries its declared kind. Regenerate from
- * inputs/server-service-boot-ts/api_smoke.json (scala-test-suites) — hand edits are
+ * inputs/bun-server-service-boot/api_smoke.json (scala-test-suites) — hand edits are
  * overwritten.
  */
 
@@ -29,36 +29,56 @@ describe("error-page-logo exports-map smoke", () => {
 	it("inlineLogoAsDataUri is a function", () => {
 		expect(typeof mod["inlineLogoAsDataUri"]).toBe("function");
 	});
-	it("inlines a stored logo as a data URI, fetching the bucket key after the /api/assets/ prefix", async () => {
+	it("inlines a stored logo as a data URI, fetching the bucket key after the /api/assets/ prefix [toBeTrue]", async () => {
 		__requested.length = 0;
 		__storageReached = false;
-		const got = await inlineLogoAsDataUri("/api/assets/c503629a/logos/cropped.png", async () => ({ file(key) { __storageReached = true; __requested.push(key); return { stat: async () => ({}), arrayBuffer: async () => new Uint8Array([137, 80, 78, 71]).buffer }; } }));
-		expect(__storageReached).toBeTrue();
+		const got = await inlineLogoAsDataUri("/api/assets/c503629a/logos/cropped.png", async () => ({ file(key) { __storageReached = true; __requested.push(key); return { stat: async () => ({}), arrayBuffer: async () => new Uint8Array([137, 80, 78, 71]).buffer }; } }))
+		expect(__storageReached).toEqual(true);
+	});
+	it("inlines a stored logo as a data URI, fetching the bucket key after the /api/assets/ prefix [toEqual]", async () => {
+		__requested.length = 0;
+		__storageReached = false;
+		const got = await inlineLogoAsDataUri("/api/assets/c503629a/logos/cropped.png", async () => ({ file(key) { __storageReached = true; __requested.push(key); return { stat: async () => ({}), arrayBuffer: async () => new Uint8Array([137, 80, 78, 71]).buffer }; } }))
 		expect(__requested).toEqual(["c503629a/logos/cropped.png"]);
-		expect(got).toBe("data:image/png;base64,iVBORw==");
 	});
-	it("a stored value without the /api/assets/ prefix is refused before storage is touched", async () => {
+	it("inlines a stored logo as a data URI, fetching the bucket key after the /api/assets/ prefix [toBe]", async () => {
+		__requested.length = 0;
+		__storageReached = false;
+		const got = await inlineLogoAsDataUri("/api/assets/c503629a/logos/cropped.png", async () => ({ file(key) { __storageReached = true; __requested.push(key); return { stat: async () => ({}), arrayBuffer: async () => new Uint8Array([137, 80, 78, 71]).buffer }; } }))
+		expect(got).toEqual("data:image/png;base64,iVBORw==");
+	});
+	it("a stored value without the /api/assets/ prefix is refused before storage is touched [toBeFalse]", async () => {
 		__requested.length = 0;
 		__storageReached = false;
-		const got = await inlineLogoAsDataUri("https://cdn.example.com/logo.png", async () => { __storageReached = true; return null; });
-		expect(__storageReached).toBeFalse();
+		const got = await inlineLogoAsDataUri("https://cdn.example.com/logo.png", async () => { __storageReached = true; return null; })
+		expect(__storageReached).toEqual(false);
+	});
+	it("a stored value without the /api/assets/ prefix is refused before storage is touched [toEqual]", async () => {
+		__requested.length = 0;
+		__storageReached = false;
+		const got = await inlineLogoAsDataUri("https://cdn.example.com/logo.png", async () => { __storageReached = true; return null; })
 		expect(__requested).toEqual([]);
+	});
+	it("a stored value without the /api/assets/ prefix is refused before storage is touched [toBeNull]", async () => {
+		__requested.length = 0;
+		__storageReached = false;
+		const got = await inlineLogoAsDataUri("https://cdn.example.com/logo.png", async () => { __storageReached = true; return null; })
 		expect(got).toBeNull();
 	});
 	it("an unavailable storage client returns null", async () => {
-		const got = await inlineLogoAsDataUri("/api/assets/org/logos/cropped.png", async () => null);
+		const got = await inlineLogoAsDataUri("/api/assets/org/logos/cropped.png", async () => null)
 		expect(got).toBeNull();
 	});
 	it("an oversized logo falls back to null instead of bloating the HTML", async () => {
-		const got = await inlineLogoAsDataUri("/api/assets/org/logos/huge.png", async () => ({ file() { return { stat: async () => ({}), arrayBuffer: async () => new ArrayBuffer(100 * 1024 + 1) }; } }));
+		const got = await inlineLogoAsDataUri("/api/assets/org/logos/huge.png", async () => ({ file() { return { stat: async () => ({}), arrayBuffer: async () => new ArrayBuffer(100 * 1024 + 1) }; } }))
 		expect(got).toBeNull();
 	});
 	it("an empty logo file falls back to null", async () => {
-		const got = await inlineLogoAsDataUri("/api/assets/org/logos/empty.png", async () => ({ file() { return { stat: async () => ({}), arrayBuffer: async () => new ArrayBuffer(0) }; } }));
+		const got = await inlineLogoAsDataUri("/api/assets/org/logos/empty.png", async () => ({ file() { return { stat: async () => ({}), arrayBuffer: async () => new ArrayBuffer(0) }; } }))
 		expect(got).toBeNull();
 	});
 	it("the stored mime survives inlining — a .jpg key inlines as image/jpeg", async () => {
-		const got = await inlineLogoAsDataUri("/api/assets/org/logos/wordmark.jpg", async () => ({ file() { return { stat: async () => ({}), arrayBuffer: async () => new Uint8Array([255, 216, 255]).buffer }; } }));
-		expect(got).toBe("data:image/jpeg;base64,/9j/");
+		const got = await inlineLogoAsDataUri("/api/assets/org/logos/wordmark.jpg", async () => ({ file() { return { stat: async () => ({}), arrayBuffer: async () => new Uint8Array([255, 216, 255]).buffer }; } }))
+		expect(got).toEqual("data:image/jpeg;base64,/9j/");
 	});
 });

package/src/mount-orpc-router.test.ts

@@ -6,6 +6,10 @@
 // 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 * as __scalaReal_teamscala_event_log_record_event from "@teamscala/event-log/record-event";
+import * as __scalaReal_teamscala_tool_executor_configure from "@teamscala/tool-executor/configure";
+import * as __scalaReal_teamscala_orpc_configure from "@teamscala/orpc/configure";
+import * as __scalaReal_teamscala_orpc_app_router from "@teamscala/orpc/app-router";
 
 import { mkdir, mkdtemp, rm } from "node:fs/promises";
 import { afterEach, describe, expect, mock, test } from "bun:test";
@@ -72,14 +76,17 @@ describe("mountOrpcRouter generated-artifact seam", () => {
 		// injectors are absent.
 		let seenKeys: Array<string> = [];
 		mock.module("@teamscala/orpc/app-router", () => ({
+	...__scalaReal_teamscala_orpc_app_router,
 			getAppRouter: async () => ({
 				healthz: { health: async () => ({ ok: true }) },
 			}),
 		}));
 		mock.module("@teamscala/orpc/configure", () => ({
+	...__scalaReal_teamscala_orpc_configure,
 			getPrisma: () => ({}),
 		}));
 		mock.module("@teamscala/tool-executor/configure", () => ({
+	...__scalaReal_teamscala_tool_executor_configure,
 			configure: (opts: Record<string, unknown>) => {
 				seenKeys = Object.keys(opts);
 			},
@@ -137,6 +144,7 @@ describe("mountOrpcRouter procedure error hook", () => {
 			}),
 		}));
 		mock.module("@teamscala/event-log/record-event", () => ({
+	...__scalaReal_teamscala_event_log_record_event,
 			recordEvent: (input: { kind: string; payload: unknown }) => {
 				recordedEvents.push(input);
 			},

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.15.0) over @teamscala/service-boot's
+ * templates/ts_function_contract_runner.pkl @1.16.1) 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
@@ -8,6 +8,7 @@
  * test-vector-rows projection row (scala-tools codegen run --repo
  * <consumer>); hand edits are overwritten.
  */
+
 function arithmetic(source: string, value: unknown, slug: string): number {
 	let pos = 0;
 	const text = source;
@@ -955,13 +956,13 @@ function assertRenderSpec(slug: string, container: HTMLElement, spec: Record<str
 }
 
 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 () => {
-			if (!globalThis.document) {
-				const { GlobalRegistrator } = await import("@happy-dom/global-registrator");
-				await GlobalRegistrator.register({ url: "http://localhost" });
-			}
 			(globalThis as Record<string, unknown>).IS_REACT_ACT_ENVIRONMENT = true;
 			const React = await import("react");
 			const { createRoot } = await import("react-dom/client");
@@ -1010,13 +1011,13 @@ async function renderRow(row: Vector): Promise<void> {
 	}
 }
 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 () => {
-			if (!globalThis.document) {
-				const { GlobalRegistrator } = await import("@happy-dom/global-registrator");
-				await GlobalRegistrator.register({ url: "http://localhost" });
-			}
 			(globalThis as Record<string, unknown>).IS_REACT_ACT_ENVIRONMENT = true;
 			const React = await import("react");
 			const { createRoot } = await import("react-dom/client");

package/src/page-server-loader-graph.test.ts

@@ -1,10 +1,10 @@
 /**
  * @status generated — ts-api-smoke template (scala-test-suites
- * templates/ts_api_smoke.pkl @1.3.0) over the exports map of @teamscala/service-boot.
- * ./page-server-loader-graph declares 1 runtime export(s) and 1 declared behaviour vector(s);
+ * templates/ts_api_smoke.pkl @1.5.0) over the exports map of @teamscala/service-boot.
+ * ./page-server-loader-graph declares 1 runtime export(s) and 2 declared behaviour vector(s);
  * this suite asserts the import resolves, the runtime surface matches
  * exactly, and every export carries its declared kind. Regenerate from
- * inputs/server-service-boot-ts/api_smoke.json (scala-test-suites) — hand edits are
+ * inputs/bun-server-service-boot/api_smoke.json (scala-test-suites) — hand edits are
  * overwritten.
  */
 
@@ -23,9 +23,13 @@ describe("page-server-loader-graph exports-map smoke", () => {
 	it("resolveFromLoaderConfig is a function", () => {
 		expect(typeof mod["resolveFromLoaderConfig"]).toBe("function");
 	});
-	it("the SSR binding is a resolver PRODUCT of the engine factory applied to the page-server client — never the factory itself", async () => {
-		const { createLoaderConfigResolver } = await import("@teamscala/loader-config/loader-config/resolve-from-loader-config");
-		expect(typeof createLoaderConfigResolver).toBe("function");
+	it("the SSR binding is a resolver PRODUCT of the engine factory applied to the page-server client — never the factory itself [toBe]", async () => {
+		const { createLoaderConfigResolver } = await import("@teamscala/loader-config/loader-config/resolve-from-loader-config")
+const got = (typeof createLoaderConfigResolver);
+		expect(got).toEqual("function");
+	});
+	it("the SSR binding is a resolver PRODUCT of the engine factory applied to the page-server client — never the factory itself [toBe]", async () => {
+		const { createLoaderConfigResolver } = await import("@teamscala/loader-config/loader-config/resolve-from-loader-config")
 		expect(resolveFromLoaderConfig).not.toBe(createLoaderConfigResolver);
 	});
 });

package/src/read-html-template.test.ts

@@ -6,12 +6,20 @@
 // 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 { afterAll as __scalaRestoreGlobals } from "bun:test";
+import { GlobalRegistrator } from "@happy-dom/global-registrator";
+const __scalaDomWasMissing = !globalThis.document;
+if (__scalaDomWasMissing) GlobalRegistrator.register();
+__scalaRestoreGlobals(async () => {
+    if (__scalaDomWasMissing) await GlobalRegistrator.unregister();
+});
+
 
 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 { readHtmlTemplate } from "./read-html-template.ts";
+const { readHtmlTemplate } = await import("./read-html-template.ts");
 
 let dir: string;
 let origCwd: string;

package/src/readiness-gate.ts

@@ -12,6 +12,10 @@ export function setReady(): void {
 	_ready = true;
 }
 
+export function __resetReadinessGateForTest(): void {
+	_ready = false;
+}
+
 export async function readinessGate(c: Context, next: Next): Promise<Response | void> {
 	try {
 		if (_ready) return next();

package/src/register-registry-page-route/apply-page-branding.test.ts

@@ -6,6 +6,16 @@
 // 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 * as __scalaReal_teamscala_db_org_branding_fetch_organisation_page_branding from "@teamscala/db-org-branding/fetch-organisation-page-branding";
+import * as __scalaReal_teamscala_db_registry_platform from "@teamscala/db/registry/platform";
+import { afterAll as __scalaRestoreGlobals } from "bun:test";
+import { GlobalRegistrator } from "@happy-dom/global-registrator";
+const __scalaDomWasMissing = !globalThis.document;
+if (__scalaDomWasMissing) GlobalRegistrator.register();
+__scalaRestoreGlobals(async () => {
+    if (__scalaDomWasMissing) await GlobalRegistrator.unregister();
+});
+
 
 import { describe, expect, mock, test } from "bun:test";
 
@@ -14,6 +24,7 @@ const TENANT_ORG = "5b742740-0f37-494c-a059-d8399ae4b350";
 const VIEWER_ORG = PLATFORM_ORG;
 
 mock.module("@teamscala/db/registry/platform", () => ({
+	...__scalaReal_teamscala_db_registry_platform,
 	getPlatformOrgId: () => PLATFORM_ORG,
 }));
 
@@ -28,7 +39,8 @@ const fetchBranding = mock(async () => ({
 	company_logo_for_light_theme: "/viewer-light.png",
 	company_logo_for_dark_theme: "/viewer-dark.png",
 }));
-mock.module("@teamscala/db/fetch-organisation-page-branding", () => ({
+mock.module("@teamscala/db-org-branding/fetch-organisation-page-branding", () => ({
+	...__scalaReal_teamscala_db_org_branding_fetch_organisation_page_branding,
 	fetchOrganisationPageBranding: fetchBranding,
 }));
 mock.module("../page-server-orpc/server-client.ts", () => ({

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

@@ -6,7 +6,7 @@
 
 
 
-import { fetchOrganisationPageBranding } from "@teamscala/db/fetch-organisation-page-branding";
+import { fetchOrganisationPageBranding } from "@teamscala/db-org-branding/fetch-organisation-page-branding";
 import { getPlatformOrgId } from "@teamscala/db/registry/platform";
 import { getAppLogger } from "@teamscala/logger/app-loggers";
 import { getServerClient } from "../page-server-orpc/server-client.ts";

package/src/register-registry-page-route/live-loader-config.test.ts

@@ -6,6 +6,7 @@
 // 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 * as __scalaReal_teamscala_logger_app_loggers from "@teamscala/logger/app-loggers";
 
 import { GlobalRegistrator } from "@happy-dom/global-registrator";
 import { afterEach, describe, expect, mock, test } from "bun:test";
@@ -44,16 +45,14 @@ mock.module("@teamscala/db/registry/load-config", () => {
 });
 
 // ── The heavy collaborators (recorded, not executed) ───────────────────
-const graphCalls: { loaderConfig: Record<string, unknown>; configFingerprint?: string }[] = [];
+const graphCalls: { loaderConfig: Record<string, unknown> }[] = [];
 
 mock.module("./resolve-request-graph.ts", () => ({
 	resolveRequestGraph: async (args: {
 		loaderConfig: Record<string, unknown>;
-		configFingerprint?: string;
 	}) => {
 		graphCalls.push({
 			loaderConfig: args.loaderConfig,
-			configFingerprint: args.configFingerprint,
 		});
 		return {};
 	},
@@ -93,8 +92,18 @@ mock.module("../bind-page-handler.ts", () => ({
 		_request: Request,
 	) => c.json(await handler.loadData(c.req.raw)),
 }));
+// Full five-method surface: mock.module installs PROCESS-WIDE, so a partial
+// double breaks every suite that imports the logger later (measured 2026-09-30).
+const loggerDouble = {
+	debug: () => {},
+	info: () => {},
+	warn: () => {},
+	error: () => {},
+	child: () => loggerDouble,
+};
 mock.module("@teamscala/logger/app-loggers", () => ({
-	getAppLogger: () => ({ info: () => {}, warn: () => {} }),
+	...__scalaReal_teamscala_logger_app_loggers,
+	getAppLogger: () => loggerDouble,
 }));
 
 const { registerRegistryPageRoute } = await import(