@formicoidea/labre-core 0.43.1 → 0.46.0

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

@@ -1,7 +1,10 @@
 export { exportBoardSvg, exportSvgCommands, selectedBoards, } from './command.js';
-export type { BoardSvgExport } from './render.js';
-export { exportBoundOf, renderBoardSvg, selectBoardElements, } from './render.js';
+export type { BoardSvgExportOptions, BoardSvgExportPart, SvgExportCandidate, } from './parts.js';
+export { boardSvgExportOptions, boardSvgExportPartOf, DEFAULT_BOARD_SVG_EXPORT_OPTIONS, selectBoardSvgParts, } from './parts.js';
+export type { BlockSvgPainter, BoardSvgExport } from './render.js';
+export { BlockSvgPainterExtension, BlockSvgPainterIdentifier, boardSvgMarkers, exportBoundOf, renderBoardSvg, selectBoardElements, } from './render.js';
 export { taggedPath2D } from './tagged-path.js';
 export type { SvgContext } from './svg-context.js';
-export { createSvgContext, runWithRecordingPath2D } from './svg-context.js';
+export { BOARD_SVG_MARKER_VERSION, createSvgContext, runWithRecordingPath2D, } from './svg-context.js';
 export { exportSvgToolbarConfig, exportSvgToolbarExtension, } from './toolbar.js';
+export { EXPORT_SVG_WORDINGS } from './translations.js';

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

@@ -1,5 +1,7 @@
 export { exportBoardSvg, exportSvgCommands, selectedBoards, } from './command.js';
-export { exportBoundOf, renderBoardSvg, selectBoardElements, } from './render.js';
+export { boardSvgExportOptions, boardSvgExportPartOf, DEFAULT_BOARD_SVG_EXPORT_OPTIONS, selectBoardSvgParts, } from './parts.js';
+export { BlockSvgPainterExtension, BlockSvgPainterIdentifier, boardSvgMarkers, exportBoundOf, renderBoardSvg, selectBoardElements, } from './render.js';
 export { taggedPath2D } from './tagged-path.js';
-export { createSvgContext, runWithRecordingPath2D } from './svg-context.js';
+export { BOARD_SVG_MARKER_VERSION, createSvgContext, runWithRecordingPath2D, } from './svg-context.js';
 export { exportSvgToolbarConfig, exportSvgToolbarExtension, } from './toolbar.js';
+export { EXPORT_SVG_WORDINGS } from './translations.js';

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

