@teamscala/service-boot 0.23.516 → 0.23.518

package/src/two-phase-readiness.test.ts

@@ -0,0 +1,102 @@
+/**
+ * @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.
+ * ./two-phase-readiness declares 6 runtime export(s) and 8 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";
+import { mock } from "bun:test";
+const __realServerClient = await import("./page-server-orpc/server-client.ts");
+const __capabilityFault: { value: string | null } = { value: null };
+mock.module("./page-server-orpc/server-client.ts", () => ({ ...__realServerClient, getServerClientCapabilityFault: () => __capabilityFault.value }));
+const __realNotFound = await import("./resource-not-found.ts");
+mock.module("./resource-not-found.ts", () => ({ ...__realNotFound, resolveErrorPageLogo: async () => "https://logo.local/light.png" }));
+const __ctx = { json: (body: unknown, status?: number, headers?: Record<string, string>) => new Response(JSON.stringify(body), { status: status ?? 200, headers }) };
+
+const mod = await import("./two-phase-readiness");
+
+const { setPageHandler, markFullAppReady, __resetPhase2StateForTest, getPageHandlerState, healthHandler, createPhase1PageHandler } = mod;
+
+describe("two-phase-readiness exports-map smoke", () => {
+	it("the runtime export set is exactly the declared surface", () => {
+		expect(Object.keys(mod).sort()).toEqual([
+			"__resetPhase2StateForTest",
+			"createPhase1PageHandler",
+			"getPageHandlerState",
+			"healthHandler",
+			"markFullAppReady",
+			"setPageHandler",
+		]);
+	});
+	it("setPageHandler is a function", () => {
+		expect(typeof mod["setPageHandler"]).toBe("function");
+	});
+	it("markFullAppReady is a function", () => {
+		expect(typeof mod["markFullAppReady"]).toBe("function");
+	});
+	it("__resetPhase2StateForTest is a function", () => {
+		expect(typeof mod["__resetPhase2StateForTest"]).toBe("function");
+	});
+	it("getPageHandlerState is a function", () => {
+		expect(typeof mod["getPageHandlerState"]).toBe("function");
+	});
+	it("healthHandler is a function", () => {
+		expect(typeof mod["healthHandler"]).toBe("function");
+	});
+	it("createPhase1PageHandler is a function", () => {
+		expect(typeof mod["createPhase1PageHandler"]).toBe("function");
+	});
+	it("a fresh boot starts unready with no handler", async () => {
+		__resetPhase2StateForTest();
+		const got = getPageHandlerState();
+		expect(got).toEqual({ ready: false, hasHandler: false });
+	});
+	it("markFullAppReady alone flips ready WITHOUT a handler — the client-render contract", async () => {
+		__resetPhase2StateForTest();
+		markFullAppReady(); const got = getPageHandlerState();
+		expect(got.ready).toBe(true);
+		expect(got.hasHandler).toBe(false);
+	});
+	it("setPageHandler implies ready AND a handler (the SSR contract)", async () => {
+		__resetPhase2StateForTest();
+		setPageHandler((() => async () => new Response("ok")) as never); const got = getPageHandlerState();
+		expect(got.ready).toBe(true);
+		expect(got.hasHandler).toBe(true);
+	});
+	it("/health reports 503 starting before phase 2", async () => {
+		__resetPhase2StateForTest(); __capabilityFault.value = null;
+		const got = healthHandler(__ctx as never) as Response;
+		expect(got.status).toBe(503);
+		expect((await got.json() as { status: string }).status).toBe("starting");
+	});
+	it("/health asserts the capability, not just the phase flag", async () => {
+		__resetPhase2StateForTest(); markFullAppReady(); __capabilityFault.value = "registered client carries no CRUD models";
+		const got = healthHandler(__ctx as never) as Response;
+		expect(got.status).toBe(503);
+		expect((await got.json() as { status: string }).status).toBe("degraded");
+	});
+	it("/health answers ok once ready and the capability is intact", async () => {
+		__resetPhase2StateForTest(); markFullAppReady(); __capabilityFault.value = null;
+		const got = healthHandler(__ctx as never) as Response;
+		expect(got.status).toBe(200);
+		expect((await got.json() as { status: string }).status).toBe("ok");
+	});
+	it("the phase-1 page handler serves the branded waking 503 before phase 2", async () => {
+		__resetPhase2StateForTest();
+		const handler = createPhase1PageHandler("svc-tr")( {} as never );
+		const got = await handler(new Request("http://x.local/"), {} as never);
+		expect(got.status).toBe(503);
+		expect(got.headers.get("content-type")).toContain("text/html");
+		expect(got.headers.get("retry-after")).not.toBeNull();
+	});
+	it("the phase-1 handler delegates to the real handler once registered", async () => {
+		__resetPhase2StateForTest(); setPageHandler((() => async () => new Response("real-render")) as never);
+		const handler = createPhase1PageHandler("svc-tr")( {} as never );
+		const got = await handler(new Request("http://x.local/"), {} as never);
+		expect(await got.text()).toBe("real-render");
+	});
+});

package/src/types.test.ts

@@ -0,0 +1,20 @@
+/**
+ * @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.
+ * ./types declares 0 runtime export(s) + 5 type(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 mod = await import("./types");
+
+describe("types exports-map smoke", () => {
+	it("is type-only — the runtime module carries no values", () => {
+		// Declared types: RendererComponentEntry, PageHandlerExtras, CreatePageHandler, PageHandlerConfig, ServiceInstallConfig
+		expect(Object.keys(mod).length).toBe(0);
+	});
+});

package/src/ui-service.test.ts

@@ -0,0 +1,24 @@
+/**
+ * @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.
+ * ./ui-service declares 1 runtime export(s) + 3 type(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 mod = await import("./ui-service");
+
+describe("ui-service exports-map smoke", () => {
+	it("the runtime export set is exactly the declared surface", () => {
+		expect(Object.keys(mod).sort()).toEqual([
+			"bootUiService",
+		]);
+	});
+	it("bootUiService is a function", () => {
+		expect(typeof mod["bootUiService"]).toBe("function");
+	});
+});

package/src/ws-boot-self-test.test.ts

@@ -0,0 +1,43 @@
+/**
+ * @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.
+ * ./ws-boot-self-test 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 mod = await import("./ws-boot-self-test");
+
+const { runWsBootSelfTest } = mod;
+
+describe("ws-boot-self-test exports-map smoke", () => {
+	it("the runtime export set is exactly the declared surface", () => {
+		expect(Object.keys(mod).sort()).toEqual([
+			"runWsBootSelfTest",
+		]);
+	});
+	it("runWsBootSelfTest is a function", () => {
+		expect(typeof mod["runWsBootSelfTest"]).toBe("function");
+	});
+	it("no declared websocket routes resolves without connecting", async () => {
+		const got = await runWsBootSelfTest({ websocket_routes: [] } as never, "svc-ws", 59999);
+		expect(got).toBeUndefined();
+	});
+	it("a route whose server upgrades resolves 101", async () => {
+		const server = Bun.serve({ port: 0, fetch(req, srv) { if (!srv.upgrade(req)) return new Response("no upgrade", { status: 401 }); }, websocket: { open() {}, message() {} } });
+		const port = server.port as number;
+		const got = await runWsBootSelfTest({ websocket_routes: [{ path: "/ws-boot-self-test" }] } as never, "svc-ws", port);
+		expect(got).toBeUndefined();
+		server.stop(true);
+	});
+	it("a route nobody listens on fails boot loudly, naming the path", async () => {
+		let thrown: unknown = null;
+		try { await runWsBootSelfTest({ websocket_routes: [{ path: "/ws-boot-self-test-dead" }] } as never, "svc-ws", 59987); } catch (err) { thrown = err; }
+		expect(thrown).not.toBeNull();
+		expect(String(thrown)).toContain("/ws-boot-self-test-dead");
+	});
+});

package/src/build-client-assets/input-fingerprint.ts

@@ -1,92 +0,0 @@
-/**
- * @system server-handlers
- * @status handwritten
- * @edit edit directly
- *
- * The content fingerprint of the client-bundle dependency closure — the
- * cache key that decides whether the boot-time client-asset build can be
- * skipped. Composes the input-hashing module's closure walkers.
- *
- * Split out of build-client-assets.ts (962 lines) alongside its build
- * siblings. Byte-for-byte move from the parent except createHash →
- * Bun.CryptoHasher (bun-native-crypto guard; identical digest output).
- */
-
-// Content fingerprint of the client-bundle dependency CLOSURE — hashed by CONTENT, never mtime (cache-key-hashes-source-inputs-only). Rebuild iff this
-// differs from the fingerprint stored in the existing manifest. Scoped to the CLOSURE (not all of node_modules) so a @teamscala/* publish that is not in this
-// service's client bundle cannot trigger a rebuild — the publish→rebuild storm is architecturally impossible (`no-uncontrolled-repetition-or-cascade`).
-//
-// Inputs (everything that can change the emitted bytes): src/entry-client.ts — the bundle entrypoint. src/page-manifest.ts — the generated block→component map the bundle is built
-//                       from; a codegen regen (block added/removed) changes it, and the hydrate bundle MUST rebuild or new blocks render
-//                       empty → hydration mismatch. src/app.css        — the Tailwind entry. @teamscala/* JS closure (hashTeamgbjJsGraph) — the CONTENT of every @teamscala/*
-//                       module reachable from the client entrypoints. Content (not version) so a mid-install stale bake (bun.lock
-//                       ahead of node_modules — the lock can name a new version while the prior bytes are still on disk) is detected on
-//                       the next boot and self-heals (scala-agents 2026-07-12). @teamscala/* CSS closure (hashResolvedPackageStylesheets) — the CONTENT of
-//                       every package stylesheet app.css @imports (transitively). third-party closure-boundary versions (hashTeamgbgJsGraph) — the resolved
-//                       VERSION of each third-party package the client closure imports (react, etc.). Third-party modules are not
-//                       content-walked (large; pinned by bun.lock + change only on a version bump), but a version bump of a closure dep
-//                       MUST invalidate, so the installed package.json#version is folded. This is the closure-scoped replacement for
-//                       hashing all of bun.lock: react bumping in the closure still rebuilds, while a backend @teamscala/* publish
-//                       outside the closure does not. NB: bun.lock is INTENTIONALLY NOT an input. It encodes every resolved
-//    @teamscala/* version (backend packages included), so it invalidates on every publish — the false-invalidation source that made every UI service rebuild
-//    on a backend publish. The closure inputs above are a strict improvement: they catch every change that affects THIS bundle AND nothing that doesn't.
-
-	// Keyed on each input's RELATIVE label + CONTENT only — never the absolute
-	// path (that would make the fingerprint cwd-dependent and defeat the skip
-	// across two checkouts of the same service). bun.lock is DELIBERATELY
-	// EXCLUDED — it encodes EVERY resolved @teamscala/* version, so folding it in
-	// invalidates on every publish including packages NOT in this service's
-	// client bundle (the publish→rebuild storm — `no-uncontrolled-repetition-
-	// or-cascade`). The closure content hashes below (hashTeamgbgJsGraph +
-	// hashResolvedPackageStylesheets) + the third-party closure-boundary
-	// versions cover every dependency change that ACTUALLY affects this bundle,
-	// so a non-closure publish changes nothing here → zero rebuild. Rebuild
-	// iff this fingerprint differs from the one stored in the manifest.
-
-	// Fold in the resolved CONTENT of every @teamscala/* JS/TS module reachable
-	// from the client entrypoints (hashTeamgbgJsGraph). bun.lock pins versions;
-	// the build reads BYTES — and a boot can build MID-INSTALL (the package-
-	// poller restarts the service after writing the new bun.lock but before
-	// node_modules extraction finishes), so Bun.build faithfully bakes the OLD
-	// @teamgbg JS while the lock-derived fingerprint is stored as "current".
-	// Every later restart then recomputes the same lock fingerprint → skip →
-	// STALE bundle served forever (scala-agents 2026-07-12: hydrate-4dad7478bd
-	// carried zero of portal-ui@2.4.41's markers across restarts). Bun.build
-	// itself is NOT caching — an isolated repro proves it reads fresh content
-	// across processes — so the fix is to make the fingerprint cover the actual
-	// @teamgbg JS bytes (the JS analogue of hashResolvedPackageStylesheets,
-	// which already closes this exact race for CSS). A stale bake then hashes
-	// differently from the freshly-installed bytes → rebuild → self-heals.
-
-import { join } from "node:path";
-import {
-	hashResolvedPackageStylesheets,
-	hashTeamgbgJsGraph,
-} from "./input-hashing.ts";
-
-export async function computeInputFingerprint(cwd: string): Promise<string> {
-	const sources: Array<[label: string, path: string]> = [
-		["src/entry-client.ts", join(cwd, "src", "entry-client.ts")],
-		["src/page-manifest.ts", join(cwd, "src", "page-manifest.ts")],
-		["src/app.css", join(cwd, "src", "app.css")],
-	];
-	const h = new Bun.CryptoHasher("sha256");
-	for (const [label, path] of sources) {
-		// Missing input contributes a stable sentinel rather than throwing — a
-		// backend service has no app.css, and that absence is itself part of the
-		// fingerprint. `(await Bun.file().text())` is parenthesised so a missing
-		// file's sync TypeError is caught (bun-async-file-operations).
-		try {
-			h.update(label).update("\0").update(await Bun.file(path).text()).update("\0");
-		} catch {
-			h.update(label).update("\0<absent>\0");
-		}
-	}
-	// Fold the resolved CONTENT of every @teamscala/* stylesheet app.css @imports
-	// (client-asset-cache-key-embeds-package-content). bun.lock pins versions; the
-	// build reads bytes. When they diverge (boot built mid-install), the lock-only
-	// fingerprint false-matches and skips forever — hashing the bytes closes it.
-	await hashResolvedPackageStylesheets(cwd, h);
-	await hashTeamgbgJsGraph(cwd, h);
-	return h.digest("hex").slice(0, 16);
-}

