@graphty/graphty-element 2.5.1 → 2.6.0

package/dist/src/data/edgeIdentity.d.ts

@@ -9,7 +9,9 @@
  * was implemented independently in four places, two of which carried a doc comment claiming to be
  * the only one, and the two sides of a style join could -- and did -- disagree in silence.
  */
-import type { EdgeId } from "../catalog/types";
+import { type DuplicatePolicy, type GraphSnapshot } from "@graphty/graph-format";
+import { type LanePair } from "../catalog/sets/hash";
+import type { EdgeId, EdgeMember, NodeId } from "../catalog/types";
 /**
  * The id of the edge carrying one counter value.
  *
@@ -27,3 +29,202 @@ export declare function edgeIdOf(counter: number): EdgeId;
  * @returns the counter, or `INVALID_INDEX` when the id is not one this element ever assigned
  */
 export declare function edgeCounterOf(id: EdgeId): number;
+/**
+ * The row of a session edge in a snapshot: its `Edge.index`.
+ * @param graph - the snapshot
+ * @param id - the session edge id
+ * @returns the row, or `INVALID_INDEX`
+ */
+export declare function edgeRowOf(graph: GraphSnapshot, id: EdgeId): number;
+/**
+ * The counter behind `GraphStore.nextEdgeId()`.
+ *
+ * An object rather than a number held by the store, so that its owner (`DataManager`, or a
+ * headless `GraphSession`) can hand the same one to every store it builds: a Clear or a replacing
+ * import then starts a new store without rewinding the counter, and an edge id is never issued
+ * twice in one session.
+ */
+export interface EdgeCounter {
+    /** The value the next edge takes. */
+    next: number;
+}
+/**
+ * A counter starting at 0.
+ * @returns the counter
+ */
+export declare function createEdgeCounter(): EdgeCounter;
+/**
+ * Continue a counter one past a value already issued, as a graph restored with its edge-id column
+ * must, so a restored id is never issued again. Never moves the counter backwards.
+ * @param counter - the counter
+ * @param last - the largest counter value the restored graph carries
+ */
+export declare function resumeEdgeCounter(counter: EdgeCounter, last: number): void;
+/**
+ * The id minted for an edge added in the session without a file id. `graphty:` is a reserved
+ * namespace, so it can never collide with an id a file chose unless the file was written by the
+ * element itself.
+ * @param counter - the edge's counter value
+ * @returns the minted id
+ */
+export declare function mintedEdgeId(counter: number): string;
+/** What becomes of a record repeating an edge the graph already holds. */
+type RepeatDecision = 
+/** `keep`: the repeat is an edge of its own. */
+{
+    readonly kind: "add";
+}
+/** `error`: the load is refused with `E_DUPLICATE_EDGE`. */
+ | {
+    readonly kind: "refuse";
+}
+/** `first`: the repeat is dropped and the survivor is untouched. */
+ | {
+    readonly kind: "drop";
+}
+/**
+ * `last`, `sum`, `min`, `max`: the survivor takes `weight`, and under `last` the repeat's
+ * attributes replace the survivor's (`replaceRecord`).
+ */
+ | {
+    readonly kind: "merge";
+    readonly weight: number;
+    readonly replaceRecord: boolean;
+};
+/**
+ * The repeated-edge survivorship decision, one place for every ingest path and every test harness,
+ * so nothing re-implements which edges survive.
+ * @param policy - `data.knownFields.repeatedEdges`, or a call's override
+ * @param survivorWeight - the weight the edge already held carries
+ * @param repeatWeight - the repeating record's resolved weight
+ * @returns the decision
+ */
+export declare function decideRepeat(policy: DuplicatePolicy, survivorWeight: number, repeatWeight: number): RepeatDecision;
+/** The element-assigned edge counter column. Its value, printed, is `Edge.id`. */
+export declare const EDGE_ID_COLUMN = "graphty.edgeId";
+/** The builder columns the completion pass fills. Internal names; the `graphty.` prefix is reserved. */
+export declare const IDENTITY_COLUMNS: {
+    /** Node: `hashNodeId` of the node id, two uint32 lanes. */
+    readonly nodeHash: "graphty.nodeHash";
+    /** Edge: `hashEdgeMember` of the edge's stable identity, two uint32 lanes. */
+    readonly edgeHash: "graphty.edgeHash";
+    /** Edge: its position among its pair's surviving edges in its load; -1 for a session edge. */
+    readonly edgeOrdinal: "graphty.edgeOrdinal";
+    /** Edge: its pair's surviving edge count in its load; -1 for a session edge. */
+    readonly edgeAmong: "graphty.edgeAmong";
+};
+/**
+ * The graph attribute recording whether edge pairs are ordered (1) or unordered (0). Latched once
+ * per store, when the first edge is completed: a pair is ordered only when the graph was declared
+ * directed by then, and a direction settled later changes nothing already written.
+ */
+export declare const PAIRS_ORDERED_ATTRIBUTE = "graphty.edgePairsOrdered";
+/** Where the completion pass reads endpoints and node ids: a builder, or a snapshot. */
+export interface IdentityGraph {
+    /**
+     * The declared endpoints of a live edge.
+     * @param edge - the edge row
+     * @returns [source index, target index]
+     */
+    endpoints(edge: number): readonly [number, number];
+    /**
+     * The id of a live node.
+     * @param node - the node row
+     * @returns the id
+     */
+    idOf(node: number): NodeId;
+    /**
+     * The hash of a live node's id, when the caller already has it (the hash of `idOf(node)`).
+     * Absent: hashed from `idOf`.
+     * @param node - the node row
+     * @returns the hash
+     */
+    hashOf?(node: number): LanePair;
+}
+/** Receives one completed edge row. */
+type IdentityWriter = (row: number, ordinal: number, among: number, hash: LanePair) => void;
+/** What the tests read: the transient bytes of the last completed load, and how many edges it held. */
+export declare const identityCounters: {
+    lastTransientBytes: number;
+    lastLoadEdges: number;
+};
+/**
+ * Complete one load: give each of its surviving edges its ordinal and among, counted per pair in
+ * ingest order, and its edge hash.
+ *
+ * The load's rows are sorted by (pair, row) through a permutation over two endpoint arrays, 20
+ * transient bytes per loaded edge with the row list and 4 per node (see `sortPairs`), and the columns are filled in one pass. No
+ * map over the whole graph's pairs is kept. Rows are appended in ingest order and a compacting
+ * freeze keeps their order, so row order within a load is counter order.
+ * @param rows - the load's surviving edge rows, ascending
+ * @param graph - where endpoints and ids are read
+ * @param ordered - whether pairs are ordered (the graph was declared directed at ingest)
+ * @param fileIdAt - the file id of the edge at a position of `rows`, or undefined
+ * @param write - receives each completed row
+ */
+export declare function completeLoad(rows: Uint32Array, graph: IdentityGraph, ordered: boolean, fileIdAt: (position: number) => string | number | undefined, write: IdentityWriter): void;
+/**
+ * The hash of a session edge: its file id when it has one, else the id minted from its counter.
+ * @param graph - where endpoints and ids are read
+ * @param row - the edge row
+ * @param counter - its counter value
+ * @param fileId - its file id, if any
+ * @param ordered - whether pairs are ordered
+ * @returns the hash
+ */
+export declare function sessionEdgeHash(graph: IdentityGraph, row: number, counter: number, fileId: string | number | undefined, ordered: boolean): LanePair;
+/** The four identity columns of a snapshot, read or computed. */
+interface IdentityColumns {
+    /** Two lanes per node. */
+    readonly nodeHash: Uint32Array;
+    /** Two lanes per edge. */
+    readonly edgeHash: Uint32Array;
+    /** Per edge; -1 for a session edge. */
+    readonly edgeOrdinal: Int32Array;
+    /** Per edge; -1 for a session edge. */
+    readonly edgeAmong: Int32Array;
+}
+/**
+ * Whether a snapshot's edge pairs are ordered: the store's latch when it has one, else the
+ * snapshot's own direction (a raw graph-format or graph-io snapshot was declared by its producer).
+ * @param snapshot - the snapshot
+ * @returns true when pairs are ordered
+ */
+export declare function pairsOrdered(snapshot: GraphSnapshot): boolean;
+/**
+ * A stable edge member with its ends in the canonical comparator order when pairs are unordered,
+ * so `b -> a` and `a -> b` spell one member of an undirected graph. Anything that is not a pair
+ * of ids passes through unchanged for a validator to judge; an already canonical member is
+ * returned as the same object.
+ * @param member - the member as given
+ * @param ordered - whether the graph's pairs are ordered
+ * @returns the member
+ */
+export declare function canonicalEdgeEnds<T>(member: T, ordered: boolean): T;
+/**
+ * A snapshot's identity columns: the store's, when it carries them, else computed from its ids on
+ * first read and cached -- exactly what the completion pass would have written had the whole
+ * snapshot been one load with no file ids.
+ * @param snapshot - the snapshot
+ * @returns the columns
+ */
+export declare function identityColumnsOf(snapshot: GraphSnapshot): IdentityColumns;
+/**
+ * The bytes the identity columns hold in a snapshot: data plus validity of each of the four,
+ * which is what the memory budget of design 6.5 counts (8 per node, 16 per edge).
+ * @param snapshot - the snapshot
+ * @returns the byte count; 0 for a snapshot without the columns
+ */
+export declare function identityColumnBytes(snapshot: GraphSnapshot): number;
+/**
+ * An edge's stable identity, built from its row's columns (design 12.3): its file id when the
+ * caller read one at the configured `edgeIdPath`, else its ordinal and among when it came from a
+ * load, else the id minted from its counter. The ends of an unordered pair are in the canonical
+ * comparator order, so both orientations of one edge give one member.
+ * @param snapshot - the snapshot the row belongs to
+ * @param edge - the edge row
+ * @param fileId - the edge's file id, read by the caller at the configured `edgeIdPath`
+ * @returns the member
+ */
+export declare function stableEdgeMember(snapshot: GraphSnapshot, edge: number, fileId?: string | number): EdgeMember;
+export {};