@@ -0,0 +1,63 @@
+/**
+ * What "Export SVG" puts in the file — the three switches of its options menu,
+ * all on by default (ADR 0025, amendment of 2026-10-04).
+ */
+export interface BoardSvgExportOptions {
+    /** The board, its framework's artefacts and its generated legend. */
+    framework: boolean;
+    /** Every other canvas element that is not a text: shapes, connectors, strokes. */
+    shapes: boolean;
+    /** Every other text: canvas texts, and the edgeless text blocks. */
+    texts: boolean;
+}
+export type BoardSvgExportPart = keyof BoardSvgExportOptions;
+export declare const DEFAULT_BOARD_SVG_EXPORT_OPTIONS: Readonly<BoardSvgExportOptions>;
+/**
+ * The options a command invocation carries, re-validated: the palette and the
+ * agent pass nothing and get everything, and only an explicit `false` switches
+ * a part off — a stray value never empties a file.
+ */
+export declare function boardSvgExportOptions(params: unknown): BoardSvgExportOptions;
+/**
+ * The stored facts the rule reads, and nothing else: an element's `role` and
+ * `type`, and a group's `childElements`. Structural, so the rule runs over a
+ * real model and over a recorded creation alike.
+ */
+export interface SvgExportCandidate {
+    readonly role?: string;
+    readonly type?: string;
+    readonly childElements?: readonly SvgExportCandidate[];
+}
+/**
+ * Which switch an element on `board` answers to.
+ *
+ * - **Framework elements**: the board itself; anything whose role shares the
+ *   board's role namespace (`wardley:map` owns `wardley:component`,
+ *   `wardley:label`, `wardley:dependency`…); the generated legend
+ *   (`core:legend`, ADR 0026) and every glyph in it; and a ROLE-LESS element
+ *   grouped with any of those. The last clause is what a framework artefact is
+ *   made of: an EDGY person and its name, a Wardley market and its three dots,
+ *   a Core Domain sub-domain and its title are one group in which only one
+ *   member carries the role.
+ * - **Other texts**: any other `text` element — a plain one, or one of ANOTHER
+ *   framework lying on this board, which is a text like any other here.
+ * - **Other shapes and strokes**: everything else — plain shapes, plain
+ *   connectors, brush and highlighter strokes, mind maps, another framework's
+ *   shapes, and a plain group (which paints nothing of its own in an export).
+ *
+ * Read off the namespace rather than a `FrameworkId` on purpose: three DDD
+ * frameworks spell their roles `es:`, `core-domain:` and `context-map:`, and
+ * the board says which one it speaks. A board with no role (Cynefin, which
+ * paints its domains itself) owns itself and nothing else. Edgeless text
+ * BLOCKS never reach this function: they carry no role and are always "other
+ * texts" ({@link selectBoardSvgParts}).
+ */
+export declare function boardSvgExportPartOf(board: SvgExportCandidate, element: SvgExportCandidate, groups: readonly SvgExportCandidate[]): BoardSvgExportPart;
+/**
+ * What the file draws under `options`: the canvas elements, in the paint order
+ * they came in, and the edgeless text blocks, which are all "other texts".
+ */
+export declare function selectBoardSvgParts<E extends SvgExportCandidate, B>(board: SvgExportCandidate, elements: readonly E[], textBlocks: readonly B[], options: Readonly<BoardSvgExportOptions>, groupsOf: (element: E) => readonly SvgExportCandidate[]): {
+    elements: E[];
+    textBlocks: B[];
+};

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

@@ -0,0 +1,67 @@
+import { LEGEND_ROLE } from '../legend.js';
+export const DEFAULT_BOARD_SVG_EXPORT_OPTIONS = Object.freeze({ framework: true, shapes: true, texts: true });
+/**
+ * The options a command invocation carries, re-validated: the palette and the
+ * agent pass nothing and get everything, and only an explicit `false` switches
+ * a part off — a stray value never empties a file.
+ */
+export function boardSvgExportOptions(params) {
+    const given = (params !== null && typeof params === 'object' ? params : {});
+    return {
+        framework: given.framework !== false,
+        shapes: given.shapes !== false,
+        texts: given.texts !== false,
+    };
+}
+/** `'wardley:component'` → `'wardley'`; nothing for a missing or empty role. */
+const namespaceOf = (role) => role?.split(':')[0] || undefined;
+/**
+ * Which switch an element on `board` answers to.
+ *
+ * - **Framework elements**: the board itself; anything whose role shares the
+ *   board's role namespace (`wardley:map` owns `wardley:component`,
+ *   `wardley:label`, `wardley:dependency`…); the generated legend
+ *   (`core:legend`, ADR 0026) and every glyph in it; and a ROLE-LESS element
+ *   grouped with any of those. The last clause is what a framework artefact is
+ *   made of: an EDGY person and its name, a Wardley market and its three dots,
+ *   a Core Domain sub-domain and its title are one group in which only one
+ *   member carries the role.
+ * - **Other texts**: any other `text` element — a plain one, or one of ANOTHER
+ *   framework lying on this board, which is a text like any other here.
+ * - **Other shapes and strokes**: everything else — plain shapes, plain
+ *   connectors, brush and highlighter strokes, mind maps, another framework's
+ *   shapes, and a plain group (which paints nothing of its own in an export).
+ *
+ * Read off the namespace rather than a `FrameworkId` on purpose: three DDD
+ * frameworks spell their roles `es:`, `core-domain:` and `context-map:`, and
+ * the board says which one it speaks. A board with no role (Cynefin, which
+ * paints its domains itself) owns itself and nothing else. Edgeless text
+ * BLOCKS never reach this function: they carry no role and are always "other
+ * texts" ({@link selectBoardSvgParts}).
+ */
+export function boardSvgExportPartOf(board, element, groups) {
+    if (element === board)
+        return 'framework';
+    const own = namespaceOf(board.role);
+    const owned = (role) => role === LEGEND_ROLE || (own !== undefined && namespaceOf(role) === own);
+    if (owned(element.role))
+        return 'framework';
+    if (element.role === undefined) {
+        const enclosing = element.childElements ? [element, ...groups] : groups;
+        const ownedGroup = enclosing.some(group => owned(group.role) ||
+            group.childElements?.some(child => owned(child.role)));
+        if (ownedGroup)
+            return 'framework';
+    }
+    return element.type === 'text' ? 'texts' : 'shapes';
+}
+/**
+ * What the file draws under `options`: the canvas elements, in the paint order
+ * they came in, and the edgeless text blocks, which are all "other texts".
+ */
+export function selectBoardSvgParts(board, elements, textBlocks, options, groupsOf) {
+    return {
+        elements: elements.filter(element => options[boardSvgExportPartOf(board, element, groupsOf(element))]),
+        textBlocks: options.texts ? [...textBlocks] : [],
+    };
+}

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

