@formicoidea/labre-core 0.47.1 → 0.49.0

package/dist/_pkgs/affine-fragment-doc-title/translations.js

@@ -47,24 +47,26 @@ export const TITLE_BAND_LOADING = [
     'com.labre.title-band.loading',
     'Loading properties',
 ];
-/** Clears a select or a date from its editor. */
-export const TITLE_BAND_CLEAR = [
-    'com.labre.title-band.clear',
-    'Clear value',
-];
 /**
- * The note header's row of child pages the document holds but does not
- * display (ADR 0035 §9d, canvas view only).
+ * The row of child pages the document holds but does not display, under the
+ * title and in the note header (ADR 0035 §9d and its 2026-10-13 amendment).
  */
 export const TITLE_BAND_NOT_SHOWN = [
     'com.labre.title-band.not-shown',
-    'Not shown in this page',
+    'Not shown on this page',
+];
+/**
+ * The button beside each page of that row: inserts a card of the page here
+ * (labre ADR-0045 §7).
+ */
+export const TITLE_BAND_SHOW_HERE = [
+    'com.labre.title-band.show-here',
+    'Show here',
 ];
 /** Every wording this package declares, in the order it renders them. */
 export const DOC_TITLE_WORDINGS = [
     DOC_TITLE_PLACEHOLDER,
     TITLE_BAND_ADD,
-    TITLE_BAND_CLEAR,
     TITLE_BAND_COLLAPSE,
     TITLE_BAND_EMPTY,
     TITLE_BAND_EXPAND,
@@ -72,4 +74,5 @@ export const DOC_TITLE_WORDINGS = [
     TITLE_BAND_LOADING,
     TITLE_BAND_NOT_SHOWN,
     TITLE_BAND_OPEN_PANEL,
+    TITLE_BAND_SHOW_HERE,
 ];

package/dist/_pkgs/affine-model/blocks/database/types.d.ts

@@ -10,8 +10,24 @@ export type CellDataType<ValueType = unknown> = {
     value: ValueType;
 };
 export type SerializedCells = Record<string, Record<string, CellDataType>>;
+/**
+ * Where a row of a view opens (ADR 0035 §8). Append-only: a stored value is
+ * never renamed or removed. An absent `openIn` reads `side`.
+ */
+export declare const DATABASE_VIEW_OPEN_IN: readonly ["side", "center", "full"];
+export type DatabaseViewOpenIn = (typeof DATABASE_VIEW_OPEN_IN)[number];
+/**
+ * The stored shape every view in `props.views` shares; each mode adds its own
+ * data on top. `sourceId` and `openIn` arrived in 0.49 (ADR 0035 §8, red
+ * zone): optional, `undefined` by default and never written on load, so a
+ * view stored by 0.48 or earlier is still a valid view and a 0.48 client
+ * ignores them. `sourceId` absent means the block's own implicit source.
+ * Held by `view-basic-data.unit.spec.ts`.
+ */
 export type ViewBasicDataType = {
     id: string;
     name: string;
     mode: string;
+    sourceId?: string;
+    openIn?: DatabaseViewOpenIn;
 };

package/dist/_pkgs/affine-model/blocks/database/types.js

@@ -1 +1,5 @@
-export {};
+/**
+ * Where a row of a view opens (ADR 0035 §8). Append-only: a stored value is
+ * never renamed or removed. An absent `openIn` reads `side`.
+ */
+export const DATABASE_VIEW_OPEN_IN = ['side', 'center', 'full'];

package/dist/_pkgs/affine-shared/services/data-source-picker-service.d.ts

@@ -0,0 +1,139 @@
+import type { ExtensionType } from '../../store/index.js';
+import type { ReadonlySignal } from '@preact/signals-core';
+/** One source of a host database, as the picker lists it. */
+export interface DataSourcePickerSource {
+    /** What a view stores as its `sourceId` (ADR 0035 §8). */
+    id: string;
+    /** Display name, already localized by the host. */
+    title: string;
+}
+/** One database the host offers a view of. */
+export interface DataSourcePickerDatabase {
+    /**
+     * What a linked view stores as its block's `externalSourceId`: the value
+     * the host's `DatabaseDataSourceProvider` reads back to build the view's
+     * data source. Opaque to the library (the Labre app writes
+     * `labre-base:<uuid>`, labre ADR-0046).
+     */
+    id: string;
+    /** Display name, already localized by the host. */
+    title: string;
+    /** Its live sources, in the host's order; the first is the default. */
+    sources: readonly DataSourcePickerSource[];
+}
+/** A property of a source as a view refers to it (an import's correspondence). */
+export interface DataSourcePickerProperty {
+    /** The property id the views store. */
+    id: string;
+    name: string;
+    /** The property type (`title`, `select`, `number`…). */
+    type: string;
+    /** A select's options: a filter on it stores their ids. */
+    options?: readonly {
+        id: string;
+        value: string;
+    }[];
+}
+/**
+ * A view of another database, or a saved view template, to copy into this
+ * database: never linked, the copy is a new view of this database.
+ */
+export interface DataSourcePickerImportedView {
+    /** The stored view as read there (`props.views[i]`, or a template). */
+    view: Readonly<Record<string, unknown>>;
+    /** The properties of the source the view read there. */
+    properties: readonly DataSourcePickerProperty[];
+    /**
+     * Source property id → property of this database, or `null` to ignore
+     * it. An id left out is ignored. A filter or a sort on an ignored property
+     * is removed, a column of it is dropped, a grouping by it is undone.
+     */
+    mapping: Readonly<Record<string, string | null>>;
+}
+/** What `importView` hands the host: where the copy lands, and the verb. */
+export interface DataSourcePickerImportRequest {
+    /** The database the copy lands in, as `list()` names it. */
+    databaseId: string;
+    /** The source the copy reads (the current view's); absent, the implicit one. */
+    sourceId?: string;
+    /** The properties of that source, for the correspondence. */
+    properties: readonly DataSourcePickerProperty[];
+    /** The layouts this database can add (preset types). Any other is refused. */
+    layouts: readonly string[];
+    /**
+     * Add the copy as a new view and show it; its id, or `null` when nothing
+     * was added (the page turned read-only, a layout not offered). One undo
+     * step.
+     */
+    add(view: DataSourcePickerImportedView): string | null;
+}
+/**
+ * The current view as a template (labre PRD REQ-DB-4): its layout, where its
+ * pages open, its properties shown and their order, its grouping. Never its
+ * filters, its sorts or a manual order: those belong to one view.
+ */
+export interface DataSourcePickerViewTemplate {
+    databaseId: string;
+    sourceId?: string;
+    /** The view's name, as shown. */
+    name: string;
+    view: Readonly<Record<string, unknown>>;
+    properties: readonly DataSourcePickerProperty[];
+}
+/**
+ * The data-source picker (ADR 0035 §9c, issue B12): the host lists the
+ * databases and sources a view may read, and creates them. The library draws
+ * the picker (`@labre/affine-database-editor`), inserts the view and never
+ * learns where a database lives.
+ *
+ * The identifier lives in core, not in the bundle §9c named: core's own
+ * slash entries that create a database read `createDatabase` (§5), and a seam
+ * identifier lives in the lowest package that reads it (§3).
+ */
+export interface DataSourcePickerService {
+    /**
+     * The databases on offer. MUST return synchronously and MUST NOT throw: the
+     * signal may start empty and fill later, the picker redraws.
+     */
+    list(): ReadonlySignal<readonly DataSourcePickerDatabase[]>;
+    /**
+     * Create a database; it resolves to the new one, with at least one source,
+     * or `null` when nothing was created (the user cancelled, the host
+     * refused). Absent, nothing creates a database: this is the host's kill
+     * switch, and the creating slash entries ("Table View", "Kanban View")
+     * leave the menu.
+     */
+    createDatabase?(): Promise<DataSourcePickerDatabase | null>;
+    /**
+     * Create a source in `databaseId`; it resolves to the new source, or
+     * `null`. Absent, the picker offers no "New source".
+     */
+    createSource?(databaseId: string): Promise<DataSourcePickerSource | null>;
+    /**
+     * Import a view of another database into `request.databaseId` (labre PRD
+     * REQ-DB-2, ADR 0035 amendment of 2026-10-14): the host lets the reader
+     * pick a view it may read and map its properties, then calls
+     * `request.add`. Absent, "+ view" offers no import and the full page lists
+     * no "Import a view".
+     */
+    importView?(request: DataSourcePickerImportRequest): void;
+    /**
+     * Keep the current view as a template, where the host keeps templates
+     * (labre: the workspace's library, REQ-DB-15); a later `importView` may
+     * offer it. Resolves `true` once saved. Absent, no "Save as template".
+     */
+    saveViewTemplate?(template: DataSourcePickerViewTemplate): Promise<boolean>;
+}
+export declare const DataSourcePickerProvider: import("../../global/di/types.js").ServiceIdentifier<DataSourcePickerService> & (<U extends DataSourcePickerService = DataSourcePickerService>(variant: import("../../global/di/types.js").ServiceVariant) => import("../../global/di/types.js").ServiceIdentifier<U>);
+/**
+ * Host seam: the host's databases and sources, or `null` to say it has none.
+ *
+ * Absent or `null`: no "Linked view of a database" entry, "+ view" offers
+ * only the sources the block already shows, and the slash entries create a
+ * native inline database as in 0.48. With a service but no `createDatabase`,
+ * no entry creates a database at all.
+ *
+ * `di.override`, so a later registration wins and registering twice never
+ * throws at boot.
+ */
+export declare function DataSourcePickerExtension(service: DataSourcePickerService | null): ExtensionType;

package/dist/_pkgs/affine-shared/services/data-source-picker-service.js

@@ -0,0 +1,22 @@
+import { createIdentifier } from '../../global/di/index.js';
+export const DataSourcePickerProvider = createIdentifier('LabreDataSourcePicker');
+/**
+ * Host seam: the host's databases and sources, or `null` to say it has none.
+ *
+ * Absent or `null`: no "Linked view of a database" entry, "+ view" offers
+ * only the sources the block already shows, and the slash entries create a
+ * native inline database as in 0.48. With a service but no `createDatabase`,
+ * no entry creates a database at all.
+ *
+ * `di.override`, so a later registration wins and registering twice never
+ * throws at boot.
+ */
+export function DataSourcePickerExtension(service) {
+    return {
+        setup: di => {
+            // `null` rides through on purpose: `getOptional` then reports no
+            // picker, which is the whole "0.48 entries" story.
+            di.override(DataSourcePickerProvider, () => service);
+        },
+    };
+}

package/dist/_pkgs/affine-shared/services/index.d.ts

@@ -7,6 +7,7 @@ export * from './canvas-local-visibility.js';
 export * from './citation-service/index.js';
 export * from './command-usage-service.js';
 export * from './comment-service/index.js';
+export * from './data-source-picker-service.js';
 export * from './doc-display-meta-service.js';
 export * from './doc-mode-service.js';
 export * from './drag-handle-config.js';

package/dist/_pkgs/affine-shared/services/index.js

@@ -7,6 +7,7 @@ export * from './canvas-local-visibility.js';
 export * from './citation-service/index.js';
 export * from './command-usage-service.js';
 export * from './comment-service/index.js';
+export * from './data-source-picker-service.js';
 export * from './doc-display-meta-service.js';
 export * from './doc-mode-service.js';
 export * from './drag-handle-config.js';

package/dist/_pkgs/affine-shared/services/linked-doc-creation-service.d.ts

@@ -2,16 +2,25 @@ import type { EditorHost } from '../../std/index.js';
 import { type ExtensionType, type Store } from '../../store/index.js';
 /**
  * Creates the new doc that the linked-doc features populate (the edgeless
- * "Create linked page" / "Turn into linked page" actions). By default this is a
- * fresh in-workspace doc; a host app can override it to ALSO persist or register
- * the doc (assign a stored id, create a metadata row, attach sync) before the
- * editor writes blocks into the returned store.
+ * "Create linked page" / "Turn into linked page" actions, and the slash menu's
+ * "New Page" since 0.48, which leaves a linked-doc card where it was typed). By
+ * default this is a fresh in-workspace doc; a host app can override it to ALSO
+ * persist or register the doc (assign a stored id, create a metadata row,
+ * attach sync) before the editor writes blocks into the returned store.
  *
- * The returned `Store` must be ready for `addBlock`. `title` is forwarded so the
- * host can record it; the caller still writes the page block's own title.
+ * The returned `Store` is left UNLOADED: the caller writes its blocks in
+ * `store.load(initFn)`, and a doc that is already loaded skips `initFn`.
+ * `title` is forwarded so the host can record it; the caller still writes the
+ * page block's own title.
  */
 export interface LinkedDocCreationProvider {
     createLinkedDoc(host: EditorHost, title?: string): Store;
+    /**
+     * Whether a doc may be created from this editor at all (a host may refuse
+     * it on a doc shared with a guest, for instance). Read by the slash menu's
+     * "New Page", which hides itself on `false`. Absent means allowed (since 0.48).
+     */
+    canCreateLinkedDoc?(host: EditorHost): boolean;
 }
 export declare const LinkedDocCreationProvider: import("../../global/di/types.js").ServiceIdentifier<LinkedDocCreationProvider> & (<U extends LinkedDocCreationProvider = LinkedDocCreationProvider>(variant: import("../../global/di/types.js").ServiceVariant) => import("../../global/di/types.js").ServiceIdentifier<U>);
 /**

package/dist/_pkgs/affine-shared/services/telemetry-service/database.d.ts

@@ -1,3 +1,4 @@
+import type { TelemetryEvent } from './types.js';
 type OrderType = 'desc' | 'asc';
 export type WithParams<Map, T> = {
     [K in keyof Map]: Map[K] & T;
@@ -15,13 +16,50 @@ export type ViewParams = {
 export type DatabaseParams = {
     blockId: string;
 };
+/**
+ * Where a database row opened (ADR 0035 §8, §9a): the view's stored `openIn`
+ * (absent reads `side`), or `full` for a Ctrl/Cmd-click. Mirrors
+ * `DatabaseViewOpenIn` of `@labre/affine-model`, which this layer cannot
+ * import.
+ */
+export type DatabaseRowOpenMode = 'side' | 'center' | 'full';
 export type DatabaseViewEvents = {
     DatabaseSortClear: {
         rulesCount: number;
     };
+    /**
+     * The user picked another layout for a view (B17). Replaces the never
+     * emitted {@link DatabaseViewEvents.ChangeDatabaseLayout}.
+     */
+    DatabaseViewTypeChanged: TelemetryEvent & {
+        fromViewType: string;
+        toViewType: string;
+    };
+    /**
+     * The user grouped a view, changed its grain or removed the grouping (B17).
+     * `groupBy` is the group-by config name (`select`, `date-month`…), `none`
+     * once removed; `propertyType` the grouped property's type. Never the
+     * property's id or name. Replaces the never emitted `CreateDatabaseGroup`.
+     */
+    DatabaseGroupChanged: TelemetryEvent & {
+        groupBy: string;
+        propertyType?: string;
+    };
+    /**
+     * A row was opened from a view (B17). `rowKind` says whether the source's
+     * rows are documents (`rowsAreDocuments`) or blocks of the database. Never
+     * the row's id: a hosted row is a document id (ADR 0035 §12).
+     */
+    DatabaseRowOpened: TelemetryEvent & {
+        mode: DatabaseRowOpenMode;
+        newTab: boolean;
+        rowKind: 'document' | 'block';
+    };
+    /** @deprecated never emitted; `DatabaseViewAdded` reports a new view. */
     CreateDatabaseView: {
         viewType: string;
     };
+    /** @deprecated never emitted; see `DatabaseViewTypeChanged`. */
     ChangeDatabaseLayout: {
         fromViewType: string;
         toViewType: string;
@@ -36,15 +74,36 @@ export type DatabaseFilterEvents = {
     CreateDatabaseFilter: {};
 };
 export type DatabaseGroupEvents = {
+    /** @deprecated never emitted; see `DatabaseGroupChanged`. */
     CreateDatabaseGroup: {
         groupBy: string;
     };
 };
 export type DatabaseEvents = {
     AddDatabase: {};
+    /** @deprecated no longer emitted since 0.49; see `DatabaseViewAdded`. */
     AddDatabaseView: {
         type: string;
     };
+    /**
+     * A view was added by a user gesture (ADR 0035 §12, B17): `existing` when
+     * it reads a source the database already has (its own included), `new`
+     * when the gesture created the source with it, `import` when it is the
+     * copy of another database's view or of a view template (0.49, appended).
+     * A database created with its first view reports `BlockCreated`, not this.
+     */
+    DatabaseViewAdded: TelemetryEvent & {
+        viewType: string;
+        source: 'existing' | 'new' | 'import';
+    };
+    /**
+     * A hosted source's values could not be loaded (ADR 0035 §9e, B17): once
+     * per failure of a source, not per banner drawn. `retryable` says whether
+     * the source offers `retryValues`.
+     */
+    DatabaseValuesLoadFailed: TelemetryEvent & {
+        retryable: boolean;
+    };
 };
 export interface DatabaseAllSortEvents {
     DatabaseSortAdd: {};

package/dist/_pkgs/affine-shared/services/title-band-service.d.ts

@@ -17,7 +17,7 @@ import type { ReadonlySignal } from '@preact/signals-core';
  * database cell read the same `type`, `data` and value.
  *
  * Absent, there is no band at all: no chips, no "+", no panel button, no "Not
- * shown in this document" row, and nothing else changes.
+ * shown on this page" row, and nothing else changes.
  */
 /**
  * One visible property of a page's sheet, in the order the band draws it.
@@ -47,6 +47,14 @@ export interface TitleBandProperty {
     value: unknown;
     /** A read-only property draws its chip and opens no editor. */
     readonly: boolean;
+    /**
+     * Whether the host takes a write of this property's definition (`data`)
+     * through {@link TitleBandService.setData}; absent means `false`. A select
+     * or multi-select whose options can be created and renamed from its chip
+     * says `true`; one whose option ids are its labels (the Labre app's
+     * `tags`) never does.
+     */
+    dataWritable?: boolean;
 }
 /**
  * The state of one page's sheet. Same four states as ADR 0006: the signal may
@@ -89,6 +97,22 @@ export interface TitleBandService {
      * clears its pending state. `value` is `null` to clear.
      */
     set(docId: string, propertyId: string, value: unknown): Promise<void>;
+    /**
+     * Write one property's definition, its `data` (a select's `options`): the
+     * band's one definition write, distinct from `set` (product owner,
+     * 2026-10-14). Called only for a property whose `dataWritable` is `true`
+     * on a chip that is not read-only, and only to create an option or rename
+     * one: the chip's tag menu offers no delete, no colour and no reordering.
+     * `data` is the whole new config, the option list in data-view's shape
+     * (`{ id, value, color }`, a created option first, its id minted by the
+     * library). The library never applies it: the option shows once it arrives
+     * through `sheet$`, so a host applies it to its sheet at once and owns the
+     * rollback. Creating an option is followed at once by a `set` that selects
+     * it: the host applies the two in the order it receives them. A rejection is
+     * the host's to report; the band logs it. Absent, every chip's options are
+     * fixed: no "Create", no option menu (the 0.48 band).
+     */
+    setData?(docId: string, propertyId: string, data: Record<string, unknown>): Promise<void>;
     /**
      * The band's "+" (REQ-PR-4): what it does is the host's (open the
      * workspace's property settings, or create a database property directly
@@ -103,12 +127,15 @@ export interface TitleBandService {
     collapsed$?(docId: string): ReadonlySignal<boolean>;
     setCollapsed?(docId: string, collapsed: boolean): void;
     /**
-     * The child pages this document holds but does not display. Read **in the
-     * canvas view only**, drawn in the note header as a "Not shown in this
-     * document" row of page links that open through the linked-document path
-     * (`RefNodeSlotsProvider.docLinkClicked`). In the page view the host draws
-     * that row under the title itself, so a document never shows two. Absent
-     * or empty, no row.
+     * The child pages this document holds but does not display, drawn in both
+     * views (under the title, and in the note header on the canvas) as a "Not
+     * shown on this page" row: each page is a link that opens through the
+     * linked-document path (`RefNodeSlotsProvider.docLinkClicked`; without it,
+     * no row), with a "Show here" button on a writable document that inserts
+     * an `affine:embed-linked-doc` card of it (end of the last note in the
+     * page view, centre of the visible canvas on the canvas). The library
+     * writes only that card: dropping the page from this list once it shows is
+     * the host's reading of the document. Absent or empty, no row.
      */
     notShown$?(docId: string): ReadonlySignal<readonly TitleBandNotShownPage[]>;
 }

package/dist/_pkgs/affine-shared/utils/model/doc.d.ts

@@ -1,5 +1,13 @@
-import type { Workspace } from '../../../store/index.js';
+import type { Store, Workspace } from '../../../store/index.js';
 export declare function createDefaultDoc(collection: Workspace, options?: {
     id?: string;
     title?: string;
-}): import("../../../store/index.js").Store;
+}): Store;
+/**
+ * The blocks of a blank page, written into an empty store: the page with its
+ * title, its surface, and one note holding an empty paragraph. Shared by
+ * `createDefaultDoc` and by the creation paths that receive their store from
+ * the host (`LinkedDocCreationProvider`), so a page opens the same whoever
+ * made it.
+ */
+export declare function writeDefaultDocBlocks(store: Store, title?: string): void;

