@object-ui/react 17.7.0 → 18.0.0

package/dist/hooks/usePageAssignment.js

@@ -6,9 +6,10 @@
  * LICENSE file in the root directory of this source tree.
  *
  * `usePageAssignment` — resolve the record PageSchema that should be rendered
- * for a given object. Walks the metadata cache exposed by `<MetadataProvider>`
- * and returns the first PageSchema whose `type === 'record'` and `object`
- * matches the requested name.
+ * for a given object. Walks the metadata cache exposed by `<MetadataProvider>`,
+ * keeps the PageSchemas whose `type === 'record'` and `object` matches the
+ * requested name, and returns the object's DEFAULT record page among them
+ * (`isDefault: true`), else the first of them.
  *
  * Returns a discriminated result by `PageSchema.kind`:
  *   - `kind === 'full'` (default): the schema fully describes the page;
@@ -18,16 +19,44 @@
  *     `buildDefaultPageSchema(objectDef, { slots })` so omitted slots
  *     fall through to synthesized defaults.
  *
- * Selection is by DECLARATION ORDER: the first matching page wins, so callers
- * can deterministically fall back to the auto-generated DetailView when no
- * record Page is authored.
+ * Selection is by the declared `PageSchema.isDefault`, then by DECLARATION
+ * ORDER among pages that are not the default: the spec allows one default
+ * record page per object, so the flag needs no tie-break here, and with no
+ * default the first matching page wins. No match returns null, so callers can
+ * deterministically fall back to the auto-generated DetailView when no record
+ * Page is authored.
  *
  * Future work (deferred): recordType / profile / app / formFactor filtering.
- * Any author-driven ordering would have to be DECLARED on `PageSchema` in
- * `@objectstack/spec` first — see the note on the selection itself below.
+ * Any further author-driven ordering would have to be DECLARED on
+ * `PageSchema` in `@objectstack/spec` first — see the note on the selection
+ * itself below.
  */
 import { useEffect, useMemo, useState } from 'react';
+import { defaultRecordPageObject } from '@objectstack/spec/ui';
 import { useMetadata } from '../context/AppShellContext.js';
+/**
+ * True when `page` is a record page bound to `objectName`: its `type` is
+ * `'record'` and its `object` names that object.
+ *
+ * This is the ONE reading of "a record page of object O" in the console. The
+ * object-based lookup below filters its candidates with it, and a route that
+ * names a page explicitly (the console's named record page route,
+ * objectui#12715) asks it before rendering the named page for a record of O,
+ * so a name that is a page of another object, or not a record page at all, is
+ * refused rather than rendered. The `pageName` override of
+ * {@link usePageAssignment} does not ask it: that option returns the page with
+ * that name whatever it is, and a caller that renders a record on the page it
+ * gets back asks this first.
+ *
+ * `type` is the one discriminator, as the lookup's own comment explains
+ * (objectui#9674): `pageType` is a key `PageSchema` refuses, so it is not read.
+ */
+export function isRecordPageOf(page, objectName) {
+    if (!page || typeof page !== 'object' || !objectName)
+        return false;
+    const p = page;
+    return p.type === 'record' && p.object === objectName;
+}
 function matchesAssignment(_page, _opts) {
     // Placeholder — every page matches until rules-based assignment lands.
     return true;
@@ -91,30 +120,44 @@ export function usePageAssignment(objectName, opts = {}) {
             // designer-side `'record_detail'` is not expressible either: it left
             // `PageTypeSchema` (framework#2265), so `type: 'record_detail'` is an
             // invalid enum value.
-            if (p.type !== 'record')
-                return false;
-            if (p.object !== objectName)
+            if (!isRecordPageOf(p, objectName))
                 return false;
             return matchesAssignment(p, opts);
         });
         if (!candidates.length)
             return null;
