@formicoidea/labre-core 0.52.0 → 0.53.0

package/dist/_pkgs/affine-shared/services/thread-marks-service.d.ts

@@ -6,6 +6,21 @@ import type { ReadonlySignal } from '@preact/signals-core';
  * the one the library already gives it: a block id, an element id.
  */
 export type ThreadMarkTargetType = 'block' | 'element';
+/**
+ * A run of text inside one block (ADR 0038, amendment of 2026-10-15): two
+ * Yjs relative positions on the block's `Y.Text`, each encoded with
+ * `Y.encodeRelativePosition` then base64. Opaque to the host, which stores
+ * and returns the two strings as they are; only the library reads them.
+ *
+ * A relative position follows the text through local and remote edits and is
+ * computed by reading, never by writing: nothing lands in the document. When
+ * the text it points at is gone, the range no longer resolves and the library
+ * falls back to the block.
+ */
+export interface ThreadTextRange {
+    start: string;
+    end: string;
+}
 /**
  * One marked target of the mounted document, as the host computes it. Ids and
  * counters only: the library never learns what the host attaches to a target,
@@ -19,6 +34,14 @@ export interface ThreadMark {
     targetId: string;
     count: number;
     unread: boolean;
+    /**
+     * The text the discussion is anchored to, for a `block` target (ignored on
+     * an `element`). Optional (ADR 0038 amendment): without it only the
+     * block's mark is drawn; with it the run is also highlighted in the page
+     * view, and a click on it opens the discussion. A range that no longer
+     * resolves is not drawn, and the block's mark stays.
+     */
+    range?: ThreadTextRange;
 }
 /**
  * What the library hands the host when someone clicks a mark or "Discuss"
@@ -26,7 +49,8 @@ export interface ThreadMark {
  *
  * `excerpt` is computed here because the library knows the content: the
  * block's text (its descendants' for a container such as a note), a canvas
- * element's label as the selection pane reads it, else the kind of target.
+ * element's label as the selection pane reads it, else the kind of target;
+ * for a text range, the text it covers.
  * Whitespace is collapsed and it is cut to at most 280 characters, an
  * ellipsis included (`THREAD_EXCERPT_MAX`). It is a snapshot for the host to
  * store beside its anchor; the library keeps no copy.
@@ -36,6 +60,13 @@ export interface ThreadOpenRequest {
     targetType: ThreadMarkTargetType;
     targetId: string;
     excerpt: string;
+    /**
+     * Set when the discussion starts on a text selection, or on a highlighted
+     * range (ADR 0038 amendment): the block is still `targetId` and
+     * `excerpt` is the selected text itself. Absent for a whole block or an
+     * element.
+     */
+    range?: ThreadTextRange;
 }
 /** The longest excerpt `openThread` is ever handed, in code points. */
 export declare const THREAD_EXCERPT_MAX = 280;

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

@@ -1,9 +1,13 @@
-import { type ThreadMarkTargetType } from '../affine-shared/services/index.js';
+import { type ThreadMarkTargetType, type ThreadTextRange } from '../affine-shared/services/index.js';
 import type { BlockStdScope } from '../std/index.js';
