@object-ui/plugin-detail 17.6.0 → 17.7.0

package/dist/renderers/recordActivityFeed.d.ts

@@ -1,5 +1,5 @@
 import { FeedItem, FeedItemType } from '@object-ui/types';
-import { FeedFilterMode } from '../RecordActivityTimeline';
+import { FeedFilterMode } from '../RecordActivityTimeline.js';
 /** Spec default for `RecordActivityProps.limit`. */
 export declare const DEFAULT_ACTIVITY_LIMIT = 20;
 /**
@@ -56,16 +56,134 @@ export declare const DEFAULT_ACTIVITY_LIMIT = 20;
  * `showCompleted`; a not-yet-held meeting is `scheduled` → `event`, shown,
  * because an upcoming meeting is the part of a timeline you still act on.
  *
- * Whether the upstream enum should GAIN `scheduled` is a platform ruling, not
- * this block's to make — filed as objectstack#11424. Until it is ruled, the
- * honest statement of this table is the one the test now pins: the upstream
- * declaration PLUS the values a shipped producer measurably writes.
+ * ## The vocabulary is OPEN — ruled. Do NOT restore set-equality.
  *
- * Values outside BOTH groups are still dropped — see
- * {@link activityRowToFeedItem}, which now says so out loud instead of
- * silently.
+ * Maintainer ruling of 2026-08-24 (objectstack `88b9d749a`), **direction 4**:
+ * `sys_activity.type` is AUTHOR-EXTENSIBLE. The declared select options are the
+ * platform's BUILT-IN set, not the column's domain, and the two facts above are
+ * why — readonly fields are never validated on write, and ADR-0052 §5b.2
+ * forwards an author's `activityMilestones[].type` into the column verbatim.
+ *
+ * So the relation this table stands in is a SUPERSET, in one direction only:
+ *
+ *  - **map ⊇ built-ins** — every value the platform declares has an entry here,
+ *    either a feed type or a deliberate `undefined` exclusion. A new built-in
+ *    with no entry is a gap, and objectui#5969's pin turns red for it.
+ *  - **NOT built-ins ⊇ map**, and NOT set-equality in either spelling. An
+ *    author-extended value legitimately exists outside the declaration, so a
+ *    pin that required the two sets to match would be false by construction.
+ *
+ * ⛔ A reader who finds no equality check here is looking at a DECISION, not an
+ * omission: objectui#5840 removed the old set-equality pin on purpose, because
+ * pinning to the closed declaration meant dropping stored rows, and
+ * objectui#5969 replaced it with the two-directional pin under this ruling.
+ *
+ * (`scheduled` — the value #5840 was about — has since been declared upstream
+ * by objectstack#11522, superseding objectstack#11424. That is precisely the
+ * drift a hand-maintained equality pin cannot survive, and the reason the pin
+ * is a superset assertion plus a fallback rather than a census of two groups.)
+ *
+ * A value outside this table is NO LONGER DROPPED: it renders through
+ * {@link UNMAPPED_ACTIVITY_FEED_TYPE}. See {@link activityRowToFeedItem}.
  */
 export declare const ACTIVITY_TYPE_TO_FEED_TYPE: Readonly<Record<string, FeedItemType | undefined>>;
