@graphty/graphty-element 2.5.2 → 2.6.1

package/dist/src/session/styles/Layer.d.ts

@@ -187,6 +187,13 @@ export interface LayerCheckOptions {
     readonly scales: ScaleRegistry;
     /** Which paths this session answers. Absent means it cannot say, and none are reported. */
     readonly paths?: PathDirectory;
+    /**
+     * A write door's check of a `{ match: "member" }` selector's scope: session edge ids to stable
+     * members, set ids checked as issued. Absent, the scope is taken as given.
+     * @param scope - The scope as given.
+     * @returns The scope the layer holds.
+     */
+    readonly admitScope?: (scope: unknown) => unknown;
 }
 /**
  * What a check produced: the verdict, and the layer itself when there is one.
@@ -312,12 +319,12 @@ export declare function isElementSource(source: LayerSource): boolean;
  * it parses, resolves and refuses, and the session it was asked about is exactly as it was
  * afterwards. Every problem is reported, not the first, because correcting one mistake per round
  * trip is how a form gets abandoned.
- * @param spec - The layer as it was authored, imported or exported.
+ * @param given - The layer as it was authored, imported or exported.
  * @param options - The id to give it, what its selector compiles against, the scales it may name,
  *     and which paths this session answers.
  * @returns The verdict, and the compiled layer when the verdict is that it is sound.
  */
-export declare function checkLayerSpec(spec: LayerSpec, options: LayerCheckOptions): LayerCheck;
+export declare function checkLayerSpec(given: LayerSpec, options: LayerCheckOptions): LayerCheck;
 /**
  * The specification a layer came from, so an update can be expressed as a patch over it.
  * @param layer - The layer.

package/dist/src/session/styles/StylesApi.d.ts

@@ -65,7 +65,7 @@ import { type EngineVersions, type ResolvedScope, type Run, type RunOptions, typ
 import type { PreparedBinding } from "./encoding";
 import { type EncodingSource, type EncodingSpec } from "./EncodingSpec";
 import { type ExplainTarget, type StyleExplanation, type UnboundLayer } from "./explain";
-import { type CompiledLayer, type Layer, type LayerPosition, type LayerRepaint, type PathDirectory, type RepaintReason, type RepaintReport, type ValidationResult } from "./Layer";
+import { type CompiledLayer, type Layer, type LayerCheckOptions, type LayerPosition, type LayerRepaint, type PathDirectory, type RepaintReason, type RepaintReport, type ValidationResult } from "./Layer";
 import { type FieldWords, type LegendBlock } from "./legend";
 import { type SelectorSource, type SelectorTarget } from "./predicate";
 import { type ScaleRegistry } from "./scales";
@@ -96,7 +96,8 @@ export interface TemplateReport {
     /** The layers that bound and now paint, bottom first. */
     readonly applied: readonly LayerId[];
     /**
-     * The layers that read nothing this session answers.
+     * The layers that read nothing this session answers, and the layers naming a set this project
+     * does not hold (detached).
      *
      * They are IN the stack and disabled, never dropped: a layer naming a run that has not been
      * started is a correct layer over a session that will answer it later, and the way to make it
@@ -399,6 +400,8 @@ export interface StylesSources {
      * across a freeze that renumbers the index space.
      */
     readonly elements: SelectorSource;
