@object-ui/react 6.2.3 → 7.1.0

package/CHANGELOG.md

@@ -1,5 +1,197 @@
 # @object-ui/react
 
+## 7.1.0
+
+### Minor Changes
+
+- a71be60: chore: drop the unrendered `blank` / `record_review` page types and their config
+
+  The `blank` and `record_review` page types have no renderer and were removed
+  from `@objectstack/spec`'s `PageTypeSchema` (framework#2265, enforce-or-remove).
+  This drops their now-dead references in objectui so the upstream spec can hard-
+  remove `BlankPageLayoutSchema` / `RecordReviewConfigSchema`:
+
+  - `PageType` union: removed `dashboard` / `form` / `record_detail` /
+    `record_review` / `overview` / `blank` (grid/gallery/kanban/calendar/timeline
+    remain — those are list _visualizations_, a separate cleanup).
+  - Removed `blankLayout` from `PageLayout` and the `blankLayout` / `recordReview`
+    handling in the spec→SDUI page bridge.
+  - Removed the redundant `BlankPageLayout{,Schema,Item,ItemSchema}` re-import from
+    `@objectstack/spec/ui` (it was never used).
+
+### Patch Changes
+
+- Updated dependencies [677f7ed]
+- Updated dependencies [08c47da]
+- Updated dependencies [a71be60]
+- Updated dependencies [cb03bc3]
+  - @object-ui/types@7.1.0
+  - @object-ui/core@7.1.0
+  - @object-ui/data-objectstack@7.1.0
+  - @object-ui/i18n@7.1.0
+
+## 7.0.0
+
+### Minor Changes
+
+- c12986e: Add resultDialog + target interpolation for one-shot action reveals
+
+  Some platform actions return values the user MUST copy now because the
+  server will not surface them again — 2FA TOTP URI + backup codes, freshly
+  minted OAuth client_secret, regenerated recovery codes. Previously these
+  had to ship as bespoke pages in `apps/account` because actions only
+  emitted a fire-and-forget toast.
+
+  **`@object-ui/core` — ActionRunner**
+
+  - New `ActionDef.resultDialog: ResultDialogSpec` field. When set on a
+    successful action, the runner suppresses the `successMessage` toast and
+    awaits the registered `ResultDialogHandler` instead. Missing handler is
+    non-fatal (logs a warning); rejected handler is treated as acknowledged.
+  - New `setResultDialogHandler(handler)` setter.
+  - New types: `ResultDialogSpec`, `ResultDialogFieldSpec`,
+    `ResultDialogHandler`.
+  - `executeUrl` and `executeAPI` now run `${param.X}` and `${ctx.X}`
+    interpolation against `target` before fetching / navigating. Values are
+    `encodeURIComponent`'d, missing keys resolve to empty string. `ctx`
+    exposes `origin`, `user`, `org`, `recordId` by default; consumers can
+    inject more via `context.ctx`.
+
+  **`@object-ui/react`**
+
+  - `ActionProvider` and `useActionRunner` both gained an `onResultDialog`
+    option that wires straight through to the runner.
+
+  **`@object-ui/app-shell`**
+
+  - New `ActionResultDialog` component — promise-based, blocks click-outside
+    and Escape (the user MUST click acknowledge), renders five field
+    formats: `qrcode` (client-side via the `qrcode` package — never sent
+    off-device, so 2FA URIs stay secret), `code-list`, `secret`, `text`,
+    `json`. Falls back to `json` when a value's shape doesn't match its
+    declared format.
+  - `ObjectView` and `RecordDetailView` install the handler and mount the
+    dialog automatically, so any action with `resultDialog` declared in
+    metadata now works without code changes.
+  - New dependency: `qrcode@^1.5.x` for client-side QR rendering.
+
+  Pairs with the framework-side `Action.resultDialog` schema added in
+  `@objectstack/spec` and the `sys_two_factor` / `sys_oauth_application` /
+  `sys_account` updates in `@objectstack/platform-objects`.
+
+### Patch Changes
+
+- 6cfa330: feat(dashboard): drill "Open in list" escape hatch + unify report drill
+
+  Adopts the mainstream BI peek-then-escalate drill model. Drill-through opens an
+  in-place drawer (keep context) and offers an "Open in list →" affordance to
+  escalate to the object's full list page (sort / bulk-select / export / shareable
+  URL) — the Looker / Power BI "see records → open in page" pattern.
+
+  - New `DrillNavigationContext` (`@object-ui/react`): the app shell provides
+    `openRecordList`; the renderer stays decoupled from console routing.
+  - The drill drawers (pivot / dataset / chart / KPI) render the escape hatch when
+    a host navigation handler is present, and hide it otherwise (self-contained
+    peek). `DashboardView` provides the handler via `useOpenRecordList`.
+  - `DrillDownConfig.target` gains `'navigate'` — skip the drawer and open the
+    list directly; degrades to `'drawer'` when no host handler is available.
+  - `ReportView` drill-through now opens the same in-place drawer (peek records →
+    click a row to open a record) instead of navigating away; the escape hatch
+    preserves the previous navigate-to-list behavior. Dashboard and report drill
+    are now unified.
+  - i18n: `dashboard.openInList` (en / zh).
+
+- e95cc25: Fix the NavigationSyncEffect baseline race: lazily-loaded `page`/`dashboard` metadata (and the empty cache during `invalidate()` refetch) could seed a partial diff baseline, making platform `sys_` pages look "user added" — the effect then wrote them into every app's navigation, 403ing on ADR-0010 locked apps (red "Failed to update navigation" toasts) and polluting writable apps. The effect now diffs only while both types are `status === 'ready'` (new optional `MetadataContextValue.getTypeStatus`), never treats `sys_`-prefixed artifacts as user creations, and skips apps whose `_lock`/`protection.lock` is `full`/`no-overlay`.
+- abe8ebc: Repoint `useClientNotifications` to the ADR-0030 `@objectstack/client` surface
+
+  The `useClientNotifications` bridge hook called `client.notifications.*` with
+  signatures that no longer exist on `@objectstack/client@7.x`:
+
+  - `registerDevice(token, platform)` → the SDK takes a single
+    `RegisterDeviceRequest` object (`{ token, platform }`).
+  - `markAsRead(id)` → there is no single-id method; the SDK exposes
+    `markRead(ids: string[])`. The hook keeps its friendly single-id API and
+    adapts to the batch call.
+
+  These helpers are the stable transport contract for ADR-0030 (Notification
+  Convergence): server-side they route to the L5 `sys_inbox_message`
+  materialization and the `sys_notification_receipt` read-state spine — the
+  re-modeled `sys_notification` L2 event no longer carries recipient/read
+  columns. (The Console bell itself reads the inbox + receipts directly via the
+  generic data API; see the `@object-ui/app-shell` bell cut-over.)
+
+  ## Cut-over sequence (operational — run in this order)
+
+  The Console UI repoint must land together with the framework pipeline **and**
+  the data migration so the bell is never blank and read-state is never lost:
+
+  1. Deploy the framework ADR-0030 change (objects + `emit()` + producers). New
+     notifications now land in `sys_inbox_message` + `sys_notification_receipt`.
+  2. Run the data migration **once** to carry existing notifications across —
+     `migrateSysNotificationToEvent({ driver, data })` from
+     `@objectstack/metadata/migrations`. It splits each legacy `sys_notification`
+     inbox row into a `sys_inbox_message` + receipt, rewrites the row to the event
+     shape, and clears the legacy columns. It is **idempotent** and reports
+     `not_applicable` on fresh installs. This runs against the ObjectStack
+     **server/data engine** — it is not a Console (frontend) step.
+  3. Deploy the objectui repoint (this change + the `@object-ui/app-shell` bell
+     cut-over).
+
+- 2270239: feat: scoped style-object rendering (ADR-0065)
+
+  A metadata node may carry `responsiveStyles` (per-breakpoint CSS-property maps);
+  `SchemaRenderer` compiles it to **id-scoped CSS** injected as a `<style>` tag and
+  appends a scope class to the node. Build-independent (arbitrary values + design
+  tokens pass through verbatim — no Tailwind JIT), collision-free (per-node scope,
+  unlayered so it beats base utilities), responsive-correct (model breakpoint maps
+  → generated `@media`, never `md:` variant classes). Adds `compileScopedStyles`/
+  `scopeClassFor`/`hasResponsiveStyles` to `@object-ui/core` and an SDUI design-token
+  palette (`--space-*`, `--surface`, `--brand`, …) to the theme. Mirrors Builder.io.
+
+- Updated dependencies [5976ba3]
+- Updated dependencies [eaccefd]
+- Updated dependencies [f7f325d]
+- Updated dependencies [c12986e]
+- Updated dependencies [71d7ce0]
+- Updated dependencies [30ee761]
+- Updated dependencies [053c948]
+- Updated dependencies [b99d9bd]
+- Updated dependencies [053c948]
+- Updated dependencies [89e113c]
+- Updated dependencies [ddbe4a2]
+- Updated dependencies [2d47e94]
+- Updated dependencies [9049bbe]
+- Updated dependencies [77cc6bb]
+- Updated dependencies [97c6831]
+- Updated dependencies [cb2fdb1]
+- Updated dependencies [a58c6b8]
+- Updated dependencies [c3749eb]
+- Updated dependencies [c09f44e]
+- Updated dependencies [6cfa330]
+- Updated dependencies [ad8ade6]
+- Updated dependencies [d54346c]
+- Updated dependencies [5332639]
+- Updated dependencies [3870c20]
+- Updated dependencies [b88c560]
+- Updated dependencies [0ad72a6]
+- Updated dependencies [3fa23a7]
+- Updated dependencies [18d0339]
+- Updated dependencies [59b6bbb]
+- Updated dependencies [d16566f]
+- Updated dependencies [1394e34]
+- Updated dependencies [300d755]
+- Updated dependencies [bd8b054]
+- Updated dependencies [4eb9cb6]
+- Updated dependencies [7c239fd]
+- Updated dependencies [858ad94]
+- Updated dependencies [2270239]
+- Updated dependencies [2f31406]
+- Updated dependencies [8d1195d]
+  - @object-ui/core@7.0.0
+  - @object-ui/data-objectstack@7.0.0
+  - @object-ui/i18n@7.0.0
+  - @object-ui/types@7.0.0
+
 ## 6.2.3
 
 ### Patch Changes

