@formicoidea/labre-core 0.50.0 → 0.52.0

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/commands.js

@@ -1,6 +1,6 @@
 import { frameCommands } from './_pkgs/affine-block-frame/index.js';
-import { copyLinkCommands, coreCommands, pivotCommands, readingCommands, tagCommands, } from './_pkgs/affine-block-root/index.js';
-import { auditCommands, canvasExportCommands, canvasGridCommands, exportSvgCommands, mapQualityCommands, selectionPaneCommands, userLayerCommands, } from './_pkgs/affine-block-surface/index.js';
+import { copyLinkCommands, coreCommands, pageExportCommands, pivotCommands, readingCommands, tagCommands, } from './_pkgs/affine-block-root/index.js';
+import { auditCommands, canvasDrawioExportCommands, canvasExportCommands, canvasGridCommands, canvasSvgExportCommands, exportSvgCommands, mapQualityCommands, selectionPaneCommands, userLayerCommands, } from './_pkgs/affine-block-surface/index.js';
 import { edgeDirectionCommands } from './_pkgs/affine-gfx-connector/index.js';
 import { shapeCommands } from './_pkgs/affine-gfx-shape/index.js';
 import { toCommandManifestEntry, } from './_pkgs/std/index.js';
@@ -49,6 +49,7 @@ export function getCommands(flags) {
     return buildCommandRegistry([
         ...coreCommands,
         ...copyLinkCommands,
+        ...pageExportCommands,
         ...pivotCommands,
         ...tagCommands,
         ...readingCommands,
@@ -59,6 +60,8 @@ export function getCommands(flags) {
         ...frameCommands,
         ...canvasGridCommands,
         ...canvasExportCommands,
+        ...canvasDrawioExportCommands,
+        ...canvasSvgExportCommands,
         ...userLayerCommands,
         ...edgeDirectionCommands,
         ...(isCapabilityEnabled(flags, 'ai-audit') ? auditCommands : []),

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

@@ -1,5 +1,6 @@
 import { type FramePreview } from './_pkgs/affine-fragment-frame-panel/index.js';
 import type { FrameBlockModel } from './_pkgs/affine-model/index.js';
+import { type TranslationParams } from './_pkgs/affine-shared/services/index.js';
 import { type BlockStdScope, type CommandFile } from './_pkgs/std/index.js';
 /**
  * `@labre/affine/host-panels` — the verbs a host's own panel calls (ADR 0034
@@ -57,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
@@ -121,6 +125,13 @@ export interface ViewAction {
     label: string;
     /** The `com.labre.*` key behind {@link label}, for a host that translates itself. */
     labelKey: string;
+    /**
+     * The `{{name}}` values {@link labelKey} is filled with, for a host that
+     * translates itself — present only on a label that has placeholders (the
+     * framework exports: `{ framework, extension }`, the framework's name
+     * already resolved). {@link label} has them filled in.
+     */
+    labelParams?: TranslationParams;
     /** Stable asset key; `getCommandIcon(std, iconKey)` is the library's icon. */
     iconKey?: string;
     /** Present only on a toggle: the state a check mark shows. */
@@ -143,7 +154,8 @@ export interface ViewActionResult {
 /**
  * The actions proper to the view the editor shows now, in their declared
  * order: the commands registered on the `'view-menu'` surface whose `scope`
- * is this mode (or `'global'`) and whose `when` holds.
+ * is this mode (or `'global'`) and whose `when` holds, and on the canvas
+ * one export per framework format the interchange registry can write.
  *
  * `mode` is the view the host shows; omitted, it is read from
  * `DocModeProvider`, and a provider that does not know (the library default
@@ -157,6 +169,17 @@ export interface ViewActionResult {
  * mode switch: the `std` is rebuilt.
  */
 export declare function getViewActions(std: BlockStdScope, mode?: 'page' | 'edgeless'): ViewAction[];
+/**
+ * The exports of the view the editor shows now — the `'export'` section of
+ * {@link getViewActions}, in the same order: what a host lists in ONE
+ * "Export…" menu. On the page: Markdown and HTML. On the canvas: PNG and PDF
+ * (with an `ExportManager`), draw.io, SVG (with a canvas renderer), one entry
+ * per framework format the registry writes (`canvas.export.<framework>.<format>`,
+ * listed while the board holds that framework's elements), then Markdown and
+ * HTML. Every one resolves {@link runViewAction} with `{ file }` and downloads
+ * nothing.
+ */
+export declare function getViewExports(std: BlockStdScope, mode?: 'page' | 'edgeless'): ViewAction[];
 /**
  * Run one entry of {@link getViewActions} by its id, through `runCommand`'s
  * bottleneck (usage and telemetry recorded once), and wait for it.