@formicoidea/labre-core 0.49.0 → 0.51.0

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

@@ -1,10 +1,10 @@
-import { ExportToPdfIcon, ExportToPngIcon, GridIcon, } from '@blocksuite/icons/lit';
+import { ExportIcon, ExportToPdfIcon, ExportToPngIcon, ExportToSvgIcon, 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, 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 { auditCommands, CanvasActiveLayer, canvasDrawioExportCommands, canvasExportCommands, CANVAS_INTERCHANGE, canvasGridCommands, canvasSvgExportCommands, EdgelessCRUDExtension, EdgelessLegacySlotExtension, EditPropsMiddlewareBuilder, exportSvgCommands, INTERCHANGE_EXPORT_ICON_KEY, InterchangeExtension, 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';
@@ -97,6 +97,26 @@ export class SurfaceViewExtension extends ViewExtensionProvider {
                 'canvas.export.png': ExportToPngIcon(),
                 'canvas.export.pdf': ExportToPdfIcon(),
             }));
+            // The canvas as a draw.io drawing (ADR 0019, amendment of 2026-10-14):
+            // the third "This view" export, and the registry's one capability no
+            // framework owns. Never gated, for the PNG's reason — it writes what the
+            // canvas paints, whatever drew it — so with every framework off the
+            // registry still answers `canvas:drawio:export`.
+            context.register(InterchangeExtension(CANVAS_INTERCHANGE));
+            context.register(CommandExtension(canvasDrawioExportCommands, {
+                'canvas.export.drawio': ExportIcon(),
+                // The icon of the view actions derived from the frameworks'
+                // `*:export` capabilities (`interchange-export.ts`): they are
+                // listed by the host façade, never registered as commands, so their
+                // one icon rides on this table.
+                [INTERCHANGE_EXPORT_ICON_KEY]: ExportIcon(),
+            }));
+            // The whole canvas as SVG (ADR 0034, amendment of 2026-10-14): the
+            // renderer replay of `export.svg`, over everything this viewer sees.
+            // Never gated, for the PNG's reason.
+            context.register(CommandExtension(canvasSvgExportCommands, {
+                'canvas.export.svg': ExportToSvgIcon(),
+            }));
             // 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-block-table/adapters/utils.js

@@ -130,12 +130,35 @@ export const parseTableFromHtml = (element, astToDelta) => {
     });
     return createTableProps(rowTextLists);
 };