package/dist/src/data/ingest.d.ts

@@ -58,10 +58,12 @@ export declare function resolveEdgeWeight(record: Record<string | number, unknow
  * @param srcId - source node id, already extracted with JMESPath
  * @param dstId - destination node id
  * @param weight - the resolved weight
+ * @param fileId - the edge's id read at the configured `edgeIdPath`, when there is one: its stable
+ *     identity (design/sets/sets-design.md 12.3)
  * @returns the logical edge index and the counter stamped into the edge's id column, or
  *     `INVALID_INDEX` for both when either id is not one graph-format accepts
  */
-export declare function ingestEdge(store: GraphStore, srcId: unknown, dstId: unknown, weight: number): {
+export declare function ingestEdge(store: GraphStore, srcId: unknown, dstId: unknown, weight: number, fileId?: string | number): {
     index: number;
     edgeId: number;
 };

package/dist/src/data/report.d.ts

@@ -60,6 +60,20 @@ export interface ImportReport {
         /** The record key weights were read from, or null when no record carried one. */
         readonly attribute: string | null;
     };
+    /**
+     * How a set, a style layer or a saved reference will find the edges this load stored again:
+     * by the file's own edge id, or, without one, by position among the edges of the same pair.
+     * A reference by position matches a different edge if a later file lists that pair's edges
+     * in another order, which is why the report says how many there are.
+     */
+    readonly edgeIdentity: {
+        /** The record key file ids were read at (`knownFields.edgeIdPath`), or null when none is configured. */
+        readonly idPath: string | null;
+        /** Edges stored with a file id. */
+        readonly byId: number;
+        /** Edges stored without one, matched by position among their pair's edges. */
+        readonly byPosition: number;
+    };
 }
 /**
  * The mutable tally a load keeps while it runs, before it is frozen into an {@link ImportReport}.
@@ -86,6 +100,10 @@ export interface ImportTally {
     weightsResolvedFrom: "path" | "legacy" | "none";
     /** The record key that weight came from. */
     weightsAttribute: string | null;
+    /** Edges stored with a file id. */
+    edgesById: number;
+    /** Edges stored without one. */
+    edgesByPosition: number;
 }
 /**
  * A fresh, zeroed tally.
@@ -104,6 +122,8 @@ interface ImportReportContext {
     readonly nodes: number;
     /** Edges the graph holds now. */
     readonly edges: number;
