weavatrix 0.3.14 → 1.0.0

package/src/analysis-kit.mjs

@@ -1,17 +0,0 @@
-// Read-only analysis primitives the weavatrix-refactor package composes into refactoring
-// plan producers. Everything exported here is PURE READ: graph identity helpers, cycle
-// detection, architecture verification, the bundled tree-sitter grammars, the read-only
-// TypeScript language-server client, and dead-code risk signals. None of it writes, applies,
-// or references applying a change — the core catalog and the release gate keep the core
-// provably free of any source-write or edit-plan path. The refactoring engines live in
-// weavatrix-refactor and import this surface.
-
-export {graphEndpointId, fileOfId} from './graph/node-id.js'
-export {Parser, Query, EXT_LANG, ensureParser} from './graph/internal-builder.langs.js'
-export {querySymbolPrecision} from './precision/symbol-query.js'
-export {createTypeScriptLspClient} from './precision/typescript-provider/client.js'
-export {verifyArchitecture} from './analysis/architecture/contract-verification.js'
-export {normalizeArchitectureContract} from './analysis/architecture-contract.js'
-export {buildFileImportGraph, findSccs} from './analysis/structure/dependency-graph.js'
-export {isFrameworkEntryFile} from './analysis/dead-check.js'
-export {hasDynamicCode, REFLECTION_CODE_RE} from './analysis/dead-code-review/policy.js'

package/src/bounds.js

@@ -1,4 +0,0 @@
-export function boundedInteger(value, fallback, minimum, maximum) {
-  const number = Number(value);
-  return Math.max(minimum, Math.min(maximum, Number.isFinite(number) ? Math.floor(number) : fallback));
-}

package/src/build-graph.js