package/dist/_pkgs/affine-shared/utils/model/doc.js

@@ -5,19 +5,29 @@ export function createDefaultDoc(collection, options = {}) {
     doc.load();
     const store = doc.getStore();
     const title = options.title ?? '';
-    const rootId = store.addBlock('affine:page', {
-        title: new Text(title),
-    });
+    writeDefaultDocBlocks(store, title);
     collection.meta.setDocMeta(doc.id, {
         title,
     });
+    // To make sure the content of new doc would not be clear
+    // By undo operation for the first time
+    store.resetHistory();
+    return store;
+}
+/**
+ * The blocks of a blank page, written into an empty store: the page with its
+ * title, its surface, and one note holding an empty paragraph. Shared by
+ * `createDefaultDoc` and by the creation paths that receive their store from
+ * the host (`LinkedDocCreationProvider`), so a page opens the same whoever
+ * made it.
+ */
+export function writeDefaultDocBlocks(store, title = '') {
+    const rootId = store.addBlock('affine:page', {
+        title: new Text(title),
+    });
     store.addBlock('affine:surface', {}, rootId);
     const noteId = store.addBlock('affine:note', {
         xywh: `[0, 0, ${DEFAULT_PAGE_BLOCK_WIDTH}, ${DEFAULT_PAGE_BLOCK_HEIGHT}]`,
     }, rootId);
     store.addBlock('affine:paragraph', {}, noteId);
-    // To make sure the content of new doc would not be clear
-    // By undo operation for the first time
-    store.resetHistory();
-    return store;
 }