@@ -1,13 +1,30 @@
 import { FrameworkBackgroundElementModel } from '../../../affine-model/index.js';
 import { Bound } from '../../../global/gfx/index.js';
 import type { BlockStdScope } from '../../../std/index.js';
-import { type GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
+import { type GfxBlockElementModel, type GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
+import type { ExtensionType } from '../../../store/index.js';
+import { CanvasRenderer } from '../../renderer/canvas-renderer.js';
+import { type BoardSvgExportOptions } from './parts.js';
 export interface BoardSvgExport {
     /** A standalone SVG document. */
     svg: string;
     /** The world-space rectangle the document covers. */
     bound: Bound;
 }
+/**
+ * How a BLOCK paints itself into the export's 2D context, in model units, the
+ * block's top-left at the origin of `matrix`.
+ *
+ * Blocks are DOM, so the canvas renderer never sees them (ADR 0025,
+ * Consequences). The one block the export draws anyway is the edgeless text —
+ * what the text tool creates by default — and its painter lives with it, in
+ * `@labre/affine-block-edgeless-text`, because the text metrics it needs
+ * (`@labre/affine-gfx-text`) sit ABOVE this package. Keyed by flavour; a block
+ * with no painter registered is simply not drawn.
+ */
+export type BlockSvgPainter<T extends GfxBlockElementModel = GfxBlockElementModel> = (model: T, ctx: CanvasRenderingContext2D, matrix: DOMMatrix, renderer: CanvasRenderer) => void;
+export declare const BlockSvgPainterIdentifier: import("../../../global/di/types.js").ServiceIdentifier<BlockSvgPainter<GfxBlockElementModel<import("../../../std/gfx/index.js").GfxCompatibleProps>>> & (<U extends BlockSvgPainter<GfxBlockElementModel<import("../../../std/gfx/index.js").GfxCompatibleProps>> = BlockSvgPainter<GfxBlockElementModel<import("../../../std/gfx/index.js").GfxCompatibleProps>>>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);
+export declare function BlockSvgPainterExtension<T extends GfxBlockElementModel>(flavour: string, painter: BlockSvgPainter<T>): ExtensionType;
 /**
  * The canvas elements that make up `board`'s picture, in paint order.
  *
@@ -28,14 +45,54 @@ export interface BoardSvgExport {
  */
 export declare function selectBoardElements<T extends GfxPrimitiveElementModel>(board: FrameworkBackgroundElementModel, candidates: readonly T[]): (FrameworkBackgroundElementModel | T)[];
 /**
- * The board's frame, widened to the union of what is painted on it: a Wardley
- * label overhanging the right edge, or a connector ending just outside, is part
- * of the picture and must not be cut off.
+ * The frame, widened to the union of what is painted: a Wardley label
+ * overhanging the right edge, or a connector ending just outside, is part of
+ * the picture and must not be cut off. The frame is the board's — or, with
+ * "Framework elements" switched off, the first thing still drawn.
  */
-export declare function exportBoundOf(board: FrameworkBackgroundElementModel, elements: readonly GfxPrimitiveElementModel[]): Bound;
+export declare function exportBoundOf(frame: {
+    readonly xywh: string;
+}, elements: readonly {
+    readonly xywh: string;
+}[]): Bound;
 /**
  * The selected board and everything painted within its frame, as an SVG
  * document — a true vector export, produced by replaying the very element
  * renderers the canvas uses into an SVG-emitting 2D context.
+ *
+ * `options` says which parts are drawn (`parts.ts`). `null` when they leave
+ * nothing to draw: an empty file is not a picture of anything.
+ *
+ * Without `options` every part is drawn, the board among them, so the 0.43
+ * call shape `renderBoardSvg(std, board).svg` keeps its non-null return
+ * (`render-board-svg-signature.unit.spec.ts`). Only the overload that takes
+ * options can answer `null`.
  */
 export declare function renderBoardSvg(std: BlockStdScope, board: FrameworkBackgroundElementModel): BoardSvgExport;
+export declare function renderBoardSvg(std: BlockStdScope, board: FrameworkBackgroundElementModel, options: Readonly<BoardSvgExportOptions>): BoardSvgExport | null;
+/**
+ * What an element's group says about it in the file (ADR 0032 §6): its id, its
+ * type, its role, its stored bound in the FILE's coordinates, the two ends of
+ * a connector and the group it belongs to — base-class fields only, so every
+ * board's SVG carries them and no framework is named here.
+ *
+ * Ids and vocabulary, never prose: no `pivotDocId` (its contract forbids an
+ * exporter to read it), no `interchange`, no tag, no link, no text — a name is
+ * read back from the `<text>` the renderer already drew.
+ */
+export declare function boardSvgMarkers(element: {
+    id: string;
+    xywh: string;
+    type?: string;
+    flavour?: string;
+    role?: string;
+    group?: {
+        id: string;
+    } | null;
+    source?: {
+        id?: string;
+    } | null;
+    target?: {
+        id?: string;
+    } | null;
+}, bound: Bound): Record<string, string>;

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

@@ -1,9 +1,21 @@
 import { FrameworkBackgroundElementModel } from '../../../affine-model/index.js';
+import { createIdentifier } from '../../../global/di/index.js';
 import { Bound } from '../../../global/gfx/index.js';
 import { GfxControllerIdentifier, } from '../../../std/gfx/index.js';
 import { CanvasRenderer } from '../../renderer/canvas-renderer.js';
 import { RoughCanvas } from '../../utils/rough/canvas.js';
+import { DEFAULT_BOARD_SVG_EXPORT_OPTIONS, selectBoardSvgParts, } from './parts.js';
 import { createSvgContext, runWithRecordingPath2D } from './svg-context.js';
+export const BlockSvgPainterIdentifier = createIdentifier('block-svg-painter');
+export function BlockSvgPainterExtension(flavour, painter) {
+    return {
+        setup: di => {
+            di.addImpl(BlockSvgPainterIdentifier(flavour), () => painter);
+        },
+    };
+}
+/** The blocks the export redraws, all of them "other texts" (`parts.ts`). */
+const SVG_TEXT_BLOCK_FLAVOURS = ['affine:edgeless-text'];
 /**
  * The canvas elements that make up `board`'s picture, in paint order.
  *
@@ -34,37 +46,105 @@ export function selectBoardElements(board, candidates) {
         : [board, ...kept];
 }
 /**
- * The board's frame, widened to the union of what is painted on it: a Wardley
- * label overhanging the right edge, or a connector ending just outside, is part
- * of the picture and must not be cut off.
+ * The frame, widened to the union of what is painted: a Wardley label
+ * overhanging the right edge, or a connector ending just outside, is part of
+ * the picture and must not be cut off. The frame is the board's — or, with
+ * "Framework elements" switched off, the first thing still drawn.
  */
-export function exportBoundOf(board, elements) {
-    let bound = Bound.deserialize(board.xywh);
+export function exportBoundOf(frame, elements) {
+    let bound = Bound.deserialize(frame.xywh);
     for (const element of elements) {
         bound = bound.unite(Bound.deserialize(element.xywh));
     }
     return bound;
 }
-/**
- * The selected board and everything painted within its frame, as an SVG
- * document — a true vector export, produced by replaying the very element
- * renderers the canvas uses into an SVG-emitting 2D context.
- */
-export function renderBoardSvg(std, board) {
+export function renderBoardSvg(std, board, given) {
+    const options = given ?? DEFAULT_BOARD_SVG_EXPORT_OPTIONS;
     const gfx = std.get(GfxControllerIdentifier);
     const renderer = gfx.surfaceComponent?.renderer;
     if (!(renderer instanceof CanvasRenderer)) {
         throw new Error('SVG export needs the surface to be painted by a CanvasRenderer.');
     }
+    const frame = Bound.deserialize(board.xywh);
     // Already sorted by `layer.compare`, which is the canvas' own z-order.
-    const candidates = gfx.getElementsByBound(Bound.deserialize(board.xywh), {
-        type: 'canvas',
-    });
-    const elements = selectBoardElements(board, candidates);
-    const bound = exportBoundOf(board, elements);
+    // What you see is what you export (ADR 0031): what this viewer hid is
+    // neither painted nor allowed to widen the picture. The board itself stays,
+    // it is the sheet being exported.
+    const candidates = gfx
+        .getElementsByBound(frame, { type: 'canvas' })
+        .filter(element => element === board || !gfx.localVisibility.isHidden(element));
+    const textBlocks = gfx
+        .getElementsByBound(frame, { type: 'block' })
+        .filter(block => SVG_TEXT_BLOCK_FLAVOURS.includes(block.flavour) &&
+        !gfx.localVisibility.isHidden(block));
+    const { elements, textBlocks: texts } = selectBoardSvgParts(board, selectBoardElements(board, candidates), textBlocks, options, element => element.groups);
+    const drawn = [...elements, ...texts];
+    if (!drawn.length) {
+        // Unreachable without options: the board is always selected and answers
+        // to "Framework elements". Thrown rather than returned, so the overload
+        // that promises an export never hands back `null`.
+        if (given === undefined) {
+            throw new Error('SVG export drew nothing with every part on: the board itself was not selected.');
+        }
+        return null;
+    }
+    const bound = exportBoundOf(options.framework ? board : drawn[0], drawn);
     return runWithRecordingPath2D(() => {
-        const { ctx, canvas, serialize } = createSvgContext(bound.w, bound.h);
-        renderer.renderBoundTo(ctx, new RoughCanvas(canvas), bound, elements);
+        const { ctx, canvas, serialize, markRoot, markedGroup } = createSvgContext(bound.w, bound.h);
+        const rc = new RoughCanvas(canvas);
+        markRoot();
+        // One model per pass, each inside a group carrying its markers (ADR 0032
+        // §6), in the canvas' own z-order: a text block is painted at its layer
+        // index, between the elements it sits between on screen.
+        const blocks = new Set(texts);
+        for (const model of [...elements, ...texts].sort(gfx.layer.compare)) {
+            if (!blocks.has(model)) {
+                const element = model;
+                markedGroup(boardSvgMarkers(element, bound), () => renderer.renderBoundTo(ctx, rc, bound, [element]));
+                continue;
+            }
+            const block = model;
+            const paint = std.getOptional(BlockSvgPainterIdentifier(block.flavour));
+            if (!paint)
+                continue;
+            markedGroup(boardSvgMarkers(block, bound), () => {
+                ctx.save();
+                paint(block, ctx, new DOMMatrix().translate(block.x - bound.x, block.y - bound.y), renderer);
+                ctx.restore();
+            });
+        }
         return { svg: serialize(), bound };
     });
 }
+/**
+ * What an element's group says about it in the file (ADR 0032 §6): its id, its
+ * type, its role, its stored bound in the FILE's coordinates, the two ends of
+ * a connector and the group it belongs to — base-class fields only, so every
+ * board's SVG carries them and no framework is named here.
+ *
+ * Ids and vocabulary, never prose: no `pivotDocId` (its contract forbids an
+ * exporter to read it), no `interchange`, no tag, no link, no text — a name is
+ * read back from the `<text>` the renderer already drew.
+ */
+export function boardSvgMarkers(element, bound) {
+    const own = Bound.deserialize(element.xywh);
+    const markers = {
+        'data-labre-id': element.id,
+        'data-labre-type': element.type ?? element.flavour ?? '',
+        'data-labre-xywh': JSON.stringify([
+            own.x - bound.x,
+            own.y - bound.y,
+            own.w,
+            own.h,
+        ]),
+    };
+    if (element.role)
+        markers['data-labre-role'] = element.role;
+    if (element.source?.id)
+        markers['data-labre-source'] = element.source.id;
+    if (element.target?.id)
+        markers['data-labre-target'] = element.target.id;
+    if (element.group?.id)
+        markers['data-labre-group'] = element.group.id;
+    return markers;
+}

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

@@ -9,6 +9,14 @@ export interface SvgContext {
     canvas: HTMLCanvasElement;
     /** The finished document, with `viewBox`, `width`/`height` in px and `xmlns`. */
     serialize(): string;
+    /** Stamps the root `<svg>` with the marker version (ADR 0032 §6). */
+    markRoot(): void;
+    /**
+     * Runs `draw` inside a new `<g>` carrying `attributes`, then closes it —
+     * however many groups `draw` left open (`renderBoundTo` restores one more
+     * time than it saves), so the next element starts beside this one.
+     */
+    markedGroup(attributes: Record<string, string>, draw: () => void): void;
 }
 /** Marks a {@link RecordingPath2D} and carries what it recorded. */
 declare const RECORDED_D: unique symbol;
@@ -46,4 +54,10 @@ export declare function readLineDash(lineDash: unknown): number[];
  * handed to {@link CanvasRenderer.renderBoundTo}.
  */
 export declare function createSvgContext(width: number, height: number): SvgContext;
+/**
+ * The marker version an export writes on its root (`data-labre-svg`), and the
+ * one a reader of it must know (ADR 0032 §6). Bumped only when the meaning of
+ * a marker changes; adding one is not a new version.
+ */
+export declare const BOARD_SVG_MARKER_VERSION = "1";
 export {};

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

@@ -1,3 +1,4 @@
+import { parseCssColor } from '../../../affine-shared/adapters/index.js';
 import { Context } from 'svgcanvas/dist/svgcanvas.esm.js';
 const PATH_OPS = ['fill', 'stroke', 'clip'];
 /** Marks a {@link RecordingPath2D} and carries what it recorded. */
@@ -203,6 +204,63 @@ export function readLineDash(lineDash) {
         return [];
     return lineDash.split(',').map(Number);
 }
+/**
+ * A colour with alpha, rewritten as the comma `rgba()` svgcanvas recognises;
+ * any other value comes back unchanged.
+ *
+ * svgcanvas splits only a value containing `rgba` into `rgb()` plus an
+ * `-opacity` attribute and writes everything else verbatim, so an 8-digit hex
+ * (`AREA_FILL`, `PIPELINE_FILL`, the DDD zones) or `transparent` reached the
+ * file as-is. Neither is an SVG 1.1 paint, and an importer that sticks to 1.1
+ * (PowerPoint's) replaces it with its own theme colour. The alpha is fixed to
+ * six decimals because svgcanvas' parser reads no exponent (`1e-7`).
+ */
+function toSvgColor(value) {
+    const parsed = parseCssColor(value);
+    if (!parsed || parsed.alpha === 1)
+        return value;
+    const { r, g, b, alpha } = parsed;
+    return `rgba(${r}, ${g}, ${b}, ${Number(alpha.toFixed(6))})`;
+}
+/**
+ * {@link toSvgColor} for a `fill` or `stroke`, where a fully transparent colour
+ * is `none`: the one invisible paint every SVG reader honours. svgcanvas births
+ * every node with `fill="none" stroke="none"` and skips a stroke equal to that
+ * default, so an invisible second pass leaves an earlier paint in place — as
+ * painting it on a canvas would.
+ */
+function toSvgPaint(value) {
+    if (typeof value !== 'string')
+        return value;
+    return parseCssColor(value)?.alpha === 0 ? 'none' : toSvgColor(value);
+}
+/**
+ * Routes every `fillStyle` / `strokeStyle` write — including the ones
+ * svgcanvas' own `restore()` makes — and every gradient stop through the
+ * converters above. Gradients and patterns pass through untouched.
+ */
+function installStaticPaint(context) {
+    for (const key of ['fillStyle', 'strokeStyle']) {
+        let current = toSvgPaint(context[key]);
+        Object.defineProperty(context, key, {
+            configurable: true,
+            enumerable: true,
+            get: () => current,
+            set: (value) => {
+                current = toSvgPaint(value);
+            },
+        });
+    }
+    for (const key of ['createLinearGradient', 'createRadialGradient']) {
+        const create = context[key];
+        context[key] = (...args) => {
+            const gradient = create.apply(context, args);
+            const addColorStop = gradient.addColorStop;
+            gradient.addColorStop = (offset, color) => addColorStop.call(gradient, offset, toSvgColor(color));
+            return gradient;
+        };
+    }
+}
 /** Adds `viewBox` / `xmlns` / px units to the root `<svg>` if they are missing. */
 function finishSvg(svg, width, height) {
     return (svg
@@ -248,10 +306,33 @@ export function createSvgContext(width, height) {
     // The one Canvas2D method a renderer calls that svgcanvas lacks — see
     // `readLineDash`. Without it a single `getLineDash()` aborts the export.
     context.getLineDash = () => readLineDash(context.lineDash);
-    installPathOps(context);
+    const internals = context;
+    installPathOps(internals);
+    installStaticPaint(context);
     return {
         ctx,
         canvas: ctx.canvas,
         serialize: () => finishSvg(context.getSerializedSvg(true), width, height),
+        markRoot: () => internals
+            .getSvg()
+            .setAttribute('data-labre-svg', BOARD_SVG_MARKER_VERSION),
+        markedGroup: (attributes, draw) => {
+            const depth = internals.__groupStack.length;
+            // svgcanvas' `save()` IS a new `<g>`, and it becomes the current node.
+            internals.save();
+            const group = internals.__currentElement;
+            for (const [name, value] of Object.entries(attributes)) {
+                group.setAttribute(name, value);
+            }
+            draw();
+            while (internals.__groupStack.length > depth)
+                internals.restore();
+        },
     };
 }
+/**
+ * The marker version an export writes on its root (`data-labre-svg`), and the
+ * one a reader of it must know (ADR 0032 §6). Bumped only when the meaning of
+ * a marker changes; adding one is not a new version.
+ */
+export const BOARD_SVG_MARKER_VERSION = '1';

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

@@ -1,6 +1,6 @@
-import { type ToolbarContext } from '../../../affine-shared/services/index.js';
+import { type ToolbarAction, type ToolbarContext } from '../../../affine-shared/services/index.js';
 export declare const exportSvgToolbarConfig: {
-    readonly actions: [import("../../../affine-shared/services/index.js").ToolbarActionGenerator];
+    readonly actions: [ToolbarAction];
     readonly when: (ctx: ToolbarContext) => boolean;
 };
 /**