@vltpkg/graph 1.0.0-rc.3 → 1.0.0-rc.31

package/README.md

@@ -1,3 +1,7 @@
+---
+title: '@vltpkg/graph'
+---
+
 ![graph](https://github.com/user-attachments/assets/dfbed9e0-8ef0-4a43-993d-d3e5d1e5ae1d)
 
 # @vltpkg/graph
@@ -41,57 +45,87 @@ At a glance:
   `node_modules/.vlt-lock.json` mirroring the current on-disk state to
   accelerate subsequent loads of the Actual graph.
 - Modifiers: Configuration for selectively altering dependency
-  resolution; Ideal/Actual builders support skipping node loads when
-  modifiers change.
+  resolution via DSS queries in `vlt.json`.
+- Peer Contexts: Isolation mechanism for peer dependencies that allows
+  multiple versions of the same package when peer requirements differ.
 
 ## API
 
-### `actual.load({ projectRoot: string }): Graph`
+### `actual.load(options): Graph`
 
 Recursively loads the `node_modules` folder found at `projectRoot` in
 order to create a graph representation of the current installed
 packages.
 
-### `async ideal.build({ projectRoot: string }): Promise<Graph>`
+### `ideal.build(options): Promise<Graph>`
 
-This method returns a new `Graph` object, reading from the
-`package.json` file located at `projectRoot` dir and building up the
-graph representation of nodes and edges from the files read from the
-local file system.
+Builds the ideal dependency graph by loading from lockfile (preferred)
+or actual graph, then expanding dependencies by fetching manifests.
+Requires `packageInfo` and `remover` in addition to standard options.
 
-### `lockfile.load({ mainManifest: Manifest, projectRoot: string }): Graph`
+### `lockfile.load(options): Graph`
 
 Loads the lockfile file found at `projectRoot` and returns the graph.
 
-### `reify(options): Promise<Diff>`
+### `lockfile.save(options): void`
+
+Saves the graph to `vlt-lock.json`.
+
+### `reify(options): Promise<ReifyResult>`
 
 Computes a `Diff` between the Actual and Ideal graphs and applies the
 minimal filesystem changes (creating/deleting links, writing
 lockfiles, hoisting, lifecycle scripts) to make the on-disk install
-match the Ideal graph.
+match the Ideal graph. Returns `{ diff, buildQueue }`.
+
+### `install(options, add?): Promise<{ graph, diff, buildQueue }>`
+
+High-level install orchestration that handles graph building, reify,
+and lockfile management. Supports `--frozen-lockfile`,
+`--clean-install`, and `--lockfile-only` modes.
+
+### `mermaidOutput(graph): string`
+
+Generates Mermaid flowchart syntax from graph data.
+
+### `humanReadableOutput(graph, options): string`
+
+Generates ASCII tree output with optional colors. Used in `vlt ls`.
+
+### `jsonOutput(graph): JSONOutputItem[]`
+
+Returns array of `{name, fromID, spec, type, to, overridden}` items.
 
 ## Usage
 
-Here's a quick example of how to use the `@vltpkg/graph.ideal.build`
-method to build a graph representation of the install defined at the
-`projectRoot` directory.
+### High-Level Install
 
-```
-import { ideal } from '@vltpkg/graph'
+```ts
+import { install } from '@vltpkg/graph'
 
-const graph = await ideal.build({ projectRoot: process.cwd() })
+const { graph, diff, buildQueue } = await install({
+  projectRoot: process.cwd(),
+  packageInfo,
+  packageJson,
+  scurry,
+  allowScripts: '*',
+})
 ```
 
 ### Load Actual Graph and Reify
 
 ```ts
 import { actual, ideal, reify } from '@vltpkg/graph'
+import { RollbackRemove } from '@vltpkg/rollback-remove'
+
+const remover = new RollbackRemove()
 
 // Load current on-disk state
 const from = actual.load({
   projectRoot: process.cwd(),
   packageJson,
   scurry,
+  loadManifests: true,
 })
 
 // Build intended end state (may start from lockfile or actual)
@@ -100,15 +134,18 @@ const to = await ideal.build({
   packageInfo,
   packageJson,
   scurry,
+  remover,
 })
 
 // Apply minimal changes to match Ideal
-await reify({
+const { diff, buildQueue } = await reify({
   graph: to,
   actual: from,
   packageInfo,
   packageJson,
   scurry,
+  remover,
+  allowScripts: '*',
 })
 ```
 
@@ -118,15 +155,48 @@ await reify({
 import { lockfile } from '@vltpkg/graph'
 
 // Load virtual graph from vlt-lock.json
-const g = lockfile.load({
+const graph = lockfile.load({
   projectRoot,
   mainManifest,
   packageJson,
-  scurry,
 })
 
-// Save both lockfile formats
-lockfile.save({ graph: g, projectRoot, packageJson, scurry })
+// Save to vlt-lock.json
+lockfile.save({ graph })
+```
+
+### Graph Visualization
+
+```ts
+import {
+  mermaidOutput,
+  humanReadableOutput,
+  jsonOutput,
+} from '@vltpkg/graph'
+
+// Mermaid flowchart (for docs, dashboards)
+const mermaid = mermaidOutput({
+  edges: [...graph.edges],
+  nodes: [...graph.nodes.values()],
+  importers: graph.importers,
+})
+
+// ASCII tree with colors (used in `vlt ls`)
+const tree = humanReadableOutput(
+  {
+    edges: [...graph.edges],
+    nodes: [...graph.nodes.values()],
+    importers: graph.importers,
+  },
+  { colors: true },
+)
+
+// JSON array of dependency items
+const json = jsonOutput({
+  edges: [...graph.edges],
+  nodes: [...graph.nodes.values()],
+  importers: graph.importers,
+})
 ```
 
 ## Architecture
@@ -137,6 +207,7 @@ Graph construction modes supported by the library:
   - Load and save via `src/lockfile/load.ts` and
     `src/lockfile/save.ts`
   - Hidden lockfile: `node_modules/.vlt-lock.json` for faster loads
+  - 📖 [Lockfile README](./src/lockfile/README.md)
 
 - Actual Graphs (filesystem-based)
   - Loaded by traversing `node_modules` via `src/actual/load.ts`
@@ -150,20 +221,28 @@ Graph construction modes supported by the library:
     `src/ideal/get-importer-specs.ts`
   - Fetches and expands manifests using `@vltpkg/package-info`, reuses
     existing nodes that satisfy specs
+  - 📖 [Ideal README](./src/ideal/README.md)
 
 Finally, `src/diff.ts` computes changes and `src/reify/` applies them
 to the filesystem.
 
+- 📖 [Reify README](./src/reify/README.md)
+- 📖 [Architecture Guide](./ARCHITECTURE.md)
+
 ## Related Workspaces
 
 - `@vltpkg/dep-id`: Unique IDs for packages, ensuring `Node` identity
 - `@vltpkg/spec`: Parse/normalize dependency specifiers and registry
   semantics
 - `@vltpkg/semver`: Semantic version parsing/comparison
+- `@vltpkg/satisfies`: Check if a DepID satisfies a Spec
 - `@vltpkg/package-info`: Fetch remote manifests and artifacts
   (registry, git, tarball)
 - `@vltpkg/package-json`: Read and cache local `package.json` files
 - `@vltpkg/workspaces`: Monorepo workspace discovery and grouping
+- `@vltpkg/rollback-remove`: Safe file removal with rollback
+  capability
+- `@vltpkg/vlt-json`: Load `vlt.json` configuration (modifiers, etc.)
 
 ## References
 

package/dist/{esm/actual → actual}/load.d.ts

@@ -91,10 +91,17 @@ export declare const asStoreConfigObject: (obj: unknown) => StoreConfigObject;
  * path-based or a registry spec, otherwise returns `undefined`.
  */
 export declare const getPathBasedId: (spec: Spec, path: Path) => DepID | undefined;
+/**
+ * Verify that all importer node_modules directories exist on disk.
+ * The hidden lockfile may report deps as installed even when a
+ * workspace's node_modules has been manually deleted. Throws if
+ * any importer node_modules directory is missing, causing the
+ * caller to fall through to filesystem-based graph loading.
+ */
+export declare const verifyImporterNodeModules: (graph: Graph, projectRoot: string) => void;
 /**
  * Read the file system looking for `node_modules` folders and
  * returns a new {@link Graph} that represents the relationship
  * between the dependencies found.
  */
 export declare const load: (options: LoadOptions) => Graph;
-//# sourceMappingURL=load.d.ts.map

package/dist/{esm/actual → actual}/load.js

@@ -1,4 +1,4 @@
-import { asDepID, hydrate, joinDepIDTuple } from '@vltpkg/dep-id';
+import { asDepID, hydrate, joinDepIDTuple, joinExtra, splitDepID, splitExtra, } from '@vltpkg/dep-id';
 import { Spec } from '@vltpkg/spec';
 import { graphStep } from '@vltpkg/output';
 import { isObject } from '@vltpkg/types';
@@ -6,7 +6,8 @@ import { shorten, getRawDependencies, getDependencies, } from "../dependencies.j
 import { Graph } from "../graph.js";
 import { loadHidden } from "../lockfile/load.js";
 import { saveHidden } from "../lockfile/save.js";
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
 /**
  * Checks if a given object is a {@link StoreConfigObject}.
  */
@@ -136,12 +137,14 @@ const parseDir = (options, scurry, packageJson, depsFound, graph, fromNode, curr
         if (!loadManifests) {
             const depId = findDepID(realpath);
             if (depId) {
-                let h = hydrate(depId, alias, {
-                    ...options,
-                });
+                let h = hydrate(depId, alias, options);
                 // if the parsed registry value is using the default value, then
                 // the node should inherit the registry value from its parent node
-                h.inheritedRegistry = fromNode.registry;
+                if (h.type === 'registry' &&
+                    h.registry === h.options.registry &&
+                    fromNode.registry) {
+                    h.registry = fromNode.registry;
+                }
                 // Check for active modifiers and replace spec even when not loading manifests
                 const { spec: modifiedSpec, queryModifier } = maybeApplyModifierToSpec(h, alias, modifierRefs);
                 h = modifiedSpec;
@@ -152,7 +155,7 @@ const parseDir = (options, scurry, packageJson, depsFound, graph, fromNode, curr
                 h, // uses spec from hydrated id
                 {
                     name,
-                }, depId, queryModifier);
+                }, depId, joinExtra({ modifier: queryModifier }));
                 // Update active entry after placing package
                 const activeModifier = modifierRefs?.get(alias);
                 if (activeModifier && node) {
@@ -177,15 +180,31 @@ const parseDir = (options, scurry, packageJson, depsFound, graph, fromNode, curr
             const depType = shorten(type, alias, fromNode.manifest);
             let spec = Spec.parse(alias, bareSpec, {
                 ...options,
+                // fall back to options.registry (which the lockfile merges into)
+                // so importer-level edges don't silently revert to the default
+                // npm registry. see vltpkg/vltpkg#1580.
+                registry: fromNode.registry ?? options.registry,
             });
-            // if the parsed registry value is using the default value, then
-            // the node should inherit the registry value from its parent node
-            spec.inheritedRegistry = fromNode.registry;
             // Check for active modifiers and replace spec if a modifier is complete
             const { spec: modifiedSpec, queryModifier } = maybeApplyModifierToSpec(spec, alias, modifierRefs);
             spec = modifiedSpec;
             const maybeId = getPathBasedId(spec, realpath);
-            node = graph.placePackage(fromNode, depType, spec, mani, maybeId, queryModifier);
+            let peerSetHash;
+            if (maybeId) {
+                // parses extra info from depID to retrieve peerSetHash
+                try {
+                    const tuple = splitDepID(maybeId);
+                    const type = tuple[0];
+                    const extra = type === 'registry' || type === 'git' ?
+                        tuple[3]
+                        : tuple[2];
+                    peerSetHash =
+                        extra ? splitExtra(extra).peerSetHash : undefined;
+                    /* c8 ignore next - impossible: getPathBasedId asserts valid dep id */
+                }
+                catch { }
+            }
+            node = graph.placePackage(fromNode, depType, spec, mani, maybeId, joinExtra({ modifier: queryModifier, peerSetHash }));
             // Update active entry after placing package
             const activeModifier = modifierRefs?.get(alias);
             if (activeModifier && node) {
@@ -223,14 +242,27 @@ const parseDir = (options, scurry, packageJson, depsFound, graph, fromNode, curr
             const depType = shorten(type, name, fromNode.manifest);
             let spec = Spec.parse(name, bareSpec, {
                 ...options,
+                registry: fromNode.registry ?? options.registry,
             });
-            // if the parsed registry value is using the default value, then
-            // the node should inherit the registry value from its parent node
-            spec.inheritedRegistry = fromNode.registry;
             // Check for active modifiers and replace spec for missing dependencies
             const { spec: modifiedSpec, queryModifier } = maybeApplyModifierToSpec(spec, name, modifierRefs);
             spec = modifiedSpec;
-            graph.placePackage(fromNode, depType, spec, undefined, undefined, queryModifier);
+            graph.placePackage(fromNode, depType, spec, undefined, undefined, joinExtra({ modifier: queryModifier }));
+        }
+    }
+};
+/**
+ * Verify that all importer node_modules directories exist on disk.
+ * The hidden lockfile may report deps as installed even when a
+ * workspace's node_modules has been manually deleted. Throws if
+ * any importer node_modules directory is missing, causing the
+ * caller to fall through to filesystem-based graph loading.
+ */
+export const verifyImporterNodeModules = (graph, projectRoot) => {
+    for (const importer of graph.importers) {
+        const nm = resolve(projectRoot, importer.location, 'node_modules');
+        if (!existsSync(nm)) {
+            throw new Error(`Missing node_modules for importer: ${importer.location}`);
         }
     }
 };
@@ -254,12 +286,14 @@ export const load = (options) => {
                 monorepo,
                 scurry,
             });
+            verifyImporterNodeModules(graph, projectRoot);
             done();
             return graph;
         }
         catch {
-            // if validation fails or any other error occurs,
-            // fall back to filesystem traversal
+            // Hidden lockfile is cache-only, safe to regenerate on any error
+            // as it will fall back to filesystem traversal
+            // TODO: Warn version mismatch to @vltpkg/output for debugging
         }
     }
     const graph = new Graph({ ...options, mainManifest });
@@ -293,12 +327,13 @@ export const load = (options) => {
         // Clean up any pending modifier entries that were never completed
         modifiers?.rollbackActiveEntries();
         // caches the load result to the hidden lockfile when enabled
-        saveHidden({
-            ...options,
-            graph,
-        });
+        if (scurry.cwd.resolve('node_modules').lstatSync()?.isDirectory()) {
+            saveHidden({
+                ...options,
+                graph,
+            });
+        }
     }
     done();
     return graph;
 };
-//# sourceMappingURL=load.js.map

package/dist/{esm/browser.d.ts → browser.d.ts}

@@ -12,4 +12,3 @@ declare const transfer: {
     load: (transfered: import("./transfer-data/load.ts").TransferData) => import("./transfer-data/load.ts").LoadResult;
 };
 export { asDependencyTypeShort, getBooleanFlagsFromNum, lockfile, longDependencyTypes, shorten, stringifyNode, transfer, };
-//# sourceMappingURL=browser.d.ts.map

package/dist/{esm/browser.js → browser.js}

@@ -14,4 +14,3 @@ const transfer = {
     load,
 };
 export { asDependencyTypeShort, getBooleanFlagsFromNum, lockfile, longDependencyTypes, shorten, stringifyNode, transfer, };
-//# sourceMappingURL=browser.js.map

package/dist/{esm/build.d.ts → build.d.ts}

@@ -26,4 +26,3 @@ export interface BuildOptions extends LoadOptions {
  * 6. Persists build results to lockfile
  */
 export declare const build: (options: BuildOptions) => Promise<BuildResult>;
-//# sourceMappingURL=build.d.ts.map

package/dist/{esm/build.js → build.js}

@@ -76,4 +76,3 @@ export const build = async (options) => {
     });
     return buildResult;
 };
