@teamscala/service-boot 0.23.439 → 0.23.441

package/package.json

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

package/src/fn-routers/public-assessment-router.test.ts

@@ -22,6 +22,7 @@ interface CapturedEmail {
 	text: string;
 }
 
+let capturedResponseRow: Record<string, unknown> | null = null;
 let capturedEmail: CapturedEmail | null = null;
 let emailResolve: ((email: CapturedEmail) => void) | null = null;
 let capturedEvent: { kind: string; payload: Record<string, unknown> } | null = null;
@@ -197,7 +198,10 @@ function makeFakePrisma() {
 		// client_database deliberately absent — the quiz prisma client is
 		// scoped without it, so the CRM branch must skip without error.
 		assessment_responses: {
-			create: async () => ({ id: "resp-1" }),
+			create: async (args: { data: Record<string, unknown> }) => {
+				capturedResponseRow = args?.data ?? null;
+				return { id: "resp-1" };
+			},
 		},
 		email_send_log: {
 			create: async () => ({}),
@@ -218,7 +222,10 @@ type SubmitHandler = (opts: {
 	context: { prisma: unknown; headers: Headers };
 }) => Promise<Record<string, unknown>>;
 
-async function submitWith45(headers = new Headers()) {
+async function submitWith45(
+	headers = new Headers(),
+	extraInput: Record<string, unknown> = {},
+) {
 	// The raw handler under ~orpc only reads { input, context }; the other
 	// ProcedureHandlerOptions fields are middleware plumbing this procedure
 	// (no middlewares) never touches, so the narrowed call shape is cast.
@@ -229,6 +236,7 @@ async function submitWith45(headers = new Headers()) {
 			firstName: "Alex Reader",
 			email: "alex@example.com",
 			answers: answersForScore45(),
+			...extraInput,
 		},
 		context: { prisma: makeFakePrisma(), headers },
 	});
@@ -237,6 +245,7 @@ async function submitWith45(headers = new Headers()) {
 beforeEach(() => {
 	capturedEmail = null;
 	capturedEvent = null;
+	capturedResponseRow = null;
 	brandRowStub = null;
 });
 
@@ -374,3 +383,55 @@ describe("publicAssessment.submit — email band single-sourced from stage_bands
 		expect(email.html).not.toMatch(/<img/i);
 	});
 });
+
+describe("prospect segmentation fields are captured without touching the score", () => {
+	const SEGMENTATION = {
+		linkedinUrl: "https://www.linkedin.com/in/alex-reader",
+		website: "https://alexreader.example",
+		teamSize: "Me + team of 2–5",
+	};
+
+	test("all three persist to their own columns", async () => {
+		await submitWith45(new Headers(), SEGMENTATION);
+		expect(capturedResponseRow?.linkedin_url).toBe(SEGMENTATION.linkedinUrl);
+		expect(capturedResponseRow?.website).toBe(SEGMENTATION.website);
+		expect(capturedResponseRow?.team_size).toBe(SEGMENTATION.teamSize);
+	});
+
+	test("the Authority Index is IDENTICAL with and without them", async () => {
+		// The operator's binding constraint: these are segmentation only and must
+		// not move the score. Asserting the same answers produce the same score
+		// either way is the only check that actually proves it — asserting the
+		// columns were written says nothing about the scorer.
+		const without = (await submitWith45()) as {
+			totalScore: number;
+			categoryScores: Record<string, number>;
+		};
+		const withFields = (await submitWith45(
+			new Headers(),
+			SEGMENTATION,
+		)) as { totalScore: number; categoryScores: Record<string, number> };
+
+		expect(withFields.totalScore).toBe(without.totalScore);
+		expect(withFields.categoryScores).toEqual(without.categoryScores);
+	});
+
+	test("omitting them writes null, not empty string", async () => {
+		// A skipped optional field must be absent in the data, so segmentation
+		// queries can tell "not asked" from "answered blank".
+		await submitWith45();
+		expect(capturedResponseRow?.linkedin_url).toBeNull();
+		expect(capturedResponseRow?.website).toBeNull();
+		expect(capturedResponseRow?.team_size).toBeNull();
+	});
+
+	test("the existing answers payload is unchanged by their presence", async () => {
+		// Guards the other direction: segmentation must not leak into `answers`,
+		// which is the set the scorer reads.
+		await submitWith45(new Headers(), SEGMENTATION);
+		const answers = capturedResponseRow?.answers as Array<{ question_id: string }>;
+		expect(answers).toHaveLength(20);
+		expect(JSON.stringify(answers)).not.toContain("linkedin");
+		expect(JSON.stringify(answers)).not.toContain("team of 2");
+	});
+});

package/src/fn-routers/public-assessment-router.ts

