@formicoidea/labre-core 0.42.0 → 0.45.0

package/dist/_pkgs/data-view/view-presets/table/pc-virtual/controller/selection.js

@@ -859,7 +859,7 @@ let SelectionElement = (() => {
                     height: `${focus.height}px`,
                     display: 'block',
                     boxShadow: focus.editing
-                        ? '0px 0px 0px 2px rgba(30, 150, 235, 0.30)'
+                        ? '0px 0px 0px 2px color-mix(in srgb, var(--affine-primary-color) 30%, transparent)'
                         : 'unset',
                 })
                 : undefined;

package/dist/_pkgs/data-view/view-presets/table/pc-virtual/group/top/header/vertical-indicator.js

@@ -101,7 +101,8 @@ let TableVerticalIndicator = (() => {
     }
 
     .with-shadow.vertical-indicator::after {
-      box-shadow: 0px 0px 8px 0px rgba(30, 150, 235, 0.35);
+      box-shadow: 0px 0px 8px 0px
+        color-mix(in srgb, var(--affine-primary-color) 35%, transparent);
     }
   `; }
         render() {

package/dist/_pkgs/data-view/view-presets/table/pc-virtual/row/row-header.js

@@ -138,7 +138,9 @@ let TableRowHeader = (() => {
       <div @click=${this.selectRow} class="${styles.checkboxWrapper}">
         <div class="${classString}">
           ${this.rowSelected$.value
-                    ? CheckBoxCheckSolidIcon({ style: `color:#1E96EB` })
+                    ? CheckBoxCheckSolidIcon({
+                        style: `color:var(--affine-primary-color)`,
+                    })
                     : CheckBoxUnIcon()}
         </div>
       </div>

package/dist/_pkgs/std/gfx/controller.d.ts

@@ -8,6 +8,7 @@ import type { CursorType } from './cursor.js';
 import { GridManager } from './grid.js';
 import { KeyboardController } from './keyboard.js';
 import { LayerManager } from './layer.js';
+import { GfxHiddenForEveryone, GfxLocalVisibility } from './local-visibility.js';
 import type { PointTestOptions } from './model/base.js';
 import { GfxBlockElementModel } from './model/gfx-block-model.js';
 import type { GfxModel } from './model/model.js';
