@formicoidea/labre-core 0.47.1 → 0.49.0

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

@@ -37,7 +37,7 @@ import { focusTextModel } from '../affine-rich-text/index.js';
 import { TitleBandProvider, translateKey } from '../affine-shared/services/index.js';
 import { matchModels } from '../affine-shared/utils/index.js';
 import { WithDisposable } from '../global/lit/index.js';
-import { ShadowlessElement } from '../std/index.js';
+import { ShadowlessElement, } from '../std/index.js';
 import { effect } from '@preact/signals-core';
 import { css, html, nothing } from 'lit';
 import { property, query, state } from 'lit/decorators.js';
@@ -60,6 +60,9 @@ let DocTitle = (() => {
     let _wrapText_decorators;
     let _wrapText_initializers = [];
     let _wrapText_extraInitializers = [];
+    let _bodyBlockId_decorators;
+    let _bodyBlockId_initializers = [];
+    let _bodyBlockId_extraInitializers = [];
     return class DocTitle extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
@@ -68,11 +71,13 @@ let DocTitle = (() => {
             __richTextElement_decorators = [query('rich-text')];
             _doc_decorators = [property({ attribute: false })];
             _wrapText_decorators = [property({ attribute: false })];
+            _bodyBlockId_decorators = [property({ attribute: false })];
             __esDecorate(this, null, __isComposing_decorators, { kind: "accessor", name: "_isComposing", static: false, private: false, access: { has: obj => "_isComposing" in obj, get: obj => obj._isComposing, set: (obj, value) => { obj._isComposing = value; } }, metadata: _metadata }, __isComposing_initializers, __isComposing_extraInitializers);
             __esDecorate(this, null, __isReadonly_decorators, { kind: "accessor", name: "_isReadonly", static: false, private: false, access: { has: obj => "_isReadonly" in obj, get: obj => obj._isReadonly, set: (obj, value) => { obj._isReadonly = value; } }, metadata: _metadata }, __isReadonly_initializers, __isReadonly_extraInitializers);
             __esDecorate(this, null, __richTextElement_decorators, { kind: "accessor", name: "_richTextElement", static: false, private: false, access: { has: obj => "_richTextElement" in obj, get: obj => obj._richTextElement, set: (obj, value) => { obj._richTextElement = value; } }, metadata: _metadata }, __richTextElement_initializers, __richTextElement_extraInitializers);
             __esDecorate(this, null, _doc_decorators, { kind: "accessor", name: "doc", static: false, private: false, access: { has: obj => "doc" in obj, get: obj => obj.doc, set: (obj, value) => { obj.doc = value; } }, metadata: _metadata }, _doc_initializers, _doc_extraInitializers);
             __esDecorate(this, null, _wrapText_decorators, { kind: "accessor", name: "wrapText", static: false, private: false, access: { has: obj => "wrapText" in obj, get: obj => obj.wrapText, set: (obj, value) => { obj.wrapText = value; } }, metadata: _metadata }, _wrapText_initializers, _wrapText_extraInitializers);
+            __esDecorate(this, null, _bodyBlockId_decorators, { kind: "accessor", name: "bodyBlockId", static: false, private: false, access: { has: obj => "bodyBlockId" in obj, get: obj => obj.bodyBlockId, set: (obj, value) => { obj.bodyBlockId = value; } }, metadata: _metadata }, _bodyBlockId_initializers, _bodyBlockId_extraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         static { this.styles = css `
@@ -162,6 +167,19 @@ let DocTitle = (() => {
             const noteId = this.doc.addBlock('affine:note', {}, this._rootModel, 0);
             return this.doc.getBlock(noteId)?.model;
         }
+        /**
+         * Leaves the title for `bodyBlockId`: the title loses the caret (its text
+         * is already stored, so that is all "validating" it means), then the block
+         * takes the caret where it can, through its `focusFirstCell` (a database
+         * block's: the first cell of a table or kanban view). A block without one,
+         * or a view without cells, keeps nothing focused. Writes nothing.
+         */
+        _leaveForBodyBlock(std, blockId) {
+            this.inlineEditor?.setInlineRange(null);
+            this.inlineEditor?.rootElement?.blur();
+            const block = std.view.getBlock(blockId);
+            block?.focusFirstCell?.();
+        }
         get _std() {
             return this._viewport?.querySelector('editor-host')?.std;
         }
@@ -275,6 +293,18 @@ let DocTitle = (() => {
         #wrapText_accessor_storage;
         get wrapText() { return this.#wrapText_accessor_storage; }
         set wrapText(value) { this.#wrapText_accessor_storage = value; }
+        #bodyBlockId_accessor_storage;
+        /**
+         * The block that is the page's body, when the document's note is not (a
+         * database's full page, ADR 0035 B13: the document holds the database
+         * block and its schema blocks in a note the page never draws). Set, the
+         * title has no body of its own: Enter and ArrowDown leave the title for
+         * this block and never add or focus a paragraph, so nothing is ever
+         * written to the note. Unset (the default), Enter splits the title into a
+         * first paragraph and ArrowDown focuses or creates one, as in 0.48.
+         */
+        get bodyBlockId() { return this.#bodyBlockId_accessor_storage; }
+        set bodyBlockId(value) { this.#bodyBlockId_accessor_storage = value; }
         constructor() {
             super(...arguments);
             this._onTitleKeyDown = (event) => {
@@ -282,6 +312,14 @@ let DocTitle = (() => {
                     return;
                 if (!this._std)
                     return;
+                if (this.bodyBlockId !== undefined &&
+                    (event.key === 'Enter' || event.key === 'ArrowDown')) {
+                    this._std.event.active = true;
+                    event.preventDefault();
+                    event.stopPropagation();
+                    this._leaveForBodyBlock(this._std, this.bodyBlockId);
+                    return;
+                }
                 if (event.key === 'Enter') {
                     this._std.event.active = true;
                     event.preventDefault();
@@ -331,7 +369,8 @@ let DocTitle = (() => {
             this.#_richTextElement_accessor_storage = (__runInitializers(this, __isReadonly_extraInitializers), __runInitializers(this, __richTextElement_initializers, void 0));
             this.#doc_accessor_storage = (__runInitializers(this, __richTextElement_extraInitializers), __runInitializers(this, _doc_initializers, void 0));
             this.#wrapText_accessor_storage = (__runInitializers(this, _doc_extraInitializers), __runInitializers(this, _wrapText_initializers, true));
-            __runInitializers(this, _wrapText_extraInitializers);
+            this.#bodyBlockId_accessor_storage = (__runInitializers(this, _wrapText_extraInitializers), __runInitializers(this, _bodyBlockId_initializers, undefined));
+            __runInitializers(this, _bodyBlockId_extraInitializers);
         }
     };
 })();

package/dist/_pkgs/affine-fragment-doc-title/index.d.ts

@@ -1,4 +1,4 @@
 export { DocTitle } from './doc-title.js';
-export { chipEditorKind, type ChipEditorKind, type ChipTag, chipValueView, type ChipValueView, formatPropertyValue, isPropertyValueEmpty, } from './title-band/format.js';
+export { type ChipTag, chipValueView, type ChipValueView, formatPropertyValue, isPropertyValueEmpty, } from './title-band/format.js';
 export { LABRE_TITLE_BAND, TitleBand } from './title-band/title-band.js';
 export { getDocTitleByEditorHost } from './utils.js';

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

@@ -1,4 +1,4 @@
 export { DocTitle } from './doc-title.js';
-export { chipEditorKind, chipValueView, formatPropertyValue, isPropertyValueEmpty, } from './title-band/format.js';
+export { chipValueView, formatPropertyValue, isPropertyValueEmpty, } from './title-band/format.js';
 export { LABRE_TITLE_BAND, TitleBand } from './title-band/title-band.js';
 export { getDocTitleByEditorHost } from './utils.js';

package/dist/_pkgs/affine-fragment-doc-title/title-band/band-cell.d.ts

@@ -0,0 +1,30 @@
+import type { TitleBandProperty } from '../../affine-shared/services/index.js';
+import { type PropertyMetaConfig } from '../../data-view/index.js';
+/** The data-view cell type that draws a band property of `type`, if any. */
+export declare function bandCellType(type: string): string | undefined;
+/**
+ * The cell's meta: one a package above registered for that cell type (the
+ * database block's `link`), else this package's preset. Without its
+ * registration a link is drawn by the `text` cell.
+ */
+export declare function bandCellMeta(type: string, registered: (cellType: string) => PropertyMetaConfig | null): PropertyMetaConfig | null;
+export declare function isBandReadonlyType(type: string): boolean;
+/** The value in the raw shape of the cell type `cellType` reads. */
+export declare function bandCellValue(cellType: string, value: unknown): unknown;
+/** The property's config as the cell reads it: a select's tags, complete. */
+export declare function bandCellData(cellType: string, property: TitleBandProperty): Record<string, unknown>;
+/**
+ * What the band writes back for a value a cell commits: `null` for an empty
+ * one (the seam's "clear"), the value itself otherwise.
+ */
+export declare function bandWriteValue(value: unknown): unknown;
+/** Whether a committed value is the one the chip already shows. */
+export declare function sameBandValue(cellType: string, current: unknown, next: unknown): boolean;
+/**
+ * Whether a chip's tag menu creates and renames options (product owner,
+ * 2026-10-14): a select or multi-select whose host takes a definition write
+ * (`setData`) and says so for this property (`dataWritable: true`). Anything
+ * else keeps its options fixed, the 0.48 band. A read-only chip opens no
+ * editor whatever this says.
+ */
+export declare function bandOptionsWritable(cellType: string, property: TitleBandProperty, hasSetData: boolean): boolean;

package/dist/_pkgs/affine-fragment-doc-title/title-band/band-cell.js

@@ -0,0 +1,137 @@
+import { selectOptionColors, } from '../../data-view/index.js';
+import { propertyPresets } from '../../data-view/property-presets/index.js';
+import { chipOptions } from './format.js';
+/**
+ * Which data-view cell draws a band property, and the value and config that
+ * cell is handed (ADR 0035 §11, amended 2026-10-13: the chips are the table's
+ * own cells).
+ *
+ * The band speaks the data-view types (§9d), plus the aliases a host's sheet
+ * holds whose shape a preset already reads: a URL is the table's `link` cell,
+ * the text-like types the `text` cell, the time stamps a read-only `date`.
+ * A type with no cell here (`relation`, `image`, an invented one) keeps the
+ * band's plain-text reading and opens the properties panel instead.
+ *
+ * The host's JSON is never trusted to have the preset's shape: a renderer
+ * that meets a string where it maps an array throws mid-render, so each value
+ * is narrowed to its cell's raw shape, and anything else reads as empty.
+ */
+const CELL_TYPES = Object.assign(Object.create(null), {
+    checkbox: 'checkbox',
+    select: 'select',
+    'multi-select': 'multi-select',
+    date: 'date',
+    'created-time': 'date',
+    'modified-time': 'date',
+    number: 'number',
+    progress: 'progress',
+    text: 'text',
+    'rich-text': 'text',
+    title: 'text',
+    email: 'text',
+    phone: 'text',
+    link: 'link',
+    url: 'link',
+});
+/** Drawn by their cell, never edited from the band. */
+const READ_ONLY_TYPES = new Set(['created-time', 'modified-time']);
+const PRESETS = new Map([
+    propertyPresets.checkboxPropertyConfig,
+    propertyPresets.datePropertyConfig,
+    propertyPresets.multiSelectPropertyConfig,
+    propertyPresets.numberPropertyConfig,
+    propertyPresets.progressPropertyConfig,
+    propertyPresets.selectPropertyConfig,
+    propertyPresets.textPropertyConfig,
+].map(meta => [meta.type, meta]));
+const DEFAULT_TAG_COLOR = selectOptionColors.at(-1)?.color ?? '';
+/** The data-view cell type that draws a band property of `type`, if any. */
+export function bandCellType(type) {
+    return CELL_TYPES[type];
+}
+/**
+ * The cell's meta: one a package above registered for that cell type (the
+ * database block's `link`), else this package's preset. Without its
+ * registration a link is drawn by the `text` cell.
+ */
+export function bandCellMeta(type, registered) {
+    const cellType = bandCellType(type);
+    if (!cellType)
+        return null;
+    return (registered(cellType) ??
+        PRESETS.get(cellType) ??
+        (cellType === 'link' ? (PRESETS.get('text') ?? null) : null));
+}
+export function isBandReadonlyType(type) {
+    return READ_ONLY_TYPES.has(type);
+}
+const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
+/** The value in the raw shape of the cell type `cellType` reads. */
+export function bandCellValue(cellType, value) {
+    switch (cellType) {
+        case 'checkbox':
+            return value === true;
+        case 'select':
+            return typeof value === 'string' && value !== '' ? value : undefined;
+        case 'multi-select':
+            return Array.isArray(value)
+                ? value.filter((id) => typeof id === 'string')
+                : undefined;
+        case 'date':
+        case 'number':
+        case 'progress':
+            return isFiniteNumber(value) ? value : undefined;
+        default:
+            if (typeof value === 'string')
+                return value;
+            if (isFiniteNumber(value))
+                return String(value);
+            return undefined;
+    }
+}
+/** The property's config as the cell reads it: a select's tags, complete. */
+export function bandCellData(cellType, property) {
+    if (cellType !== 'select' && cellType !== 'multi-select') {
+        return property.data;
+    }
+    const options = chipOptions(property).map(tag => ({
+        id: tag.id,
+        value: tag.label,
+        color: tag.color ?? DEFAULT_TAG_COLOR,
+    }));
+    return { ...property.data, options };
+}
+/**
+ * What the band writes back for a value a cell commits: `null` for an empty
+ * one (the seam's "clear"), the value itself otherwise.
+ */
+export function bandWriteValue(value) {
+    if (value === undefined)
+        return null;
+    if (typeof value === 'string' && value.trim() === '')
+        return null;
+    if (typeof value === 'number' && Number.isNaN(value))
+        return null;
+    return value;
+}
+/** Whether a committed value is the one the chip already shows. */
+export function sameBandValue(cellType, current, next) {
+    const a = bandWriteValue(bandCellValue(cellType, current));
+    const b = bandWriteValue(next);
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((item, i) => item === b[i]);
+    }
+    return a === b;
+}
+/**
+ * Whether a chip's tag menu creates and renames options (product owner,
+ * 2026-10-14): a select or multi-select whose host takes a definition write
+ * (`setData`) and says so for this property (`dataWritable: true`). Anything
+ * else keeps its options fixed, the 0.48 band. A read-only chip opens no
+ * editor whatever this says.
+ */
+export function bandOptionsWritable(cellType, property, hasSetData) {
+    return (hasSetData &&
+        property.dataWritable === true &&
+        (cellType === 'select' || cellType === 'multi-select'));
+}

package/dist/_pkgs/affine-fragment-doc-title/title-band/format.d.ts

@@ -1,9 +1,9 @@
 import type { TitleBandProperty } from '../../affine-shared/services/index.js';
 /**
- * How a chip of the title band draws a property's value, and which editor a
- * click opens — pure, render-free, so a host's own properties panel can show
- * the very text a chip shows (`formatPropertyValue`, re-exported by
- * `@labre/affine/host-panels`).
+ * A property's value as one line of text — pure, render-free, so a host's own
+ * properties panel can show what a chip reads (`formatPropertyValue`,
+ * re-exported by `@labre/affine/host-panels`), and the band can still read
+ * a type no data-view cell draws (`relation`, an unknown one).
  *
  * The value is the JSON a data-view cell of `type` holds (ADR 0035 §9d), and
  * the shapes below are the data-view presets' own: an option id for `select`,
@@ -11,12 +11,9 @@ import type { TitleBandProperty } from '../../affine-shared/services/index.js';
  * formatted with the number preset's options, so a chip and a database cell
  * read the same.
  *
- * ponytail: the band draws its chips and editors itself, per type, rather
- * than mounting the data-view cell renderers, which need a `Cell` bound to a
- * view and a data source the band does not have. The ceiling is a type the
- * band does not know: it is drawn as plain text and opens no editor. The
- * upgrade path is a hosted data source for the page's sheet once
- * `HostedDataSourceBase` exists (ADR 0035 §7, issue B1).
+ * The chips themselves no longer read this: each value is drawn and edited by
+ * the data-view cell of its type (`./band-cell.ts`, ADR 0035 §11 amended
+ * 2026-10-13). This text is the host panels' reading and the band's fallback.
  */
 /** A select option as a data-view `select` / `multi-select` holds it. */
 export interface ChipTag {
@@ -37,8 +34,6 @@ export type ChipValueView = {
     kind: 'tags';
     tags: ChipTag[];
 };
-/** The editor a click on a chip opens; `none` for a type the band cannot edit. */
-export type ChipEditorKind = 'toggle' | 'select' | 'multi-select' | 'date' | 'number' | 'text' | 'none';
 /**
  * The number preset's formats (`data-view/…/number/utils/formatter.ts`),
  * restated rather than imported: the preset formats with
@@ -60,10 +55,3 @@ export declare function chipValueView(property: TitleBandProperty, locale: strin
  * mark, not a word, so a host draws its own from `property.value`.
  */
 export declare function formatPropertyValue(property: TitleBandProperty, locale?: string): string;
-/**
- * A number typed in a chip's editor: blanks dropped, a decimal comma read as
- * a point. `NaN` for anything else, which the band writes as `null`.
- */
-export declare function parseChipNumber(text: string): number;
-/** The editor a click on this property's chip opens. */
-export declare function chipEditorKind(property: TitleBandProperty): ChipEditorKind;

package/dist/_pkgs/affine-fragment-doc-title/title-band/format.js

@@ -1,12 +1,3 @@
-const TEXT_TYPES = new Set([
-    'text',
-    'rich-text',
-    'title',
-    'url',
-    'link',
-    'email',
-    'phone',
-]);
 const DATE_TYPES = new Set(['date', 'created-time', 'modified-time']);
 const currency = (code) => ({
     style: 'currency',
@@ -151,32 +142,3 @@ export function formatPropertyValue(property, locale = 'en-US') {
             return '';
     }
 }
-/**
- * A number typed in a chip's editor: blanks dropped, a decimal comma read as
- * a point. `NaN` for anything else, which the band writes as `null`.
- */
-export function parseChipNumber(text) {
-    const compact = text.replace(/\s/g, '');
-    if (compact === '')
-        return NaN;
-    return Number(compact.replace(',', '.'));
-}
-/** The editor a click on this property's chip opens. */
-export function chipEditorKind(property) {
-    if (property.readonly)
-        return 'none';
-    const { type } = property;
-    if (type === 'checkbox')
-        return 'toggle';
-    if (type === 'select')
-        return 'select';
-    if (type === 'multi-select')
-        return 'multi-select';
-    if (type === 'date')
-        return 'date';
-    if (type === 'number' || type === 'progress')
-        return 'number';
-    if (TEXT_TYPES.has(type))
-        return 'text';
-    return 'none';
-}

package/dist/_pkgs/affine-fragment-doc-title/title-band/show-here.d.ts

@@ -0,0 +1,19 @@
+import type { BlockStdScope } from '../../std/index.js';
+/**
+ * "Show here" (labre ADR-0045 §7): insert a card of page `pageId` into the
+ * open document, so a child page the document held without showing becomes
+ * shown. The host computes the "Not shown" list; once the card exists, its
+ * own reading of the document drops the page from it. Nothing here knows a
+ * parent or a child: the card is an ordinary `affine:embed-linked-doc`,
+ * exactly what pasting a link to that page would make.
+ *
+ * - page view: at the end of the last note the page view shows (a new note
+ *   when there is none);
+ * - canvas: centred in the visible part of the canvas, through the CRUD
+ *   `addBlock`, which stamps the viewer's active layer (ADR 0031 §6), then
+ *   selected so the reader sees what appeared.
+ *
+ * One gesture, one undo step (`captureSync`). A read-only document gets
+ * nothing. Returns the new card's id, or `null` when nothing was written.
+ */
+export declare function showPageHere(std: BlockStdScope, surface: 'page' | 'canvas', pageId: string): string | null;

package/dist/_pkgs/affine-fragment-doc-title/title-band/show-here.js

@@ -0,0 +1,61 @@
+import { EdgelessCRUDIdentifier } from '../../affine-block-surface/index.js';
+import { EMBED_CARD_HEIGHT, EMBED_CARD_WIDTH, } from '../../affine-shared/consts/index.js';
+import { TelemetryProvider } from '../../affine-shared/services/index.js';
+import { getLastNoteBlock } from '../../affine-shared/utils/index.js';
+import { Bound } from '../../global/gfx/index.js';
+import { GfxControllerIdentifier } from '../../std/gfx/index.js';
+const LINKED_DOC = 'affine:embed-linked-doc';
+/** The canvas card's style, the one "Linked doc" inserts on the canvas. */
+const CANVAS_STYLE = 'vertical';
+/**
+ * "Show here" (labre ADR-0045 §7): insert a card of page `pageId` into the
+ * open document, so a child page the document held without showing becomes
+ * shown. The host computes the "Not shown" list; once the card exists, its
+ * own reading of the document drops the page from it. Nothing here knows a
+ * parent or a child: the card is an ordinary `affine:embed-linked-doc`,
+ * exactly what pasting a link to that page would make.
+ *
+ * - page view: at the end of the last note the page view shows (a new note
+ *   when there is none);
+ * - canvas: centred in the visible part of the canvas, through the CRUD
+ *   `addBlock`, which stamps the viewer's active layer (ADR 0031 §6), then
+ *   selected so the reader sees what appeared.
+ *
+ * One gesture, one undo step (`captureSync`). A read-only document gets
+ * nothing. Returns the new card's id, or `null` when nothing was written.
+ */
+export function showPageHere(std, surface, pageId) {
+    const { store } = std;
+    if (store.readonly || !store.root || !pageId)
+        return null;
+    store.captureSync();
+    const id = surface === 'canvas'
+        ? insertOnCanvas(std, pageId)
+        : insertInPage(std, pageId);
+    if (id) {
+        std.getOptional(TelemetryProvider)?.track('BlockCreated', {
+            blockType: LINKED_DOC,
+        });
+    }
+    return id;
+}
+function insertInPage(std, pageId) {
+    const { store } = std;
+    const root = store.root;
+    if (!root)
+        return null;
+    const noteId = getLastNoteBlock(store)?.id ?? store.addBlock('affine:note', {}, root.id);
+    return store.addBlock(LINKED_DOC, { pageId }, noteId);
+}
+function insertOnCanvas(std, pageId) {
+    const gfx = std.get(GfxControllerIdentifier);
+    const surface = gfx.surface;
+    if (!surface)
+        return null;
+    const xywh = Bound.fromCenter([gfx.viewport.centerX, gfx.viewport.centerY], EMBED_CARD_WIDTH[CANVAS_STYLE], EMBED_CARD_HEIGHT[CANVAS_STYLE]).serialize();
+    const id = std
+        .get(EdgelessCRUDIdentifier)
+        .addBlock(LINKED_DOC, { pageId, xywh, style: CANVAS_STYLE }, surface);
+    gfx.selection.set({ elements: [id], editing: false });
+    return id;
+}

package/dist/_pkgs/affine-fragment-doc-title/title-band/title-band.d.ts

@@ -14,40 +14,55 @@ declare const TitleBand_base: typeof ShadowlessElement & import("../../global/ut
  *
  * Fed by `TitleBandProvider` alone (§9d): no provider, nothing at all. The
  * chips are the sheet's visible properties in the host's order, an empty one
- * included (REQ-PR-1); a click opens the editor of the property's data-view
- * type and hands the value back through `set`, showing the chip as pending
- * until the host settles it. The band never writes to the document and never
- * applies a value. The "+" is drawn when the host passes `add`; the panel
- * button when a `PropertiesPanelProvider` is registered; the "Not shown in
- * this document" row only on the canvas (the page view's row is the host's).
+ * included (REQ-PR-1). Each value is drawn and edited by the cell the inline
+ * table mounts for its data-view type (`<dv-standalone-cell>`, ADR 0035
+ * §11 amended 2026-10-13): the checkbox, the tag menu of a select, the date
+ * picker, the number, text and link inputs, with the table's own styles. The
+ * value the cell commits goes back through `set`, the chip shows pending
+ * until the host settles it, and a type with no cell keeps a plain-text
+ * reading that opens the properties panel. The band never applies a value, and writes to
+ * the document only the card "Show here" inserts. The "+" is drawn when the
+ * host passes `add`; the panel button when a `PropertiesPanelProvider` is
+ * registered. The "Not shown on this page" row is drawn in both views
+ * from the host's `notShown$` (ADR 0035 §9d, amended 2026-10-13): each page
+ * opens through the linked-document path, and "Show here" inserts a card of
+ * it into this document; the host then drops the page from its list.
  */
 export declare class TitleBand extends TitleBand_base {
     static styles: import("lit").CSSResult;
     private _sources;
-    /** The editor menu open now, put away with the band. */
-    private _menu;
-    private _pop;
     /** Collapse state when the host does not remember one. */
     private readonly _localCollapsed$;
     /** Property ids whose `set` has not settled yet. */
     private readonly _pending$;
     /** Read inside `render` it subscribes, through `SignalWatcher`. */
     private get _readonly();
+    /** The table's own flags, so a number reads as it does in a cell. */
+    private readonly _featureFlags$;
     private get _locale();
     private _t;
     private _getSources;
     private _isCollapsed;
     private _setCollapsed;
     private _write;
-    private readonly _onChip;
-    private _tagLabel;
-    private _clearItem;
-    private _popSelect;
-    private _popMultiSelect;
-    private _popDate;
-    private _popInput;
+    /**
+     * A definition a select's tag menu commits (a created or renamed option):
+     * handed to the host's `setData`, never applied here.
+     */
+    private _writeData;
+    /** A value a cell commits: unchanged, nothing is written. */
+    private _commit;
+    /** Neither the property nor the document can be written, or the type. */
+    private _isReadonlyChip;
+    /**
+     * The cell that draws `prop`, built once per property and type: its value,
+     * name and config are read from the sheet, so a new sheet updates the cell
+     * in place and an editor open in it stays open.
+     */
+    private _cellFor;
     private readonly _openPanel;
-    private _renderValue;
+    private readonly _onChip;
+    private _renderFallback;
     private _renderChip;
     private _renderTools;
     private _renderSheet;
@@ -56,7 +71,7 @@ export declare class TitleBand extends TitleBand_base {
     render(): TemplateResult<1> | typeof nothing;
     accessor std: BlockStdScope | null;
     accessor docId: string;
-    /** Where the band is drawn; only the canvas draws the "Not shown" row. */
+    /** Where the band is drawn: where "Show here" puts the card. */
     accessor surface: 'page' | 'canvas';
 }
 export {};