@object-ui/core 16.0.0 → 17.1.0

package/dist/evaluator/SafeExpressionParser.js

@@ -298,7 +298,10 @@ export class SafeExpressionParser {
         this.skipWhitespace();
         // eslint-disable-next-line no-constant-condition
         while (true) {
-            let op = null;
+            // Every branch below either assigns `op` or `break`s out of the loop, so
+            // `op` is always set by the time the switch reads it (no null initializer
+            // needed).
+            let op;
             if (this.peek() === '=' && this.peek(1) === '=' && this.peek(2) === '=') {
                 op = '===';
                 this.pos += 3;
@@ -648,7 +651,7 @@ export class SafeExpressionParser {
         // Optional exponent: e+5, E-3
         if (/[eE]/.test(this.source[this.pos] ?? '')) {
             this.pos++; // consume 'e' or 'E'
-            if (/[+\-]/.test(this.source[this.pos] ?? ''))
+            if (/[+-]/.test(this.source[this.pos] ?? ''))
                 this.pos++; // optional sign
             let expDigits = 0;
             while (this.pos < this.source.length && /\d/.test(this.source[this.pos])) {

package/dist/evaluator/fieldRules.d.ts

@@ -37,8 +37,6 @@ export declare function resolveFieldRuleState(rules: {
     visibleWhen?: FieldRulePredicate;
     readonlyWhen?: FieldRulePredicate;
     requiredWhen?: FieldRulePredicate;
-    /** Back-compat alias of `requiredWhen` (spec @deprecated). */
-    conditionalRequired?: FieldRulePredicate;
 }, record: Record<string, unknown>, statics: {
     required?: boolean;
     readonly?: boolean;

package/dist/evaluator/fieldRules.js

@@ -79,8 +79,9 @@ export function resolveFieldRuleState(rules, record, statics, previous, scope) {
         (rules.readonlyWhen != null
             ? evalFieldPredicate(rules.readonlyWhen, record, false, previous, scope)
             : false);
-    const requiredPred = rules.requiredWhen ?? rules.conditionalRequired;
     const required = statics.required === true ||
-        (requiredPred != null ? evalFieldPredicate(requiredPred, record, false, previous, scope) : false);
+        (rules.requiredWhen != null
+            ? evalFieldPredicate(rules.requiredWhen, record, false, previous, scope)
+            : false);
     return { visible, readonly, required };
 }

package/dist/evaluator/optionLint.js

@@ -109,7 +109,10 @@ export function lintOptionPredicates(fields) {
             continue;
         knownFields.add(f.name);
         if (OPTION_FIELD_TYPES.has(fieldType(f)) && f.options && f.options.length > 0) {
-            domainByField.set(f.name, new Set(f.options.map((o) => o.value)));
+            // Values stringify at this boundary (#3090 widened OptionLike.value):
+            // the domain is compared against CEL literal TEXT, so the canonical
+            // string form is the right footing for numeric/boolean options too.
+            domainByField.set(f.name, new Set(f.options.map((o) => String(o.value))));
         }
     }
     const issues = [];
@@ -123,7 +126,7 @@ export function lintOptionPredicates(fields) {
             const source = predicateSource(opt.visibleWhen);
             if (!source.trim())
                 continue;
-            const option = opt.value;
+            const option = String(opt.value); // report key — display form (#3090)
             // 1. Syntax — canonical CEL parse (no schema hint = no scope false-positives).
             const parsed = validateExpression('predicate', source);
             if (!parsed.ok) {

package/dist/evaluator/optionRules.d.ts

@@ -28,6 +28,7 @@
  * security boundary: when an option is gated for access-control reasons the
  * server must also reject writes of its value.
  */
+import type { DependsOnInput } from '@object-ui/types';
 import { type FieldRulePredicate } from './fieldRules.js';
 /**
  * Minimal shape of a select/radio option this module reads. Deliberately has no
@@ -36,15 +37,21 @@ import { type FieldRulePredicate } from './fieldRules.js';
  */
 export interface OptionLike {
     label: string;
-    value: string;
+    /** Widened with `SelectOption.value` (#3090): the option engines treat the
+     * value opaquely (gate/filter by `visibleWhen`, compare by identity), so a
+     * numeric/boolean authored value flows through unchanged. */
+    value: string | number | boolean;
     /** Per-option visibility predicate (CEL). Omit = always available. */
     visibleWhen?: FieldRulePredicate;
 }
-/** A field's `dependsOn` as authored: a bare name, or a list of names / `{field,param}`. */
-export type DependsOnInput = string | Array<string | {
-    field: string;
-    param?: string;
-}> | undefined | null;
+/**
+ * A field's `dependsOn` as authored — imported from `@object-ui/types`, where
+ * `FormField.dependsOn` is declared with it (framework#4074; formerly a local
+ * declaration that only the reader knew about, while the public
+ * `FormField.dependsOn` said `string`). Re-exported for this module's existing
+ * consumers.
+ */
+export type { DependsOnInput } from '@object-ui/types';
 /**
  * Normalize a field's `dependsOn` to the list of sibling field names it reacts
  * to. The lookup-only `{field,param}` form contributes just its `field`.
@@ -68,3 +75,25 @@ export declare function resolveVisibleOptions<T extends OptionLike>(options: rea
  * no longer offered). An empty value is always "valid" (nothing to clear).
  */
 export declare function isValueStillOffered(value: unknown, visibleOptions: readonly OptionLike[]): boolean;
+/** The resolved state of a cascading / role-gated option list. */
+export interface CascadingOptions<T extends OptionLike> {
+    /** Offered options after `visibleWhen` filtering. Empty while gated. */
+    options: T[];
+    /** True when a declared `dependsOn` field is empty — the list is gated. */
+    gated: boolean;
+    /** Normalized `dependsOn` field names (drives the "select the parent first" hint). */
+    dependsOnFields: string[];
+}
+/**
+ * Resolve an option field's offered set in one shot: normalize `dependsOn`,
+ * decide whether the list is gated (a controlling field is still empty), and —
+ * unless gated — filter by each option's `visibleWhen`. The single source of
+ * truth behind the option widgets' `useCascadingOptions` hook and the form
+ * renderer's inline pre-filter / cascade-clear, so gating and filtering can
+ * never drift between them (#2715).
+ *
+ * `gated` is true only when there IS a `dependsOn` and one of its fields is
+ * empty; a field with no `dependsOn` is never gated (its options are filtered
+ * purely by `visibleWhen`). Callers format their own hint from `dependsOnFields`.
+ */
+export declare function resolveCascadingOptions<T extends OptionLike>(rawOptions: readonly T[] | undefined | null, record: Record<string, unknown>, dependsOn: DependsOnInput, scope?: Record<string, unknown>): CascadingOptions<T>;

package/dist/evaluator/optionRules.js

@@ -5,29 +5,6 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-/**
- * Client-side resolution of per-option visibility for `select` / `radio` /
- * `multiselect` fields — cascading (dependent) options and role/context gating.
- *
- * An option carries an optional `visibleWhen` CEL predicate; the option is
- * offered only when it evaluates TRUE against the live record + `current_user`
- * (the SAME engine and binding environment as a field-level `visibleWhen`, via
- * {@link evalFieldPredicate}). This expresses both:
- *   - cascades — `record.country == 'cn'` (the dependent list narrows as the
- *     controlling field changes), and
- *   - role/context gating — `'admin' in current_user.positions`.
- *
- * A field declares which sibling fields its option list reacts to via
- * `dependsOn` (aligns with `@objectstack/spec` Field.dependsOn — the same knob
- * lookups use). While any dependency is empty the list is *gated*: we surface a
- * "select the parent first" hint instead of an unfiltered set, mirroring the
- * dependent-lookup UX (#2215).
- *
- * Evaluation is fail-open (a broken/absent predicate keeps the option) — the
- * same safe default as field visibility. Client-side hiding is UX, not a
- * security boundary: when an option is gated for access-control reasons the
- * server must also reject writes of its value.
- */
 import { evalFieldPredicate } from './fieldRules.js';
 /**
  * Normalize a field's `dependsOn` to the list of sibling field names it reacts
@@ -78,3 +55,21 @@ export function isValueStillOffered(value, visibleOptions) {
     }
     return visibleOptions.some((o) => o.value === value);
 }
+/**
+ * Resolve an option field's offered set in one shot: normalize `dependsOn`,
+ * decide whether the list is gated (a controlling field is still empty), and —
+ * unless gated — filter by each option's `visibleWhen`. The single source of
+ * truth behind the option widgets' `useCascadingOptions` hook and the form
+ * renderer's inline pre-filter / cascade-clear, so gating and filtering can
+ * never drift between them (#2715).
+ *
+ * `gated` is true only when there IS a `dependsOn` and one of its fields is
+ * empty; a field with no `dependsOn` is never gated (its options are filtered
+ * purely by `visibleWhen`). Callers format their own hint from `dependsOnFields`.
+ */
+export function resolveCascadingOptions(rawOptions, record, dependsOn, scope) {
+    const dependsOnFields = resolveDependsOnFields(dependsOn);
+    const gated = dependsOnFields.length > 0 && isOptionGroupGated(dependsOn, record);
+    const options = gated ? [] : resolveVisibleOptions(rawOptions, record, scope);
+    return { options, gated, dependsOnFields };
+}

package/dist/index.d.ts

@@ -14,8 +14,11 @@ export * from './registry/WidgetRegistry.js';
 export * from './validation/index.js';
 export * from './builder/schema-builder.js';
 export * from './utils/filter-converter.js';
+export * from './utils/managedBy.js';
 export * from './utils/extract-records.js';
 export * from './utils/expand-fields.js';
+export * from './utils/column-identity.js';
+export * from './utils/sort-values.js';
 export * from './evaluator/index.js';
 export * from './actions/index.js';
 export * from './query/index.js';
@@ -39,6 +42,7 @@ export * from './runtime/capabilities.js';
 export { composeStacks } from '@objectstack/spec';
 export * from './utils/drill-down.js';
 export * from './utils/date-macros.js';
+export * from './utils/filter-tokens.js';
 export * from './utils/dashboard-filters.js';
 export * from './utils/merge-filters.js';
 export * from './utils/compare-to.js';
@@ -47,3 +51,4 @@ export * from './utils/dataset-format.js';
 export * from './utils/record-title.js';
 export * from './utils/export-filename.js';
 export * from './utils/reference-keys.js';
+export * from './utils/normalize-list-view.js';

package/dist/index.js

@@ -13,8 +13,11 @@ export * from './registry/WidgetRegistry.js';
 export * from './validation/index.js';
 export * from './builder/schema-builder.js';
 export * from './utils/filter-converter.js';
+export * from './utils/managedBy.js';
 export * from './utils/extract-records.js';
 export * from './utils/expand-fields.js';
+export * from './utils/column-identity.js';
+export * from './utils/sort-values.js';
 export * from './evaluator/index.js';
 export * from './actions/index.js';
 export * from './query/index.js';
@@ -38,6 +41,10 @@ export * from './runtime/capabilities.js';
 export { composeStacks } from '@objectstack/spec';
 export * from './utils/drill-down.js';
 export * from './utils/date-macros.js';
+// Session-scoped filter placeholders ({current_user_id} / {current_org_id})
+// plus `resolveFilterPlaceholders`, the single entry point every surface
+// should call so no vocabulary is silently skipped (framework #3574).
+export * from './utils/filter-tokens.js';
 export * from './utils/dashboard-filters.js';
 export * from './utils/merge-filters.js';
 export * from './utils/compare-to.js';
@@ -46,3 +53,4 @@ export * from './utils/dataset-format.js';
 export * from './utils/record-title.js';
 export * from './utils/export-filename.js';
 export * from './utils/reference-keys.js';
+export * from './utils/normalize-list-view.js';

package/dist/registry/Registry.d.ts

@@ -62,6 +62,22 @@ export type ComponentConfig<T = any> = ComponentMeta & {
     type: string;
     component: ComponentRenderer<T>;
 };
+/**
+ * A CONTRACT-surface entry (ADR-0080), as returned by
+ * {@link Registry.getPublicConfigs}.
+ *
+ * Same shape as {@link ComponentConfig} except `component` is absent while the
+ * entry is still a pending `registerLazy` stub: the plugin module has not been
+ * imported yet, so there is no renderer to hand out. Consumers render such an
+ * entry through `SchemaRenderer`, which triggers the loader and shows a
+ * placeholder in the meantime (objectui#2953).
+ */
+export type PublicComponentConfig<T = any> = ComponentMeta & {
+    type: string;
+    component?: ComponentRenderer<T>;
+    /** True while this entry is a `registerLazy` stub whose loader has not run. */
+    lazy?: boolean;
+};
 /**
  * Lazy loader function used by `Registry.registerLazy`. The loader is invoked
  * the first time a missing component type is requested through `getAsync`/the
@@ -79,6 +95,14 @@ export declare class Registry<T = any> {
      * load completes.
      */
     private listeners;
+    /**
+     * Bumped whenever the set of KNOWN types changes — a registration, an
+     * unregistration, or a new lazy stub. A cheap cache key for consumers that
+     * derive something from the whole registry (whitelists, manifests, palettes)
+     * and need to rebuild when it grows. Counting types is not a substitute: a
+     * registration paired with an unregistration leaves the count untouched.
+     */
+    private version;
     /**
      * Register a component with optional namespace support.
      * If namespace is provided in meta, the component will be registered as "namespace:type".
@@ -141,6 +165,11 @@ export declare class Registry<T = any> {
      */
     subscribe(listener: () => void): () => void;
     private notify;
+    /**
+     * Monotonic counter of changes to the set of known types. Rebuild anything
+     * derived from the whole registry when this moves — see {@link getKnownTypes}.
+     */
+    getVersion(): number;
     /**
      * Get a component by type. Supports both namespaced and non-namespaced lookups.
      *
@@ -164,6 +193,13 @@ export declare class Registry<T = any> {
     /**
      * Get component configuration by type with namespace support.
      *
+     * LOADED registrations only — a type that exists solely as a `registerLazy`
+     * stub returns `undefined` here, because callers read `.component` off the
+     * result and a stub has no renderer until its loader runs. The *contract*
+     * question ("is this tag part of the public surface?") must not depend on
+     * load order, so {@link getPublicConfigs} resolves lazy stubs separately
+     * (objectui#2953). Use {@link hasLazy} / {@link loadLazy} to reach a stub.
+     *
      * @param type - Component type (e.g., 'button' or 'ui:button')
      * @param namespace - Optional namespace for lookup priority
      * @returns Component configuration or undefined
@@ -178,23 +214,66 @@ export declare class Registry<T = any> {
      */
     has(type: string, namespace?: string): boolean;
     /**
-     * Get all registered component types.
+     * Get all LOADED component types — what can be rendered right now.
+     *
+     * Pending `registerLazy` stubs are not included; use {@link getKnownTypes}
+     * for the question "is this a type this app knows about", which is what a
+     * whitelist or manifest wants (objectui#2953).
      *
      * @returns Array of all component type identifiers
      */
     getAllTypes(): string[];
+    /**
+     * Every type the registry can resolve — loaded registrations PLUS pending
+     * lazy stubs, deduped. Both the bare and namespaced keys are included, as
+     * they are in {@link getAllTypes}.
+     *
+     * This is the set to build a whitelist or a manifest from. Keying one off
+     * `getAllTypes()` instead makes it depend on which plugin chunks happen to
+     * have loaded: a lazily-registered block gets rejected as unknown, and
+     * whether it does varies by session (objectui#2953).
+     */
+    getKnownTypes(): string[];
+    /**
+     * Metadata for `type` — from the loaded registration when there is one,
+     * otherwise from a pending `registerLazy` stub.
+     *
+     * Use this when you need to know what a type IS (namespace, container-ness,
+     * declared inputs). {@link getConfig} answers a different question — "can I
+     * render this right now" — and is deliberately loaded-only, since callers
+     * read `.component` off it.
+     *
+     * A stub carries only what `registerLazy` was given, so `inputs` is usually
+     * absent until the chunk loads. Consumers should treat that as "not yet
+     * known", not as "declares no props".
+     */
+    getMeta(type: string, namespace?: string): ComponentMeta | undefined;
     /**
      * Get all registered component configurations.
      *
      * @returns Array of all component configurations
      */
     getAllConfigs(): ComponentConfig<T>[];
+    /**
+     * Resolve `tag` for the CONTRACT surface: the loaded registration when the
+     * component is already in the registry, otherwise the metadata of a pending
+     * `registerLazy` stub.
+     *
+     * A block registered lazily is a first-class member of the contract — the
+     * loader is recorded at boot and the plugin chunk is imported on first use —
+     * so contract membership must not hinge on whether that import happened to
+     * have run yet (objectui#2953).
+     */
+    private getContractConfig;
     /**
      * Get the curated PUBLIC-tier component configs (ADR-0080) — those registered
      * with `tier: 'public'`. This is the contract/AI-vocabulary surface, a subset
      * of the full rendering capability returned by {@link getAllConfigs}.
+     *
+     * Includes blocks that are only lazily registered so far; those come back
+     * with `lazy: true` and no `component` (see {@link PublicComponentConfig}).
      */
-    getPublicConfigs(): ComponentConfig<T>[];
+    getPublicConfigs(): PublicComponentConfig<T>[];
     /**
      * Get all components in a specific namespace.
      *

package/dist/registry/Registry.js

@@ -31,6 +31,19 @@ export class Registry {
             writable: true,
             value: new Set()
         });
+        /**
+         * Bumped whenever the set of KNOWN types changes — a registration, an
+         * unregistration, or a new lazy stub. A cheap cache key for consumers that
+         * derive something from the whole registry (whitelists, manifests, palettes)
+         * and need to rebuild when it grows. Counting types is not a substitute: a
+         * registration paired with an unregistration leaves the count untouched.
+         */
+        Object.defineProperty(this, "version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
     }
     /**
      * Register a component with optional namespace support.
@@ -144,6 +157,10 @@ export class Registry {
         if (meta?.namespace && !meta?.skipFallback) {
             this.lazyEntries.set(type, entry);
         }
+        // Bump the version but do NOT notify: the set of KNOWN types grew, so
+        // whitelists and manifests must rebuild, but nothing new can render yet —
+        // waking every subscriber for each stub at boot would be pure churn.
+        this.version++;
     }
     /**
      * Returns true if `type` (or its namespaced form) has a registered lazy
@@ -186,6 +203,7 @@ export class Registry {
         };
     }
     notify() {
+        this.version++;
         for (const listener of this.listeners) {
             try {
                 listener();
@@ -195,6 +213,13 @@ export class Registry {
             }
         }
     }
+    /**
+     * Monotonic counter of changes to the set of known types. Rebuild anything
+     * derived from the whole registry when this moves — see {@link getKnownTypes}.
+     */
+    getVersion() {
+        return this.version;
+    }
     /**
      * Get a component by type. Supports both namespaced and non-namespaced lookups.
      *
@@ -226,6 +251,13 @@ export class Registry {
     /**
      * Get component configuration by type with namespace support.
      *
+     * LOADED registrations only — a type that exists solely as a `registerLazy`
+     * stub returns `undefined` here, because callers read `.component` off the
+     * result and a stub has no renderer until its loader runs. The *contract*
+     * question ("is this tag part of the public surface?") must not depend on
+     * load order, so {@link getPublicConfigs} resolves lazy stubs separately
+     * (objectui#2953). Use {@link hasLazy} / {@link loadLazy} to reach a stub.
+     *
      * @param type - Component type (e.g., 'button' or 'ui:button')
      * @param namespace - Optional namespace for lookup priority
      * @returns Component configuration or undefined
@@ -256,13 +288,47 @@ export class Registry {
         return this.components.has(type);
     }
     /**
-     * Get all registered component types.
+     * Get all LOADED component types — what can be rendered right now.
+     *
+     * Pending `registerLazy` stubs are not included; use {@link getKnownTypes}
+     * for the question "is this a type this app knows about", which is what a
+     * whitelist or manifest wants (objectui#2953).
      *
      * @returns Array of all component type identifiers
      */
     getAllTypes() {
         return Array.from(this.components.keys());
     }
+    /**
+     * Every type the registry can resolve — loaded registrations PLUS pending
+     * lazy stubs, deduped. Both the bare and namespaced keys are included, as
+     * they are in {@link getAllTypes}.
+     *
+     * This is the set to build a whitelist or a manifest from. Keying one off
+     * `getAllTypes()` instead makes it depend on which plugin chunks happen to
+     * have loaded: a lazily-registered block gets rejected as unknown, and
+     * whether it does varies by session (objectui#2953).
+     */
+    getKnownTypes() {
+        return Array.from(new Set([...this.components.keys(), ...this.lazyEntries.keys()]));
+    }
+    /**
+     * Metadata for `type` — from the loaded registration when there is one,
+     * otherwise from a pending `registerLazy` stub.
+     *
+     * Use this when you need to know what a type IS (namespace, container-ness,
+     * declared inputs). {@link getConfig} answers a different question — "can I
+     * render this right now" — and is deliberately loaded-only, since callers
+     * read `.component` off it.
+     *
+     * A stub carries only what `registerLazy` was given, so `inputs` is usually
+     * absent until the chunk loads. Consumers should treat that as "not yet
+     * known", not as "declares no props".
+     */
+    getMeta(type, namespace) {
+        const key = namespace ? `${namespace}:${type}` : type;
+        return this.components.get(key) ?? this.lazyEntries.get(key)?.meta;
+    }
     /**
      * Get all registered component configurations.
      *
@@ -271,10 +337,39 @@ export class Registry {
     getAllConfigs() {
         return Array.from(this.components.values());
     }
+    /**
+     * Resolve `tag` for the CONTRACT surface: the loaded registration when the
+     * component is already in the registry, otherwise the metadata of a pending
+     * `registerLazy` stub.
+     *
+     * A block registered lazily is a first-class member of the contract — the
+     * loader is recorded at boot and the plugin chunk is imported on first use —
+     * so contract membership must not hinge on whether that import happened to
+     * have run yet (objectui#2953).
+     */
+    getContractConfig(tag) {
+        const loaded = this.components.get(tag);
+        if (loaded)
+            return loaded;
+        const entry = this.lazyEntries.get(tag);
+        if (!entry)
+            return undefined;
+        // Mirror registerLazy's key derivation so the canonical `type` matches the
+        // one `register()` will store once the loader runs — that keeps the dedupe
+        // below stable across the load. `tag` may already carry the namespace
+        // (lazyEntries holds both keys; curated tags like `record:details` are
+        // themselves colon-shaped), so don't prefix it twice.
+        const ns = entry.meta?.namespace;
+        const canonical = ns && !tag.startsWith(`${ns}:`) ? `${ns}:${tag}` : tag;
+        return { ...entry.meta, type: canonical, lazy: true };
+    }
     /**
      * Get the curated PUBLIC-tier component configs (ADR-0080) — those registered
      * with `tier: 'public'`. This is the contract/AI-vocabulary surface, a subset
      * of the full rendering capability returned by {@link getAllConfigs}.
+     *
+     * Includes blocks that are only lazily registered so far; those come back
+     * with `lazy: true` and no `component` (see {@link PublicComponentConfig}).
      */
     getPublicConfigs() {
         // Dedupe by the config's canonical (namespaced) `type` — a component is
@@ -292,12 +387,17 @@ export class Registry {
         };
         // Curated contract list first (stable, reviewable order) …
         for (const tag of PUBLIC_BLOCKS)
-            add(tag, this.getConfig(tag));
+            add(tag, this.getContractConfig(tag));
         // … plus any bare registration that opted in explicitly via `tier: 'public'`.
         for (const [key, cfg] of this.components.entries()) {
             if (cfg.tier === 'public' && !key.includes(':'))
                 add(key, cfg);
         }
+        // … and the same opt-in for stubs whose loader has not run yet.
+        for (const [key, entry] of this.lazyEntries.entries()) {
+            if (entry.meta?.tier === 'public' && !key.includes(':'))
+                add(key, this.getContractConfig(key));
+        }
         return out;
     }
     /**

package/dist/registry/public-blocks.js

@@ -42,7 +42,58 @@ export const PUBLIC_BLOCKS = [
     'record:highlights',
     'record:related_list',
     'record:path',
-    'line_items',
+    // `record:`-prefixed, like its four siblings above. @object-ui/plugin-form
+    // registers this one with `skipFallback: true`, so the bare `line_items` key
+    // it was listed under here never existed — the block has shipped all along
+    // but could never resolve through the contract (objectui#2953 follow-up).
+    'record:line_items',
+    // Configurable as of objectui#3023 follow-up: these shipped with renderers
+    // but no declared `inputs`, so a model could only emit them bare — which is
+    // why they sat outside the contract. Their inputs now mirror what the
+    // renderers actually read, so they are authorable and belong here.
+    //
+    // `record:chatter` is deliberately NOT in this list: it is the same renderer
+    // as `record:discussion` under a Salesforce-familiar name, kept for schemas
+    // already in the wild. Two spellings of one block is ambiguity an authoring
+    // model has no way to resolve, so the vocabulary carries the spec's name.
+    'record:activity',
+    'record:discussion',
+    'record:history',
+    'record:quick_actions',
+    'record:reference_rail',
+    'record:alert',
+    // ── Tier A, continued — page-semantic blocks (the spec ui/page vocabulary) ─
+    // The `page:` / `element:` / `action:` families the Studio page designer
+    // offers and @objectstack/spec's page schema enumerates. Same standing as
+    // the `record:` family above: semantic page blocks, not primitives.
+    //
+    // Deliberately NOT here (each guarded, with its reason, by the console's
+    // reverse-coverage test):
+    //   action:bar               record:quick_actions covers the record action
+    //                            strip, and the spec blesses button/group/icon/
+    //                            menu but not bar
+    //   element:image            duplicates the curated `image` primitive below —
+    //                            one spelling per concept
+    //   element:record_picker    record picking is a field widget, not a page
+    //                            block (Studio palette exclusion)
+    //   element:text_input       bare inputs belong to a form, not a page block
+    //                            (Studio palette exclusion)
+    //   element:metadata_viewer  internal metadata debugging surface
+    'page:tabs',
+    'page:card',
+    'page:accordion',
+    'page:section',
+    'page:footer',
+    'page:sidebar',
+    'element:text',
+    'element:number',
+    'element:button',
+    'element:definition-list',
+    'element:repeater',
+    'action:button',
+    'action:group',
+    'action:menu',
+    'action:icon',
     // ── Tier B — layout / content primitives ──────────────────────────────────
     'flex',
     'grid',

package/dist/theme/ThemeEngine.js

@@ -316,10 +316,6 @@ export function mergeThemes(parent, child) {
         shadows: child.shadows || parent.shadows
             ? { ...parent.shadows, ...child.shadows }
             : undefined,
-        // Deep-merge breakpoints
-        breakpoints: child.breakpoints || parent.breakpoints
-            ? { ...parent.breakpoints, ...child.breakpoints }
-            : undefined,
         // Deep-merge animation
         animation: child.animation || parent.animation
             ? {
@@ -339,18 +335,10 @@ export function mergeThemes(parent, child) {
         zIndex: child.zIndex || parent.zIndex
             ? { ...parent.zIndex, ...child.zIndex }
             : undefined,
-        // Deep-merge spacing
-        spacing: child.spacing || parent.spacing
-            ? { ...parent.spacing, ...child.spacing }
-            : undefined,
         // Deep-merge customVars
         customVars: child.customVars || parent.customVars
             ? { ...parent.customVars, ...child.customVars }
             : undefined,
-        // Deep-merge logo
-        logo: child.logo || parent.logo
-            ? { ...parent.logo, ...child.logo }
-            : undefined,
     };
 }
 /**

package/dist/utils/chart-series.d.ts

@@ -89,6 +89,34 @@ export declare function findChartSeriesRow(rows: Array<Record<string, unknown>>
  * paint identically across the chart view and dashboard widgets.
  */
 export declare function buildOptionColorMap(options: unknown): Record<string, string> | null;
+/**
+ * Build the DECLARED category order from a select field's `options` — the
+ * sequence the author wrote them in on the object (framework#3588).
+ *
+ * A picklist's option order is already the domain order: a sales `stage` field
+ * lists Qualification → Needs Analysis → Proposal → Negotiation because that IS
+ * the pipeline. Analytics groups by that field and returns buckets in whatever
+ * order the GROUP BY produced (usually alphabetical), which for an
+ * ordered-sequence chart — a funnel above all — draws a shape that reads as a
+ * pipeline but isn't one.
+ *
+ * Emits BOTH the stored `value` and its display `label` per option, adjacent
+ * and in declared order, for the same reason {@link buildOptionColorMap} keys
+ * by both: a chart row's category may carry either, depending on whether the
+ * server resolved the dimension's labels. Rank is "index of first match", so
+ * either key ranks the option identically.
+ *
+ * Returns `null` for a field with no options, so callers keep their existing
+ * ordering (a funnel falls back to descending by value).
+ */
+export declare function buildCategoryOrder(options: unknown): string[] | null;
+/**
+ * Rank map for {@link buildCategoryOrder} keys — `category → position`, first
+ * occurrence wins. Categories absent from the declared order get no entry; the
+ * caller decides where those sort (see `AdvancedChartImpl`, which keeps them
+ * after the declared ones rather than dropping them).
+ */
+export declare function buildCategoryRank(order: string[] | null | undefined): Map<string, number> | null;
 /**
  * Build a `{ value → label }` map from a select/enum field's `options`, for
  * resolving a grouped dimension's stored value to its display label (fed to