@formicoidea/labre-core 0.50.0 → 0.51.0

package/dist/_pkgs/affine-block-surface/extensions/export-manager/draw-image-block.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Paint an image block's picture into its box for the raster export
+ * (ADR 0037): the cropped part when there is a crop and the source has a
+ * pixel size, otherwise the whole picture — the 5-argument call every
+ * uncropped image, and an SVG with no intrinsic size, always took.
+ */
+export declare function drawImageBlock(ctx: Pick<CanvasRenderingContext2D, 'drawImage'>, image: HTMLImageElement, crop: unknown, box: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}): void;

package/dist/_pkgs/affine-block-surface/extensions/export-manager/draw-image-block.js

@@ -0,0 +1,15 @@
+import { imageCropSourceRect, readImageCrop } from '../../../affine-model/index.js';
+/**
+ * Paint an image block's picture into its box for the raster export
+ * (ADR 0037): the cropped part when there is a crop and the source has a
+ * pixel size, otherwise the whole picture — the 5-argument call every
+ * uncropped image, and an SVG with no intrinsic size, always took.
+ */
+export function drawImageBlock(ctx, image, crop, box) {
+    const source = imageCropSourceRect(readImageCrop(crop), image.naturalWidth, image.naturalHeight);
+    if (!source) {
+        ctx.drawImage(image, box.x, box.y, box.w, box.h);
+        return;
+    }
+    ctx.drawImage(image, source.x, source.y, source.w, source.h, box.x, box.y, box.w, box.h);
+}

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

@@ -9,6 +9,7 @@ import { StdIdentifier, } from '../../../std/index.js';
 import { GfxBlockElementModel, GfxControllerIdentifier, GfxPrimitiveElementModel, isGfxGroupCompatibleModel, } from '../../../std/gfx/index.js';
 import { CanvasRenderer } from '../../renderer/canvas-renderer.js';
 import { getBgGridGap } from '../../utils/get-bg-grip-gap.js';
+import { drawImageBlock } from './draw-image-block.js';
 /**
  * The SVG the PNG export paints the canvas background from: the background
  * colour, plus the dotted grid unless `gridColor` is `null` — what this
@@ -364,7 +365,12 @@ export class ExportManager {
                     img.src = URL.createObjectURL(blob);
                 });
                 const blockBound = xywhArrayToObject(block);
-                ctx.drawImage(await blobToImage(blob), blockBound.x - bound.x, blockBound.y - bound.y, blockBound.w, blockBound.h);
+                drawImageBlock(ctx, await blobToImage(blob), block.props.crop, {
+                    x: blockBound.x - bound.x,
+                    y: blockBound.y - bound.y,
+                    w: blockBound.w,
+                    h: blockBound.h,
+                });
             }
             const blockComponent = this.editorHost.view.getBlock(block.id);
             if (blockComponent) {

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

@@ -1,5 +1,5 @@
 import { FrameworkBackgroundElementModel } from '../../../affine-model/index.js';
-import type { AnyCommandDescriptor, BlockStdScope } from '../../../std/index.js';
+import type { AnyCommandDescriptor, BlockStdScope, CommandFile } from '../../../std/index.js';
 import { type BoardSvgExportOptions } from './parts.js';
 /**
  * The framework boards in the current canvas selection.
@@ -22,3 +22,9 @@ export declare function selectedBoards(std: BlockStdScope): FrameworkBackgroundE
  */
 export declare function exportBoardSvg(std: BlockStdScope, options?: Readonly<BoardSvgExportOptions>): void;
 export declare const exportSvgCommands: AnyCommandDescriptor[];
+/**
+ * The whole canvas as an SVG file, or `null` when there is nothing to draw.
+ * Named after the page, like the PNG.
+ */
+export declare function canvasSvgFile(std: BlockStdScope): CommandFile | null;
+export declare const canvasSvgExportCommands: AnyCommandDescriptor[];

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

