@teamscala/service-boot 0.23.478 → 0.23.481

package/package.json

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

package/src/fn-routers/assessment-report-pair.test.ts

@@ -105,3 +105,32 @@ describe("resolveReportHalves", () => {
 		).rejects.toThrow(/matches no quiz response/);
 	});
 });
+
+describe("superseded-pass leak prevention", () => {
+	test("the live pass reaches the reader and the superseded pass's wording never does", async () => {
+		const SUPERSEDED_MARKER = "SUPERSEDED-PASS-64-PARKED-DOMAIN-CLAIM";
+		const superseded = annaResearch({
+			id: "research-superseded",
+			superseded_at: "2026-09-04T01:00:00Z",
+			findings: { intro: `${SUPERSEDED_MARKER}: no website exists.` },
+		});
+		const live = annaResearch({ id: "research-live", findings: { intro: "launcha.marketing is live and names you." } });
+		const client = {
+			assessment_research: {
+				findFirst: async () => live,
+			},
+			assessment_responses: {
+				findFirst: async () => null,
+				findMany: async () => [],
+			},
+		};
+		const halves = await resolveReportHalves({
+			input: { response: null, research: superseded, id: superseded.id },
+			client,
+			params: {},
+		});
+		const text = JSON.stringify(halves.research);
+		expect(text).not.toContain(SUPERSEDED_MARKER);
+		expect(text).toContain("launcha.marketing is live and names you");
+	});
+});

package/src/fn-routers/assessment-research-report-data.test.ts

@@ -128,7 +128,7 @@ describe("research shaping", () => {
 		});
 		expect(data.research.combinedStatement).toContain("17 points higher");
 		expect(data.research.combinedBand).toBe("Recognised");
-		expect(data.research.reportDate).toBe("2026-09-01");
+		expect(data.research.reportDate).toBe("2026-09-04");
 	});
 
 	test("research-only person: the research score drives the snapshot and the self sections stay absent", () => {
@@ -229,34 +229,5 @@ describe("the rendered text surface is one-person clean", () => {
 			expect(strings).not.toContain(marker);
 		}
 	});
-
-	// "a different person's research never renders here" is enforced UPSTREAM:
-	// the pairing resolver matches halves by normalised LinkedIn identity, and
-	// its refusal tests live in fn-routers/assessment-report-pair.test.ts.
 });
 
-describe("small derivations", () => {
-	test("gapText is signed and plain", () => {
-		expect(gapText(54, 71)).toBe("+17");
-		expect(gapText(71, 54)).toBe("-17");
-		expect(gapText(54, 54)).toBe("0");
-	});
-
-	test("prepared-for line reads exactly brand and person", () => {
-		expect(buildPreparedFor("Launcha Marketing", "Anna Osherov")).toBe(
-			"Launcha Marketing and Anna Osherov",
-		);
-	});
-
-	test("combined statement names the direction, size and band", () => {
-		const statement = buildCombinedStatement({
-			selfScore: 54,
-			researchScore: 71,
-			bandSteps: 1,
-			researchBandName: "Recognised",
-		});
-		expect(statement).toContain("17 points higher");
-		expect(statement).toContain("one band higher");
-		expect(statement).toContain("Recognised");
-	});
-});

package/src/fn-routers/assessment-research-report-data.ts

@@ -229,7 +229,7 @@ export interface ResearchReportData {
 	methodRawScores: string;
 	methodSources: string;
 	researchedAt: string;
-	/** the report's date: the quiz completion when a response exists, else the research date */
+	/** the report's date: always the research pass date (when the report was produced) */
 	reportDate: string;
 }
 
@@ -373,7 +373,7 @@ export function buildResearchReportData(opts: {
 		methodRawScores: findings.rawScoresNote ?? "",
 		methodSources: findings.sourceSummary ?? "",
 		researchedAt: isoDay(research.researched_at),
-		reportDate: isoDay(response?.completed_at) || isoDay(research.researched_at),
+		reportDate: isoDay(research.researched_at),
 	};
 }
 

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

@@ -13,7 +13,10 @@ import { afterEach, describe, expect, mock, test } from "bun:test";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { mountOrpcRouter } from "./mount-orpc-router.ts";
-
+// Captured at module-load time — BEFORE any mock.module() in the test bodies
+// replaces the specifier — so the error-hook test can restore the REAL
+// configured-primitive surface the mount wires the recorder through.
+import * as orpcConfigureReal from "@teamscala/orpc/configure";
 const originalCwd = process.cwd();
 const tempDirs: string[] = [];
 
