septum 0.1.5 → 0.1.7

package/src/core/database/repositories/dependency.repository.ts

@@ -1,12 +1,18 @@
 import * as fs from "node:fs";
+import { dirname, join, posix } from "node:path";
 import type { Database } from "bun:sqlite";
 import type {
   ExtractedDependency,
+  FileConnectionsSummary,
   GetSymbolImpactResponse,
   InboundCaller,
   VerticalSliceRecord,
 } from "../../../types/index.ts";
 
+function escapeRegExp(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 export class DependencyRepository {
   constructor(private db: Database) {}
 
@@ -103,6 +109,13 @@ export class DependencyRepository {
     return this.db.query<VerticalSliceRecord, []>("SELECT * FROM vertical_slices ORDER BY id ASC").all();
   }
 
+  public countVerticalSlices(): number {
+    const row = this.db
+      .query<{ cnt: number }, []>("SELECT COUNT(*) as cnt FROM vertical_slices")
+      .get();
+    return row?.cnt ?? 0;
+  }
+
   public clearVerticalSlices(domainId?: number): void {
     if (domainId) {
       this.db.query("DELETE FROM vertical_slices WHERE domain_id = ?").run(domainId);
@@ -135,6 +148,107 @@ export class DependencyRepository {
     return this.db.query<any, []>(query).all();
   }
 
+  public getDomainFileConnections(domainId?: number): Map<string, FileConnectionsSummary> {
+    const allFiles = this.db
+      .query<{ id: number; domain_id: number; path: string }, []>(
+        "SELECT id, domain_id, path FROM files ORDER BY path ASC"
+      )
+      .all();
+
+    const fileById = new Map<number, { id: number; domain_id: number; path: string }>();
+    const fileByNormPath = new Map<string, string>();
+    const fileByNoExtPath = new Map<string, string>();
+
+    for (const f of allFiles) {
+      const norm = f.path.replace(/\\/g, "/").replace(/^\.\//, "");
+      fileById.set(f.id, { ...f, path: norm });
+      fileByNormPath.set(norm.toLowerCase(), f.path);
+      const noExt = norm.replace(/\.[^/.]+$/, "").toLowerCase();
+      fileByNoExtPath.set(noExt, f.path);
+      if (noExt.endsWith("/index")) {
+        fileByNoExtPath.set(noExt.slice(0, -"/index".length), f.path);
+      }
+    }
+
+    const resolveInternalTarget = (sourcePath: string, rawTarget: string): string | null => {
+      const cleaned = rawTarget.trim().replace(/^['"]|['"]$/g, "").replace(/\\/g, "/");
+      if (!cleaned) return null;
+
+      if (cleaned.startsWith(".")) {
+        const srcDir = posix.dirname(sourcePath.replace(/\\/g, "/"));
+        const joined = posix.normalize(posix.join(srcDir, cleaned)).replace(/^\.\//, "");
+        const lowerJoined = joined.toLowerCase();
+        const exact = fileByNormPath.get(lowerJoined) ?? fileByNoExtPath.get(lowerJoined.replace(/\.[^/.]+$/, ""));
+        if (exact) return exact;
+      }
+
+      const aliasClean = cleaned.replace(/^@\//, "src/").replace(/^\.\//, "");
+      const lowerAlias = aliasClean.toLowerCase();
+      const byAlias = fileByNormPath.get(lowerAlias) ?? fileByNoExtPath.get(lowerAlias.replace(/\.[^/.]+$/, ""));
+      if (byAlias) return byAlias;
+
+      for (const [noExt, origPath] of fileByNoExtPath.entries()) {
+        if (noExt.endsWith(`/${lowerAlias}`)) {
+          return origPath;
+        }
+      }
+      return null;
+    };
+
+    const importsFromMap = new Map<string, Set<string>>();
+    const importedByMap = new Map<string, Set<string>>();
+    for (const f of allFiles) {
+      importsFromMap.set(f.path, new Set());
+      importedByMap.set(f.path, new Set());
+    }
+
+    const allInternalDeps = this.db
+      .query<{ source_file_id: number; target_symbol_or_path: string }, []>(
+        "SELECT source_file_id, target_symbol_or_path FROM dependencies WHERE is_external = 0"
+      )
+      .all();
+
+    for (const dep of allInternalDeps) {
+      const srcFile = fileById.get(dep.source_file_id);
+      if (!srcFile) continue;
+      const resolvedTarget = resolveInternalTarget(srcFile.path, dep.target_symbol_or_path);
+      if (resolvedTarget && resolvedTarget !== srcFile.path) {
+        importsFromMap.get(srcFile.path)?.add(resolvedTarget);
+        if (!importedByMap.has(resolvedTarget)) {
+          importedByMap.set(resolvedTarget, new Set());
+        }
+        importedByMap.get(resolvedTarget)?.add(srcFile.path);
+      }
+    }
+
+    const result = new Map<string, FileConnectionsSummary>();
+    for (const f of allFiles) {
+      if (domainId !== undefined && f.domain_id !== domainId) continue;
+      const importsFrom = Array.from(importsFromMap.get(f.path) ?? []).sort();
+      const importedBy = Array.from(importedByMap.get(f.path) ?? []).sort();
+      result.set(f.path, {
+        imports_from: importsFrom,
+        imported_by_count: importedBy.length,
+        imported_by: importedBy,
+      });
+    }
+
+    return result;
+  }
+
+  public getFileConnections(filePath: string): FileConnectionsSummary {
+    const clean = filePath.replace(/\\/g, "/").replace(/^\.\//, "");
+    const allConns = this.getDomainFileConnections();
+    return (
+      allConns.get(clean) ??
+      allConns.get(filePath) ?? {
+        imports_from: [],
+        imported_by_count: 0,
+        imported_by: [],
+      }
+    );
+  }
+
   public getSymbolImpact(symbolQuery: string): GetSymbolImpactResponse {
     const trimmed = symbolQuery.trim();
     if (!trimmed) {
@@ -144,7 +258,7 @@ export class DependencyRepository {
         warning: "Empty symbol query provided.",
         impact_summary: {
           total_dependents: 0,
-          risk_level: "low",
+          risk_level: "unknown",
           affected_files_count: 0,
         },
         inbound_callers: [],
@@ -163,38 +277,126 @@ export class DependencyRepository {
       targetMethod = parts[1];
     }
 
-    // 1. Inbound dependencies from dependencies table
+    // 1. Look up target symbol in symbols joined with files to find its defining file_path & stem
+    const targetSymRows = this.db
+      .query<{ name: string; file_path: string }, [string, string, string, string]>(
+        `SELECT s.name, f.path AS file_path
+         FROM symbols s
+         JOIN files f ON s.file_id = f.id
+         WHERE s.name = ? OR s.name = ? OR s.name LIKE ? OR s.name LIKE ?`
+      )
+      .all(trimmed, targetContainer, `${targetContainer}::%`, `%::${targetContainer}`);
+
+    const definingFiles = new Set<string>(
+      targetSymRows.map((r) => r.file_path.replace(/\\/g, "/"))
+    );
+    const definingFileStems = Array.from(
+      new Set(
+        Array.from(definingFiles)
+          .map((p) => p.split("/").pop()?.replace(/\.[^.]+$/, "") || "")
+          .filter((s) => s.length >= 2)
+      )
+    );
+
+    // 2. Query dependencies matching targetContainer, trimmed, import_statement, or defining file stem
+    const whereClauses: string[] = [
+      "d.target_symbol_or_path LIKE ?",
+      "d.import_statement LIKE ?",
+      "d.target_symbol_or_path LIKE ?",
+    ];
+    const queryParams: string[] = [
+      `%${targetContainer}%`,
+      `%${targetContainer}%`,
+      `%${trimmed}%`,
+    ];
+
+    for (const stem of definingFileStems) {
+      whereClauses.push("d.target_symbol_or_path LIKE ?");
+      queryParams.push(`%${stem}%`);
+    }
+
     const depSql = `
       SELECT 
         f.path AS file,
         d.line_number,
         d.target_symbol_or_path,
+        d.import_statement,
         dom.name AS domain_name
       FROM dependencies d
       JOIN files f ON d.source_file_id = f.id
-      JOIN domains dom ON f.domain_id = dom.id
-      WHERE d.target_symbol_or_path LIKE ?
-         OR d.target_symbol_or_path LIKE ?
+      LEFT JOIN domains dom ON f.domain_id = dom.id
+      WHERE ${whereClauses.join(" OR ")}
       ORDER BY f.path ASC, d.line_number ASC
     `;
-    const depRows = this.db
-      .query<any, [string, string]>(depSql)
-      .all(`%${targetContainer}%`, `%${trimmed}%`);
+    const rawDepRows = this.db.query<any, string[]>(depSql).all(...queryParams);
 
-    const callersMap = new Map<string, InboundCaller>();
+    const containerWordRegex = new RegExp(`\\b${escapeRegExp(targetContainer)}\\b`);
+    const depRows = rawDepRows.filter((row) => {
+      const normCallerFile = String(row.file).replace(/\\/g, "/");
+      if (definingFiles.has(normCallerFile)) return false;
 
-    for (const row of depRows) {
-      // Find enclosing symbol in caller file if any
-      const enclosing = this.db
-        .query<{ name: string; kind: string }, [string, number]>(
-          `SELECT s.name, s.kind 
+      const stmt = String(row.import_statement || "");
+      const target = String(row.target_symbol_or_path || "");
+
+      if (containerWordRegex.test(stmt) || containerWordRegex.test(target)) {
+        return true;
+      }
+
+      // If no named specifier braces are present, accept path match against defining file stem
+      if (!stmt.includes("{")) {
+        for (const stem of definingFileStems) {
+          const stemRegex = new RegExp(`(?:^|[\\\\/])${escapeRegExp(stem)}(?:\\.[^\\\\/]+)?$`);
+          if (stemRegex.test(target)) {
+            return true;
+          }
+        }
+      }
+
+      return false;
+    });
+
+    // 3. Batch-load all symbols for candidate caller files in ONE query (zero N+1)
+    const uniqueCallerFiles = Array.from(new Set(depRows.map((r) => String(r.file))));
+    const callerSymbolsByFile = new Map<
+      string,
+      Array<{ name: string; kind: string; line_start: number; line_end: number }>
+    >();
+
+    if (uniqueCallerFiles.length > 0) {
+      const placeholders = uniqueCallerFiles.map(() => "?").join(",");
+      const allCallerSyms = this.db
+        .query<
+          { name: string; kind: string; line_start: number; line_end: number; path: string },
+          string[]
+        >(
+          `SELECT s.name, s.kind, s.line_start, s.line_end, f.path
            FROM symbols s
            JOIN files f ON s.file_id = f.id
-           WHERE f.path = ? AND ? BETWEEN s.line_start AND s.line_end
-           ORDER BY (s.line_end - s.line_start) ASC LIMIT 1`
+           WHERE f.path IN (${placeholders})
+           ORDER BY (s.line_end - s.line_start) ASC`
         )
-        .get(row.file, row.line_number);
+        .all(...uniqueCallerFiles);
 
+      for (const sym of allCallerSyms) {
+        const list = callerSymbolsByFile.get(sym.path) || [];
+        list.push(sym);
+        callerSymbolsByFile.set(sym.path, list);
+      }
+    }
+
+    const findEnclosingSymbol = (
+      filePath: string,
+      lineNum: number
+    ): { name: string; kind: string } | undefined => {
+      const syms = callerSymbolsByFile.get(filePath);
+      if (!syms) return undefined;
+      return syms.find((s) => lineNum >= s.line_start && lineNum <= s.line_end);
+    };
+
+    const callersMap = new Map<string, InboundCaller>();
+
+    for (const row of depRows) {
+      const enclosing = findEnclosingSymbol(row.file, row.line_number);
       const callerName = enclosing ? enclosing.name : `${row.file}:${row.line_number}`;
       const key = `${row.file}:${row.line_number}:${callerName}`;
 
@@ -204,16 +406,14 @@ export class DependencyRepository {
           caller: callerName,
           line: row.line_number,
           kind: enclosing?.kind || "import",
-          domain: row.domain_name,
+          domain: row.domain_name ?? undefined,
         });
       }
     }
 
-    // 2. Scan file content of callers or related files for exact method calls if targetMethod specified
+    // 4. Scan file content of callers for exact method calls if targetMethod specified
     if (targetMethod) {
-      // Look for files importing targetContainer and inspect if they call targetMethod
-      const uniqueFiles = Array.from(new Set(depRows.map((r) => r.file)));
-      for (const filePath of uniqueFiles) {
+      for (const filePath of uniqueCallerFiles) {
         try {
           if (fs.existsSync(filePath)) {
             const content = fs.readFileSync(filePath, "utf-8");
@@ -222,19 +422,11 @@ export class DependencyRepository {
               const line = lines[i];
               if (
                 line.includes(`->${targetMethod}(`) ||
-                line.includes(`::${targetMethod}(`)
+                line.includes(`::${targetMethod}(`) ||
+                line.includes(`.${targetMethod}(`)
               ) {
                 const lineNum = i + 1;
-                const enclosing = this.db
-                  .query<{ name: string; kind: string }, [string, number]>(
-                    `SELECT s.name, s.kind 
-                     FROM symbols s
-                     JOIN files f ON s.file_id = f.id
-                     WHERE f.path = ? AND ? BETWEEN s.line_start AND s.line_end
-                     ORDER BY (s.line_end - s.line_start) ASC LIMIT 1`
-                  )
-                  .get(filePath, lineNum);
-
+                const enclosing = findEnclosingSymbol(filePath, lineNum);
                 const callerName = enclosing ? enclosing.name : `${filePath}:${lineNum}`;
                 const key = `${filePath}:${lineNum}:${callerName}`;
                 if (!callersMap.has(key)) {
@@ -267,18 +459,11 @@ export class DependencyRepository {
       riskLevel = "medium";
     }
 
-    // 3. Determine if symbol exists in index
-    const symbolInDb = this.db
-      .query<{ count: number }, [string, string, string]>(
-        `SELECT COUNT(*) as count FROM symbols 
-         WHERE name = ? OR name = ? OR name = ? LIMIT 1`
-      )
-      .get(trimmed, targetContainer, targetMethod || trimmed)?.count ?? 0;
-
-    const foundInIndex = symbolInDb > 0 || depRows.length > 0;
+    // 5. Determine if symbol exists in index
+    const foundInIndex = targetSymRows.length > 0 || depRows.length > 0;
     const warning = foundInIndex
       ? undefined
-      : `Symbol '${trimmed}' was not found in Septum index (neither in declared symbols nor tracked dependencies). Risk assessment defaults to low (0 callers) due to unindexed status.`;
+      : `Symbol '${trimmed}' was not found in Septum index (neither in declared symbols nor tracked dependencies). Risk cannot be assessed without index evidence.`;
 
     return {
       target_symbol: trimmed,
@@ -286,7 +471,7 @@ export class DependencyRepository {
       warning,
       impact_summary: {
         total_dependents: inboundCallers.length,
-        risk_level: riskLevel,
+        risk_level: foundInIndex ? riskLevel : "unknown",
         affected_files_count: affectedFiles.size,
       },
       inbound_callers: inboundCallers,
@@ -312,42 +497,43 @@ export class DependencyRepository {
       .all(cleanPath, `%${cleanPath}`);
 
     const matchedFiles = new Set<string>();
+    const orConditions: string[] = [];
+    const params: string[] = [];
 
     if (baseName.length >= 3) {
+      orConditions.push("d.target_symbol_or_path LIKE ?");
+      params.push(`%${cleanPath}%`);
+      orConditions.push("d.target_symbol_or_path LIKE ?");
+      params.push(`%${baseName}%`);
+    }
+
+    for (const sym of symbols.slice(0, 8)) {
+      const symName = sym.name.split("::").pop() || sym.name;
+      if (symName.length >= 4) {
+        orConditions.push("d.target_symbol_or_path LIKE ?");
+        params.push(`%${symName}%`);
+        orConditions.push("d.import_statement LIKE ?");
+        params.push(`%${symName}%`);
+      }
+    }
+
+    if (orConditions.length > 0) {
+      params.push(`%${cleanPath}`);
       const depRows = this.db
-        .query<{ file: string }, [string, string, string]>(
+        .query<{ file: string }, string[]>(
           `SELECT DISTINCT f.path AS file
            FROM dependencies d
            JOIN files f ON d.source_file_id = f.id
-           WHERE (d.target_symbol_or_path LIKE ? OR d.target_symbol_or_path LIKE ?)
+           WHERE (${orConditions.join(" OR ")})
              AND f.path NOT LIKE ?`
         )
-        .all(`%${cleanPath}%`, `%${baseName}%`, `%${cleanPath}`);
+        .all(...params);
 
       for (const row of depRows) {
         matchedFiles.add(row.file);
       }
     }
 
-    for (const sym of symbols.slice(0, 8)) {
-      const symName = sym.name.split("::").pop() || sym.name;
-      if (symName.length >= 4) {
-        const symDeps = this.db
-          .query<{ file: string }, [string, string]>(
-            `SELECT DISTINCT f.path AS file
-             FROM dependencies d
-             JOIN files f ON d.source_file_id = f.id
-             WHERE d.target_symbol_or_path LIKE ?
-               AND f.path NOT LIKE ?
-             LIMIT 10`
-          )
-          .all(`%${symName}%`, `%${cleanPath}`);
-        for (const r of symDeps) {
-          matchedFiles.add(r.file);
-        }
-      }
-    }
-
     const consumerList = Array.from(matchedFiles);
     let riskLevel: "low" | "medium" | "high" = "low";
     if (consumerList.length >= 5) {

package/src/core/database/repositories/domain.repository.ts

@@ -7,6 +7,15 @@ import type {
   SymbolKind,
   SymbolRecord,
 } from "../../../types/index.ts";
+import { DependencyRepository } from "./dependency.repository.ts";
+
+const CONTAINER_KINDS = new Set<SymbolKind>([
+  "class",
+  "interface",
+  "trait",
+  "struct",
+  "enum",
+]);
 
 export class DomainRepository {
   constructor(private db: Database) {}
@@ -70,11 +79,15 @@ export class DomainRepository {
 
   public getDomainCatalog(
     domainName: string,
-    archetypeFilter?: string
+    archetypeFilter?: string,
+    options?: { detailLevel?: "compact" | "full"; fileFilter?: string }
   ): DomainCatalogResponse | null {
     const domain = this.getDomainByName(domainName);
     if (!domain) return null;
 
+    const detailLevel = options?.detailLevel ?? "compact";
+    const fileFilter = options?.fileFilter?.trim();
+
     const allowedDeps: string[] = JSON.parse(domain.allowed_deps_json || "[]");
     const forbiddenDeps: string[] = JSON.parse(domain.forbidden_deps_json || "[]");
 
@@ -87,7 +100,14 @@ export class DomainRepository {
     }
     filesQuery += " ORDER BY path ASC";
 
-    const files = this.db.query<FileRecord, any>(filesQuery).all(...params);
+    const allDomainFiles = this.db.query<FileRecord, any>(filesQuery).all(...params);
+    const totalFiles = allDomainFiles.length;
+
+    const files = fileFilter
+      ? allDomainFiles.filter((f) =>
+          f.path.replace(/\\/g, "/").toLowerCase().includes(fileFilter.replace(/\\/g, "/").toLowerCase())
+        )
+      : allDomainFiles;
 
     const catalogFiles: DomainCatalogResponse["files"] = [];
 
@@ -115,6 +135,10 @@ export class DomainRepository {
       }
     }
 
+    // Batch compute file connections for the domain (zero N+1)
+    const depRepo = new DependencyRepository(this.db);
+    const connectionsByPath = depRepo.getDomainFileConnections(domain.id);
+
     for (const file of files) {
       const symbols = symbolsByFileId.get(file.id) ?? [];
 
@@ -123,6 +147,7 @@ export class DomainRepository {
         {
           name: string;
           kind: SymbolKind;
+          lineSpan: string;
           properties: string[];
           methods: string[];
           signatures: string[];
@@ -130,63 +155,66 @@ export class DomainRepository {
       >();
 
       for (const sym of symbols) {
-        if (
-          sym.kind === "class" ||
-          sym.kind === "interface" ||
-          sym.kind === "trait" ||
-          sym.kind === "enum"
-        ) {
+        const lineSpan = `${sym.line_start}-${sym.line_end}`;
+        if (CONTAINER_KINDS.has(sym.kind)) {
           if (!symbolMap.has(sym.name)) {
             symbolMap.set(sym.name, {
               name: sym.name,
               kind: sym.kind,
+              lineSpan,
               properties: [],
               methods: [],
               signatures: [sym.signature],
             });
           }
-        } else if (sym.kind === "method") {
-          let targetContainer = Array.from(symbolMap.values()).pop();
+        } else if (sym.kind === "method" || sym.kind === "property") {
+          let targetContainer:
+            | {
+                name: string;
+                kind: SymbolKind;
+                lineSpan: string;
+                properties: string[];
+                methods: string[];
+                signatures: string[];
+              }
+            | undefined;
+
           if (sym.name.includes("::")) {
             const containerName = sym.name.split("::")[0];
-            if (symbolMap.has(containerName)) {
-              targetContainer = symbolMap.get(containerName);
+            const candidate = symbolMap.get(containerName);
+            if (candidate && CONTAINER_KINDS.has(candidate.kind)) {
+              targetContainer = candidate;
             }
           }
+
           if (targetContainer) {
-            targetContainer.methods.push(sym.signature);
-          } else {
-            symbolMap.set(sym.name, {
-              name: sym.name,
-              kind: sym.kind,
-              properties: [],
-              methods: [],
-              signatures: [sym.signature],
-            });
-          }
-        } else if (sym.kind === "property") {
-          let targetContainer = Array.from(symbolMap.values()).pop();
-          if (sym.name.includes("::")) {
-            const containerName = sym.name.split("::")[0];
-            if (symbolMap.has(containerName)) {
-              targetContainer = symbolMap.get(containerName);
+            if (sym.kind === "method") {
+              targetContainer.methods.push(sym.signature);
+            } else {
+              targetContainer.properties.push(sym.signature);
             }
-          }
-          if (targetContainer) {
-            targetContainer.properties.push(sym.signature);
           } else {
             symbolMap.set(sym.name, {
               name: sym.name,
               kind: sym.kind,
-              properties: [sym.signature],
+              lineSpan,
+              properties: sym.kind === "property" ? [sym.signature] : [],
               methods: [],
               signatures: [sym.signature],
             });
           }
         } else {
+          if (
+            detailLevel === "compact" &&
+            (sym.kind === "variable" || sym.kind === "constant") &&
+            sym.visibility === "private"
+          ) {
+            continue;
+          }
           symbolMap.set(sym.name, {
             name: sym.name,
             kind: sym.kind,
+            lineSpan,
             properties: [],
             methods: [],
             signatures: [sym.signature],
@@ -194,25 +222,54 @@ export class DomainRepository {
         }
       }
 
+      const rawConn = connectionsByPath.get(file.path);
+      const fileConnections = {
+        imports_from: rawConn?.imports_from ?? [],
+        imported_by_count: rawConn?.imported_by_count ?? 0,
+      };
+
       catalogFiles.push({
         path: file.path,
         archetype: file.archetype,
-        symbols: Array.from(symbolMap.values()).map((s) => ({
-          name: s.name,
-          kind: s.kind,
-          properties: s.properties.length > 0 ? s.properties : undefined,
-          methods: s.methods.length > 0 ? s.methods : undefined,
-          signatures: s.signatures.length > 0 ? s.signatures : undefined,
-        })),
+        line_count: file.line_count,
+        connections: fileConnections,
+        symbols: Array.from(symbolMap.values()).map((s) => {
+          if (detailLevel === "compact") {
+            return {
+              name: s.name,
+              kind: s.kind,
+              line_span: s.lineSpan,
+              methods_count: s.methods.length > 0 ? s.methods.length : undefined,
+              properties_count: s.properties.length > 0 ? s.properties.length : undefined,
+            };
+          }
+          return {
+            name: s.name,
+            kind: s.kind,
+            line_span: s.lineSpan,
+            methods_count: s.methods.length > 0 ? s.methods.length : undefined,
+            properties_count: s.properties.length > 0 ? s.properties.length : undefined,
+            properties: s.properties.length > 0 ? s.properties : undefined,
+            methods: s.methods.length > 0 ? s.methods : undefined,
+            signatures: s.signatures.length > 0 ? s.signatures : undefined,
+          };
+        }),
       });
     }
 
     return {
       domain: domain.name,
       root: domain.root_path,
+      detail_level: detailLevel,
+      total_files: totalFiles,
+      showing_files: catalogFiles.length,
       allowed_dependencies: allowedDeps,
       forbidden_dependencies: forbiddenDeps,
       files: catalogFiles,
+      agent_hint:
+        detailLevel === "compact"
+          ? "Compact view (<400 tokens). Use septum_get_symbol({ symbol }) for exact method signatures, or septum_get_domain_catalog({ domain, detail_level: 'full', file_filter: '<path>' }) for full member lists."
+          : undefined,
     };
   }
 }