@freighttech/ui 0.13.18

package/dist/backend/dynamic-table/registry/ContentRegistryContext.js

@@ -0,0 +1,126 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { useAccessibleTables, useTableById } from "./TableRegistryContext.js";
+import {
+  EMPTY_WIDGET_CATALOG,
+  useWidgetCatalog,
+  widgetLoaderKeyExists
+} from "./widgetCatalog.js";
+const DEFAULT_VALUE = {
+  ...EMPTY_WIDGET_CATALOG,
+  mounted: false,
+  // Default-deny, exactly as `TableRegistryContext` defaults `hasFeature` to
+  // false: a host that forgot the provider offers nothing rather than
+  // everything.
+  loaderKeyExists: () => false
+};
+const ContentRegistryContext = React.createContext(DEFAULT_VALUE);
+function ContentRegistryProvider({
+  value,
+  children
+}) {
+  const resolved = React.useMemo(
+    () => ({
+      widgets: value.widgets,
+      context: value.context,
+      ready: value.ready,
+      mounted: true,
+      loaderKeyExists: value.loaderKeyExists ?? widgetLoaderKeyExists
+    }),
+    [value]
+  );
+  return /* @__PURE__ */ jsx(ContentRegistryContext.Provider, { value: resolved, children });
+}
+function ContentRegistryBootstrap({ children }) {
+  const catalog = useWidgetCatalog();
+  return /* @__PURE__ */ jsx(ContentRegistryProvider, { value: catalog, children });
+}
+function useContentRegistry() {
+  return React.useContext(ContentRegistryContext);
+}
+function useWidgetRenderContext() {
+  return useContentRegistry().context;
+}
+function widgetItem(entry) {
+  return {
+    kind: "widget",
+    id: entry.id,
+    title: entry.title,
+    icon: entry.icon ?? void 0,
+    group: entry.moduleId,
+    loaderKey: entry.loaderKey,
+    description: entry.description,
+    defaultSettings: entry.defaultSettings,
+    supportsRefresh: entry.supportsRefresh
+  };
+}
+function tableItem(definition) {
+  return {
+    kind: "table",
+    id: definition.metadata.id,
+    title: definition.metadata.title,
+    icon: definition.metadata.icon,
+    group: definition.metadata.group,
+    definition
+  };
+}
+function useAccessibleContent() {
+  const tables = useAccessibleTables();
+  const { widgets } = useContentRegistry();
+  return React.useMemo(
+    () => [...tables.map(tableItem), ...widgets.map(widgetItem)],
+    [tables, widgets]
+  );
+}
+function useWidgetById(ref) {
+  const { widgets, ready, mounted, loaderKeyExists } = useContentRegistry();
+  return React.useMemo(() => {
+    if (!mounted) {
+      if (ref.widgetId && process.env.NODE_ENV !== "production") {
+        try {
+          console.warn(
+            "[ContentRegistry] A widget slot was resolved with no ContentRegistryProvider mounted. Wrap the host in <ContentRegistryBootstrap> \u2014 otherwise every widget pane reads as removed."
+          );
+        } catch {
+        }
+      }
+      return { item: null, status: "unknown" };
+    }
+    const entry = widgets.find((w) => w.id === ref.widgetId);
+    if (entry) return { item: widgetItem(entry), status: "ok" };
+    if (!ready) return { item: null, status: "loading" };
+    if (loaderKeyExists(ref.loaderKey)) return { item: null, status: "denied" };
+    return { item: null, status: "unknown" };
+  }, [widgets, ready, mounted, loaderKeyExists, ref, ref.widgetId, ref.loaderKey]);
+}
+function useTableContentById(ref) {
+  const { definition, status } = useTableById(ref.tableId);
+  return React.useMemo(
+    () => ({ item: definition ? tableItem(definition) : null, status }),
+    [definition, status]
+  );
+}
+function useContentById(ref) {
+  const tableRef = React.useMemo(
+    () => ref?.kind === "table" ? ref : { kind: "table", tableId: "" },
+    [ref]
+  );
+  const widgetRef = React.useMemo(
+    () => ref?.kind === "widget" ? ref : { kind: "widget", widgetId: "", loaderKey: "" },
+    [ref]
+  );
+  const table = useTableContentById(tableRef);
+  const widget = useWidgetById(widgetRef);
+  if (!ref) return { item: null, status: "unknown" };
+  return ref.kind === "table" ? table : widget;
+}
+export {
+  ContentRegistryBootstrap,
+  ContentRegistryProvider,
+  useAccessibleContent,
+  useContentById,
+  useContentRegistry,
+  useWidgetRenderContext
+};
+//# sourceMappingURL=ContentRegistryContext.js.map

