@formicoidea/labre-core 0.32.0 → 0.33.0

package/dist/_pkgs/affine-shared/services/command-usage-service.js

@@ -0,0 +1,109 @@
+import { CommandUsageIdentifier, } from '../../std/index.js';
+/**
+ * Where `createLocalCommandUsageStore` persists. Namespaced like the rest of
+ * Labre's browser-local state, and versionless on purpose: the shape is two
+ * numbers per command, and a reader that does not recognise an entry drops it.
+ */
+export const COMMAND_USAGE_KEY = 'labre:command-usage';
+/**
+ * Enough for every command of every framework several times over (the registry
+ * holds 76 today), small enough that the JSON stays a few kilobytes. Overflow
+ * evicts the least recently used entry, so the measure a ranking cares about —
+ * what this user reached for lately — is the last thing lost.
+ */
+const MAX_ENTRIES = 200;
+/**
+ * `localStorage` throws outright in a few environments (private mode quotas,
+ * sandboxed frames, some test runners), and a usage measure is never important
+ * enough to take a command down with it — every access is therefore
+ * best-effort. Same rule and same shape as the icon picker's recent store.
+ */
+const storage = () => {
+    try {
+        return globalThis.localStorage ?? null;
+    }
+    catch {
+        return null;
+    }
+};
+const readUsage = () => {
+    try {
+        const raw = storage()?.getItem(COMMAND_USAGE_KEY);
+        if (!raw)
+            return {};
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object')
+            return {};
+        // Entry by entry: one corrupted record must not discard the whole table.
+        const usage = {};
+        for (const [id, value] of Object.entries(parsed)) {
+            const { c, t } = (value ?? {});
+            if (typeof c === 'number' && typeof t === 'number')
+                usage[id] = { c, t };
+        }
+        return usage;
+    }
+    catch {
+        return {};
+    }
+};
+const writeUsage = (usage) => {
+    try {
+        storage()?.setItem(COMMAND_USAGE_KEY, JSON.stringify(usage));
+    }
+    catch {
+        // best-effort: this session keeps working, the measure just misses a run
+    }
+};
+/** Keeps the {@link MAX_ENTRIES} most recently used entries, nothing else. */
+const evictOverflow = (usage) => {
+    const ids = Object.keys(usage);
+    if (ids.length <= MAX_ENTRIES)
+        return usage;
+    const kept = ids
+        .sort((a, b) => usage[b].t - usage[a].t)
+        .slice(0, MAX_ENTRIES);
+    return Object.fromEntries(kept.map(id => [id, usage[id]]));
+};
+/**
+ * The default {@link CommandUsageStore}: recency and frequency in this
+ * browser's `localStorage`, per command id.
+ *
+ * It measures only. Nothing ranks anything here — PF6's "seven most-recent +
+ * six most-used" sub-menu reads these numbers, and a host that
+ * wants the measure to follow the user across devices replaces the whole store
+ * through {@link CommandUsageExtension}.
+ */
+export function createLocalCommandUsageStore() {
+    return {
+        record: (command) => {
+            const usage = readUsage();
+            const previous = usage[command.id];
+            usage[command.id] = { c: (previous?.c ?? 0) + 1, t: Date.now() };
+            writeUsage(evictOverflow(usage));
+        },
+        statsOf: (commandId) => {
+            const entry = readUsage()[commandId];
+            return entry ? { count: entry.c, lastUsedAt: entry.t } : undefined;
+        },
+    };
+}
+/**
+ * Host override seam: replace the browser-local measure with the host's own.
+ *
+ * This is where a host persists command usage in ITS database — so the ranking
+ * follows the user from laptop to browser to tablet instead of restarting at
+ * zero, which is exactly what a "most-used" sub-menu is judged on. The library
+ * ships the local store as the default (`CommandUsageViewExtension`) and never
+ * requires a host to care.
+ *
+ * Mirrors `EditorSettingExtension` / `KeymapOverrideExtension`: `di.override`,
+ * so a host registering after the library's own extensions always wins.
+ */
+export function CommandUsageExtension(store) {
+    return {
+        setup: di => {
+            di.override(CommandUsageIdentifier, () => store);
+        },
+    };
+}

package/dist/_pkgs/affine-shared/services/comment-service/block-comment-manager.js