@@ -85,3 +88,96 @@ describe("mountOrpcRouter generated-artifact seam", () => {
 		expect(seenKeys).not.toContain("getMcpGatewayUrl");
 	});
 });
+
+describe("mountOrpcRouter procedure error hook", () => {
+	test("a throwing procedure through the mounted route records a durable event with the stack", async () => {
+		const service = await mkdtemp(join(tmpdir(), "mount-orpc-router-test-"));
+		tempDirs.push(service);
+		await mkdir(join(service, "prisma/generated/orpc/routers"), {
+			recursive: true,
+		});
+		await Bun.file(join(service, "prisma/schema.prisma")).write(
+			'datasource db { provider = "postgresql" }',
+		);
+		await Bun.file(
+			join(service, "prisma/generated/orpc/routers/index.ts"),
+		).write("export const router = {};\n");
+		process.chdir(service);
+
+		const { os } = await import("@orpc/server");
+		// The REAL installed orpc surface stays live (configure +
+		// procedure-error-report + the RPCHandler the mount builds) so the
+		// asserted record proves the wiring, not a mock agreeing with itself.
+		// Only the app router source and the event-log write boundary are
+		// replaced. The earlier test in this file partially mocked the
+		// configure specifier; restore the real exports first. getPrisma is
+		// configured because the route reads it per request.
+		mock.module("@teamscala/orpc/configure", () => orpcConfigureReal);
+		const { configure: orpcConfigure } = await import(
+			"@teamscala/orpc/configure"
+		);
+		orpcConfigure({ getPrisma: () => ({}) as never });
+
+		const recordedEvents: Array<{ kind: string; payload: unknown }> = [];
+		mock.module("@teamscala/orpc/app-router", () => ({
+			getAppRouter: async () => ({
+				fn: {
+					test: {
+						boom: os.handler(async () => {
+							throw new ReferenceError("mount-boundary boom");
+						}),
+					},
+				},
+			}),
+		}));
+		mock.module("@teamscala/event-log/record-event", () => ({
+			recordEvent: (input: { kind: string; payload: unknown }) => {
+				recordedEvents.push(input);
+			},
+		}));
+
+		let routeHandler: ((c: unknown) => Promise<Response>) | undefined;
+		const app = {
+			post: (
+				_path: string,
+				...handlers: Array<(c: unknown) => Promise<Response>>
+			) => {
+				routeHandler = handlers.at(-1);
+			},
+		};
+		await mountOrpcRouter(app as never, "scala-mcp");
+		expect(routeHandler).toBeTypeOf("function");
+
+		const response = await routeHandler?.({
+			req: {
+				raw: new Request("http://localhost/api/rpc/fn/test/boom", {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({}),
+				}),
+				path: "/api/rpc/fn/test/boom",
+				method: "POST",
+			},
+			notFound: () => new Response(null, { status: 404 }),
+		});
+
+		expect(response?.status).toBe(500);
+		expect(recordedEvents).toHaveLength(1);
+		const { kind, payload } = recordedEvents[0];
+		expect(kind).toBe("orpc.procedure.failed");
+		const record = payload as {
+			procedure: string;
+			errorName: string;
+			message: string;
+			errorId: string;
+			stackHead: string;
+		};
+		expect(record.procedure).toBe("fn.test.boom");
+		expect(record.errorName).toBe("ReferenceError");
+		expect(record.message).toContain("mount-boundary boom");
+		expect(record.errorId).toBeTruthy();
+		const stackLines = record.stackHead.split("\n");
+		expect(stackLines.length).toBeGreaterThanOrEqual(2);
+		expect(stackLines[0]).toContain("ReferenceError");
+	});
+});

package/src/mount-orpc-router.ts

@@ -11,7 +11,7 @@
 
 import { join } from "node:path";
 import { getAppLogger } from "@teamscala/logger/app-loggers";
-import type { InjectedDb8 } from "@teamscala/db/db8-registry";
+import type { Db8Client } from "@teamscala/db/db8-registry";
 import type { Hono } from "hono";
 import { bodyLimit } from "hono/body-limit";
 