@@ -3,7 +3,7 @@ import { NotificationProvider, translateKey, } from '../../../affine-shared/serv
 import { downloadBlob, safeFilename } from '../../../affine-shared/utils/index.js';
 import { GfxControllerIdentifier } from '../../../std/gfx/index.js';
 import { boardSvgExportOptions, DEFAULT_BOARD_SVG_EXPORT_OPTIONS, } from './parts.js';
-import { renderBoardSvg } from './render.js';
+import { canvasRendererOf, renderBoardSvg, renderCanvasSvg } from './render.js';
 import { EXPORT_SVG_NOTHING_TO_EXPORT } from './translations.js';
 /** What the file is, told to the browser. */
 const SVG_MIME = 'image/svg+xml';
@@ -106,3 +106,62 @@ const exportSvg = {
     run: (std, _invocation, params) => exportBoardSvg(std, boardSvgExportOptions(params)),
 };
 export const exportSvgCommands = [exportSvg];
+/**
+ * The whole canvas as an SVG file, or `null` when there is nothing to draw.
+ * Named after the page, like the PNG.
+ */
+export function canvasSvgFile(std) {
+    const rendered = renderCanvasSvg(std);
+    if (!rendered)
+        return null;
+    const title = std.store.workspace.meta.getDocMeta(std.store.id)?.title;
+    return {
+        blob: new Blob([rendered.svg], { type: `${SVG_MIME};charset=utf-8` }),
+        filename: `${safeFilename(title, SVG_FILENAME_FALLBACK)}.svg`,
+    };
+}
+/**
+ * "Export as SVG" of the WHOLE canvas, the fourth export of the canvas's
+ * "This view" (ADR 0034, amendment of 2026-10-14), on the model of
+ * `canvas.export.png`: given `params.deliver` (`runViewAction`) it hands the
+ * file over and downloads nothing; without it (the palette) it downloads.
+ *
+ * `export.svg` exports ONE selected board; this exports everything this
+ * viewer sees, with the same renderer replay and the same `data-labre-*`
+ * markers (ADR 0025, ADR 0032). What the replay cannot draw is left out and
+ * the description says so: the canvas' DOM blocks — notes, frames, images,
+ * embeds — have no SVG painter; edgeless texts do.
+ *
+ * `owner: 'core'`, never gated, no `telemetry` (it names no framework,
+ * like the PNG). Listed only where a `CanvasRenderer` paints the canvas.
+ */
+const exportCanvasSvg = {
+    id: 'canvas.export.svg',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.canvas.export.svg',
+    labelFallback: 'Export as SVG',
+    descriptionKey: 'com.labre.command.canvas.export.svg.description',
+    descriptionFallback: 'Download the whole canvas as a vector SVG file: shapes, lines, texts and boards. Notes, frames and images are not drawn.',
+    category: 'export',
+    iconKey: 'canvas.export.svg',
+    keywords: ['svg', 'vector', 'image', 'export', 'download'],
+    surfaces: ['view-menu', 'palette'],
+    order: 13,
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    when: std => canvasRendererOf(std) !== null,
+    run: (std, _invocation, params) => {
+        const file = canvasSvgFile(std);
+        if (!file)
+            return;
+        const deliver = params?.deliver;
+        if (typeof deliver === 'function')
+            deliver(file);
+        else
+            downloadBlob(file.blob, file.filename);
+    },
+};
+export const canvasSvgExportCommands = [
+    exportCanvasSvg,
+];

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

@@ -1,8 +1,8 @@
-export { exportBoardSvg, exportSvgCommands, selectedBoards, } from './command.js';
+export { canvasSvgExportCommands, canvasSvgFile, exportBoardSvg, exportSvgCommands, selectedBoards, } from './command.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 { BlockSvgPainterExtension, BlockSvgPainterIdentifier, boardSvgMarkers, canvasRendererOf, canvasSvgModels, exportBoundOf, renderBoardSvg, renderCanvasSvg, selectBoardElements, } from './render.js';
 export { taggedPath2D } from './tagged-path.js';
 export type { SvgContext } from './svg-context.js';
 export { BOARD_SVG_MARKER_VERSION, createSvgContext, runWithRecordingPath2D, } from './svg-context.js';

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

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

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

