@teamscala/service-boot 0.23.433 → 0.23.434

package/package.json

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

package/src/fn-routers/index.ts

@@ -13,10 +13,24 @@
  * RegionPageSwap can fetch a region's Puck page on demand and render it into a
  * slot — the no-reload half of `region-views-are-pages` (every region is a Puck
  * page; switching a view loads a different page's content).
+ *
+ * `resolvePanelData` WAS RESTORED 2026-08-31. `72ac1a7` ("Retire unoffered page
+ * ORPC procedures") deleted it three weeks earlier as unoffered, but its
+ * consumer is live and in ANOTHER REPO: `use-region-page.ts` in
+ * @teamscala/ui-foundation calls `regions.resolvePanelData` on every panel
+ * open. Only the comment describing it was left behind — the shape
+ * `a-deleted-producer-leaves-its-consumers-executing` names, where deleting a
+ * producer leaves its consumers demanding something that can no longer exist.
+ *
+ * It failed SILENTLY for three weeks because the client treats a failure as
+ * best-effort and maps it to null, so the 404 rendered an empty panel with no
+ * error anywhere. Observed live as `POST /api/rpc/regions/resolvePanelData 404`
+ * on every panel open on projects-dev.
  */
 
 import { registerCustomRouter } from "@teamscala/orpc/app-router";
 import { puckPagesRouter } from "../page-server-orpc/puck-pages-router";
+import { resolvePanelDataHandler } from "./panel-data-router.ts";
 import { watchDataChange } from "@teamscala/realtime-utils/data-change-procedure";
 import { watchPresence } from "@teamscala/realtime-utils/presence-procedure";
 import { agreementSendRouter } from "./agreement-send-router.ts";
@@ -51,6 +65,8 @@ export function registerFnRouters(): void {
 		loadPage: puckPagesRouter.loadFromWebsite,
 		// Resolve a page-kind panel's OWN loaderData (panel_view.loader_slug) so a
 		// panel region renders against the panel page's data, not the host's.
+		//
+		resolvePanelData: resolvePanelDataHandler,
 	});
 	registerCustomRouter("realtime", {
 		watchDataChange,

package/src/fn-routers/panel-data-router.ts

@@ -0,0 +1,104 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * `regions.resolvePanelData` — resolves a page-kind panel's OWN loaderData so a
+ * panel region renders blocks against the panel page's data, not the host
+ * page's. RegionPageSwap calls this on panel-open + injects the result via
+ * LiveDataProvider("page-data"), making panel-embedded data blocks (e.g. the
+ * workload Chart) self-sufficient: each panel carries its own data, no host
+ * coupling + no preloading the host route.
+ *
+ * Flow (registry reads via the loadRegistryConfig helper — registry-via-helper):
+ * panel_view.content.loader_slug → resource_loader config → orgId derived from
+ * the serving website (builda_websites.organisation_id) → resolveFromLoaderConfig
+ * → the loader's resolved sources. Panels without a loader_slug (e.g. the AI
+ * panel, whose block self-loads) return null — no extra round-trip, no behavior
+ * change.
+ */
+import { os } from "@orpc/server";
+import * as v from "valibot";
+import { loadRegistryConfig } from "@teamscala/db/registry/load-config";
+import type { PanelViewKey } from "@teamscala/db/registry/generated/panel-view";
+import type { ResourceLoaderKey } from "@teamscala/db/registry/generated/resource-loader";
+import { resolveFromLoaderConfig } from "../resolve-from-loader-config.ts";
+
+interface Context {
+	prisma: {
+		builda_websites: {
+			findFirst: (args: unknown) => Promise<{
+				organisation_id?: string | null;
+			} | null>;
+		};
+	};
+}
+
+const panelViewSchema = v.looseObject({
+	content: v.looseObject({ loader_slug: v.optional(v.string()) }),
+});
+
+export const resolvePanelDataHandler = os
+	.$context<Context>()
+	.input(
+		v.object({
+			panelSlug: v.string(),
+			websiteSlug: v.string(),
+			/** Tenant orgId (preferred over the website's organisation_id, which is
+			 * the platform org on a multi-tenant portal — not the tenant). The
+			 * caller (RegionPageSwap) threads this from __PAGE_DATA__.orgId. */
+			orgId: v.optional(v.string()),
+		}),
+	)
+	.handler(async ({ input, context }) => {
+		// panel_view → loader_slug (null when missing or the panel has no loader).
+		let loaderSlug: string | undefined;
+		try {
+			// THE SLUG IS RUNTIME-SUPPLIED, so it cannot be statically a
+			// PanelViewKey: it arrives from the browser as the opened panel's
+			// name. The lookup itself is the validation — loadRegistryConfig
+			// throws when no such row exists, and the catch below turns that into
+			// the documented null. Narrowing here states that contract rather
+			// than asserting the value is known good.
+			const pv = await loadRegistryConfig(
+				"panel_view",
+				input.panelSlug as PanelViewKey,
+				panelViewSchema,
+			);
+			loaderSlug = pv.content?.loader_slug;
+		} catch {
+			return null;
+		}
+		if (!loaderSlug) return null;
+		// resource_loader → its config (loose schema; resolveFromLoaderConfig owns
+		// the typed LoaderConfig contract).
+		let loader: unknown;
+		try {
+			loader = await loadRegistryConfig(
+				"resource_loader",
+				// Same contract: loader_slug is read from the panel row's loose
+				// content schema as a plain string, and a missing row throws into
+				// the catch below.
+				loaderSlug as ResourceLoaderKey,
+				v.unknown(),
+			);
+		} catch {
+			return null;
+		}
+		// Tenant orgId: prefer the caller-provided value (the route's tenant org,
+		// threaded from __PAGE_DATA__.orgId); fall back to the website's
+		// organisation_id (the platform org — wrong for multi-tenant portals, but
+		// the only derivable value when the caller omits it).
+		let orgId = input.orgId;
+		if (!orgId) {
+			const site = await context.prisma.builda_websites.findFirst({
+				where: { OR: [{ slug: input.websiteSlug }, { id: input.websiteSlug }] },
+				select: { organisation_id: true },
+			});
+			orgId = site?.organisation_id ?? undefined;
+		}
+		return await resolveFromLoaderConfig(
+			loader as Parameters<typeof resolveFromLoaderConfig>[0],
+			{ orgId },
+		);
+	});