package/dist/backend/dynamic-table/registry/ContentRegistryContext.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/backend/dynamic-table/registry/ContentRegistryContext.tsx"],
+  "sourcesContent": ["'use client'\n\n// One registry over the two things a pane can hold.\n//\n// It WRAPS `TableRegistryContext` rather than replacing it: tables keep their\n// existing provider, their existing `hasFeature` injection and\n// `filterAccessibleTables`, and every page that renders a table by id is\n// untouched. This layer adds widgets beside them and resolves both through ONE\n// lookup with ONE set of degradation states, so a host renders a slot without\n// caring which kind it holds.\n//\n// \u2500\u2500 The four states, and why widgets can reach all four \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Tables get `denied` from the host's grant check. Widgets cannot: the server\n// catalogue (`/api/dashboards/layout`) returns only the ALLOWED set, so a widget\n// the user may not have is simply absent \u2014 indistinguishable from one deleted in\n// a release. The client-side widget entry registry closes that gap: it is\n// unfiltered and lists every widget compiled into the build, so\n//\n//     in catalogue                        -> ok\n//     not in catalogue, code exists       -> denied\n//     not in catalogue, no code           -> unknown\n//     catalogue still in flight           -> loading\n//\n// which is the same vocabulary tables already use, arrived at honestly rather\n// than by collapsing two different failures into one message.\n//\n// Spec: .ai/specs/2026-08-17-split-view-workspace-composition.md (Phase 2)\n\nimport * as React from 'react'\nimport type { PaneContentRef } from '../split-view/types'\nimport type { TableDefinition } from './types'\nimport { useAccessibleTables, useTableById } from './TableRegistryContext'\nimport {\n  EMPTY_WIDGET_CATALOG,\n  useWidgetCatalog,\n  widgetLoaderKeyExists,\n  type WidgetCatalog,\n  type WidgetCatalogEntry,\n} from './widgetCatalog'\n\n/** Same four states the table registry already uses. Do not add a fifth. */\nexport type ContentStatus = 'ok' | 'unknown' | 'denied' | 'loading'\n\nexport type TableContentItem = {\n  kind: 'table'\n  id: string\n  title: string\n  icon?: string\n  group?: string\n  definition: TableDefinition\n}\n\nexport type WidgetContentItem = {\n  kind: 'widget'\n  id: string\n  title: string\n  icon?: string\n  group?: string\n  /** What `loadDashboardWidgetModule` takes. Present on widgets only. */\n  loaderKey: string\n  description?: string | null\n  defaultSettings?: unknown\n  supportsRefresh?: boolean\n}\n\n/** One entry a picker can list and a pane can mount, of either kind. */\nexport type PaneContentItem = TableContentItem | WidgetContentItem\n\nexport type ContentRegistryValue = WidgetCatalog & {\n  /**\n   * True only when a provider is actually mounted.\n   *\n   * Distinct from `ready`, which means \"the catalogue answered\". Without this a\n   * host that forgot the provider would sit at `loading` forever, which reads as\n   * \"still working\" \u2014 the one failure mode worse than an error.\n   */\n  mounted: boolean\n  /** Injected so tests need no widget bootstrap. Defaults to the real registry. */\n  loaderKeyExists: (loaderKey: string) => boolean\n}\n\nconst DEFAULT_VALUE: ContentRegistryValue = {\n  ...EMPTY_WIDGET_CATALOG,\n  mounted: false,\n  // Default-deny, exactly as `TableRegistryContext` defaults `hasFeature` to\n  // false: a host that forgot the provider offers nothing rather than\n  // everything.\n  loaderKeyExists: () => false,\n}\n\nconst ContentRegistryContext = React.createContext<ContentRegistryValue>(DEFAULT_VALUE)\n\n/**\n * Supplies an already-resolved catalogue. Use this when a host owns the fetch\n * (or a test owns the fixtures); use `ContentRegistryBootstrap` otherwise.\n */\nexport function ContentRegistryProvider({\n  value,\n  children,\n}: {\n  value: Omit<ContentRegistryValue, 'mounted' | 'loaderKeyExists'> &\n    Partial<Pick<ContentRegistryValue, 'loaderKeyExists'>>\n  children: React.ReactNode\n}) {\n  const resolved = React.useMemo<ContentRegistryValue>(\n    () => ({\n      widgets: value.widgets,\n      context: value.context,\n      ready: value.ready,\n      mounted: true,\n      loaderKeyExists: value.loaderKeyExists ?? widgetLoaderKeyExists,\n    }),\n    [value],\n  )\n  return <ContentRegistryContext.Provider value={resolved}>{children}</ContentRegistryContext.Provider>\n}\n\n/**\n * Fetches the widget catalogue and provides it. Mount once, inside whatever\n * already provides the table registry and a react-query client.\n */\nexport function ContentRegistryBootstrap({ children }: { children: React.ReactNode }) {\n  const catalog = useWidgetCatalog()\n  return <ContentRegistryProvider value={catalog}>{children}</ContentRegistryProvider>\n}\n\nexport function useContentRegistry(): ContentRegistryValue {\n  return React.useContext(ContentRegistryContext)\n}\n\n/** The widget render context (`userId` / `tenantId` / `organizationId`), or null. */\nexport function useWidgetRenderContext() {\n  return useContentRegistry().context\n}\n\nfunction widgetItem(entry: WidgetCatalogEntry): WidgetContentItem {\n  return {\n    kind: 'widget',\n    id: entry.id,\n    title: entry.title,\n    icon: entry.icon ?? undefined,\n    group: entry.moduleId,\n    loaderKey: entry.loaderKey,\n    description: entry.description,\n    defaultSettings: entry.defaultSettings,\n    supportsRefresh: entry.supportsRefresh,\n  }\n}\n\nfunction tableItem(definition: TableDefinition): TableContentItem {\n  return {\n    kind: 'table',\n    id: definition.metadata.id,\n    title: definition.metadata.title,\n    icon: definition.metadata.icon,\n    group: definition.metadata.group,\n    definition,\n  }\n}\n\n/**\n * Everything the current user may put in a slot \u2014 tables AND widgets.\n *\n * Tables come through `filterAccessibleTables` (the host's grant check, applied\n * client-side, UX not security); widgets arrive pre-filtered by the server. Two\n * ACL paths, because the two halves genuinely have two authorities \u2014 but one\n * result shape, so a picker never branches.\n */\nexport function useAccessibleContent(): PaneContentItem[] {\n  const tables = useAccessibleTables()\n  const { widgets } = useContentRegistry()\n  return React.useMemo(\n    () => [...tables.map(tableItem), ...widgets.map(widgetItem)],\n    [tables, widgets],\n  )\n}\n\nfunction useWidgetById(ref: Extract<PaneContentRef, { kind: 'widget' }>): {\n  item: PaneContentItem | null\n  status: ContentStatus\n} {\n  const { widgets, ready, mounted, loaderKeyExists } = useContentRegistry()\n  return React.useMemo(() => {\n    if (!mounted) {\n      // Only complain about a slot that actually names a widget \u2014 the sentinel\n      // ref below keeps hook order stable on table-only pages, and those hosts\n      // are under no obligation to mount this provider.\n      if (ref.widgetId && process.env.NODE_ENV !== 'production') {\n        try {\n          console.warn(\n            '[ContentRegistry] A widget slot was resolved with no ContentRegistryProvider mounted. ' +\n              'Wrap the host in <ContentRegistryBootstrap> \u2014 otherwise every widget pane reads as removed.',\n          )\n        } catch {}\n      }\n      return { item: null, status: 'unknown' as const }\n    }\n    const entry = widgets.find((w) => w.id === ref.widgetId)\n    if (entry) return { item: widgetItem(entry), status: 'ok' as const }\n    if (!ready) return { item: null, status: 'loading' as const }\n    // Absent from the allowed set. Its code still being in the build is what\n    // makes this a permission verdict rather than a missing feature.\n    if (loaderKeyExists(ref.loaderKey)) return { item: null, status: 'denied' as const }\n    return { item: null, status: 'unknown' as const }\n  }, [widgets, ready, mounted, loaderKeyExists, ref, ref.widgetId, ref.loaderKey])\n}\n\nfunction useTableContentById(ref: Extract<PaneContentRef, { kind: 'table' }>): {\n  item: PaneContentItem | null\n  status: ContentStatus\n} {\n  const { definition, status } = useTableById(ref.tableId)\n  return React.useMemo(\n    () => ({ item: definition ? tableItem(definition) : null, status }),\n    [definition, status],\n  )\n}\n\n/**\n * Resolve one slot's content, of either kind.\n *\n * Both branches run their hooks unconditionally \u2014 `PaneContentRef.kind` is\n * stable for the life of a slot (changing content replaces the node, minting a\n * new pane id), so this cannot reorder hooks between renders, and keeping both\n * live avoids forcing every caller to branch before it knows what it has.\n */\nexport function useContentById(ref: PaneContentRef | null | undefined): {\n  item: PaneContentItem | null\n  status: ContentStatus\n} {\n  const tableRef = React.useMemo<Extract<PaneContentRef, { kind: 'table' }>>(\n    () => (ref?.kind === 'table' ? ref : { kind: 'table', tableId: '' }),\n    [ref],\n  )\n  const widgetRef = React.useMemo<Extract<PaneContentRef, { kind: 'widget' }>>(\n    () => (ref?.kind === 'widget' ? ref : { kind: 'widget', widgetId: '', loaderKey: '' }),\n    [ref],\n  )\n  const table = useTableContentById(tableRef)\n  const widget = useWidgetById(widgetRef)\n\n  if (!ref) return { item: null, status: 'unknown' }\n  return ref.kind === 'table' ? table : widget\n}\n"],
+  "mappings": ";AAkHS;AAtFT,YAAY,WAAW;AAGvB,SAAS,qBAAqB,oBAAoB;AAClD;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAGK;AA2CP,MAAM,gBAAsC;AAAA,EAC1C,GAAG;AAAA,EACH,SAAS;AAAA;AAAA;AAAA;AAAA,EAIT,iBAAiB,MAAM;AACzB;AAEA,MAAM,yBAAyB,MAAM,cAAoC,aAAa;AAM/E,SAAS,wBAAwB;AAAA,EACtC;AAAA,EACA;AACF,GAIG;AACD,QAAM,WAAW,MAAM;AAAA,IACrB,OAAO;AAAA,MACL,SAAS,MAAM;AAAA,MACf,SAAS,MAAM;AAAA,MACf,OAAO,MAAM;AAAA,MACb,SAAS;AAAA,MACT,iBAAiB,MAAM,mBAAmB;AAAA,IAC5C;AAAA,IACA,CAAC,KAAK;AAAA,EACR;AACA,SAAO,oBAAC,uBAAuB,UAAvB,EAAgC,OAAO,UAAW,UAAS;AACrE;AAMO,SAAS,yBAAyB,EAAE,SAAS,GAAkC;AACpF,QAAM,UAAU,iBAAiB;AACjC,SAAO,oBAAC,2BAAwB,OAAO,SAAU,UAAS;AAC5D;AAEO,SAAS,qBAA2C;AACzD,SAAO,MAAM,WAAW,sBAAsB;AAChD;AAGO,SAAS,yBAAyB;AACvC,SAAO,mBAAmB,EAAE;AAC9B;AAEA,SAAS,WAAW,OAA8C;AAChE,SAAO;AAAA,IACL,MAAM;AAAA,IACN,IAAI,MAAM;AAAA,IACV,OAAO,MAAM;AAAA,IACb,MAAM,MAAM,QAAQ;AAAA,IACpB,OAAO,MAAM;AAAA,IACb,WAAW,MAAM;AAAA,IACjB,aAAa,MAAM;AAAA,IACnB,iBAAiB,MAAM;AAAA,IACvB,iBAAiB,MAAM;AAAA,EACzB;AACF;AAEA,SAAS,UAAU,YAA+C;AAChE,SAAO;AAAA,IACL,MAAM;AAAA,IACN,IAAI,WAAW,SAAS;AAAA,IACxB,OAAO,WAAW,SAAS;AAAA,IAC3B,MAAM,WAAW,SAAS;AAAA,IAC1B,OAAO,WAAW,SAAS;AAAA,IAC3B;AAAA,EACF;AACF;AAUO,SAAS,uBAA0C;AACxD,QAAM,SAAS,oBAAoB;AACnC,QAAM,EAAE,QAAQ,IAAI,mBAAmB;AACvC,SAAO,MAAM;AAAA,IACX,MAAM,CAAC,GAAG,OAAO,IAAI,SAAS,GAAG,GAAG,QAAQ,IAAI,UAAU,CAAC;AAAA,IAC3D,CAAC,QAAQ,OAAO;AAAA,EAClB;AACF;AAEA,SAAS,cAAc,KAGrB;AACA,QAAM,EAAE,SAAS,OAAO,SAAS,gBAAgB,IAAI,mBAAmB;AACxE,SAAO,MAAM,QAAQ,MAAM;AACzB,QAAI,CAAC,SAAS;AAIZ,UAAI,IAAI,YAAY,QAAQ,IAAI,aAAa,cAAc;AACzD,YAAI;AACF,kBAAQ;AAAA,YACN;AAAA,UAEF;AAAA,QACF,QAAQ;AAAA,QAAC;AAAA,MACX;AACA,aAAO,EAAE,MAAM,MAAM,QAAQ,UAAmB;AAAA,IAClD;AACA,UAAM,QAAQ,QAAQ,KAAK,CAAC,MAAM,EAAE,OAAO,IAAI,QAAQ;AACvD,QAAI,MAAO,QAAO,EAAE,MAAM,WAAW,KAAK,GAAG,QAAQ,KAAc;AACnE,QAAI,CAAC,MAAO,QAAO,EAAE,MAAM,MAAM,QAAQ,UAAmB;AAG5D,QAAI,gBAAgB,IAAI,SAAS,EAAG,QAAO,EAAE,MAAM,MAAM,QAAQ,SAAkB;AACnF,WAAO,EAAE,MAAM,MAAM,QAAQ,UAAmB;AAAA,EAClD,GAAG,CAAC,SAAS,OAAO,SAAS,iBAAiB,KAAK,IAAI,UAAU,IAAI,SAAS,CAAC;AACjF;AAEA,SAAS,oBAAoB,KAG3B;AACA,QAAM,EAAE,YAAY,OAAO,IAAI,aAAa,IAAI,OAAO;AACvD,SAAO,MAAM;AAAA,IACX,OAAO,EAAE,MAAM,aAAa,UAAU,UAAU,IAAI,MAAM,OAAO;AAAA,IACjE,CAAC,YAAY,MAAM;AAAA,EACrB;AACF;AAUO,SAAS,eAAe,KAG7B;AACA,QAAM,WAAW,MAAM;AAAA,IACrB,MAAO,KAAK,SAAS,UAAU,MAAM,EAAE,MAAM,SAAS,SAAS,GAAG;AAAA,IAClE,CAAC,GAAG;AAAA,EACN;AACA,QAAM,YAAY,MAAM;AAAA,IACtB,MAAO,KAAK,SAAS,WAAW,MAAM,EAAE,MAAM,UAAU,UAAU,IAAI,WAAW,GAAG;AAAA,IACpF,CAAC,GAAG;AAAA,EACN;AACA,QAAM,QAAQ,oBAAoB,QAAQ;AAC1C,QAAM,SAAS,cAAc,SAAS;AAEtC,MAAI,CAAC,IAAK,QAAO,EAAE,MAAM,MAAM,QAAQ,UAAU;AACjD,SAAO,IAAI,SAAS,UAAU,QAAQ;AACxC;",
+  "names": []
+}

