forgeos 0.1.0-alpha.0 → 0.1.0-alpha.2

package/src/forge/cli/version.ts

@@ -1 +1 @@
-export const CLI_VERSION = "0.0.0";
+export { CLI_VERSION } from "../version.ts";

package/src/forge/compiler/agent-contract/build.ts

@@ -8,6 +8,9 @@ import { GENERATOR_VERSION } from "../emitter/constants.ts";
 import { stripDeterministicHeader } from "../primitives/header.ts";
 import { canonicalJson, normalizeNewlines, serializeCanonical } from "../primitives/serialize.ts";
 import { resolveByPackageName } from "../recipes/registry.ts";
+import {
+  defaultRuntimeCompatibility,
+} from "../package-graph/oracle.ts";
 import { secretLeakScan } from "../sandbox/secret-scan.ts";
 import type { AiRegistry } from "../types/ai-registry.ts";
 import type { AppGraph } from "../types/app-graph.ts";
@@ -37,6 +40,7 @@ import type {
   AgentCapabilityMap,
   AgentCapabilityMapEntry,
   AgentContract,
+  AgentDependencyApiInfo,
   AgentFrontendRuntimeBindingInfo,
   AgentFrontendUsageInfo,
   AgentHttpEndpointInfo,
@@ -220,6 +224,22 @@ function buildIntegrations(classified: ClassifiedPackage[]): AgentIntegrationInf
   return sorted([...byAlias.values()], (entry) => entry.alias);
 }
 