+    /** See {@link LayerCheckOptions.admitScope}. */
+    readonly admitScope?: LayerCheckOptions["admitScope"];
     /**
      * The element's own layers, seeded at the bottom of the stack in the order given.
      *

package/dist/src/session/styles/explain.d.ts

@@ -156,8 +156,11 @@ export declare function explainStyle(target: ExplainTarget, sources: ExplainSour
  * not been started yet is a correct layer over a session that will answer it later, and a layer
  * imported with a style document may name a column the next dataset does have. What it must never
  * be is invisible -- a confident empty screen reads exactly like a correct answer of zero.
- * @param sources - The stack and the path directory. With no directory nothing is reported.
- * @returns One entry per layer that reads only paths nothing answers, bottom first.
+ * A `{match:"member"}` layer whose scope cannot be resolved -- a set this project does not hold --
+ * is reported as detached, whatever the directory says.
+ * @param sources - The stack and the path directory. With no directory only detached layers are
+ *     reported.
+ * @returns One entry per layer that reads only paths nothing answers or is detached, bottom first.
  */
 export declare function unboundLayers(sources: ExplainSources): readonly UnboundLayer[];
 /**

package/dist/src/session/styles/predicate.d.ts

@@ -37,7 +37,8 @@
  *
  * Nothing here reaches Babylon.js, Lit or the DOM.
  */
-import type { EdgeId, NodeId, Path, Query } from "../../catalog/types";
+import { type U32 } from "@graphty/graph-format";
+import type { EdgeId, NodeId, Path, Query, Scope } from "../../catalog/types";
 /** Which kind of element a selector and its predicate speak about. */
 export type SelectorTarget = "node" | "edge";
 /**
@@ -128,6 +129,31 @@ export interface SelectorSource {
      * @returns The cut, or undefined.
      */
     readonly topCut?: (path: Path, target: SelectorTarget, n: number) => number | undefined;
+    /**
+     * The live membership of one scope, which a `{match:"member"}` selector tests by index.
+     * Absent, a `{match:"member"}` selector is refused.
+     *
+     * Asked once, when the layer is compiled; what comes back is read per element and follows the
+     * scope as it changes, so the compiled layer never has to be compiled again.
+     * @param scope - The scope, already checked.
+     * @returns Its live membership.
+     */
+    readonly scope?: (scope: Scope) => LiveScope;
+}
+/** The live membership of one scope, as a `{match:"member"}` selector reads it. */
+export interface LiveScope {
+    /**
+     * The members of one half, as a bitmap over the snapshot the session holds now.
+     * @param target - Nodes or edges.
+     * @returns The bitmap, or null when the scope paints nothing (detached, or it cannot be
+     *     evaluated).
+     */
+    bits(target: SelectorTarget): U32 | null;
+    /**
+     * Why the scope paints nothing, when it cannot be resolved.
+     * @returns The reason in a sentence, or undefined when it resolves.
+     */
+    problem(): string | undefined;
 }
 /**
  * One target's half of a {@link SelectorSource}, resolved once so the predicate never chooses.
@@ -173,7 +199,7 @@ export type ElementPredicate = (index: number) => boolean;
 /** A selector, reduced to the test a repaint runs and the columns that test reads. */
 export interface CompiledSelector {
     /** Which selector kind this was compiled from. */
-    readonly match: "everything" | "expression" | "has" | "ids" | "top";
+    readonly match: "everything" | "expression" | "has" | "ids" | "top" | "member";
     /** Which kind of element it speaks about. */
     readonly target: SelectorTarget;
     /**
@@ -194,6 +220,11 @@ export interface CompiledSelector {
      * for and leaves the reference check to whoever holds one.
      */
     readonly paths: readonly Path[];
+    /**
+     * Why a `{match:"member"}` selector paints nothing, when its scope cannot be resolved (a
+     * removed set, a cycle). Absent for every other kind.
+     */
+    readonly problem?: () => string | undefined;
 }
 /**
  * Write a column key as a path an expression selector reads back as the same key.
@@ -256,6 +287,14 @@ export declare function idsPredicate(columns: ElementColumns, ids: ReadonlySet<E
  * @returns The test.
  */
 export declare function topPredicate(columns: ElementColumns, path: Path, cutOf: () => number | undefined): ElementPredicate;