package/dist/backend/dynamic-table/registry/TableRegistryContext.js

@@ -0,0 +1,43 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { filterAccessibleTables, findTableDefinition } from "./filterAccessibleTables.js";
+const EMPTY = [];
+const TableRegistryContext = React.createContext({
+  tables: EMPTY,
+  // Default-deny. A host that forgot to mount the provider shows nothing rather
+  // than everything — the failure is visible, not permissive.
+  hasFeature: () => false,
+  ready: false
+});
+function TableRegistryProvider({
+  value,
+  children
+}) {
+  return /* @__PURE__ */ jsx(TableRegistryContext.Provider, { value, children });
+}
+function useTableRegistry() {
+  return React.useContext(TableRegistryContext);
+}
+function useAccessibleTables() {
+  const { tables, hasFeature } = useTableRegistry();
+  return React.useMemo(() => filterAccessibleTables(tables, hasFeature), [tables, hasFeature]);
+}
+function useTableById(id) {
+  const { tables, hasFeature, ready } = useTableRegistry();
+  return React.useMemo(() => {
+    if (!id) return { definition: null, status: "unknown" };
+    const definition = findTableDefinition(tables, id);
+    if (!definition) return { definition: null, status: "unknown" };
+    if (!ready) return { definition, status: "loading" };
+    const allowed = definition.metadata.features.every((f) => hasFeature(f));
+    return allowed ? { definition, status: "ok" } : { definition, status: "denied" };
+  }, [id, tables, hasFeature, ready]);
+}
+export {
+  TableRegistryProvider,
+  useAccessibleTables,
+  useTableById,
+  useTableRegistry
+};
+//# sourceMappingURL=TableRegistryContext.js.map

