@formicoidea/labre-core 0.52.0 → 0.54.0

package/dist/_pkgs/affine-widget-thread-marks/text-range.d.ts

@@ -0,0 +1,26 @@
+import type { ThreadTextRange } from '../affine-shared/services/index.js';
+import * as Y from 'yjs';
+/** Where a range sits in its block's text today, by index. */
+export interface ResolvedThreadRange {
+    index: number;
+    length: number;
+}
+/**
+ * The anchor of `length` characters from `index` in `yText` (ADR 0038,
+ * amendment of 2026-10-15), or `null` for an empty run or one outside the
+ * text.
+ *
+ * `start` sticks to the first selected character (`assoc = 0`) and `end` to
+ * the last one (`assoc = -1`), so typing right after the run does not grow
+ * it. Creating a relative position only reads the item ids: nothing is
+ * written to the document (held by `text-range.unit.spec.ts`).
+ */
+export declare function encodeThreadRange(yText: Y.Text, index: number, length: number): ThreadTextRange | null;
+/**
+ * Where `range` sits in `yText` now, or `null` when it cannot say: the text
+ * is detached, a string is not a position, a position belongs to another
+ * text, or the run collapsed because its text was deleted. Never throws: a
+ * host's stored anchor may be anything, and an unresolvable range simply is
+ * not drawn.
+ */
+export declare function resolveThreadRange(yText: Y.Text, range: ThreadTextRange): ResolvedThreadRange | null;

package/dist/_pkgs/affine-widget-thread-marks/text-range.js