+/**
+ * The predicate for `{match:"member"}`: one bit test by index against the scope's live bitmap,
+ * read per element so the layer follows the scope without being compiled again.
+ * @param live - The scope's live membership.
+ * @param target - Which half the layer paints.
+ * @returns The test.
+ */
+export declare function scopePredicate(live: LiveScope, target: SelectorTarget): ElementPredicate;
 /**
  * Parse and compile `{match:"expression"}`.
  *

package/dist/src/session/styles/repaint.d.ts

@@ -299,6 +299,25 @@ export interface RepaintEngine extends ElementPaint {
      * this: the record is what lets a removed run's layer take its paint back.
      */
     renumbered(): void;
+    /**
+     * Repaint named elements from the whole stack, because what a layer matches moved without the
+     * layer changing: a `{match:"member"}` layer whose set was redefined repaints exactly the
+     * elements that entered or left it (design/sets 11).
+     *
+     * Indices at or past the element count are skipped, and repeats are painted once.
+     * @param stack - The stack to paint from, bottom first.
+     * @param dirty - The dense indices to repaint, per kind of element.
+     * @param context - The signal to stop on and the progress channel.
+     * @returns How much was painted.
+     */
+    repaintElements(stack: readonly CompiledLayer[], dirty: ElementIndices, context: RepaintContext): Promise<RepaintReport>;
+}
+/** Dense indices per kind of element. */
+export interface ElementIndices {
+    /** Node indices. */
+    readonly node: ArrayLike<number>;
+    /** Edge indices. */
+    readonly edge: ArrayLike<number>;
 }
 /**
  * Build the repaint one session paints through.

package/dist/src/session/styles/selector.d.ts

@@ -1,9 +1,10 @@
 /**
- * @file What a style layer paints: the four selector kinds, and the one call that turns one into
- * the closure a repaint runs.
+ * @file What a style layer paints: the selector kinds, and the one call that turns one into the
+ * closure a repaint runs.
  *
- * FOUR KINDS, AND THE SPLIT IS THE POINT. Only `{match:"expression"}` reaches an evaluator.
- * `{match:"has"}` is a column presence test, `{match:"ids"}` is a set membership test, and
+ * THE SPLIT IS THE POINT. Only `{match:"expression"}` reaches an evaluator.
+ * `{match:"has"}` is a column presence test, `{match:"ids"}` is a set membership test,
+ * `{match:"member"}` is one bit test against a scope's live bitmap, and
  * `{match:"everything"}` is no test at all. Measured on this machine, the presence test costs
  * 7.3 ns per element against 1,322 ns for a `jmespath.search()` call, so the kind a layer is
  * written in is a performance decision and not only an ergonomic one. That is why `encode()`
@@ -30,13 +31,15 @@
  *
  * Nothing here reaches Babylon.js, Lit or the DOM.
  */
-import type { EdgeId, NodeId, Path, Query } from "../../catalog/types";
+import type { EdgeId, NodeId, Path, Query, Scope } from "../../catalog/types";
 import { type CompiledSelector, type SelectorSource, type SelectorTarget } from "./predicate";
 /**
  * Which elements a layer paints.
  *
  * Read the file's opening note before adding a kind: the union is small because each member is a
  * different COST, not a different spelling of the same question.
+ *
+ * OPEN UNION: kinds may be added in a minor release; handle unknown kinds.
  */
 export type Selector = 
 /** Every element the layer's target names. The only universal match, and it is written out. */
@@ -79,6 +82,14 @@ export type Selector =
     readonly match: "top";
     readonly path: Path;
     readonly n: number;