-//# sourceMappingURL=build.js.map

package/dist/{esm/dependencies.d.ts → dependencies.d.ts}

@@ -63,4 +63,3 @@ export declare const getRawDependencies: (node: NodeLike) => Map<string, RawDepe
  * from a given node manifest, including missing dependencies.
  */
 export declare const getDependencies: (node: NodeLike, options: SpecOptions) => Map<string, Dependency>;
-//# sourceMappingURL=dependencies.d.ts.map

package/dist/{esm/dependencies.js → dependencies.js}

@@ -109,4 +109,3 @@ export const getDependencies = (node, options) => {
     }
     return res;
 };
-//# sourceMappingURL=dependencies.js.map

package/dist/{esm/diff.d.ts → diff.d.ts}

@@ -53,6 +53,7 @@ export declare class Diff {
         nodes: {
             add: {
                 rawManifest?: import("@vltpkg/types").Override<import("@vltpkg/types").Manifest, import("@vltpkg/types").NormalizedFields> | undefined;
+                peerSetHash?: string | undefined;
                 id: import("@vltpkg/dep-id").DepID;
                 name: string;
                 version: string | undefined;
@@ -70,11 +71,13 @@ export declare class Diff {
                     engines?: Record<string, string>;
                     os?: string[] | string;
                     cpu?: string[] | string;
+                    libc?: string[] | string;
                 } | undefined;
                 buildState: "none" | "needed" | "built" | "failed";
             }[];
             delete: {
                 rawManifest?: import("@vltpkg/types").Override<import("@vltpkg/types").Manifest, import("@vltpkg/types").NormalizedFields> | undefined;
+                peerSetHash?: string | undefined;
                 id: import("@vltpkg/dep-id").DepID;
                 name: string;
                 version: string | undefined;
@@ -92,6 +95,7 @@ export declare class Diff {
                     engines?: Record<string, string>;
                     os?: string[] | string;
                     cpu?: string[] | string;
+                    libc?: string[] | string;
                 } | undefined;
                 buildState: "none" | "needed" | "built" | "failed";
             }[];
@@ -113,4 +117,3 @@ export declare class Diff {
     };
 }
 export {};
-//# sourceMappingURL=diff.d.ts.map

package/dist/{esm/diff.js → diff.js}

@@ -80,8 +80,12 @@ export class Diff {
                 continue;
             if (fromEdge?.to)
                 this.edges.delete.add(fromEdge);
-            if (edge.to)
+            if (edge.to) {
                 this.edges.add.add(edge);
+                if (!edge.optional) {
+                    this.optionalOnly = false;
+                }
+            }
         }
         for (const edge of this.from.edges) {
             // the node with this dep, in the to graph
@@ -145,4 +149,3 @@ ${lines
         };
     }
 }
