@object-ui/components 17.7.0 → 18.0.0

package/dist/lib/inline-markdown.d.ts

@@ -0,0 +1,64 @@
+/**
+ * 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.
+ *
+ * The one inline Markdown renderer (objectui#12778): `**bold**`, `*italic*`,
+ * `` `code` `` and `[text](url)`, drawn as React elements, never as an HTML
+ * string. Two surfaces read it: `element:text`, whose spec declares its
+ * `content` as "Text or Markdown content", and the console's marketplace
+ * README renderer (`MarkdownText` in `@object-ui/app-shell`), which owns the
+ * block half (headings, lists, fences) and hands each block's text here.
+ *
+ * Raw HTML (objectui#12146) is recognised by CommonMark's "Raw HTML" grammar
+ * and skipped: neither rendered nor printed. The grammar pieces are exported
+ * because `MarkdownText`'s "HTML blocks" rules are spelled from the same open
+ * and closing tag.
+ *
+ * A link keeps its `href` only for `http:`, `https:`, `mailto:` and `tel:`, or
+ * for a scheme-less reference (a path, a query, a fragment). Anything else —
+ * `javascript:`, `data:`, `vbscript:`, in any case — prints its text with no
+ * anchor. React 19 blocks `javascript:` URLs itself; this package's peer range
+ * admits React 18, which does not. An `href` carrying whitespace or a control
+ * character is refused outright, because browsers strip those before reading
+ * the scheme (`java\tscript:` runs as `javascript:`).
+ *
+ * Emphasis follows CommonMark's flanking rule in its simplest form: the
+ * delimiter run may not sit against whitespace on its inner side, so a lone
+ * `*` or `2 * 3 * 4` prints as typed. A code span is a single backtick pair;
+ * a run of two or more backticks (a fence typed into inline text) prints as
+ * typed.
+ */
+import * as React from 'react';
+/** CommonMark "open tag", as a RegExp source. */
+export declare const RAW_HTML_OPEN_TAG = "<[A-Za-z][A-Za-z0-9-]*(?:\\s+[A-Za-z_:][A-Za-z0-9_.:-]*(?:\\s*=\\s*(?:[^\"'=<>`\\s]+|'[^']*'|\"[^\"]*\"))?)*\\s*\\/?>";
+/** CommonMark "closing tag", as a RegExp source. */
+export declare const RAW_HTML_CLOSING_TAG = "<\\/[A-Za-z][A-Za-z0-9-]*\\s*>";
+/**
+ * The `href` a Markdown link may carry, or `null` when it may not carry one.
+ * Allow-list, not deny-list: a scheme this does not name is refused.
+ */
+export declare function safeLinkHref(raw: string): string | null;
+export interface InlineMarkdownOptions {
+    /** Classes for the drawn elements; each defaults to none. */
+    classNames?: {
+        code?: string;
+        strong?: string;
+        em?: string;
+        link?: string;
+    };
+    /**
+     * Which links open in a new tab (`target="_blank" rel="noopener noreferrer"`):
+     * `'all'`, or `'external'` — `http:` / `https:` and protocol-relative URLs,
+     * leaving a same-site path, `mailto:` and `tel:` in the same tab.
+     */
+    newTab?: 'all' | 'external';
+}
+/**
+ * Renders one run of text through the inline subset. Every pattern is tried
+ * at each step and the earliest match wins, so the order below only breaks
+ * ties at the same position.
+ */
+export declare function renderInlineMarkdown(input: string, options?: InlineMarkdownOptions): React.ReactNode;

package/dist/renderers/action/disabled-reason.d.ts

