@object-ui/components 17.6.0 → 17.7.0

package/README.md

@@ -86,15 +86,16 @@ tree-shake that import away.
 ```tsx
 import { SchemaRenderer } from '@object-ui/react'
 import { initializeComponents } from '@object-ui/components'
+import type { DeclaredNode } from '@object-ui/types'
 
 initializeComponents()
 
-const schema = {
+const schema: DeclaredNode = {
   type: 'card',
   title: 'Welcome',
-  body: {
+  children: {
     type: 'text',
-    value: 'Hello from Object UI!'
+    content: 'Hello from Object UI!'
   }
 }
 
@@ -175,6 +176,7 @@ them draw the notification's `severity` icon unless it declares an `icon`
 override naming a real Lucide icon. See the
 [notifications guide](https://objectui.org/docs/guide/notifications).
 
+<!-- doc-snippet: fragment — router-layout excerpt: `Outlet` is react-router's, supplied by the host application -->
 ```tsx
 import { NotificationBanners, NotificationAlerts } from '@object-ui/components';
 

package/dist/custom/button-group.d.ts

@@ -1,7 +1,7 @@
 import { VariantProps } from 'class-variance-authority';
 import { Separator } from '../ui/separator.js';
 declare const buttonGroupVariants: (props?: ({
-    orientation?: "horizontal" | "vertical" | null | undefined;
+    orientation?: "vertical" | "horizontal" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 declare function ButtonGroup({ className, orientation, ...props }: React.ComponentProps<"div"> & VariantProps<typeof buttonGroupVariants>): import("react").JSX.Element;
 declare function ButtonGroupText({ className, asChild, ...props }: React.ComponentProps<"div"> & {

package/dist/custom/combobox.d.ts

@@ -1,3 +1,4 @@
+import { ComboboxOption } from '@object-ui/types/form';
 /**
  * ObjectUI
  * Copyright (c) 2024-present ObjectStack Inc.
@@ -6,10 +7,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 import * as React from "react";
-export interface ComboboxOption {
-    value: string;
-    label: string;
-}
+export type { ComboboxOption } from '@object-ui/types/form';
 /**
  * Beyond its own named props, the combobox accepts standard button attributes
  * (`id`, `aria-*`, `data-*`, handlers, …) and forwards them to the trigger —

package/dist/custom/empty.d.ts

@@ -6,15 +6,27 @@ declare const emptyMediaVariants: (props?: ({
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 declare function EmptyMedia({ className, variant, ...props }: React.ComponentProps<"div"> & VariantProps<typeof emptyMediaVariants>): import("react").JSX.Element;
 declare function EmptyTitle({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
-declare function EmptyDescription({ className, ...props }: React.ComponentProps<"p">): import("react").JSX.Element;
+declare function EmptyDescription({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
 declare function EmptyContent({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
 /**
  * EmptyValue — universal inline placeholder for missing cell/field values.
  *
  * Use this anywhere a renderer would otherwise show "-" or "—" for a null,
- * undefined or empty value. It renders a muted, non-interactive en-dash that
- * does not inherit link/button colors from surrounding ancestors, so a missing
- * value never looks clickable.
+ * undefined or empty value. It renders a muted, non-interactive EM-dash (the
+ * `glyph` default below is U+2014, and every call site depends on that width)
+ * that does not inherit link/button colors from surrounding ancestors, so a
+ * missing value never looks clickable. This sentence said "en-dash" until
+ * objectui#8506: the word was wrong, never the code — do not "fix" the glyph
+ * to match a stale docblock.
+ *
+ * ⚠️ A caller that passes a `title` through `...props` must also pass
+ * `pointer-events-auto` in `className`. `pointer-events-none` below stops this
+ * span being a hit target, so a `title` on it never renders a tooltip — the
+ * hover falls through to whichever ancestor has one. The attribute stays in the
+ * DOM either way, which is exactly why nothing catches it: a test that reads
+ * `getAttribute('title')` is green over a tooltip that can never appear
+ * (objectui#8506, where `DetailSection` kept such a `title` and two landed pins
+ * navigate by it).
  */
 declare function EmptyValue({ className, glyph, ...props }: React.ComponentProps<"span"> & {
     glyph?: string;

package/dist/custom/field.d.ts

@@ -25,7 +25,7 @@ export interface FieldProps extends React.HTMLAttributes<HTMLDivElement>, Varian
  * A labelled form-control wrapper: label, slotted control, description, error.
  *
  * Named `FieldContainer`, not `Field` (objectstack#4115): `@objectstack/spec/data`
- * exports `Field` — an object FIELD's metadata (type, reference_to, options,
+ * exports `Field` — an object FIELD's metadata (type, reference, options,
  * permissions, …) and its builder namespace — which has nothing to do with this
  * `<div>`. Two unrelated things under one name is the defect that issue exists
  * to remove; `@object-ui/app-shell` already renamed the same kind of collision

package/dist/custom/filter-builder.d.ts

@@ -1,3 +1,4 @@
+import { FilterBuilderCondition as AuthoredFilterBuilderCondition, FilterGroup as AuthoredFilterGroup } from '@object-ui/types';
 /**
  * ObjectUI
  * Copyright (c) 2024-present ObjectStack Inc.
@@ -16,21 +17,43 @@ import * as React from "react";
  * and `operator` here is the builder's own dropdown vocabulary
  * (`FILTER_BUILDER_OPERATORS`), not the spec's `$`-tokens.
  *
- * `@object-ui/types` already renamed its identical concept to
- * `FilterBuilderCondition` (objectui#3068); this is the same thing, so it takes
- * the same name rather than inventing a second dialect. Note the same name is
- * NOT the right answer everywhere: `@object-ui/app-shell`'s `FilterCondition`
- * really was the spec's ObjectQL AST and was re-exported (objectui#3169).
+ * DERIVED from `@object-ui/types`, never declared a second time (objectui#9306,
+ * which settles objectui#6349's two parked name-authority rows). That declaration is
+ * the one name authority for the row; this one takes every member from it
+ * (`id`, required since objectui#8415, and `field`) and restates exactly two,
+ * each a named extension:
+ *
+ *   - `operator` — {@link FilterBuilderOperator}: the protocol's ids, which is
+ *     what the authority declares, plus the opt-in `exists` / `notExists` the
+ *     protocol has no member for (objectui#9559 ruling B keeps them opt-in and
+ *     unfolded). It was `string`, which let a caller hand the builder an id no
+ *     dropdown entry can hold.
+ *   - `value` — REQUIRED and narrowed to the scalar-or-list union this builder
+ *     edits, where the authority declares `value?: any`. Every exported helper
+ *     below that takes a row's value (`reshapeFilterValue`, `retypeFilterValue`,
+ *     `narrowFilterValueToOptions`, …) is typed on this member, so `any` here
+ *     would switch their checking off in silence.
  */
-export interface FilterBuilderCondition {
-    id: string;
-    field: string;
-    operator: string;
+export interface FilterBuilderCondition extends Omit<AuthoredFilterBuilderCondition, "operator" | "value"> {
+    operator: FilterBuilderOperator;
     value: string | number | boolean | (string | number | boolean)[];
 }
-export interface FilterGroup {
-    id: string;
-    logic: "and" | "or";
+/**
+ * The group the FilterBuilder edits: one `logic` over FLAT rows.
+ *
+ * DERIVED from `@object-ui/types` like the row above (objectui#9306). Only
+ * `conditions` is restated, to hold THIS package's row; `id` and `logic` are
+ * the authority's own. So `id` is OPTIONAL here, as it is there: nothing in
+ * this builder reads a group's `id`, `onChange` hands back whatever group the
+ * host passed (an id-less group comes back id-less), and only `EMPTY_GROUP`
+ * invents one. The `id: string` this package used to declare described a
+ * group the builder never guaranteed.
+ *
+ * `conditions` is flat because the builder is: it draws each entry as one row
+ * and has no control that creates a group. The authority retired nested
+ * sub-groups in the same change and its zod mirror refuses one by name.
+ */
+export interface FilterGroup extends Omit<AuthoredFilterGroup, "conditions"> {
     conditions: FilterBuilderCondition[];
 }
 export interface FilterBuilderProps {
@@ -69,34 +92,34 @@ declare const defaultOperators: readonly [{
     readonly value: "equals";
     readonly label: "Equals";
 }, {
-    readonly value: "notEquals";
+    readonly value: "not_equals";
     readonly label: "Does not equal";
 }, {
     readonly value: "contains";
     readonly label: "Contains";
 }, {
-    readonly value: "containsCaseInsensitive";
+    readonly value: "icontains";
     readonly label: "Contains (ignore case)";
 }, {
-    readonly value: "notContains";
+    readonly value: "not_contains";
     readonly label: "Does not contain";
 }, {
-    readonly value: "isEmpty";
+    readonly value: "is_empty";
     readonly label: "Is empty";
 }, {
-    readonly value: "isNotEmpty";
+    readonly value: "is_not_empty";
     readonly label: "Is not empty";
 }, {
-    readonly value: "greaterThan";
+    readonly value: "greater_than";
     readonly label: "Greater than";
 }, {
-    readonly value: "lessThan";
+    readonly value: "less_than";
     readonly label: "Less than";
 }, {
-    readonly value: "greaterOrEqual";
+    readonly value: "greater_than_or_equal";
     readonly label: "Greater than or equal";
 }, {
-    readonly value: "lessOrEqual";
+    readonly value: "less_than_or_equal";
     readonly label: "Less than or equal";
 }, {
     readonly value: "before";
@@ -111,19 +134,19 @@ declare const defaultOperators: readonly [{
     readonly value: "in";
     readonly label: "In";
 }, {
-    readonly value: "notIn";
+    readonly value: "not_in";
     readonly label: "Not in";
 }, {
-    readonly value: "startsWith";
+    readonly value: "starts_with";
     readonly label: "Starts with";
 }, {
-    readonly value: "endsWith";
+    readonly value: "ends_with";
     readonly label: "Ends with";
 }, {
-    readonly value: "isNull";
+    readonly value: "is_null";
     readonly label: "Is null";
 }, {
-    readonly value: "isNotNull";
+    readonly value: "is_not_null";
     readonly label: "Is not null";
 }, {
     readonly value: "exists";
@@ -137,30 +160,79 @@ declare const defaultOperators: readonly [{
  * hold, derived from the operators it actually renders. Includes the opt-in
  * ids: they are drawable, just not offered unconditionally.
  *
- * Exported because several translation tables map an external vocabulary
- * (the spec's `VIEW_FILTER_OPERATORS`, Mongo `$`-tokens) *onto* this one, and
- * a value that is not in this list produces a condition row whose operator
- * select has nothing to select. Those tables assert against this export
- * rather than restating it, so adding an operator here is the only edit
- * needed to widen them.
+ * Since objectui#9306 these ARE the protocol's ids — the twenty members of the
+ * spec's `VIEW_FILTER_OPERATORS`, plus the opt-in `exists` / `notExists` the
+ * protocol has no member for — so a table that maps the spec's vocabulary onto
+ * this one is an identity over the twenty. It is still exported because those
+ * tables, and the parity pins over them, assert against this list rather than
+ * restating it: a value that is not in it produces a condition row whose
+ * operator select has nothing to select.
+ */
+export declare const FILTER_BUILDER_OPERATORS: ("in" | "starts_with" | "ends_with" | "contains" | "equals" | "not_equals" | "greater_than" | "greater_than_or_equal" | "less_than" | "less_than_or_equal" | "before" | "after" | "not_in" | "not_contains" | "icontains" | "between" | "is_null" | "is_not_null" | "is_empty" | "is_not_empty" | "exists" | "notExists")[];
+/**
+ * An operator id the FilterBuilder can render: the spec's `ViewFilterOperator`
+ * plus the two opt-in existence ids (objectui#9306). A type-level pin in
+ * `filter-builder-protocol-ids-9306.test.tsx` holds it EQUAL to that union, so
+ * a protocol member added upstream fails to compile there until the dropdown
+ * offers it.
  */
-export declare const FILTER_BUILDER_OPERATORS: ("endsWith" | "startsWith" | "in" | "after" | "equals" | "notEquals" | "contains" | "containsCaseInsensitive" | "notContains" | "isEmpty" | "isNotEmpty" | "greaterThan" | "lessThan" | "greaterOrEqual" | "lessOrEqual" | "before" | "between" | "notIn" | "isNull" | "isNotNull" | "exists" | "notExists")[];
-/** An operator id the FilterBuilder can render. */
 export type FilterBuilderOperator = (typeof defaultOperators)[number]['value'];
 /**
- * Operator ids for which this builder renders NO value input — so "no value"
- * is the row's FINISHED state, not an unfinished one (objectui#4744).
+ * The spelling a stored operator is READ as — the protocol id for every
+ * spelling the spec or this builder ever wrote (objectui#9306).
+ *
+ * The ruling this executes: camelCase is the deprecated alias form
+ * (objectui#7993), accepted on read and rewritten on write. So a filter stored
+ * as `{ operator: 'greaterOrEqual' }` keeps loading — it is folded here, through
+ * the spec's own `normalizeFilterOperator`, onto `greater_than_or_equal` — and
+ * the builder holds and emits that canonical id from then on, so the next write
+ * the author makes stores it. A lossless conversion on the read side, ⛔ not a
+ * second vocabulary: nothing this builder EMITS is ever a camelCase id.
+ *
+ * An id nothing folds (`exists`, `notExists`, a spelling from no vocabulary)
+ * comes back unchanged, exactly as the spec's normalizer returns it: inventing
+ * a mapping for a word the protocol does not contain would be a claim, not a
+ * repair.
+ *
+ * ⚠️ One guard on the spec's answer, and only because the builder now STORES
+ * what this returns (before objectui#9306 the fold was used for comparison
+ * only). `normalizeFilterOperator` is declared to return a string, but it
+ * looks the spelling up on a plain object, so an `Object.prototype` key comes
+ * back as whatever the prototype holds — `'constructor'` returns the `Object`
+ * function, measured on `@objectstack/spec` 17.4.0. Held in a row and written
+ * back, that would drop the row's operator on serialisation. A non-string
+ * answer is therefore treated as "nothing folds" and the spelling is kept;
+ * the defect itself belongs to the spec and is reported there, not patched
+ * around here in any other way.
+ */
+export declare function normalizeFilterBuilderOperator(operator: string): string;
+/**
+ * Operator ids — this dropdown's own ids, which are the protocol's canonical
+ * spellings since objectui#9306 — for which this builder renders no value
+ * input, so "no value" is the row's FINISHED state, not an unfinished one
+ * (objectui#4744).
  *
  * This is the source of truth for that distinction, and it lives here because
- * this component is the thing that decides it: `needsValueInput` below is
- * defined as the complement of this set, so the two cannot say different
- * things. Every consumer that has to tell a complete value-less row from a
- * half-filled one reads it FROM here rather than restating it:
+ * this component is the thing that decides it. But membership here is not the
+ * whole question: `needsValueInput` below asks it of the row's spelling AFTER
+ * {@link normalizeFilterBuilderOperator} (objectui#9302), so the gate answers
+ * "no value" for spellings that are NOT members — the deprecated camelCase ids
+ * a stored filter may still carry, and the alias rows the spec publishes for
+ * those same operators. A consumer holding a spelling that did not come from
+ * this dropdown must therefore fold it before asking, and fold this set's own
+ * members through the same normalizer too — the spec's `normalizeFilterOperator`
+ * is the identity on them, so that fold costs nothing and keeps the consumer
+ * correct whichever vocabulary this set is written in. How much wider the
+ * gate's preimage is is NOT restated here: the pin
+ * `filter-builder-valueless-canonical-spelling-9302.test.tsx` walks the
+ * spec's two published tables and names every row it measures, which is the
+ * only form of that answer that moves when those tables do (AGENTS.md #9).
+ *
+ * Every consumer that has to tell a complete value-less row from a half-filled
+ * one reads the membership FROM here rather than restating it:
  *
  *   - `plugin-list`'s `convertFilterGroupToAST` — what the live grid QUERIES;
- *   - `app-shell`'s `foldFilterGroupToSpecRules` — what a saved view PERSISTS
- *     (its `VALUELESS_FILTER_OPERATORS` is this set plus the canonical spec
- *     spellings, which only that layer sees).
+ *   - `app-shell`'s `foldFilterGroupToSpecRules` — what a saved view PERSISTS.
  *
  * Placement is forced by the dependency graph — `app-shell` depends on
  * `plugin-list` depends on this package, so this is the only module all three
@@ -168,11 +240,12 @@ export type FilterBuilderOperator = (typeof defaultOperators)[number]['value'];
  * states is a fact about what this dropdown draws.
  *
  * Why it exists at all: each consumer used to keep its own copy, and the
- * live-grid copy listed only `isEmpty`/`isNotEmpty`. A fresh row is seeded
- * `{ operator: 'equals', value: '' }` and the operator dropdown preserves
- * `value`, so picking **Is null** as the first action left `value: ''` — the
- * grid read that as an unfinished row, dropped it, and applied NO filter at
- * all while the panel showed one. Silent, and every record came back.
+ * live-grid copy listed only the two empty-string operators. A fresh row is
+ * seeded `{ operator: 'equals', value: '' }` and the operator dropdown
+ * preserves `value`, so picking **Is null** as the first action left
+ * `value: ''` — the grid read that as an unfinished row, dropped it, and
+ * applied NO filter at all while the panel showed one. Silent, and every
+ * record came back.
  *
  * `exists` / `notExists` stay listed even though `OPT_IN_OPERATORS` withholds
  * them from most consumers (objectui#4736): the builder still draws them
@@ -193,13 +266,14 @@ export declare const VALUELESS_FILTER_BUILDER_OPERATORS: ReadonlySet<string>;
  */
 export type FilterValueArity = "scalar" | "list" | "pair";
 /**
- * Which value shape `operator` takes, in EITHER dialect.
+ * Which value shape `operator` takes, whichever spelling it arrives in.
  *
- * The argument is folded through the spec's own `normalizeFilterOperator`
- * first, so the builder's camelCase dropdown ids (`notIn`) and the canonical
- * spellings a stored rule carries (`not_in`) land on the same answer. That
- * fold is the whole point: one vocabulary, declared upstream, consulted here —
- * not a second local dialect that has to be kept in sync by hand.
+ * The argument is folded through {@link normalizeFilterBuilderOperator} — the
+ * spec's own `normalizeFilterOperator` plus the builder's one unfolded legacy
+ * id — first, so the canonical id this dropdown emits (`not_in`) and the
+ * deprecated alias a stored filter may still carry (`notIn`) land on the same
+ * answer. That fold is the whole point: one vocabulary, declared upstream,
+ * consulted here — not a second local dialect kept in sync by hand.
  *
  * @internal exported for tests
  */
@@ -230,7 +304,7 @@ export declare function reshapeFilterValue(value: FilterBuilderCondition["value"
  * NEW field offers (objectui#4768).
  *
  * Each field type has its own operator bucket, and the buckets are not nested:
- * a `select` column offers `in` / `notIn`, a `text` column does not. Changing
+ * a `select` column offers `in` / `not_in`, a `text` column does not. Changing
  * the field used to write `{ field }` alone, so the row's operator survived
  * into a bucket that no longer contains it — `in` on a text column. The Radix
  * trigger then had nothing to render (its `SelectValue` matches against the
@@ -243,22 +317,80 @@ export declare function reshapeFilterValue(value: FilterBuilderCondition["value"
  * entry (`equals` for every bucket this builder draws), and the caller then
  * re-shapes the value for that operator's family.
  *
- * Membership is decided CANONICALLY, through the spec's own
- * `normalizeFilterOperator` — the same fold `filterValueArity` uses. A stored
- * rule can reach this builder spelled `not_in` while the dropdown lists the
- * alias `notIn`; those are one operator, so a select→lookup switch must not
- * silently rewrite the author's operator to `equals` just because the two
- * spellings differ. The fold is safe to compare through because it is
- * INJECTIVE over this builder's vocabulary — all 22 ids in `defaultOperators`
- * normalize to 22 distinct canonical operators, pinned in
- * `filter-builder-field-switch-operator.test.tsx` — so no two OFFERED
- * operators can ever collapse onto one another.
+ * Membership is decided CANONICALLY, through
+ * {@link normalizeFilterBuilderOperator} — the same fold `filterValueArity`
+ * uses. A caller can hand this helper a row spelled with the deprecated alias
+ * `notIn` while the dropdown lists the protocol id `not_in`; those are one
+ * operator, so a select→lookup switch must not silently rewrite the author's
+ * operator to `equals` just because the two spellings differ. The fold is safe
+ * to compare through because it is INJECTIVE over this builder's vocabulary —
+ * all 22 ids in `defaultOperators` normalize to 22 distinct canonical
+ * operators, pinned in `filter-builder-field-switch-operator.test.tsx` — so no
+ * two OFFERED operators can ever collapse onto one another.
  *
  * @internal exported for tests
  */
 export declare function reconcileOperatorForField(operator: string, offeredOperators: ReadonlyArray<{
     value: string;
 }>): string;
+/**
+ * The offered id the operator trigger COMPARES against — the last site in this
+ * component that read the operator literally instead of through the spec's
+ * fold (objectui#7561).
+ *
+ * Radix matches `SelectValue` against the `SelectItem`s actually MOUNTED, and
+ * the mounted ids are this builder's own vocabulary — the protocol's canonical
+ * ids since objectui#9306 (they were camelCase when this helper was written). A
+ * row can hold the operator under another spelling of the SAME operator and
+ * still be perfectly valid:
+ *
+ *   - a deprecated camelCase alias such as `greaterThan`, which a filter saved
+ *     before objectui#9306 still carries;
+ *   - the spec's alias table `gt` / `lt` / `eq`, which three schema-catalog
+ *     entries author today.
+ *
+ * When this helper was written the mounted id was `greaterThan` and the stored
+ * spelling `greater_than`; neither matched the other literally, so the trigger
+ * drew BLANK over a row that filtered correctly — the user's own operator,
+ * invisible and unreachable.
+ * Everywhere the operator's MEANING matters this component already folds first
+ * ({@link filterValueArity}, {@link reconcileOperatorForField}); this was the
+ * one place it did not, and that omission — not the vocabulary divergence — is
+ * what produced the blank.
+ *
+ * So the comparison is made canonically and the MOUNTED spelling is handed to
+ * the trigger. Three things this deliberately does NOT do, each of them a
+ * separate ruling (objectui#7561):
+ *
+ *   1. it does not rewrite `condition.operator` — the row keeps the spelling it
+ *      arrived with, exactly as {@link reconcileOperatorForField} keeps it, and
+ *      nothing is written back on render. (Since objectui#9306 the BUILDER
+ *      folds a row's spelling once, at its read boundary — see
+ *      {@link normalizeFilterBuilderOperator} — so the rows it renders already
+ *      hold protocol ids. This helper still folds both sides, because it is
+ *      exported and its caller's rows need not have come through that
+ *      boundary.)
+ *   2. it does not mount a new `SelectItem`, so the vocabulary the dropdown
+ *      EMITS is byte-identical — contrast the value select above, where
+ *      objectui#4874 ruling C mounts the outside-options value as its own
+ *      option. That answer is right there and wrong here: the value's domain is
+ *      the author's data, while the operator's domain is a declared vocabulary,
+ *      and mounting a foreign spelling would admit a second one;
+ *   3. it does not widen what any schema ACCEPTS.
+ *
+ * Safe to compare through because the fold is INJECTIVE over this builder's
+ * vocabulary — all 22 ids in `defaultOperators` normalize to 22 distinct
+ * canonical operators, pinned in `filter-builder-field-switch-operator.test.tsx`
+ * — so no two OFFERED operators can collapse onto one another and the match is
+ * unambiguous. An operator no offered id folds onto falls through to the row's
+ * own spelling and still draws blank: inventing a label for a word this
+ * vocabulary does not contain would be a claim, not a repair.
+ *
+ * @internal exported for tests
+ */
+export declare function mountedOperatorValue(operator: string, offeredOperators: ReadonlyArray<{
+    value: string;
+}>): string;
 /**
  * Re-TYPE a row's `value` for the field it is being changed TO — the type
  * question, standing beside {@link reshapeFilterValue}'s shape question
@@ -285,7 +417,7 @@ export declare function reconcileOperatorForField(operator: string, offeredOpera
  *   - `scalar` — converted, or `""`.
  *   - `list` — converted ENTRY BY ENTRY, keeping the ones that carry:
  *     `["42", "acme"]` → `[42]`, and `[]` when none do. Reachable today only
- *     between the two buckets that offer `in`/`notIn` (`select` ↔ `lookup`),
+ *     between the two buckets that offer `in`/`not_in` (`select` ↔ `lookup`),
  *     which are both text-family, so the conversion is the identity there; it
  *     is written for the family the operator lands in rather than for today's
  *     buckets, and pinned directly on this helper.

package/dist/custom/index.d.ts

@@ -25,4 +25,3 @@ export * from './RecordTitleChip.js';
 export * from './refresh-indicator.js';
 export * from './view-states.js';
 export * from './mobile-dialog-content.js';
-export * from './export-progress-dialog.js';

package/dist/custom/item.d.ts

@@ -18,7 +18,7 @@ declare function Item({ className, variant, size, asChild, ...props }: React.Com
     asChild?: boolean;
 }): React.JSX.Element;
 declare const itemMediaVariants: (props?: ({
-    variant?: "image" | "default" | "icon" | null | undefined;
+    variant?: "default" | "icon" | "image" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 declare function ItemMedia({ className, variant, ...props }: React.ComponentProps<"div"> & VariantProps<typeof itemMediaVariants>): React.JSX.Element;
 declare function ItemContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;

package/dist/custom/kbd.d.ts

@@ -6,5 +6,5 @@
  * LICENSE file in the root directory of this source tree.
  */
 declare function Kbd({ className, ...props }: React.ComponentProps<"kbd">): import("react").JSX.Element;
-declare function KbdGroup({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
+declare function KbdGroup({ className, ...props }: React.ComponentProps<"kbd">): import("react").JSX.Element;
 export { Kbd, KbdGroup };

package/dist/custom/mobile-dialog-content.d.ts

@@ -43,5 +43,26 @@ type InteractOutsideHandler = NonNullable<React.ComponentPropsWithoutRef<typeof
  * plain backdrop click with no flyout open.
  */
 export declare function usePopperAwareInteractOutside(onInteractOutside?: InteractOutsideHandler): InteractOutsideHandler;
-export declare const MobileDialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export type MobileDialogContentProps = React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> & {
+    /**
+     * Whether the dialog draws its own close (X) button. Defaults to `true`;
+     * `false` leaves it out of the DOM entirely (objectui#11061), the same
+     * switch upstream Shadcn's `DialogContent` names `showCloseButton`. The
+     * dialog stays dismissable without it: Escape and a backdrop click still
+     * reach the `Dialog`'s `onOpenChange(false)` through Radix, so a caller that
+     * hides the X only has to keep whatever explicit way out its body offers.
+     */
+    showCloseButton?: boolean;
+};
+export declare const MobileDialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    /**
+     * Whether the dialog draws its own close (X) button. Defaults to `true`;
+     * `false` leaves it out of the DOM entirely (objectui#11061), the same
+     * switch upstream Shadcn's `DialogContent` names `showCloseButton`. The
+     * dialog stays dismissable without it: Escape and a backdrop click still
+     * reach the `Dialog`'s `onOpenChange(false)` through Radix, so a caller that
+     * hides the X only has to keep whatever explicit way out its body offers.
+     */
+    showCloseButton?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
 export {};