@object-ui/app-shell 5.1.1 → 5.3.0

package/CHANGELOG.md

@@ -1,5 +1,327 @@
 # @object-ui/app-shell — Changelog
 
+## 5.3.0
+
+### Minor Changes
+
+- efb4c00: feat(observability): Sentry integration + bundle splitting for production launch
+
+  **Sentry (opt-in via `VITE_SENTRY_DSN`)**
+  - New `initSentry()` / `captureError()` / `setSentryUser()` / `getSentry()`
+    helpers exported from `@object-ui/app-shell`.
+  - Dynamic-import design: when `VITE_SENTRY_DSN` is unset, `@sentry/react`
+    is **never fetched** — zero bundle cost for self-hosted users.
+  - `ErrorBoundary.componentDidCatch` now best-effort reports to Sentry.
+  - Console app calls `initSentry()` before React mount; never blocks first
+    paint.
+  - Configurable via:
+    - `VITE_SENTRY_DSN` — required to enable
+    - `VITE_SENTRY_ENVIRONMENT` — defaults to `MODE`
+    - `VITE_SENTRY_RELEASE` — defaults to `VITE_APP_VERSION`
+    - `VITE_SENTRY_TRACES_SAMPLE_RATE` — defaults to `0.1`
+    - `VITE_SENTRY_REPLAY=true` — opt-in to 10% on-error replay
+  - Sensitive URL params (`token`, `access_token`, `apiKey`, etc.) are
+    stripped from breadcrumb URLs before send.
+
+  **Bundle splitting**
+  - `plugin-dashboard` (8 component types) now lazy-registered via
+    `ComponentRegistry.registerLazy()` — only loads on dashboard pages.
+  - `plugin-dashboard` and `plugin-report` each get their own chunk
+    (previously merged into `plugins-views`).
+  - Net first-paint JS reduction: **~200 KB** when the user never visits a
+    dashboard or report page.
+  - New chunks: `plugin-dashboard` (119 K), `plugin-report` (92 K),
+    `vendor-sentry` (346 K raw / 97 K brotli, lazy).
+  - `plugins-views` shrinks 387 K → 180 K (now `plugin-list` + `plugin-detail` only).
+
+### Patch Changes
+
+- @object-ui/types@5.3.0
+- @object-ui/core@5.3.0
+- @object-ui/i18n@5.3.0
+- @object-ui/react@5.3.0
+- @object-ui/components@5.3.0
+- @object-ui/fields@5.3.0
+- @object-ui/layout@5.3.0
+- @object-ui/data-objectstack@5.3.0
+- @object-ui/auth@5.3.0
+- @object-ui/permissions@5.3.0
+- @object-ui/collaboration@5.3.0
+- @object-ui/providers@5.3.0
+
+## 5.2.1
+
+### Patch Changes
+
+- 9ccda28: security: force DOMPurify to `^3.4.5` via pnpm override
+
+  Resolves 8 moderate-severity GHSA advisories against the transitive
+  `dompurify@3.2.7` pulled in by `monaco-editor`. Vulnerabilities covered:
+  - SAFE_FOR_TEMPLATES bypass in RETURN_DOM mode
+  - FORBID_TAGS bypassed by function-based ADD_TAGS predicate
+  - Prototype Pollution to XSS via CUSTOM_ELEMENT_HANDLING fallback
+  - ADD_TAGS function-form short-circuit bypass of FORBID_TAGS
+  - ADD_ATTR predicate skipping URI validation
+  - USE_PROFILES prototype pollution enabling event handlers
+  - mutation-XSS via Re-Contextualization
+  - Generic XSS vector
+
+  No API changes; override is transparent to consumers.
+  - @object-ui/types@5.2.1
+  - @object-ui/core@5.2.1
+  - @object-ui/i18n@5.2.1
+  - @object-ui/react@5.2.1
+  - @object-ui/components@5.2.1
+  - @object-ui/fields@5.2.1
+  - @object-ui/layout@5.2.1
+  - @object-ui/data-objectstack@5.2.1
+  - @object-ui/auth@5.2.1
+  - @object-ui/permissions@5.2.1
+  - @object-ui/collaboration@5.2.1
+  - @object-ui/providers@5.2.1
+
+## 5.2.0
+
+### Minor Changes
+
+- 321294c: Cmd-K now shows recently viewed records in its empty state, sourced
+  from the existing cloud-synced `sys_user_preference` adapter (already
+  wired by `RecentItemsProvider` + `useTrackRouteAsRecent` +
+  `RecordDetailView`). Multi-device by construction: open a record on
+  laptop, see it in `⌘K → Recently viewed` on phone.
+  - Group renders only when input is empty (no competition with search).
+  - Limited to the 5 most recent record-type entries.
+  - New i18n key `console.commandPalette.recentRecords` (en + zh seeded;
+    other locales fall back to `defaultValue: "Recently viewed"`).
+
+- b2d1704: feat(cmdk): record search across objects in the Command Palette
+  - New `useRecordSearch` hook in `@object-ui/react` debounces a query, fans out
+    to `dataSource.find(name, { $search, $top })` across candidate objects, and
+    aggregates hits. Race-safe via a monotonic runId; per-object 404s are
+    silently dropped via `Promise.allSettled`.
+  - `CommandPalette` (`@object-ui/app-shell`) now accepts a `dataSource` prop;
+    when supplied, the palette renders a `Records` group at the top with hits
+    scoped to the active app's nav objects. Item `value` embeds the live query
+    so cmdk's client-side filter doesn't hide async results.
+  - Added `console.commandPalette.records` i18n key (`Records` / `记录`).
+
+- 921bd28: Console now honors `App.homePageId` for the bare `/console/apps/:appName`
+  landing route. Previously it always redirected to the first reachable nav
+  item, so CRM-style apps with KPI dashboards still landed users on the
+  first object list (e.g. Leads) rather than the configured home page.
+
+  The new `resolveLandingRoute` looks up the `homePageId` nav item, builds
+  its route (object / view / page / dashboard / report), and falls back to
+  the existing `findFirstRoute` only when no `homePageId` is set or it
+  resolves to a routeless item type.
+
+- 3ebba63: Fix silent blank page on shorthand record deep-links.
+
+  Three related fixes that all addressed the same UX: a user follows a URL
+  shaped `/{object}/{recordId}` and sees a completely blank content area.
+  1. **`useNavigationOverlay` produced the broken URL itself.** When
+     middle-click / Cmd-click opened a gallery card in a new tab and no
+     `onNavigate` was provided, the hook built `/{object}/{id}` — a URL
+     shape that does not match any route in the console route table. The
+     builder now emits the canonical `/{object}/record/{id}`.
+  2. **Shorthand redirect for externally shared links.** Even with the
+     producer fixed, links pasted from email / Slack / older builds
+     still use the shorthand. The console now intercepts
+     `/{:objectName}/:maybeRecordId` and, when the second segment looks
+     like a record id (URL-safe slug ≥ 6 chars, not a reserved keyword),
+     redirects to `/{objectName}/record/{recordId}` preserving query and
+     hash.
+  3. **Visible 404 fallback.** Routes that match nothing at all now
+     render an explicit "Page not found" empty state with a "Go back"
+     action instead of leaving the content area blank. Silent failures
+     are now visible failures.
+
+- a4a0e1d: Add `<PresenceProvider>` abstraction with `useTenantPresence()` and
+  `useRecordPresence(objectName, recordId)` hooks. The default source is a
+  no-op so hooks return `[]` until a host app wires in a realtime
+  transport (WebSocket / SSE). Replaces the two architectural TODOs in
+  `AppHeader` (tenant scope) and `RecordDetailView` (record scope) that
+  were waiting on this abstraction.
+
+  `AppHeader` now falls back to `useTenantPresence()` when the
+  `presenceUsers` prop is omitted, and `RecordDetailView` renders
+  `<PresenceAvatars>` next to the lifecycle badge when other users are
+  viewing the same record. Both code paths render exactly as before when
+  no provider is mounted, so this change is non-visual for existing
+  consumers.
+
+### Patch Changes
+
+- 9997cae: DataSource: add optional `bulkUpdate(resource, ids, patch)` for "same patch, many rows" interactions (Slack "mark all as read", Linear "archive selected"). The ObjectStack adapter routes to `POST /api/v1/data/:object/updateMany` so the client pays one HTTP/auth/RLS round-trip instead of N parallel PATCHes, eliminating mark-all-read jank on inboxes with 50+ unread.
+
+  AppHeader's `markAllRead` now prefers `bulkUpdate`, with a transparent fallback to the per-id loop for adapters that don't implement the helper.
+
+- 0a644f0: feat(app-shell): CommandPalette searching indicator
+
+  When `useRecordSearch` is mid-flight (debounced fetch across objects
+  hasn't returned yet), the palette now surfaces a subtle visual:
+  - A small pulsing primary-coloured dot next to the **Records** group
+    heading, so the user sees that more results may still appear.
+  - A `Searching…` placeholder inside the empty state when the user has
+    typed something but no hits exist yet — replaces the static
+    "No results found." message until the request settles.
+
+  New i18n key `console.commandPalette.searching` (en + zh).
+
+- 5f71924: feat(app-shell): better default toast UX in ConsoleToaster
+
+  `ConsoleToaster` now ships UX-positive defaults that match the Linear
+  / Notion pattern users expect from an enterprise console:
+  - `position="top-right"` — keeps the user's primary work area (centre
+    - bottom) unobstructed.
+  - `closeButton` — every toast has an explicit X so users can dismiss
+    rather than wait the duration out.
+  - `richColors` — type-aware coloured backgrounds (success / error /
+    warning / info) so the kind of message is legible at a glance.
+  - `expand` — toast stack expands on hover so users can read multiple
+    recent toasts without dismissing.
+  - `visibleToasts={4}` — prevents the corner from being overrun.
+  - `duration: 4000` — long enough to read + click an `Undo` action.
+
+  All of these are still overridable via `<ConsoleToaster …>` props.
+
+- 5425608: CRM UX polish pass — calmer enterprise look across detail + kanban.
+  - **plugin-kanban**: column headers now use a 2px muted accent stripe with
+    neutral foreground titles + a quiet grey count pill instead of full
+    rainbow gradient + colored title + colored count. Pipeline boards
+    (Opportunity, Case, Task, Lead) look like Salesforce/Linear instead of
+    a toy. WIP-limit overflow remains destructive-red so urgency stays loud.
+  - **plugin-detail (`record:reference_rail`)**: new `hideEmpty` prop
+    (default true) collapses entries whose total === 0 into a single
+    `+ N empty (Quotes · Products …)` chip at the bottom of the rail.
+    Removes the 4–7 "No records" stack that dominated the aside.
+  - **plugin-detail (`record:path`)**: completed stages now render with an
+    emerald-tinted background + bold green check instead of low-contrast
+    `bg-muted text-muted-foreground` (which read as "light grey on white"
+    and was borderline unreadable).
+  - **app-shell (`RecordDetailView`)**: record-not-found short-circuit.
+    Previously a stale/missing recordId still rendered the page chrome
+    (rail, discussion, breadcrumb with the raw id), making invalid links
+    look like a partially broken page. Now renders a clean centered
+    `Empty` state with database icon + i18n'd "Record not found" copy.
+  - **i18n**: added `detail.showEmptyRelated_{one,other}` and
+    `empty.recordNotFound{,Description}` keys (en + zh).
+
+- 710fbe6: feat(app-shell): notification center animation polish
+
+  InboxPopover now animates every signal that matters for "noticing":
+  - Bell button **bounces once** when total pressure increases (new
+    notification or approval arrives). Tracks previous total via a ref
+    so the very first render — when the server-side counts hydrate —
+    does not trigger a spurious bounce.
+  - Bell badge **zooms in** on every count change (re-keyed on
+    `totalBadge` so each transition is an independent animation).
+  - Per-tab counter badges (Notifications / Approvals) get the same
+    zoom-in treatment on count change.
+  - Notification list rows **fade + slide in from top** with a small
+    staggered delay (capped at 6×20ms so a full list never feels
+    laggy).
+  - Activity rows mirror the same fade/slide pattern.
+  - Empty states (`You're all caught up`, `No recent activity`, `No
+pending approvals`) fade in instead of popping in.
+  - The unread dot (•) is now always rendered but fades its opacity
+    when `is_read` flips, instead of disappearing instantly — gives a
+    smooth "marked read" affordance.
+
+  All animations are wrapped in `motion-safe:` utility variants so
+  users with `prefers-reduced-motion` see the previous (instant) UI.
+  No new dependencies; reuses `tailwindcss-animate` utilities already
+  present in the design system.
+
+- 7c441f5: End-to-end @-mention notifications.
+
+  `@object-ui/plugin-detail` now exports `extractMentions(text, suggestions)`
+  — a small utility that resolves `@<label>` tokens in a comment body to
+  user ids, using the same suggestion list that drives the in-editor
+  dropdown. Handles labels with spaces ("@QA Test"), CJK ("@王小明"),
+  longest-match disambiguation ("Anna Lee" wins over "Anna"), and ignores
+  unknown @-tokens. 9 unit tests.
+
+  `@object-ui/app-shell` `RecordDetailView` now:
+  1. Serializes the resolved mention ids into `sys_comment.mentions`
+     (previously hard-coded `'[]'`, so servers had no idea who was being
+     pinged).
+  2. Fan-outs a `sys_notification` row per mentioned recipient
+     (self-mentions are filtered as noise) with the canonical bell-inbox
+     shape: `type: 'mention'`, `recipient_id`, `actor_name`, `title`,
+     `body` preview (≤140 chars), `source_object`/`source_id`/
+     `source_comment_id`, `is_read: false`, `created_at`.
+
+  The notification write tolerates 404 silently, so deployments without
+  a notification collection degrade to the previous behavior (mention
+  text + highlight, no inbox row). Spec-compliant servers that emit
+  notifications via their own sys_comment after-create hook can ignore
+  the client-side write — the bell de-dupes by id at the polling layer.
+
+- 072cad0: Always seed @-mention suggestions with the current user so the dropdown
+  appears even when the backend has no `sys_user` directory (or the fetch
+  fails). Hosts with a real user roster still get the merged list —
+  current user first, then directory entries de-duped by id.
+
+  Previously, typing `@` in the discussion comment box was a no-op on
+  example backends that don't serve `sys_user`, making the feature look
+  broken. Authors can now at minimum mention themselves; richer rosters
+  are merged in automatically when available.
+
+- 54e3dfb: Remove unused stub renderers from `@object-ui/app-shell`:
+  - `ObjectRenderer` / `ObjectRendererProps`
+  - `DashboardRenderer` / `DashboardRendererProps`
+  - `PageRenderer` / `PageRendererProps`
+  - `FormRenderer` / `FormRendererProps`
+
+  These were placeholder components that never delegated to a real
+  SchemaRenderer — they rendered a literal `"TODO"` string and were not
+  consumed anywhere in the monorepo or in the official Console app.
+  Because they were non-functional, no working production code could
+  have depended on them; this is treated as a patch-level cleanup rather
+  than a semver-major break.
+
+  If you were importing one of the removed stubs (and somehow got past
+  the "TODO" placeholder render), the real renderers ship from the
+  respective plugin packages:
+  - Dashboard → `@object-ui/plugin-dashboard` (`DashboardRenderer`)
+  - Page / Object / Form → `@object-ui/react` (`SchemaRenderer`) +
+    `@object-ui/plugin-form` / `@object-ui/plugin-grid` etc.
+
+- Updated dependencies [de0c5e6]
+- Updated dependencies [9997cae]
+- Updated dependencies [321294c]
+- Updated dependencies [b2d1704]
+- Updated dependencies [0a644f0]
+- Updated dependencies [a3cb88f]
+- Updated dependencies [5425608]
+- Updated dependencies [6c3f018]
+- Updated dependencies [d912a60]
+- Updated dependencies [87bc8ff]
+- Updated dependencies [3ebba63]
+- Updated dependencies [e919433]
+- Updated dependencies [a8d12ec]
+- Updated dependencies [a4a0e1d]
+- Updated dependencies [70b5570]
+- Updated dependencies [aa063db]
+- Updated dependencies [d9c3bae]
+- Updated dependencies [d1442e3]
+- Updated dependencies [7c7400a]
+- Updated dependencies [b703480]
+- Updated dependencies [e7b6eae]
+  - @object-ui/types@5.2.0
+  - @object-ui/data-objectstack@5.2.0
+  - @object-ui/core@5.2.0
+  - @object-ui/i18n@5.2.0
+  - @object-ui/react@5.2.0
+  - @object-ui/fields@5.2.0
+  - @object-ui/components@5.2.0
+  - @object-ui/collaboration@5.2.0
+  - @object-ui/layout@5.2.0
+  - @object-ui/auth@5.2.0
+  - @object-ui/permissions@5.2.0
+  - @object-ui/providers@5.2.0
+
 ## 5.1.1
 
 ### Patch Changes

