@formicoidea/labre-core 0.31.0 → 0.32.0

package/dist/_pkgs/std/utils/tree.js

@@ -18,16 +18,67 @@ import { isGfxGroupCompatibleModel, } from '../gfx/model/base.js';
  * The result should be `[G1, G4, E6]`
  */
 export function getTopElements(elements) {
-    const results = new Set(elements);
-    elements = [...new Set(elements)];
-    elements.forEach(e1 => {
-        elements.forEach(e2 => {
-            if (isGfxGroupCompatibleModel(e1) && e1.hasDescendant(e2)) {
-                results.delete(e2);
+    const uniqueElements = [...new Set(elements)];
+    const selected = new Set(uniqueElements);
+    const topElements = [];
+    // Walk each element UP to the root instead of asking every pair whether one
+    // contains the other: the pairwise form walked the whole subtree of every
+    // group for every other element in the list, which is what made a large
+    // selection expensive.
+    for (const element of uniqueElements) {
+        let ancestor = element.group;
+        let hasSelectedAncestor = false;
+        while (ancestor) {
+            if (selected.has(ancestor)) {
+                hasSelectedAncestor = true;
+                break;
             }
-        });
+            ancestor = ancestor.group;
+        }
+        if (!hasSelectedAncestor) {
+            topElements.push(element);
+        }
+    }
+    return topElements;
+}
+/**
+ * Add several children to a container in one go.
+ *
+ * A container that knows how to take a batch (`addChildren`) gets the whole
+ * list, so it can write them within a single transaction; anything else falls
+ * back to one `addChild` per element, which is exactly what the caller would
+ * have written by hand.
+ */
+export function batchAddChildren(container, elements) {
+    const uniqueElements = [...new Set(elements)];
+    if (uniqueElements.length === 0)
+        return;
+    const batchContainer = container;
+    if (batchContainer.addChildren) {
+        batchContainer.addChildren(uniqueElements);
+        return;
+    }
+    uniqueElements.forEach(element => {
+        container.addChild(element);
+    });
+}
+/**
+ * Remove several children from a container in one go. See
+ * {@link batchAddChildren}.
+ */
+export function batchRemoveChildren(container, elements) {
+    const uniqueElements = [...new Set(elements)];
+    if (uniqueElements.length === 0)
+        return;
+    const batchContainer = container;
+    if (batchContainer.removeChildren) {
+        batchContainer.removeChildren(uniqueElements);
+        return;
+    }
+    uniqueElements.forEach(element => {
+        // oxlint-disable-next-line unicorn/prefer-dom-node-remove
+        container.removeChild(element);
     });
-    return [...results];
 }
 function traverse(element, preCallback, postCallBack) {
     // avoid infinite loop caused by circular reference

package/dist/_pkgs/std/view/element/gfx-block-component.js

@@ -18,6 +18,12 @@ function updateTransform(element) {
     element.style.transformOrigin = '0 0';
     element.style.transform = element.getCSSTransform();
 }
+function updateZIndex(element) {
+    const zIndex = element.toZIndex();
+    if (element.style.zIndex !== zIndex) {
+        element.style.zIndex = zIndex;
+    }
+}
 function updateBlockVisibility(view) {
     if (view.transformState$.value === 'active') {
         view.style.visibility = 'visible';
@@ -40,11 +46,18 @@ function handleGfxConnection(instance) {
     instance.disposables.add(instance.store.slots.blockUpdated.subscribe(({ type, id }) => {
         if (id === instance.model.id && type === 'update') {
             updateTransform(instance);
+            updateZIndex(instance);
         }
     }));
+    // A reorder changes no property of this block, only the layer it sits in,
+    // so the stacking has to be read back from the layer manager.
+    instance.disposables.add(instance.gfx.layer.slots.layerUpdated.subscribe(() => {
+        updateZIndex(instance);
+    }));
     instance.disposables.add(effect(() => {
         updateBlockVisibility(instance);
         updateTransform(instance);
+        updateZIndex(instance);
     }));
 }
 export class GfxBlockComponent extends BlockComponent {
@@ -73,13 +86,17 @@ export class GfxBlockComponent extends BlockComponent {
     onBoxSelected(_) { }
     getCSSTransform() {
         const viewport = this.gfx.viewport;
-        const { translateX, translateY, zoom } = viewport;
+        const { translateX, translateY, zoom, viewScale } = viewport;
         const bound = Bound.deserialize(this.model.xywh);
-        const scaledX = bound.x * zoom;
-        const scaledY = bound.y * zoom;
+        // An outer container may scale the whole editor (`viewScale`). The block
+        // is placed inside that container, so the placement has to be stated in
+        // the container's already scaled space, otherwise the container applies
+        // its scale a second time and the block drifts away from the canvas.
+        const scaledX = (bound.x * zoom) / viewScale;
+        const scaledY = (bound.y * zoom) / viewScale;
         const deltaX = scaledX - bound.x;
         const deltaY = scaledY - bound.y;
-        return `translate(${translateX + deltaX}px, ${translateY + deltaY}px) scale(${zoom})`;
+        return `translate(${translateX / viewScale + deltaX}px, ${translateY / viewScale + deltaY}px) scale(${zoom / viewScale})`;
     }
     getRenderingRect() {
         const { xywh$ } = this.model;
@@ -159,16 +176,9 @@ export function toGfxBlockComponent(CustomBlock) {
             super.connectedCallback();
             handleGfxConnection(this);
         }
-        // eslint-disable-next-line sonarjs/no-identical-functions
         getCSSTransform() {
-            const viewport = this.gfx.viewport;
-            const { translateX, translateY, zoom } = viewport;
-            const bound = Bound.deserialize(this.model.xywh);
-            const scaledX = bound.x * zoom;
-            const scaledY = bound.y * zoom;
-            const deltaX = scaledX - bound.x;
-            const deltaY = scaledY - bound.y;
-            return `translate(${translateX + deltaX}px, ${translateY + deltaY}px) scale(${zoom})`;
+            // A converted block is placed exactly like a native one.
+            return GfxBlockComponent.prototype.getCSSTransform.call(this);
         }
         // eslint-disable-next-line sonarjs/no-identical-functions
         getRenderingRect() {

package/dist/_pkgs/store/extension/workspace/workspace-meta.d.ts

@@ -16,6 +16,16 @@ export interface DocMeta {
     createDate: number;
     updatedDate?: number;
     favorite?: boolean;
+    /**
+     * Set by the host when the doc sits in its trash. The doc is still in the
+     * workspace — it loads and round-trips as usual — but references to it
+     * (linked-doc and synced-doc cards) render as deleted.
+     *
+     * Optional and absent from documents written before it existed: the meta map
+     * is stored key by key, so an older document simply reads `undefined` here
+     * and an older reader ignores the key.
+     */
+    trash?: boolean;
 }
 export interface WorkspaceMeta {
     get docMetas(): DocMeta[];

package/dist/_pkgs/store/model/block/flat-sync-controller.js

@@ -22,11 +22,12 @@ export class FlatSyncController {
             throw new BlockSuiteError(ErrorCode.ModelCRUDError, `schema for flavour: ${this.flavour} not found`);
         }
         const model = schema.model.toModel?.() ?? new BlockModel();
+        const defaultProps = schema.model.props?.(internalPrimitives);
         model.schema = schema;
         model.id = this.id;
         model.keys = Array.from(props);
         model.yBlock = this.yBlock;
-        const reactive = new ReactiveFlatYMap(this.yBlock, model.deleted, this.onChange);
+        const reactive = new ReactiveFlatYMap(this.yBlock, model.deleted, this.onChange, defaultProps);
         this._reactive = reactive;
         const proxy = reactive.proxy;
         model._props = proxy;
@@ -35,17 +36,6 @@ export class FlatSyncController {
         if (this.doc) {
             model.store = this.doc;
         }
-        const defaultProps = schema.model.props?.(internalPrimitives);
-        if (defaultProps) {
-            Object.entries(defaultProps).forEach(([key, value]) => {
-                if (key in proxy) {
-                    return;
-                }
-                if (value === undefined)
-                    return;
-                proxy[key] = value;
-            });
-        }
         return model;
     }
     _parseYBlock() {

package/dist/_pkgs/store/model/store/crud.js

@@ -190,10 +190,13 @@ export class DocCRUD {
         return findParent(root);
     }
     getPrev(id) {
-        return this._getSiblings(id, (index, parent) => parent
-            .get('sys:children')
-            .toArray()
-            .at(index - 1) ?? null);
+        return this._getSiblings(id, (index, parent) => {
+            // `at(-1)` would wrap around to the last child, so the first child has to
+            // be answered before indexing.
+            if (index === 0)
+                return null;
+            return parent.get('sys:children').toArray().at(index - 1) ?? null;
+        });
     }
     moveBlocks(blocksToMove, newParent, targetSibling = null, shouldInsertBeforeSibling = true) {
         if (blocksToMove.length > 1 &&

package/dist/_pkgs/store/reactive/flat-native-y/index.d.ts

@@ -17,7 +17,7 @@ export declare class ReactiveFlatYMap extends BaseReactiveYData<UnRecord, YMap<u
     private _byPassYjs;
     private readonly _getProxy;
     private readonly _updateWithYjsSkip;
-    constructor(_ySource: YMap<unknown>, _onDispose: Subject<void>, _onChange?: OnChange | undefined);
+    constructor(_ySource: YMap<unknown>, _onDispose: Subject<void>, _onChange?: OnChange | undefined, defaultProps?: Record<string, unknown>);
     pop: (prop: string) => void;
     stash: (prop: string) => void;
 }

package/dist/_pkgs/store/reactive/flat-native-y/index.js

@@ -8,7 +8,7 @@ import { initializeData } from './initialize.js';
 import { createProxy } from './proxy.js';
 import { getYEventHandler } from './y-event-handler.js';
 export class ReactiveFlatYMap extends BaseReactiveYData {
-    constructor(_ySource, _onDispose, _onChange) {
+    constructor(_ySource, _onDispose, _onChange, defaultProps) {
         super();
         this._ySource = _ySource;
         this._onDispose = _onDispose;
@@ -87,7 +87,7 @@ export class ReactiveFlatYMap extends BaseReactiveYData {
         });
         this._source = source;
         const proxy = this._getProxy(source, source);
-        Object.entries(source).forEach(([key, value]) => {
+        const initSignals = (key, value) => {
             const signalData = signal(value);
             source[`${key}$`] = signalData;
             const unsubscribe = signalData.subscribe(next => {
@@ -103,9 +103,31 @@ export class ReactiveFlatYMap extends BaseReactiveYData {
                 subscription.unsubscribe();
                 unsubscribe();
             });
+        };
+        Object.entries(source).forEach(([key, value]) => {
+            initSignals(key, value);
         });
+        // Props declared with an `undefined` default are never written to the Y.Map,
+        // so they have no counterpart in `source`. Give them a signal anyway, so
+        // consumers can read and write `prop$` before the prop ever gets a value.
+        if (defaultProps) {
+            Object.entries(defaultProps).forEach(([key, value]) => {
+                if (!(key in proxy) && value === undefined) {
+                    initSignals(key, value);
+                }
+            });
+        }
         this._proxy = proxy;
         this._ySource.observe(this._observer);
         this._initialized = true;
+        // Defined defaults are applied after initialization, so that they are
+        // written through to the Y.Map exactly as before.
+        if (defaultProps) {
+            Object.entries(defaultProps).forEach(([key, value]) => {
+                if (key in proxy || value === undefined)
+                    return;
+                proxy[key] = value;
+            });
+        }
     }
 }

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)[];