fix(examples): load jsonRenderUiRenderer via bundler-ignored import in hub-next

Turbopack bundled the static `@devframes/json-render-ui/hub` import into the
Next server chunk, so the helper's `import.meta.url`-based bundle-path
resolution pointed inside `.next/…/assets/dist/` and tripped DF8109. Load it
through the same bundler-ignored dynamic `import()` as the plugins, so Node
resolves the published `dist` at request time and the renderer module resolves
correctly.

Also type the React example's dock renderer against the moved
`JsonRenderDockRenderer` contract, and widen the client renderer registry's
`register`/`renderers` inputs to `DockRenderer<any>` so a renderer narrowed to
a specific entry variant plugs in.

Author: antfubot

examples/hub-next/src/client/devframe/next-devframe-hub.ts

@@ -1,12 +1,12 @@
-import type { HubDevframeEntry, HubInstance } from '@devframes/hub/initiate'
+import type { DockRendererRegistration, HubDevframeEntry, HubInstance } from '@devframes/hub/initiate'
 import type { DevframeHubContext } from '@devframes/hub/node'
+import type { jsonRenderUiRenderer as JsonRenderUiRenderer } from '@devframes/json-render-ui/hub'
 import type { DevframeDefinition } from 'devframe'
 import { homedir } from 'node:os'
 import process from 'node:process'
 import { fileURLToPath } from 'node:url'
 import { defineHubRpcFunction } from '@devframes/hub'
 import { DEVFRAMES_HUB_BASE, initHub } from '@devframes/hub/initiate'
-import { jsonRenderUiRenderer } from '@devframes/json-render-ui/hub'
 import { toJsonRenderDockEntry } from '@devframes/json-render/hub'
 import { createDashboardView } from 'json-render/dashboard'
 import { dirname, join } from 'pathe'
@@ -62,6 +62,19 @@ async function loadAssetsDevframe(): Promise<DevframeDefinition> {
   return (mod.createAssetsDevframe as (options: { dir: string, watch: boolean }) => DevframeDefinition)({ dir, watch: false })
 }
 
