@teamscala/service-boot 0.23.495 → 0.23.496

package/package.json

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

package/src/build-client-assets/hydrate-bundle.ts

@@ -55,7 +55,7 @@
 	// be silently bypassed; a valid local-export chunk carries a
 	// class/function/const/var/let/import, a valid re-export carries `from`).
 
-import { mkdir, readdir, rm } from "node:fs/promises";
+import { mkdir, readdir, rename, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { getAppLogger } from "@teamscala/logger/app-loggers";
 import { fileHash, removeStaleHashedFiles } from "./hashed-output.ts";
@@ -79,6 +79,7 @@ export async function buildHydrateBundle(
 ): Promise<HydrateBundleResult | null> {
 	const entry = join(cwd, "src", "entry-client.ts");
 	const outDir = join(cwd, "dist", "client");
+	const tmpFile = join(outDir, `${HYDRATE_BASE}.js`);
 
 	if (!(await Bun.file(entry).exists())) {
 		log.warn(
@@ -122,26 +123,7 @@ export async function buildHydrateBundle(
 			entrypoints: [entry],
 			target: "browser",
 			outdir: outDir,
-			// THE BUNDLER OWNS THE HASH, because it also writes the references.
-			// Under `splitting: true` + `publicPath`, Bun bakes the entry's
-			// build-time name into every chunk that imports it. Naming the entry
-			// `hydrate.js` here and RENAMING it to `hydrate-<hash>.js` afterwards
-			// moved the file but could not rewrite the specifiers already emitted
-			// into the chunks — so every chunk imported `/assets/hydrate.js`, which
-			// no longer existed. 404 on the module, the importing block dies, and
-			// the page still returns 200 with every guard green.
-			//
-			// MEASURED 2026-09-08 on quiz.scala.business: `AssessmentFlowBlock`
-			// failed with "Failed to fetch dynamically imported module"; crawling
-			// the served graph (142 level-1 + 76 level-2 assets) found exactly one
-			// broken URL — `/assets/hydrate.js` — imported by the entry itself and
-			// by most chunks. Hash applied OUTSIDE the generator is two artefacts
-			// that must agree with nothing making them (`one-generator-pattern`).
-			naming: {
-				entry: `${HYDRATE_BASE}-[hash].[ext]`,
-				chunk: "chunk-[hash].[ext]",
-				asset: "[name]-[hash].[ext]",
-			},
+			naming: `${HYDRATE_BASE}.js`,
 			minifyWhitespace: process.env.NODE_ENV === "production",
 			minifySyntax: process.env.NODE_ENV === "production",
 			minifyIdentifiers: false,
@@ -250,24 +232,10 @@ export async function buildHydrateBundle(
 		);
 	}
 
-	// Bun emitted the hashed entry itself, so the name it wrote into every
-	// chunk IS the name on disk. Read it back from the build's own output
-	// list rather than reconstructing it — a reconstructed name is a second
-	// copy of a fact the bundler already owns, which is the defect this
-	// change removes (`a-mutating-verb-reads-back-what-it-claims`).
-	const entryOutput = result.outputs.find(
-		(o) => o.kind === "entry-point",
-	);
-	if (!entryOutput) {
-		throw new Error(
-			"[build-client-assets] Bun.build reported success but emitted no entry-point output — refusing to ship a bundle with no entry.",
-		);
-	}
-	const hashedName = entryOutput.path.split("/").pop() as string;
+	const hash = await fileHash(tmpFile);
+	const hashedName = `${HYDRATE_BASE}-${hash}.js`;
 	const hashedPath = join(outDir, hashedName);
-	const hash =
-		/^hydrate-([A-Za-z0-9]+)\.js$/.exec(hashedName)?.[1] ??
-		(await fileHash(hashedPath));
+	await rename(tmpFile, hashedPath);
 	removeStaleHashedFiles(outDir, HYDRATE_BASE, "js", hashedName);
 
 	// Splitting emits one chunk per lazy import() alongside the entry. Keep the

package/src/resource-chat-inject.page-assistant.test.ts

@@ -0,0 +1,165 @@
+/**
+ * @system ui-service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * resource-chat-inject.page-assistant.test.ts — the page assistant must be
+ * PRESENT IN RENDERED OUTPUT on every link shape a page resolves.
+ *
+ * THE DEFECT THIS PINS (found 2026-09-08, quiz report page): the page_route's
+ * assistant named resource_key "response" — the loader's RAW response hit.
+ * On /report/<response-id> that hit exists and the chat bubble injected. On
+ * anchor links (a research-record id, live or superseded) the raw hit is
+ * null, injectResourceChatLauncher read no organisation_id off it, returned
+ * SILENTLY, and the page rendered a complete report at 200 with the
+ * assistant simply absent — 552KB of script gone, no error anywhere. The
+ * page's reportData was byte-identical across all three shapes, which is
+ * exactly why a data-equality check could not see it: the launcher is a
+ * separate BLOCK whose presence depends on resolved[resourceKey], not on the
+ * report data.
+ *
+ * THE FIX SHAPE: the page's resource_key names the PAIRED key ("pair"),
+ * which exists on every link shape and carries organisation_id (the pair
+ * resolver returns the anchor half's organisation). These tests drive the
+ * injector with graphs shaped exactly like the loader produces for each of
+ * the three link shapes and assert the launcher lands in the rendered
+ * content tree — the thing that becomes markup — for ALL THREE. A
+ * data-equality assertion cannot pass in their place.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+
+/** The ONE active launcher block_schema slug — the Puck registry key. */
+const REGISTERED_LAUNCHER_SLUG = "ResourceLauncher";
+
+mock.module("@teamscala/db/registry/load-config", () => ({
+	loadRegistryConfig: async () => ({ agentId: "agent-1" }),
+}));
+mock.module("./page-server-orpc/server-client.ts", () => ({
+	getServerClient: () => ({
+		ai_agents: {
+			findFirst: async () => ({
+				name: "Results Assistant",
+				welcome_message: "Hi! Ask me anything about your results.",
+				conversation_starters: ["What are my strengths?"],
+				primary_color: "#6366f1",
+			}),
+		},
+	}),
+}));
+mock.module("@teamscala/logger/app-loggers", () => ({
+	getAppLogger: () => ({ error: (...args: unknown[]) => void args }),
+}));
+
+const { injectResourceChatLauncher } = await import("./resource-chat-inject.ts");
+
+const ORG = "org-1";
+const AGENT_OPTS = {
+	agentConfigSlug: "assessment-assistant-agent" as never,
+	launchLabel: "Ask about your results",
+	placeholder: "Ask about your results…",
+	regionSlots: ["header", "body", "footer"] as readonly string[],
+};
+
+/** A resolved response row as the loader's response source selects it. */
+const RESPONSE_ROW = {
+	id: "resp-1",
+	assessment_id: "asm-1",
+	organisation_id: ORG,
+	total_score: 64,
+	first_name: "Anna",
+};
+
+/** The paired key as resolveReportHalves returns it — present on EVERY link
+ *  shape, carrying the anchor half's organisation. */
+const PAIRED = {
+	response: RESPONSE_ROW,
+	research: { id: "research-live", assessment_id: "asm-1", organisation_id: ORG },
+	assessment_id: "asm-1",
+	organisation_id: ORG,
+};
+
+function pageGraph(
+	responseSource: unknown,
+	pairSource: Record<string, unknown>,
+): Record<string, unknown> {
+	return {
+		response: responseSource,
+		pair: pairSource,
+		quiz: { id: "asm-1", organisation_id: ORG, title: "Authority Index" },
+		brand: { primaryColor: "#123456" },
+		body: { puck_data: { root: { props: {} }, zones: {}, content: [] } },
+		header: { puck_data: { root: { props: {} }, zones: {}, content: [] } },
+		footer: { puck_data: { root: { props: {} }, zones: {}, content: [] } },
+	};
+}
+
+/** The launcher renders `position: fixed`, so it may land in whichever
+ *  region slot is declared first — count across EVERY slot, not one. */
+function launcherBlocks(
+	resolved: Record<string, unknown>,
+): Array<{ type: string; props?: Record<string, unknown> }> {
+	const out: Array<{ type: string; props?: Record<string, unknown> }> = [];
+	for (const slot of AGENT_OPTS.regionSlots) {
+		const content = (
+			resolved[slot] as {
+				puck_data?: { content?: Array<{ type: string; props?: Record<string, unknown> }> };
+			}
+		).puck_data?.content;
+		for (const block of content ?? []) {
+			if (block.type === REGISTERED_LAUNCHER_SLUG) out.push(block);
+		}
+	}
+	return out;
+}
+
+async function launcherCount(
+	responseSource: unknown,
+	pairSource: Record<string, unknown>,
+	resourceKey: string,
+): Promise<number> {
+	const resolved = pageGraph(responseSource, pairSource);
+	await injectResourceChatLauncher(resolved, "", { ...AGENT_OPTS, resourceKey });
+	return launcherBlocks(resolved).length;
+}
+
+describe("page assistant renders on every link shape", () => {
+	test("response-id link: raw hit exists, launcher renders", async () => {
+		expect(await launcherCount(RESPONSE_ROW, PAIRED, "pair")).toBe(1);
+	});
+
+	test("live research-anchor link: raw hit is null, launcher still renders", async () => {
+		expect(await launcherCount(null, PAIRED, "pair")).toBe(1);
+	});
+
+	test("superseded research-anchor link: raw hit is null, launcher still renders", async () => {
+		// identical graph shape to the live anchor — resolution to the live
+		// pass happens upstream in the pair resolver, so the injection surface
+		// is the same and is exercised identically
+		expect(await launcherCount(null, PAIRED, "pair")).toBe(1);
+	});
+
+	test("the launcher block carries the agent, org scope and context", async () => {
+		const resolved = pageGraph(null, PAIRED);
+		await injectResourceChatLauncher(resolved, "viewer@example.com", {
+			...AGENT_OPTS,
+			resourceKey: "pair",
+		});
+		const launchers = launcherBlocks(resolved);
+		expect(launchers.length).toBe(1);
+		const launcher = launchers[0];
+		expect(launcher.props.agentId).toBe("agent-1");
+		expect(launcher.props.organisationId).toBe(ORG);
+		expect(typeof launcher.props.runtimeContext).toBe("string");
+		expect((launcher.props.runtimeContext as string).length).toBeGreaterThan(0);
+	});
+
+	test("the DEFECT SHAPE: keying the raw response hit on an anchor link silently renders none", async () => {
+		// resource_key "response" + a null raw hit is the 2026-09-08 regression.
+		// The injector contract is fail-soft for the render, so the absence is
+		// quiet — this pins the shape with the reason spelled out, so the row
+		// can never go back to a key that is null on anchor links without the
+		// next reader finding this.
+		expect(await launcherCount(null, PAIRED, "response")).toBe(0);
+	});
+});

package/src/resource-chat-inject.ts

@@ -315,7 +315,21 @@ export async function injectResourceChatLauncher(
 	const organisationId =
 		opts.organisationId ||
 		(typeof record?.organisation_id === "string" ? record.organisation_id : "");
-	if (!organisationId) return;
+	if (!organisationId) {
+		// THIS BAIL USED TO BE SILENT, AND A SILENT DROP IS THE WORST FAILURE
+		// SHAPE A BLOCK CAN HAVE (measured 2026-09-08 on the quiz report): the
+		// page returns 200 and looks complete while the assistant is simply
+		// absent — resource_key named a resolved key that is null on some link
+		// shapes (a research-anchor link has no raw response match), and the
+		// page rendered a full report with no bubble and no error anywhere.
+		// The page must stay usable (fail-soft for the RENDER is the contract),
+		// but a declared assistant that did not inject is never "fine": name
+		// the key and the reason so the absence is observable.
+		getAppLogger().error(
+			`[resource-chat] assistant declared but NOT injected: resolved["${opts.resourceKey}"] is ${record === undefined ? "absent" : "null"} or carries no organisation_id — the launcher is silently missing from this page`,
+		);
+		return;
+	}
 
 	let agentId = "";
 	try {