@object-ui/app-shell 6.2.3 → 7.1.0

package/dist/providers/MetadataProvider.js

@@ -1,6 +1,10 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useState, useEffect, useCallback, useRef, useMemo, } from 'react';
+import { MetadataClient } from '@object-ui/data-objectstack';
+import { resolveInlineMode } from '@object-ui/plugin-form';
 import { MetadataCtx, useMetadata } from '@object-ui/react';
+import { usePreviewDrafts } from '../preview/PreviewModeContext';
+import { subscribeCanvasInvalidate, subscribeMetadataRefresh } from '../assistant/assistantBus';
 export { useMetadataItem } from '@object-ui/react';
 export { useMetadata };
 // ---------------------------------------------------------------------------
@@ -41,7 +45,15 @@ function debug(...args) {
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-function extractItems(res) {
+/** Exported for tests — both metadata sources must normalize identically. */
+export function extractItems(res) {
+    // Both source shapes must parse: the adapter SDK returns the wrapped
+    // `{ type, items: [...] }` envelope, while the ADR-0037 preview path's
+    // MetadataClient.list() returns the already-unwrapped array. Dropping the
+    // bare-array shape silently emptied the ENTIRE draft-preview world (every
+    // type read 0 items), stranding the Live Canvas on "No Apps Configured".
+    if (Array.isArray(res))
+        return res;
     if (res && typeof res === 'object' && 'items' in res && Array.isArray(res.items)) {
         return res.items;
     }
@@ -61,14 +73,54 @@ function isNamedItem(item) {
         'name' in item &&
         typeof item.name === 'string');
 }
-function mergeViewsIntoObjects(objects, views) {
+/** A first-class ViewItem carries a `viewKind` discriminant + `object` binding. */
+function isViewItem(view) {
+    return !!view && typeof view === 'object' && !!view.viewKind && !!view.object;
+}
+export function mergeViewsIntoObjects(objects, views) {
+    var _a;
     if (!objects.length || !views.length)
         return objects;
     const byObject = {};
+    // Objects that received expanded ViewItems — their legacy aggregated
+    // container (also present in the `view` list) is superseded and skipped.
+    const hasViewItems = new Set();
+    for (const view of views) {
+        if (isViewItem(view))
+            hasViewItems.add(view.object);
+    }
     for (const view of views) {
+        // ── New protocol: independent ViewItem ({ name, object, viewKind, config }) ──
+        if (isViewItem(view)) {
+            const bucket = (byObject[_a = view.object] || (byObject[_a] = { listViews: {}, formViews: {} }));
+            // Canonical `<object>.<key>` name doubles as the view id, so `/view/<name>`
+            // URLs resolve directly against the switcher tab ids.
+            const key = view.name || `${view.object}.${view.viewKind}`;
+            const body = view.config && typeof view.config === 'object' ? view.config : {};
+            // Flatten `config` to the legacy NamedListView/FormView shape the
+            // renderer consumes (type/data/columns/sections at top level); carry the
+            // item-level label/isDefault and stamp `name` so primary-view promotion
+            // (which matches on `list.name`) finds this entry by its listViews key.
+            const entry = { ...body, name: key, label: view.label ?? body.label, isDefault: !!view.isDefault };
+            if (view.viewKind === 'form') {
+                bucket.formViews[key] = entry;
+                if (view.isDefault || !bucket.form)
+                    bucket.form = entry;
+            }
+            else {
+                bucket.listViews[key] = entry;
+                if (view.isDefault)
+                    bucket.primary = entry;
+            }
+            continue;
+        }
+        // ── Legacy aggregated container ({ list, form, listViews, formViews }) ──
         const objName = view?.name || view?.list?.data?.object || view?.form?.data?.object;
         if (!objName)
             continue;
+        // Expanded ViewItems supersede the bare container for this object.
+        if (hasViewItems.has(objName))
+            continue;
         const bucket = (byObject[objName] || (byObject[objName] = { listViews: {}, formViews: {} }));
         if (view.list) {
             // Preserve the primary list view as `obj.list` per @objectstack/spec
@@ -115,6 +167,67 @@ function mergeViewsIntoObjects(objects, views) {
         return merged;
     });
 }
+/**
+ * Relationship-driven master-detail: a child object's `master_detail`/`lookup`
+ * field can carry `inlineEdit: true` to declare "edit me inline within my
+ * parent's form". This pass scans every object for such fields and merges the
+ * resulting child collections into each parent object's form view as
+ * `subforms` — so the parent's standard create/edit form renders an atomic
+ * master-detail form with NO view config and NO bespoke page. The intent lives
+ * in the data model (where it's defined once, e.g. by an AI modelling the
+ * schema); forms just follow. An explicit `form.subforms` entry for the same
+ * child overrides the model-derived one.
+ */
+export function attachInlineSubforms(objects) {
+    if (!objects?.length)
+        return objects;
+    const inlineByParent = {};
+    for (const child of objects) {
+        const fields = child?.fields;
+        if (!fields)
+            continue;
+        const entries = Array.isArray(fields)
+            ? fields.map((f) => [f?.name, f])
+            : Object.entries(fields);
+        for (const [fname, fdef] of entries) {
+            const d = fdef;
+            if (!fname || !d?.inlineEdit)
+                continue;
+            if (d.type !== 'master_detail' && d.type !== 'lookup')
+                continue;
+            const parent = d.reference;
+            if (!parent)
+                continue;
+            (inlineByParent[parent] || (inlineByParent[parent] = [])).push({
+                childObject: child.name,
+                relationshipField: fname,
+                // Resolve the inline-edit form factor (grid vs per-row form) from the
+                // declared value, falling back to the smart default by child shape.
+                inlineMode: resolveInlineMode(child, d.inlineEdit, { relationshipField: fname }),
+                ...(d.inlineTitle ? { title: d.inlineTitle } : {}),
+                ...(Array.isArray(d.inlineColumns) ? { columns: d.inlineColumns } : {}),
+                ...(typeof d.inlineAmountField === 'string' ? { amountField: d.inlineAmountField } : {}),
+            });
+        }
+    }
+    if (!Object.keys(inlineByParent).length)
+        return objects;
+    return objects.map((obj) => {
+        const derived = inlineByParent[obj.name];
+        if (!derived?.length)
+            return obj;
+        const form = { ...(obj.form || { type: 'simple' }) };
+        const explicit = Array.isArray(form.subforms) ? form.subforms : [];
+        const explicitChildren = new Set(explicit.map((s) => s.childObject));
+        // Model-derived first; an explicit view subform for the same child wins.
+        form.subforms = [...derived.filter((d) => !explicitChildren.has(d.childObject)), ...explicit];
+        const next = { ...obj, form };
+        if (obj.formViews?.default) {
+            next.formViews = { ...obj.formViews, default: { ...obj.formViews.default, subforms: form.subforms } };
+        }
+        return next;
+    });
+}
 function emptyEntry() {
     return {
         status: 'idle',
@@ -157,6 +270,20 @@ export function MetadataProvider({ children, adapter, ttlMs = DEFAULT_TTL_MS })
     const itemPromisesRef = useRef(new Map());
     const adapterRef = useRef(adapter);
     adapterRef.current = adapter;
+    // ADR-0037 Live Canvas: when the tree is in draft-preview mode, metadata
+    // reads come from the REST `?preview=draft` overlay (pending ADR-0033
+    // drafts win over active) instead of the adapter SDK. The MetadataClient
+    // is used because the SDK's meta API doesn't carry the preview flag; same
+    // endpoints, same cookie auth. Reads only — every write path is unchanged.
+    const previewDrafts = usePreviewDrafts();
+    const previewClient = useMemo(() => {
+        if (!previewDrafts)
+            return null;
+        const baseUrl = (typeof import.meta !== 'undefined' && import.meta.env?.VITE_SERVER_URL) || '';
+        return new MetadataClient({ baseUrl, previewDrafts: true });
+    }, [previewDrafts]);
+    const previewClientRef = useRef(previewClient);
+    previewClientRef.current = previewClient;
     const [version, setVersion] = useState(0);
     // Defer state bumps so they never occur synchronously during a consumer's
     // render phase. `ensureType` may be invoked from inside `useMemo` getters
@@ -171,6 +298,14 @@ export function MetadataProvider({ children, adapter, ttlMs = DEFAULT_TTL_MS })
             Promise.resolve().then(() => setVersion(v => v + 1));
         }
     }, []);
+    // Entering/leaving preview swaps the entire metadata source — the published
+    // and draft-overlaid worlds must never mix in one cache. Drop everything and
+    // let consumers refetch through the new source.
+    useEffect(() => {
+        cacheRef.current.clear();
+        itemPromisesRef.current.clear();
+        bump();
+    }, [previewDrafts, bump]);
     const getEntry = useCallback((type) => {
         let entry = cacheRef.current.get(type);
         if (!entry) {
@@ -190,9 +325,13 @@ export function MetadataProvider({ children, adapter, ttlMs = DEFAULT_TTL_MS })
         const started = Date.now();
         entry.status = 'loading';
         entry.error = null;
-        const client = adapterRef.current.getClient();
-        const promise = client.meta
-            .getItems(type)
+        // Preview mode reads the draft-overlaid world (`?preview=draft`);
+        // normal mode reads the adapter SDK as before.
+        const preview = previewClientRef.current;
+        const fetchItems = preview
+            ? preview.list(type)
+            : adapterRef.current.getClient().meta.getItems(type);
+        const promise = fetchItems
             .then((res) => {
             const items = extractItems(res);
             entry.items = items;
@@ -206,7 +345,9 @@ export function MetadataProvider({ children, adapter, ttlMs = DEFAULT_TTL_MS })
                     entry.byName.set(it.name, it);
                 }
             }
-            if (type === 'app')
+            // Never let the draft-overlaid world poison the published session
+            // cache — preview is ephemeral by design.
+            if (type === 'app' && !preview)
                 saveToSession(type, items);
             debug(`fetched type=${type} items=${items.length} in ${Date.now() - started}ms`);
             bump();
@@ -243,9 +384,11 @@ export function MetadataProvider({ children, adapter, ttlMs = DEFAULT_TTL_MS })
         if (existing)
             return existing;
         const started = Date.now();
-        const client = adapterRef.current.getClient();
-        const promise = client.meta
-            .getItem(type, name)
+        const preview = previewClientRef.current;
+        const fetchItem = preview
+            ? preview.get(type, name)
+            : adapterRef.current.getClient().meta.getItem(type, name);
+        const promise = fetchItem
             .then((res) => {
             const item = extractItem(res);
             if (item)
@@ -297,11 +440,44 @@ export function MetadataProvider({ children, adapter, ttlMs = DEFAULT_TTL_MS })
         }
         bump();
     }, [bump]);
+    // ADR-0037 P2.5 — same-document live refresh: while this tree renders the
+    // draft overlay, chat hosts announce each drafted artifact on the assistant
+    // bus; drop that type's cache entry so the next read refetches the updated
+    // draft world. Published-mode trees ignore the events entirely.
+    useEffect(() => {
+        if (!previewDrafts)
+            return;
+        return subscribeCanvasInvalidate(({ type }) => {
+            invalidate(type);
+        });
+    }, [previewDrafts, invalidate]);
+    // Live-metadata-changed refresh: a publish (drafts → live) or a marketplace
+    // install changed the registry out-of-band, so the schema this tree cached
+    // is stale. Refetch every loaded type — open forms/views/nav then reflect
+    // the new live world without a manual page reload (the chat-card "Publish"
+    // and Browse-page install paths do not reload, unlike the DraftPreviewBar).
+    // NOT gated to preview-drafts mode: the live world every tree reads changed.
+    useEffect(() => {
+        return subscribeMetadataRefresh(() => {
+            // The adapter keeps its OWN object-schema cache (getObjectSchema) that the
+            // context refresh below does not touch. A publish/install just changed the
+            // live schema, so drop it too — otherwise create/edit forms (which read
+            // the adapter's getObjectSchema, NOT this context) keep showing the
+            // pre-publish field set until the adapter cache's 5-minute TTL lapses.
+            try {
+                adapterRef.current?.clearCache?.();
+            }
+            catch { /* adapter mid-swap */ }
+            void refresh();
+        });
+    }, [refresh]);
     const [initialLoading, setInitialLoading] = useState(true);
     const [initialError, setInitialError] = useState(null);
     useEffect(() => {
         let cancelled = false;
-        const cached = loadFromSession('app');
+        // Session-cached apps are PUBLISHED-world data — seeding them while in
+        // draft preview would flash the wrong universe before the fetch lands.
+        const cached = previewDrafts ? null : loadFromSession('app');
         if (cached) {
             const entry = getEntry('app');
             entry.items = cached;
@@ -334,7 +510,7 @@ export function MetadataProvider({ children, adapter, ttlMs = DEFAULT_TTL_MS })
         return () => {
             cancelled = true;
         };
-    }, [adapter, ensureType, getEntry, bump]);
+    }, [adapter, ensureType, getEntry, bump, previewDrafts]);
     const value = useMemo(() => {
         void version;
         const readType = (type) => {
@@ -350,7 +526,8 @@ export function MetadataProvider({ children, adapter, ttlMs = DEFAULT_TTL_MS })
             get objects() {
                 const objs = readType(TYPE_BY_STATE_KEY.objects);
                 const views = readType('view');
-                return views.length ? mergeViewsIntoObjects(objs, views) : objs;
+                const merged = views.length ? mergeViewsIntoObjects(objs, views) : objs;
+                return attachInlineSubforms(merged);
             },
             get dashboards() {
                 return readType(TYPE_BY_STATE_KEY.dashboards);
@@ -368,6 +545,9 @@ export function MetadataProvider({ children, adapter, ttlMs = DEFAULT_TTL_MS })
             ensureType,
             getItem,
             getItemsByType,
+            // Pure read — must NOT kick a fetch, so render-phase status checks
+            // can't recurse into ensureType.
+            getTypeStatus: (type) => getEntry(type).status,
         };
         return base;
     }, [version, initialLoading, initialError, ensureType, getItem, getEntry, refresh, invalidate]);

package/dist/runtime-config.d.ts

@@ -9,8 +9,8 @@
  * those don't reflect the runtime the SPA is actually attached to (e.g.
  * a tenant ObjectOS runtime pointing at a separate cloud control plane).
  *
- * Mirrors `apps/studio/src/lib/config.ts` but lives in app-shell because
- * the Console SPA in `apps/console` consumes app-shell code.
+ * The runtime-config shape lives in app-shell because the Console SPA in
+ * `apps/console` consumes app-shell code.
  *
  * Server-side: see
  *   cloud/packages/service-cloud/src/multi-environment-plugins.ts
@@ -22,6 +22,41 @@ export interface RuntimeFeatures {
     installLocal: boolean;
     /** `/api/v1/marketplace/*` is reachable from this runtime. */
     marketplace: boolean;
+    /**
+     * AI-driven metadata authoring ("online development") is offered by this
+     * runtime. Default true; the capability is still gated server-side by the
+     * presence of the metadata-authoring agent. When false, the SPA hides the
+     * AI authoring affordances (generic data-chat assistant is unaffected).
+     */
+    aiStudio: boolean;
+    /**
+     * Auto-publish AI-built apps in the author's own environment. When true, the
+     * Studio chat fires the publish-drafts call automatically the moment the
+     * agent drafts an app, so the user refreshes and sees it live WITH its sample
+     * data — no manual "go home and publish" step. Server-derived from the plan
+     * (env-revertible via `OS_AI_AUTOPUBLISH_DISABLED`). Default true.
+     */
+    autoPublishAiBuilds: boolean;
+    /**
+     * Branded subdomains + custom (BYO-DNS) domains are available on this
+     * environment's plan. Optional commercial flag — absent on self-hosted /
+     * vanilla runtimes (treated as off). When false the SPA hides custom-domain
+     * settings (or shows them as an upgrade affordance). Server-derived from the
+     * plan entitlements (cloud ADR-0011/0012).
+     */
+    customDomain?: boolean;
+    /**
+     * SSO / SAML enterprise login is available on this environment's plan.
+     * Optional commercial flag — absent on self-hosted / vanilla runtimes
+     * (treated as off). Server-derived from the plan entitlements.
+     */
+    sso?: boolean;
+}
+export interface RuntimeBranding {
+    /** Product name shown in browser title, splash, account chrome. */
+    productName: string;
+    /** Short variant for PWA shortName / compact spots. */
+    productShortName: string;
 }
 export interface RuntimeConfig {
     /**
@@ -35,6 +70,7 @@ export interface RuntimeConfig {
     defaultOrgId?: string | null;
     defaultEnvironmentId?: string | null;
     features: RuntimeFeatures;
+    branding: RuntimeBranding;
 }
 /**
  * Fetch the server-pushed runtime config and merge it into the singleton.
@@ -49,6 +85,14 @@ export interface RuntimeConfig {
 export declare function initRuntimeConfig(baseUrl?: string): Promise<void>;
 /** Read-only accessor. Returns the current snapshot. */
 export declare function getRuntimeConfig(): RuntimeConfig;
+/**
+ * Product name shown in browser title, splash, account chrome.
+ * Falls back to `'ObjectOS'` when the server hasn't been contacted yet.
+ * Operators override via `OS_PRODUCT_NAME` env var or
+ * `new RuntimeConfigPlugin({ productName: 'Acme Studio' })`.
+ */
+export declare function getProductName(): string;
+export declare function getProductShortName(): string;
 /** Whether `initRuntimeConfig()` has run at least once. */
 export declare function isRuntimeConfigInitialised(): boolean;
 /**

package/dist/runtime-config.js

@@ -4,7 +4,8 @@ const defaults = {
     singleEnvironment: false,
     defaultOrgId: null,
     defaultEnvironmentId: null,
-    features: { installLocal: false, marketplace: true },
+    features: { installLocal: false, marketplace: true, aiStudio: true, autoPublishAiBuilds: true, customDomain: false, sso: false },
+    branding: { productName: 'ObjectOS', productShortName: 'ObjectOS' },
 };
 let current = { ...defaults };
 let initialised = false;
@@ -17,6 +18,10 @@ function applyUpdate(patch) {
             ...current.features,
             ...(patch.features ?? {}),
         },
+        branding: {
+            ...current.branding,
+            ...(patch.branding ?? {}),
+        },
     };
 }
 /**
@@ -50,8 +55,24 @@ export async function initRuntimeConfig(baseUrl = '') {
                 ? {
                     installLocal: !!body.features.installLocal,
                     marketplace: body.features.marketplace !== false,
+                    aiStudio: body.features.aiStudio !== false,
+                    autoPublishAiBuilds: body.features.autoPublishAiBuilds !== false,
+                    // Commercial flags default OFF unless the server explicitly grants
+                    // them — never show a paid surface on an unknown/older runtime.
+                    customDomain: body.features.customDomain === true,
+                    sso: body.features.sso === true,
                 }
                 : current.features,
+            branding: body.branding
+                ? {
+                    productName: typeof body.branding.productName === 'string' && body.branding.productName.trim()
+                        ? body.branding.productName.trim()
+                        : current.branding.productName,
+                    productShortName: typeof body.branding.productShortName === 'string' && body.branding.productShortName.trim()
+                        ? body.branding.productShortName.trim()
+                        : current.branding.productShortName,
+                }
+                : current.branding,
         });
     }
     catch {
@@ -66,6 +87,18 @@ export async function initRuntimeConfig(baseUrl = '') {
 export function getRuntimeConfig() {
     return current;
 }
+/**
+ * Product name shown in browser title, splash, account chrome.
+ * Falls back to `'ObjectOS'` when the server hasn't been contacted yet.
+ * Operators override via `OS_PRODUCT_NAME` env var or
+ * `new RuntimeConfigPlugin({ productName: 'Acme Studio' })`.
+ */
+export function getProductName() {
+    return current.branding?.productName || 'ObjectOS';
+}
+export function getProductShortName() {
+    return current.branding?.productShortName || getProductName();
+}
 /** Whether `initRuntimeConfig()` has run at least once. */
 export function isRuntimeConfigInitialised() {
     return initialised;
@@ -81,6 +114,10 @@ export function getCloudBase() {
 }
 /** Test/dev helper. */
 export function resetRuntimeConfigForTesting() {
-    current = { ...defaults, features: { ...defaults.features } };
+    current = {
+        ...defaults,
+        features: { ...defaults.features },
+        branding: { ...defaults.branding },
+    };
     initialised = false;
 }

package/dist/services/builtinComponents.js

@@ -1,4 +1,3 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
 /**
  * Built-in component registrations — Phase 3b + 3c.
@@ -7,21 +6,18 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * own admin UI is registered with the ComponentRegistry before
  * AppContent mounts the first `<Route path="component/...">`.
  *
- * Plugins follow the same pattern: their package entry point imports
- * a similar registration module, so `import '@object-ui/plugin-foo'`
- * is enough to make the plugin's component refs reachable from app
- * metadata.
- *
- * Phase 3c — also registers the new generic metadata admin engine and
- * pre-wires specialised editors for `object` and `field` so admins
- * still get the polished ObjectManager / FieldDesigner experience
- * inside the unified Setup-app shell.
+ * Registers the generic metadata admin engine and a specialised
+ * permission-matrix editor for `permission`. The previous View /
+ * Dashboard / Page bespoke "designer" tabs were removed: they never
+ * produced usable output and confused authors. Those types now use the
+ * same JSONSchema-driven Form + Preview experience as every other
+ * metadata type.
  */
-import { lazy, Suspense } from 'react';
 import { registerAppComponent } from './componentRegistry';
 import { MetadataDirectoryPage, MetadataResourceRouter, registerMetadataResource, } from '../views/metadata-admin';
 import { PermissionMatrixEditPage } from '../views/metadata-admin/PermissionMatrixEditor';
-import { DesignerEditorBody } from '../views/metadata-admin/DesignerEditorWrapper';
+import { PackagesPage } from '../views/metadata-admin/PackagesPage';
+import { isAggregatedViewContainer, viewDisplayType, } from '../views/metadata-admin/view-item-normalize';
 /* -------------------------------------------------------------------------- */
 /* 1) Top-level admin pages — bound to `metadata:directory` + `metadata:resource` */
 /* -------------------------------------------------------------------------- */
@@ -35,18 +31,16 @@ registerAppComponent({
     ref: 'metadata:resource',
     label: 'Metadata Resource',
     source: '@object-ui/app-shell',
-    // The router switches between list / new / edit / history based on
-    // the sub-path under `/component/metadata/resource/...`.
     component: MetadataResourceRouter,
 });
+registerAppComponent({
+    ref: 'developer:packages',
+    label: 'Packages',
+    source: '@object-ui/app-shell',
+    component: PackagesPage,
+});
 /* -------------------------------------------------------------------------- */
-/* 2) Specialised editors for flagship types — opt the generic engine        */
-/*    out for the types that already have polished bespoke surfaces.         */
-/*                                                                            */
-/*    Note: `object` and `field` intentionally use the generic engine so the */
-/*    Metadata Directory has a consistent list/edit experience across every  */
-/*    type (only `permission`, `view`, `dashboard`, `page` keep bespoke      */
-/*    editors below — those are visual designers, not list/form pages).      */
+/* 2) Generic resources — list + JSONSchema-driven form for every type.       */
 /* -------------------------------------------------------------------------- */
 registerMetadataResource({
     type: 'object',
@@ -96,58 +90,42 @@ registerMetadataResource({
     ],
 });
 /* -------------------------------------------------------------------------- */
-/* 4) Bespoke designers wired through DesignerEditorWrapper (Phase 3d).      */
-/*    These types continue to use the generic AutoForm-style list and        */
-/*    history pages but swap the edit page for the existing visual designer. */
+/* 4) UI metadata types — list + form. No bespoke visual designers: views,   */
+/*    dashboards and pages are authored as JSON metadata; the Preview tab    */
+/*    renders them live for verification.                                    */
 /* -------------------------------------------------------------------------- */
-const ObjectViewConfigurator = lazy(() => import('@object-ui/plugin-designer').then((m) => ({ default: m.ObjectViewConfigurator })));
-const DashboardEditor = lazy(() => import('@object-ui/plugin-designer').then((m) => ({ default: m.DashboardEditor })));
-const PageCanvasEditor = lazy(() => import('@object-ui/plugin-designer').then((m) => ({ default: m.PageCanvasEditor })));
-function ViewEditPage(props) {
-    return (_jsx(DesignerEditorBody, { ...props, fromMetadata: (raw) => {
-            // Normalize backend view metadata into the shape ObjectViewConfigurator expects.
-            // Built-in views may omit `columns` or use legacy field names.
-            const base = raw && typeof raw === 'object' ? raw : {};
-            return {
-                viewType: base.viewType ?? base.type ?? 'grid',
-                columns: Array.isArray(base.columns) ? base.columns : [],
-                filters: Array.isArray(base.filters) ? base.filters : [],
-                sorts: Array.isArray(base.sorts) ? base.sorts : [],
-                pageSize: typeof base.pageSize === 'number' ? base.pageSize : 25,
-                ...base,
-            };
-        }, renderDesigner: (value, onChange, readOnly) => (_jsx(Suspense, { fallback: _jsx(DesignerFallback, { label: "view designer" }), children: _jsx(ObjectViewConfigurator, { config: value, onChange: (next) => onChange(next), readOnly: readOnly }) })) }));
-}
-function DashboardEditPage(props) {
-    return (_jsx(DesignerEditorBody, { ...props, renderDesigner: (value, onChange, readOnly) => (_jsx(Suspense, { fallback: _jsx(DesignerFallback, { label: "dashboard editor" }), children: _jsx(DashboardEditor, { schema: value, onChange: (next) => onChange(next), readOnly: readOnly }) })) }));
-}
-function PageEditPage(props) {
-    return (_jsx(DesignerEditorBody, { ...props, renderDesigner: (value, onChange, readOnly) => (_jsx(Suspense, { fallback: _jsx(DesignerFallback, { label: "page canvas" }), children: _jsx(PageCanvasEditor, { schema: value, onChange: (next) => onChange(next), readOnly: readOnly }) })) }));
-}
-function DesignerFallback({ label }) {
-    return (_jsxs("div", { className: "p-6 text-sm text-muted-foreground", children: ["Loading ", label, "\u2026"] }));
-}
 registerMetadataResource({
     type: 'view',
     label: 'Views',
     description: 'Saved list / kanban / calendar / gantt configurations on top of an object.',
     domain: 'ui',
-    DesignerTab: ViewEditPage,
-    designerTabLabel: 'View designer',
     listColumns: [
         { key: 'name', label: 'Name', width: '30%' },
         { key: 'object', label: 'Object', width: '20%' },
-        { key: 'type', label: 'Type', width: '15%' },
+        {
+            key: 'type',
+            label: 'Type',
+            width: '15%',
+            // Expanded ViewItems keep their display type under `config.type`
+            // and only the list/form family at the top level — derive it so the
+            // column shows "calendar" / "grid" / "form" instead of "—".
+            render: (_v, item) => viewDisplayType(item) ?? '—',
+        },
         { key: 'label', label: 'Label' },
     ],
+    // ADR-0017 — the framework exposes each view as a canonical first-class
+    // ViewItem ({ name, object, viewKind, label, config }). The inspector and
+    // preview read that shape directly (`draft.config`), so NO toDraft/fromDraft
+    // adapter is wired here — the canonical shape round-trips untouched.
+    // Hide the bare aggregated container the framework keeps for runtime
+    // dual-read — its views are already listed as expanded ViewItems.
+    listFilter: (item) => !isAggregatedViewContainer(item),
 });
 registerMetadataResource({
     type: 'dashboard',
     label: 'Dashboards',
     description: 'Composed dashboards with charts, KPIs, and tables.',
     domain: 'ui',
-    DesignerTab: DashboardEditPage,
-    designerTabLabel: 'Dashboard designer',
     listColumns: [
         { key: 'name', label: 'Name', width: '30%' },
         { key: 'label', label: 'Label', width: '30%' },
@@ -157,13 +135,44 @@ registerMetadataResource({
 registerMetadataResource({
     type: 'page',
     label: 'Pages',
-    description: 'Visual page layouts authored in the Page Canvas editor.',
+    description: 'Visual page layouts authored as JSON metadata.',
     domain: 'ui',
-    DesignerTab: PageEditPage,
-    designerTabLabel: 'Page canvas',
     listColumns: [
         { key: 'name', label: 'Name', width: '30%' },
         { key: 'label', label: 'Label', width: '30%' },
         { key: 'route', label: 'Route' },
     ],
 });
+/* -------------------------------------------------------------------------- */
+/* 5) Documentation — the `book` navigation spine (ADR-0046 §6). A book is an  */
+/*    ordered set of groups whose membership over docs is DERIVED from each    */
+/*    group's include rule; the Preview tab renders that spine for authoring.  */
+/* -------------------------------------------------------------------------- */
+registerMetadataResource({
+    type: 'book',
+    label: 'Documentation Books',
+    description: 'Documentation navigation spine — ordered groups with membership derived over docs (glob/tag rules), plus an explicit pages override for curated order.',
+    domain: 'system',
+    searchableFields: ['name', 'label', 'description', 'slug'],
+    listColumns: [
+        { key: 'name', label: 'Name', width: '25%' },
+        { key: 'label', label: 'Label', width: '25%' },
+        {
+            key: 'audience',
+            label: 'Audience',
+            width: '12%',
+            render: (v) => v == null
+                ? 'org'
+                : typeof v === 'object' && v && 'profile' in v
+                    ? `profile: ${v.profile}`
+                    : String(v),
+        },
+        {
+            key: 'groups',
+            label: 'Groups',
+            width: '10%',
+            render: (v) => (Array.isArray(v) ? String(v.length) : '0'),
+        },
+        { key: 'description', label: 'Description' },
+    ],
+});

package/dist/skeletons/SkeletonDashboard.d.ts

@@ -9,5 +9,5 @@ interface SkeletonDashboardProps {
     /** Number of widget cards to render */
     cards?: number;
 }
-export declare function SkeletonDashboard({ cards }: SkeletonDashboardProps): import("react/jsx-runtime").JSX.Element;
+export declare function SkeletonDashboard({ cards }: SkeletonDashboardProps): import("react").JSX.Element;
 export {};

package/dist/skeletons/SkeletonDetail.d.ts

@@ -11,5 +11,5 @@ interface SkeletonDetailProps {
     /** Number of columns */
     columns?: number;
 }
-export declare function SkeletonDetail({ fields, columns }: SkeletonDetailProps): import("react/jsx-runtime").JSX.Element;
+export declare function SkeletonDetail({ fields, columns }: SkeletonDetailProps): import("react").JSX.Element;
 export {};

package/dist/skeletons/SkeletonGrid.d.ts

@@ -11,5 +11,5 @@ interface SkeletonGridProps {
     /** Number of columns to render */
     columns?: number;
 }
-export declare function SkeletonGrid({ rows, columns }: SkeletonGridProps): import("react/jsx-runtime").JSX.Element;
+export declare function SkeletonGrid({ rows, columns }: SkeletonGridProps): import("react").JSX.Element;
 export {};