+/**
+ * A cell holds rich text, and no inline matcher turns an `image` into a delta:
+ * `![alt](url)` in a pasted Markdown table used to vanish from its cell. It is
+ * kept as a link named by its alt text (its URL when it has none), so nothing
+ * of the source is lost; the link matcher still refuses an unsafe scheme and
+ * keeps the words (labre REQ-IM-2, "no data loss").
+ */
+function imagesAsLinks(node) {
+    if (node.type === 'image') {
+        return {
+            type: 'link',
+            url: node.url,
+            title: node.title,
+            children: [{ type: 'text', value: node.alt || node.url }],
+        };
+    }
+    if (!('children' in node))
+        return node;
+    return {
+        ...node,
+        children: node.children.map(child => imagesAsLinks(child)),
+    };
+}
 export const parseTableFromMarkdown = (node, astToDelta) => {
     const rowTextLists = [];
     node.children.forEach(row => {
         const rowText = [];
         row.children.forEach(cell => {
-            rowText.push(astToDelta(cell));
+            rowText.push(astToDelta(imagesAsLinks(cell)));
         });
         rowTextLists.push(rowText);
     });

package/dist/_pkgs/affine-components/color-picker/color-panel.d.ts

@@ -16,6 +16,17 @@ export declare class EdgelessColorPanel extends LitElement {
     select(palette: Palette): void;
     get resolvedValue(): string | null;
     willUpdate(changedProperties: PropertyValues<this>): void;
+    connectedCallback(): void;
+    /**
+     * The keyboard path of the grid (a roving tab stop, ADR 0036 amendment of
+     * 2026-10-14): Tab reaches one swatch, the current colour or the first;
+     * the arrows move between swatches (up and down by `columns` when the grid
+     * declares them, else by one); Enter or Space picks, through the same
+     * click a pointer sends. A handled key goes no further, so the canvas does
+     * not also read it as a nudge or a pan.
+     */
+    private readonly _onKeydown;
+    private _focusIndex;
     render(): import("lit-html").TemplateResult<1>;
     accessor hasTransparent: boolean;
     accessor hollowCircle: boolean;

package/dist/_pkgs/affine-components/color-picker/color-panel.js

@@ -142,6 +142,12 @@ let EdgelessColorButton = (() => {
     :host([active])::after {
       border: 1.5px solid var(--affine-primary-color);
     }
+
+    :host(:focus-visible) {
+      outline: 2px solid ${unsafeCSSVarV2('layer/insideBorder/primaryBorder')};
+      outline-offset: 2px;
+      border-radius: 50%;
+    }
   `; }
         get preprocessColor() {
             const value = resolveColor(this.color, this.theme);
@@ -150,7 +156,11 @@ let EdgelessColorButton = (() => {
         render() {
             const { label, preprocessColor, hollowCircle } = this;
             const additionIcon = AdditionIcon(preprocessColor, !!hollowCircle);
-            return html `<div class="color-unit" aria-label=${ifDefined(label)}>
+            return html `<div
+      class="color-unit"
+      aria-label=${ifDefined(label)}
+      title=${ifDefined(label)}
+    >
       ${additionIcon}
     </div>`;
         }
@@ -268,38 +278,56 @@ let EdgelessColorPanel = (() => {
                 }
             }
         }
+        connectedCallback() {
+            super.connectedCallback();
+            if (!this.hasAttribute('role'))
+                this.setAttribute('role', 'radiogroup');
+        }
         render() {
+            const resolvedValue = this.resolvedValue;
+            const resolved = this.palettes.map(palette => resolveColor(palette.value, this.theme));
+            const activeIndex = resolved.findIndex(color => isEqual(color, resolvedValue));
+            const focusIndex = this._focusIndex !== undefined && this._focusIndex < resolved.length
+                ? this._focusIndex
+                : Math.max(activeIndex, 0);
             return html `
-      ${repeat(this.palettes, palette => palette.key, palette => {
-                const resolvedColor = resolveColor(palette.value, this.theme);
-                const activated = isEqual(resolvedColor, this.resolvedValue);
+      ${repeat(this.palettes, palette => palette.key, (palette, index) => {
+                const resolvedColor = resolved[index] ?? '';
+                const activated = isEqual(resolvedColor, resolvedValue);
+                const label = resolvePaletteLabel(this.std, palette);
                 return html `<edgeless-color-button
             class=${classMap({ large: true })}
-            .label=${resolvePaletteLabel(this.std, palette)}
+            role="radio"
+            aria-checked=${activated ? 'true' : 'false'}
+            aria-label=${label}
+            tabindex=${index === focusIndex ? '0' : '-1'}
+            .label=${label}
             .color=${palette.value}
             .theme=${this.theme}
             .hollowCircle=${this.hollowCircle}
             ?active=${activated}
             @click=${() => {
+                    this._focusIndex = index;
                     this.select(palette);
                     this.value = resolvedColor;
                 }}
+            @keydown=${(event) => this._onKeydown(event, index)}
           >
           </edgeless-color-button>`;
             })}
       <slot name="custom"></slot>
     `;
         }
-        #hasTransparent_accessor_storage = __runInitializers(this, _hasTransparent_initializers, true);
+        #hasTransparent_accessor_storage;
         get hasTransparent() { return this.#hasTransparent_accessor_storage; }
         set hasTransparent(value) { this.#hasTransparent_accessor_storage = value; }
-        #hollowCircle_accessor_storage = (__runInitializers(this, _hasTransparent_extraInitializers), __runInitializers(this, _hollowCircle_initializers, false));
+        #hollowCircle_accessor_storage;
         get hollowCircle() { return this.#hollowCircle_accessor_storage; }
         set hollowCircle(value) { this.#hollowCircle_accessor_storage = value; }
-        #palettes_accessor_storage = (__runInitializers(this, _hollowCircle_extraInitializers), __runInitializers(this, _palettes_initializers, DefaultTheme.Palettes));
+        #palettes_accessor_storage;
         get palettes() { return this.#palettes_accessor_storage; }
         set palettes(value) { this.#palettes_accessor_storage = value; }
-        #std_accessor_storage = (__runInitializers(this, _palettes_extraInitializers), __runInitializers(this, _std_initializers, undefined));
+        #std_accessor_storage;
         /**
          * Optional: with none, every swatch's label resolves to its English
          * fallback (or, for a swatch neither {@link resolvePaletteLabel} tier
@@ -308,17 +336,64 @@ let EdgelessColorPanel = (() => {
          */
         get std() { return this.#std_accessor_storage; }
         set std(value) { this.#std_accessor_storage = value; }
-        #theme_accessor_storage = (__runInitializers(this, _std_extraInitializers), __runInitializers(this, _theme_initializers, void 0));
+        #theme_accessor_storage;
         get theme() { return this.#theme_accessor_storage; }
         set theme(value) { this.#theme_accessor_storage = value; }
-        #value_accessor_storage = (__runInitializers(this, _theme_extraInitializers), __runInitializers(this, _value_initializers, null));
+        #value_accessor_storage;
         get value() { return this.#value_accessor_storage; }
         set value(value) { this.#value_accessor_storage = value; }
-        #columns_accessor_storage = (__runInitializers(this, _value_extraInitializers), __runInitializers(this, _columns_initializers, undefined));
+        #columns_accessor_storage;
         get columns() { return this.#columns_accessor_storage; }
         set columns(value) { this.#columns_accessor_storage = value; }
         constructor() {
             super(...arguments);
+            /**
+             * The keyboard path of the grid (a roving tab stop, ADR 0036 amendment of
+             * 2026-10-14): Tab reaches one swatch, the current colour or the first;
+             * the arrows move between swatches (up and down by `columns` when the grid
+             * declares them, else by one); Enter or Space picks, through the same
+             * click a pointer sends. A handled key goes no further, so the canvas does
+             * not also read it as a nudge or a pan.
+             */
+            this._onKeydown = (event, index) => {
+                if (event.isComposing)
+                    return;
+                if (event.key === 'Enter' || event.key === ' ') {
+                    event.preventDefault();
+                    event.stopPropagation();
+                    event.currentTarget.click();
+                    return;
+                }
+                const perRow = this.columns ?? 1;
+                const step = event.key === 'ArrowLeft'
+                    ? -1
+                    : event.key === 'ArrowRight'
+                        ? 1
+                        : event.key === 'ArrowUp'
+                            ? -perRow
+                            : event.key === 'ArrowDown'
+                                ? perRow
+                                : 0;
+                if (step === 0)
+                    return;
+                event.preventDefault();
+                event.stopPropagation();
+                const swatches = [
+                    ...this.renderRoot.querySelectorAll('edgeless-color-button'),
+                ];
+                const next = Math.min(Math.max(index + step, 0), swatches.length - 1);
+                this._focusIndex = next;
+                this.requestUpdate();
+                swatches[next]?.focus();
+            };
+            this._focusIndex = undefined;
+            this.#hasTransparent_accessor_storage = __runInitializers(this, _hasTransparent_initializers, true);
+            this.#hollowCircle_accessor_storage = (__runInitializers(this, _hasTransparent_extraInitializers), __runInitializers(this, _hollowCircle_initializers, false));
+            this.#palettes_accessor_storage = (__runInitializers(this, _hollowCircle_extraInitializers), __runInitializers(this, _palettes_initializers, DefaultTheme.Palettes));
+            this.#std_accessor_storage = (__runInitializers(this, _palettes_extraInitializers), __runInitializers(this, _std_initializers, undefined));
+            this.#theme_accessor_storage = (__runInitializers(this, _std_extraInitializers), __runInitializers(this, _theme_initializers, void 0));
+            this.#value_accessor_storage = (__runInitializers(this, _theme_extraInitializers), __runInitializers(this, _value_initializers, null));
+            this.#columns_accessor_storage = (__runInitializers(this, _value_extraInitializers), __runInitializers(this, _columns_initializers, undefined));
             __runInitializers(this, _columns_extraInitializers);
         }
     };

package/dist/_pkgs/affine-components/color-picker/framework-palette.d.ts

@@ -94,6 +94,14 @@ export declare function frameworkOfElement(gfx: GfxController, model: GfxModel):
  * palette, which is true of every element in it.
  */
 export declare function frameworkOfSelection(gfx: GfxController, models: readonly GfxModel[]): FrameworkId | undefined;
+/**
+ * The palettes the frameworks whose tooling is on registered with this
+ * editor, in {@link FRAMEWORK_IDS} order so the pages read the same way in
+ * every picker: the canvas carousel below and the database colour grid
+ * (`@labre/data-view`, ADR 0036 amendment of 2026-10-14) both page through
+ * this list.
+ */
+export declare function contributedFrameworkPalettes(std: BlockStdScope): FrameworkPalette[];
 /**
  * The carousel a contextual toolbar hands its colour picker.
  *

package/dist/_pkgs/affine-components/color-picker/framework-palette.js

@@ -144,6 +144,16 @@ export function frameworkOfSelection(gfx, models) {
         return undefined;
     return unanimous(models.map(model => frameworkOfElement(gfx, model)));
 }
+/**
+ * The palettes the frameworks whose tooling is on registered with this
+ * editor, in {@link FRAMEWORK_IDS} order so the pages read the same way in
+ * every picker: the canvas carousel below and the database colour grid
+ * (`@labre/data-view`, ADR 0036 amendment of 2026-10-14) both page through
+ * this list.
+ */
+export function contributedFrameworkPalettes(std) {
+    return [...std.provider.getAll(FrameworkPaletteIdentifier).values()].sort((a, b) => FRAMEWORK_IDS.indexOf(a.framework) - FRAMEWORK_IDS.indexOf(b.framework));
+}
 /**
  * The carousel a contextual toolbar hands its colour picker.
  *
@@ -154,9 +164,7 @@ export function frameworkOfSelection(gfx, models) {
  * carousel, else the base palette.
  */
 export function frameworkPaletteGroups(std, models, basePalettes) {
-    const contributed = [
-        ...std.provider.getAll(FrameworkPaletteIdentifier).values(),
-    ].sort((a, b) => FRAMEWORK_IDS.indexOf(a.framework) - FRAMEWORK_IDS.indexOf(b.framework));
+    const contributed = contributedFrameworkPalettes(std);
     const groups = [
         {
             key: BASE_PALETTE_KEY,

package/dist/_pkgs/affine-components/color-picker/icons.d.ts

@@ -1,5 +1,14 @@
 import { type TemplateResult } from 'lit';
 export declare function TransparentIcon(hollowCircle?: boolean): TemplateResult<1>;
+/**
+ * A swatch paints through `style` as well as the `fill` attribute: its colour
+ * may be a CSS variable string (the database options' chip colours, ADR 0036
+ * amendment of 2026-10-14), and `var(...)` in an SVG presentation attribute
+ * is an engine's courtesy (Chromium resolves it) where a `fill` declaration
+ * is the CSS rule. The inline style wins and paints a plain colour exactly
+ * as the attribute did.
+ */
 export declare function CircleIcon(color: string): TemplateResult<1>;
+/** Painted through `style` too, for the reason {@link CircleIcon} gives. */
 export declare function HollowCircleIcon(color: string): TemplateResult<1>;
 export declare function AdditionIcon(color: string, hollowCircle: boolean): TemplateResult<1>;

package/dist/_pkgs/affine-components/color-picker/icons.js

@@ -1,6 +1,7 @@
 import { isTransparent } from '../../affine-model/index.js';
 import { cssVarV2 } from '../../affine-shared/theme/index.js';
 import { html, svg } from 'lit';
+import { styleMap } from 'lit/directives/style-map.js';
 export function TransparentIcon(hollowCircle = false) {
     const CircleIcon = hollowCircle
         ? svg `<circle cx="10" cy="10" r="8" fill="white" />`
@@ -23,6 +24,14 @@ export function TransparentIcon(hollowCircle = false) {
     </svg>
   `;
 }
+/**
+ * A swatch paints through `style` as well as the `fill` attribute: its colour
+ * may be a CSS variable string (the database options' chip colours, ADR 0036
+ * amendment of 2026-10-14), and `var(...)` in an SVG presentation attribute
+ * is an engine's courtesy (Chromium resolves it) where a `fill` declaration
+ * is the CSS rule. The inline style wins and paints a plain colour exactly
+ * as the attribute did.
+ */
 export function CircleIcon(color) {
     return html `
     <svg
@@ -31,11 +40,13 @@ export function CircleIcon(color) {
       height="20"
       viewBox="0 0 20 20"
       fill="${color}"
+      style=${styleMap({ fill: color })}
     >
       <circle cx="10" cy="10" r="10" />
     </svg>
   `;
 }
+/** Painted through `style` too, for the reason {@link CircleIcon} gives. */
 export function HollowCircleIcon(color) {
     return html `
     <svg
@@ -44,6 +55,7 @@ export function HollowCircleIcon(color) {
       height="20"
       viewBox="0 0 20 20"
       fill="${color}"
+      style=${styleMap({ fill: color })}
     >
       <path
         fill-rule="evenodd"

package/dist/_pkgs/affine-gfx-note/toolbar/note-menu.js

@@ -32,13 +32,12 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { addAttachments } from '../../affine-block-attachment/index.js';
+import { pickAndAddAttachments } from '../../affine-block-attachment/index.js';
 import { insertLinkByQuickSearchCommand } from '../../affine-block-bookmark/index.js';
-import { addImages } from '../../affine-block-image/index.js';
+import { pickAndAddImages } from '../../affine-block-image/index.js';
 import { DefaultTool } from '../../affine-block-surface/index.js';
 import { MAX_IMAGE_WIDTH } from '../../affine-model/index.js';
 import { TelemetryProvider, translateKey } from '../../affine-shared/services/index.js';
-import { getImageFilesFromLocal, openSingleFileWith, } from '../../affine-shared/utils/index.js';
 import { EdgelessToolbarToolMixin } from '../../affine-widget-edgeless-toolbar/index.js';
 import { AttachmentIcon, ImageIcon, LinkIcon } from '@blocksuite/icons/lit';
 import { effect } from '@preact/signals-core';
@@ -112,8 +111,7 @@ let EdgelessNoteMenu = (() => {
   `; }
         async _addImages() {
             this._imageLoading = true;
-            const imageFiles = await getImageFilesFromLocal();
-            const ids = await addImages(this.edgeless.std, imageFiles, {
+            const ids = await pickAndAddImages(this.edgeless.std, {
                 maxWidth: MAX_IMAGE_WIDTH,
             });
             this._imageLoading = false;
@@ -185,10 +183,9 @@ let EdgelessNoteMenu = (() => {
               .activeMode=${'background'}
               .tooltip=${translateKey(this.edgeless.std, ...GFX_NOTE_MENU_FILE)}
               @click=${async () => {
-                const file = await openSingleFileWith();
-                if (!file)
+                const ids = await pickAndAddAttachments(this.edgeless.std);
+                if (!ids.length)
                     return;
-                await addAttachments(this.edgeless.std, [file]);
                 this.gfx.tool.setTool(DefaultTool);
                 this.edgeless.std
                     .getOptional(TelemetryProvider)

package/dist/_pkgs/affine-gfx-template/contribute.d.ts

@@ -26,9 +26,19 @@ export declare const TemplateCategoryIdentifier: import("../global/di/types.js")
  */
 export declare function TemplateCategoryExtension(...categories: TemplateCategory[]): ExtensionType;
 /**
- * The catalogue ONE editor sees: the built-in categories (`Other`, plus
- * whatever a host appended through `EdgelessTemplatePanel.templates.extend`)
- * followed by the categories the view extensions mounted on this `std`
- * registered — i.e. exactly the frameworks whose tooling is on.
+ * The identity of the host's category of saved frames (the
+ * `FrameTemplateProvider` seam): the stable name the panel remembers and
+ * lists by. Its tab reads {@link TEMPLATE_PANEL_CATEGORY_SAVED_FRAMES}.
+ */
+export declare const SAVED_FRAMES_CATEGORY = "Saved frames";
+/**
+ * The catalogue ONE editor sees: the built-in `Other`, then the categories
+ * the view extensions mounted on this `std` registered — i.e. exactly the
+ * frameworks whose tooling is on — then the host's saved frames, when a
+ * host keeps them (`FrameTemplateProvider`).
+ *
+ * Per editor, from its DI container: the module-level `extend(...)` of
+ * 0.49 and earlier, which appended for every editor and was never emptied,
+ * is gone (a host category is a `TemplateCategoryExtension`).
  */
 export declare function templateManagerFor(std: BlockStdScope): TemplateManager;

package/dist/_pkgs/affine-gfx-template/contribute.js

@@ -1,6 +1,8 @@
+import { FrameTemplateProvider, } from '../affine-shared/services/index.js';
 import { createIdentifier } from '../global/di/index.js';
 import { builtInTemplates } from './toolbar/builtin-templates.js';
 import { resolveTemplateName } from './toolbar/resolve-name.js';
+import { TEMPLATE_PANEL_CATEGORY_SAVED_FRAMES } from './translations.js';
 /**
  * A framework registers its Templates-panel categories here; the panel reads
  * them back from the std of the edgeless it opens on. One identifier per
@@ -33,20 +35,61 @@ export function TemplateCategoryExtension(...categories) {
         },
     };
 }
+/**
+ * The identity of the host's category of saved frames (the
+ * `FrameTemplateProvider` seam): the stable name the panel remembers and
+ * lists by. Its tab reads {@link TEMPLATE_PANEL_CATEGORY_SAVED_FRAMES}.
+ */
+export const SAVED_FRAMES_CATEGORY = 'Saved frames';
+function savedFrameTemplate(service, saved) {
+    return {
+        name: saved.title,
+        type: 'template',
+        content: saved.snapshot,
+        preview: saved.preview,
+        // The panel runs `afterInsert` only once the template job has resolved.
+        afterInsert: service.frameInserted
+            ? std => service.frameInserted?.({
+                docId: std.store.id,
+                templateId: saved.id,
+            })
+            : undefined,
+    };
+}
+/**
+ * The host's saved frames as a category, or none without a host. Lazy: the
+ * host is asked only when the panel shows the tab or searches across tabs.
+ */
+function savedFramesCategory(std) {
+    const service = std.provider.getOptional(FrameTemplateProvider);
+    if (!service)
+        return null;
+    return {
+        name: SAVED_FRAMES_CATEGORY,
+        nameKey: TEMPLATE_PANEL_CATEGORY_SAVED_FRAMES[0],
+        templates: async () => (await service.list()).map(saved => savedFrameTemplate(service, saved)),
+    };
+}
 function loadCategory(category) {
     return Array.isArray(category.templates)
         ? Promise.resolve(category.templates)
         : category.templates();
 }
 /**
- * The catalogue ONE editor sees: the built-in categories (`Other`, plus
- * whatever a host appended through `EdgelessTemplatePanel.templates.extend`)
- * followed by the categories the view extensions mounted on this `std`
- * registered — i.e. exactly the frameworks whose tooling is on.
+ * The catalogue ONE editor sees: the built-in `Other`, then the categories
+ * the view extensions mounted on this `std` registered — i.e. exactly the
+ * frameworks whose tooling is on — then the host's saved frames, when a
+ * host keeps them (`FrameTemplateProvider`).
+ *
+ * Per editor, from its DI container: the module-level `extend(...)` of
+ * 0.49 and earlier, which appended for every editor and was never emptied,
+ * is gone (a host category is a `TemplateCategoryExtension`).
  */
 export function templateManagerFor(std) {
+    const saved = savedFramesCategory(std);
     const contributed = [
         ...std.provider.getAll(TemplateCategoryIdentifier).values(),
+        ...(saved ? [saved] : []),
     ];
     const byName = (name) => contributed.find(c => c.name === name);
     return {
@@ -57,8 +100,6 @@ export function templateManagerFor(std) {
             ]),
         ],
         categoryLabel: name => byName(name)?.nameKey ?? builtInTemplates.categoryLabel(name),
-        // Both halves, so a host's `extend(...)` can still append to a framework's
-        // own category (the global half answers `[]` for a name it does not know).
         list: async (name) => {
             const category = byName(name);
             return [

package/dist/_pkgs/affine-gfx-template/toolbar/builtin-templates.d.ts

@@ -1,9 +1,14 @@
-import type { Template, TemplateCategory, TemplateManager } from './template-type.js';
+import type { Template, TemplateCategory } from './template-type.js';
 export declare const templates: TemplateCategory[];
+/**
+ * The catalogue every editor has, whatever is mounted: `Other`. A host or a
+ * framework adds a category per editor with `TemplateCategoryExtension`; the
+ * module-level `extend(...)` this object carried until 0.49 appended for every
+ * editor of the page and was never emptied.
+ */
 export declare const builtInTemplates: {
     list: (category: string) => Promise<Template[]>;
     categories: () => Promise<string[]>;
     categoryLabel: (name: string) => string | undefined;
     search: (keyword: string, cateName?: string) => Promise<Template[]>;
-    extend(manager: TemplateManager): void;
 };

package/dist/_pkgs/affine-gfx-template/toolbar/builtin-templates.js

@@ -16,48 +16,27 @@ function lcs(text1, text2) {
     }
     return dp[text1.length][text2.length];
 }
-const extendTemplate = [];
-const flat = (arr) => arr.reduce((pre, current) => {
-    if (current) {
-        return pre.concat(current);
-    }
-    return pre;
-}, []);
+/**
+ * The catalogue every editor has, whatever is mounted: `Other`. A host or a
+ * framework adds a category per editor with `TemplateCategoryExtension`; the
+ * module-level `extend(...)` this object carried until 0.49 appended for every
+ * editor of the page and was never emptied.
+ */
 export const builtInTemplates = {
     list: async (category) => {
-        const extendTemplates = flat(await Promise.all(extendTemplate.map(manager => manager.list(category))));
-        // eslint-disable-next-line sonarjs/no-empty-collection
         const cate = templates.find(cate => cate.name === category);
         if (!cate)
-            return extendTemplates;
-        const result = cate.templates instanceof Function
-            ? await cate.templates()
-            : await Promise.all(Object.values(cate.templates));
-        return result.concat(extendTemplates);
-    },
-    categories: async () => {
-        const extendCates = flat(await Promise.all(extendTemplate.map(manager => manager.categories())));
-        // eslint-disable-next-line sonarjs/no-empty-collection
-        return templates.map(cate => cate.name).concat(extendCates);
-    },
-    categoryLabel: (name) => {
-        // eslint-disable-next-line sonarjs/no-empty-collection
-        const own = templates.find(cate => cate.name === name)?.nameKey;
-        if (own)
-            return own;
-        for (const manager of extendTemplate) {
-            const key = manager.categoryLabel?.(name);
-            if (key)
-                return key;
-        }
-        return undefined;
+            return [];
+        return cate.templates instanceof Function
+            ? cate.templates()
+            : cate.templates;
     },
+    categories: async () => templates.map(cate => cate.name),
+    categoryLabel: (name) => templates.find(cate => cate.name === name)?.nameKey,
     search: async (keyword, cateName) => {
-        const candidates = flat(await Promise.all(extendTemplate.map(manager => manager.search(keyword, cateName))));
+        const candidates = [];
         keyword = keyword.trim().toLocaleLowerCase();
-        await Promise.all(
-        // eslint-disable-next-line sonarjs/no-empty-collection
-        templates.map(async (categroy) => {
+        await Promise.all(templates.map(async (categroy) => {
             if (cateName && cateName !== categroy.name) {
                 return;
             }
@@ -73,9 +52,4 @@ export const builtInTemplates = {
         }));
         return candidates;
     },
-    extend(manager) {
-        if (extendTemplate.includes(manager))
-            return;
-        extendTemplate.push(manager);
-    },
 };

package/dist/_pkgs/affine-gfx-template/toolbar/resolve-name.d.ts

@@ -10,7 +10,7 @@ import type { Template } from './template-type.js';
  * through this generic seam.
  *
  * `Template.name` itself stays the STABLE identity `templateFromCommand`
- * bakes in (the drag payload, the `repeat` key, the `templateCache` storage
+ * bakes in (the drag payload, the search, the `templateCache` storage
  * key) — and it is ALSO what gets passed as `translateKey`'s fallback, never
  * `command.labelFallback`: most derived templates leave `name` at its default
  * (the command's own fallback, so the two agree anyway), but a few tiles

package/dist/_pkgs/affine-gfx-template/toolbar/resolve-name.js

@@ -10,7 +10,7 @@ import { getRegisteredCommands } from '../../std/index.js';
  * through this generic seam.
  *
  * `Template.name` itself stays the STABLE identity `templateFromCommand`
- * bakes in (the drag payload, the `repeat` key, the `templateCache` storage
+ * bakes in (the drag payload, the search, the `templateCache` storage
  * key) — and it is ALSO what gets passed as `translateKey`'s fallback, never
  * `command.labelFallback`: most derived templates leave `name` at its default
  * (the command's own fallback, so the two agree anyway), but a few tiles

package/dist/_pkgs/affine-gfx-template/toolbar/template-panel.d.ts

@@ -6,16 +6,16 @@ declare const EdgelessTemplatePanel_base: typeof LitElement & import("../../glob
 export declare class EdgelessTemplatePanel extends EdgelessTemplatePanel_base {
     static styles: import("lit").CSSResult;
     /**
-     * The GLOBAL half of the catalogue — `Other` and a host's `extend(...)`.
-     * Framework categories are not here: they live in the editor's DI container
-     * (`TemplateCategoryExtension`) and are read through {@link catalogue}.
+     * The GLOBAL half of the catalogue — `Other`. Framework and host
+     * categories are not here: they live in the editor's DI container
+     * (`TemplateCategoryExtension`, `FrameTemplateProvider`) and are read
+     * through {@link catalogue}.
      */
     static templates: {
         list: (category: string) => Promise<Template[]>;
         categories: () => Promise<string[]>;
         categoryLabel: (name: string) => string | undefined;
         search: (keyword: string, cateName?: string) => Promise<Template[]>;
-        extend(manager: import("./template-type.js").TemplateManager): void;
     };
     /** What THIS edgeless offers: the global half plus its std's categories. */
     get catalogue(): import("./template-type.js").TemplateManager;