@@ -1,209 +0,0 @@
-// Graph build — weavatrix's own web-tree-sitter builder.
-// Emits <weavatrix-graphs/<repo>>/graph.json for the rest of the pipeline.
-//
-// The parse itself runs in a WORKER THREAD (build-worker.js): in-process it pinned Electron's main
-// event loop for the whole repo walk, and since Windows routes window input through the main process
-// the ENTIRE app froze on big repos. The worker writes graph.json itself and returns only counts +
-// summaries. If the worker can't even start (exotic packaging), we fall back to the in-process build
-// rather than lose the feature.
-import { existsSync, readFileSync, mkdirSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { Worker } from "node:worker_threads";
-import { childProcessEnv } from "./child-env.js";
-import { graphHomeDir, graphOutDirForRepo, graphStorageKey, repoTopFolders, summarizeCommunities, summarizeHotspots, filterGraphForMode, filterGraphByScope } from "./graph/layout.js";
-import { registerRepository } from "./graph/repo-registry.js";
-import { refreshGraphIncrementally, snapshotRepository } from "./graph/incremental-refresh.js";
-import { atomicWriteFileSync, withFileLock } from "./graph/file-lock.js";
-import { graphSchemaIsCurrent, repositoryFreshnessProbe, stampRepositoryFreshness } from "./graph/freshness-probe.js";
-import { buildLspPrecisionOverlay, invalidatePrecisionOverlay, precisionSummary } from "./precision/lsp-overlay.js";
-
-// The worker path deadlocks web-tree-sitter's WASM in Electron's worker threads (fine in plain Node) — off
-// until that's Electron-safe. In-process + event-loop yielding keeps the window responsive without it.
-const USE_BUILD_WORKER = false;
-
-// Hard ceiling so a wedged parse (WASM stuck, pathological file, symlink loop) can NEVER leave the UI on
-// an eternal "BUILDING GRAPH…". On timeout we terminate the worker and reject as a REAL failure (no
-// workerStartFailed → we do NOT fall back to the in-process build, which would hang the same way and
-// freeze the whole app on the main thread). 4 min is generous for very large repos.
-const BUILD_WORKER_TIMEOUT_MS = 4 * 60 * 1000;
-
-export function defaultPrecisionMode(env = process.env) {
-  return env?.WEAVATRIX_PRECISION === "off" ? "off" : "lsp";
-}
-
-// One-line human status for a precision summary (precisionSummary shape) — the graph_stats
-// composition, shared by the build log and open_repo so every surface reads the same fraction.
-export function precisionStatusLine(precision) {
-  const p = precision || {};
-  if (p.state === "NONE") return `Semantic precision: NONE — ${p.reason || "no eligible JavaScript/TypeScript semantic targets"}`;
-  return `Semantic precision: ${p.state || "UNAVAILABLE"} — ${p.queried || 0}/${p.candidates || 0} bounded target(s) queried${p.truncated ? " (truncated)" : ""}; ${p.verifiedEdges || 0} EXACT_LSP edge(s)${p.state !== "COMPLETE" && p.reason ? `; ${p.reason}` : ""}`;
-}
-
-function buildGraphInWorker(payload) {
-  return new Promise((resolve, reject) => {
-    let worker;
-    try {
-      worker = new Worker(new URL("./graph/build-worker.js", import.meta.url), { workerData: payload, env: childProcessEnv() });
-    } catch (e) {
-      reject(Object.assign(e, { workerStartFailed: true }));
-      return;
-    }
-    let settled = false;
-    let timer = null;
-    const done = (fn, v) => {
-      if (settled) return;
-      settled = true;
-      if (timer) { clearTimeout(timer); timer = null; }
-      fn(v);
-    };
-    timer = setTimeout(() => {
-      try { worker.terminate(); } catch { /* already gone */ }
-      done(reject, new Error(`graph build timed out after ${Math.round(BUILD_WORKER_TIMEOUT_MS / 1000)}s (the parser is wedged on this repo — try again, or report it)`));
-    }, BUILD_WORKER_TIMEOUT_MS);
-    worker.once("message", (msg) => {
-      if (msg && msg.ok) done(resolve, msg);
-      else done(reject, new Error((msg && msg.error) || "graph worker failed"));
-    });
-    worker.once("error", (e) => done(reject, Object.assign(e, { workerStartFailed: true })));
-    worker.once("exit", (code) => { if (code !== 0) done(reject, Object.assign(new Error(`graph worker exited with code ${code}`), { workerStartFailed: true })); });
-  });
-}
-
-async function buildAndWriteInProcess(repoPath, { mode, scope, precision, graphJson, central }) {
-  const { buildInternalGraph } = await import("./graph/internal-builder.js");
-  // Capture the cheap Git state on both sides of the authoritative build. Only an unchanged pair is
-  // safe to persist: if the working tree moves while parsing, the next process must take the slow path.
-  const probeBefore = scope ? null : repositoryFreshnessProbe(repoPath);
-  let graph;
-  let refresh = null;
-  if (mode === "full" && !scope && existsSync(graphJson)) {
-    try {
-      const existing = JSON.parse(readFileSync(graphJson, "utf8"));
-      if (existing.graphBuildMode === "full" && !existing.graphBuildScope && graphSchemaIsCurrent(existing)) {
-        refresh = await refreshGraphIncrementally(repoPath, existing, { buildGraph: buildInternalGraph });
-        graph = refresh.graph;
-      }
-    } catch { /* malformed/legacy graph: the safe path below is a full rebuild */ }
-  }
-  if (!graph && mode !== "full" && !scope && existsSync(graphJson)) {
-    try {
-      const existing = JSON.parse(readFileSync(graphJson, "utf8"));
-      if (existing.graphBuildMode === mode && existing.graphRevision && graphSchemaIsCurrent(existing)) {
-        const snapshot = snapshotRepository(repoPath);
-        if (snapshot.revision === existing.graphRevision) {
-          graph = existing;
-          refresh = { kind: "none", changedFiles: [], reason: "content-unchanged", revision: snapshot.revision };
-        }
-      }
-    } catch { /* malformed/legacy filtered graph: rebuild below */ }
-  }
-  if (!graph) {
-    graph = await buildInternalGraph(repoPath);
-    refresh = { kind: "full", changedFiles: [], reason: "full-build-requested", revision: graph.graphRevision };
-  }
-  // mode (no-tests/tests-only) + path-scope reuse the same pure filters graph-builder used.
-  if (mode === "no-tests" || mode === "tests-only") graph = filterGraphForMode(graph, mode, { repoRoot: repoPath });
-  if (scope) graph = filterGraphByScope(graph, scope);
-  graph.graphBuildMode = mode;
-  graph.graphBuildScope = scope || "";
-  const requestedPrecision = precision === "off" ? "off" : "lsp";
-  const precisionModeChanged = graph.graphPrecisionMode !== requestedPrecision;
-  graph.graphPrecisionMode = requestedPrecision;
-  const probeAfter = scope ? null : repositoryFreshnessProbe(repoPath);
-  const stableProbe = probeBefore && probeAfter === probeBefore ? probeAfter : null;
-  const freshnessMetadataChanged = stampRepositoryFreshness(graph, stableProbe, mode);
-  // Auto-refresh runs before every graph/health call. A no-op must not serialize and rewrite a
-  // multi-megabyte graph merely to answer that nothing changed (or manufacture a newer mtime).
-  // A one-time metadata-only write is intentional for legacy graphs so the next MCP process can use
-  // the persisted probe instead of repeating a full repository snapshot.
-  if (refresh?.kind !== "none" || freshnessMetadataChanged || precisionModeChanged) {
-    mkdirSync(central, { recursive: true });
-    atomicWriteFileSync(graphJson, JSON.stringify(graph), "utf8");
-  }
-  mkdirSync(central, { recursive: true });
-  let precisionOverlay = await buildLspPrecisionOverlay({
-    repoRoot: repoPath,
-    graph,
-    graphPath: graphJson,
-    mode: requestedPrecision,
-  });
-  if (requestedPrecision === "lsp") {
-    try {
-      // LSP deliberately runs after graph serialization and can outlive the initial snapshot. A
-      // complete second content snapshot catches source/config add-delete races (including Git
-      // assume-unchanged paths) that a status-only token cannot prove away.
-      if (snapshotRepository(repoPath).revision !== graph.graphRevision) {
-        precisionOverlay = invalidatePrecisionOverlay(graphJson, graph);
-      }
-    } catch {
-      precisionOverlay = invalidatePrecisionOverlay(
-        graphJson,
-        graph,
-        "repository freshness could not be verified after semantic precision",
-      );
-    }
-  }
-  return {
-    nodes: graph.nodes.length,
-    links: graph.links.length,
-    communities: summarizeCommunities(graphJson),
-    hotspots: summarizeHotspots(graphJson),
-    refresh,
-    precision: precisionSummary(precisionOverlay),
-  };
-}
-
-export async function buildGraphForRepo(repoPath, {
-  mode = "full",
-  scope = "",
-  precision = defaultPrecisionMode(),
-  outDir,
-  graphHome,
-} = {}) {
-  if (!existsSync(repoPath)) return { ok: false, error: "Repo path not found", builder: "internal" };
-  const registryHome = graphHome || graphHomeDir();
-  const canonicalDir = graphHome ? join(registryHome, graphStorageKey(repoPath)) : graphOutDirForRepo(repoPath);
-  const central = outDir || canonicalDir;
-  const graphJson = join(central, "graph.json");
-  try {
-    // In-process is the ONLY path now. The worker (buildGraphInWorker) hung web-tree-sitter's WASM inside an
-    // Electron worker thread → an eternal "BUILDING GRAPH…" for JS repos, even though the same code finishes
-    // in ~3s on the main thread (and in a plain-Node worker). buildInternalGraph now YIELDS the event loop
-    // between file chunks, so the main-thread parse no longer freezes the window — the reason the worker was
-    // introduced. buildGraphInWorker/USE_BUILD_WORKER are kept for a future Electron-safe re-enable.
-    const build = () => USE_BUILD_WORKER
-      ? buildGraphInWorker({ repoPath, mode, scope, precision, graphJson, central }).catch((e) => {
-          if (e && e.workerStartFailed) return buildAndWriteInProcess(repoPath, { mode, scope, precision, graphJson, central });
-          throw e;
-        })
-      : buildAndWriteInProcess(repoPath, { mode, scope, precision, graphJson, central });
-    // Canonical graphs are shared by all local MCP clients. Serialize the complete read/refresh/write
-    // transaction so an older process cannot overwrite a newer incremental result.
-    const canonical = !scope && resolve(central) === resolve(canonicalDir);
-    const built = canonical
-      ? await withFileLock(join(central, ".graph.lock"), build, { timeoutMs: 5 * 60_000, staleMs: 10 * 60_000 })
-      : await build();
-    // Scoped builds are disposable diagnostics under modules/<scope>; registering one would retarget
-    // list_known_repos and cross-repo analysis away from the complete canonical graph.
-    if (canonical) {
-      registerRepository({ repoPath, graphDir: central, graphHome: registryHome });
-    }
-    return {
-      ok: true,
-      builder: "internal",
-      mode,
-      scope,
-      topFolders: repoTopFolders(repoPath),
-      report: "",
-      graphFile: "", // no graph.html — weavatrix renders its own GUI board/relations views
-      graphDir: central,
-      communities: built.communities,
-      hotspots: built.hotspots,
-      refresh: built.refresh,
-      precision: built.precision,
-      log: `built-in builder: ${built.nodes} nodes, ${built.links} static links (${built.refresh?.kind || "full"}: ${built.refresh?.reason || "build"}); ${precisionStatusLine(built.precision)}`
-    };
-  } catch (error) {
-    return { ok: false, error: `graph build failed: ${error.message}`, builder: "internal" };
-  }
-}

package/src/child-env.js

@@ -1,7 +0,0 @@
-// Child processes and worker threads never need credentials owned by a composing connector.
-// Keep connector secrets in the parent MCP process and out of Git/LSP/test subprocesses.
-export function childProcessEnv(overrides = {}) {
-  const env = { ...process.env, ...overrides };
-  delete env.WEAVATRIX_SYNC_TOKEN;
-  return env;
-}

package/src/config.js

@@ -1,5 +0,0 @@
-// weavatrix config (Node).
-import { fileURLToPath } from "node:url";
-
-const MAIN_DIR = fileURLToPath(new URL(".", import.meta.url));
-export const ROOT_DIR = MAIN_DIR; // fallback cwd for repo-list helpers when a call passes none

package/src/extension/local-services.mjs

@@ -1,75 +0,0 @@
-import {readFileSync, statSync} from 'node:fs'
-import {createHash} from 'node:crypto'
-import {basename} from 'node:path'
-import {graphStaleness} from '../mcp/graph-context.mjs'
-import {createSyncPayload, createSyncPayloadV3, MAX_SYNC_BODY_BYTES} from '../mcp/sync-payload.mjs'
-import {createEvidenceSnapshot} from '../mcp/evidence-snapshot.mjs'
-import {graphHomeDir, graphOutDirForRepo} from '../graph/layout.js'
-import {registerRepository, repositoryRecord} from '../graph/repo-registry.js'
-import {writeCachedArchitectureContract} from '../analysis/architecture-contract.js'
-import {collectInstalled} from '../security/installed.js'
-import {toolResult} from '../mcp/tool-result.mjs'
-import {
-    commitAdvisoryRefresh, createAdvisoryQueryPlan, DEFAULT_STORE, storeMeta,
-} from '../security/advisory-store.js'
-
-const MAX_GRAPH_FILE_BYTES = 64 * 1024 * 1024
-
-const repositoryLabel = (repoRoot) => {
-    const safe = basename(String(repoRoot || '')).normalize('NFKC').replace(/[^a-z0-9._-]+/gi, '-').replace(/^-+|-+$/g, '')
-    return (safe || 'repo').slice(0, 128)
-}
-
-const identityFor = (repoRoot) => repositoryRecord(repoRoot, graphHomeDir())
-    || registerRepository({repoPath: repoRoot, graphDir: graphOutDirForRepo(repoRoot), graphHome: graphHomeDir()})
-
-// Produces the exact source-free wire material locally. It reads no credentials and performs no
-// network I/O; the caller owns destination policy, consent, authentication and transport.
-export async function createSourceFreeSyncMaterial(graph, {payloadVersion = 3} = {}, ctx = {}) {
-    if (!graph) throw new Error('No graph loaded — build one first (open_repo / rebuild_graph).')
-    if (!ctx.graphPath || !ctx.repoRoot) throw new Error('No active repository graph — open_repo first.')
-    const size = statSync(ctx.graphPath).size
-    if (size > MAX_GRAPH_FILE_BYTES) throw new Error(`graph.json exceeds the ${MAX_GRAPH_FILE_BYTES / 1024 / 1024} MB local safety limit`)
-    const raw = JSON.parse(readFileSync(ctx.graphPath, 'utf8'))
-    let payload
-    if (Number(payloadVersion) === 2) {
-        payload = createSyncPayload(raw)
-    } else {
-        if (graphStaleness(ctx).stale) throw new Error('Cannot produce synchronized evidence from a stale graph. Run rebuild_graph first.')
-        payload = createSyncPayloadV3(raw, await createEvidenceSnapshot({repoRoot: ctx.repoRoot, graph: raw}))
-    }
-    const body = JSON.stringify(payload)
-    const bodyBytes = Buffer.byteLength(body)
-    if (bodyBytes > MAX_SYNC_BODY_BYTES) throw new Error(`source-free payload exceeds the ${MAX_SYNC_BODY_BYTES / 1024} KB safety limit`)
-    const identity = identityFor(ctx.repoRoot)
-    return Object.freeze({
-        payload,
-        body,
-        bodyBytes,
-        bodyHash: createHash('sha256').update(body).digest('hex'),
-        repoName: repositoryLabel(ctx.repoRoot),
-        repositoryId: identity.repositoryId,
-        graphPath: ctx.graphPath,
-    })
-}
-
-export function activeRepositoryIdentity(ctx = {}) {
-    if (!ctx.repoRoot || !ctx.graphPath) throw new Error('No active repository graph — open_repo first.')
-    const identity = identityFor(ctx.repoRoot)
-    return Object.freeze({repositoryId: identity.repositoryId, repoName: repositoryLabel(ctx.repoRoot), graphPath: ctx.graphPath})
-}
-
-export const cacheArchitectureContract = (graphPath, contract) => writeCachedArchitectureContract(graphPath, contract)
-
-export function installedPackageCoordinates(repoRoot) {
-    if (!repoRoot) throw new Error('No repository root is active.')
-    return collectInstalled(repoRoot).installed
-}
-
-export const advisoryCacheMetadata = (storePath = DEFAULT_STORE) => ({
-    path: storePath,
-    ...storeMeta(storePath),
-})
-
-export {commitAdvisoryRefresh, createAdvisoryQueryPlan}
-export {toolResult}

package/src/git-exec.js

@@ -1,67 +0,0 @@
-// The single chokepoint for launching git. Every git subprocess in the package routes through here,
-// so there is one place that applies `-C <repoRoot>` containment, a credential-stripped child
-// environment, a hidden Windows window and a bounded timeout — instead of a dozen near-identical
-// spawnSync wrappers scattered across the analysis, graph and MCP layers.
-import { spawnSync, spawn } from "node:child_process";
-import { childProcessEnv } from "./child-env.js";
-
-// Synchronous git. Returns the raw spawnSync result ({status, stdout, stderr, error}) so callers keep
-// their existing status/stdout/error handling. encoding defaults to "utf8" (pass "buffer" for binary
-// stdout); maxBuffer and stdio are forwarded only when provided so Node's defaults are preserved.
-export function runGit(repoRoot, args, options = {}) {
-  const spawnOptions = {
-    encoding: options.encoding ?? "utf8",
-    windowsHide: true,
-    timeout: options.timeout ?? 8000,
-    env: childProcessEnv(options.env),
-  };
-  if (options.maxBuffer != null) spawnOptions.maxBuffer = options.maxBuffer;
-  if (options.stdio != null) spawnOptions.stdio = options.stdio;
-  return spawnSync("git", ["-C", repoRoot, ...args], spawnOptions);
-}
-
-// Streaming git for the history collector: byte-bounded stdout, a hard timeout that SIGKILLs the child,
-// and a resolved {stdout, stderr, exitCode, truncated}. The caller owns cwd/env so reads can be scoped
-// to a specific worktree.
-export function boundedGitCommand(command, args, options) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      cwd: options.cwd, env: options.env, shell: false, windowsHide: true,
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-    const stdout = [], stderr = [];
-    let stdoutBytes = 0, stderrBytes = 0, truncated = false, timedOut = false, settled = false;
-    const finish = (callback) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      callback();
-    };
-    const stop = () => { try { child.kill("SIGKILL"); } catch { /* process already exited */ } };
-    const timer = setTimeout(() => { timedOut = true; stop(); }, options.timeoutMs);
-    child.stdout?.on("data", (chunk) => {
-      if (truncated) return;
-      const remaining = options.maxOutputBytes - stdoutBytes;
-      if (remaining <= 0) { truncated = true; stop(); return; }
-      const kept = chunk.length <= remaining ? chunk : chunk.subarray(0, remaining);
-      stdout.push(kept); stdoutBytes += kept.length;
-      if (kept.length !== chunk.length) { truncated = true; stop(); }
-    });
-    child.stderr?.on("data", (chunk) => {
-      const remaining = 64 * 1024 - stderrBytes;
-      if (remaining <= 0) return;
-      const kept = chunk.length <= remaining ? chunk : chunk.subarray(0, remaining);
-      stderr.push(kept); stderrBytes += kept.length;
-    });
-    child.on("error", (error) => finish(() => reject(error)));
-    child.on("close", (exitCode) => finish(() => {
-      if (timedOut) return reject(new Error("git history collection timed out"));
-      resolve({
-        stdout: Buffer.concat(stdout),
-        stderr: Buffer.concat(stderr).toString("utf8"),
-        exitCode: Number(exitCode ?? 1),
-        truncated,
-      });
-    }));
-  });
-}