package/dist/backend/dynamic-table/registry/TableRegistryContext.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/backend/dynamic-table/registry/TableRegistryContext.tsx"],
+  "sourcesContent": ["'use client'\n\n// The seam between the registry (which knows nothing about auth) and a host\n// (which does).\n//\n// Pages live in `packages/*` and the collected registry lives in `apps/web`, so\n// a page cannot import it directly without inverting the dependency. A context\n// mounted once in the backend layout carries both halves \u2014 the tables the host\n// collected, and the host's own feature check \u2014 to any page that wants to\n// render a table by id.\n//\n// Spec: .ai/specs/2026-08-04-module-table-registry.md\n\nimport * as React from 'react'\nimport type { TableDefinition } from './types'\nimport { filterAccessibleTables, findTableDefinition } from './filterAccessibleTables'\n\nexport type TableRegistryValue = {\n  /** Every table this host collected, before ACL. */\n  tables: TableDefinition[]\n  /**\n   * Host-supplied grant check. Opaque to the registry \u2014 the backend resolves it\n   * through `POST /api/auth/feature-check` (organization-scoped, server-side);\n   * another surface would resolve it against its own authority.\n   */\n  hasFeature: (feature: string) => boolean\n  /** False while grants are still loading, so a picker can avoid flashing an\n   *  empty list and then filling it. */\n  ready: boolean\n}\n\nconst EMPTY: TableDefinition[] = []\n\nconst TableRegistryContext = React.createContext<TableRegistryValue>({\n  tables: EMPTY,\n  // Default-deny. A host that forgot to mount the provider shows nothing rather\n  // than everything \u2014 the failure is visible, not permissive.\n  hasFeature: () => false,\n  ready: false,\n})\n\nexport function TableRegistryProvider({\n  value,\n  children,\n}: {\n  value: TableRegistryValue\n  children: React.ReactNode\n}) {\n  return (\n    <TableRegistryContext.Provider value={value}>{children}</TableRegistryContext.Provider>\n  )\n}\n\nexport function useTableRegistry(): TableRegistryValue {\n  return React.useContext(TableRegistryContext)\n}\n\n/** The tables the current user may see, memoised against the grant function. */\nexport function useAccessibleTables(): TableDefinition[] {\n  const { tables, hasFeature } = useTableRegistry()\n  return React.useMemo(() => filterAccessibleTables(tables, hasFeature), [tables, hasFeature])\n}\n\n/**\n * Resolve one table by id, with the two degradations a host needs.\n * `unknown` \u2014 not in the registry (e.g. a saved layout naming a removed table).\n * `denied`  \u2014 present but the user lacks its features.\n */\nexport function useTableById(id: string | null | undefined): {\n  definition: TableDefinition | null\n  status: 'ok' | 'unknown' | 'denied' | 'loading'\n} {\n  const { tables, hasFeature, ready } = useTableRegistry()\n  return React.useMemo(() => {\n    if (!id) return { definition: null, status: 'unknown' as const }\n    const definition = findTableDefinition(tables, id)\n    if (!definition) return { definition: null, status: 'unknown' as const }\n    if (!ready) return { definition, status: 'loading' as const }\n    const allowed = definition.metadata.features.every((f) => hasFeature(f))\n    return allowed\n      ? { definition, status: 'ok' as const }\n      : { definition, status: 'denied' as const }\n  }, [id, tables, hasFeature, ready])\n}\n"],
+  "mappings": ";AAiDI;AApCJ,YAAY,WAAW;AAEvB,SAAS,wBAAwB,2BAA2B;AAgB5D,MAAM,QAA2B,CAAC;AAElC,MAAM,uBAAuB,MAAM,cAAkC;AAAA,EACnE,QAAQ;AAAA;AAAA;AAAA,EAGR,YAAY,MAAM;AAAA,EAClB,OAAO;AACT,CAAC;AAEM,SAAS,sBAAsB;AAAA,EACpC;AAAA,EACA;AACF,GAGG;AACD,SACE,oBAAC,qBAAqB,UAArB,EAA8B,OAAe,UAAS;AAE3D;AAEO,SAAS,mBAAuC;AACrD,SAAO,MAAM,WAAW,oBAAoB;AAC9C;AAGO,SAAS,sBAAyC;AACvD,QAAM,EAAE,QAAQ,WAAW,IAAI,iBAAiB;AAChD,SAAO,MAAM,QAAQ,MAAM,uBAAuB,QAAQ,UAAU,GAAG,CAAC,QAAQ,UAAU,CAAC;AAC7F;AAOO,SAAS,aAAa,IAG3B;AACA,QAAM,EAAE,QAAQ,YAAY,MAAM,IAAI,iBAAiB;AACvD,SAAO,MAAM,QAAQ,MAAM;AACzB,QAAI,CAAC,GAAI,QAAO,EAAE,YAAY,MAAM,QAAQ,UAAmB;AAC/D,UAAM,aAAa,oBAAoB,QAAQ,EAAE;AACjD,QAAI,CAAC,WAAY,QAAO,EAAE,YAAY,MAAM,QAAQ,UAAmB;AACvE,QAAI,CAAC,MAAO,QAAO,EAAE,YAAY,QAAQ,UAAmB;AAC5D,UAAM,UAAU,WAAW,SAAS,SAAS,MAAM,CAAC,MAAM,WAAW,CAAC,CAAC;AACvE,WAAO,UACH,EAAE,YAAY,QAAQ,KAAc,IACpC,EAAE,YAAY,QAAQ,SAAkB;AAAA,EAC9C,GAAG,CAAC,IAAI,QAAQ,YAAY,KAAK,CAAC;AACpC;",
+  "names": []
+}