package/src/build-client-assets/input-hashing.ts

@@ -1,206 +0,0 @@
-/**
- * @system service-boot
- * @status handwritten
- * @edit edit directly
- *
- * Input hashing for the client-asset build fingerprint.
- *
- * Split out of build-client-assets.ts, which had grown to 1221 lines holding
- * six distinct concerns (lock + status, manifest, hydrate bundle, source maps,
- * stylesheet/tailwind, and this). `single-purpose-file` did not catch it: that
- * rule flags a file whose top-level exports share no common name root, which
- * measures export-NAME cohesion rather than how many concerns a file holds — so
- * a large file with few tidily-named exports stays invisible to it.
- *
- * This module owns ONE concern: turning the build's real inputs into a stable
- * hash. `computeInputFingerprint` (still in the parent, and still the only
- * exported entry point) composes the two functions exported here; everything
- * else is module-private because nothing outside needs it.
- *
- * Byte-for-byte move — imports adjusted, nothing else. No renames, no type
- * changes (`migrations-copy-not-rewrite`).
- */
-
-import { dirname, join, relative, resolve } from "node:path";
-import { firstPartyScopeAlternation } from "@teamscala/os/workspace-topology/first-party-scopes";
-
-// Resolve + hash the content of every `@import` in app.css's @teamscala/*
-// stylesheet chain — INCLUDING transitive @imports (generic-ui/styles.css
-// @imports blk-utilities/styles.css; hashing only the direct import left
-// blk-utilities changes undetected → stale bundle). Cycle-safe via `seen`.
-export async function hashResolvedPackageStylesheets(
-	cwd: string,
-	h: Bun.CryptoHasher,
-): Promise<void> {
-	let appCss: string;
-	try {
-		appCss = await Bun.file(join(cwd, "src", "app.css")).text();
-	} catch {
-		return; // no app.css → nothing to fold (the main loop already recorded <absent>)
-	}
-	const seen = new Set<string>();
-	const hashSpec = async (spec: string, base: string): Promise<void> => {
-		if (seen.has(spec)) return;
-		seen.add(spec);
-		try {
-			const resolved = await Bun.resolve(spec, base);
-			const content = await Bun.file(resolved).text();
-			h.update("pkgcss:").update(spec).update("\0").update(content).update("\0");
-			// Follow transitive @imports within this stylesheet (relative + @teamscala/*).
-			for (const child of [
-				...content.matchAll(/@import\s+["']([^"']+)["']/g),
-			].map((m) => m[1].trim())) {
-				if (child.startsWith("tailwindcss")) continue;
-				await hashSpec(child, dirname(resolved));
-			}
-		} catch {
-			h.update("pkgcss:").update(spec).update("\0<unresolved>\0");
-		}
-	};
-	for (const spec of [
-		...appCss.matchAll(new RegExp(`@import\\s+["']((?:${firstPartyScopeAlternation()})\\/[^"']+)['"]`, "g")),
-	].map((m) => m[1].trim())) {
-		await hashSpec(spec, join(cwd, "src"));
-	}
-}
-
-// The JS twin of hashResolvedPackageStylesheets: resolve + hash the CONTENT of every @teamscala/* JS/TS module reachable from the client entrypoints, so a
-// mid-install stale bake (bun.lock ahead of node_modules — see computeInputFingerprint) is detected on the next boot and self-heals. Third-party modules are NOT walked
-// (their versions are pinned by bun.lock and they don't change on a @teamgbg
-// publish); only the @teamgbg surface — the publish-driven change graph — is folded.
-//
-// Determinism: per-file content hashes are collected into a map keyed on the
-// package-relative path, then folded into the aggregate hasher in SORTED path
-// order. The walk itself runs bounded-concurrent (no-serial-per-unit-work-on-hot-
-// paths — the @teamgbg graph is ~1k+ files for a large UI; a serial await-per-file
-// walk starves the boot path), but scheduling order never affects the result.
-const JS_IMPORT_SPEC_RE = /\b(?:from|import|export|require)\s*\(?["']([^"']+)["']/g;
-const JS_GRAPH_CONCURRENCY = 32;
-
-// Parse the package name (scoped `@scope/pkg` or unscoped `pkg`) from a
-// resolved node_modules path. lastIndexOf picks the INNERMOST package when
-// node_modules is nested (a -> node_modules/b), which is the package actually
-// imported. Returns null for a path not under node_modules.
-function nodeModulesPkgName(resolvedPath: string): string | null {
-	const idx = resolvedPath.lastIndexOf("/node_modules/");
-	if (idx < 0) return null;
-	const rest = resolvedPath.slice(idx + "/node_modules/".length);
-	const slash = rest.indexOf("/");
-	if (rest.startsWith("@")) {
-		if (slash < 0) return rest; // malformed scoped name with no slash
-		const secondSlash = rest.indexOf("/", slash + 1);
-		return secondSlash < 0 ? rest : rest.slice(0, secondSlash);
-	}
-	return slash < 0 ? rest : rest.slice(0, slash);
-}
-
-// Best-effort read of an installed package's declared version. Used at the
-// third-party closure boundary so a version bump of a closure dep (react, etc.)
-// invalidates the fingerprint without content-walking the (large, pinned)
-// package. Returns null on any failure — an ABSENT signal, not a masking
-// fallback (protective-layers-fail-explicitly): the caller omits the package,
-// so a later successful read folds in a real version and invalidates. Never
-// returns a non-null placeholder that would hide the failure.
-async function readInstalledPkgVersion(
-	resolvedPath: string,
-	pkgName: string,
-): Promise<string | null> {
-	const marker = "/node_modules/";
-	const idx = resolvedPath.lastIndexOf(marker);
-	const pkgRoot = join(resolvedPath.slice(0, idx + marker.length), pkgName);
-	try {
-		const pkg = await Bun.file(join(pkgRoot, "package.json")).json();
-		return typeof pkg.version === "string" ? pkg.version : null;
-	} catch {
-		return null;
-	}
-}
-
-export async function hashTeamgbgJsGraph(
-	cwd: string,
-	h: Bun.CryptoHasher,
-): Promise<void> {
-	const roots = [];
-	for (const p of [
-		join(cwd, "src", "entry-client.ts"),
-		join(cwd, "src", "page-manifest.ts"),
-	]) {
-		if (await Bun.file(p).exists()) roots.push(p);
-	}
-	if (roots.length === 0) return; // backend service — no client bundle to guard
-
-	const seen = new Set<string>();
-	for (const r of roots) seen.add(r);
-	const fileHashes = new Map<string, string>(); // pkg-relative path → content hash
-	const thirdPartyVersions = new Map<string, string>(); // pkg name → installed version
-
-	let frontier: string[] = [...roots];
-	while (frontier.length > 0) {
-		const batch = frontier.splice(0, JS_GRAPH_CONCURRENCY);
-		const expanded = await Promise.all(
-			batch.map(async (file) => {
-				let text: string;
-				try {
-					text = await Bun.file(file).text();
-				} catch {
-					return [] as string[];
-				}
-				const nmIdx = file.indexOf("/node_modules/@teamscala/");
-				if (nmIdx >= 0) {
-					const rel = file.slice(nmIdx + "/node_modules/".length); // @teamscala/pkg/...
-					fileHashes.set(rel, new Bun.CryptoHasher("sha256").update(text).digest("hex"));
-				}
-				const next: string[] = [];
-				for (const m of text.matchAll(JS_IMPORT_SPEC_RE)) {
-					let resolved: string;
-					try {
-						resolved = await Bun.resolve(m[1].trim(), dirname(file));
-					} catch {
-						continue;
-					}
-					const inNodeModules = resolved.includes("/node_modules/");
-					const isTeamgbg = resolved.includes("/node_modules/@teamscala/");
-					if (inNodeModules && !isTeamgbg) {
-						// Third-party closure boundary: stop the content walk (large,
-						// version-pinned packages) but record this dep's resolved VERSION
-						// so a closure version bump (react, …) still invalidates the
-						// fingerprint. The closure-scoped replacement for hashing all of
-						// bun.lock (`no-uncontrolled-repetition-or-cascade`). has()+set()
-						// straddle an await, so two concurrent imports of the same package
-						// can both read its version — idempotent (same value), so the
-						// folded result is deterministic regardless of scheduling.
-						const pkgName = nodeModulesPkgName(resolved);
-						if (pkgName && !thirdPartyVersions.has(pkgName)) {
-							const version = await readInstalledPkgVersion(resolved, pkgName);
-							// null = absent (unreadable package.json) — OMIT so a later
-							// successful read invalidates; never mask behind a placeholder
-							// (protective-layers-fail-explicitly). has() stays false → the
-							// read is re-attempted on the next import (cheap, bounded by
-							// closure size); a successful read sets + dedups.
-							if (version !== null) thirdPartyVersions.set(pkgName, version);
-						}
-						continue;
-					}
-					// Atomic dedup: check+add are synchronous (no await between), so on
-					// the single-threaded event loop only one task ever enqueues a path.
-					if (seen.has(resolved)) continue;
-					seen.add(resolved);
-					next.push(resolved);
-				}
-				return next;
-			}),
-		);
-		for (const arr of expanded) frontier.push(...arr);
-	}
-
-	for (const rel of [...fileHashes.keys()].sort()) {
-		h.update("tgjs:").update(rel).update("\0").update(fileHashes.get(rel) as string).update("\0");
-	}
-	// Fold the resolved versions of every third-party package at the closure
-	// boundary, sorted by name for determinism. This is the ONLY signal for
-	// third-party changes (their bodies are not content-walked); without it a
-	// react version bump in the closure would bake a stale bundle.
-	for (const name of [...thirdPartyVersions.keys()].sort()) {
-		h.update("tpv:").update(name).update("\0").update(thirdPartyVersions.get(name) as string).update("\0");
-	}
-}

package/src/handlers/bun-stable-watch.ts

@@ -1,86 +0,0 @@
-/**
- * @system server-boot
- * @status handwritten
- * @edit edit directly
- *
- * The `bun-stable-watch` pg-boss handler — the durable trigger for the
- * bun-1.4 lock-resolution escape hatch's atomic flip-back (open-migration
- * `bun-14-lock-resolution-pin`). Polls the public npm `bun` `latest`
- * dist-tag once daily; when a STABLE 1.4.x (≥1.4.0, no prerelease) ships,
- * records a detection event so the escape hatch can be retired via the atomic
- * flip-back: `config/scala-tools-deps.lockResolutionBun` → "bun" + the ~18
- * `railpack_config` rows → 1.4.0 stable + delete the pinned
- * `/usr/local/bin/bun-1.3.14` binary + a green deploy (all one change). The
- * flip-back itself is a deliberate action, not auto-fired — it mutates config
- * + railpack + a binary + a deploy.
- *
- * `bun/latest` returns the stable release (canaries live under the `canary`
- * dist-tag, not `latest`), so a non-prerelease version ≥1.4.0 means stable
- * shipped. A daily `bun.watch.tick` liveness event lets a watchdog detect a
- * silently-stopped watch (the same shape as `sweep.completed`).
- *
- * Registered under slug `@teamscala/service-boot:bun-stable-watch`.
- */
-import type { ScheduledJobConfig } from "@teamscala/db-validation/registry-schemas/scheduled-job";
-import { recordEvent } from "@teamscala/event-log/record-event";
-import { getAppLogger } from "@teamscala/logger/app-loggers";
-import { getDistTagVersion } from "@teamscala/publish-registry";
-import { pgBossHandlerRegistry } from "../pg-boss-handler-registry.ts";
-
-const NPM_REGISTRY = "https://registry.npmjs.org";
-const TARGET_STABLE = "1.4.0"; // flip back when a stable at or above this ships
-
-interface BunLatestManifest {
-	version: string;
-}
-
-function parseSemver(
-	v: string,
-): { major: number; minor: number; patch: number; prerelease: string } | null {
-	const m = /^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/.exec(v.trim());
-	if (!m) return null;
-	return { major: Number(m[1]), minor: Number(m[2]), patch: Number(m[3]), prerelease: m[4] ?? "" };
-}
-
-/** A stable (non-prerelease) release at or above the target version. */
-function isStableAtOrAbove(version: string, target: string): boolean {
-	const v = parseSemver(version);
-	const t = parseSemver(target);
-	if (!v || !t) return false;
-	if (v.prerelease) return false; // canary/beta/rc are not stable
-	if (v.major !== t.major) return v.major > t.major;
-	if (v.minor !== t.minor) return v.minor > t.minor;
-	return v.patch >= t.patch;
-}
-
-async function bunStableWatch(_ctx: { config: ScheduledJobConfig }): Promise<void> {
-	const log = getAppLogger();
-	const version = await getDistTagVersion("bun", "latest", NPM_REGISTRY);
-	if (!version) {
-		log.warn("[bun-stable-watch] failed to fetch npm bun/latest");
-		return;
-	}
-	if (isStableAtOrAbove(version, TARGET_STABLE)) {
-		log.warn(
-			`[bun-stable-watch] Bun stable ${version} (>=${TARGET_STABLE}) shipped — escape hatch 'bun-14-lock-resolution-pin' is ready to retire. Run the atomic flip-back: config/scala-tools-deps.lockResolutionBun -> "bun" + railpack_config rows -> 1.4.0 stable + delete /usr/local/bin/bun-1.3.14 + a green deploy.`,
-		);
-		recordEvent({
-			kind: "bun.stable.shipped",
-			payload: {
-				latest: version,
-				targetStable: TARGET_STABLE,
-				note: "escape hatch bun-14-lock-resolution-pin ready to retire; verify railpack 1.4.0 support then run the atomic flip-back",
-			},
-		});
-		return;
-	}
-	log.info(
-		`[bun-stable-watch] npm bun/latest = ${version} — not yet stable ${TARGET_STABLE}; escape hatch remains`,
-	);
-	recordEvent({
-		kind: "bun.watch.tick",
-		payload: { latest: version, targetStable: TARGET_STABLE },
-	});
-}
-
-pgBossHandlerRegistry.register("@teamscala/service-boot:bun-stable-watch", bunStableWatch);

package/src/handlers/messaging-send-reconcile-logic.test.ts

@@ -1,79 +0,0 @@
-// @system codegen
-// @status generated
-// @edit change the suite in the owned-suites band, then re-run codegen. Hand-edits are overwritten.
-//
-// This suite's assertions are OWNED by the codegen band: the band module
-// 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 { describe, expect, test } from "bun:test";
-import {
-	buildBackfillRow,
-	diffOutboundSends,
-	type GowaOutboundMessage,
-} from "./messaging-send-reconcile-logic.ts";
-
-const NOW = new Date("2026-08-26T02:30:00Z");
-const SETTLE_MS = 120_000;
-
-describe("diffOutboundSends", () => {
-	const rawSend: GowaOutboundMessage = {
-		id: "3EB0F05AC9FAAF24BDA045",
-		chat_jid: "61428193498@s.whatsapp.net",
-		content: "Launcha Authority Index — report page header",
-		timestamp: "2026-08-25T16:13:57Z",
-		is_from_me: true,
-	};
-
-	test("CLEAN: every outbound id already recorded — nothing to backfill", () => {
-		const missing = diffOutboundSends(
-			[rawSend],
-			new Set(["3EB0F05AC9FAAF24BDA045"]),
-			NOW,
-			SETTLE_MS,
-		);
-		expect(missing).toEqual([]);
-	});
-
-	test("VIOLATING: a GOWA-outbound send with no recorded row is a backfill candidate", () => {
-		const missing = diffOutboundSends([rawSend], new Set(), NOW, SETTLE_MS);
-		expect(missing).toHaveLength(1);
-		expect(missing[0]).toEqual({
-			id: "3EB0F05AC9FAAF24BDA045",
-			chatJid: "61428193498@s.whatsapp.net",
-			content: "Launcha Authority Index — report page header",
-			timestamp: "2026-08-25T16:13:57.000Z",
-		});
-	});
-
-	test("inbound messages are never candidates (they record themselves via webhook)", () => {
-		const inbound: GowaOutboundMessage = { ...rawSend, is_from_me: false };
-		expect(diffOutboundSends([inbound], new Set(), NOW, SETTLE_MS)).toEqual([]);
-	});
-
-	test("a send younger than the settle window waits one tick for the recorder", () => {
-		const fresh: GowaOutboundMessage = {
-			...rawSend,
-			timestamp: "2026-08-26T02:29:30Z",
-		};
-		expect(diffOutboundSends([fresh], new Set(), NOW, SETTLE_MS)).toEqual([]);
-	});
-});
-
-describe("buildBackfillRow", () => {
-	test("carries the provider id, the recipient, and the reconciled send_kind", () => {
-		const row = buildBackfillRow({
-			id: "3EB0AF4413C8A5A0694B38",
-			chatJid: "61428193498@s.whatsapp.net",
-			content: "The quiz report email as delivered",
-			timestamp: "2026-08-25T16:14:13Z",
-		});
-		expect(row.direction).toBe("outbound");
-		expect(row.event_type).toBe("sent");
-		expect(row.external_msg_id).toBe("3EB0AF4413C8A5A0694B38");
-		expect(row.external_chat_id).toBe("61428193498@s.whatsapp.net");
-		expect(row.user_phone).toBe("61428193498@s.whatsapp.net");
-		expect(row.payload.send_kind).toBe("gowa-reconcile");
-	});
-});