+}
+/**
+ * The members of a scope, usually a kept set. One bit test per element against the scope's
+ * live bitmap, which follows the set; a scope that cannot be resolved paints nothing.
+ */
+ | {
+    readonly match: "member";
+    readonly of: Scope;
 };
 /**
  * Turn a selector into the predicate a repaint runs.

package/dist/src/session/types.d.ts

@@ -26,6 +26,7 @@ import type { ResultsApi } from "./results";
 import type { Caveats, EngineVersions, Run, RunChange, RunExecutor, RunOptions, RunQueue, RunsApi } from "./runs";
 import type { ScopeApi } from "./scope/index";
 import type { SelectionApi, SelectionDelta, SelectionOwner } from "./selection";
+import type { SetChange, SetsApi } from "./sets/types";
 import type { ElementPaint, SessionStylesApi, StyleChange, StylesApi } from "./styles";
 import type { SessionVisibilityApi, VisibilityApi, VisibilityChange } from "./visibility";
 /**
@@ -424,6 +425,14 @@ export interface SessionEventMap {
     "capabilities:changed": {
         readonly capabilities: AccelerationCapabilities;
     };
+    /**
+     * A kept set was created, renamed, redefined or removed: one event per set a write touched,
+     * after the write committed. A write that was refused publishes nothing.
+     *
+     * Membership has no event: a set's members follow the data lazily, so a panel showing counts
+     * re-reads them on the events it already watches and on this one.
+     */
+    "set:changed": SetChange;
 }
 /**
  * A painting the element started for itself, and why it did not land.
@@ -460,6 +469,15 @@ export interface GraphSession {
      * it without resolving it, and keeping one under a name.
      */
     readonly scope: ScopeApi;
+    /**
+     * The kept sets: named collections of nodes and edges -- groups, kept selections, communities
+     * and paths -- that anything taking a scope can name as `{ set: id }`.
+     *
+     * A set is fixed (a member list), a rule (a query or rule tree that follows the data) or a
+     * path (an ordered walk). Reading and counting one goes through `scope.resolve({ set: id })`
+     * and `scope.count({ set: id })`; every change is published as `set:changed`.
+     */
+    readonly sets: SetsApi;
     /**
      * What is selected: two sets, five set operations, one selection for the whole session.
      *

package/dist/src/session/visibility/VisibilityApi.d.ts

@@ -44,7 +44,9 @@ import { type GraphSnapshot } from "@graphty/graph-format";
 import type { EdgeId, NodeId, Path, Scope } from "../../catalog/types";
 import { type EngineVersions, type ResolvedScope, type Run, type RunOptions, type RunQueue } from "../runs";
 import { type ScopeVisibilitySource } from "../scope/index";
-import { type Filter, type FilterSources, type TimeWindow } from "./filter";
+import { type DependencySources } from "../sets/dependencies";
+import type { SetWatch } from "../sets/notify";
+import { type FilterSources, type RuleTree, type TimeWindow } from "./filter";
 /**
  * How much of the graph is showing, which is what a status bar reads.
  *
@@ -143,7 +145,7 @@ export interface VisibilityApi {
     /** How much of the graph is showing. */
     readonly summary: VisibilitySummary;
     /** The filter in force, or null when no filter is hiding anything. */
-    readonly filter: Filter | null;
+    readonly filter: RuleTree | null;
     /** The time window in force, or null when no window is hiding anything. */
     readonly window: TimeWindow | null;
     /**
@@ -165,7 +167,7 @@ export interface VisibilityApi {
      * @returns The run, which resolves with the counts.
      * @throws A `GraphtyError` when the filter is malformed or needs something this session lacks.
      */
-    set(filter: Filter | null, options?: RunOptions): Run<FilterResult>;
+    set(filter: RuleTree | null, options?: RunOptions): Run<FilterResult>;
     /**
      * Apply a time window, or clear it with null.
      *
@@ -240,6 +242,47 @@ export interface VisibilitySources extends FilterSources {
      * @param change - The counts, the unresolved paths, and what produced the change.
      */
     readonly onChange?: (change: VisibilityChange) => void;