package/src/graph/build-worker.js

@@ -1,49 +0,0 @@
-// build-worker.js — runs the web-tree-sitter graph build OFF Electron's main thread. In-process the
-// parse blocks the main event loop for the whole repo walk (big repos = many seconds), and on Windows
-// window input routing lives on the main process — so the ENTIRE app froze during "BUILDING THE
-// GRAPH…". The worker builds, filters, writes graph.json and computes the summaries; only the small
-// result object crosses back (never the graph itself — structured-cloning a huge graph would stall
-// the main thread again).
-import { parentPort, workerData } from "node:worker_threads";
-import { buildInternalGraph } from "./internal-builder.js";
-import { filterGraphForMode, filterGraphByScope, summarizeCommunities, summarizeHotspots } from "./layout.js";
-import { atomicWriteFileSync } from "./file-lock.js";
-import { snapshotRepository } from "./incremental-refresh.js";
-import { buildLspPrecisionOverlay, invalidatePrecisionOverlay, precisionSummary } from "../precision/lsp-overlay.js";
-
-(async () => {
-  const { repoPath, mode, scope, precision, graphJson, central } = workerData || {};
-  try {
-    let graph = await buildInternalGraph(repoPath);
-    if (mode === "no-tests" || mode === "tests-only") graph = filterGraphForMode(graph, mode, { repoRoot: repoPath });
-    if (scope) graph = filterGraphByScope(graph, scope);
-    graph.graphBuildMode = mode;
-    graph.graphBuildScope = scope || "";
-    graph.graphPrecisionMode = precision === "off" ? "off" : "lsp";
-    atomicWriteFileSync(graphJson, JSON.stringify(graph), "utf8");
-    let overlay = await buildLspPrecisionOverlay({repoRoot: repoPath, graph, graphPath: graphJson, mode: graph.graphPrecisionMode});
-    if (graph.graphPrecisionMode === "lsp") {
-      try {
-        if (snapshotRepository(repoPath).revision !== graph.graphRevision) {
-          overlay = invalidatePrecisionOverlay(graphJson, graph);
-        }
-      } catch {
-        overlay = invalidatePrecisionOverlay(
-          graphJson,
-          graph,
-          "repository freshness could not be verified after semantic precision",
-        );
-      }
-    }
-    parentPort.postMessage({
-      ok: true,
-      nodes: graph.nodes.length,
-      links: graph.links.length,
-      communities: summarizeCommunities(graphJson),
-      hotspots: summarizeHotspots(graphJson),
-      precision: precisionSummary(overlay),
-    });
-  } catch (e) {
-    parentPort.postMessage({ ok: false, error: (e && e.message) || String(e) });
-  }
-})();