-        // Declaration order decides: the first match wins.
+        // The object's DEFAULT record page decides; with none, declaration order.
+        //
+        // At most one `isDefault: true` record page may exist for an object in a
+        // deployment. That is the spec's rule on `PageSchema.isDefault` (maintainer
+        // ruling A on objectstack#23015, record 6134056653), and the platform
+        // refuses a second default, naming both pages, at every door that can add
+        // one: `defineStack` / `composeStacks` (so `os validate` and a source boot),
+        // package registration, and metadata save. So this hook honours the flag
+        // with NO tie-break of its own. It asks `defaultRecordPageObject`, the one
+        // reading of "the default record page of an object" each of those doors
+        // asks, so the page the platform judges to be the default is the page that
+        // opens. Replacing a platform record page stays an ADR-0005 overlay by name
+        // (the same page, not a second default) or host composition; neither a
+        // second default nor an earlier position in the served list overrides one.
         //
-        // This used to sort on a `priority` key read off the candidate. No author
-        // could ever set it: `PageSchema` is a `strictObject` and does not declare
-        // `priority`, so a page carrying one is a HARD PARSE ERROR, not a page that
-        // sorts first. Every candidate therefore read `0`, the comparator returned
-        // `0` for every pair, and a stable sort left declaration order untouched —
-        // the sort documented an affordance the schema refuses (objectui#7298).
+        // Boundary, stated rather than left implicit: at a cold boot every package
+        // registers before the environment's stored pages hydrate, so a stored
+        // default saved while no package held that object's default, and a package
+        // that adds one later, both reach the registry unrefused
+        // (objectstack#23213, closed not_planned). This hook invents no precedence
+        // for that pair (no layer, package or recency rung); served order stays the
+        // only order it has, so the first default served wins.
         //
-        // `isDefault` is not consulted here either. It IS declared on `PageSchema`,
-        // so unlike `priority` it is writable — but nothing in this decision reads
-        // it, which makes the flag on a shipped page (e.g. the platform's
-        // `sys_user_detail`) inert while looking decisive. Reading it would be new
-        // behaviour, not a repair; it is recorded here so the next reader does not
-        // mistake the flag for the thing that picks the page.
-        return candidates[0];
+        // Among pages that are not the default, declaration order is the last
+        // resort: the first match wins. This used to sort on a `priority` key read
+        // off the candidate. No author could ever set it: `PageSchema` is a
+        // `strictObject` and does not declare `priority`, so a page carrying one is
+        // a HARD PARSE ERROR, not a page that sorts first. Every candidate therefore
+        // read `0`, the comparator returned `0` for every pair, and a stable sort
+        // left declaration order untouched — the sort documented an affordance the
+        // schema refuses (objectui#7298).
+        return candidates.find(p => defaultRecordPageObject(p) === objectName) ?? candidates[0];
     }, [meta.pages, objectName, opts.pageName, opts.recordType, opts.profile, opts.app, opts.formFactor]);
     // Discriminate by `kind`: full pages populate `page`, slotted pages
     // populate `slots`. Missing `kind` defaults to 'full' for backwards

package/dist/hooks/useViewData.d.ts

