@object-ui/components 17.3.0 → 17.5.0

package/dist/lib/sidebar-cookie.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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.
+ */
+/**
+ * Reads the persisted sidebar collapse state back out of `document.cookie` —
+ * objectui#4234.
+ *
+ * `SidebarProvider` has always WRITTEN `sidebar_state` on every toggle (7-day
+ * max-age) and never read it back, so a collapsed sidebar came back expanded
+ * on the next load: the cookie was present and correct, and nothing consulted
+ * it. Upstream Shadcn closes that loop in a **server component** — it reads the
+ * cookie there and hands the value down as `defaultOpen`. A pure SPA (the
+ * console) has no such step, so the read has to happen client-side, which is
+ * what this function is for.
+ *
+ * ## Why the implementation lives HERE and not in the primitive
+ *
+ * `packages/components/src/ui/**` is regenerated from the Shadcn registry
+ * (AGENTS.md Commandment #7) — anything written there is overwritten by the
+ * next `pnpm shadcn:update`. `src/lib/` is not part of that regeneration, so
+ * this file is permanent. `sidebar.tsx` gets only a one-line call, re-applied
+ * on every sync by the declared patch in `scripts/shadcn-local-patches.mjs`.
+ * Keeping the payload out of the regenerated zone is what makes the patch small
+ * enough to survive upstream churn — the same shape as `close-label.tsx`.
+ *
+ * ## Why the cookie NAME is a parameter
+ *
+ * The name is owned by the write side: `SIDEBAR_COOKIE_NAME` in `sidebar.tsx`,
+ * the same constant the `document.cookie =` assignment interpolates. Passing it
+ * in keeps that the single source of truth — a second spelling here could drift
+ * from the writer and would read a cookie nobody writes. (Importing the
+ * constant instead would make `sidebar.tsx` and this module circular.)
+ *
+ * ## Strict values, deliberately
+ *
+ * Only the two literals the write side produces are accepted. Anything else —
+ * absent, empty, `"1"`, `"collapsed"`, a truncated value — returns `undefined`
+ * so the caller falls through to its `defaultOpen`. That is contract-first
+ * (AGENTS.md #0.1): the writer is ours and emits exactly `true`/`false`, so a
+ * tolerant parse here would only serve values no part of this system writes,
+ * and would silently invent a preference the user never expressed.
+ *
+ * @param name Cookie name to look up, matched EXACTLY (not by prefix or
+ *   substring), so `sidebar_state_v2` / `my_sidebar_state` never answer for
+ *   `sidebar_state`.
+ * @returns `true` / `false` for a persisted preference, or `undefined` when
+ *   there is none to honour — including on the server, where there is no
+ *   `document` to read (Next.js SSRs `"use client"` components for the initial
+ *   HTML, so this guard is load-bearing for `apps/site`, not defensive noise).
+ */
+export declare function readSidebarStateCookie(name: string): boolean | undefined;

package/dist/renderers/action/action-bar.d.ts