@@ -0,0 +1,6 @@
+/**
+ * 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";

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

@@ -0,0 +1,8 @@
+// Its own module so the headless interchange entry (`./interchange`) can read
+// it without the SVG export's graph (ADR 0012, P3 as amended 2026-10-14).
+/**
+ * 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/render.d.ts

@@ -1,7 +1,7 @@
 import { FrameworkBackgroundElementModel } from '../../../affine-model/index.js';
 import { Bound } from '../../../global/gfx/index.js';
 import type { BlockStdScope } from '../../../std/index.js';
-import { type GfxBlockElementModel, type GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
+import { GfxBlockElementModel, 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';
@@ -70,6 +70,33 @@ export declare function exportBoundOf(frame: {
  */
 export declare function renderBoardSvg(std: BlockStdScope, board: FrameworkBackgroundElementModel): BoardSvgExport;
 export declare function renderBoardSvg(std: BlockStdScope, board: FrameworkBackgroundElementModel, options: Readonly<BoardSvgExportOptions>): BoardSvgExport | null;
+/**
+ * The surface's painter, or `null` when the canvas is not painted by a
+ * {@link CanvasRenderer} (no surface mounted, a DOM renderer): what the SVG
+ * export replays into its own context.
+ */
+export declare function canvasRendererOf(std: BlockStdScope): CanvasRenderer | null;
+/**
+ * What the WHOLE canvas export draws: every canvas element and every edgeless
+ * text block this viewer sees (ADR 0031: what they hid is neither painted nor
+ * allowed to widen the picture), in the canvas' own z-order.
+ *
+ * The canvas' other blocks — notes, frames, images, embeds, attachments — are
+ * DOM, and no painter draws them into the 2D context (ADR 0025,
+ * Consequences): they are not in the file. A block that registers a
+ * {@link BlockSvgPainterExtension} joins without a change here.
+ */
+export declare function canvasSvgModels(std: BlockStdScope): {
+    elements: GfxPrimitiveElementModel[];
+    textBlocks: GfxBlockElementModel[];
+};
+/**
+ * The whole canvas as one SVG document: {@link renderBoardSvg}'s replay of
+ * the canvas renderers, over everything {@link canvasSvgModels} keeps, framed
+ * by the union of what is painted. `null` when there is nothing to draw, or
+ * no {@link CanvasRenderer} to draw it with.
+ */
+export declare function renderCanvasSvg(std: BlockStdScope): 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

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

@@ -1,7 +1,7 @@
 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 { GfxBlockElementModel, GfxControllerIdentifier, GfxPrimitiveElementModel, } 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';