package/dist/backend/dynamic-table/registry/filterAccessibleTables.js

@@ -0,0 +1,13 @@
+function filterAccessibleTables(tables, hasFeature) {
+  return tables.filter(
+    (table) => table.metadata.features.every((feature) => hasFeature(feature))
+  );
+}
+function findTableDefinition(tables, id) {
+  return tables.find((t) => t.metadata.id === id) ?? null;
+}
+export {
+  filterAccessibleTables,
+  findTableDefinition
+};
+//# sourceMappingURL=filterAccessibleTables.js.map

package/dist/backend/dynamic-table/registry/filterAccessibleTables.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/backend/dynamic-table/registry/filterAccessibleTables.ts"],
+  "sourcesContent": ["import type { TableDefinition } from './types'\n\n/**\n * Narrow a registry to the tables a user may see.\n *\n * **Pure on purpose.** It calls no endpoint and knows nothing about who is\n * logged in \u2014 `metadata.features` are opaque strings and the HOST injects the\n * check. That is what keeps the registry usable by more than one surface: the\n * backend resolves grants through `POST /api/auth/feature-check` (which is\n * organization-scoped, server-side), and any other host wires `hasFeature` to\n * its own authority.\n *\n * **This filter is UX, not security.** The boundary is unchanged and unmoved:\n * every table's own list route still declares and enforces its feature\n * requirements. Hiding an inaccessible table from a picker is courtesy \u2014 it\n * stops a host offering something that would render an empty error \u2014 and a\n * table reached some other way (a stale saved layout) is still refused by the\n * route, not by this function.\n */\nexport function filterAccessibleTables(\n  tables: TableDefinition[],\n  hasFeature: (feature: string) => boolean,\n): TableDefinition[] {\n  return tables.filter((table) =>\n    table.metadata.features.every((feature) => hasFeature(feature)),\n  )\n}\n\n/** Look one up by `metadata.id`. Returns null rather than throwing \u2014 a host\n *  restoring a saved layout must degrade that slot, not fail the whole view. */\nexport function findTableDefinition(\n  tables: TableDefinition[],\n  id: string,\n): TableDefinition | null {\n  return tables.find((t) => t.metadata.id === id) ?? null\n}\n"],
+  "mappings": "AAmBO,SAAS,uBACd,QACA,YACmB;AACnB,SAAO,OAAO;AAAA,IAAO,CAAC,UACpB,MAAM,SAAS,SAAS,MAAM,CAAC,YAAY,WAAW,OAAO,CAAC;AAAA,EAChE;AACF;AAIO,SAAS,oBACd,QACA,IACwB;AACxB,SAAO,OAAO,KAAK,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,KAAK;AACrD;",
+  "names": []
+}

package/dist/backend/dynamic-table/registry/index.js

@@ -0,0 +1,44 @@
+import { lazyTable } from "./lazyTable.js";
+import { filterAccessibleTables, findTableDefinition } from "./filterAccessibleTables.js";
+import {
+  TableRegistryProvider,
+  useTableRegistry,
+  useAccessibleTables,
+  useTableById
+} from "./TableRegistryContext.js";
+import {
+  ContentRegistryProvider,
+  ContentRegistryBootstrap,
+  useContentRegistry,
+  useAccessibleContent,
+  useContentById,
+  useWidgetRenderContext
+} from "./ContentRegistryContext.js";
+import {
+  useWidgetCatalog,
+  widgetLoaderKeyExists,
+  parseWidgetCatalog,
+  parseWidgetRenderContext,
+  EMPTY_WIDGET_CATALOG
+} from "./widgetCatalog.js";
+export {
+  ContentRegistryBootstrap,
+  ContentRegistryProvider,
+  EMPTY_WIDGET_CATALOG,
+  TableRegistryProvider,
+  filterAccessibleTables,
+  findTableDefinition,
+  lazyTable,
+  parseWidgetCatalog,
+  parseWidgetRenderContext,
+  useAccessibleContent,
+  useAccessibleTables,
+  useContentById,
+  useContentRegistry,
+  useTableById,
+  useTableRegistry,
+  useWidgetCatalog,
+  useWidgetRenderContext,
+  widgetLoaderKeyExists
+};
+//# sourceMappingURL=index.js.map

package/dist/backend/dynamic-table/registry/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/backend/dynamic-table/registry/index.ts"],
+  "sourcesContent": ["export type {\n  TableDefinition,\n  TableDefinitionMetadata,\n  TableHostContext,\n  TableLoader,\n} from './types'\nexport { lazyTable } from './lazyTable'\nexport { filterAccessibleTables, findTableDefinition } from './filterAccessibleTables'\nexport {\n  TableRegistryProvider,\n  useTableRegistry,\n  useAccessibleTables,\n  useTableById,\n} from './TableRegistryContext'\nexport type { TableRegistryValue } from './TableRegistryContext'\nexport {\n  ContentRegistryProvider,\n  ContentRegistryBootstrap,\n  useContentRegistry,\n  useAccessibleContent,\n  useContentById,\n  useWidgetRenderContext,\n} from './ContentRegistryContext'\nexport type {\n  ContentRegistryValue,\n  ContentStatus,\n  PaneContentItem,\n  TableContentItem,\n  WidgetContentItem,\n} from './ContentRegistryContext'\nexport {\n  useWidgetCatalog,\n  widgetLoaderKeyExists,\n  parseWidgetCatalog,\n  parseWidgetRenderContext,\n  EMPTY_WIDGET_CATALOG,\n} from './widgetCatalog'\nexport type { WidgetCatalog, WidgetCatalogEntry } from './widgetCatalog'\n"],
+  "mappings": "AAMA,SAAS,iBAAiB;AAC1B,SAAS,wBAAwB,2BAA2B;AAC5D;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAQP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;",
+  "names": []
+}

