@formicoidea/labre-core 0.43.1 → 0.46.0

package/dist/_pkgs/affine-block-root/edgeless/utils/clone-utils.js

@@ -1,4 +1,5 @@
 import { ConnectorElementModel, GroupElementModel, MindmapElementModel, } from '../../../affine-model/index.js';
+import { sourceLayerOf } from '../../../affine-block-surface/index.js';
 import { getTopElements, GfxBlockElementModel, isGfxGroupCompatibleModel, } from '../../../std/gfx/index.js';
 /**
  * return all elements in the tree of the elements
@@ -16,11 +17,29 @@ export function getSortedCloneElements(elements) {
     });
     return sortEdgelessElements([...set]);
 }
+/**
+ * The data a clone gesture in the same document (duplicate, alt-drag)
+ * re-creates. Each model asks for its source's layer EXPLICITLY, the default
+ * layer included (ADR 0031, amendment "A duplicate stays in its source's
+ * layer, the default one included"): a default-layer model serializes no
+ * `layer`, and "absent" would hand its copy to the viewer's active layer. A
+ * paste goes through `prepareClipboardData` instead and keeps §6's rule — it
+ * cannot tell the default layer from another document.
+ */
 export function prepareCloneData(elements, std) {
     elements = sortEdgelessElements(elements);
     const job = std.store.getTransformer();
     const res = elements.map(element => {
         const data = serializeElement(element, elements, job);
+        if (!data)
+            return data;
+        const layer = sourceLayerOf(element);
+        if ('props' in data && data.type === 'block') {
+            data.props = { ...data.props, layer };
+        }
+        else {
+            data.layer = layer;
+        }
         return data;
     });
     return res.filter((d) => !!d);
@@ -77,7 +96,16 @@ export function sortEdgelessElements(elements) {
         const rest = elements.filter(element => !(element instanceof ConnectorElementModel));
         return [...rest, ...connectors];
     };
+    // A child may be claimed by two containers in a stored document (a frame and
+    // a group: an older paste let the frame adopt a child before the pasted group
+    // claimed it). `getTopElements` then reports it as a top element — its
+    // `.group` reads the other container — and the walk meets it again under its
+    // group. Visit each element once, or the paste creates it twice.
+    const visited = new Set();
     const traverse = (element) => {
+        if (visited.has(element))
+            return;
+        visited.add(element);
         if (isGfxGroupCompatibleModel(element)) {
             moveConnectorToEnd(element.childElements).forEach(child => traverse(child));
         }

package/dist/_pkgs/affine-block-root/keyboard/commands.js

@@ -1,7 +1,7 @@
 import { EdgelessCRUDIdentifier, getLastPropsKey, } from '../../affine-block-surface/index.js';
 import { EditPropsStore } from '../../affine-shared/services/index.js';
 import { pickStylePropsForKey } from '../../affine-shared/utils/index.js';
-import { IS_WINDOWS } from '../../global/env/index.js';
+import { IS_LINUX, IS_WINDOWS } from '../../global/env/index.js';
 import { GfxControllerIdentifier, GfxPrimitiveElementModel, } from '../../std/gfx/index.js';
 import { duplicate } from '../edgeless/utils/clipboard-utils.js';
 /**
@@ -21,12 +21,13 @@ import { duplicate } from '../edgeless/utils/clipboard-utils.js';
  *
  * Computed by the `when` predicate AND by `run`, on purpose: the projection to
  * a shortcut only consumes the keystroke when `when` holds, and this gesture
- * must fall through when it has nothing to apply — on Windows `Mod+Y` is also
- * the `redo-windows` alias, which has to keep working.
+ * must fall through when it has nothing to apply — on Windows and Linux `Mod+Y`
+ * is also the `redo-windows` alias, which has to keep working.
  */
 function lastStyleTargets(std) {
     // Readonly: nothing to repaint, so `when` fails and the keystroke falls
-    // through (on Windows Mod+Y is also the redo alias, itself readonly-gated).
+    // through (on Windows and Linux Mod+Y is also the redo alias, itself
+    // readonly-gated).
     if (std.store.readonly)
         return [];
     const gfx = std.get(GfxControllerIdentifier);
@@ -72,7 +73,9 @@ export const coreCommands = [
         },
     },
     {
-        // Windows-only redo alias (Ctrl+Y); not bound on mac (empty combo).
+        // Redo alias (Ctrl+Y) on Windows and Linux; not bound on mac (empty
+        // combo). The id still says "windows": command ids are persisted in
+        // users' override tables, so it is kept rather than renamed.
         id: 'redo-windows',
         owner: 'core',
         kind: 'action',
@@ -84,7 +87,7 @@ export const coreCommands = [
         scope: 'global',
         defaultKeys: { mac: [], other: ['Control-y'] },
         availability: 'always',
-        when: () => IS_WINDOWS,
+        when: () => IS_WINDOWS || IS_LINUX,
         run: std => {
             if (std.store.canRedo)
                 std.store.redo();

package/dist/_pkgs/affine-block-root/preview/edgeless-root-preview-block.js

@@ -33,7 +33,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 import { EdgelessCRUDIdentifier, getBgGridGap, } from '../../affine-block-surface/index.js';
-import { EditorSettingProvider, FontLoaderService, ThemeProvider, ViewportElementProvider, } from '../../affine-shared/services/index.js';
+import { documentShowsGrid, EditorSettingProvider, FontLoaderService, ThemeProvider, ViewportElementProvider, } from '../../affine-shared/services/index.js';
 import { requestThrottledConnectedFrame } from '../../affine-shared/utils/index.js';
 import { BlockComponent, SurfaceSelection, } from '../../std/index.js';
 import { GfxControllerIdentifier, } from '../../std/gfx/index.js';
@@ -95,6 +95,11 @@ let EdgelessRootPreviewBlockComponent = (() => {
       );
     }
 
+    /* ADR 0031 §11: a preview follows the document's showGrid alone. */
+    affine-edgeless-root-preview .edgeless-background.grid-hidden {
+      background-image: none;
+    }
+
     @media print {
       .selected {
         background-color: transparent !important;
@@ -208,8 +213,16 @@ let EdgelessRootPreviewBlockComponent = (() => {
                 ...this.backgroundStyle,
                 background: this.overrideBackground,
             });
+            // A preview is a picture of the document, not a viewer's session: no
+            // viewer override and no host default, only what the document saved.
+            const gridClass = documentShowsGrid(this.surfaceBlockModel)
+                ? ''
+                : ' grid-hidden';
             return html `
-      <div class="edgeless-background edgeless-container" style=${background}>
+      <div
+        class="edgeless-background edgeless-container${gridClass}"
+        style=${background}
+      >
         <gfx-viewport
           .enableChildrenSchedule=${!this._disableScheduleUpdate}
           .viewport=${this._gfx.viewport}

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

@@ -4,6 +4,10 @@ import { type ChromeWording } from '../affine-shared/services/index.js';
  * `PACKAGE_SEED_WORDINGS` in `@labre/affine/translations` — see that file and
  * `packages/affine/shared/src/services/translation-service/README.md`.
  */
+/**
+ * Aliases (L7 dedupe): the callout's own row says the same two words (#468),
+ * so they live in `chrome.ts` under the keys they always had.
+ */
 export declare const ROOT_TOOLBAR_CONVERSIONS_ARIA: ChromeWording;
 export declare const ROOT_TOOLBAR_TURN_INTO: ChromeWording;
 export declare const ROOT_TOOLBAR_CREATE_TABLE: ChromeWording;
@@ -51,8 +55,9 @@ export declare const ROOT_TOAST_ZOOM_TO_SELECTION: ChromeWording;
 export declare const ROOT_MINDMAP_SEED_NEW_NODE: ChromeWording;
 /**
  * This package's own CHROME wordings — L7 dedupe aliased
- * `ROOT_TOOLBAR_CREATE_LINKED_DOC`, `ROOT_TOOLBAR_FRAME`, `ROOT_TOOLBAR_RELOAD`
- * and `ROOT_TOOLBAR_REMOVE_LINK` to `chrome.ts` wordings — not listed again
+ * `ROOT_TOOLBAR_CONVERSIONS_ARIA`, `ROOT_TOOLBAR_CREATE_LINKED_DOC`,
+ * `ROOT_TOOLBAR_FRAME`, `ROOT_TOOLBAR_RELOAD`, `ROOT_TOOLBAR_REMOVE_LINK` and
+ * `ROOT_TOOLBAR_TURN_INTO` to `chrome.ts` wordings — not listed again
  * here, same rule the note/slash-menu packages' own chrome aliases already
  * follow.
  */

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

@@ -1,18 +1,16 @@
-import { TOOL_NAME_FRAME, TOOLBAR_CREATE_LINKED_DOC_TITLE, TOOLBAR_RELOAD, TOOLBAR_REMOVE_LINK, } from '../affine-shared/services/index.js';
+import { TOOL_NAME_FRAME, TOOLBAR_CONVERSIONS_ARIA, TOOLBAR_CREATE_LINKED_DOC_TITLE, TOOLBAR_RELOAD, TOOLBAR_REMOVE_LINK, TOOLBAR_TURN_INTO, } from '../affine-shared/services/index.js';
 /**
  * This package's own wordings, joined into `PACKAGE_WORDINGS` /
  * `PACKAGE_SEED_WORDINGS` in `@labre/affine/translations` — see that file and
  * `packages/affine/shared/src/services/translation-service/README.md`.
  */
 /* ── The block contextual toolbar (`configs/toolbar.ts`) ──────────────── */
-export const ROOT_TOOLBAR_CONVERSIONS_ARIA = [
-    'com.labre.root.toolbar.conversions',
-    'Conversions',
-];
-export const ROOT_TOOLBAR_TURN_INTO = [
-    'com.labre.root.toolbar.turn-into',
-    'Turn into',
-];
+/**
+ * Aliases (L7 dedupe): the callout's own row says the same two words (#468),
+ * so they live in `chrome.ts` under the keys they always had.
+ */
+export const ROOT_TOOLBAR_CONVERSIONS_ARIA = TOOLBAR_CONVERSIONS_ARIA;
+export const ROOT_TOOLBAR_TURN_INTO = TOOLBAR_TURN_INTO;
 export const ROOT_TOOLBAR_CREATE_TABLE = [
     'com.labre.root.toolbar.create-table',
     'Create Table',
@@ -134,14 +132,13 @@ export const ROOT_MINDMAP_SEED_NEW_NODE = [
 ];
 /**
  * This package's own CHROME wordings — L7 dedupe aliased
- * `ROOT_TOOLBAR_CREATE_LINKED_DOC`, `ROOT_TOOLBAR_FRAME`, `ROOT_TOOLBAR_RELOAD`
- * and `ROOT_TOOLBAR_REMOVE_LINK` to `chrome.ts` wordings — not listed again
+ * `ROOT_TOOLBAR_CONVERSIONS_ARIA`, `ROOT_TOOLBAR_CREATE_LINKED_DOC`,
+ * `ROOT_TOOLBAR_FRAME`, `ROOT_TOOLBAR_RELOAD`, `ROOT_TOOLBAR_REMOVE_LINK` and
+ * `ROOT_TOOLBAR_TURN_INTO` to `chrome.ts` wordings — not listed again
  * here, same rule the note/slash-menu packages' own chrome aliases already
  * follow.
  */
 export const ROOT_CHROME_WORDINGS = [
-    ROOT_TOOLBAR_CONVERSIONS_ARIA,
-    ROOT_TOOLBAR_TURN_INTO,
     ROOT_TOOLBAR_CREATE_TABLE,
     ROOT_ALIGNMENT_MENU_ARIA,
     ROOT_ALIGN_LEFT,

package/dist/_pkgs/affine-block-surface/adapters/markdown/element-adapter/type.d.ts

@@ -1,6 +1,6 @@
-import type { ExtensionType } from '../../../../../store/index.js';
 import type { MarkdownAST } from '../../../../affine-shared/adapters/index.js';
 import { type ServiceIdentifier } from '../../../../global/di/index.js';
+import type { ExtensionType } from '../../../../store/index.js';
 import type { ElementModelMatcher } from '../../type.js';
 export type ElementToMarkdownAdapterMatcher = ElementModelMatcher<MarkdownAST>;
 export declare const ElementToMarkdownAdapterMatcherIdentifier: ServiceIdentifier<ElementToMarkdownAdapterMatcher> & (<U extends ElementToMarkdownAdapterMatcher = ElementToMarkdownAdapterMatcher>(variant: import("../../../../global/di/types.js").ServiceVariant) => ServiceIdentifier<U>);

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

@@ -30,7 +30,7 @@ export declare const elementsCtorMap: {
     umlRegion: typeof UmlRegionElementModel;
     umlFragment: typeof UmlFragmentElementModel;
 };
-export { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, C4BoardElementModel, C4BoundaryElementModel, C4NodeElementModel, ConnectorElementModel, ContextMapBoardElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyBoardElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, EventStormingBoardElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, SurfaceElementModel, TextElementModel, UmlDiagramElementModel, UmlFragmentElementModel, UmlNodeElementModel, UmlPartitionElementModel, UmlRegionElementModel, UmlSubjectElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, };
+export { BrushElementModel, ConnectorElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, SurfaceElementModel, TextElementModel, };
 export declare enum CanvasElementType {
     BRUSH = "brush",
     CONNECTOR = "connector",

package/dist/_pkgs/affine-block-surface/element-model/index.js

@@ -30,7 +30,7 @@ export const elementsCtorMap = {
     umlRegion: UmlRegionElementModel,
     umlFragment: UmlFragmentElementModel,
 };
-export { BpmnNodeElementModel, BpmnPoolElementModel, BrushElementModel, C4BoardElementModel, C4BoundaryElementModel, C4NodeElementModel, ConnectorElementModel, ContextMapBoardElementModel, CoreDomainChartElementModel, CynefinElementModel, EdgyBoardElementModel, EdgyFacetsElementModel, EdgyNodeElementModel, EstuarineElementModel, EventStormingBoardElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, SurfaceElementModel, TextElementModel, UmlDiagramElementModel, UmlFragmentElementModel, UmlNodeElementModel, UmlPartitionElementModel, UmlRegionElementModel, UmlSubjectElementModel, WardleyBackgroundElementModel, WardleyNodeElementModel, };
+export { BrushElementModel, ConnectorElementModel, GroupElementModel, HighlighterElementModel, MindmapElementModel, ShapeElementModel, SurfaceElementModel, TextElementModel, };
 export var CanvasElementType;
 (function (CanvasElementType) {
     CanvasElementType["BRUSH"] = "brush";

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

@@ -30,8 +30,7 @@
 import { getAuditCriteria, requestAudit, TelemetryProvider, } from '../../affine-shared/services/index.js';
 import { GfxControllerIdentifier, GfxPrimitiveElementModel, roleIsA, } from '../../std/gfx/index.js';
 import { z } from 'zod';
-import { backgroundInstanceZones, backgroundPlot, } from '../framework-background/def.js';
-import { backgroundAxisFacts, containingFrame, } from '../framework-background/facts.js';
+import { backgroundAxisFacts, backgroundPlotRatios, backgroundZoneAt, backgroundZones, containingFrame, } from '../framework-background/facts.js';
 import { ValidationManager, ValidationRuleIdentifier, } from './validation.js';
 /**
  * `map.audit` takes no required parameter: the assistant audits what is
@@ -113,69 +112,21 @@ function collectFrames(rules, elements) {
                     type: def.type,
                     ...(typeof profileId === 'string' ? { profileId } : {}),
                     axes: backgroundAxisFacts(def),
-                    // The framework's zones first, then the ones THIS frame declares —
-                    // a BPMN pool's lanes. Concatenated rather than merged: the two
-                    // namespaces are kept apart by the instance ids' prefix, so `zoneAt`
-                    // resolves them by the same containment test and a framework zone
-                    // still wins a genuine overlap, which is the reading that was true
-                    // before an element could partition its own plot.
-                    zones: [
-                        ...(def.zones ?? []).map(zone => ({
-                            id: zone.id,
-                            rect: { ...zone.rect },
-                        })),
-                        ...backgroundInstanceZones(def, el).map(zone => ({
-                            id: zone.id,
-                            ...(zone.name !== undefined ? { name: zone.name } : {}),
-                            rect: { ...zone.rect },
-                        })),
-                    ],
+                    // The zones THIS frame has — the framework's, in the variant it is
+                    // turned to, then its own (a BPMN pool's lanes) — read through the
+                    // helper the reading panel uses, so the two cannot disagree. Copied
+                    // field by field: the declared label is painting data, not a fact.
+                    zones: backgroundZones(def, el).map(zone => ({
+                        id: zone.id,
+                        ...(zone.name !== undefined ? { name: zone.name } : {}),
+                        rect: { ...zone.rect },
+                    })),
                 },
             });
         }
     }
     return frames;
 }
-/**
- * Where an element's centre sits inside a frame's PLOT, as ratios.
- *
- * A POSITION, not a membership test: it is asked only about an element some
- * frame already contains, and answers where in that frame's plot it lies.
- *
- * Ratios of the plot and not of the element box: a Wardley transition drawn at
- * `0.4` is 40 % of the PLOT, not of the map element, and the margin between the
- * two is exactly where the axis titles live. `backgroundPlot` is the one place
- * that knows the difference, and this is the only reason this function exists
- * rather than a subtraction at the call site.
- *
- * Not clamped: an element just off the left edge reads as `-0.03`, which is a
- * true and useful thing to say. `null` for a degenerate plot.
- */
-function plotRatios(frame, bound) {
-    const plot = backgroundPlot(frame.def, frame.bound.w, frame.bound.h);
-    if (!(plot.width > 0) || !(plot.height > 0))
-        return null;
-    const cx = bound.x + bound.w / 2;
-    const cy = bound.y + bound.h / 2;
-    return [
-        (cx - frame.bound.x - plot.x0) / plot.width,
-        (cy - frame.bound.y - plot.y0) / plot.height,
-    ];
-}
-/**
- * The zone a plot-ratio point falls in, if any — one the framework declares or
- * one the frame itself does. It needs to know nothing about the difference: the
- * fact carries both, in that order, as rectangles in the same ratios.
- */
-function zoneAt(frame, at) {
-    for (const zone of frame.fact.zones) {
-        const { x, y, w, h } = zone.rect;
-        if (at[0] >= x && at[0] <= x + w && at[1] >= y && at[1] <= y + h) {
-            return zone.id;
-        }
-    }
-    return undefined;
-}
 /**
  * Levels 1 and 2, copied out of the engine's verdict.
  *
@@ -245,8 +196,9 @@ export function collectAuditFacts(std) {
             elementFacts.push({ id: el.id, role });
             continue;
         }
-        const at = plotRatios(frame, bound);
-        const zone = at === null ? undefined : zoneAt(frame, at);
+        // A POSITION, not a membership test: `frame` already contains the element.
+        const at = backgroundPlotRatios(frame.def, frame.bound, bound);
+        const zone = at === null ? undefined : backgroundZoneAt(frame.fact.zones, at)?.id;
         elementFacts.push({
             id: el.id,
             role,

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

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

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

@@ -0,0 +1,71 @@
+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`.
+ *
+ * Both self-emit `CanvasGridToggled` (see the telemetry README): `scope` is
+ * which gesture ran, and a save that changes nothing reports nothing.
+ */
+function reportGrid(std, scope, visible) {
+    std.getOptional(TelemetryProvider)?.track('CanvasGridToggled', {
+        page: 'whiteboard editor',
+        scope,
+        visible,
+    });
+}
+/**
+ * Show or hide the grid for THIS viewer, on this document. Writes nothing to
+ * the document, so a reader may do it too.
+ */
+const toggleGrid = {
+    id: 'canvas.grid.toggle',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.canvas.grid.toggle',
+    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.',
+    keywords: ['grid', 'dots', 'background'],
+    surfaces: ['palette', 'agent'],
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    when: std => !!std.getOptional(CanvasGrid),
+    run: std => {
+        const grid = std.getOptional(CanvasGrid);
+        if (!grid)
+            return;
+        reportGrid(std, 'local', grid.toggle());
+    },
+};
+/**
+ * Store the grid as this viewer sees it on the document, for everyone, and
+ * drop this viewer's own override. Read-only refuses (`availability`, and
+ * again in `CanvasGrid.saveForEveryone`).
+ */
+const saveGridForEveryone = {
+    id: 'canvas.grid.saveForEveryone',
+    owner: 'core',
+    kind: 'action',
+    labelKey: 'com.labre.command.canvas.grid.save-for-everyone',
+    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.',
+    keywords: ['grid', 'dots', 'background', 'document'],
+    surfaces: ['palette', 'agent'],
+    scope: 'edgeless',
+    defaultKeys: { mac: [], other: [] },
+    availability: 'editable',
+    when: std => !!std.getOptional(CanvasGrid),
+    run: std => {
+        const saved = std.getOptional(CanvasGrid)?.saveForEveryone() ?? null;
+        if (saved === null)
+            return;
+        reportGrid(std, 'everyone', saved);
+    },
+};
+export const canvasGridCommands = [
+    toggleGrid,
+    saveGridForEveryone,
+];

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

@@ -0,0 +1 @@
+export { canvasGridCommands } from './commands.js';

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

@@ -0,0 +1 @@
+export { canvasGridCommands } from './commands.js';

package/dist/_pkgs/affine-block-surface/extensions/clipboard-config.js

@@ -4,12 +4,16 @@ import { StdIdentifier } from '../../std/index.js';
 import { Extension } from '../../store/index.js';
 import { getSurfaceComponent } from '../utils/get-surface-block.js';
 import { EdgelessCRUDIdentifier } from './crud-extension.js';
+import { applyCreationLayer } from './user-layers/creation.js';
 export const EdgelessClipboardConfigIdentifier = createIdentifier('edgeless-clipboard-config');
 export class EdgelessClipboardConfig extends Extension {
     constructor(std) {
         super();
         this.std = std;
         this.onBlockSnapshotPaste = async (snapshot, doc, parent, index) => {
+            // The clipboard's block path follows the elements' rule (ADR 0031 §6):
+            // a layer of this surface is kept, anything else lands in the active one.
+            applyCreationLayer(this.std, snapshot.props);
             const block = await this.std.clipboard.pasteBlockSnapshot(snapshot, doc, parent, index);
             return block?.id ?? null;
         };

package/dist/_pkgs/affine-block-surface/extensions/crud-extension.js

@@ -5,6 +5,7 @@ import { GfxBlockElementModel, GfxControllerIdentifier, isGfxGroupCompatibleMode
 import { Extension } from '../../store/index.js';
 import { getLastPropsKey } from '../utils/get-last-props-key.js';
 import { isConnectable, isNoteBlock } from './query.js';
+import { applyCreationLayer } from './user-layers/creation.js';
 export const EdgelessCRUDIdentifier = createIdentifier('AffineEdgelessCrudService');
 export class EdgelessCRUDExtension extends Extension {
     constructor(std) {
@@ -48,6 +49,9 @@ export class EdgelessCRUDExtension extends Extension {
                 ...props,
                 index: gfx.layer.generateIndex(),
             };
+            // A gfx block gets the elements' rule (ADR 0031 §6): its own layer if it
+            // names one of this surface, else the viewer's active layer.
+            applyCreationLayer(this.std, nProps);
             return this.std.store.addBlock(flavour, nProps, parentId, parentIndex);
         };
         this.addElement = (type, props) => {

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

@@ -3,6 +3,18 @@ import { type BlockStdScope, 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';
+export type EdgelessBackgroundOptions = {
+    size: number;
+    backgroundColor: string;
+    /** `null` when the grid is off (ADR 0031 §11): the background alone. */
+    gridColor: string | null;
+};
+/**
+ * The SVG the PNG export paints the canvas background from: the background
+ * colour, plus the dotted grid unless `gridColor` is `null` — what this
+ * viewer sees, as `CanvasGrid.visible$` says.
+ */
+export declare function edgelessBackgroundSvg(width: number, height: number, { size, backgroundColor, gridColor }: EdgelessBackgroundOptions): string;
 export declare class ExportManager {
     readonly std: BlockStdScope;
     /**

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

@@ -1,8 +1,8 @@
 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 { CHROME_UNTITLED, translateKey } from '../../../affine-shared/services/index.js';
-import { isInsidePageEditor, matchModels } from '../../../affine-shared/utils/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 { BlockSuiteError, ErrorCode } from '../../../global/exceptions/index.js';
 import { deserializeXYWH } from '../../../global/gfx/index.js';
 import { StdIdentifier, } from '../../../std/index.js';
@@ -10,6 +10,17 @@ import { GfxBlockElementModel, GfxControllerIdentifier, GfxPrimitiveElementModel
 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
+ * viewer sees, as `CanvasGrid.visible$` says.
+ */
+export function edgelessBackgroundSvg(width, height, { size, backgroundColor, gridColor }) {
+    const grid = gridColor === null
+        ? ''
+        : ` background-image: radial-gradient(${gridColor} 1px, ${backgroundColor} 1px)`;
+    return `<svg width='${width}px' height='${height}px' xmlns='http://www.w3.org/2000/svg' style='background-size:${size}px ${size}px;background-color:${backgroundColor};${grid}'></svg>`;
+}
 export class ExportManager {
     /**
      * The image proxy every remote-image fetch of the export goes through —
@@ -157,11 +168,12 @@ export class ExportManager {
                     return false;
                 }
             },
-            onclone: async (_documentClone, element) => {
+            onclone: async (documentClone, element) => {
+                normalizeCanvasExportColors(documentClone, element);
                 element.style.height = `${viewportHeight}px`;
                 await this.replaceImgSrcWithSvg(element);
             },
-            backgroundColor: window.getComputedStyle(viewportElement).backgroundColor,
+            backgroundColor: toLegacyColors(window.getComputedStyle(viewportElement).backgroundColor),
             x: pageLeft - viewport.left,
             width: pageWidth,
             height: viewportHeight,
@@ -179,8 +191,8 @@ export class ExportManager {
         this._checkCanContinueToCanvas(pathname, editorMode);
         return data;
     }
-    _drawEdgelessBackground(ctx, { size, backgroundColor, gridColor, }) {
-        const svgImg = `<svg width='${ctx.canvas.width}px' height='${ctx.canvas.height}px' xmlns='http://www.w3.org/2000/svg' style='background-size:${size}px ${size}px;background-color:${backgroundColor}; background-image: radial-gradient(${gridColor} 1px, ${backgroundColor} 1px)'></svg>`;
+    _drawEdgelessBackground(ctx, options) {
+        const svgImg = edgelessBackgroundSvg(ctx.canvas.width, ctx.canvas.height, options);
         const img = new Image();
         const cleanup = () => {
             img.onload = null;
@@ -218,6 +230,7 @@ export class ExportManager {
                 }
             },
             onclone: async (documentClone, element) => {
+                normalizeCanvasExportColors(documentClone, element);
                 // html2canvas can't support transform feature
                 element.style.setProperty('transform', 'none');
                 const layer = element.classList.contains('.affine-edgeless-layer')
@@ -300,7 +313,10 @@ export class ExportManager {
             await this._drawEdgelessBackground(ctx, {
                 backgroundColor: containerComputedStyle.getPropertyValue('--affine-background-primary-color'),
                 size: getBgGridGap(edgelessBackground.zoom),
-                gridColor: containerComputedStyle.getPropertyValue('--affine-edgeless-grid-color'),
+                // What this viewer sees: off leaves the background colour alone.
+                gridColor: (this.std.getOptional(CanvasGrid)?.visible$.peek() ?? true)
+                    ? containerComputedStyle.getPropertyValue('--affine-edgeless-grid-color')
+                    : null,
             });
         }
         if (!blocks && !elements) {
@@ -331,6 +347,10 @@ export class ExportManager {
             elements = [...elementSet];
             blocks = [...blockSet];
         }
+        // What you see is what you export (ADR 0031, resolved at acceptance): a
+        // block this viewer hid is not drawn. Canvas elements are left out by the
+        // renderer's own paint predicate.
+        blocks = blocks.filter(block => !gfx.localVisibility.isHidden(block));
         for (const block of blocks) {
             if (matchModels(block, [ImageBlockModel])) {
                 if (!block.props.sourceId)

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

@@ -1,5 +1,6 @@
 import { FrameworkBackgroundElementModel } from '../../../affine-model/index.js';
 import type { AnyCommandDescriptor, BlockStdScope } from '../../../std/index.js';
+import { type BoardSvgExportOptions } from './parts.js';
 /**
  * The framework boards in the current canvas selection.
  *
@@ -19,5 +20,5 @@ export declare function selectedBoards(std: BlockStdScope): FrameworkBackgroundE
  * on the browser — a result nobody can read off the gesture. One board, one
  * file, every time.
  */
-export declare function exportBoardSvg(std: BlockStdScope): void;
+export declare function exportBoardSvg(std: BlockStdScope, options?: Readonly<BoardSvgExportOptions>): void;
 export declare const exportSvgCommands: AnyCommandDescriptor[];

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

@@ -1,7 +1,10 @@
 import { FrameworkBackgroundElementModel } from '../../../affine-model/index.js';
+import { NotificationProvider, translateKey, } from '../../../affine-shared/services/index.js';
 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 { EXPORT_SVG_NOTHING_TO_EXPORT } from './translations.js';
 /** What the file is, told to the browser. */
 const SVG_MIME = 'image/svg+xml';
 /** The name a board with no document title falls back to. */
@@ -29,11 +32,20 @@ export function selectedBoards(std) {
  * on the browser — a result nobody can read off the gesture. One board, one
  * file, every time.
  */
-export function exportBoardSvg(std) {
+export function exportBoardSvg(std, options = DEFAULT_BOARD_SVG_EXPORT_OPTIONS) {
     const [board] = selectedBoards(std);
     if (!board)
         return;
-    const { svg } = renderBoardSvg(std, board);
+    const rendered = renderBoardSvg(std, board, options);
+    if (!rendered) {
+        // Every part left was switched off. Said once, through the host's
+        // notification seam; a host without one simply gets no file.
+        std
+            .getOptional(NotificationProvider)
+            ?.toast(translateKey(std, ...EXPORT_SVG_NOTHING_TO_EXPORT));
+        return;
+    }
+    const { svg } = rendered;
     const title = std.store.workspace.meta.getDocMeta(std.store.id)?.title;
     downloadBlob(
     // The charset is the browser's business, not the format's: `image/svg+xml`
@@ -53,6 +65,13 @@ export function exportBoardSvg(std) {
  * It READS, so there is no read-only guard: taking a picture of a board you
  * cannot edit is precisely what a reader does.
  *
+ * Its optional params are the export options (`parts.ts`), which the "⋮"
+ * entry asks for before it runs this. Every other surface — the palette, the
+ * catalogue, a shortcut, the agent — passes nothing and exports everything,
+ * without a dialog. They are deliberately not declared as `params`: the agent
+ * contract stays "export the selected board", and `run` re-validates whatever
+ * arrives.
+ *
  * No `telemetry` field: `CommandTelemetry.framework` is typed on `FrameworkId`,
  * and this command cannot name one — the surface package knows a board by its
  * MODEL CLASS, and nothing in it maps `bpmnPool` back to `bpmn` without
@@ -84,6 +103,6 @@ const exportSvg = {
     // union can express.
     availability: 'selection:framework',
     when: std => selectedBoards(std).length > 0,
-    run: std => exportBoardSvg(std),
+    run: (std, _invocation, params) => exportBoardSvg(std, boardSvgExportOptions(params)),
 };
 export const exportSvgCommands = [exportSvg];