@formicoidea/labre-core 0.32.0 → 0.34.1

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/translation-service/chrome.d.ts

@@ -0,0 +1,106 @@
+/**
+ * The editor's own chrome wordings, as `[key, fallback]` pairs.
+ *
+ * ## Why they are a table and not forty literals
+ *
+ * "Copy", "Delete", "Card view" are the SAME word on a dozen toolbars — the
+ * bookmark's, the image's, the embed's, the linked doc's — and a literal per
+ * call site is a wording a host has to translate a dozen times and can get
+ * twelve different answers for. One pair per word, imported where it is
+ * rendered, is what makes the manifest's promise ("every key the library can
+ * ask for") describe a list a human can actually word.
+ *
+ * ## The tuple shape is load-bearing
+ *
+ * `translateKey(std, ...COPY)` spreads into `(std, key, fallback)`, so a call
+ * site names the wording once and cannot pair the wrong fallback with the right
+ * key. It is also what
+ * `packages/affine/all/src/__tests__/translations/manifest.unit.spec.ts` reads:
+ * the two adjacent literals below are the pair its drift check confirms the
+ * manifest against, which is why the wordings live in literals here rather than
+ * being derived from anything.
+ *
+ * Chrome, so every one of them ships an English default: a standalone
+ * playground with no `TranslationProvider` registered must read exactly as it
+ * did before these keys existed.
+ */
+/** A wording the library can ask the host for: its key, and its English default. */
+export type ChromeWording = readonly [key: string, fallback: string];
+/**
+ * The transient messages the editor puts on screen after a gesture.
+ *
+ * They were the last English strings left in a fully translated host (#182):
+ * silent while nobody injected a `NotificationProvider`, and English in the
+ * middle of a French UI the moment somebody did.
+ */
+export declare const TOAST_COPIED_TO_CLIPBOARD: ChromeWording;
+export declare const TOAST_LINKED_DOC_CREATED: ChromeWording;
+export declare const TOAST_NOTE_REMOVED_FROM_PAGE: ChromeWording;
+export declare const TOAST_FRAME_INSERTED_INTO_PAGE: ChromeWording;
+export declare const TOAST_NO_LINK_FOUND: ChromeWording;
+export declare const TOOLBAR_BRING_TO_FRONT: ChromeWording;
+export declare const TOOLBAR_SEND_TO_BACK: ChromeWording;
+export declare const TOOLBAR_COPY: ChromeWording;
+export declare const TOOLBAR_DUPLICATE: ChromeWording;
+export declare const TOOLBAR_DELETE: ChromeWording;
+export declare const TOOLBAR_LOCK: ChromeWording;
+export declare const TOOLBAR_MORE: ChromeWording;
+export declare const TOOLBAR_LINK: ChromeWording;
+export declare const TOOLBAR_CREATE_LINKED_DOC: ChromeWording;
+export declare const TOOLBAR_DRAW_CONNECTOR: ChromeWording;
+/**
+ * The four wordings of the view switcher — the control that decides whether a
+ * link is drawn as words, as a card or as the document itself.
+ *
+ * One set for every block that offers it (bookmark, attachment, embed, linked
+ * doc, synced doc, iframe, the inline link and the inline reference): they are
+ * one control with one vocabulary, and a host that had to word "Card view"
+ * eight times would end up with eight wordings of it.
+ */
+export declare const TOOLBAR_SWITCH_VIEW: ChromeWording;
+export declare const TOOLBAR_INLINE_VIEW: ChromeWording;
+export declare const TOOLBAR_CARD_VIEW: ChromeWording;
+export declare const TOOLBAR_EMBED_VIEW: ChromeWording;
+/**
+ * The four states a linked-doc card can be in with nothing to show: deleted,
+ * unreadable, empty, and — for the SYNCED card, which frames a page rather
+ * than a doc — empty in its own words.
+ *
+ * All four and not only the two the recette caught (#183): they are one
+ * sentence rendered by one ternary, and translating half of it would leave a
+ * card that changes language when the document it points at goes missing.
+ */
+export declare const LINKED_DOC_DELETED: ChromeWording;
+export declare const LINKED_DOC_FAILED: ChromeWording;
+export declare const LINKED_DOC_EMPTY_PREVIEW: ChromeWording;
+export declare const SYNCED_DOC_EMPTY_PREVIEW: ChromeWording;
+/**
+ * The resize toggle, which is the one entry EVERY framework board carries —
+ * Wardley, BPMN, C4, EDGY, Cynefin, Estuarine and the two DDD boards all
+ * register the same always-on button (`docs/adr/0009`: a stored board must stay
+ * usable with its framework switched off).
+ *
+ * Declared here rather than once per framework because it is not a framework's
+ * own word: it names a behaviour of the generic frame primitive, and eight
+ * copies of it in eight manifests would be eight keys for one tooltip.
+ */
+export declare const BOARD_RESIZE_TOGGLE: ChromeWording;
+/**
+ * The legend button, in the two wordings the boards actually use: the notation
+ * boards say "notation", Wardley says "components".
+ *
+ * Two keys and not one interpolated sentence, for the reason the interchange
+ * counts already ran on — the seam has no interpolation, so the smallest honest
+ * unit is the whole sentence.
+ */
+export declare const BOARD_LEGEND_NOTATION: ChromeWording;
+export declare const BOARD_LEGEND_COMPONENTS: ChromeWording;
+/**
+ * Every wording declared above, in declaration order.
+ *
+ * The manifest (`@labre/affine/translations`) walks this instead of restating
+ * the pairs, so a wording added here reaches a host's catalogue with no second
+ * edit — the same "declared data, not restated data" rule the roles, the rules
+ * and the commands already follow.
+ */
+export declare const CHROME_WORDINGS: readonly ChromeWording[];