+    /** The configured file-id path, or null. */
+    readonly idPath: string | null;
 }
 /**
  * Freeze one load's tally and its context into the report a consumer reads.

package/dist/src/graphty-element.d.ts

@@ -1,7 +1,7 @@
 import type { DuplicatePolicy } from "@graphty/graph-format";
 import { LitElement } from "lit";
 import { type AccelerationPolicy } from "./acceleration";
-import type { AlgorithmKey, Scope } from "./catalog/types";
+import type { AlgorithmKey, Scope, ScopeInput } from "./catalog/types";
 import type { GraphBackgroundConfig, GraphBehaviorConfig, GraphSelectionStyleInput, ViewMode } from "./config";
 import { type AlgorithmOnLoad } from "./config/DataConfig";
 import type { PartialXRConfig } from "./config/xr-config-schema";
@@ -9,7 +9,7 @@ import { Graph } from "./Graph";
 import type { ScreenshotOptions, ScreenshotResult } from "./screenshot/types.js";
 import type { GraphSession } from "./session";
 import type { Run, StartOptions } from "./session/runs";
-import type { SelectionDelta, SelectionTarget, SetOp } from "./session/selection";
+import type { SelectionDelta, SelectionOp, SelectionTarget } from "./session/selection";
 /**
  * Graphty creates a graph
  */