+/**
+ * The presentation an `sys_activity.type` value outside
+ * {@link ACTIVITY_TYPE_TO_FEED_TYPE} renders through.
+ *
+ * The second half of the direction-4 ruling (2026-08-24, objectstack `88b9d749a`): if
+ * the column is author-extensible, then a value this map has never heard of is
+ * REAL RECORD ACTIVITY that an author extended the platform with — not a
+ * mistake — and dropping it is the objectui#5840 failure mode reappearing for
+ * every author who ever writes one. Stored, queryable, invisible.
+ *
+ * `system` is the generic bucket rather than a new feed type because
+ * `FeedItemType` is a CLOSED spec enum owned by `@objectstack/spec` — minting a
+ * kind for "we don't know" is a platform change, not this block's.
+ *
+ * ⚠️ This is a FLOOR under the map, never a substitute for it. objectui#5840
+ * rejected a catch-all *offered as the fix* — an unmeasured type rendering as
+ * `system` is not the same data as a type someone read and mapped. What makes
+ * the catch-all safe here is that it does not stand alone: the superset pin
+ * above forces every built-in to keep its OWN presentation, so the fallback can
+ * only ever receive values nobody has ruled on yet, and the diagnostic below
+ * names each one so somebody can.
+ */
+export declare const UNMAPPED_ACTIVITY_FEED_TYPE: FeedItemType;
+/**
+ * Feed kinds an ObjectUI surface produces WITHOUT going through
+ * {@link ACTIVITY_TYPE_TO_FEED_TYPE}.
+ *
+ * Exactly one today: `comment`, built from `sys_comment` rows by app-shell's
+ * `RecordDetailView` (the `sys_comment` read, and the two optimistic rows the
+ * composer writes) and handed to this block through `DiscussionContext`. It
+ * cannot be derived here — app-shell depends on this package, not the other way
+ * round — so it is DECLARED, and `feedTypeProducerCensus-5877.test.ts` re-runs
+ * the census over the repository so the declaration cannot go stale silently.
+ *
+ * ## Census, and the pathspec it was taken over (objectui#5877)
+ *
+ * Every `.ts` / `.tsx` file in the repository that is not a test, at every top
+ * level (`packages/`, `apps/`, `examples/`, `scripts/`, `e2e/`), narrowed to the
+ * files that mention `FeedItem` at all — you cannot construct one without
+ * naming the type — then read for `FeedItemType` literals. 1622 files scanned,
+ * 13 mention `FeedItem`, one produces a kind off this map. A census is only as
+ * wide as its pathspec, so the pathspec is stated rather than implied, and the
+ * test above holds it.
+ *
+ * ⛔ NOT counted, deliberately: app-shell's `sharedUserFeeds.ts` /
+ * `activityItemType.ts` read the same `sys_activity` rows but produce
+ * `ActivityItemType` (`create` / `update` / `delete` / `comment` / `system`), a
+ * DIFFERENT five-value vocabulary that is not a projection of this one in either
+ * direction (objectui#6730 records why converging them costs rows). A row it
+ * turns into an `ActivityItem` never becomes a `FeedItem`, so it produces
+ * nothing for this feed. `ActivityEntry` in `@object-ui/types` is a third
+ * vocabulary again, and has no producer at all.
+ *
+ * ⚠️ Also NOT counted, and the reason the diagnostic below names it: a HOST can
+ * hand this block a feed of its own (`items` on the node, or a
+ * `DiscussionContext` it mounts itself). Those items are produced outside this
+ * repository, so no census taken here can bound their kinds.
+ */
+export declare const FEED_TYPES_PRODUCED_OFF_MAP: readonly FeedItemType[];
+/**
+ * Feed kinds this repository has decided NOT to adopt — as opposed to kinds
+ * nothing happens to produce.
+ *
+ * The distinction matters more than the diagnostic that uses it. Reporting a
+ * decision as a defect is how a warning channel gets trained out of an author's
+ * attention, and these three are decisions: `created` / `deleted` / `shared`
+ * rows are mapped to `field_change` ON PURPOSE, because `RecordDetailView` and
+ * this block must agree about what a `created` row IS before either can move to
+ * the richer kind. Adopting them is a change to that shared map, not to this
+ * block. The reasoning is written out at {@link ACTIVITY_TYPE_TO_FEED_TYPE}.
+ *
+ * ⚠️ This list is a TRANSCRIPTION of that prose, not a derivation, and there is
+ * no way to make it one: the decision exists as a comment, and a comment is not
+ * machine-readable. Two consequences, both load-bearing:
+ *
+ *  1. it is only as true as the prose it was copied from, so it is edited
+ *     together with that prose and never on its own;
+ *  2. a kind that is NOT on this list is not thereby known to be an oversight.
+ *     It is only known to have no producer. Whether somebody decided against it
+ *     and did not write it down is not recorded anywhere this code can read, and
+ *     the message below says so rather than guessing.
+ *
+ * ⛔ Do not extend it by inference. A kind belongs here when a decision about it
+ * is written down, not when its absence looks deliberate.
+ */
+export declare const DELIBERATELY_UNADOPTED_FEED_TYPES: readonly FeedItemType[];
+/**
+ * Every feed kind some ObjectUI surface can put on a record feed.
+ *
+ * DERIVED from the producers themselves — the map's range, its fallback, and
+ * the declared off-map producer above — never a second hand-written list of
+ * kinds. Giving an unproduced kind a producer (one new entry in
+ * {@link ACTIVITY_TYPE_TO_FEED_TYPE}) therefore retires its diagnostic in the
+ * same edit, with nothing else to remember. A hand-kept copy would not, and
+ * that copy is exactly what this file's header records the cost of.
+ */
+export declare const PRODUCED_FEED_TYPES: ReadonlySet<FeedItemType>;
 /** A row as `sys_activity` returns it. Loose on purpose: the block reads a
  *  system table it does not own, and an unknown column is not an error. */
 export interface SysActivityRow {
@@ -80,6 +198,12 @@ export interface SysActivityRow {
     source_id?: string | number | null;
     [k: string]: unknown;
 }
+/** Test seam: forget which `types` entries have already been named. */
+export declare function resetUnrecognisedFeedTypeWarnings(): void;
+/** Test seam: forget which unproduced `types` entries have already been named. */
+export declare function resetUnproducedFeedTypeWarnings(): void;
+/** Test seam: forget which `filterMode` values have already been named. */
+export declare function resetUnrecognisedFilterModeWarnings(): void;
 /**
  * Coerce an authored `filterMode` to a value the timeline understands.
  *
@@ -87,10 +211,40 @@ export interface SysActivityRow {
  * `<Select>` handed a value with no matching item renders blank and the
  * dropdown reads as broken. Same posture as objectui#3151 — an unrecognised
  * filter token is skipped, never turned into a filter that can't match.
+ *
+ * ## Why that fallback needs a diagnostic (objectui#5891)
+ *
+ * `'all'` is the WIDEST of the four declared modes — `filterItems` in
+ * `RecordActivityTimeline` narrows to ONE feed type for each of the other three
+ * and returns the feed untouched for `'all'` — so every unrecognised value
+ * lands on the one option that shows the author MORE than they asked for. A
+ * near-miss like `comments-only` or `commentsOnly` therefore opens the panel on
+ * the unfiltered stream, and the tell is a PLAUSIBLE result (a populated
+ * timeline) rather than an empty one that gets investigated. That is the same
+ * shape objectui#5841 removed from the sibling `types` sanitiser.
+ *
+ * The ruling on this card (triage, 2026-08-25) is that the defect is the
+ * INVISIBILITY, not the fallback: `filterMode` seeds a control the user can
+ * change, and there is no defensible narrower default to fall back to instead.
+ * So nothing that renders changes here — what changes is that the fold is now
+ * SAID OUT LOUD, once per distinct offending value on each block (see
+ * {@link warnOnce}).
+ *
+ * `block` is the registered name of the block the value was authored on
+ * (`record:activity`, `record:chatter`, `record:discussion`). It is REQUIRED,
+ * not defaulted: the message is addressed to that block's author, and a default
+ * would hand every caller that forgot it some other block's name — the defect
+ * objectui#9557 removed.
+ *
+ * Absent (`undefined` / `null`) is silent: no `filterMode` was authored, which
+ * is not a mistake, and a warning about a decision teaches authors to ignore
+ * the channel. Only a value the author actually wrote is reported.
+ *
+ * The declared modes named in the message are read from `@objectstack/spec`'s
+ * `FeedFilterMode` at runtime, never re-typed here — see the file header for
+ * what a hand copy of a spec enum cost.
  */
-export declare function normalizeFilterMode(value: unknown): FeedFilterMode;
-/** Test seam: forget which `types` entries have already been named. */
-export declare function resetUnrecognisedFeedTypeWarnings(): void;
+export declare function normalizeFilterMode(value: unknown, block: string): FeedFilterMode;
 /**
  * Sanitise an authored `types` allow-list. Narrowing or refusal, never widening.
  *
@@ -103,6 +257,7 @@ export declare function resetUnrecognisedFeedTypeWarnings(): void;
  * | `[]`                          | `[]`        | nothing — the author said "no kinds" |
  * | `['crm_task']` (none known)   | `[]`        | nothing, plus one diagnostic   |
  * | `['task', 'crm_task']`        | `['task']`  | the recognised members, plus one diagnostic |
+ * | `['approval']` (no producer)  | `['approval']` | nothing, plus one diagnostic — the kind is declared and honoured, but nothing emits it (objectui#5877) |
  *
  * `undefined` now means "no `types` key was authored" and ONLY that. It used to
  * mean that OR "everything you authored was dropped", and {@link applyFeedConfig}
@@ -121,13 +276,57 @@ export declare function resetUnrecognisedFeedTypeWarnings(): void;
  * Membership is read from `@objectstack/spec`'s `FeedItemType` at runtime, never
  * re-typed here — see the file header for what a hand copy of a spec enum cost.
  *
- * NOT pure: an entry it cannot recognise logs once (see {@link warnOnce}). The
- * failure being repaired is invisibility, so the diagnostic is the other half of
- * the fix rather than a nicety.
+ * NOT pure, on TWO independent channels (see {@link warnOnce}) — the failure
+ * being repaired is invisibility in both cases, so the diagnostics are the other
+ * half of the fix rather than a nicety:
+ *
+ *  - an entry it cannot recognise logs once (no declared kind matches it);
+ *  - a RECOGNISED entry that no producer emits logs once as well, on its own
+ *    channel — see {@link warnUnproducedFeedTypes}. That one changes nothing
+ *    about the return value: the kind is declared, so it is kept and honoured.
+ *
+ * Both channels name, and dedupe per, the REQUIRED `block` the list was
+ * authored on — see {@link normalizeFilterMode} for why it has no default.
+ */
+export declare function normalizeFeedTypes(value: unknown, block: string): FeedItemType[] | undefined;
+/**
+ * The ONE resolver for this block's row cap (objectui#10096, objectui#10145).
+ *
+ * A refused value is dropped for this block's own default.
+ *
+ * ⛔ Not `Math.floor`, which objectui#10096 replaced: flooring REPAIRED an
+ * authored `2.5` into a two-row window and handed it back as a result, so the
+ * author got a silently different number than the one they wrote. Refusing and
+ * defaulting is the answer the sibling `record:history` gives through
+ * `normalizeHistoryLimit`, and the answer objectui#9925 landed at three further
+ * read points (all three test `typeof value === 'number'` first, as this does).
+ *
+ * `NaN` and both infinities are refused (not integers); `0` and negatives are
+ * refused (not positive); `undefined` is the unauthored case and resolves to
+ * the default without being a refusal.
+ *
+ * ⚠️ FAIL-SOFT on purpose: throwing would take out a record page over one
+ * declaration. It is NOT silent — the renderers that call this state every
+ * refusal through `describeRefusedFeedLimit` (objectui#10097 ruled "always
+ * warn" for the family; objectui#10145 extends the refused set to non-numbers).
+ * This function stays pure so it can run on every render.
+ *
+ * ⭐ Shared with `record:chatter` / `record:discussion`, which resolve
+ * `feed.limit` through this same function — `RecordChatterProps.feed` is
+ * `RecordActivityProps`, so it is the same declared member and the same
+ * refusal.
  */
-export declare function normalizeFeedTypes(value: unknown): FeedItemType[] | undefined;
-/** Coerce `limit` to a positive integer, falling back to the spec default. */
 export declare function normalizeLimit(value: unknown): number;
+/**
+ * The diagnostic half of the row-cap refusal for the blocks that resolve
+ * through `normalizeLimit` (`record:activity`, `record:chatter`,
+ * `record:discussion`). `null` means "nothing to say": an absent `limit`
+ * (`undefined` / `null`) is not a mistake, and a usable one is not either.
+ *
+ * Callers fire it from an effect keyed on the declaration — the channel
+ * objectui#9925 uses at its three read points — never from render.
+ */
+export declare function describeRefusedFeedLimit(block: string, authored: unknown): string | null;
 /**
  * Timestamp of a `sys_activity` row.
  *
@@ -143,9 +342,18 @@ export declare function resetUnknownActivityTypeWarnings(): void;
  * One `sys_activity` row → one {@link FeedItem}, or `null` when the row is not
  * record activity (see {@link ACTIVITY_TYPE_TO_FEED_TYPE}).
  *
- * Two different `null`s, and the difference is the point: a type the table
- * maps to `undefined` is a deliberate exclusion and returns quietly; a type the
- * table does not contain at all is an unmapped producer and says so once.
+ * Three outcomes, and the difference between the last two is the whole of the
+ * direction-4 ruling (2026-08-24, objectstack `88b9d749a`):
+ *
+ *  - a type mapped to a feed type renders with THAT presentation;
+ *  - a type the table maps to `undefined` is a DELIBERATE exclusion — `null`,
+ *    quietly, because a warning about a decision teaches authors to ignore the
+ *    channel;
+ *  - a type the table does not contain at all is an AUTHOR-EXTENDED value under
+ *    the ruled open vocabulary. It renders through
+ *    {@link UNMAPPED_ACTIVITY_FEED_TYPE} and says so once. It used to return
+ *    `null` here, which made every extended value invisible — the same outcome
+ *    objectui#5840 was filed for, reached by a different route.
  */
 export declare function activityRowToFeedItem(row: SysActivityRow, systemActorLabel: string): FeedItem | null;
 /** The subset of `RecordActivityProps` that decides which items survive. */
@@ -173,8 +381,52 @@ export interface AppliedFeed {
  * `pageSize` is the effective window (`limit` on first render, grown by
  * "Load more"); it is separate from `config.limit` so paging does not have to
  * rewrite the authored config.
+ *
+ * `block` is the registered name of the block whose config this is; the
+ * `types` diagnostics are addressed to it (objectui#9557, see
+ * {@link normalizeFilterMode}).
  */
-export declare function applyFeedConfig(items: readonly FeedItem[], config: FeedConfigFilters, pageSize: number): AppliedFeed;
+export declare function applyFeedConfig(items: readonly FeedItem[], config: FeedConfigFilters, pageSize: number, block: string): AppliedFeed;
 /** Sort a feed chronologically and de-duplicate by id (feeds are append-only). */
 export declare function mergeFeedItems(...groups: readonly FeedItem[][]): FeedItem[];
+/**
+ * Whether a rejected feed read — `sys_activity` or `sys_comment` — was REFUSED
+ * (objectui#11195): the server answered, and the answer was "not for you".
+ *
+ * A refused read and an empty read are different answers about the record, and
+ * the panel used to give both the same one. Every failure on the feed landed on
+ * `No activity recorded` / `No comments yet`, so a member the server refused
+ * read a permission wall as a record where nothing had happened. The panel now
+ * shows a no-permission state for a refused read instead, and keeps the empty
+ * state for a read that answered with zero rows.
+ *
+ * The verdict is `classifyLoadError`'s (`@object-ui/react`), the read
+ * classifier `ListView`'s error panel and `RecordAttachmentsPanel` already
+ * share. Nothing here reads a status or a code of its own. Refused means the
+ * two kinds that are about the caller:
+ *
+ *   - `forbidden`: 403, or a `PERMISSION_DENIED` / `FORBIDDEN` envelope;
+ *   - `unauthorized`: 401, or `UNAUTHORIZED` / `UNAUTHENTICATED`.
+ *
+ * ⚠️ The 401 half is a deliberate difference from `RecordAttachmentsPanel`,
+ * whose `denied` state does not claim a 401. The triage on objectui#11195 ruled
+ * it for this panel: any refused read (401 / 403, or a permission envelope)
+ * shows the no-permission state.
+ *
+ * NOT refused, so these keep today's empty state:
+ *
+ *   - `api-disabled` (`OBJECT_API_DISABLED` 404 / `OBJECT_API_METHOD_NOT_ALLOWED`
+ *     405): a property of the object's metadata, not of the caller, and no
+ *     permission grant changes it;
+ *   - a bare 404 (`sys_activity` on a deployment without the audit plugin).
+ *     The ObjectStack adapter already answers that as zero rows; another
+ *     adapter's rejection classifies as `network` and lands here;
+ *   - `rejected` (400) and `network` (a 5xx, an unreachable server). Those are
+ *     failures, not refusals. The panel has no error state of its own, so they
+ *     still render the empty state.
+ *
+ * ⛔ A refusal is not retried. A refused read is the same answer on every
+ * retry, so the callers write it into state and do not re-issue the read.
+ */
+export declare function isRefusedFeedRead(err: unknown): boolean;
 //# sourceMappingURL=recordActivityFeed.d.ts.map

package/dist/renderers/recordActivityFeed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recordActivityFeed.d.ts","sourceRoot":"","sources":["../../src/renderers/recordActivityFeed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAKhE,oDAAoD;AACpD,eAAO,MAAM,sBAAsB,KAAK,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,GAAG,SAAS,CAAC,CAazF,CAAC;AAgBF;2EAC2E;AAC3E,MAAM,WAAW,cAAc;IAC7B,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACnC,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,CAIlE;AAkCD,uEAAuE;AACvE,wBAAgB,iCAAiC,IAAI,IAAI,CAExD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,EAAE,GAAG,SAAS,CAuC7E;AAED,8EAA8E;AAC9E,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAGrD;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,cAAc,GAAG,MAAM,CAM7D;AAiCD,4EAA4E;AAC5E,wBAAgB,gCAAgC,IAAI,IAAI,CAEvD;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,cAAc,EACnB,gBAAgB,EAAE,MAAM,GACvB,QAAQ,GAAG,IAAI,CAoBjB;AAED,4EAA4E;AAC5E,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,2EAA2E;IAC3E,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAC;IACd,uEAAuE;IACvE,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,MAAM,EAAE,iBAAiB,EACzB,QAAQ,EAAE,MAAM,GACf,WAAW,CAyCb;AAED,kFAAkF;AAClF,wBAAgB,cAAc,CAAC,GAAG,MAAM,EAAE,SAAS,QAAQ,EAAE,EAAE,GAAG,QAAQ,EAAE,CAU3E"}
+{"version":3,"file":"recordActivityFeed.d.ts","sourceRoot":"","sources":["../../src/renderers/recordActivityFeed.ts"],"names":[],"mappings":"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"}

package/dist/renderers/recordComponentAria.d.ts

@@ -0,0 +1,44 @@
+import { RecordComponentAriaProps } from '@object-ui/types';
+/**
+ * The authored `aria` bag as a renderer actually receives it: the declared
+ * face, plus the undeclared `label` spelling a stored document may still carry.
+ */
+export type AuthoredRecordAria = RecordComponentAriaProps & {
+    /**
+     * ⛔ Not a member of the contract. It is the shared ARIA shape's alias entry
+     * and is refused on parse. Declared on this type ONLY so the diagnostic can
+     * see it without an `as any` cast (a cast is how `record:path` once came to
+     * read this spelling and no other).
+     *
+     * ⚠️ It is never read as a name. objectui#9945 retired the fold that did;
+     * a served value is reported, and only for a caller that names its `block`.
+     * See this module's header.
+     */
+    label?: string;
+};
+/** What {@link useRecordAriaProps} spreads onto a block's container element. */
+export interface RecordAriaDomProps {
+    'aria-label'?: string;
+    'aria-describedby'?: string;
+    role?: string;
+}
+/**
+ * The ARIA DOM props for a `record:*` block's own container.
+ *
+ * @param aria - the authored bag, straight off the node's `aria` key.
+ * @param defaultRole - the role this block renders when the author declares
+ *   none. Omit it and the container stays role-less until an author declares a
+ *   name, a description or a role — at which point `'region'` carries the name,
+ *   because an attribute on a `generic` element carries nothing.
+ * @param defaultLabel - the block's built-in accessible name, used when the
+ *   author declared none (or declared an empty one).
+ * @param block - the block's registered type (`record:path`), named in the
+ *   report of a served `aria.label`. Omit it and that spelling is still not
+ *   read, just not reported. See this module's header for which blocks pass it.
+ */
+export declare function useRecordAriaProps(aria: AuthoredRecordAria | undefined, { defaultRole, defaultLabel, block, }?: {
+    defaultRole?: string;
+    defaultLabel?: string;
+    block?: string;
+}): RecordAriaDomProps;
+//# sourceMappingURL=recordComponentAria.d.ts.map

package/dist/renderers/recordComponentAria.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recordComponentAria.d.ts","sourceRoot":"","sources":["../../src/renderers/recordComponentAria.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmGG;AAKH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AAEjE;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,wBAAwB,GAAG;IAC1D;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,gFAAgF;AAChF,MAAM,WAAW,kBAAkB;IACjC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAwCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,kBAAkB,GAAG,SAAS,EACpC,EACE,WAAW,EACX,YAAY,EACZ,KAAK,GACN,GAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GACtE,kBAAkB,CAapB"}

package/dist/renderers/relatedListActions.d.ts

@@ -0,0 +1,102 @@
+/**
+ * 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.
+ *
+ * `record:related_list.actions` — where an authored action id lands on the list,
+ * or why it is refused (objectui#11163; the maintainer's ENFORCE ruling on
+ * objectstack-ai/objectstack#20665).
+ *
+ * The contract declares the key as `z.array(z.string())`, "Action IDs available
+ * for related records". This module is the whole of its meaning, kept apart
+ * from the renderer so the file that draws the block keeps exporting
+ * components only:
+ *
+ *   - RESOLUTION is `resolveDeclaredActionIds` — the one function
+ *     `page:header`, `record:quick_actions` and `record:alert` resolve an
+ *     authored action id through (objectui#7182, objectui#7382) — against the
+ *     RELATED object's registered `actions`. ⛔ No second lookup: the caller
+ *     reads that registry through `useMetadataItem('object', …)`, the same
+ *     entry `record:quick_actions.actionNames` uses.
+ *   - Only the IDS arm is this key's. The inline-object arm of the shared
+ *     rule is `page:header`'s transition tolerance (objectstack#11592) and is
+ *     not inherited here, the choice `record:alert` made for its CTA: an
+ *     object in this array would widen what a related list can run past what
+ *     the object declares.
+ *   - PLACEMENT is each action's own `locations`, read by `actionRendersAt`
+ *     — the platform's one placement rule, and the rule the host bridge
+ *     (`RelatedRecordActionsBridge.deriveActions`) already applies to this
+ *     list: `list_toolbar` draws a header button; `list_item` and
+ *     `record_related` draw a row-menu item (objectui#11270). This block only
+ *     ever renders inside a parent record, which is the scope `record_related`
+ *     names (objectstack-ai/objectstack#20937, triage `5919625056`: row
+ *     placement, inside a record only). Naming an action here does not bypass
+ *     location filtering (only a list view's selection bar is placed by
+ *     naming), so an id whose action declares none of the three is REFUSED
+ *     rather than drawn somewhere or dropped.
+ *   - ORDER is the author's, within each surface.
+ */
+/**
+ * An action definition as the registry holds it — the two members read here,
+ * typed `unknown` because the definitions arrive straight off the metadata
+ * wire (the reason `actionRendersAt` gives for its own parameter).
+ */
+export interface RegisteredRelatedAction {
+    readonly name?: unknown;
+    readonly locations?: unknown;
+}
+/** One reason an authored entry does not render, stated for the author. */
+export type RelatedListActionRefusal = 
+/** The array itself is refused: not an array, or not all action ids. */
+{
+    readonly kind: 'array';
+    readonly message: string;
+}
+/** An id that names no registered action of the related object. */
+ | {
+    readonly kind: 'unresolved';
+    readonly id: string;
+}
+/** An id that resolves, to an action declaring no location this list renders. */
+ | {
+    readonly kind: 'unplaced';
+    readonly id: string;
+};
+export interface PlacedRelatedListActions<T> {
+    /** `list_toolbar` actions, in authored order — the list's header buttons. */
+    readonly toolbar: T[];
+    /** `list_item` and `record_related` actions, in authored order — each row's menu. */
+    readonly row: T[];
+    /** Every authored entry that renders nowhere, and why. */
+    readonly refused: RelatedListActionRefusal[];
+}
+/**
+ * Whether an authored value has any id to look up — the registry-independent
+ * half of the shared rule, so the caller requests the metadata read only when
+ * it can change the answer (a `[]`, an object array or a refused array is
+ * decided without it).
+ */
+export declare function relatedListActionsNeedLookup(authored: unknown): boolean;
+/**
+ * Resolve and place an authored `record:related_list.actions` value.
+ *
+ * `registered` is the related object's `actions` once the metadata lookup has
+ * ANSWERED. The caller does not call this while the lookup is in flight: every
+ * id would come back unresolved and the list would refuse an id it is about to
+ * resolve.
+ *
+ * An id authored twice renders once, at its first position — it is drawn, so
+ * nothing the author asked for is dropped.
+ */
+export declare function placeAuthoredRelatedListActions<T extends RegisteredRelatedAction>(authored: unknown, registered: readonly T[] | null | undefined): PlacedRelatedListActions<T>;
+/**
+ * The refusal notice's text — one sentence per refused entry, naming it and
+ * the related object, so the fix is a one-entry edit.
+ *
+ * `objectKnown` is whether the lookup found the related object at all: an id
+ * cannot be "not an action of" an object whose metadata never arrived.
+ */
+export declare function describeRelatedListActionRefusals(refused: readonly RelatedListActionRefusal[], objectName: string, objectKnown: boolean): string;
+//# sourceMappingURL=relatedListActions.d.ts.map

package/dist/renderers/relatedListActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relatedListActions.d.ts","sourceRoot":"","sources":["../../src/renderers/relatedListActions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAIH;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,2EAA2E;AAC3E,MAAM,MAAM,wBAAwB;AAClC,wEAAwE;AACtE;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE;AACtD,mEAAmE;GACjE;IAAE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE;AACtD,iFAAiF;GAC/E;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvD,MAAM,WAAW,wBAAwB,CAAC,CAAC;IACzC,6EAA6E;IAC7E,QAAQ,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC;IACtB,qFAAqF;IACrF,QAAQ,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC;IAClB,0DAA0D;IAC1D,QAAQ,CAAC,OAAO,EAAE,wBAAwB,EAAE,CAAC;CAC9C;AAQD;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAIvE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,+BAA+B,CAAC,CAAC,SAAS,uBAAuB,EAC/E,QAAQ,EAAE,OAAO,EACjB,UAAU,EAAE,SAAS,CAAC,EAAE,GAAG,IAAI,GAAG,SAAS,GAC1C,wBAAwB,CAAC,CAAC,CAAC,CA6C7B;AAED;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,SAAS,wBAAwB,EAAE,EAC5C,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,OAAO,GACnB,MAAM,CAeR"}

package/dist/summaryChipPercent.d.ts

@@ -0,0 +1,83 @@
+import { PercentScale } from '@object-ui/core';
+/**
+ * The ONE rule the `summaryFields` chip scales a stored `percent` by — and it
+ * is the repo's, not this file's (objectui#9071).
+ *
+ * ⭐ Since objectui#9167 this is the chip's BAR path only. The chip's TEXT goes
+ * straight to `formatPercent` in `@object-ui/fields` — the list cell's own
+ * body, which applies {@link percentDisplayValue} itself and then the locale's
+ * percent affix at the field's precision. See "The half objectui#9071 did NOT
+ * take" below, which objectui#9167 closed.
+ *
+ * ## Why this function exists at all (objectui#8728)
+ *
+ * The chip beside the record H1 draws a percent TWICE — as its text and as a
+ * small bar — and the two halves scaled the same stored number by two
+ * different rules:
+ *
+ *     display = `${num}%`;                            // the text: no scaling
+ *     const normalized = num <= 1 ? num * 100 : num;  // the bar: ratio, scaled
+ *
+ * so a stored `0.123` labelled itself `0.123%` beside a bar filled to 12.3%.
+ * One control, two percentages, and neither half told the reader which one was
+ * right. Both halves read this function — which is why it is a named function
+ * and not the same ternary written twice. The next reader cannot
+ * re-desynchronise them without deleting a call site.
+ *
+ * ## What objectui#9071 DELETED, and why aligning it would not have done
+ *
+ * objectui#8728 converged the chip's two halves onto the BAR's rule and
+ * recorded, rather than decided, that the rule was the chip's own. The census
+ * it asked for answered the question: the predicate that stood here —
+ * a pass-through spelled `if (raw > 1) return raw;`, i.e. the bar's original
+ * `num <= 1` written the other way round — was the only spelling of its kind on
+ * this side of the tree, and it disagreed with the declared single source of
+ * truth at EXACTLY 1 and at every value AT OR BELOW -1:
+ *
+ * | stored | the deleted local rule | `percentDisplayValue`, and every other band |
+ * |--------|------------------------|---------------------------------------------|
+ * | `0.25` | `25%`                  | `25%`   (the band they always agreed on)     |
+ * | `1`    | `100%`                 | `1%`                                         |
+ * | `-1`   | `-100%`                | `-1%`                                        |
+ * | `-5`   | `-500%`                | `-5%`                                        |
+ *
+ * ⛔ The repair is NOT to move the local predicate's boundary onto the shared
+ * one. That would leave two rules agreeing by coincidence — the same shape
+ * objectui#5607 removed one package over, and the shape that produced this
+ * drift in the first place. The predicate is gone; the authority is
+ * {@link percentDisplayValue} in `@object-ui/core`, whose own doc comment
+ * requires exactly this of a third surface, and which the list cell
+ * (`formatPercent` / `PercentCellRenderer`), the dashboard measure
+ * (`formatMeasure`) and the grid column summary already read.
+ *
+ * ## The half objectui#9071 did NOT take — closed by objectui#9167
+ *
+ * That doc comment asks a third surface for BOTH halves — the scaling AND the
+ * convention. objectui#9071 moved the SCALING only: the chip stated the full
+ * JavaScript number with a bare `%` while the list cell rendered through the
+ * locale's percent affix at the field's precision (`0` by default), so a stored
+ * `12.3` read `12.3%` beside the H1 and `12%` in the list — two spellings of
+ * one magnitude, with the two bars proving the magnitude was one. That card
+ * stopped because its acceptance forbade moving values the chip rendered
+ * correctly today, and the convention half moves several.
+ *
+ * objectui#9167 took it, value by value rather than by inspection: both
+ * surfaces were driven in the same run, on the same field, for every stored
+ * value below, and every row that MOVED moved onto the reading the list cell
+ * was already giving. The chip's text is now the cell's own `formatPercent`
+ * call, byte for byte, and this function is left
+ * holding the BAR alone. The table and its `de-DE` leg are pinned in
+ * `__tests__/summaryChip.percentConvention-9167.test.tsx`.
+ *
+ * ## The storage is the field's, stated by the caller (objectui#11475)
+ *
+ * `percentScale` is the storage the chip's field declares, which `DetailView`
+ * reads with `percentCellScale` (`@object-ui/fields`): the spec's
+ * `percentScaleOf`, the answer the list cell reads too. Until objectui#11475
+ * the shared source guessed the storage from the value's magnitude, so the
+ * table above, whose every row is that guess, no longer describes this
+ * function: a fraction-stored `1` now fills the bar to 100%, and a
+ * whole-stored `0.5` to half a percent.
+ */
+export declare function summaryChipPercentPoints(raw: number, percentScale: PercentScale): number;
+//# sourceMappingURL=summaryChipPercent.d.ts.map

package/dist/summaryChipPercent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summaryChipPercent.d.ts","sourceRoot":"","sources":["../src/summaryChipPercent.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,GAAG,MAAM,CAyBxF"}