@formicoidea/labre-core 0.42.0 → 0.43.1

package/dist/_pkgs/affine-block-root/commands/copy-link-commands.js

@@ -0,0 +1,155 @@
+/**
+ * `doc.copyLink` — put the current document's URL on the clipboard, anchored on
+ * whatever is selected.
+ *
+ * The library does not know what a document's address looks like: routing is
+ * the host's, and the seam for it — `GenerateDocUrlProvider` — has shipped
+ * since AFFiNE with **no consumer at all** on either side. This command is the
+ * consumer, and the counterpart of the paste path that already turns a host URL
+ * back into an inline reference (`ParseDocUrlProvider`, read by
+ * `adapters/middlewares/paste.ts`). Copy here, paste there, and the round trip
+ * closes without the library ever spelling a URL.
+ *
+ * It lives in the registry rather than in the host chrome because ADR 0008
+ * makes a command the single source for its keystroke, its palette entry and
+ * its Settings › Shortcuts row. A host-side button would be reachable from none
+ * of the three, and would not fire while the focus is inside the editor.
+ *
+ * Default chord `Mod-Alt-l` (product decision, PR #401 — the gesture users
+ * already know from Notion). NOT `Mod-l`: `Ctrl+L` / `Cmd+L` is the browser's
+ * address bar and never reaches the page, so a default on it would silently do
+ * nothing on the web. `scope: 'global'` so it fires in page mode and on the
+ * canvas alike.
+ *
+ * **`navigator.clipboard` can be absent, not merely refusing.** The Clipboard
+ * API is a secure-context feature: over plain `http://` on anything but
+ * `localhost`, and in a cross-origin iframe with no `clipboard-write`
+ * permission, the `clipboard` property is `undefined` altogether — so reaching
+ * for `writeText` throws a synchronous `TypeError` out of `run` rather than
+ * returning a promise to reject. That is checked before anything is announced:
+ * no copy, no toast, no telemetry, one `console.error` saying why. Announcing a
+ * copy that never happened is the one failure mode worse than doing nothing.
+ *
+ * A clipboard that EXISTS and then rejects (permission denied at the moment of
+ * writing) is a different case and is left as it is: the promise is caught, and
+ * the toast has already been shown — the same optimistic behaviour the inline
+ * link toolbar has always had, kept deliberately so the two copy-a-link
+ * gestures do not answer differently.
+ */
+import { DocModeProvider, GenerateDocUrlProvider, NotificationProvider, TOAST_LINK_COPIED, TelemetryProvider, translateKey, } from '../../affine-shared/services/index.js';
+import { BlockSelection, SurfaceSelection, } from '../../std/index.js';
+/**
+ * Where the link points INSIDE the document, read off the live selection.
+ *
+ * `mode` is not decoration: the reader of these params
+ * (`extractSearchParams`, `adapters/middlewares/paste.ts`) only looks at
+ * `blockIds` / `elementIds` once it has found a valid `mode` in the query
+ * string, so an anchor emitted without one is dropped on the way back in. When
+ * no `DocModeProvider` is registered the anchor is therefore left out entirely
+ * rather than written in a form nothing can read — the link still opens the
+ * document, which is the honest degradation.
+ *
+ * Canvas before prose: a surface selection and a block selection can coexist in
+ * the store (selecting a note on the canvas leaves the page's own selection
+ * behind), and on the canvas the element IS what the user pointed at.
+ *
+ * A caret is deliberately NOT an anchor. `TextSelection` exists the whole time
+ * somebody is typing, so reading it would mean every copy silently points at a
+ * paragraph instead of the document — the opposite of what an unsolicited
+ * keystroke should do.
+ */
+function anchorOf(std) {
+    const mode = std.getOptional(DocModeProvider)?.getEditorMode();
+    if (!mode)
+        return undefined;
+    const elementIds = std.selection
+        .filter(SurfaceSelection)
+        .flatMap(selection => selection.elements);
+    if (elementIds.length)
+        return { mode, elementIds };
+    const blockIds = std.selection
+        .filter(BlockSelection)
+        .map(selection => selection.blockId);
+    if (blockIds.length)
+        return { mode, blockIds };
+    return { mode };
+}
+/**
+ * The seam, or nothing. Read through `getOptional` like every other host seam,
+ * and reported as UNAVAILABLE rather than as a silent no-op: a palette entry
+ * that copies nothing and a shortcut that does nothing are both worse than an
+ * entry that is not there (`docs/integrate/04-host-seams.md`, step 2 of "How to
+ * add a seam").
+ */
+const canCopyDocLink = (std) => !!std.getOptional(GenerateDocUrlProvider);
+const copyDocLink = {
+    id: 'doc.copyLink',
+    owner: 'core',
+    kind: 'action',
+    // `com.labre.command.*` like the other keyless-by-intent core commands, not
+    // `com.labre.keyboardShortcuts.*`: this one is a capability that happens to
+    // carry a default chord, and the shortcut namespace would file it as a
+    // keymap row for a translator.
+    labelKey: 'com.labre.command.doc.copy-link',
+    labelFallback: 'Copy document link',
+    descriptionKey: 'com.labre.command.doc.copy-link.description',
+    descriptionFallback: 'Copy a link to this document, anchored on the selection, so it can be ' +
+        'pasted into a text as a reference.',
+    keywords: ['link', 'url', 'share', 'reference'],
+    surfaces: ['palette', 'agent'],
+    scope: 'global',
+    defaultKeys: { mac: ['Mod-Alt-l'], other: ['Mod-Alt-l'] },
+    // Copying an address is legitimate in a read-only document, so nothing here
+    // is gated on `editable`; the only precondition is the seam, which is not
+    // expressible in the serializable union and therefore rides on `when`.
+    availability: 'always',
+    when: canCopyDocLink,
+    run: (std, invocation) => {
+        // The load-bearing half of the gate: `runCommand` consults neither
+        // `availability` nor `when`, so the palette and the agent reach `run`
+        // directly — the same arbitration `tag.set` records.
+        const generator = std.getOptional(GenerateDocUrlProvider);
+        if (!generator)
+            return;
+        const params = anchorOf(std);
+        const url = generator.generateDocUrl(std.store.id, params);
+        // A host may decline — an unsaved document, one it does not route. Nothing
+        // is copied and nothing is announced.
+        if (!url)
+            return;
+        // Not a promise rejection: outside a secure context the property itself is
+        // `undefined`, so this would be a synchronous `TypeError` thrown out of
+        // `run` — and `runCommand` only catches what a returned promise rejects
+        // with, so it would surface as an unhandled error taking the keystroke
+        // down with it. Nothing announced, one line saying why.
+        if (!navigator.clipboard) {
+            console.error('doc.copyLink: no clipboard API — a secure context (https, or ' +
+                'localhost) is required, and an iframe needs `clipboard-write`.');
+            return;
+        }
+        navigator.clipboard.writeText(url).catch(console.error);
+        std
+            .getOptional(NotificationProvider)
+            ?.toast(translateKey(std, ...TOAST_LINK_COPIED));
+        // Self-emitted rather than declared through `CommandDescriptor.telemetry`:
+        // that field routes the bottleneck's reporter onto the three framework
+        // CREATION events and requires a `FrameworkId`, and this command creates
+        // nothing and belongs to no framework. `CopiedLink` is the event the two
+        // other copy-a-link sites already emit (the inline link toolbar, the
+        // iframe embed toolbar); reusing it keeps "links copied" one series.
+        // Ids never cross: the document id and the anchored ids stay here.
+        std.getOptional(TelemetryProvider)?.track('CopiedLink', {
+            page: params?.mode === 'edgeless' ? 'whiteboard editor' : 'doc editor',
+            segment: 'editor',
+            module: invocation.surface,
+            control: invocation.source,
+            type: params?.elementIds?.length
+                ? 'element'
+                : params?.blockIds?.length
+                    ? 'block'
+                    : 'document',
+            result: 'success',
+        });
+    },
+};
+export const copyLinkCommands = [copyDocLink];

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