@@ -96,7 +96,7 @@ export declare class Graphty extends LitElement {
      * </script>
      * ```
      */
-    select(target: SelectionTarget, op?: SetOp): Promise<SelectionDelta>;
+    select(target: SelectionTarget, op?: SelectionOp): Promise<SelectionDelta>;
     /**
      * Called when the element is added to the DOM. Sets up the graph container and resize observer.
      */
@@ -429,6 +429,40 @@ export declare class Graphty extends LitElement {
      * Sets layout-specific configuration. Updates active layout if one is set.
      */
     set layoutConfig(value: Record<string, unknown> | undefined);
+    /**
+     * What the layout runs over: a set, a query, a list of nodes -- any scope.
+     * @remarks
+     * The scope's nodes move and every other node is held where it is. The members are the ones
+     * the scope had when the layout started, so a later click, filter change or attribute edit
+     * does not move what the layout holds, and a node added afterwards is held too.
+     *
+     * CARRIED across `layout` and `layoutConfig` changes, so changing one force setting never
+     * un-scopes the layout. Setting it restarts the running layout. Only a live simulation --
+     * whose catalogue entry reads `scoped: true` -- lays out a scope; under any other layout, or
+     * when the set it names is removed, the scope is inactive and the whole graph is laid out.
+     * Nothing here throws: a value that is not a scope is reported and dropped.
+     *
+     * Reads `undefined` when layouts run over the whole graph, never `"graph"`.
+     * @since 2.5.0
+     * @example JavaScript property
+     * ```typescript
+     * const id = element.session.sets.create({ kind: "fixed", nodes: ["a", "b", "c"], reading: "induced" });
+     * element.layout = "ngraph";
+     * element.layoutScope = { set: id };
+     * ```
+     * @example HTML attribute (JSON)
+     * ```html
+     * <graphty-element layout="ngraph" layout-scope='{"nodes":["a","b","c"]}'></graphty-element>
+     * ```
+     * @returns The scope, or undefined for the whole graph
+     */
+    get layoutScope(): Scope | undefined;
+    /**
+     * Sets what the layout runs over, and restarts the running layout over it. A value that is
+     * not a scope is reported and dropped, never thrown: this setter is reached from
+     * `attributeChangedCallback`, where a throw would reach nobody.
+     */
+    set layoutScope(value: ScopeInput | undefined);
     /**
      * How the element DRIVES the layout, as distinct from what the layout engine is configured
      * with.
@@ -1345,7 +1379,9 @@ export declare class Graphty extends LitElement {
      * default engine, or a registered engine name (such as `"ngraph"`).
      * @param type - Layout id or engine name
      * @param opts - Layout-specific options
-     * @param options - Queue options
+     * @param options - Queue options, and `scope`: what the layout runs over. A live simulation
+     *   moves the scope's nodes and holds the rest; absent keeps the scope already set, and
+     *   `"graph"` clears it. See {@link Graphty.layoutScope}.
      * @returns Promise that resolves when layout is initialized
      * @since 1.5.0
      * @example
@@ -1355,7 +1391,7 @@ export declare class Graphty extends LitElement {
      * await element.setLayout('ngraph', { springLength: 100 });
      * ```
      */
-    setLayout(type: string, opts?: object, options?: import("./utils/queue-migration").QueueableOptions): Promise<void>;
+    setLayout(type: string, opts?: object, options?: import("./utils/queue-migration").SetLayoutOptions): Promise<void>;
     /**
      * Zoom the camera to fit all nodes in view.
      * @since 1.5.0
@@ -1540,7 +1576,7 @@ export declare class Graphty extends LitElement {
      * ```
      */
     applyCameraView(id: string, options?: {
-        scope?: Scope;
+        scope?: ScopeInput;
         params?: Readonly<Record<string, unknown>>;
     } & import("./screenshot/types.js").CameraAnimationOptions): Promise<void>;
     /**

package/dist/src/layout/D3GraphLayoutEngine.d.ts

@@ -1,3 +1,4 @@
+import type { NodeMask } from "@graphty/graph-format";
 import { Edge as D3Edge, forceSimulation, InputEdge as D3InputEdge, Node as D3Node } from "d3-force-3d";
 import { z } from "zod/v4";
 import { type OptionsSchema } from "../config";
@@ -21,6 +22,8 @@ export declare class D3GraphEngine extends LayoutEngine {
     static type: string;
     static maxDimensions: number;
     static zodOptionsSchema: OptionsSchema;
+    /** Accepts a scope: a held node is fixed through d3's own `fx`/`fy`/`fz`. */
+    static scoped: boolean;
     d3ForceLayout: ReturnType<typeof forceSimulation>;
     d3AlphaMin: number;
     d3AlphaTarget: number;
@@ -123,6 +126,14 @@ export declare class D3GraphEngine extends LayoutEngine {
      * @param n - The node to unpin
      */
     unpin(n: Node): void;
+    /**
+     * Holds the nodes a scoped layout may not move, as d3 fixes a node: at its current position.
+     *
+     * A node that is no longer held is released unless the reader pinned it.
+     * @param mask - One bit per row to hold, or null to hold nothing.
+     * @param rows - How many rows the mask covers.
+     */
+    setHoldMask(mask: NodeMask | null, rows: number): void;
     /**
      * Take a node out of the simulation.
      *

package/dist/src/layout/LayoutEngine.d.ts

@@ -1,3 +1,4 @@
+import { type NodeMask } from "@graphty/graph-format";
 import { z } from "zod/v4";
 import type { AuthoredLayoutDescriptor } from "../catalog/types";
 import type { OptionsSchema } from "../config";
@@ -53,6 +54,25 @@ export interface LayoutEngineStatics {
      * for, instead of offering it on seventeen layouts that ignore it.
      */
     honoursWeights?: boolean;
+    /**
+     * Whether this engine can lay out a set of nodes while holding every other node still, which is
+     * what `setLayout(type, opts, { scope })` asks of it.
+     *
+     * Optional, and false unless declared: an engine that says nothing refuses a scope with
+     * `E_UNSUPPORTED`, so no existing engine is handed a hold it never agreed to.
+     *
+     * THE CONTRACT A SCOPED ENGINE ACCEPTS. The element hands it a hold mask through
+     * {@link LayoutEngine.setHoldMask} after `init()` and again whenever the graph is renumbered,
+     * and the protected `writeNodePosition` already refuses a layout write onto a held row that
+     * has a coordinate -- so a held node never MOVES under any engine. That alone is not enough:
+     * an engine that keeps integrating a held body computes every force on its members against a
+     * position the element will never draw. A scoped engine must therefore treat held nodes as
+     * fixed in its own state -- a fixed-node mask, `fx`/`fy`, a pinned body -- read through
+     * the protected `isHeld(index)`, including for a node added after the hold was set and a node a
+     * reader unpins while it is held. The hold is never a pin: it is not written to the element's
+     * pin lane, so it never leaks into saved pins or exports.
+     */
+    scoped?: boolean;
     /**
      * What the catalogue publishes about this layout, so a picker can offer it.
      *
@@ -98,6 +118,14 @@ export declare abstract class LayoutEngine {
      * advertising a control that changes nothing.
      */
     static honoursWeights: boolean;
+    /**
+     * Whether this engine accepts a scope. See {@link LayoutEngineStatics.scoped}, which states the
+     * contract a scoped engine accepts.
+     *
+     * False here because a one-shot arrangement recomputes every coordinate from scratch, and
+     * where it would place a subset among nodes it may not move is a question nothing answers yet.
+     */
+    static scoped: boolean;
     /**
      * What a picker reads about this layout. See {@link LayoutEngineStatics.descriptor}.
      *
@@ -136,6 +164,10 @@ export declare abstract class LayoutEngine {
      * would silently swap that array for the one its own graph owns.
      */
     private positionArrayAttached;
+    /** The rows the element is holding still, or null when nothing is held. See {@link setHoldMask}. */
+    private hold;
+    /** How many rows {@link hold} covers; a row at or past it is newer than the hold, so held. */
+    private holdRows;
     abstract init(): Promise<void>;
     abstract addNode(n: Node): void;
     abstract addEdge(e: Edge): void;
@@ -211,6 +243,30 @@ export declare abstract class LayoutEngine {
      * @param positions - the element-owned array
      */
     attachPositions(positions: ElementPositions): void;
+    /**
+     * Hold the nodes a scoped layout may not move, or release them all with null.
+     *
+     * The element calls this on an engine whose class declares `static scoped = true`, after
+     * `init()` and after every renumbering of the graph. A set bit is a held row. A row at or past
+     * `rows` belongs to a node that arrived after the scope was captured, and is held too: the
+     * members of a scoped layout are the ones it started with. An engine that overrides this calls
+     * `super.setHoldMask` first and then fixes held nodes in its own state (see
+     * {@link LayoutEngineStatics.scoped}).
+     * @param mask - One bit per row, set for a row to hold; null holds nothing.
+     * @param rows - How many rows the mask covers.
+     */
+    setHoldMask(mask: NodeMask | null, rows: number): void;
+    /**
+     * The hold mask the element last handed this engine, or null when nothing is held.
+     * @returns The mask, which the caller must not change.
+     */
+    get holdMask(): NodeMask | null;
+    /**
+     * Whether the element is holding this row still for a scoped layout.
+     * @param index - The node's row, or `INVALID_INDEX`.
+     * @returns True while a hold is set and the row is held or newer than the hold.
+     */
+    protected isHeld(index: number): boolean;
     /**
      * Copy every node's current coordinates out of the engine and into the position array.
      *

package/dist/src/layout/NGraphLayoutEngine.d.ts

@@ -1,3 +1,4 @@
+import type { NodeMask } from "@graphty/graph-format";
 import { Layout as NGraphLayout } from "ngraph.forcelayout";
 import { Graph as NGraph, Link as NGraphLink, Node as NGraphNode } from "ngraph.graph";
 import { type OptionsSchema } from "../config";
@@ -11,6 +12,8 @@ export declare class NGraphEngine extends LayoutEngine {
     static type: string;
     static maxDimensions: number;
     static zodOptionsSchema: OptionsSchema;
+    /** Accepts a scope: a held node is a pinned body in ngraph's own simulation. */
+    static scoped: boolean;
     ngraph: NGraph;
     ngraphLayout: NGraphLayout<NGraph>;
     /**
@@ -104,6 +107,13 @@ export declare class NGraphEngine extends LayoutEngine {
      * @param n - The node to unpin
      */
     unpin(n: Node): void;
+    /**
+     * Holds the nodes a scoped layout may not move, as pinned bodies. A node that is no longer
+     * held is released unless the reader pinned it.
+     * @param mask - One bit per row to hold, or null to hold nothing.
+     * @param rows - How many rows the mask covers.
+     */
+    setHoldMask(mask: NodeMask | null, rows: number): void;
     /**
      * Take a node out of the simulation, and the links ngraph drops with it.
      *

package/dist/src/layout/SimulationLayoutEngine.d.ts

@@ -186,6 +186,11 @@ export interface SimulationEngineInit {
  */
 export declare class SimulationLayoutEngine extends LayoutEngine {
     #private;
+    /**
+     * Every simulation accepts a scope: a held row is OR-ed into the fixed-node mask, so the
+     * simulation stops integrating it as well as publishing it. See `LayoutEngineStatics.scoped`.
+     */
+    static scoped: boolean;
     /** Which simulation this bridge drives. */
     readonly simulationType: SimulationType;
     /** The accelerator member this simulation needs, asked of the controller before every build. */
@@ -372,6 +377,12 @@ export declare class SimulationLayoutEngine extends LayoutEngine {
      * @param n - The node that was unpinned.
      */
     unpin(n: Node): void;
+    /**
+     * Holds the rows a scoped layout may not move, in the simulation's own fixed-node mask too.
+     * @param mask - One bit per row to hold, or null to hold nothing.
+     * @param rows - How many rows the mask covers.
+     */
+    setHoldMask(mask: NodeMask | null, rows: number): void;
     /**
      * Places one node now. A drag reaches this per pointer move, and `replayPins` once per pin.
      * @param n - The node that moved.

package/dist/src/managers/AlgorithmManager.d.ts

@@ -92,6 +92,14 @@ export declare class AlgorithmManager implements Manager {
      * @returns The target.
      */
     private targetFor;
+    /**
+     * A run's scope as bitmaps over the snapshot the graph holds now. The run resolved it when it
+     * started; a freeze since then resolves it again, so an algorithm never reads bitmaps over a
+     * snapshot that is no longer the graph.
+     * @param context - What the run handed the work.
+     * @returns The scope, or null when the run carries none this module can read.
+     */
+    private scopeOf;
     /**
      * Do the work.
      *

package/dist/src/managers/DataManager.d.ts

@@ -80,6 +80,17 @@ export declare class DataManager implements Manager {
     private logger;
     /** The one graph-format builder and its cached snapshot; replaced only by `clear()`/`dispose()`. */
     private store;
+    /**
+     * The edge counter every store this manager builds draws from, so a Clear or a replacing
+     * import never rewinds it and an edge id is never issued twice (design/sets 4.2).
+     */
+    private readonly edgeCounter;
+    /**
+     * The attribute revisions and the input tick (design/sets 6.2), the same object the session
+     * over this manager reads, handed to every store this manager builds so a freeze advances it
+     * and a Clear never rewinds it.
+     */
+    private readonly inputs;
     graphResults?: AdHocData;
     meshCache: MeshCache;
     private graphContext;