@teamscala/service-boot 0.23.455 → 0.23.457

package/package.json

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

package/src/build-client-assets/styles-build.test.ts

@@ -0,0 +1,157 @@
+/**
+ * @system server-handlers
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Behavioural pins for the stylesheet resolver (operator ruling 2026-09-03:
+ * the fallback chain IS the drift — a bare id resolved via Bun.resolve
+ * returned whatever the package's main was (a .js for a normal package),
+ * the resolve(base, id) tail invented nonexistent paths whose ENOENT
+ * surfaced as misleading downstream CSS errors, and inlineCssImports
+ * SWALLOWED unresolved imports, leaving literals that failed downstream
+ * instead of at the build. Every case below pins the ruled contract:
+ * resolve or THROW naming the specifier; remote https imports are skipped
+ * explicitly, never resolved and never thrown on.
+ */
+import { describe, expect, test } from "bun:test";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { bunResolveStylesheet } from "./styles-build.ts";
+
+async function makeTree(tag: string, files: Record<string, string>) {
+	const root = join(tmpdir(), `styles-build-${tag}-${process.pid}`);
+	await rm(root, { recursive: true, force: true });
+	for (const [rel, content] of Object.entries(files)) {
+		const p = join(root, rel);
+		await mkdir(p.slice(0, p.lastIndexOf("/")), { recursive: true });
+		await writeFile(p, content);
+	}
+	return root;
+}
+
+describe("bunResolveStylesheet — relative ids", () => {
+	test("a relative import that exists resolves and inlines its nested @imports", async () => {
+		const root = await makeTree("rel-ok", {
+			"src/entry.css": '@import "./leaf.css";\n.body { color: red; }\n',
+			"src/leaf.css": ".leaf { color: blue; }\n",
+		});
+		const r = await bunResolveStylesheet("./entry.css", join(root, "src"), root);
+		expect(r.content).toContain(".body");
+		expect(r.content).toContain(".leaf");
+		await rm(root, { recursive: true, force: true });
+	});
+
+	test("a relative import that does NOT exist throws naming the specifier and the path", async () => {
+		const root = await makeTree("rel-missing", {
+			"src/entry.css": ".body { color: red; }\n",
+		});
+		const err = await bunResolveStylesheet(
+			"./nope.css",
+			join(root, "src"),
+			root,
+		).catch((e) => e);
+		expect(err).toBeInstanceOf(Error);
+		expect((err as Error).message).toContain('"./nope.css"');
+		expect((err as Error).message).toContain("not found");
+		await rm(root, { recursive: true, force: true });
+	});
+});
+
+describe("bunResolveStylesheet — bare ids", () => {
+	test("a CSS-only package resolves via its declared style entry", async () => {
+		const root = await makeTree("bare-style", {
+			"node_modules/tw-animate-css/package.json": JSON.stringify({
+				name: "tw-animate-css",
+				exports: { ".": { style: "./dist/tw-animate.css" } },
+			}),
+			"node_modules/tw-animate-css/dist/tw-animate.css":
+				".tw-animate { animation: none; }\n",
+			"src/app.css": '.x { color: red; }\n',
+		});
+		const r = await bunResolveStylesheet(
+			"tw-animate-css",
+			join(root, "src"),
+			root,
+		);
+		expect(r.content).toContain(".tw-animate");
+		await rm(root, { recursive: true, force: true });
+	});
+
+	test("a normal JS package (no style entry) THROWS naming the specifier — never its .js main", async () => {
+		const root = await makeTree("bare-js-main", {
+			"node_modules/lodash/package.json": JSON.stringify({
+				name: "lodash",
+				main: "lodash.js",
+			}),
+			"node_modules/lodash/lodash.js": "module.exports = {};\n",
+			"src/app.css": ".x { color: red; }\n",
+		});
+		const err = await bunResolveStylesheet(
+			"lodash",
+			join(root, "src"),
+			root,
+		).catch((e) => e);
+		expect(err).toBeInstanceOf(Error);
+		expect((err as Error).message).toContain('"lodash"');
+		expect((err as Error).message).toContain("no style entry");
+		expect((err as Error).message).not.toContain("lodash.js");
+		await rm(root, { recursive: true, force: true });
+	});
+
+	test("a bare id with no package anywhere THROWS naming the specifier and both roots", async () => {
+		const root = await makeTree("bare-missing", {
+			"src/app.css": ".x { color: red; }\n",
+		});
+		const src = join(root, "src");
+		const err = await bunResolveStylesheet("no-such-pkg", src, root).catch(
+			(e) => e,
+		);
+		expect(err).toBeInstanceOf(Error);
+		expect((err as Error).message).toContain('"no-such-pkg"');
+		expect((err as Error).message).toContain("unresolved");
+		expect((err as Error).message).toContain(src);
+		await rm(root, { recursive: true, force: true });
+	});
+});
+
+describe("bunResolveStylesheet — remote @imports", () => {
+	test("a remote https @import is kept verbatim (stripped later by stripRemoteImports), never resolved", async () => {
+		const root = await makeTree("remote-skip", {
+			"node_modules/cdn-fonts/package.json": JSON.stringify({
+				name: "cdn-fonts",
+				exports: { ".": { style: "./index.css" } },
+			}),
+			"node_modules/cdn-fonts/index.css":
+				'@import "https://rsms.me/inter/inter.css";\n.cdn { font-family: inter; }\n',
+			"src/app.css": ".x { color: red; }\n",
+		});
+		const r = await bunResolveStylesheet(
+			"cdn-fonts",
+			join(root, "src"),
+			root,
+		);
+		expect(r.content).toContain("https://rsms.me/inter/inter.css");
+		expect(r.content).toContain(".cdn");
+		await rm(root, { recursive: true, force: true });
+	});
+
+	test("a LOCAL @import of a missing file THROWS at the build instead of leaving a literal", async () => {
+		const root = await makeTree("local-missing-nested", {
+			"node_modules/broken-pkg/package.json": JSON.stringify({
+				name: "broken-pkg",
+				exports: { ".": { style: "./index.css" } },
+			}),
+			"node_modules/broken-pkg/index.css": '@import "./gone.css";\n.real { color: red; }\n',
+			"src/app.css": ".x { color: red; }\n",
+		});
+		const err = await bunResolveStylesheet(
+			"broken-pkg",
+			join(root, "src"),
+			root,
+		).catch((e) => e);
+		expect(err).toBeInstanceOf(Error);
+		expect((err as Error).message).toContain('"./gone.css"');
+		await rm(root, { recursive: true, force: true });
+	});
+});

