@graphty/graphty-element 2.5.2 → 2.6.0

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

@@ -0,0 +1,209 @@
+/**
+ * @file The five set operations as pure functions over the current records (design/sets/sets-design.md
+ * sections 4.6, 12.5, 13.2).
+ *
+ * Each `prepare*` takes the records and one concrete command -- everything minted (id, order) and
+ * everything resolved (stable edge members) already in it -- and returns the record to write, or
+ * null for a no-op. It validates, clones, canonicalises and deep-freezes, and carries any top-level
+ * record field it does not know through unchanged. It never writes: the store does, so a future
+ * command dispatcher can call the same functions and record their output.
+ *
+ * Also here, because every record is built here: the compact form of a fixed set's edge members
+ * (typed arrays over an interned id table, materialised as `definition.edges` on first read), the
+ * member summaries a member delta updates in O(delta), and the memoised revision.
+ *
+ * Pure and Node-safe.
+ */
+import type { EdgeMember, NodeId, SetCreatedFrom, SetDefinition, SetId } from "../../catalog/types";
+import type { ElementSet } from "./types";
+/**
+ * The most edge members a member edit may touch. A step of undo history keeps the prior and next
+ * record whole, about 24 bytes per edge member, so edits above this wait for a per-member op log.
+ */
+export declare const MAX_EDGE_MEMBER_EDIT = 1000000;
+/**
+ * Invocation counts the complexity tests read (design/sets plan 1.4). Internal; never reset here.
+ * - `interns`: ids looked up in or added to an edge-column id table, three or fewer a member.
+ */
+export declare const prepareCounters: {
+    interns: number;
+};
+/** What the prepare functions read: the live records. */
+export interface RecordView {
+    /**
+     * One live record.
+     * @param id - Its id.
+     * @returns The record, or undefined.
+     */
+    get(id: SetId): ElementSet | undefined;
+    /**
+     * Every live record, in any order.
+     * @returns The records.
+     */
+    values(): Iterable<ElementSet>;
+}
+/**
+ * The name the element picks when none is given: "Set N" for the smallest free N.
+ * @param records - The records.
+ * @returns The name.
+ */
+export declare function defaultName(records: RecordView): string;
+/**
+ * Edge members read one at a time, without materialising them all: an array, or a fixed set's
+ * compact columns, which build each member only when it is read. Internal.
+ */
+export interface EdgeMemberList {
+    readonly length: number;
+    /**
+     * One member.
+     * @param index - Its position.
+     * @returns The member, or undefined past the end.
+     */
+    at(index: number): EdgeMember | undefined;
+}
+/**
+ * The first kind or field of a definition this element does not know, or null. A definition a
+ * door built is known to be null; any other (a restored one) is checked once and remembered.
+ * @param definition - The definition.
+ * @returns The name, or null.
+ */
+export declare function opaqueName(definition: SetDefinition): string | null;
+/**
+ * A listed fixed definition built from members the element read off a snapshot, canonical and
+ * frozen in the compact column form. The work a caller's definition needs at the synchronous
+ * commit (validating, canonicalising, sorting, interning) happens here instead, so a materialising
+ * door does it in its asynchronous step. Internal.
+ * @param nodes - Node ids, any order.
+ * @param members - Stable edge members with their ends already canonical, any order.
+ * @returns The frozen definition, which `set.create` stores as it is.
+ */
+export declare function prebuiltListed(nodes: readonly NodeId[], members: readonly EdgeMember[]): SetDefinition;
+/**
+ * Whether a value is a definition {@link prebuiltListed} built. Internal.
+ * @param definition - The value.
+ * @returns True when it is.
+ */
+export declare function isPrebuilt(definition: unknown): definition is SetDefinition;
+/**
+ * A record restored from stored state (a file, an undo step): validated in load mode, so an
+ * unknown kind or field is kept and the definition is opaque. Unknown top-level fields are kept.
+ * @param value - The stored record `{ id, name, order, definition, createdFrom, ... }`.
+ * @returns The frozen record, ready for the store's `put`.
+ * @throws `E_BAD_COMMAND` for a record missing a field or holding a malformed known node.
+ */
+export declare function loadRecord(value: unknown): ElementSet;
+/** `set.create`, concrete: everything minted and resolved. */
+interface CreateCommand {
+    readonly id: SetId;
+    readonly name: string;
+    readonly order: number;
+    /** Edge members in stable form. */
+    readonly definition: unknown;
+    readonly createdFrom: SetCreatedFrom;
+}
+/**
+ * `set.create`.
+ * @param records - The records.
+ * @param command - The concrete command.
+ * @returns The new record.
+ * @throws `E_BAD_COMMAND` for a bad name, a live id or a malformed definition; `E_DUPLICATE_ID`
+ * for a taken name.
+ */
+export declare function prepareCreate(records: RecordView, command: CreateCommand): ElementSet;
+/**
+ * `set.rename`. Keeps the id, the definition (so the revision) and every unknown field.
+ * @param records - The records.
+ * @param command - The set and its new name.
+ * @param command.id - The set.
+ * @param command.name - The new name.
+ * @returns The new record, or null when the trimmed name is the current one.
+ * @throws `E_BAD_COMMAND` for an unknown id or an empty name; `E_DUPLICATE_ID` for a taken name.
+ */
+export declare function prepareRename(records: RecordView, command: {
+    readonly id: SetId;
+    readonly name: string;
+}): ElementSet | null;
+/**
+ * `set.redefine`. A redefine that changes only a fixed set's reading shares the prior member
+ * arrays, so history copies nothing.
+ * @param records - The records.
+ * @param command - The set and its new definition, edge members stable.
+ * @param command.id - The set.
+ * @param command.definition - The new definition.
+ * @returns The new record, or null when the canonical definition is unchanged.
+ * @throws `E_BAD_COMMAND` for an unknown id or a malformed definition; `E_UNSUPPORTED` for an
+ * opaque prior definition.
+ */
+export declare function prepareRedefine(records: RecordView, command: {
+    readonly id: SetId;
+    readonly definition: unknown;
+}): ElementSet | null;
+/** `set.members`, concrete: members in stable form. */
+interface MembersCommand {
+    readonly id: SetId;
+    readonly add?: {
+        readonly nodes?: readonly NodeId[];
+        readonly edges?: readonly EdgeMember[];
+    };
+    readonly remove?: {
+        readonly nodes?: readonly NodeId[];
+        readonly edges?: readonly EdgeMember[];
+    };
+}
+/**
+ * `set.members`: remove, then add. Fixed sets only. Removing a node also removes every edge
+ * member incident to it. The revision's member sums move by exactly the members that changed.
+ * @param records - The records.
+ * @param command - The set and its delta.
+ * @param limit - The most edge members an edit may touch.
+ * @returns The new record, or null when every added member was present and every removed one absent.
+ * @throws `E_BAD_COMMAND` for an unknown id, a set that is not fixed or a malformed member;
+ * `E_UNSUPPORTED` for opaque content; `E_TOO_LARGE` above the edge-member limit.
+ */
+export declare function prepareMembers(records: RecordView, command: MembersCommand, limit?: number): ElementSet | null;
+/**
+ * `set.remove`: checks the set exists.
+ * @param records - The records.
+ * @param command - The set.
+ * @param command.id - Its id.
+ * @returns The id to delete.
+ * @throws `E_BAD_COMMAND` for an unknown id.
+ */
+export declare function prepareRemove(records: RecordView, command: {
+    readonly id: SetId;
+}): SetId;
+/**
+ * A fixed definition's listed edge members, read through its compact columns when it has them, so
+ * a resolution never materialises `definition.edges`.
+ * @param definition - A fixed definition.
+ * @returns The members.
+ */
+export declare function listedEdgesOf(definition: Extract<SetDefinition, {
+    kind: "fixed";
+}>): EdgeMemberList;
+/**
+ * Door-mode edge members in the compact column form a fixed set holds them in: about 20 bytes a
+ * member plus the interned ids, instead of an object each.
+ * @param members - Members with an id, or an ordinal with among.
+ * @returns The members, and the bytes they hold by the columns' accounting.
+ */
+export declare function compactEdgeMembers(members: readonly EdgeMember[]): EdgeMemberList & {
+    readonly bytes: number;
+};
+/**
+ * A record's size by this module's own accounting, which the scale tests hold to a budget: 64 bytes of
+ * fields plus two a name character, 8 a node member plus the edge columns for a fixed set, two a
+ * JSON character of the definition for anything else.
+ * @param record - The record.
+ * @returns The byte count.
+ */
+export declare function recordBytes(record: ElementSet): number;
+/**
+ * Whether a definition holds an edge member: a binary search over a fixed set's edge columns, a
+ * scan of anything else's edges (a path's steps, a restored fixed set).
+ * @param definition - The definition.
+ * @param member - A canonical member.
+ * @returns True when some edge member equals it.
+ */
+export declare function holdsEdgeMember(definition: SetDefinition, member: EdgeMember): boolean;
+export {};

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

