@graphty/graph-format 0.0.0 → 0.2.0

package/dist/src/builder/compact.d.ts

@@ -0,0 +1,515 @@
+/**
+ * The builder's staging representation and its compaction (design sections 6.2 and 6.3 step 1).
+ *
+ * Staging is structure-of-arrays typed storage that grows by doubling: the node side (`ids`,
+ * `idToIndex`, `nodeAlive`, the incidence-list heads `firstOut` / `firstIn`), the edge side (`src`,
+ * `dst`, `weight`, `weightSet`, `edgeAlive`, the incidence-list links `nextOut` / `nextIn`), the live
+ * counts, and one `StagingColumn` per declared node / edge / extension column (a growable typed array,
+ * packed bitmap or JS array plus an optional validity bitmap and, for dict columns, an interning
+ * dictionary). No per-node or per-edge object is ever allocated.
+ *
+ * Compaction (`compactStaging`) gathers a NEW staging object through node and edge remaps assigned in
+ * index order (invariant I14): tombstoned nodes and edges disappear, `refersTo` column values are
+ * rewritten (dangling references become INVALID_INDEX with the row unset), fresh `ids` / `idToIndex`
+ * objects are built so the previous snapshot keeps the ones it shares (design section 4.2), and the
+ * incidence lists are rebuilt. The source staging is never modified, so a freeze that throws after
+ * compacting leaves the builder exactly as it was (design section 11.1); the builder commits the new
+ * staging only when the freeze succeeds.
+ */
+import { DictionaryBuilder } from "../columns/dictionary.js";
+import { GrowableBitmap, GrowableTypedArray } from "../columns/growable.js";
+import { type InferredDtype } from "../columns/infer.js";
+import { type Column, type ColumnDeclPatch, type ColumnDomain, type ColumnMeta, type Dtype, type NodeId, type TypedArrayData, type U32 } from "../types/index.js";
+/**
+ * The dtype an inferred (auto-declared) column starts with for a value (design section 5.1).
+ * @param value - the first set value
+ * @returns the inferred dtype; E_COLUMN_TYPE for a value no column can hold
+ */
+export declare function inferInitialDtype(value: unknown): InferredDtype;
+/**
+ * The position of a dtype in the widening order of design section 5.1, for the union rule of
+ * `addGraph()` (design section 6.6): the dtypes outside the inference order map to the narrowest
+ * inferred dtype that can hold every value of theirs.
+ * @param dtype - any dtype
+ * @returns the inferred dtype the column widens to when it must hold values of `dtype`
+ */
+export declare function inferredEquivalent(dtype: Dtype): InferredDtype;
+/** The widening a write caused on an inferred column. */
+interface WideningStep {
+    /** The dtype before. */
+    readonly from: Dtype;
+    /** The dtype after. */
+    readonly to: Dtype;
+}
+/**
+ * One growable column of the builder (design section 6.2).
+ *
+ * A DECLARED column stores values in the storage of its dtype (a growable typed array for the numeric
+ * dtypes and dict codes, a growable bitmap for bool, a JS array for string / list / json) plus an
+ * optional validity bitmap and, for dict columns, the interning dictionary; rows are materialised
+ * lazily up to `length` and unset rows physically hold the fill (design section 5.3). It never widens
+ * and rejects values it cannot hold with E_COLUMN_TYPE at the write.
+ *
+ * An INFERRED column (auto-declared by a string column name in `setNodeValue` / `addNodeRecord`, or
+ * a declared column widened by the union rule of `addGraph`) keeps the values exactly as written in a
+ * JS array and widens its dtype monotonically per design section 5.1 as wider values arrive; the
+ * values are coerced ONCE, at freeze, to the final dtype (bool -> 1 / 0 in a number column, number or
+ * boolean -> its canonical text in a string column), exactly as `fromRecords` would.
+ */
+export declare class StagingColumn {
+    /** The resolved metadata; replaced when an inferred column widens. */
+    meta: ColumnMeta;
+    /** Rows materialised so far. */
+    length: number;
+    /** Declared numeric data (rows * components) or dict codes. */
+    typed: GrowableTypedArray<TypedArrayData> | null;
+    /** Declared bool data. */
+    bits: GrowableBitmap | null;
+    /** Declared string / list / json rows, or the raw values of an inferred column. */
+    values: unknown[] | null;
+    /** dict only: the interning dictionary. */
+    dictionary: DictionaryBuilder | null;
+    /** The validity bitmap; null for a non-nullable column. */
+    validity: GrowableBitmap | null;
+    private inferrer;
+    private readonly resizable;
+    /**
+     * Create an empty column.
+     * @param meta - the resolved metadata
+     * @param inferred - whether the column stages raw values and may widen
+     * @param resizable - the staging buffer kind (tests pass false); undefined = engine default
+     * @param dictionary - an existing dictionary to share (compaction); a fresh one when omitted
+     */
+    constructor(meta: ColumnMeta, inferred: boolean, resizable?: boolean, dictionary?: DictionaryBuilder);
+    /**
+     * Whether the column stages raw values and may widen.
+     * @returns true for an inferred column
+     */
+    get inferred(): boolean;
+    /**
+     * The inferred dtype of an inferred column, or null.
+     * @returns the current inferred dtype
+     */
+    get inferredDtype(): InferredDtype | null;
+    /**
+     * Make at least `rows` rows exist, unset (when nullable) and holding the fill.
+     * @param rows - the row count to reach
+     */
+    ensureLength(rows: number): void;
+    /**
+     * Whether a row holds a value.
+     * @param row - the row
+     * @returns true when set (non-nullable columns: when materialised)
+     */
+    isSet(row: number): boolean;
+    /**
+     * Set one cell (design sections 5.1 and 6.6). `undefined` unsets the row, and so does `null`
+     * except on a declared json column (JSON null imports as unset, design section 5.3). An inferred
+     * column widens when the value is wider than its dtype; the widening is returned so the builder
+     * can report it.
+     * @param row - the row; rows below it are materialised
+     * @param value - the value
+     * @returns the widening that took place, or null
+     */
+    write(row: number, value: unknown): WideningStep | null;
+    /**
+     * Validate a value exactly as `write` would, without writing anything: the same E_COLUMN_TYPE
+     * errors for a value the column cannot hold (a non-representable number, a lone surrogate, a
+     * non-JSON object, an unset value on a non-nullable column). The record methods of the builder
+     * validate every attribute before they apply anything (design section 11.1).
+     * @param row - the row the value is meant for (error details only)
+     * @param value - the value
+     */
+    checkValue(row: number, value: unknown): void;
+    /**
+     * Unset one cell: the validity bit is cleared and the fill is written back (design section 5.3).
+     * @param row - the row; E_COLUMN_TYPE on a non-nullable column
+     */
+    unset(row: number): void;
+    /**
+     * The E_COLUMN_TYPE error for unsetting a row of a non-nullable column.
+     * @param row - the row
+     * @returns the error
+     */
+    private unsetError;
+    /**
+     * The JS value of one cell as the frozen column would hold it: a number (or an array of
+     * `components` numbers), a boolean, a string, a list or a json value; undefined for an unset or
+     * unmaterialised row. An inferred column's raw value is coerced to its current dtype.
+     * @param row - the row
+     * @returns the value
+     */
+    read(row: number): unknown;
+    /**
+     * Widen the column to a wider dtype of the design section 5.1 order. An inferred column only
+     * changes its dtype (its raw values are coerced at freeze); a declared column becomes inferred:
+     * its current values are read out and kept as raw values from then on.
+     * @param next - the dtype to widen to
+     */
+    widenTo(next: InferredDtype): void;
+    /**
+     * A new column of the same shape holding the rows `indexMap` selects (`out[i] = this[indexMap[i]]`),
+     * or every row in order when `indexMap` is null, with `refersTo` values rewritten through
+     * `valueRemap` when given: an in-range value maps to its new index and a dangling reference
+     * becomes INVALID_INDEX with the row unset (for a list, dangling items are dropped and a row whose
+     * every item dangled becomes unset and empty). The dictionary of a dict column is shared.
+     * @param indexMap - new row -> old row, or null to keep every row
+     * @param valueRemap - the remap of the space the values reference, or null
+     * @returns the gathered column
+     */
+    gather(indexMap: U32 | null, valueRemap: U32 | null): StagingColumn;
+    /**
+     * Leave row `i` of a gathered column unset because its reference dangled (design section 5.11).
+     * A non-nullable column gains a validity bitmap and becomes nullable (invariant I12 forbids a set
+     * row holding INVALID_INDEX; `remapColumn` flips `nullable` the same way): every earlier row is
+     * marked set except a scalar reference row still holding the INVALID_INDEX fill.
+     * @param i - the row being gathered; rows below it are already gathered
+     */
+    private unsetDangling;
+    /**
+     * Freeze the column into `rows` rows (design section 6.3 step 10): typed data is copied out of
+     * staging into exact-length buffers (invariant I18), the validity bitmap is copied (and dropped when
+     * every row is set), a dict dictionary is copied so the snapshot's column never changes (I17), and
+     * string / list / json rows and the raw values of an inferred column go through the column factory,
+     * which coerces them to the final dtype.
+     * @param rows - the row count of the table
+     * @returns the frozen column
+     */
+    toColumn(rows: number): Column;
+    /**
+     * Bytes of typed staging held by the column (JS arrays are not counted).
+     * @returns the byte count
+     */
+    byteLength(): number;
+    /**
+     * Allocate the storage of the current dtype (raw values for an inferred column).
+     * @param dictionary - a dictionary to share, or undefined for a fresh seeded one
+     */
+    private allocate;
+    /**
+     * The number written into unset numeric rows (the dict fill code for dict columns).
+     * @returns the fill
+     */
+    private fillNumber;
+    /**
+     * The JS value stored in unset rows of a JS-array column (undefined for an inferred column).
+     * @returns the fill
+     */
+    private fillValue;
+    /**
+     * The entry handed to the column factory for an unset row of a declared JS-array column:
+     * undefined for a nullable column, the fill for a non-nullable one (json: null, the one JSON value
+     * that means "nothing").
+     * @returns the entry
+     */
+    private unsetEntry;
+    private writeFill;
+    /**
+     * Keep a raw value on an inferred column after checking it is storable at all (a json value must
+     * be JSON; a string must be well-formed).
+     * @param row - the row
+     * @param value - the value as written
+     */
+    private storeRaw;
+    /**
+     * The checks of storeRaw: a string must be well-formed, an object must be JSON.
+     * @param row - the row
+     * @param value - the value as written
+     */
+    private checkRaw;
+    /**
+     * Store a value on a declared column: validate and normalise it (E_COLUMN_TYPE when the column
+     * cannot hold it), then write the normalised form.
+     * @param row - the row
+     * @param value - the value
+     */
+    private store;
+    /**
+     * Validate a value against a declared column's dtype and return the form `put` writes: a number
+     * or an array of `components` numbers, a boolean, a string, a copied list, or a JSON value.
+     * @param row - the row (error details only)
+     * @param value - the value
+     * @returns the normalised value
+     */
+    private coerce;
+    /**
+     * Write a value `coerce` returned.
+     * @param row - the row
+     * @param value - the normalised value
+     */
+    private put;
+}
+/**
+ * Create a staging column from a declaration patch.
+ * @param name - the column name
+ * @param domain - the table
+ * @param decl - the declaration; dtype required
+ * @param inferred - whether the column may widen
+ * @param resizable - the staging buffer kind
+ * @returns the column
+ */
+export declare function createStagingColumn(name: string, domain: ColumnDomain, decl: ColumnDeclPatch, inferred: boolean, resizable?: boolean): StagingColumn;
+/** One extension table under construction (design section 5.10). */
+export interface ExtensionStaging {
+    /** The table name. */
+    readonly name: string;
+    /** Its columns in declaration order. */
+    readonly columns: StagingColumn[];
+    /** Rows appended so far. */
+    rowCount: number;
+}
+/** Construction options of a Staging. */
+interface StagingOptions {
+    /** Staging weight precision (design section 3.7). */
+    readonly weightDtype: "f32" | "f64";
+    /** Allocate the weight array up front (`weighted: true`). */
+    readonly weighted: boolean;
+    /** Node capacity hint. */
+    readonly expectedNodes: number | null;
+    /** Edge capacity hint. */
+    readonly expectedEdges: number | null;
+    /** The staging buffer kind; undefined = engine default. */
+    readonly resizable: boolean | undefined;
+}
+/**
+ * Whether every edge so far agreed on supplying or omitting its weight (design section 3.7): the
+ * `weightSet` bitmap is only allocated once they disagree ("mixed").
+ */
+type WeightMode = "none" | "explicit" | "omitted" | "mixed";
+/**
+ * The staging of one builder (design section 6.2). Plain growable storage plus the push and link
+ * primitives; every rule (id validation, policies, error codes) lives in the builder.
+ */
+export declare class Staging {
+    /** The staging options. */
+    readonly options: StagingOptions;
+    /** The ids in index order, or null while every node is anonymous (id === index). */
+    ids: NodeId[] | null;
+    /** id -> index, shared by reference with frozen snapshots; null while every node is anonymous. */
+    idToIndex: Map<NodeId, number> | null;
+    /** Bit i set: node i is live. */
+    readonly nodeAlive: GrowableBitmap;
+    /** Head of the out-list of every node (an edge index), INVALID_INDEX = empty. */
+    readonly firstOut: GrowableTypedArray<U32>;
+    /** Head of the in-list of every node. */
+    readonly firstIn: GrowableTypedArray<U32>;
+    /** Declared source of every edge. */
+    readonly src: GrowableTypedArray<U32>;
+    /** Declared target of every edge. */
+    readonly dst: GrowableTypedArray<U32>;
+    /** Per-edge weights (f32 or f64 per weightDtype), or null while unweighted. */
+    weight: GrowableTypedArray<TypedArrayData> | null;
+    /** Bit e set: edge e's weight was supplied explicitly; null while every edge agrees. */
+    weightSet: GrowableBitmap | null;
+    /** Whether edges so far supplied, omitted, or disagreed about their weight. */
+    weightMode: WeightMode;
+    /** Bit e set: edge e is live. */
+    readonly edgeAlive: GrowableBitmap;
+    /** Next edge in the out-list of the source of every edge. */
+    readonly nextOut: GrowableTypedArray<U32>;
+    /** Next edge in the in-list of the target of every edge. */
+    readonly nextIn: GrowableTypedArray<U32>;
+    /** Live node count. */
+    liveNodeCount: number;
+    /** Live edge count. */
+    liveEdgeCount: number;
+    /** Live self-loop count. */
+    selfLoopCount: number;
+    /** Node columns in handle order. */
+    nodeColumns: StagingColumn[];
+    /** Edge columns in handle order. */
+    edgeColumns: StagingColumn[];
+    /** Extension tables in handle order. */
+    extensions: ExtensionStaging[];
+    /**
+     * Create empty staging.
+     * @param options - precision, capacity hints and buffer kind
+     */
+    constructor(options: StagingOptions);
+    /**
+     * The next node index to be assigned.
+     * @returns the node bound
+     */
+    get nodeBound(): number;
+    /**
+     * The next edge index to be assigned.
+     * @returns the edge bound
+     */
+    get edgeBound(): number;
+    /**
+     * Whether tombstoned nodes or edges exist.
+     * @returns true when compaction is needed
+     */
+    get hasTombstones(): boolean;
+    /**
+     * Grow 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;
+    /**
+     * Materialise `ids` and `idToIndex` from the anonymous prefix (every node so far has id === index).
+     */
+    materialiseIds(): void;
+    /**
+     * Append a live node; the id is recorded only when the id structures exist.
+     * @param id - the id, or null for an anonymous node (id === index)
+     * @returns the new index
+     */
+    pushNode(id: NodeId | null): number;
+    /**
+     * The weight array, allocated on first use and back-filled with 1 for existing edges.
+     * @returns the growable weight array
+     */
+    ensureWeights(): GrowableTypedArray<TypedArrayData>;
+    /**
+     * Record whether an edge's weight was explicit (design section 3.7): the `weightSet` bitmap is
+     * allocated on the first edge that disagrees with every earlier one.
+     * @param edge - the edge index (=== edgeBound - 1 when appending)
+     * @param explicit - whether the weight was supplied
+     */
+    trackWeight(edge: number, explicit: boolean): void;
+    /**
+     * Whether an edge's weight was supplied explicitly (design section 3.7).
+     * @param e - the edge index
+     * @returns true when explicit
+     */
+    weightExplicit(e: number): boolean;
+    /**
+     * Append a live edge and link it into both incidence lists. The caller has validated the
+     * endpoints and the weight.
+     * @param u - source index
+     * @param v - target index
+     * @param weight - the weight, or undefined when omitted (stored as 1 when the array exists)
+     * @returns the new edge index
+     */
+    pushEdge(u: number, v: number, weight: number | undefined): number;
+    /**
+     * Append `src.length` live edges at once (the bulk `addEdges` path): the same storage, weight
+     * tracking and incidence-list linking as one pushEdge per edge in order, done as typed-array
+     * passes. The caller has validated the endpoints and the weights.
+     * @param src - source indices
+     * @param dst - target indices, as many as `src`
+     * @param weights - the explicit weight of every edge, or null when every weight is omitted
+     * @returns the first new edge index
+     */
+    pushEdges(src: U32, dst: U32, weights: TypedArrayData | null): number;
+    /**
+     * trackWeight for a batch of `count` edges from `first` that all supplied or all omitted their
+     * weight: the same mode transitions and bitmap contents as `count` calls in order.
+     * @param first - the first edge of the batch
+     * @param count - the batch size, at least 1
+     * @param explicit - whether the batch supplied its weights
+     */
+    private trackWeights;
+    /**
+     * Tombstone a live edge (O(1)).
+     * @param e - a live edge index
+     */
+    killEdge(e: number): void;
+    /**
+     * Live edges leaving a node, walked from the out-list (O(degree)).
+     * @param u - the node index
+     * @returns the live edge indices in ascending order
+     */
+    outEdges(u: number): U32;
+    /**
+     * Live edges entering a node, walked from the in-list (O(degree)).
+     * @param v - the node index
+     * @returns the live edge indices in ascending order
+     */
+    inEdges(v: number): U32;
+    /**
+     * Live edges incident to a node in either orientation (the undirected outEdgesOf / inEdgesOf,
+     * design section 6.6 and invariant I7): both lists walked, a self-loop listed once (O(degree)).
+     * @param u - the node index
+     * @returns the live edge indices in ascending order
+     */
+    incidentEdges(u: number): U32;
+    /**
+     * Bytes of typed staging held (capacity, not length), for `byteLength()`.
+     * @returns the byte count
+     */
+    byteLength(): number;
+    private allocateWeights;
+    /**
+     * Allocate the weightSet bitmap over `edge + 1` bits: every earlier edge gets `earlier`, `edge`
+     * itself the opposite.
+     * @param earlier - the value of every edge before `edge`
+     * @param edge - the first disagreeing edge
+     * @returns the new bitmap
+     */
+    private allocateWeightSet;
+}
+/** The maps of the two index spaces a `refersTo` column's values may live in (old -> new, or source -> builder). */
+export interface IndexMaps {
+    /** Node index map. */
+    readonly node: U32;
+    /** Edge index map. */
+    readonly edge: U32;
+}
+/** An old -> new index remap with its inverse and the new count. */
+export interface IndexRemap {
+    /** old index -> new index or INVALID_INDEX. */
+    readonly remap: U32;
+    /** new index -> old index. */
+    readonly origin: U32;
+    /** The new count. */
+    readonly count: number;
+}
+/**
+ * The remap that drops every index whose `keep(i)` is false, assigning new indices in index order
+ * (invariant I14).
+ * @param bound - the old index space size
+ * @param keep - whether an old index survives
+ * @returns the remap, its inverse and the new count
+ */
+export declare function remapDropping(bound: number, keep: (i: number) => boolean): IndexRemap;
+/**
+ * The remap that keeps exactly the indices whose bit is set in `keep` (a bitmap over `bound` bits),
+ * assigning new indices in index order (invariant I14): `remapDropping` over the builder's alive
+ * bitmaps without a call per index.
+ * @param bound - the old index space size
+ * @param keep - a bitmap of at least `bound` bits; bit i set = old index i survives
+ * @returns the remap, its inverse and the new count
+ */
+export declare function remapKeepingBits(bound: number, keep: U32): IndexRemap;
+/**
+ * The remap that keeps exactly the survivors of a merge walk (the indices with `survivorOf[e] === e`),
+ * assigning new indices in index order (invariant I14): `remapDropping` for design section 6.5's
+ * step-7 repeat without a call per edge.
+ * @param survivorOf - old edge -> its survivor (itself for a survivor)
+ * @returns the remap, its inverse and the new count
+ */
+export declare function remapSurvivors(survivorOf: U32): IndexRemap;
+/** What a compaction gathers: the node and edge remaps plus optional merged-weight overrides. */
+interface CompactionPlan {
+    /** The node remap (old -> new). */
+    readonly nodes: IndexRemap;
+    /** The edge remap (old -> new) of the ROWS; merged edges map to INVALID_INDEX here (their survivor carries them). */
+    readonly edges: IndexRemap;
+    /**
+     * The remap `refersTo: "edge"` VALUES are rewritten through when it differs from the row remap: a
+     * merged edge maps to its survivor's new index (design sections 5.11 and 7.3), never to
+     * INVALID_INDEX. Null when the row remap applies to values too.
+     */
+    readonly edgeValues: U32 | null;
+    /** Per NEW edge: the reduced weight to store where `mergedWeightStored` is set; null when no merge happened. */
+    readonly mergedWeights: Float64Array | null;
+    /** Per NEW edge: bit set when `mergedWeights` holds a value to store; null when no merge happened. */
+    readonly mergedWeightStored: U32 | null;
+    /** Per NEW edge: bit set when the merged group's weight is explicit after the merge; null when no merge happened. */
+    readonly mergedWeightSet: U32 | null;
+}
+/**
+ * Gather a new staging through a compaction plan (design section 6.3 step 1). The source is left
+ * untouched; the result has no tombstones, fresh `ids` / `idToIndex` objects (or none when every node
+ * is anonymous), rebuilt incidence lists, gathered columns with `refersTo` values rewritten, and
+ * extension tables with their `refersTo` values rewritten.
+ * @param source - the staging to compact
+ * @param plan - the remaps and merge overrides
+ * @returns the compacted staging
+ */
+export declare function compactStaging(source: Staging, plan: CompactionPlan): Staging;
+export {};
+//# sourceMappingURL=compact.d.ts.map

package/dist/src/builder/compact.d.ts.map

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