+    /** Called on every version bump of either mask, which is what advances the session input tick. */
+    readonly onMaskVersion?: () => void;
+    /**
+     * Where the sets a `member` leaf names are looked up, so a filter that reads `"visible"` or
+     * `"search"` through them is refused, and a pass never reads the masks it is writing.
+     */
+    readonly dependencies?: DependencySources;
+    /**
+     * A write door's check of a filter: session edge ids inside a `member` leaf's inline
+     * definition to stable members, and every set id it names checked as issued. Absent, the
+     * filter is taken as given.
+     * @param filter - The filter as given.
+     * @returns The filter to hold.
+     */
+    readonly admit?: (filter: RuleTree) => RuleTree;
+    /**
+     * How the filter follows the sets its `scope` leaves name (design/sets 11). Absent, a filter
+     * is re-evaluated only when it is set again or the snapshot moves.
+     */
+    readonly watch?: FilterWatchSources;
+}
+/** What the filter follows its sets through: the session's change notifier and cache. */
+interface FilterWatchSources {
+    /**
+     * Watch through the session's notifier.
+     * @param watch - The watch; it resolves to whether the masks were re-evaluated.
+     * @returns Stops watching.
+     */
+    subscribe(watch: SetWatch<boolean>): () => void;
+    /**
+     * A scope's input signature now.
+     * @param scope - The scope.
+     * @returns The signature, or null when its inputs cannot be enumerated.
+     */
+    signature(scope: Scope): string | null;
+    /**
+     * Pin a scope's cache entry, so budget pressure never evicts what the filter shows.
+     * @param scope - The scope.
+     * @returns Releases the pin.
+     */
+    pin(scope: Scope): () => void;
 }
 /**
  * Build the visibility model one session holds.
@@ -252,3 +295,4 @@ export interface VisibilitySources extends FilterSources {
  * @returns The visibility model, including the masks the scope resolver reads.
  */
 export declare function createVisibilityApi(sources: VisibilitySources): SessionVisibilityApi;
+export {};

package/dist/src/session/visibility/filter.d.ts

@@ -37,56 +37,11 @@
  *
  * Nothing here reaches Babylon.js, Lit or the DOM.
  */
-import { type GraphSnapshot } from "@graphty/graph-format";
-import type { EdgeId, NodeId, Path, Query } from "../../catalog/types";
+import { type GraphSnapshot, type U32 } from "@graphty/graph-format";
+import type { EdgeId, NodeId, Path, Query, ResultItem, RuleTree, RunId, Scope } from "../../catalog/types";
 import { type ComponentLabels, type ElementMask } from "../scope/index";
-/** Which arcs a degree filter counts. */
-export type FilterDirection = "in" | "out" | "all";
-/**
- * What to keep.
- *
- * Ten kinds, of which eight speak about nodes, one (`edges`) speaks about edges, and three
- * (`all`, `any`, `not`) combine the others. A group with no members constrains nothing: an empty
- * list in a form means "nothing chosen", not "nothing allowed", and a filter builder that blanked
- * the graph the moment its last chip was removed would be unusable.
- */
-export type Filter = {
-    readonly kind: "expression";
-    readonly where: Query;
-} | {
-    readonly kind: "range";
-    readonly attribute: Path;
-    readonly min?: number;
-    readonly max?: number;
-} | {
-    readonly kind: "categories";
-    readonly attribute: Path;
-    readonly values: readonly string[];
-} | {
-    readonly kind: "degree";
-    readonly min?: number;
-    readonly max?: number;
-    readonly direction?: FilterDirection;
-} | {
-    readonly kind: "component";
-    readonly id: number;
-} | {
-    readonly kind: "neighborhood";
-    readonly seeds: readonly NodeId[];
-    readonly depth: number;
-} | {
-    readonly kind: "edges";
-    readonly where: Query;
-} | {
-    readonly kind: "all";
-    readonly of: readonly Filter[];
-} | {
-    readonly kind: "any";
-    readonly of: readonly Filter[];
-} | {
-    readonly kind: "not";
-    readonly of: Filter;
-};
+import { type DependencySources } from "../sets/dependencies";
+export type { RuleTree } from "../../catalog/types";
 /** How wide a step a time window advances by, when something advances it. */
 export type TimeStep = number | "hour" | "day" | "week" | "month" | "quarter" | "year";
 /**
@@ -170,6 +125,66 @@ export interface FilterSources {
      * @returns The unresolved paths.
      */
     readonly unresolvedPathsOf?: (where: Query) => readonly Path[];