@@ -61,8 +61,8 @@ export function exportBoundOf(frame, elements) {
 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)) {
+    const renderer = canvasRendererOf(std);
+    if (!renderer) {
         throw new Error('SVG export needs the surface to be painted by a CanvasRenderer.');
     }
     const frame = Bound.deserialize(board.xywh);
@@ -89,13 +89,73 @@ export function renderBoardSvg(std, board, given) {
         return null;
     }
     const bound = exportBoundOf(options.framework ? board : drawn[0], drawn);
+    return paintSvg(std, renderer, elements, texts, bound);
+}
+/**
+ * The surface's painter, or `null` when the canvas is not painted by a
+ * {@link CanvasRenderer} (no surface mounted, a DOM renderer): what the SVG
+ * export replays into its own context.
+ */
+export function canvasRendererOf(std) {
+    const renderer = std.get(GfxControllerIdentifier).surfaceComponent?.renderer;
+    return renderer instanceof CanvasRenderer ? renderer : null;
+}
+/**
+ * What the WHOLE canvas export draws: every canvas element and every edgeless
+ * text block this viewer sees (ADR 0031: what they hid is neither painted nor
+ * allowed to widen the picture), in the canvas' own z-order.
+ *
+ * The canvas' other blocks — notes, frames, images, embeds, attachments — are
+ * DOM, and no painter draws them into the 2D context (ADR 0025,
+ * Consequences): they are not in the file. A block that registers a
+ * {@link BlockSvgPainterExtension} joins without a change here.
+ */
+export function canvasSvgModels(std) {
+    const gfx = std.get(GfxControllerIdentifier);
+    const elements = [];
+    const textBlocks = [];
+    for (const model of [...gfx.gfxElements].sort(gfx.layer.compare)) {
+        if (gfx.localVisibility.isHidden(model))
+            continue;
+        if (model instanceof GfxPrimitiveElementModel) {
+            elements.push(model);
+        }
+        else if (model instanceof GfxBlockElementModel &&
+            std.getOptional(BlockSvgPainterIdentifier(model.flavour))) {
+            textBlocks.push(model);
+        }
+    }
+    return { elements, textBlocks };
+}
+/**
+ * The whole canvas as one SVG document: {@link renderBoardSvg}'s replay of
+ * the canvas renderers, over everything {@link canvasSvgModels} keeps, framed
+ * by the union of what is painted. `null` when there is nothing to draw, or
+ * no {@link CanvasRenderer} to draw it with.
+ */
+export function renderCanvasSvg(std) {
+    const renderer = canvasRendererOf(std);
+    if (!renderer)
+        return null;
+    const { elements, textBlocks } = canvasSvgModels(std);
+    const drawn = [...elements, ...textBlocks];
+    const [first] = drawn;
+    if (!first)
+        return null;
+    return paintSvg(std, renderer, elements, textBlocks, exportBoundOf(first, drawn));
+}
+/**
+ * Replay `elements` and `texts` into an SVG-emitting 2D context framed by
+ * `bound`, 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.
+ */
+function paintSvg(std, renderer, elements, texts, bound) {
+    const gfx = std.get(GfxControllerIdentifier);
     return runWithRecordingPath2D(() => {
         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)) {

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

@@ -1,3 +1,4 @@
+import { BOARD_SVG_MARKER_VERSION } from './marker-version.js';
 /**
  * A 2D context that records an SVG document instead of pixels, shaped so the
  * existing canvas renderers can paint into it unchanged.
@@ -54,10 +55,4 @@ 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 {};
+export { BOARD_SVG_MARKER_VERSION };

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

@@ -1,5 +1,6 @@
 import { parseCssColor } from '../../../affine-shared/adapters/index.js';
 import { Context } from 'svgcanvas/dist/svgcanvas.esm.js';
+import { BOARD_SVG_MARKER_VERSION } from './marker-version.js';
 const PATH_OPS = ['fill', 'stroke', 'clip'];
 /** Marks a {@link RecordingPath2D} and carries what it recorded. */
 const RECORDED_D = Symbol('labre.export-svg.recorded-d');
@@ -330,9 +331,4 @@ export function createSvgContext(width, height) {
         },
     };
 }
