@teamscala/service-boot 0.23.447 → 0.23.449

package/package.json

@@ -6,7 +6,7 @@
   },
   "name": "@teamscala/service-boot",
   "type": "module",
-  "version": "0.23.447",
+  "version": "0.23.449",
   "sideEffects": false,
   "imports": {
     "#service-boot/*": "./src/*",

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

@@ -41,13 +41,11 @@ describe("mountOrpcRouter generated-artifact seam", () => {
 		);
 	});
 
-	test("the configured getMcpGatewayUrl returns undefined without throwing (ctx regression)", async () => {
-		// Regression: the previous form read an out-of-scope `ctx` (commit
-		// c39d279) and threw ReferenceError on first invoke. A getter that
-		// crashes when called can hide indefinitely — the regression is a test
-		// that actually CALLS it. Returning undefined explicitly matches what
-		// callers (sdk-mcp-forwarder) already handle: an absent gateway URL
-		// means "SDK tools unusable in this service".
+	test("the generic mount no longer injects a gateway URL — the executor derives its host from the registry", async () => {
+		// The retired MCP_GATEWAY_URL env name and its injector are gone: the
+		// sdk-mcp-forwarder resolves the SDK execution host from the
+		// mcp_server/scala-mcp registry row via loadRegistryConfig. A missing
+		// row refuses at the boundary (assertSdkHostResolved), never via env.
 		const service = await mkdtemp(join(tmpdir(), "mount-orpc-router-test-"));
 		tempDirs.push(service);
 		await mkdir(join(service, "prisma/generated/orpc/routers"), {
@@ -64,8 +62,9 @@ describe("mountOrpcRouter generated-artifact seam", () => {
 		process.chdir(service);
 
 		// Stub the collaborators the mount reaches BEFORE configureToolExecutor
-		// — the point is to capture the opts object and call the getter.
-		const capture: { getMcpGatewayUrl?: () => unknown } = {};
+		// — the point is to capture the opts object and assert the injector is
+		// absent.
+		let seenKeys: Array<string> = [];
 		mock.module("@teamscala/orpc/app-router", () => ({
 			getAppRouter: async () => ({
 				healthz: { health: async () => ({ ok: true }) },
@@ -75,18 +74,14 @@ describe("mountOrpcRouter generated-artifact seam", () => {
 			getPrisma: () => ({}),
 		}));
 		mock.module("@teamscala/tool-executor/configure", () => ({
-			configure: (opts: { getMcpGatewayUrl?: () => unknown }) => {
-				capture.getMcpGatewayUrl = opts.getMcpGatewayUrl;
+			configure: (opts: Record<string, unknown>) => {
+				seenKeys = Object.keys(opts);
 			},
 		}));
 
 		const app = { post: () => {} };
 		await mountOrpcRouter(app as never, "scala-mcp");
 
-		expect(typeof capture.getMcpGatewayUrl).toBe("function");
-		// THE regression: invoking the getter must not throw.
-		expect(() => capture.getMcpGatewayUrl!()).not.toThrow();
-		// And it returns undefined — explicit, never a ReferenceError.
-		expect(capture.getMcpGatewayUrl!()).toBeUndefined();
+		expect(seenKeys).not.toContain("getMcpGatewayUrl");
 	});
 });

package/src/mount-orpc-router.ts

@@ -12,7 +12,7 @@
 import { join } from "node:path";
 import { getAppLogger } from "@teamscala/logger/app-loggers";
 import { registerFnRouters } from "./fn-routers/index.ts";
-import type { InjectedDb8 } from "@teamscala/orpc/configure";
+import type { InjectedDb8 } from "@teamscala/db/db8-registry";
 import type { Hono } from "hono";
 import { bodyLimit } from "hono/body-limit";
 
@@ -86,6 +86,11 @@ export async function mountOrpcRouter(
 					connectionString: process.env.DATABASE_URL,
 					serviceName: serviceSlug,
 				})) as never;
+				// Register for db-core internals (registry loaders, raw fallbacks)
+				// routing v8-first via getDb8() — the same coexistence shape as
+				// the RPC context injection above.
+				const { registerDb8 } = await import("@teamscala/db/db8-registry");
+				registerDb8(db8 as never);
 			}
 		} catch (err) {
 			log.info(
@@ -122,14 +127,6 @@ export async function mountOrpcRouter(
 		configureToolExecutor({
 			getAppRouter: () => getAppRouter(),
 			getPrisma: () => getConfiguredPrisma(),
-			// Central MCP gateway URL — sdk:* tool calls from any non-host service
-			// forward here (scala-mcp owns every @teamscala/api-* adapter per
-			// operator ruling 2026-08-26). Returns undefined explicitly: callers
-			// (sdk-mcp-forwarder) treat absent as "SDK tool unusable in this
-			// service" and refuse with that message. The previous form read an
-			// out-of-scope `ctx` (c39d279) and would have thrown ReferenceError
-			// on first invoke instead of returning undefined.
-			getMcpGatewayUrl: () => undefined,
 			createHostCommandInvoker: (config) => createHostCommandInvoker(config as never),
 			getCallerContext: () => getCallerContext(),
 			decryptSecretConfig: (raw) => decryptSecretConfig(raw as never),

package/src/read-html-template.ts

@@ -53,6 +53,7 @@
 
 import { createCache } from "@teamscala/cache/create-cache";
 import { readClientBuildStatus } from "./build-client-assets/manifest.ts";
+import { themeFontsLink } from "./theme-fonts-link.ts";
 import { join } from "node:path";
 
 interface AssetManifest {
@@ -67,7 +68,7 @@ const PAGE_DOCUMENT = `<!doctype html>
 		<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover, interactive-widget=resizes-content" />
 		<link rel="preconnect" href="https://fonts.googleapis.com" />
 		<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-		<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=optional" />
+		<!--theme-fonts-->
 		<link rel="stylesheet" href="{{stylesPath}}" />
 		<!--head-outlet-->
 	</head>
@@ -140,7 +141,11 @@ export async function readHtmlTemplate(): Promise<string> {
 	}
 	let html = PAGE_DOCUMENT
 		.replace(/\{\{stylesPath\}\}/g, manifest.stylesPath)
-		.replace(/\{\{hydratePath\}\}/g, manifest.hydratePath);
+		.replace(/\{\{hydratePath\}\}/g, manifest.hydratePath)
+		// The head's font families derive from the css_theme row (one source);
+		// captured at cache build — boot-time semantics, a row edit reaches the
+		// envelope on the next service restart.
+		.replace("<!--theme-fonts-->", () => themeFontsLink());
 	// Tombstone stamp — surfaces a failed client build at the served layer.
 	// `<meta>` in <head> is the minimum-invasive vehicle (no layout shift, no
 	// JS dependency, visible via view-source / devtools / a future status

package/src/theme-fonts-link.test.ts

@@ -0,0 +1,98 @@
+/**
+ * @system ui-service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * The served <head> carries every font family the css_theme row declares —
+ * derived from the row (one source), never a hard-coded family list. The old
+ * envelope loaded only Inter, so the proposal heading variant's manuscript
+ * serif never loaded and fell back to Times (2026-09-02).
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+
+type ConfigRow = { fonts?: Record<string, string> } | undefined;
+let injectedConfig: ConfigRow;
+
+mock.module("@teamscala/db/registry/accessors", () => ({
+	getEntryConfig: (_type: string, _slug: string) => injectedConfig,
+}));
+
+const { readHtmlTemplate } = await import("./read-html-template.ts");
+const { primaryFontFamily, themeFontFamilies, themeFontsLink } = await import(
+	"./theme-fonts-link.ts"
+);
+
+const { mkdir, mkdtemp, rm } = await import("node:fs/promises");
+const { tmpdir } = await import("node:os");
+const { join } = await import("node:path");
+const { beforeEach, afterEach } = await import("bun:test");
+
+let dir: string;
+let origCwd: string;
+
+beforeEach(async () => {
+	origCwd = process.cwd();
+	dir = await mkdtemp(join(tmpdir(), "theme-fonts-link-"));
+	await mkdir(join(dir, "dist", "client"), { recursive: true });
+	process.chdir(dir);
+});
+
+afterEach(async () => {
+	process.chdir(origCwd);
+	await rm(dir, { recursive: true, force: true });
+});
+
+async function writeManifest(): Promise<void> {
+	await Bun.file(
+		join(dir, "dist", "client", "asset-manifest.json"),
+	).write(
+		`${JSON.stringify({ stylesPath: "/assets/styles.css", hydratePath: "/assets/hydrate.js" }, null, 2)}\n`,
+	);
+}
+
+async function servedHead(): Promise<string> {
+	await writeManifest();
+	const html = await readHtmlTemplate();
+	return html.slice(0, html.indexOf("</head>"));
+}
+
+describe("theme-fonts-link", () => {
+	test("primaryFontFamily takes the first family of a stack", () => {
+		expect(primaryFontFamily("Inter, sans-serif")).toBe("Inter");
+		expect(primaryFontFamily("'Playfair Display'")).toBe("Playfair Display");
+	});
+
+	test("families derive from the css_theme row, deduplicated", () => {
+		injectedConfig = {
+			fonts: {
+				body: "Inter, sans-serif",
+				heading: "Inter, sans-serif",
+				manuscript: "Playfair Display",
+			},
+		};
+		expect(themeFontFamilies()).toEqual(["Inter", "Playfair Display"]);
+	});
+
+	test("the served head carries every family the row declares", async () => {
+		injectedConfig = {
+			fonts: {
+				body: "Inter, sans-serif",
+				heading: "Inter, sans-serif",
+				manuscript: "Playfair Display",
+			},
+		};
+		const head = await servedHead();
+		expect(head).toContain("family=Inter");
+		expect(head).toContain(encodeURIComponent("Playfair Display"));
+		expect(head).not.toContain("<!--theme-fonts-->");
+	});
+
+	test("an absent row degrades to no fonts link — never throws", async () => {
+		injectedConfig = undefined;
+		expect(themeFontsLink()).toBe("");
+		const head = await servedHead();
+		expect(head).not.toContain("fonts.googleapis.com/css2");
+		expect(head).toContain("<!--head-outlet-->");
+	});
+});

package/src/theme-fonts-link.ts

@@ -0,0 +1,64 @@
+/**
+ * @system ui-service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Derives the document head's Google Fonts link from the `css_theme` row's
+ * `fonts` map — the ONE source for the families a page's variants reference
+ * (`the-theme-decides-colour-not-the-component` extends to type). The old
+ * envelope hard-coded Inter, so a proposal heading naming a manuscript serif
+ * ("Playfair Display") never had its family loaded and fell back to Times
+ * (2026-09-02). Now every family the row declares is loaded; a family a
+ * variant names that the row does not declare is a row defect, caught at the
+ * row's schema boundary.
+ *
+ * Read from the boot registry cache (captured at service boot, the same
+ * semantics as the resource_loader capture) and guarded: a missing or
+ * unreadable row degrades to NO fonts link — system fonts render, the page
+ * still works. This module must never throw into the document builder.
+ */
+
+import { getEntryConfig } from "@teamscala/db/registry/accessors";
+
+interface ThemeFontsConfig {
+	fonts?: Record<string, string>;
+}
+
+/** The primary family name of a CSS font stack: "Inter, sans-serif" →
+ * "Inter"; "Playfair Display" → "Playfair Display". */
+export function primaryFontFamily(stack: string): string {
+	const first = stack.split(",")[0] ?? "";
+	return first.trim().replace(/^['"]|['"]$/g, "");
+}
+
+/** The declared theme families, deduplicated by primary family, in row
+ * order (body, heading, manuscript, mono…). Empty when the row is absent. */
+export function themeFontFamilies(): string[] {
+	try {
+		const config = getEntryConfig<ThemeFontsConfig>("css_theme", "default");
+		const fonts = config?.fonts ?? {};
+		const seen = new Set<string>();
+		const families: string[] = [];
+		for (const value of Object.values(fonts)) {
+			if (typeof value !== "string" || value.trim() === "") continue;
+			const primary = primaryFontFamily(value);
+			if (primary === "" || seen.has(primary)) continue;
+			seen.add(primary);
+			families.push(primary);
+		}
+		return families;
+	} catch {
+		return [];
+	}
+}
+
+/** The <link> tag loading every declared theme family, or "" when none. */
+export function themeFontsLink(): string {
+	const families = themeFontFamilies();
+	if (families.length === 0) return "";
+	const WEIGHTS = "400;500;600;700";
+	const params = families
+		.map((family) => `family=${encodeURIComponent(family)}:wght@${WEIGHTS}`)
+		.join("&");
+	return `<link rel="stylesheet" href="https://fonts.googleapis.com/css2?${params}&display=optional" />`;
+}