package/dist/_pkgs/data-view/core/component/cell-status/cell-status-css.d.ts

@@ -0,0 +1,2 @@
+export declare const cellSkeletonStyle: string;
+export declare const cellEmptyStyle: string;

package/dist/_pkgs/data-view/core/component/cell-status/cell-status-css.js

@@ -0,0 +1,16 @@
+import { css } from '@emotion/css';
+// The title band's loading chip, in a cell (`labre-title-band-skeleton`):
+// same hover tone, same radius, no motion to honour or disable.
+export const cellSkeletonStyle = css({
+    display: 'block',
+    width: '60%',
+    maxWidth: '120px',
+    height: '16px',
+    margin: '8px',
+    borderRadius: '6px',
+    backgroundColor: 'var(--affine-hover-color)',
+});
+export const cellEmptyStyle = css({
+    display: 'block',
+    minHeight: '32px',
+});

package/dist/_pkgs/data-view/core/component/cell-status/cell-status.d.ts

@@ -0,0 +1,10 @@
+import { type TemplateResult } from 'lit';
+import type { Cell } from '../../view-manager/cell.js';
+/**
+ * What a cell container draws INSTEAD of its renderer while the cell is not
+ * `ready` (ADR 0035 §9e): a skeleton while `pending`, an empty cell on
+ * `error`. `undefined` when ready, so the container mounts its renderer as in
+ * 0.48. No renderer is mounted otherwise, which is what keeps a cell whose
+ * value never arrived from being edited over.
+ */
+export declare function renderCellStatus(cell: Cell | undefined): TemplateResult | undefined;