@@ -1,8 +1,8 @@
-import { ActionSchema, ActionLocation } from '@object-ui/types';
+import { UIActionSchema, ActionLocation } from '@object-ui/types';
 export interface ActionBarSchema {
     type: 'action:bar';
     /** Business actions to render — subject to inline/overflow split via {@link maxVisible} */
-    actions?: ActionSchema[];
+    actions?: UIActionSchema[];
     /**
      * System/chrome actions (Duplicate, Export, View History, Delete, etc.) that
      * are *always* placed in the overflow menu — never inline — regardless of
@@ -13,7 +13,7 @@ export interface ActionBarSchema {
      * The first system action is automatically separated from business-overflow
      * entries by a menu separator.
      */
-    systemActions?: ActionSchema[];
+    systemActions?: UIActionSchema[];
     /** Filter actions by this location */
     location?: ActionLocation;
     /** Maximum visible inline actions before overflow into "More" menu (default: 3) */

package/dist/renderers/action/action-button.d.ts

@@ -1,6 +1,16 @@
-import { ActionSchema } from '@object-ui/types';
+import { UIActionSchema } from '@object-ui/types';
+/**
+ * The declared props. `schema` is `UIActionSchema` (objectui#4418): every key
+ * this renderer forwards below — `target`, `endpoint`, `bodyExtra`,
+ * `bodyShape`, `locations`, `enabled`, `size` — is declared by the modern type
+ * and by no other, and the legacy `crud.ts` `ActionSchema` it used to name is
+ * `@deprecated` and requires `type: 'action'` (this renderer serves
+ * `'script' | 'url' | 'modal' | 'flow' | 'api'`). `actionType` stays on the
+ * intersection: it is the legacy-shaped override this renderer reads FIRST
+ * (`schema.actionType || schema.type`), and it is not a `UIActionSchema` key.
+ */
 export interface ActionButtonProps {
-    schema: ActionSchema & {
+    schema: UIActionSchema & {
         type: string;
         className?: string;
         actionType?: string;

package/dist/renderers/action/action-group.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { ActionSchema, ActionLocation } from '@object-ui/types';
+import { UIActionSchema, ActionLocation } from '@object-ui/types';
 export interface ActionGroupSchema {
     type: 'action:group';
     /** Group name */
@@ -9,7 +9,7 @@ export interface ActionGroupSchema {
     /** Group icon */
     icon?: string;
     /** Actions in this group */
-    actions?: ActionSchema[];
+    actions?: UIActionSchema[];
     /** Display mode: inline button row or dropdown */
     display?: 'dropdown' | 'inline';
     /** Filter actions by location */
@@ -35,7 +35,13 @@ export interface ActionGroupSchema {
  * showed even when its predicate was false.
  */
 export declare const DropdownActionItem: React.FC<{
-    action: ActionSchema;
+    action: UIActionSchema;
     index: number;
-    onSelect: (action: ActionSchema) => void | Promise<void>;
+    onSelect: (action: UIActionSchema) => void | Promise<void>;
+    /**
+     * The row this group is mounted over, forwarded by the host. Optional: an
+     * object-level group genuinely has no row, and a predicate over an empty
+     * record is still evaluable (objectui#4075).
+     */
+    record?: unknown;
 }>;

package/dist/renderers/action/action-icon.d.ts

@@ -1,6 +1,14 @@
-import { ActionSchema } from '@object-ui/types';
+import { UIActionSchema } from '@object-ui/types';
+/**
+ * The declared props. `schema` is `UIActionSchema` (objectui#4418) for the same
+ * reason as `action:button`'s: `target`, `endpoint`, `bodyExtra`, `bodyShape`,
+ * `locations`, `enabled` and `size` are all modern-only keys this renderer
+ * forwards, and the legacy `crud.ts` `ActionSchema` is `@deprecated` and pins
+ * `type: 'action'` where this renderer's own registry `inputs` declare
+ * `'script' | 'url' | 'modal' | 'flow' | 'api'`.
+ */
 export interface ActionIconProps {
-    schema: ActionSchema & {
+    schema: UIActionSchema & {
         type: string;
         className?: string;
     };

package/dist/renderers/action/action-menu.d.ts

@@ -1,4 +1,5 @@
-import { ActionSchema } from '@object-ui/types';
+import { default as React } from 'react';
+import { UIActionSchema } from '@object-ui/types';
 export interface ActionMenuSchema {
     type: 'action:menu';
     /** Menu trigger label (defaults to icon-only) */
@@ -6,7 +7,7 @@ export interface ActionMenuSchema {
     /** Menu trigger icon (defaults to more-horizontal) */
     icon?: string;
     /** Actions to render as menu items */
-    actions?: ActionSchema[];
+    actions?: UIActionSchema[];
     /** Trigger variant */
     variant?: string;
     /** Trigger size */
@@ -17,3 +18,20 @@ export interface ActionMenuSchema {
     className?: string;
     [key: string]: any;
 }
+/**
+ * One action inside an `action:menu`. Exported for its pin tests only (it is
+ * not re-exported from the package index) — mirrors `DropdownActionItem` in
+ * `action-group.tsx`, whose gate is the same one.
+ */
+export declare const ActionMenuItem: React.FC<{
+    action: UIActionSchema;
+    onExecute: (action: UIActionSchema) => Promise<void>;
+    /**
+     * The row this menu is mounted over, forwarded by the host. Optional: an
+     * object-level menu genuinely has no row, and a predicate over an empty
+     * record is still evaluable (objectui#4075 — the failure being fixed is a
+     * predicate that FAULTS on an unbound root, not one that reads a missing
+     * field).
+     */
+    record?: unknown;
+}>;

package/dist/renderers/action/auto-trigger.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Is this action asking to be auto-triggered? One spelling of the test, so the
+ * flag cannot be read as `!== undefined` in one renderer and `=== true` in
+ * another. Deliberately strict: only the literal `true` arms it.
+ */
+export declare function hasAutoTrigger(action: unknown): boolean;
+/**
+ * Run `run` at most once, as soon as `armed` is true.
+ *
+ * `run` may change identity freely (it is rebuilt from `schema` on most
+ * renders); the ref is what makes this once-only, so depending on it is safe.
+ */
+export declare function useAutoTriggerOnce(armed: boolean, run: () => void | Promise<void>): void;

package/dist/renderers/action/visibility-gate.d.ts

@@ -0,0 +1,81 @@
+/**
+ * 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.
+ */
+/**
+ * Did this action DECLARE a visibility gate at all? The renderer-side name for
+ * the repo's one definition of that question, which now lives one layer down in
+ * `@object-ui/core` as `hasDeclaredPredicate`
+ * (`packages/core/src/evaluator/declaredPredicate.ts`) — read the reasoning
+ * there; only what is specific to this file is repeated below.
+ *
+ * ## Why this module is now a re-export (objectui#3850 / objectui#3862)
+ *
+ * The question was answered three times with three different scopes, and the
+ * widest-scoped answer was on the key where the mistake is not benign:
+ *
+ *   - HERE, `!= null && !== ''` — so every OBJECT counted as a declared gate,
+ *     including `{ dialect: 'cel', source: '' }`. That envelope is not an exotic
+ *     spelling: `@objectstack/spec`'s `ExpressionInputSchema` normalizes every
+ *     authored predicate into one, so "the author left the predicate empty"
+ *     compiles to exactly it. The verdict path then normalized the same value to
+ *     `undefined` and `evaluateCondition(undefined)` answered `true` = "no
+ *     condition, so visible/enabled" — which on `disabled` means GREYED OUT.
+ *     A button disabled forever, indistinguishable from the metadata's intent
+ *     (objectui#3850).
+ *   - `SchemaRenderer`'s inline `!== undefined`, one notch wider again, so
+ *     `disabled: null` greyed out any node on the generic rendering path
+ *     (objectui#3862).
+ *   - `ActionRunner`'s module-private helper, which asked "does this normalize
+ *     to something evaluable?" — the scope objectui#3850 then ruled to be THE
+ *     scope (objectui#3848).
+ *
+ * The ruling: a gate is declared when normalization still leaves a condition to
+ * evaluate. `''`, a whitespace-only string, an empty-`source` envelope and any
+ * non-predicate value are therefore NOT declared, and one definition in core
+ * says so for the renderers, `SchemaRenderer` and the execution entry alike.
+ *
+ * The NAME is kept (`hasDeclaredVisibilityGate`) and this module keeps
+ * re-exporting it: the five member-action call sites — `action:button`,
+ * `action:icon`, `action:group`'s inline button and dropdown item, and
+ * `action:menu`'s item, plus `DeclaredActionsBar` and `record-quick-actions`
+ * through the `@object-ui/components` barrel — are unchanged by this move. The
+ * name is historic (objectui#3492 arrived through `visible`) and the predicate is
+ * key-neutral, which the call-site comments already say.
+ *
+ * ## What did NOT change: truthiness still cannot answer this
+ *
+ * `if (action.visible && !isVisible)` was the objectui#3812 defect: it
+ * classified `visible: false` — the most explicit way an author can say "never
+ * show this" — as *ungated*, so the gate never consulted the verdict and the
+ * action rendered for everyone. A declared boolean is still a declared gate
+ * here; only the empty and non-predicate shapes moved.
+ *
+ * ## The scope change is not verdict-neutral on every key — measured
+ *
+ * On `visible` the empty shapes were mostly benign already, because the two
+ * mistakes cancelled: over-broad "declared" plus `evaluateCondition` answering
+ * `true` for an empty predicate = SHOWN, the same result as "no gate". Measured
+ * on this tree (`action:button`, before → after):
+ *
+ *   | value                        | `visible`         | `disabled`        | `enabled`         |
+ *   |------------------------------|-------------------|-------------------|-------------------|
+ *   | `''`                         | shown → shown     | on → on           | on → on           |
+ *   | `{ dialect:'cel', source:'' }`| shown → shown    | GREY → on         | on → on           |
+ *   | `{ source: '' }`             | shown → shown     | GREY → on         | on → on           |
+ *   | `'   '` (whitespace)         | HIDDEN → shown    | on → on           | GREY → on         |
+ *   | `0` / `{}` (not a predicate) | shown → shown     | GREY → on         | on → on           |
+ *   | `true` / `false` / CEL / `${…}`| unchanged        | unchanged         | unchanged         |
+ *
+ * The whitespace row is the one that moves on `visible`, and it moves toward the
+ * invariant rather than away from it: `'   '` used to be normalized to `'${   }'`
+ * (the normalizer wraps it rather than folding it), which evaluates falsy, so a
+ * predicate that says nothing HID the action from everyone. "An empty predicate
+ * must not hide the action from everyone" is what this gate has always claimed —
+ * the whitespace spelling simply never obeyed it. Same story on the negated
+ * `enabled` leg, where it greyed the control out instead.
+ */
+export { hasDeclaredPredicate as hasDeclaredVisibilityGate } from '@object-ui/core';

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

@@ -9,7 +9,7 @@
  * record of an object and writes the selection into a page variable.
  *
  * Data binding follows the spec's ElementDataSource (`schema.dataSource`):
- *   { object, filter?, sort?, limit? }
+ *   { object, view?, filter?, sort?, limit? }
  * with `properties.object` accepted as a fallback. Display config is read off
  * `schema.properties`:
  *   { labelField='name', valueField='id', label?, placeholder?, emptyText? }
@@ -20,6 +20,15 @@
  * picker is uncontrolled (still usable, just inert) so it never throws outside
  * a Page. The written value drives any predicate referencing `page.<var>`
  * (e.g. another component's `visible` / `visibility`).
+ *
+ * `view` is resolved through {@link useElementDataSource} rather than read off
+ * the binding directly (objectstack#6953). This block used to take `object` /
+ * `filter` / `sort` / `limit` off `schema.dataSource` and DROP `view`, so
+ * `dataSource: { object: 'account', view: 'hot' }` — the spec's own example —
+ * built an unfiltered picker over every account instead of the rows the saved
+ * view selects. That symptom is quieter than the one objectstack#5576 fixed on
+ * `list-view`: nothing errors, the list is simply WIDER than what was authored,
+ * which is exactly the failure an AI-authored page hides best.
  */
 import * as React from 'react';
 declare function ElementRecordPickerRenderer({ schema }: {

package/dist/renderers/complex/data-table.d.ts

@@ -7,6 +7,101 @@ import { DataTableSchema } from '@object-ui/types';
  * only reachable structurally through `DataTableSchema`.
  */
 type RowActionDef = NonNullable<DataTableSchema['rowActionDefs']>[number];
+/**
+ * The authoring shape of the built-in row Edit/Delete predicates — derived from
+ * `DataTableSchema`, never restated by hand (objectui#4354). Everything below
+ * reads what the production caller hands it (`schema.rowEditPredicates` /
+ * `rowDeletePredicates`), so a hand-written `{ visibleWhen?: unknown; … }` here
+ * would be a second definition of one authoring shape, free to drift from the
+ * type it is supposed to mirror without a single test going red.
+ *
+ * The union of the two twins is deliberate: every consumer below serves BOTH
+ * built-ins (`name: 'edit' | 'delete'`), so it may only read keys that BOTH
+ * schema keys declare — if either twin dropped one, the read stops compiling
+ * instead of silently reading `undefined`.
+ */
+type BuiltinRowPredicates = NonNullable<DataTableSchema['rowEditPredicates'] | DataTableSchema['rowDeletePredicates']>;
+/**
+ * Does the built-in Edit/Delete item render for THIS row? The single
+ * definition, read both by the item itself and by the row-level guard that
+ * decides whether the "⋮" trigger exists at all. The two disagreeing is
+ * objectui#3562: the guard counted handlers, the items were then filtered by
+ * these predicates, and a row with every item suppressed still got a trigger
+ * that opened an empty 128×10 box.
+ *
+ * `visibleWhen` counts as a declared gate by `!= null`, not by truthiness —
+ * `visibleWhen: false` hides the item rather than reading as "ungated".
+ *
+ * The parameter is consumption-shaped — visibility is all this decides, so
+ * `disabledWhen` is deliberately absent — but `Pick`ed from the authoring type
+ * rather than hand-written, so it is a SUBSET of that type by construction
+ * (objectui#4354).
+ */
+export declare function isBuiltinRowActionVisible(predicates: Pick<BuiltinRowPredicates, 'visibleWhen'> | undefined, name: 'edit' | 'delete', row: any, scope: Record<string, unknown>): boolean;
+/**
+ * Does this schema-driven custom row action render for THIS row? Same
+ * single-definition rule as the built-ins above.
+ *
+ * A gate counts as DECLARED by `!= null && !== ''`, never by truthiness
+ * (objectui#3758). Truthiness cannot answer the question: `visible: false` is a
+ * declared gate that excludes every row, and testing `!action.visible`
+ * classified it as *ungated* — so the most explicit way to say "never show this"
+ * rendered the item for everyone, and counted toward the "⋮" guard. This is the
+ * invariant objectui#3492 established for the selection bar (plugin-grid's
+ * `hasVisibilityGate`), and the same `!= null` posture the built-in `visibleWhen`
+ * gate above has always had. The boolean then decides in
+ * {@link evalRowActionVisibility}, which short-circuits it instead of handing it
+ * to the engine.
+ *
+ * `''` is grouped with `null` deliberately: an empty predicate is nothing to
+ * evaluate, so it must not hide the item from everyone either.
+ */
+export declare function isCustomRowActionVisible(action: {
+    name?: string;
+    visible?: unknown;
+} | undefined, row: any, scope: Record<string, unknown>): boolean;
+/** What the row overflow menu will actually render for ONE row. */
+export interface DataTableRowMenuPlan {
+    /** The built-in Edit item renders for this row. */
+    edit: boolean;
+    /** The built-in Delete item renders for this row. */
+    remove: boolean;
+    /** Custom actions surviving their own `visible` predicate, in declared order. */
+    custom: RowActionDef[];
+    /** Items that will render. `0` means: render no trigger at all (#3562). */
+    count: number;
+}
+/**
+ * Resolve the row overflow menu for ONE row — which items survive their
+ * per-record predicates, and how many that leaves.
+ *
+ * Per ROW, not per table: `visibleWhen` / `visible` are per-record predicates,
+ * so two rows of the same table legitimately differ (one keeps Edit, the next
+ * has nothing left). A table-level guard cannot express that, which is why the
+ * trigger decision lives here and is recomputed for every row.
+ *
+ * Only visibility is decided here — a `disabled` item still renders (greyed
+ * out) and still counts, exactly as before. That counting is pinned where it
+ * can be OBSERVED, on the rendered menu, by
+ * `data-table-row-menu-empty-guard.test.tsx`'s "keeps the trigger for a row
+ * whose only item renders merely DISABLED".
+ *
+ * The predicate parameters are consumption-shaped — this function reads
+ * `visibleWhen` and nothing else, and the signature keeps saying so — but each
+ * is `Pick`ed from the authoring key its production caller passes, rather than
+ * hand-restated (objectui#4354). Same subset, minus the drift: a rename in
+ * `@object-ui/types` fails here at compile time instead of leaving a stale
+ * hand-copy that still type-checks against nothing.
+ */
+export declare function planDataTableRowMenu(input: {
+    onRowEdit?: unknown;
+    onRowDelete?: unknown;
+    editPredicates?: Pick<NonNullable<DataTableSchema['rowEditPredicates']>, 'visibleWhen'>;
+    deletePredicates?: Pick<NonNullable<DataTableSchema['rowDeletePredicates']>, 'visibleWhen'>;
+    customActions: readonly RowActionDef[];
+    row: any;
+    scope: Record<string, unknown>;
+}): DataTableRowMenuPlan;
 /**
  * One schema-driven custom row action in the data-table's inline row overflow
  * menu. Extracted into its own component so the action's `visible` (and
@@ -50,10 +145,11 @@ export declare const DataTableRowActionItem: React.FC<{
  */
 export declare const DataTableBuiltinRowActionItem: React.FC<{
     name: 'edit' | 'delete';
-    predicates?: {
-        visibleWhen?: unknown;
-        disabledWhen?: unknown;
-    };
+    /**
+     * The whole authoring pair, because this component reads both keys — derived
+     * from `DataTableSchema` rather than hand-copied (objectui#4354).
+     */
+    predicates?: BuiltinRowPredicates;
     row: any;
     icon: React.ReactNode;
     label: string;

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

@@ -14,7 +14,8 @@
  *   - PageCardProps      -> page:card
  *   - PageAccordionProps -> page:accordion
  *   - PageHeaderProps    -> page:header
- *   - page:footer / page:sidebar / page:section thin wrappers
+ *   - PageContainerProps -> page:footer / page:sidebar / page:section
+ *                           (the thin wrappers; one shared `children` slot)
  */
 /**
  * Strip dangling connectors that survive when a `titleFormat` interpolates

package/dist/ui/command.d.ts

@@ -49,7 +49,7 @@ declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<
     ref?: React.Ref<HTMLInputElement>;
 } & {
     asChild?: boolean;
-}, "key" | "asChild" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "onChange" | "value" | "type"> & {
+}, "key" | "asChild" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "type" | "onChange" | "value"> & {
     value?: string;
     onValueChange?: (search: string) => void;
 } & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/components",
-  "version": "17.3.0",
+  "version": "17.5.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-rc.2",
+    "@objectstack/spec": "^17.0.0-rc.6",
     "@radix-ui/react-accordion": "^1.2.20",
     "@radix-ui/react-alert-dialog": "^1.1.23",
     "@radix-ui/react-aspect-ratio": "^1.1.15",
@@ -60,22 +60,22 @@
     "date-fns": "^4.4.0",
     "embla-carousel-react": "^8.6.0",
     "input-otp": "^1.4.2",
-    "lucide-react": "^1.28.0",
+    "lucide-react": "^1.29.0",
     "next-themes": "^0.4.6",
     "react-day-picker": "^10.0.1",
-    "react-hook-form": "^7.83.0",
+    "react-hook-form": "^7.84.0",
     "react-resizable-panels": "^4.12.2",
     "recharts": "3.10.1",
     "sonner": "^2.0.7",
     "tailwind-merge": "^3.6.0",
     "tailwindcss-animate": "^1.0.7",
     "vaul": "^1.1.2",
-    "@object-ui/core": "17.3.0",
-    "@object-ui/i18n": "17.3.0",
-    "@object-ui/react": "17.3.0",
-    "@object-ui/react-runtime": "17.3.0",
-    "@object-ui/sdui-parser": "17.3.0",
-    "@object-ui/types": "17.3.0"
+    "@object-ui/core": "17.5.0",
+    "@object-ui/i18n": "17.5.0",
+    "@object-ui/react": "17.5.0",
+    "@object-ui/react-runtime": "17.5.0",
+    "@object-ui/sdui-parser": "17.5.0",
+    "@object-ui/types": "17.5.0"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",
@@ -90,10 +90,10 @@
     "@vitejs/plugin-react": "^6.0.5",
     "autoprefixer": "^10.5.4",
     "postcss": "^8.5.26",
-    "shadcn": "^4.16.0",
+    "shadcn": "^4.16.2",
     "tailwindcss": "^4.3.3",
     "typescript": "^6.0.3",
-    "vite": "^8.2.0",
+    "vite": "^8.2.1",
     "vite-plugin-dts": "^5.0.3",
     "zod": "^4.4.3"
   },
@@ -124,7 +124,7 @@
     "prebuild": "pnpm --filter @object-ui/types build && pnpm --filter @object-ui/core build && pnpm --filter @object-ui/react build",
     "pretest": "pnpm run prebuild",
     "test": "vitest run",
-    "type-check": "tsc --noEmit && tsc -p tsconfig.typetests.json",
+    "type-check": "tsc --noEmit && tsc -p tsconfig.test.json",
     "lint": "eslint ."
   }
 }