@savvifi/meridian-aion-web 0.3.1 → 0.4.0

package/dist/adhoc-bridge.d.ts

@@ -0,0 +1,8 @@
+import type { ReactAdhocFactory } from "@savvifi/meridian-web-react";
+/**
+ * An adhoc registry that resolves EVERY handler_id to the neutral placeholder, so
+ * any bespoke (or newly-added) detail widget degrades gracefully rather than
+ * surfacing a warning. Pass as `adhoc={neutralAdhocRegistry}` to MeridianMuiProvider
+ * on both the server and client render paths.
+ */
+export declare const neutralAdhocRegistry: Record<string, ReactAdhocFactory>;

package/dist/adhoc-bridge.js

@@ -0,0 +1,42 @@
+// The graceful-degrade bridge for bespoke detail widgets (a document file viewer,
+// a task discussion thread, a team members panel, …) that don't yet have a
+// purpose-built meridian panel. The projection emits these as AdhocPanels; without
+// a host handler the kit would draw a "unsupported panel shape" WARNING — a visible
+// layout error. This registry resolves ANY handler_id to a neutral, low-emphasis
+// placeholder instead, so the detail page degrades cleanly until each widget gets a
+// real renderer. Kit-neutral (plain elements + --mer-* theme vars) so this package
+// takes no MUI dependency.
+import { createElement } from "react";
+/** "tasks-detail-discussion" → "Tasks Detail Discussion". */
+function humanize(id) {
+    return id
+        .replace(/[-_.]+/g, " ")
+        .replace(/\b\w/g, (c) => c.toUpperCase())
+        .trim();
+}
+/** A muted placeholder card for a not-yet-ported bespoke widget — never a warning. */
+function NeutralAdhoc({ descriptor }) {
+    const handlerId = descriptor.body.case === "adhoc" ? descriptor.body.value.handlerId : "";
+    const label = descriptor.title || humanize(handlerId) || "Section";
+    return createElement("section", {
+        className: "mer-adhoc-placeholder",
+        "data-handler": handlerId,
+        style: {
+            border: "1px solid var(--mer-border, #e0e0e0)",
+            borderRadius: 8,
+            padding: "16px 20px",
+            color: "var(--mer-fg, inherit)",
+            background: "var(--mer-surface, transparent)",
+        },
+    }, createElement("div", { style: { fontSize: 14, fontWeight: 600, marginBottom: 4 } }, label), createElement("div", { style: { fontSize: 13, opacity: 0.6 } }, "This section isn't available in this view yet."));
+}
+/**
+ * An adhoc registry that resolves EVERY handler_id to the neutral placeholder, so
+ * any bespoke (or newly-added) detail widget degrades gracefully rather than
+ * surfacing a warning. Pass as `adhoc={neutralAdhocRegistry}` to MeridianMuiProvider
+ * on both the server and client render paths.
+ */
+export const neutralAdhocRegistry = new Proxy({}, {
+    get: () => NeutralAdhoc,
+    has: () => true,
+});

package/dist/render-client.js

@@ -9,7 +9,8 @@ import { ViewDescriptorSchema } from "@savvifi/meridian-proto-ts/proto/view_pb.j
 import { ViewRenderer, } from "@savvifi/meridian-web-react";
 import { MeridianMuiProvider } from "@savvifi/meridian-mui-kit";
 import { savviSkin } from "./savvi-skin.js";
+import { neutralAdhocRegistry } from "./adhoc-bridge.js";
 export function MeridianEntityView({ viewJson, initialData, invoker, mode = "light", onAction, resolveHref, }) {
     const view = fromJson(ViewDescriptorSchema, viewJson);
-    return createElement(MeridianMuiProvider, { invoker, theme: savviSkin, mode, onAction, resolveHref }, createElement(ViewRenderer, { view, initialData }));
+    return createElement(MeridianMuiProvider, { invoker, theme: savviSkin, mode, onAction, resolveHref, adhoc: neutralAdhocRegistry }, createElement(ViewRenderer, { view, initialData }));
 }

package/dist/render-server.d.ts

@@ -32,6 +32,21 @@ export interface RenderMeridianEntityViewResult {
     node: ReactNode | null;
     dehydrated: MeridianDehydratedView | null;
 }
