@object-ui/app-shell 6.2.3 → 7.1.0

package/dist/preview/PreviewDraftEmptyState.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * ADR-0037 — the draft preview's own empty/error states.
+ *
+ * A `?preview=draft` tree (the Live Canvas iframe, or a hand-opened preview
+ * URL) must NEVER fall through to the console's generic "No Apps Configured"
+ * screen: that screen tells the user nothing exists and offers "Create Your
+ * First App" — both wrong and disorienting inside a preview of an app the AI
+ * just drafted. Preview has exactly three honest non-happy states, all
+ * rendered here:
+ *
+ *  - loading failed   → say so, offer Retry (the overlay read errored);
+ *  - app not in draft → the build likely failed or hasn't run — point the
+ *                       user back to the conversation, never to "create app";
+ *  - nothing drafted  → same message, generic (no app name in the URL).
+ *
+ * Deliberately CTA-free beyond Retry: the preview is a window owned by the
+ * build conversation; every corrective action lives there.
+ */
+import { Eye, RefreshCw, TriangleAlert } from 'lucide-react';
+import { Empty, EmptyTitle, EmptyDescription, Button } from '@object-ui/components';
+import { useObjectTranslation } from '@object-ui/i18n';
+export function PreviewDraftEmptyState({ appName, error, onRetry }) {
+    const { t } = useObjectTranslation();
+    const failed = Boolean(error);
+    return (_jsx("div", { className: "flex h-screen items-center justify-center", "data-testid": "preview-draft-empty-state", children: _jsxs(Empty, { children: [_jsx("div", { className: "mb-2 flex justify-center text-muted-foreground", "aria-hidden": "true", children: failed ? _jsx(TriangleAlert, { className: "h-8 w-8" }) : _jsx(Eye, { className: "h-8 w-8" }) }), _jsx(EmptyTitle, { children: failed
+                        ? t('preview.empty.loadFailedTitle', { defaultValue: 'Draft preview failed to load' })
+                        : appName
+                            ? t('preview.empty.notReadyTitle', {
+                                app: appName,
+                                defaultValue: '“{{app}}” isn’t in the draft yet',
+                            })
+                            : t('preview.empty.nothingTitle', { defaultValue: 'Nothing to preview yet' }) }), _jsx(EmptyDescription, { children: failed
+                        ? t('preview.empty.loadFailedDescription', {
+                            defaultValue: 'The draft overlay could not be read. Retry, or check your connection.',
+                        })
+                        : t('preview.empty.notReadyDescription', {
+                            defaultValue: 'The build may still be running, or it may have failed before this app was staged. Check the conversation for the build status — this pane refreshes as drafts land.',
+                        }) }), _jsx("div", { className: "mt-4 flex justify-center", children: _jsxs(Button, { variant: "outline", onClick: onRetry, "data-testid": "preview-draft-retry", children: [_jsx(RefreshCw, { className: "mr-1.5 h-3.5 w-3.5" }), t('preview.empty.retry', { defaultValue: 'Retry' })] }) })] }) }));
+}

package/dist/preview/PreviewModeContext.d.ts