+/**
+ * The reference json-render renderer registration for `initHub({ renderers })`.
+ * Loaded through the same bundler-ignored dynamic `import()` as the plugins:
+ * `jsonRenderUiRenderer()` resolves its prebuilt module via `import.meta.url`,
+ * which only points at the published `dist` when Node loads the package at
+ * request time — a static import would be rewritten into a Next server chunk,
+ * making the path resolve inside `.next/` (see `DF8109`).
+ */
+async function loadJsonRenderUiRenderer(): Promise<DockRendererRegistration> {
+  const mod = await import(/* webpackIgnore: true */ /* turbopackIgnore: true */ '@devframes/json-render-ui/hub')
+  return (mod.jsonRenderUiRenderer as typeof JsonRenderUiRenderer)()
+}
+
 /**
  * URL base the a11y agent module is served under — inside the hub namespace,
  * so the one catch-all route reaches it.
@@ -158,6 +171,10 @@ export async function nextDevframeHub(
   // the origin, so their BroadcastChannel connects.
   const a11yAgent = await loadA11yAgentMount()
 
+  // The reference json-render renderer module, loaded the same bundler-ignored
+  // way so its `import.meta.url` bundle path resolves to the published `dist`.
+  const jsonRenderRenderer = await loadJsonRenderUiRenderer()
+
   // Demo devframes alongside the dogfooded built-in plugin packages. The
   // shared-iframe soft-navigation demo mounts as a `subTabs` anchor (a shared
   // `frameId` + the postmessage protocol) so the client host attaches the
@@ -215,7 +232,7 @@ export async function nextDevframeHub(
     // local React renderer for the same type (app/page.tsx), which takes
     // precedence — witnessing both sides of the swap seam: the manifest
     // composition AND a local frontend replacing it.
-    renderers: [jsonRenderUiRenderer()],
+    renderers: [jsonRenderRenderer],
     // Record this hub in the global registry so `devframe connect` discovers
     // it — running inside the Next dev server — like any standalone devframe.
     // The instance owns the record (written once its pinned origin resolves,

examples/hub-next/src/client/json-render/dock-renderer.tsx

@@ -96,14 +96,18 @@ function JsonRenderView({ spec, rpc, registry, viewId }: JsonRenderViewProps): R
 export function createReactJsonRenderDockRenderer(): JsonRenderDockRenderer {
   return async ({ entry, container, context }) => {
     const view: JsonRenderViewRef = entry.view
-    const rpc = context.rpc
+    const { rpc } = context
+    // The action bridge only needs a loose `call(method, …)` — the client's
+    // typed `DevframeRpcClient` narrows `method` to known keys, so widen it at
+    // the prop boundary for the dynamic spec-action names.
+    const bridgeRpc = rpc as unknown as JsonRenderViewProps['rpc']
     const viewId = 'stateKey' in view ? view.stateKey : entry.id
     const root = createRoot(container)
 
     // Inline view: render the embedded spec once, no shared state involved.
     if ('spec' in view) {
       root.render(
-        <JsonRenderView spec={view.spec} rpc={rpc} registry={baseReactRegistry} viewId={viewId} />,
+        <JsonRenderView spec={view.spec} rpc={bridgeRpc} registry={baseReactRegistry} viewId={viewId} />,
       )
       return {
         dispose() {
@@ -112,12 +116,12 @@ export function createReactJsonRenderDockRenderer(): JsonRenderDockRenderer {
       }
     }
 
-    const state = await rpc.sharedState.get(view.stateKey, { initialValue: null })
+    const state = await rpc.sharedState.get<Spec>(view.stateKey, { initialValue: null as unknown as Spec })
     const render = (): void => {
       root.render(
         <JsonRenderView
           spec={state.value() as Spec | null}
-          rpc={rpc}
+          rpc={bridgeRpc}
           registry={baseReactRegistry}
           viewId={viewId}
         />,

packages/hub/src/client/host.ts

@@ -66,7 +66,7 @@ export interface DevframeClientHostOptions {
    * Local registrations take precedence over the hub's renderer manifest
    * (`initHub({ renderers })`) — explicit local code beats wire config.
    */
-  renderers?: Record<string, DockRenderer>
+  renderers?: Record<string, DockRenderer<any>>
   /**
    * Hub-wide override of the top-level dock-bar category ordering — a map of
    * category id → ordering weight (lower sorts earlier), mirroring the shape

packages/hub/src/client/renderers.ts

@@ -61,8 +61,13 @@ export type DockRendererMountResult
  * instance and disposes it when the entry deactivates.
  */
 export interface DockRenderersContext {
-  /** Register a renderer for a dock `type`. Returns an unregister function. */
-  register: (type: string, renderer: DockRenderer) => () => void
+  /**
+   * Register a renderer for a dock `type`. Returns an unregister function.
+   * Accepts a renderer narrowed to any specific entry variant (e.g. a
+   * {@link DockRenderer}<DevframeJsonRenderDockEntry> from an integration
+   * package) — the type routes only its own entries to it.
+   */
+  register: (type: string, renderer: DockRenderer<any>) => () => void
   /** Look up the locally-registered renderer for a dock `type`, if any. */
   get: (type: string) => DockRenderer | undefined
   /**
@@ -99,7 +104,7 @@ export interface CreateDockRenderersContextOptions {
   /** The assembled client context handed to renderers at mount. */
   context: () => DevframeClientContext
   /** Renderers registered locally at boot — these win over manifest modules. */
-  local?: Record<string, DockRenderer>
+  local?: Record<string, DockRenderer<any>>
   /** The current {@link DockRendererManifest} (live getter). */
   manifest?: () => DockRendererManifest
   /**