@@ -41,6 +41,10 @@ const submitSchema = v.object({
 	email: v.string(),
 	company: v.optional(v.string()),
 	phone: v.optional(v.string()),
+	// Prospect segmentation, captured at the company step. All optional and all
+	// written to their own columns — none is an input to scoring, which reads
+	// `answers` alone.
+	linkedinUrl: v.optional(v.string()),
 	website: v.optional(v.string()),
 	industry: v.optional(v.string()),
 	teamSize: v.optional(v.string()),
@@ -178,6 +182,9 @@ export const publicAssessmentRouter = {
 					first_name: firstName,
 					last_name: lastName,
 					company: input.company ?? null,
+					linkedin_url: input.linkedinUrl ?? null,
+					website: input.website ?? null,
+					team_size: input.teamSize ?? null,
 					total_score: totalScore,
 					category_scores: categoryScores,
 					answers: input.answers.map((a) => ({

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

@@ -73,4 +73,24 @@ describe("readHtmlTemplate manifest-keyed cache", () => {
 		expect(html).toContain("/assets/hydrate.js");
 		expect(html).toContain("/assets/styles.css");
 	});
+
+	// The fallback is correct as a LAST RESORT and dangerous as a SILENT one:
+	// the unhashed names it emits were never built, so the page 200s while its
+	// stylesheet 404s. Measured 2026-09-01 — a client-facing proposal served
+	// unstyled while the deploy reported SUCCESS, because nothing anywhere in
+	// the stack distinguished "client build never ran" from "client build fine".
+	// The stamp is what makes the two distinguishable to an operator, a probe,
+	// or a deploy gate, so it is asserted rather than left to inspection.
+	test("stamps the page when no manifest was built, so a dead deploy is visible", async () => {
+		const html = await readHtmlTemplate();
+		expect(html).toContain('name="x-client-build-status"');
+		expect(html).toContain('content="missing-manifest"');
+	});
+
+	test("does not stamp missing-manifest once a real manifest exists", async () => {
+		await writeManifest("/assets/hydrate-abc.js", "/assets/styles-abc.css");
+		const html = await readHtmlTemplate();
+		expect(html).toContain("/assets/hydrate-abc.js");
+		expect(html).not.toContain('content="missing-manifest"');
+	});
 });

package/src/read-html-template.ts

@@ -40,6 +40,7 @@
  */
 
 import { createCache } from "@teamscala/cache/create-cache";
+import { getAppLogger } from "@teamscala/logger/app-loggers";
 import { readClientBuildStatus } from "./build-client-assets/manifest.ts";
 import { join } from "node:path";
 
@@ -93,7 +94,7 @@ async function manifestMtimeMs(): Promise<number> {
 	}
 }
 
-async function loadManifest(): Promise<AssetManifest> {
+async function loadManifest(): Promise<AssetManifest | null> {
 	const path = manifestPath();
 	if (await Bun.file(path).exists()) {
 		try {
@@ -101,10 +102,21 @@ async function loadManifest(): Promise<AssetManifest> {
 			if (parsed.stylesPath && parsed.hydratePath) {
 				return { stylesPath: parsed.stylesPath, hydratePath: parsed.hydratePath };
 			}
-		} catch (error) {}
-			getAppLogger().warn("asset manifest unreadable — falling back to default template wiring", error);
+			getAppLogger().warn(
+				`[read-html-template] asset manifest at ${path} is missing stylesPath/hydratePath — serving unbuilt fallback URLs`,
+			);
+		} catch (error) {
+			getAppLogger().warn(
+				`[read-html-template] asset manifest at ${path} is unreadable — serving unbuilt fallback URLs`,
+				error,
+			);
+		}
+		return null;
 	}
-	return FALLBACK;
+	getAppLogger().warn(
+		`[read-html-template] no asset manifest at ${path} — the client build did not run for this deployment; serving unbuilt fallback URLs that will 404`,
+	);
+	return null;
 }
 
 export async function readHtmlTemplate(): Promise<string> {
@@ -113,8 +125,24 @@ export async function readHtmlTemplate(): Promise<string> {
 	if (cached && cached.manifestMtime === manifestMtime) return cached.html;
 	const manifest = await loadManifest();
 	let html = PAGE_DOCUMENT
-		.replace(/\{\{stylesPath\}\}/g, manifest.stylesPath)
-		.replace(/\{\{hydratePath\}\}/g, manifest.hydratePath);
+		.replace(/\{\{stylesPath\}\}/g, (manifest ?? FALLBACK).stylesPath)
+		.replace(/\{\{hydratePath\}\}/g, (manifest ?? FALLBACK).hydratePath);
+	// An ABSENT manifest is a failed client build wearing a working service's
+	// clothes: boot succeeds, SSR renders, every response is 200, and the only
+	// symptom is a stylesheet URL that was never built. Measured 2026-09-01 —
+	// proposals.scala.business served a client-facing proposal unstyled while
+	// Railway reported the deploy SUCCESS, because the fallback silently
+	// substitutes unhashed names for assets no build produced. The tombstone
+	// below already exists for a build that FAILED loudly; a build that never
+	// ran must be equally visible, or a broken deployment is indistinguishable
+	// from a working one at every layer that reports on it
+	// (`a-component-may-not-report-a-state-it-has-not-verified`).
+	if (!manifest) {
+		const meta = `<meta name="x-client-build-status" content="missing-manifest" data-reason="no dist/client/asset-manifest.json; asset URLs below are unbuilt and will 404">`;
+		html = html.includes("</head>")
+			? html.replace("</head>", `${meta}</head>`)
+			: `${meta}${html}`;
+	}
 	// 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