@@ -0,0 +1,57 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * ADR-0037 Live Canvas — preview mode plumbing.
+ *
+ * One URL flag (`?preview=draft`) flips the whole renderer tree into
+ * "as-if-published" mode: metadata reads overlay pending ADR-0033 drafts on
+ * the active registry, so an unpublished app/view/dashboard renders exactly
+ * what Publish would make real. The canvas (and the Preview button in chat)
+ * navigate with this flag; everything below just reads the context.
+ *
+ * Read-only by design: preview changes the SOURCE of metadata reads, never
+ * writes, and Publish remains the single commit gate.
+ */
+import { type ReactNode } from 'react';
+/** Query flag that switches the console into draft-preview mode. */
+export declare const PREVIEW_QUERY_FLAG = "preview";
+export declare const PREVIEW_QUERY_VALUE = "draft";
+/** True when `search` (a `location.search` string) carries `preview=draft`. */
+export declare function isPreviewSearch(search: string): boolean;
+/**
+ * Declare that the NEXT navigation is an intentional exit from draft preview.
+ * Call right before navigating away (e.g. the preview bar's Exit button);
+ * without it, the sticky keeper re-applies `?preview=draft` to in-app
+ * navigation so a click inside the previewed app can't silently drop the
+ * draft world mid-session.
+ */
+export declare function markPreviewExit(): void;
+/**
+ * Provides the preview-mode flag to the tree. Reads the router location
+ * LIVE, so entering/leaving `?preview=draft` flips consumers without a
+ * remount. `force` overrides the URL — the Live Canvas mounts its embedded
+ * renderer subtree with `force` so the canvas is always a draft window
+ * regardless of the host page's own URL.
+ *
+ * STICKY by design: preview is URL-keyed, but in-app navigation (the app's
+ * landing redirect, sidebar links, row clicks) builds URLs without the
+ * query string. Once the tree is in preview, this provider re-applies the
+ * flag (history REPLACE, no extra entry) to any same-session navigation
+ * that lost it — so the only way out of the draft world is the explicit
+ * Exit affordance ({@link markPreviewExit}), never an accidental click.
+ */
+export declare function PreviewModeProvider({ force, children }: {
+    force?: boolean;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * Whether the current tree renders the draft-overlaid world. Defaults to
+ * false outside a provider, so surfaces that never mount preview (login,
+ * bare pages) keep reading published metadata only.
+ */
+export declare function usePreviewDrafts(): boolean;

package/dist/preview/PreviewModeContext.js

@@ -0,0 +1,99 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * ADR-0037 Live Canvas — preview mode plumbing.
+ *
+ * One URL flag (`?preview=draft`) flips the whole renderer tree into
+ * "as-if-published" mode: metadata reads overlay pending ADR-0033 drafts on
+ * the active registry, so an unpublished app/view/dashboard renders exactly
+ * what Publish would make real. The canvas (and the Preview button in chat)
+ * navigate with this flag; everything below just reads the context.
+ *
+ * Read-only by design: preview changes the SOURCE of metadata reads, never
+ * writes, and Publish remains the single commit gate.
+ */
+import { createContext, useContext, useEffect, useMemo, useState } from 'react';
+import { useLocation, useNavigate } from 'react-router-dom';
+const PreviewModeContext = createContext(false);
+/** Query flag that switches the console into draft-preview mode. */
+export const PREVIEW_QUERY_FLAG = 'preview';
+export const PREVIEW_QUERY_VALUE = 'draft';
+/** True when `search` (a `location.search` string) carries `preview=draft`. */
+export function isPreviewSearch(search) {
+    return new URLSearchParams(search).get(PREVIEW_QUERY_FLAG) === PREVIEW_QUERY_VALUE;
+}
+// Set by markPreviewExit() for exactly one navigation: the user explicitly
+// left preview (DraftPreviewBar's Exit / post-publish), so the keeper below
+// must NOT re-stick the flag onto the next location.
+let previewExitRequested = false;
+/**
+ * Declare that the NEXT navigation is an intentional exit from draft preview.
+ * Call right before navigating away (e.g. the preview bar's Exit button);
+ * without it, the sticky keeper re-applies `?preview=draft` to in-app
+ * navigation so a click inside the previewed app can't silently drop the
+ * draft world mid-session.
+ */
+export function markPreviewExit() {
+    previewExitRequested = true;
+}
+/**
+ * Provides the preview-mode flag to the tree. Reads the router location
+ * LIVE, so entering/leaving `?preview=draft` flips consumers without a
+ * remount. `force` overrides the URL — the Live Canvas mounts its embedded
+ * renderer subtree with `force` so the canvas is always a draft window
+ * regardless of the host page's own URL.
+ *
+ * STICKY by design: preview is URL-keyed, but in-app navigation (the app's
+ * landing redirect, sidebar links, row clicks) builds URLs without the
+ * query string. Once the tree is in preview, this provider re-applies the
+ * flag (history REPLACE, no extra entry) to any same-session navigation
+ * that lost it — so the only way out of the draft world is the explicit
+ * Exit affordance ({@link markPreviewExit}), never an accidental click.
+ */
+export function PreviewModeProvider({ force, children }) {
+    const location = useLocation();
+    const navigate = useNavigate();
+    const fromUrl = useMemo(() => isPreviewSearch(location.search), [location.search]);
+    // Sticky state: stays true across the flag-less navigation window so the
+    // CONTEXT VALUE never flickers false mid-session. A flicker is not benign —
+    // it swaps the whole metadata source to published for one render, which
+    // (a) wastes a full refetch and (b) feeds cross-world diffs to effects
+    // like NavigationSyncEffect that must never see the two worlds as one
+    // timeline (that misread once WROTE nav changes from inside a preview).
+    const [sticky, setSticky] = useState(fromUrl);
+    useEffect(() => {
+        if (fromUrl) {
+            setSticky(true);
+            previewExitRequested = false;
+            return;
+        }
+        if (!sticky)
+            return;
+        if (previewExitRequested) {
+            previewExitRequested = false;
+            setSticky(false);
+            return;
+        }
+        // In-app navigation lost the flag without an explicit exit — restore it
+        // in place (history REPLACE, no extra entry) so a refresh/share of the
+        // URL stays in the draft world too.
+        const params = new URLSearchParams(location.search);
+        params.set(PREVIEW_QUERY_FLAG, PREVIEW_QUERY_VALUE);
+        navigate(`${location.pathname}?${params.toString()}${location.hash}`, { replace: true });
+    }, [fromUrl, sticky, location.pathname, location.search, location.hash, navigate]);
+    return (_jsx(PreviewModeContext.Provider, { value: force ?? (fromUrl || sticky), children: children }));
+}
+/**
+ * Whether the current tree renders the draft-overlaid world. Defaults to
+ * false outside a provider, so surfaces that never mount preview (login,
+ * bare pages) keep reading published metadata only.
+ */
+export function usePreviewDrafts() {
+    return useContext(PreviewModeContext);
+}

package/dist/preview/UnpublishedAppBar.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare function UnpublishedAppBar(): import("react").JSX.Element | null;

package/dist/preview/UnpublishedAppBar.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * ADR-0045 — the "unpublished app" banner. Renders while the CURRENT app is
+ * materialized-but-unlisted (`app.hidden === true`): the app is fully real —
+ * tables, data, interactions — but end users can't see it (launchers exclude
+ * it; the REST gate strips it for non-builders). The banner narrates that
+ * state and offers the one action that matters: Publish, which simply flips
+ * visibility (`hidden: false`) — instant and reversible, per ADR-0045.
+ *
+ * Sibling of DraftPreviewBar (the ADR-0037 draft-overlay watermark): that bar
+ * owns mutation preview (`?preview=draft`); this one owns the materialize
+ * regime. In preview mode this bar yields — the draft bar already narrates.
+ */
+import { useState } from 'react';
+import { useLocation, useParams } from 'react-router-dom';
+import { EyeOff, History, Rocket } from 'lucide-react';
+import { toast } from 'sonner';
+import { Button } from '@object-ui/components';
+import { useObjectTranslation } from '@object-ui/i18n';
+import { useMetadata } from '../providers/MetadataProvider';
+import { matchAppBySegment } from '../utils/appRoute';
+import { CommitTimeline } from './CommitTimeline';
+import { usePreviewDrafts } from './PreviewModeContext';
+export function UnpublishedAppBar() {
+    const preview = usePreviewDrafts();
+    const { appName } = useParams();
+    const location = useLocation();
+    const { apps, refresh } = useMetadata();
+    const { t } = useObjectTranslation();
+    const [publishing, setPublishing] = useState(false);
+    const [historyOpen, setHistoryOpen] = useState(false);
+    // The draft-preview watermark owns the preview tree; never stack both bars.
+    if (preview)
+        return null;
+    const routeApp = appName ?? location.pathname.match(/\/apps\/([^/?#]+)/)?.[1];
+    if (!routeApp)
+        return null;
+    const app = matchAppBySegment(apps ?? [], routeApp);
+    if (!app || app.hidden !== true)
+        return null;
+    // ADR-0067 — the package this app belongs to keys its commit timeline.
+    const packageId = app?.packageId ?? app?._packageId ?? null;
+    const publish = async () => {
+        setPublishing(true);
+        try {
+            // Publish = the ADR-0045 visibility flip: one metadata write, no
+            // lifecycle machinery. Body is the full current app with hidden:false
+            // (the meta save endpoint replaces the overlay row).
+            const res = await fetch(`/api/v1/meta/app/${encodeURIComponent(routeApp)}`, {
+                method: 'PUT',
+                credentials: 'include',
+                headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+                body: JSON.stringify({ ...app, hidden: false }),
+            });
+            if (!res.ok) {
+                const payload = await res.json().catch(() => null);
+                throw new Error(payload?.error?.message ?? payload?.error ?? `HTTP ${res.status}`);
+            }
+            toast.success(t('preview.unpublishedBar.published', {
+                defaultValue: 'Published! The app is now visible to your users.',
+            }));
+            refresh?.();
+        }
+        catch (e) {
+            toast.error(`${t('preview.unpublishedBar.publishFailed', { defaultValue: 'Publish failed' })}: ${e.message}`);
+        }
+        finally {
+            setPublishing(false);
+        }
+    };
+    return (_jsxs(_Fragment, { children: [_jsxs("div", { className: "sticky top-0 z-40 flex items-center gap-3 border-b border-amber-300/70 bg-amber-50 px-4 py-2 text-sm text-amber-900 dark:border-amber-700/60 dark:bg-amber-950/40 dark:text-amber-200", "data-testid": "unpublished-app-bar", children: [_jsx(EyeOff, { className: "h-4 w-4 shrink-0" }), _jsx("p", { className: "min-w-0 flex-1 truncate", children: t('preview.unpublishedBar.message', {
+                            defaultValue: 'Unpublished app — fully functional, but only builders can see it. Publish to make it visible to your users.',
+                        }) }), packageId ? (_jsxs(Button, { size: "sm", variant: "outline", onClick: () => setHistoryOpen(true), "data-testid": "unpublished-app-history", children: [_jsx(History, { className: "mr-1 h-3.5 w-3.5" }), t('preview.history.button', { defaultValue: 'History' })] })) : null, _jsxs(Button, { size: "sm", onClick: publish, disabled: publishing, "data-testid": "unpublished-app-publish", children: [_jsx(Rocket, { className: "mr-1 h-3.5 w-3.5" }), publishing
+                                ? t('preview.unpublishedBar.publishing', { defaultValue: 'Publishing…' })
+                                : t('preview.unpublishedBar.publish', { defaultValue: 'Publish' })] })] }), packageId ? (_jsx(CommitTimeline, { open: historyOpen, onOpenChange: setHistoryOpen, packageId: packageId, onReverted: refresh })) : null] }));
+}

package/dist/preview/commitHistory.d.ts

@@ -0,0 +1,28 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * ADR-0067 — package-scoped commit history reads/writes for the timeline.
+ *
+ * Each AI build (and Studio batch) lands as one revertible COMMIT on top of
+ * the metadata history. The history-not-confirm model: you don't approve each
+ * publish — you review this timeline and revert if a change was wrong. These
+ * helpers read the timeline (`GET /packages/:id/commits`) and revert one
+ * commit (`POST /packages/:id/commits/:cid/revert`). Cookie-authenticated like
+ * every console call; tolerant of the `{ data: ... }` / bare envelope shapes.
+ */
+export interface CommitEntry {
+    id: string;
+    operation: 'apply' | 'revert';
+    message?: string;
+    actor?: string;
+    aiModel?: string;
+    itemCount: number;
+    createdAt?: string;
+}
+export declare function fetchCommits(packageId: string): Promise<CommitEntry[]>;
+export declare function revertCommit(packageId: string, commitId: string): Promise<void>;

package/dist/preview/commitHistory.js

@@ -0,0 +1,48 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export async function fetchCommits(packageId) {
+    const res = await fetch(`/api/v1/packages/${encodeURIComponent(packageId)}/commits`, {
+        credentials: 'include',
+        headers: { Accept: 'application/json' },
+        cache: 'no-store',
+    });
+    if (!res.ok)
+        throw new Error(`commits HTTP ${res.status}`);
+    const data = (await res.json());
+    const list = Array.isArray(data)
+        ? data
+        : data?.commits ??
+            data?.data?.commits ??
+            [];
+    return (Array.isArray(list) ? list : []).map((raw) => {
+        const c = raw;
+        return {
+            id: String(c.id),
+            operation: c.operation === 'revert' ? 'revert' : 'apply',
+            message: typeof c.message === 'string' ? c.message : undefined,
+            actor: typeof c.actor === 'string' ? c.actor : undefined,
+            aiModel: typeof c.aiModel === 'string' ? c.aiModel : undefined,
+            itemCount: typeof c.itemCount === 'number' ? c.itemCount : 0,
+            createdAt: typeof c.createdAt === 'string' ? c.createdAt : undefined,
+        };
+    });
+}
+export async function revertCommit(packageId, commitId) {
+    const res = await fetch(`/api/v1/packages/${encodeURIComponent(packageId)}/commits/${encodeURIComponent(commitId)}/revert`, {
+        method: 'POST',
+        credentials: 'include',
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+        body: '{}',
+    });
+    const payload = (await res.json().catch(() => null));
+    const inner = payload?.data ?? payload ?? undefined;
+    if (!res.ok || inner?.success === false) {
+        const err = payload?.error;
+        throw new Error((typeof err === 'object' ? err?.message : err) ?? `HTTP ${res.status}`);
+    }
+}

package/dist/preview/draftStatus.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Live draft-status read for the chat's draft cards (panel-as-source-of-truth,
+ * made literal): how many drafts are still PENDING in a package, straight from
+ * the ADR-0033 `_drafts` endpoint. The chat passes this to
+ * `fetchPendingDraftCount` so a card's Publish/Published affordance reflects
+ * the server's CURRENT state — across conversation reloads, other sessions'
+ * publishes, and later edits into the same package — instead of replaying the
+ * tool-result snapshot it was born with.
+ *
+ * Cookie-authenticated like every other console call; tolerant of both
+ * response shapes (`[...]` and `{ drafts: [...] }`).
+ */
+export declare function fetchPendingDraftCount(packageId: string): Promise<number>;

package/dist/preview/draftStatus.js

@@ -0,0 +1,27 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Live draft-status read for the chat's draft cards (panel-as-source-of-truth,
+ * made literal): how many drafts are still PENDING in a package, straight from
+ * the ADR-0033 `_drafts` endpoint. The chat passes this to
+ * `fetchPendingDraftCount` so a card's Publish/Published affordance reflects
+ * the server's CURRENT state — across conversation reloads, other sessions'
+ * publishes, and later edits into the same package — instead of replaying the
+ * tool-result snapshot it was born with.
+ *
+ * Cookie-authenticated like every other console call; tolerant of both
+ * response shapes (`[...]` and `{ drafts: [...] }`).
+ */
+export async function fetchPendingDraftCount(packageId) {
+    const res = await fetch(`/api/v1/meta/_drafts?packageId=${encodeURIComponent(packageId)}`, { credentials: 'include', headers: { Accept: 'application/json' }, cache: 'no-store' });
+    if (!res.ok)
+        throw new Error(`_drafts HTTP ${res.status}`);
+    const data = (await res.json());
+    const list = Array.isArray(data) ? data : data?.drafts ?? data?.data?.drafts ?? [];
+    return Array.isArray(list) ? list.length : 0;
+}

package/dist/preview/usePublishAllDrafts.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+type TranslateFn = (key: string, opts?: Record<string, unknown>) => string;
+export interface PublishAllResult {
+    ok: boolean;
+    /** Count of drafts the call attempted to publish. */
+    attempted: number;
+}
+export declare function usePublishAllDrafts(t: TranslateFn): {
+    publishAll: () => Promise<PublishAllResult>;
+    publishing: boolean;
+};
+export {};

package/dist/preview/usePublishAllDrafts.js

@@ -0,0 +1,106 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * One-click "publish everything pending" — shared by the Home pending-drafts
+ * banner and the ADR-0037 draft-preview bar, so both surfaces publish through
+ * the SAME governed path and report the SAME health.
+ *
+ * Package-bound drafts go through `POST /packages/:id/publish-drafts` — the
+ * path that orders structure-before-seeds server-side and runs the ADR-0038
+ * L3 runtime probes; findings surface as a loud warning toast instead of a
+ * blind "Published!". Package-less drafts fall back to by-reference publish
+ * (structure first, seeds last) so they never dead-end.
+ */
+import { useCallback, useState } from 'react';
+import { toast } from 'sonner';
+import { publishHealthFromResponse } from '@object-ui/plugin-chatbot';
+import { useMetadataClient } from '../views/metadata-admin/useMetadata';
+export function usePublishAllDrafts(t) {
+    const client = useMetadataClient();
+    const [publishing, setPublishing] = useState(false);
+    const publishAll = useCallback(async () => {
+        setPublishing(true);
+        try {
+            const pending = ((await client.listDrafts?.({})) || [])
+                .filter((d) => d && typeof d.type === 'string' && typeof d.name === 'string')
+                .map((d) => ({
+                type: d.type,
+                name: d.name,
+                packageId: typeof d.packageId === 'string' && d.packageId ? d.packageId : null,
+            }));
+            if (pending.length === 0) {
+                toast.info(t('home.pendingDrafts.nothing', { defaultValue: 'Nothing to publish.' }));
+                return { ok: true, attempted: 0 };
+            }
+            const packageIds = [...new Set(pending.map((d) => d.packageId).filter((p) => p !== null))];
+            const orphans = pending.filter((d) => d.packageId === null);
+            const seedProblems = [];
+            const probeProblems = [];
+            let seededRows = 0;
+            const recordHealth = (health) => {
+                if (!health)
+                    return;
+                if (health.seedError)
+                    seedProblems.push(health.seedError);
+                if (typeof health.seededRows === 'number')
+                    seededRows += health.seededRows;
+                for (const issue of health.issues ?? []) {
+                    if (issue.severity === 'error')
+                        probeProblems.push(issue.message);
+                }
+            };
+            for (const packageId of packageIds) {
+                const res = await fetch(`/api/v1/packages/${encodeURIComponent(packageId)}/publish-drafts`, {
+                    method: 'POST',
+                    credentials: 'include',
+                    headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+                    body: '{}',
+                });
+                const payload = await res.json().catch(() => null);
+                if (!res.ok || payload?.success === false) {
+                    throw new Error(payload?.error?.message || `HTTP ${res.status}`);
+                }
+                recordHealth(publishHealthFromResponse(payload));
+            }
+            const ordered = [
+                ...orphans.filter((d) => d.type !== 'seed'),
+                ...orphans.filter((d) => d.type === 'seed'),
+            ];
+            for (const d of ordered) {
+                const res = await client.publishDraft(d.type, d.name);
+                const seedApplied = res?.seedApplied;
+                if (seedApplied && seedApplied.success === false) {
+                    seedProblems.push(seedApplied.error ?? `${d.name}: sample data failed to load`);
+                }
+            }
+            if (probeProblems.length > 0) {
+                toast.warning(t('home.pendingDrafts.probeWarn', { defaultValue: 'Published, but verification found problems.' }), { description: probeProblems[0] });
+            }
+            else if (seedProblems.length > 0) {
+                toast.warning(t('home.pendingDrafts.seedWarn', { defaultValue: 'Published, but some sample data failed to load.' }), { description: seedProblems[0] });
+            }
+            else {
+                toast.success(seededRows > 0
+                    ? t('home.pendingDrafts.publishedVerified', {
+                        count: seededRows,
+                        defaultValue: 'Published & verified — {{count}} sample row(s) live.',
+                    })
+                    : t('home.pendingDrafts.published', { defaultValue: 'Published! Your changes are live.' }));
+            }
+            return { ok: true, attempted: pending.length };
+        }
+        catch (e) {
+            toast.error(`${t('home.pendingDrafts.publishFailed', { defaultValue: 'Publish failed' })}: ${e.message}`);
+            return { ok: false, attempted: 0 };
+        }
+        finally {
+            setPublishing(false);
+        }
+    }, [client, t]);
+    return { publishAll, publishing };
+}

package/dist/providers/AdapterProvider.d.ts

@@ -18,4 +18,4 @@ interface AdapterProviderProps {
  * Creates an ObjectStackAdapter, connects to the API, then provides it to children.
  * Shows nothing (returns null) until the adapter is ready.
  */
-export declare function AdapterProvider({ children, adapter: externalAdapter }: AdapterProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function AdapterProvider({ children, adapter: externalAdapter }: AdapterProviderProps): import("react").JSX.Element;

package/dist/providers/AdapterProvider.js

@@ -11,6 +11,7 @@ import { useState, useEffect } from 'react';
 import { ObjectStackAdapter } from '@object-ui/data-objectstack';
 import { createAuthenticatedFetch } from '@object-ui/auth';
 import { AdapterCtx } from '@object-ui/react';
+import { installSettleSignalGlobal, withSettleSignal } from '../observability/settleSignal';
 export { useAdapter } from '@object-ui/react';
 /**
  * Creates an ObjectStackAdapter, connects to the API, then provides it to children.
@@ -24,11 +25,15 @@ export function AdapterProvider({ children, adapter: externalAdapter }) {
             return;
         }
         let cancelled = false;
+        // Expose window.__objectui.{pendingRequests,idle,whenIdle} so an automated
+        // (AI) browser driver has one "is the app settled?" predicate (ADR-0054 C5).
+        installSettleSignalGlobal();
         async function init() {
             try {
                 const a = new ObjectStackAdapter({
                     baseUrl: import.meta.env.VITE_SERVER_URL || '',
-                    fetch: createAuthenticatedFetch(),
+                    // Count every outbound request in the global in-flight signal (C5).
+                    fetch: withSettleSignal(createAuthenticatedFetch()),
                     autoReconnect: true,
                     maxReconnectAttempts: 5,
                     reconnectDelay: 1000,

package/dist/providers/ExpressionProvider.d.ts

@@ -41,7 +41,7 @@ interface ExpressionProviderProps {
     data?: Record<string, any>;
     features?: Record<string, any>;
 }
-export declare function ExpressionProvider({ children, user, app, data, features }: ExpressionProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function ExpressionProvider({ children, user, app, data, features }: ExpressionProviderProps): React.JSX.Element;
 /**
  * Hook to access the expression context.
  * Returns the full context value or a default empty context.

package/dist/providers/MetadataProvider.d.ts

@@ -1,5 +1,5 @@
 import { type ReactNode } from 'react';
-import type { ObjectStackAdapter } from '@object-ui/data-objectstack';
+import { type ObjectStackAdapter } from '@object-ui/data-objectstack';
 import { useMetadata, type MetadataContextValue, type MetadataState } from '@object-ui/react';
 export type { MetadataState, MetadataContextValue };
 export { useMetadataItem } from '@object-ui/react';
@@ -10,7 +10,22 @@ interface MetadataProviderProps {
     adapter: ObjectStackAdapter;
     ttlMs?: number;
 }
-export declare function MetadataProvider({ children, adapter, ttlMs }: MetadataProviderProps): import("react/jsx-runtime").JSX.Element;
+/** Exported for tests — both metadata sources must normalize identically. */
+export declare function extractItems(res: unknown): any[];
+export declare function mergeViewsIntoObjects(objects: any[], views: any[]): any[];
+/**
+ * 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 declare function attachInlineSubforms(objects: any[]): any[];
+export declare function MetadataProvider({ children, adapter, ttlMs }: MetadataProviderProps): import("react").JSX.Element;
 export declare function useMetadataType(type: string): {
     items: any[];
     loading: boolean;