@@ -1,6 +1,6 @@
 import { DividerBlockModel } from '../../../affine-model/index.js';
 import { DisposableGroup } from '../../../global/disposable/index.js';
-import { BlockSelection, LifeCycleWatcher, TextSelection, } from '../../../std/index.js';
+import { BlockSelection, LifeCycleWatcher, TextSelection } from '../../../std/index.js';
 import { signal } from '@preact/signals-core';
 import { getSelectedBlocksCommand } from '../../commands/index.js';
 import { ImageSelection } from '../../selection/index.js';

package/dist/_pkgs/affine-shared/services/doc-display-meta-service.js

@@ -1,5 +1,5 @@
 import { createIdentifier } from '../../global/di/index.js';
-import { disposeMember, } from '../../global/disposable/index.js';
+import { disposeMember } from '../../global/disposable/index.js';
 import { AliasIcon, BlockLinkIcon, DeleteIcon, EdgelessIcon, LinkedEdgelessIcon, LinkedPageIcon, PageIcon, } from '@blocksuite/icons/lit';
 import { LifeCycleWatcher, StdIdentifier } from '../../std/index.js';
 import { computed, signal, } from '@preact/signals-core';

package/dist/_pkgs/affine-shared/services/embed-iframe/embed-iframe-config.js

@@ -1,4 +1,4 @@
-import { createIdentifier, } from '../../../global/di/index.js';
+import { createIdentifier } from '../../../global/di/index.js';
 export const EmbedIframeConfigIdentifier = createIdentifier('EmbedIframeConfig');
 export function EmbedIframeConfigExtension(config) {
     const identifier = EmbedIframeConfigIdentifier(config.name);

package/dist/_pkgs/affine-shared/services/index.d.ts

@@ -1,7 +1,9 @@
+export * from './artefact-catalogue-service.js';
 export * from './audit-service.js';
 export * from './auto-clear-selection-service.js';
 export * from './block-meta-service.js';
 export * from './citation-service/index.js';
+export * from './command-usage-service.js';
 export * from './comment-service/index.js';
 export * from './doc-display-meta-service.js';
 export * from './doc-mode-service.js';

package/dist/_pkgs/affine-shared/services/index.js

@@ -1,7 +1,9 @@
+export * from './artefact-catalogue-service.js';
 export * from './audit-service.js';
 export * from './auto-clear-selection-service.js';
 export * from './block-meta-service.js';
 export * from './citation-service/index.js';
+export * from './command-usage-service.js';
 export * from './comment-service/index.js';
 export * from './doc-display-meta-service.js';
 export * from './doc-mode-service.js';

package/dist/_pkgs/affine-shared/services/pivot-materiality-publisher.js

@@ -110,7 +110,8 @@ export class PivotMaterialityPublisher extends LifeCycleWatcher {
         // there is nobody to announce to, so nothing is subscribed and the whole
         // watcher costs one lookup. Binding and qualification keep working: they
         // are element-local writes and never needed the host.
-        if (!this.std.getOptional(PivotPropertiesProvider)?.publishOccurrenceMaterialities) {
+        if (!this.std.getOptional(PivotPropertiesProvider)
+            ?.publishOccurrenceMaterialities) {
             return;
         }
         // The surface is a SIGNAL, not a fact: it can legitimately be null at mount

package/dist/_pkgs/affine-shared/services/telemetry-service/lifecycle.d.ts

@@ -34,7 +34,7 @@ export type BlockLifecycleEvents = {
  * manipulated ('background:classic', 'node:market', 'connector:link'…).
  */
 export interface FrameworkElementEvent extends TelemetryEvent {
-    framework: 'wardley' | 'edgy' | 'cynefin' | 'bpmn' | 'event-storming' | 'core-domain' | 'context-map';
+    framework: 'wardley' | 'edgy' | 'cynefin' | 'bpmn' | 'c4' | 'event-storming' | 'core-domain' | 'context-map';
     element: string;
 }
 /**
@@ -101,11 +101,83 @@ export interface EdgeDirectionEvent extends TelemetryEvent {
     /** How many edges the single gesture reversed. */
     elementCount: number;
 }
+/**
+ * A framework element became a NEARBY kind of itself — a task said more
+ * precisely as a user task, a start event as a timer start — from its own
+ * contextual toolbar, in one atomic write.
+ *
+ * **A new event name, for the reason {@link FrameworkPromotionEvent} gives.**
+ * ADR 0003 § 2 defines the creation event as UI intent emitted at INSERTION
+ * sites, and a morph inserts nothing: no element is created, destroyed or
+ * swapped, no id changes, no geometry moves and no connector is re-pointed.
+ * Reusing `FrameworkElementAdded` would count a drawn-then-refined artefact
+ * twice and inflate "elements added per framework" permanently.
+ *
+ * Worth measuring on its own, too. The set of reachable kinds is DATA a
+ * framework declares by hand, and the only evidence that a declared family is
+ * the right family is how often it is actually crossed — a pair nobody ever
+ * morphs between did not need to be offered, and a morph users reach for
+ * constantly says the palette led them to the wrong artefact first.
+ *
+ * Ids only: the two roles, and their framework. Never a kind's board content,
+ * never the element ids, never the label anybody typed.
+ */
+export interface FrameworkElementMorphedEvent extends TelemetryEvent {
+    page?: 'whiteboard editor';
+    /**
+     * Owning framework — the declaration's own wire key, matching what
+     * `reportCommandTelemetry` sends for that framework's commands.
+     *
+     * OPTIONAL for the same reason it is on {@link FrameworkPromotionEvent}: the
+     * capability is generic, and an element type may one day declare a morph
+     * without belonging to a framework the union names. Absent rather than
+     * `'unknown'`, per the repo convention.
+     */
+    framework?: FrameworkId;
+    /** Role id the selection carried, when they all carried the same one. */
+    fromRole?: string;
+    /** Role id it now carries. */
+    toRole?: string;
+    /** How many elements the single gesture actually rewrote. */
+    elementCount: number;
+}
+/**
+ * A framework VIEW was told which level it draws — a C4 board set to Context,
+ * Container or Component, or put back to a free sketch.
+ *
+ * **A new event name, for the reason {@link FrameworkPromotionEvent} gives.**
+ * Nothing is inserted, nothing is morphed and no level of requirement changes:
+ * the author is stating what the sheet IS, which is a fact none of the existing
+ * events describes. Reusing one of them would corrupt the funnel it belongs to.
+ *
+ * Worth measuring on its own, and for the same reason a profile change is: this
+ * is an OPTIONAL declaration nothing forces, so how often it is made is the only
+ * evidence that asking for it was worth the toolbar entry — and a level users
+ * set and then clear is a rule pack that argued with a drawing they meant.
+ *
+ * Ids only: the framework and the level's own closed vocabulary. Never the
+ * board's title, never what is drawn on it.
+ */
+export interface FrameworkViewLevelEvent extends TelemetryEvent {
+    page?: 'whiteboard editor';
+    /** Owning framework of the view, e.g. `c4`. */
+    framework: FrameworkId;
+    /**
+     * The level now in force, from the framework's own closed vocabulary —
+     * `'none'` when the view has been put back to declaring nothing, which is a
+     * value the dashboard needs as much as the others.
+     */
+    level: string;
+    /** The one it replaces, when the view declared one. */
+    previousLevel?: string;
+}
 export type FrameworkDiagramEvents = {
     FrameworkElementAdded: FrameworkElementEvent;
     FrameworkToolPicked: FrameworkElementEvent;
     FrameworkLegendCreated: FrameworkElementEvent;
     FrameworkElementPromoted: FrameworkPromotionEvent;
+    FrameworkElementMorphed: FrameworkElementMorphedEvent;
+    FrameworkViewLevelSet: FrameworkViewLevelEvent;
     EdgeDirectionInverted: EdgeDirectionEvent;
 };
 /**

package/dist/_pkgs/affine-shared/services/toolbar-service/registry.d.ts

@@ -8,7 +8,19 @@ import type { ToolbarModule } from './module.js';
 export declare const ToolbarModuleIdentifier: import("../../../global/di/types.js").ServiceIdentifier<ToolbarModule> & (<U extends ToolbarModule = ToolbarModule>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);
 export declare const ToolbarRegistryIdentifier: import("../../../global/di/types.js").ServiceIdentifier<ToolbarRegistryExtension> & (<U extends ToolbarRegistryExtension = ToolbarRegistryExtension>(variant: import("../../../global/di/types.js").ServiceVariant) => import("../../../global/di/types.js").ServiceIdentifier<U>);
 export declare function ToolbarModuleExtension(module: ToolbarModule): ExtensionType;
+/** The flavour a DI variant speaks for, owner suffix and all. */
+export declare function toolbarModuleFlavour(variant: string): string;
+/**
+ * A second (or third) module on one flavour, named by who contributes it.
+ *
+ * The owner is never shown and never parsed back — it exists so two
+ * contributors cannot claim one DI variant. Use a stable, framework-scoped
+ * name (`c4-morph`), because it is the identity the container refuses
+ * duplicates on.
+ */
+export declare function toolbarModuleKey(flavour: string, owner: string): string;
 export declare class ToolbarRegistryExtension extends Extension {
+    #private;
     readonly std: BlockStdScope;
     flavour$: import("@preact/signals-core").Signal<string>;
     elementsMap$: import("@preact/signals-core").Signal<Map<string, GfxModel[]>>;
@@ -20,8 +32,40 @@ export declare class ToolbarRegistryExtension extends Extension {
     placement$: import("@preact/signals-core").Signal<ToolbarPlacement>;
     flags: Flags;
     constructor(std: BlockStdScope);
+    /**
+     * Every module of every flavour, keyed by the DI variant it was registered
+     * under — which for a shared flavour carries an owner suffix. Read
+     * {@link modulesFor} instead unless the variant itself is the question.
+     */
     get modules(): Map<string, ToolbarModule>;
+    /**
+     * Every module contributing to one flavour's row — the bare-key module
+     * first, then the owner-suffixed ones in registration order.
+     */
+    modulesFor(flavour: string): readonly ToolbarModule[];
+    /**
+     * The config registered under the flavour ITSELF, or `null`.
+     *
+     * Deliberately not "the first module of this flavour". The callers of this
+     * method ask a question about one identified registration — does this block
+     * flavour have a toolbar of its own, where does that toolbar sit — and an
+     * owner-suffixed contributor is an ADDITION to a row, not a stand-in for the
+     * module that defines it. Answering with a contributor would make the reply
+     * depend on which frameworks a host happened to switch on: with `wardley`
+     * off and `c4` on, `custom:affine:surface:group` has no bare module at all,
+     * and returning C4's morph there would let a placement (or a `has`-style
+     * probe) be decided by a menu that only some builds ship.
+     */
     getModuleBy(flavour: string): import("./config.js").ToolbarModuleConfig | null;
+    /**
+     * Where a flavour's row sits: the first module of it that actually SAYS.
+     *
+     * A row is one row however many modules contribute to it, so the placement
+     * is a property of the flavour and not of a registration — and a contributor
+     * that declares none must not be read as declaring the default. Scanning for
+     * the first module with a `placement` keeps the answer the same whether the
+     * framework that states it is registered first, last, or under an owner.
+     */
     getModulePlacement(flavour: string, fallback?: ToolbarPlacement): ToolbarPlacement;
     static setup(di: Container): void;
 }

package/dist/_pkgs/affine-shared/services/toolbar-service/registry.js

@@ -12,6 +12,61 @@ export function ToolbarModuleExtension(module) {
         },
     };
 }
+/**
+ * What separates a flavour from the OWNER of one of its modules.
+ *
+ * A module is registered under one DI variant, and until now that variant WAS
+ * the flavour — so a flavour held at most two modules, its own key and its
+ * `custom:` twin, and a third contributor got a `DuplicateServiceDefinitionError`
+ * at setup rather than a menu entry. That ceiling was invisible until two
+ * frameworks needed the same element: `affine:surface:group` carries the native
+ * group operations, `custom:affine:surface:group` carries Wardley's
+ * qualification dropdown, and a C4 component IS a group — so C4's morph had
+ * nowhere at all to be registered.
+ *
+ * {@link toolbarModuleKey} gives it one. `custom:affine:surface:group#c4-morph`
+ * is a DISTINCT DI variant and therefore never collides, while
+ * {@link ToolbarRegistryExtension.modulesFor} still hands it to the row drawn
+ * for `custom:affine:surface:group`. Nothing about the existing keys changes:
+ * a module registered under a bare flavour is that flavour's first module, and
+ * every registration in the library before this one stays exactly as it was.
+ */
+const MODULE_OWNER_SEPARATOR = '#';
+/** The flavour a DI variant speaks for, owner suffix and all. */
+export function toolbarModuleFlavour(variant) {
+    const at = variant.indexOf(MODULE_OWNER_SEPARATOR);
+    return at < 0 ? variant : variant.slice(0, at);
+}
+/**
+ * A second (or third) module on one flavour, named by who contributes it.
+ *
+ * The owner is never shown and never parsed back — it exists so two
+ * contributors cannot claim one DI variant. Use a stable, framework-scoped
+ * name (`c4-morph`), because it is the identity the container refuses
+ * duplicates on.
+ */
+export function toolbarModuleKey(flavour, owner) {
+    // Checked ALWAYS, and deliberately not behind a `process.env.NODE_ENV` dev
+    // guard. This library is published SOURCE-FIRST, so a `process` reference is
+    // not erased by anybody's build: a host consuming raw ESM would meet
+    // `ReferenceError: process is not defined` the moment a framework registered
+    // a shared toolbar module — i.e. at editor setup, on every document. The
+    // check costs one falsy test and one `includes` on a short string, run a
+    // handful of times per editor, which is nothing next to being the only
+    // `process` reference in the shipped source.
+    //
+    // What it prevents is silent: an empty owner produces `flavour#`, which is a
+    // DIFFERENT variant from `flavour` and would therefore register a second
+    // module the bare-key lookups below never see, and an owner carrying the
+    // separator makes `toolbarModuleFlavour` cut in the wrong place, filing the
+    // module under a flavour nobody draws.
+    if (!owner || owner.includes(MODULE_OWNER_SEPARATOR)) {
+        throw new Error(`toolbarModuleKey: owner must be non-empty and free of "${MODULE_OWNER_SEPARATOR}" (got ${JSON.stringify(owner)})`);
+    }
+    return `${flavour}${MODULE_OWNER_SEPARATOR}${owner}`;
+}
+/** One shared empty answer, so a miss allocates nothing and can be frozen. */
+const NO_MODULES = Object.freeze([]);
 export class ToolbarRegistryExtension extends Extension {
     constructor(std) {
         super();
@@ -21,18 +76,121 @@ export class ToolbarRegistryExtension extends Extension {
         this.message$ = signal(null);
         this.placement$ = signal('top');
         this.flags = new Flags();
+        /**
+         * The modules grouped by the FLAVOUR they speak for, computed once.
+         *
+         * Once, because the registrations are fixed for the life of a container —
+         * they are DI impls, added at setup and never afterwards — while
+         * {@link modulesFor} is asked six times per toolbar render, and a toolbar
+         * re-renders on every selection change, every drag frame and every zoom
+         * notch.
+         *
+         * A module registered under the BARE flavour leads its group, and the rest
+         * follow in registration order. The order is what decides nothing much —
+         * `renderToolbar` sorts the merged actions by `placement`, `id` and `score`
+         * — and it is pinned all the same, because "which module answers a bare-key
+         * question" must not depend on which framework happened to be registered
+         * first.
+         *
+         * Each group is FROZEN: it is handed out by {@link modulesFor} on every
+         * render, and a caller that sorted or spliced the answer in place would
+         * silently rewrite the registry for every later render.
+         */
+        this.#grouped = null;
     }
+    /**
+     * Every module of every flavour, keyed by the DI variant it was registered
+     * under — which for a shared flavour carries an owner suffix. Read
+     * {@link modulesFor} instead unless the variant itself is the question.
+     */
     get modules() {
         return this.std.provider.getAll(ToolbarModuleIdentifier);
     }
+    /**
+     * The modules grouped by the FLAVOUR they speak for, computed once.
+     *
+     * Once, because the registrations are fixed for the life of a container —
+     * they are DI impls, added at setup and never afterwards — while
+     * {@link modulesFor} is asked six times per toolbar render, and a toolbar
+     * re-renders on every selection change, every drag frame and every zoom
+     * notch.
+     *
+     * A module registered under the BARE flavour leads its group, and the rest
+     * follow in registration order. The order is what decides nothing much —
+     * `renderToolbar` sorts the merged actions by `placement`, `id` and `score`
+     * — and it is pinned all the same, because "which module answers a bare-key
+     * question" must not depend on which framework happened to be registered
+     * first.
+     *
+     * Each group is FROZEN: it is handed out by {@link modulesFor} on every
+     * render, and a caller that sorted or spliced the answer in place would
+     * silently rewrite the registry for every later render.
+     */
+    #grouped;
+    get #groups() {
+        if (!this.#grouped) {
+            const groups = new Map();
+            for (const [variant, module] of this.modules) {
+                const flavour = toolbarModuleFlavour(variant);
+                const group = groups.get(flavour);
+                if (!group)
+                    groups.set(flavour, [module]);
+                else if (variant === flavour)
+                    group.unshift(module);
+                else
+                    group.push(module);
+            }
+            for (const group of groups.values())
+                Object.freeze(group);
+            this.#grouped = groups;
+        }
+        return this.#grouped;
+    }
+    /**
+     * Every module contributing to one flavour's row — the bare-key module
+     * first, then the owner-suffixed ones in registration order.
+     */
+    modulesFor(flavour) {
+        return this.#groups.get(flavour) ?? NO_MODULES;
+    }
+    /**
+     * The config registered under the flavour ITSELF, or `null`.
+     *
+     * Deliberately not "the first module of this flavour". The callers of this
+     * method ask a question about one identified registration — does this block
+     * flavour have a toolbar of its own, where does that toolbar sit — and an
+     * owner-suffixed contributor is an ADDITION to a row, not a stand-in for the
+     * module that defines it. Answering with a contributor would make the reply
+     * depend on which frameworks a host happened to switch on: with `wardley`
+     * off and `c4` on, `custom:affine:surface:group` has no bare module at all,
+     * and returning C4's morph there would let a placement (or a `has`-style
+     * probe) be decided by a menu that only some builds ship.
+     */
     getModuleBy(flavour) {
-        return this.modules.get(flavour)?.config ?? null;
+        return (this.modulesFor(flavour).find(module => module.id.variant === flavour)
+            ?.config ?? null);
     }
+    /**
+     * Where a flavour's row sits: the first module of it that actually SAYS.
+     *
+     * A row is one row however many modules contribute to it, so the placement
+     * is a property of the flavour and not of a registration — and a contributor
+     * that declares none must not be read as declaring the default. Scanning for
+     * the first module with a `placement` keeps the answer the same whether the
+     * framework that states it is registered first, last, or under an owner.
+     */
     getModulePlacement(flavour, fallback = 'top') {
-        return (this.getModuleBy(`custom:${flavour}`)?.placement ??
-            this.getModuleBy(flavour)?.placement ??
+        return (this.#placementOf(`custom:${flavour}`) ??
+            this.#placementOf(flavour) ??
             fallback);
     }
+    #placementOf(flavour) {
+        for (const module of this.modulesFor(flavour)) {
+            if (module.config.placement)
+                return module.config.placement;
+        }
+        return undefined;
+    }
     static setup(di) {
         di.addImpl(ToolbarRegistryIdentifier, this, [StdIdentifier]);
     }

package/dist/_pkgs/affine-shared/services/universe-tag-defs-service.js

@@ -95,7 +95,9 @@ export function buildUniverseRegistry(packs) {
     const drafts = new Map();
     const frameworks = [];
     let rank = 0;
-    const issue = (severity, code, message, id) => issues.push(id === undefined ? { severity, code, message } : { severity, code, id, message });
+    const issue = (severity, code, message, id) => issues.push(id === undefined
+        ? { severity, code, message }
+        : { severity, code, id, message });
     for (const pack of packs) {
         if (pack?.formatVersion !== 1) {
             // The WHOLE pack is dropped: a format we do not understand may mean
@@ -126,7 +128,7 @@ export function buildUniverseRegistry(packs) {
     const merged = [...drafts.values()]
         .map(draft => finishDraft(draft))
         .sort((a, b) => (a.order ?? 0) - (b.order ?? 0) ||
-        (drafts.get(a.id).rank - drafts.get(b.id).rank) ||
+        drafts.get(a.id).rank - drafts.get(b.id).rank ||
         a.id.localeCompare(b.id));
     // Keyed by plain `string`, not by `QualifiedId`: a lookup comes from a
     // DOCUMENT, which may carry any id at all, and the template-literal type is a
@@ -172,7 +174,7 @@ function mergeTagDef(drafts, def, pack, issue, rank) {
     const incomingOpen = def.values === 'open';
     const existingOpen = existing.values === 'open';
     if (incomingOpen !== existingOpen) {
-        issue('error', 'duplicate-conflict', `Tag "${def.id}": pack "${pack.packId}" declares ${incomingOpen ? "an open value list" : 'a closed value list'} but the opposite was declared first and stands.`, def.id);
+        issue('error', 'duplicate-conflict', `Tag "${def.id}": pack "${pack.packId}" declares ${incomingOpen ? 'an open value list' : 'a closed value list'} but the opposite was declared first and stands.`, def.id);
     }
     else if (existing.values !== 'open') {
         // Additive: values union by value id, last cosmetic wins.

package/dist/_pkgs/affine-shared/test-utils/affine-template.js

@@ -1,7 +1,7 @@
 import { CodeBlockSchemaExtension, DatabaseBlockSchemaExtension, ImageBlockSchemaExtension, ListBlockSchemaExtension, NoteBlockSchemaExtension, ParagraphBlockSchemaExtension, RootBlockSchemaExtension, } from '../../affine-model/index.js';
 import { Container } from '../../global/di/index.js';
 import { TextSelection } from '../../std/index.js';
-import { Text, } from '../../store/index.js';
+import { Text } from '../../store/index.js';
 import { TestWorkspace } from '../../store/test/index.js';
 import { createTestHost } from './create-test-host.js';
 const DEFAULT_EXTENSIONS = [

package/dist/_pkgs/affine-shared/utils/edgeless.js

@@ -1,5 +1,5 @@
 import { FrameBlockModel, GroupElementModel } from '../../affine-model/index.js';
-import { deserializeXYWH, getQuadBoundWithRotation, } from '../../global/gfx/index.js';
+import { deserializeXYWH, getQuadBoundWithRotation } from '../../global/gfx/index.js';
 export function getSelectedRect(selected) {
     if (selected.length === 0) {
         return new DOMRect();

package/dist/_pkgs/affine-shared/utils/file/filesys.d.ts

@@ -11,12 +11,46 @@ declare global {
         showOpenFilePicker?: (options?: OpenFilePickerOptions) => Promise<FileSystemFileHandle[]>;
     }
 }
+/**
+ * One filter a file dialog offers: what to call it, and the MIME types it
+ * accepts with the extensions that go with each.
+ *
+ * The table below is the CLOSED list of filters this library ships. It is not
+ * the only source of one: an interchange format declares its own extensions and
+ * mime (`docs/adr/0012`), and a picker built from a registry entry cannot be a
+ * row in a hand-maintained table — the whole point of the registry is that a
+ * framework adds a format without a second file agreeing to it. So the shape is
+ * named and {@link openSingleFileWithSpec} takes it directly; `FileTypes` keeps
+ * naming the filters that are the editor's own.
+ */
+export interface FilePickerSpec {
+    description: string;
+    accept: Record<string, string[]>;
+}
 /**
  * See https://web.dev/patterns/files/open-one-or-multiple-files/
+ *
+ * There is no `'Bpmn'` here any more, and no row for it above. A BPMN document
+ * is not the editor's own kind of file: it is one INTERCHANGE FORMAT among the
+ * several a framework declares (`docs/adr/0012`), and its filter is built from
+ * that declaration by {@link openSingleFileWithSpec}. Keeping a second copy in
+ * this table would be a copy nobody reads and everybody has to keep in step —
+ * the format's `extensions` and `mime` are the one statement of what a `.bpmn`
+ * file is called.
  */
 type AcceptTypes = 'Any' | 'Images' | 'Videos' | 'Audios' | 'Markdown' | 'Html' | 'Zip' | 'MindMap';
 export declare function openFilesWith(acceptType?: AcceptTypes, multiple?: boolean): Promise<File[] | null>;
 export declare function openSingleFileWith(acceptType?: AcceptTypes): Promise<File | null>;
+/**
+ * One file, filtered by a spec the caller built rather than by a name in
+ * {@link FileTypes}.
+ *
+ * What {@link openSingleFileWith} is for the editor's own dialogs, this is for
+ * anything whose filter is DECLARED somewhere else — today the interchange
+ * registry, whose formats each carry their extensions and their mime and are
+ * added by a framework, not by editing the table above.
+ */
+export declare function openSingleFileWithSpec(spec: FilePickerSpec): Promise<File | null>;
 export declare function getImageFilesFromLocal(): Promise<File[]>;
 export declare function downloadBlob(blob: Blob, name: string): void;
 /**