-/**
- * 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';
+export { BOARD_SVG_MARKER_VERSION };

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

@@ -3,12 +3,14 @@ export * from './canvas-grid/index.js';
 export * from './clipboard-config.js';
 export * from './crud-extension.js';
 export * from './dom-element-renderer.js';
+export * from './drawio-export/index.js';
 export * from './edit-props-middleware-builder.js';
 export * from './editor-anchored-panel.js';
 export * from './element-renderer.js';
 export * from './export-manager/index.js';
 export * from './export-svg/index.js';
 export * from './interchange.js';
+export * from './interchange-export.js';
 export * from './interchange-import.js';
 export * from './legacy-slot-extension.js';
 export * from './legend.js';

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

@@ -3,12 +3,14 @@ export * from './canvas-grid/index.js';
 export * from './clipboard-config.js';
 export * from './crud-extension.js';
 export * from './dom-element-renderer.js';
+export * from './drawio-export/index.js';
 export * from './edit-props-middleware-builder.js';
 export * from './editor-anchored-panel.js';
 export * from './element-renderer.js';
 export * from './export-manager/index.js';
 export * from './export-svg/index.js';
 export * from './interchange.js';
+export * from './interchange-export.js';
 export * from './interchange-import.js';
 export * from './legacy-slot-extension.js';
 export * from './legend.js';

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

@@ -0,0 +1,84 @@
+import { type ChromeWording } from '../../affine-shared/services/index.js';
+import { type AnyCommandDescriptor, type BlockStdScope, type CommandFile, type FrameworkId } from '../../std/index.js';
+import { type InterchangeExportCapability } from './interchange.js';
+/**
+ * **One "This view" export per `*:export` capability a framework registered**
+ * (ADR 0034, amendment of 2026-10-14; ADR 0012).
+ *
+ * The registry already answers "what can Labre write, for which framework";
+ * this projects that answer into view actions, the way the senior sub-menu is
+ * a projection of the command descriptors. Nothing is declared per framework:
+ * a capability registered from a framework's FLAG-GATED view extension yields
+ * its action, a framework switched off registers no capability and therefore
+ * lists no action (ADR 0009: a flag gates tooling), and the next framework that
+ * declares an exporter is listed with no change here.
+ *
+ * Read off the registry at the moment the host lists the view's actions, NOT
+ * registered as commands: a command enters the static registry
+ * (`getCommands`), and from there every projection of it — the catalogue that
+ * must hold every framework command, the per-framework counts, the senior
+ * row's cap, Settings › Shortcuts — would grow by one row per format for an
+ * entry that only a host menu draws. Each framework keeps its own selection
+ * export (`bpmn.exportXml`, `uml.exportXmi`…) on its toolbar, catalogue and
+ * palette; this is the whole-board twin a page-level "Export…" lists.
+ *
+ * The canvas's own capabilities (owner `'canvas'`, `canvas:drawio:export`)
+ * are left out: they have their hand-written command (`canvas.export.drawio`),
+ * and a second entry would list draw.io twice.
+ */
+/** "Export BPMN as .bpmn" — the framework's name, the format's extension. */
+export declare const INTERCHANGE_EXPORT_LABEL: ChromeWording;
+/** The notice's title when the writer could not say everything. */
+export declare const INTERCHANGE_EXPORT_WARNINGS: ChromeWording;
+export declare const INTERCHANGE_EXPORT_WORDINGS: readonly ChromeWording[];
+/** One icon for every format: the registry declares none of its own. */
+export declare const INTERCHANGE_EXPORT_ICON_KEY = "canvas.export.interchange";
+/**
+ * `canvas.export.<framework>.<format>` — `canvas.export.bpmn.bpmn`,
+ * `canvas.export.uml.xmi`. The framework is part of the id because a format
+ * id is not unique across owners (`drawio` is UML's reader and the canvas's
+ * writer). Stable: a host keys its test ids and icons on it, and usage is
+ * recorded under it.
+ */
+export declare function interchangeExportActionId(capability: InterchangeExportCapability): string;
+/**
+ * The whole board as the capability writes it, or `null` when the canvas
+ * holds nothing of its framework.
+ *
+ * The WHOLE surface in document order, never the selection and never what
+ * this viewer hid: a semantic export is a statement about the board, and
+ * logic keeps what a viewer hid (ADR 0031) — the selection exports stay the
+ * framework's own commands. The raw page title goes in, the capability makes
+ * it safe to write to disk (`InterchangeExportContext.name`).
+ */
+export declare function interchangeExportFile(std: BlockStdScope, capability: InterchangeExportCapability): {
+    file: CommandFile;
+    warnings: readonly string[];
+} | null;
+/**
+ * The view action of one capability. `owner` and `telemetry` name the
+ * framework, so `runCommand` reports the export as that framework's
+ * (`FrameworkElementAdded`, element `canvas:export-<format>`, module
+ * `<framework> view-menu`). It READS: offered on a read-only page. Listed
+ * only while the canvas holds an element of that framework (its role's
+ * namespace): an export of nothing is not an export.
+ *
+ * A warning is never an error — the file is valid. What the writer could not
+ * say goes to the notification seam, in its own English words (the
+ * capability's `warnings` carry no key); with no seam, it is dropped.
+ */
+export declare function interchangeExportCommand(capability: InterchangeExportCapability & {
+    framework: FrameworkId;
+}): AnyCommandDescriptor;
+/** A derived view action and the capability it runs. */
+export interface InterchangeExportAction {
+    command: AnyCommandDescriptor;
+    capability: InterchangeExportCapability & {
+        framework: FrameworkId;
+    };
+}
+/**
+ * Every framework export this editor offers now, in the registry's id order:
+ * what the registry holds, so what the flags let through.
+ */
+export declare function interchangeExportActions(std: BlockStdScope): InterchangeExportAction[];

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

