@graphty/graphty-element 2.5.1 → 2.6.0

package/dist/src/session/selection/targets.d.ts

@@ -28,7 +28,7 @@
  * Nothing here reaches Babylon.js, Lit or the DOM.
  */
 import { type GraphSnapshot } from "@graphty/graph-format";
-import type { EdgeId, NodeId, Path, Query, Scope } from "../../catalog/types";
+import type { EdgeId, NodeId, Path, Query, ScopeInput, SelectionDirection } from "../../catalog/types";
 import type { ResultsApi, RunRef } from "../results/types";
 import { ElementMask, type MaskIdSpace } from "../scope/ElementMask";
 import type { ScopeResolver } from "../scope/ScopeApi";
@@ -42,8 +42,7 @@ import type { ScopeResolver } from "../scope/ScopeApi";
  *   ignoring case. A key no node carries is searched as plain substring text.
  */
 export type SelectionTextMode = "substring" | "exact" | "regex" | "attribute";
-/** Which way a neighbourhood target follows an edge. */
-export type SelectionDirection = "in" | "out" | "all";
+export type { SelectionDirection } from "../../catalog/types";
 /** Elements named outright, by the ids a consumer already holds. */
 export interface ElementIdTarget {
     /** The nodes. Ids the graph no longer holds are ignored, the way a scope ignores them. */
@@ -81,7 +80,7 @@ export type SelectionTarget = ElementIdTarget | NeighborhoodTarget
 /** Every element a predicate matches, narrowed to a scope when one is named. */
  | {
     readonly where: Query;
-    readonly scope?: Scope;
+    readonly scope?: ScopeInput;
 }
 /**
  * Every node a text search finds, narrowed to a scope when one is named.
@@ -94,15 +93,15 @@ export type SelectionTarget = ElementIdTarget | NeighborhoodTarget
  | {
     readonly text: string;
     readonly mode?: SelectionTextMode;
-    readonly scope?: Scope;
+    readonly scope?: ScopeInput;
 }
 /** A pasted list of ids, which may name nodes, edges, or nothing at all. */
  | {
     readonly ids: readonly string[];
 }
-/** Everything a scope covers. */
+/** Everything a scope covers. An inline `{ define }` may name edges by session edge id. */
  | {
-    readonly scope: Scope;
+    readonly scope: ScopeInput;
 }
 /**
  * The highest-ranked elements of a finished run. A tie group is taken whole and only when it

package/dist/src/session/sets/SetsApi.d.ts

@@ -0,0 +1,110 @@
+/**
+ * @file The synchronous doors of `session.sets`: the reads that only look at records and the
+ * writes that resolve nothing (design/sets/sets-design.md sections 13.2, 13.3, 15.2).
+ *
+ * Each write door does the one thing a pure `prepare` cannot: it reaches the graph to turn a
+ * session edge id into the edge's stable identity, and it mints the id and the order. Then, in one
+ * store write group, it prepares one operation and writes the result. A no-op writes nothing and
+ * emits nothing.
+ *
+ * Built by the session and published on it as `session.sets`.
+ */
+import { type GraphSnapshot } from "@graphty/graph-format";
+import type { EdgeId, EdgeMember, RuleTree, RunId, Scope, SetCreatedFrom, SetDefinitionInput, SetId } from "../../catalog/types";
+import type { SessionAttributes } from "../types";
+import { type Materialiser } from "./algebra";
+import { type DependencySources } from "./dependencies";
+import type { Offering } from "./offers";
+import { type StatusRun, type StatusSources } from "./status";
+import { SetsStore } from "./store";
+import type { SetsApi, SetUser } from "./types";
+/** What the doors read from the rest of the session. */
+interface SetsDependencies {
+    /**
+     * A session edge's stable identity.
+     * @param id - The session edge id.
+     * @returns The member, or undefined when the graph holds no such edge.
+     */
+    edgeMember(id: EdgeId): EdgeMember | undefined;
+    /**
+     * Whether the graph's edge pairs are ordered (it was declared directed at ingest). False: an
+     * edge member given in stable form is stored with its ends in canonical order, so both
+     * spellings of one undirected edge are one member. Absent: members are stored as given.
+     */
+    readonly pairsOrdered?: () => boolean;
+    /** The most edge members one member edit may touch. */
+    readonly maxEdgeMembers?: number;
+    /**
+     * Where the references a rule makes are looked up (kept sets, saved scopes, the visibility
+     * filter), so a write that would make a cycle is refused. Absent: the kept sets alone.
+     */
+    readonly dependencies?: DependencySources;
+    /** The runs, for status and "Used by". Absent: no run exists. */
+    readonly runs?: {
+        get(id: RunId): StatusRun | undefined;
+        list(): readonly StatusRun[];
+    };
+    /** What the last pass over a kept set found. Absent: status reads no pass. */
+    readonly outcome?: StatusSources["outcome"];
+    /**
+     * The resolve step of `createFrom`, `combine` and `createPath`. Absent: those doors refuse
+     * with `E_UNSUPPORTED`.
+     */
+    readonly materialise?: Materialiser;
+    /** Offers and Memberships. Absent: `offers` and `containing` refuse with `E_UNSUPPORTED`. */
+    readonly offering?: Pick<Offering, "offers" | "memberships">;
+    /**
+     * The token of a run's current execution, which an offer must still hold. Absent: the
+     * `runs` dependency's, else no execution is current and every offer is stale.
+     * @param run - The run.
+     * @returns The token, or undefined when the run has no result.
+     */
+    readonly executionOf?: (run: RunId) => string | undefined;
+    /**
+     * The live users of sets beyond kept sets and runs (style layers and the visibility filter),
+     * each with the scope or filter tree it names, for `usedBy`. Absent: none.
+     * @returns The users.
+     */
+    readonly users?: () => Iterable<{
+        readonly user: SetUser;
+        readonly scope: Scope | RuleTree;
+    }>;
+}
+/**
+ * A session edge's stable identity, read from the current snapshot: its file id at the configured
+ * `edgeIdPath` when there is one, else its ordinal among its pair's edges in its load, else the id
+ * minted from its counter.
+ * @param snapshot - The current snapshot.
+ * @param id - The session edge id.
+ * @param attributes - The edge's attribute bag by row, where the file id is read.
+ * @param edgeIdPath - The configured file-id path, or null.
+ * @returns The member, or undefined when the snapshot holds no such edge.
+ */
+export declare function sessionEdgeMember(snapshot: GraphSnapshot, id: EdgeId, attributes: (row: number) => SessionAttributes | undefined, edgeIdPath: string | null): EdgeMember | undefined;
+/**
+ * Keep a definition, recording what it was created from: the door the element's own verbs (a
+ * promoted selection) dispatch through, since the published `create` always records `user`.
+ * Internal.
+ * @param api - Doors {@link createSetsApi} built.
+ * @param definition - The definition.
+ * @param name - The name; "Set N" when absent.
+ * @param createdFrom - What the set was created from.
+ * @returns The minted id.
+ * @throws An Error for doors it did not build; otherwise as `create` refuses.
+ */
+export declare function createSetAs(api: SetsApi, definition: SetDefinitionInput, name: string | undefined, createdFrom: SetCreatedFrom): SetId;
+/**
+ * The store behind a set of doors, for the internal readers that resolve kept sets. Internal.
+ * @param api - Doors {@link createSetsApi} built.
+ * @returns The store.
+ * @throws An Error for doors it did not build.
+ */
+export declare function setsStoreOf(api: SetsApi): SetsStore;
+/**
+ * Build the synchronous doors over a store.
+ * @param dependencies - Where session edge ids are looked up.
+ * @param store - The slice; a fresh one when absent.
+ * @returns The doors.
+ */
+export declare function createSetsApi(dependencies: SetsDependencies, store?: SetsStore): SetsApi;
+export {};

package/dist/src/session/sets/algebra.d.ts

@@ -0,0 +1,124 @@
+/**
+ * @file Set algebra and the resolve step of the materialising doors (design/sets/sets-design.md
+ * sections 4.1, 5.1, 7 and 13.3).
+ *
+ * `combineMasks` is the edge rule of section 7 over bitmaps: every operand induced gives an
+ * induced result, anything else is edge-first. The {@link Materialiser} is the asynchronous half
+ * of `createFrom`, `combine` and `createPath`: it resolves its source against the current graph
+ * and builds a concrete fixed or path definition with every edge member already in stable form,
+ * so the synchronous commit that follows only sorts, interns and freezes.
+ *
+ * Nothing here mints, names or writes: the doors do that in one tick after this resolves.
+ *
+ * Node-safe.
+ */
+import { type GraphSnapshot, type U32 } from "@graphty/graph-format";
+import type { EdgeId, EdgeMember, EdgeReading, NodeId, Scope, SetCombine, SetCreatedFrom, SetDefinition } from "../../catalog/types";
+import type { ElementMask } from "../scope/ElementMask";
+import type { Offering } from "./offers";
+import { type Resolution } from "./resolve";
+import type { SetOffer } from "./types";
+/** The four combinations, in the order the doors check them. */
+export declare const SET_COMBINES: readonly SetCombine[];
+/** One operand of a combination: its two bitmaps, and whether it reads `induced`. */
+export interface AlgebraOperand {
+    readonly nodes: U32;
+    readonly edges: U32;
+    readonly induced: boolean;
+}
+/**
+ * Combine resolved operands by the edge rule of design 7. Every operand induced: the nodes are the
+ * op on the node bitmaps and the edges are induced from them. Otherwise edge-first: the edges are
+ * the op on the edge bitmaps and the nodes are the op on the node bitmaps plus those edges'
+ * endpoints, so every member edge keeps both endpoints.
+ * @param op - The combination.
+ * @param operands - Two or more operands over one snapshot.
+ * @param graph - The snapshot.
+ * @returns The combined bitmaps.
+ */
+export declare function combineMasks(op: SetCombine, operands: readonly AlgebraOperand[], graph: GraphSnapshot): AlgebraOperand;
+/** A source resolved into what `set.create` records: nothing minted, every edge member stable. */
+export interface Concrete {
+    /** A fixed or path definition in stable form. */
+    readonly definition: SetDefinition;
+    /** Each edge member with the session edge it came from, so the door can seed it (design 4.2). */
+    readonly refs: readonly (readonly [EdgeId, EdgeMember])[];
+    /**
+     * The seeds of a prebuilt definition, member key to counter, built in the asynchronous step so
+     * the commit adopts them instead of computing one key per member.
+     */
+    readonly seeds?: ReadonlyMap<string, number>;
+    readonly createdFrom: SetCreatedFrom;
+}
+/** The resolve step of the materialising doors. Injectable, so a test can hold it open. */
+export interface Materialiser {
+    /**
+     * A scope's or an offer's current members as a fixed definition (design 15.2 `createFrom`
+     * defaults; an offer keeps its reading and is created from `result`).
+     * @param source - A canonical scope, or an offer.
+     * @param reading - The caller's reading, or undefined for the default.
+     * @returns The concrete definition.
+     */
+    from(source: Scope | SetOffer, reading: EdgeReading | undefined): Promise<Concrete>;
+    /**
+     * Two or more scopes combined into a fixed definition (design 7).
+     * @param op - The combination.
+     * @param of - Canonical scopes.
+     * @param reading - The caller's reading, or undefined for the default.
+     * @returns The concrete definition.
+     */
+    combine(op: SetCombine, of: readonly Scope[], reading: EdgeReading | undefined): Promise<Concrete>;
+    /**
+     * The selected edges ordered into a walk, or a path offer in its result's order.
+     * @param source - `"selection"`, or a path offer.
+     * @returns The concrete path definition.
+     */
+    path(source: "selection" | SetOffer): Promise<Concrete>;
+}
+/** What the resolve step reads from the session. */
+interface MaterialiseSources {
+    /** The current snapshot. */
+    snapshot(): GraphSnapshot;
+    /**
+     * A scope's resolution against the current snapshot.
+     * @param scope - A canonical scope.
+     * @returns The resolution and the snapshot it was resolved against.
+     * @throws A `GraphtyError` when the scope cannot be resolved.
+     */
+    resolve(scope: Scope): {
+        readonly resolution: Resolution;
+        readonly graph: GraphSnapshot;
+    };
+    /**
+     * How a scope reads, following a `{ set }` to its definition.
+     * @param scope - A canonical scope.
+     * @returns The reading.
+     */
+    readingOf(scope: Scope): EdgeReading;
+    /**
+     * A session edge's stable identity.
+     * @param id - The session edge id.
+     * @returns The member, or undefined when the graph holds no such edge.
+     */
+    edgeMember(id: EdgeId): EdgeMember | undefined;
+    /** The selection's two masks, synced to the current snapshot. Absent refuses `"selection"`. */
+    readonly selection?: () => {
+        readonly nodes: ElementMask<NodeId>;
+        readonly edges: ElementMask<EdgeId>;
+    };
+    /** The offers' edge-count pass and path order. Absent: an offer resolves, and counts nothing. */
+    readonly offering?: Pick<Offering, "countEdges" | "orderOf">;
+}
+/**
+ * Whether a source is an offer rather than a scope.
+ * @param source - A scope or an offer.
+ * @returns True for an offer.
+ */
+export declare function isOffer(source: unknown): source is SetOffer;
+/**
+ * Build the resolve step over a session.
+ * @param sources - What it reads.
+ * @returns The resolve step.
+ */
+export declare function createMaterialiser(sources: MaterialiseSources): Materialiser;
+export {};

package/dist/src/session/sets/cache.d.ts

@@ -0,0 +1,197 @@
+/**
+ * @file The resolution cache, the summary cache and the cached resolver of kept sets
+ * (design/sets/sets-design.md section 6.2).
+ *
+ * RESOLUTIONS are pulled, never pushed: nothing is recomputed until something reads it. An entry
+ * is keyed by what was resolved -- a kept set's frozen definition, or an inline scope's canonical
+ * key -- and holds the one resolution of the latest input signature (`./signature`) it was asked
+ * under. A read under another signature misses and replaces it, so an entry of an older serial is
+ * never served. Keying a kept set by its definition rather than its record is what lets a rename
+ * hit, and an undo that restores the identical record hit again.
+ *
+ * The cache is bounded in BYTES, not entries: 64 MB by default, counted as the byte length of each
+ * entry's two bitmaps (no two entries share one). Entries whose key is pinned (a style layer or the
+ * visibility filter names it) are counted separately and never evicted, and may exceed the bound;
+ * unpinned entries may use whatever the pins leave, and never less than 16 MB, so runs and counts
+ * do not thrash. Eviction is least recently used first.
+ *
+ * SUMMARIES hold one entry per kept set id: the latest signature and its counts, so a panel
+ * counting 200 sets never needs 200 resolutions resident and nothing grows under streaming data.
+ *
+ * OFFER COUNTS hold one entry per run: what `./offers` counted of the run's current execution
+ * over one snapshot. They are keyed by the run and valid for exactly one (execution, store,
+ * snapshot serial); anything else misses and replaces the entry.
+ *
+ * Nothing here reaches Babylon.js, Lit or the DOM.
+ */
+import type { SetDefinition, SetId } from "../../catalog/types";
+import { type Resolution, type ResolveContext } from "./resolve";
+import { type SignatureMemo } from "./signature";
+/** Counts the cache tests read. */
+export declare const cacheCounters: {
+    hits: number;
+    misses: number;
+    evictions: number;
+};
+/**
+ * A kept set's counts under one signature, and the outcome of the pass that produced them, which
+ * status reads without resolving.
+ */
+interface SetSummary {
+    readonly signature: string;
+    /** The definition the pass resolved, so an outcome is never read for a later definition. */
+    readonly definition: SetDefinition;
+    readonly nodeCount: number;
+    readonly edgeCount: number;
+    readonly missingNodes: number;
+    readonly missingEdges: number;
+    readonly ambiguousEdges: number;
+    /** Why the pass resolved nothing, when it could not evaluate the definition. */
+    readonly problem?: Resolution["problem"];
+}
+/**
+ * What `./offers` counted of one run's execution over one snapshot: members per item key, and the
+ * edge-count pass once it has run.
+ */
+export interface OfferCounts {
+    readonly execution: string | undefined;
+    /** Identity of the store the snapshot came from. */
+    readonly store: number;
+    readonly serial: number;
+    /** Item key (`itemKeyOf`) to its value and the nodes whose values name it. */
+    readonly nodes: ReadonlyMap<string, {
+        readonly value: string | number | boolean;
+        readonly count: number;
+    }>;
+    /** The edge-count pass: item key to its edges and, read `listed`, its nodes with the edges' endpoints. */
+    pass?: ReadonlyMap<string, {
+        readonly edges: number;
+        readonly nodes: number;
+    }>;
+}
+/** One session's resolution cache, its summaries and its signature memo. */
+export declare class SetsCache {
+    private readonly options;
+    /** The signature memo every resolution through this cache shares. */
+    readonly memo: SignatureMemo;
+    /** Summaries by set id. */
+    readonly summaries: Map<string, SetSummary>;
+    /** Offer counts by run id. */
+    readonly offers: Map<string, OfferCounts>;
+    /** Entries, least recently used first. */
+    private readonly entries;
+    /** How many holders pin each key. */
+    private readonly pins;
+    private unpinned;
+    private pinned;
+    /**
+     * An empty cache.
+     * @param options - The bounds.
+     * @param options.limit - The byte bound; {@link RESOLUTION_BYTES} by default.
+     * @param options.reserve - The bytes always left to unpinned entries; {@link UNPINNED_RESERVE_BYTES}.
+     */
+    constructor(options?: {
+        readonly limit?: number;
+        readonly reserve?: number;
+    });
+    /**
+     * The bytes cached, pinned and unpinned.
+     * @returns The byte count.
+     */
+    get bytes(): number;
+    /**
+     * The bytes pinned entries hold.
+     * @returns The byte count.
+     */
+    get pinnedBytes(): number;
+    /**
+     * How many entries are cached.
+     * @returns The count.
+     */
+    get size(): number;
+    /**
+     * Every cached resolution with its key, least recently used first. For the accounting test.
+     * @returns The entries.
+     */
+    cached(): [unknown, Resolution][];
+    /**
+     * The resolution cached for a key under a signature.
+     * @param key - What was resolved.
+     * @param signature - Its input signature now.
+     * @returns The resolution, or undefined on a miss.
+     */
+    lookup(key: unknown, signature: string): Resolution | undefined;
+    /**
+     * The resolution cached for a key under a signature, counting nothing and moving nothing: for
+     * a reader that only uses a resolution when one happens to be there.
+     * @param key - What was resolved.
+     * @param signature - Its input signature now.
+     * @returns The resolution, or undefined when none is cached under that signature.
+     */
+    peek(key: unknown, signature: string): Resolution | undefined;
+    /**
+     * Cache a resolution, replacing the key's entry, then evict past the bound.
+     * @param key - What was resolved.
+     * @param signature - The signature it was resolved under.
+     * @param resolution - The resolution.
+     */
+    store(key: unknown, signature: string, resolution: Resolution): void;
+    /**
+     * Pin a key: its entry is never evicted while any pin holds.
+     * @param key - The key.
+     * @returns A function that releases this pin.
+     */
+    pin(key: unknown): () => void;
+    /**
+     * Count an entry's bytes in its bucket.
+     * @param key - Its key.
+     * @param bytes - Its bytes; negative to uncount.
+     */
+    private account;
+    /**
+     * Remove a key's entry.
+     * @param key - The key.
+     */
+    private drop;
+    /** Evict unpinned entries, least recently used first, while they are over their budget. */
+    private evict;
+}
+/**
+ * What a kept set covers, through the context's cache when it has one. Also records the set's
+ * summary.
+ * @param record - The set: its id and frozen definition.
+ * @param record.id - Its id.
+ * @param record.definition - Its definition.
+ * @param context - What the resolution reads; `context.cache` is consulted when present.
+ * @returns The resolution.
+ */
+export declare function resolveSet(record: {
+    readonly id: SetId;
+    readonly definition: SetDefinition;
+}, context: ResolveContext): Resolution;
+/**
+ * A kept set's counts: from its summary while the signature holds, else resolved.
+ * @param record - The set.
+ * @param record.id - Its id.
+ * @param record.definition - Its definition.
+ * @param context - What the resolution reads; needs `context.cache`.
+ * @returns The counts.
+ */
+export declare function countsOf(record: {
+    readonly id: SetId;
+    readonly definition: SetDefinition;
+}, context: ResolveContext): Pick<SetSummary, "nodeCount" | "edgeCount" | "missingNodes" | "missingEdges">;
+/**
+ * What the last pass over a kept set found, when that pass resolved its current definition: why it
+ * resolved nothing, and how many edge members more than one edge carries. Never resolves.
+ * @param cache - The cache.
+ * @param record - The set.
+ * @param record.id - Its id.
+ * @param record.definition - Its definition.
+ * @returns The outcome, or undefined when no pass has resolved this definition.
+ */
+export declare function outcomeOf(cache: SetsCache, record: {
+    readonly id: SetId;
+    readonly definition: SetDefinition;
+}): Pick<SetSummary, "problem" | "ambiguousEdges"> | undefined;
+export {};

package/dist/src/session/sets/captures.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @file Held-item captures (design/sets/sets-design.md section 5.2).
+ *
+ * A rule's `item` leaf that carries a `run` HOLDS that run (execution) of its result. When the run
+ * re-executes in place, the values that execution published are replaced, so before they go the
+ * re-run captures the members of every item a live reference holds: a sorted id list per item,
+ * stored on the run under the execution, as `held: { [execution]: { [itemKey]: capture } }`. The
+ * holding reference then resolves to the capture and reads "Earlier run".
+ *
+ * A capture is STATE, not cache: it is written only by a run command (a re-run), and each run
+ * command carries a capture forward only while live state still holds its execution. Nothing
+ * prunes it from anywhere else, so what a saved file holds never depends on when something ran.
+ * With no capture (a file written without it), the reference resolves to nothing and its status
+ * says `values-not-kept`.
+ *
+ * Nothing here reaches Babylon.js, Lit or the DOM.
+ */
+import { type GraphSnapshot } from "@graphty/graph-format";
+import type { EdgeMember, ItemKey, NodeId, ResultItem, RunId } from "../../catalog/types";
+import type { CapturedHalves, FilterRunResult } from "../visibility/filter";
+import { type EdgeMemberList } from "./prepare";
+import { type ResolveContext } from "./resolve";
+/** One held item's members, as a re-run captured them. Frozen. */
+export interface Capture {
+    /** Present when the item's field lives on nodes: the node ids, sorted. */
+    readonly nodes?: readonly NodeId[];
+    /**
+     * Present when it lives on edges: the edges' stable identities, sorted by key, in the compact
+     * column form a fixed set holds them in.
+     */
+    readonly edges?: EdgeMemberList;
+}
+/** One run's captures: by held execution, then by item key ({@link itemKeyOf}). */
+export type HeldCaptures = ReadonlyMap<string, ReadonlyMap<string, Capture>>;
+/**
+ * An item key as a string: the field, and the value with its type, so `1` and `"1"` differ.
+ * @param key - The key.
+ * @returns The string.
+ */
+export declare function itemKeyOf(key: ItemKey): string;
+/**
+ * The items of one run that the holders hold by execution, in the definitions, scopes and rule
+ * trees given and the definitions they carry inline.
+ * @param holders - Definitions, scopes or rule trees (kept sets' definitions, the visibility filter).
+ * @param run - The run.
+ * @returns Execution to item key to key.
+ */
+export declare function heldItems(holders: Iterable<unknown>, run: RunId): Map<string, Map<string, ItemKey>>;
+/**
+ * The members one item of a result holds now, as a capture.
+ * @param result - The run's current result, by dense index.
+ * @param key - The item's key.
+ * @param snapshot - The snapshot the result is read against.
+ * @param edgeMemberOf - An edge row's stable identity.
+ * @returns The capture: a half only where the result publishes the field per element.
+ */
+export declare function captureItem(result: FilterRunResult, key: ItemKey, snapshot: GraphSnapshot, edgeMemberOf: (row: number) => EdgeMember | undefined): Capture;
+/**
+ * The captures a re-run leaves on its run: for every item a holder holds, the capture of the
+ * execution being replaced when it is that one, else the one already kept. An execution nothing
+ * holds any more is not carried forward.
+ * @param prior - The run's captures before the re-run.
+ * @param held - What the holders hold of this run ({@link heldItems}).
+ * @param current - The execution being replaced, or undefined when the run has no result.
+ * @param capture - Captures one item of the result being replaced; absent when there is none.
+ * @returns The run's captures after the re-run.
+ */
+export declare function nextCaptures(prior: HeldCaptures, held: ReadonlyMap<string, ReadonlyMap<string, ItemKey>>, current: string | undefined, capture: ((key: ItemKey) => Capture) | undefined): HeldCaptures;
+/**
+ * The capture a run keeps for one held item, if any.
+ * @param captures - The run's captures.
+ * @param item - The item, with its execution.
+ * @returns The capture, or undefined.
+ */
+export declare function captureOf(captures: HeldCaptures, item: ResultItem): Capture | undefined;
+/**
+ * A capture as bitmaps over the context snapshot, rebound like a fixed set's members: node ids
+ * through the id map, edges by stable identity. Memoised per capture and snapshot.
+ * @param capture - The capture.
+ * @param context - What the resolution reads.
+ * @returns The halves.
+ */
+export declare function capturedHalves(capture: Capture, context: ResolveContext): CapturedHalves;