@@ -0,0 +1,59 @@
+import * as Y from 'yjs';
+function toBase64(bytes) {
+    let binary = '';
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary);
+}
+function fromBase64(text) {
+    return Uint8Array.from(atob(text), char => char.charCodeAt(0));
+}
+/**
+ * The anchor of `length` characters from `index` in `yText` (ADR 0038,
+ * amendment of 2026-10-15), or `null` for an empty run or one outside the
+ * text.
+ *
+ * `start` sticks to the first selected character (`assoc = 0`) and `end` to
+ * the last one (`assoc = -1`), so typing right after the run does not grow
+ * it. Creating a relative position only reads the item ids: nothing is
+ * written to the document (held by `text-range.unit.spec.ts`).
+ */
+export function encodeThreadRange(yText, index, length) {
+    if (!(length > 0) || index < 0 || index + length > yText.length) {
+        return null;
+    }
+    const start = Y.createRelativePositionFromTypeIndex(yText, index, 0);
+    const end = Y.createRelativePositionFromTypeIndex(yText, index + length, -1);
+    return {
+        start: toBase64(Y.encodeRelativePosition(start)),
+        end: toBase64(Y.encodeRelativePosition(end)),
+    };
+}
+function absoluteIndex(encoded, yText, doc) {
+    const position = Y.createAbsolutePositionFromRelativePosition(Y.decodeRelativePosition(fromBase64(encoded)), doc);
+    // A position of another text (a host that mixed up two anchors) is not
+    // this block's run.
+    return position && position.type === yText ? position.index : null;
+}
+/**
+ * Where `range` sits in `yText` now, or `null` when it cannot say: the text
+ * is detached, a string is not a position, a position belongs to another
+ * text, or the run collapsed because its text was deleted. Never throws: a
+ * host's stored anchor may be anything, and an unresolvable range simply is
+ * not drawn.
+ */
+export function resolveThreadRange(yText, range) {
+    const doc = yText.doc;
+    if (!doc)
+        return null;
+    try {
+        const start = absoluteIndex(range.start, yText, doc);
+        const end = absoluteIndex(range.end, yText, doc);
+        if (start === null || end === null || end <= start)
+            return null;
+        return { index: start, length: end - start };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/_pkgs/affine-widget-thread-marks/toolbar.d.ts

@@ -9,15 +9,16 @@ import { type ThreadTarget } from './excerpt.js';
  * - On the canvas, exactly one selected model: a canvas element (shape,
  *   connector, group, framework board) is an `element`, a canvas block (note,
  *   frame, image, embed) a `block`.
- * - A text selection within one block: that block (the grain is the block,
- *   never a range of text).
+ * - A text selection: the block it starts in, with the selected run of that
+ *   block's text (ADR 0038, amendment of 2026-10-15).
  * - One selected block, or the block a hover toolbar is drawn for.
  */
 export declare function threadTargetOf(ctx: ToolbarContext): ThreadTarget | null;
 /**
  * Ask the host to open the discussion of `target`, with the excerpt the
  * library computes. Nothing is written: no prop, no id in the document.
- * Without the seam, nothing happens.
+ * Without the seam, nothing happens. `range` is handed over only when there
+ * is one, so a host comparing requests sees the first shape for a whole block.
  */
 export declare function openThreadOn(std: BlockStdScope, target: ThreadTarget): void;
 export declare const THREAD_DISCUSS_ACTION_ID = "g.thread-discuss";

package/dist/_pkgs/affine-widget-thread-marks/toolbar.js

@@ -3,6 +3,7 @@ import { ToolbarModuleExtension, toolbarModuleKey, ThreadMarksProvider, } from '
 import { BlockFlavourIdentifier, BlockSelection, TextSelection, } from '../std/index.js';
 import { GfxPrimitiveElementModel } from '../std/gfx/index.js';
 import { threadExcerpt } from './excerpt.js';
+import { encodeThreadRange } from './text-range.js';
 import { THREAD_DISCUSS } from './translations.js';
 /** Containers a discussion never anchors to: the page and the canvas itself. */
 const NOT_A_TARGET = new Set(['affine:page', 'affine:surface']);
@@ -14,6 +15,22 @@ function blockTarget(id, ctx) {
         return null;
     return { targetType: 'block', targetId: model.id };
 }
+/**
+ * The block a text selection starts in, with the selected run of it. A
+ * selection over several blocks anchors to the first one, on the part of it
+ * that is selected (ADR 0038, amendment of 2026-10-15). A run that cannot be
+ * encoded (an empty one, a block with no text) leaves the block alone.
+ */
+function textTarget(text, ctx) {
+    const target = blockTarget(text.from.blockId, ctx);
+    if (!target)
+        return null;
+    const yText = ctx.store.getModelById(target.targetId)?.text?.yText;
+    const range = yText
+        ? encodeThreadRange(yText, text.from.index, text.from.length)
+        : null;
+    return range ? { ...target, range } : target;
+}
 /**
  * The ONE target a toolbar row speaks for, or `null` when it speaks for
  * several (a discussion anchors to one block or one element, labre ADR-0048).
@@ -21,8 +38,8 @@ function blockTarget(id, ctx) {
  * - On the canvas, exactly one selected model: a canvas element (shape,
  *   connector, group, framework board) is an `element`, a canvas block (note,
  *   frame, image, embed) a `block`.
- * - A text selection within one block: that block (the grain is the block,
- *   never a range of text).
+ * - A text selection: the block it starts in, with the selected run of that
+ *   block's text (ADR 0038, amendment of 2026-10-15).
  * - One selected block, or the block a hover toolbar is drawn for.
  */
 export function threadTargetOf(ctx) {
@@ -38,11 +55,8 @@ export function threadTargetOf(ctx) {
             : blockTarget(model.id, ctx);
     }
     const text = ctx.selection.find(TextSelection);
-    if (text) {
-        const from = text.from.blockId;
-        const to = text.to?.blockId ?? from;
-        return from === to ? blockTarget(from, ctx) : null;
-    }
+    if (text)
+        return textTarget(text, ctx);
     if (ctx.selection.filter(BlockSelection).length > 1)
         return null;
     return blockTarget(ctx.getCurrentModelBy(BlockSelection)?.id, ctx);
@@ -50,7 +64,8 @@ export function threadTargetOf(ctx) {
 /**
  * Ask the host to open the discussion of `target`, with the excerpt the
  * library computes. Nothing is written: no prop, no id in the document.
- * Without the seam, nothing happens.
+ * Without the seam, nothing happens. `range` is handed over only when there
+ * is one, so a host comparing requests sees the first shape for a whole block.
  */
 export function openThreadOn(std, target) {
     const service = std.getOptional(ThreadMarksProvider);
@@ -61,6 +76,7 @@ export function openThreadOn(std, target) {
         targetType: target.targetType,
         targetId: target.targetId,
         excerpt: threadExcerpt(std, target),
+        ...(target.range ? { range: target.range } : {}),
     });
 }
 export const THREAD_DISCUSS_ACTION_ID = 'g.thread-discuss';

package/dist/_pkgs/affine-widget-thread-marks/widget.d.ts

@@ -1,5 +1,7 @@
+import { type SelectionRect } from '../affine-shared/commands/index.js';
 import { type ThreadMark } from '../affine-shared/services/index.js';
 import { WidgetComponent } from '../std/index.js';
+import { nothing } from 'lit';
 export declare const AFFINE_THREAD_MARKS_WIDGET = "affine-thread-marks-widget";
 /**
  * Where a mark sits, relative to the widget's own origin: beside a block of
@@ -15,6 +17,8 @@ export interface ThreadMarkPlace {
 export interface PlacedThreadMark extends ThreadMarkPlace {
     mark: ThreadMark;
 }
+/** Is the point (viewport coordinates) inside one of the rects? */
+export declare function hitsThreadRange(rects: readonly SelectionRect[], x: number, y: number): boolean;
 /**
  * The marks to draw, from what the host says and where the editor finds each
  * target. Pure, so the "ignore what is absent" rule is held by a test:
@@ -22,7 +26,9 @@ export interface PlacedThreadMark extends ThreadMarkPlace {
  * - a target `locate` cannot find (deleted, of the other view, hidden for this
  *   viewer) is skipped, never an error: an orphan anchor has no mark;
  * - a mark at `count <= 0` is not drawn;
- * - two marks on one target are one mark: counts add up, unread wins.
+ * - two marks on one target are one mark: counts add up, unread wins, and
+ *   the run of text it opens is kept only when every merged mark names the
+ *   same one (a mark that stands for several discussions opens the block).
  */
 export declare function placeThreadMarks(marks: readonly ThreadMark[], locate: (mark: ThreadMark) => ThreadMarkPlace | null): PlacedThreadMark[];
 /**
@@ -31,6 +37,15 @@ export declare function placeThreadMarks(marks: readonly ThreadMark[], locate: (
  * on the canvas on the corner of each marked element or block. A click asks
  * the host to open the discussion, exactly as "Discuss" does.
  *
+ * A mark that carries a `range` also highlights that run of its block's text
+ * in the page view (ADR 0038, amendment of 2026-10-15). The run is resolved
+ * from its Yjs relative positions on every render and drawn as the range's
+ * client rects (the technique of `doc-remote-selection`), never as a mark in
+ * the text. The highlight takes no pointer event, so nothing blocks placing
+ * the caret or selecting; a click that lands on it with nothing selected
+ * opens its discussion. A run that no longer resolves is not drawn, and the
+ * block's own mark stays.
+ *
  * It reads the seam and the layout, and writes nothing. Positions are
  * client rects taken relative to the widget's own box and recomputed, once a
  * frame at most, when the marks, the document, the canvas or the window
@@ -41,8 +56,24 @@ export declare class ThreadMarksWidget extends WidgetComponent {
     private readonly _refresh;
     private get _edgeless();
     connectedCallback(): void;
+    /**
+     * A click on a highlighted run opens its discussion. The click is not
+     * consumed: the caret lands where it was put. A click that ends a drag
+     * (something is selected) is a selection, not a request.
+     */
+    private readonly _onClick;
+    /** Open the discussion of the run under the point, if there is one. */
+    private _openRangeAt;
+    private _resolve;
+    /**
+     * The runs to highlight, in viewport coordinates, page view only: on the
+     * canvas a note's text may sit under a shape, and this overlay would paint
+     * over it. `ponytail:` a run in a canvas note keeps only its block's mark;
+     * drawing it there needs the canvas stacking, if a reader asks for it.
+     */
+    private _ranges;
     private _locate;
-    render(): unknown;
+    render(): import("lit-html").TemplateResult<1> | typeof nothing;
 }
 declare global {
     interface HTMLElementTagNameMap {

package/dist/_pkgs/affine-widget-thread-marks/widget.js

@@ -1,17 +1,27 @@
 import { CommentIcon } from '@blocksuite/icons/lit';
 import { isPainted } from '../affine-block-surface/index.js';
+import { getRangeRects, } from '../affine-shared/commands/index.js';
 import { ThreadMarksProvider, translateKey, } from '../affine-shared/services/index.js';
 import { isInsideEdgelessEditor, requestThrottledConnectedFrame, } from '../affine-shared/utils/index.js';
-import { WidgetComponent } from '../std/index.js';
+import { TextSelection, WidgetComponent } from '../std/index.js';
 import { GfxBlockElementModel, GfxControllerIdentifier, GfxPrimitiveElementModel, } from '../std/gfx/index.js';
 import { effect } from '@preact/signals-core';
 import { cssVarV2 } from '@toeverything/theme/v2';
 import { css, html, nothing, unsafeCSS } from 'lit';
 import { repeat } from 'lit/directives/repeat.js';
 import { styleMap } from 'lit/directives/style-map.js';
+import { resolveThreadRange } from './text-range.js';
 import { openThreadOn } from './toolbar.js';
 import { THREAD_DISCUSS } from './translations.js';
 export const AFFINE_THREAD_MARKS_WIDGET = 'affine-thread-marks-widget';
+/** Is the point (viewport coordinates) inside one of the rects? */
+export function hitsThreadRange(rects, x, y) {
+    return rects.some(rect => x >= rect.left &&
+        x <= rect.left + rect.width &&
+        y >= rect.top &&
+        y <= rect.top + rect.height);
+}
+const sameRange = (a, b) => a?.start === b?.start && a?.end === b?.end;
 /**
  * The marks to draw, from what the host says and where the editor finds each
  * target. Pure, so the "ignore what is absent" rule is held by a test:
@@ -19,7 +29,9 @@ export const AFFINE_THREAD_MARKS_WIDGET = 'affine-thread-marks-widget';
  * - a target `locate` cannot find (deleted, of the other view, hidden for this
  *   viewer) is skipped, never an error: an orphan anchor has no mark;
  * - a mark at `count <= 0` is not drawn;
- * - two marks on one target are one mark: counts add up, unread wins.
+ * - two marks on one target are one mark: counts add up, unread wins, and
+ *   the run of text it opens is kept only when every merged mark names the
+ *   same one (a mark that stands for several discussions opens the block).
  */
 export function placeThreadMarks(marks, locate) {
     const merged = new Map();
@@ -33,6 +45,7 @@ export function placeThreadMarks(marks, locate) {
                 ...seen,
                 count: seen.count + mark.count,
                 unread: seen.unread || mark.unread,
+                range: sameRange(seen.range, mark.range) ? seen.range : undefined,
             }
             : mark);
     }
@@ -50,6 +63,15 @@ export function placeThreadMarks(marks, locate) {
  * on the canvas on the corner of each marked element or block. A click asks
  * the host to open the discussion, exactly as "Discuss" does.
  *
+ * A mark that carries a `range` also highlights that run of its block's text
+ * in the page view (ADR 0038, amendment of 2026-10-15). The run is resolved
+ * from its Yjs relative positions on every render and drawn as the range's
+ * client rects (the technique of `doc-remote-selection`), never as a mark in
+ * the text. The highlight takes no pointer event, so nothing blocks placing
+ * the caret or selecting; a click that lands on it with nothing selected
+ * opens its discussion. A run that no longer resolves is not drawn, and the
+ * block's own mark stays.
+ *
  * It reads the seam and the layout, and writes nothing. Positions are
  * client rects taken relative to the widget's own box and recomputed, once a
  * frame at most, when the marks, the document, the canvas or the window
@@ -61,6 +83,16 @@ export class ThreadMarksWidget extends WidgetComponent {
         this._refresh = requestThrottledConnectedFrame(() => {
             this.requestUpdate();
         }, this);
+        /**
+         * A click on a highlighted run opens its discussion. The click is not
+         * consumed: the caret lands where it was put. A click that ends a drag
+         * (something is selected) is a selection, not a request.
+         */
+        this._onClick = (event) => {
+            if (window.getSelection()?.isCollapsed === false)
+                return;
+            this._openRangeAt(event.clientX, event.clientY);
+        };
     }
     static { this.styles = css `
     :host {
@@ -88,6 +120,16 @@ export class ThreadMarksWidget extends WidgetComponent {
       pointer-events: auto;
     }
 
+    .thread-range {
+      position: absolute;
+      top: 0;
+      left: 0;
+      background-color: ${unsafeCSS(cssVarV2('block/comment/highlightDefault'))};
+      border-bottom: 2px solid
+        ${unsafeCSS(cssVarV2('block/comment/highlightUnderline'))};
+      pointer-events: none;
+    }
+
     .thread-mark[data-unread] {
       color: ${unsafeCSS(cssVarV2('text/emphasis'))};
     }
@@ -116,6 +158,12 @@ export class ThreadMarksWidget extends WidgetComponent {
         _disposables.addFromEvent(window, 'resize', this._refresh);
         // Capture: the page view scrolls in a container, not the window.
         _disposables.addFromEvent(window, 'scroll', this._refresh, true);
+        // A highlighted run moves with every keystroke, local or remote, and a
+        // text edit is no block update: follow the document itself.
+        const doc = std.store.spaceDoc;
+        doc.on('update', this._refresh);
+        _disposables.add(() => doc.off('update', this._refresh));
+        _disposables.addFromEvent(std.host, 'click', this._onClick);
         const gfx = std.getOptional(GfxControllerIdentifier);
         if (gfx) {
             _disposables.add(gfx.viewport.viewportUpdated.subscribe(this._refresh));
@@ -134,6 +182,62 @@ export class ThreadMarksWidget extends WidgetComponent {
             }));
         }
     }
+    /** Open the discussion of the run under the point, if there is one. */
+    _openRangeAt(x, y) {
+        const service = this.std.getOptional(ThreadMarksProvider);
+        if (!service)
+            return;
+        const hit = this._ranges(service.marks$.peek()).find(({ rects }) => hitsThreadRange(rects, x, y));
+        if (!hit)
+            return;
+        openThreadOn(this.std, {
+            targetType: 'block',
+            targetId: hit.mark.targetId,
+            range: hit.mark.range,
+        });
+    }
+    _resolve(mark) {
+        if (mark.targetType !== 'block' || !mark.range)
+            return null;
+        const yText = this.std.store.getModelById(mark.targetId)?.text?.yText;
+        return yText ? resolveThreadRange(yText, mark.range) : null;
+    }
+    /**
+     * The runs to highlight, in viewport coordinates, page view only: on the
+     * canvas a note's text may sit under a shape, and this overlay would paint
+     * over it. `ponytail:` a run in a canvas note keeps only its block's mark;
+     * drawing it there needs the canvas stacking, if a reader asks for it.
+     */
+    _ranges(marks) {
+        if (this._edgeless)
+            return [];
+        const drawn = [];
+        for (const mark of marks) {
+            if (!(mark.count > 0))
+                continue;
+            const run = this._resolve(mark);
+            if (!run)
+                continue;
+            let range;
+            try {
+                range = this.std.range.textSelectionToRange(this.std.selection.create(TextSelection, {
+                    from: { blockId: mark.targetId, ...run },
+                    to: null,
+                }));
+            }
+            catch {
+                // The inline editor has not rendered the latest text yet: the next
+                // frame draws it.
+                range = null;
+            }
+            if (!range)
+                continue;
+            const rects = getRangeRects(range, null);
+            if (rects.length > 0)
+                drawn.push({ mark, rects });
+        }
+        return drawn;
+    }
     _locate(mark, origin) {
         const edgeless = this._edgeless;
         if (edgeless) {
@@ -180,10 +284,21 @@ export class ThreadMarksWidget extends WidgetComponent {
             return nothing;
         const origin = this.getBoundingClientRect();
         const placed = placeThreadMarks(marks, mark => this._locate(mark, origin));
-        if (placed.length === 0)
+        const ranges = this._ranges(marks);
+        if (placed.length === 0 && ranges.length === 0)
             return nothing;
         const label = translateKey(this.std, ...THREAD_DISCUSS);
-        return repeat(placed, ({ mark }) => `${mark.targetType}:${mark.targetId}`, ({ mark, x, y, anchor }) => html `<icon-button
+        const highlights = ranges.flatMap(({ mark, rects }) => rects.map(rect => html `<div
+            class="thread-range"
+            data-testid="thread-range"
+            data-target-id=${mark.targetId}
+            style=${styleMap({
+            width: `${rect.width}px`,
+            height: `${rect.height}px`,
+            transform: `translate(${rect.left - origin.left}px, ${rect.top - origin.top}px)`,
+        })}
+          ></div>`));
+        return html `${highlights}${repeat(placed, ({ mark }) => `${mark.targetType}:${mark.targetId}`, ({ mark, x, y, anchor }) => html `<icon-button
           class="thread-mark"
           data-testid="thread-mark"
           data-target-type=${mark.targetType}
@@ -206,9 +321,10 @@ export class ThreadMarksWidget extends WidgetComponent {
             openThreadOn(this.std, {
                 targetType: mark.targetType,
                 targetId: mark.targetId,
+                range: mark.range,
             });
         }}
           >${CommentIcon({ width: '16px', height: '16px' })}</icon-button
-        >`);
+        >`)}`;
     }
 }

package/dist/_pkgs/affine-widget-toolbar/utils.d.ts

@@ -1,5 +1,5 @@
 import { type EditorToolbar } from '../affine-components/toolbar/index.js';
-import { ActionPlacement, type ToolbarActions, type ToolbarContext, type ToolbarLayoutStep, type ToolbarPlacement } from '../affine-shared/services/index.js';
+import { ActionPlacement, type ToolbarAction, type ToolbarActions, type ToolbarContext, type ToolbarLayoutStep, type ToolbarPlacement } from '../affine-shared/services/index.js';
 import type { AutoUpdateOptions, ReferenceElement, SideObject } from '@floating-ui/dom';
 export declare const sideMap: Map<string, {
     top: number;
@@ -33,6 +33,7 @@ export declare function combine(actions: ToolbarActions, context: ToolbarContext
     content?: ((cx: ToolbarContext) => import("lit-html").TemplateResult | null) | (import("lit-html").TemplateResult | null);
     run?: (cx: ToolbarContext) => void;
 }[];
+export declare function group(actions: ToolbarAction[]): ToolbarAction[];
 /**
  * How much of the row an entry has given up, decided by {@link ToolbarFitter}
  * and re-applied by every render until the room changes again.

package/dist/_pkgs/affine-widget-toolbar/utils.js

@@ -210,7 +210,7 @@ export function combine(actions, context) {
     });
     return filtered;
 }
-function group(actions) {
+export function group(actions) {
     const grouped = groupBy(actions, a => a.id);
     const paired = toPairs(grouped).map(([_, items]) => {
         if (items.length === 1)
@@ -222,7 +222,10 @@ function group(actions) {
     });
     return paired;
 }
-const merge = (a, b) => mergeWith(a, b, (obj, src) => Array.isArray(obj) ? group(obj.concat(src)) : src);
+// Only a group's `actions` is a list of entries to merge by id; any other
+// array (a `labelWording` tuple) is a value, and grouping it turned the
+// wording into a keyless object the host's i18next choked on.
+const merge = (a, b) => mergeWith(a, b, (obj, src, key) => key === 'actions' && Array.isArray(obj) ? group(obj.concat(src)) : src);
 export function emptyToolbarLayout() {
     return { shrunk: new Set(), collapsed: new Set() };
 }

package/dist/_pkgs/data-view/core/common/properties.js

@@ -147,11 +147,11 @@ let DataViewPropertiesSettingView = (() => {
       width: 4px;
       height: 12px;
       border-radius: 1px;
-      background-color: #efeff0;
+      background-color: var(--affine-border-color);
     }
 
     .property-item:hover .property-item-drag-bar {
-      background-color: #c0bfc1;
+      background-color: var(--affine-placeholder-color);
     }
 
     .property-item-icon {

package/dist/_pkgs/data-view/core/common/property-menu.d.ts

@@ -2,7 +2,7 @@ import { type MenuConfig, type PopupTarget } from '../../../affine-components/co
 import { type Wording } from '../utils/wording.js';
 import type { Property } from '../view-manager/property.js';
 import type { SingleView } from '../view-manager/single-view.js';
-export declare const inputConfig: (property: Property) => (menu: import("../../../affine-components/context-menu/menu.js").Menu) => import("lit-html").TemplateResult<1> | undefined;
+export declare const inputConfig: (property: Property, wording?: Wording) => (menu: import("../../../affine-components/context-menu/menu.js").Menu) => import("lit-html").TemplateResult<1> | undefined;
 export declare const typeConfig: (property: Property, wording?: Wording) => (menu: import("../../../affine-components/context-menu/menu.js").Menu, index: number) => import("lit-html").TemplateResult | undefined;
 /** What a property menu's opener adds around the shared entries. */
 export type PropertyMenuSlots = {
@@ -28,8 +28,8 @@ export type PropertyMenuSlots = {
  * ponytail: "Number Format" stays a table slot (its bar is a table/pc
  * element, behind `enable_number_formatting`, off in Labre), so the
  * properties list does not offer it. Move the bar to core and the entry into
- * this list when the flag ships. The virtual and mobile table headers still
- * spell their own copy of these entries; point them here in a dedicated pass.
+ * this list when the flag ships. The virtual table header still spells its
+ * own copy of these entries; point it here in a dedicated pass.
  */
 export declare const propertyMenuItems: (property: Property, slots?: PropertyMenuSlots) => MenuConfig[];
 export declare const popPropertyMenu: (target: PopupTarget, property: Property, slots?: PropertyMenuSlots) => import("../../../affine-components/context-menu/menu-renderer.js").MenuHandler;

package/dist/_pkgs/data-view/core/common/property-menu.js

@@ -2,10 +2,10 @@ import { menu, popMenu, } from '../../../affine-components/context-menu/index.js
 import { TOOLBAR_DELETE, TOOLBAR_DUPLICATE, } from '../../../affine-shared/services/index.js';
 import { DeleteIcon, DuplicateIcon, ViewIcon } from '@blocksuite/icons/lit';
 import { html } from 'lit/static-html.js';
-import { DATA_VIEW_PROPERTY_HIDE_IN_VIEW, DATA_VIEW_PROPERTY_TYPE, } from '../../translations.js';
+import { DATA_VIEW_PROPERTY_HIDE_IN_VIEW, DATA_VIEW_PROPERTY_NAME, DATA_VIEW_PROPERTY_TYPE, DATA_VIEW_PROPERTY_TYPE_ENTRY, } from '../../translations.js';
 import { renderUniLit } from '../utils/uni-component/index.js';
 import { englishWording } from '../utils/wording.js';
-export const inputConfig = (property) => {
+export const inputConfig = (property, wording = englishWording) => {
     return menu.input({
         prefix: html `
       <div class="affine-database-column-type-menu-icon">
@@ -13,7 +13,7 @@ export const inputConfig = (property) => {
       </div>
     `,
         initialValue: property.name$.value,
-        placeholder: 'Property name',
+        placeholder: wording(DATA_VIEW_PROPERTY_NAME),
         // Persist on blur so the typed name survives the menu being dismissed by
         // a click outside, which never fires the completion path.
         onBlur: text => {
@@ -25,7 +25,7 @@ export const typeConfig = (property, wording = englishWording) => {
     return menu.group({
         items: [
             menu.subMenu({
-                name: 'Type',
+                name: wording(DATA_VIEW_PROPERTY_TYPE_ENTRY),
                 hide: () => !property.typeCanSet,
                 postfix: html ` <div
           class="affine-database-column-type-icon"
@@ -75,13 +75,13 @@ export const typeConfig = (property, wording = englishWording) => {
  * ponytail: "Number Format" stays a table slot (its bar is a table/pc
  * element, behind `enable_number_formatting`, off in Labre), so the
  * properties list does not offer it. Move the bar to core and the entry into
- * this list when the flag ships. The virtual and mobile table headers still
- * spell their own copy of these entries; point them here in a dedicated pass.
+ * this list when the flag ships. The virtual table header still spells its
+ * own copy of these entries; point it here in a dedicated pass.
  */
 export const propertyMenuItems = (property, slots = {}) => {
     const wording = slots.wording ?? englishWording;
     return [
-        inputConfig(property),
+        inputConfig(property, wording),
         typeConfig(property, wording),
         ...(slots.afterType ?? []),
         menu.group({

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

@@ -136,7 +136,10 @@ let Overflow = (() => {
             const moreWidth = moreButton?.getBoundingClientRect().width;
             if (moreWidth !== undefined)
                 this.moreExtraWidth = moreWidth;
-            const widths = Array.from(this.items, item => item.getBoundingClientRect().width);
+            // The natural width: a host may let a drawn item give way (the views
+            // bar clips its pinned tab), and a shrunk width fed back here would make
+            // room that is not there, then take it back, pass after pass.
+            const widths = Array.from(this.items, item => item.scrollWidth);
             const drawn = fitOverflow({
                 widths,
                 container: this.getBoundingClientRect().width,

package/dist/_pkgs/data-view/core/group-by/renderer/base.d.ts

@@ -1,10 +1,13 @@
-import { ShadowlessElement } from '../../../../std/index.js';
+import { type BlockStdScope, ShadowlessElement } from '../../../../std/index.js';
 import type { Group } from '../trait.js';
 import type { GroupRenderProps } from '../types.js';
 declare const BaseGroup_base: typeof ShadowlessElement & import("../../../../global/utils/types.js").Constructor<import("../../../../global/lit/with-disposable.js").DisposableClass>;
 export declare class BaseGroup<JsonValue, Data extends Record<string, unknown>> extends BaseGroup_base implements GroupRenderProps<JsonValue, Data> {
     accessor group: Group<unknown, JsonValue, Data>;
     accessor readonly: boolean;
+    /** Absent outside an editor host: the wordings read English. */
+    accessor std: BlockStdScope;
+    get ungrouped(): string;
     updateData(data: Data): void;
     updateValue(value: JsonValue): void;
     get value(): JsonValue;