package/dist/backend/dynamic-table/registry/lazyTable.js

@@ -0,0 +1,55 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import * as React from "react";
+import TableSkeleton from "../components/TableSkeleton.js";
+function lazyTable(loader) {
+  let cached = null;
+  let pending = null;
+  let failed = null;
+  const load = () => {
+    if (cached) return Promise.resolve();
+    if (!pending) {
+      pending = loader().then((mod) => {
+        cached = mod.default ?? mod;
+      }).catch((err) => {
+        pending = null;
+        failed = err;
+        throw err;
+      });
+    }
+    return pending;
+  };
+  const LazyTable = (props) => {
+    const [, setTick] = React.useState(0);
+    React.useEffect(() => {
+      let cancelled = false;
+      void load().then(() => {
+        if (!cancelled) setTick((v) => v + 1);
+      }).catch((err) => {
+        if (cancelled) return;
+        try {
+          console.error("Failed to load table component", err);
+        } catch {
+        }
+        setTick((v) => v + 1);
+      });
+      return () => {
+        cancelled = true;
+      };
+    }, []);
+    if (cached) {
+      const Loaded = cached;
+      return /* @__PURE__ */ jsx(Loaded, { ...props });
+    }
+    if (failed) {
+      return /* @__PURE__ */ jsx("div", { className: "p-4 text-body-regular-sm", role: "alert", "data-table-load-error": "", children: "This table could not be loaded." });
+    }
+    return /* @__PURE__ */ jsx(TableSkeleton, { rows: 10, columns: 5 });
+  };
+  LazyTable.displayName = "LazyTable";
+  return LazyTable;
+}
+export {
+  lazyTable
+};
+//# sourceMappingURL=lazyTable.js.map

package/dist/backend/dynamic-table/registry/lazyTable.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/backend/dynamic-table/registry/lazyTable.tsx"],
+  "sourcesContent": ["'use client'\n\n// Mirrors `lazyDashboardWidget` (@open-mercato/shared/modules/dashboard/widgets.ts:64):\n// a cached, single-flight loader so a table's code is only fetched when a host\n// actually renders it, and only once no matter how many hosts mount at the\n// same moment.\n\nimport * as React from 'react'\nimport TableSkeleton from '../components/TableSkeleton'\nimport type { TableHostContext, TableLoader } from './types'\n\nexport function lazyTable(\n  loader: TableLoader,\n): React.ComponentType<TableHostContext> {\n  let cached: React.ComponentType<TableHostContext> | null = null\n  let pending: Promise<void> | null = null\n  let failed: unknown = null\n\n  const load = () => {\n    if (cached) return Promise.resolve()\n    if (!pending) {\n      pending = loader()\n        .then((mod) => {\n          cached =\n            (mod as { default?: React.ComponentType<TableHostContext> }).default ??\n            (mod as React.ComponentType<TableHostContext>)\n        })\n        .catch((err) => {\n          // Clear `pending` so a later mount retries rather than awaiting a\n          // promise that will never resolve \u2014 a failed chunk fetch is usually\n          // transient (deploy mid-session, flaky network).\n          pending = null\n          failed = err\n          throw err\n        })\n    }\n    return pending\n  }\n\n  const LazyTable: React.ComponentType<TableHostContext> = (props) => {\n    const [, setTick] = React.useState(0)\n\n    React.useEffect(() => {\n      let cancelled = false\n      void load()\n        .then(() => {\n          if (!cancelled) setTick((v) => v + 1)\n        })\n        .catch((err) => {\n          if (cancelled) return\n          try {\n            console.error('Failed to load table component', err)\n          } catch {}\n          // Re-render so the failure is SHOWN. A lazy loader that swallows its\n          // error leaves a permanent skeleton, which reads as \"still loading\"\n          // forever \u2014 the one outcome worse than an error message.\n          setTick((v) => v + 1)\n        })\n      return () => {\n        cancelled = true\n      }\n    }, [])\n\n    if (cached) {\n      const Loaded = cached\n      return <Loaded {...props} />\n    }\n    if (failed) {\n      return (\n        <div className=\"p-4 text-body-regular-sm\" role=\"alert\" data-table-load-error=\"\">\n          This table could not be loaded.\n        </div>\n      )\n    }\n    return <TableSkeleton rows={10} columns={5} />\n  }\n\n  LazyTable.displayName = 'LazyTable'\n  return LazyTable\n}\n"],
+  "mappings": ";AAiEa;AA1Db,YAAY,WAAW;AACvB,OAAO,mBAAmB;AAGnB,SAAS,UACd,QACuC;AACvC,MAAI,SAAuD;AAC3D,MAAI,UAAgC;AACpC,MAAI,SAAkB;AAEtB,QAAM,OAAO,MAAM;AACjB,QAAI,OAAQ,QAAO,QAAQ,QAAQ;AACnC,QAAI,CAAC,SAAS;AACZ,gBAAU,OAAO,EACd,KAAK,CAAC,QAAQ;AACb,iBACG,IAA4D,WAC5D;AAAA,MACL,CAAC,EACA,MAAM,CAAC,QAAQ;AAId,kBAAU;AACV,iBAAS;AACT,cAAM;AAAA,MACR,CAAC;AAAA,IACL;AACA,WAAO;AAAA,EACT;AAEA,QAAM,YAAmD,CAAC,UAAU;AAClE,UAAM,CAAC,EAAE,OAAO,IAAI,MAAM,SAAS,CAAC;AAEpC,UAAM,UAAU,MAAM;AACpB,UAAI,YAAY;AAChB,WAAK,KAAK,EACP,KAAK,MAAM;AACV,YAAI,CAAC,UAAW,SAAQ,CAAC,MAAM,IAAI,CAAC;AAAA,MACtC,CAAC,EACA,MAAM,CAAC,QAAQ;AACd,YAAI,UAAW;AACf,YAAI;AACF,kBAAQ,MAAM,kCAAkC,GAAG;AAAA,QACrD,QAAQ;AAAA,QAAC;AAIT,gBAAQ,CAAC,MAAM,IAAI,CAAC;AAAA,MACtB,CAAC;AACH,aAAO,MAAM;AACX,oBAAY;AAAA,MACd;AAAA,IACF,GAAG,CAAC,CAAC;AAEL,QAAI,QAAQ;AACV,YAAM,SAAS;AACf,aAAO,oBAAC,UAAQ,GAAG,OAAO;AAAA,IAC5B;AACA,QAAI,QAAQ;AACV,aACE,oBAAC,SAAI,WAAU,4BAA2B,MAAK,SAAQ,yBAAsB,IAAG,6CAEhF;AAAA,IAEJ;AACA,WAAO,oBAAC,iBAAc,MAAM,IAAI,SAAS,GAAG;AAAA,EAC9C;AAEA,YAAU,cAAc;AACxB,SAAO;AACT;",
+  "names": []
+}