@@ -20,6 +21,18 @@ export declare class GfxController extends LifeCycleWatcher {
     private readonly _surface$;
     readonly cursor$: Signal<CursorType>;
     readonly keyboard: KeyboardController;
+    /**
+     * What this viewer has hidden on the canvas (ADR 0031 §8). Read by the
+     * renderers, the DOM block views, pointer picking and the marquee — never by
+     * `grid.search`, whose answer rules and legends share.
+     */
+    readonly localVisibility: GfxLocalVisibility;
+    /**
+     * The ids hidden for everyone (ADR 0031 §7), followed on the surface and
+     * the store and registered into {@link localVisibility}: what nobody sees
+     * is, a fortiori, not seen by this viewer.
+     */
+    readonly hiddenForEveryone: GfxHiddenForEveryone;
     readonly viewport: Viewport;
     get grid(): GridManager;
     get layer(): LayerManager;

package/dist/_pkgs/std/gfx/controller.js

@@ -10,6 +10,7 @@ import { GridManager } from './grid.js';
 import { gfxControllerKey } from './identifiers.js';
 import { KeyboardController } from './keyboard.js';
 import { LayerManager } from './layer.js';
+import { GfxHiddenForEveryone, GfxLocalVisibility, } from './local-visibility.js';
 import { GfxBlockElementModel } from './model/gfx-block-model.js';
 import { GfxPrimitiveElementModel } from './model/surface/element-model.js';
 import { FIT_TO_SCREEN_PADDING, Viewport, ZOOM_INITIAL } from './viewport.js';
@@ -46,11 +47,27 @@ export class GfxController extends LifeCycleWatcher {
         this._disposables = new DisposableGroup();
         this._surface$ = new Signal(null);
         this.cursor$ = new Signal();
+        /**
+         * What this viewer has hidden on the canvas (ADR 0031 §8). Read by the
+         * renderers, the DOM block views, pointer picking and the marquee — never by
+         * `grid.search`, whose answer rules and legends share.
+         */
+        this.localVisibility = new GfxLocalVisibility();
+        /**
+         * The ids hidden for everyone (ADR 0031 §7), followed on the surface and
+         * the store and registered into {@link localVisibility}: what nobody sees
+         * is, a fortiori, not seen by this viewer.
+         */
+        this.hiddenForEveryone = new GfxHiddenForEveryone();
         this.viewport = new Viewport();
         this.keyboard = new KeyboardController(std);
         this._disposables.add(onSurfaceAdded(this.doc, surface => {
             this._surface$.value = surface;
+            this.hiddenForEveryone.watch(this.doc, surface);
         }));
+        this._disposables.add(this.localVisibility.register(this.hiddenForEveryone.ids$));
+        this._disposables.add(this.localVisibility.registerLayers(this.hiddenForEveryone.layerIds$));
+        this._disposables.add(() => this.hiddenForEveryone.dispose());
         this._disposables.add(this.viewport);
         this._disposables.add(this.keyboard);
         this.std.provider.getAll(GfxClassExtenderIdentifier).forEach(ext => {
@@ -94,8 +111,11 @@ export class GfxController extends LifeCycleWatcher {
             h: responsePadding[1] * 2,
         };
         const candidates = this.grid.search(hitTestBound);
-        const picked = candidates.filter(elm => elm.includesPoint(x, y, options, this.std.host) ||
-            elm.externalBound?.isPointInBound([x, y]));
+        // A model this viewer hid is not under the pointer: it is not painted,
+        // so it cannot be what the user aims at (ADR 0031 §8).
+        const picked = candidates.filter(elm => !this.localVisibility.isHidden(elm) &&
+            (elm.includesPoint(x, y, options, this.std.host) ||
+                elm.externalBound?.isPointInBound([x, y])));
         picked.sort(this.layer.compare);
         if (all) {
             return picked;

package/dist/_pkgs/std/gfx/grid.d.ts

@@ -45,8 +45,37 @@ export declare class GridManager extends GfxExtension {
     remove(element: GfxModel | GfxLocalElementModel): void;
     /**
      * Search for elements in a bound.
-     * @param bound
-     * @param options
+     *
+     * Skips the stored `hidden` (mindmap collapse) and NOTHING ELSE, on purpose:
+     * this answer is shared by painting, picking AND logic — rules, legends,
+     * semantic exports — and a viewer's local hide must never change what
+     * another viewer's rules or legend say about the same document (ADR 0031
+     * §8). A new visibility is applied by the consumer, never added here.
+     *
+     * Caller audit (ADR 0031 §9; the row of its table each caller belongs to):
+     *
+     * - paint — the canvas renderer's bound pass (`_renderByBound`, which also
+     *   paints the SVG export and the PNG export's canvas layer) and the DOM
+     *   renderer's two passes: filter through the shared paint predicate
+     *   (`isPainted`, `affine-block-surface/renderer/paint-predicate.ts`).
+     * - paint, blocks — `gfx-viewport`'s `getModelsInViewport` in the edgeless
+     *   root and its preview: which DOM blocks to mount; a block's own
+     *   visibility is its view's business.
+     * - picking — `GfxController.getElementByPoint` and every caller of it
+     *   (selection, hover highlights, frame highlight, peek, connector reveal,
+     *   mindmap drag, pan, text tools, element link, spotlight).
+     * - marquee — `GfxController.getElementsByBound` from
+     *   `InteractivityManager.handleBoxSelection`.
+     * - export — `getElementsByBound` from the PNG export (`ExportManager`),
+     *   the SVG board export (`renderBoardSvg`) and copy-as-PNG
+     *   (`EdgelessClipboardController`'s canvas path).
+     * - logic, keeps every visibility — `getElementsByBound` from the legend
+     *   (`rolesInBound`, the legend redraw), and the surface-ref slash menu's
+     *   free-space search (a hidden element still takes its room).
+     * - pointer-adjacent, no row in the table yet, keeps every visibility today
+     *   — the connector tool's connectable targets in view and the snap
+     *   overlay's alignment candidates: a connector may still attach to, and a
+     *   drag still snap to, an element the viewer hid.
      */
     search<T extends BuiltInFilterType = 'canvas' | 'block'>(bound: IBound, options?: {
         /**

package/dist/_pkgs/std/gfx/index.d.ts

@@ -10,12 +10,14 @@ export { GfxControllerIdentifier } from './identifiers.js';
 export type { BoxSelectionContext, DragEndContext, DragExtensionInitializeContext, DragInitializationOption, DragMoveContext, DragStartContext, ExtensionDragEndContext, ExtensionDragMoveContext, ExtensionDragStartContext, GfxInteractivityContext, GfxViewInteractionConfig, ResizeConstraint, ResizeEndContext, ResizeHandle, ResizeMoveContext, ResizeStartContext, RotateConstraint, RotateEndContext, RotateMoveContext, RotateStartContext, SelectContext, } from './interactivity/index.js';
 export { GfxViewEventManager, GfxViewInteractionExtension, InteractivityExtension, InteractivityIdentifier, InteractivityManager, } from './interactivity/index.js';
 export { LayerManager, type ReorderingDirection } from './layer.js';
+export { GfxHiddenForEveryone, GfxLocalVisibility, } from './local-visibility.js';
 export type { GfxCompatibleInterface, GfxElementGeometry, GfxGroupCompatibleInterface, PointTestOptions, } from './model/base.js';
 export { gfxGroupCompatibleSymbol, isGfxGroupCompatibleModel, } from './model/base.js';
 export { GfxBlockElementModel, type GfxCommonBlockProps, GfxCompatibleBlockModel as GfxCompatible, type GfxCompatibleProps, } from './model/gfx-block-model.js';
 export { type GfxModel, isPrimitiveModel } from './model/model.js';
 export { convert, convertProps, derive, field, getDerivedProps, getFieldPropsSet, getLocalPropsSet, initializeObservers, initializeWatchers, local, observe, updateDerivedProps, watch, } from './model/surface/decorators/index.js';
-export { type BaseElementProps, type ForeignInterchange, type InterchangeScope, GfxGroupLikeElementModel, GfxPrimitiveElementModel, type SerializedElement, type ValidationException, } from './model/surface/element-model.js';
+export { type BaseElementProps, type ForeignInterchange, type InterchangeScope, GfxGroupLikeElementModel, GfxPrimitiveElementModel, isStoredHiddenForEveryone, type SerializedElement, type ValidationException, } from './model/surface/element-model.js';
+export { DEFAULT_LAYER_ID, layerCarrierOf, ownLayerOf, type SurfaceLayerRecord, SurfaceUserLayers, } from './model/surface/user-layers.js';
 export { GfxLocalElementModel, prop, } from './model/surface/local-element-model.js';
 export { collectPivotOccurrences, isPivotBound, type PivotBoundElement, type PivotOccurrence, resolvePivotBinding, } from './model/surface/pivot.js';
 export { type EdgeDirectionDef, findRoleDef, isTypedEdgeRole, type RoleDef, type RoleDefs, type RoleId, roleIsA, type RoleKind, RoleVocabularyExtension, RoleVocabularyIdentifier, } from './model/surface/role.js';

package/dist/_pkgs/std/gfx/index.js

@@ -8,11 +8,13 @@ export { DEFAULT_HIGHLIGHT_DURATION, DEFAULT_HIGHLIGHT_PADDING, ElementHighlight
 export { GfxControllerIdentifier } from './identifiers.js';
 export { GfxViewEventManager, GfxViewInteractionExtension, InteractivityExtension, InteractivityIdentifier, InteractivityManager, } from './interactivity/index.js';
 export { LayerManager } from './layer.js';
+export { GfxHiddenForEveryone, GfxLocalVisibility, } from './local-visibility.js';
 export { gfxGroupCompatibleSymbol, isGfxGroupCompatibleModel, } from './model/base.js';
 export { GfxBlockElementModel, GfxCompatibleBlockModel as GfxCompatible, } from './model/gfx-block-model.js';
 export { isPrimitiveModel } from './model/model.js';
 export { convert, convertProps, derive, field, getDerivedProps, getFieldPropsSet, getLocalPropsSet, initializeObservers, initializeWatchers, local, observe, updateDerivedProps, watch, } from './model/surface/decorators/index.js';
-export { GfxGroupLikeElementModel, GfxPrimitiveElementModel, } from './model/surface/element-model.js';
+export { GfxGroupLikeElementModel, GfxPrimitiveElementModel, isStoredHiddenForEveryone, } from './model/surface/element-model.js';
+export { DEFAULT_LAYER_ID, layerCarrierOf, ownLayerOf, SurfaceUserLayers, } from './model/surface/user-layers.js';
 export { GfxLocalElementModel, prop, } from './model/surface/local-element-model.js';
 export { collectPivotOccurrences, isPivotBound, resolvePivotBinding, } from './model/surface/pivot.js';
 export { findRoleDef, isTypedEdgeRole, roleIsA, RoleVocabularyExtension, RoleVocabularyIdentifier, } from './model/surface/role.js';

package/dist/_pkgs/std/gfx/interactivity/manager.js

@@ -225,6 +225,10 @@ export class InteractivityManager extends GfxExtension {
     }
     handleBoxSelection(context) {
         const elements = this.gfx.getElementsByBound(context.box).filter(model => {
+            // The marquee takes what the viewer sees: a locally hidden model is
+            // left out (ADR 0031 §8). The selection pane still selects it.
+            if (this.gfx.localVisibility.isHidden(model))
+                return false;
             const view = this.gfx.view.get(model);
             if (!view ||
                 view.onBoxSelected({
@@ -283,6 +287,9 @@ export class InteractivityManager extends GfxExtension {
             onDragMove(lastEvent);
         });
         const onDragMove = (event) => {
+            // The viewport watcher replays the latest pointer position; without
+            // this it replayed the drag start and snapped the elements back.
+            lastEvent = event;
             dragLastPos = Point.from(this.gfx.viewport.toModelCoordFromClientCoord([event.x, event.y]));
             const moveContext = {
                 ...internal,

package/dist/_pkgs/std/gfx/layer.js

@@ -220,11 +220,22 @@ export class LayerManager extends GfxExtension {
                     layerElements[0],
                     last(layerElements),
                 ], target)) {
-                    const insertIdx = layerElements.findIndex((_, idx) => {
-                        const pre = layerElements[idx - 1];
-                        return (compare(target, layerElements[idx]) < 0 &&
-                            (!pre || compare(target, pre) >= 0));
-                    });
+                    // The first element `target` sorts before. The layer is sorted and
+                    // `target` is in its range, so that position is found by bisection
+                    // rather than by comparing `target` with every element: a frame
+                    // adopting N children re-inserted each of them, N² comparisons.
+                    let low = 0;
+                    let high = layerElements.length;
+                    while (low < high) {
+                        const mid = (low + high) >>> 1;
+                        if (compare(target, layerElements[mid]) < 0) {
+                            high = mid;
+                        }
+                        else {
+                            low = mid + 1;
+                        }
+                    }
+                    const insertIdx = low;
                     if (layer.type === type) {
                         addToLayer(layer, target, insertIdx);
                         updateLayersZIndex(layers, cur);
@@ -468,6 +479,31 @@ export class LayerManager extends GfxExtension {
      * @returns
      */
     generateIndex(reverse = false) {
+        // With user layers the paint order is layer rank first (ADR 0031 §4), so
+        // the first and last runs no longer hold the lowest and highest `index`.
+        // "Above everything" must still mean above every key, which, rank first,
+        // is the top of whichever layer the new element lands in.
+        // Every model is scanned, not the runs' edges: a run can span two user
+        // layers, and the lower layer's highest key then sits mid-run.
+        if (this._surface?.userLayers.ranks) {
+            let lowest = null;
+            let highest = null;
+            for (const model of [...this.canvasElements, ...this.blocks]) {
+                const index = model.index;
+                if (typeof index !== 'string')
+                    continue;
+                if (lowest === null || index < lowest)
+                    lowest = index;
+                if (highest === null || index > highest)
+                    highest = index;
+            }
+            if (lowest === null || highest === null) {
+                return LayerManager.INITIAL_INDEX;
+            }
+            return reverse
+                ? generateKeyBetween(null, lowest)
+                : generateKeyBetween(highest, null);
+        }
         if (reverse) {
             const firstIndex = this.layers[0]?.indexes[0];
             return firstIndex
@@ -493,6 +529,13 @@ export class LayerManager extends GfxExtension {
         }
         else {
             elements = this.layers.reduce((pre, current) => pre.concat(current.elements.filter(element => element.group == null)), []);
+            // Forward / backward / front / back move an element WITHIN its user
+            // layer (ADR 0031 §4): its neighbours are that layer's members only.
+            const userLayers = this._surface?.userLayers;
+            if (userLayers?.ranks) {
+                const own = userLayers.effectiveLayerOf(element);
+                elements = elements.filter(other => userLayers.effectiveLayerOf(other) === own);
+            }
         }
         const currentIdx = elements.indexOf(element);
         switch (direction) {
@@ -553,6 +596,13 @@ export class LayerManager extends GfxExtension {
             }
             if (payload.type === 'update') {
                 const block = store.getModelById(payload.id);
+                // A block moved to another user layer (ADR 0031 §3) stacks
+                // elsewhere: re-sort it as if its `index` changed.
+                if (payload.props.key === 'layer' &&
+                    block instanceof GfxBlockElementModel &&
+                    this.blocks.includes(block)) {
+                    this.update(block);
+                }
                 if ((payload.props.key === 'index' ||
                     payload.props.key === 'childElementIds') &&
                     block instanceof GfxBlockElementModel &&
@@ -599,6 +649,24 @@ export class LayerManager extends GfxExtension {
                 if (payload.props['index'] || payload.props['childIds']) {
                     this.update(surface.getElementById(payload.id), payload.props);
                 }
+                else if ('layer' in payload.props || 'layer' in payload.oldValues) {
+                    // Moved to another user layer (ADR 0031 §3), set or cleared:
+                    // re-sort as an `index` change would (a group re-sorts whole).
+                    const element = surface.getElementById(payload.id);
+                    if (element)
+                        this.update(element);
+                }
+            }));
+            // The layer list changed — created, reordered, removed (ADR 0031 §2):
+            // every rank may have moved, so the whole order is rebuilt.
+            this._disposable.add(surface.propsUpdated.subscribe(({ key }) => {
+                if (key !== 'layers')
+                    return;
+                this._reset();
+                this.slots.layerUpdated.next({
+                    type: 'update',
+                    initiatingElement: surface,
+                });
             }));
             this._disposable.add(surface.elementRemoved.subscribe(payload => this.delete(payload.model)));
             this._disposable.add(surface.localElementAdded.subscribe(elm => {

package/dist/_pkgs/std/gfx/local-visibility.d.ts

@@ -0,0 +1,88 @@
+import type { Store } from '../../store/index.js';
+import { type ReadonlySignal } from '@preact/signals-core';
+import type { GfxLocalElementModel } from './model/surface/local-element-model.js';
+import type { GfxModel } from './model/model.js';
+import type { SurfaceBlockModel } from './model/surface/surface-model.js';
+/**
+ * The ids of the elements and gfx blocks hidden for everyone (ADR 0031 §7) —
+ * the SHARED half of the paint and pick predicate, kept as a set so the
+ * renderers ask one `has` per element and pay nothing when nobody hid
+ * anything.
+ *
+ * Built from the document once per surface, then kept current by the
+ * surface's element events and the store's block events, local or remote
+ * alike: a peer's "hide for everyone" reaches this viewer the moment its
+ * update does. Registered by `GfxController` into its
+ * {@link GfxLocalVisibility}, beside the viewer's own local hide, so every
+ * site that already skips what this viewer hid skips this too — and
+ * `grid.search`, which reads neither, keeps counting both.
+ */
+export declare class GfxHiddenForEveryone {
+    private readonly _ids$;
+    private readonly _layerIds$;
+    private _unwatch;
+    /** Every id carrying the stored `hiddenForEveryone`. */
+    get ids$(): ReadonlySignal<ReadonlySet<string>>;
+    /**
+     * Every user layer hidden for everyone — `hidden: true` on its record (ADR
+     * 0031 §7): one write for a whole layer, never one per member.
+     */
+    get layerIds$(): ReadonlySignal<ReadonlySet<string>>;
+    /** Follow `surface` and `store`; `null` stops following. */
+    watch(store: Store, surface: SurfaceBlockModel | null): void;
+    dispose(): void;
+}
+/**
+ * What THIS viewer does not see on the canvas — the per-editor predicate hook
+ * of ADR 0031 §8.
+ *
+ * `std` knows nothing about why an element is hidden for one viewer; the
+ * affine layer (`CanvasLocalVisibility`) registers a signal of ids and owns
+ * their persistence. `GfxController` registers one more source, the ids
+ * hidden for everyone ({@link GfxHiddenForEveryone}): the shared half of the
+ * same predicate, so the sites below skip both with one question. Layers
+ * have their own sources (`registerLayers`), local and shared alike: a model
+ * whose EFFECTIVE layer is hidden is hidden. This class answers the one
+ * question the gfx plumbing asks — "does this viewer see that model?" — at the places a viewer's eye
+ * and hand reach the canvas: the renderers, the DOM block views, pointer
+ * picking and the marquee.
+ *
+ * It is deliberately NOT consulted by `GridManager.search`: that answer is
+ * shared with rules, legends and semantic exports, and one viewer's local
+ * hide must never change what another viewer's rules say about the same
+ * document.
+ *
+ * Reactive: `isHidden` reads a signal, so an effect or a `computed` that asks
+ * re-runs when the set changes (the DOM block views rely on it). With nothing
+ * registered, or nothing hidden, every answer is `false` after one size check.
+ */
+export declare class GfxLocalVisibility {
+    private readonly _sources$;
+    /** Every id hidden for this viewer, across every registered source. */
+    readonly hiddenIds$: ReadonlySignal<ReadonlySet<string>>;
+    private readonly _layerSources$;
+    /** Every user layer hidden for this viewer, across every layer source. */
+    readonly hiddenLayerIds$: ReadonlySignal<ReadonlySet<string>>;
+    /** Add a source of hidden ids. Returns its disposer. */
+    register(source: ReadonlySignal<ReadonlySet<string>>): () => void;
+    /** Add a source of hidden LAYER ids (ADR 0031, stage 7). Returns its disposer. */
+    registerLayers(source: ReadonlySignal<ReadonlySet<string>>): () => void;
+    /**
+     * Is `model` hidden for this viewer — itself, or through a group-like
+     * ELEMENT ancestor (a group, a mindmap)?
+     *
+     * Frames are not walked, although they are group-compatible: a frame is a
+     * slide, and hiding the frame hides the frame, not what it holds (ADR 0031
+     * §5). A model no surface holds has no ancestors to ask about.
+     */
+    isHidden(model: GfxModel | GfxLocalElementModel): boolean;
+    /**
+     * Whether `model`'s EFFECTIVE layer is one of `layers` — the outermost
+     * group's layer, so a whole group hides with its layer. A hidden frame's
+     * layer hides the frame, not what it holds (ADR 0031 §5). Local elements
+     * belong to no layer. A surface with no `layers` record still has the
+     * default layer, shown and hideable before it is recorded (ADR 0031
+     * amendments): every model is then in it.
+     */
+    private _inHiddenLayer;
+}

package/dist/_pkgs/std/gfx/local-visibility.js

@@ -0,0 +1,217 @@
+import { computed, signal } from '@preact/signals-core';
+import { GfxBlockElementModel } from './model/gfx-block-model.js';
+import { GfxPrimitiveElementModel, isStoredHiddenForEveryone, } from './model/surface/element-model.js';
+import { userLayersOf } from './model/surface/user-layers.js';
+const NOTHING_HIDDEN = new Set();
+/**
+ * The ids of the elements and gfx blocks hidden for everyone (ADR 0031 §7) —
+ * the SHARED half of the paint and pick predicate, kept as a set so the
+ * renderers ask one `has` per element and pay nothing when nobody hid
+ * anything.
+ *
+ * Built from the document once per surface, then kept current by the
+ * surface's element events and the store's block events, local or remote
+ * alike: a peer's "hide for everyone" reaches this viewer the moment its
+ * update does. Registered by `GfxController` into its
+ * {@link GfxLocalVisibility}, beside the viewer's own local hide, so every
+ * site that already skips what this viewer hid skips this too — and
+ * `grid.search`, which reads neither, keeps counting both.
+ */
+export class GfxHiddenForEveryone {
+    constructor() {
+        this._ids$ = signal(NOTHING_HIDDEN);
+        this._layerIds$ = signal(NOTHING_HIDDEN);
+        this._unwatch = null;
+    }
+    /** Every id carrying the stored `hiddenForEveryone`. */
+    get ids$() {
+        return this._ids$;
+    }
+    /**
+     * Every user layer hidden for everyone — `hidden: true` on its record (ADR
+     * 0031 §7): one write for a whole layer, never one per member.
+     */
+    get layerIds$() {
+        return this._layerIds$;
+    }
+    /** Follow `surface` and `store`; `null` stops following. */
+    watch(store, surface) {
+        this.dispose();
+        if (!surface)
+            return;
+        const initial = new Set();
+        for (const element of surface.elementModels) {
+            if (isStoredHiddenForEveryone(element))
+                initial.add(element.id);
+        }
+        for (const model of store.getAllModels()) {
+            if (model instanceof GfxBlockElementModel &&
+                isStoredHiddenForEveryone(model)) {
+                initial.add(model.id);
+            }
+        }
+        this._ids$.value = initial.size ? initial : NOTHING_HIDDEN;
+        const readLayers = () => {
+            const hidden = new Set();
+            for (const [id, record] of Object.entries(surface.props.layers ?? {})) {
+                if (record?.hidden === true)
+                    hidden.add(id);
+            }
+            const current = this._layerIds$.peek();
+            if (hidden.size === current.size &&
+                [...hidden].every(id => current.has(id))) {
+                return;
+            }
+            this._layerIds$.value = hidden.size ? hidden : NOTHING_HIDDEN;
+        };
+        readLayers();
+        const recheck = (id, model) => {
+            const hidden = model !== null && isStoredHiddenForEveryone(model);
+            const current = this._ids$.peek();
+            if (current.has(id) === hidden)
+                return;
+            const next = new Set(current);
+            if (hidden)
+                next.add(id);
+            else
+                next.delete(id);
+            this._ids$.value = next.size ? next : NOTHING_HIDDEN;
+        };
+        const subscriptions = [
+            surface.propsUpdated.subscribe(({ key }) => {
+                if (key === 'layers')
+                    readLayers();
+            }),
+            surface.elementAdded.subscribe(({ id }) => recheck(id, surface.getElementById(id))),
+            surface.elementUpdated.subscribe(({ id }) => recheck(id, surface.getElementById(id))),
+            surface.elementRemoved.subscribe(({ id }) => recheck(id, null)),
+            store.slots.blockUpdated.subscribe(payload => {
+                if (payload.type === 'delete') {
+                    recheck(payload.id, null);
+                    return;
+                }
+                if (payload.type === 'update' &&
+                    payload.props.key !== 'hiddenForEveryone') {
+                    return;
+                }
+                recheck(payload.id, store.getBlock(payload.id)?.model ?? null);
+            }),
+        ];
+        this._unwatch = () => subscriptions.forEach(sub => sub.unsubscribe());
+    }
+    dispose() {
+        this._unwatch?.();
+        this._unwatch = null;
+        this._ids$.value = NOTHING_HIDDEN;
+        this._layerIds$.value = NOTHING_HIDDEN;
+    }
+}
+/**
+ * What THIS viewer does not see on the canvas — the per-editor predicate hook
+ * of ADR 0031 §8.
+ *
+ * `std` knows nothing about why an element is hidden for one viewer; the
+ * affine layer (`CanvasLocalVisibility`) registers a signal of ids and owns
+ * their persistence. `GfxController` registers one more source, the ids
+ * hidden for everyone ({@link GfxHiddenForEveryone}): the shared half of the
+ * same predicate, so the sites below skip both with one question. Layers
+ * have their own sources (`registerLayers`), local and shared alike: a model
+ * whose EFFECTIVE layer is hidden is hidden. This class answers the one
+ * question the gfx plumbing asks — "does this viewer see that model?" — at the places a viewer's eye
+ * and hand reach the canvas: the renderers, the DOM block views, pointer
+ * picking and the marquee.
+ *
+ * It is deliberately NOT consulted by `GridManager.search`: that answer is
+ * shared with rules, legends and semantic exports, and one viewer's local
+ * hide must never change what another viewer's rules say about the same
+ * document.
+ *
+ * Reactive: `isHidden` reads a signal, so an effect or a `computed` that asks
+ * re-runs when the set changes (the DOM block views rely on it). With nothing
+ * registered, or nothing hidden, every answer is `false` after one size check.
+ */
+export class GfxLocalVisibility {
+    constructor() {
+        this._sources$ = signal([]);
+        /** Every id hidden for this viewer, across every registered source. */
+        this.hiddenIds$ = computed(() => unionOf(this._sources$.value));
+        this._layerSources$ = signal([]);
+        /** Every user layer hidden for this viewer, across every layer source. */
+        this.hiddenLayerIds$ = computed(() => unionOf(this._layerSources$.value));
+    }
+    /** Add a source of hidden ids. Returns its disposer. */
+    register(source) {
+        this._sources$.value = [...this._sources$.peek(), source];
+        return () => {
+            this._sources$.value = this._sources$
+                .peek()
+                .filter(existing => existing !== source);
+        };
+    }
+    /** Add a source of hidden LAYER ids (ADR 0031, stage 7). Returns its disposer. */
+    registerLayers(source) {
+        this._layerSources$.value = [...this._layerSources$.peek(), source];
+        return () => {
+            this._layerSources$.value = this._layerSources$
+                .peek()
+                .filter(existing => existing !== source);
+        };
+    }
+    /**
+     * Is `model` hidden for this viewer — itself, or through a group-like
+     * ELEMENT ancestor (a group, a mindmap)?
+     *
+     * Frames are not walked, although they are group-compatible: a frame is a
+     * slide, and hiding the frame hides the frame, not what it holds (ADR 0031
+     * §5). A model no surface holds has no ancestors to ask about.
+     */
+    isHidden(model) {
+        const hiddenLayers = this.hiddenLayerIds$.value;
+        if (hiddenLayers.size > 0 && this._inHiddenLayer(model, hiddenLayers)) {
+            return true;
+        }
+        const hidden = this.hiddenIds$.value;
+        if (hidden.size === 0)
+            return false;
+        if (hidden.has(model.id))
+            return true;
+        let ancestors;
+        try {
+            ancestors = model.groups ?? [];
+        }
+        catch {
+            return false;
+        }
+        return ancestors.some(ancestor => ancestor instanceof GfxPrimitiveElementModel && hidden.has(ancestor.id));
+    }
+    /**
+     * Whether `model`'s EFFECTIVE layer is one of `layers` — the outermost
+     * group's layer, so a whole group hides with its layer. A hidden frame's
+     * layer hides the frame, not what it holds (ADR 0031 §5). Local elements
+     * belong to no layer. A surface with no `layers` record still has the
+     * default layer, shown and hideable before it is recorded (ADR 0031
+     * amendments): every model is then in it.
+     */
+    _inHiddenLayer(model, layers) {
+        const userLayers = userLayersOf(model);
+        if (!userLayers)
+            return false;
+        if (!(model instanceof GfxPrimitiveElementModel) &&
+            !(model instanceof GfxBlockElementModel)) {
+            return false;
+        }
+        return layers.has(userLayers.effectiveLayerOf(model));
+    }
+}
+function unionOf(sources) {
+    if (sources.length === 0)
+        return NOTHING_HIDDEN;
+    if (sources.length === 1)
+        return sources[0].value;
+    const union = new Set();
+    for (const source of sources) {
+        for (const id of source.value)
+            union.add(id);
+    }
+    return union;
+}

package/dist/_pkgs/std/gfx/model/gfx-block-model.d.ts

@@ -13,6 +13,19 @@ export type GfxCompatibleProps = {
     xywh: SerializedXYWH;
     index: string;
     lockedBySelf?: boolean;
+    /**
+     * "Hide for everyone" (ADR 0031 §7). `true` or absent, never `false`:
+     * unhiding deletes the `prop:` key through the props proxy, so the block
+     * goes back to byte-identical. Every gfx block schema declares it with an
+     * `undefined` default, the way it declares `lockedBySelf`.
+     */
+    hiddenForEveryone?: true;
+    /**
+     * The user layer this block belongs to (ADR 0031 §3); `undefined` = the
+     * default layer. Declared by every gfx block schema with an `undefined`
+     * default, like `hiddenForEveryone`.
+     */
+    layer?: string;
 };
 /**
  * This type include the common props for the graphic block model.