@@ -0,0 +1,311 @@
+/**
+ * @file Synchronous bitmap resolution of every `Scope` form and of fixed definitions, and the
+ * edge-member binding a listed set and a path share (design/sets/sets-design.md sections 4.1,
+ * 4.2, 6.1, 6.3, 6.4 and 12.3).
+ *
+ * A resolution is two packed bitmaps in graph-format's mask layout, one over the context
+ * snapshot's nodes and one over its edges, tagged with the snapshot serial and the store it was
+ * resolved against. It is synchronous because the style and visibility passes need an answer
+ * inside the pass; the doors that resolve asynchronously wrap it.
+ *
+ * Every resolution satisfies the ENDPOINT INVARIANT: an edge bit is set only when both of its
+ * endpoints' node bits are. Readings are applied once, at the root: a chain of saved scopes
+ * resolves to a node half (plus the visible scope's edge constraint), and the root derives the
+ * edges from it.
+ *
+ * Nothing here reaches Babylon.js, Lit or the DOM.
+ */
+import { type GraphSnapshot, type U32 } from "@graphty/graph-format";
+import type { EdgeId, EdgeMember, NodeId, Path, Query, RunId, Scope, ScopeId, SetDefinition, SetId } from "../../catalog/types";
+import { GraphtyError } from "../../errors";
+import type { AttributeRevisions, InputTick } from "../attributes";
+import type { ElementMask } from "../scope/ElementMask";
+import { type CompiledHalves, type FilterSources, type FilterValueSource, type ScopeLeaf } from "../visibility/filter";
+import type { SetsCache } from "./cache";
+import { type EdgeMemberList } from "./prepare";
+/**
+ * Invocation counts the complexity tests read (design/sets plan 1.4). Internal; never reset here.
+ * - `edgePasses`: full passes over the edge list; `edgeRowVisits`: edge rows those passes read.
+ * - `maskPacks`: byte masks packed into bitmaps.
+ * - `digestSums`: masked sums over the hash columns.
+ * - `idSetBuilds`: id `Set`s materialised from a bitmap.
+ */
+export declare const resolveCounters: {
+    edgePasses: number;
+    edgeRowVisits: number;
+    maskPacks: number;
+    digestSums: number;
+    idSetBuilds: number;
+    /** Binding plans built: one per definition and seed version. */
+    bindingPlans: number;
+    /** Edge-id column scans that merged against the sorted seeded counters. */
+    bindMerges: number;
+    /** Edge-id column scans that binary-searched them, because the column was not monotonic. */
+    bindSearches: number;
+    /** Edge passes matching unseeded members by stable identity. */
+    identityPasses: number;
+};
+/** One resolution: what a scope or a definition covers in one snapshot. */
+export interface Resolution {
+    /** Node bitmap over the context snapshot's nodes. */
+    readonly nodes: U32;
+    /** Edge bitmap over the context snapshot's edges. Every set edge has both endpoints set. */
+    readonly edges: U32;
+    /** How many node bits are set. */
+    readonly nodeCount: number;
+    /** How many edge bits are set. */
+    readonly edgeCount: number;
+    /** The serial of the snapshot this was resolved against. */
+    readonly serial: number;
+    /** The store instance this was resolved against, or null when the context named none. */
+    readonly store: object | null;
+    /** Named node ids the graph does not hold, one per unresolved entry. */
+    readonly missingNodes: number;
+    /**
+     * Named edge members no edge matches; for a path, the steps none of whose edges are there.
+     */
+    readonly missingEdges: number;
+    /**
+     * Of the unmatched edge members, those more than one edge carries (`ambiguous-parallel-edge`):
+     * two loads gave two edges the same pair, ordinal and among, and neither is bound.
+     */
+    readonly ambiguousEdges: number;
+    /**
+     * Why this resolution is empty when its definition could not be evaluated (a cycle, a missing
+     * referent, a capability the session lacks). Only a quiet resolution carries one; a door throws
+     * the same error instead.
+     */
+    readonly problem?: GraphtyError;
+}
+/** Which connected component each node belongs to. */
+export interface ComponentLabels {
+    /** One component number per dense node index. */
+    readonly labels: ArrayLike<number>;
+    /** How many components there are, so the labels are `[0, count)`. */
+    readonly count: number;
+}
+/** Everything a resolution reads that it does not compute. */
+export interface ResolveContext {
+    /** The context snapshot: the full graph today; a rule's future `scope` evaluates here. */
+    readonly snapshot: GraphSnapshot;
+    /** The node id map; the snapshot's own unless a caller (a counting test) wraps it. */
+    readonly ids?: {
+        indexOf(id: NodeId): number;
+    };
+    /** The store instance the resolution is tagged with. */
+    readonly store?: object | null;
+    /** What is visible. Absent means nothing hides anything. */
+    readonly visibility?: {
+        nodes(): ElementMask<NodeId>;
+        edges(): ElementMask<EdgeId>;
+    };
+    /** What is selected. Absent refuses `"selection"`. */
+    readonly selection?: {
+        nodes(): ElementMask<NodeId>;
+    };
+    /** The connected components. Absent refuses `"largest-component"`. */
+    readonly components?: () => ComponentLabels;
+    /** The nodes a predicate matches. Absent refuses `{ where }`. */
+    readonly match?: (where: Query) => Iterable<NodeId>;
+    /** The edges a predicate matches. Absent refuses a rule's `edges` leaf. */
+    readonly matchEdges?: (where: Query) => Iterable<EdgeId>;
+    /** Attribute values. Absent refuses a rule's `range` and `categories` leaves. */
+    readonly values?: FilterValueSource;
+    /** A run's current result. Absent refuses a rule's `item` leaf and a `threshold` over `results.*`. */
+    readonly result?: FilterSources["result"];
+    /** What a held item's re-run captured (`./captures`). Absent: nothing was captured. */
+    readonly captured?: FilterSources["captured"];
+    /**
+     * The saved scopes `{ set }` names. Absent: no scope is saved. Replaced, never mutated, on
+     * every write, so its identity says whether it moved.
+     */
+    readonly saved?: ReadonlyMap<ScopeId, {
+        readonly spec: Scope;
+    }>;
+    /** The kept sets, and the seeds their edge members bind through. */
+    readonly sets?: {
+        list(): readonly unknown[];
+        get(id: SetId): unknown;
+        seedsOf(id: SetId): EdgeSeeds | undefined;
+        /**
+         * A removed id's tombstone: the name it had, and its record while anything names it, which
+         * a reference to the removed set resolves through.
+         */
+        tombstone?(id: SetId): {
+            readonly name: string;
+            readonly record?: {
+                readonly definition: SetDefinition;
+            };
+        } | undefined;
+    };
+    /**
+     * The paths a query's compiled expression reads.
+     * @param where - The query.
+     * @returns The paths.
+     */
+    readonly pathsOf?: (where: Query) => readonly Path[];
+    /** The node attribute revisions. */
+    readonly revisions?: AttributeRevisions;
+    /** The edge attribute revisions, which a rule's `edges` leaf is keyed on. */
+    readonly edgeRevisions?: AttributeRevisions;
+    /**
+     * The token of a run's current result, or undefined when it has none.
+     * @param run - The run.
+     * @returns The token.
+     */
+    readonly executionOf?: (run: RunId) => string | undefined;
+    /** The session input tick, which scopes the signature memo. Absent: nothing is memoised. */
+    readonly tick?: InputTick;
+    /** The resolution cache. Absent: every resolution is computed. */
+    readonly cache?: SetsCache;
+    /**
+     * Which halves carry a value path. Absent: an `item` or `threshold` leaf is not known to
+     * speak edges.
+     * @param path - The path.
+     * @returns `"node"`, `"edge"`, or both.
+     */
+    readonly fieldKinds?: (path: Path) => readonly string[];
+}
+/** The node half of a resolution, before the root applies the reading. */
+export interface NodeHalf {
+    /** The node bitmap. */
+    readonly nodes: U32;
+    /** The edges the specification allows beyond the induced rule (the visible edges), or null. */
+    readonly constraint: U32 | null;
+    /** True when the node half is every node and there is no constraint: every edge is in. */
+    readonly all: boolean;
+    /** Unresolved node entries. */
+    readonly missingNodes: number;
+}
+/**
+ * The node half of one `Scope`, following saved scopes to what they hold.
+ * @param scope - The specification.
+ * @param context - What the resolution reads.
+ * @param seen - The saved ids already followed, which is how a cycle is caught.
+ * @returns The node half.
+ * @throws A `GraphtyError` when the specification needs a capability the context lacks, names an
+ *     unknown saved scope, or a ring of saved scopes.
+ */
+export declare function resolveNodeHalf(scope: Scope, context: ResolveContext, seen?: Set<ScopeId>): NodeHalf;
+/**
+ * Resolve without throwing: a definition that cannot be evaluated resolves to nothing, carrying
+ * the refusal as its `problem`. What a pass (the visibility filter, a kept set counted in a panel)
+ * uses, because inside a pass nothing throws.
+ * @param resolve - The resolution to attempt.
+ * @param context - What the resolution reads.
+ * @returns The resolution, or an empty one with its problem.
+ */
+export declare function resolveQuietly(resolve: () => Resolution, context: ResolveContext): Resolution;
+/**
+ * What a `member` leaf speaks: the referenced set's nodes, and its edges when its reading is
+ * `listed` or `clipped`.
+ * @param scope - The referenced set.
+ * @param context - What the resolution reads.
+ * @param seen - The sets followed so far.
+ * @returns The leaf.
+ * @throws A `GraphtyError` as the scope's resolution does.
+ */
+export declare function scopeLeafIn(scope: Scope, context: ResolveContext, seen?: readonly SetId[]): ScopeLeaf;
+/**
+ * A rule's compiled halves, before the reading is applied: a node test and an edge test by dense
+ * index, null where the tree is silent.
+ * @param definition - A canonical rule.
+ * @param context - What the tests read.
+ * @param seen - The sets followed so far.
+ * @returns The halves.
+ * @throws A `GraphtyError` when a leaf needs a capability the context lacks.
+ */
+export declare function ruleHalves(definition: Extract<SetDefinition, {
+    kind: "rule";
+}>, context: ResolveContext, seen?: readonly SetId[]): CompiledHalves;
+/**
+ * What a definition covers. Opaque content resolves to nothing (design 12.5).
+ * @param definition - A canonical definition.
+ * @param context - What the resolution reads.
+ * @param seen - The kept sets followed so far, this one last when it is kept.
+ * @param id - The kept set, whose seeds its edge members bind through; absent for an inline one.
+ * @returns The resolution.
+ * @throws A `GraphtyError` when a rule cannot be evaluated: a cycle, a missing referent, a
+ * capability the context lacks.
+ */
+export declare function resolveDefinitionIn(definition: SetDefinition, context: ResolveContext, seen?: readonly SetId[], id?: SetId): Resolution;
+/**
+ * The induced (or, with a constraint, clipped) edges of a node half: one pass over the edge list.
+ * @param half - The node half.
+ * @param snapshot - The context snapshot.
+ * @returns The edge bitmap.
+ */
+export declare function deriveEdges(half: NodeHalf, snapshot: GraphSnapshot): U32;
+/**
+ * Dress a node half and its edges as a resolution.
+ * @param half - The node half.
+ * @param edges - The edge bitmap.
+ * @param context - What was resolved against.
+ * @param missingEdges - Unmatched edge members.
+ * @param ambiguousEdges - Of those, the ones more than one edge carries.
+ * @returns The resolution.
+ */
+export declare function resolutionOf(half: NodeHalf, edges: U32, context: ResolveContext, missingEdges: number, ambiguousEdges?: number): Resolution;
+/**
+ * What one `Scope` covers, synchronously. Its edges are the ones with both endpoints in its
+ * nodes, narrowed by the visible edges for `"visible"` (the clipped reading). Served from
+ * `context.cache` while the scope's input signature holds.
+ * @param scope - The specification.
+ * @param context - What the resolution reads.
+ * @returns The resolution.
+ * @throws A `GraphtyError` as {@link resolveNodeHalf} does.
+ */
+export declare function resolveScope(scope: Scope, context: ResolveContext): Resolution;
+/** A member more than one edge carries. */
+export declare const EDGE_AMBIGUOUS = -2;
+/**
+ * One set's seeds: member key to the session edge counter the member entered the set through.
+ * `version` moves on every write, so a binding plan built from an older version is rebuilt.
+ */
+export interface EdgeSeeds {
+    readonly counters: ReadonlyMap<string, number>;
+    readonly version: number;
+}
+/**
+ * The key a seed is filed under: the member's fields, types kept, so `1` and `"1"` differ.
+ * @param member - The member.
+ * @returns The key.
+ */
+export declare function edgeMemberKey(member: EdgeMember): string;
+/**
+ * The row each edge member binds in the context snapshot: seeded first, then by identity.
+ * @param key - The frozen definition the members belong to; the binding table is keyed by it.
+ * @param members - The members.
+ * @param context - What the resolution reads.
+ * @param seeds - The set's seeds, if any.
+ * @returns One entry per member: its row, {@link EDGE_MISSING} or {@link EDGE_AMBIGUOUS}.
+ */
+export declare function bindEdgeMembers(key: object, members: EdgeMemberList, context: ResolveContext, seeds?: EdgeSeeds): Int32Array;
+/**
+ * Set a row's edge bit and its endpoints' node bits.
+ * @param row - The edge row.
+ * @param snapshot - The context snapshot.
+ * @param nodes - The node bitmap.
+ * @param edges - The edge bitmap.
+ */
+export declare function addEdgeRow(row: number, snapshot: GraphSnapshot, nodes: U32, edges: U32): void;
+/**
+ * What a fixed definition covers. `induced`: its nodes and the edges between them, its edge
+ * members inert. `listed`: its nodes plus its bound edge members and their ends.
+ * @param definition - A canonical fixed definition.
+ * @param context - What the resolution reads.
+ * @param seeds - The set's seeds, for a kept set.
+ * @returns The resolution.
+ */
+export declare function resolveFixed(definition: Extract<SetDefinition, {
+    kind: "fixed";
+}>, context: ResolveContext, seeds?: EdgeSeeds): Resolution;
+/**
+ * A resolution's `d1:` membership digest: one masked sum over each hash column, computed on first
+ * read and memoised on the resolution.
+ * @param resolution - The resolution.
+ * @param snapshot - The snapshot it was resolved against.
+ * @returns The digest.
+ * @throws An Error when the snapshot is not the one the resolution was resolved against.
+ */
+export declare function digestOf(resolution: Resolution, snapshot: GraphSnapshot): string;

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