+    /**
+     * What a `member` leaf's set covers. Absent refuses a `member` leaf.
+     * @param scope - The referenced set.
+     * @returns Its node half, and its edge half when its reading speaks edges.
+     */
+    readonly scope?: (scope: Scope) => ScopeLeaf;
+    /**
+     * A run's current result, as `item` and `threshold` leaves read it. Absent refuses both over
+     * `results.*`; a run it does not know leaves the leaf holding nothing.
+     * @param run - The run.
+     * @returns The result, or undefined when the run has none.
+     */
+    readonly result?: (run: RunId) => FilterRunResult | undefined;
+    /**
+     * What a held item's execution held, captured when its run re-executed, as bitmaps over the
+     * snapshot (design/sets 5.2). Absent, or undefined for an item: nothing was captured, and a
+     * held execution that is no longer current holds nothing.
+     * @param item - The item, with its execution.
+     * @returns Its node bitmap when its field lives on nodes, its edge bitmap when on edges.
+     */
+    readonly captured?: (item: ResultItem) => CapturedHalves | undefined;
+}
+/** A captured item's members over the snapshot: null for a half the item's field does not live on. */
+export interface CapturedHalves {
+    readonly nodes: U32 | null;
+    readonly edges: U32 | null;
+}
+/** A run's current result, as the compiler reads it. */
+export interface FilterRunResult {
+    /** The token of the execution these values belong to; compared for equality only. */
+    readonly execution: string | undefined;
+    /** Which fields the result publishes per node, per edge or for the graph. */
+    readonly fields: readonly {
+        readonly name: string;
+        readonly kind: "node" | "edge" | "graph";
+    }[];
+    /**
+     * One node's value for a field.
+     * @param index - The dense node index.
+     * @param field - The field.
+     * @returns The value, or undefined when the node carries none.
+     */
+    nodeValue(index: number, field: string): unknown;
+    /**
+     * One edge's value for a field.
+     * @param index - The dense (logical) edge index.
+     * @param field - The field.
+     * @returns The value, or undefined when the edge carries none.
+     */
+    edgeValue(index: number, field: string): unknown;
+}
+/**
+ * What a `member` leaf speaks: the referenced set's nodes, and its edges only when the set is read
+ * `listed` or `clipped`. `edges: null` is silent, exactly as a node leaf is.
+ */
+export interface ScopeLeaf {
+    /** Node bitmap over the snapshot. */
+    readonly nodes: U32;
+    /** Edge bitmap over the snapshot, or null when the set is read `induced`. */
+    readonly edges: U32 | null;
 }
 /** Whether one element, named by its dense index, passes a test. */
 export type ElementTest = (index: number) => boolean;
