@object-ui/core 17.1.0 → 17.3.0

package/dist/utils/freeze-schema.js

@@ -9,7 +9,7 @@
  * System View immutability layer.
  *
  * A "System View" is any UI schema authored in source code (imported `.ts`/`.json`,
- * `as const` literals, or returned from a `defineView()` call). Such schemas are
+ * `as const` literals, or returned from a `defineSystemView()` call). Such schemas are
  * part of the product contract and MUST NOT be mutated at runtime. Mutation
  * would cause behavior drift, break TypeScript inference, and bypass code review.
  *
@@ -86,11 +86,19 @@ export function deepFreeze(value, seen = new WeakSet()) {
 /**
  * Mark and freeze a code-loaded schema as a System View.
  *
+ * Named `defineView` until objectstack#4115, which is a name `@objectstack/spec`
+ * owns for something else entirely: the spec's `defineView(config)` is the
+ * VIEW-DOCUMENT factory — it parses a `ViewSchema` (`{ list, form, listViews,
+ * formViews }`) and returns a validated `View`. This one takes an arbitrary
+ * object, stamps the System-View marker and deep-freezes it; it validates
+ * nothing. An app-shell comment already conflated the two, which is precisely
+ * the planted-premise failure the guard exists to stop.
+ *
  * @example
  * ```ts
- * import { defineView } from '@object-ui/core';
+ * import { defineSystemView } from '@object-ui/core';
  *
- * export const userListView = defineView({
+ * export const userListView = defineSystemView({
  *   type: 'list',
  *   data: { object: 'User' },
  *   columns: [{ name: 'email' }],
@@ -103,9 +111,9 @@ export function deepFreeze(value, seen = new WeakSet()) {
  * To produce a mutable derivative (Tenant or User View), call
  * `cloneAsOverride(userListView)`.
  */
-export function defineView(schema) {
+export function defineSystemView(schema) {
     if (schema == null || typeof schema !== 'object') {
-        throw new TypeError('[ObjectUI] defineView() expects a non-null object schema.');
+        throw new TypeError('[ObjectUI] defineSystemView() expects a non-null object schema.');
     }
     // Stamp the marker on the root only — nested nodes share origin via lineage.
     // Non-enumerable keeps it out of JSON, spreads, and Object.keys.
@@ -120,7 +128,7 @@ export function defineView(schema) {
     return deepFreeze(schema);
 }
 /**
- * Runtime check: was this object produced by `defineView()` (or loaded from a
+ * Runtime check: was this object produced by `defineSystemView()` (or loaded from a
  * source that forwards the marker)?
  */
 export function isSystemView(value) {

package/dist/utils/managedBy.d.ts

@@ -1,51 +1,54 @@
 /**
- * managedBy — the single source of truth for interpreting an object's
- * lifecycle bucket (`ObjectSchema.managedBy`) into CRUD affordances.
+ * managedBy — the UI end of the platform's `managedBy` → CRUD affordance
+ * contract (ADR-0103).
  *
- * UI-side mirror of the framework's `resolveCrudAffordances()`
- * (`@objectstack/spec/data/object.zod.ts`, ADR-0103). Lives in `@object-ui/core`
- * — React-free and reachable by every UI package (app-shell, plugin-detail,
- * plugin-form, plugin-grid) — so the bucket logic is defined ONCE instead of
- * hand-mirrored in each. Components ask "should I show New / Import / Edit /
- * Delete / Export?" and get an answer that tracks the object's lifecycle without
- * special-casing `sys_*` names.
+ * ## What is spec-owned here, and what is not (objectstack#4115)
  *
- * The bucket UNION type lives in `@object-ui/types` (`ManagedByBucket`) so the
- * schema field can reference it; this module re-exports it for convenience.
- * Only the affordance BOOLEANS live here — all translated copy (badge variants,
- * empty-state messages) stays in `@object-ui/app-shell`.
+ * The bucket logic is **the spec's**, and this module now says so in code
+ * rather than in a comment. `CrudAffordances` / `RowCrudPredicates` are
+ * re-exported from `@objectstack/spec/data`, and the bucket resolution itself
+ * delegates to the spec's `resolveCrudAffordances()`.
+ *
+ * This module used to describe itself as a "UI-side mirror" of that function
+ * and carry its own `DEFAULTS` table — a line-for-line copy of the spec's
+ * `CRUD_AFFORDANCE_DEFAULTS`, plus a copy of its override parser. A faithful
+ * copy passes every value comparison and every behavioural test, so nothing
+ * would have caught the release in which the spec re-buckets an object class;
+ * reference identity is the only check that distinguishes a re-export from a
+ * fork (objectui#3003).
+ *
+ * What is genuinely objectui's and keeps a local name:
+ * {@link resolveEffectiveCrudAffordances} — the spec's object-level matrix
+ * INTERSECTED with the server-resolved effective API operation set (#3391), so
+ * the UI never offers a button the server would 405. The spec's function has
+ * no such notion; naming ours after it was the misdescription this burn-down
+ * removes.
+ *
+ * Lives in `@object-ui/core` — React-free and reachable by every UI package
+ * (app-shell, plugin-detail, plugin-form, plugin-grid) — so the intersection is
+ * defined ONCE instead of hand-mirrored in each. The bucket UNION type lives in
+ * `@object-ui/types` (`ManagedByBucket`) and is re-exported here for
+ * convenience. All translated copy (badge variants, empty-state messages) stays
+ * in `@object-ui/app-shell`.
  */
+import { type CrudAffordances, type RowCrudPredicates } from '@objectstack/spec/data';
 export type { ManagedByBucket } from '@object-ui/types';
-export interface CrudAffordances {
-    /** Generic "New" button for single-record creation. */
-    create: boolean;
-    /** CSV bulk-import wizard. */
-    import: boolean;
-    /** Inline + form editing of existing rows. */
-    edit: boolean;
-    /** Row-level + bulk delete. */
-    delete: boolean;
-    /** CSV / clipboard export. */
-    exportCsv: boolean;
-    /**
-     * Per-record CEL predicates for the built-in row Edit/Delete actions,
-     * present only when `userActions.edit` / `delete` used the object form
-     * (objectui#2614). Carried through as authored for row renderers to evaluate;
-     * they never affect the object-level booleans above.
-     */
-    editPredicates?: RowCrudPredicates;
-    deletePredicates?: RowCrudPredicates;
-}
-/** Per-record predicates from the #2614 object form of a userActions flag. */
-export interface RowCrudPredicates {
-    visibleWhen?: unknown;
-    disabledWhen?: unknown;
-}
+/**
+ * The resolved CRUD affordance matrix and its per-record predicate envelope
+ * are **spec-owned** (`@objectstack/spec/data`, ADR-0103) and re-exported here,
+ * not re-declared.
+ *
+ * Note this also TIGHTENS the predicate types: the local copies typed
+ * `visibleWhen` / `disabledWhen` as `unknown`, while the spec types them as
+ * `Expression | ExpressionInput` — the authored CEL shorthand or its envelope.
+ * The local `unknown` was imprecision, not a deliberate dialect.
+ */
+export type { CrudAffordances, RowCrudPredicates };
 /** `edit`/`delete` accept a bare boolean or the #2614 object form. */
 export type UserActionOverride = boolean | {
     enabled?: boolean;
-    visibleWhen?: unknown;
-    disabledWhen?: unknown;
+    visibleWhen?: RowCrudPredicates['visibleWhen'];
+    disabledWhen?: RowCrudPredicates['disabledWhen'];
 };
 export interface UserActionsOverride {
     create?: boolean;
@@ -63,11 +66,14 @@ export interface SchemaLike {
  * the given bucket default, surfacing any per-record predicates alongside.
  *
  * THE single parser for the `userActions.{edit,delete}` override shape — every
- * UI package (grid row affordances, related-list row predicates, this module's
- * own `resolveCrudAffordances`) routes through here instead of re-implementing
- * the boolean/object-form parse locally. `base` is the bucket default an
- * omitted `enabled` falls back to (callers that only gate on an explicit
- * opt-out pass `true`; predicate extraction is independent of `base`).
+ * UI package (grid row affordances, related-list row predicates) routes through
+ * here instead of re-implementing the boolean/object-form parse locally. The
+ * spec keeps its equivalent (`normalizeRowCrudOverride`) module-private, so
+ * this stays a local declaration — under a name the spec does not own.
+ *
+ * `base` is the bucket default an omitted `enabled` falls back to (callers that
+ * only gate on an explicit opt-out pass `true`; predicate extraction is
+ * independent of `base`).
  */
 export declare function normalizeUserAction(v: UserActionOverride | undefined | null, base: boolean): {
     enabled: boolean;
@@ -82,7 +88,15 @@ export declare function normalizeUserAction(v: UserActionOverride | undefined |
  */
 export declare function userActionPredicates(v: UserActionOverride | undefined | null): RowCrudPredicates | undefined;
 /**
- * Resolve the effective CRUD affordances for an object schema.
+ * Resolve the CRUD affordances a UI surface should expose for an object —
+ * the spec's object-level matrix, INTERSECTED with what the server will
+ * actually accept.
+ *
+ * The bucket/`userActions` half is **not computed here**: it is delegated to
+ * `resolveCrudAffordances()` from `@objectstack/spec/data` (ADR-0103), so the
+ * bucket table has exactly one definition on the platform. Only the
+ * intersection below is objectui's, which is why this function no longer
+ * carries the spec's name (objectstack#4115).
  *
  * @param obj The object schema (managedBy bucket + userActions overrides).
  * @param effectiveApiOperations OPTIONAL server-resolved effective API operation
@@ -93,13 +107,27 @@ export declare function userActionPredicates(v: UserActionOverride | undefined |
  *   (old backend / no effective set) leaves the affordances untouched —
  *   backward-compatible. An empty array means "expose nothing" → all bits off.
  */
-export declare function resolveCrudAffordances(obj: SchemaLike | null | undefined, effectiveApiOperations?: readonly string[] | null): CrudAffordances;
+export declare function resolveEffectiveCrudAffordances(obj: SchemaLike | null | undefined, effectiveApiOperations?: readonly string[] | null): CrudAffordances;
 /** True only when a `userActions` flag (bare boolean or #2614 object form) opts the write in. */
 export declare function isWriteOptedIn(v: UserActionOverride | undefined | null): boolean;
 /**
- * ADR-0103 — a `system`-bucket object that opened ANY write via `userActions`
- * is admin/user-writable DATA, not an engine-owned monitoring surface. Used to
- * pick the writable-system badge/empty-state copy.
+ * True for a platform-defined schema whose DATA is admin/user-writable — the
+ * `system-data` bucket. Used to pick the writable-system badge/empty-state copy
+ * instead of the engine-owned "read-only monitoring surface" copy.
+ *
+ * **Simplified in protocol 17 (objectstack#3355).** Under ADR-0103's v16 split
+ * this had to RECOVER the distinction from `userActions`: `system` doubled as
+ * both the engine-owned default and the writable set, so "did it open any
+ * write?" was the only way to tell a Notification Preferences grid from an
+ * automation-run log. v17 retired that overload — the writable half is now the
+ * `system-data` bucket (writable by DEFAULT) and the engine-owned half is
+ * `engine-owned` — so the bucket answers the question directly and the
+ * `userActions` probe would only re-derive what the value already states.
+ *
+ * The narrowing case is deliberately still `true`: a `system-data` grid that
+ * narrows to edit-only is still platform-schema/user-data and should read as
+ * such. The spec refuses `system-data` on an object that narrows away every
+ * write, so there is no "writable bucket with no writes" shape to worry about.
  */
 export declare function isSystemWritable(obj: SchemaLike | null | undefined): boolean;
 /**

package/dist/utils/managedBy.js

@@ -1,38 +1,50 @@
 /**
- * managedBy — the single source of truth for interpreting an object's
- * lifecycle bucket (`ObjectSchema.managedBy`) into CRUD affordances.
+ * managedBy — the UI end of the platform's `managedBy` → CRUD affordance
+ * contract (ADR-0103).
  *
- * UI-side mirror of the framework's `resolveCrudAffordances()`
- * (`@objectstack/spec/data/object.zod.ts`, ADR-0103). Lives in `@object-ui/core`
- * — React-free and reachable by every UI package (app-shell, plugin-detail,
- * plugin-form, plugin-grid) — so the bucket logic is defined ONCE instead of
- * hand-mirrored in each. Components ask "should I show New / Import / Edit /
- * Delete / Export?" and get an answer that tracks the object's lifecycle without
- * special-casing `sys_*` names.
+ * ## What is spec-owned here, and what is not (objectstack#4115)
  *
- * The bucket UNION type lives in `@object-ui/types` (`ManagedByBucket`) so the
- * schema field can reference it; this module re-exports it for convenience.
- * Only the affordance BOOLEANS live here — all translated copy (badge variants,
- * empty-state messages) stays in `@object-ui/app-shell`.
+ * The bucket logic is **the spec's**, and this module now says so in code
+ * rather than in a comment. `CrudAffordances` / `RowCrudPredicates` are
+ * re-exported from `@objectstack/spec/data`, and the bucket resolution itself
+ * delegates to the spec's `resolveCrudAffordances()`.
+ *
+ * This module used to describe itself as a "UI-side mirror" of that function
+ * and carry its own `DEFAULTS` table — a line-for-line copy of the spec's
+ * `CRUD_AFFORDANCE_DEFAULTS`, plus a copy of its override parser. A faithful
+ * copy passes every value comparison and every behavioural test, so nothing
+ * would have caught the release in which the spec re-buckets an object class;
+ * reference identity is the only check that distinguishes a re-export from a
+ * fork (objectui#3003).
+ *
+ * What is genuinely objectui's and keeps a local name:
+ * {@link resolveEffectiveCrudAffordances} — the spec's object-level matrix
+ * INTERSECTED with the server-resolved effective API operation set (#3391), so
+ * the UI never offers a button the server would 405. The spec's function has
+ * no such notion; naming ours after it was the misdescription this burn-down
+ * removes.
+ *
+ * Lives in `@object-ui/core` — React-free and reachable by every UI package
+ * (app-shell, plugin-detail, plugin-form, plugin-grid) — so the intersection is
+ * defined ONCE instead of hand-mirrored in each. The bucket UNION type lives in
+ * `@object-ui/types` (`ManagedByBucket`) and is re-exported here for
+ * convenience. All translated copy (badge variants, empty-state messages) stays
+ * in `@object-ui/app-shell`.
  */
-const DEFAULTS = {
-    platform: { create: true, import: true, edit: true, delete: true, exportCsv: true },
-    config: { create: true, import: false, edit: true, delete: true, exportCsv: true },
-    system: { create: false, import: false, edit: false, delete: false, exportCsv: true },
-    'engine-owned': { create: false, import: false, edit: false, delete: false, exportCsv: true },
-    'append-only': { create: false, import: false, edit: false, delete: false, exportCsv: true },
-    'better-auth': { create: false, import: false, edit: false, delete: false, exportCsv: true },
-};
+import { resolveCrudAffordances as resolveSpecCrudAffordances, } from '@objectstack/spec/data';
 /**
  * Collapse an `edit`/`delete` override (boolean or #2614 object form) onto
  * the given bucket default, surfacing any per-record predicates alongside.
  *
  * THE single parser for the `userActions.{edit,delete}` override shape — every
- * UI package (grid row affordances, related-list row predicates, this module's
- * own `resolveCrudAffordances`) routes through here instead of re-implementing
- * the boolean/object-form parse locally. `base` is the bucket default an
- * omitted `enabled` falls back to (callers that only gate on an explicit
- * opt-out pass `true`; predicate extraction is independent of `base`).
+ * UI package (grid row affordances, related-list row predicates) routes through
+ * here instead of re-implementing the boolean/object-form parse locally. The
+ * spec keeps its equivalent (`normalizeRowCrudOverride`) module-private, so
+ * this stays a local declaration — under a name the spec does not own.
+ *
+ * `base` is the bucket default an omitted `enabled` falls back to (callers that
+ * only gate on an explicit opt-out pass `true`; predicate extraction is
+ * independent of `base`).
  */
 export function normalizeUserAction(v, base) {
     if (v == null)
@@ -73,7 +85,15 @@ const AFFORDANCE_TO_API_OPERATION = {
     exportCsv: 'export',
 };
 /**
- * Resolve the effective CRUD affordances for an object schema.
+ * Resolve the CRUD affordances a UI surface should expose for an object —
+ * the spec's object-level matrix, INTERSECTED with what the server will
+ * actually accept.
+ *
+ * The bucket/`userActions` half is **not computed here**: it is delegated to
+ * `resolveCrudAffordances()` from `@objectstack/spec/data` (ADR-0103), so the
+ * bucket table has exactly one definition on the platform. Only the
+ * intersection below is objectui's, which is why this function no longer
+ * carries the spec's name (objectstack#4115).
  *
  * @param obj The object schema (managedBy bucket + userActions overrides).
  * @param effectiveApiOperations OPTIONAL server-resolved effective API operation
@@ -84,23 +104,15 @@ const AFFORDANCE_TO_API_OPERATION = {
  *   (old backend / no effective set) leaves the affordances untouched —
  *   backward-compatible. An empty array means "expose nothing" → all bits off.
  */
-export function resolveCrudAffordances(obj, effectiveApiOperations) {
-    const bucket = obj?.managedBy ?? 'platform';
-    const base = DEFAULTS[bucket] ?? DEFAULTS.platform;
-    const o = obj?.userActions ?? {};
-    const edit = normalizeUserAction(o.edit, base.edit);
-    const del = normalizeUserAction(o.delete, base.delete);
-    const out = {
-        create: o.create ?? base.create,
-        import: o.import ?? base.import,
-        edit: edit.enabled,
-        delete: del.enabled,
-        exportCsv: o.exportCsv ?? base.exportCsv,
-    };
-    if (edit.predicates)
-        out.editPredicates = edit.predicates;
-    if (del.predicates)
-        out.deletePredicates = del.predicates;
+export function resolveEffectiveCrudAffordances(obj, effectiveApiOperations) {
+    // The spec's resolver is the single definition of the bucket defaults and the
+    // `userActions` override parse (including the #2614 object form). Its input
+    // type does not model the `null`s objectui's loosely-typed schemas carry, so
+    // they are normalised away at this one seam rather than re-deriving anything.
+    const out = resolveSpecCrudAffordances({
+        managedBy: obj?.managedBy ?? undefined,
+        userActions: (obj?.userActions ?? undefined),
+    });
     // [#3391] Intersect with the server's effective API operations when present.
     // The frontend consumes the effective set the server hands down; it never
     // reads the raw `apiMethods` nor re-derives.
@@ -118,15 +130,26 @@ export function isWriteOptedIn(v) {
     return v === true || (typeof v === 'object' && v !== null && v.enabled === true);
 }
 /**
- * ADR-0103 — a `system`-bucket object that opened ANY write via `userActions`
- * is admin/user-writable DATA, not an engine-owned monitoring surface. Used to
- * pick the writable-system badge/empty-state copy.
+ * True for a platform-defined schema whose DATA is admin/user-writable — the
+ * `system-data` bucket. Used to pick the writable-system badge/empty-state copy
+ * instead of the engine-owned "read-only monitoring surface" copy.
+ *
+ * **Simplified in protocol 17 (objectstack#3355).** Under ADR-0103's v16 split
+ * this had to RECOVER the distinction from `userActions`: `system` doubled as
+ * both the engine-owned default and the writable set, so "did it open any
+ * write?" was the only way to tell a Notification Preferences grid from an
+ * automation-run log. v17 retired that overload — the writable half is now the
+ * `system-data` bucket (writable by DEFAULT) and the engine-owned half is
+ * `engine-owned` — so the bucket answers the question directly and the
+ * `userActions` probe would only re-derive what the value already states.
+ *
+ * The narrowing case is deliberately still `true`: a `system-data` grid that
+ * narrows to edit-only is still platform-schema/user-data and should read as
+ * such. The spec refuses `system-data` on an object that narrows away every
+ * write, so there is no "writable bucket with no writes" shape to worry about.
  */
 export function isSystemWritable(obj) {
-    if (obj?.managedBy !== 'system')
-        return false;
-    const o = obj?.userActions ?? {};
-    return o.create === true || isWriteOptedIn(o.edit) || isWriteOptedIn(o.delete);
+    return obj?.managedBy === 'system-data';
 }
 /**
  * Whether an object's rows may be edited in place (detail inline-edit / form
@@ -143,5 +166,5 @@ export function isSystemWritable(obj) {
  *   bucket affordance untouched.
  */
 export function isObjectInlineEditable(obj, effectiveApiOperations) {
-    return resolveCrudAffordances(obj, effectiveApiOperations).edit;
+    return resolveEffectiveCrudAffordances(obj, effectiveApiOperations).edit;
 }

package/dist/utils/normalize-list-view.d.ts

@@ -5,10 +5,20 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
+import type { RowHeight } from '@objectstack/spec/ui';
 /** ListView's toolbar density vocabulary — three steps, not the spec's five. */
 export type DensityMode = 'compact' | 'comfortable' | 'spacious';
-/** The spec's `RowHeightSchema` vocabulary. */
-export type RowHeight = 'compact' | 'short' | 'medium' | 'tall' | 'extra_tall';
+/**
+ * The spec's `RowHeightSchema` vocabulary — **re-exported, not re-declared**.
+ *
+ * The hand-written union that used to sit here already advertised itself as
+ * "the spec's `RowHeightSchema` vocabulary" in its doc comment, which is the
+ * failure class objectstack#4115 is about: the claim was true when written and
+ * nothing would have caught the day it stopped being true. The maps below are
+ * `Record<RowHeight, …>`, so a spec-side addition now fails the build here
+ * instead of silently leaving a row height with no density mapping.
+ */
+export type { RowHeight };
 /**
  * `densityMode` → `rowHeight`. The two vocabularies are not the same size: the
  * spec has five row heights, ListView's toolbar offers three. Widening maps

package/dist/utils/predicate-fields.d.ts

@@ -0,0 +1,96 @@
+/**
+ * ObjectUI — predicate field harvesting
+ * 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.
+ */
+/**
+ * Which record fields a view's PREDICATES read — the half of a view's field
+ * appetite that is not its columns.
+ *
+ * A list view projects what it DISPLAYS: `$select` is built from the column
+ * list (plus `id` and the expanded relation roots). That is correct for
+ * rendering and wrong for gating, because a `visible` / `disabled` /
+ * conditional-formatting predicate reads fields nobody put on screen — gating a
+ * row action on `record.owner` while showing Title / Status is the ordinary
+ * case, not an exotic one.
+ *
+ * The field then simply is not in the payload, and CEL does not treat an absent
+ * key as null: `record.owner == os.user.id` FAULTS with `No such key: owner`.
+ * Fault handling differs per surface and both answers are wrong — fail-CLOSED
+ * on the row kebab and the selection bar (the button silently disappears for
+ * everyone), fail-OPEN on the lenient paths (it appears for everyone). Nothing
+ * in either outcome points at a projection.
+ *
+ * Harvesting the names a predicate mentions and adding them to `$select` is
+ * what closes that. Note what it deliberately does NOT add: `$expand`. A
+ * predicate wants the stored foreign key, which is exactly what an unexpanded
+ * relation column already is — so a predicate-only relation field costs one
+ * more column and no extra round trip. (A relation that IS displayed still gets
+ * expanded for its label, and `toPredicateRecord` collapses it back for the
+ * predicate.)
+ */
+/**
+ * The columns the framework provisions on EVERY business object
+ * (`applySystemFields`) but does not publish in the object's `fields` metadata.
+ *
+ * They matter here because the most ordinary ownership predicate there is —
+ * `record.owner_id == os.user.id` — names one of them. Checking a harvested
+ * name against the declared fields alone would drop it, leaving the predicate
+ * with the same missing key the harvest exists to prevent.
+ *
+ * Deliberately the columns OBSERVED on a live payload rather than
+ * `SYSTEM_MANAGED_FIELD_NAMES` (`@object-ui/types`), which is the broader
+ * DISPLAY-oriented set and carries legacy aliases (`_id`, `createdAt`,
+ * `modified`, `space`) that are not columns anywhere. An alias in `$select` is
+ * exactly the unknown key the guard exists to keep out.
+ */
+export declare const PLATFORM_RECORD_COLUMNS: ReadonlySet<string>;
+/**
+ * Whether a harvested name is safe to put in a `$select` projection: either the
+ * object declares it, or it is one of the platform columns every object has.
+ *
+ * The check is not pedantry — an unknown key is not ignored by every backend
+ * (the cloud multi-tenant runtime answers with an EMPTY result set), so without
+ * it one typo'd predicate could blank a whole list.
+ */
+export declare function isProjectableField(name: string, declaredFields: Record<string, unknown> | null | undefined): boolean;
+/**
+ * Collect the record field names referenced by a set of predicates.
+ *
+ * Accepts predicates in every authored shape (bare CEL string, the
+ * `{ dialect, source }` envelope, `null`/`undefined`/boolean — the last three
+ * contribute nothing). Returns names in first-seen order, deduplicated.
+ *
+ * The result is a set of CANDIDATES, not verified fields: a typo'd predicate
+ * yields a name this object does not have. Callers must intersect it with the
+ * object's declared fields before putting it in a query — an unknown key in
+ * `$select` is not ignored by every backend (the cloud runtime answers with an
+ * empty result set), which would turn a typo into a blank list.
+ */
+export declare function collectPredicateFieldRefs(predicates: readonly unknown[]): string[];
+/**
+ * Every predicate a list-ish view carries, flattened for
+ * {@link collectPredicateFieldRefs}.
+ *
+ * One reader so the projection cannot fall behind the surfaces: each entry here
+ * is a place a predicate is actually evaluated against a row — conditional
+ * formatting, the row kebab (custom defs AND the built-in Edit/Delete
+ * overrides), the selection bar, and the object's declared actions.
+ *
+ * `objectActions` is deliberately the object's WHOLE action set rather than
+ * only the ones this view promotes. Narrowing it would mean re-running the
+ * name resolution `resolveLegacyRowActions` / `resolveBulkActions` already do,
+ * at a point in the fetch where the view's `rowActions` / `bulkActions` lists
+ * have not been folded yet — and the two directions of error are not
+ * symmetric: an extra column costs bytes, a missing one silently breaks the
+ * predicate that needed it.
+ */
+export declare function listViewPredicates(view: {
+    conditionalFormatting?: readonly unknown[] | null;
+    rowActionDefs?: readonly unknown[] | null;
+    bulkActionDefs?: readonly unknown[] | null;
+    objectActions?: readonly unknown[] | null;
+    userActions?: Record<string, unknown> | null;
+}): unknown[];