-/** A block or a canvas element, by the id the library gave it. */
+/**
+ * A block or a canvas element, by the id the library gave it, and for a
+ * block optionally a run of its text (ADR 0038, amendment of 2026-10-15).
+ */
 export interface ThreadTarget {
     targetType: ThreadMarkTargetType;
     targetId: string;
+    range?: ThreadTextRange;
 }
 /**
  * Collapse whitespace and cut to {@link THREAD_EXCERPT_MAX} code points, the

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

@@ -2,6 +2,7 @@ import { getSurfaceBlock } from '../affine-block-surface/index.js';
 import { THREAD_EXCERPT_MAX, } from '../affine-shared/services/index.js';
 import { selectionPaneRowLabel, selectionPaneTypeLabel, } from '../affine-widget-edgeless-toolbar/index.js';
 import { GfxBlockElementModel } from '../std/gfx/index.js';
+import { resolveThreadRange } from './text-range.js';
 const ELLIPSIS = '…';
 /**
  * Collapse whitespace and cut to {@link THREAD_EXCERPT_MAX} code points, the
@@ -45,6 +46,13 @@ function rawExcerpt(std, target) {
         const model = std.store.getModelById(target.targetId);
         if (!model)
             return '';
+        // A run of text reads as itself: the quote a reader selected. A range
+        // that no longer resolves falls back to the block, like its mark.
+        const yText = model.text?.yText;
+        const run = target.range && yText ? resolveThreadRange(yText, target.range) : null;
+        if (yText && run) {
+            return yText.toString().slice(run.index, run.index + run.length);
+        }
         const text = blockText(model);
         if (text.trim())
             return text;

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

@@ -1,4 +1,5 @@
 export * from './excerpt.js';
+export * from './text-range.js';
 export * from './toolbar.js';
 export * from './translations.js';
 export * from './widget.js';

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

@@ -2,6 +2,7 @@ import { WidgetViewExtension } from '../std/index.js';
 import { literal, unsafeStatic } from 'lit/static-html.js';
 import { AFFINE_THREAD_MARKS_WIDGET } from './widget.js';
 export * from './excerpt.js';
+export * from './text-range.js';
 export * from './toolbar.js';
 export * from './translations.js';
 export * from './widget.js';

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:
@@ -31,6 +35,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 +54,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,26 @@
 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);
+}
 /**
  * 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:
@@ -50,6 +59,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 +79,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 +116,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 +154,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 +178,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 +280,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}
@@ -209,6 +320,6 @@ export class ThreadMarksWidget extends WidgetComponent {
             });
         }}
           >${CommentIcon({ width: '16px', height: '16px' })}</icon-button
-        >`);
+        >`)}`;
     }
 }

package/dist/host-panels.d.ts

@@ -59,7 +59,7 @@ export { frameCommands, type ReorderFramesParams, reorderFramesParams, } from '.
 export { formatPropertyValue, isPropertyValueEmpty, } from './_pkgs/affine-fragment-doc-title/index.js';
 export type { PropertiesPanelRequest, PropertiesPanelService, TitleBandNotShownPage, TitleBandProperty, TitleBandService, TitleBandSheetState, } from './_pkgs/affine-shared/services/index.js';
 export { ThreadMarksExtension } from './_pkgs/affine-shared/services/index.js';
-export type { ThreadMark, ThreadMarksService, ThreadMarkTargetType, ThreadOpenRequest, } from './_pkgs/affine-shared/services/index.js';
+export type { ThreadMark, ThreadMarksService, ThreadMarkTargetType, ThreadOpenRequest, ThreadTextRange, } from './_pkgs/affine-shared/services/index.js';
 export { type ThreadTarget, threadExcerpt, } from './_pkgs/affine-widget-thread-marks/index.js';
 /**
  * The document's frames in presentation order, first slide first — the order

package/dist/host-panels.js

@@ -77,7 +77,8 @@ export { formatPropertyValue, isPropertyValueEmpty, } from './_pkgs/affine-fragm
  * among its editor extensions. Gathered here with its types so a host's
  * discussion module imports one entry; `threadExcerpt` is the excerpt the
  * editor hands `openThread`, for a host that starts a discussion from its
- * own UI.
+ * own UI. `ThreadTextRange` (amendment of 2026-10-15) is the opaque text
+ * anchor a request may carry and a mark may hand back.
  */
 export { ThreadMarksExtension } from './_pkgs/affine-shared/services/index.js';
 export { threadExcerpt, } from './_pkgs/affine-widget-thread-marks/index.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-core",
   "description": "Labre editor — the full BlockSuite-derived editor as one package.",
-  "version": "0.52.0",
+  "version": "0.53.0",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",