@formicoidea/labre-core 0.30.1 → 0.32.0

package/dist/_pkgs/store/test/test-workspace.js

@@ -1,137 +1,12 @@
-import { BlockSuiteError, ErrorCode } from '../../global/exceptions/index.js';
-import { NoopLogger } from '../../global/utils/index.js';
-import { AwarenessEngine, BlobEngine, DocEngine, MemoryBlobSource, NoopDocSource, } from '../../sync/index.js';
-import { Subject } from 'rxjs';
-import { Awareness } from 'y-protocols/awareness.js';
-import * as Y from 'yjs';
-import { nanoid } from '../utils/id-generator.js';
-import { AwarenessStore } from '../yjs/index.js';
-import { TestDoc } from './test-doc.js';
-import { TestMeta } from './test-meta.js';
+import { WorkspaceBase } from '../impls/workspace-base.js';
 /**
  * @internal
  * Test only
- * Do not use this in production
+ * Do not use this in production — use `WorkspaceImpl` from `@labre/store`.
+ *
+ * Independent from `WorkspaceImpl`: both derive from the shared internal
+ * {@link WorkspaceBase} (neither extends the other), so a test-only helper
+ * added here never leaks into the production class.
  */
-export class TestWorkspace {
-    get docs() {
-        return this.blockCollections;
-    }
-    constructor({ id, idGenerator, awarenessSources = [], docSources = {
-        main: new NoopDocSource(),
-    }, blobSources = {
-        main: new MemoryBlobSource(),
-    }, } = {}) {
-        this.storeExtensions = [];
-        this.blockCollections = new Map();
-        this.slots = {
-            docListUpdated: new Subject(),
-        };
-        this.id = id || '';
-        this.doc = new Y.Doc({ guid: id });
-        this.awarenessStore = new AwarenessStore(new Awareness(this.doc));
-        const logger = new NoopLogger();
-        this.awarenessSync = new AwarenessEngine(this.awarenessStore.awareness, awarenessSources);
-        this.docSync = new DocEngine(this.doc, docSources.main, docSources.shadows ?? [], logger);
-        this.blobSync = new BlobEngine(blobSources.main, blobSources.shadows ?? [], logger);
-        this.idGenerator = idGenerator ?? nanoid;
-        this.meta = new TestMeta(this.doc);
-        this._bindDocMetaEvents();
-    }
-    _bindDocMetaEvents() {
-        this.meta.docMetaAdded.subscribe(docId => {
-            const doc = new TestDoc({
-                id: docId,
-                collection: this,
-                doc: this.doc,
-                awarenessStore: this.awarenessStore,
-            });
-            this.blockCollections.set(doc.id, doc);
-        });
-        this.meta.docMetaUpdated.subscribe(() => this.slots.docListUpdated.next());
-        this.meta.docMetaRemoved.subscribe(id => {
-            const space = this.getBlockCollection(id);
-            if (!space)
-                return;
-            this.blockCollections.delete(id);
-            space.remove();
-        });
-    }
-    _hasDoc(docId) {
-        return this.docs.has(docId);
-    }
-    /**
-     * Verify that all data has been successfully saved to the primary storage.
-     * Return true if the data transfer is complete and it is secure to terminate the synchronization operation.
-     */
-    canGracefulStop() {
-        this.docSync.canGracefulStop();
-    }
-    /**
-     * By default, only an empty doc will be created.
-     * If the `init` parameter is passed, a `surface`, `note`, and `paragraph` block
-     * will be created in the doc simultaneously.
-     */
-    createDoc(docId) {
-        const id = docId ?? this.idGenerator();
-        if (this._hasDoc(id)) {
-            throw new BlockSuiteError(ErrorCode.DocCollectionError, 'doc already exists');
-        }
-        this.meta.addDocMeta({
-            id,
-            title: '',
-            createDate: Date.now(),
-            tags: [],
-        });
-        return this.getDoc(id);
-    }
-    dispose() {
-        this.awarenessStore.destroy();
-    }
-    /**
-     * Terminate the data sync process forcefully, which may cause data loss.
-     * It is advised to invoke `canGracefulStop` before calling this method.
-     */
-    forceStop() {
-        this.docSync.forceStop();
-        this.blobSync.stop();
-        this.awarenessSync.disconnect();
-    }
-    getBlockCollection(docId) {
-        const space = this.docs.get(docId);
-        return space ?? null;
-    }
-    getDoc(docId) {
-        const collection = this.getBlockCollection(docId);
-        return collection;
-    }
-    removeDoc(docId) {
-        const docMeta = this.meta.getDocMeta(docId);
-        if (!docMeta) {
-            throw new BlockSuiteError(ErrorCode.DocCollectionError, `doc meta not found: ${docId}`);
-        }
-        const blockCollection = this.getBlockCollection(docId);
-        if (!blockCollection)
-            return;
-        blockCollection.dispose();
-        this.meta.removeDocMeta(docId);
-        this.blockCollections.delete(docId);
-    }
-    /**
-     * Start the data sync process
-     */
-    start() {
-        this.docSync.start();
-        this.blobSync.start();
-        this.awarenessSync.connect();
-    }
-    /**
-     * Wait for all data has been successfully saved to the primary storage.
-     */
-    waitForGracefulStop(abort) {
-        return this.docSync.waitForGracefulStop(abort);
-    }
-    waitForSynced() {
-        return this.docSync.waitForSynced();
-    }
+export class TestWorkspace extends WorkspaceBase {
 }

package/dist/_pkgs/store/transformer/assets.d.ts

@@ -1,5 +1,5 @@
-import type { BlockProps } from '../model';
-import type { BlobCRUD } from './type';
+import type { BlockProps } from '../model/index.js';
+import type { BlobCRUD } from './type.js';
 type AssetsManagerConfig = {
     blob: BlobCRUD;
 };

package/dist/_pkgs/store/transformer/base.d.ts

@@ -1,8 +1,8 @@
-import { BlockModel } from '../model/block/block-model';
-import { type DraftModel } from '../model/block/draft';
-import { type InternalPrimitives } from '../model/block/zod';
-import type { AssetsManager } from './assets';
-import type { BlockSnapshot } from './type';
+import { BlockModel } from '../model/block/block-model.js';
+import { type DraftModel } from '../model/block/draft.js';
+import { type InternalPrimitives } from '../model/block/zod.js';
+import type { AssetsManager } from './assets.js';
+import type { BlockSnapshot } from './type.js';
 export type BlockSnapshotLeaf = Pick<BlockSnapshot, 'id' | 'flavour' | 'props' | 'version'>;
 export type FromSnapshotPayload = {
     json: BlockSnapshotLeaf;

package/dist/_pkgs/store/transformer/base.js

@@ -1,7 +1,7 @@
-import { BlockModel } from '../model/block/block-model';
-import { toDraftModel } from '../model/block/draft';
-import { internalPrimitives, } from '../model/block/zod';
-import { fromJSON, toJSON } from './json';
+import { BlockModel } from '../model/block/block-model.js';
+import { toDraftModel } from '../model/block/draft.js';
+import { internalPrimitives, } from '../model/block/zod.js';
+import { fromJSON, toJSON } from './json.js';
 export class BaseBlockTransformer {
     _propsFromSnapshot(propsJson) {
         return Object.fromEntries(Object.entries(propsJson).map(([key, value]) => {

package/dist/_pkgs/store/transformer/index.d.ts

@@ -1,7 +1,7 @@
-export * from './assets';
-export * from './base';
-export * from './json';
-export * from './middleware';
-export * from './slice';
-export * from './transformer';
-export * from './type';
+export * from './assets.js';
+export * from './base.js';
+export * from './json.js';
+export * from './middleware.js';
+export * from './slice.js';
+export * from './transformer.js';
+export * from './type.js';

package/dist/_pkgs/store/transformer/index.js

@@ -1,7 +1,7 @@
-export * from './assets';
-export * from './base';
-export * from './json';
-export * from './middleware';
-export * from './slice';
-export * from './transformer';
-export * from './type';
+export * from './assets.js';
+export * from './base.js';
+export * from './json.js';
+export * from './middleware.js';
+export * from './slice.js';
+export * from './transformer.js';
+export * from './type.js';

package/dist/_pkgs/store/transformer/json.js

@@ -1,7 +1,7 @@
-import { NATIVE_UNIQ_IDENTIFIER, TEXT_UNIQ_IDENTIFIER } from '../consts';
-import { isPureObject } from '../reactive';
-import { Boxed } from '../reactive/boxed';
-import { Text } from '../reactive/text';
+import { NATIVE_UNIQ_IDENTIFIER, TEXT_UNIQ_IDENTIFIER } from '../consts.js';
+import { isPureObject } from '../reactive/index.js';
+import { Boxed } from '../reactive/boxed.js';
+import { Text } from '../reactive/text/index.js';
 export function toJSON(value) {
     if (value instanceof Boxed) {
         return {

package/dist/_pkgs/store/transformer/slice.d.ts

@@ -1,4 +1,4 @@
-import { BlockModel, type DraftModel, type Store } from '../model/index';
+import { BlockModel, type DraftModel, type Store } from '../model/index.js';
 type SliceData = {
     content: DraftModel[];
     workspaceId: string;

package/dist/_pkgs/store/transformer/slice.js

@@ -1,4 +1,4 @@
-import { BlockModel, toDraftModel, } from '../model/index';
+import { BlockModel, toDraftModel, } from '../model/index.js';
 export class Slice {
     get content() {
         return this.data.content;

package/dist/_pkgs/store/transformer/type.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import type { DocMeta, DocsPropertiesMeta } from '../extension';
-import type { Store } from '../model';
+import type { DocMeta, DocsPropertiesMeta } from '../extension/index.js';
+import type { Store } from '../model/index.js';
 export type BlockSnapshot = {
     type: 'block';
     id: string;

package/dist/_pkgs/sync/doc/peer.js

@@ -1,4 +1,4 @@
-import isEqual from 'lodash-es/isEqual';
+import isEqual from 'lodash-es/isEqual.js';
 import { Subject } from 'rxjs';
 import { applyUpdate, encodeStateAsUpdate, encodeStateVector, mergeUpdates, } from 'yjs';
 import { PriorityAsyncQueue, SharedPriorityTarget, } from '../utils/async-queue.js';

package/dist/commands.d.ts

@@ -0,0 +1,58 @@
+import { type AnyCommandDescriptor, type CommandManifestEntry, type CommandSurface, type FrameworkId } from './_pkgs/std/index.js';
+import { type LabreFlags } from './flags.js';
+/**
+ * The command registry, enumerated WITHOUT an editor instance — the property
+ * that makes it usable by host-side panels (Settings › Shortcuts, the
+ * "more artefacts" sidepanel). See `docs/adr/0008`.
+ *
+ * Gating has two sides and both are honoured: registration (`CommandExtension`
+ * inside each framework's flag-gated view extension) decides what BINDS, and
+ * `isBlockEnabled` here decides what a host ENUMERATES. A unit test asserts the
+ * two agree — a framework toggled off must vanish from the manifest and bind
+ * nothing.
+ *
+ * Bundled distribution note: the framework groups below are STRIPPED from
+ * `@formicoidea/labre-core` by `scripts/build-bundles.mjs` (`shortcuts: true`
+ * on the framework's descriptor) — each framework bundle exports its own
+ * commands and the host appends them for the frameworks it enables.
+ */
+interface FrameworkCommandGroup {
+    owner: FrameworkId;
+    commands: AnyCommandDescriptor[];
+}
+/**
+ * Pure aggregator (exported for testing): core commands plus the commands of
+ * every framework group whose flag is enabled.
+ */
+export declare function buildCommandRegistry(core: AnyCommandDescriptor[], groups: FrameworkCommandGroup[], flags?: LabreFlags): AnyCommandDescriptor[];
+/**
+ * Every command a given flag set exposes. Shapes are core canvas, so their
+ * commands are always-on like root's — and so are Map quality (PF7.11), which
+ * belongs to the SURFACE rather than to any framework (it appears for whichever
+ * framework declared a nudge or an on-demand rule, and its own `when` asks the
+ * engine that question), and `edge.invert-direction` (`docs/adr/0010` M3),
+ * which acts on whatever carries an edge ROLE — document content — so it must
+ * stay reachable on a board whose framework tooling is switched off; it is
+ * registered from the always-on connector view extension for the same reason.
+ *
+ * `auditCommands` is `'core'`-owned but NOT always-on: it rides the `ai-audit`
+ * capability switch, which is a second axis (see `OPTIONAL_CAPABILITIES`). The
+ * read side is filtered here, the registration side by `AuditViewExtension` in
+ * `getInternalViewExtensions` — the same two-sided gate a framework flag gets,
+ * and the same test asserts the two agree.
+ *
+ * The two sit side by side deliberately: Map quality is the DETERMINISTIC
+ * second moment (levels 1–2 of the validation taxonomy) and the audit is level
+ * 3, which is why one is unconditional and the other rides a switch. Neither
+ * depends on the other, and the engine depends on neither.
+ */
+export declare function getCommands(flags?: LabreFlags): AnyCommandDescriptor[];
+/**
+ * The serializable catalogue manifest — what crosses the host seam for the
+ * sidepanel, the palette and the agent. No functions, no templates: an
+ * `iconKey` resolved lib-side, and availability as a closed union.
+ */
+export declare function getCommandManifest(flags?: LabreFlags): CommandManifestEntry[];
+/** The manifest entries one surface offers, ordered. */
+export declare function getCommandManifestForSurface(surface: CommandSurface, flags?: LabreFlags): CommandManifestEntry[];
+export {};

package/dist/commands.js

@@ -0,0 +1,66 @@
+import { coreCommands, pivotCommands, readingCommands, tagCommands, } from './_pkgs/affine-block-root/index.js';
+import { auditCommands, mapQualityCommands, } from './_pkgs/affine-block-surface/index.js';
+import { edgeDirectionCommands } from './_pkgs/affine-gfx-connector/index.js';
+import { shapeCommands } from './_pkgs/affine-gfx-shape/index.js';
+import { toCommandManifestEntry, } from './_pkgs/std/index.js';
+import { isBlockEnabled, isCapabilityEnabled, } from './flags.js';
+const FRAMEWORK_COMMAND_GROUPS = [];
+/**
+ * Pure aggregator (exported for testing): core commands plus the commands of
+ * every framework group whose flag is enabled.
+ */
+export function buildCommandRegistry(core, groups, flags) {
+    const all = [...core];
+    for (const { owner, commands } of groups) {
+        if (isBlockEnabled(flags, owner))
+            all.push(...commands);
+    }
+    return all;
+}
+/**
+ * Every command a given flag set exposes. Shapes are core canvas, so their
+ * commands are always-on like root's — and so are Map quality (PF7.11), which
+ * belongs to the SURFACE rather than to any framework (it appears for whichever
+ * framework declared a nudge or an on-demand rule, and its own `when` asks the
+ * engine that question), and `edge.invert-direction` (`docs/adr/0010` M3),
+ * which acts on whatever carries an edge ROLE — document content — so it must
+ * stay reachable on a board whose framework tooling is switched off; it is
+ * registered from the always-on connector view extension for the same reason.
+ *
+ * `auditCommands` is `'core'`-owned but NOT always-on: it rides the `ai-audit`
+ * capability switch, which is a second axis (see `OPTIONAL_CAPABILITIES`). The
+ * read side is filtered here, the registration side by `AuditViewExtension` in
+ * `getInternalViewExtensions` — the same two-sided gate a framework flag gets,
+ * and the same test asserts the two agree.
+ *
+ * The two sit side by side deliberately: Map quality is the DETERMINISTIC
+ * second moment (levels 1–2 of the validation taxonomy) and the audit is level
+ * 3, which is why one is unconditional and the other rides a switch. Neither
+ * depends on the other, and the engine depends on neither.
+ */
+export function getCommands(flags) {
+    return buildCommandRegistry([
+        ...coreCommands,
+        ...pivotCommands,
+        ...tagCommands,
+        ...readingCommands,
+        ...shapeCommands,
+        ...mapQualityCommands,
+        ...edgeDirectionCommands,
+        ...(isCapabilityEnabled(flags, 'ai-audit') ? auditCommands : []),
+    ], FRAMEWORK_COMMAND_GROUPS, flags);
+}
+/**
+ * The serializable catalogue manifest — what crosses the host seam for the
+ * sidepanel, the palette and the agent. No functions, no templates: an
+ * `iconKey` resolved lib-side, and availability as a closed union.
+ */
+export function getCommandManifest(flags) {
+    return getCommands(flags).map(toCommandManifestEntry);
+}
+/** The manifest entries one surface offers, ordered. */
+export function getCommandManifestForSurface(surface, flags) {
+    return getCommandManifest(flags)
+        .filter(entry => entry.surfaces.includes(surface))
+        .sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+}

package/dist/extensions/command-telemetry.d.ts

@@ -0,0 +1,21 @@
+import { type ViewExtensionContext, ViewExtensionProvider } from '../_pkgs/affine-ext-loader/index.js';
+import { type CommandDescriptor, type CommandInvocation, type CommandTelemetryReporter } from '../_pkgs/std/index.js';
+import type { ExtensionType } from '../_pkgs/store/index.js';
+export declare function reportCommandTelemetry(track: (event: string, payload: Record<string, unknown>) => void, command: CommandDescriptor, invocation: CommandInvocation): void;
+/**
+ * The production reporter. Exported so a test can register it on a stub `std`
+ * and drive the WHOLE path — `runCommand` → reporter → `TelemetryProvider` —
+ * rather than calling the mapping function directly, which would never notice
+ * a second emitter left behind in an action body.
+ */
+export declare const commandTelemetryReporter: CommandTelemetryReporter;
+export declare const CommandTelemetryExtension: ExtensionType;
+/**
+ * Registered unconditionally by `getInternalViewExtensions`: the emitter is not
+ * a framework's business, and a framework toggled off simply never invokes a
+ * command.
+ */
+export declare class CommandTelemetryViewExtension extends ViewExtensionProvider {
+    name: string;
+    setup(context: ViewExtensionContext): void;
+}

package/dist/extensions/command-telemetry.js

@@ -0,0 +1,89 @@
+import { ViewExtensionProvider, } from '../_pkgs/affine-ext-loader/index.js';
+import { TelemetryProvider } from '../_pkgs/affine-shared/services/index.js';
+import { CommandTelemetryIdentifier, } from '../_pkgs/std/index.js';
+import { frameworkDescriptor } from '../frameworks.js';
+/**
+ * The ONE place a framework command's telemetry is emitted.
+ *
+ * Before PF3 every surface re-implemented its own `track()` — which is how
+ * cynefin-estuarine ended up emitting nothing at all, and how the same artefact
+ * could be counted differently depending on which menu created it. The registry
+ * now calls this reporter from `runCommand`, and nowhere else.
+ *
+ * Wire values are HISTORICAL by construction: `framework` and `segment` come
+ * from `FrameworkDescriptor.telemetryKey` / `.telemetrySegment`, so unifying
+ * the code-side identity breaks no existing PostHog dashboard.
+ */
+/** `CommandKind` → the ADR 0003 event it reports. */
+const EVENT_BY_KIND = {
+    artefact: 'FrameworkElementAdded',
+    toggle: 'FrameworkElementAdded',
+    tool: 'FrameworkToolPicked',
+    legend: 'FrameworkLegendCreated',
+    action: 'FrameworkElementAdded',
+};
+/**
+ * `module`, per historical convention: the menu that created the element, or
+ * the literal `'keyboard shortcut'` Wardley already emitted.
+ */
+function moduleOf(telemetryKey, invocation) {
+    if (invocation.surface === 'shortcut')
+        return 'keyboard shortcut';
+    if (invocation.surface === 'senior-menu')
+        return `${telemetryKey} menu`;
+    return `${telemetryKey} ${invocation.surface}`;
+}
+export function reportCommandTelemetry(track, command, invocation) {
+    const { telemetry } = command;
+    if (!telemetry)
+        return;
+    const framework = frameworkDescriptor(telemetry.framework);
+    if (!framework)
+        return;
+    track(EVENT_BY_KIND[command.kind], {
+        framework: framework.telemetryKey,
+        element: telemetry.element,
+        page: 'whiteboard editor',
+        segment: framework.telemetrySegment,
+        module: moduleOf(framework.telemetryKey, invocation),
+        // New dimension, no existing value changed: which of the five consumers
+        // invoked the command. This is the metric that will arbitrate the 14
+        // senior slots against the sidepanel against the palette.
+        control: invocation.source,
+    });
+}
+/**
+ * The production reporter. Exported so a test can register it on a stub `std`
+ * and drive the WHOLE path — `runCommand` → reporter → `TelemetryProvider` —
+ * rather than calling the mapping function directly, which would never notice
+ * a second emitter left behind in an action body.
+ */
+export const commandTelemetryReporter = ({ std, command, invocation, }) => {
+    const telemetry = std.getOptional(TelemetryProvider);
+    if (!telemetry)
+        return;
+    reportCommandTelemetry((event, payload) => telemetry.track(event, payload), command, invocation);
+};
+export const CommandTelemetryExtension = {
+    // Factory form, not value form: the container calls a function argument as a
+    // factory, so registering the reporter directly would resolve it with the
+    // service provider instead of the report.
+    setup: di => {
+        di.addImpl(CommandTelemetryIdentifier, () => commandTelemetryReporter);
+    },
+};
+/**
+ * Registered unconditionally by `getInternalViewExtensions`: the emitter is not
+ * a framework's business, and a framework toggled off simply never invokes a
+ * command.
+ */
+export class CommandTelemetryViewExtension extends ViewExtensionProvider {
+    constructor() {
+        super(...arguments);
+        this.name = 'affine-command-telemetry';
+    }
+    setup(context) {
+        super.setup(context);
+        context.register(CommandTelemetryExtension);
+    }
+}

package/dist/extensions/store.d.ts

@@ -1,8 +1,13 @@
 import { AttachmentStoreExtension } from '../_pkgs/affine-block-attachment/store.js';
 import { NoteStoreExtension } from '../_pkgs/affine-block-note/store.js';
-import { type BlockFlags } from '../flags.js';
+import type { LabreFlags } from '../flags.js';
 /**
- * Store extensions, honoring block flags.
- * Omitted flags default to enabled. See {@link BlockFlags}.
+ * Store extensions.
+ *
+ * Registered UNCONDITIONALLY: the store side (models, adapters, transformers)
+ * is what makes a document readable and round-trippable, and a flag must never
+ * gate that (see {@link LabreFlags} and `docs/adr/0009`). The `flags` parameter
+ * is kept for source compatibility with callers written against the previous
+ * contract, and is deliberately ignored.
  */
-export declare function getInternalStoreExtensions(flags?: BlockFlags): (typeof AttachmentStoreExtension | typeof NoteStoreExtension)[];
+export declare function getInternalStoreExtensions(_flags?: LabreFlags): (typeof AttachmentStoreExtension | typeof NoteStoreExtension)[];

package/dist/extensions/store.js

@@ -30,43 +30,46 @@ import { LatexStoreExtension as InlineLatexStoreExtension } from '../_pkgs/affin
 import { LinkStoreExtension } from '../_pkgs/affine-inline-link/store.js';
 import { InlinePresetStoreExtension } from '../_pkgs/affine-inline-preset/store.js';
 import { ReferenceStoreExtension } from '../_pkgs/affine-inline-reference/store.js';
-import { isBlockEnabled, } from '../flags.js';
 /**
- * Store extensions, honoring block flags.
- * Omitted flags default to enabled. See {@link BlockFlags}.
+ * Store extensions.
+ *
+ * Registered UNCONDITIONALLY: the store side (models, adapters, transformers)
+ * is what makes a document readable and round-trippable, and a flag must never
+ * gate that (see {@link LabreFlags} and `docs/adr/0009`). The `flags` parameter
+ * is kept for source compatibility with callers written against the previous
+ * contract, and is deliberately ignored.
  */
-export function getInternalStoreExtensions(flags) {
-    const on = (block) => isBlockEnabled(flags, block);
+export function getInternalStoreExtensions(_flags) {
     return [
         FoundationStoreExtension,
-        ...(on('attachment') ? [AttachmentStoreExtension] : []),
-        ...(on('bookmark') ? [BookmarkStoreExtension] : []),
-        ...(on('callout') ? [CalloutStoreExtension] : []),
-        ...(on('code') ? [CodeStoreExtension] : []),
-        ...(on('data-view') ? [DataViewStoreExtension] : []),
-        ...(on('database') ? [DatabaseStoreExtension] : []),
-        ...(on('divider') ? [DividerStoreExtension] : []),
-        ...(on('edgeless-text') ? [EdgelessTextStoreExtension] : []),
-        ...(on('embed') ? [EmbedStoreExtension] : []),
-        ...(on('embed-doc') ? [EmbedDocStoreExtension] : []),
-        ...(on('frame') ? [FrameStoreExtension] : []),
-        ...(on('image') ? [ImageStoreExtension] : []),
-        ...(on('latex') ? [LatexStoreExtension] : []),
-        ...(on('list') ? [ListStoreExtension] : []),
+        AttachmentStoreExtension,
+        BookmarkStoreExtension,
+        CalloutStoreExtension,
+        CodeStoreExtension,
+        DataViewStoreExtension,
+        DatabaseStoreExtension,
+        DividerStoreExtension,
+        EdgelessTextStoreExtension,
+        EmbedStoreExtension,
+        EmbedDocStoreExtension,
+        FrameStoreExtension,
+        ImageStoreExtension,
+        LatexStoreExtension,
+        ListStoreExtension,
         NoteStoreExtension,
         ParagraphStoreExtension,
-        ...(on('surface-ref') ? [SurfaceRefStoreExtension] : []),
-        ...(on('table') ? [TableStoreExtension] : []),
+        SurfaceRefStoreExtension,
+        TableStoreExtension,
         SurfaceStoreExtension,
         RootStoreExtension,
         FootnoteStoreExtension,
         LinkStoreExtension,
         ReferenceStoreExtension,
-        ...(on('latex') ? [InlineLatexStoreExtension] : []),
+        InlineLatexStoreExtension,
         InlinePresetStoreExtension,
-        ...(on('brush') ? [BrushStoreExtension] : []),
+        BrushStoreExtension,
         ShapeStoreExtension,
-        ...(on('mindmap') ? [MindmapStoreExtension] : []),
+        MindmapStoreExtension,
         ConnectorStoreExtension,
         GroupStoreExtension,
         TextStoreExtension,

package/dist/extensions/view.d.ts

@@ -1,7 +1,12 @@
 import { AdapterPanelViewExtension } from '../_pkgs/affine-fragment-adapter-panel/view.js';
-import { type BlockFlags } from '../flags.js';
+import { type LabreFlags } from '../flags.js';
 /**
- * View extensions, honoring block flags.
- * Omitted flags default to enabled. See {@link BlockFlags}.
+ * View extensions.
+ *
+ * Rendering is registered UNCONDITIONALLY; a flag removes only the matching
+ * TOOLING extension (senior button, its submenus and its creation shortcuts),
+ * so a framework switched off disappears from the toolbar without any element
+ * already drawn disappearing from the canvas. Omitted flags default to
+ * enabled. See {@link BlockFlags} and `docs/adr/0009`.
  */
-export declare function getInternalViewExtensions(flags?: BlockFlags): (typeof AdapterPanelViewExtension)[];
+export declare function getInternalViewExtensions(flags?: LabreFlags): (typeof AdapterPanelViewExtension)[];