@@ -1,5 +1,6 @@
 export * from './adapters/index.js';
 export * from './clipboard/index.js';
+export * from './commands/copy-link-commands.js';
 export * from './commands/pivot-commands.js';
 export * from './commands/reading-commands.js';
 export * from './commands/tag-commands.js';

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

@@ -1,5 +1,6 @@
 export * from './adapters/index.js';
 export * from './clipboard/index.js';
+export * from './commands/copy-link-commands.js';
 export * from './commands/pivot-commands.js';
 export * from './commands/reading-commands.js';
 export * from './commands/tag-commands.js';

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

@@ -4,6 +4,7 @@ import { ToolbarModuleExtension, ViewportElementExtension, } from '../affine-sha
 import { BlockFlavourIdentifier, BlockViewExtension, FlavourExtension, CommandExtension, ShortcutKeymapExtension, } from '../std/index.js';
 import { literal } from 'lit/static-html.js';
 import { PageClipboard, ReadOnlyClipboard } from './clipboard/index.js';
+import { copyLinkCommands } from './commands/copy-link-commands.js';
 import { pivotCommands } from './commands/pivot-commands.js';
 import { readingCommands } from './commands/reading-commands.js';
 import { tagCommands } from './commands/tag-commands.js';
@@ -70,6 +71,7 @@ export class RootViewExtension extends ViewExtensionProvider {
                 ...pivotCommands,
                 ...tagCommands,
                 ...readingCommands,
+                ...copyLinkCommands,
             ]),
             ShortcutKeymapExtension('global'),
             ToolbarModuleExtension({

package/dist/_pkgs/affine-block-surface/extensions/interchange-import.js

@@ -276,6 +276,15 @@ const IMPORT_DONE_KEY = 'com.labre.interchange.import.done';
 const IMPORT_DONE_FALLBACK = 'file imported';
 const IMPORT_FAILED_KEY = 'com.labre.interchange.import.failed';
 const IMPORT_FAILED_FALLBACK = 'This file could not be imported';
+/**
+ * What an imported sheet is called when neither the file nor the source
+ * document names it — resolved HERE, at the creation site, because that is
+ * where `std` is (ADR 0023 §3: a seed is translated by whoever writes it, and
+ * a pure reader never can). The readers keep the same English text as their
+ * own last-resort default, so a headless call still produces a named sheet.
+ */
+const IMPORT_DEFAULT_NAME_KEY = 'com.labre.interchange.import.default-name';
+const IMPORT_DEFAULT_NAME_FALLBACK = 'Imported diagram';
 /**
  * The document went read-only between the moment the file was accepted and the
  * moment its board was about to be written — see the second guard in
@@ -531,7 +540,10 @@ export async function importInterchangeFile(std, capability, file, options = {})
         // inflated" and "this is not a BPMN document" are the same event to the
         // person who picked the file, and they take the same notification.
         const source = options.decode ? await options.decode(text, file) : text;
-        result = capability.run(source, { name: file.name });
+        result = capability.run(source, {
+            name: file.name.trim() ||
+                translateKey(std, IMPORT_DEFAULT_NAME_KEY, IMPORT_DEFAULT_NAME_FALLBACK),
+        });
     }
     catch (error) {
         // `InterchangeImportError` checked FIRST: a reader that throws it declared

package/dist/_pkgs/affine-block-surface/extensions/legend.d.ts

@@ -128,6 +128,14 @@ export declare function legendFromCommands(std: BlockStdScope, owner: CommandOwn
  * Build the legend of what is drawn inside `board` and drop it bottom-left of
  * it, grouped and selected. THE gesture the shared toolbar button runs.
  *
+ * REPLACES the board's own legend if it already has one, rather than stacking a
+ * second box on the first (issue #391): the placement is derived from the board
+ * alone, so every press landed at the same pixel and the copies were invisible
+ * — one box to the eye, N groups and N × ~15 elements in the document. The
+ * second press is therefore a REFRESH, which is what a user who has just added
+ * three artefacts is asking for; the cost is that hand retouching of the box is
+ * lost, and one undo brings it back (see {@link legendsOn} and ADR 0026).
+ *
  * Returns the group id, or `undefined` when there is no surface to draw on.
  */
 export declare function createBoardLegend(std: BlockStdScope, board: {

package/dist/_pkgs/affine-block-surface/extensions/legend.js

@@ -276,13 +276,42 @@ const INSET_BOTTOM = 56;
  * It is also why a legend never lists itself: nothing it draws carries a role.
  */
 export function rolesInBound(gfx, bound) {
+    return rolesOf(gfx.getElementsByBound(bound, { type: 'canvas' }));
+}
+/** {@link rolesInBound} over a perimeter already scanned. */
+function rolesOf(elements) {
     const present = new Set();
-    for (const el of gfx.getElementsByBound(bound, { type: 'canvas' })) {
+    for (const el of elements) {
         if (el.role !== undefined)
             present.add(el.role);
     }
     return present;
 }
+/**
+ * The legends ALREADY drawn on this board — what turns the button's second
+ * press into "regenerate" rather than a second stacked box (issue #391).
+ *
+ * The scan already sees them: a generated legend's wrapper carries
+ * {@link LEGEND_ROLE}, so recognising one costs a filter over the elements the
+ * perimeter pass returned, and nothing in the document format changes.
+ *
+ * CONTAINMENT rather than intersection, which is what `getElementsByBound`
+ * answers with: two boards drawn edge to edge each overlap the other's corner,
+ * and the press on one would eat the other's box. A legend is inset well inside
+ * the board it documents, so asking for the whole box costs nothing here and
+ * keeps the neighbour's.
+ *
+ * Two boxes it deliberately does not find: one the author dragged off the board
+ * (it is no longer this board's legend, and a fresh one is drawn), and one
+ * generated before {@link LEGEND_ROLE} shipped in 0.42 — that box carries no
+ * role, so the old stacking survives on those documents. Nothing is backfilled,
+ * as ever (ADR 0026).
+ */
+function legendsOn(elements, bound) {
+    return elements.filter(el => el.type === 'group' &&
+        el.role === LEGEND_ROLE &&
+        bound.contains(el.elementBound));
+}
 /** Every registered vocabulary, merged — a role id is namespaced, so it is flat. */
 function vocabularyOf(std) {
     const merged = {};
@@ -410,15 +439,32 @@ function boardLegendBox(std, owner) {
  * Build the legend of what is drawn inside `board` and drop it bottom-left of
  * it, grouped and selected. THE gesture the shared toolbar button runs.
  *
+ * REPLACES the board's own legend if it already has one, rather than stacking a
+ * second box on the first (issue #391): the placement is derived from the board
+ * alone, so every press landed at the same pixel and the copies were invisible
+ * — one box to the eye, N groups and N × ~15 elements in the document. The
+ * second press is therefore a REFRESH, which is what a user who has just added
+ * three artefacts is asking for; the cost is that hand retouching of the box is
+ * lost, and one undo brings it back (see {@link legendsOn} and ADR 0026).
+ *
  * Returns the group id, or `undefined` when there is no surface to draw on.
  */
 export function createBoardLegend(std, board, owner) {
     const gfx = std.get(GfxControllerIdentifier);
     const surface = gfx.surface;
-    if (!surface)
+    // The button already refuses on a readonly document; said again here because
+    // this gesture now DELETES before it draws, and a refused delete followed by
+    // a throwing draw is the one order that could lose a box.
+    if (!surface || std.store.readonly)
         return undefined;
     const bound = Bound.deserialize(board.xywh);
-    const present = rolesInBound(gfx, bound);
+    const inside = gfx.getElementsByBound(bound, { type: 'canvas' });
+    const previous = legendsOn(inside, bound);
+    // The box about to be drawn describes the DRAWING, never the box it replaces:
+    // the outgoing wrapper is dropped from the scan so `core:legend` is not among
+    // the roles the rows are derived from. Its glyphs carry no role at all.
+    const outgoing = new Set(previous);
+    const present = rolesOf(inside.filter(el => !outgoing.has(el)));
     const sections = legendFromCommands(std, owner, present);
     const box = boardLegendBox(std, owner);
     const layout = {
@@ -432,7 +478,17 @@ export function createBoardLegend(std, board, owner) {
     const extras = box?.extras?.({ std, board, present }) ?? [];
     const title = translateKey(std, ...(box?.titleWording ?? BOARD_LEGEND_TITLE));
     const { height } = measureLegend(sections, layout, extras);
+    // ONE checkpoint, in front of BOTH halves of the replacement: a single
+    // Ctrl+Z after a regenerate puts the previous box back whole, rather than
+    // leaving the board with no legend at all.
     std.store.captureSync();
+    if (previous.length > 0) {
+        const crud = std.get(EdgelessCRUDIdentifier);
+        // Cascades into the group's children (`crud-extension.ts`), so one call
+        // per legend takes the whole box away.
+        for (const legend of previous)
+            crud.removeElement(legend.id);
+    }
     const id = addLegend(surface, std, bound.x + INSET_X, bound.y + bound.h - INSET_BOTTOM - height, { title, sections, extras, ...layout });
     gfx.selection.set({ elements: [id], editing: false });
     return id;

package/dist/_pkgs/affine-block-surface/extensions/morph-toolbar.js

@@ -229,6 +229,10 @@ export function morphToolbarConfig(spec) {
                     return renderPickerMenu({
                         testId: 'element-morph',
                         label: wording(ctx, spec.label),
+                        // The shell's accessible name stays the stable ENGLISH
+                        // identifier: composing it from the translated label produced
+                        // half a sentence per language (#390).
+                        menuAria: `${spec.label.fallback.toLowerCase()}-menu`,
                         // The current kind's own icon on the closed button, exactly as the
                         // shape picker shows the current shape: the dropdown reads as a
                         // statement about the selection before it is opened.

package/dist/_pkgs/affine-block-surface/extensions/svg-sketch-translations.d.ts

@@ -39,6 +39,9 @@ export declare const SVG_SKETCH_SKIPPED: ChromeWording;
 export declare const SVG_SKETCH_REMOVED: ChromeWording;
 export declare const SVG_SKETCH_REMOVED_ATTRIBUTE: ChromeWording;
 export declare const SVG_SKETCH_EMPTY: ChromeWording;
+export declare const SVG_SKETCH_ERROR_MALFORMED_XML: ChromeWording;
+export declare const SVG_SKETCH_ERROR_NOT_SVG: ChromeWording;
+export declare const SVG_SKETCH_ERROR_SANITIZED_AWAY: ChromeWording;
 /**
  * Every wording declared above, in declaration order — joined into
  * `PACKAGE_WORDINGS` (`packages/affine/all/src/translations.ts`) alongside

package/dist/_pkgs/affine-block-surface/extensions/svg-sketch-translations.js

@@ -92,6 +92,26 @@ export const SVG_SKETCH_EMPTY = [
     'com.labre.interchange.svg.empty',
     'No shape or text was recognised in this SVG, so nothing was drawn.',
 ];
+/* ── The reader's own refusals (#390) ─────────────────────────────────────
+ *
+ * Thrown via `InterchangeImportError` and rendered by `runInterchangeImport`
+ * in the failure notification — the same shape as `BPMN_IMPORT_ERRORS`
+ * (`gfx/bpmn/src/import.ts`), and keyed for the same reason: these three
+ * sentences were written for a user, not for a console, and were reaching a
+ * French host in English because a bare `new Error(…)` carries no key.
+ */
+export const SVG_SKETCH_ERROR_MALFORMED_XML = [
+    'com.labre.interchange.svg.error.malformed-xml',
+    'This file is not well-formed XML, so no drawing can be read out of it: {{detail}}',
+];
+export const SVG_SKETCH_ERROR_NOT_SVG = [
+    'com.labre.interchange.svg.error.not-svg',
+    'An SVG opens on <svg>; this one opens on <{{tag}}>.',
+];
+export const SVG_SKETCH_ERROR_SANITIZED_AWAY = [
+    'com.labre.interchange.svg.error.sanitized-away',
+    'Nothing survived sanitizing this SVG, so there is no drawing to read.',
+];
 /**
  * Every wording declared above, in declaration order — joined into
  * `PACKAGE_WORDINGS` (`packages/affine/all/src/translations.ts`) alongside
@@ -117,4 +137,7 @@ export const SVG_SKETCH_WORDINGS = [
     SVG_SKETCH_REMOVED,
     SVG_SKETCH_REMOVED_ATTRIBUTE,
     SVG_SKETCH_EMPTY,
+    SVG_SKETCH_ERROR_MALFORMED_XML,
+    SVG_SKETCH_ERROR_NOT_SVG,
+    SVG_SKETCH_ERROR_SANITIZED_AWAY,
 ];

package/dist/_pkgs/affine-block-surface/extensions/svg-sketch.d.ts

@@ -1,4 +1,4 @@
-import type { InterchangeImportContext, InterchangeImportResult } from './interchange.js';
+import { type InterchangeImportContext, type InterchangeImportResult } from './interchange.js';
 /**
  * **SVG → a canvas sketch.** The platform's VISUAL-tier importer, shared by
  * every framework that declares it (`docs/adr/0012`, P2).

package/dist/_pkgs/affine-block-surface/extensions/svg-sketch.js

@@ -1,6 +1,7 @@
 import { ShapeStyle, ShapeType, StrokeStyle, TextAlign, } from '../../affine-model/index.js';
 import DOMPurify from 'dompurify';
-import { SVG_SKETCH_CURRENT_COLOR, SVG_SKETCH_CURVE, SVG_SKETCH_EMPTY, SVG_SKETCH_EMPTY_BOX, SVG_SKETCH_EMPTY_TEXT, SVG_SKETCH_FLAT_POLYGON, SVG_SKETCH_FONT_UNIT, SVG_SKETCH_HIDDEN_DISPLAY, SVG_SKETCH_HIDDEN_VISIBILITY, SVG_SKETCH_LONE_POINT, SVG_SKETCH_OPACITY, SVG_SKETCH_PAINT_SERVER, SVG_SKETCH_PERCENT_RADIUS, SVG_SKETCH_REMOVED, SVG_SKETCH_REMOVED_ATTRIBUTE, SVG_SKETCH_SKIPPED, SVG_SKETCH_SWITCH, SVG_SKETCH_TRANSFORM, } from './svg-sketch-translations.js';
+import { InterchangeImportError, } from './interchange.js';
+import { SVG_SKETCH_CURRENT_COLOR, SVG_SKETCH_CURVE, SVG_SKETCH_EMPTY, SVG_SKETCH_EMPTY_BOX, SVG_SKETCH_EMPTY_TEXT, SVG_SKETCH_ERROR_MALFORMED_XML, SVG_SKETCH_ERROR_NOT_SVG, SVG_SKETCH_ERROR_SANITIZED_AWAY, SVG_SKETCH_FLAT_POLYGON, SVG_SKETCH_FONT_UNIT, SVG_SKETCH_HIDDEN_DISPLAY, SVG_SKETCH_HIDDEN_VISIBILITY, SVG_SKETCH_LONE_POINT, SVG_SKETCH_OPACITY, SVG_SKETCH_PAINT_SERVER, SVG_SKETCH_PERCENT_RADIUS, SVG_SKETCH_REMOVED, SVG_SKETCH_REMOVED_ATTRIBUTE, SVG_SKETCH_SKIPPED, SVG_SKETCH_SWITCH, SVG_SKETCH_TRANSFORM, } from './svg-sketch-translations.js';
 /**
  * **SVG → a canvas sketch.** The platform's VISUAL-tier importer, shared by
  * every framework that declares it (`docs/adr/0012`, P2).
@@ -879,10 +880,15 @@ function parseSvgRoot(source, notes) {
             .split('\n')
             .map(line => line.trim())
             .filter(line => line.length > 0);
-        throw new Error(`This file is not well-formed XML, so no drawing can be read out of it: ${summary.slice(0, 200)}`);
+        const detail = summary.slice(0, 200);
+        throw new InterchangeImportError(`This file is not well-formed XML, so no drawing can be read out of it: ${detail}`, {
+            messageKey: SVG_SKETCH_ERROR_MALFORMED_XML[0],
+            messageParams: { detail },
+        });
     }
     if (nameOf(doc.documentElement) !== 'svg') {
-        throw new Error(`An SVG opens on <svg>; this one opens on <${doc.documentElement?.localName ?? 'nothing'}>.`);
+        const tag = doc.documentElement?.localName ?? 'nothing';
+        throw new InterchangeImportError(`An SVG opens on <svg>; this one opens on <${tag}>.`, { messageKey: SVG_SKETCH_ERROR_NOT_SVG[0], messageParams: { tag } });
     }
     const clean = DOMPurify.sanitize(source, {
         USE_PROFILES: { svg: true },
@@ -923,7 +929,9 @@ function parseSvgRoot(source, notes) {
     // overload, which answers an `HTMLElement` — the sanitized body wrapper.
     const root = childElements(clean).find(child => nameOf(child) === 'svg');
     if (!root) {
-        throw new Error('Nothing survived sanitizing this SVG, so there is no drawing to read.');
+        throw new InterchangeImportError(SVG_SKETCH_ERROR_SANITIZED_AWAY[1], {
+            messageKey: SVG_SKETCH_ERROR_SANITIZED_AWAY[0],
+        });
     }
     return root;
 }

package/dist/_pkgs/affine-block-surface/framework-background/background-view.js

@@ -105,7 +105,7 @@ export class FrameworkBackgroundView extends GfxElementModelView {
             font: '14px Inter, sans-serif',
             color: 'var(--affine-text-primary-color, #1f2328)',
             background: 'var(--affine-background-overlay-panel-color, #ffffff)',
-            border: '1px solid var(--affine-primary-color, #1e96eb)',
+            border: '1px solid var(--affine-primary-color)',
             borderRadius: '6px',
             boxShadow: 'var(--affine-shadow-2, 0 2px 8px rgba(0,0,0,0.18))',
             outline: 'none',

package/dist/_pkgs/affine-block-surface/framework-background/fit.d.ts

@@ -0,0 +1,36 @@
+/**
+ * How a framework that draws a FIXED reference artwork puts it in its element.
+ *
+ * A declared background (`FrameworkBackgroundDef`) never needs this: it is made
+ * of ratios of a plot and stretches with the element by construction. The
+ * frameworks that reproduce an authored drawing — Cynefin, Estuarine, EDGY, the
+ * DDD stencils — cannot stretch: circles would turn into ellipses and a
+ * hand-drawn boundary into a smear. They fit the artwork uniformly instead and
+ * centre what is left over.
+ *
+ * This was written three times over — `gfx/cynefin-estuarine/src/utils.ts`,
+ * `gfx/ddd-shared/src/shared/utils.ts` and `gfx/edgy/src/consts.ts` — with the
+ * same body each time. One source of truth (R37): the three call it, and a
+ * board that crops itself onto its drawing
+ * (`gfx/cynefin-estuarine/src/cynefin/crop.ts`) reads the very function the
+ * renderer painted through, so the two can never disagree about where the
+ * drawing is.
+ */
+/** A uniform fit: the scale, and the offsets that centre the letterbox. */
+export interface RefFit {
+    /** Scale from reference units to element units. */
+    s: number;
+    /** Left offset of the fitted artwork inside the element, in element units. */
+    ox: number;
+    /** Top offset of the fitted artwork inside the element, in element units. */
+    oy: number;
+}
+/**
+ * Uniform fit of a `refW × refH` reference design into a `w × h` box: the
+ * scale factor plus the centring offsets (letterboxed), undistorted.
+ *
+ * The fitted artwork is `refW * s` by `refH * s` and shares the box's CENTRE —
+ * `ox + refW * s / 2 === w / 2` — which is what lets a board crop itself onto
+ * its drawing without the drawing moving, rotation included.
+ */
+export declare function refScale(w: number, h: number, refW: number, refH: number): RefFit;

package/dist/_pkgs/affine-block-surface/framework-background/fit.js

@@ -0,0 +1,30 @@
+/**
+ * How a framework that draws a FIXED reference artwork puts it in its element.
+ *
+ * A declared background (`FrameworkBackgroundDef`) never needs this: it is made
+ * of ratios of a plot and stretches with the element by construction. The
+ * frameworks that reproduce an authored drawing — Cynefin, Estuarine, EDGY, the
+ * DDD stencils — cannot stretch: circles would turn into ellipses and a
+ * hand-drawn boundary into a smear. They fit the artwork uniformly instead and
+ * centre what is left over.
+ *
+ * This was written three times over — `gfx/cynefin-estuarine/src/utils.ts`,
+ * `gfx/ddd-shared/src/shared/utils.ts` and `gfx/edgy/src/consts.ts` — with the
+ * same body each time. One source of truth (R37): the three call it, and a
+ * board that crops itself onto its drawing
+ * (`gfx/cynefin-estuarine/src/cynefin/crop.ts`) reads the very function the
+ * renderer painted through, so the two can never disagree about where the
+ * drawing is.
+ */
+/**
+ * Uniform fit of a `refW × refH` reference design into a `w × h` box: the
+ * scale factor plus the centring offsets (letterboxed), undistorted.
+ *
+ * The fitted artwork is `refW * s` by `refH * s` and shares the box's CENTRE —
+ * `ox + refW * s / 2 === w / 2` — which is what lets a board crop itself onto
+ * its drawing without the drawing moving, rotation included.
+ */
+export function refScale(w, h, refW, refH) {
+    const s = Math.min(w / refW, h / refH);
+    return { s, ox: (w - refW * s) / 2, oy: (h - refH * s) / 2 };
+}

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

@@ -1,6 +1,7 @@
 export * from './background-view.js';
 export * from './def.js';
 export * from './facts.js';
+export * from './fit.js';
 export * from './interaction.js';
 export * from './labels.js';
 export * from './renderer.js';

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

@@ -1,6 +1,7 @@
 export * from './background-view.js';
 export * from './def.js';
 export * from './facts.js';
+export * from './fit.js';
 export * from './interaction.js';
 export * from './labels.js';
 export * from './renderer.js';

package/dist/_pkgs/affine-block-surface/renderer/element-highlight-overlay.js

@@ -1,4 +1,4 @@
-import { ThemeProvider } from '../../affine-shared/services/index.js';
+import { getChromeAccentColor } from '../../affine-shared/services/index.js';
 import { DisposableGroup } from '../../global/disposable/index.js';
 import { effect } from '@preact/signals-core';
 import { Overlay } from './overlay.js';
@@ -8,8 +8,6 @@ const HIGHLIGHT_STROKE_WIDTH = 2;
 const HIGHLIGHT_GAP = 4;
 /** Ring corner radius, in screen pixels. */
 const HIGHLIGHT_RADIUS = 4;
-/** Used when no theme is provided, matches the legacy frame highlight. */
-const FALLBACK_HIGHLIGHT_COLOR = '#1E96EB';
 /**
  * Draws the transient emphasis ring around the elements held by
  * `gfx.highlight` (`ElementHighlightManager`).
@@ -20,10 +18,7 @@ const FALLBACK_HIGHLIGHT_COLOR = '#1E96EB';
 export class ElementHighlightOverlay extends Overlay {
     static { this.overlayName = 'element-highlight'; }
     get _strokeColor() {
-        return (this.gfx.std
-            .getOptional(ThemeProvider)
-            ?.getCssVariableColor('--affine-primary-color') ??
-            FALLBACK_HIGHLIGHT_COLOR);
+        return getChromeAccentColor(this.gfx.std);
     }
     constructor(gfx) {
         super(gfx);

package/dist/_pkgs/affine-block-surface-ref/configs/tooltips.js

@@ -6,8 +6,8 @@ export const EdgelessTooltip = html `<svg width="170" height="106" viewBox="0 0
 <rect width="170" height="106" rx="2" fill="white"/>
 </mask>
 <g mask="url(#mask0_16460_1252)">
-<rect x="100.5" y="42.6565" width="141" height="51" stroke="#1E96EB" stroke-width="3" stroke-dasharray="5 5"/>
-<circle cx="101.5" cy="43.5" r="6" fill="white" stroke="#1E96EB" stroke-width="3"/>
+<rect x="100.5" y="42.6565" width="141" height="51" stroke="var(--affine-primary-color)" stroke-width="3" stroke-dasharray="5 5"/>
+<circle cx="101.5" cy="43.5" r="6" fill="white" stroke="var(--affine-primary-color)" stroke-width="3"/>
 <rect x="105" y="8" width="59" height="26" rx="10" fill="black" fill-opacity="0.1"/>
 <text fill="#121212" xml:space="preserve" style="white-space: pre" font-family="Inter" font-size="12" letter-spacing="0em"><tspan x="117" y="25.3636">Group</tspan></text>
 <mask id="mask1_16460_1252" style="mask-type:alpha" maskUnits="userSpaceOnUse" x="0" y="0" width="98" height="106">

package/dist/_pkgs/affine-components/color-picker/palette-carousel.js

@@ -125,6 +125,11 @@ export const paletteCarouselStyles = css `
     /* Nine pages fit without scrolling; the cap is a seatbelt for a tenth. */
     max-height: 280px;
     overflow-y: auto;
+    /* Same trap as the popup box that holds this list (issue #392, see
+     * toolbar/menu-button.ts): an overflow-y of its own makes the other axis
+     * scrollable too, and this list is one long page name — a translation, or
+     * a tenth page — away from overflowing it. */
+    overflow-x: hidden;
     overscroll-behavior: contain;
     animation: palette-carousel-settle ${springDuration} ${springEasing};
   }

package/dist/_pkgs/affine-components/color-picker/styles.js

@@ -109,7 +109,7 @@ export const COLOR_PICKER_STYLE = css `
   }
   .modes .mode button[active] {
     pointer-events: none;
-    outline: 2px solid var(--affine-brand-color, #1e96eb);
+    outline: 2px solid var(--affine-brand-color);
   }
 
   .content {

package/dist/_pkgs/affine-components/context-menu/button.js

@@ -264,7 +264,9 @@ export const menuButtonItems = {
         const data = {
             content: () => html `
           ${config.checked.value
-                ? CheckBoxCheckSolidIcon({ style: `color:#1E96EB` })
+                ? CheckBoxCheckSolidIcon({
+                    style: `color:var(--affine-primary-color)`,
+                })
                 : CheckBoxUnIcon()}
           <div class="affine-menu-action-text">
             ${config.label?.() ?? config.name}

package/dist/_pkgs/affine-components/icons/ai.js

@@ -9,11 +9,11 @@ export const AIStarIcon = html `<svg
   <g clip-path="url(#clip0_7444_26654)">
     <path
       d="M9.40033 4.57585C9.36627 4.27519 9.11207 4.04792 8.80948 4.04761C8.50689 4.0473 8.25223 4.27405 8.21756 4.57465C7.99211 6.52928 7.40771 7.90373 6.46492 8.84651C5.52213 9.7893 4.14769 10.3737 2.19305 10.5991C1.89246 10.6338 1.66571 10.8885 1.66602 11.1911C1.66633 11.4937 1.8936 11.7479 2.19426 11.7819C4.11659 11.9997 5.52025 12.5838 6.48542 13.5315C7.44696 14.4757 8.04356 15.8498 8.21597 17.7908C8.24327 18.0981 8.50096 18.3337 8.80954 18.3333C9.11813 18.333 9.37528 18.0969 9.40189 17.7894C9.56714 15.8804 10.1632 14.4774 11.1295 13.5111C12.0958 12.5448 13.4988 11.9487 15.4078 11.7835C15.7153 11.7569 15.9514 11.4997 15.9517 11.1911C15.9521 10.8825 15.7165 10.6249 15.4092 10.5976C13.4683 10.4252 12.0941 9.82855 11.15 8.86701C10.2022 7.90184 9.61807 6.49818 9.40033 4.57585Z"
-      fill="#1E96EB"
+      fill="var(--affine-primary-color)"
     />
     <path
       d="M15.7849 1.87208C15.7717 1.75516 15.6728 1.66678 15.5551 1.66666C15.4375 1.66654 15.3384 1.75472 15.3249 1.87162C15.2373 2.63175 15.01 3.16626 14.6434 3.5329C14.2767 3.89954 13.7422 4.1268 12.9821 4.21448C12.8652 4.22796 12.777 4.327 12.7771 4.44467C12.7772 4.56234 12.8656 4.6612 12.9826 4.67445C13.7301 4.75912 14.276 4.9863 14.6513 5.35485C15.0253 5.72203 15.2573 6.25642 15.3243 7.01121C15.335 7.13075 15.4352 7.22235 15.5552 7.22221C15.6752 7.22208 15.7752 7.13025 15.7855 7.01069C15.8498 6.26831 16.0816 5.72268 16.4574 5.3469C16.8332 4.97111 17.3788 4.73932 18.1212 4.67505C18.2407 4.6647 18.3325 4.5647 18.3327 4.44469C18.3328 4.32469 18.2412 4.22448 18.1217 4.21386C17.3669 4.14681 16.8325 3.9148 16.4653 3.54087C16.0968 3.16552 15.8696 2.61966 15.7849 1.87208Z"
-      fill="#1E96EB"
+      fill="var(--affine-primary-color)"
     />
   </g>
   <defs>
@@ -46,7 +46,7 @@ export const AIStopIcon = html `<svg
       fill-rule="evenodd"
       clip-rule="evenodd"
       d="M17.0827 10C17.0827 13.912 13.9114 17.0834 9.99935 17.0834C6.08733 17.0834 2.91602 13.912 2.91602 10C2.91602 6.088 6.08733 2.91669 9.99935 2.91669C13.9114 2.91669 17.0827 6.088 17.0827 10ZM18.3327 10C18.3327 14.6024 14.6017 18.3334 9.99935 18.3334C5.39698 18.3334 1.66602 14.6024 1.66602 10C1.66602 5.39765 5.39698 1.66669 9.99935 1.66669C14.6017 1.66669 18.3327 5.39765 18.3327 10ZM8.33268 6.66669C7.41221 6.66669 6.66602 7.41288 6.66602 8.33335V11.6667C6.66602 12.5872 7.41221 13.3334 8.33268 13.3334H11.666C12.5865 13.3334 13.3327 12.5872 13.3327 11.6667V8.33335C13.3327 7.41288 12.5865 6.66669 11.666 6.66669H8.33268Z"
-      fill="#1E96EB"
+      fill="var(--affine-primary-color)"
     />
   </g>
   <defs>