@formicoidea/labre-core 0.47.1 → 0.48.0

package/dist/_pkgs/affine-block-database/view.js

@@ -1,12 +1,14 @@
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
 import { DatabaseBlockModel } from '../affine-model/index.js';
 import { SlashMenuConfigExtension } from '../affine-widget-slash-menu/index.js';
+import { StandaloneCellMetaExtension } from '../data-view/index.js';
 import { BlockViewExtension, FlavourExtension } from '../std/index.js';
 import { literal } from 'lit/static-html.js';
 import { z } from 'zod';
 import { DatabaseConfigExtension } from './config.js';
 import { databaseSlashMenuConfig } from './configs/slash-menu.js';
 import { effects } from './effects.js';
+import { linkColumnConfig } from './properties/link/cell-renderer.js';
 const optionsSchema = z.object({
     configure: z
         .function()
@@ -29,6 +31,9 @@ export class DatabaseViewExtension extends ViewExtensionProvider {
             FlavourExtension('affine:database'),
             BlockViewExtension('affine:database', literal `affine-database`),
             SlashMenuConfigExtension('affine:database', databaseSlashMenuConfig),
+            // The title band draws a `link` / `url` property with the table's link
+            // cell; it sits below this package and cannot import it (ADR 0035 §11).
+            StandaloneCellMetaExtension(linkColumnConfig),
         ]);
         if (options) {
             context.register(DatabaseConfigExtension({ configure: options.configure }));

package/dist/_pkgs/affine-block-embed-doc/embed-linked-doc-block/configs/new-doc.d.ts

@@ -0,0 +1,25 @@
+import type { BlockStdScope } from '../../../std/index.js';
+import type { BlockModel } from '../../../store/index.js';
+/**
+ * Whether the slash menu offers "New Page" here: the card's schema is
+ * registered, and the host, if it creates docs, does not refuse it on this
+ * editor (`LinkedDocCreationProvider.canCreateLinkedDoc`).
+ */
+export declare function canCreateDocHere(std: BlockStdScope, model: BlockModel): boolean;
+/**
+ * The slash menu's "New Page": creates a page and leaves a CARD of it
+ * (`affine:embed-linked-doc`) right after the block the gesture was typed in.
+ * A paragraph the gesture left empty is replaced by the card, as Notion turns
+ * the line into the page. A card shows a child where its parent places it; an
+ * inline mention is only a reference (Labre ADR-0045 §9, host side).
+ *
+ * The page comes from the host's `LinkedDocCreationProvider` when there is
+ * one (the host persists it, registers it, decides its parent), else from the
+ * workspace (`createDefaultDoc`, the playground and standalone editors).
+ *
+ * One undo step for the card and the removed line. When no card can go there
+ * (a parent whose schema refuses it, an edgeless text for one), the gesture
+ * falls back on the inline mention it used to leave, so it always yields a way
+ * to the page. Returns the new page's id, or null on a read-only store.
+ */
+export declare function createDocFromSlash(std: BlockStdScope, model: BlockModel): string | null;

package/dist/_pkgs/affine-block-embed-doc/embed-linked-doc-block/configs/new-doc.js

@@ -0,0 +1,71 @@
+import { insertContent } from '../../../affine-rich-text/index.js';
+import { REFERENCE_NODE } from '../../../affine-shared/consts/index.js';
+import { LinkedDocCreationProvider, TelemetryProvider, } from '../../../affine-shared/services/index.js';
+import { createDefaultDoc, writeDefaultDocBlocks, } from '../../../affine-shared/utils/index.js';
+const LINKED_DOC = 'affine:embed-linked-doc';
+/**
+ * Whether the slash menu offers "New Page" here: the card's schema is
+ * registered, and the host, if it creates docs, does not refuse it on this
+ * editor (`LinkedDocCreationProvider.canCreateLinkedDoc`).
+ */
+export function canCreateDocHere(std, model) {
+    if (!model.store.schema.flavourSchemaMap.has(LINKED_DOC))
+        return false;
+    const creation = std.getOptional(LinkedDocCreationProvider);
+    return creation?.canCreateLinkedDoc?.(std.host) ?? true;
+}
+/**
+ * The slash menu's "New Page": creates a page and leaves a CARD of it
+ * (`affine:embed-linked-doc`) right after the block the gesture was typed in.
+ * A paragraph the gesture left empty is replaced by the card, as Notion turns
+ * the line into the page. A card shows a child where its parent places it; an
+ * inline mention is only a reference (Labre ADR-0045 §9, host side).
+ *
+ * The page comes from the host's `LinkedDocCreationProvider` when there is
+ * one (the host persists it, registers it, decides its parent), else from the
+ * workspace (`createDefaultDoc`, the playground and standalone editors).
+ *
+ * One undo step for the card and the removed line. When no card can go there
+ * (a parent whose schema refuses it, an edgeless text for one), the gesture
+ * falls back on the inline mention it used to leave, so it always yields a way
+ * to the page. Returns the new page's id, or null on a read-only store.
+ */
+export function createDocFromSlash(std, model) {
+    const { store } = std;
+    if (store.readonly)
+        return null;
+    const pageId = createNewDoc(std).id;
+    store.captureSync();
+    if (insertCard(store, model, pageId)) {
+        std.getOptional(TelemetryProvider)?.track('BlockCreated', {
+            blockType: LINKED_DOC,
+        });
+    }
+    else {
+        insertContent(std, model, REFERENCE_NODE, {
+            reference: { type: 'LinkedPage', pageId },
+        });
+    }
+    return pageId;
+}
+function createNewDoc(std) {
+    const creation = std.getOptional(LinkedDocCreationProvider);
+    if (!creation)
+        return createDefaultDoc(std.store.workspace);
+    const doc = creation.createLinkedDoc(std.host, '');
+    doc.load(() => writeDefaultDocBlocks(doc));
+    // The new page's first undo must not empty it (as in `createDefaultDoc`).
+    doc.resetHistory();
+    return doc;
+}
+function insertCard(store, anchor, pageId) {
+    const parent = store.getParent(anchor);
+    if (!parent || !store.schema.isValid(LINKED_DOC, parent.flavour)) {
+        return null;
+    }
+    const cardId = store.addBlock(LINKED_DOC, { pageId }, parent, parent.children.indexOf(anchor) + 1);
+    if (anchor.flavour === 'affine:paragraph' && anchor.text?.length === 0) {
+        store.deleteBlock(anchor);
+    }
+    return cardId;
+}

package/dist/_pkgs/affine-block-embed-doc/embed-linked-doc-block/configs/slash-menu.js

@@ -1,11 +1,9 @@
 import { EmbedLinkedDocBlockSchema } from '../../../affine-model/index.js';
-import { insertContent } from '../../../affine-rich-text/index.js';
-import { REFERENCE_NODE } from '../../../affine-shared/consts/index.js';
-import { createDefaultDoc } from '../../../affine-shared/utils/index.js';
 import { SlashMenuConfigIdentifier, } from '../../../affine-widget-slash-menu/index.js';
 import { LinkedPageIcon, PlusIcon } from '@blocksuite/icons/lit';
 import {} from '../../../store/index.js';
 import { EMBED_DOC_SLASH_LINKED_DOC_CAPTION, EMBED_DOC_SLASH_LINKED_DOC_DESCRIPTION, EMBED_DOC_SLASH_LINKED_DOC_NAME, EMBED_DOC_SLASH_NEW_DOC_DESCRIPTION, EMBED_DOC_SLASH_NEW_DOC_NAME, } from '../../translations.js';
+import { canCreateDocHere, createDocFromSlash } from './new-doc.js';
 import { LinkDocTooltip, NewDocTooltip } from './tooltips.js';
 const linkedDocSlashMenuConfig = {
     items: [
@@ -21,15 +19,9 @@ const linkedDocSlashMenuConfig = {
                 captionWording: EMBED_DOC_SLASH_NEW_DOC_NAME,
             },
             group: '3_Page@0',
-            when: ({ model }) => model.store.schema.flavourSchemaMap.has('affine:embed-linked-doc'),
+            when: ({ std, model }) => canCreateDocHere(std, model),
             action: ({ std, model }) => {
-                const newDoc = createDefaultDoc(std.host.store.workspace);
-                insertContent(std, model, REFERENCE_NODE, {
-                    reference: {
-                        type: 'LinkedPage',
-                        pageId: newDoc.id,
-                    },
-                });
+                createDocFromSlash(std, model);
             },
         },
         {

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,22 @@
+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;

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

@@ -0,0 +1,125 @@
+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;
+}

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,50 @@ 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 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 +66,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 {};