@formicoidea/labre-core 0.42.0 → 0.45.0

package/dist/_pkgs/affine-block-surface/extensions/legend.js

@@ -276,13 +276,42 @@ const INSET_BOTTOM = 56;
  * It is also why a legend never lists itself: nothing it draws carries a role.
  */
 export function rolesInBound(gfx, bound) {
+    return rolesOf(gfx.getElementsByBound(bound, { type: 'canvas' }));
+}
+/** {@link rolesInBound} over a perimeter already scanned. */
+function rolesOf(elements) {
     const present = new Set();
-    for (const el of gfx.getElementsByBound(bound, { type: 'canvas' })) {
+    for (const el of elements) {
         if (el.role !== undefined)
             present.add(el.role);
     }
     return present;
 }
+/**
+ * The legends ALREADY drawn on this board — what turns the button's second
+ * press into "regenerate" rather than a second stacked box (issue #391).
+ *
+ * The scan already sees them: a generated legend's wrapper carries
+ * {@link LEGEND_ROLE}, so recognising one costs a filter over the elements the
+ * perimeter pass returned, and nothing in the document format changes.
+ *
+ * CONTAINMENT rather than intersection, which is what `getElementsByBound`
+ * answers with: two boards drawn edge to edge each overlap the other's corner,
+ * and the press on one would eat the other's box. A legend is inset well inside
+ * the board it documents, so asking for the whole box costs nothing here and
+ * keeps the neighbour's.
+ *
+ * Two boxes it deliberately does not find: one the author dragged off the board
+ * (it is no longer this board's legend, and a fresh one is drawn), and one
+ * generated before {@link LEGEND_ROLE} shipped in 0.42 — that box carries no
+ * role, so the old stacking survives on those documents. Nothing is backfilled,
+ * as ever (ADR 0026).
+ */
+function legendsOn(elements, bound) {
+    return elements.filter(el => el.type === 'group' &&
+        el.role === LEGEND_ROLE &&
+        bound.contains(el.elementBound));
+}
 /** Every registered vocabulary, merged — a role id is namespaced, so it is flat. */
 function vocabularyOf(std) {
     const merged = {};
@@ -410,15 +439,32 @@ function boardLegendBox(std, owner) {
  * Build the legend of what is drawn inside `board` and drop it bottom-left of
  * it, grouped and selected. THE gesture the shared toolbar button runs.
  *
+ * REPLACES the board's own legend if it already has one, rather than stacking a
+ * second box on the first (issue #391): the placement is derived from the board
+ * alone, so every press landed at the same pixel and the copies were invisible
+ * — one box to the eye, N groups and N × ~15 elements in the document. The
+ * second press is therefore a REFRESH, which is what a user who has just added
+ * three artefacts is asking for; the cost is that hand retouching of the box is
+ * lost, and one undo brings it back (see {@link legendsOn} and ADR 0026).
+ *
  * Returns the group id, or `undefined` when there is no surface to draw on.
  */
 export function createBoardLegend(std, board, owner) {
     const gfx = std.get(GfxControllerIdentifier);
     const surface = gfx.surface;
-    if (!surface)
+    // The button already refuses on a readonly document; said again here because
+    // this gesture now DELETES before it draws, and a refused delete followed by
+    // a throwing draw is the one order that could lose a box.
+    if (!surface || std.store.readonly)
         return undefined;
     const bound = Bound.deserialize(board.xywh);
-    const present = rolesInBound(gfx, bound);
+    const inside = gfx.getElementsByBound(bound, { type: 'canvas' });
+    const previous = legendsOn(inside, bound);
+    // The box about to be drawn describes the DRAWING, never the box it replaces:
+    // the outgoing wrapper is dropped from the scan so `core:legend` is not among
+    // the roles the rows are derived from. Its glyphs carry no role at all.
+    const outgoing = new Set(previous);
+    const present = rolesOf(inside.filter(el => !outgoing.has(el)));
     const sections = legendFromCommands(std, owner, present);
     const box = boardLegendBox(std, owner);
     const layout = {
@@ -432,7 +478,17 @@ export function createBoardLegend(std, board, owner) {
     const extras = box?.extras?.({ std, board, present }) ?? [];
     const title = translateKey(std, ...(box?.titleWording ?? BOARD_LEGEND_TITLE));
     const { height } = measureLegend(sections, layout, extras);
+    // ONE checkpoint, in front of BOTH halves of the replacement: a single
+    // Ctrl+Z after a regenerate puts the previous box back whole, rather than
+    // leaving the board with no legend at all.
     std.store.captureSync();
+    if (previous.length > 0) {
+        const crud = std.get(EdgelessCRUDIdentifier);
+        // Cascades into the group's children (`crud-extension.ts`), so one call
+        // per legend takes the whole box away.
+        for (const legend of previous)
+            crud.removeElement(legend.id);
+    }
     const id = addLegend(surface, std, bound.x + INSET_X, bound.y + bound.h - INSET_BOTTOM - height, { title, sections, extras, ...layout });
     gfx.selection.set({ elements: [id], editing: false });
     return id;

package/dist/_pkgs/affine-block-surface/extensions/morph-toolbar.js

@@ -229,6 +229,10 @@ export function morphToolbarConfig(spec) {
                     return renderPickerMenu({
                         testId: 'element-morph',
                         label: wording(ctx, spec.label),
+                        // The shell's accessible name stays the stable ENGLISH
+                        // identifier: composing it from the translated label produced
+                        // half a sentence per language (#390).
+                        menuAria: `${spec.label.fallback.toLowerCase()}-menu`,
                         // The current kind's own icon on the closed button, exactly as the
                         // shape picker shows the current shape: the dropdown reads as a
                         // statement about the selection before it is opened.

package/dist/_pkgs/affine-block-surface/extensions/reading-widget.d.ts

@@ -130,13 +130,20 @@ export declare class ReadingProposalWidget extends EditorAnchoredPanel {
      */
     private _renderValueFlow;
     /**
-     * Where the subject sits along the frame's phase axis.
+     * The zone of the frame the subject sits in — Wardley's evolution phase, a
+     * Core Domain Chart's quadrant, a BPMN lane — under the framework's own
+     * heading (`frame.label`), or the engine's default for a profile that names
+     * none (`readingFrameWording`).
      *
-     * Absent ENTIRELY — not "no phase to read" — for a framework that declares no
-     * frame. The empty state below is about a component that could have been on a
-     * map and is not; telling the author of a BPMN task that it is "not on a
-     * framework background" would be answering a question their notation never
-     * asks.
+     * Absent ENTIRELY — not "no zone to read" — for a framework that declares no
+     * frame. The empty state below is about an artefact that could have been on
+     * a frame and is not, in the framework's own words (`frame.none`) or the
+     * default ones.
+     *
+     * The zone is named the way the board names it: the user's words when they
+     * wrote some (a renamed quadrant, a lane's name), the vocabulary otherwise,
+     * and "Unnamed" for a zone the board paints but never writes on — never the
+     * zone's id, which is not a word anyone drew.
      */
     private _renderPhase;
     private _renderNaming;

package/dist/_pkgs/affine-block-surface/extensions/reading-widget.js

@@ -40,7 +40,7 @@ import { css, html, nothing } from 'lit';
 import { state } from 'lit/decorators.js';
 import { literal, unsafeStatic } from 'lit/static-html.js';
 import { EditorAnchoredPanel, editorAnchoredPanelStyles, } from './editor-anchored-panel.js';
-import { PivotRecordPickerProvider, ReadingManager, readingRelationDefs, readRecord, readValueFlows, } from './reading.js';
+import { PivotRecordPickerProvider, ReadingManager, readingFrameWording, readingRelationDefs, readRecord, readValueFlows, } from './reading.js';
 export const READING_PROPOSAL_WIDGET = 'affine-reading-proposal-widget';
 /** The two commands the confirmations drive. Spelled once. */
 const TAG_SET_ID = 'tag.set';
@@ -514,21 +514,37 @@ let ReadingProposalWidget = (() => {
           </div>`)}`);
         }
         /**
-         * Where the subject sits along the frame's phase axis.
+         * The zone of the frame the subject sits in — Wardley's evolution phase, a
+         * Core Domain Chart's quadrant, a BPMN lane — under the framework's own
+         * heading (`frame.label`), or the engine's default for a profile that names
+         * none (`readingFrameWording`).
          *
-         * Absent ENTIRELY — not "no phase to read" — for a framework that declares no
-         * frame. The empty state below is about a component that could have been on a
-         * map and is not; telling the author of a BPMN task that it is "not on a
-         * framework background" would be answering a question their notation never
-         * asks.
+         * Absent ENTIRELY — not "no zone to read" — for a framework that declares no
+         * frame. The empty state below is about an artefact that could have been on
+         * a frame and is not, in the framework's own words (`frame.none`) or the
+         * default ones.
+         *
+         * The zone is named the way the board names it: the user's words when they
+         * wrote some (a renamed quadrant, a lane's name), the vocabulary otherwise,
+         * and "Unnamed" for a zone the board paints but never writes on — never the
+         * zone's id, which is not a word anyone drew.
          */
         _renderPhase(reading, profile) {
             if (!profile.frame)
                 return nothing;
+            const { label, none } = readingFrameWording(profile.frame);
             const { phase } = reading;
-            return this._field('reading-phase', translateKey(this.std, 'com.labre.reading.field.phase', 'Evolution phase'), phase
+            const words = !phase
+                ? ''
+                : phase.name !== undefined
+                    ? phase.name.trim()
+                    : phase.labelKey !== undefined
+                        ? translateKey(this.std, phase.labelKey, phase.labelFallback ?? phase.labelKey)
+                        : (phase.labelFallback ?? '');
+            return this._field('reading-phase', translateKey(this.std, label.labelKey, label.labelFallback), phase
                 ? html `<div class="reading-value" data-zone-id=${phase.zoneId}>
-              ${translateKey(this.std, phase.labelKey ?? phase.zoneId, phase.labelFallback ?? phase.zoneId)}
+              ${words ||
+                    translateKey(this.std, 'com.labre.reading.zone.unnamed', 'Unnamed')}
             </div>
             ${phase.inTransitionBand
                     ? html `<div class="reading-note" data-testid="reading-phase-band">
@@ -537,7 +553,7 @@ let ReadingProposalWidget = (() => {
                 </div>`
                     : nothing}`
                 : html `<div class="reading-empty" data-testid="reading-phase-none">
-            ${translateKey(this.std, 'com.labre.reading.phase.none', 'Not on a framework background — no phase to read.')}
+            ${translateKey(this.std, none.labelKey, none.labelFallback)}
           </div>`);
         }
         _renderNaming(reading) {

package/dist/_pkgs/affine-block-surface/extensions/reading.d.ts

@@ -1,4 +1,4 @@
-import { type TagDef } from '../../affine-shared/services/index.js';
+import { type ChromeWording, type TagDef } from '../../affine-shared/services/index.js';
 import { LifeCycleWatcher, type BlockStdScope, type FrameworkId } from '../../std/index.js';
 import type { RoleDefs, RoleId } from '../../std/gfx/index.js';
 import { GfxPrimitiveElementModel } from '../../std/gfx/index.js';
@@ -92,6 +92,14 @@ export interface ReadingRelationSideLabel {
     /** The framework's own English wording, for a host that ships no catalogue. */
     labelFallback: string;
 }
+/**
+ * One wording a framework declares for the frame field of the panel: key plus
+ * its own English, so a host with no catalogue still reads a real phrase.
+ */
+export interface ReadingFrameWording {
+    labelKey: string;
+    labelFallback: string;
+}
 /**
  * The typed edge a reading walks, and the two words the framework reads it
  * with.
@@ -185,13 +193,41 @@ export interface ReadingProfile {
      * reads them in, so the first is the question the artefact answers first.
      */
     alsoRelations?: readonly ReadingRelationDef[];
-    /** The frame the phase is read from. */
+    /**
+     * The frame the subject's ZONE is read from — Wardley's evolution phase, a
+     * Core Domain Chart's quadrant, a BPMN pool's lane.
+     */
     frame?: {
         backgroundRole: RoleId;
         /** The declaration itself, carried as data exactly like `roles` is. */
         background: FrameworkBackgroundDef;
-        /** Which plot axis the zones are laid along. */
-        axis: 'x' | 'y';
+        /**
+         * The plot axis the zones are laid ALONG, for a frame read in one
+         * dimension: Wardley's phases are columns of the evolution axis, so only
+         * the `x` position matters and a component in the top or bottom margin of
+         * the plot still has a phase.
+         *
+         * Absent, the frame is read in TWO dimensions: the subject is in the zone
+         * whose rectangle holds its centre — a quadrant, a lane — and nowhere when
+         * none does. A 2D frame has no transition band.
+         */
+        axis?: 'x' | 'y';
+        /**
+         * The panel's heading for the field — "Evolution phase", "Zone", "Lane".
+         * The framework's own word, like a relation's sides: the panel used to
+         * hard-code Wardley's, which a chart or a pool would have worn too.
+         *
+         * Optional because a 0.43 profile has no such field and a minor release
+         * never breaks a host: absent, the panel reads
+         * {@link READING_FRAME_DEFAULT_WORDING}, which is what 0.43 showed for
+         * every frame (`readingFrameWording`).
+         */
+        label?: ReadingFrameWording;
+        /**
+         * What the field says when the subject sits in no zone of any frame.
+         * Optional for the reason {@link label} is, with the same default.
+         */
+        none?: ReadingFrameWording;
     };
     /**
      * Which properties of the PIVOT RECORD the reading may compare itself
@@ -207,6 +243,21 @@ export interface ReadingProfile {
         phase?: string;
     };
 }
+/** The default frame wording, as the rows the key manifest walks. */
+export declare const READING_FRAME_WORDINGS: readonly ChromeWording[];
+/** The default frame wording, as a profile's `frame.label` / `frame.none`. */
+export declare const READING_FRAME_DEFAULT_WORDING: Readonly<{
+    label: ReadingFrameWording;
+    none: ReadingFrameWording;
+}>;
+/**
+ * The two wordings the panel reads a frame with: the framework's own where it
+ * declares them, {@link READING_FRAME_DEFAULT_WORDING} where it does not.
+ */
+export declare function readingFrameWording(frame: NonNullable<ReadingProfile['frame']>): {
+    label: ReadingFrameWording;
+    none: ReadingFrameWording;
+};
 /** Where the other end of a typed edge sits, relative to the subject. */
 export type ReadingRelationSide = 'consumer' | 'supplier';
 /**
@@ -271,12 +322,24 @@ export interface ReadingRelation {
      */
     contradictsGeometry: boolean;
 }
-/** Where the subject sits along the frame's phase axis. */
+/**
+ * The zone of the frame the subject sits in: a phase along an axis, or a
+ * region of the plane (see `ReadingProfile.frame.axis`).
+ */
 export interface ReadingPhase {
-    /** The declared zone id, e.g. `product`. */
+    /** The zone id, e.g. `product`, or `lane:<id>` for an instance zone. */
     zoneId: string;
+    /** The declared zone's vocabulary, absent on a zone the board never names. */
     labelKey?: string;
     labelFallback?: string;
+    /**
+     * The words the USER wrote for this zone, which is what the board paints in
+     * place of the vocabulary: a renamed zone label stored on the frame (the
+     * declaration's `label.prop`), or a lane's name. Wins over
+     * {@link labelKey} exactly as it does on the canvas (`backgroundLabelText`),
+     * so the panel and the board never name one zone two ways.
+     */
+    name?: string;
     /**
      * The subject sits in the band around a zone transition — Wardley's zone of
      * punctuated equilibrium, declared by the background as
@@ -331,6 +394,19 @@ export interface ElementReading {
     /** `undefined` with no nature, no convention for it, or no name to judge. */
     naming: ReadingNaming | undefined;
 }
+/**
+ * The subject's NAME.
+ *
+ * Its own text first, then — because a framework artefact on this canvas is a
+ * composite — the text of the sibling carrying the profile's label role. That
+ * is the same fact `tags-toolbar.ts` works around from the other direction: one
+ * click selects the group, the role lives on the circle, and the name lives on
+ * a free text beside it.
+ *
+ * Exported for the selection pane, which names its rows the same way (ADR 0031
+ * §12): one rule for "what is this element called", not two.
+ */
+export declare function readName(element: GfxPrimitiveElementModel, profile: Pick<ReadingProfile, 'labelRole' | 'roles'>): string;
 /** What the reading needs to know that is not in the document. */
 export interface ReadingOptions {
     /**

package/dist/_pkgs/affine-block-surface/extensions/reading.js

@@ -8,7 +8,49 @@ import { effect, signal } from '@preact/signals-core';
 // reading is a one-way read of pure declaration data that must never pull a
 // canvas in.
 import { backgroundPlot, } from '../framework-background/def.js';
-import { backgroundTransitionBands, containingFrame, } from '../framework-background/facts.js';
+import { backgroundPlotRatios, backgroundTransitionBands, backgroundZoneAt, backgroundZones, containingFrame, } from '../framework-background/facts.js';
+/**
+ * The frame wording of a profile that declares none — the heading and the
+ * empty state 0.43 showed for every frame, before a framework could name its
+ * own.
+ *
+ * Owned by the ENGINE rather than by Wardley, whose words they also are,
+ * because a host profile written against 0.43 reads with them too: declared in
+ * a framework bundle, they would vanish from a host that does not install it.
+ * Wardley's profile declares no wording and inherits these.
+ *
+ * Spelled as `[key, English]` rows, the form the key manifest walks and its
+ * drift check pairs with this declaration, then read as a profile's wording.
+ */
+const READING_FRAME_DEFAULT_LABEL = [
+    'com.labre.reading.field.phase',
+    'Evolution phase',
+];
+const READING_FRAME_DEFAULT_NONE = [
+    'com.labre.reading.phase.none',
+    'Not on a framework background — no phase to read.',
+];
+/** The default frame wording, as the rows the key manifest walks. */
+export const READING_FRAME_WORDINGS = [
+    READING_FRAME_DEFAULT_LABEL,
+    READING_FRAME_DEFAULT_NONE,
+];
+const asFrameWording = ([labelKey, labelFallback,]) => ({ labelKey, labelFallback });
+/** The default frame wording, as a profile's `frame.label` / `frame.none`. */
+export const READING_FRAME_DEFAULT_WORDING = {
+    label: asFrameWording(READING_FRAME_DEFAULT_LABEL),
+    none: asFrameWording(READING_FRAME_DEFAULT_NONE),
+};
+/**
+ * The two wordings the panel reads a frame with: the framework's own where it
+ * declares them, {@link READING_FRAME_DEFAULT_WORDING} where it does not.
+ */
+export function readingFrameWording(frame) {
+    return {
+        label: frame.label ?? READING_FRAME_DEFAULT_WORDING.label,
+        none: frame.none ?? READING_FRAME_DEFAULT_WORDING.none,
+    };
+}
 /**
  * Every relation table a profile declares, in reading order.
  *
@@ -102,8 +144,11 @@ function groupMembers(element) {
  * is the same fact `tags-toolbar.ts` works around from the other direction: one
  * click selects the group, the role lives on the circle, and the name lives on
  * a free text beside it.
+ *
+ * Exported for the selection pane, which names its rows the same way (ADR 0031
+ * §12): one rule for "what is this element called", not two.
  */
-function readName(element, profile) {
+export function readName(element, profile) {
     const own = ownText(element);
     if (own)
         return own;
@@ -168,13 +213,37 @@ function frameOf(element, elements, profile) {
         roleIsA(candidate.role, frame.backgroundRole, profile.roles)), candidate => candidate.elementBound);
 }
 /**
- * The phase, read from the position and the frame's DECLARED zones.
+ * How a zone is named, as the BOARD names it: the user's own words first — a
+ * renamed label stored on the frame, a lane's name — then the vocabulary.
  *
- * Two facts, both taken from the declaration and never from a number in this
- * file: which zone the subject's centre falls in, and whether it is inside the
- * band around a transition. The second is the "zone of punctuated equilibrium"
- * — the frontier is a region, not a coordinate — and a component sitting in one
- * is a different statement from a component sitting in a phase.
+ * The same precedence `backgroundLabelText` paints with, minus the translation:
+ * the reading carries the key and the panel resolves it, so the record and the
+ * drift comparison keep working on the vocabulary.
+ */
+function zoneWording(zone, model) {
+    const label = zone.label;
+    const stored = label?.prop !== undefined ? model[label.prop] : undefined;
+    const name = stored !== undefined && stored !== null ? String(stored) : zone.name;
+    return {
+        ...(label?.labelKey !== undefined ? { labelKey: label.labelKey } : {}),
+        ...(label?.fallback !== undefined ? { labelFallback: label.fallback } : {}),
+        ...(name !== undefined ? { name } : {}),
+    };
+}
+/**
+ * The zone, read from the position and the zones the frame INSTANCE has
+ * ({@link backgroundZones}: the framework's in the instance's variant, then the
+ * instance's own).
+ *
+ * Along an axis (Wardley), two facts, both taken from the declaration and never
+ * from a number in this file: which zone the subject's centre falls in, and
+ * whether it is inside the band around a transition. The second is the "zone of
+ * punctuated equilibrium" — the frontier is a region, not a coordinate — and a
+ * component sitting in one is a different statement from a component sitting in
+ * a phase.
+ *
+ * In the plane (no `axis`: a Core Domain Chart, a BPMN pool), the zone whose
+ * rectangle holds the centre, through the helper the audit uses, and no band.
  */
 function readPhase(element, elements, profile) {
     const frame = profile.frame;
@@ -185,11 +254,25 @@ function readPhase(element, elements, profile) {
         return undefined;
     const def = frame.background;
     const bound = background.elementBound;
+    const model = background;
+    const zones = backgroundZones(def, model);
+    const axis = frame.axis;
+    if (axis === undefined) {
+        const at = backgroundPlotRatios(def, bound, element.elementBound);
+        const zone = at === null ? undefined : backgroundZoneAt(zones, at);
+        if (!zone)
+            return undefined;
+        return {
+            zoneId: zone.id,
+            ...zoneWording(zone, model),
+            inTransitionBand: false,
+        };
+    }
     const plot = backgroundPlot(def, bound.w, bound.h);
     const [cx, cy] = centreOf(element.elementBound);
-    const along = frame.axis === 'x' ? cx : cy;
-    const origin = frame.axis === 'x' ? bound.x + plot.x0 : bound.y + plot.y0;
-    const span = frame.axis === 'x' ? plot.width : plot.height;
+    const along = axis === 'x' ? cx : cy;
+    const origin = axis === 'x' ? bound.x + plot.x0 : bound.y + plot.y0;
+    const span = axis === 'x' ? plot.width : plot.height;
     if (!(span > 0))
         return undefined;
     const ratio = (along - origin) / span;
@@ -198,25 +281,20 @@ function readPhase(element, elements, profile) {
     // phase it is visibly not in.
     if (ratio < 0 || ratio > 1)
         return undefined;
-    const zone = (def.zones ?? []).find(({ rect }) => {
-        const start = frame.axis === 'x' ? rect.x : rect.y;
-        const size = frame.axis === 'x' ? rect.w : rect.h;
+    const zone = zones.find(({ rect }) => {
+        const start = axis === 'x' ? rect.x : rect.y;
+        const size = axis === 'x' ? rect.w : rect.h;
         // Half-open, so a component exactly on a divider reads as the phase it is
         // entering — the same side the band below reports as the frontier.
         return ratio >= start && (ratio < start + size || start + size >= 1);
     });
     if (!zone)
         return undefined;
-    const bands = backgroundTransitionBands(def, bound)[frame.axis];
+    const bands = backgroundTransitionBands(def, bound)[axis];
     const band = bands.find(({ min, max }) => along >= min && along <= max);
     return {
         zoneId: zone.id,
-        ...(zone.label?.labelKey !== undefined
-            ? { labelKey: zone.label.labelKey }
-            : {}),
-        ...(zone.label?.fallback !== undefined
-            ? { labelFallback: zone.label.fallback }
-            : {}),
+        ...zoneWording(zone, model),
         inTransitionBand: band !== undefined,
         ...(band !== undefined ? { bandId: band.id } : {}),
     };

package/dist/_pkgs/affine-block-surface/extensions/selection-pane/actions.d.ts

@@ -0,0 +1,80 @@
+import type { BlockStdScope } from '../../../std/index.js';
+import type { SelectionPaneNode } from './tree.js';
+/**
+ * Move `id` so it sits directly ABOVE `above` in the stack — `null` puts it at
+ * the bottom of its stack. Answers whether anything was written.
+ *
+ * The drop target of a drag in a top-first list: dropping a row just over row
+ * X means "directly above X". The new `index` is a key between the two
+ * neighbours (the same `fractional-indexing` keys `LayerManager` generates), so
+ * one field of one model is written and nothing else moves.
+ *
+ * Refused, with nothing written: a read-only document; a mindmap node (it has
+ * no index of its own — the whole mindmap moves as one, as the toolbar's
+ * reorder already says); an `above` that is not stacked with `id`; and a
+ * target that is where the model already is.
+ */
+export declare function reorderPaneElement(std: BlockStdScope, id: string, above: string | null): boolean;
+/**
+ * Lock or unlock each model ON ITS OWN. Answers whether anything was written.
+ *
+ * Deliberately not the contextual toolbar's lock: that one, given several
+ * elements, wraps them into a new group and locks the group — a structural
+ * edit a row's padlock must never make. Here each row keeps its place in the
+ * tree; only `lockedBySelf` changes, and only where it differs.
+ */
+export declare function setPaneElementsLocked(std: BlockStdScope, ids: readonly string[], locked: boolean): boolean;
+/**
+ * Hide models for EVERYONE, or show them again (ADR 0031 §7). Answers how
+ * many models were written.
+ *
+ * Writes the stored `hiddenForEveryone` — never `hidden`, which mindmap
+ * collapse owns. Hiding writes `true`; showing REMOVES the key (`clearField`
+ * on an element, the props proxy's delete on a block), never stores `false`,
+ * so an unhidden document is byte-identical to one never hidden. Models
+ * already in the asked state are skipped, so a gesture that changes nothing
+ * writes nothing and pushes no undo step; the rest go in one transaction
+ * after one `captureSync()`.
+ */
+export declare function setPaneElementsHiddenForEveryone(std: BlockStdScope, ids: readonly string[], hidden: boolean): number;
+/**
+ * Rename a group through its existing stored `title`. Answers whether
+ * anything was written. An empty or unchanged title writes nothing.
+ */
+export declare function renamePaneGroup(std: BlockStdScope, id: string, title: string): boolean;
+/**
+ * Rename a frame through its existing stored `title`, edited in place — the
+ * `Text` the frame's own title editor binds to, never a replaced one, so an
+ * open title editor keeps its binding. Answers whether anything was written.
+ * An empty or unchanged title writes nothing.
+ */
+export declare function renamePaneFrame(std: BlockStdScope, id: string, title: string): boolean;
+/** Something the pane can be filtered by: a frame, and only a frame. */
+export interface SelectionPaneFilterTarget {
+    id: string;
+    /**
+     * Always `'frame'`. A framework board was offered too until the product
+     * owner's review narrowed the filter to frames (ADR 0031, amendments); the
+     * field stays so a host reading it has nothing to change.
+     */
+    kind: 'frame';
+}
+/** The frames on the canvas, top first — what the pane's filter offers. */
+export declare function selectionPaneFilterTargets(std: BlockStdScope): SelectionPaneFilterTarget[];
+/**
+ * The ids a frame filter keeps: the frame itself — a row like any other, so
+ * the list keeps showing what it is filtered by (ADR 0031, amendments) — its
+ * `childElementIds` and their descendants. `null` for an id that is not a
+ * frame.
+ */
+export declare function selectionPaneFilterMembers(std: BlockStdScope, targetId: string): Set<string> | null;
+/**
+ * The tree narrowed to `members`: a row is kept when it is a member or holds
+ * one, so a group reaching into a frame stays as the path to its member.
+ *
+ * A LAYER row is always kept, its children narrowed (ADR 0031, amendments): a
+ * layer is where new elements land and where a drop goes, not something a
+ * frame holds, and a layer created under a filter that hid it read as a
+ * "New layer" button doing nothing.
+ */
+export declare function filterSelectionPaneTree(nodes: readonly SelectionPaneNode[], members: ReadonlySet<string>): SelectionPaneNode[];