package/dist/_pkgs/data-view/core/component/cell-status/cell-status.js

@@ -0,0 +1,23 @@
+import { html } from 'lit';
+import { cellEmptyStyle, cellSkeletonStyle } from './cell-status-css.js';
+/**
+ * What a cell container draws INSTEAD of its renderer while the cell is not
+ * `ready` (ADR 0035 §9e): a skeleton while `pending`, an empty cell on
+ * `error`. `undefined` when ready, so the container mounts its renderer as in
+ * 0.48. No renderer is mounted otherwise, which is what keeps a cell whose
+ * value never arrived from being edited over.
+ */
+export function renderCellStatus(cell) {
+    const status = cell?.status$?.value ?? 'ready';
+    if (status === 'ready')
+        return undefined;
+    if (status === 'pending') {
+        return html `<span
+      class="${cellSkeletonStyle}"
+      data-testid="dv-cell-skeleton"
+      data-cell-status="pending"
+      aria-busy="true"
+    ></span>`;
+    }
+    return html `<span class="${cellEmptyStyle}" data-cell-status="error"></span>`;
+}

package/dist/_pkgs/data-view/core/component/index.d.ts

@@ -1,3 +1,4 @@
 export * from './button/button.js';
 export * from './overflow/overflow.js';
 export * from './tags/index.js';