+/** The command-palette seed: list compositions (as an array) + dialog compositions
+ *  keyed by their id. Values are the aion @aion/ui-contracts composition shapes;
+ *  typed loosely here so this seam stays free of the studio-UI type surface —
+ *  the host casts at the RootContainer boundary. */
+export interface CommandPaletteData {
+    /** Installed list compositions (carry the create-form fields). */
+    compositions: unknown[];
+    /** Installed dialog compositions, keyed by composition id. */
+    dialogCompositions: Record<string, unknown>;
+}
+/** Load the command-palette seed from the request graph. Non-fatal callers should
+ *  catch and fall back to an empty seed (the palette then renders nothing). */
+export declare function loadCommandPaletteData(input: {
+    graph: CompositionGraphClient;
+}): Promise<CommandPaletteData>;
 export declare function renderMeridianEntityView(input: RenderMeridianEntityViewInput): Promise<RenderMeridianEntityViewResult>;
 /** The host-supplied transport that fetches a Layout's ViewDescriptor as proto-JSON.
  *  Abstracted so the gRPC client (Connect / grpc-js) is a host adapter, not a dep of

package/dist/render-server.js

@@ -12,9 +12,10 @@ import { createEntityOpsInvoker, projectEntityView, } from "@savvifi/meridian-ai
 import { buildPageRequest, readPage, ViewRenderer, } from "@savvifi/meridian-web-react";
 import { MeridianMuiProvider } from "@savvifi/meridian-mui-kit";
 import { parseAndValidateEntityRoute } from "@aion/entity-route-runtime/entity-route/index.js";
-import { loadInstalledEntityDetailCompositions, loadInstalledEntityListCompositions, } from "@aion/entity-route-runtime/composition/loader.js";
+import { loadInstalledDialogCompositions, loadInstalledEntityDetailCompositions, loadInstalledEntityListCompositions, } from "@aion/entity-route-runtime/composition/loader.js";
 import { savviSkin } from "./savvi-skin.js";
 import { NotFoundSignal } from "./not-found.js";
+import { neutralAdhocRegistry } from "./adhoc-bridge.js";
 /** `/entities/products/id/123` → `["products","id","123"]` (strip the prefix). */
 function routeSegments(pathname) {
     const parts = pathname.replace(/^\/+|\/+$/g, "").split("/");
@@ -30,6 +31,30 @@ function firstTablePanel(view) {
     }
     return undefined;
 }