@@ -0,0 +1,150 @@
+import { NotificationProvider, translateKey, } from '../../affine-shared/services/index.js';
+import { downloadBlob } from '../../affine-shared/utils/index.js';
+import { FRAMEWORK_IDS, frameworkOfRole, } from '../../std/index.js';
+import { GfxControllerIdentifier } from '../../std/gfx/index.js';
+import { interchangeCapabilities, } from './interchange.js';
+/**
+ * **One "This view" export per `*:export` capability a framework registered**
+ * (ADR 0034, amendment of 2026-10-14; ADR 0012).
+ *
+ * The registry already answers "what can Labre write, for which framework";
+ * this projects that answer into view actions, the way the senior sub-menu is
+ * a projection of the command descriptors. Nothing is declared per framework:
+ * a capability registered from a framework's FLAG-GATED view extension yields
+ * its action, a framework switched off registers no capability and therefore
+ * lists no action (ADR 0009: a flag gates tooling), and the next framework that
+ * declares an exporter is listed with no change here.
+ *
+ * Read off the registry at the moment the host lists the view's actions, NOT
+ * registered as commands: a command enters the static registry
+ * (`getCommands`), and from there every projection of it — the catalogue that
+ * must hold every framework command, the per-framework counts, the senior
+ * row's cap, Settings › Shortcuts — would grow by one row per format for an
+ * entry that only a host menu draws. Each framework keeps its own selection
+ * export (`bpmn.exportXml`, `uml.exportXmi`…) on its toolbar, catalogue and
+ * palette; this is the whole-board twin a page-level "Export…" lists.
+ *
+ * The canvas's own capabilities (owner `'canvas'`, `canvas:drawio:export`)
+ * are left out: they have their hand-written command (`canvas.export.drawio`),
+ * and a second entry would list draw.io twice.
+ */
+/** "Export BPMN as .bpmn" — the framework's name, the format's extension. */
+export const INTERCHANGE_EXPORT_LABEL = [
+    'com.labre.command.canvas.export.interchange',
+    'Export {{framework}} as {{extension}}',
+];
+/** The notice's title when the writer could not say everything. */
+export const INTERCHANGE_EXPORT_WARNINGS = [
+    'com.labre.command.canvas.export.interchange.warnings',
+    'What this export could not write down',
+];
+export const INTERCHANGE_EXPORT_WORDINGS = [
+    INTERCHANGE_EXPORT_LABEL,
+    INTERCHANGE_EXPORT_WARNINGS,
+];
+/** One icon for every format: the registry declares none of its own. */
+export const INTERCHANGE_EXPORT_ICON_KEY = 'canvas.export.interchange';
+/**
+ * `canvas.export.<framework>.<format>` — `canvas.export.bpmn.bpmn`,
+ * `canvas.export.uml.xmi`. The framework is part of the id because a format
+ * id is not unique across owners (`drawio` is UML's reader and the canvas's
+ * writer). Stable: a host keys its test ids and icons on it, and usage is
+ * recorded under it.
+ */
+export function interchangeExportActionId(capability) {
+    return `canvas.export.${capability.framework}.${capability.format.id}`;
+}
+const isFrameworkId = (id) => FRAMEWORK_IDS.includes(id);
+function surfaceElementsOf(std) {
+    return std.get(GfxControllerIdentifier).surface?.elementModels ?? [];
+}
+/**
+ * The whole board as the capability writes it, or `null` when the canvas
+ * holds nothing of its framework.
+ *
+ * The WHOLE surface in document order, never the selection and never what
+ * this viewer hid: a semantic export is a statement about the board, and
+ * logic keeps what a viewer hid (ADR 0031) — the selection exports stay the
+ * framework's own commands. The raw page title goes in, the capability makes
+ * it safe to write to disk (`InterchangeExportContext.name`).
+ */
+export function interchangeExportFile(std, capability) {
+    const elements = surfaceElementsOf(std);
+    if (!elements.some(e => frameworkOfRole(e.role) === capability.framework)) {
+        return null;
+    }
+    const title = std.store.workspace.meta.getDocMeta(std.store.id)?.title;
+    const { text, filename, mime, warnings } = capability.run(elements, {
+        name: title,
+    });
+    return {
+        // The charset is the browser's business, not the format's.
+        file: {
+            blob: new Blob([text], { type: `${mime};charset=utf-8` }),
+            filename,
+        },
+        warnings: warnings ?? [],
+    };
+}
+/**
+ * The view action of one capability. `owner` and `telemetry` name the
+ * framework, so `runCommand` reports the export as that framework's
+ * (`FrameworkElementAdded`, element `canvas:export-<format>`, module
+ * `<framework> view-menu`). It READS: offered on a read-only page. Listed
+ * only while the canvas holds an element of that framework (its role's
+ * namespace): an export of nothing is not an export.
+ *
+ * A warning is never an error — the file is valid. What the writer could not
+ * say goes to the notification seam, in its own English words (the
+ * capability's `warnings` carry no key); with no seam, it is dropped.
+ */
+export function interchangeExportCommand(capability) {
+    return {
+        id: interchangeExportActionId(capability),
+        owner: capability.framework,
+        kind: 'action',
+        labelKey: INTERCHANGE_EXPORT_LABEL[0],
+        labelFallback: INTERCHANGE_EXPORT_LABEL[1],
+        category: 'export',
+        iconKey: INTERCHANGE_EXPORT_ICON_KEY,
+        surfaces: ['view-menu'],
+        order: 14,
+        scope: 'edgeless',
+        defaultKeys: { mac: [], other: [] },
+        telemetry: {
+            framework: capability.framework,
+            element: `canvas:export-${capability.format.id}`,
+        },
+        when: std => surfaceElementsOf(std).some(e => frameworkOfRole(e.role) === capability.framework),
+        run: (std, _invocation, params) => {
+            const exported = interchangeExportFile(std, capability);
+            if (!exported)
+                return;
+            const deliver = params?.deliver;
+            if (typeof deliver === 'function')
+                deliver(exported.file);
+            else
+                downloadBlob(exported.file.blob, exported.file.filename);
+            if (exported.warnings.length === 0)
+                return;
+            std.getOptional(NotificationProvider)?.notify({
+                title: translateKey(std, ...INTERCHANGE_EXPORT_WARNINGS),
+                message: exported.warnings.join('\n'),
+                accent: 'warning',
+                duration: 8000,
+            });
+        },
+    };
+}
+/**
+ * Every framework export this editor offers now, in the registry's id order:
+ * what the registry holds, so what the flags let through.
+ */
+export function interchangeExportActions(std) {
+    return interchangeCapabilities(std.provider, { direction: 'export' })
+        .filter((capability) => isFrameworkId(capability.framework))
+        .map(capability => ({
+        capability,
+        command: interchangeExportCommand(capability),
+    }));
+}