@platformos/platformos-graph 0.0.19 → 0.0.20

package/src/graph/test-helpers.ts

@@ -3,7 +3,6 @@ import { AbstractFileSystem } from '@platformos/platformos-common';
 import { NodeFileSystem } from '@platformos/platformos-check-node';
 import { vi } from 'vitest';
 import { URI } from 'vscode-uri';
-import { getWebComponentMap } from '../getWebComponentMap';
 import { toSourceCode } from '../toSourceCode';
 import { identity } from '../utils';
 
@@ -17,18 +16,12 @@ export function makeGetSourceCode(fs: AbstractFileSystem) {
 export const fixturesRoot = pathUtils.join(URI.file(__dirname), ...'../../fixtures'.split('/'));
 export const skeleton = pathUtils.join(fixturesRoot, 'skeleton');
 
-export async function getDependencies(rootUri: string, fs: AbstractFileSystem = NodeFileSystem) {
+export function getDependencies(fs: AbstractFileSystem = NodeFileSystem) {
   const getSourceCode = makeGetSourceCode(fs);
-  const deps = {
+  return {
     fs,
     getSourceCode,
-    getWebComponentDefinitionReference: (customElementName: string) =>
-      webComponentDefs.get(customElementName),
   };
-
-  const webComponentDefs = await getWebComponentMap(rootUri, deps);
-
-  return deps;
 }
 
 // This thing is way too hard to type.

package/src/graph/traverse-edges.spec.ts

@@ -0,0 +1,278 @@
+import { path as pathUtils } from '@platformos/platformos-check-common';
+import { beforeAll, describe, expect, it } from 'vitest';
+import { buildAppGraph } from '../index';
+import {
+  AppGraph,
+  Dependencies,
+  LiquidModule,
+  LiquidModuleKind,
+  ModuleType,
+  Reference,
+} from '../types';
+import { getGraphQLModuleByUri, getPartialModuleByUri } from './module';
+import { fixturesRoot, getDependencies } from './test-helpers';
+
+/**
+ * The exact source range of `snippet` within `source`. Derived from the fixture
+ * text (rather than hard-coded offsets) so the assertion is self-documenting
+ * and survives edits to unrelated lines.
+ */
+function rangeOf(source: string, snippet: string): [number, number] {
+  const start = source.indexOf(snippet);
+  if (start < 0) throw new Error(`snippet not found in fixture: ${snippet}`);
+  return [start, start + snippet.length];
+}
+
+/** A `direct` dependency Reference with no target range (the common case here). */
+function directRef(
+  sourceUri: string,
+  sourceRange: [number, number],
+  targetUri: string,
+  kind: Reference['kind'],
+): Reference {
+  return {
+    source: { uri: sourceUri, range: sourceRange },
+    target: { uri: targetUri },
+    type: 'direct',
+    kind,
+  };
+}
+
+const partialNode = (uri: string, exists: boolean, references: Reference[]): LiquidModule => ({
+  type: ModuleType.Liquid,
+  kind: LiquidModuleKind.Partial,
+  uri,
+  exists,
+  dependencies: [],
+  references,
+});
+
+describe('URI normalization in graph node factories', () => {
+  const emptyGraph = (): AppGraph => ({
+    rootUri: 'file:///app',
+    entryPoints: [],
+    modules: {},
+  });
+
+  it('getPartialModuleByUri returns a Partial node with a forward-slash URI', () => {
+    const mod = getPartialModuleByUri(
+      emptyGraph(),
+      'file:///d:/a/repo\\app\\lib\\queries\\list.liquid',
+    );
+    expect(mod).toEqual({
+      type: ModuleType.Liquid,
+      kind: LiquidModuleKind.Partial,
+      uri: 'file:///d:/a/repo/app/lib/queries/list.liquid',
+      dependencies: [],
+      references: [],
+    });
+  });
+
+  it('getGraphQLModuleByUri returns a GraphQL node with a forward-slash URI', () => {
+    const mod = getGraphQLModuleByUri(
+      emptyGraph(),
+      'file:///d:/a/repo\\app\\graphql\\find.graphql',
+    );
+    expect(mod).toEqual({
+      type: ModuleType.GraphQL,
+      kind: 'graphql',
+      uri: 'file:///d:/a/repo/app/graphql/find.graphql',
+      dependencies: [],
+      references: [],
+    });
+  });
+});
+
+describe('Graph traversal: {% function %} edges', () => {
+  const rootUri = pathUtils.join(fixturesRoot, 'function-edges');
+  const p = (part: string) => pathUtils.join(rootUri, ...part.split('/'));
+  let graph: AppGraph;
+  let indexSource: string;
+  let brokenSource: string;
+
+  beforeAll(async () => {
+    const dependencies: Dependencies = getDependencies();
+    graph = await buildAppGraph(rootUri, dependencies);
+    indexSource = (await dependencies.getSourceCode(p('app/views/pages/index.liquid'))).source;
+    brokenSource = (await dependencies.getSourceCode(p('app/views/pages/broken.liquid'))).source;
+  }, 15000);
+
+  it('links a page to the resolved lib query via a single function edge', () => {
+    const edge = directRef(
+      p('app/views/pages/index.liquid'),
+      rangeOf(indexSource, "function items = 'queries/list'"),
+      p('app/lib/queries/list.liquid'),
+      'function',
+    );
+    expect(graph.modules[p('app/views/pages/index.liquid')].dependencies).toEqual([edge]);
+    expect(graph.modules[p('app/lib/queries/list.liquid')]).toEqual(
+      partialNode(p('app/lib/queries/list.liquid'), true, [edge]),
+    );
+  });
+
+  it('records a missing function target as an exists:false node', () => {
+    const edge = directRef(
+      p('app/views/pages/broken.liquid'),
+      rangeOf(brokenSource, "function ghost = 'queries/missing'"),
+      p('app/lib/queries/missing.liquid'),
+      'function',
+    );
+    expect(graph.modules[p('app/lib/queries/missing.liquid')]).toEqual(
+      partialNode(p('app/lib/queries/missing.liquid'), false, [edge]),
+    );
+  });
+});
+
+describe('Graph traversal: {% graphql %} edges', () => {
+  const rootUri = pathUtils.join(fixturesRoot, 'graphql-edges');
+  const p = (part: string) => pathUtils.join(rootUri, ...part.split('/'));
+  let graph: AppGraph;
+  let indexSource: string;
+  let brokenSource: string;
+
+  const graphqlNode = (uri: string, exists: boolean, references: Reference[]) => ({
+    type: ModuleType.GraphQL,
+    kind: 'graphql' as const,
+    uri,
+    exists,
+    dependencies: [],
+    references,
+  });
+
+  beforeAll(async () => {
+    const dependencies: Dependencies = getDependencies();
+    graph = await buildAppGraph(rootUri, dependencies);
+    indexSource = (await dependencies.getSourceCode(p('app/views/pages/index.liquid'))).source;
+    brokenSource = (await dependencies.getSourceCode(p('app/views/pages/broken.liquid'))).source;
+  }, 15000);
+
+  it('links a page to the resolved .graphql operation via a single graphql edge', () => {
+    const edge = directRef(
+      p('app/views/pages/index.liquid'),
+      rangeOf(indexSource, "graphql posts = 'blog_posts/find', id: '1'"),
+      p('app/graphql/blog_posts/find.graphql'),
+      'graphql',
+    );
+    expect(graph.modules[p('app/views/pages/index.liquid')].dependencies).toEqual([edge]);
+    expect(graph.modules[p('app/graphql/blog_posts/find.graphql')]).toEqual(
+      graphqlNode(p('app/graphql/blog_posts/find.graphql'), true, [edge]),
+    );
+  });
+
+  it('records a missing graphql target as an exists:false GraphQL node', () => {
+    const edge = directRef(
+      p('app/views/pages/broken.liquid'),
+      rangeOf(brokenSource, "graphql ghost = 'blog_posts/missing'"),
+      p('app/graphql/blog_posts/missing.graphql'),
+      'graphql',
+    );
+    expect(graph.modules[p('app/graphql/blog_posts/missing.graphql')]).toEqual(
+      graphqlNode(p('app/graphql/blog_posts/missing.graphql'), false, [edge]),
+    );
+  });
+});
+
+describe('Graph traversal: {% include %} edges', () => {
+  const rootUri = pathUtils.join(fixturesRoot, 'include-edges');
+  const p = (part: string) => pathUtils.join(rootUri, ...part.split('/'));
+  let graph: AppGraph;
+  let indexSource: string;
+
+  beforeAll(async () => {
+    const dependencies: Dependencies = getDependencies();
+    graph = await buildAppGraph(rootUri, dependencies);
+    indexSource = (await dependencies.getSourceCode(p('app/views/pages/index.liquid'))).source;
+  }, 15000);
+
+  it('tags an include edge with kind "include" (distinct from render)', () => {
+    const edge = directRef(
+      p('app/views/pages/index.liquid'),
+      rangeOf(indexSource, "{% include 'shared/header' %}"),
+      p('app/views/partials/shared/header.liquid'),
+      'include',
+    );
+    expect(graph.modules[p('app/views/pages/index.liquid')].dependencies).toEqual([edge]);
+    expect(graph.modules[p('app/views/partials/shared/header.liquid')]).toEqual(
+      partialNode(p('app/views/partials/shared/header.liquid'), true, [edge]),
+    );
+  });
+});
+
+describe('Graph traversal: {% background %} edges', () => {
+  const rootUri = pathUtils.join(fixturesRoot, 'background-edges');
+  const p = (part: string) => pathUtils.join(rootUri, ...part.split('/'));
+  let graph: AppGraph;
+  let indexSource: string;
+  let brokenSource: string;
+
+  beforeAll(async () => {
+    const dependencies: Dependencies = getDependencies();
+    graph = await buildAppGraph(rootUri, dependencies);
+    indexSource = (await dependencies.getSourceCode(p('app/views/pages/index.liquid'))).source;
+    brokenSource = (await dependencies.getSourceCode(p('app/views/pages/broken.liquid'))).source;
+  }, 15000);
+
+  it('links a page to the background partial via a single background edge', () => {
+    const edge = directRef(
+      p('app/views/pages/index.liquid'),
+      rangeOf(indexSource, "background job_id = 'jobs/notify', data: 'x'"),
+      p('app/views/partials/jobs/notify.liquid'),
+      'background',
+    );
+    expect(graph.modules[p('app/views/pages/index.liquid')].dependencies).toEqual([edge]);
+    expect(graph.modules[p('app/views/partials/jobs/notify.liquid')]).toEqual(
+      partialNode(p('app/views/partials/jobs/notify.liquid'), true, [edge]),
+    );
+  });
+
+  it('records a missing background target as an exists:false node', () => {
+    const edge = directRef(
+      p('app/views/pages/broken.liquid'),
+      rangeOf(brokenSource, "background job_id = 'jobs/missing'"),
+      p('app/lib/jobs/missing.liquid'),
+      'background',
+    );
+    expect(graph.modules[p('app/lib/jobs/missing.liquid')]).toEqual(
+      partialNode(p('app/lib/jobs/missing.liquid'), false, [edge]),
+    );
+  });
+});
+
+describe('Graph traversal: module-namespaced targets (modules/<name>/public/...)', () => {
+  const rootUri = pathUtils.join(fixturesRoot, 'module-edges');
+  const p = (part: string) => pathUtils.join(rootUri, ...part.split('/'));
+  let graph: AppGraph;
+  let indexSource: string;
+
+  beforeAll(async () => {
+    const dependencies: Dependencies = getDependencies();
+    graph = await buildAppGraph(rootUri, dependencies);
+    indexSource = (await dependencies.getSourceCode(p('app/views/pages/index.liquid'))).source;
+  }, 15000);
+
+  it('resolves function + render targets into modules/<name>/public/{lib,views/partials}', () => {
+    const functionEdge = directRef(
+      p('app/views/pages/index.liquid'),
+      rangeOf(indexSource, "function items = 'modules/my_module/queries/get'"),
+      p('modules/my_module/public/lib/queries/get.liquid'),
+      'function',
+    );
+    const renderEdge = directRef(
+      p('app/views/pages/index.liquid'),
+      rangeOf(indexSource, "{% render 'modules/my_module/card' %}"),
+      p('modules/my_module/public/views/partials/card.liquid'),
+      'render',
+    );
+
+    expect(graph.modules[p('app/views/pages/index.liquid')].dependencies).toEqual([
+      functionEdge,
+      renderEdge,
+    ]);
+    expect(graph.modules[p('modules/my_module/public/lib/queries/get.liquid')]).toEqual(
+      partialNode(p('modules/my_module/public/lib/queries/get.liquid'), true, [functionEdge]),
+    );
+    expect(graph.modules[p('modules/my_module/public/views/partials/card.liquid')]).toEqual(
+      partialNode(p('modules/my_module/public/views/partials/card.liquid'), true, [renderEdge]),
+    );
+  });
+});

package/src/graph/traverse.ts

@@ -1,17 +1,31 @@
-import { NodeTypes } from '@platformos/liquid-html-parser';
-import { SourceCodeType, visit, Visitor } from '@platformos/platformos-check-common';
+import { NamedTags, NodeTypes } from '@platformos/liquid-html-parser';
+import { SourceCodeType, UriString, visit, Visitor } from '@platformos/platformos-check-common';
+import { DocumentsLocator } from '@platformos/platformos-common';
+import { URI } from 'vscode-uri';
 import {
   AugmentedDependencies,
   AppGraph,
   AppModule,
+  FileSourceCode,
   LiquidModule,
   ModuleType,
   Range,
   Reference,
+  ReferenceKind,
   Void,
 } from '../types';
-import { assertNever, exists, isString } from '../utils';
-import { getAssetModule, getLayoutModule, getPartialModule } from './module';
+import { assertNever, exists, isString, unique } from '../utils';
+import { getAssetModule, getGraphQLModuleByUri, getPartialModuleByUri } from './module';
+
+/** A resolved outgoing reference: the target graph node + its call-site range + kind. */
+interface ResolvedReference {
+  target: AppModule;
+  sourceRange: Range;
+  kind: ReferenceKind;
+}
+
+/** The dependency surface the reference resolver needs: just a filesystem (for DocumentsLocator). */
+type ResolverDependencies = Pick<AugmentedDependencies, 'fs'>;
 
 export async function traverseModule(
   module: AppModule,
@@ -44,6 +58,10 @@ export async function traverseModule(
       return; // Nothing to traverse in assets
     }
 
+    case ModuleType.GraphQL: {
+      return; // Leaf node — GraphQL documents have no platformOS dependencies
+    }
+
     default: {
       return assertNever(module);
     }
@@ -56,13 +74,47 @@ async function traverseLiquidModule(
   deps: AugmentedDependencies,
 ) {
   const sourceCode = await deps.getSourceCode(module.uri);
+  const references = await resolveLiquidReferences(appGraph, sourceCode, deps);
 
-  if (sourceCode.ast instanceof Error) return; // can't visit what you can't parse
+  for (const reference of references) {
+    bind(module, reference.target, {
+      sourceRange: reference.sourceRange,
+      kind: reference.kind,
+    });
+  }
 
-  const visitor: Visitor<
-    SourceCodeType.LiquidHtml,
-    { target: AppModule; sourceRange: Range; targetRange?: Range }
-  > = {
+  const modules = unique(references.map((ref) => ref.target));
+  const promises = modules.map((mod) => traverseModule(mod, appGraph, deps));
+
+  return Promise.all(promises);
+}
+
+/**
+ * Resolve a single parsed Liquid file's outgoing references — the one place that
+ * knows how each Liquid construct (`render`/`include`, `function`, `background`,
+ * `graphql`, asset filters) maps to a target module + {@link ReferenceKind}.
+ *
+ * Both the full-project traversal ({@link traverseLiquidModule}) and the
+ * standalone per-file primitive ({@link extractFileReferences}) go through this,
+ * so resolution can never drift between "graph build" and "validate one buffer".
+ *
+ * Targets are produced via the module factories (which normalize URIs), so keys
+ * match the rest of the graph on every platform. Unparseable input yields no
+ * references rather than throwing.
+ */
+async function resolveLiquidReferences(
+  appGraph: AppGraph,
+  sourceCode: FileSourceCode,
+  deps: ResolverDependencies,
+): Promise<ResolvedReference[]> {
+  if (sourceCode.ast instanceof Error) return []; // can't visit what you can't parse
+
+  // Canonical target resolution (lib paths, module prefixes, extensions) is
+  // owned by check-common's DocumentsLocator — never re-derived here.
+  const documentsLocator = new DocumentsLocator(deps.fs);
+  const rootUri = URI.parse(appGraph.rootUri);
+
+  const visitor: Visitor<SourceCodeType.LiquidHtml, ResolvedReference> = {
     // {{ 'app.js' | asset_url }}
     // {{ 'image.png' | asset_img_url }}
     // {{ 'icon.svg' | inline_asset_content }}
@@ -78,61 +130,136 @@ async function traverseLiquidModule(
         return {
           target: assetModule,
           sourceRange: [parentNode.position.start, parentNode.position.end],
+          kind: 'asset',
         };
       }
     },
 
-    // <custom-element></custom-element>
-    HtmlElement: async (node) => {
-      if (node.name.length !== 1) return;
-      if (node.name[0].type !== NodeTypes.TextNode) return;
-      const nodeNameNode = node.name[0];
-      const nodeName = nodeNameNode.value;
-      if (!nodeName.includes('-')) return; // skip non-custom-elements
+    // {% render 'partial' %} / {% include 'partial' %}
+    // Both resolve through DocumentsLocator (like function/graphql), so module
+    // prefixes (`modules/<m>/...`), the lib search path, and `.liquid` /
+    // `.html.liquid` extensions are handled uniformly — not hard-coded to
+    // `app/views/partials`.
+    RenderMarkup: async (node, ancestors) => {
+      const partial = node.partial;
+      const tag = ancestors.at(-1)!;
+      if (!isStringLiteral(partial)) return; // dynamic target — skip
+      const isInclude = tag.type === NodeTypes.LiquidTag && tag.name === NamedTags.include;
+      const uri = await documentsLocator.locateOrDefault(
+        rootUri,
+        isInclude ? 'include' : 'render',
+        partial.value,
+      );
+      if (!uri) return;
+      return {
+        target: getPartialModuleByUri(appGraph, uri),
+        sourceRange: [tag.position.start, tag.position.end],
+        kind: isInclude ? 'include' : 'render',
+      };
+    },
 
-      const result = deps.getWebComponentDefinitionReference(nodeName);
-      if (!result) return;
-      const { assetName, range } = result;
-      const assetModule = getAssetModule(appGraph, assetName);
-      if (!assetModule) return;
+    // {% function result = 'queries/...' %} / {% function res = 'commands/...' %}
+    FunctionMarkup: async (node, ancestors) => {
+      const target = node.partial;
+      const tag = ancestors.at(-1)!;
+      if (!isStringLiteral(target)) return; // dynamic target — skip
+      const uri = await documentsLocator.locateOrDefault(rootUri, 'function', target.value);
+      if (!uri) return;
+      return {
+        target: getPartialModuleByUri(appGraph, uri),
+        sourceRange: [tag.position.start, tag.position.end],
+        kind: 'function',
+      };
+    },
 
+    // {% background job_id = 'partial', ... %} (file-based form)
+    // Runs a partial asynchronously; `node.partial` is the partial reference,
+    // resolved against the same search paths as {% function %}. The inline form
+    // ({% background %}...{% endbackground %}) parses to BackgroundInlineMarkup,
+    // has no file target, and is intentionally not matched here.
+    BackgroundMarkup: async (node, ancestors) => {
+      const target = node.partial;
+      const tag = ancestors.at(-1)!;
+      if (!isStringLiteral(target)) return; // dynamic target — skip
+      const uri = await documentsLocator.locateOrDefault(rootUri, 'function', target.value);
+      if (!uri) return;
       return {
-        target: assetModule,
-        sourceRange: [node.blockStartPosition.start, nodeNameNode.position.end],
-        targetRange: range,
+        target: getPartialModuleByUri(appGraph, uri),
+        sourceRange: [tag.position.start, tag.position.end],
+        kind: 'background',
       };
     },
 
-    // {% render 'partial' %}
-    RenderMarkup: async (node, ancestors) => {
-      const partial = node.partial;
+    // {% graphql result = 'path/to/operation' %}
+    // `node.name` is the RESULT variable; the operation-file path is `node.graphql`.
+    GraphQLMarkup: async (node, ancestors) => {
+      const op = node.graphql;
       const tag = ancestors.at(-1)!;
-      if (!isString(partial) && partial.type === NodeTypes.String) {
-        return {
-          target: getPartialModule(appGraph, partial.value),
-          sourceRange: [tag.position.start, tag.position.end],
-        };
-      }
+      if (!isStringLiteral(op)) return; // dynamic/inline — no static file
+      const uri = await documentsLocator.locateOrDefault(rootUri, 'graphql', op.value);
+      if (!uri) return;
+      return {
+        target: getGraphQLModuleByUri(appGraph, uri),
+        sourceRange: [tag.position.start, tag.position.end],
+        kind: 'graphql',
+      };
     },
   };
 
-  const references = await visit(sourceCode.ast, visitor);
-
-  for (const reference of references) {
-    bind(module, reference.target, {
-      sourceRange: reference.sourceRange,
-      targetRange: reference.targetRange,
-    });
-  }
+  return visit(sourceCode.ast, visitor);
+}
 
-  const modules = unique(references.map((ref) => ref.target));
-  const promises = modules.map((mod) => traverseModule(mod, appGraph, deps));
+/**
+ * Extract one Liquid file's outgoing dependency references, resolved against the
+ * project at `rootUri`, WITHOUT building the whole app graph.
+ *
+ * This is the per-file primitive for consumers that hold a single (possibly
+ * in-flight, not-yet-on-disk) buffer — e.g. a `validate_code`-style tool that
+ * parses the buffer with {@link toSourceCode} and wants the file's resolved
+ * `render`/`include`/`function`/`background`/`graphql`/asset edges with their
+ * canonical target URIs and {@link ReferenceKind}. Resolution uses the same
+ * `DocumentsLocator`-backed logic as the full graph build, so a target's URI is
+ * identical to the key it would have as a graph node.
+ *
+ * Notes for consumers:
+ * - Targets are returned whether or not they exist on disk (resolution is
+ *   path-based). To distinguish missing targets, `stat` `target.uri` via the
+ *   same `fs`; unresolved/missing partials are also surfaced by the linter's
+ *   `MissingPartial` check, so prefer that for diagnostics.
+ * - Only statically resolvable references are returned; dynamic targets
+ *   (`{% render some_var %}`) and inline forms are skipped.
+ * - `sourceCode` is parsed by the caller (from the buffer, not disk); only `fs`
+ *   is touched here, for target resolution.
+ */
+export async function extractFileReferences(
+  rootUri: UriString,
+  sourceUri: UriString,
+  sourceCode: FileSourceCode,
+  deps: ResolverDependencies,
+): Promise<Reference[]> {
+  // A throwaway graph so the URI-normalizing module factories can be reused; it
+  // is never traversed and is discarded with this call.
+  const scratchGraph: AppGraph = { rootUri, entryPoints: [], modules: {} };
+  const references = await resolveLiquidReferences(scratchGraph, sourceCode, deps);
 
-  return Promise.all(promises);
+  return references.map((reference) => ({
+    source: { uri: sourceUri, range: reference.sourceRange },
+    target: { uri: reference.target.uri },
+    type: 'direct',
+    kind: reference.kind,
+  }));
 }
 
-function unique<T>(arr: T[]): T[] {
-  return [...new Set(arr)];
+/**
+ * A render/function/graphql target that is a static string literal (e.g.
+ * `{% render 'partial' %}`), narrowed to its `NodeTypes.String` member so the
+ * `.value` is accessible. Dynamic targets (`{% render var %}`) return false and
+ * are skipped — the graph only records statically resolvable edges.
+ */
+function isStringLiteral<T extends { type: NodeTypes }>(
+  node: T,
+): node is Extract<T, { type: NodeTypes.String }> {
+  return !isString(node) && node.type === NodeTypes.String;
 }
 
 /**
@@ -147,18 +274,19 @@ export function bind(
   target: AppModule,
   {
     sourceRange,
-    targetRange,
     type = 'direct', // the type of dependency, can be 'direct' or 'indirect'
+    kind, // the semantic Liquid construct that created the edge
   }: {
     sourceRange?: Range; // a range in the source module that references the child
-    targetRange?: Range; // a range in the child module that is being referenced
     type?: Reference['type']; // the type of dependency
+    kind?: ReferenceKind; // render | include | function | background | graphql | asset | layout
   } = {},
 ): void {
   const dependency: Reference = {
     source: { uri: source.uri, range: sourceRange },
-    target: { uri: target.uri, range: targetRange },
+    target: { uri: target.uri },
     type: type,
+    kind: kind,
   };
 
   source.dependencies.push(dependency);

package/src/index.ts

@@ -1,5 +1,5 @@
 export { buildAppGraph } from './graph/build';
+export { extractFileReferences } from './graph/traverse';
 export { serializeAppGraph } from './graph/serialize';
-export { getWebComponentMap, findWebComponentReferences } from './getWebComponentMap';
 export { parseJs, toSourceCode } from './toSourceCode';
 export * from './types';