+/** The first detail panel's record fetch (header / record-card share the read op),
+ *  so the SSR seed carries the record — the client hydrates without a refetch. */
+function firstDetailPopulate(view) {
+    for (const slot of view.slots) {
+        const body = slot.panel?.body;
+        if ((body?.case === "detailHeader" || body?.case === "recordCard") && body.value.populate) {
+            return { populate: body.value.populate, idField: body.value.idField || "id" };
+        }
+    }
+    return undefined;
+}
+/** Load the command-palette seed from the request graph. Non-fatal callers should
+ *  catch and fall back to an empty seed (the palette then renders nothing). */
+export async function loadCommandPaletteData(input) {
+    const systemGraphFactory = async () => input.graph;
+    const [listCompositions, dialogCompositions] = await Promise.all([
+        loadInstalledEntityListCompositions({ systemGraphFactory }),
+        loadInstalledDialogCompositions({ systemGraphFactory }),
+    ]);
+    return {
+        compositions: Object.values(listCompositions),
+        dialogCompositions,
+    };
+}
 export async function renderMeridianEntityView(input) {
     const { caller, graph, mode = "light", notFound = "throw" } = input;
     const parsed = parseAndValidateEntityRoute(routeSegments(input.pathname));
@@ -49,12 +74,19 @@ export async function renderMeridianEntityView(input) {
     const composition = compositions[entityType];
     if (!composition)
         return miss();
-    // CLIENT pagination: the aion entity list ops return a bounded set and don't
-    // honor a client-supplied page size (the composition fixes it), so paginate the
-    // fetched rows in the renderer — the page-size selector then slices locally and
-    // the count is real. This matches the old studio DataTableView (fetch + local
-    // paginate); server-cursor paging would need the ops to accept a runtime size.
-    const view = projectEntityView(composition, { kind, pagination: "client", pageSize: 20 });
+    // CURSOR pagination: the aion entity list ops now honor a runtime page size +
+    // pageToken and return a real `{ items, nextToken, hasMore, totalCount }` page
+    // (DEV-18242), so page true server-side — the renderer sends `pageToken`/`pageSize`
+    // and reads `nextToken`/`totalCount` back. Scales past one page, unlike the prior
+    // CLIENT workaround that fetched a bounded set and sliced it locally.
+    const view = projectEntityView(composition, {
+        kind,
+        pagination: "cursor",
+        pageSize: 20,
+        // DETAIL: the record id from the route → ViewDescriptor.subject_id, which the
+        // detail panels bind into their populate request.
+        entityId: entityId ?? undefined,
+    });
     const invoker = createEntityOpsInvoker(caller.entities?.ops);
     // Pre-fetch page-0 for the table so the SSR HTML carries real rows (and the
     // client hydrates without an immediate refetch). Non-fatal: on failure we
@@ -71,7 +103,23 @@ export async function renderMeridianEntityView(input) {
             // leave unseeded
         }
     }
-    const node = createElement(MeridianMuiProvider, { invoker, theme: savviSkin, mode }, createElement(ViewRenderer, { view, initialData }));
+    // DETAIL: pre-fetch the record so the header / record-card panels paint real
+    // values server-side. Stored as a one-row page — useRecord reads `seed.rows[0]`.
+    // Non-fatal, same as the table seed.
+    const detailFetch = firstDetailPopulate(view);
+    if (detailFetch && entityId) {
+        try {
+            const request = { [detailFetch.idField]: entityId };
+            const response = await invoker.invoke(detailFetch.populate.service, detailFetch.populate.method, request);
+            initialData[`${detailFetch.populate.service}.${detailFetch.populate.method}`] = {
+                rows: [response],
+            };
+        }
+        catch {
+            // leave unseeded
+        }
+    }
+    const node = createElement(MeridianMuiProvider, { invoker, theme: savviSkin, mode, adhoc: neutralAdhocRegistry }, createElement(ViewRenderer, { view, initialData }));
     return {
         node,
         dehydrated: { viewJson: toJson(ViewDescriptorSchema, view), initialData },
@@ -98,7 +146,7 @@ export async function renderCrdLayout(input) {
             // leave unseeded
         }
     }
-    const node = createElement(MeridianMuiProvider, { invoker, theme: savviSkin, mode }, createElement(ViewRenderer, { view: descriptor, initialData }));
+    const node = createElement(MeridianMuiProvider, { invoker, theme: savviSkin, mode, adhoc: neutralAdhocRegistry }, createElement(ViewRenderer, { view: descriptor, initialData }));
     return {
         node,
         dehydrated: { viewJson: toJson(ViewDescriptorSchema, descriptor), initialData },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@savvifi/meridian-aion-web",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "type": "module",
   "description": "The aion/web <-> meridian-ux render seam: renderMeridianEntityView (server — parse route, load composition, project to a ViewDescriptor, pre-fetch page-0, render + dehydrate) + MeridianEntityView (client hydration) + savviSkin. Lets an SSR host (e.g. aion/web on Hono+Vite) render entity routes through meridian instead of the legacy React path.",
   "publishConfig": {
@@ -36,11 +36,11 @@
     "typecheck": "tsc -p tsconfig.json"
   },
   "dependencies": {
-    "@savvifi/meridian-aion-projection": "^0.2.2",
-    "@savvifi/meridian-mui-kit": "^0.3.0",
-    "@savvifi/meridian-proto-ts": "^0.7.0",
+    "@savvifi/meridian-aion-projection": "^0.3.0",
+    "@savvifi/meridian-mui-kit": "^0.4.0",
+    "@savvifi/meridian-proto-ts": "^0.8.0",
     "@savvifi/meridian-schemas": "^0.7.0",
-    "@savvifi/meridian-web-react": "^0.5.0",
+    "@savvifi/meridian-web-react": "^0.6.0",
     "@bufbuild/protobuf": "2.12.1"
   },
   "peerDependencies": {