package/dist/_pkgs/affine-shared/services/translation-service/chrome.js

@@ -0,0 +1,201 @@
+/**
+ * The editor's own chrome wordings, as `[key, fallback]` pairs.
+ *
+ * ## Why they are a table and not forty literals
+ *
+ * "Copy", "Delete", "Card view" are the SAME word on a dozen toolbars — the
+ * bookmark's, the image's, the embed's, the linked doc's — and a literal per
+ * call site is a wording a host has to translate a dozen times and can get
+ * twelve different answers for. One pair per word, imported where it is
+ * rendered, is what makes the manifest's promise ("every key the library can
+ * ask for") describe a list a human can actually word.
+ *
+ * ## The tuple shape is load-bearing
+ *
+ * `translateKey(std, ...COPY)` spreads into `(std, key, fallback)`, so a call
+ * site names the wording once and cannot pair the wrong fallback with the right
+ * key. It is also what
+ * `packages/affine/all/src/__tests__/translations/manifest.unit.spec.ts` reads:
+ * the two adjacent literals below are the pair its drift check confirms the
+ * manifest against, which is why the wordings live in literals here rather than
+ * being derived from anything.
+ *
+ * Chrome, so every one of them ships an English default: a standalone
+ * playground with no `TranslationProvider` registered must read exactly as it
+ * did before these keys existed.
+ */
+/* ── Toasts ───────────────────────────────────────────────────────────── */
+/**
+ * The transient messages the editor puts on screen after a gesture.
+ *
+ * They were the last English strings left in a fully translated host (#182):
+ * silent while nobody injected a `NotificationProvider`, and English in the
+ * middle of a French UI the moment somebody did.
+ */
+export const TOAST_COPIED_TO_CLIPBOARD = [
+    'com.labre.toast.copied-to-clipboard',
+    'Copied to clipboard',
+];
+export const TOAST_LINKED_DOC_CREATED = [
+    'com.labre.toast.linked-doc-created',
+    'Linked doc created',
+];
+export const TOAST_NOTE_REMOVED_FROM_PAGE = [
+    'com.labre.toast.note-removed-from-page-mode',
+    'Note removed from Page Mode',
+];
+export const TOAST_FRAME_INSERTED_INTO_PAGE = [
+    'com.labre.toast.frame-inserted-into-page',
+    'Frame inserted into Page.',
+];
+export const TOAST_NO_LINK_FOUND = [
+    'com.labre.toast.no-link-found',
+    'No link found',
+];
+/* ── Toolbars and menus ───────────────────────────────────────────────── */
+export const TOOLBAR_BRING_TO_FRONT = [
+    'com.labre.toolbar.bring-to-front',
+    'Bring to Front',
+];
+export const TOOLBAR_SEND_TO_BACK = [
+    'com.labre.toolbar.send-to-back',
+    'Send to Back',
+];
+export const TOOLBAR_COPY = ['com.labre.toolbar.copy', 'Copy'];
+export const TOOLBAR_DUPLICATE = [
+    'com.labre.toolbar.duplicate',
+    'Duplicate',
+];
+export const TOOLBAR_DELETE = [
+    'com.labre.toolbar.delete',
+    'Delete',
+];
+export const TOOLBAR_LOCK = ['com.labre.toolbar.lock', 'Lock'];
+export const TOOLBAR_MORE = ['com.labre.toolbar.more', 'More'];
+export const TOOLBAR_LINK = ['com.labre.toolbar.link', 'Link'];
+export const TOOLBAR_CREATE_LINKED_DOC = [
+    'com.labre.toolbar.create-linked-doc',
+    'Create linked doc',
+];
+export const TOOLBAR_DRAW_CONNECTOR = [
+    'com.labre.toolbar.draw-connector',
+    'Draw connector',
+];
+/**
+ * The four wordings of the view switcher — the control that decides whether a
+ * link is drawn as words, as a card or as the document itself.
+ *
+ * One set for every block that offers it (bookmark, attachment, embed, linked
+ * doc, synced doc, iframe, the inline link and the inline reference): they are
+ * one control with one vocabulary, and a host that had to word "Card view"
+ * eight times would end up with eight wordings of it.
+ */
+export const TOOLBAR_SWITCH_VIEW = [
+    'com.labre.toolbar.switch-view',
+    'Switch view',
+];
+export const TOOLBAR_INLINE_VIEW = [
+    'com.labre.toolbar.inline-view',
+    'Inline view',
+];
+export const TOOLBAR_CARD_VIEW = [
+    'com.labre.toolbar.card-view',
+    'Card view',
+];
+export const TOOLBAR_EMBED_VIEW = [
+    'com.labre.toolbar.embed-view',
+    'Embed view',
+];
+/* ── What a linked-doc card says instead of a preview ─────────────────── */
+/**
+ * The four states a linked-doc card can be in with nothing to show: deleted,
+ * unreadable, empty, and — for the SYNCED card, which frames a page rather
+ * than a doc — empty in its own words.
+ *
+ * All four and not only the two the recette caught (#183): they are one
+ * sentence rendered by one ternary, and translating half of it would leave a
+ * card that changes language when the document it points at goes missing.
+ */
+export const LINKED_DOC_DELETED = [
+    'com.labre.embed.linked-doc.deleted',
+    'This linked doc is deleted.',
+];
+export const LINKED_DOC_FAILED = [
+    'com.labre.embed.linked-doc.failed',
+    'This linked doc failed to load.',
+];
+export const LINKED_DOC_EMPTY_PREVIEW = [
+    'com.labre.embed.linked-doc.empty-preview',
+    'Preview of the doc will be displayed here.',
+];
+export const SYNCED_DOC_EMPTY_PREVIEW = [
+    'com.labre.embed.synced-doc.empty-preview',
+    'Preview of the page will be displayed here.',
+];
+/* ── The board toolbars every framework shares ────────────────────────── */
+/**
+ * The resize toggle, which is the one entry EVERY framework board carries —
+ * Wardley, BPMN, C4, EDGY, Cynefin, Estuarine and the two DDD boards all
+ * register the same always-on button (`docs/adr/0009`: a stored board must stay
+ * usable with its framework switched off).
+ *
+ * Declared here rather than once per framework because it is not a framework's
+ * own word: it names a behaviour of the generic frame primitive, and eight
+ * copies of it in eight manifests would be eight keys for one tooltip.
+ */
+export const BOARD_RESIZE_TOGGLE = [
+    'com.labre.board.toolbar.resize-toggle',
+    'Enable / lock resizing',
+];
+/**
+ * The legend button, in the two wordings the boards actually use: the notation
+ * boards say "notation", Wardley says "components".
+ *
+ * Two keys and not one interpolated sentence, for the reason the interchange
+ * counts already ran on — the seam has no interpolation, so the smallest honest
+ * unit is the whole sentence.
+ */
+export const BOARD_LEGEND_NOTATION = [
+    'com.labre.board.toolbar.legend',
+    'Generate the legend (notation present)',
+];
+export const BOARD_LEGEND_COMPONENTS = [
+    'com.labre.board.toolbar.legend.components',
+    'Generate the legend (components present)',
+];
+/**
+ * Every wording declared above, in declaration order.
+ *
+ * The manifest (`@labre/affine/translations`) walks this instead of restating
+ * the pairs, so a wording added here reaches a host's catalogue with no second
+ * edit — the same "declared data, not restated data" rule the roles, the rules
+ * and the commands already follow.
+ */
+export const CHROME_WORDINGS = [
+    TOAST_COPIED_TO_CLIPBOARD,
+    TOAST_LINKED_DOC_CREATED,
+    TOAST_NOTE_REMOVED_FROM_PAGE,
+    TOAST_FRAME_INSERTED_INTO_PAGE,
+    TOAST_NO_LINK_FOUND,
+    TOOLBAR_BRING_TO_FRONT,
+    TOOLBAR_SEND_TO_BACK,
+    TOOLBAR_COPY,
+    TOOLBAR_DUPLICATE,
+    TOOLBAR_DELETE,
+    TOOLBAR_LOCK,
+    TOOLBAR_MORE,
+    TOOLBAR_LINK,
+    TOOLBAR_CREATE_LINKED_DOC,
+    TOOLBAR_DRAW_CONNECTOR,
+    TOOLBAR_SWITCH_VIEW,
+    TOOLBAR_INLINE_VIEW,
+    TOOLBAR_CARD_VIEW,
+    TOOLBAR_EMBED_VIEW,
+    LINKED_DOC_DELETED,
+    LINKED_DOC_FAILED,
+    LINKED_DOC_EMPTY_PREVIEW,
+    SYNCED_DOC_EMPTY_PREVIEW,
+    BOARD_RESIZE_TOGGLE,
+    BOARD_LEGEND_NOTATION,
+    BOARD_LEGEND_COMPONENTS,
+];

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

@@ -1,5 +1,6 @@
 import type { BlockStdScope } from '../../../std/index.js';
 import type { ExtensionType } from '../../../store/index.js';
+export * from './chrome.js';
 /**
  * The library holds no prose: every human-readable string it produces —
  * shortcut labels, role names, validation messages — is an i18n KEY

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

@@ -1,4 +1,5 @@
 import { createIdentifier } from '../../../global/di/index.js';
+export * from './chrome.js';
 /**
  * The primary subtag of the host's language, lower-cased — `'fr'` for
  * `'fr-CA'` — or `undefined` when no host said.

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;
 /**