@teamscala/service-boot 0.23.436 → 0.23.437

package/package.json

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

package/src/discover-blocks.ts

@@ -25,6 +25,7 @@ import { join } from "node:path";
 import { getPrisma } from "@teamscala/db/prisma-registry";
 import { BlockSchemaConfigSchema } from "@teamscala/db-validation/registry-schemas/block-schema";
 import * as v from "valibot";
+import { isReactElementType } from "./is-react-element-type.ts";
 import type { RendererComponentEntry } from "./types.ts";
 
 export interface DiscoveredBlocks {
@@ -159,7 +160,7 @@ export async function discoverBlocks(
 				),
 			])) as Record<string, unknown>;
 			const component = mod[componentExport] ?? mod.default;
-			if (typeof component !== "function") {
+			if (!isReactElementType(component)) {
 				skipped.push(
 					`${row.slug} (${componentExport} not a component in ${componentPath})`,
 				);

package/src/is-react-element-type.test.ts

@@ -0,0 +1,46 @@
+/**
+ * @system ui-service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Pins the three React idioms a `typeof === "function"` check silently rejects.
+ * The memo case is the measured one: PresenceAvatars rendered blank on every
+ * scala-projects page carrying it, because memo() returns an object.
+ */
+
+import { expect, test } from "bun:test";
+import { forwardRef, lazy, memo } from "react";
+import { isReactElementType } from "./is-react-element-type.ts";
+
+function Plain() {
+	return null;
+}
+
+test("accepts a plain function component", () => {
+	expect(isReactElementType(Plain)).toBe(true);
+});
+
+test("accepts memo() — the PresenceAvatars shape that rendered blank", () => {
+	expect(isReactElementType(memo(Plain))).toBe(true);
+});
+
+test("accepts forwardRef()", () => {
+	expect(isReactElementType(forwardRef(() => null))).toBe(true);
+});
+
+test("accepts lazy()", () => {
+	expect(isReactElementType(lazy(async () => ({ default: Plain })))).toBe(true);
+});
+
+test("still rejects what genuinely cannot render", () => {
+	expect(isReactElementType(undefined)).toBe(false);
+	expect(isReactElementType(null)).toBe(false);
+	expect(isReactElementType({})).toBe(false);
+	expect(isReactElementType("PresenceAvatarsBlock")).toBe(false);
+	expect(isReactElementType(42)).toBe(false);
+});
+
+test("rejects a plain object wearing a non-symbol $$typeof", () => {
+	// A data blob with the key but not the symbol must not pass as renderable.
+	expect(isReactElementType({ $$typeof: "react.memo" })).toBe(false);
+});

package/src/is-react-element-type.ts

@@ -0,0 +1,20 @@
+/**
+ * @system ui-service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Is a resolved module export something React can render?
+ *
+ * `typeof x === "function"` is NOT that question. memo(), forwardRef() and
+ * lazy() all return OBJECTS carrying a `$$typeof` symbol, so a shape check on
+ * `function` rejects three of React's own idioms as "not a component".
+ * Measured 2026-09-01: scala-projects skipped PresenceAvatars for exactly this
+ * reason — the block is `memo(function PresenceAvatarsBlock(...))` — and every
+ * page rendering it came out blank with no error beyond one boot WARN.
+ */
+
+export function isReactElementType(value: unknown): boolean {
+	if (typeof value === "function") return true;
+	if (typeof value !== "object" || value === null) return false;
+	return typeof (value as { $$typeof?: unknown }).$$typeof === "symbol";
+}