-//# sourceMappingURL=diff.js.map

package/dist/{esm/edge.d.ts → edge.d.ts}

@@ -41,6 +41,6 @@ export declare class Edge implements EdgeLike {
         type: DependencyTypeShort;
         spec: string;
     };
+    toString(): string;
 }
 export {};
-//# sourceMappingURL=edge.d.ts.map

package/dist/{esm/edge.js → edge.js}

@@ -70,5 +70,8 @@ export class Edge {
             spec: String(this.spec),
         };
     }
+    toString() {
+        const to = `${this.name}${this.to ? '' : ' (missing)'}`;
+        return `Edge from: ${this.from.id} --|${this.type}|--> ${to}`;
+    }
 }
-//# sourceMappingURL=edge.js.map

package/dist/fixup-added-names.d.ts

@@ -0,0 +1,18 @@
+import { Spec } from '@vltpkg/spec';
+import type { Dependency } from './dependencies.ts';
+import type { Manifest } from '@vltpkg/types';
+import type { SpecOptions } from '@vltpkg/spec';
+/**
+ * When adding new dependencies, it's very common to not have a dependency
+ * name directly available to reference, e.g: `file:local/folder` or
+ * `remote:tarball-url.tgz`. In these cases, a placeholder `(unknown)` name
+ * is used in the `Spec` object and the `add` Map structure that holds
+ * references to added dependencies will use the stringified spec as a key.
+ *
+ * This helper function fixes unknown names in the `add` map by replacing
+ * placeholder specs with the correct names from the provided manifest.
+ *
+ * It also fixes empty bareSpec values (from CLI args like `vlt install foo`)
+ * by calculating the proper semver range from the resolved manifest version.
+ */
+export declare const fixupAddedNames: (add: Map<string, Dependency> | undefined, manifest: Pick<Manifest, "name" | "version"> | undefined, options: SpecOptions, spec: Spec) => Spec;