@@ -198,9 +213,29 @@ export interface CompiledVisibility {
  * Check a filter and a window before anything starts working on them.
  * @param filter - The filter, or null for none.
  * @param window - The time window, or null for none.
+ * @param dependencies - Where the references a `member` leaf makes are looked up, so a filter that
+ *     reaches `"visible"` or `"search"` through kept sets is refused (`details.reason: "cycle"`), and
+ *     one whose item follows a partition group (`"follow-group"`).
  * @throws A `GraphtyError` when either is malformed.
  */
-export declare function assertVisibility(filter: Filter | null, window: TimeWindow | null): void;
+export declare function assertVisibility(filter: RuleTree | null, window: TimeWindow | null, dependencies?: DependencySources): void;
+/** One filter's two halves, before they are folded together. */
+export interface CompiledHalves {
+    /** The node test, or null when this filter says nothing about nodes. */
+    readonly node: ElementTest | null;
+    /** The edge test, or null when this filter says nothing about edges. */
+    readonly edge: ElementTest | null;
+}
+/**
+ * Compile a rule tree into its two halves, for a rule set: the same compiler the visibility
+ * filter runs, so a rule and a filter can never disagree. The tree is already validated.
+ * @param graph - The snapshot every test is written against.
+ * @param filter - The tree.
+ * @param sources - Where to read what the compiler cannot compute.
+ * @returns The node test and the edge test, either null when the tree is silent about it.
+ * @throws A `GraphtyError` when the tree needs a capability the sources lack.
+ */
+export declare function compileFilter(graph: GraphSnapshot, filter: RuleTree, sources: FilterSources): CompiledHalves;
 /**
  * Turn a filter and a time window into the two tests a pass runs.
  *
@@ -219,7 +254,7 @@ export declare function assertVisibility(filter: Filter | null, window: TimeWind
  * @returns The compiled tests, and the door to the unresolved paths once a pass has run.
  * @throws A `GraphtyError` when either is malformed or needs a capability this session lacks.
  */
-export declare function compileVisibility(graph: GraphSnapshot, filter: Filter | null, window: TimeWindow | null, sources: FilterSources): CompiledVisibility;
+export declare function compileVisibility(graph: GraphSnapshot, filter: RuleTree | null, window: TimeWindow | null, sources: FilterSources): CompiledVisibility;
 /** Everything one pass of the compiled tests writes into. */
 export interface VisibilityPass {
     /** The snapshot the tests were compiled against. */

package/dist/src/session/visibility/index.d.ts

@@ -12,5 +12,5 @@
  *
  * Nothing in this module's import graph reaches Babylon.js, Lit or the DOM.
  */
-export { assertVisibility, type CompiledVisibility, compileVisibility, type ElementTest, type Filter, type FilterDirection, type FilterSources, type FilterValueSource, runPass, runPassInSlices, type TimeStep, type TimeWindow, type VisibilityPass, } from "./filter";
+export { assertVisibility, type CompiledVisibility, compileVisibility, type ElementTest, type FilterSources, type FilterValueSource, type RuleTree, runPass, runPassInSlices, type TimeStep, type TimeWindow, type VisibilityPass, } from "./filter";
 export { createVisibilityApi, type FilterResult, type SessionVisibilityApi, type VisibilityApi, type VisibilityChange, type VisibilitySources, type VisibilitySummary, } from "./VisibilityApi";

package/dist/src/testing/fakeAccelerator.d.ts

@@ -66,6 +66,11 @@ interface FakeAcceleratorCalls {
     dispose: number;
     /** The snapshots handed to `release()`, in call order. */
     release: GraphSnapshot[];
+    /**
+     * The snapshots handed to an algorithm member, in call order: what a real accelerator would
+     * have uploaded and keeps resident until it is released. A release test compares the two.
+     */
+    uploaded: GraphSnapshot[];
     /** How many times a simulation was loaded. */
     load: number;
     /** How many batches were SUBMITTED; a coalesced `step()` does not count. */

package/dist/src/utils/queue-migration.d.ts

@@ -1,3 +1,4 @@
+import type { ScopeInput } from "../catalog/types";
 import type { OperationCategory } from "../managers/OperationQueueManager";
 export interface QueueableOptions {
     /**
@@ -17,6 +18,22 @@ export interface QueueableOptions {
      */
     respectProgress?: boolean;
 }
+/**
+ * What `setLayout` accepts as its third argument: the queue options, and what the layout runs over.
+ */
+export interface SetLayoutOptions extends QueueableOptions {
+    /**
+     * What the layout runs over. The scope's nodes move and every other node is held still; a node
+     * added after the layout starts is held too, because the members are the ones the scope had
+     * when the layout started.
+     *
+     * CARRIED: absent keeps the scope the last layout ran over, so changing one option never
+     * un-scopes a layout; `"graph"` clears it. Only a live simulation accepts one -- a layout
+     * whose catalogue entry reads `scoped: false` refuses it with `E_UNSUPPORTED` -- and a scope
+     * that is malformed or names a removed set is refused with `E_BAD_COMMAND`.
+     */
+    scope?: ScopeInput;
+}
 /**
  * Algorithm-specific options (source, target, startNode, etc.)
  * These are passed through to the algorithm's configure method.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphty/graphty-element",
-  "version": "2.5.2",
+  "version": "2.6.1",
   "description": "A Web Component library for 3D/2D graph visualization built with Lit and Babylon.js",
   "type": "module",
   "customElements": "./dist/custom-elements.json",
@@ -115,26 +115,31 @@
     "@types/lodash": "^4.17.19",
     "@types/papaparse": "^5.5.0",
     "@types/toposort": "^2.0.7",
+    "@vitest/browser-playwright": "4.1.11",
     "ai": "^5.0.104",
     "encrypt-storage": "^2.14.7",
+    "eslint": "^9.29.0",
     "eslint-plugin-jsdoc": "^50.6.17",
     "fast-check": "^4.2.0",
     "iwer": "^2.1.1",
     "lit": "^3.3.1",
     "lodash": "^4.17.21",
     "ngraph.random": "^1.2.0",
-    "pngjs": "^7.0.0",
     "storybook": "^9.1.20",
+    "tsx": "^4.21.0",
     "typedoc": "^0.28.15",
     "typedoc-plugin-markdown": "^4.9.0",
     "typedoc-vitepress-theme": "^1.1.2",
     "typescript": "^5.9.3",
+    "typescript-eslint": "^8.34.1",
+    "vite": "^7.0.0",
     "vite-plugin-cem": "^0.8.2",
     "vite-plugin-eslint": "^1.8.1",
     "vitepress": "^1.6.3",
-    "vitest": "^3.2.4",
-    "@graphty/remote-logger": "^1.3.8",
-    "@graphty/webgpu-graph-algorithms": "^0.6.9"
+    "vitest": "4.1.11",
+    "@graphty/remote-logger": "^1.3.10",
+    "@graphty/graph-samples": "^0.1.6",
+    "@graphty/webgpu-graph-algorithms": "^0.6.11"
   },
   "peerDependencies": {
     "@ai-sdk/anthropic": "^2.0.50",
@@ -146,7 +151,7 @@
     "ai": "^5.0.104",
     "encrypt-storage": "^2.14.7",
     "lit": "^3.0.0",
-    "@graphty/webgpu-graph-algorithms": "^0.6.9"
+    "@graphty/webgpu-graph-algorithms": "^0.6.11"
   },
   "peerDependenciesMeta": {
     "@ai-sdk/anthropic": {
@@ -184,9 +189,9 @@
     "papaparse": "^5.5.3",
     "toposort": "^2.0.2",
     "zod": "^3.25.28",
-    "@graphty/algorithms": "^2.0.6",
-    "@graphty/graph-format": "^1.0.7",
-    "@graphty/layout": "^1.10.2"
+    "@graphty/graph-format": "^1.1.1",
+    "@graphty/algorithms": "^2.1.1",
+    "@graphty/layout": "^1.10.4"
   },
   "overrides": {
     "storybook": "$storybook"
@@ -245,6 +250,7 @@
     "coverage:fast": "vitest run --project=default --coverage",
     "coverage:preview": "npx serve coverage -p ${PORT:?start it through servherd, which sets PORT}",
     "lint": "eslint && tsc --noEmit && npm run typecheck:strict-consumer",
+    "benchmark": "tsx benchmarks/run.ts",
     "typecheck:strict-consumer": "tsc -p tsconfig.strict-consumer.json",
     "lint:fix": "eslint --fix",
     "lint:knip": "cd .. && ./tools/run-knip.sh --workspace graphty-element",