@@ -0,0 +1,49 @@
+import { default as React } from 'react';
+/** A reason to show, with the ids the control's ARIA attributes point at. */
+export interface DisabledReason {
+    /** The localized reason text. */
+    text: string;
+    /** Id of the element holding the reason — the control's description. */
+    id: string;
+    /** Id of a menu item's label element — the item's name when it shows a reason. */
+    labelId: string;
+}
+/**
+ * The reason for a control, or `undefined` when it gives none.
+ *
+ * `disabledByPredicate` is the caller's DECLARED-`disabled` verdict alone, never
+ * the OR it hands the control's `disabled` prop. A hook, so call it with the
+ * other hooks, ahead of any early return.
+ */
+export declare function useDisabledReason(disabledByPredicate: boolean): DisabledReason | undefined;
+/**
+ * The control's `aria-describedby`: an id it already carries (an authored
+ * `ariaDescribedBy` reaches `action:button` and `action:icon` through their DOM
+ * pass-through) followed by the reason's, or `undefined` when there is neither.
+ */
+export declare function describedByWithReason(existing: unknown, reason: DisabledReason | undefined): string | undefined;
+/**
+ * Wraps a disabled button in the tooltip trigger that carries its reason, or
+ * returns the button alone when there is no reason. `heading` is shown above
+ * the reason inside the tooltip; `action:icon` passes its label there, since an
+ * icon-only control has no visible name and its own label tooltip cannot open
+ * while it is disabled.
+ */
+export declare function DisabledReasonTrigger({ reason, heading, children, }: {
+    reason: DisabledReason | undefined;
+    heading?: React.ReactNode;
+    children: React.ReactElement;
+}): React.ReactElement;
+/** The ARIA a menu item carries while it shows a reason; none otherwise. */
+export declare function menuItemReasonAria(reason: DisabledReason | undefined): {
+    'aria-labelledby'?: string;
+    'aria-describedby'?: string;
+};
+/**
+ * A menu item's label, with the reason as a visible second line under it when
+ * there is one. Pair it with `menuItemReasonAria` on the item.
+ */
+export declare function DisabledReasonMenuLabel({ reason, children, }: {
+    reason: DisabledReason | undefined;
+    children: React.ReactNode;
+}): React.ReactElement;

package/dist/renderers/action/static-params.d.ts