package/dist/fixup-added-names.js

@@ -0,0 +1,46 @@
+import { Spec } from '@vltpkg/spec';
+import { calculateSaveValue } from "./reify/calculate-save-value.js";
+/**
+ * When adding new dependencies, it's very common to not have a dependency
+ * name directly available to reference, e.g: `file:local/folder` or
+ * `remote:tarball-url.tgz`. In these cases, a placeholder `(unknown)` name
+ * is used in the `Spec` object and the `add` Map structure that holds
+ * references to added dependencies will use the stringified spec as a key.
+ *
+ * This helper function fixes unknown names in the `add` map by replacing
+ * placeholder specs with the correct names from the provided manifest.
+ *
+ * It also fixes empty bareSpec values (from CLI args like `vlt install foo`)
+ * by calculating the proper semver range from the resolved manifest version.
+ */
+export const fixupAddedNames = (add, manifest, options, spec) => {
+    // Handle nameless dependencies
+    if (add && manifest?.name && spec.name === '(unknown)') {
+        const s = add.get(String(spec));
+        if (s) {
+            // removes the previous, placeholder entry key
+            add.delete(String(spec));
+            // replaces spec with a version with the correct name
+            spec = Spec.parse(manifest.name, spec.bareSpec, options);
+            // updates the add map with the fixed up spec
+            const n = {
+                type: s.type,
+                spec,
+            };
+            add.set(manifest.name, n);
+        }
+    }
+    // Fix empty bareSpec (usually from CLI args like `vlt install foo`)
+    // by calculating the proper semver range from the resolved manifest version
+    if (add && manifest?.version && !spec.bareSpec) {
+        const addEntry = add.get(spec.name);
+        if (addEntry) {
+            const saveValue = calculateSaveValue(spec.final.type, spec, undefined, manifest.version);
+            if (saveValue && saveValue !== spec.bareSpec) {
+                spec = Spec.parse(spec.name, saveValue, options);
+                addEntry.spec = spec;
+            }
+        }
+    }
+    return spec;
+};