package/dist/SchemaRenderer.d.ts

@@ -28,7 +28,7 @@ export declare class SchemaErrorBoundary extends Component<{
         resetKey?: any;
     }): void;
     handleRetry: () => void;
-    render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+    render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
 }
 export declare const SchemaRenderer: React.ForwardRefExoticComponent<Omit<{
     schema: SchemaNode;

package/dist/SchemaRenderer.js

@@ -7,8 +7,10 @@ import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-run
  * LICENSE file in the root directory of this source tree.
  */
 import React, { forwardRef, useContext, useMemo, useEffect, useReducer, useState, Component } from 'react';
-import { ComponentRegistry, ExpressionEvaluator, isObjectUIError, ERROR_CODES, debugLog, debugTime, debugTimeEnd, DebugCollector, validateSchema, } from '@object-ui/core';
+import { ComponentRegistry, ExpressionEvaluator, isObjectUIError, ERROR_CODES, debugLog, debugTime, debugTimeEnd, DebugCollector, validateSchema, hasResponsiveStyles, scopeClassFor, compileScopedStyles, } from '@object-ui/core';
 import { SchemaRendererContext } from './context/SchemaRendererContext';
+import { usePredicateScope } from './hooks/useExpression';
+import { usePageVariables } from './hooks/usePageVariables';
 import { resolveI18nLabel } from './utils/i18n';
 /**
  * Dev-mode schema validation.
@@ -137,6 +139,15 @@ export class SchemaErrorBoundary extends Component {
 export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
     const context = useContext(SchemaRendererContext);
     const dataSource = context?.dataSource || {};
+    // Ambient host scope (user / app / features), fed by app-shell's
+    // ExpressionProvider. Threaded into `visible`/expression evaluation so
+    // component predicates can gate on the signed-in user & deployment flags.
+    const predicateScope = usePredicateScope();
+    // Page-local state (PageSchema.variables), provided by PageVariablesProvider.
+    // Exposed to predicates/bindings under `page.<var>` so an interactive element
+    // (e.g. element:record_picker) writing a variable can drive another
+    // component's `visible`/`visibility`. Empty object outside a Page.
+    const { variables: pageVariables } = usePageVariables();
     // Re-render trigger when the global ComponentRegistry mutates (e.g. a
     // lazy-loaded plugin finishes registering its components).
     const [, forceUpdate] = useReducer((n) => n + 1, 0);
@@ -151,11 +162,23 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
         return unsubscribe;
     }, []);
     const [lazyError, setLazyError] = useState(null);
+    // Stable fallback id for scoping a styled node that didn't declare an `id`.
+    const autoStyleId = React.useId();
     // Evaluate schema expressions against the data source
     const evaluatedSchema = useMemo(() => {
         if (!schema || typeof schema === 'string')
             return schema;
-        const evaluator = new ExpressionEvaluator({ data: dataSource });
+        // `data` (record/datasource) plus the ambient host scope. `current_user`
+        // is aliased to `user` so both `user.email` and `current_user.email`
+        // resolve in component `visible`/`visibleOn` expressions. `page` exposes
+        // page-local state so predicates can gate on `page.<var>` (e.g. a record
+        // picker's selection toggling another component's visibility).
+        const evaluator = new ExpressionEvaluator({
+            ...predicateScope,
+            current_user: predicateScope?.user,
+            data: dataSource,
+            page: pageVariables,
+        });
         // Shallow copy
         const newSchema = { ...schema };
         // COMPAT: Hoist 'properties' up to schema level
@@ -193,7 +216,7 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
             }
             newSchema.props = newProps;
         }
-        // Evaluate visibility: visible / visibleOn / hidden / hiddenOn
+        // Evaluate visibility: visible / visibleOn / visibility / hidden / hiddenOn
         const shouldHide = (() => {
             if (newSchema.visible !== undefined) {
                 return !evaluator.evaluateCondition(newSchema.visible);
@@ -201,6 +224,13 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
             if (newSchema.visibleOn !== undefined) {
                 return !evaluator.evaluateCondition(newSchema.visibleOn);
             }
+            // `visibility` is the spec-canonical predicate (PageComponentSchema.visibility,
+            // an ExpressionInput) — show-when-truthy, same semantics as `visibleOn`. The
+            // spec→node bridge preserves it verbatim on the node, so this is where it
+            // finally gates rendering (previously it was inert and leaked as a DOM prop).
+            if (newSchema.visibility !== undefined) {
+                return !evaluator.evaluateCondition(newSchema.visibility);
+            }
             if (newSchema.hidden !== undefined) {
                 return evaluator.evaluateCondition(newSchema.hidden);
             }
@@ -226,7 +256,7 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
             newSchema._disabled = true;
         }
         return newSchema;
-    }, [schema, dataSource]);
+    }, [schema, dataSource, predicateScope, pageVariables]);
     if (!evaluatedSchema)
         return null;
     // Handle visibility: if evaluated schema is hidden, render nothing
@@ -261,9 +291,25 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
     // Note: We don't forward the ref to the Component because components in the registry
     // may not support refs. The SchemaRenderer itself can still receive refs for its own use.
     // Extract schema metadata properties that should NOT be passed as React props
-    const { type: _type, children: _children, body: _body, schema: _schema, visible: _visible, visibleOn: _visibleOn, hidden: _hidden, hiddenOn: _hiddenOn, disabled: _disabled, disabledOn: _disabledOn, _hidden: __hidden, // stripped: internal visibility flag
+    const { type: _type, children: _children, body: _body, schema: _schema, visible: _visible, visibleOn: _visibleOn, visibility: _visibility, hidden: _hidden, hiddenOn: _hiddenOn, disabled: _disabled, disabledOn: _disabledOn, _hidden: __hidden, // stripped: internal visibility flag
     _disabled: __disabled, // stripped: internal disabled flag
+    responsiveStyles: _responsiveStyles, // stripped: compiled to scoped CSS, not a DOM prop
     ...componentProps } = evaluatedSchema;
+    // SDUI scoped styling (ADR-0065): a node's `responsiveStyles` compiles to
+    // id-scoped CSS injected as a <style> tag, and a scope class is appended to
+    // the node's className. Build-independent, collision-free, responsive-correct.
+    const hasScopedStyles = hasResponsiveStyles(_responsiveStyles);
+    const scopeClass = hasScopedStyles ? scopeClassFor(evaluatedSchema.id ?? autoStyleId) : '';
+    const scopedCss = hasScopedStyles ? compileScopedStyles(`.${scopeClass}`, _responsiveStyles) : '';
+    const mergedClassName = scopeClass
+        ? [evaluatedSchema.className, scopeClass].filter(Boolean).join(' ')
+        : evaluatedSchema.className;
+    // Some renderers read `schema.className` directly (e.g. element:text) while
+    // others read the `className` prop (e.g. flex/container). Set both so the
+    // scope class lands regardless of which channel a renderer honours.
+    const schemaForComponent = scopeClass
+        ? { ...evaluatedSchema, className: mergedClassName }
+        : evaluatedSchema;
     // Extract AriaPropsSchema properties for accessibility
     const ariaProps = resolveAriaProps(evaluatedSchema);
     // Debug-mode enhancements: extra data attributes + perf tracking
@@ -277,19 +323,19 @@ export const SchemaRenderer = forwardRef(({ schema, ...props }, _ref) => {
     }
     debugTime(`render:${evaluatedSchema.type}:${evaluatedSchema.id ?? 'anon'}`);
     const renderStart = isDebug ? performance.now() : 0;
-    const rendered = (_jsx(SchemaErrorBoundary, { componentType: evaluatedSchema.type, resetKey: evaluatedSchema.id ?? null, children: React.createElement(Component, {
-            schema: evaluatedSchema,
-            ...componentProps, // Spread non-metadata schema properties as props
-            ...(evaluatedSchema.props || {}), // Override with explicit props if provided
-            ...ariaProps, // Inject ARIA attributes from AriaPropsSchema
-            ...debugAttrs, // Debug-mode data attributes
-            disabled: __disabled || undefined,
-            className: evaluatedSchema.className,
-            'data-obj-id': evaluatedSchema.id,
-            'data-obj-type': evaluatedSchema.type,
-            ...(__DEV__ && !_validation.valid ? { 'data-obj-schema-invalid': 'true' } : {}),
-            ...props
-        }) }));
+    const rendered = (_jsxs(SchemaErrorBoundary, { componentType: evaluatedSchema.type, resetKey: evaluatedSchema.id ?? null, children: [scopedCss ? (_jsx("style", { "data-os-scope": scopeClass, dangerouslySetInnerHTML: { __html: scopedCss } })) : null, React.createElement(Component, {
+                schema: schemaForComponent,
+                ...componentProps, // Spread non-metadata schema properties as props
+                ...(evaluatedSchema.props || {}), // Override with explicit props if provided
+                ...ariaProps, // Inject ARIA attributes from AriaPropsSchema
+                ...debugAttrs, // Debug-mode data attributes
+                disabled: __disabled || undefined,
+                className: mergedClassName,
+                'data-obj-id': evaluatedSchema.id,
+                'data-obj-type': evaluatedSchema.type,
+                ...(__DEV__ && !_validation.valid ? { 'data-obj-schema-invalid': 'true' } : {}),
+                ...props
+            })] }));
     debugTimeEnd(`render:${evaluatedSchema.type}:${evaluatedSchema.id ?? 'anon'}`);
     // Report render perf to DebugCollector when debug mode is active
     if (isDebug && renderStart) {

package/dist/context/ActionContext.d.ts

@@ -12,7 +12,7 @@
  * Components can consume actions without creating their own runner instances.
  */
 import React from 'react';
-import { ActionRunner, type ActionContext as ActionCtx, type ActionDef, type ActionResult, type ConfirmationHandler, type ToastHandler, type ModalHandler, type NavigationHandler, type ParamCollectionHandler } from '@object-ui/core';
+import { ActionRunner, type ActionContext as ActionCtx, type ActionDef, type ActionResult, type ConfirmationHandler, type ToastHandler, type ModalHandler, type NavigationHandler, type ParamCollectionHandler, type ResultDialogHandler } from '@object-ui/core';
 export interface ActionProviderProps {
     children: React.ReactNode;
     /** Initial action context (record, user, data, etc.) */
@@ -27,6 +27,8 @@ export interface ActionProviderProps {
     onNavigate?: NavigationHandler;
     /** Custom param collection handler — show dialog to collect ActionParam values */
     onParamCollection?: ParamCollectionHandler;
+    /** Custom result-dialog handler — show one-shot reveal of API response after success */
+    onResultDialog?: ResultDialogHandler;
     /** Pre-registered custom action handlers */
     handlers?: Record<string, (action: ActionDef, ctx: ActionCtx) => Promise<ActionResult>>;
 }
@@ -46,6 +48,7 @@ interface ActionContextValue {
     /** Update context data */
     updateContext: (ctx: Partial<ActionCtx>) => void;
 }
+export declare const ActionCtxReact: React.Context<ActionContextValue | null>;
 /**
  * ActionProvider — Provides a shared ActionRunner to the tree.
  *

package/dist/context/ActionContext.js

@@ -14,7 +14,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
  */
 import { createContext, useCallback, useContext, useMemo, useState } from 'react';
 import { ActionRunner, } from '@object-ui/core';
-const ActionCtxReact = createContext(null);
+export const ActionCtxReact = createContext(null);
 /**
  * ActionProvider — Provides a shared ActionRunner to the tree.
  *
@@ -30,12 +30,25 @@ const ActionCtxReact = createContext(null);
  * </ActionProvider>
  * ```
  */
-export const ActionProvider = ({ children, context = {}, onConfirm, onToast, onModal, onNavigate, onParamCollection, handlers, }) => {
+export const ActionProvider = ({ children, context = {}, onConfirm, onToast, onModal, onNavigate, onParamCollection, onResultDialog, handlers, }) => {
     const [loading, setLoading] = useState(false);
     const [error, setError] = useState(null);
     const [result, setResult] = useState(null);
     const runner = useMemo(() => {
-        const r = new ActionRunner(context);
+        // Normalize the evaluator scope so predicates can use *either* flat
+        // (`record`, `user`, `objectName`) *or* the canonical `ctx.*` namespace
+        // (`ctx.user`, `ctx.record`, `ctx.objectName`). The CEL/predicate
+        // convention used across the platform (sys-user, sys-invitation,
+        // skills/objectstack-formula, …) is `ctx.user.id` — exposing both
+        // shapes from one place keeps every consumer working without forcing
+        // every call site to repeat the same `{ ..., ctx: { ... } }` boilerplate.
+        const normalizedContext = {
+            ...context,
+            ctx: (context && typeof context.ctx === 'object')
+                ? { ...context, ...context.ctx }
+                : { ...context },
+        };
+        const r = new ActionRunner(normalizedContext);
         if (onConfirm)
             r.setConfirmHandler(onConfirm);
         if (onToast)
@@ -46,6 +59,8 @@ export const ActionProvider = ({ children, context = {}, onConfirm, onToast, onM
             r.setNavigationHandler(onNavigate);
         if (onParamCollection)
             r.setParamCollectionHandler(onParamCollection);
+        if (onResultDialog)
+            r.setResultDialogHandler(onResultDialog);
         if (handlers) {
             Object.entries(handlers).forEach(([name, handler]) => {
                 r.registerHandler(name, handler);

package/dist/context/AppShellContext.d.ts

@@ -10,12 +10,22 @@ export interface MetadataState {
     loading: boolean;
     error: Error | null;
 }
+export type MetadataTypeStatus = 'idle' | 'loading' | 'ready' | 'error';
 export interface MetadataContextValue extends MetadataState {
     refresh: (type?: string) => Promise<void>;
     invalidate: (type: string, name?: string) => void;
     ensureType: (type: string) => Promise<any[]>;
     getItem: (type: string, name: string) => Promise<any | null>;
     getItemsByType: (type: string) => any[];
+    /**
+     * Per-type load status. Lazy types ('page', 'dashboard', …) return their
+     * items array immediately — empty or stale while a (re)fetch is in flight —
+     * so consumers that DIFF the list over time (e.g. NavigationSyncEffect)
+     * must distinguish "empty because unloaded" from "actually empty" and only
+     * trust snapshots taken while the type is 'ready'. Optional so hand-rolled
+     * context values in tests keep working; absent means "always ready".
+     */
+    getTypeStatus?: (type: string) => MetadataTypeStatus;
 }
 export declare const MetadataCtx: import("react").Context<MetadataContextValue | null>;
 export declare function useMetadata(): MetadataContextValue;

package/dist/context/AppShellContext.js

@@ -27,6 +27,7 @@ export function useMetadata() {
             ensureType: async () => [],
             getItem: async () => null,
             getItemsByType: () => [],
+            getTypeStatus: () => 'ready',
         };
     }
     return ctx;

package/dist/context/DrillNavigationContext.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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.
+ */
+/**
+ * DrillNavigationContext — host-provided navigation for drill "escape hatches".
+ *
+ * Dashboard/report drill-through opens an in-place drawer listing the records
+ * behind a clicked aggregate (the mainstream "peek without losing context"
+ * default). But sometimes the user wants the *full* object list page — to sort,
+ * bulk-select, switch views, export, or get a shareable URL. That requires
+ * console-specific URL building + SPA routing, which lives in the app shell,
+ * not the renderer.
+ *
+ * The app shell provides `openRecordList`; the drill drawers consume it to
+ * render an "Open in list →" action (and to honor `drillDown.target:
+ * 'navigate'`, which skips the drawer entirely). When no provider is present
+ * (e.g. an embedded/standalone renderer with no router) the affordance is
+ * simply hidden — drill stays in the drawer.
+ */
+import React from 'react';
+export interface DrillNavigationValue {
+    /**
+     * Open the full list page for `objectName`, scoped by `filter` (an object
+     * FIELD name → raw stored value map). Implemented by the app shell as a
+     * SPA navigation to the object's list route. Absent when no host wired it.
+     */
+    openRecordList?: (objectName: string, filter?: Record<string, unknown>) => void;
+}
+export declare const DrillNavigationContext: React.Context<DrillNavigationValue>;
+export declare const DrillNavigationProvider: React.FC<{
+    value: DrillNavigationValue;
+    children: React.ReactNode;
+}>;
+/** Consume the host-provided drill navigation handlers (empty object if none). */
+export declare function useDrillNavigation(): DrillNavigationValue;

package/dist/context/DrillNavigationContext.js

@@ -0,0 +1,31 @@
+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.
+ */
+/**
+ * DrillNavigationContext — host-provided navigation for drill "escape hatches".
+ *
+ * Dashboard/report drill-through opens an in-place drawer listing the records
+ * behind a clicked aggregate (the mainstream "peek without losing context"
+ * default). But sometimes the user wants the *full* object list page — to sort,
+ * bulk-select, switch views, export, or get a shareable URL. That requires
+ * console-specific URL building + SPA routing, which lives in the app shell,
+ * not the renderer.
+ *
+ * The app shell provides `openRecordList`; the drill drawers consume it to
+ * render an "Open in list →" action (and to honor `drillDown.target:
+ * 'navigate'`, which skips the drawer entirely). When no provider is present
+ * (e.g. an embedded/standalone renderer with no router) the affordance is
+ * simply hidden — drill stays in the drawer.
+ */
+import { createContext, useContext } from 'react';
+export const DrillNavigationContext = createContext({});
+export const DrillNavigationProvider = ({ value, children }) => (_jsx(DrillNavigationContext.Provider, { value: value, children: children }));
+/** Consume the host-provided drill navigation handlers (empty object if none). */
+export function useDrillNavigation() {
+    return useContext(DrillNavigationContext);
+}

package/dist/context/PreviewModeContext.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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.
+ */
+import React from 'react';
+/**
+ * PreviewModeContext — signals that the subtree is rendered inside a design /
+ * metadata preview surface (the Studio canvas, a view/page preview pane) rather
+ * than a live runtime route.
+ *
+ * Overlay form components (DrawerForm, ModalForm) consume this to render their
+ * body inline instead of mounting a portalled modal Sheet/Dialog. A modal in a
+ * preview escapes the canvas and locks the whole editor — Radix sets body
+ * `pointer-events:none` and traps focus while open — which reads as a frozen UI.
+ *
+ * Defaults to `false`, so live runtime usage (record pages, action modals,
+ * the field/object designers) is completely unaffected.
+ */
+declare const PreviewModeContext: React.Context<boolean>;
+export declare const PreviewModeProvider: ({ value, children, }: {
+    value?: boolean;
+    children: React.ReactNode;
+}) => React.JSX.Element;
+/** True when rendering inside a design / preview surface. Safe outside a provider. */
+export declare const usePreviewMode: () => boolean;
+export { PreviewModeContext };

package/dist/context/PreviewModeContext.js

@@ -0,0 +1,27 @@
+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.
+ */
+import { createContext, useContext } from 'react';
+/**
+ * PreviewModeContext — signals that the subtree is rendered inside a design /
+ * metadata preview surface (the Studio canvas, a view/page preview pane) rather
+ * than a live runtime route.
+ *
+ * Overlay form components (DrawerForm, ModalForm) consume this to render their
+ * body inline instead of mounting a portalled modal Sheet/Dialog. A modal in a
+ * preview escapes the canvas and locks the whole editor — Radix sets body
+ * `pointer-events:none` and traps focus while open — which reads as a frozen UI.
+ *
+ * Defaults to `false`, so live runtime usage (record pages, action modals,
+ * the field/object designers) is completely unaffected.
+ */
+const PreviewModeContext = createContext(false);
+export const PreviewModeProvider = ({ value = true, children, }) => (_jsx(PreviewModeContext.Provider, { value: value, children: children }));
+/** True when rendering inside a design / preview surface. Safe outside a provider. */
+export const usePreviewMode = () => useContext(PreviewModeContext);
+export { PreviewModeContext };

package/dist/context/SchemaRendererContext.d.ts

@@ -12,6 +12,6 @@ export declare const SchemaRendererProvider: ({ children, dataSource, debug, deb
     dataSource: any;
     debug?: boolean;
     debugFlags?: DebugFlags;
-}) => import("react/jsx-runtime").JSX.Element;
+}) => React.JSX.Element;
 export declare const useSchemaContext: () => SchemaRendererContextType;
 export declare const useDataScope: (path?: string) => any;

package/dist/context/ThemeContext.d.ts

@@ -75,7 +75,7 @@ export interface ThemeProviderProps {
  * </ThemeProvider>
  * ```
  */
-export declare function ThemeProvider({ themes: themesInput, defaultTheme, defaultMode, persist, storageKey, target, children, }: ThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function ThemeProvider({ themes: themesInput, defaultTheme, defaultMode, persist, storageKey, target, children, }: ThemeProviderProps): React.JSX.Element;
 /**
  * useTheme — access the current theme context.
  *

package/dist/context/index.d.ts

@@ -1,4 +1,5 @@
 export * from './SchemaRendererContext';
+export * from './PreviewModeContext';
 export * from './ActionContext';
 export * from './ThemeContext';
 export * from './NotificationContext';
@@ -6,3 +7,4 @@ export * from './DndContext';
 export * from './AppShellContext';
 export * from './RecordContext';
 export * from './DiscussionContext';
+export * from './DrillNavigationContext';

package/dist/context/index.js

@@ -1,4 +1,5 @@
 export * from './SchemaRendererContext';
+export * from './PreviewModeContext';
 export * from './ActionContext';
 export * from './ThemeContext';
 export * from './NotificationContext';
@@ -6,3 +7,4 @@ export * from './DndContext';
 export * from './AppShellContext';
 export * from './RecordContext';
 export * from './DiscussionContext';
+export * from './DrillNavigationContext';

package/dist/hooks/useActionEngine.js

@@ -21,16 +21,59 @@
  * const toolbarActions = getActionsForLocation('list_toolbar');
  * ```
  */
-import { useCallback, useMemo } from 'react';
+import { useCallback, useContext, useMemo } from 'react';
 import { ActionEngine, } from '@object-ui/core';
+import { ActionCtxReact } from '../context/ActionContext';
 export function useActionEngine(options = {}) {
     const { actions = [], context = {} } = options;
+    // When wrapped in an <ActionProvider>, reuse its ActionRunner so that:
+    //   • Visibility / disabled / condition CEL expressions evaluate against
+    //     the same context (user, datasource, etc.) the provider was seeded
+    //     with — not just the per-call `context` arg.
+    //   • Action execution (executeAction / handleShortcut) inherits the
+    //     provider's confirm / param-collection / modal / result-dialog /
+    //     toast / navigate handlers. Without sharing, a nested engine would
+    //     silently no-op on any action that declares `params: [...]` or
+    //     `confirmText`, because its local runner has no handlers installed.
+    // When no provider is present (unit tests, standalone playgrounds), we
+    // fall back to a self-contained runner constructed from the `context` arg.
+    const providerCtx = useContext(ActionCtxReact);
+    const sharedRunner = providerCtx?.runner ?? null;
     const engine = useMemo(() => {
-        const e = new ActionEngine(context);
+        // When standalone (no surrounding `<ActionProvider>`), normalize the
+        // context so predicates can use both `record`/`user` and `ctx.*`.
+        const normalizedStandalone = (context && Object.keys(context).length > 0)
+            ? {
+                ...context,
+                ctx: (context.ctx && typeof context.ctx === 'object')
+                    ? { ...context, ...context.ctx }
+                    : { ...context },
+            }
+            : context;
+        const e = sharedRunner ? new ActionEngine(sharedRunner) : new ActionEngine(normalizedStandalone);
+        // When sharing a provider runner, MERGE per-render flat keys into the
+        // existing `ctx` instead of overwriting it. The provider seeds
+        // `ctx: { record, user, objectName, … }` once; if we replaced it with
+        // just `ctx: { record, recordId, objectName }` here we would erase
+        // `ctx.user` and every `record.id == ctx.user.id` predicate would
+        // evaluate against `undefined.id` (→ throws → hidden).
+        if (sharedRunner && context && Object.keys(context).length > 0) {
+            const runner = e.getRunner();
+            const existing = runner.getEvaluator().getContext().toObject();
+            const existingCtx = (existing && typeof existing.ctx === 'object') ? existing.ctx : {};
+            const callerCtx = (context.ctx && typeof context.ctx === 'object')
+                ? context.ctx
+                : context;
+            const merged = {
+                ...context,
+                ctx: { ...existingCtx, ...callerCtx },
+            };
+            runner.updateContext(merged);
+        }
         e.registerActions(actions);
         return e;
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [JSON.stringify(actions), JSON.stringify(context)]);
+    }, [sharedRunner, JSON.stringify(actions), JSON.stringify(context)]);
     const getActionsForLocation = useCallback((location) => engine.getActionsForLocation(location), [engine]);
     const getBulkActions = useCallback(() => engine.getBulkActions(), [engine]);
     const executeAction = useCallback((name, contextOverride) => engine.executeAction(name, contextOverride), [engine]);

package/dist/hooks/useActionRunner.d.ts

@@ -5,7 +5,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import { ActionRunner, type ActionContext, type ActionDef, type ActionResult, type ConfirmationHandler, type ToastHandler, type ModalHandler, type NavigationHandler } from '@object-ui/core';
+import { ActionRunner, type ActionContext, type ActionDef, type ActionResult, type ConfirmationHandler, type ToastHandler, type ModalHandler, type NavigationHandler, type ParamCollectionHandler, type ResultDialogHandler } from '@object-ui/core';
 export interface UseActionRunnerOptions {
     context?: ActionContext;
     /** Custom confirmation handler — wire to Shadcn AlertDialog or similar */
@@ -16,6 +16,10 @@ export interface UseActionRunnerOptions {
     onModal?: ModalHandler;
     /** Custom navigation handler — SPA-aware routing */
     onNavigate?: NavigationHandler;
+    /** Custom param-collection handler — show dialog to gather params before execution */
+    onParamCollection?: ParamCollectionHandler;
+    /** Custom result-dialog handler — one-shot reveal of API response on success */
+    onResultDialog?: ResultDialogHandler;
 }
 /**
  * Hook for executing actions with loading state, typed with ActionDef.

package/dist/hooks/useActionRunner.js

@@ -31,7 +31,7 @@ export function useActionRunner(optionsOrContext = {}) {
     const options = 'context' in optionsOrContext
         ? optionsOrContext
         : { context: optionsOrContext };
-    const { context = {}, onConfirm, onToast, onModal, onNavigate } = options;
+    const { context = {}, onConfirm, onToast, onModal, onNavigate, onParamCollection, onResultDialog } = options;
     const [loading, setLoading] = useState(false);
     const [error, setError] = useState(null);
     const [result, setResult] = useState(null);
@@ -45,6 +45,10 @@ export function useActionRunner(optionsOrContext = {}) {
             r.setModalHandler(onModal);
         if (onNavigate)
             r.setNavigationHandler(onNavigate);
+        if (onParamCollection)
+            r.setParamCollectionHandler(onParamCollection);
+        if (onResultDialog)
+            r.setResultDialogHandler(onResultDialog);
         return r;
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [JSON.stringify(context)]);

package/dist/hooks/useClientNotifications.js

@@ -11,6 +11,14 @@
  * Bridge hook between the @objectstack/client notifications API
  * and the local NotificationContext state. Fetches server-side
  * notifications and surfaces them through the existing provider.
+ *
+ * ADR-0030 (Notification Convergence): the `client.notifications.*` helpers
+ * are the stable transport contract — the server routes them to the L5
+ * `sys_inbox_message` materialization and the `sys_notification_receipt`
+ * read-state spine (the re-modeled `sys_notification` L2 event carries no
+ * recipient/read columns). This hook only needs to call the SDK with its
+ * current signatures: `list(options)`, `markRead(ids[])`, `markAllRead()`,
+ * and `registerDevice(request)`.
  */
 import { useCallback, useContext, useEffect, useRef, useState } from 'react';
 import { SchemaRendererContext } from '../context/SchemaRendererContext';
@@ -111,7 +119,13 @@ export function useClientNotifications(options = {}) {
             return;
         setError(null);
         try {
-            await client.notifications.registerDevice(token, platform);
+            // ADR-0030 / @objectstack/client v7+: registerDevice takes a single
+            // RegisterDeviceRequest object (`{ token, platform }`), not positional
+            // args. `platform` is the device platform enum.
+            await client.notifications.registerDevice({
+                token,
+                platform: platform,
+            });
         }
         catch (err) {
             const wrapped = err instanceof Error ? err : new Error('Failed to register device');
@@ -155,7 +169,11 @@ export function useClientNotifications(options = {}) {
             return;
         setError(null);
         try {
-            await client.notifications.markAsRead(id);
+            // ADR-0030 / @objectstack/client v7+: the SDK exposes `markRead(ids[])`
+            // (batch) — there is no single-id `markAsRead`. Server-side this writes
+            // the `read` state to the `sys_notification_receipt` spine. We keep the
+            // friendly single-id hook API and adapt to the batch call.
+            await client.notifications.markRead([id]);
         }
         catch (err) {
             const wrapped = err instanceof Error ? err : new Error('Failed to mark as read');

package/dist/hooks/usePageVariables.d.ts

@@ -14,6 +14,13 @@ import type { PageVariable } from '@object-ui/types';
 export interface PageVariablesContextValue {
     /** Current variable values */
     variables: Record<string, any>;
+    /**
+     * The variable definitions backing this provider. Exposed so writer
+     * elements can resolve which variable they feed via `PageVariable.source`
+     * (the component id that writes to the variable) — see
+     * {@link usePageVariableBinding}.
+     */
+    definitions: PageVariable[];
     /** Set a single variable value */
     setVariable: (name: string, value: any) => void;
     /** Set multiple variable values at once */
@@ -65,3 +72,36 @@ export declare function usePageVariables(): PageVariablesContextValue;
  * Hook to check if a PageVariablesProvider is available.
  */
 export declare function useHasPageVariables(): boolean;
+/**
+ * A writer binding for a page variable, resolved from a component id.
+ */
+export interface PageVariableBinding {
+    /** The bound variable's name */
+    name: string;
+    /** The bound variable's current value */
+    value: any;
+    /** Write a new value into the bound variable */
+    setValue: (value: any) => void;
+}
+/**
+ * Resolve the page variable that a given component writes to.
+ *
+ * Per `@objectstack/spec`'s `PageVariableSchema`, a variable's `source`
+ * names the **component id** that feeds it — e.g. a `variables` entry
+ * `{ name: 'selectedProjectId', source: 'project_picker' }` is written by the
+ * component whose `id` is `project_picker`. An interactive element (record
+ * picker, filter, …) calls this with its own `schema.id` and writes the
+ * user's selection through the returned `setValue`.
+ *
+ * Returns `null` when no variable targets the given component (or when called
+ * outside a {@link PageVariablesProvider}), so callers can treat themselves as
+ * uncontrolled in that case.
+ *
+ * @example
+ * ```tsx
+ * const binding = usePageVariableBinding(schema.id);
+ * // on selection:
+ * binding?.setValue(record.id);
+ * ```
+ */
+export declare function usePageVariableBinding(componentId?: string): PageVariableBinding | null;

package/dist/hooks/usePageVariables.js

@@ -71,7 +71,8 @@ export const PageVariablesProvider = ({ definitions, children, }) => {
     const resetVariables = useCallback(() => {
         setVariablesState(initializeVariables(definitions));
     }, [definitions]);
-    const value = useMemo(() => ({ variables, setVariable, setVariables, resetVariables }), [variables, setVariable, setVariables, resetVariables]);
+    const defs = useMemo(() => definitions ?? [], [definitions]);
+    const value = useMemo(() => ({ variables, definitions: defs, setVariable, setVariables, resetVariables }), [variables, defs, setVariable, setVariables, resetVariables]);
     return (_jsx(PageVariablesContext.Provider, { value: value, children: children }));
 };
 PageVariablesProvider.displayName = 'PageVariablesProvider';
@@ -94,6 +95,7 @@ export function usePageVariables() {
         // Graceful fallback — allows components to work outside a Page
         return {
             variables: {},
+            definitions: [],
             setVariable: () => { },
             setVariables: () => { },
             resetVariables: () => { },
@@ -107,3 +109,39 @@ export function usePageVariables() {
 export function useHasPageVariables() {
     return useContext(PageVariablesContext) !== null;
 }
+/**
+ * Resolve the page variable that a given component writes to.
+ *
+ * Per `@objectstack/spec`'s `PageVariableSchema`, a variable's `source`
+ * names the **component id** that feeds it — e.g. a `variables` entry
+ * `{ name: 'selectedProjectId', source: 'project_picker' }` is written by the
+ * component whose `id` is `project_picker`. An interactive element (record
+ * picker, filter, …) calls this with its own `schema.id` and writes the
+ * user's selection through the returned `setValue`.
+ *
+ * Returns `null` when no variable targets the given component (or when called
+ * outside a {@link PageVariablesProvider}), so callers can treat themselves as
+ * uncontrolled in that case.
+ *
+ * @example
+ * ```tsx
+ * const binding = usePageVariableBinding(schema.id);
+ * // on selection:
+ * binding?.setValue(record.id);
+ * ```
+ */
+export function usePageVariableBinding(componentId) {
+    const { variables, definitions, setVariable } = usePageVariables();
+    return useMemo(() => {
+        if (!componentId)
+            return null;
+        const def = definitions.find((d) => d.source === componentId);
+        if (!def)
+            return null;
+        return {
+            name: def.name,
+            value: variables[def.name],
+            setValue: (value) => setVariable(def.name, value),
+        };
+    }, [componentId, definitions, variables, setVariable]);
+}

package/dist/spec-bridge/bridges/list-view.d.ts

@@ -32,7 +32,6 @@ interface ListViewSpec {
     sort?: any;
     searchableFields?: string[];
     filterableFields?: string[];
-    quickFilters?: any[];
     selection?: any;
     pagination?: any;
     rowHeight?: string;

package/dist/spec-bridge/bridges/list-view.js

@@ -5,7 +5,6 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import { normalizeQuickFilters } from '@object-ui/core';
 function mapColumn(col) {
     const mapped = {
         accessorKey: col.field,
@@ -81,10 +80,6 @@ export const bridgeListView = (spec, _context) => {
         node.searchableFields = spec.searchableFields;
     if (spec.filterableFields)
         node.filterableFields = spec.filterableFields;
-    // Normalize quickFilters: spec format { field, operator, value } → ObjectUI format
-    const normalizedQF = normalizeQuickFilters(spec.quickFilters);
-    if (normalizedQF)
-        node.quickFilters = normalizedQF;
     if (spec.resizable != null)
         node.resizable = spec.resizable;
     if (spec.striped != null)
@@ -126,8 +121,6 @@ export const bridgeListView = (spec, _context) => {
         node.appearance = spec.appearance;
     if (spec.compactToolbar != null)
         node.compactToolbar = spec.compactToolbar;
-    if (spec.tabs)
-        node.tabs = spec.tabs;
     if (spec.addRecord)
         node.addRecord = spec.addRecord;
     if (spec.showRecordCount != null)

package/dist/spec-bridge/bridges/page.d.ts

@@ -30,13 +30,6 @@ interface PageVariable {
     defaultValue?: any;
     source?: string;
 }
-interface BlankPageLayoutItem {
-    componentId: string;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
 interface PageSpec {
     name?: string;
     label?: string;
@@ -47,13 +40,6 @@ interface PageSpec {
     regions?: PageRegion[];
     template?: string;
     object?: string;
-    blankLayout?: {
-        columns?: number;
-        rowHeight?: number;
-        gap?: number;
-        items?: BlankPageLayoutItem[];
-    };
-    recordReview?: any;
     isDefault?: boolean;
     assignedProfiles?: string[];
     interfaceConfig?: any;

package/dist/spec-bridge/bridges/page.js

@@ -72,12 +72,8 @@ export const bridgePage = (spec, _context) => {
         node.template = spec.template;
     if (spec.object)
         node.object = spec.object;
-    // P1.4 — Blank page layout
-    if (spec.blankLayout)
-        node.blankLayout = spec.blankLayout;
-    // P1.4 — Additional page properties
-    if (spec.recordReview)
-        node.recordReview = spec.recordReview;
+    // Additional page properties (blankLayout/recordReview dropped — their page
+    // types have no renderer and were removed from @objectstack/spec, framework#2265)
     if (spec.isDefault != null)
         node.isDefault = spec.isDefault;
     if (spec.assignedProfiles)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/react",
-  "version": "6.2.3",
+  "version": "7.1.0",
   "type": "module",
   "license": "MIT",
   "description": "React bindings and SchemaRenderer component for Object UI",
@@ -24,19 +24,19 @@
     }
   },
   "dependencies": {
-    "@objectstack/spec": "^6.7.1",
-    "react-hook-form": "^7.76.1",
-    "@object-ui/core": "6.2.3",
-    "@object-ui/data-objectstack": "6.2.3",
-    "@object-ui/i18n": "6.2.3",
-    "@object-ui/types": "6.2.3"
+    "@objectstack/spec": "^10.0.0",
+    "react-hook-form": "^7.80.0",
+    "@object-ui/core": "7.1.0",
+    "@object-ui/data-objectstack": "7.1.0",
+    "@object-ui/i18n": "7.1.0",
+    "@object-ui/types": "7.1.0"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0"
   },
   "devDependencies": {
-    "@types/react": "19.2.15",
+    "@types/react": "19.2.17",
     "@types/react-dom": "19.2.3",
     "typescript": "^6.0.3"
   },