+function buildDependencyApis(packageGraph: PackageGraph): AgentDependencyApiInfo[] {
+  return sorted(packageGraph.packages, (pkg) => pkg.name).map((pkg) => ({
+    package: pkg.name,
+    version: pkg.version,
+    source: pkg.source,
+    entrypoints: sorted(pkg.entrypoints, (entrypoint) => entrypoint.subpath).map((entrypoint) => ({
+      subpath: entrypoint.subpath,
+      dtsPath: entrypoint.dtsPath,
+      exportCount: entrypoint.exports.length,
+      exports: uniqueSorted(entrypoint.exports.map((exported) => exported.name)),
+    })),
+    runtimeCompatibility: pkg.runtimeCompatibility ?? defaultRuntimeCompatibility(),
+    runtimeTypeMismatches: pkg.runtimeTypeMismatches ?? [],
+  }));
+}
+
 function runtimeRules(): AgentRuntimeRule[] {
   return [
     {
@@ -378,6 +398,8 @@ function playbooks(): AgentPlaybook[] {
       title: "Upgrade a package",
       steps: [
         "Run forge deps upgrade-plan <package> --to latest.",
+        "Use forge deps inspect <package> --json and forge deps api <package> <symbol> --json before relying on changed external APIs.",
+        "Use forge deps trace <package> --json when exports or type resolution are ambiguous.",
         "Read .forge/upgrades/.../plan.md.",
         "If risk is high, inspect affected files and generated adapters before applying.",
         "Apply with forge deps upgrade-apply <plan>.",
@@ -905,6 +927,7 @@ export function buildAgentContractArtifacts(
         deniedContexts: classified?.classification.incompatible ?? [],
       };
     }),
+    dependencyApis: buildDependencyApis(input.packageGraph),
     integrations: buildIntegrations(input.classified),
     secrets: sorted(input.secretRegistry.secrets, (secret) => secret.name).map((secret) => ({
       name: secret.name,
@@ -1155,6 +1178,9 @@ forge inspect app --json
 forge inspect all --json
 forge inspect frontend --json
 forge inspect capabilities --json
+forge deps inspect <package> --json
+forge deps api <package> <symbol> --json
+forge deps trace <package> --json
 forge auth check --json
 forge inspect runtime-matrix --json
 forge inspect policies --json
@@ -1337,6 +1363,8 @@ Use:
 
 \`\`\`bash
 forge deps upgrade-plan <package> --to latest
+forge deps inspect <package> --json
+forge deps api <package> <symbol> --json
 forge deps upgrade-apply <plan>
 forge verify --strict
 \`\`\`

package/src/forge/compiler/agent-contract/types.ts

@@ -1,4 +1,5 @@
 import type { Diagnostic } from "../types/diagnostic.ts";
+import type { PackageRuntimeCompatibility, RuntimeTypeMismatch } from "../types/package-graph.ts";
 import type { RuntimeContext } from "../types/runtime.ts";
 
 export interface AgentProjectInfo {
@@ -100,6 +101,20 @@ export interface AgentPackageInfo {
   deniedContexts: RuntimeContext[];
 }
 
+export interface AgentDependencyApiInfo {
+  package: string;
+  version: string;
+  source: "static" | "static+runtime";
+  entrypoints: Array<{
+    subpath: string;
+    dtsPath: string | null;
+    exportCount: number;
+    exports: string[];
+  }>;
+  runtimeCompatibility: PackageRuntimeCompatibility;
+  runtimeTypeMismatches: RuntimeTypeMismatch[];
+}
+
 export interface AgentIntegrationInfo {
   alias: string;
   packages: string[];
@@ -308,6 +323,7 @@ export interface AgentContract {
   data: AgentDataInfo;
   policies: AgentPolicyInfo[];
   packages: AgentPackageInfo[];
+  dependencyApis: AgentDependencyApiInfo[];
   integrations: AgentIntegrationInfo[];
   secrets: AgentSecretInfo[];
   telemetry: AgentTelemetryInfo;

package/src/forge/compiler/app-graph/build.ts

@@ -1,110 +1,110 @@
-import { canonicalJson } from "../primitives/serialize.ts";
-import { hashStable } from "../primitives/hash.ts";
-import { normalizePath } from "../primitives/paths.ts";
-import { stableSortEdges, stableSortSymbols } from "../primitives/sort.ts";
-import type { AppGraph, SourceFile } from "../types/app-graph.ts";
-import { detectDuplicateSymbols } from "./dup-symbol.ts";
-import { buildModuleGraph } from "./module-graph.ts";
-import { incrementalParse } from "./parser.ts";
-import { buildForgeSymbols } from "./symbols.ts";
-import { hashTsconfigForWorkspace } from "./tsconfig-hash.ts";
-import type { ParseInvalidationKey } from "./types.ts";
-import { buildAnalyzerVersion } from "./types.ts";
-import {
-  APP_GRAPH_SCHEMA_VERSION,
-  FORGE_CLASSIFIER_VERSION,
-  GENERATOR_VERSION,
-  TREE_SITTER_GRAMMAR_VERSION,
-} from "./versions.ts";
-
-export interface AppGraphBuildOptions {
-  workspaceRoot: string;
-  sources: SourceFile[];
-  prior?: AppGraph;
-  tsconfigPath?: string;
-  /** When provided, skips re-reading and hashing tsconfig.json. */
-  tsconfigHash?: string;
-}
-
-function normalizeSources(sources: SourceFile[]): SourceFile[] {
-  return sources.map((source) => ({
-    ...source,
-    path: normalizePath(source.path),
-  }));
-}
-
-function computeInputHash(
-  sources: SourceFile[],
-  invalidation: ParseInvalidationKey,
-): string {
-  const payload = {
-    files: [...sources]
-      .map((source) => ({ path: source.path, contentHash: source.contentHash }))
-      .sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0)),
-    invalidation,
-  };
-  return hashStable(canonicalJson(payload));
-}
-
-function parseInvalidationFromPrior(prior: AppGraph): ParseInvalidationKey | undefined {
-  const analyzer = prior.analyzerVersion;
-  const schemaMatch = /schema:([^+]+)/.exec(analyzer);
-  const grammarMatch = /grammar:([^+]+)/.exec(analyzer);
-  const classifierMatch = /classifier:([^+]+)/.exec(analyzer);
-  const tsconfigMatch = /tsconfig:([^+]+)/.exec(analyzer);
-
-  if (!schemaMatch || !grammarMatch || !classifierMatch || !tsconfigMatch) {
-    return undefined;
-  }
-
-  return {
-    schemaVersion: schemaMatch[1] ?? APP_GRAPH_SCHEMA_VERSION,
-    grammarVersion: grammarMatch[1] ?? TREE_SITTER_GRAMMAR_VERSION,
-    classifierVersion: classifierMatch[1] ?? FORGE_CLASSIFIER_VERSION,
-    tsconfigHash: tsconfigMatch[1] ?? "",
-  };
-}
-
-export async function buildAppGraph(
-  options: AppGraphBuildOptions,
-): Promise<AppGraph> {
-  const sources = normalizeSources(options.sources);
-  const tsconfigHash =
-    options.tsconfigHash ??
-    hashTsconfigForWorkspace(
-      options.workspaceRoot,
-      options.tsconfigPath,
-    );
-
-  const invalidation: ParseInvalidationKey = {
-    schemaVersion: APP_GRAPH_SCHEMA_VERSION,
-    grammarVersion: TREE_SITTER_GRAMMAR_VERSION,
-    classifierVersion: FORGE_CLASSIFIER_VERSION,
-    tsconfigHash,
-  };
-
-  const priorInvalidation = options.prior
-    ? parseInvalidationFromPrior(options.prior)
-    : undefined;
-
-  const { symbols: rawSymbols, diagnostics: parseDiagnostics } =
-    incrementalParse(
-      sources,
-      options.prior?.symbols,
-      priorInvalidation,
-      invalidation,
-    );
-
-  const forgeSymbols = buildForgeSymbols(rawSymbols, sources);
-  const dupDiagnostics = detectDuplicateSymbols(forgeSymbols);
-  const moduleGraph = buildModuleGraph(
-    sources,
-    rawSymbols,
-    options.workspaceRoot,
-    options.tsconfigPath,
-    options.prior,
-  );
-
+import { canonicalJson } from "../primitives/serialize.ts";
+import { hashStable } from "../primitives/hash.ts";
+import { normalizePath } from "../primitives/paths.ts";
+import { stableSortEdges, stableSortSymbols } from "../primitives/sort.ts";
+import type { AppGraph, SourceFile } from "../types/app-graph.ts";
+import { detectDuplicateSymbols } from "./dup-symbol.ts";
+import { buildModuleGraph } from "./module-graph.ts";
+import { incrementalParse } from "./parser.ts";
+import { buildForgeSymbols } from "./symbols.ts";
+import { hashTsconfigForWorkspace } from "./tsconfig-hash.ts";
+import type { ParseInvalidationKey } from "./types.ts";
+import { buildAnalyzerVersion } from "./types.ts";
+import {
+  APP_GRAPH_SCHEMA_VERSION,
+  FORGE_CLASSIFIER_VERSION,
+  GENERATOR_VERSION,
+  TREE_SITTER_GRAMMAR_VERSION,
+} from "./versions.ts";
+
+export interface AppGraphBuildOptions {
+  workspaceRoot: string;
+  sources: SourceFile[];
+  prior?: AppGraph;
+  tsconfigPath?: string;
+  /** When provided, skips re-reading and hashing tsconfig.json. */
+  tsconfigHash?: string;
+}
+
+function normalizeSources(sources: SourceFile[]): SourceFile[] {
+  return sources.map((source) => ({
+    ...source,
+    path: normalizePath(source.path),
+  }));
+}
+
+function computeInputHash(
+  sources: SourceFile[],
+  invalidation: ParseInvalidationKey,
+): string {
+  const payload = {
+    files: [...sources]
+      .map((source) => ({ path: source.path, contentHash: source.contentHash }))
+      .sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0)),
+    invalidation,
+  };
+  return hashStable(canonicalJson(payload));
+}
+
+function parseInvalidationFromPrior(prior: AppGraph): ParseInvalidationKey | undefined {
+  const analyzer = prior.analyzerVersion;
+  const schemaMatch = /schema:([^+]+)/.exec(analyzer);
+  const grammarMatch = /grammar:([^+]+)/.exec(analyzer);
+  const classifierMatch = /classifier:([^+]+)/.exec(analyzer);
+  const tsconfigMatch = /tsconfig:([^+]+)/.exec(analyzer);
+
+  if (!schemaMatch || !grammarMatch || !classifierMatch || !tsconfigMatch) {
+    return undefined;
+  }
+
+  return {
+    schemaVersion: schemaMatch[1] ?? APP_GRAPH_SCHEMA_VERSION,
+    grammarVersion: grammarMatch[1] ?? TREE_SITTER_GRAMMAR_VERSION,
+    classifierVersion: classifierMatch[1] ?? FORGE_CLASSIFIER_VERSION,
+    tsconfigHash: tsconfigMatch[1] ?? "",
+  };
+}
+
+export async function buildAppGraph(
+  options: AppGraphBuildOptions,
+): Promise<AppGraph> {
+  const sources = normalizeSources(options.sources);
+  const tsconfigHash =
+    options.tsconfigHash ??
+    hashTsconfigForWorkspace(
+      options.workspaceRoot,
+      options.tsconfigPath,
+    );
+
+  const invalidation: ParseInvalidationKey = {
+    schemaVersion: APP_GRAPH_SCHEMA_VERSION,
+    grammarVersion: TREE_SITTER_GRAMMAR_VERSION,
+    classifierVersion: FORGE_CLASSIFIER_VERSION,
+    tsconfigHash,
+  };
+
+  const priorInvalidation = options.prior
+    ? parseInvalidationFromPrior(options.prior)
+    : undefined;
+
+  const { symbols: rawSymbols, diagnostics: parseDiagnostics } =
+    incrementalParse(
+      sources,
+      options.prior?.symbols,
+      priorInvalidation,
+      invalidation,
+    );
+
+  const forgeSymbols = buildForgeSymbols(rawSymbols, sources);
+  const dupDiagnostics = detectDuplicateSymbols(forgeSymbols);
+  const moduleGraph = buildModuleGraph(
+    sources,
+    rawSymbols,
+    options.workspaceRoot,
+    options.tsconfigPath,
+    options.prior,
+  );
+
   return {
     schemaVersion: APP_GRAPH_SCHEMA_VERSION,
     generatorVersion: GENERATOR_VERSION,
@@ -114,8 +114,8 @@ export async function buildAppGraph(
       sources.map((source) => [source.path, source.contentHash]),
     ),
     symbols: stableSortSymbols(forgeSymbols),
-    edges: stableSortEdges([]),
-    moduleGraph,
-    diagnostics: [...parseDiagnostics, ...dupDiagnostics],
-  };
-}
+    edges: stableSortEdges([]),
+    moduleGraph,
+    diagnostics: [...parseDiagnostics, ...dupDiagnostics],
+  };
+}

package/src/forge/compiler/app-graph/classify.ts

@@ -1,10 +1,10 @@
-import type { ForgeKind } from "../types/app-graph.ts";
-import { FORGE_BUILDER_APIS } from "./forge-apis.ts";
-
-/**
- * Classify a Forge builder callee into exactly one ForgeKind, or null when
- * the callee is not a known Forge builder API.
- */
-export function classifyForgeCallee(callee: string): ForgeKind | null {
-  return FORGE_BUILDER_APIS[callee] ?? null;
-}
+import type { ForgeKind } from "../types/app-graph.ts";
+import { FORGE_BUILDER_APIS } from "./forge-apis.ts";
+
+/**
+ * Classify a Forge builder callee into exactly one ForgeKind, or null when
+ * the callee is not a known Forge builder API.
+ */
+export function classifyForgeCallee(callee: string): ForgeKind | null {
+  return FORGE_BUILDER_APIS[callee] ?? null;
+}

package/src/forge/compiler/app-graph/dup-symbol.ts

@@ -1,29 +1,29 @@
-import { forgeDupSymbol } from "../diagnostics/create.ts";
-import type { Diagnostic } from "../types/diagnostic.ts";
-import type { ForgeSymbol } from "../types/app-graph.ts";
-
-/**
- * Emit FORGE_DUP_SYMBOL warnings for stable-id collisions without discarding symbols.
- */
-export function detectDuplicateSymbols(symbols: ForgeSymbol[]): Diagnostic[] {
-  const groups = new Map<string, ForgeSymbol[]>();
-
-  for (const symbol of symbols) {
-    const list = groups.get(symbol.id) ?? [];
-    list.push(symbol);
-    groups.set(symbol.id, list);
-  }
-
-  const diagnostics: Diagnostic[] = [];
-
-  for (const group of groups.values()) {
-    if (group.length <= 1) {
-      continue;
-    }
-    for (const symbol of group) {
-      diagnostics.push(forgeDupSymbol(symbol.qualifiedName, symbol.file));
-    }
-  }
-
-  return diagnostics;
-}
+import { forgeDupSymbol } from "../diagnostics/create.ts";
+import type { Diagnostic } from "../types/diagnostic.ts";
+import type { ForgeSymbol } from "../types/app-graph.ts";
+
+/**
+ * Emit FORGE_DUP_SYMBOL warnings for stable-id collisions without discarding symbols.
+ */
+export function detectDuplicateSymbols(symbols: ForgeSymbol[]): Diagnostic[] {
+  const groups = new Map<string, ForgeSymbol[]>();
+
+  for (const symbol of symbols) {
+    const list = groups.get(symbol.id) ?? [];
+    list.push(symbol);
+    groups.set(symbol.id, list);
+  }
+
+  const diagnostics: Diagnostic[] = [];
+
+  for (const group of groups.values()) {
+    if (group.length <= 1) {
+      continue;
+    }
+    for (const symbol of group) {
+      diagnostics.push(forgeDupSymbol(symbol.qualifiedName, symbol.file));
+    }
+  }
+
+  return diagnostics;
+}

package/src/forge/compiler/app-graph/extract.ts

@@ -1,124 +1,124 @@
-import type { SyntaxNode } from "tree-sitter";
-import { classifyForgeCallee } from "./classify.ts";
-import type { RawSymbol } from "./types.ts";
-
-export interface SymbolNameInfo {
-  name: string;
-  qualifiedName: string;
-  exportPath: string;
-}
-
-export function resolveCalleeName(functionNode: SyntaxNode): string | null {
-  if (functionNode.type === "identifier") {
-    return functionNode.text;
-  }
-
-  if (functionNode.type === "member_expression") {
-    const property = functionNode.childForFieldName("property");
-    if (property && (property.type === "property_identifier" || property.type === "identifier")) {
-      return property.text;
-    }
-  }
-
-  return null;
-}
-
-export function inferSymbolName(callNode: SyntaxNode): SymbolNameInfo {
-  let exportPath = "";
-  let parent: SyntaxNode | null = callNode.parent;
-
-  while (parent) {
-    if (parent.type === "variable_declarator") {
-      const nameNode = parent.childForFieldName("name");
-      if (nameNode) {
-        const name = nameNode.text;
-        return { name, qualifiedName: name, exportPath };
-      }
-    }
-
-    if (parent.type === "lexical_declaration" || parent.type === "variable_declaration") {
-      const declarator = parent.namedChildren.find(
-        (child) => child.type === "variable_declarator",
-      );
-      if (declarator) {
-        const nameNode = declarator.childForFieldName("name");
-        if (nameNode) {
-          const name = nameNode.text;
-          return { name, qualifiedName: name, exportPath };
-        }
-      }
-    }
-
-    if (parent.type === "export_statement") {
-      const declaration = parent.childForFieldName("declaration");
-      if (declaration?.type === "lexical_declaration" || declaration?.type === "variable_declaration") {
-        const declarator = declaration.namedChildren.find(
-          (child) => child.type === "variable_declarator",
-        );
-        if (declarator) {
-          const nameNode = declarator.childForFieldName("name");
-          if (nameNode) {
-            const name = nameNode.text;
-            return { name, qualifiedName: name, exportPath: "" };
-          }
-        }
-      }
-
-      const value = parent.childForFieldName("value");
-      if (value === callNode || value?.descendantsOfType("call_expression").includes(callNode)) {
-        exportPath = "default";
-        const fallback = "__default_export__";
-        return { name: fallback, qualifiedName: fallback, exportPath };
-      }
-    }
-
-    parent = parent.parent;
-  }
-
-  const fallback = `__forge_${callNode.startPosition.row}_${callNode.startPosition.column}`;
-  return { name: fallback, qualifiedName: fallback, exportPath };
-}
-
-export function extractSymbolsFromTree(
-  root: SyntaxNode,
-  file: string,
-  source: string,
-): RawSymbol[] {
-  const symbols: RawSymbol[] = [];
-  const visited = new Set<string>();
-
-  function visit(node: SyntaxNode): void {
-    if (node.type === "call_expression") {
-      const functionNode = node.childForFieldName("function");
+import type { SyntaxNode } from "tree-sitter";
+import { classifyForgeCallee } from "./classify.ts";
+import type { RawSymbol } from "./types.ts";
+
+export interface SymbolNameInfo {
+  name: string;
+  qualifiedName: string;
+  exportPath: string;
+}
+
+export function resolveCalleeName(functionNode: SyntaxNode): string | null {
+  if (functionNode.type === "identifier") {
+    return functionNode.text;
+  }
+
+  if (functionNode.type === "member_expression") {
+    const property = functionNode.childForFieldName("property");
+    if (property && (property.type === "property_identifier" || property.type === "identifier")) {
+      return property.text;
+    }
+  }
+
+  return null;
+}
+
+export function inferSymbolName(callNode: SyntaxNode): SymbolNameInfo {
+  let exportPath = "";
+  let parent: SyntaxNode | null = callNode.parent;
+
+  while (parent) {
+    if (parent.type === "variable_declarator") {
+      const nameNode = parent.childForFieldName("name");
+      if (nameNode) {
+        const name = nameNode.text;
+        return { name, qualifiedName: name, exportPath };
+      }
+    }
+
+    if (parent.type === "lexical_declaration" || parent.type === "variable_declaration") {
+      const declarator = parent.namedChildren.find(
+        (child) => child.type === "variable_declarator",
+      );
+      if (declarator) {
+        const nameNode = declarator.childForFieldName("name");
+        if (nameNode) {
+          const name = nameNode.text;
+          return { name, qualifiedName: name, exportPath };
+        }
+      }
+    }
+
+    if (parent.type === "export_statement") {
+      const declaration = parent.childForFieldName("declaration");
+      if (declaration?.type === "lexical_declaration" || declaration?.type === "variable_declaration") {
+        const declarator = declaration.namedChildren.find(
+          (child) => child.type === "variable_declarator",
+        );
+        if (declarator) {
+          const nameNode = declarator.childForFieldName("name");
+          if (nameNode) {
+            const name = nameNode.text;
+            return { name, qualifiedName: name, exportPath: "" };
+          }
+        }
+      }
+
+      const value = parent.childForFieldName("value");
+      if (value === callNode || value?.descendantsOfType("call_expression").includes(callNode)) {
+        exportPath = "default";
+        const fallback = "__default_export__";
+        return { name: fallback, qualifiedName: fallback, exportPath };
+      }
+    }
+
+    parent = parent.parent;
+  }
+
+  const fallback = `__forge_${callNode.startPosition.row}_${callNode.startPosition.column}`;
+  return { name: fallback, qualifiedName: fallback, exportPath };
+}
+
+export function extractSymbolsFromTree(
+  root: SyntaxNode,
+  file: string,
+  source: string,
+): RawSymbol[] {
+  const symbols: RawSymbol[] = [];
+  const visited = new Set<string>();
+
+  function visit(node: SyntaxNode): void {
+    if (node.type === "call_expression") {
+      const functionNode = node.childForFieldName("function");
       if (functionNode && functionNode.type === "identifier") {
-        const callee = resolveCalleeName(functionNode);
-        if (callee) {
-          const kind = classifyForgeCallee(callee);
-          if (kind) {
-            const key = `${kind}:${node.startIndex}:${node.endIndex}`;
-            if (!visited.has(key)) {
-              visited.add(key);
-              const { name, qualifiedName, exportPath } = inferSymbolName(node);
-              symbols.push({
-                kind,
-                name,
-                qualifiedName,
-                file,
-                span: { start: node.startIndex, end: node.endIndex },
-                exportPath,
-                sourceSlice: source.slice(node.startIndex, node.endIndex),
-              });
-            }
-          }
-        }
-      }
-    }
-
-    for (const child of node.namedChildren) {
-      visit(child);
-    }
-  }
-
-  visit(root);
-  return symbols;
-}
+        const callee = resolveCalleeName(functionNode);
+        if (callee) {
+          const kind = classifyForgeCallee(callee);
+          if (kind) {
+            const key = `${kind}:${node.startIndex}:${node.endIndex}`;
+            if (!visited.has(key)) {
+              visited.add(key);
+              const { name, qualifiedName, exportPath } = inferSymbolName(node);
+              symbols.push({
+                kind,
+                name,
+                qualifiedName,
+                file,
+                span: { start: node.startIndex, end: node.endIndex },
+                exportPath,
+                sourceSlice: source.slice(node.startIndex, node.endIndex),
+              });
+            }
+          }
+        }
+      }
+    }
+
+    for (const child of node.namedChildren) {
+      visit(child);
+    }
+  }
+
+  visit(root);
+  return symbols;
+}