package/dist/{esm/graph.d.ts → graph.d.ts}

@@ -6,6 +6,7 @@ import type { Monorepo } from '@vltpkg/workspaces';
 import type { InspectOptions } from 'node:util';
 import { Edge } from './edge.ts';
 import { Node } from './node.ts';
+import type { PeerContext } from './ideal/types.ts';
 declare const kCustomInspect: unique symbol;
 export type ManifestInventory = Map<DepID, NormalizedManifest>;
 export type GraphOptions = SpecOptions & {
@@ -73,7 +74,26 @@ export declare class Graph implements GraphLike {
      * The root of the project this graph represents
      */
     projectRoot: string;
+    /**
+     * The peer context sets used to resolve peer dependencies within this graph.
+     */
+    peerContexts: PeerContext[];
+    /**
+     * Cache of forked peer contexts so identical fork operations can reuse
+     * previously created contexts instead of duplicating them.
+     *
+     * Key format is internal and constructed in `ideal/peers.ts`.
+     */
+    peerContextForkCache: Map<string, PeerContext>;
+    /**
+     * Tracks the current peer context index.
+     */
+    currentPeerContextIndex: number;
     constructor(options: GraphOptions);
+    /**
+     * Get the next peer context index.
+     */
+    nextPeerContextIndex(): number;
     /**
      * Delete all nodes and edges that are unreachable from the importers.
      * The collection of deleted nodes is returned.
@@ -93,7 +113,7 @@ export declare class Graph implements GraphLike {
     /**
      * Find an existing node to satisfy a dependency
      */
-    findResolution(spec: Spec, fromNode: Node, queryModifier?: string): Node | undefined;
+    findResolution(spec: Spec, fromNode: Node, extra?: string): Node | undefined;
     /**
      * Create a new node in the graph.
      */
@@ -121,13 +141,13 @@ export declare class Graph implements GraphLike {
     /**
      * Removes the resolved node of a given edge.
      */
-    removeEdgeResolution(edge: Edge, queryModifier?: string): void;
+    removeEdgeResolution(edge: Edge, extra?: string): void;
     /**
-     * Reset resolution cache data.
+     * Remove all edges from the graph while preserving nodes and resolution caches.
+     * This allows the graph to be reconstructed efficiently using the existing nodes.
      */
-    resetResolution(): void;
+    resetEdges(): void;
     toJSON(): import("./index.ts").LockfileData;
     [kCustomInspect](_: number, options: InspectOptions): string;
 }
 export {};
-//# sourceMappingURL=graph.d.ts.map