@teamscala/service-boot 0.23.388 → 0.23.389

package/package.json

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

package/src/module-not-found.test.ts

@@ -0,0 +1,84 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Locks the mount candidate-chain regression (2026-08-24): scala-agents-ui
+ * crash-looped at boot because @teamscala/cli-session exports ./boot/mount.ts
+ * and not ./mount.ts. The chain already listed boot/mount.ts as a fallback,
+ * but Bun names an unexported subpath by its BARE package, so the first
+ * candidate's miss was classified as a real error and boot died before the
+ * fallback ran. The whole value of the chain is that candidate 1 may be absent.
+ */
+
+import { describe, expect, it } from "bun:test";
+import { barePackageOf, isModuleNotFound } from "./module-not-found";
+
+describe("barePackageOf", () => {
+	it("keeps the scope for scoped packages", () => {
+		expect(barePackageOf("@teamscala/cli-session/mount.ts")).toBe(
+			"@teamscala/cli-session",
+		);
+		expect(barePackageOf("@teamscala/cli-session")).toBe(
+			"@teamscala/cli-session",
+		);
+	});
+
+	it("takes the first segment for unscoped packages", () => {
+		expect(barePackageOf("hono/mount.ts")).toBe("hono");
+		expect(barePackageOf("hono")).toBe("hono");
+	});
+});
+
+describe("isModuleNotFound", () => {
+	// The exact shape Bun emits for an unexported subpath: it names the
+	// PACKAGE, never the subpath that was asked for.
+	const bunSubpathMiss = {
+		message:
+			"Cannot find package '@teamscala/cli-session' imported from /srv/node_modules/@teamscala/service-boot/src/mount-server-packages.ts",
+	};
+
+	it("treats an unexported subpath as not-found so the chain falls through", () => {
+		expect(
+			isModuleNotFound(bunSubpathMiss, "@teamscala/cli-session/mount.ts"),
+		).toBe(true);
+	});
+
+	it("still matches when the error names the full specifier", () => {
+		expect(
+			isModuleNotFound(
+				{ message: "Cannot find module '@teamscala/x/mount.ts'" },
+				"@teamscala/x/mount.ts",
+			),
+		).toBe(true);
+	});
+
+	it("does NOT swallow a transitive miss of a DIFFERENT module", () => {
+		// A file inside the candidate failing to resolve something else must
+		// surface as a real error, or the true cause hides behind "not found".
+		expect(
+			isModuleNotFound(
+				{ message: "Cannot find package '@teamscala/some-other-dep'" },
+				"@teamscala/cli-session/mount.ts",
+			),
+		).toBe(false);
+	});
+
+	it("does NOT swallow a syntax or runtime error", () => {
+		expect(
+			isModuleNotFound(
+				new SyntaxError("Unexpected token"),
+				"@teamscala/cli-session/mount.ts",
+			),
+		).toBe(false);
+	});
+
+	it("reads non-Error throwables defensively (Bun ResolveMessage is not an Error)", () => {
+		expect(
+			isModuleNotFound(
+				"Cannot find package '@teamscala/cli-session'",
+				"@teamscala/cli-session/mount.ts",
+			),
+		).toBe(true);
+	});
+});

package/src/module-not-found.ts

@@ -0,0 +1,39 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Classifies a failed dynamic import as "this candidate is absent" vs a real
+ * error, for the server_package mount candidate chain. Extracted from
+ * mount-server-packages so the classification is testable: as a closure it
+ * could not be exercised, and it shipped wrong.
+ */
+
+/** `@scope/name/sub/path.ts` -> `@scope/name`; `name/sub` -> `name`. */
+export function barePackageOf(specifier: string): string {
+	const parts = specifier.split("/");
+	return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+
+/**
+ * True when the import failed because `requestedPath` itself is absent.
+ *
+ * Bun reports an unexported SUBPATH as `Cannot find package '<bare>'`, naming
+ * the package rather than the subpath, so the bare name of THIS candidate
+ * counts as not-found. Without that the first candidate's miss is
+ * misclassified as fatal and the fallbacks never run (measured 2026-08-24:
+ * scala-agents-ui crash-looped because cli-session exports ./boot/mount.ts and
+ * not ./mount.ts). A transitive miss naming a DIFFERENT module still surfaces.
+ */
+export function isModuleNotFound(err: unknown, requestedPath: string): boolean {
+	const msg =
+		(err as { message?: string })?.message ??
+		(typeof err === "string" ? err : String(err));
+	const bare = barePackageOf(requestedPath);
+	return (
+		msg.includes(`Cannot find module '${requestedPath}'`) ||
+		msg.includes(`Cannot find package '${requestedPath}'`) ||
+		msg.includes(`Cannot find module '${bare}'`) ||
+		msg.includes(`Cannot find package '${bare}'`)
+	);
+}

package/src/mount-server-packages.ts

@@ -20,6 +20,7 @@ import {
 	type MountRegistry,
 } from "@teamscala/os/runtime-contracts/mount-context";
 import type { Hono } from "hono";
+import { isModuleNotFound } from "./module-not-found";
 
 type ServerPackageMount = (ctx: MountContext) => Promise<void> | void;
 
@@ -68,19 +69,7 @@ export async function mountServerPackages(
 		return mountRegistry;
 	}
 
-	const isModuleNotFound = (err: unknown, requestedPath: string): boolean => {
-		// Bun's ResolveMessage is not an Error subclass — read message defensively.
-		// Match ONLY when the missing module is the candidate path itself; transitive
-		// not-found errors (e.g. a file inside the candidate fails to resolve a
-		// different module) must surface, not be swallowed as "not found here".
-		const msg =
-			(err as { message?: string })?.message ??
-			(typeof err === "string" ? err : String(err));
-		return (
-			msg.includes(`Cannot find module '${requestedPath}'`) ||
-			msg.includes(`Cannot find package '${requestedPath}'`)
-		);
-	};
+
 
 	for (const pkg of serverPackages) {
 		try {