@@ -55,8 +55,10 @@ export interface UseViewDataResult<T = any> {
  *
  * 1. Resolves the ViewData config to the right DataSource adapter
  *    - `provider: 'object'` → context DataSource (ObjectStackAdapter)
- *    - `provider: 'api'`    → ApiDataSource (raw HTTP)
  *    - `provider: 'value'`  → ValueDataSource (in-memory)
+ *    The view-level `provider: 'api'` is retired in `@objectstack/spec`
+ *    (objectstack#23082) and has no arm in `resolveDataSource`: a block that
+ *    still names it is an unknown provider there (objectui#12325).
  * 2. Fetches data automatically on mount
  * 3. Provides loading/error states and refresh capability
  *

package/dist/hooks/useViewData.js

@@ -22,8 +22,10 @@ import { SchemaRendererContext } from '../context/SchemaRendererContext.js';
  *
  * 1. Resolves the ViewData config to the right DataSource adapter
  *    - `provider: 'object'` → context DataSource (ObjectStackAdapter)
- *    - `provider: 'api'`    → ApiDataSource (raw HTTP)
  *    - `provider: 'value'`  → ValueDataSource (in-memory)
+ *    The view-level `provider: 'api'` is retired in `@objectstack/spec`
+ *    (objectstack#23082) and has no arm in `resolveDataSource`: a block that
+ *    still names it is an unknown provider there (objectui#12325).
  * 2. Fetches data automatically on mount
  * 3. Provides loading/error states and refresh capability
  *
@@ -44,30 +46,19 @@ import { SchemaRendererContext } from '../context/SchemaRendererContext.js';
  */
 export function useViewData(options) {
     const { viewData, resource = '', params, dataSource: explicitDataSource, adapterOptions, skip = false, } = options;
-    // Get context DataSource + host-authenticated fetch
+    // Get context DataSource
     const context = useContext(SchemaRendererContext);
     const contextDataSource = context?.dataSource ?? null;
-    const contextApiFetch = context?.apiFetch;
     // Resolve the DataSource — memoize to prevent re-creation on every render.
     // We key on the viewData provider + config identity.
     const resolvedDataSource = useMemo(() => {
         if (explicitDataSource)
             return explicitDataSource;
-        // Default the 'api' provider's fetch to the host's authenticated fetch
-        // (SchemaRendererContext.apiFetch) so custom endpoints carry the same
-        // credentials as native requests; explicit adapterOptions still win.
-        return resolveDataSource(viewData, contextDataSource, {
-            fetch: contextApiFetch,
-            ...adapterOptions,
-        });
+        return resolveDataSource(viewData, contextDataSource, adapterOptions);
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [
         explicitDataSource,
-        contextApiFetch,
         viewData?.provider,
-        // For 'api' provider, key on read/write URLs
-        viewData?.provider === 'api' ? viewData.read?.url : undefined,
-        viewData?.provider === 'api' ? viewData.write?.url : undefined,
         // For 'value' provider, key on items reference (or length as proxy)
         viewData?.provider === 'value' ? viewData.items?.length : undefined,
         contextDataSource,

package/dist/index.d.ts

@@ -12,6 +12,7 @@ export * from './context/index.js';
 export * from './LazyPluginLoader.js';
 export * from './data-invalidation.js';
 export * from './element-data-source/ElementDataSourceGate.js';
+export * from './element-data-source/useElementApiDataSource.js';
 export { resolveKeyedI18nLabel } from './utils/i18n.js';
 export { resolveInlineAriaProps } from './utils/inlineAria.js';
 export { isConfigBag } from './utils/configBag.js';

package/dist/index.js

@@ -14,6 +14,9 @@ export * from './data-invalidation.js';
 // PageComponentSchema.dataSource — mapping the spec's per-element data binding
 // onto the schema keys each object-bound block reads (objectstack#6953).
 export * from './element-data-source/ElementDataSourceGate.js';
+// PageComponentSchema.dataSource as the spec's API binding — the read behind
+// the `data` root `SchemaRenderer` binds for it (objectui#12197).
+export * from './element-data-source/useElementApiDataSource.js';
 // i18n utilities
 export { resolveKeyedI18nLabel } from './utils/i18n.js';
 // The spec's NESTED `aria` bag (`AriaPropsSchema`) → `aria-label` /

package/dist/utils/localeMap.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Is this value an inline locale map, in `InlineLocaleMapSchema`'s sense?
+ *
+ * The member loop first is a fast reject and not a second definition: the
+ * schema requires every value to be a string, so the loop can only turn away
+ * what the schema turns away, and it does so without the schema's per-key
+ * issue reporting. Most data objects carry a non-string member.
+ */
+export declare function isInlineLocaleMap(value: unknown): value is Record<string, string>;
+/** Visit one member. `locale` is the member's key (`en`, `zh-CN`, `default`). */
+export type LocaleMapMemberVisitor = (member: string, locale: string) => unknown;
+/**
+ * Map every member of an inline locale map through `visit` and return the
+ * result, spelled as a string: the map itself when nothing changed (copy on
+ * write).
+ *
+ * The evaluation memo passes the evaluator; the dev diagnostic passes a visitor
+ * that records the member and returns it unchanged.
+ */
+export declare function mapLocaleMapMembers(map: Record<string, string>, visit: LocaleMapMemberVisitor): Record<string, string>;

package/dist/utils/localeMap.js

@@ -0,0 +1,106 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Each member of an inline locale map is evaluated like a plain string on the
+ * same key (objectui#12936).
+ *
+ * ## The rule
+ *
+ * A node's config-bag value that is an INLINE LOCALE MAP - the second
+ * authorized form of the spec's `I18nLabel`, for example
+ * `title: { en: 'Published ${data.at}', 'zh-CN': '...${data.at}' }` - has
+ * every member evaluated by the `SchemaRenderer` evaluation memo, with the same
+ * evaluator and so against the same scope as a plain string on that key:
+ * `record`, `current_user` / `user`, `page`, the host's ambient roots, and
+ * `data` on a node with an API binding. The block then picks one member for
+ * the viewer's language (`pickLocalized`) and draws an evaluated string.
+ *
+ * Before it, the map was a data object to the per-value loops, which hand a
+ * data object over as authored, so the member the block picked kept its
+ * `${...}` and drew it as text. A plain string with the same hole on the same
+ * key was evaluated, so localizing a line was what broke it.
+ *
+ * ## What a locale map is: the spec's answer, not a third one
+ *
+ * {@link isInlineLocaleMap} asks `@objectstack/spec`'s `InlineLocaleMapSchema`,
+ * the schema the contract declares the form with: every key a BCP-47 tag or
+ * `default` (never `key` / `defaultValue`), every value a string. A value with
+ * a non-string member, or with a key that is not a locale tag, is NOT a locale
+ * map: it stays a data object and is handed over as authored, with nothing
+ * inside it evaluated. No other object is walked.
+ *
+ * ⚠️ The boundary that follows from asking the contract: an object whose keys
+ * all parse as locale tags (any two or three letters do, so `{ id, url }`
+ * qualifies) and whose values are all strings IS an inline locale map to the
+ * spec, and so it is one here too, and a `${...}` in its members is evaluated.
+ *
+ * ## Why this module exists
+ *
+ * Two readers must agree on one radius, as they do for `params`
+ * (`paramsBag.ts`): the memo that EVALUATES the members, and the dev
+ * diagnostic (`unevaluatedExpression.ts`) that REPORTS a member still carrying
+ * `${...}` afterwards because its expression threw. Both import this module, so
+ * a member that fails to evaluate is reported exactly as a plain string that
+ * fails is.
+ *
+ * ## The result is still a locale map
+ *
+ * A member's result is spelled as a string. A member that is one whole hole,
+ * `'${data.count}'`, evaluates to the number itself, as a plain string does;
+ * left a number, the member would be skipped by every `pickLocalized` limb
+ * (each reads string entries only) and the viewer would get another locale's
+ * line, or nothing. `String(result ?? '')` is the spelling the evaluator
+ * already gives an interpolated part of a plain string.
+ *
+ * ## Copy on write
+ *
+ * The map is copied only when a member changed, so a map without a hole comes
+ * back as the very object that went in, and the authored map is never mutated.
+ * Nothing may depend on that identity (AGENTS.md #10).
+ */
+import { InlineLocaleMapSchema } from '@objectstack/spec/ui';
+import { isConfigBag } from './configBag.js';
+/**
+ * Is this value an inline locale map, in `InlineLocaleMapSchema`'s sense?
+ *
+ * The member loop first is a fast reject and not a second definition: the
+ * schema requires every value to be a string, so the loop can only turn away
+ * what the schema turns away, and it does so without the schema's per-key
+ * issue reporting. Most data objects carry a non-string member.
+ */
+export function isInlineLocaleMap(value) {
+    if (!isConfigBag(value))
+        return false;
+    for (const member of Object.values(value)) {
+        if (typeof member !== 'string')
+            return false;
+    }
+    return InlineLocaleMapSchema.safeParse(value).success;
+}
+/**
+ * Map every member of an inline locale map through `visit` and return the
+ * result, spelled as a string: the map itself when nothing changed (copy on
+ * write).
+ *
+ * The evaluation memo passes the evaluator; the dev diagnostic passes a visitor
+ * that records the member and returns it unchanged.
+ */
+export function mapLocaleMapMembers(map, visit) {
+    let copy;
+    for (const locale of Object.keys(map)) {
+        const member = map[locale];
+        const result = visit(member, locale);
+        const next = typeof result === 'string' ? result : String(result ?? '');
+        if (next !== member) {
+            if (!copy)
+                copy = { ...map };
+            copy[locale] = next;
+        }
+    }
+    return copy ?? map;
+}

package/dist/utils/propsBagDiagnostic.js

@@ -34,8 +34,9 @@ import { isConfigBag } from './configBag.js';
  * (objectui#6665): the `props` leg renders `No results found`, the `properties`
  * leg renders the rows.
  *
- * Every gate accepts the `props` spelling — `BaseSchema` is `.passthrough()`
- * with `[key: string]: any` — and `props` is documented as the annotated legacy
+ * The tolerant gates accept the `props` spelling — the zod `BaseSchema` is
+ * `.passthrough()`, and the TS face admitted it through `[key: string]: any`
+ * until objectui#8347 (a typed literal refuses it now) — and `props` is documented as the annotated legacy
  * alias of the config bag, so nothing between the author and the screen says a
  * word. That is the success-receipt shape objectui#6575 and objectui#6665 exist
  * to remove; this is the third instance, and the first at a tier that covers

package/dist/utils/unevaluatedExpression.d.ts

@@ -18,7 +18,9 @@ export type UnevaluatedChannel = 'schema' | 'properties' | 'props';
 export interface UnevaluatedExpressionFinding {
     /**
      * The key holding the raw source — or, for a leaf of a `params` bag, that
-     * leaf's path from the bag (`params.target.id`, `params.ids[0]`).
+     * leaf's path from the bag (`params.target.id`, `params.ids[0]`), or, for a
+     * member of an inline locale map, the key and the member's locale
+     * (`title.zh-CN`).
      */
     key: string;
     /** The authored channel the key was read from. */

package/dist/utils/unevaluatedExpression.js

@@ -6,6 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 import { isConfigBag } from './configBag.js';
+import { isInlineLocaleMap, mapLocaleMapMembers } from './localeMap.js';
 import { PARAMS_KEY, isParamsBag, mapParamsLeaves } from './paramsBag.js';
 /**
  * Dev-build diagnostic: an UNEVALUATED template expression reached the DOM.
@@ -65,6 +66,13 @@ import { PARAMS_KEY, isParamsBag, mapParamsLeaves } from './paramsBag.js';
  * that still cannot resolve is reported by its path (`params.target.id`,
  * `properties.params.ids[0]`). Radius equal to evaluation by construction,
  * not by two copies agreeing; every other key stays shallow on both sides.
+ *
+ * And for exactly ONE value shape, one level deep: an inline locale map
+ * (objectui#12936). Each member is evaluated like a plain string on the same
+ * key, so each member is scanned like one, through the same recogniser and
+ * walker (`localeMap.ts`), and a member whose expression threw is reported by
+ * its locale (`properties.title.zh-CN`). Any other object stays unscanned, as
+ * it stays unevaluated.
  */
 /** What counts as an expression — the evaluator's own definition. */
 const EXPRESSION_PATTERN = /\$\{([^}]+)\}/g;
@@ -111,6 +119,16 @@ function scanBag(bag, channel, into, skip) {
             });
             continue;
         }
+        // objectui#12936 — an inline locale map's members are evaluated like plain
+        // strings, so they are scanned like them, through the evaluator's own
+        // recogniser and walker. The visitor returns each member unchanged.
+        if (isInlineLocaleMap(value)) {
+            mapLocaleMapMembers(value, (member, locale) => {
+                pushIfUnevaluated(key + '.' + locale, channel, member, into);
+                return member;
+            });
+            continue;
+        }
         if (typeof value !== 'string')
             continue;
         pushIfUnevaluated(key, channel, value, into);

package/dist/utils/visibilityDiagnostic.d.ts

@@ -14,8 +14,8 @@
  * ## The defect this names
  *
  * `SchemaRenderer`'s visibility chain is FAIL-SOFT: `evaluateCondition` answers
- * an unevaluable predicate with `true`. On the four negated legs (`visible` /
- * `visibleWhen` / `visibleOn` / `visibility`) that `true` means SHOWN — so "this
+ * an unevaluable predicate with `true`. On the negated legs (`visible` /
+ * `visibleWhen` / `visibleOn`) that `true` means SHOWN — so "this
  * predicate is broken" and "this predicate said yes" reach the screen as the
  * same pixel. An author who mistyped a root, or who wrote a `record.*` gate
  * before objectui#5454 bound the row, saw their block render and had no signal
@@ -136,7 +136,7 @@ export type PredicateScopeTier = 'page-component' | 'app-shell';
  * to the node is not a property of the predicate - it is a property of the gate
  * it was authored on, and the consequence paragraph has to say which:
  *
- * `'visibility'` - the visibility chain. Its `true` means SHOWN on the four
+ * `'visibility'` - the visibility chain. Its `true` means SHOWN on the
  * negated legs, so the safe default does NOT bite: a predicate that could not be
  * evaluated reads on screen exactly like one that said yes, which is why the
  * console line is the only signal an author gets.
@@ -180,10 +180,19 @@ export type PredicateScopeTier = 'page-component' | 'app-shell';
  * package entry, and the chain stops there (no sibling package re-exports it,
  * and no file outside `packages/react` names it). A consumer switching
  * EXHAUSTIVELY over the union, or holding a `Record<PredicateGateKind, ...>`,
- * gains a third case to answer. That is a type-level change only: no runtime
+ * gains a case to answer. That is a type-level change only: no runtime
  * signature moved, and every value that was accepted before still is.
+ *
+ * `'withholding'` - the app-shell's navigation `visible` gate (objectui#12700).
+ * A visibility predicate on a navigation entry, but one whose FAULT is answered
+ * fail-CLOSED: the shell withholds an entry whose gate it cannot evaluate (most
+ * often a `current_user.can(...)` asked before the permissions payload is
+ * there) instead of drawing it for everyone. So the default BITES, and the
+ * sentence `'visibility'` prints - "reads on screen exactly like one that said
+ * yes" - would be the opposite of what the member sees. Same opening line as
+ * `'visibility'`, for the same reason `'concealment'` keeps it.
  */
-export type PredicateGateKind = 'visibility' | 'enablement' | 'concealment';
+export type PredicateGateKind = 'visibility' | 'enablement' | 'concealment' | 'withholding';
 /**
  * Build the message. Separate from the emit so a test can assert the words,
  * not merely that something was logged.

package/dist/utils/visibilityDiagnostic.js

@@ -14,8 +14,8 @@
  * ## The defect this names
  *
  * `SchemaRenderer`'s visibility chain is FAIL-SOFT: `evaluateCondition` answers
- * an unevaluable predicate with `true`. On the four negated legs (`visible` /
- * `visibleWhen` / `visibleOn` / `visibility`) that `true` means SHOWN — so "this
+ * an unevaluable predicate with `true`. On the negated legs (`visible` /
+ * `visibleWhen` / `visibleOn`) that `true` means SHOWN — so "this
  * predicate is broken" and "this predicate said yes" reach the screen as the
  * same pixel. An author who mistyped a root, or who wrote a `record.*` gate
  * before objectui#5454 bound the row, saw their block render and had no signal
@@ -135,6 +135,14 @@ const GATE_KIND_COPY = {
             'in the renderer: the block is missing because the predicate above could\n' +
             'not be evaluated.\n',
     },
+    // The app-shell navigation gate (objectui#12700): fail-CLOSED on a fault.
+    withholding: {
+        prefix: UNRESOLVABLE_VISIBILITY_PREFIX,
+        consequence: 'The entry was treated as its safe default, which on THIS gate is the one\n' +
+            'that BITES: a navigation entry whose predicate cannot be evaluated is\n' +
+            'WITHHELD - not drawn - until it can be, so a missing entry may be this\n' +
+            'fault rather than a gate that said no.\n',
+    },
     enablement: {
         prefix: UNRESOLVABLE_ENABLEMENT_PREFIX,
         consequence: 'The node was treated as its safe default, which on THIS gate is the one\n' +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/react",
-  "version": "17.7.0",
+  "version": "18.0.0",
   "type": "module",
   "license": "MIT",
   "description": "React bindings and SchemaRenderer component for Object UI",
@@ -24,11 +24,11 @@
     }
   },
   "dependencies": {
-    "@objectstack/spec": "^17.1.0",
-    "@object-ui/data-objectstack": "17.7.0",
-    "@object-ui/types": "17.7.0",
-    "@object-ui/core": "17.7.0",
-    "@object-ui/i18n": "17.7.0"
+    "@objectstack/spec": "^18.0.0",
+    "@object-ui/data-objectstack": "18.0.0",
+    "@object-ui/types": "18.0.0",
+    "@object-ui/core": "18.0.0",
+    "@object-ui/i18n": "18.0.0"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",