@graphty/graph-format 0.0.0 → 0.2.0

package/dist/src/populate/from-csr.d.ts

@@ -0,0 +1,61 @@
+/**
+ * `fromCsr()` (design section 8.1, entry point 2; decision C12): adopt prebuilt CSR arrays -- from
+ * a file, a worker, another package or a generator that emits CSR directly -- without copying by
+ * default (GraphBLAS pack semantics: the caller transfers ownership and must not mutate them
+ * afterwards), with full validation by default because adopted arrays typically come from a file or
+ * the network (design section 9.5).
+ *
+ * The pipeline: resolve the optional arrays (an absent `arcToEdge` is the identity of a directed
+ * graph, an absent `edgeToArc` is derived in one O(m) pass, `edgeCount` defaults to the arc count or
+ * is derived from `arcToEdge`); adopt or copy; detect an already-aligned shared buffer as the arena
+ * (design section 10.3); build a candidate snapshot; check the rows (invariant I4) when `sortRows`
+ * is set and, when some row is unsorted, rebuild a fresh sorted core through the freeze pipeline's
+ * counting sorts over the declared edge list (the caller's arrays are not modified; the cost is a
+ * freeze); validate at the requested level; verify the caller's flag claims (invariant I9).
+ *
+ * `detectArena()` is exported for `fromWire`, which applies the same detection when a manifest
+ * carries no arena descriptor (design section 8.1).
+ */
+import { type CoreArrays } from "../builder/arena.js";
+import { type GraphSnapshot } from "../snapshot/graph-snapshot.js";
+import { type ArenaLayout, type CsrInput, type FromCsrOptions, type GraphMeta, type GraphMetaPatch } from "../types/index.js";
+/**
+ * Detect whether adopted core arrays already form an arena (design sections 8.1 and 10.3): every
+ * present, non-empty, non-identity core array is a view over ONE plain ArrayBuffer, laid out hot to
+ * cold (rowPtr, colIdx, weights, arcToEdge, edgeToArc) without overlap, each starting at a multiple
+ * of 256 bytes relative to `rowPtr`. When they do, that buffer is the arena: `byteOffset` is
+ * rowPtr's, `byteLength` spans to the end of the last array and `hotByteLength` ends at the weights
+ * (or colIdx, or rowPtr) segment. Otherwise null. Arrays whose segment would be null (a zero-length
+ * array, an absent weights array, an identity permutation given as null) do not take part.
+ * @param core - the core arrays; `arcToEdge` / `edgeToArc` null when identity
+ * @returns the arena layout, or null when the arrays are not an aligned shared buffer
+ */
+export declare function detectArena(core: Omit<CoreArrays, "arena">): ArenaLayout | null;
+/**
+ * Resolve a GraphMetaPatch into a complete GraphMeta (design section 5.9) with the builder's
+ * `setMeta` rules over empty metadata (E_COLUMN_TYPE with details.field on a bad field).
+ * @param patch - the patch, or undefined for no metadata
+ * @returns the metadata, frozen
+ */
+export declare function resolveGraphMeta(patch: GraphMetaPatch | undefined): GraphMeta;
+/**
+ * Build a snapshot from prebuilt CSR arrays (design section 8.1). The arrays are ADOPTED without
+ * copying by default (`copy: false`): the caller transfers ownership and must not mutate them
+ * afterwards; when they already share one plain ArrayBuffer at 256-byte-aligned offsets in arena
+ * order that buffer becomes the snapshot's arena, otherwise `arena` is null. With `copy: true` (or
+ * when an array is over a SharedArrayBuffer) the core is copied into a fresh arena. `validate`
+ * defaults to "full" (design section 9.5), which computes the flags and verifies the caller's claims
+ * (invariant I9); "structure" and "none" trust every claimed flag and compute only the unclaimed ones
+ * (design section 8.1: "structure" skips the sortedness / multigraph / flag checks and trusts
+ * `flags`). With `sortRows: true` (the default) invariant I4 is checked in O(m) and unsorted rows
+ * are rebuilt through the freeze pipeline into a fresh arena; `sortRows: false` asserts sorted rows,
+ * checked under "full". A directed input without `arcToEdge` (or with the identity) keeps identity
+ * permutations lazy, so `edgeList().weights` aliases `weights`.
+ * @param input - the arrays and counts; an undirected input must supply arcToEdge
+ * @param options - validation level, copy and sortRows
+ * @returns the snapshot; E_INVALID_SNAPSHOT (details.invariant, location) on every rejected input,
+ *   E_INVALID_ID / E_DUPLICATE_ID for bad ids, E_COLUMN_LENGTH for a column or id array of the wrong
+ *   length, E_TOO_LARGE for a node count above MAX_COUNT
+ */
+export declare function fromCsr(input: CsrInput, options?: FromCsrOptions): GraphSnapshot;
+//# sourceMappingURL=from-csr.d.ts.map

package/dist/src/populate/from-csr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-csr.d.ts","sourceRoot":"","sources":["../../../src/populate/from-csr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAiC,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAOrF,OAAO,EAAkB,KAAK,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAcnF,OAAO,EACH,KAAK,WAAW,EAKhB,KAAK,QAAQ,EAIb,KAAK,cAAc,EACnB,KAAK,SAAS,EACd,KAAK,cAAc,EAMtB,MAAM,mBAAmB,CAAC;AAmN3B;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,GAAG,WAAW,GAAG,IAAI,CA4C/E;AAmFD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS,GAAG,SAAS,CAE7E;AAgPD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,GAAE,cAAmB,GAAG,aAAa,CAsFpF"}