@formicoidea/labre-core 0.57.0 → 0.59.0

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

@@ -4,21 +4,95 @@ import { isPureObject, native2Y } from '../../reactive/index.js';
 import { internalPrimitives } from '../block/zod.js';
 export class DocCRUD {
     get root() {
-        let rootId = null;
-        this._yBlocks.forEach(yBlock => {
-            const flavour = yBlock.get('sys:flavour');
-            const schema = this._schema.flavourSchemaMap.get(flavour);
-            if (!schema)
-                return;
-            if (schema.model.role === 'root') {
-                rootId = yBlock.get('sys:id');
-            }
-        });
-        return rootId;
+        return this._ensureIndex().root;
     }
     constructor(_yBlocks, _schema) {
         this._yBlocks = _yBlocks;
         this._schema = _schema;
+        /**
+         * In-memory index of the tree: `childId -> parentId` plus the root id,
+         * rebuilt lazily after any structural change. Nothing here is written to Yjs
+         * (ADR 0041).
+         *
+         * Why: `root` scanned every block and `getParent` walked the tree from the
+         * root, so a load path calling `getParent` once per block was quadratic
+         * (#507: 11 s for 4000 blocks under a query with `viewType: 'hidden'`, whose
+         * `setAncestorsToDisplayIfHidden` climbs the ancestors of every block). #508
+         * only skipped that walk for queries that cannot hide blocks; the index
+         * makes the walk itself linear.
+         *
+         * Invalidation contract:
+         * - every transaction, local, remote (`Y.applyUpdate`) or undo, reaches
+         *   `beforeObserverCalls` before any observer runs, so observers and
+         *   everything after them read a fresh index;
+         * - inside a transaction, before that event, only the mutators below write
+         *   the tree (`sys:children`, the blocks map): each drops the index before
+         *   its first write, so a throw half-way leaves no stale index, and again
+         *   after its last one, so a read in between cannot cache a half-written
+         *   tree. A new writer of `sys:children` must do the same.
+         */
+        this._index = null;
+        /** Once deaf to remote changes, every read rebuilds (the pre-#507 cost). */
+        this._live = false;
+        this._onBeforeObserverCalls = (transaction) => {
+            if (!this._index)
+                return;
+            // `changed` only lists types that existed before the transaction: a block
+            // created in it shows up through the blocks map, a children array created
+            // in it through its block's `sys:children` key.
+            for (const [type, keys] of transaction.changed) {
+                if (type === this._yBlocks ||
+                    type._item?.parentSub === 'sys:children' ||
+                    keys.has('sys:children') ||
+                    keys.has('sys:flavour') ||
+                    keys.has('sys:id')) {
+                    this._index = null;
+                    return;
+                }
+            }
+        };
+        if (!_yBlocks.doc)
+            return;
+        _yBlocks.doc.on('beforeObserverCalls', this._onBeforeObserverCalls);
+        this._live = true;
+    }
+    dispose() {
+        this._yBlocks.doc?.off('beforeObserverCalls', this._onBeforeObserverCalls);
+        this._live = false;
+        this._index = null;
+    }
+    // Same answers as the former scan + DFS: the last root in map order, and the
+    // first parent met in a pre-order walk from it. Orphans have none, nor does
+    // the root even when some block lists it as a child. A block listed twice
+    // keeps its first parent and its subtree is walked once, which also ends a
+    // cycle where the former DFS overflowed the stack.
+    _ensureIndex() {
+        if (this._index)
+            return this._index;
+        let root = null;
+        this._yBlocks.forEach(yBlock => {
+            const schema = this._schema.flavourSchemaMap.get(yBlock.get('sys:flavour'));
+            if (schema?.model.role === 'root')
+                root = yBlock.get('sys:id');
+        });
+        const parentOf = new Map();
+        const walk = (parentId) => {
+            const children = this._yBlocks.get(parentId)?.get('sys:children');
+            if (!children)
+                return;
+            for (const childId of children.toArray()) {
+                if (childId === root || parentOf.has(childId))
+                    continue;
+                parentOf.set(childId, parentId);
+                walk(childId);
+            }
+        };
+        if (root)
+            walk(root);
+        const index = { root, parentOf };
+        if (this._live)
+            this._index = index;
+        return index;
     }
     _getSiblings(id, fn) {
         const parentId = this.getParent(id);
@@ -46,6 +120,10 @@ export class DocCRUD {
             ? this._yBlocks.get(parent)?.get('sys:flavour')
             : undefined;
         this._schema.validate(flavour, parentFlavour);
+        // Read the index before the first write; a root-role block never has a
+        // default parent, so the new block cannot change the answer.
+        const parentId = parent ?? (schema.model.role === 'root' ? null : this.root);
+        this._index = null;
         const yBlock = new Y.Map();
         this._yBlocks.set(id, yBlock);
         const version = schema.version;
@@ -84,7 +162,6 @@ export class DocCRUD {
                 yBlock.set(`prop:${key}`, native2Y(value));
             });
         }
-        const parentId = parent ?? (schema.model.role === 'root' ? null : this.root);
         if (!parentId)
             return;
         const yParent = this._yBlocks.get(parentId);
@@ -97,6 +174,7 @@ export class DocCRUD {
                 : parentIndex
             : yParentChildren.length;
         yParentChildren.insert(index, [id]);
+        this._index = null;
     }
     deleteBlock(id, options = {
         deleteChildren: true,
@@ -116,6 +194,7 @@ export class DocCRUD {
         const yParent = this._yBlocks.get(parent);
         const yParentChildren = yParent.get('sys:children');
         const modelIndex = yParentChildren.toArray().indexOf(id);
+        this._index = null;
         if (modelIndex > -1) {
             yParentChildren.delete(modelIndex, 1);
         }
@@ -162,6 +241,7 @@ export class DocCRUD {
         };
         apply();
         this._yBlocks.delete(id);
+        this._index = null;
     }
     getNext(id) {
         return this._getSiblings(id, (index, parent) => parent
@@ -170,24 +250,7 @@ export class DocCRUD {
             .at(index + 1) ?? null);
     }
     getParent(targetId) {
-        const root = this.root;
-        if (!root || root === targetId)
-            return null;
-        const findParent = (parentId) => {
-            const parentYBlock = this._yBlocks.get(parentId);
-            if (!parentYBlock)
-                return null;
-            const children = parentYBlock.get('sys:children');
-            for (const childId of children.toArray()) {
-                if (childId === targetId)
-                    return parentId;
-                const parent = findParent(childId);
-                if (parent != null)
-                    return parent;
-            }
-            return null;
-        };
-        return findParent(root);
+        return this._ensureIndex().parentOf.get(targetId) ?? null;
     }
     getPrev(id) {
         return this._getSiblings(id, (index, parent) => {
@@ -241,6 +304,7 @@ export class DocCRUD {
             children.push(blockId);
         });
         let insertIndex = 0;
+        this._index = null;
         Array.from(childBlocksPerParent.entries()).forEach(([parentBlock, blocksToMove], index) => {
             const targetParentBlock = this._yBlocks.get(newParent);
             if (!targetParentBlock)
@@ -280,13 +344,16 @@ export class DocCRUD {
             updateInsertIndex();
             targetParentChildren.insert(insertIndex, blocksToMove);
         });
+        this._index = null;
     }
     updateBlockChildren(id, children) {
         const yBlock = this._yBlocks.get(id);
         if (!yBlock)
             return;
         const yChildrenArray = yBlock.get('sys:children');
+        this._index = null;
         yChildrenArray.delete(0, yChildrenArray.length);
         yChildrenArray.push(children);
+        this._index = null;
     }
 }

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

@@ -10,9 +10,10 @@ export function runQuery(query, block) {
 /**
  * A loose query hides a block only through a `viewType: 'hidden'` entry, so
  * without one no ancestor can be hidden and the walk below is a no-op. The
- * walk costs one O(n) `getParent` per ancestor, which made opening a store
+ * walk cost one O(n) `getParent` per ancestor, which made opening a store
  * with the default query quadratic in the block count (#507, guard
- * `__tests__/query.unit.spec.ts`).
+ * `__tests__/query.unit.spec.ts`); `getParent` is now an index lookup
+ * (ADR 0041), and skipping the no-op walk still saves the calls.
  */
 function canHideBlocks(query) {
     if (query.mode !== 'loose')

package/dist/_pkgs/store/model/store/store.d.ts

@@ -172,6 +172,27 @@ export declare class Store {
     private readonly _runQuery;
     private readonly _doc;
     private readonly _blocks;
+    /**
+     * The blocks record while a batch runs, `null` otherwise (#507, ADR 0041).
+     *
+     * Adding a block used to copy the whole record into a new one, once per
+     * block: quadratic when a store opens on n blocks, and far slower with real
+     * string ids than with integer-like ones, which V8 copies on a fast path
+     * (2000 string ids: 2.6 s under any query). A batch copies the record once,
+     * adds and removes blocks in this draft, and assigns `_blocks` once at the
+     * end, so its subscribers are notified once.
+     *
+     * The store's own reads (`getBlock`, `hasBlock`, `getParent`,
+     * `blockSize`…) go through `_peekBlocks()` and see each block as soon as
+     * its `add` is handled, as before; `blockUpdated` still fires per block.
+     * Only a direct read of `store.blocks` sees the batch at its end. Batches:
+     * the init loop of the constructor, and a transaction that adds or removes
+     * more than one block; a single block keeps the per-block assignment.
+     */
+    private _blocksDraft;
+    private _blocksDraftChanged;
+    private _peekBlocks;
+    private _batchBlocks;
     private readonly _crud;
     private readonly _query;
     private readonly _readonly;

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

@@ -24,6 +24,28 @@ const internalExtensions = [StoreSelectionExtension, HistoryExtension];
  * @category Store
  */
 export class Store {
+    _peekBlocks() {
+        return this._blocksDraft ?? this._blocks.peek();
+    }
+    _batchBlocks(fn) {
+        // A batch opened inside another one is part of it: the outer one assigns.
+        if (this._blocksDraft) {
+            fn();
+            return;
+        }
+        const draft = { ...this._blocks.peek() };
+        this._blocksDraft = draft;
+        this._blocksDraftChanged = false;
+        try {
+            fn();
+        }
+        finally {
+            this._blocksDraft = null;
+            // An unchanged batch notifies nobody, like the per-block path.
+            if (this._blocksDraftChanged)
+                this._blocks.value = draft;
+        }
+    }
     /**
      * Get the id of the store.
      *
@@ -73,7 +95,7 @@ export class Store {
      * @category Block CRUD
      */
     get blockSize() {
-        return Object.values(this._blocks.peek()).length;
+        return Object.values(this._peekBlocks()).length;
     }
     /**
      * Check if the store can redo
@@ -271,6 +293,25 @@ export class Store {
             runQuery(this._query, block);
         };
         this._blocks = signal({});
+        /**
+         * The blocks record while a batch runs, `null` otherwise (#507, ADR 0041).
+         *
+         * Adding a block used to copy the whole record into a new one, once per
+         * block: quadratic when a store opens on n blocks, and far slower with real
+         * string ids than with integer-like ones, which V8 copies on a fast path
+         * (2000 string ids: 2.6 s under any query). A batch copies the record once,
+         * adds and removes blocks in this draft, and assigns `_blocks` once at the
+         * end, so its subscribers are notified once.
+         *
+         * The store's own reads (`getBlock`, `hasBlock`, `getParent`,
+         * `blockSize`…) go through `_peekBlocks()` and see each block as soon as
+         * its `add` is handled, as before; `blockUpdated` still fires per block.
+         * Only a direct read of `store.blocks` sees the batch at its end. Batches:
+         * the init loop of the constructor, and a transaction that adds or removes
+         * more than one block; a single block keeps the per-block assignment.
+         */
+        this._blocksDraft = null;
+        this._blocksDraftChanged = false;
         this._query = {
             match: [],
             mode: 'loose',
@@ -350,7 +391,16 @@ export class Store {
             this.disposableGroup.add(this.slots.rootDeleted);
         };
         this._handleYEvents = (events) => {
-            events.forEach(event => this._handleYEvent(event));
+            const handle = () => events.forEach(event => this._handleYEvent(event));
+            // One transaction that adds or removes several blocks (a remote load, a
+            // paste, a subtree deletion) assigns the blocks record once (#507); a
+            // single block keeps the per-block path unchanged.
+            const keys = events.reduce((count, event) => event.target === this._yBlocks ? count + event.keys.size : count, 0);
+            if (keys > 1) {
+                this._batchBlocks(handle);
+                return;
+            }
+            handle();
         };
         this.slots = {
             ready: new Subject(),
@@ -383,12 +433,14 @@ export class Store {
             this._query = query;
         }
         this._yBlocks.observeDeep(this._handleYEvents);
-        this._yBlocks.forEach((_, id) => {
-            this._handleYBlockAdd(id, false);
-            if (id in this._blocks.peek()) {
-                return;
-            }
-            this._onBlockAdded(id, false, true);
+        this._batchBlocks(() => {
+            this._yBlocks.forEach((_, id) => {
+                this._handleYBlockAdd(id, false);
+                if (id in this._peekBlocks()) {
+                    return;
+                }
+                this._onBlockAdded(id, false, true);
+            });
         });
         this._subscribeToSlots();
     }
@@ -406,7 +458,7 @@ export class Store {
     }
     _onBlockAdded(id, isLocal, init) {
         try {
-            if (id in this._blocks.peek()) {
+            if (id in this._peekBlocks()) {
                 return;
             }
             const yBlock = this._yBlocks.get(id);
@@ -430,10 +482,16 @@ export class Store {
             };
             const block = new Block(this._schema, yBlock, this, options);
             this._runQuery(block);
-            this._blocks.value = {
-                ...this._blocks.value,
-                [id]: block,
-            };
+            if (this._blocksDraft) {
+                this._blocksDraft[id] = block;
+                this._blocksDraftChanged = true;
+            }
+            else {
+                this._blocks.value = {
+                    ...this._blocks.value,
+                    [id]: block,
+                };
+            }
             block.model.created.next();
             if (block.model.role === 'root') {
                 this.slots.rootAdded.next(id);
@@ -468,8 +526,14 @@ export class Store {
                 model: block.model,
                 isLocal,
             });
-            const { [id]: _, ...blocks } = this._blocks.peek();
-            this._blocks.value = blocks;
+            if (this._blocksDraft) {
+                delete this._blocksDraft[id];
+                this._blocksDraftChanged = true;
+            }
+            else {
+                const { [id]: _, ...blocks } = this._blocks.peek();
+                this._blocks.value = blocks;
+            }
             block.model.deleted.next();
             block.model.dispose();
         }
@@ -633,7 +697,7 @@ export class Store {
      * @category Block CRUD
      */
     getBlock(id) {
-        return this._blocks.peek()[id];
+        return this._peekBlocks()[id];
     }
     /**
      * Gets a block by its ID
@@ -643,7 +707,9 @@ export class Store {
      * @category Block CRUD
      */
     getBlock$(id) {
-        return this._blocks.value[id];
+        // Subscribes to the record, answers from the draft during a batch.
+        const blocks = this._blocks.value;
+        return (this._blocksDraft ?? blocks)[id];
     }
     /**
      * Get a model by its ID
@@ -664,7 +730,7 @@ export class Store {
      */
     getBlocksByFlavour(blockFlavour) {
         const flavours = typeof blockFlavour === 'string' ? [blockFlavour] : blockFlavour;
-        return Object.values(this._blocks.peek()).filter(({ flavour }) => flavours.includes(flavour));
+        return Object.values(this._peekBlocks()).filter(({ flavour }) => flavours.includes(flavour));
     }
     /**
      * Get all models in the store
@@ -673,7 +739,7 @@ export class Store {
      * @category Block CRUD
      */
     getAllModels() {
-        return Object.values(this._blocks.peek()).map(block => block.model);
+        return Object.values(this._peekBlocks()).map(block => block.model);
     }
     /**
      * Get all models of specified flavour(s)
@@ -697,7 +763,7 @@ export class Store {
         const parentId = this._crud.getParent(targetId);
         if (!parentId)
             return null;
-        const parent = this._blocks.peek()[parentId];
+        const parent = this._peekBlocks()[parentId];
         if (!parent)
             return null;
         return parent.model;
@@ -750,7 +816,7 @@ export class Store {
      * @category Block CRUD
      */
     hasBlock(id) {
-        return id in this._blocks.peek();
+        return id in this._peekBlocks();
     }
     /**
      * Move blocks to a new parent block
@@ -858,6 +924,7 @@ export class Store {
         this.slots.blockUpdated.complete();
         this.slots.yBlockUpdated.complete();
         this.disposableGroup.dispose();
+        this._crud.dispose();
         this._isDisposed = true;
     }
     _handleYBlockAdd(id, isLocal) {

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

@@ -10,6 +10,32 @@ export type TransformerOptions = {
     docCRUD: DocCRUD;
     middlewares?: TransformerMiddleware[];
 };
+interface DraftBlockTreeNode {
+    draft: DraftModel;
+    snapshot: BlockSnapshot;
+    children: Array<DraftBlockTreeNode>;
+}
+/**
+ * A block snapshot converted to draft models and not written yet: what
+ * {@link Transformer.prepareSnapshotToBlock} returns and
+ * {@link Transformer.insertPrepared} writes. `id` is the id the root block
+ * will have, after the `beforeImport` middlewares (a replaced one).
+ */
+export interface PreparedBlockSnapshot {
+    readonly id: string;
+    readonly tree: DraftBlockTreeNode;
+    readonly parent?: string;
+    readonly index?: number;
+}
+/**
+ * What {@link Transformer.insertPrepared} wrote. A block model only exists
+ * once the transaction that wrote it has ended, so the `afterImport` events
+ * wait for `flushAfterImport`, which returns the root model.
+ */
+export interface InsertedBlockSnapshot {
+    readonly id: string;
+    flushAfterImport(): BlockModel | null;
+}
 export declare class Transformer {
     private readonly _adapterConfigs;
     private readonly _transformerConfigs;
@@ -22,6 +48,24 @@ export declare class Transformer {
     docToSnapshot: (doc: Store) => DocSnapshot | undefined;
     sliceToSnapshot: (slice: Slice) => SliceSnapshot | undefined;
     snapshotToBlock: (snapshot: BlockSnapshot, doc: Store, parent?: string, index?: number) => Promise<BlockModel | undefined>;
+    /**
+     * The first half of {@link snapshotToBlock}: fires `beforeImport` and
+     * converts every node (the block transformers await their blobs here), and
+     * writes nothing. Pair it with {@link insertPrepared} on the SAME
+     * transformer: a middleware keeps its state per transformer
+     * (`replaceIdMiddleware`'s id map). Split so that a gesture can await every
+     * preparation first, then write them all in one synchronous transaction —
+     * one undo step whatever the preparation took (ADR 0042).
+     */
+    prepareSnapshotToBlock: (snapshot: BlockSnapshot, parent?: string, index?: number) => Promise<PreparedBlockSnapshot | undefined>;
+    /**
+     * The second half of {@link snapshotToBlock}: adds the prepared blocks to
+     * `doc` synchronously, without the yield every `BATCH_SIZE` blocks, so the
+     * caller may run it inside its own `store.transact`. The `afterImport`
+     * events (middlewares write props from them) wait for `flushAfterImport()`,
+     * to call once that transaction has ended and the models exist.
+     */
+    insertPrepared: (prepared: PreparedBlockSnapshot, doc: Store) => InsertedBlockSnapshot | undefined;
     snapshotToDoc: (snapshot: DocSnapshot) => Promise<Store | undefined>;
     snapshotToModelData: (snapshot: BlockSnapshot) => Promise<import("./base.js").SnapshotNode<object> | undefined>;
     snapshotToSlice: (snapshot: SliceSnapshot, doc: Store, parent?: string, index?: number) => Promise<Slice | undefined>;
@@ -40,9 +84,11 @@ export declare class Transformer {
     private _getSchema;
     private _getTransformer;
     private _insertBlockTree;
+    private _insertBlockTreeSync;
     private _rebuildBlockTree;
     private _snapshotToBlock;
     private _triggerBeforeImportEvent;
     reset(): void;
     [Symbol.dispose](): void;
 }
+export {};

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

@@ -134,6 +134,65 @@ export class Transformer {
                 return;
             }
         };
+        /**
+         * The first half of {@link snapshotToBlock}: fires `beforeImport` and
+         * converts every node (the block transformers await their blobs here), and
+         * writes nothing. Pair it with {@link insertPrepared} on the SAME
+         * transformer: a middleware keeps its state per transformer
+         * (`replaceIdMiddleware`'s id map). Split so that a gesture can await every
+         * preparation first, then write them all in one synchronous transaction —
+         * one undo step whatever the preparation took (ADR 0042).
+         */
+        this.prepareSnapshotToBlock = async (snapshot, parent, index) => {
+            try {
+                BlockSnapshotSchema.parse(snapshot);
+                this._triggerBeforeImportEvent(snapshot, parent, index);
+                const flatSnapshots = [];
+                this._flattenSnapshot(snapshot, flatSnapshots, parent, index);
+                const tree = await this._convertFlatSnapshots(flatSnapshots);
+                return { id: tree.draft.id, tree, parent, index };
+            }
+            catch (error) {
+                console.error(`Error when preparing snapshot to block:`);
+                console.error(error);
+                return;
+            }
+        };
+        /**
+         * The second half of {@link snapshotToBlock}: adds the prepared blocks to
+         * `doc` synchronously, without the yield every `BATCH_SIZE` blocks, so the
+         * caller may run it inside its own `store.transact`. The `afterImport`
+         * events (middlewares write props from them) wait for `flushAfterImport()`,
+         * to call once that transaction has ended and the models exist.
+         */
+        this.insertPrepared = (prepared, doc) => {
+            const inserted = [];
+            try {
+                this._insertBlockTreeSync([prepared.tree], doc, inserted, prepared.parent, prepared.index);
+            }
+            catch (error) {
+                console.error(`Error when inserting prepared snapshot:`);
+                console.error(error);
+                if (inserted.length === 0)
+                    return;
+            }
+            return {
+                id: prepared.id,
+                flushAfterImport: () => {
+                    for (const node of inserted) {
+                        const model = doc.getBlock(node.draft.id)?.model;
+                        if (!model)
+                            continue;
+                        this._slots.afterImport.next({
+                            type: 'block',
+                            model,
+                            snapshot: node.snapshot,
+                        });
+                    }
+                    return doc.getBlock(prepared.id)?.model ?? null;
+                },
+            };
+        };
         this.snapshotToDoc = async (snapshot) => {
             try {
                 this._slots.beforeImport.next({
@@ -407,6 +466,17 @@ export class Transformer {
         }
         return counter;
     }
+    _insertBlockTreeSync(nodes, doc, inserted, parentId, startIndex) {
+        nodes.forEach((node, index) => {
+            const { id, flavour, props } = node.draft;
+            const actualIndex = startIndex !== undefined ? startIndex + index : undefined;
+            doc.addBlock(flavour, { id, ...props }, parentId, actualIndex);
+            inserted.push(node);
+            if (node.children.length > 0) {
+                this._insertBlockTreeSync(node.children, doc, inserted, id);
+            }
+        });
+    }
     _rebuildBlockTree(draftModels) {
         const nodeMap = new Map();
         // First pass: create nodes and add them to the map
@@ -436,6 +506,8 @@ export class Transformer {
         const flatSnapshots = [];
         this._flattenSnapshot(snapshot, flatSnapshots, parent, index);
         const blockTree = await this._convertFlatSnapshots(flatSnapshots);
+        // Not `insertPrepared`: an import may hold thousands of blocks, and this
+        // path yields to the main thread every BATCH_SIZE of them.
         await this._insertBlockTree([blockTree], doc, parent, index);
         return doc.getBlock(snapshot.id)?.model ?? null;
     }

package/dist/commands.js

@@ -1,5 +1,6 @@
 import { frameCommands } from './_pkgs/affine-block-frame/index.js';
-import { copyLinkCommands, coreCommands, pageExportCommands, pivotCommands, readingCommands, tagCommands, } from './_pkgs/affine-block-root/index.js';
+import { imageReplaceCommands } from './_pkgs/affine-block-image/index.js';
+import { copyLinkCommands, coreCommands, invisibleCharactersCommands, pageExportCommands, pivotCommands, readingCommands, tagCommands, } from './_pkgs/affine-block-root/index.js';
 import { auditCommands, canvasDrawioExportCommands, canvasExportCommands, canvasGridCommands, canvasSvgExportCommands, exportSvgCommands, mapQualityCommands, selectionPaneCommands, userLayerCommands, } 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';
@@ -50,6 +51,7 @@ export function getCommands(flags) {
         ...coreCommands,
         ...copyLinkCommands,
         ...pageExportCommands,
+        ...invisibleCharactersCommands,
         ...pivotCommands,
         ...tagCommands,
         ...readingCommands,
@@ -58,6 +60,9 @@ export function getCommands(flags) {
         ...exportSvgCommands,
         ...selectionPaneCommands,
         ...frameCommands,
+        // ADR 0044: registered by the image view extension, so they go with
+        // the `image` flag here too.
+        ...(isBlockEnabled(flags, 'image') ? imageReplaceCommands : []),
         ...canvasGridCommands,
         ...canvasExportCommands,
         ...canvasDrawioExportCommands,

package/dist/translations.js

@@ -29,6 +29,7 @@ import { PRESET_WORDINGS } from './_pkgs/affine-inline-preset/translations.js';
 import { REFERENCE_WORDINGS } from './_pkgs/affine-inline-reference/translations.js';
 import { CHROME_WORDINGS, } from './_pkgs/affine-shared/services/index.js';
 import { CALLOUT_WORDINGS } from './_pkgs/affine-block-callout/translations.js';
+import { TABLE_WORDINGS } from './_pkgs/affine-block-table/translations.js';
 import { CODE_WORDINGS } from './_pkgs/affine-block-code/translations.js';
 import { LATEX_WORDINGS } from './_pkgs/affine-block-latex/translations.js';
 import { NOTE_WORDINGS } from './_pkgs/affine-block-note/translations.js';
@@ -295,6 +296,7 @@ const PACKAGE_WORDINGS = [
     CODE_WORDINGS,
     LATEX_WORDINGS,
     CALLOUT_WORDINGS,
+    TABLE_WORDINGS,
     PARAGRAPH_WORDINGS,
     ADAPTER_PANEL_WORDINGS,
     DOC_TITLE_WORDINGS,