@@ -28,43 +28,35 @@ export declare function readStaticParamValues(subject: StaticParamsSubject, wher
  */
 export type ConfigBagEvaluator = (bag: unknown) => unknown;
 /**
- * A container MEMBER with its `properties` evaluated (objectui#10290).
+ * An `action:bar` member with its `properties` evaluated (objectui#10290).
  *
- * `action:bar`, `action:group` and `action:menu` draw their member actions
- * themselves, so a member never passes through the `SchemaRenderer` memo that
- * evaluates a node's `properties`. Its static values ride `properties.params`
- * (objectui#10289), and they are templates (objectui#7867): on a record page,
+ * `action:bar` mounts its inline members on `action:button` / `action:icon`
+ * itself, so a member never passes through the `SchemaRenderer` memo that
+ * evaluates a node's `properties`. The renderer it lands on reads the static
+ * values off `properties.params` ({@link readStaticParamValues},
+ * objectui#10289), and they are templates (objectui#7867): on a record page,
  * `"recordId": "${record.id}"` has to reach the handler as the record's id. The
- * container evaluates the member's `properties` with the memo's own evaluator
- * and scope (`evaluateBag`, from `useConfigBagEvaluator()`), once, where it
- * composes or runs the member.
+ * bar evaluates the member's `properties` with the memo's own evaluator and
+ * scope (`evaluateBag`, from `useConfigBagEvaluator()`), once, where it
+ * composes the member.
  *
  * Returns the member itself when it carries no `properties` bag. Only
  * `properties` is evaluated. It is not copied onto the member (the memo's
  * hoist), and the member's other keys are left as authored.
- */
-export declare function withEvaluatedProperties<T extends object>(member: T, evaluateBag: ConfigBagEvaluator): T;
-/**
- * A container member's static values (objectui#10290): its `properties.params`,
- * evaluated through {@link withEvaluatedProperties}, or `undefined`.
  *
- * For `action:group` / `action:menu` items, which run the member themselves.
- * (`action:bar` hands an inline member to `action:button` / `action:icon` with
- * its `properties` already evaluated, and `readStaticParamValues` reads it
- * there.)
+ * `action:group` and `action:menu` do not call this: their members carry no
+ * `properties` bag (objectui#11638).
  */
-export declare function readMemberStaticParamValues(member: StaticParamsSubject, evaluateBag: ConfigBagEvaluator): Record<string, unknown> | undefined;
+export declare function withEvaluatedProperties<T extends object>(member: T, evaluateBag: ConfigBagEvaluator): T;
 /**
  * The same ruling on a spec ACTION ENTRY (objectui#10462): `element:button`'s
  * inline `action`, `action:group` / `action:menu` items and `page:header`'s
  * actions. `params` is an entry's `ActionParam[]` input list and nothing else.
- * (An `action:group` / `action:menu` item is also a container member, so its
- * static values are read from `properties.params` and evaluated by the
- * container through {@link readMemberStaticParamValues} (objectui#10290).
- * `UIActionSchema` declares no `properties`, so on a container member this bag
- * is read off the authored object, not off a declared key. `element:button`'s
- * inline `action` and `page:header`'s actions do not read
- * `properties.params`.)
+ * (No entry surface reads a `properties.params` bag. `UIActionSchema` declares
+ * no `properties`, and the spec refuses one on an `action:group` /
+ * `action:menu` member: its static parameter values are not part of the inline
+ * action vocabulary, and an action that needs them is its own `action:button`
+ * node (objectui#11638).)
  *
  * One type is still different: `api`. The objectstack#5777 window keeps the
  * runner reading an object `params` as the request payload (with its own

package/dist/renderers/basic/data-list.d.ts

@@ -14,6 +14,7 @@
  *                               row, no toolbar/card/pagination.
  *
  * Props are read off `schema.properties` (spec convention) with a `schema.props`
- * fallback, matching the other `element:*` renderers.
+ * fallback, matching the other `element:*` renderers. The repeater's query is
+ * the node-level `dataSource` binding alone (objectui#11880, objectui#12345).
  */
 export {};

package/dist/renderers/basic/elements.d.ts

@@ -22,8 +22,7 @@
  * All props are read off `schema.properties` per the spec's
  * `UIComponent.properties` convention; `schema.props` is also accepted
  * as a fallback so authors transitioning between conventions keep working.
- * `element:number` also reads the node-level `dataSource` binding: its
- * `object` wins over the flat one, and its filter is AND-combined with the
- * flat one (objectui#10909).
+ * `element:number` reads its query from the node-level `dataSource` binding
+ * ONLY: its `object` and its `filter` (objectui#10909, objectui#11880).
  */
 export {};

package/dist/renderers/basic/record-picker.d.ts

@@ -10,8 +10,9 @@
  *
  * Data binding follows the spec's ElementDataSource (`schema.dataSource`):
  *   { object, view?, filter?, sort?, limit? }
- * with `properties.object` accepted as a fallback. Display config is read off
- * `schema.properties`:
+ * and is read from there ONLY: the flat `properties.object` / `filter` /
+ * `sort` / `limit` are not read (objectui#11880, objectstack#11509 ruled
+ * A-narrow). Display config is read off `schema.properties`:
  *   { labelField='name', valueField='id', label?, placeholder?, emptyText? }
  *
  * The selection is written through `usePageVariableBinding(schema.id)`: the

package/dist/renderers/complex/dataTableBindDiagnostic.d.ts

@@ -32,8 +32,8 @@
  * EMPTY_ROWS` off the node, and the file calls no such hook.
  *
  * A `bind` on a `data-table` is nevertheless accepted by every gate: the TS
- * side by `BaseSchema`'s `[key: string]: any`, the zod side by `BaseSchema`
- * being `.passthrough()` (which `DataTableSchema.extend(…)` inherits). So the
+ * side because `BaseSchema` declares `bind` for every node (objectui#6357), the
+ * zod side by `BaseSchema` being `.passthrough()` (which `DataTableSchema.extend(…)` inherits). So the
  * author gets a table drawing a correct-looking header over the "No results
  * found" empty state, with no error, no warning and no diagnostic — the
  * hardest failure shape for a human OR an AI author to self-check, because a

package/dist/renderers/layout/containers.d.ts

@@ -1,20 +1,34 @@
+import { default as React } from 'react';
 /**
- * ObjectUI
- * Copyright (c) 2024-present ObjectStack Inc.
+ * The props of {@link PageHeaderActions}.
  *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * Spec-aligned container renderers for the `page:*` component namespace.
- * Backs the Page-as-root record detail page model (Salesforce Lightning
- * Record Page parity).
+ * `actions`, `maxVisible` and `mobileMaxVisible` are `page:header`'s own
+ * authored keys, read as that block reads them; the system actions are not a
+ * prop, they come from `RecordContext.headerSystemActions` as they always did.
+ */
+export interface PageHeaderActionsProps {
+    /** The authored `actions` array: action ids (the contract) or, during the transition, inline action objects. */
+    actions?: unknown;
+    /** The inline-button budget on desktop, as `page:header`'s `maxVisible`; an out-of-contract value falls back to 3. */
+    maxVisible?: unknown;
+    /** The inline-button budget on mobile, as `page:header`'s `mobileMaxVisible`; an out-of-contract value falls back to 1. */
+    mobileMaxVisible?: unknown;
+    /** Drawn in place of the action row when no action survives the gates. */
+    emptySlot?: React.ReactNode;
+}
+/**
+ * A record's header actions: the declared actions placed at `record_header` /
+ * `record_more` and the host's system actions (Edit / Share / Delete), gated,
+ * ordered, split into inline buttons and the `⋯` overflow, and dispatched
+ * through the action runner.
  *
- * Maps `packages/spec/src/ui/component.zod.ts` props:
- *   - PageTabsProps      -> page:tabs
- *   - PageCardProps      -> page:card
- *   - PageAccordionProps -> page:accordion
- *   - PageHeaderProps    -> page:header
- *   - PageContainerProps -> page:footer / page:sidebar / page:section
- *                           (the thin wrappers; one shared `children` slot)
+ * This is `page:header`'s action row, lifted out of `PageHeaderRenderer` so
+ * that a host can draw the same row where a page has no `page:header`
+ * (objectui#12906): a page that declares `print` may hold only the printable
+ * component types, and `page:header` is not one of them, so the console's
+ * record view draws this row in its screen-only chrome beside Print. It is
+ * the ONE resolver for both surfaces, ⛔ never a second one. It must render
+ * inside the record's `RecordContext` and `ActionProvider`, as `page:header`
+ * does.
  */
-export {};
+export declare const PageHeaderActions: React.FC<PageHeaderActionsProps>;

package/dist/renderers/layout/page-block-grid.d.ts

@@ -0,0 +1,29 @@
+import { default as React } from 'react';
+/**
+ * Lays a list of page blocks on the 12-column block grid (objectui#12624):
+ * each block takes the span its kind gets from `./page-block-span`, folded by
+ * breakpoint. One component for every block list that folds this way: a
+ * region's blocks (`RegionContent` in `./page.tsx`) and the children of
+ * `page:card` / `page:section` (`./containers.tsx`), so a container in a
+ * region spans 12 by its own kind and its children fold like region blocks.
+ * A cell is `empty:hidden`, so a block that renders nothing leaves no gap.
+ */
+export declare const PageBlockGrid: React.FC<{
+    nodes: readonly unknown[];
+    className?: string;
+    /** Marks the list as a rail's: every block in it, nested ones too, spans 12. */
+    rail?: boolean;
+    /** Key prefix for blocks with no `id`. */
+    keyPrefix?: string;
+    /** Maps a node to the schema `SchemaRenderer` renders (identity by default). */
+    toSchema?: (node: unknown) => unknown;
+    attributes?: Record<string, string | undefined>;
+    /** The grid element, for a caller that measures it (the region's posture, objectui#12703). */
+    gridRef?: React.Ref<HTMLDivElement>;
+}>;
+/**
+ * A container's child slot as a block grid: a list goes on the grid, while a
+ * bare node or text renders as it did (`renderChildren`), since there is
+ * nothing to lay out beside it.
+ */
+export declare function renderBlockChildren(children: unknown, render: (c: unknown) => React.ReactNode): React.ReactNode;

package/dist/renderers/layout/page-block-span.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 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.
+ */
+/**
+ * How wide a page block sits in its region's 12-column block grid
+ * (objectui#12624).
+ *
+ * The width is DERIVED from the block's kind, never authored:
+ * `@objectstack/spec`'s `PageComponentSchema` declares no `span`, and on
+ * `PageRegionSchema` `span` is only a refused alias of `width`. So this file
+ * adds no key an author can write; it names, once, which registered block
+ * types are metric tiles (3 of 12) and which are charts (6 of 12). Every other
+ * type, a type this table does not name included, spans the full 12.
+ *
+ * The keys are the registry keys the blocks are registered under (the bare
+ * key where the registration keeps one, and the namespaced key). The page
+ * renderer (`RegionContent` in `./page.tsx`) and the Studio page designer's
+ * block card (app-shell `PageBlockCanvas`) both read this table, so the span
+ * the designer shows is the span the page draws.
+ */
+export type PageBlockSpan = 3 | 6 | 12;
+/** Registered block type → its span, for the types narrower than 12. */
+export declare const PAGE_BLOCK_SPANS: ReadonlyMap<string, 3 | 6>;
+/**
+ * The span a block of this type takes; a type the table does not name takes
+ * 12. A block in a `rail` region (below) takes 12 whatever its kind: a rail is
+ * a narrow column, where a fold by viewport width would squeeze a tile to a
+ * sliver.
+ */
+export declare function pageBlockSpan(type: unknown, rail?: boolean): PageBlockSpan;
+/**
+ * Is this region a rail — the narrow `sidebar` / `aside` column beside `main`?
+ * Both are on every layout that places those slots beside `main` (no
+ * template, `default`, `full-width`, `three-column`); `header-sidebar-main`
+ * places only `sidebar` there (an `aside` joins `main`'s column); the
+ * `dashboard` template makes every region but `header` / `footer` a grid cell,
+ * so it has none. The page renderer passes the same answer structurally, by
+ * the slot it places a region in.
+ */
+export declare function isPageRailRegion(regionName: unknown, template?: unknown): boolean;
+/**
+ * The span folded by breakpoint: as declared from `xl` (1280px) up; between
+ * `md` (768px) and `xl` tiles take 6 and charts 12; under `md` every block
+ * takes 12. LITERAL class strings so Tailwind's scanner emits them.
+ */
+export declare const PAGE_BLOCK_SPAN_CLASS: Readonly<Record<PageBlockSpan, string>>;

package/dist/renderers/layout/page-description-context.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+/**
+ * The page `description` a titled `page:header` draws under its title
+ * (objectui#12624).
+ *
+ * When an authored `page:header` owns the page's `h1`, the page renderer no
+ * longer draws the description in its own heading block, which sat ABOVE the
+ * regions and so above the title. It hands the description down here instead,
+ * and the header draws it after the title, the order the console page header
+ * uses. Every page renderer provides a value (null when it draws the
+ * description itself), so a page nested in another never reads the outer
+ * page's description.
+ */
+export declare const PageDescriptionContext: React.Context<React.ReactNode>;

package/dist/renderers/layout/page-print.d.ts

@@ -0,0 +1,14 @@
+import { PageNodeSchema } from '@object-ui/types';
+/** The page's `print` declaration, as the node type carries it from the spec by reference. */
+export type PagePrintDeclaration = NonNullable<PageNodeSchema['print']>;
+/** The DOM attribute `PageRenderer` stamps on the root of a print page; every rule below is scoped to it. */
+export declare const PRINT_PAGE_ATTRIBUTE = "data-print-page";
+/** The DOM attribute on the running-region table `PageRenderer` draws for `repeatHeader` / `repeatFooter`. */
+export declare const PRINT_RUNNING_ATTRIBUTE = "data-print-running";
+/** True when `value` is a `print` declaration object — the one condition under which a page is a print page. */
+export declare function isPagePrintDeclaration(value: unknown): value is PagePrintDeclaration;
+/**
+ * Build the print stylesheet for a page that declares `print`. Pure: the same
+ * declaration always yields the same text, so it is pinned as text.
+ */
+export declare function buildPagePrintStylesheet(print: PagePrintDeclaration): string;

package/dist/renderers/layout/page-region-posture.d.ts

@@ -0,0 +1,82 @@
+/**
+ * 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 * as React from 'react';
+/**
+ * How a block in a page region should present itself, judged by the region's
+ * MEASURED width against the page's (objectui#12703).
+ *
+ *  - `'compact'`: the region is narrower than half the page — the `aside` rail
+ *    beside `main`, a sidebar, a third of a three-column body. A list block
+ *    there draws a short list (title, count, two-line rows) instead of the
+ *    object list's own chrome.
+ *  - `'full'`: the region is half the page or wider.
+ *
+ * `null` — the answer outside any page region, and inside one whose width is
+ * not known yet (no layout: server render, jsdom, the first render before the
+ * measurement lands). A block reads `null` exactly as `'full'`: an unknown
+ * width keeps today's full rendering.
+ *
+ * ⭐ DERIVED, never authored. `@objectstack/spec` declares no posture or
+ * `compact` key on a page, a region or a block, and this adds none: the page
+ * renderer measures, and a block reads the answer through
+ * {@link usePageRegionPosture}. ⛔ Not a viewport breakpoint: a region's
+ * width relative to its page is what decides, so the same `aside` is compact
+ * on a wide screen and full once the layout stacks it under `main`.
+ */
+export type PageRegionPosture = 'compact' | 'full';
+/**
+ * The posture a region `regionWidth` wide takes on a page `pageWidth` wide.
+ * `null` when either width is unknown (zero, negative or not a number): the
+ * caller then keeps the full rendering.
+ */
+export declare function pageRegionPostureFor(regionWidth: number, pageWidth: number): PageRegionPosture | null;
+/**
+ * The page body's width, as a store a region subscribes to rather than a
+ * context VALUE: a value that changed on every resize would re-render every
+ * region and the whole block tree under it, while a subscription re-renders a
+ * region only when its posture flips.
+ */
+export interface PageWidthStore {
+    get(): number;
+    set(width: number): void;
+    subscribe(listener: () => void): () => void;
+}
+/**
+ * The page's width store, watching the page body `bodyRef` points at — the
+ * element the page's regions are laid out in. Called by `PageRenderer`, the
+ * component that RENDERS that element, and handed to {@link PageWidthProvider}.
+ *
+ * ⚠️ The watch has to run in the component that renders the body element, not
+ * in a provider nested inside it: React attaches a host element's ref after
+ * the layout effects of the components below it have run, so a provider
+ * inside the body would find the ref still empty.
+ */
+export declare function usePageWidthStore(bodyRef: React.RefObject<HTMLElement | null>): PageWidthStore;
+/** Publishes the page's width store to every region under it. Rendered by `PageRenderer`. */
+export declare const PageWidthProvider: React.FC<{
+    store: PageWidthStore;
+    children: React.ReactNode;
+}>;
+/**
+ * Measures the region `regionRef` points at against the page width published
+ * above it and tells the region's blocks their posture. Rendered by the page
+ * renderer's `RegionContent`. It re-renders when the posture flips and at no
+ * other resize, and its `children` element is the same one each time, so a
+ * flip reaches the blocks that read the posture and nothing else.
+ */
+export declare const PageRegionPostureProvider: React.FC<{
+    regionRef: React.RefObject<HTMLElement | null>;
+    children: React.ReactNode;
+}>;
+/**
+ * The posture of the page region this block renders in: `'compact'` when the
+ * region is narrower than half the page, `'full'` when it is not, `null`
+ * outside a page region or before the width is known — read `null` as
+ * `'full'`. Safe outside any provider.
+ */
+export declare function usePageRegionPosture(): PageRegionPosture | null;

package/dist/ui/button.d.ts

@@ -8,7 +8,7 @@ import { VariantProps } from 'class-variance-authority';
  */
 import * as React from "react";
 declare const buttonVariants: (props?: ({
-    variant?: "link" | "default" | "secondary" | "outline" | "ghost" | "destructive" | null | undefined;
+    variant?: "link" | "default" | "secondary" | "ghost" | "outline" | "destructive" | null | undefined;
     size?: "default" | "sm" | "lg" | "icon" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/components",
-  "version": "17.7.0",
+  "version": "18.0.0",
   "type": "module",
   "license": "MIT",
   "description": "Standard UI component library for Object UI, built with Shadcn UI + Tailwind CSS",
@@ -26,7 +26,7 @@
     "./style.css": "./dist/index.css"
   },
   "dependencies": {
-    "@objectstack/spec": "^17.0.0",
+    "@objectstack/spec": "^18.0.0",
     "@radix-ui/react-accordion": "^1.2.20",
     "@radix-ui/react-alert-dialog": "^1.1.23",
     "@radix-ui/react-aspect-ratio": "^1.1.15",
@@ -68,12 +68,12 @@
     "tailwind-merge": "^3.6.0",
     "tailwindcss-animate": "^1.0.7",
     "vaul": "^1.1.2",
-    "@object-ui/core": "17.7.0",
-    "@object-ui/i18n": "17.7.0",
-    "@object-ui/react-runtime": "17.7.0",
-    "@object-ui/react": "17.7.0",
-    "@object-ui/sdui-parser": "17.7.0",
-    "@object-ui/types": "17.7.0"
+    "@object-ui/core": "18.0.0",
+    "@object-ui/react": "18.0.0",
+    "@object-ui/react-runtime": "18.0.0",
+    "@object-ui/i18n": "18.0.0",
+    "@object-ui/sdui-parser": "18.0.0",
+    "@object-ui/types": "18.0.0"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",