@formicoidea/labre-core 0.46.2 → 0.47.0

package/dist/_pkgs/affine-block-data-view/columns/index.d.ts

@@ -6,7 +6,7 @@ export declare const queryBlockColumns: (PropertyMetaConfig<"checkbox", {}, bool
         color: string;
     }[];
 }, string[], string[]> | PropertyMetaConfig<"number", {
-    format: "number" | "numberWithCommas" | "percent" | "currencyYen" | "currencyINR" | "currencyCNY" | "currencyUSD" | "currencyEUR" | "currencyGBP";
+    format: "number" | "percent" | "numberWithCommas" | "currencyINR" | "currencyYen" | "currencyCNY" | "currencyUSD" | "currencyEUR" | "currencyGBP";
     decimal?: number | undefined;
 }, number | null, number | null> | PropertyMetaConfig<"progress", {}, number, number> | PropertyMetaConfig<"select", {
     options: {

package/dist/_pkgs/affine-block-database/data-source.d.ts

@@ -25,7 +25,7 @@ export declare class DatabaseBlockDataSource extends ExternalDataSourceBase {
             color: string;
         }[];
     }, string[], string[]> | PropertyMetaConfig<"number", {
-        format: "number" | "numberWithCommas" | "percent" | "currencyYen" | "currencyINR" | "currencyCNY" | "currencyUSD" | "currencyEUR" | "currencyGBP";
+        format: "number" | "percent" | "numberWithCommas" | "currencyINR" | "currencyYen" | "currencyCNY" | "currencyUSD" | "currencyEUR" | "currencyGBP";
         decimal?: number | undefined;
     }, number | null, number | null> | PropertyMetaConfig<"progress", {}, number, number> | PropertyMetaConfig<"select", {
         options: {

package/dist/_pkgs/affine-block-database/properties/converts.d.ts

@@ -18,14 +18,14 @@ export declare const databasePropertyConverts: ({
     from: any;
     to: any;
     convert: import("../index.js").ConvertFunction<import("../index.js").PropertyModel<"number", {
-        format: "number" | "numberWithCommas" | "percent" | "currencyYen" | "currencyINR" | "currencyCNY" | "currencyUSD" | "currencyEUR" | "currencyGBP";
+        format: "number" | "percent" | "numberWithCommas" | "currencyINR" | "currencyYen" | "currencyCNY" | "currencyUSD" | "currencyEUR" | "currencyGBP";
         decimal?: number | undefined;
     }, number | null, number | null>, import("../index.js").PropertyModel<"progress", {}, number, number>>;
 } | {
     from: any;
     to: any;
     convert: import("../index.js").ConvertFunction<import("../index.js").PropertyModel<"progress", {}, number, number>, import("../index.js").PropertyModel<"number", {
-        format: "number" | "numberWithCommas" | "percent" | "currencyYen" | "currencyINR" | "currencyCNY" | "currencyUSD" | "currencyEUR" | "currencyGBP";
+        format: "number" | "percent" | "numberWithCommas" | "currencyINR" | "currencyYen" | "currencyCNY" | "currencyUSD" | "currencyEUR" | "currencyGBP";
         decimal?: number | undefined;
     }, number | null, number | null>>;
 } | {
@@ -68,7 +68,7 @@ export declare const databasePropertyConverts: ({
     from: any;
     to: any;
     convert: import("../index.js").ConvertFunction<import("../index.js").PropertyModel<"rich-text", {}, import("./rich-text/define.js").RichTextCellType | undefined, string>, import("../index.js").PropertyModel<"number", {
-        format: "number" | "numberWithCommas" | "percent" | "currencyYen" | "currencyINR" | "currencyCNY" | "currencyUSD" | "currencyEUR" | "currencyGBP";
+        format: "number" | "percent" | "numberWithCommas" | "currencyINR" | "currencyYen" | "currencyCNY" | "currencyUSD" | "currencyEUR" | "currencyGBP";
         decimal?: number | undefined;
     }, number | null, number | null>>;
 } | {
@@ -97,7 +97,7 @@ export declare const databasePropertyConverts: ({
     from: any;
     to: any;
     convert: import("../index.js").ConvertFunction<import("../index.js").PropertyModel<"number", {
-        format: "number" | "numberWithCommas" | "percent" | "currencyYen" | "currencyINR" | "currencyCNY" | "currencyUSD" | "currencyEUR" | "currencyGBP";
+        format: "number" | "percent" | "numberWithCommas" | "currencyINR" | "currencyYen" | "currencyCNY" | "currencyUSD" | "currencyEUR" | "currencyGBP";
         decimal?: number | undefined;
     }, number | null, number | null>, import("../index.js").PropertyModel<"rich-text", {}, import("./rich-text/define.js").RichTextCellType | undefined, string>>;
 } | {

package/dist/_pkgs/affine-block-database/properties/index.d.ts

@@ -10,7 +10,7 @@ export declare const databaseBlockProperties: {
         }[];
     }, string[], string[]>;
     numberColumnConfig: import("../index.js").PropertyMetaConfig<"number", {
-        format: "number" | "numberWithCommas" | "percent" | "currencyYen" | "currencyINR" | "currencyCNY" | "currencyUSD" | "currencyEUR" | "currencyGBP";
+        format: "number" | "percent" | "numberWithCommas" | "currencyINR" | "currencyYen" | "currencyCNY" | "currencyUSD" | "currencyEUR" | "currencyGBP";
         decimal?: number | undefined;
     }, number | null, number | null>;
     progressColumnConfig: import("../index.js").PropertyMetaConfig<"progress", {}, number, number>;

package/dist/_pkgs/affine-block-frame/commands.js

@@ -1,5 +1,8 @@
+import { EditPropsStore } from '../affine-shared/services/index.js';
+import { GfxControllerIdentifier } from '../std/gfx/index.js';
 import { z } from 'zod';
 import { reorderFramePresentation } from './frame-order.js';
+import { PresentTool } from './present-tool.js';
 /**
  * The frames' commands, `owner: 'core'`: a frame belongs to no framework, and
  * `'core'` owners are exempt from the id-prefix rule (ADR 0008).
@@ -46,4 +49,41 @@ const reorderFrames = {
         reorderFramePresentation(std, parsed.data.ids, parsed.data.before);
     },
 };
-export const frameCommands = [reorderFrames];
+/**
+ * Start the slideshow (ADR 0034, amendment of 2026-10-13): the frames in
+ * presentation order, full screen, Esc to leave — the presentation tool owns
+ * all of it from here. The entry a host's view menu (or its header's
+ * "Present" button) runs; a document without frames gets the tool's own
+ * "no frame" notice.
+ *
+ * Edgeless only, like the tool it arms: a host showing the page view switches
+ * to the canvas with its OWN mode toggle first (it owns the toggle's state and
+ * the persisted mode), then runs this on the new editor scope once the canvas
+ * has mounted. It reads, so a reader may present. The fit or fill choice is the
+ * viewer's, stored by the frame panel's setting (`presentFillScreen`).
+ */
+const present = {
+    id: 'canvas.present',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.canvas.present',
+    labelFallback: 'Present',
+    descriptionKey: 'com.labre.command.canvas.present.description',
+    descriptionFallback: 'Show the frames one after the other, full screen, in presentation order.',
+    category: 'present',
+    iconKey: 'canvas.present',
+    keywords: ['present', 'slides', 'slideshow', 'frames', 'presentation'],
+    surfaces: ['view-menu', 'palette'],
+    order: 20,
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    run: std => {
+        const fill = std
+            .getOptional(EditPropsStore)
+            ?.getStorage('presentFillScreen');
+        std.get(GfxControllerIdentifier).tool.setTool(PresentTool, {
+            mode: fill ? 'fill' : 'fit',
+        });
+    },
+};
+export const frameCommands = [reorderFrames, present];

package/dist/_pkgs/affine-block-frame/frame-manager.d.ts

@@ -35,7 +35,7 @@ export declare class EdgelessFrameManager extends GfxExtension {
             index: string;
             presentationIndex?: string;
         };
-    }>(a: T, b: T): 1 | 0 | -1;
+    }>(a: T, b: T): 0 | 1 | -1;
     private _addChildrenToLegacyFrame;
     private _addFrameBlock;
     /**

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

@@ -1,3 +1,4 @@
+import { PresentationIcon } from '@blocksuite/icons/lit';
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
 import { CommandExtension } from '../std/index.js';
 import { frameCommands } from './commands.js';
@@ -34,8 +35,12 @@ export class FrameViewExtension extends ViewExtensionProvider {
             context.register(FrameBlockInteraction);
             // The presentation order's one write (ADR 0034). The frame panel also
             // mounts in page mode: it runs the imported descriptor, not this
-            // registration, so its reorder works in both modes.
-            context.register(CommandExtension(frameCommands));
+            // registration, so its reorder works in both modes. `canvas.present`
+            // rides along: a host's view menu lists it in edgeless mode, and a
+            // `frame: false` assembly loses it with the rest of the frame tooling.
+            context.register(CommandExtension(frameCommands, {
+                'canvas.present': PresentationIcon(),
+            }));
         }
     }
 }

package/dist/_pkgs/affine-block-note/components/edgeless-page-block-title.d.ts

@@ -1,6 +1,13 @@
 import { NoteBlockModel } from '../../affine-model/index.js';
 import { type BlockStdScope, ShadowlessElement } from '../../std/index.js';
 declare const EdgelessPageBlockTitle_base: typeof ShadowlessElement & import("../../global/utils/types.js").Constructor<import("../../global/lit/with-disposable.js").DisposableClass>;
+/**
+ * The head of the page's note on the canvas: the host's title, if its
+ * `NoteConfigExtension` draws one, then the title band (ADR 0035 §11). The
+ * band sits inside the note's DOM so it follows the zoom like the rest of the
+ * note (REQ-PR-7); it draws nothing when the host registers no
+ * `TitleBandProvider`.
+ */
 export declare class EdgelessPageBlockTitle extends EdgelessPageBlockTitle_base {
     render(): import("lit-html").TemplateResult<1> | undefined;
     accessor std: BlockStdScope;

package/dist/_pkgs/affine-block-note/components/edgeless-page-block-title.js

@@ -40,6 +40,13 @@ import { html } from 'lit';
 import { property } from 'lit/decorators.js';
 import { NoteConfigExtension } from '../config.js';
 import * as styles from './edgeless-page-block-title.css.js';
+/**
+ * The head of the page's note on the canvas: the host's title, if its
+ * `NoteConfigExtension` draws one, then the title band (ADR 0035 §11). The
+ * band sits inside the note's DOM so it follows the zoom like the rest of the
+ * note (REQ-PR-7); it draws nothing when the host registers no
+ * `TitleBandProvider`.
+ */
 let EdgelessPageBlockTitle = (() => {
     let _classDecorators = [requiredProperties({
             note: PropTypes.instanceOf(NoteBlockModel),
@@ -76,7 +83,14 @@ let EdgelessPageBlockTitle = (() => {
                 note: this.note,
                 std: this.std,
             });
-            return html `<div class=${styles.pageBlockTitle}>${title}</div>`;
+            return html `<div class=${styles.pageBlockTitle}>
+      ${title}
+      <labre-title-band
+        .std=${this.std}
+        .docId=${this.std.store.id}
+        .surface=${'canvas'}
+      ></labre-title-band>
+    </div>`;
         }
         #std_accessor_storage = __runInitializers(this, _std_initializers, void 0);
         get std() { return this.#std_accessor_storage; }

package/dist/_pkgs/affine-block-surface/extensions/canvas-grid/commands.js

@@ -1,9 +1,10 @@
 import { CanvasGrid, TelemetryProvider } from '../../../affine-shared/services/index.js';
 /**
  * The canvas grid's two commands (ADR 0031 §11, §12), `owner: 'core'`, on the
- * palette and the agent. The library has no page "more" menu — that belongs
- * to the host — so these are the grid's whole UI here; a host puts them in
- * its own menu through `runCommand`.
+ * palette, the agent and the host's view menu (`'view-menu'`, ADR 0034
+ * amendment of 2026-10-13). The library has no page "more" menu — that
+ * belongs to the host — so these are the grid's whole UI here; a host lists
+ * them with `getViewActions` and runs them through `runCommand`.
  *
  * Both self-emit `CanvasGridToggled` (see the telemetry README): `scope` is
  * which gesture ran, and a save that changes nothing reports nothing.
@@ -27,11 +28,17 @@ const toggleGrid = {
     labelFallback: 'Show or hide the grid',
     descriptionKey: 'com.labre.command.canvas.grid.toggle.description',
     descriptionFallback: 'Show or hide the canvas grid on your screen only. Nothing changes for anyone else.',
+    category: 'display',
+    iconKey: 'canvas.grid',
     keywords: ['grid', 'dots', 'background'],
-    surfaces: ['palette', 'agent'],
+    surfaces: ['palette', 'agent', 'view-menu'],
+    order: 0,
     scope: 'edgeless',
     defaultKeys: { mac: [], other: [] },
     when: std => !!std.getOptional(CanvasGrid),
+    // What this viewer sees now. A signal read, so a menu that reads it inside
+    // an effect ticks and unticks with the grid, whoever flips it.
+    checked: std => std.getOptional(CanvasGrid)?.visible$.value ?? false,
     run: std => {
         const grid = std.getOptional(CanvasGrid);
         if (!grid)
@@ -52,12 +59,19 @@ const saveGridForEveryone = {
     labelFallback: 'Save the grid for everyone',
     descriptionKey: 'com.labre.command.canvas.grid.save-for-everyone.description',
     descriptionFallback: 'Make the grid as you see it now the setting of this document, for everyone who opens it.',
+    category: 'display',
     keywords: ['grid', 'dots', 'background', 'document'],
-    surfaces: ['palette', 'agent'],
+    surfaces: ['palette', 'agent', 'view-menu'],
+    order: 1,
     scope: 'edgeless',
     defaultKeys: { mac: [], other: [] },
     availability: 'editable',
-    when: std => !!std.getOptional(CanvasGrid),
+    // Offered once this viewer has a grid of their own (`source$` is
+    // `'local'`, i.e. after a toggle): that is what the gesture saves, and the
+    // follow-up the hosts' menus already showed after the toggle. A signal
+    // read, so a view menu read inside an effect shows the entry right after a
+    // toggle and drops it after the save.
+    when: std => std.getOptional(CanvasGrid)?.source$.value === 'local',
     run: std => {
         const saved = std.getOptional(CanvasGrid)?.saveForEveryone() ?? null;
         if (saved === null)

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

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

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

@@ -0,0 +1,79 @@
+import { downloadBlob } from '../../../affine-shared/utils/index.js';
+import { ExportManager } from './export-manager.js';
+/**
+ * "Export as PNG" and "Export as PDF" of the canvas, in the command registry
+ * (ADR 0034, amendment of 2026-10-13). `owner: 'core'`: the picture is the
+ * canvas's, whatever drew on it.
+ *
+ * On the `'view-menu'` surface because the export is proper to the canvas
+ * VIEW (the host's "This view" section reads them through `getViewActions`),
+ * and on the palette. Not `'agent'`: an agent turn would drop a file on the
+ * user's disk they did not ask for.
+ *
+ * The library renders and the host decides where the bytes go: given
+ * `params.deliver` (`CommandFileParams`), the command hands the file over and
+ * downloads nothing — `runViewAction` passes one and returns the file. Without
+ * it (the palette, a bound chord) the command downloads the file itself, which
+ * is what a standalone editor needs. Nothing to draw, no file, no error.
+ *
+ * It READS, so there is no read-only guard: a reader exports what they see.
+ * No `telemetry` field, for `export.svg`'s reason — it names no framework —
+ * and usage is still measured by `runCommand`.
+ */
+function deliverOf(params) {
+    const deliver = params?.deliver;
+    return typeof deliver === 'function' ? deliver : undefined;
+}
+async function exportCanvas(std, render, params) {
+    const exporter = std.getOptional(ExportManager);
+    if (!exporter)
+        return;
+    const file = await render(exporter);
+    if (!file)
+        return;
+    const deliver = deliverOf(params);
+    if (deliver)
+        deliver(file);
+    else
+        downloadBlob(file.blob, file.filename);
+}
+const exportPng = {
+    id: 'canvas.export.png',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.canvas.export.png',
+    labelFallback: 'Export as PNG',
+    descriptionKey: 'com.labre.command.canvas.export.png.description',
+    descriptionFallback: 'Download the whole canvas as an image, as you see it on your screen.',
+    category: 'export',
+    iconKey: 'canvas.export.png',
+    keywords: ['png', 'image', 'export', 'download', 'picture'],
+    surfaces: ['view-menu', 'palette'],
+    order: 10,
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    when: std => !!std.getOptional(ExportManager),
+    run: (std, _invocation, params) => exportCanvas(std, exporter => exporter.pngFile(), params),
+};
+const exportPdf = {
+    id: 'canvas.export.pdf',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.canvas.export.pdf',
+    labelFallback: 'Export as PDF',
+    descriptionKey: 'com.labre.command.canvas.export.pdf.description',
+    descriptionFallback: 'Download the whole canvas as a one-page PDF holding its image.',
+    category: 'export',
+    iconKey: 'canvas.export.pdf',
+    keywords: ['pdf', 'export', 'download', 'print'],
+    surfaces: ['view-menu', 'palette'],
+    order: 11,
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    when: std => !!std.getOptional(ExportManager),
+    run: (std, _invocation, params) => exportCanvas(std, exporter => exporter.pdfFile(), params),
+};
+export const canvasExportCommands = [
+    exportPng,
+    exportPdf,
+];

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

@@ -1,5 +1,5 @@
 import type { IBound } from '../../../global/gfx/index.js';
-import { type BlockStdScope, type EditorHost } from '../../../std/index.js';
+import { type BlockStdScope, type CommandFile, type EditorHost } from '../../../std/index.js';
 import { GfxBlockElementModel, type GfxController, GfxPrimitiveElementModel } from '../../../std/gfx/index.js';
 import type { ExtensionType, Store } from '../../../store/index.js';
 import { CanvasRenderer } from '../../renderer/canvas-renderer.js';
@@ -39,7 +39,24 @@ export declare class ExportManager {
     edgelessToCanvas(surfaceRenderer: CanvasRenderer, bound: IBound, gfx: GfxController, blocks?: GfxBlockElementModel[], elements?: GfxPrimitiveElementModel[], edgelessBackground?: {
         zoom: number;
     }): Promise<HTMLCanvasElement | undefined>;
+    /**
+     * The canvas (or, in page mode, the document) as a PNG file, or `null` when
+     * there is nothing to draw. Renders, never downloads: the caller decides
+     * where the bytes go (`canvas.export.png` hands them to a host, or to the
+     * browser).
+     */
+    pngFile(): Promise<CommandFile | null>;
+    /**
+     * The same picture in a one-page PDF (`pdf-lib`, loaded on demand), or
+     * `null` when there is nothing to draw. The PDF is an image: its text is
+     * not selectable.
+     */
+    pdfFile(): Promise<CommandFile | null>;
+    /** Render, then hand the file to the browser. Nothing to draw, no file. */
     exportPdf(): Promise<void>;
+    /** Render, then hand the file to the browser. Nothing to draw, no file. */
     exportPng(): Promise<void>;
+    /** The document title, sanitised; the translated "Untitled" without one. */
+    private _fileStem;
 }
 export declare const ExportManagerExtension: ExtensionType;

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

@@ -2,14 +2,13 @@ import { ImageBlockModel } from '../../../affine-model/index.js';
 import { FetchUtils, ImageProxyService } from '../../../affine-shared/adapters/index.js';
 import { CANVAS_EXPORT_IGNORE_TAGS } from '../../../affine-shared/consts/index.js';
 import { CanvasGrid, CHROME_UNTITLED, translateKey, } from '../../../affine-shared/services/index.js';
-import { isInsidePageEditor, matchModels, normalizeCanvasExportColors, toLegacyColors, } from '../../../affine-shared/utils/index.js';
+import { downloadBlob, isInsidePageEditor, matchModels, normalizeCanvasExportColors, safeFilename, toLegacyColors, } from '../../../affine-shared/utils/index.js';
 import { BlockSuiteError, ErrorCode } from '../../../global/exceptions/index.js';
 import { deserializeXYWH } from '../../../global/gfx/index.js';
 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 { FileExporter } from './file-exporter.js';
 /**
  * The SVG the PNG export paints the canvas background from: the background
  * colour, plus the dotted grid unless `gridColor` is `null` — what this
@@ -379,38 +378,62 @@ export class ExportManager {
         ctx.drawImage(surfaceCanvas, 50, 50, bound.w, bound.h);
         return canvas;
     }
-    async exportPdf() {
-        const rootModel = this.doc.root;
-        if (!rootModel)
-            return;
-        const canvasImage = await this._toCanvas();
-        if (!canvasImage) {
-            return;
-        }
+    /**
+     * The canvas (or, in page mode, the document) as a PNG file, or `null` when
+     * there is nothing to draw. Renders, never downloads: the caller decides
+     * where the bytes go (`canvas.export.png` hands them to a host, or to the
+     * browser).
+     */
+    async pngFile() {
+        if (!this.doc.root)
+            return null;
+        const canvas = await this._toCanvas();
+        if (!canvas)
+            return null;
+        const blob = await new Promise(resolve => canvas.toBlob(resolve, 'image/png'));
+        if (!blob)
+            return null;
+        return { blob, filename: `${this._fileStem()}.png` };
+    }
+    /**
+     * The same picture in a one-page PDF (`pdf-lib`, loaded on demand), or
+     * `null` when there is nothing to draw. The PDF is an image: its text is
+     * not selectable.
+     */
+    async pdfFile() {
+        if (!this.doc.root)
+            return null;
+        const canvas = await this._toCanvas();
+        if (!canvas)
+            return null;
         const PDFLib = await import('pdf-lib');
         const pdfDoc = await PDFLib.PDFDocument.create();
-        const page = pdfDoc.addPage([canvasImage.width, canvasImage.height]);
-        const imageEmbed = await pdfDoc.embedPng(canvasImage.toDataURL('PNG'));
-        const { width, height } = imageEmbed.scale(1);
-        page.drawImage(imageEmbed, {
-            x: 0,
-            y: 0,
-            width,
-            height,
-        });
-        const pdfBase64 = await pdfDoc.saveAsBase64({ dataUri: true });
-        FileExporter.exportFile(rootModel.props.title.toString() + '.pdf', pdfBase64);
+        const page = pdfDoc.addPage([canvas.width, canvas.height]);
+        const image = await pdfDoc.embedPng(canvas.toDataURL('image/png'));
+        const { width, height } = image.scale(1);
+        page.drawImage(image, { x: 0, y: 0, width, height });
+        const bytes = await pdfDoc.save();
+        return {
+            blob: new Blob([bytes], { type: 'application/pdf' }),
+            filename: `${this._fileStem()}.pdf`,
+        };
     }
+    /** Render, then hand the file to the browser. Nothing to draw, no file. */
+    async exportPdf() {
+        const file = await this.pdfFile();
+        if (file)
+            downloadBlob(file.blob, file.filename);
+    }
+    /** Render, then hand the file to the browser. Nothing to draw, no file. */
     async exportPng() {
-        const rootModel = this.doc.root;
-        if (!rootModel)
-            return;
-        const canvasImage = await this._toCanvas();
-        if (!canvasImage) {
-            return;
-        }
-        const title = this.doc.root.props.title.toString();
-        FileExporter.exportPng(title.trim() || translateKey(this.std, ...CHROME_UNTITLED), canvasImage.toDataURL('image/png'));
+        const file = await this.pngFile();
+        if (file)
+            downloadBlob(file.blob, file.filename);
+    }
+    /** The document title, sanitised; the translated "Untitled" without one. */
+    _fileStem() {
+        const root = this.doc.root;
+        return safeFilename(root?.props.title.toString(), translateKey(this.std, ...CHROME_UNTITLED));
     }
 }
 export const ExportManagerExtension = {

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

@@ -1 +1,2 @@
+export { canvasExportCommands } from './commands.js';
 export { ExportManager, ExportManagerExtension } from './export-manager.js';

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

@@ -1 +1,2 @@
+export { canvasExportCommands } from './commands.js';
 export { ExportManager, ExportManagerExtension } from './export-manager.js';

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

@@ -1,9 +1,10 @@
+import { ExportToPdfIcon, ExportToPngIcon, GridIcon, } from '@blocksuite/icons/lit';
 import { ViewExtensionProvider, } from '../affine-ext-loader/index.js';
 import { CanvasGrid, CanvasLocalVisibility, } from '../affine-shared/services/index.js';
 import { BlockViewExtension, CommandExtension, FlavourExtension, } from '../std/index.js';
 import { literal } from 'lit/static-html.js';
 import { effects } from './effects.js';
-import { auditCommands, CanvasActiveLayer, canvasGridCommands, EdgelessCRUDExtension, EdgelessLegacySlotExtension, EditPropsMiddlewareBuilder, exportSvgCommands, exportSvgToolbarExtension, mapQualityCommands, mapQualityWidget, ReadingManager, readingProposalWidget, readingToolbarExtension, selectionPaneCommands, SelectionPaneModel, SpotlightManager, UserLayerMiddlewareBuilder, userLayerCommands, ValidationManager, validationExceptionToolbarExtension, ValidationOverlay, violationDetailWidget, } from './extensions/index.js';
+import { auditCommands, CanvasActiveLayer, canvasExportCommands, canvasGridCommands, EdgelessCRUDExtension, EdgelessLegacySlotExtension, EditPropsMiddlewareBuilder, exportSvgCommands, exportSvgToolbarExtension, mapQualityCommands, mapQualityWidget, ReadingManager, readingProposalWidget, readingToolbarExtension, selectionPaneCommands, SelectionPaneModel, SpotlightManager, UserLayerMiddlewareBuilder, userLayerCommands, ValidationManager, validationExceptionToolbarExtension, ValidationOverlay, violationDetailWidget, } from './extensions/index.js';
 import { ExportManagerExtension } from './extensions/export-manager/export-manager.js';
 import { BackgroundStackingExtension } from './framework-background/stacking.js';
 import { ElementHighlightOverlay } from './renderer/element-highlight-overlay.js';
@@ -87,7 +88,15 @@ export class SurfaceViewExtension extends ViewExtensionProvider {
             // the edgeless root's background, the surface container and the PNG
             // export; previews follow the document setting alone.
             context.register(CanvasGrid);
-            context.register(CommandExtension(canvasGridCommands));
+            context.register(CommandExtension(canvasGridCommands, { 'canvas.grid': GridIcon() }));
+            // The canvas's PNG and PDF export (ADR 0034, amendment of 2026-10-13):
+            // the "This view" entries a host lists with `getViewActions`. Edgeless
+            // only — the page-mode export was never offered — and never gated: a
+            // picture of what is on the canvas is not a framework's tooling.
+            context.register(CommandExtension(canvasExportCommands, {
+                'canvas.export.png': ExportToPngIcon(),
+                'canvas.export.pdf': ExportToPdfIcon(),
+            }));
             // User layers (ADR 0031 §2-§6): the viewer's active layer (session
             // only), the `beforeAdd` middleware that stamps it on what is created,
             // and the commands the pane's layer rows run. Content, never gated.

package/dist/_pkgs/affine-fragment-doc-title/doc-title.d.ts

@@ -13,6 +13,14 @@ export declare class DocTitle extends DocTitle_base {
     get inlineEditor(): import("../affine-shared/types/index.js").AffineInlineEditor | null;
     get inlineEditorContainer(): HTMLDivElement;
     connectedCallback(): void;
+    /**
+     * The `std` the title band reads its seams from, when the band belongs
+     * here: in the page view, never inside a note on the canvas, where
+     * `edgeless-page-block-title` draws the band itself (ADR 0035 §11), so a
+     * host that renders this title in the note header does not get two.
+     */
+    private get _bandStd();
+    firstUpdated(): void;
     render(): import("lit-html").TemplateResult<1>;
     private accessor _isComposing;
     private accessor _isReadonly;