@formicoidea/labre-core 0.51.0 → 0.52.0

package/dist/_pkgs/affine-block-surface/index.d.ts

@@ -4,6 +4,7 @@ export { SurfaceElementModel, SurfaceGroupLikeModel, } from './element-model/bas
 export { CanvasElementType } from './element-model/index.js';
 export { CanvasRenderer } from './renderer/canvas-renderer.js';
 export { DomRenderer } from './renderer/dom-renderer.js';
+export { isPainted } from './renderer/paint-predicate.js';
 export { ElementHighlightOverlay } from './renderer/element-highlight-overlay.js';
 export type { ElementRenderer } from './renderer/elements/index.js';
 export * from './renderer/elements/type.js';

package/dist/_pkgs/affine-block-surface/index.js

@@ -6,6 +6,7 @@ export { SurfaceElementModel, SurfaceGroupLikeModel, } from './element-model/bas
 export { CanvasElementType } from './element-model/index.js';
 export { CanvasRenderer } from './renderer/canvas-renderer.js';
 export { DomRenderer } from './renderer/dom-renderer.js';
+export { isPainted } from './renderer/paint-predicate.js';
 export { ElementHighlightOverlay } from './renderer/element-highlight-overlay.js';
 export * from './renderer/elements/type.js';
 export { Overlay, OverlayIdentifier } from './renderer/overlay.js';

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

@@ -38,6 +38,7 @@ export * from './quick-search-service.js';
 export * from './selection-pane-service.js';
 export * from './telemetry-service/index.js';
 export * from './theme-service.js';
+export * from './thread-marks-service.js';
 export * from './title-band-service.js';
 export * from './toolbar-service/index.js';
 export * from './translation-service/index.js';

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

@@ -38,6 +38,7 @@ export * from './quick-search-service.js';
 export * from './selection-pane-service.js';
 export * from './telemetry-service/index.js';
 export * from './theme-service.js';
+export * from './thread-marks-service.js';
 export * from './title-band-service.js';
 export * from './toolbar-service/index.js';
 export * from './translation-service/index.js';

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

@@ -0,0 +1,69 @@
+import type { ExtensionType } from '../../store/index.js';
+import type { ReadonlySignal } from '@preact/signals-core';
+/**
+ * What a mark sits on (ADR 0038): a block, in either view, or a canvas element
+ * no block backs (a shape, a connector, a group, a framework board). The id is
+ * the one the library already gives it: a block id, an element id.
+ */
+export type ThreadMarkTargetType = 'block' | 'element';
+/**
+ * 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,
+ * who wrote it or what it says.
+ *
+ * `count` is how many the host has on that target (a mark at `0` or below is
+ * not drawn); `unread` turns the mark to the accent colour.
+ */
+export interface ThreadMark {
+    targetType: ThreadMarkTargetType;
+    targetId: string;
+    count: number;
+    unread: boolean;
+}
+/**
+ * What the library hands the host when someone clicks a mark or "Discuss"
+ * (`com.labre.thread.discuss`) in a block or element toolbar.
+ *
+ * `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.
+ * 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.
+ */
+export interface ThreadOpenRequest {
+    docId: string;
+    targetType: ThreadMarkTargetType;
+    targetId: string;
+    excerpt: string;
+}
+/** The longest excerpt `openThread` is ever handed, in code points. */
+export declare const THREAD_EXCERPT_MAX = 280;
+/**
+ * The "has a thread" seam (ADR 0038): the host owns the discussions, the
+ * library marks what the host says is marked and asks the host to open one.
+ *
+ * Nothing is written to the document, ever: no prop, no id in the content, no
+ * write on load. That is why it is not `CommentProvider`, which writes
+ * `block.props.comments` and ignores canvas elements.
+ *
+ * Absent or `null`: no mark is drawn and no toolbar offers "Discuss".
+ */
+export interface ThreadMarksService {
+    /**
+     * The marks of the mounted document. Read reactively: a new array
+     * repaints the marks. An id the editor cannot find (a deleted block, an
+     * element of the other view) is ignored, never an error.
+     */
+    marks$: ReadonlySignal<readonly ThreadMark[]>;
+    /** Open (or start) the discussion on a target. Writes nothing here. */
+    openThread(request: ThreadOpenRequest): void;
+}
+export declare const ThreadMarksProvider: import("../../global/di/types.js").ServiceIdentifier<ThreadMarksService> & (<U extends ThreadMarksService = ThreadMarksService>(variant: import("../../global/di/types.js").ServiceVariant) => import("../../global/di/types.js").ServiceIdentifier<U>);
+/**
+ * Host seam: the host's thread marks, or `null` to say there are none.
+ *
+ * `di.override`, like every panel seam, so a later registration wins and
+ * registering twice never throws at boot.
+ */
+export declare function ThreadMarksExtension(service: ThreadMarksService | null): ExtensionType;

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