package/src/graph/builder/go-receiver-resolution.js

@@ -1,112 +0,0 @@
-import {goTypeName} from './lang-go.js'
-
-const dirOf = (file) => file.includes('/') ? file.slice(0, file.lastIndexOf('/')) : ''
-
-export function createGoReceiverResolution({resolution, nodeById, importedLocals}) {
-    const {dirSymbols, dirMethods, dirMethodsByName, dirTypes, resolveCall} = resolution
-    const typeRef = (rawType, contextFile, fallbackDir = dirOf(contextFile)) => {
-        const raw = String(rawType || '').trim()
-        if (!raw) return null
-        const dot = raw.indexOf('.')
-        if (dot > 0) {
-            const imported = importedLocals.get(contextFile)?.get(raw.slice(0, dot))
-            return imported?.targetDir ? {dir: imported.targetDir, name: raw.slice(dot + 1)} : null
-        }
-        return {dir: fallbackDir, name: raw}
-    }
-    const fieldType = (receiver, fieldName) => {
-        if (!receiver?.name || !fieldName) return null
-        const typeId = dirTypes.get(receiver.dir)?.get(receiver.name)
-        const typeNode = typeId && nodeById.get(typeId)
-        const rawFieldType = typeNode?.field_types?.[fieldName]
-        return rawFieldType ? typeRef(rawFieldType, typeNode.source_file, receiver.dir) : null
-    }
-    const exactMethod = (receiver, methodName) => {
-        const candidates = receiver && dirMethods.get(receiver.dir)?.get(receiver.name)?.get(methodName)
-        return candidates?.length === 1 ? candidates[0] : null
-    }
-    const uniqueMethod = (dir, methodName) => {
-        const candidates = dirMethodsByName.get(dir)?.get(methodName) || []
-        return candidates.length === 1 ? candidates[0] : null
-    }
-    const returnType = (targetId, callerFile) => {
-        const target = targetId && nodeById.get(targetId)
-        return target?.return_type
-            ? typeRef(target.return_type, target.source_file || callerFile, dirOf(target.source_file || callerFile))
-            : null
-    }
-    const fieldChildren = (node, name) => {
-        const children = node?.childrenForFieldName?.(name)
-        if (Array.isArray(children) && children.length) return children
-        const child = node?.childForFieldName?.(name)
-        return child ? [child] : []
-    }
-    const receiverBindings = (selector, file) => {
-        const bindings = new Map()
-        let scope = selector
-        while (scope?.parent && !['function_declaration', 'method_declaration'].includes(scope.type)) scope = scope.parent
-        if (!scope || !['function_declaration', 'method_declaration'].includes(scope.type)) return bindings
-        const callRow = selector.startPosition.row
-        const containsCall = (node) => node.startIndex <= selector.startIndex && node.endIndex >= selector.endIndex
-        const expressionType = (node) => {
-            if (!node) return null
-            const declared = goTypeName(node)
-            if (declared) return typeRef(declared, file)
-            if (['parenthesized_expression', 'unary_expression'].includes(node.type)) {
-                return expressionType(node.childForFieldName?.('operand') || node.namedChildren?.[0])
-            }
-            if (node.type === 'composite_literal') return typeRef(goTypeName(node.childForFieldName?.('type')), file)
-            if (node.type === 'identifier') return bindings.get(node.text) || null
-            if (node.type === 'selector_expression') return fieldType(expressionType(node.childForFieldName?.('operand')), node.childForFieldName?.('field')?.text)
-            if (node.type !== 'call_expression') return null
-            const fn = node.childForFieldName?.('function')
-            if (fn?.type === 'identifier') {
-                const returned = returnType(resolveCall(fn.text, file), file)
-                if (returned) return returned
-                if (dirTypes.get(dirOf(file))?.has(fn.text)) return typeRef(fn.text, file)
-                if (/^New[A-Z_]/.test(fn.text)) return typeRef(fn.text.slice(3), file)
-            }
-            if (fn?.type === 'selector_expression') {
-                const operand = fn.childForFieldName?.('operand'), member = fn.childForFieldName?.('field')?.text
-                const imported = operand?.type === 'identifier' && importedLocals.get(file)?.get(operand.text)
-                if (imported?.targetDir && member) {
-                    const returned = returnType(dirSymbols.get(imported.targetDir)?.get(member), file)
-                    if (returned) return returned
-                    if (/^New[A-Z_]/.test(member)) return {dir: imported.targetDir, name: member.slice(3)}
-                }
-            }
-            return null
-        }
-        const bindTyped = (node) => {
-            const reference = typeRef(goTypeName(node.childForFieldName?.('type')), file)
-            const names = fieldChildren(node, 'name').filter((name) => ['identifier', 'field_identifier'].includes(name.type))
-            if (reference) for (const name of names) bindings.set(name.text, reference)
-            else if (node.type === 'var_spec') {
-                const values = node.childForFieldName?.('value')?.namedChildren || []
-                for (let index = 0; index < Math.min(names.length, values.length); index++) {
-                    const inferred = expressionType(values[index])
-                    if (inferred) bindings.set(names[index].text, inferred)
-                }
-            }
-        }
-        const bindAssignment = (node) => {
-            const left = node.childForFieldName?.('left')?.namedChildren || []
-            const right = node.childForFieldName?.('right')?.namedChildren || []
-            for (let index = 0; index < Math.min(left.length, right.length); index++) {
-                if (left[index].type !== 'identifier') continue
-                const inferred = expressionType(right[index])
-                if (inferred) bindings.set(left[index].text, inferred)
-            }
-        }
-        const visit = (node) => {
-            if (!node || node.startPosition.row > callRow) return
-            if (node !== scope && ['function_declaration', 'method_declaration', 'func_literal'].includes(node.type) && !containsCall(node)) return
-            if (['parameter_declaration', 'var_spec'].includes(node.type)) bindTyped(node)
-            else if (['short_var_declaration', 'assignment_statement'].includes(node.type)) bindAssignment(node)
-            for (const child of node.namedChildren || []) visit(child)
-        }
-        visit(scope)
-        return bindings
-    }
-    return {dirOf, fieldType, exactMethod, uniqueMethod, receiverBindings}
-}