package/dist/chrome/CommandPalette.d.ts

@@ -11,6 +11,11 @@ interface CommandPaletteProps {
     activeApp: any;
     objects: any[];
     onAppChange: (name: string) => void;
+    /**
+     * Optional data source used to power record search across objects. When
+     * omitted, the palette behaves exactly as before — nav items only.
+     */
+    dataSource?: any;
 }
-export declare function CommandPalette({ apps, activeApp, objects: _objects, onAppChange }: CommandPaletteProps): import("react/jsx-runtime").JSX.Element;
+export declare function CommandPalette({ apps, activeApp, objects, onAppChange, dataSource }: CommandPaletteProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/chrome/CommandPalette.js

@@ -7,17 +7,20 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  *
  * Uses Shadcn's Command (cmdk) component — keyboard-accessible, fuzzy search.
  */
-import { useEffect, useState, useCallback } from 'react';
+import { useEffect, useState, useCallback, useMemo } from 'react';
 import { useNavigate, useParams } from 'react-router-dom';
 import { CommandDialog, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, } from '@object-ui/components';
 import { LayoutDashboard, FileText, BarChart3, Moon, Sun, Monitor, Search, Plus, } from 'lucide-react';
+import { useRecordSearch } from '@object-ui/react';
 import { useTheme } from './ThemeProvider';
 import { useExpressionContext, evaluateVisibility } from '../providers/ExpressionProvider';
 import { useObjectTranslation } from '@object-ui/i18n';
-import { resolveI18nLabel } from '../utils';
+import { resolveI18nLabel, getRecordDisplayName } from '../utils';
 import { getIcon } from '../utils/getIcon';
-export function CommandPalette({ apps, activeApp, objects: _objects, onAppChange }) {
+import { useRecentItems } from '../context/RecentItemsProvider';
+export function CommandPalette({ apps, activeApp, objects, onAppChange, dataSource }) {
     const [open, setOpen] = useState(false);
+    const [inputValue, setInputValue] = useState('');
     const navigate = useNavigate();
     const { appName } = useParams();
     const { setTheme } = useTheme();
@@ -34,6 +37,11 @@ export function CommandPalette({ apps, activeApp, objects: _objects, onAppChange
         document.addEventListener('keydown', down);
         return () => document.removeEventListener('keydown', down);
     }, []);
+    // Reset query when the palette closes so reopening doesn't show stale state.
+    useEffect(() => {
+        if (!open)
+            setInputValue('');
+    }, [open]);
     const baseUrl = `/apps/${appName || activeApp?.name}`;
     const runCommand = useCallback((command) => {
         setOpen(false);
@@ -41,7 +49,35 @@ export function CommandPalette({ apps, activeApp, objects: _objects, onAppChange
     }, []);
     // Extract navigation items from active app, filtering by visibility expressions
     const navItems = flattenNavigation(activeApp?.navigation || []).filter((item) => evaluateVisibility(item.visible ?? item.visibleOn, evaluator));
-    return (_jsxs(CommandDialog, { open: open, onOpenChange: setOpen, children: [_jsx(CommandInput, { placeholder: t('console.commandPalette.placeholder') }), _jsxs(CommandList, { children: [_jsx(CommandEmpty, { children: t('console.commandPalette.noResults') }), navItems.filter(i => i.type === 'object').length > 0 && (_jsx(CommandGroup, { heading: t('console.commandPalette.objects'), children: navItems
+    // Whitelist of object names visible in this app's nav — used as the search
+    // scope so we don't fan out to every object in the tenant.
+    const searchableObjectNames = useMemo(() => navItems
+        .filter((i) => i.type === 'object' && typeof i.objectName === 'string')
+        .map((i) => i.objectName), 
+    // navItems is rebuilt every render (filtered list); use a stable signature.
+    [activeApp?.name, navItems.map((i) => i.objectName || '').join('|')]);
+    const { results: recordHits, isSearching } = useRecordSearch({
+        query: inputValue,
+        objects,
+        dataSource,
+        objectNames: searchableObjectNames,
+        enabled: open && Boolean(dataSource),
+        getDisplayName: getRecordDisplayName,
+    });
+    // Cloud-synced (sys_user_preference) recently-visited records,
+    // surfaced in the empty state so the palette is useful before the
+    // user types anything. Filtered down to record-type entries so we
+    // don't double up with the per-app nav above.
+    const { recentItems } = useRecentItems();
+    const recentRecords = useMemo(() => recentItems.filter((it) => it.type === 'record').slice(0, 5), [recentItems]);
+    const showRecentRecords = open && inputValue.trim().length === 0 && recentRecords.length > 0;
+    return (_jsxs(CommandDialog, { open: open, onOpenChange: setOpen, children: [_jsx(CommandInput, { placeholder: t('console.commandPalette.placeholder'), value: inputValue, onValueChange: setInputValue }), _jsxs(CommandList, { children: [_jsx(CommandEmpty, { children: isSearching ? (_jsxs("span", { className: "inline-flex items-center gap-2 text-muted-foreground", children: [_jsx("span", { "aria-hidden": true, className: "inline-block h-1.5 w-1.5 rounded-full bg-primary motion-safe:animate-pulse" }), t('console.commandPalette.searching', { defaultValue: 'Searching…' })] })) : (t('console.commandPalette.noResults')) }), showRecentRecords && (_jsx(CommandGroup, { heading: t('console.commandPalette.recentRecords', { defaultValue: 'Recently viewed' }), children: recentRecords.map((item) => (_jsxs(CommandItem, { value: `recent ${item.label} ${item.id}`, onSelect: () => runCommand(() => navigate(item.href)), children: [_jsx(Search, { className: "mr-2 h-4 w-4" }), _jsx("span", { className: "truncate", children: item.label })] }, `recent:${item.id}`))) })), recordHits.length > 0 && (_jsx(CommandGroup, { heading: _jsxs("span", { className: "inline-flex items-center gap-2", children: [t('console.commandPalette.records', { defaultValue: 'Records' }), isSearching && (_jsx("span", { "aria-hidden": true, className: "inline-block h-1.5 w-1.5 rounded-full bg-primary motion-safe:animate-pulse" }))] }), children: recordHits.map((hit) => {
+                            const Icon = getIcon(hit.icon);
+                            return (_jsxs(CommandItem, { 
+                                // Embed the live query so cmdk's client-side filter doesn't
+                                // hide async hits that don't textually match the input.
+                                value: `record ${inputValue} ${hit.display} ${hit.objectLabel} ${hit.objectName} ${hit.recordId}`, onSelect: () => runCommand(() => navigate(`${baseUrl}/${hit.objectName}/record/${hit.recordId}`)), children: [_jsx(Icon, { className: "mr-2 h-4 w-4" }), _jsx("span", { className: "truncate", children: hit.display }), _jsx("span", { className: "ml-auto text-xs text-muted-foreground", children: hit.objectLabel })] }, `${hit.objectName}:${hit.recordId}`));
+                        }) })), navItems.filter(i => i.type === 'object').length > 0 && (_jsx(CommandGroup, { heading: t('console.commandPalette.objects'), children: navItems
                             .filter(i => i.type === 'object')
                             .map(item => {
                             const Icon = getIcon(item.icon);

package/dist/chrome/ConsoleToaster.js

@@ -11,13 +11,20 @@ import { CircleCheck, Info, LoaderCircle, OctagonX, TriangleAlert } from 'lucide
 import { useTheme } from './ThemeProvider';
 export function ConsoleToaster(props) {
     const { theme = 'system' } = useTheme();
-    return (_jsx(Sonner, { theme: theme, className: "toaster group", icons: {
+    return (_jsx(Sonner, { theme: theme, className: "toaster group", 
+        // UX defaults chosen for an enterprise console — match the Linear /
+        // Notion pattern users expect. Callers can still override any of
+        // these via the spread `{...props}` below.
+        position: "top-right", closeButton: true, richColors: true, expand: true, visibleToasts: 4, icons: {
             success: _jsx(CircleCheck, { className: "h-4 w-4" }),
             info: _jsx(Info, { className: "h-4 w-4" }),
             warning: _jsx(TriangleAlert, { className: "h-4 w-4" }),
             error: _jsx(OctagonX, { className: "h-4 w-4" }),
             loading: _jsx(LoaderCircle, { className: "h-4 w-4 animate-spin" }),
         }, toastOptions: {
+            // 4s default keeps actionable toasts visible long enough to
+            // click an Undo button without feeling sticky.
+            duration: 4000,
             classNames: {
                 toast: 'group toast group-[.toaster]:bg-background group-[.toaster]:text-foreground group-[.toaster]:border-border group-[.toaster]:shadow-lg',
                 description: 'group-[.toast]:text-muted-foreground',

package/dist/chrome/ErrorBoundary.js

@@ -19,6 +19,7 @@ import { Component } from 'react';
 import { Button, Empty, EmptyTitle, EmptyDescription } from '@object-ui/components';
 import { AlertTriangle, RotateCcw, Home } from 'lucide-react';
 import { useObjectTranslation } from '@object-ui/i18n';
+import { captureError } from '../observability';
 /** Inner fallback component that uses the i18n hook */
 function DefaultErrorFallback({ error, onReset }) {
     const { t } = useObjectTranslation();
@@ -42,6 +43,8 @@ export class ErrorBoundary extends Component {
     }
     componentDidCatch(error, errorInfo) {
         console.error('[ErrorBoundary] Caught error:', error, errorInfo);
+        // Best-effort: report to Sentry if initialized. No-op when DSN absent.
+        captureError(error, { componentStack: errorInfo.componentStack });
         this.props.onError?.(error, errorInfo);
     }
     render() {

package/dist/chrome/RouteFader.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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.
+ */
+/**
+ * `RouteFader` — light-touch fade-in animation that replays whenever
+ * the route pathname changes.
+ *
+ * Why this implementation choice:
+ *   The textbook approach (`<div key={pathname}>`) would remount every
+ *   page on navigation. That breaks scroll position, loses form state,
+ *   and re-fetches data that didn't need to refetch.
+ *
+ *   Instead we keep the wrapper stable and replay the CSS animation by
+ *   manipulating className directly via a layout effect: strip the
+ *   animation classes, force a reflow, then re-add them. The browser
+ *   restarts the animation against the same DOM node. React's VDOM
+ *   doesn't see the temporary class swap — it's pure DOM choreography
+ *   — so children are never remounted.
+ *
+ *   The animation is gated on `motion-safe:` so users with
+ *   `prefers-reduced-motion: reduce` see hard page swaps.
+ */
+import * as React from 'react';
+export interface RouteFaderProps {
+    children: React.ReactNode;
+    className?: string;
+}
+export declare function RouteFader({ children, className }: RouteFaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/chrome/RouteFader.js

@@ -0,0 +1,52 @@
+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.
+ */
+/**
+ * `RouteFader` — light-touch fade-in animation that replays whenever
+ * the route pathname changes.
+ *
+ * Why this implementation choice:
+ *   The textbook approach (`<div key={pathname}>`) would remount every
+ *   page on navigation. That breaks scroll position, loses form state,
+ *   and re-fetches data that didn't need to refetch.
+ *
+ *   Instead we keep the wrapper stable and replay the CSS animation by
+ *   manipulating className directly via a layout effect: strip the
+ *   animation classes, force a reflow, then re-add them. The browser
+ *   restarts the animation against the same DOM node. React's VDOM
+ *   doesn't see the temporary class swap — it's pure DOM choreography
+ *   — so children are never remounted.
+ *
+ *   The animation is gated on `motion-safe:` so users with
+ *   `prefers-reduced-motion: reduce` see hard page swaps.
+ */
+import * as React from 'react';
+import { useLocation } from 'react-router-dom';
+const ANIM_CLASSES = ['motion-safe:animate-in', 'motion-safe:fade-in-0', 'motion-safe:duration-150'];
+export function RouteFader({ children, className }) {
+    const location = useLocation();
+    const ref = React.useRef(null);
+    const prevPath = React.useRef(location.pathname);
+    React.useLayoutEffect(() => {
+        if (prevPath.current === location.pathname)
+            return;
+        prevPath.current = location.pathname;
+        const el = ref.current;
+        if (!el)
+            return;
+        // Drop the animation classes, force a reflow read, then re-add
+        // them. This is the canonical CSS "restart animation" trick.
+        el.classList.remove(...ANIM_CLASSES);
+        // Reading `offsetWidth` forces layout, which is what tells the
+        // browser to flush the previous animation state.
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        el.offsetWidth;
+        el.classList.add(...ANIM_CLASSES);
+    }, [location.pathname]);
+    return (_jsx("div", { ref: ref, className: [...ANIM_CLASSES, className ?? ''].filter(Boolean).join(' '), children: children }));
+}

package/dist/chrome/index.d.ts

@@ -3,6 +3,8 @@ export { KeyboardShortcutsDialog } from './KeyboardShortcutsDialog';
 export { OnboardingWalkthrough } from './OnboardingWalkthrough';
 export { ConditionalAuthWrapper } from './ConditionalAuthWrapper';
 export { ConsoleToaster } from './ConsoleToaster';
+export { RouteFader } from './RouteFader';
 export { ErrorBoundary } from './ErrorBoundary';
 export { LoadingScreen } from './LoadingScreen';
 export { ThemeProvider, useTheme } from './ThemeProvider';
+export { toastWithUndo, type ToastWithUndoOptions } from './toast-helpers';

package/dist/chrome/index.js

@@ -3,6 +3,8 @@ export { KeyboardShortcutsDialog } from './KeyboardShortcutsDialog';
 export { OnboardingWalkthrough } from './OnboardingWalkthrough';
 export { ConditionalAuthWrapper } from './ConditionalAuthWrapper';
 export { ConsoleToaster } from './ConsoleToaster';
+export { RouteFader } from './RouteFader';
 export { ErrorBoundary } from './ErrorBoundary';
 export { LoadingScreen } from './LoadingScreen';
 export { ThemeProvider, useTheme } from './ThemeProvider';
+export { toastWithUndo } from './toast-helpers';

package/dist/chrome/toast-helpers.d.ts

@@ -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.
+ */
+/**
+ * Toast helpers — convention-encoding wrappers around `sonner` so
+ * destructive flows (delete, archive, bulk-update) consistently expose
+ * an Undo affordance.
+ *
+ * Why a helper instead of raw `toast.success(...)` at call sites:
+ *   1. Most "delete OK" toasts in the codebase do not offer Undo, even
+ *      when the underlying API supports a reversal. The helper makes
+ *      adding Undo a one-line change.
+ *   2. The label, duration, and aria semantics stay consistent across
+ *      surfaces — recently-deleted records, archived comments, bulk
+ *      operations — so users don't have to relearn the affordance per
+ *      view.
+ *
+ * Usage:
+ *
+ *   import { toastWithUndo } from '@object-ui/app-shell';
+ *
+ *   toastWithUndo('Lead deleted', {
+ *     onUndo: () => dataSource.restore('lead', id),
+ *   });
+ */
+import { type ExternalToast } from 'sonner';
+export interface ToastWithUndoOptions extends ExternalToast {
+    /**
+     * Callback invoked when the user clicks the Undo action. May return a
+     * promise; the toast stays visible until it resolves and a follow-up
+     * success/error toast is emitted automatically.
+     */
+    onUndo: () => void | Promise<unknown>;
+    /** Label for the Undo button. Defaults to "Undo". */
+    undoLabel?: string;
+    /** Toast intent. Defaults to "success" (green check). */
+    intent?: 'success' | 'info' | 'warning';
+    /**
+     * Toast visible duration in ms. Slightly longer than default 4s so
+     * users have time to click Undo on screen-edge toasts.
+     */
+    duration?: number;
+}
+export declare function toastWithUndo(message: string, opts: ToastWithUndoOptions): string | number;