package/dist/backend/dynamic-table/registry/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/backend/dynamic-table/registry/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/backend/dynamic-table/registry/widgetCatalog.js

@@ -0,0 +1,96 @@
+"use client";
+import * as React from "react";
+import { useQuery } from "@tanstack/react-query";
+import { useOrganizationScopeVersion } from "@open-mercato/shared/lib/frontend/useOrganizationScope";
+import { apiCall } from "../../utils/apiCall.js";
+import { getDashboardWidgets } from "../../dashboard/widgetRegistry.js";
+const EMPTY_WIDGET_CATALOG = {
+  widgets: [],
+  context: null,
+  ready: false
+};
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function asSize(value) {
+  return value === "sm" || value === "md" || value === "lg" ? value : "md";
+}
+function parseWidgetCatalog(payload) {
+  const rows = Array.isArray(payload?.widgets) ? payload.widgets : [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const row of rows) {
+    const id = asString(row?.id);
+    const loaderKey = asString(row?.loaderKey);
+    if (!id || !loaderKey || seen.has(id)) continue;
+    seen.add(id);
+    out.push({
+      id,
+      title: asString(row?.title) ?? id,
+      description: asString(row?.description),
+      loaderKey,
+      icon: asString(row?.icon),
+      features: Array.isArray(row?.features) ? row.features.filter((f) => typeof f === "string") : [],
+      moduleId: asString(row?.moduleId) ?? "other",
+      defaultSettings: row?.defaultSettings ?? null,
+      defaultSize: asSize(row?.defaultSize),
+      supportsRefresh: row?.supportsRefresh === true
+    });
+  }
+  return out;
+}
+function parseWidgetRenderContext(payload) {
+  const raw = payload?.context;
+  if (!raw || typeof raw !== "object") return null;
+  const userId = asString(raw.userId);
+  if (!userId) return null;
+  return {
+    userId,
+    tenantId: asString(raw.tenantId),
+    organizationId: asString(raw.organizationId),
+    userName: asString(raw.userName),
+    userEmail: asString(raw.userEmail),
+    userLabel: asString(raw.userLabel)
+  };
+}
+function widgetLoaderKeyExists(loaderKey) {
+  if (!loaderKey) return false;
+  try {
+    return getDashboardWidgets().some((entry) => entry.key === loaderKey);
+  } catch {
+    return false;
+  }
+}
+function useWidgetCatalog(options) {
+  const scopeVersion = useOrganizationScopeVersion();
+  const enabled = options?.enabled !== false;
+  const { data, isFetched } = useQuery({
+    queryKey: ["dashboard-widget-catalog", scopeVersion],
+    queryFn: async () => {
+      const res = await apiCall("/api/dashboards/layout");
+      if (!res.ok || !res.result) return { widgets: [], context: null };
+      return {
+        widgets: parseWidgetCatalog(res.result),
+        context: parseWidgetRenderContext(res.result)
+      };
+    },
+    staleTime: 6e4,
+    enabled
+  });
+  return React.useMemo(
+    () => ({
+      widgets: data?.widgets ?? [],
+      context: data?.context ?? null,
+      ready: enabled ? isFetched : false
+    }),
+    [data, isFetched, enabled]
+  );
+}
+export {
+  EMPTY_WIDGET_CATALOG,
+  parseWidgetCatalog,
+  parseWidgetRenderContext,
+  useWidgetCatalog,
+  widgetLoaderKeyExists
+};
+//# sourceMappingURL=widgetCatalog.js.map