@@ -0,0 +1,20 @@
+import { createIdentifier } from '../../global/di/index.js';
+/** The longest excerpt `openThread` is ever handed, in code points. */
+export const THREAD_EXCERPT_MAX = 280;
+export const ThreadMarksProvider = createIdentifier('LabreThreadMarks');
+/**
+ * Host seam: the host's thread marks, or `null` to say there are none.
+ *
+ * `di.override`, like every panel seam, so a later registration wins and
+ * registering twice never throws at boot.
+ */
+export function ThreadMarksExtension(service) {
+    return {
+        setup: di => {
+            // `null` rides through the factory on purpose: `getOptional` then
+            // reports the seam as absent, which is the whole "no mark, no button"
+            // story.
+            di.override(ThreadMarksProvider, () => service);
+        },
+    };
+}

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

@@ -0,0 +1 @@
+export declare function effects(): void;

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

@@ -0,0 +1,4 @@
+import { AFFINE_THREAD_MARKS_WIDGET, ThreadMarksWidget } from './widget.js';
+export function effects() {
+    customElements.define(AFFINE_THREAD_MARKS_WIDGET, ThreadMarksWidget);
+}

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

@@ -0,0 +1,19 @@
+import { type ThreadMarkTargetType } 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. */
+export interface ThreadTarget {
+    targetType: ThreadMarkTargetType;
+    targetId: string;
+}
+/**
+ * Collapse whitespace and cut to {@link THREAD_EXCERPT_MAX} code points, the
+ * ellipsis included. Code points, not UTF-16 units, so an emoji is never cut
+ * in half and a host counting characters (Postgres `char_length`) agrees.
+ */
+export declare function truncateThreadExcerpt(raw: string): string;
+/**
+ * The excerpt handed to `openThread` (ADR 0038): what the target says, as a
+ * reader would recognise it, at most {@link THREAD_EXCERPT_MAX} characters.
+ * Read only: nothing is written, nothing is cached.
+ */
+export declare function threadExcerpt(std: BlockStdScope, target: ThreadTarget): string;

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

@@ -0,0 +1,68 @@
+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';
+const ELLIPSIS = '…';
+/**
+ * Collapse whitespace and cut to {@link THREAD_EXCERPT_MAX} code points, the
+ * ellipsis included. Code points, not UTF-16 units, so an emoji is never cut
+ * in half and a host counting characters (Postgres `char_length`) agrees.
+ */
+export function truncateThreadExcerpt(raw) {
+    const text = raw.replace(/\s+/g, ' ').trim();
+    const chars = Array.from(text);
+    if (chars.length <= THREAD_EXCERPT_MAX)
+        return text;
+    return (chars
+        .slice(0, THREAD_EXCERPT_MAX - 1)
+        .join('')
+        .trimEnd() + ELLIPSIS);
+}
+/**
+ * A block's own text, then its descendants' in document order (a note, a
+ * callout, a list item with children), until there is more than an excerpt
+ * can hold.
+ */
+function blockText(model) {
+    const parts = [];
+    let length = 0;
+    const visit = (block) => {
+        if (length > THREAD_EXCERPT_MAX)
+            return;
+        const own = block.text?.toString() ?? '';
+        if (own.trim()) {
+            parts.push(own);
+            length += own.length + 1;
+        }
+        for (const child of block.children)
+            visit(child);
+    };
+    visit(model);
+    return parts.join(' ');
+}
+function rawExcerpt(std, target) {
+    if (target.targetType === 'block') {
+        const model = std.store.getModelById(target.targetId);
+        if (!model)
+            return '';
+        const text = blockText(model);
+        if (text.trim())
+            return text;
+        // A canvas block with no text reads as the selection pane names it: a
+        // frame by its title, an image or a note by its kind.
+        if (model instanceof GfxBlockElementModel) {
+            return selectionPaneRowLabel(std, model);
+        }
+        return selectionPaneTypeLabel(std, model.flavour);
+    }
+    const element = getSurfaceBlock(std.store)?.getElementById(target.targetId);
+    return element ? selectionPaneRowLabel(std, element) : '';
+}
+/**
+ * The excerpt handed to `openThread` (ADR 0038): what the target says, as a
+ * reader would recognise it, at most {@link THREAD_EXCERPT_MAX} characters.
+ * Read only: nothing is written, nothing is cached.
+ */
+export function threadExcerpt(std, target) {
+    return truncateThreadExcerpt(rawExcerpt(std, target));
+}

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