package/src/build-client-assets/styles-build.ts

@@ -31,31 +31,91 @@ async function resolveStylesheetRaw(
 		const r = await Bun.resolve("tailwindcss/index.css", cwd);
 		return { path: r, base: dirname(r), content: await Bun.file(r).text() };
 	}
-	try {
-		const r = await Bun.resolve(id, base);
-		return { path: r, base: dirname(r), content: await Bun.file(r).text() };
-	} catch (error) {
-		getAppLogger().warn("style import resolve failed — trying package fallback", error);
+	if (id.startsWith(".")) {
+		// Relative import: resolve against the importing file's directory and
+		// REQUIRE existence — a missing leaf is a build-breaking error naming
+		// the specifier, never a silently-dropped subtree.
+		const p = resolve(base, id);
+		if (!(await Bun.file(p).exists())) {
+			throw new Error(
+				`style import "${id}" not found at ${p} (resolved relative to ${base})`,
+			);
+		}
+		return { path: p, base: dirname(p), content: await Bun.file(p).text() };
 	}
-	if (!id.startsWith(".")) {
-		try {
-			const pkgPath = await Bun.resolve(id + "/package.json", cwd);
-			const pkg = JSON.parse(await Bun.file(pkgPath).text());
-			const entry =
-				pkg.exports?.["."]?.style || pkg.style || pkg.main;
-			if (entry) {
-				const r = resolve(dirname(pkgPath), entry);
+	// A BARE SPECIFIER IS A PACKAGE NAME PLUS AN OPTIONAL SUBPATH, and the two
+	// must be separated before anything is looked up. `@teamscala/ui-foundation`
+	// is a package; `@teamscala/ui-foundation/theme/styles.css` is that same
+	// package plus an explicit file inside it. Treating the whole string as a
+	// package name looks for node_modules/@teamscala/ui-foundation/theme/
+	// styles.css/package.json, which cannot exist — so EVERY subpath import
+	// fails and the styles bundle dies, taking the theme layer with it.
+	//
+	// A scoped name is the FIRST TWO segments (@scope/name); an unscoped name
+	// is the first. Everything after that is a path inside the package and is
+	// resolved directly — it names a file, so there is nothing to negotiate and
+	// no style entry to consult.
+	const segments = id.split("/");
+	const nameLength = id.startsWith("@") ? 2 : 1;
+	const packageName = segments.slice(0, nameLength).join("/");
+	const subpath = segments.slice(nameLength).join("/");
+
+	// Find node_modules/<packageName>/package.json by walking upward from the
+	// importing file's dir then cwd. Bun.resolve is not used: it hands back
+	// whatever the package's main is — for a normal JS package a .js entry,
+	// not the declared stylesheet — and an `exports` allow-list blocks the
+	// package.json subpath on exactly the CSS-only packages this must serve.
+	const tried: string[] = [];
+	for (const root of [base, cwd]) {
+		let dir = root;
+		for (;;) {
+			const pkgPath = join(dir, "node_modules", packageName, "package.json");
+			if (await Bun.file(pkgPath).exists()) {
+				const pkgDir = dirname(pkgPath);
+				const pkg = await Bun.file(pkgPath).json();
+				if (subpath) {
+					// THE EXPORTS MAP IS THE AUTHORITY ON WHERE A SUBPATH LIVES,
+					// and it commonly REMAPS. `@teamscala/ui-foundation` publishes
+					// "./theme/styles.css" -> "./src/theme/styles.css", so resolving
+					// the subpath literally against the package root looks for a
+					// file that has never existed there. Consult exports first and
+					// fall back to the literal path only for a package that
+					// declares none.
+					const exported = pkg.exports?.[`./${subpath}`];
+					const mapped: string | undefined =
+						typeof exported === "string"
+							? exported
+							: (exported?.style ?? exported?.default);
+					const r = resolve(pkgDir, mapped ?? subpath);
+					if (!(await Bun.file(r).exists())) {
+						throw new Error(
+							`style import "${id}" resolves to ${r}, which does not exist` +
+								(mapped
+									? ` (exports maps "./${subpath}" to "${mapped}")`
+									: ` (${packageName} declares no exports entry for "./${subpath}")`),
+						);
+					}
+					return { path: r, base: dirname(r), content: await Bun.file(r).text() };
+				}
+				// No subpath: the package itself must declare its stylesheet.
+				const entry: string | undefined = pkg.exports?.["."]?.style ?? pkg.style;
+				if (!entry) {
+					throw new Error(
+						`style import "${id}" resolved to ${pkgPath} but the package declares no style entry (exports["."].style / style) — not a stylesheet package`,
+					);
+				}
+				const r = resolve(pkgDir, entry);
 				return { path: r, base: dirname(r), content: await Bun.file(r).text() };
 			}
-		} catch (error) {
-			getAppLogger().warn(
-				"package style entry resolve failed — falling back to bare resolve",
-				error,
-			);
+			tried.push(pkgPath);
+			const parent = dirname(dir);
+			if (parent === dir) break;
+			dir = parent;
 		}
 	}
-	const r = resolve(base, id);
-	return { path: r, base: dirname(r), content: await Bun.file(r).text() };
+	throw new Error(
+		`style import "${id}" unresolved — no node_modules/${packageName}/package.json found walking up from ${base} or ${cwd} (${tried.length} location(s) tried)`,
+	);
 }
 
 // Tailwind v4's compile() invokes `loadStylesheet` for DIRECT @imports in the entry (app.css) but does NOT re-invoke it for @imports WITHIN the loaded
@@ -87,14 +147,18 @@ async function inlineCssImports(
 			result += m[0];
 			continue;
 		}
+		// Remote @imports are CSP-forbidden and stripped by
+		// stripRemoteImports AFTER the compile: skip them here EXPLICITLY —
+		// they must never reach resolveStylesheetRaw, and an unresolved
+		// LOCAL import below is a throw, not a swallow.
+		if (spec.startsWith("http://") || spec.startsWith("https://")) {
+			result += m[0];
+			continue;
+		}
 		if (seen.has(spec)) continue; // cycle guard
 		seen.add(spec);
-		try {
-			const resolved = await resolveStylesheetRaw(spec, base, cwd);
-			result += await inlineCssImports(resolved.content, resolved.base, cwd, seen);
-		} catch {
-			result += m[0]; // unresolved — keep literal; CSS/Tailwind will surface it
-		}
+		const resolved = await resolveStylesheetRaw(spec, base, cwd);
+		result += await inlineCssImports(resolved.content, resolved.base, cwd, seen);
 	}
 	result += css.slice(lastIdx);
 	return result;
@@ -111,6 +175,8 @@ async function bunResolveStylesheet(
 	return { ...resolved, content };
 }
 
+export { bunResolveStylesheet };
+
 // The app owns its fonts via an explicit, CSP-allowlisted <link> in index.html (Google Fonts — `style-src ... fonts.googleapis.com`, `font-src ...
 // fonts.gstatic.com`). Third-party package CSS MUST NOT inject its own remote `@import url(http…)`: @puckeditor/core/dist/index.css opens with
 // `@import "https://rsms.me/inter/inter.css"`, an arbitrary CDN our CSP does NOT allow. The Tailwind compile inlines that mid-output, where it was either

package/src/proposal-authorized-emails.ts

@@ -33,8 +33,6 @@ export async function resolveProposalAuthorizedEmails(
 	proposalId: string,
 ): Promise<Set<string>> {
 	try {
-		const { getPrisma } = await import("@teamscala/db/prisma-registry");
-		const prisma = getPrisma();
 		const rows = await queryRows`
 			SELECT lower(u.email) AS email
 			  FROM better_auth_member m

package/src/resolve-from-loader-config.test.ts

@@ -52,8 +52,7 @@ describe("interpolateMeta (resolver_input ref contract)", () => {
 });
 
 describe("resource-loader model capability", () => {
-	test("an optional source still refuses a model absent from the generated client", async () => {
-		const original = isServerClientRegistered() ? getServerClient() : null;
+	test("an optional source still refuses a model absent from the generated client", async () => {		const original = isServerClientRegistered() ? getServerClient() : null;
 		setServerClient({} as never);
 		try {
 			await expect(
@@ -104,3 +103,114 @@ describe("resource-loader model capability", () => {
 		}
 	});
 });
+
+describe("required sources refuse unresolvable where refs", () => {
+	// The 2026-09-03 proposal outage class: interpolateTemplate DROPS a key
+	// whose ref resolves undefined, so a required source queries with a
+	// partial (or empty) filter — which matches an ARBITRARY row or none,
+	// serving a silent empty page instead of failing. Null is a real value
+	// (an unset column) and must keep flowing through.
+	const original = isServerClientRegistered() ? getServerClient() : null;
+	const capturingClient = (captured: { where: unknown }) => ({
+		builda_pages: {
+			findFirst: async (args: { where: unknown }) => {
+				captured.where = args.where;
+				return { id: "row" };
+			},
+		},
+	} as never);
+
+	test("a required source with an undefined ref throws naming it", async () => {
+		setServerClient(capturingClient({ where: null }));
+		try {
+			await expect(
+				resolveFromLoaderConfig(
+					{
+						sources: [
+							{
+								key: "page",
+								source: "orpc",
+								model: "builda_pages",
+								where: { id: ":proposal.page_id" },
+								optional: false,
+							},
+						],
+					},
+					{ id: "p1" },
+				),
+			).rejects.toThrow(/required source "page".*:proposal\.page_id.*undefined/);
+		} finally {
+			setServerClient(original as never);
+		}
+	});
+
+	test("an optional source with the same undefined ref still resolves null", async () => {
+		setServerClient({
+			builda_pages: { findFirst: async () => null },
+		} as never);
+		try {
+			await expect(
+				resolveFromLoaderConfig(
+					{
+						sources: [
+							{
+								key: "page",
+								source: "orpc",
+								model: "builda_pages",
+								where: { id: ":proposal.page_id" },
+								optional: true,
+							},
+						],
+					},
+					{ id: "p1" },
+				),
+			).resolves.toEqual({ page: null });
+		} finally {
+			setServerClient(original as never);
+		}
+	});
+
+	test("a resolved null flows through as a null filter on a required source", async () => {
+		const captured = { where: null as unknown };
+		// The first source resolves a row whose partner_id IS null — null is a
+		// real value flowing through interpolation, not an unresolved ref.
+		setServerClient({
+			builda_pages: {
+				findFirst: async (args: { where: unknown }) => {
+					captured.where = args.where;
+					return (args.where as { id: string }).id === "p1"
+						? { id: "p1", partner_id: null }
+						: null;
+				},
+			},
+		} as never);
+		try {
+			await resolveFromLoaderConfig(
+				{
+					sources: [
+						{
+							key: "proposal",
+							source: "orpc",
+							model: "builda_pages",
+							where: { id: ":id" },
+							optional: false,
+						},
+						{
+							key: "partnerOrg",
+							source: "orpc",
+							model: "builda_pages",
+							where: { partner_id: ":proposal.partner_id" },
+							optional: false,
+							depends_on: ["proposal"],
+						},
+					],
+				},
+				{ id: "p1" },
+			);
+		} finally {
+			setServerClient(original as never);
+		}
+		// The partnerOrg source queried WITH { partner_id: null }, not refused.
+		expect(captured.where).toEqual({ partner_id: null });
+	});
+});

package/src/resolve-from-loader-config.ts

@@ -12,6 +12,7 @@
  */
 
 import { loadRegistryConfig } from "@teamscala/db/registry/load-config";
+import type { ResolverFnKey } from "@teamscala/db/registry/generated/resolver-fn";
 import { ResolverFnConfigSchema } from "@teamscala/db-validation/registry-schemas/resolver-fn";
 import { getServerClient } from "./page-server-orpc/server-client";
 
@@ -120,7 +121,7 @@ function toSelectMap(
  * hardcoded if(resolver_fn==='X') chain — adding a resolver is now a registry_edit row.
  */
 async function resolveByResolverFn(
-	slug: string,
+	slug: ResolverFnKey,
 	input: Record<string, unknown>,
 	params: Record<string, unknown>,
 ): Promise<unknown> {
@@ -145,6 +146,40 @@ async function resolveByResolverFn(
 	return fn({ input, client: await getServerClient(), params });
 }
 
+/**
+ * Exact `:ref` strings inside a raw where/resolver_input whose value resolves
+ * to undefined — the keys interpolateTemplate DROPS. A dropped where key on a
+ * required source would query with a partial (or empty) filter, which matches
+ * an ARBITRARY row — worse than an error, so required sources refuse here
+ * instead (`a-component-may-not-report-a-state-it-has-not-verified`). Null is
+ * a real value (an unset column filtered as null) and never counts as broken.
+ */
+function unresolvedTemplateRefs(
+	template: unknown,
+	params: Record<string, unknown>,
+	resolved: Record<string, unknown>,
+): string[] {
+	const broken: string[] = [];
+	const walk = (node: unknown): void => {
+		if (typeof node === "string") {
+			const exact = node.match(/^:([a-zA-Z0-9_.]+)$/);
+			if (exact && resolveParamRef(exact[1], params, resolved) === undefined) {
+				broken.push(exact[1]);
+			}
+			return;
+		}
+		if (Array.isArray(node)) {
+			for (const v of node) walk(v);
+			return;
+		}
+		if (node != null && typeof node === "object") {
+			for (const v of Object.values(node)) walk(v);
+		}
+	};
+	walk(template);
+	return broken;
+}
+
 async function resolveSource(
 	source: SourceConfig,
 	params: Record<string, unknown>,
@@ -156,6 +191,14 @@ async function resolveSource(
 		case "orpc":
 		case "prisma": {
 			if (!source.model) return null;
+			if (!source.optional && source.where) {
+				const broken = unresolvedTemplateRefs(source.where, params, resolved);
+				if (broken.length > 0) {
+					throw new Error(
+						`[resource_loader] required source "${source.key}": where ref(s) ${broken.map((ref) => `:${ref}`).join(", ")} resolved to undefined — refusing to query without them (a dropped filter silently matches an arbitrary row)`,
+					);
+				}
+			}
 			const where = source.where
 				? (interpolateTemplate(source.where, params, resolved) as Record<
 						string,
@@ -187,7 +230,11 @@ async function resolveSource(
 					) as Record<string, unknown>)
 				: {};
 
-			return resolveByResolverFn(source.resolver_fn ?? "", input, params);
+			return resolveByResolverFn(
+				source.resolver_fn as ResolverFnKey,
+				input,
+				params,
+			);
 		}
 		default:
 			throw new Error(