@@ -94,8 +94,28 @@ export async function mountOrpcRouter(
 		const router = await getAppRouter();
 		if (!router || Object.keys(router).length === 0) return null;
 
+		// The mount error hook: every procedure error crossing this boundary is
+		// shaped by buildErrorReport (errorId, class, stack head) and recorded
+		// durably via event-log before ORPC swallows it into a stackless 500.
+		// The recorder is wired HERE because orpc is primitives tier and cannot
+		// import @teamscala/event-log across a same-tier edge — the boot layer
+		// owns that dependency.
+		const { procedureErrorReportInterceptor } = await import(
+			"@teamscala/orpc/procedure-error-report"
+		);
+		const { recordEvent } = await import("@teamscala/event-log/record-event");
+		const { configure: orpcConfigure } = await import(
+			"@teamscala/orpc/configure"
+		);
+		orpcConfigure({
+			procedureErrorRecorder: (record) =>
+				recordEvent({ kind: "orpc.procedure.failed", payload: record }),
+		});
+
 		const { RPCHandler } = await import("@orpc/server/fetch");
-		const handler = new RPCHandler(router as never, {});
+		const handler = new RPCHandler(router as never, {
+			interceptors: [procedureErrorReportInterceptor()] as never,
+		});
 
 		// The bootloader injects the service Prisma client into ORPC's configured
 		// primitive. Reading it through that surface keeps this mount on the same
@@ -109,7 +129,7 @@ export async function mountOrpcRouter(
 		// the EXPECTED state for services that have not migrated — db8 stays
 		// undefined and v7 procedures are untouched. One boot-time creation,
 		// closed over by the request handler (connects lazily on first query).
-		let db8: InjectedDb8 | undefined;
+		let db8: Db8Client | undefined;
 		try {
 			if (process.env.DATABASE_URL) {
 				const { createDbClientV8 } = await import(
@@ -175,7 +195,12 @@ export async function mountOrpcRouter(
 				import("@teamscala/db/work-items"),
 				import("@teamscala/email-client/client"),
 			]);
-			configureWorkItems({ emailSender: createEmailClient(), logger: log });
+			configureWorkItems({
+				// The injected contract is the template-send subset; the real
+				// client's send agrees at every call site ({to, template, vars}).
+				emailSender: createEmailClient() as never,
+				logger: log,
+			});
 		} catch (err) {
 			log.warn(
 				`[scala-install:${serviceSlug}] work-items email sender not wired: ${err instanceof Error ? err.message : err}`,
@@ -234,11 +259,10 @@ export async function mountOrpcRouter(
 					context: { prisma, db8, headers: c.req.raw.headers, resolveUser },
 				});
 				if (!result?.matched) return c.notFound();
-				// ORPC swallows procedure errors into a 500 response with a
-				// generic INTERNAL_SERVER_ERROR body. Without logging here the
-				// only signal is a fleet-wide spike in 500s with no traceback —
-				// measured 2026-09-04 when the regenerated prisma client shipped
-				// an empty orm and every model action returned a silent 500.
+				// Response-side signal only (a fleet-wide 500 spike with no
+				// traceback — measured 2026-09-04). The real error, its class and
+				// its stack are captured by the mount error hook above; this line
+				// stays for failures that reach the boundary without a throw.
 				if (result.response.status >= 500) {
 					log.error(
 						`[ORPC] ${c.req.method} ${c.req.path} → ${result.response.status}`,

package/src/register-registry-page-route/region-slots-page-data.ts

@@ -92,7 +92,7 @@ export function regionSlotsPageData(
 					{
 						templateTitle: (meta.title as string) || undefined,
 						websiteName: (website.name as string) || undefined,
-						organisationName: (brand.companyName as string) || undefined,
+						organisationName: (brand.companyFriendlyName as string) || (brand.companyName as string) || undefined,
 						entityTitle: entityTitle || undefined,
 					},
 					{ orgPrefix },
@@ -164,7 +164,7 @@ export function regionSlotsPageData(
 			{
 				templateTitle: (meta.title as string) || undefined,
 				websiteName: (website.name as string) || undefined,
-				organisationName: (brand.companyName as string) || undefined,
+				organisationName: (brand.companyFriendlyName as string) || (brand.companyName as string) || undefined,
 					pageName: contentPageName,
 					entityTitle: entityTitle || undefined,
 				},