@@ -0,0 +1,5 @@
+export * from './excerpt.js';
+export * from './toolbar.js';
+export * from './translations.js';
+export * from './widget.js';
+export declare const threadMarksWidget: import("../store/index.js").ExtensionType;

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

@@ -0,0 +1,8 @@
+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 './toolbar.js';
+export * from './translations.js';
+export * from './widget.js';
+export const threadMarksWidget = WidgetViewExtension('affine:page', AFFINE_THREAD_MARKS_WIDGET, literal `${unsafeStatic(AFFINE_THREAD_MARKS_WIDGET)}`);

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

@@ -0,0 +1,49 @@
+import { type ToolbarContext } from '../affine-shared/services/index.js';
+import { type BlockStdScope } from '../std/index.js';
+import type { ExtensionType } from '../store/index.js';
+import { type ThreadTarget } from './excerpt.js';
+/**
+ * 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).
+ *
+ * - 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).
+ * - 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.
+ */
+export declare function openThreadOn(std: BlockStdScope, target: ThreadTarget): void;
+export declare const THREAD_DISCUSS_ACTION_ID = "g.thread-discuss";
+/**
+ * "Discuss" in the toolbar of every block and every canvas element (ADR 0038).
+ * Shown only when the host registered the seam and the row speaks for one
+ * target. It is not AFFiNE's `blockCommentToolbarButton`: that one writes the
+ * comment id into the block.
+ */
+export declare const threadDiscussToolbarConfig: {
+    readonly when: (ctx: ToolbarContext) => boolean;
+    readonly actions: [{
+        readonly id: "g.thread-discuss";
+        readonly icon: import("lit-html").TemplateResult<1>;
+        readonly labelWording: import("../affine-shared/services/index.js").ChromeWording;
+        readonly tooltipWording: import("../affine-shared/services/index.js").ChromeWording;
+        readonly run: (ctx: ToolbarContext) => void;
+    }];
+};
+/**
+ * Registered on the two wildcard rows, each under an owner key: the bare
+ * `affine:surface:*` is the root's built-in canvas module, and an owner key
+ * never collides with a bare one. `affine:*` is merged into every row the
+ * toolbar draws; `affine:surface:*` names the canvas rows explicitly, so a
+ * row that stopped merging `affine:*` would still offer it. Where both apply,
+ * the toolbar merges entries by id, so the row shows "Discuss" once. A new
+ * block or framework inherits it by doing nothing.
+ */
+export declare const threadDiscussToolbarExtensions: ExtensionType[];

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