@@ -0,0 +1,77 @@
+/**
+ * @file Input signatures: a string built only from what one definition reads, so a resolution is
+ * served again exactly while none of those inputs moved (design/sets/sets-design.md sections 5.2
+ * and 6.2).
+ *
+ * A signature is `<store>|<serial>|<parts>`. The store and the snapshot serial are in every one.
+ * The parts name the other inputs the definition reads, and nothing else:
+ *
+ * - `"visible"` and `"selection"`: the mask objects and their versions;
+ * - `{ where }` and a rule over a query: the attribute revision of every top-level field its
+ *   compiled paths read, and the execution token of every run whose results they read;
+ * - `{ set }`: the identity of the saved record it names, or an explicit absent marker, and the
+ *   parts of what that record holds, recursively;
+ * - a kept fixed or path set with edge members: the identity and version of its seeds.
+ *
+ * Records and definitions are frozen and replaced on every write, so their identity is exact: a
+ * rename keeps the definition object and moves nothing, an undo that restores the identical
+ * record matches again.
+ *
+ * A definition whose inputs the context cannot enumerate (a query with no path reader, say) has
+ * no signature: `null`, and it is never cached.
+ *
+ * Signatures are memoised per read epoch -- the store, the serial, the session input tick and
+ * the identity of the saved-scope map and the kept-set list -- so a chain of sets naming one
+ * base walks the base once. Without a tick the context cannot tell when an attribute or a token
+ * moved, so nothing is memoised.
+ *
+ * Nothing here reaches Babylon.js, Lit or the DOM.
+ */
+import type { Scope, SetDefinition, SetId } from "../../catalog/types";
+import type { ResolveContext } from "./resolve";
+/**
+ * The definition of the kept set an id names, when the context holds one: the live set's, else
+ * the removed set's kept record, so a reference to a removed set reads what it read before the
+ * removal (design/sets 15.3, item 33).
+ * @param id - The id.
+ * @param context - What the resolution reads.
+ * @returns The definition, or undefined.
+ */
+export declare function keptDefinition(id: SetId, context: ResolveContext): SetDefinition | undefined;
+/** Invocation counts the complexity tests read. `walks`: saved-scope and kept-set parts computed, not memoised. */
+export declare const signatureCounters: {
+    walks: number;
+};
+/**
+ * A small number standing for an object's identity, stable for the object's life.
+ * @param value - The object.
+ * @returns Its number.
+ */
+export declare function identityOf(value: object): number;
+/** One read epoch's memo: signature parts by set id or target key. */
+export interface SignatureMemo {
+    epoch: string;
+    readonly parts: Map<unknown, string | null>;
+}
+/**
+ * A fresh memo.
+ * @returns It.
+ */
+export declare function createSignatureMemo(): SignatureMemo;
+/**
+ * The input signature of one `Scope`.
+ * @param scope - The specification.
+ * @param context - What the resolution reads.
+ * @param memo - The epoch memo, when the caller keeps one.
+ * @returns The signature, or null when the scope must not be cached.
+ */
+export declare function scopeSignature(scope: Scope, context: ResolveContext, memo?: SignatureMemo): string | null;
+/**
+ * The input signature of a kept set's definition.
+ * @param id - The set's id, which its seeds are filed under.
+ * @param definition - Its frozen definition.
+ * @param context - What the resolution reads.
+ * @param memo - The epoch memo, when the caller keeps one.
+ * @returns The signature, or null when it must not be cached.
+ */
+export declare function definitionSignature(id: SetId, definition: SetDefinition, context: ResolveContext, memo?: SignatureMemo): string | null;