@byline/core 3.13.3 → 3.15.0

package/dist/@types/admin-types.d.ts

@@ -182,15 +182,26 @@ export interface CollectionAdminConfig<T = any> {
     /** Column definitions for the collection list view. */
     columns?: ColumnDefinition<T>[];
     /**
-     * Column definitions for this collection when it appears as the target
-     * of a relation picker (the modal opened from a `relation` field widget).
+     * Column definitions for rendering this collection as a compact **item
+     * row / tile** wherever a single document is shown outside its own list —
+     * the relation picker modal, relation-summary tiles, `hasMany` relation
+     * tiles, and (planned) cross-collection search-result rows.
      *
-     * Shape matches `ColumnDefinition` so formatters like a thumbnail cell or
-     * date formatter can be reused across list and picker. Omit to fall back
-     * to a single-line render of `useAsTitle` + `path`.
+     * It is a per-collection *item contract*: it declares both **what to fetch**
+     * (the projection — which fields hydrate the row, including relation
+     * `displayField`s) and **how to render** (the columns + formatters, e.g. a
+     * thumbnail cell or date formatter). Shape matches `ColumnDefinition` so
+     * formatters are shared with the list view. Omit to fall back to a
+     * single-line render of `useAsTitle` + `path`.
      *
-     * Purely a UI concern — does not affect populate's default projection,
-     * which uses `CollectionDefinition.useAsTitle` server-side.
+     * Resolve it through `resolveItemViewColumns(config)` rather than reading
+     * the field directly, so the deprecated `picker` alias keeps working.
+     */
+    itemView?: ColumnDefinition<T>[];
+    /**
+     * @deprecated Renamed to {@link itemView}. Kept as a backwards-compatible
+     * alias — `itemView` wins when both are present. Read both via
+     * `resolveItemViewColumns(config)`. Will be removed in a future major.
      */
     picker?: ColumnDefinition<T>[];
     /** Default columns to show when no explicit column config is provided. */
@@ -299,6 +310,33 @@ export interface CollectionAdminConfig<T = any> {
      * ```
      */
     listView?: (props: ListViewComponentProps) => any;
+    /**
+     * Header action components for the **default** list view — rendered in the
+     * list header alongside the Create button. Each receives a
+     * {@link ListActionComponentProps} (`{ collectionPath }`). The reusable
+     * injection point for collection-level admin actions (reindex search,
+     * export, bulk operations, …) without replacing the whole `listView`.
+     *
+     * Ignored when a custom `listView` is provided (that component owns its own
+     * chrome). Components are responsible for their own permission gating.
+     *
+     * @example
+     * ```ts
+     * import { ReindexButton } from '@byline/host-tanstack-start/admin-shell/collections/reindex-button'
+     * // In your CollectionAdminConfig:
+     * listActions: [ReindexButton],
+     * ```
+     */
+    listActions?: Array<(props: ListActionComponentProps) => any>;
+}
+/**
+ * Props passed to each `CollectionAdminConfig.listActions` component. Kept
+ * minimal and framework-agnostic (`@byline/core` is React-free); components
+ * resolve everything else (server fns, abilities, toasts) from the host.
+ */
+export interface ListActionComponentProps {
+    /** The collection path the list view is showing, e.g. `'docs'`. */
+    collectionPath: string;
 }
 /**
  * Type-safe factory for creating a `CollectionAdminConfig` linked to a schema.

package/dist/@types/collection-types.d.ts

@@ -10,6 +10,7 @@ import type { ReadContext } from './db-types.js';
 import type { FieldSetData, FieldSetDataAllLocales, StoredFileValue } from './field-data-types.js';
 import type { Block, DefaultValue, Field, FileField, ImageField } from './field-types.js';
 import type { QueryPredicate } from './query-predicate.js';
+import type { SearchFieldDecl } from './search-types.js';
 import type { IStorageProvider } from './storage-types.js';
 import type { Prettify } from './type-utils.js';
 /** Output format for Sharp-generated image variants. */
@@ -895,12 +896,39 @@ export interface CollectionDefinition {
      */
     hooks?: CollectionHooks | CollectionHooksLoader;
     /**
-     * Configures which text fields are searched when the admin list view's
-     * search box is used. Only `store_text` fields are supported for now.
-     * Falls back to `{ fields: ['title'] }` when omitted.
+     * Search configuration for this collection — a **role-based** declaration
+     * of what to index. The implementor names fields by the role they play;
+     * core derives each field's type from the schema and assembles the
+     * type-enriched `SearchDocument` (see the `SearchProvider` seam in
+     * `docs/05-reading-and-delivery/07-search.md`). Nothing is auto-pulled, so
+     * unindexed content (editorial notes, internal fields) never leaks into
+     * the index.
+     *
+     * - `body` — fields whose text feeds the full-text searchable content.
+     *   Text fields contribute their value; `richText` fields are extracted to
+     *   plain text via the registered `fields.richText.toText` seam. Each entry
+     *   is a field path, or `{ field, boost }` to weight it for scoring
+     *   providers that support `capabilities.weighting`. Drives the admin
+     *   list-view search box (its `store_text` subset). Falls back to the
+     *   identity field (`useAsTitle`) when omitted.
+     * - `facets` — relation field paths to controlled-vocabulary collections.
+     *   Core resolves each target's `counter` field (the stable aggregation id)
+     *   and its `useAsTitle` (the term, folded into searchable text). `{ field,
+     *   boost }` weights the indexed term.
+     * - `filters` — scalar field paths projected for filtering / sorting (not
+     *   scored).
+     * - `zones` — the search scope(s) this collection belongs to. A collection
+     *   can belong to more than one zone (e.g. both a dedicated `publications`
+     *   archive search and a general `site` search). When a collection opts
+     *   into search without naming zones, it gets a single implicit zone equal
+     *   to its collection path, so single-collection search always works and
+     *   shared `site`-style zones are opt-in.
      */
     search?: {
-        fields: string[];
+        body?: SearchFieldDecl[];
+        facets?: SearchFieldDecl[];
+        filters?: string[];
+        zones?: string[];
     };
     /**
      * The field that represents this document's identity — used anywhere a

package/dist/@types/field-types.d.ts

@@ -405,6 +405,27 @@ export interface RelationField extends NonlocalizableField {
      * summary. Falls back to the first text field if omitted.
      */
     displayField?: string;
+    /**
+     * When `true`, the field holds an **ordered list** of target references
+     * rather than a single one. The value shape becomes an array of relation
+     * envelopes (`RelatedDocumentValue[]`), persisted as indexed `store_relation`
+     * rows (`<field>.0`, `<field>.1`, …) and reconstructed in order. The admin
+     * widget renders an add / remove / drag-reorder list of summary tiles.
+     *
+     * A given target may appear at most once (the widget dedups on
+     * `targetDocumentId`). Defaults to single-target (`false` / absent).
+     */
+    hasMany?: boolean;
+    /**
+     * Minimum number of references required when `hasMany` is `true`. Enforced by
+     * the generated Zod schema. Ignored for single-target relations.
+     */
+    minItems?: number;
+    /**
+     * Maximum number of references allowed when `hasMany` is `true`. Enforced by
+     * the generated Zod schema. Ignored for single-target relations.
+     */
+    maxItems?: number;
 }
 export interface FileField extends NonlocalizableField {
     type: 'file';
@@ -687,4 +708,26 @@ export interface RichTextToMarkdownContext {
  * by contract — output is never re-imported.
  */
 export type RichTextToMarkdownFn = (ctx: RichTextToMarkdownContext) => string;
+/**
+ * Context passed to the richtext plain-text extractor for one rich-text
+ * field value. Read-only and synchronous — walks the stored editor JSON
+ * directly (no editor instantiation, no DB reads).
+ */
+export interface RichTextToTextContext {
+    /** The richText field's value (raw editor JSON, possibly stringified). */
+    value: unknown;
+    /** Field path within the document — e.g. `'body'` or `'content.0.caption'`. */
+    fieldPath: string;
+    /** Collection path the document belongs to. */
+    collectionPath: string;
+}
+/**
+ * Server-side plain-text extractor contract — flattens a rich-text value to
+ * indexable plain text (a recursive text-node accumulator, no markdown
+ * syntax). Editor adapters export an implementation (e.g. `lexicalToText`
+ * from `@byline/richtext-lexical/server`); installations register one via
+ * `ServerConfig.fields.richText.toText`. Consumed by search indexing
+ * (`buildSearchDocument`) to feed `body`. One-way and lossy by contract.
+ */
+export type RichTextToTextFn = (ctx: RichTextToTextContext) => string;
 export {};

package/dist/@types/index.d.ts

@@ -12,6 +12,7 @@ export * from './field-data-types.js';
 export * from './field-types.js';
 export * from './populate-types.js';
 export * from './query-predicate.js';
+export * from './search-types.js';
 export * from './site-config.js';
 export * from './storage-types.js';
 export * from './store-types.js';

package/dist/@types/index.js

@@ -12,6 +12,7 @@ export * from './field-data-types.js';
 export * from './field-types.js';
 export * from './populate-types.js';
 export * from './query-predicate.js';
+export * from './search-types.js';
 export * from './site-config.js';
 export * from './storage-types.js';
 export * from './store-types.js';

package/dist/@types/search-types.d.ts

@@ -0,0 +1,275 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+/**
+ * The `SearchProvider` seam — a provider-agnostic search interface,
+ * registered on `ServerConfig.search` and composed by `initBylineCore()`,
+ * mirroring how `IDbAdapter`, `IStorageProvider`, and the
+ * `fields.richText.*` adapters plug into core.
+ *
+ * Core normalises each document into a flat, provider-agnostic,
+ * **type-enriched** {@link SearchDocument} and hands that to the provider —
+ * the provider never sees EAV store rows. The document carries a typed,
+ * role-tagged field projection ({@link SearchField}) so a driver can map
+ * each field onto its own index schema (Postgres store columns + weighted
+ * tsvector, Solr dynamic fields, a vector store's payload, …) without
+ * re-deriving types. A built-in Postgres full-text driver ships as
+ * `@byline/search-postgres`; external drivers implement the same interface
+ * rather than forking the read path.
+ *
+ * The provider factory (e.g. `postgresSearch({ getClient })`) lives in the
+ * driver package, not here — core declares only the interface and its data
+ * types, the same way `RichTextPopulateFn` is declared in core while
+ * `lexicalEditorPopulateServer()` lives in `@byline/richtext-lexical`. This
+ * keeps `@byline/core` from depending on `@byline/client`.
+ *
+ * See `docs/05-reading-and-delivery/07-search.md` for the full design.
+ */
+import type { QueryPredicate } from './query-predicate.js';
+/**
+ * One field declaration in a collection's role-based `search` config — a
+ * field path, or `{ field, boost }` to weight it for scoring providers that
+ * support `capabilities.weighting`. The bare-string shorthand uses the
+ * provider's default weight.
+ */
+export type SearchFieldDecl = string | {
+    field: string;
+    boost?: number;
+};
+/**
+ * The index value type of a projected field — schema-derived by core, so a
+ * driver can map the field onto its own schema without re-inspecting the
+ * collection definition (Solr dynamic-field suffixes like `_txt` / `_i` /
+ * `_ss`, Postgres store columns, etc.).
+ */
+export type SearchFieldType = 
+/** Free-text, full-text-tokenised (text / textArea / select label / extracted rich-text). */
+'text'
+/** Exact-match string, not tokenised (slug, enum value). */
+ | 'keyword' | 'integer' | 'float' | 'boolean' | 'datetime'
+/** Controlled-vocabulary reference — value is {@link SearchFacetValue}[]. */
+ | 'facet';
+/**
+ * What a projected field is *for*, declared by the collection's role-based
+ * `search` config:
+ * - `body` — feeds the full-text searchable content
+ * - `facet` — a controlled-vocabulary reference (term indexed, id aggregated)
+ * - `filter` — a scalar projected for filtering / sorting (not scored)
+ */
+export type SearchFieldRole = 'body' | 'facet' | 'filter';
+/**
+ * One controlled-vocabulary facet value: the aggregation key (the target's
+ * `counter` field value — the stable small-int id used by facet URLs and
+ * the aggregator) plus the localized term (the target's `useAsTitle`),
+ * which is folded into the searchable text so a free-text query matches it.
+ */
+export interface SearchFacetValue {
+    id: number | string;
+    term: string;
+}
+/**
+ * A single field in the {@link SearchDocument} projection — a value plus the
+ * type and role a driver needs to index it. `name` is the field path and
+ * the default index field name.
+ */
+export interface SearchField {
+    /** Field path within the document, e.g. `'title'`, `'abstract'`, `'topics'`. */
+    name: string;
+    /** Schema-derived index value type. */
+    type: SearchFieldType;
+    /** Config-declared role. */
+    role: SearchFieldRole;
+    /** Extracted, locale-resolved value. */
+    value: string | number | boolean | SearchFacetValue[] | null;
+    /**
+     * Optional relevance weight for scoring providers that support it
+     * (`capabilities.weighting`). Postgres maps it to a `setweight` class,
+     * Solr to a `qf` field boost; providers without weighting ignore it.
+     * Unset means the provider default.
+     */
+    boost?: number;
+}
+/**
+ * The flat, provider-agnostic, type-enriched representation of a document
+ * that core feeds to a `SearchProvider`. Assembled from the EAV store by
+ * core; the provider indexes it without any knowledge of store tables or
+ * path notation.
+ *
+ * One `SearchDocument` exists per `(collectionPath, documentId, locale)` —
+ * `upsert` is idempotent on that triple.
+ */
+export interface SearchDocument {
+    /** Collection path, e.g. `"docs"` or `"publications"`. */
+    collectionPath: string;
+    /** The document's stable id (shared across versions and locales). */
+    documentId: string;
+    /** Content locale this index entry represents. */
+    locale: string;
+    /**
+     * Lifecycle status of the indexed version (e.g. `"published"`). Carried
+     * so the provider can apply published-only filtering at query time.
+     */
+    status: string;
+    /**
+     * Resolved search-scope membership for this document, derived from its
+     * collection's `search.zones` config at index time. A document with no
+     * declared zones gets a single implicit zone equal to its collection
+     * path, so single-collection search always works.
+     */
+    zones: string[];
+    /**
+     * The collection's identity value — resolved via `useAsTitle`
+     * (`resolveIdentityField`), never assumed to be a literal `title` field.
+     * Always present for hit display, independent of the `body` projection.
+     */
+    title: string;
+    /** The document's URL path, or `null` when the collection has none. */
+    path: string | null;
+    /**
+     * The typed, role-tagged field projection the driver consumes. Built only
+     * from the fields the collection's `search` config opts into — nothing is
+     * auto-pulled, so unindexed content (editorial notes, etc.) never leaks.
+     */
+    fields: SearchField[];
+    /** ISO-8601 timestamp of the indexed version. */
+    updatedAt: string;
+}
+/**
+ * A search request. Either collection-scoped (`collectionPath`) for
+ * homogeneous results, or zone-scoped (`zone`) for heterogeneous
+ * cross-collection results — see the two `client.search()` entry points.
+ */
+export interface SearchQuery {
+    /** The free-text query string. */
+    query: string;
+    /**
+     * Cross-collection scope — every collection indexed into this zone.
+     * Mutually exclusive with `collectionPath` in practice.
+     */
+    zone?: string;
+    /** Single-collection scope. */
+    collectionPath?: string;
+    /**
+     * Structured filters AND-merged with the text query. Reuses the same
+     * predicate shape as the client `where` clause / `beforeRead` scoping.
+     */
+    where?: QueryPredicate;
+    /** Field names to compute facet buckets for (driver-capability gated). */
+    facets?: string[];
+    /** Restrict to a single content locale. */
+    locale?: string;
+    /**
+     * Status filter. Defaults to `'published'` (safe for public readers);
+     * `'any'` is for admin contexts.
+     */
+    status?: 'published' | 'any';
+    /** Max hits to return. */
+    limit?: number;
+    /** Offset for pagination. */
+    offset?: number;
+}
+/**
+ * A single ranked result. Always carries the lightweight projection needed
+ * to render a plain-text row without hydration; the consumer hydrates ids
+ * into shaped `ClientDocument`s separately (the two-tier results model).
+ */
+export interface SearchHit {
+    collectionPath: string;
+    documentId: string;
+    locale: string;
+    /** The collection's identity value (see {@link SearchDocument.title}). */
+    title: string;
+    path: string | null;
+    /** Provider-assigned relevance score; higher is more relevant. */
+    score: number;
+    /**
+     * Matched snippets per field, when the driver supports highlighting
+     * (`capabilities.highlights`). Enough to render a result row inline.
+     */
+    highlights?: Record<string, string[]>;
+}
+/** A single facet bucket — a distinct value and its match count. */
+export interface SearchFacetBucket {
+    value: string;
+    count: number;
+}
+/** The result envelope returned by `SearchProvider.search`. */
+export interface SearchResults {
+    hits: SearchHit[];
+    /** Total matches across all pages (not just the returned `hits`). */
+    total: number;
+    /**
+     * Facet buckets keyed by field name, when `facets` was requested and the
+     * driver supports them.
+     */
+    facets?: Record<string, SearchFacetBucket[]>;
+}
+/**
+ * What a given driver can actually do. Lets consumers (the admin UI, the
+ * MCP tool) light up facets / typo-tolerance / semantic / weighting features
+ * only where the registered driver supports them, and keeps optional
+ * capabilities (e.g. BM25, which depends on a Postgres extension that isn't
+ * universally available) honest about a deployment's real reach rather than
+ * assumed.
+ */
+export interface SearchCapabilities {
+    /** Faceted aggregation over indexed fields. */
+    facets: boolean;
+    /** Fuzzy / typo-tolerant matching (e.g. `pg_trgm`). */
+    typoTolerance: boolean;
+    /** Vector / semantic / hybrid retrieval. */
+    semantic: boolean;
+    /**
+     * BM25-quality ranking (IDF-aware). The built-in Postgres `tsvector`
+     * floor is `false` here; satisfied by `lakebase_text`, ParadeDB, or
+     * `pg_textsearch` where available.
+     */
+    bm25: boolean;
+    /** Per-field relevance weighting (`SearchField.boost`). */
+    weighting: boolean;
+    /** Matched-snippet highlighting in results. */
+    highlights: boolean;
+}
+/**
+ * The provider-agnostic search seam. A driver implements indexing
+ * (`upsert` / `remove`), querying (`search`), and optional bulk rebuild
+ * (`reindex`), and declares its {@link SearchCapabilities} statically.
+ *
+ * Registered as `ServerConfig.search`; `initBylineCore()` fails fast when a
+ * collection opts into search but no provider is registered.
+ */
+export interface SearchProvider {
+    /**
+     * What this driver supports. Static — a driver knows its own shape at
+     * construction. Read by consumers to gate UI/feature exposure.
+     */
+    readonly capabilities: SearchCapabilities;
+    /**
+     * Add or replace a document in the index. Idempotent on
+     * `(collectionPath, documentId, locale)`.
+     */
+    upsert(doc: SearchDocument): Promise<void>;
+    /**
+     * Remove a document from the index — all locales when `locale` is
+     * omitted, or a single `(collectionPath, documentId, locale)` entry.
+     */
+    remove(ref: {
+        collectionPath: string;
+        documentId: string;
+        locale?: string;
+    }): Promise<void>;
+    /** Execute a query and return ranked hits. */
+    search(query: SearchQuery): Promise<SearchResults>;
+    /**
+     * Drop and rebuild a collection's slice (or the whole index). Used for
+     * first-time backfill, driver swaps, and after a `search` config change.
+     * Optional — not every driver supports bulk rebuild.
+     */
+    reindex?(opts: {
+        collectionPath?: string;
+    }): Promise<void>;
+}

package/dist/@types/search-types.js

@@ -0,0 +1,8 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export {};

package/dist/@types/site-config.d.ts

@@ -10,7 +10,8 @@ import type { SlugifierFn } from '../utils/slugify.js';
 import type { CollectionAdminConfig } from './admin-types.js';
 import type { CollectionDefinition } from './collection-types.js';
 import type { IDbAdapter } from './db-types.js';
-import type { RichTextEditorComponent, RichTextEmbedFn, RichTextPopulateFn, RichTextToMarkdownFn } from './field-types.js';
+import type { RichTextEditorComponent, RichTextEmbedFn, RichTextPopulateFn, RichTextToMarkdownFn, RichTextToTextFn } from './field-types.js';
+import type { SearchProvider } from './search-types.js';
 import type { IStorageProvider } from './storage-types.js';
 export type DbAdapterFn = (args: {
     connectionString: string;
@@ -314,6 +315,35 @@ export interface ServerConfig<TAdminStore = unknown> extends BaseConfig {
              * it. Synchronous and read-only — it walks stored editor JSON.
              */
             toMarkdown?: RichTextToMarkdownFn;
+            /**
+             * `toText` — plain-text extractor for search indexing. Flattens a
+             * rich-text value to indexable plain text (a recursive text-node
+             * accumulator, no markdown). Consumed by `buildSearchDocument` to feed
+             * a collection's searchable `body`. Required when any collection's
+             * `search.body` includes a `richText` field.
+             */
+            toText?: RichTextToTextFn;
         };
     };
+    /**
+     * Search provider — the `SearchProvider` seam. Registered top-level
+     * beside `db` and `storage`, composed by `initBylineCore()`.
+     *
+     * Drivers ship as separate packages and are constructed via a factory,
+     * mirroring the richText server adapters. The built-in Postgres
+     * full-text driver is `@byline/search-postgres`. When any collection
+     * opts into search (`CollectionDefinition.search`) but no provider is
+     * registered, `initBylineCore()` fails fast.
+     *
+     * @example
+     * ```ts
+     * import { postgresSearch } from '@byline/search-postgres'
+     *
+     * defineServerConfig({
+     *   // ...
+     *   search: postgresSearch({ getClient: getAdminBylineClient }),
+     * })
+     * ```
+     */
+    search?: SearchProvider;
 }

package/dist/auth/assert-actor-can-perform.test.node.js

@@ -104,7 +104,15 @@ describe('assertActorCanPerform', () => {
     describe('super-admin', () => {
         it('passes every verb on every collection without explicit abilities', () => {
             const ctx = createSuperAdminContext();
-            const verbs = ['read', 'create', 'update', 'delete', 'publish', 'changeStatus'];
+            const verbs = [
+                'read',
+                'create',
+                'update',
+                'delete',
+                'publish',
+                'changeStatus',
+                'reindex',
+            ];
             for (const verb of verbs) {
                 expect(() => assertActorCanPerform(ctx, 'any-collection', verb)).not.toThrow();
             }

package/dist/auth/register-collection-abilities.d.ts

@@ -10,7 +10,7 @@ import type { CollectionDefinition } from '../@types/index.js';
 /**
  * Auto-register the CRUD + workflow abilities contributed by a collection.
  *
- * Every registered collection contributes exactly six abilities, all in
+ * Every registered collection contributes exactly seven abilities, all in
  * the `collections.<path>` group:
  *
  *   - `collections.<path>.read`          — enumerate / fetch documents
@@ -21,19 +21,22 @@ import type { CollectionDefinition } from '../@types/index.js';
  *                                          `published` status
  *   - `collections.<path>.changeStatus`  — any other workflow transition
  *                                          (draft → custom state, etc.)
+ *   - `collections.<path>.reindex`       — rebuild the collection's search
+ *                                          index (admin maintenance task)
  *
  * Registration is unconditional: every collection in Byline has a workflow
  * (the default `draft → published → archived` one when not explicitly
- * configured), so `publish` and `changeStatus` always apply. Keeping the
- * six-ability contract uniform makes the role editor UI predictable and
- * avoids hidden conditional logic downstream.
+ * configured), so `publish` and `changeStatus` always apply; `reindex` is
+ * likewise uniform (a no-op for collections without a `search` config).
+ * Keeping the seven-ability contract uniform makes the role editor UI
+ * predictable and avoids hidden conditional logic downstream.
  *
  * Called from `initBylineCore()` for each declared collection. See
  * docs/AUTHN-AUTHZ.md.
  */
 export declare function registerCollectionAbilities(registry: AbilityRegistry, definition: CollectionDefinition): void;
 /** The ability suffixes that every collection contributes. Exposed for contract tests. */
-export declare const COLLECTION_ABILITY_VERBS: readonly ["read", "create", "update", "delete", "publish", "changeStatus"];
+export declare const COLLECTION_ABILITY_VERBS: readonly ["read", "create", "update", "delete", "publish", "changeStatus", "reindex"];
 export type CollectionAbilityVerb = (typeof COLLECTION_ABILITY_VERBS)[number];
 /** Compute the full ability key for a collection path and verb. */
 export declare function collectionAbilityKey(path: string, verb: CollectionAbilityVerb): string;

package/dist/auth/register-collection-abilities.js

@@ -8,7 +8,7 @@
 /**
  * Auto-register the CRUD + workflow abilities contributed by a collection.
  *
- * Every registered collection contributes exactly six abilities, all in
+ * Every registered collection contributes exactly seven abilities, all in
  * the `collections.<path>` group:
  *
  *   - `collections.<path>.read`          — enumerate / fetch documents
@@ -19,12 +19,15 @@
  *                                          `published` status
  *   - `collections.<path>.changeStatus`  — any other workflow transition
  *                                          (draft → custom state, etc.)
+ *   - `collections.<path>.reindex`       — rebuild the collection's search
+ *                                          index (admin maintenance task)
  *
  * Registration is unconditional: every collection in Byline has a workflow
  * (the default `draft → published → archived` one when not explicitly
- * configured), so `publish` and `changeStatus` always apply. Keeping the
- * six-ability contract uniform makes the role editor UI predictable and
- * avoids hidden conditional logic downstream.
+ * configured), so `publish` and `changeStatus` always apply; `reindex` is
+ * likewise uniform (a no-op for collections without a `search` config).
+ * Keeping the seven-ability contract uniform makes the role editor UI
+ * predictable and avoids hidden conditional logic downstream.
  *
  * Called from `initBylineCore()` for each declared collection. See
  * docs/AUTHN-AUTHZ.md.
@@ -70,6 +73,12 @@ export function registerCollectionAbilities(registry, definition) {
         group,
         source: 'collection',
     });
+    registry.register({
+        key: `${base}.reindex`,
+        label: `Reindex ${plural} search`,
+        group,
+        source: 'collection',
+    });
 }
 /** The ability suffixes that every collection contributes. Exposed for contract tests. */
 export const COLLECTION_ABILITY_VERBS = [
@@ -79,6 +88,7 @@ export const COLLECTION_ABILITY_VERBS = [
     'delete',
     'publish',
     'changeStatus',
+    'reindex',
 ];
 /** Compute the full ability key for a collection path and verb. */
 export function collectionAbilityKey(path, verb) {