package/src/graph/builder/js/dynamic-import.js

@@ -1,26 +0,0 @@
-// Resolve only the bounded local-file portion of URL-based dynamic imports.
-// Runtime substitutions remain uncertain; this candidate exists solely so a
-// statically named module is not mislabeled as an orphan.
-export function boundedUrlImportTarget(arg, {field, fileRel, resolveJsImport}) {
-  if (!arg || arg.type !== "member_expression" || field(arg, "property")?.text !== "href") return null;
-  const created = field(arg, "object");
-  if (!created || created.type !== "new_expression" || field(created, "constructor")?.text !== "URL") return null;
-  const urlArgs = field(created, "arguments")?.namedChildren || [];
-  if (urlArgs.length !== 2 || urlArgs[1].text !== "import.meta.url") return null;
-
-  const source = urlArgs[0];
-  let rawSpec = "";
-  if (source.type === "string") {
-    rawSpec = source.text.replace(/^['"`]|['"`]$/g, "");
-  } else if (source.type === "template_string") {
-    const parts = source.namedChildren || [];
-    if (parts.length !== 2 || parts[0].type !== "string_fragment" || parts[1].type !== "template_substitution") return null;
-    rawSpec = parts[0].text;
-  } else return null;
-
-  if (!/^\.\.?\//.test(rawSpec)) return null;
-  const staticPath = rawSpec.split(/[?#]/)[0];
-  if (!/\.[cm]?[jt]sx?$/i.test(staticPath)) return null;
-  const target = resolveJsImport(fileRel, staticPath);
-  return target ? {rawSpec: staticPath, target} : null;
-}

package/src/graph/builder/js/queries.js

@@ -1,48 +0,0 @@
-export const CALLABLE = /arrow_function|function|function_expression|generator_function/
-
-export const FUNCS = `
-  (function_declaration name: (identifier) @fn)
-  (generator_function_declaration name: (identifier) @fn)
-  (class_declaration name: (_) @class)
-  (method_definition name: (_) @method)`
-
-export const TOPVARS = `
-  (program (lexical_declaration (variable_declarator) @decl))
-  (program (variable_declaration (variable_declarator) @decl))
-  (program (export_statement (lexical_declaration (variable_declarator) @decl)))
-  (program (export_statement (variable_declaration (variable_declarator) @decl)))`
-
-export const TYPES = `
-  (interface_declaration name: (_) @interface)
-  (type_alias_declaration name: (_) @type)
-  (enum_declaration name: (_) @enum)`
-
-export const REQUIRE = `(variable_declarator name: (_) @lhs value: (call_expression function: (identifier) @req arguments: (arguments (string (string_fragment) @src))))`
-
-export function parseExportSpecifiers(raw) {
-  return String(raw || '').split(',').map((part) => {
-    const text = part.trim()
-    const typeOnly = /^type\s+/.test(text)
-    const clean = text.replace(/^type\s+/, '').trim()
-    const match = clean.match(/^([A-Za-z_$][\w$]*|default)(?:\s+as\s+([A-Za-z_$][\w$]*|default))?$/)
-    return match ? {imported: match[1], exported: match[2] || match[1], typeOnly} : null
-  }).filter(Boolean)
-}
-
-export function importTypeOnly(node) {
-  if (/^\s*import\s+type\b/.test(node.text)) return true
-  const clause = node.namedChildren.find((child) => child.type === 'import_clause')
-  if (!clause) return false
-  const parts = clause.namedChildren
-  if (parts.some((child) => child.type === 'identifier' || child.type === 'namespace_import')) return false
-  const named = parts.find((child) => child.type === 'named_imports')
-  const specifiers = named?.namedChildren.filter((child) => child.type === 'import_specifier') || []
-  return specifiers.length > 0 && specifiers.every((specifier) => /^\s*type\b/.test(specifier.text))
-}
-
-export function reexportTypeOnly(node) {
-  if (/^\s*export\s+type\b/.test(node.text)) return true
-  const clause = node.namedChildren.find((child) => child.type === 'export_clause')
-  const specifiers = clause?.namedChildren.filter((child) => child.type === 'export_specifier') || []
-  return specifiers.length > 0 && specifiers.every((specifier) => /^\s*type\b/.test(specifier.text))
-}