package/dist/backend/dynamic-table/registry/widgetCatalog.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/backend/dynamic-table/registry/widgetCatalog.ts"],
+  "sourcesContent": ["'use client'\n\n// The widget half of the content registry: what widgets exist, what the user is\n// allowed to place, and the render context they need \u2014 WITHOUT loading a single\n// widget chunk.\n//\n// \u2500\u2500 Why /api/dashboards/layout and not /api/dashboards/widgets/catalog \u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// The catalog endpoint reads like the obvious choice and is the wrong one. Twice:\n//\n//  1. It is gated on `dashboards.admin.assign-widgets`\n//     (@open-mercato/core/modules/dashboards/api/widgets/catalog.ts:10) and 403s\n//     for every ordinary user. A picker built on it would be empty for exactly\n//     the people who use it.\n//  2. It is NOT ACL-filtered per user. It returns every widget the build\n//     contains, so the few users who can call it would be offered widgets they\n//     may not render.\n//\n// `GET /api/dashboards/layout` requires only `dashboards.view` and returns\n// `widgets` already narrowed by `resolveAllowedWidgetIds`, which applies BOTH\n// the role/user widget assignments and `userHasAllFeatures(...)` against the\n// widget's own `metadata.features`. It also returns `context` \u2014 the\n// user/tenant/organization triple every widget component is handed \u2014 which the\n// catalog endpoint does not, and which we would otherwise have no honest source\n// for. One call answers both questions the same way the dashboard asks them.\n//\n// **It is a GET that writes.** When the user has no `DashboardLayout` row yet it\n// creates one seeded with the default widgets, and it prunes widgets that are no\n// longer permitted. That is the same effect as visiting /backend/dashboard, and\n// it is idempotent after the first call \u2014 but it IS a side effect and is\n// recorded here rather than discovered later. There is no read-only endpoint\n// that answers \"which widgets may I place\" without an upstream change, and an\n// upstream change is out of scope.\n//\n// Spec: .ai/specs/2026-08-17-split-view-workspace-composition.md (Phase 2)\n\nimport * as React from 'react'\nimport { useQuery } from '@tanstack/react-query'\nimport { useOrganizationScopeVersion } from '@open-mercato/shared/lib/frontend/useOrganizationScope'\nimport type {\n  DashboardWidgetRenderContext,\n  DashboardWidgetSize,\n} from '@open-mercato/shared/modules/dashboard/widgets'\nimport { apiCall } from '../../utils/apiCall'\nimport { getDashboardWidgets } from '../../dashboard/widgetRegistry'\n\n/**\n * One widget as the picker and the pane need it: enough to list it, enough to\n * mount it, and nothing that requires fetching its code.\n *\n * Mirrors the DTO `/api/dashboards/layout` returns, minus the fields only the\n * dashboard's own grid uses.\n */\nexport type WidgetCatalogEntry = {\n  /** '<module>.dashboard.<slug>' \u2014 the stable id stored on a pane. */\n  id: string\n  title: string\n  description: string | null\n  /** Key into the client-side widget entry registry; what `loadDashboardWidgetModule` takes. */\n  loaderKey: string\n  /** lucide-react icon name, same convention as `TableDefinitionMetadata.icon`. */\n  icon: string | null\n  /** ACL features the widget declares. Already applied server-side; kept for display and audit. */\n  features: string[]\n  /** Owning module \u2014 the only grouping the DTO carries, so it is the picker's group. */\n  moduleId: string\n  defaultSettings: unknown\n  defaultSize: DashboardWidgetSize\n  supportsRefresh: boolean\n}\n\nexport type WidgetCatalog = {\n  /** Widgets this user may place, ACL-filtered server-side. */\n  widgets: WidgetCatalogEntry[]\n  /** The user/tenant/org triple a widget component is handed. Null until fetched. */\n  context: DashboardWidgetRenderContext | null\n  /** False while the catalogue is in flight, so a picker does not flash empty. */\n  ready: boolean\n}\n\nexport const EMPTY_WIDGET_CATALOG: WidgetCatalog = {\n  widgets: [],\n  context: null,\n  ready: false,\n}\n\ntype LayoutWidgetDto = {\n  id?: unknown\n  title?: unknown\n  description?: unknown\n  defaultSize?: unknown\n  defaultSettings?: unknown\n  features?: unknown\n  moduleId?: unknown\n  icon?: unknown\n  loaderKey?: unknown\n  supportsRefresh?: unknown\n}\n\ntype LayoutContextDto = {\n  userId?: unknown\n  tenantId?: unknown\n  organizationId?: unknown\n  userName?: unknown\n  userEmail?: unknown\n  userLabel?: unknown\n}\n\ntype LayoutResponse = {\n  widgets?: LayoutWidgetDto[]\n  context?: LayoutContextDto | null\n}\n\nfunction asString(value: unknown): string | null {\n  return typeof value === 'string' && value.length > 0 ? value : null\n}\n\nfunction asSize(value: unknown): DashboardWidgetSize {\n  return value === 'sm' || value === 'md' || value === 'lg' ? value : 'md'\n}\n\n/**\n * Narrow the DTO to what we render.\n *\n * Defensive because the response is a wire format: a widget missing `id` or\n * `loaderKey` cannot be placed OR mounted, so it is dropped rather than listed\n * as an entry that fails the moment it is picked.\n */\nexport function parseWidgetCatalog(payload: LayoutResponse | null): WidgetCatalogEntry[] {\n  const rows = Array.isArray(payload?.widgets) ? payload!.widgets! : []\n  const seen = new Set<string>()\n  const out: WidgetCatalogEntry[] = []\n  for (const row of rows) {\n    const id = asString(row?.id)\n    const loaderKey = asString(row?.loaderKey)\n    if (!id || !loaderKey || seen.has(id)) continue\n    seen.add(id)\n    out.push({\n      id,\n      title: asString(row?.title) ?? id,\n      description: asString(row?.description),\n      loaderKey,\n      icon: asString(row?.icon),\n      features: Array.isArray(row?.features) ? row!.features!.filter((f): f is string => typeof f === 'string') : [],\n      moduleId: asString(row?.moduleId) ?? 'other',\n      defaultSettings: row?.defaultSettings ?? null,\n      defaultSize: asSize(row?.defaultSize),\n      supportsRefresh: row?.supportsRefresh === true,\n    })\n  }\n  return out\n}\n\nexport function parseWidgetRenderContext(\n  payload: LayoutResponse | null,\n): DashboardWidgetRenderContext | null {\n  const raw = payload?.context\n  if (!raw || typeof raw !== 'object') return null\n  const userId = asString(raw.userId)\n  if (!userId) return null\n  return {\n    userId,\n    tenantId: asString(raw.tenantId),\n    organizationId: asString(raw.organizationId),\n    userName: asString(raw.userName),\n    userEmail: asString(raw.userEmail),\n    userLabel: asString(raw.userLabel),\n  }\n}\n\n/**\n * Does a widget's code exist in THIS build at all?\n *\n * The one signal that separates \"removed from the product\" from \"you are not\n * permitted it\" \u2014 because the server catalogue only ever returns the allowed\n * set, so absence from it means both things at once. The client entry registry\n * (populated by `registerDashboardWidgets` at bootstrap) is unfiltered and\n * carries only `{ key, loader }`, so this costs no fetch and loads no chunk.\n */\nexport function widgetLoaderKeyExists(loaderKey: string): boolean {\n  if (!loaderKey) return false\n  try {\n    return getDashboardWidgets().some((entry) => entry.key === loaderKey)\n  } catch {\n    // Not registered (server render, or a host that never bootstrapped). Say\n    // \"unknown\", not \"denied\" \u2014 claiming a permission verdict we cannot make.\n    return false\n  }\n}\n\n/**\n * Fetch + cache the widget catalogue.\n *\n * Keyed on the organization scope version for the same reason\n * `TableRegistryBootstrap` is: widget grants are per organization, and the org\n * switcher changes scope client-side with no reload, so a key without it would\n * serve the previous org's answer. `staleTime` matches the table grants (60s).\n */\nexport function useWidgetCatalog(options?: { enabled?: boolean }): WidgetCatalog {\n  const scopeVersion = useOrganizationScopeVersion()\n  const enabled = options?.enabled !== false\n\n  const { data, isFetched } = useQuery({\n    queryKey: ['dashboard-widget-catalog', scopeVersion],\n    queryFn: async () => {\n      const res = await apiCall<LayoutResponse>('/api/dashboards/layout')\n      // A failed call offers nothing. Default-deny keeps a transient network\n      // error from listing widgets the user cannot actually render.\n      if (!res.ok || !res.result) return { widgets: [], context: null }\n      return {\n        widgets: parseWidgetCatalog(res.result),\n        context: parseWidgetRenderContext(res.result),\n      }\n    },\n    staleTime: 60_000,\n    enabled,\n  })\n\n  return React.useMemo(\n    () => ({\n      widgets: data?.widgets ?? [],\n      context: data?.context ?? null,\n      ready: enabled ? isFetched : false,\n    }),\n    [data, isFetched, enabled],\n  )\n}\n"],
+  "mappings": "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",
+  "names": []
+}