@@ -0,0 +1,108 @@
+import { CommentIcon } from '@blocksuite/icons/lit';
+import { ToolbarModuleExtension, toolbarModuleKey, ThreadMarksProvider, } from '../affine-shared/services/index.js';
+import { BlockFlavourIdentifier, BlockSelection, TextSelection, } from '../std/index.js';
+import { GfxPrimitiveElementModel } from '../std/gfx/index.js';
+import { threadExcerpt } from './excerpt.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']);
+function blockTarget(id, ctx) {
+    if (!id)
+        return null;
+    const model = ctx.store.getModelById(id);
+    if (!model || NOT_A_TARGET.has(model.flavour))
+        return null;
+    return { targetType: 'block', targetId: model.id };
+}
+/**
+ * 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).
+ *
+ * - 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).
+ * - One selected block, or the block a hover toolbar is drawn for.
+ */
+export function threadTargetOf(ctx) {
+    if (ctx.hasSelectedSurfaceModels) {
+        const models = ctx.getSurfaceModels();
+        if (models.length !== 1)
+            return null;
+        const model = models[0];
+        if (!model)
+            return null;
+        return model instanceof GfxPrimitiveElementModel
+            ? { targetType: 'element', targetId: model.id }
+            : 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 (ctx.selection.filter(BlockSelection).length > 1)
+        return null;
+    return blockTarget(ctx.getCurrentModelBy(BlockSelection)?.id, 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.
+ */
+export function openThreadOn(std, target) {
+    const service = std.getOptional(ThreadMarksProvider);
+    if (!service)
+        return;
+    service.openThread({
+        docId: std.store.id,
+        targetType: target.targetType,
+        targetId: target.targetId,
+        excerpt: threadExcerpt(std, target),
+    });
+}
+export const THREAD_DISCUSS_ACTION_ID = 'g.thread-discuss';
+/**
+ * "Discuss" in the toolbar of every block and every canvas element (ADR 0038).
+ * Shown only when the host registered the seam and the row speaks for one
+ * target. It is not AFFiNE's `blockCommentToolbarButton`: that one writes the
+ * comment id into the block.
+ */
+export const threadDiscussToolbarConfig = {
+    when: ctx => Boolean(ctx.std.getOptional(ThreadMarksProvider)) &&
+        threadTargetOf(ctx) !== null,
+    actions: [
+        {
+            id: THREAD_DISCUSS_ACTION_ID,
+            icon: CommentIcon(),
+            labelWording: THREAD_DISCUSS,
+            tooltipWording: THREAD_DISCUSS,
+            run: ctx => {
+                const target = threadTargetOf(ctx);
+                if (target)
+                    openThreadOn(ctx.std, target);
+            },
+        },
+    ],
+};
+/**
+ * Registered on the two wildcard rows, each under an owner key: the bare
+ * `affine:surface:*` is the root's built-in canvas module, and an owner key
+ * never collides with a bare one. `affine:*` is merged into every row the
+ * toolbar draws; `affine:surface:*` names the canvas rows explicitly, so a
+ * row that stopped merging `affine:*` would still offer it. Where both apply,
+ * the toolbar merges entries by id, so the row shows "Discuss" once. A new
+ * block or framework inherits it by doing nothing.
+ */
+export const threadDiscussToolbarExtensions = [
+    ToolbarModuleExtension({
+        id: BlockFlavourIdentifier(toolbarModuleKey('affine:*', 'thread')),
+        config: threadDiscussToolbarConfig,
+    }),
+    ToolbarModuleExtension({
+        id: BlockFlavourIdentifier(toolbarModuleKey('affine:surface:*', 'thread')),
+        config: threadDiscussToolbarConfig,
+    }),
+];

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

@@ -0,0 +1,9 @@
+import type { ChromeWording } from '../affine-shared/services/index.js';
+/**
+ * "Discuss": the toolbar action that asks the host to open the discussion of
+ * a block or a canvas element, and the accessible name of the mark drawn on
+ * what already has one (ADR 0038).
+ */
+export declare const THREAD_DISCUSS: ChromeWording;
+/** Every wording this package declares, in the order it renders them. */
+export declare const THREAD_MARKS_WORDINGS: readonly ChromeWording[];

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

@@ -0,0 +1,11 @@
+/**
+ * "Discuss": the toolbar action that asks the host to open the discussion of
+ * a block or a canvas element, and the accessible name of the mark drawn on
+ * what already has one (ADR 0038).
+ */
+export const THREAD_DISCUSS = [
+    'com.labre.thread.discuss',
+    'Discuss',
+];
+/** Every wording this package declares, in the order it renders them. */
+export const THREAD_MARKS_WORDINGS = [THREAD_DISCUSS];

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

@@ -0,0 +1,12 @@
+import { type ViewExtensionContext, ViewExtensionProvider } from '../affine-ext-loader/index.js';
+/**
+ * The "has a thread" seam's view side (ADR 0038): the marks widget and the
+ * "Discuss" toolbar module, in both views. Registered unconditionally: the
+ * seam, not a flag, decides whether anything shows (no flag gates a
+ * discussion, labre P5).
+ */
+export declare class ThreadMarksViewExtension extends ViewExtensionProvider {
+    name: string;
+    effect(): void;
+    setup(context: ViewExtensionContext): void;
+}

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

@@ -0,0 +1,25 @@
+import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
+import { effects } from './effects.js';
+import { threadMarksWidget } from './index.js';
+import { threadDiscussToolbarExtensions } from './toolbar.js';
+/**
+ * The "has a thread" seam's view side (ADR 0038): the marks widget and the
+ * "Discuss" toolbar module, in both views. Registered unconditionally: the
+ * seam, not a flag, decides whether anything shows (no flag gates a
+ * discussion, labre P5).
+ */
+export class ThreadMarksViewExtension extends ViewExtensionProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'affine-thread-marks-widget';
+    }
+    effect() {
+        super.effect();
+        effects();
+    }
+    setup(context) {
+        super.setup(context);
+        context.register(threadMarksWidget);
+        context.register(threadDiscussToolbarExtensions);
+    }
+}

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

@@ -0,0 +1,51 @@
+import { type ThreadMark } from '../affine-shared/services/index.js';
+import { WidgetComponent } from '../std/index.js';
+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
+ * the page (`side`, in the right gutter, at the block's top), or on the
+ * top-right corner of a canvas model or of a block inside a canvas note
+ * (`corner`, centred on it).
+ */
+export interface ThreadMarkPlace {
+    x: number;
+    y: number;
+    anchor: 'side' | 'corner';
+}
+export interface PlacedThreadMark extends ThreadMarkPlace {
+    mark: ThreadMark;
+}
+/**
+ * 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:
+ *
+ * - 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.
+ */
+export declare function placeThreadMarks(marks: readonly ThreadMark[], locate: (mark: ThreadMark) => ThreadMarkPlace | null): PlacedThreadMark[];
+/**
+ * The "has a thread" marks (ADR 0038), one widget for both views, mounted on
+ * the root like `remote-selection`: in the page view beside each marked block,
+ * 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.
+ *
+ * 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
+ * change. Without the seam it renders nothing.
+ */
+export declare class ThreadMarksWidget extends WidgetComponent {
+    static styles: import("lit").CSSResult;
+    private readonly _refresh;
+    private get _edgeless();
+    connectedCallback(): void;
+    private _locate;
+    render(): unknown;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        [AFFINE_THREAD_MARKS_WIDGET]: ThreadMarksWidget;
+    }
+}

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

@@ -0,0 +1,214 @@
+import { CommentIcon } from '@blocksuite/icons/lit';
+import { isPainted } from '../affine-block-surface/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 { 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 { openThreadOn } from './toolbar.js';
+import { THREAD_DISCUSS } from './translations.js';
+export const AFFINE_THREAD_MARKS_WIDGET = 'affine-thread-marks-widget';
+/**
+ * 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:
+ *
+ * - 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.
+ */
+export function placeThreadMarks(marks, locate) {
+    const merged = new Map();
+    for (const mark of marks) {
+        if (!(mark.count > 0))
+            continue;
+        const key = `${mark.targetType}:${mark.targetId}`;
+        const seen = merged.get(key);
+        merged.set(key, seen
+            ? {
+                ...seen,
+                count: seen.count + mark.count,
+                unread: seen.unread || mark.unread,
+            }
+            : mark);
+    }
+    const placed = [];
+    for (const mark of merged.values()) {
+        const place = locate(mark);
+        if (place)
+            placed.push({ ...place, mark });
+    }
+    return placed;
+}
+/**
+ * The "has a thread" marks (ADR 0038), one widget for both views, mounted on
+ * the root like `remote-selection`: in the page view beside each marked block,
+ * 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.
+ *
+ * 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
+ * change. Without the seam it renders nothing.
+ */
+export class ThreadMarksWidget extends WidgetComponent {
+    constructor() {
+        super(...arguments);
+        this._refresh = requestThrottledConnectedFrame(() => {
+            this.requestUpdate();
+        }, this);
+    }
+    static { this.styles = css `
+    :host {
+      position: absolute;
+      top: 0;
+      left: 0;
+      width: 0;
+      height: 0;
+      overflow: visible;
+      pointer-events: none;
+      z-index: 1;
+    }
+
+    .thread-mark {
+      position: absolute;
+      top: 0;
+      left: 0;
+      gap: 2px;
+      padding: 0 6px 0 4px;
+      border-radius: 12px;
+      border: 1px solid ${unsafeCSS(cssVarV2('layer/insideBorder/border'))};
+      background: ${unsafeCSS(cssVarV2('layer/background/overlayPanel'))};
+      box-shadow: var(--affine-shadow-1);
+      color: ${unsafeCSS(cssVarV2('text/secondary'))};
+      pointer-events: auto;
+    }
+
+    .thread-mark[data-unread] {
+      color: ${unsafeCSS(cssVarV2('text/emphasis'))};
+    }
+
+    @media (pointer: coarse) {
+      .thread-mark::after {
+        content: '';
+        position: absolute;
+        inset: -10px;
+      }
+    }
+  `; }
+    get _edgeless() {
+        return isInsideEdgelessEditor(this.std.host);
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        const { _disposables, std } = this;
+        // The seam is fixed for the editor's life: without it, follow nothing,
+        // so a host that has no threads pays nothing on a pan or a keystroke.
+        if (!std.getOptional(ThreadMarksProvider))
+            return;
+        _disposables.add(std.store.slots.blockUpdated.subscribe(this._refresh));
+        // A block mounts after the widget: a mark on it can only be placed then.
+        _disposables.add(std.view.viewUpdated.subscribe(this._refresh));
+        _disposables.addFromEvent(window, 'resize', this._refresh);
+        // Capture: the page view scrolls in a container, not the window.
+        _disposables.addFromEvent(window, 'scroll', this._refresh, true);
+        const gfx = std.getOptional(GfxControllerIdentifier);
+        if (gfx) {
+            _disposables.add(gfx.viewport.viewportUpdated.subscribe(this._refresh));
+            // The surface may load after the widget connects: follow it.
+            _disposables.add(effect(() => {
+                const surface = gfx.surface$.value;
+                if (!surface)
+                    return;
+                this._refresh();
+                const subscriptions = [
+                    surface.elementAdded.subscribe(this._refresh),
+                    surface.elementRemoved.subscribe(this._refresh),
+                    surface.elementUpdated.subscribe(this._refresh),
+                ];
+                return () => subscriptions.forEach(s => s.unsubscribe());
+            }));
+        }
+    }
+    _locate(mark, origin) {
+        const edgeless = this._edgeless;
+        if (edgeless) {
+            const gfx = this.std.get(GfxControllerIdentifier);
+            const model = gfx.getElementById(mark.targetId);
+            if (model instanceof GfxPrimitiveElementModel ||
+                model instanceof GfxBlockElementModel) {
+                // What this viewer does not see carries no mark (ADR 0031): the
+                // renderers' own predicate for an element, the local hide for a block.
+                const painted = model instanceof GfxPrimitiveElementModel
+                    ? isPainted(model, gfx.localVisibility)
+                    : !gfx.localVisibility.isHidden(model);
+                if (!painted)
+                    return null;
+                const bound = model.elementBound;
+                const [x, y] = gfx.viewport.toViewCoord(bound.maxX, bound.y);
+                return {
+                    x: x + gfx.viewport.left - origin.left,
+                    y: y + gfx.viewport.top - origin.top,
+                    anchor: 'corner',
+                };
+            }
+        }
+        if (mark.targetType !== 'block')
+            return null;
+        const block = this.std.view.getBlock(mark.targetId);
+        if (!block)
+            return null;
+        const rect = block.getBoundingClientRect();
+        if (rect.width === 0 && rect.height === 0)
+            return null;
+        return {
+            x: rect.right - origin.left,
+            y: rect.top - origin.top,
+            anchor: edgeless ? 'corner' : 'side',
+        };
+    }
+    render() {
+        const service = this.std.getOptional(ThreadMarksProvider);
+        if (!service)
+            return nothing;
+        const marks = service.marks$.value;
+        if (marks.length === 0)
+            return nothing;
+        const origin = this.getBoundingClientRect();
+        const placed = placeThreadMarks(marks, mark => this._locate(mark, origin));
+        if (placed.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
+          class="thread-mark"
+          data-testid="thread-mark"
+          data-target-type=${mark.targetType}
+          data-target-id=${mark.targetId}
+          ?data-unread=${mark.unread}
+          width="auto"
+          height="24px"
+          .active=${mark.unread}
+          .text=${String(mark.count)}
+          aria-label=${label}
+          title=${label}
+          style=${styleMap({
+            transform: anchor === 'side'
+                ? `translate(${x + 8}px, ${y}px)`
+                : `translate(${x}px, ${y}px) translate(-50%, -50%)`,
+        })}
+          @pointerdown=${(event) => event.stopPropagation()}
+          @click=${(event) => {
+            event.stopPropagation();
+            openThreadOn(this.std, {
+                targetType: mark.targetType,
+                targetId: mark.targetId,
+            });
+        }}
+          >${CommentIcon({ width: '16px', height: '16px' })}</icon-button
+        >`);
+    }
+}

package/dist/extensions/view.js

@@ -54,6 +54,7 @@ import { PageDraggingAreaViewExtension } from '../_pkgs/affine-widget-page-dragg
 import { RemoteSelectionViewExtension } from '../_pkgs/affine-widget-remote-selection/view.js';
 import { ScrollAnchoringViewExtension } from '../_pkgs/affine-widget-scroll-anchoring/view.js';
 import { SlashMenuViewExtension } from '../_pkgs/affine-widget-slash-menu/view.js';
+import { ThreadMarksViewExtension } from '../_pkgs/affine-widget-thread-marks/view.js';
 import { ToolbarViewExtension } from '../_pkgs/affine-widget-toolbar/view.js';
 import { ViewportOverlayViewExtension } from '../_pkgs/affine-widget-viewport-overlay/view.js';
 import { isBlockEnabled, isCapabilityEnabled, } from '../flags.js';
@@ -158,6 +159,7 @@ export function getInternalViewExtensions(flags) {
         KeyboardToolbarViewExtension,
         LinkedDocViewExtension,
         RemoteSelectionViewExtension,
+        ThreadMarksViewExtension,
         ScrollAnchoringViewExtension,
         SlashMenuViewExtension,
         ToolbarViewExtension,

package/dist/host-panels.d.ts

@@ -58,6 +58,9 @@ export { type SelectionPaneNode, selectionPaneTree, } from './_pkgs/affine-block
 export { frameCommands, type ReorderFramesParams, reorderFramesParams, } from './_pkgs/affine-block-frame/index.js';
 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 ThreadTarget, threadExcerpt, } from './_pkgs/affine-widget-thread-marks/index.js';
 /**
  * The document's frames in presentation order, first slide first — the order
  * `canvas.frame.reorder` writes and the presentation walks. Works in page mode

package/dist/host-panels.js

@@ -70,6 +70,17 @@ export { frameCommands, reorderFramesParams, } from './_pkgs/affine-block-frame/
  * value.
  */
 export { formatPropertyValue, isPropertyValueEmpty, } from './_pkgs/affine-fragment-doc-title/index.js';
+/*
+ * The "has a thread" seam (ADR 0038). The editor marks what the host says
+ * has a discussion and asks the host to open one, with an excerpt it
+ * computes; the host registers `ThreadMarksExtension({ marks$, openThread })`
+ * 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.
+ */
+export { ThreadMarksExtension } from './_pkgs/affine-shared/services/index.js';
+export { threadExcerpt, } from './_pkgs/affine-widget-thread-marks/index.js';
 /**
  * The document's frames in presentation order, first slide first — the order
  * `canvas.frame.reorder` writes and the presentation walks. Works in page mode

package/dist/translations.js

@@ -41,6 +41,7 @@ import { EDGELESS_TOOLBAR_WORDINGS } from './_pkgs/affine-widget-edgeless-toolba
 import { ZOOM_TOOLBAR_WORDINGS } from './_pkgs/affine-widget-edgeless-zoom-toolbar/translations.js';
 import { LINKED_DOC_WORDINGS } from './_pkgs/affine-widget-linked-doc/translations.js';
 import { REMOTE_SELECTION_WORDINGS } from './_pkgs/affine-widget-remote-selection/translations.js';
+import { THREAD_MARKS_WORDINGS } from './_pkgs/affine-widget-thread-marks/translations.js';
 import { SLASH_MENU_WORDINGS } from './_pkgs/affine-widget-slash-menu/translations.js';
 import { TOOLBAR_WIDGET_WORDINGS } from './_pkgs/affine-widget-toolbar/translations.js';
 import { collectTranslationKeys, commandCategoryTranslationEntries, commandTranslationEntries, mergeTranslationEntries, } from './_pkgs/std/index.js';
@@ -309,6 +310,7 @@ const PACKAGE_WORDINGS = [
     ZOOM_TOOLBAR_WORDINGS,
     LINKED_DOC_WORDINGS,
     REMOTE_SELECTION_WORDINGS,
+    THREAD_MARKS_WORDINGS,
     TOOLBAR_WIDGET_WORDINGS,
     COMPONENTS_WORDINGS,
     INLINE_LATEX_WORDINGS,

package/package.json

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