@graphty/graph-format 0.0.0 → 0.2.0

package/dist/src/builder/graph-builder.d.ts

@@ -0,0 +1,602 @@
+/**
+ * GraphBuilder: the only mutable object in the package and the producer of snapshots (design
+ * section 6). A long-lived, structure-of-arrays accumulator (compact.ts) that can be frozen
+ * repeatedly through the pipeline of freeze.ts. Node indices are assigned in first-seen order and
+ * edge indices in addEdge order (invariant I14); removal tombstones in O(degree) through the two
+ * incidence lists; a compacting freeze renumbers the builder's own indices to equal the new
+ * snapshot's (decision C7) and reports the remaps; freeze() never shares core arrays or columns with
+ * the snapshot (I18) while the id `Map` and `ids` array are shared by design (section 4.2).
+ *
+ * Every public method and getter throws E_BUILDER_DISPOSED after dispose(); every throw leaves the
+ * builder in a consistent state (design section 11.1): the failing operation is not applied (the
+ * record, composition and expansion methods validate everything they will write before the first
+ * mutation), and a freeze that fails commits nothing.
+ */
+import { type BuilderOptionsPatch, type ColumnDecl, type ColumnDeclPatch, type ColumnHandle, type Dtype, type ExtensionHandle, type F32, type F64, type FreezeOptions, type FreezeReport, type GraphBuilderContract, type GraphBuilderOptions, type GraphMetaPatch, type GraphSnapshot, type NodeId, type ResolvedBuilderOptions, type SetDirectedOptions, type TypedArrayData, type U32 } from "../types/index.js";
+/**
+ * The mutable accumulator that produces frozen snapshots (design sections 6 and 12.2). Construct
+ * with `{ directed }` (required) and the policies of GraphBuilderOptions; push nodes and edges by id
+ * or by index; declare and write attribute columns; call `freeze()` as often as needed. Implements
+ * GraphSink, the subset importers program against (design section 8.3).
+ */
+export declare class GraphBuilder implements GraphBuilderContract {
+    private readonly fixed;
+    private directedValue;
+    private locked;
+    private optionsCache;
+    private staging;
+    /** Column name -> index of the node staging columns; rebuilt when the column array is replaced. */
+    private nodeNames;
+    /** Column name -> index of the edge staging columns; rebuilt when the column array is replaced. */
+    private edgeNames;
+    private graphValues;
+    private metaValue;
+    private widenings;
+    private mutations;
+    private dirtyFlag;
+    private disposed;
+    /**
+     * Create an empty builder.
+     * @param options - the options; `directed` is required
+     */
+    constructor(options: GraphBuilderOptions);
+    /**
+     * Seed a builder from a snapshot in O(n + m) (design section 6.6): ids, edges in logical order
+     * with their declared orientation, weights (through the role-"weight" column when present, so an
+     * f64 shadow and the explicit / omitted record survive), columns, extension tables and meta;
+     * indices are preserved. The staging precision follows an f64 shadow unless the patch says
+     * otherwise.
+     * @param snapshot - the snapshot to continue
+     * @param options - option overrides; `directed` defaults to the snapshot's
+     * @returns the builder
+     */
+    static from(snapshot: GraphSnapshot, options?: BuilderOptionsPatch): GraphBuilder;
+    /**
+     * The resolved options; `directed` is the current value.
+     * @returns the options
+     */
+    get options(): ResolvedBuilderOptions;
+    /**
+     * The current direction.
+     * @returns true when directed
+     */
+    get directed(): boolean;
+    /**
+     * Whether lockDirected() was called.
+     * @returns true when locked
+     */
+    get directedLocked(): boolean;
+    /**
+     * Live node count.
+     * @returns the count
+     */
+    get nodeCount(): number;
+    /**
+     * Live edge count (exact, from the incidence lists).
+     * @returns the count
+     */
+    get edgeCount(): number;
+    /**
+     * Next node index to be assigned.
+     * @returns the bound
+     */
+    get nodeBound(): number;
+    /**
+     * Next logical edge index to be assigned.
+     * @returns the bound
+     */
+    get edgeBound(): number;
+    /**
+     * Increments on every topology or weight mutation; column writes and freeze() do not count.
+     * @returns the count
+     */
+    get mutationCount(): number;
+    /**
+     * Whether the builder was mutated since the last freeze() (true for a builder never frozen).
+     * @returns true when a fresh freeze would differ from the last one
+     */
+    get dirty(): boolean;
+    /**
+     * Change the direction (design section 6.6): a no-op when unchanged; free while no live edge
+     * exists; with live edges only undirected -> directed with `expand`, which appends a mirror edge
+     * for every live edge and writes the graphty.directed / graphty.pair columns. E_DIRECTED when
+     * locked or refused.
+     * @param directed - the new direction
+     * @param options - `expand` for the in-place expansion
+     */
+    setDirected(directed: boolean, options?: SetDirectedOptions): void;
+    /** Fix the direction: every later changing setDirected() throws E_DIRECTED. */
+    lockDirected(): void;
+    /**
+     * Add a node, or return the index of the live node with this id; a tombstoned id is revived at
+     * its old index (design section 6.6).
+     * @param id - the node id; E_INVALID_ID when illegal
+     * @returns the node index
+     */
+    addNode(id: NodeId): number;
+    /**
+     * Add many nodes, writing every id's index (new or existing) into `out`.
+     * @param ids - the ids
+     * @param out - receives the indices; allocated when omitted; E_COLUMN_LENGTH when too short
+     * @returns `out`
+     */
+    addNodes(ids: Iterable<NodeId>, out?: U32): U32;
+    /**
+     * Append `count` nodes whose ids are their own indices, never touching the id Map while every
+     * node is anonymous (design section 6.6).
+     * @param count - how many; E_TOO_LARGE beyond MAX_COUNT; E_DUPLICATE_ID when an index is already an id
+     * @returns the first new index
+     */
+    addAnonymousNodes(count: number): number;
+    /**
+     * Whether a live node has this id (total: an illegal id is simply absent).
+     * @param id - the id
+     * @returns true when present and alive
+     */
+    hasNode(id: NodeId): boolean;
+    /**
+     * Total lookup of a live node.
+     * @param id - the id
+     * @returns the index, or INVALID_INDEX
+     */
+    indexOf(id: NodeId): number;
+    /**
+     * The id of a live node index.
+     * @param index - the index; E_INDEX_RANGE when out of range or tombstoned
+     * @returns the id
+     */
+    idOf(index: number): NodeId;
+    /**
+     * Tombstone a node and every live incident edge (O(degree)); bumps mutationCount.
+     * @param id - the id; E_UNKNOWN_NODE when absent or already removed
+     * @returns the removed live incident edge indices, ascending
+     */
+    removeNode(id: NodeId): U32;
+    /**
+     * Tombstone a node by index and every live incident edge.
+     * @param index - the index; E_UNKNOWN_NODE (details.index) when out of range or removed
+     * @returns the removed live incident edge indices, ascending
+     */
+    removeNodeByIndex(index: number): U32;
+    /**
+     * Grow staging capacity ahead of a bulk push.
+     * @param nodes - the node count to fit
+     * @param edges - the edge count to fit
+     */
+    reserve(nodes?: number, edges?: number): void;
+    /**
+     * Add a logical edge by id; unknown endpoints are created when addMissingNodes is set (a
+     * tombstoned endpoint is revived), else E_UNKNOWN_NODE. A NaN weight is E_INVALID_WEIGHT.
+     * @param source - source id
+     * @param target - target id
+     * @param weight - the weight; 1 when omitted
+     * @returns the logical edge index
+     */
+    addEdge(source: NodeId, target: NodeId, weight?: number): number;
+    /**
+     * Add a logical edge by node index.
+     * @param u - source index; E_UNKNOWN_NODE (details.index) when out of range or removed
+     * @param v - target index
+     * @param weight - the weight; 1 when omitted
+     * @returns the logical edge index
+     */
+    addEdgeByIndex(u: number, v: number, weight?: number): number;
+    /**
+     * Bulk add edges by node index (the index-space path used with addAnonymousNodes). Everything is
+     * validated before the first edge is pushed.
+     * @param src - source indices
+     * @param dst - target indices; E_COLUMN_LENGTH when the lengths differ
+     * @param weights - per-edge weights; 1 when omitted; E_INVALID_WEIGHT for NaN
+     * @returns the first new logical edge index
+     */
+    addEdges(src: U32, dst: U32, weights?: F32 | F64): number;
+    /**
+     * Bulk add edges by id. Every id and weight is validated before anything is added.
+     * @param src - source ids
+     * @param dst - target ids; E_COLUMN_LENGTH when the lengths differ
+     * @param weights - per-edge weights; 1 when omitted
+     * @returns the first new logical edge index
+     */
+    addEdgesByIds(src: ArrayLike<NodeId>, dst: ArrayLike<NodeId>, weights?: ArrayLike<number>): number;
+    /**
+     * Tombstone an edge (O(1)); bumps mutationCount when something was removed.
+     * @param edge - the logical edge index
+     * @returns true when a live edge was removed
+     */
+    removeEdge(edge: number): boolean;
+    /**
+     * Whether an edge index is live.
+     * @param edge - the logical edge index
+     * @returns true when live
+     */
+    hasEdge(edge: number): boolean;
+    /**
+     * Read a live edge's endpoints back.
+     * @param edge - the logical edge index; E_INDEX_RANGE when out of range or removed
+     * @returns [source index, target index] in declared orientation
+     */
+    edgeEndpoints(edge: number): readonly [source: number, target: number];
+    /**
+     * Read a live edge's weight back.
+     * @param edge - the logical edge index; E_INDEX_RANGE when out of range or removed
+     * @returns the weight (1 when unweighted)
+     */
+    edgeWeight(edge: number): number;
+    /**
+     * Set the weight of a live edge, allocating the weight array on first use and marking the weight
+     * explicit; bumps mutationCount.
+     * @param edge - the logical edge index; E_INDEX_RANGE when out of range or removed
+     * @param weight - the weight; E_INVALID_WEIGHT for NaN
+     */
+    setEdgeWeight(edge: number, weight: number): void;
+    /**
+     * Live edges leaving a node, from the out-list (O(degree)). On an undirected builder every
+     * incident edge leaves the node (invariant I7, the snapshot's row holds both orientations), so
+     * both lists are walked and a self-loop is listed once.
+     * @param index - the node index; E_INDEX_RANGE when out of range
+     * @returns a fresh ascending array of live edge indices
+     */
+    outEdgesOf(index: number): U32;
+    /**
+     * Live edges entering a node, from the in-list (O(degree)); on an undirected builder the same
+     * set as outEdgesOf (the alias rule of inDegree === outDegree).
+     * @param index - the node index; E_INDEX_RANGE when out of range
+     * @returns a fresh ascending array of live edge indices
+     */
+    inEdgesOf(index: number): U32;
+    /**
+     * Live edges u -> v (undirected: either orientation), from the incidence lists.
+     * @param u - source index; E_INDEX_RANGE when out of range
+     * @param v - target index; E_INDEX_RANGE when out of range
+     * @returns a fresh ascending array of live edge indices
+     */
+    findEdges(u: number, v: number): U32;
+    /**
+     * Declare a node column; the same shape again returns the existing handle, a different shape is
+     * E_COLUMN_EXISTS, a taken role E_DUPLICATE_ROLE.
+     * @param decl - the declaration
+     * @returns the column handle
+     */
+    declareNodeColumn(decl: ColumnDecl): ColumnHandle;
+    /**
+     * Declare an edge column; the same shape again returns the existing handle, a different shape is
+     * E_COLUMN_EXISTS, a taken role E_DUPLICATE_ROLE.
+     * @param decl - the declaration
+     * @returns the column handle
+     */
+    declareEdgeColumn(decl: ColumnDecl): ColumnHandle;
+    /**
+     * Look up a node column handle.
+     * @param name - the column name
+     * @returns the handle, or INVALID_INDEX when absent
+     */
+    nodeColumn(name: string): ColumnHandle;
+    /**
+     * Look up an edge column handle.
+     * @param name - the column name
+     * @returns the handle, or INVALID_INDEX when absent
+     */
+    edgeColumn(name: string): ColumnHandle;
+    /**
+     * Set one node cell; a string column name auto-declares an inferred column (design section 5.1)
+     * on the first set value, and an unset value for an undeclared name is a no-op.
+     * @param column - the handle (E_UNKNOWN_COLUMN when stale) or name
+     * @param index - the node index; E_INDEX_RANGE when out of range
+     * @param value - the value; undefined / null unset the row
+     */
+    setNodeValue(column: ColumnHandle | string, index: number, value: unknown): void;
+    /**
+     * Set one edge cell; a string column name auto-declares an inferred column.
+     * @param column - the handle (E_UNKNOWN_COLUMN when stale) or name
+     * @param edge - the logical edge index; E_INDEX_RANGE when out of range
+     * @param value - the value; undefined / null unset the row
+     */
+    setEdgeValue(column: ColumnHandle | string, edge: number, value: unknown): void;
+    /**
+     * Widen an inferred node column to a wider dtype of the design section 5.1 order without
+     * changing any value (an importer that knows from the lexical grammar that a column of `2.0`
+     * cells is f64 although every value so far was integral). A no-op when the column is already
+     * as wide; E_COLUMN_TYPE for a declared (non-inferred) column, a dtype outside the inference
+     * order or a narrower one; the widening is reported in FreezeReport.widened.
+     * @param column - the handle (E_UNKNOWN_COLUMN when stale) or name (E_UNKNOWN_COLUMN when absent)
+     * @param dtype - the dtype to widen to
+     */
+    widenNodeColumn(column: ColumnHandle | string, dtype: Dtype): void;
+    /**
+     * Widen an inferred edge column to a wider dtype of the design section 5.1 order without
+     * changing any value; see widenNodeColumn().
+     * @param column - the handle (E_UNKNOWN_COLUMN when stale) or name (E_UNKNOWN_COLUMN when absent)
+     * @param dtype - the dtype to widen to
+     */
+    widenEdgeColumn(column: ColumnHandle | string, dtype: Dtype): void;
+    /**
+     * Bulk-set a node column from a typed array (copied into staging); replaces a column of the same
+     * name. The length must be nodeBound * components (bool: ceil(nodeBound / 32) words).
+     * @param name - the column name
+     * @param data - the values
+     * @param decl - declaration fields (dtype defaults to the array's)
+     */
+    setNodeColumn(name: string, data: TypedArrayData, decl?: ColumnDeclPatch): void;
+    /**
+     * Bulk-set an edge column from a typed array (copied into staging); replaces a column of the same
+     * name. The length must be edgeBound * components.
+     * @param name - the column name
+     * @param data - the values
+     * @param decl - declaration fields (dtype defaults to the array's)
+     */
+    setEdgeColumn(name: string, data: TypedArrayData, decl?: ColumnDeclPatch): void;
+    /**
+     * Set a graph-level attribute (the graph table's single row); the value and declaration are
+     * checked now, the column is built at freeze.
+     * @param name - the column name
+     * @param value - the value; undefined unsets it
+     * @param decl - declaration fields for the column
+     */
+    setGraphValue(name: string, value: unknown, decl?: ColumnDeclPatch): void;
+    /**
+     * Merge fields into the graph metadata (design section 5.9); undefined fields are left alone,
+     * `extra` must be a JSON value (E_COLUMN_TYPE with details.field otherwise).
+     * @param meta - the fields to set
+     */
+    setMeta(meta: GraphMetaPatch): void;
+    /**
+     * Create an extension table (design section 5.10).
+     * @param name - the table name; E_COLUMN_EXISTS when taken
+     * @param decls - its columns; E_COLUMN_EXISTS for a repeated name, E_DUPLICATE_ROLE for a repeated role
+     * @returns the table handle
+     */
+    addExtensionTable(name: string, decls: readonly ColumnDecl[]): ExtensionHandle;
+    /**
+     * Append a row to an extension table.
+     * @param table - the table handle; E_INDEX_RANGE when unknown
+     * @param values - one value per declared column; E_COLUMN_LENGTH otherwise
+     * @returns the new row index
+     */
+    addExtensionRow(table: ExtensionHandle, values: readonly unknown[]): number;
+    /**
+     * Add a node from a record: every key present overwrites that row (last-write-wins per attribute,
+     * design section 6.6), auto-declaring inferred columns.
+     * @param id - the node id
+     * @param attrs - attribute values keyed by column name
+     * @returns the node index
+     */
+    addNodeRecord(id: NodeId, attrs: Readonly<Record<string, unknown>>): number;
+    /**
+     * Add an edge from a record; always a new edge (parallels are kept). The weight comes from
+     * `weightKey` ("weight" by default; null = none) and must be a number (E_INVALID_WEIGHT).
+     * @param source - source id
+     * @param target - target id
+     * @param attrs - attribute values keyed by column name
+     * @param weightKey - the key holding the weight; default "weight"; null = no weight
+     * @returns the logical edge index
+     */
+    addEdgeRecord(source: NodeId, target: NodeId, attrs: Readonly<Record<string, unknown>>, weightKey?: string | null): number;
+    /**
+     * Append another snapshot (design section 6.6): nodes are merged by id ("merge": the incoming set
+     * rows overwrite; "error": E_DUPLICATE_ID), edges are appended in logical order with their
+     * declared orientation and weights, columns declared in both graphs widen to the union dtype of
+     * design section 5.1, dictionaries are re-interned, extension tables are appended with their
+     * references rewritten, and graph attributes overwrite by name.
+     * @param snapshot - the snapshot to append
+     * @param options - duplicate-id handling
+     * @param options.onDuplicateNode - "merge" (default) or "error"
+     */
+    addGraph(snapshot: GraphSnapshot, options?: {
+        readonly onDuplicateNode?: "merge" | "error" | undefined;
+    }): void;
+    /**
+     * Run the freeze pipeline of design section 6.3 and return a snapshot; the builder keeps its
+     * staging (compacted and renumbered when tombstones existed, rewritten by a merge policy) unless
+     * `release` is set.
+     * @param options - the freeze options
+     * @returns the snapshot
+     */
+    freeze(options?: FreezeOptions): GraphSnapshot;
+    /**
+     * freeze() plus the report of what was renumbered, merged, dropped and widened (design section
+     * 6.6): the remaps are relative to the previous freeze (the builder's own index space on the
+     * first) and null exactly when nothing was renumbered.
+     * @param options - the freeze options
+     * @returns the snapshot and its report
+     */
+    freezeWithReport(options?: FreezeOptions): {
+        snapshot: GraphSnapshot;
+        report: FreezeReport;
+    };
+    /** Empty the builder (nodes, edges, columns, extension tables, graph attributes, meta), keeping its options and lock. */
+    clear(): void;
+    /** Release everything; every further call throws E_BUILDER_DISPOSED. */
+    dispose(): void;
+    /**
+     * Bytes of typed staging currently held (capacity, not length; JS arrays and the id Map excluded).
+     * @returns the byte count
+     */
+    byteLength(): number;
+    private check;
+    private mutated;
+    private freshStaging;
+    /**
+     * The index a validated id would get from addValidatedNode: its existing (live or tombstoned)
+     * index, or the next one.
+     * @param id - a validated id
+     * @returns the prospective index
+     */
+    private prospectiveNodeIndex;
+    /**
+     * The live index of an id, total.
+     * @param id - any value
+     * @returns the index, or INVALID_INDEX when absent, illegal or tombstoned
+     */
+    private lookup;
+    private isLiveNode;
+    private isLiveEdge;
+    private checkNodeIndex;
+    private checkEdgeIndex;
+    private checkLiveNode;
+    private checkEdge;
+    private checkNodeLimit;
+    /**
+     * The E_TOO_LARGE check of invariant I3 at the add* call that would cross the limit: the edge
+     * index space and the live arc count (doubled for an undirected graph, loops once) must both
+     * stay at or below MAX_COUNT.
+     * @param addingEdges - edges about to be added
+     * @param addingArcs - arcs they contribute (1 per directed edge or loop, 2 per undirected non-loop)
+     */
+    private checkEdgeLimit;
+    /**
+     * The arcs a batch of edges contributes.
+     * @param src - sources
+     * @param dst - targets
+     * @param count - how many
+     * @returns the arc count
+     */
+    private arcsOf;
+    /**
+     * Add or revive a validated id.
+     * @param id - a validated id
+     * @returns the index
+     */
+    private addValidatedNode;
+    /**
+     * Resolve an edge endpoint id: the live index, a revived or new node under addMissingNodes, or
+     * E_UNKNOWN_NODE.
+     * @param id - a validated id
+     * @returns the index
+     */
+    private resolveEndpoint;
+    private requireLive;
+    private removeLiveNode;
+    /**
+     * Validate a weight argument: NaN is E_INVALID_WEIGHT; on an unweighted (`weighted: false`) builder
+     * only 1 is accepted and it is treated as omitted.
+     * @param weight - the argument
+     * @param edge - the bulk position, for the error details
+     * @returns the weight to store, or undefined when omitted
+     */
+    private checkWeight;
+    private pushEdge;
+    /**
+     * The in-place expansion of design section 6.6: every live edge u -> v gets a mirror v -> u at a
+     * new index (loops are not mirrored), graphty.directed is 0 for both halves and graphty.pair links
+     * them; every other column's mirror rows stay unset.
+     */
+    private expandToDirected;
+    private columnsOf;
+    private handleOf;
+    /**
+     * The index of a staging column by name in O(1): a Map beside each column array, rebuilt when
+     * the array is replaced (a fresh staging, a compaction) and kept in step by pushColumn().
+     * Column names never change, so the map is invalidated only by identity or length.
+     * @param columns - the node or edge staging columns
+     * @param name - the column name
+     * @returns the index, or -1 when absent
+     */
+    private columnIndex;
+    /**
+     * Append a staging column and keep the name index in step.
+     * @param columns - the node or edge staging columns
+     * @param column - the column to append
+     * @returns the new column's index
+     */
+    private pushColumn;
+    /**
+     * Declare a column (design section 11.3): the same shape returns the existing handle, another
+     * shape is E_COLUMN_EXISTS, a role held by another column E_DUPLICATE_ROLE.
+     * @param domain - node or edge
+     * @param decl - the declaration
+     * @returns the handle
+     */
+    private declare;
+    /**
+     * The checks of declare() without applying anything: the resolved metadata and, when a column
+     * of the same shape exists, its handle.
+     * @param domain - node or edge
+     * @param decl - the declaration
+     * @returns the metadata and the existing handle (INVALID_INDEX when the column is new)
+     */
+    private checkDeclaration;
+    /**
+     * The staging column a handle or name refers to, auto-declaring an inferred column for an unknown
+     * name when the value is set.
+     * @param domain - node or edge
+     * @param column - the handle or name
+     * @param value - the value about to be written (decides the inferred dtype)
+     * @returns the column, or null when an unknown name receives an unset value
+     */
+    private resolveColumn;
+    /**
+     * Validate every value of a record against the columns it would be written to, without writing
+     * (design section 11.1: a record whose value is refused is not applied at all). An existing
+     * column checks the value as its `write` would; a new name must be inferrable (a JSON value or a
+     * well-formed string) unless the value is unset.
+     * @param domain - node or edge
+     * @param row - the row the record is meant for (error details only)
+     * @param keys - the record keys
+     * @param attrs - the record
+     */
+    private checkCells;
+    /**
+     * The refersTo range rule of invariant I12 at the write: an index-valued cell of a refersTo
+     * column must be below the referenced space's current bound (a tombstoned target is a dangling
+     * reference the next compaction resolves) or INVALID_INDEX; E_INDEX_RANGE otherwise. A scalar
+     * INVALID_INDEX means "no reference" and is written as an unset row (E_COLUMN_TYPE on a
+     * non-nullable column, which cannot hold it). Values of other shapes are left to the column's
+     * own type check.
+     * @param meta - the column
+     * @param value - the value about to be written
+     * @returns the value to write (undefined for a scalar INVALID_INDEX)
+     */
+    private checkReference;
+    /**
+     * The checks copyColumn would fail on before it writes anything: a new column's role must be
+     * free (E_DUPLICATE_ROLE).
+     * @param domain - node or edge
+     * @param column - the incoming column
+     */
+    private checkIncomingColumn;
+    /**
+     * The checks appendExtension would fail on before it writes anything: an existing table of the
+     * same name must hold every incoming column (E_UNKNOWN_COLUMN); a new table's declarations must
+     * resolve (E_COLUMN_EXISTS / E_DUPLICATE_ROLE).
+     * @param name - the table name
+     * @param table - the incoming table
+     */
+    private checkIncomingExtension;
+    /**
+     * The widening of widenNodeColumn / widenEdgeColumn.
+     * @param domain - node or edge
+     * @param column - the handle or name
+     * @param dtype - the dtype to widen to
+     */
+    private widenColumn;
+    private writeCell;
+    /**
+     * Replace or create a column from a typed array (setNodeColumn / setEdgeColumn).
+     * @param domain - node or edge
+     * @param rows - the table's current bound
+     * @param name - the column name
+     * @param data - the values
+     * @param decl - the declaration patch
+     */
+    private setBulkColumn;
+    private extensionOf;
+    /**
+     * Copy a snapshot column into the builder (addGraph): declared under the same metadata when the
+     * name is new, else widened to the union dtype (design section 6.6); every set row is written
+     * through `rowMap`, with refersTo values rewritten through `refs`.
+     * @param domain - node or edge
+     * @param column - the source column
+     * @param rowMap - source row -> builder row
+     * @param refs - source node / edge index -> builder index
+     */
+    private copyColumn;
+    /**
+     * Append the rows of a snapshot extension table (addGraph): into the table of the same name when
+     * the columns match, else a new table is declared from the source columns.
+     * @param name - the table name
+     * @param table - the source table
+     * @param refs - source node / edge index -> builder index
+     */
+    private appendExtension;
+}
+//# sourceMappingURL=graph-builder.d.ts.map

package/dist/src/builder/graph-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-builder.d.ts","sourceRoot":"","sources":["../../../src/builder/graph-builder.ts"],"names":[],"mappings":"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"}