+export * from './cell-status/cell-status.js';

package/dist/_pkgs/data-view/core/component/index.js

@@ -1,3 +1,4 @@
 export * from './button/button.js';
 export * from './overflow/overflow.js';
 export * from './tags/index.js';
+export * from './cell-status/cell-status.js';

package/dist/_pkgs/data-view/core/component/overflow/fit.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Which items of an overflowing row are drawn, from measured widths (the
+ * view bar's tabs, ADR 0035 B11, labre PRD REQ-DB-7: "as many tabs as the
+ * width allows, the rest under N more").
+ *
+ * - Everything fits: every item is drawn and the trailing slot holds only
+ *   what it holds when nothing is hidden (`trailing`, the "+" of the view
+ *   bar).
+ * - Otherwise the trailing slot also holds the "N more" button
+ *   (`moreExtra` wider), and the items are drawn in order while they fit,
+ *   stopping at the first that does not: the order of the row is the order
+ *   of the views, never reshuffled to pack more in.
+ * - The `pinned` item (the current view) is always drawn, even alone and
+ *   wider than the room: a view you are looking at never hides under "more".
+ *   Its room is reserved first, so it takes the place of the last item that
+ *   would have fitted.
+ *
+ * Returns the drawn indices in ascending order.
+ */
+export declare function fitOverflow(input: {
+    widths: readonly number[];
+    container: number;
+    trailing: number;
+    moreExtra: number;
+    pinned?: number;
+}): number[];

package/dist/_pkgs/data-view/core/component/overflow/fit.js

@@ -0,0 +1,48 @@
+/**
+ * Which items of an overflowing row are drawn, from measured widths (the
+ * view bar's tabs, ADR 0035 B11, labre PRD REQ-DB-7: "as many tabs as the
+ * width allows, the rest under N more").
+ *
+ * - Everything fits: every item is drawn and the trailing slot holds only
+ *   what it holds when nothing is hidden (`trailing`, the "+" of the view
+ *   bar).
+ * - Otherwise the trailing slot also holds the "N more" button
+ *   (`moreExtra` wider), and the items are drawn in order while they fit,
+ *   stopping at the first that does not: the order of the row is the order
+ *   of the views, never reshuffled to pack more in.
+ * - The `pinned` item (the current view) is always drawn, even alone and
+ *   wider than the room: a view you are looking at never hides under "more".
+ *   Its room is reserved first, so it takes the place of the last item that
+ *   would have fitted.
+ *
+ * Returns the drawn indices in ascending order.
+ */
+export function fitOverflow(input) {
+    const { widths, container, trailing, moreExtra } = input;
+    const pinned = input.pinned !== undefined &&
+        input.pinned >= 0 &&
+        input.pinned < widths.length
+        ? input.pinned
+        : -1;
+    const total = widths.reduce((sum, width) => sum + width, 0);
+    if (total + trailing <= container) {
+        return widths.map((_, index) => index);
+    }
+    const budget = container - trailing - moreExtra;
+    const drawn = [];
+    let used = pinned >= 0 ? (widths[pinned] ?? 0) : 0;
+    for (let index = 0; index < widths.length; index++) {
+        if (index === pinned)
+            continue;
+        const width = widths[index] ?? 0;
+        if (used + width > budget)
+            break;
+        drawn.push(index);
+        used += width;
+    }
+    if (pinned >= 0) {
+        drawn.push(pinned);
+        drawn.sort((a, b) => a - b);
+    }
+    return drawn;
+}