@formicoidea/labre-core 0.50.0 → 0.52.0

package/dist/_pkgs/affine-block-image/image-resize-manager.js

@@ -1,6 +1,8 @@
+import { ImageBlockModel, readImageCrop } from '../affine-model/index.js';
 import { DocModeProvider } from '../affine-shared/services/index.js';
 import { getClosestBlockComponentByElement, getModelByElement, } from '../affine-shared/utils/index.js';
 import { GfxControllerIdentifier } from '../std/gfx/index.js';
+import { wholeImageSize } from './crop/crop-math.js';
 export class ImageResizeManager {
     constructor() {
         this._activeComponent = null;
@@ -16,6 +18,19 @@ export class ImageResizeManager {
         const dragModel = getModelByElement(this._activeComponent);
         dragModel?.store.captureSync();
         const { width, height } = this._imageContainer.getBoundingClientRect();
+        // A cropped page image shows a window on the picture, but `width` and
+        // `height` stay the size of the WHOLE picture (ADR 0037): the HTML
+        // adapter and an older client draw it whole at that size.
+        const crop = dragModel instanceof ImageBlockModel
+            ? readImageCrop(dragModel.props.crop)
+            : undefined;
+        if (crop) {
+            const img = this._activeComponent.querySelector('img');
+            dragModel?.store.updateBlock(dragModel, wholeImageSize({ w: width / this._zoom, h: height / this._zoom }, crop, img?.naturalWidth && img.naturalHeight
+                ? { width: img.naturalWidth, height: img.naturalHeight }
+                : null));
+            return;
+        }
         dragModel?.store.updateBlock(dragModel, {
             width: width / this._zoom,
             height: height / this._zoom,

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

@@ -1,4 +1,5 @@
 export * from './adapters/index.js';
+export { addImagesFromAssets, addSiblingImageBlocksFromAssets, pickAndAddImages, pickAndAddSiblingImageBlocks, replaceImage, } from './asset-picker.js';
 export * from './commands/index.js';
 export * from './edgeless-clipboard-config.js';
 export * from './image-block.js';

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

@@ -1,4 +1,5 @@
 export * from './adapters/index.js';
+export { addImagesFromAssets, addSiblingImageBlocksFromAssets, pickAndAddImages, pickAndAddSiblingImageBlocks, replaceImage, } from './asset-picker.js';
 export * from './commands/index.js';
 export * from './edgeless-clipboard-config.js';
 export * from './image-block.js';

package/dist/_pkgs/affine-block-image/translations.d.ts

@@ -14,6 +14,16 @@ export declare const IMAGE_SLASH_DESCRIPTION: ChromeWording;
 /** The slash-menu tooltip's own caption, distinct from the item's name. */
 export declare const IMAGE_SLASH_PHOTO_CAPTION: ChromeWording;
 export declare const IMAGE_TOOLBAR_TURN_INTO_CARD_VIEW: ChromeWording;
+/**
+ * « Rogner » (ADR 0037): the toolbar button, its presets and the way back to
+ * the whole picture. The ratios are words too — a host may write « 16/9 ».
+ */
+export declare const IMAGE_TOOLBAR_CROP: ChromeWording;
+export declare const IMAGE_TOOLBAR_CROP_FREE: ChromeWording;
+export declare const IMAGE_TOOLBAR_CROP_16_9: ChromeWording;
+export declare const IMAGE_TOOLBAR_CROP_4_3: ChromeWording;
+export declare const IMAGE_TOOLBAR_CROP_1_1: ChromeWording;
+export declare const IMAGE_TOOLBAR_CROP_ORIGINAL: ChromeWording;
 export declare const IMAGE_PREVIEW_TITLE: ChromeWording;
 /**
  * The upload/download toasts (`utils.ts`) and the resource controller's
@@ -25,6 +35,11 @@ export declare const IMAGE_TOAST_DOWNLOAD_FAILED: ChromeWording;
 export declare const IMAGE_TOAST_DOWNLOADING: ChromeWording;
 export declare const IMAGE_TOAST_COPIED: ChromeWording;
 export declare const IMAGE_TOAST_READ_SIZE_FAILED: ChromeWording;
+/**
+ * The image toolbar's "Replace" (`configs/replace-action.ts`), offered only
+ * with a host asset dialog (`AssetPickerProvider`).
+ */
+export declare const IMAGE_TOOLBAR_REPLACE: ChromeWording;
 /**
  * This package's contribution to the translation-key manifest, listed in
  * `PACKAGE_WORDINGS` under source `chrome`

package/dist/_pkgs/affine-block-image/translations.js

@@ -23,6 +23,34 @@ export const IMAGE_TOOLBAR_TURN_INTO_CARD_VIEW = [
     'com.labre.image.toolbar.turn-into-card-view',
     'Turn into card view',
 ];
+/**
+ * « Rogner » (ADR 0037): the toolbar button, its presets and the way back to
+ * the whole picture. The ratios are words too — a host may write « 16/9 ».
+ */
+export const IMAGE_TOOLBAR_CROP = [
+    'com.labre.image.toolbar.crop',
+    'Crop',
+];
+export const IMAGE_TOOLBAR_CROP_FREE = [
+    'com.labre.image.toolbar.crop.free',
+    'Free',
+];
+export const IMAGE_TOOLBAR_CROP_16_9 = [
+    'com.labre.image.toolbar.crop.ratio-16-9',
+    '16:9',
+];
+export const IMAGE_TOOLBAR_CROP_4_3 = [
+    'com.labre.image.toolbar.crop.ratio-4-3',
+    '4:3',
+];
+export const IMAGE_TOOLBAR_CROP_1_1 = [
+    'com.labre.image.toolbar.crop.ratio-1-1',
+    '1:1',
+];
+export const IMAGE_TOOLBAR_CROP_ORIGINAL = [
+    'com.labre.image.toolbar.crop.original',
+    'Original image',
+];
 export const IMAGE_PREVIEW_TITLE = [
     'com.labre.image.preview.title',
     'Image Block',
@@ -49,6 +77,14 @@ export const IMAGE_TOAST_READ_SIZE_FAILED = [
     'com.labre.image.toast.read-size-failed',
     'Failed to read image size, please try another image',
 ];
+/**
+ * The image toolbar's "Replace" (`configs/replace-action.ts`), offered only
+ * with a host asset dialog (`AssetPickerProvider`).
+ */
+export const IMAGE_TOOLBAR_REPLACE = [
+    'com.labre.image.toolbar.replace',
+    'Replace',
+];
 /**
  * This package's contribution to the translation-key manifest, listed in
  * `PACKAGE_WORDINGS` under source `chrome`
@@ -60,9 +96,16 @@ export const IMAGE_WORDINGS = [
     IMAGE_SLASH_DESCRIPTION,
     IMAGE_SLASH_PHOTO_CAPTION,
     IMAGE_TOOLBAR_TURN_INTO_CARD_VIEW,
+    IMAGE_TOOLBAR_CROP,
+    IMAGE_TOOLBAR_CROP_FREE,
+    IMAGE_TOOLBAR_CROP_16_9,
+    IMAGE_TOOLBAR_CROP_4_3,
+    IMAGE_TOOLBAR_CROP_1_1,
+    IMAGE_TOOLBAR_CROP_ORIGINAL,
     IMAGE_PREVIEW_TITLE,
     IMAGE_TOAST_DOWNLOAD_FAILED,
     IMAGE_TOAST_DOWNLOADING,
     IMAGE_TOAST_COPIED,
     IMAGE_TOAST_READ_SIZE_FAILED,
+    IMAGE_TOOLBAR_REPLACE,
 ];

package/dist/_pkgs/affine-block-image/utils.d.ts

@@ -1,3 +1,4 @@
+import { type ImageBlockProps } from '../affine-model/index.js';
 import { Bound, type IVec } from '../global/gfx/index.js';
 import { type BlockStdScope } from '../std/index.js';
 import type { BlockModel } from '../store/index.js';
@@ -19,5 +20,17 @@ export declare function addImages(std: BlockStdScope, files: File[], options: {
     maxWidth?: number;
     shouldTransformPoint?: boolean;
 }): Promise<string[]>;
+export type ImageBlockSource = Pick<Required<ImageBlockProps>, 'size' | 'sourceId' | 'width' | 'height'>;
+/**
+ * Lays image blocks out on the canvas around `options.point` (the viewport's
+ * centre without one), in the viewer's active layer, and selects them. Shared
+ * by the files path (`addImages`) and the asset path
+ * (`addImagesFromAssets`), which only differ in where `sourceId` comes from.
+ */
+export declare function placeImagesOnCanvas(std: BlockStdScope, propsArray: ImageBlockSource[], options: {
+    point?: IVec;
+    maxWidth?: number;
+    shouldTransformPoint?: boolean;
+}): string[];
 export declare function calcBoundByOrigin(point: IVec, inTopLeft?: boolean, width?: number, height?: number): Bound;
 export declare function duplicate(block: ImageBlockComponent): void;

package/dist/_pkgs/affine-block-image/utils.js

@@ -194,8 +194,17 @@ export async function addImages(std, files, options) {
         return [];
     if (hasExceeded(std, files))
         return [];
-    const flavour = ImageBlockSchema.model.flavour;
     const propsArray = await Promise.all(files.map(file => buildPropsWith(std, file)));
+    return placeImagesOnCanvas(std, propsArray, options);
+}
+/**
+ * Lays image blocks out on the canvas around `options.point` (the viewport's
+ * centre without one), in the viewer's active layer, and selects them. Shared
+ * by the files path (`addImages`) and the asset path
+ * (`addImagesFromAssets`), which only differ in where `sourceId` comes from.
+ */
+export function placeImagesOnCanvas(std, propsArray, options) {
+    const flavour = ImageBlockSchema.model.flavour;
     const gfx = std.get(GfxControllerIdentifier);
     const isMultiple = propsArray.length > 1;
     const inTopLeft = isMultiple;

package/dist/_pkgs/affine-block-root/clipboard/page-clipboard.js

@@ -1,3 +1,4 @@
+import { lonePastedUrl, proposeLinkViews } from '../../affine-inline-link/index.js';
 import { deleteTextCommand } from '../../affine-inline-preset/index.js';
 import { pasteMiddleware, replaceIdMiddleware, surfaceRefToEmbed, uploadMiddleware, } from '../../affine-shared/adapters/index.js';
 import { clearAndSelectFirstModelCommand, deleteSelectedModelsCommand, getBlockIndexCommand, getBlockSelectionsCommand, getImageSelectionsCommand, getSelectedModelsCommand, getTextSelectionCommand, retainFirstModelCommand, } from '../../affine-shared/commands/index.js';
@@ -112,8 +113,12 @@ export class PageClipboard extends ReadOnlyClipboard {
                 if (!ctx.parentBlock) {
                     return;
                 }
+                // A lone URL still pastes as a plain link; its views are then offered,
+                // never applied (labre REQ-IM-1).
+                const url = lonePastedUrl(e.clipboardData?.getData('text/plain'));
                 this.std.clipboard
                     .paste(e, this.std.store, ctx.parentBlock.model.id, ctx.blockIndex ? ctx.blockIndex + 1 : 1)
+                    .then(() => (url ? proposeLinkViews(this.std, url) : false))
                     .catch(console.error);
                 return next();
             })

package/dist/_pkgs/affine-block-root/commands/page-export-commands.d.ts

@@ -0,0 +1,2 @@
+import type { AnyCommandDescriptor } from '../../std/index.js';
+export declare const pageExportCommands: AnyCommandDescriptor[];

package/dist/_pkgs/affine-block-root/commands/page-export-commands.js

@@ -0,0 +1,71 @@
+/**
+ * `page.export.markdown` and `page.export.html` — the page as a Markdown or an
+ * HTML file, through the adapters the library already ships
+ * (`MarkdownTransformer.docFile`, `HtmlTransformer.docFile`).
+ *
+ * View actions (ADR 0034, amendments of 2026-10-13 and 2026-10-14): on the
+ * `'view-menu'` surface under the `'export'` category, so a host lists them
+ * with every other export of the view it shows (`getViewExports`,
+ * `@labre/affine/host-panels`), and on the palette. Given `params.deliver`
+ * (`runViewAction`) the file goes to the host and nothing is downloaded;
+ * without it (the palette, a bound chord) the command downloads it itself.
+ *
+ * `scope: 'global'`: the page's text is the same in both views — the notes of
+ * a canvas are the page's paragraphs — so both views list them. A page whose
+ * blocks reference images or attachments comes out as a zip, the file
+ * (`index.md` / `index.html`) beside an `assets/` folder its links point at.
+ *
+ * `owner: 'core'` and no `telemetry` (it names no framework, like the canvas
+ * exports); `runCommand` still records usage. It READS: no read-only guard.
+ * Not `'agent'`: an agent turn would drop a file the user did not ask for.
+ */
+import { downloadBlob } from '../../affine-shared/utils/index.js';
+import { HtmlTransformer, MarkdownTransformer, } from '../../affine-widget-linked-doc/index.js';
+async function exportPage(std, render, params) {
+    const file = await render(std);
+    if (!file)
+        return;
+    const deliver = params?.deliver;
+    if (typeof deliver === 'function')
+        deliver(file);
+    else
+        downloadBlob(file.blob, file.filename);
+}
+const exportMarkdown = {
+    id: 'page.export.markdown',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.page.export.markdown',
+    labelFallback: 'Export as Markdown',
+    descriptionKey: 'com.labre.command.page.export.markdown.description',
+    descriptionFallback: 'Download the page as a Markdown file, in a zip with its images when it has any.',
+    category: 'export',
+    iconKey: 'page.export.markdown',
+    keywords: ['markdown', 'md', 'export', 'download'],
+    surfaces: ['view-menu', 'palette'],
+    order: 15,
+    scope: 'global',
+    defaultKeys: { mac: [], other: [] },
+    run: (std, _invocation, params) => exportPage(std, ({ store }) => MarkdownTransformer.docFile(store), params),
+};
+const exportHtml = {
+    id: 'page.export.html',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.page.export.html',
+    labelFallback: 'Export as HTML',
+    descriptionKey: 'com.labre.command.page.export.html.description',
+    descriptionFallback: 'Download the page as an HTML file, in a zip with its images when it has any.',
+    category: 'export',
+    iconKey: 'page.export.html',
+    keywords: ['html', 'web', 'export', 'download'],
+    surfaces: ['view-menu', 'palette'],
+    order: 16,
+    scope: 'global',
+    defaultKeys: { mac: [], other: [] },
+    run: (std, _invocation, params) => exportPage(std, ({ store }) => HtmlTransformer.docFile(store), params),
+};
+export const pageExportCommands = [
+    exportMarkdown,
+    exportHtml,
+];

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

@@ -1,6 +1,7 @@
 export * from './adapters/index.js';
 export * from './clipboard/index.js';
 export * from './commands/copy-link-commands.js';
+export * from './commands/page-export-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,6 +1,7 @@
 export * from './adapters/index.js';
 export * from './clipboard/index.js';
 export * from './commands/copy-link-commands.js';
+export * from './commands/page-export-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

@@ -1,3 +1,4 @@
+import { ExportToHtmlIcon, ExportToMarkdownIcon } from '@blocksuite/icons/lit';
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
 import { NoteBlockSchema } from '../affine-model/index.js';
 import { ToolbarModuleExtension, ViewportElementExtension, } from '../affine-shared/services/index.js';
@@ -5,6 +6,7 @@ import { BlockFlavourIdentifier, BlockViewExtension, FlavourExtension, CommandEx
 import { literal } from 'lit/static-html.js';
 import { PageClipboard, ReadOnlyClipboard } from './clipboard/index.js';
 import { copyLinkCommands } from './commands/copy-link-commands.js';
+import { pageExportCommands } from './commands/page-export-commands.js';
 import { pivotCommands } from './commands/pivot-commands.js';
 import { readingCommands } from './commands/reading-commands.js';
 import { tagCommands } from './commands/tag-commands.js';
@@ -73,6 +75,12 @@ export class RootViewExtension extends ViewExtensionProvider {
                 ...readingCommands,
                 ...copyLinkCommands,
             ]),
+            // The page as Markdown or HTML (ADR 0034, amendment of 2026-10-14):
+            // view actions of both views, never gated — the page's own text.
+            CommandExtension(pageExportCommands, {
+                'page.export.markdown': ExportToMarkdownIcon(),
+                'page.export.html': ExportToHtmlIcon(),
+            }),
             ShortcutKeymapExtension('global'),
             ToolbarModuleExtension({
                 id: BlockFlavourIdentifier(NoteBlockSchema.model.flavour),

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

@@ -0,0 +1,30 @@
+import { type InterchangeExportCapability, type InterchangeFormat } from '../interchange.js';
+/**
+ * The owner of what the CANVAS writes, whatever drew on it (`docs/adr/0019`,
+ * amendment of 2026-10-14).
+ *
+ * The registry's `framework` field names who owns the vocabulary a capability
+ * speaks (`docs/adr/0012` P1). A generic rendering speaks none — a shape, a
+ * line, a group — so its owner is the canvas itself, the owner `'core'` plays
+ * for the canvas's PNG export in the command registry. Unlike a framework's,
+ * this capability is registered UNCONDITIONALLY, from the surface's own view
+ * extension: no flag gates a picture of what is on the canvas
+ * (`interchange-gating.unit.spec.ts` pins that it survives every flag off).
+ */
+export declare const CANVAS_INTERCHANGE_OWNER = "canvas";
+/**
+ * draw.io, as the canvas writes it. **Visual** (`docs/adr/0012` P2): the file
+ * carries a drawing, so no round trip is promised and none is implied — the
+ * same tier, id and extensions as UML's draw.io READER (`UML_DRAWIO_FORMAT`),
+ * because it is the same format, read and written by two owners.
+ */
+export declare const CANVAS_DRAWIO_FORMAT: InterchangeFormat;
+/**
+ * `canvas:drawio:export` — the canvas, or a selection of it, as one
+ * uncompressed draw.io page. `run` is {@link exportCanvasDrawio}, the pure
+ * writer labre-mcp can call directly; the `canvas.export.drawio` command
+ * calls THIS, so the two cannot write different bytes.
+ */
+export declare const CANVAS_DRAWIO_EXPORT: InterchangeExportCapability;
+/** Everything the canvas registers, for the surface's view extension. */
+export declare const CANVAS_INTERCHANGE: readonly InterchangeExportCapability[];

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

@@ -0,0 +1,44 @@
+import { interchangeCapabilityId, } from '../interchange.js';
+import { DRAWIO_EXTENSION, DRAWIO_MIME, exportCanvasDrawio } from './writer.js';
+/**
+ * The owner of what the CANVAS writes, whatever drew on it (`docs/adr/0019`,
+ * amendment of 2026-10-14).
+ *
+ * The registry's `framework` field names who owns the vocabulary a capability
+ * speaks (`docs/adr/0012` P1). A generic rendering speaks none — a shape, a
+ * line, a group — so its owner is the canvas itself, the owner `'core'` plays
+ * for the canvas's PNG export in the command registry. Unlike a framework's,
+ * this capability is registered UNCONDITIONALLY, from the surface's own view
+ * extension: no flag gates a picture of what is on the canvas
+ * (`interchange-gating.unit.spec.ts` pins that it survives every flag off).
+ */
+export const CANVAS_INTERCHANGE_OWNER = 'canvas';
+/**
+ * draw.io, as the canvas writes it. **Visual** (`docs/adr/0012` P2): the file
+ * carries a drawing, so no round trip is promised and none is implied — the
+ * same tier, id and extensions as UML's draw.io READER (`UML_DRAWIO_FORMAT`),
+ * because it is the same format, read and written by two owners.
+ */
+export const CANVAS_DRAWIO_FORMAT = {
+    id: 'drawio',
+    tier: 'visual',
+    extensions: [DRAWIO_EXTENSION, '.drawio.xml', '.xml'],
+    mime: DRAWIO_MIME,
+};
+/**
+ * `canvas:drawio:export` — the canvas, or a selection of it, as one
+ * uncompressed draw.io page. `run` is {@link exportCanvasDrawio}, the pure
+ * writer labre-mcp can call directly; the `canvas.export.drawio` command
+ * calls THIS, so the two cannot write different bytes.
+ */
+export const CANVAS_DRAWIO_EXPORT = {
+    id: interchangeCapabilityId(CANVAS_INTERCHANGE_OWNER, CANVAS_DRAWIO_FORMAT.id, 'export'),
+    framework: CANVAS_INTERCHANGE_OWNER,
+    format: CANVAS_DRAWIO_FORMAT,
+    direction: 'export',
+    run: exportCanvasDrawio,
+};
+/** Everything the canvas registers, for the surface's view extension. */
+export const CANVAS_INTERCHANGE = [
+    CANVAS_DRAWIO_EXPORT,
+];

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

@@ -0,0 +1,26 @@
+/**
+ * A stored colour as draw.io can paint it: `#RRGGBB`, or `none`.
+ *
+ * draw.io has none of our variables, so every colour is RESOLVED to a value
+ * here, the way `ThemeProvider.getColorValue(color, fallback, true)` resolves
+ * one for a canvas painter — without its DOM, which a pure writer has none of:
+ * a `{ light, dark }` pair takes its LIGHT side (a file is printed on white), a
+ * legacy `--affine-*` name is looked up in the same static table the theme
+ * service reads, and a `var(--…)` inside that table is followed, a bounded
+ * number of hops.
+ *
+ * `opacity` is the alpha a value carried (`rgba(…, .5)`, `#rrggbbaa`), in
+ * draw.io's percent, and only when it is below 100: the style keys draw.io
+ * takes it under differ per use (`fillOpacity`, `strokeOpacity`), so the
+ * caller names the key.
+ */
+export interface DrawioColor {
+    value: string;
+    opacity?: number;
+}
+/**
+ * Resolve a stored {@link Color} for the file. `undefined` when there is
+ * nothing to say (no colour stored, or one this writer cannot read), so the
+ * caller leaves draw.io's own default in place rather than writing a guess.
+ */
+export declare function drawioColor(color: unknown): DrawioColor | undefined;

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

@@ -0,0 +1,82 @@
+import { ColorScheme, resolveColor } from '../../../affine-model/index.js';
+import { combinedLightCssVariables } from '@toeverything/theme';
+const NONE = { value: 'none' };
+/** How many `var(--…)` hops a value may take before it is given up on. */
+const MAX_VAR_HOPS = 4;
+const VAR = /^var\(\s*(--[\w-]+)\s*(?:,[^)]*)?\)$/;
+const HEX = /^#([\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/i;
+const RGB = /^rgba?\(([^)]*)\)$/i;
+const hex2 = (channel) => Math.round(Math.min(255, Math.max(0, channel)))
+    .toString(16)
+    .padStart(2, '0');
+function withAlpha(rgb, alpha) {
+    if (alpha <= 0)
+        return NONE;
+    const value = `#${rgb.map(hex2).join('')}`.toUpperCase();
+    return alpha < 1 ? { value, opacity: Math.round(alpha * 100) } : { value };
+}
+function parseValue(raw) {
+    const value = raw.trim();
+    if (!value)
+        return undefined;
+    if (value.toLowerCase() === 'transparent' || value.toLowerCase() === 'none') {
+        return NONE;
+    }
+    const hex = HEX.exec(value)?.[1];
+    if (hex) {
+        const full = hex.length <= 4
+            ? [...hex].map(digit => digit + digit).join('')
+            : hex.toLowerCase();
+        const channel = (at) => Number.parseInt(full.slice(at, at + 2), 16);
+        return withAlpha([channel(0), channel(2), channel(4)], full.length === 8 ? channel(6) / 255 : 1);
+    }
+    const rgb = RGB.exec(value)?.[1];
+    if (rgb) {
+        const parts = rgb
+            .split(/[\s,/]+/)
+            .filter(Boolean)
+            .map(part => part.endsWith('%')
+            ? (Number.parseFloat(part) / 100) * 255
+            : Number.parseFloat(part));
+        const [r, g, b] = parts;
+        if (r === undefined ||
+            g === undefined ||
+            b === undefined ||
+            ![r, g, b].every(Number.isFinite)) {
+            return undefined;
+        }
+        // The alpha of `rgba(…, 50%)` was scaled as a channel above; undo that.
+        const rawAlpha = rgb.split(/[\s,/]+/).filter(Boolean)[3];
+        const alpha = rawAlpha === undefined
+            ? 1
+            : rawAlpha.endsWith('%')
+                ? Number.parseFloat(rawAlpha) / 100
+                : Number.parseFloat(rawAlpha);
+        return withAlpha([r, g, b], Number.isFinite(alpha) ? alpha : 1);
+    }
+    return undefined;
+}
+/**
+ * Resolve a stored {@link Color} for the file. `undefined` when there is
+ * nothing to say (no colour stored, or one this writer cannot read), so the
+ * caller leaves draw.io's own default in place rather than writing a guess.
+ */
+export function drawioColor(color) {
+    if (color === undefined || color === null || color === '')
+        return undefined;
+    if (typeof color !== 'string' && typeof color !== 'object')
+        return undefined;
+    let value = resolveColor(color, ColorScheme.Light, '');
+    for (let hop = 0; hop <= MAX_VAR_HOPS; hop++) {
+        const name = value.startsWith('--') ? value : VAR.exec(value)?.[1];
+        if (!name)
+            return parseValue(value);
+        if (name.endsWith('transparent'))
+            return NONE;
+        const next = combinedLightCssVariables[name];
+        if (!next)
+            return undefined;
+        value = next;
+    }
+    return undefined;
+}

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

@@ -0,0 +1,18 @@
+import type { AnyCommandDescriptor, BlockStdScope, CommandFile } from '../../../std/index.js';
+import { type GfxModel } from '../../../std/gfx/index.js';
+/**
+ * What the export takes: the selection when there is one, the whole canvas
+ * otherwise — in the canvas's own z-order, and as this viewer SEES it (ADR
+ * 0031: what they hid is neither painted nor exported, the PNG's rule).
+ *
+ * A selected group or frame brings what it holds: selecting a classifier
+ * selects its group, and a group exported without its shape and its words
+ * would be an empty box.
+ */
+export declare function canvasDrawioSource(std: BlockStdScope): GfxModel[];
+/**
+ * The canvas (or its selection) as a draw.io file, or `null` when there is
+ * nothing on it. Through the declared capability, never round it.
+ */
+export declare function canvasDrawioFile(std: BlockStdScope): CommandFile | null;
+export declare const canvasDrawioExportCommands: AnyCommandDescriptor[];

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

@@ -0,0 +1,91 @@
+import { downloadBlob } from '../../../affine-shared/utils/index.js';
+import { GfxBlockElementModel, GfxControllerIdentifier, GfxPrimitiveElementModel, } from '../../../std/gfx/index.js';
+import { CANVAS_DRAWIO_EXPORT } from './capability.js';
+/**
+ * What the export takes: the selection when there is one, the whole canvas
+ * otherwise — in the canvas's own z-order, and as this viewer SEES it (ADR
+ * 0031: what they hid is neither painted nor exported, the PNG's rule).
+ *
+ * A selected group or frame brings what it holds: selecting a classifier
+ * selects its group, and a group exported without its shape and its words
+ * would be an empty box.
+ */
+export function canvasDrawioSource(std) {
+    const gfx = std.get(GfxControllerIdentifier);
+    const selection = gfx.selection.editing ? [] : gfx.selection.selectedElements;
+    let models;
+    if (selection.length === 0) {
+        models = gfx.gfxElements;
+    }
+    else {
+        const picked = new Set();
+        for (const model of selection) {
+            picked.add(model);
+            const descendants = model
+                .descendantElements;
+            if (Array.isArray(descendants)) {
+                for (const descendant of descendants) {
+                    picked.add(descendant);
+                }
+            }
+        }
+        models = [...picked];
+    }
+    return models
+        .filter(model => !gfx.localVisibility.isHidden(model))
+        .sort((a, b) => gfx.layer.compare(a, b));
+}
+/**
+ * The canvas (or its selection) as a draw.io file, or `null` when there is
+ * nothing on it. Through the declared capability, never round it.
+ */
+export function canvasDrawioFile(std) {
+    const models = canvasDrawioSource(std);
+    if (models.length === 0)
+        return null;
+    const { text, filename, mime } = CANVAS_DRAWIO_EXPORT.run(models.filter((model) => model instanceof GfxPrimitiveElementModel), {
+        name: std.store.workspace.meta.getDocMeta(std.store.id)?.title,
+        blocks: models.filter((model) => model instanceof GfxBlockElementModel),
+    });
+    return { blob: new Blob([text], { type: mime }), filename };
+}
+/**
+ * "Export as draw.io", the third export of the canvas's "This view" section
+ * (ADR 0034, amendment of 2026-10-13), on the model of `canvas.export.png`:
+ * given `params.deliver` it hands the file over and downloads nothing
+ * (`runViewAction`), without it (the palette) it downloads the file itself.
+ *
+ * `owner: 'core'` and never gated, for the PNG's reason: a picture of what is
+ * on the canvas is not a framework's tooling. Not `'agent'`: an agent turn
+ * would drop a file the user did not ask for. It READS, so no read-only guard.
+ * Nothing to export, no file and no error.
+ */
+const exportDrawio = {
+    id: 'canvas.export.drawio',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.canvas.export.drawio',
+    labelFallback: 'Export as draw.io',
+    descriptionKey: 'com.labre.command.canvas.export.drawio.description',
+    descriptionFallback: 'Download the selection, or the whole canvas, as a draw.io drawing: shapes, lines and words, best effort, no round trip.',
+    category: 'export',
+    iconKey: 'canvas.export.drawio',
+    keywords: ['drawio', 'draw.io', 'diagrams.net', 'mxgraph', 'export'],
+    surfaces: ['view-menu', 'palette'],
+    order: 12,
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    run: (std, _invocation, params) => {
+        const file = canvasDrawioFile(std);
+        if (!file)
+            return;
+        const deliver = params?.deliver;
+        if (typeof deliver === 'function')
+            deliver(file);
+        else
+            downloadBlob(file.blob, file.filename);
+    },
+};
+export const canvasDrawioExportCommands = [
+    exportDrawio,
+];

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

@@ -0,0 +1,3 @@
+export { CANVAS_DRAWIO_EXPORT, CANVAS_DRAWIO_FORMAT, CANVAS_INTERCHANGE, CANVAS_INTERCHANGE_OWNER, } from './capability.js';
+export { canvasDrawioExportCommands, canvasDrawioFile, canvasDrawioSource, } from './command.js';
+export { exportCanvasDrawio } from './writer.js';

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

@@ -0,0 +1,3 @@
+export { CANVAS_DRAWIO_EXPORT, CANVAS_DRAWIO_FORMAT, CANVAS_INTERCHANGE, CANVAS_INTERCHANGE_OWNER, } from './capability.js';
+export { canvasDrawioExportCommands, canvasDrawioFile, canvasDrawioSource, } from './command.js';
+export { exportCanvasDrawio } from './writer.js';