@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-lens/dist/clients/dependency-checker.js

@@ -1,525 +0,0 @@
-import { recordDegradationOnce } from "./degradation-ledger.js";
-import { createSubsystemLogger } from "./extension-log.js";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { mapWithConcurrency } from "./map-with-concurrency.js";
-import { findNodeToolBinary } from "./package-manager.js";
-import { isFullyQualified } from "./path-utils.js";
-import { safeSpawnAsync } from "./safe-spawn.js";
-import { compareOrdinal } from "./string-utils.js";
-import { createAvailabilityChecker, discoverManagedTool, getManagedToolEnvironment, resolveAvailableOrInstall } from "./dispatch/runners/utils/runner-helpers.js";
-import { createAvailabilityLatch } from "./dispatch/runners/utils/availability-policy.js";
-export function buildMadgeArgs(target, projectRoot) {
-  const args = ["--circular", "--extensions", "ts,tsx,js,jsx,mjs,cjs"];
-  const tsConfig = path.join(projectRoot, "tsconfig.json");
-  if (fs.existsSync(tsConfig)) {
-    args.push("--ts-config", tsConfig);
-  }
-  args.push("--json", target);
-  return args;
-}
-function parseMadgeCycles(stdout, baseDir, projectRoot) {
-  const parsed = JSON.parse(stdout || "[]");
-  const cycles = Array.isArray(parsed) ? parsed : [];
-  const circular = [];
-  const circularFiles = new Set;
-  for (const cycle of cycles) {
-    const resolvedPaths = cycle.map((f) => path.resolve(baseDir, f));
-    for (const f of resolvedPaths) {
-      circularFiles.add(f);
-    }
-    circular.push({
-      file: resolvedPaths[0],
-      path: resolvedPaths
-    });
-  }
-  recordDegradationOnce({
-    kind: "madge-skip-visibility-unavailable",
-    subject: projectRoot,
-    reason: "madge --warning is inert under --json; skipped-file visibility is unavailable for this scan"
-  });
-  return { circular, circularFiles };
-}
-const MADGE_BATCH_CONCURRENCY = 6;
-const MADGE_STATS_TARGET_CAP = 12;
-const MADGE_STATS_TARGET_MIN_DURATION_MS = 100;
-function isWithin(dir, target) {
-  const rel = path.relative(dir, target);
-  return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
-}
-function classifyMadgeKind(resolved, managedToolsDir, projectRoot) {
-  if (!isFullyQualified(resolved))
-    return "path";
-  if (isWithin(managedToolsDir, resolved))
-    return "managed";
-  if (isWithin(projectRoot, resolved))
-    return "local";
-  return "global";
-}
-async function resolvedCommandIsStale(resolved, spawnableCache) {
-  if (resolved.kind === "npx")
-    return false;
-  if (isFullyQualified(resolved.cmd))
-    return !fs.existsSync(resolved.cmd);
-  const cached = spawnableCache.get(resolved.cmd);
-  if (cached !== undefined)
-    return !cached;
-  const { isSpawnableCommand } = await import("./installer/index.js");
-  const spawnable = await isSpawnableCommand(resolved.cmd);
-  spawnableCache.set(resolved.cmd, spawnable);
-  return !spawnable;
-}
-
-export { mapWithConcurrency };
-
-export class DependencyChecker {
-  madgeAvailability = createAvailabilityChecker("madge", ".cmd", ["--version"], {
-    environment: (cwd) => getManagedToolEnvironment("madge", cwd),
-    unclassifiedFailureOutcome: "missing"
-  });
-  availabilityLatch = createAvailabilityLatch();
-  ensureInFlight = null;
-  checkInFlight = new Map;
-  scanInFlight = new Map;
-  log;
-  importCache = new Map;
-  lastCircular = [];
-  circularFiles = new Set;
-  opGeneration = 0;
-  stateGeneration = 0;
-  madgeCommand = new Map;
-  spawnableCache = new Map;
-  static instances = new Set;
-  constructor(verbose = false) {
-    this.log = verbose ? createSubsystemLogger("deps") : () => {};
-    DependencyChecker.instances.add(new WeakRef(this));
-  }
-  resetMadgeMemo() {
-    this.madgeCommand.clear();
-    this.spawnableCache.clear();
-  }
-  static resetMadgeManagedPathMemo() {
-    for (const ref of DependencyChecker.instances) {
-      const checker = ref.deref();
-      if (!checker) {
-        DependencyChecker.instances.delete(ref);
-        continue;
-      }
-      checker.resetMadgeMemo();
-    }
-  }
-  async resolveMadge(projectRoot) {
-    const cached = this.madgeCommand.get(projectRoot);
-    if (cached) {
-      const resolved = await cached;
-      if (!await resolvedCommandIsStale(resolved, this.spawnableCache))
-        return resolved;
-      const current = this.madgeCommand.get(projectRoot);
-      if (current === cached) {
-        this.madgeCommand.delete(projectRoot);
-      } else {
-        if (current)
-          return current;
-      }
-    }
-    const resolving = this.resolveUnlessNpx(projectRoot);
-    this.madgeCommand.set(projectRoot, resolving);
-    return resolving;
-  }
-  async resolveUnlessNpx(projectRoot) {
-    const resolved = await this.doResolveMadge(projectRoot);
-    if (resolved.kind === "npx")
-      this.madgeCommand.delete(projectRoot);
-    return resolved;
-  }
-  async doResolveMadge(projectRoot) {
-    try {
-      const { getManagedToolsDir } = await import("./installer/index.js");
-      const classify = (cmd) => ({
-        cmd,
-        prefix: [],
-        kind: classifyMadgeKind(cmd, getManagedToolsDir(), projectRoot)
-      });
-      const bin = await findNodeToolBinary("madge", projectRoot);
-      if (bin)
-        return classify(bin);
-      const discovered = await discoverManagedTool("madge");
-      if (discovered)
-        return classify(discovered);
-    } catch (err) {
-      this.log(`Madge resolution failed, falling back to npx: ${String(err)}`);
-    }
-    return { cmd: "npx", prefix: ["madge"], kind: "npx" };
-  }
-  publishState(gen, circular, circularFiles) {
-    if (gen < this.stateGeneration)
-      return;
-    this.stateGeneration = gen;
-    this.lastCircular = circular;
-    this.circularFiles = circularFiles;
-  }
-  async ensureAvailable(cwd = process.cwd()) {
-    const memo = this.availabilityLatch.read();
-    if (memo !== null)
-      return memo;
-    if (this.ensureInFlight)
-      return this.ensureInFlight;
-    this.ensureInFlight = this.doEnsureAvailable(cwd);
-    try {
-      return await this.ensureInFlight;
-    } finally {
-      this.ensureInFlight = null;
-    }
-  }
-  async doEnsureAvailable(cwd) {
-    const resolved = await resolveAvailableOrInstall(this.madgeAvailability, "madge", cwd);
-    if (resolved !== null) {
-      this.availabilityLatch.noteAvailable();
-      return true;
-    }
-    const verdict = this.madgeAvailability.getVerdict(cwd);
-    this.availabilityLatch.noteUnavailable(verdict.outcome ?? "missing", verdict.cause ?? "not-found");
-    return false;
-  }
-  getAvailabilityVerdict() {
-    return {
-      outcome: this.availabilityLatch.getOutcome(),
-      cause: this.availabilityLatch.getCause(),
-      retryAtMs: this.availabilityLatch.getRetryAtMs()
-    };
-  }
-  isInCircular(filePath) {
-    const normalized = path.resolve(filePath);
-    return this.circularFiles.has(normalized);
-  }
-  getCircularForFile(filePath) {
-    const normalized = path.resolve(filePath);
-    const deps = [];
-    for (const dep of this.lastCircular) {
-      if (dep.file === normalized || dep.path.includes(normalized)) {
-        for (const f of dep.path) {
-          if (f !== normalized) {
-            deps.push(path.relative(process.cwd(), f));
-          }
-        }
-      }
-    }
-    return Array.from(new Set(deps));
-  }
-  extractImports(filePath) {
-    const content = fs.readFileSync(filePath, "utf-8");
-    const imports = new Set;
-    const importPattern = /(?:import|export)\s+(?:.*?\s+from\s+)?['"]([^'"]+)['"]/g;
-    const requirePattern = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-    let match;
-    while ((match = importPattern.exec(content)) !== null) {
-      if (match[1].startsWith(".")) {
-        imports.add(match[1]);
-      }
-    }
-    while ((match = requirePattern.exec(content)) !== null) {
-      if (match[1].startsWith(".")) {
-        imports.add(match[1]);
-      }
-    }
-    return imports;
-  }
-  importsChanged(filePath) {
-    const normalized = path.resolve(filePath);
-    if (!fs.existsSync(normalized)) {
-      this.importCache.delete(normalized);
-      return true;
-    }
-    const stat = fs.statSync(normalized);
-    const cached = this.importCache.get(normalized);
-    if (cached && cached.timestamp >= stat.mtimeMs && cached.size === stat.size) {
-      return false;
-    }
-    const newImports = this.extractImports(normalized);
-    const hasChanged = !cached || !this.setsEqual(cached.imports, newImports);
-    this.importCache.set(normalized, {
-      imports: newImports,
-      timestamp: stat.mtimeMs,
-      size: stat.size
-    });
-    return hasChanged;
-  }
-  setsEqual(a, b) {
-    if (a.size !== b.size)
-      return false;
-    for (const item of a) {
-      if (!b.has(item))
-        return false;
-    }
-    return true;
-  }
-  async checkFile(filePath, cwd) {
-    const normalized = path.resolve(filePath);
-    if (!fs.existsSync(normalized)) {
-      return {
-        hasCircular: false,
-        circular: [],
-        checked: false,
-        cacheHit: false
-      };
-    }
-    const projectRoot = path.resolve(cwd || process.cwd());
-    const importsChanged = this.importsChanged(normalized);
-    if (!importsChanged) {
-      return {
-        hasCircular: this.circularFiles.has(normalized),
-        circular: this.lastCircular.filter((d) => d.file === normalized || d.path.includes(normalized)),
-        checked: true,
-        cacheHit: true
-      };
-    }
-    const gen = ++this.opGeneration;
-    if (!await this.ensureAvailable(projectRoot)) {
-      return {
-        hasCircular: false,
-        circular: [],
-        checked: false,
-        cacheHit: false
-      };
-    }
-    const key = `${projectRoot}:${normalized}`;
-    const existing = this.checkInFlight.get(key);
-    if (existing)
-      return existing;
-    const promise = this.runCheckFile(normalized, projectRoot, gen).finally(() => {
-      if (this.checkInFlight.get(key) === promise) {
-        this.checkInFlight.delete(key);
-      }
-    });
-    this.checkInFlight.set(key, promise);
-    return promise;
-  }
-  async runCheckFile(normalized, projectRoot, gen) {
-    const resolved = await this.resolveMadge(projectRoot);
-    const spawnResult = await this.runMadgeSpawn(normalized, projectRoot, resolved);
-    if (!spawnResult.ok) {
-      return {
-        hasCircular: false,
-        circular: [],
-        checked: false,
-        cacheHit: false
-      };
-    }
-    this.publishState(gen, spawnResult.circular, spawnResult.circularFiles);
-    return {
-      hasCircular: spawnResult.circular.length > 0,
-      circular: spawnResult.circular.filter((d) => d.file === normalized || d.path.includes(normalized)),
-      checked: true,
-      cacheHit: false
-    };
-  }
-  async runMadgeSpawn(normalized, projectRoot, { cmd, prefix }) {
-    this.log(`Imports changed for ${path.basename(normalized)}, checking dependencies...`);
-    try {
-      const result = await safeSpawnAsync(cmd, [...prefix, ...buildMadgeArgs(normalized, projectRoot)], {
-        timeout: 15000,
-        cwd: projectRoot
-      });
-      if (result.error) {
-        this.log(`Check error: ${result.error.message}`);
-        return { ok: false };
-      }
-      const { circular, circularFiles } = parseMadgeCycles(result.stdout || "", path.dirname(normalized), projectRoot);
-      return {
-        ok: true,
-        circular,
-        circularFiles
-      };
-    } catch (err) {
-      this.log(`Check error: ${err.message}`);
-      return { ok: false };
-    }
-  }
-  buildCachedResult(normalized, circular, circularFiles) {
-    return {
-      hasCircular: circularFiles.has(normalized),
-      circular: circular.filter((d) => d.file === normalized || d.path.includes(normalized)),
-      checked: true,
-      cacheHit: true
-    };
-  }
-  async checkFilesBatch(filePaths, cwd) {
-    const projectRoot = path.resolve(cwd || process.cwd());
-    const results = new Map;
-    const gen = ++this.opGeneration;
-    const entries = [];
-    for (const file of filePaths) {
-      const normalized = path.resolve(projectRoot, file);
-      if (!fs.existsSync(normalized)) {
-        entries.push({ kind: "missing", file });
-        continue;
-      }
-      entries.push(this.importsChanged(normalized) ? { kind: "miss", file, normalized } : { kind: "hit", file, normalized });
-    }
-    const missEntries = entries.filter((e) => e.kind === "miss");
-    const notAvailableResult = {
-      hasCircular: false,
-      circular: [],
-      checked: false,
-      cacheHit: false
-    };
-    const stats = {
-      requested: filePaths.length,
-      missing: entries.filter((e) => e.kind === "missing").length,
-      cacheHits: entries.filter((e) => e.kind === "hit").length,
-      spawned: 0,
-      failed: 0,
-      resolveMs: 0,
-      targets: [],
-      targetsTruncated: false
-    };
-    if (missEntries.length > 0 && !await this.ensureAvailable(projectRoot)) {
-      stats.failed = missEntries.length;
-      for (const entry of entries) {
-        if (entry.kind === "hit") {
-          results.set(entry.file, this.buildCachedResult(entry.normalized, this.lastCircular, this.circularFiles));
-        } else {
-          results.set(entry.file, notAvailableResult);
-        }
-      }
-      return { results, stats };
-    }
-    const spawnResults = new Map;
-    const spawnDurations = new Map;
-    if (missEntries.length > 0) {
-      const resolveStart = Date.now();
-      const resolved = await this.resolveMadge(projectRoot);
-      stats.resolveMs = Date.now() - resolveStart;
-      stats.commandKind = resolved.kind;
-      await mapWithConcurrency(missEntries, MADGE_BATCH_CONCURRENCY, async (entry) => {
-        stats.spawned++;
-        const startedAt = Date.now();
-        spawnResults.set(entry.normalized, await this.runMadgeSpawn(entry.normalized, projectRoot, resolved));
-        spawnDurations.set(entry.normalized, Date.now() - startedAt);
-      });
-    }
-    let foldedCircular = this.lastCircular;
-    let foldedCircularFiles = this.circularFiles;
-    let folded = false;
-    for (const entry of entries) {
-      if (entry.kind === "missing") {
-        results.set(entry.file, notAvailableResult);
-        continue;
-      }
-      if (entry.kind === "hit") {
-        results.set(entry.file, this.buildCachedResult(entry.normalized, foldedCircular, foldedCircularFiles));
-        continue;
-      }
-      const spawnResult = spawnResults.get(entry.normalized);
-      const durationMs = spawnDurations.get(entry.normalized) ?? 0;
-      if (durationMs >= MADGE_STATS_TARGET_MIN_DURATION_MS && stats.targets.length < MADGE_STATS_TARGET_CAP) {
-        stats.targets.push({
-          file: path.relative(projectRoot, entry.normalized),
-          durationMs,
-          ok: spawnResult?.ok === true
-        });
-      } else if (durationMs >= MADGE_STATS_TARGET_MIN_DURATION_MS) {
-        stats.targetsTruncated = true;
-      }
-      if (!spawnResult || !spawnResult.ok) {
-        stats.failed++;
-        results.set(entry.file, notAvailableResult);
-        continue;
-      }
-      foldedCircular = spawnResult.circular;
-      foldedCircularFiles = spawnResult.circularFiles;
-      folded = true;
-      results.set(entry.file, {
-        hasCircular: spawnResult.circular.length > 0,
-        circular: spawnResult.circular.filter((d) => d.file === entry.normalized || d.path.includes(entry.normalized)),
-        checked: true,
-        cacheHit: false
-      });
-    }
-    if (folded) {
-      this.publishState(gen, foldedCircular, foldedCircularFiles);
-    }
-    return { results, stats };
-  }
-  formatWarning(filePath, deps) {
-    if (deps.length === 0)
-      return "";
-    const filename = path.basename(filePath);
-    const depNames = deps.map((d) => path.basename(d));
-    let output = `[Circular Deps] ${filename} is in a cycle:
-`;
-    output += `  ${filename} ↔ ${depNames.join(", ")}
-`;
-    output += `
-  Consider extracting shared code to a separate module.
-`;
-    return output;
-  }
-  async scanProject(cwd) {
-    const projectRoot = path.resolve(cwd || process.cwd());
-    if (!fs.existsSync(projectRoot)) {
-      return { circular: [], count: 0 };
-    }
-    const entries = fs.readdirSync(projectRoot);
-    const hasSourceFiles = entries.some((e) => /\.(ts|tsx|js|jsx)$/.test(e) && !e.endsWith(".d.ts"));
-    if (!hasSourceFiles) {
-      return { circular: [], count: 0 };
-    }
-    if (!await this.ensureAvailable(projectRoot)) {
-      return { circular: [], count: 0 };
-    }
-    const existing = this.scanInFlight.get(projectRoot);
-    if (existing)
-      return existing;
-    const gen = ++this.opGeneration;
-    const promise = this.runScanProject(projectRoot, gen).finally(() => {
-      if (this.scanInFlight.get(projectRoot) === promise) {
-        this.scanInFlight.delete(projectRoot);
-      }
-    });
-    this.scanInFlight.set(projectRoot, promise);
-    return promise;
-  }
-  async runScanProject(projectRoot, gen) {
-    try {
-      const { cmd, prefix } = await this.resolveMadge(projectRoot);
-      const result = await safeSpawnAsync(cmd, [...prefix, ...buildMadgeArgs(projectRoot, projectRoot)], {
-        timeout: 30000,
-        cwd: projectRoot
-      });
-      if (result.error) {
-        this.log(`Scan error: ${result.error.message}`);
-        return { circular: [], count: 0 };
-      }
-      const { circular, circularFiles } = parseMadgeCycles(result.stdout || "", projectRoot, projectRoot);
-      this.publishState(gen, circular, circularFiles);
-      return { circular, count: circular.length, analyzed: true };
-    } catch (err) {
-      this.log(`Scan error: ${err.message}`);
-      return { circular: [], count: 0 };
-    }
-  }
-  formatScanResult(circular) {
-    if (circular.length === 0)
-      return "";
-    const seen = new Set;
-    let output = `[Circular Deps] ${circular.length} cycle(s) found:
-`;
-    for (const dep of circular) {
-      const cycleKey = [...dep.path].sort(compareOrdinal).join("→");
-      if (seen.has(cycleKey))
-        continue;
-      seen.add(cycleKey);
-      const names = dep.path.map((p) => path.relative(process.cwd(), p));
-      output += `  • ${names.join(" → ")}
-`;
-    }
-    output += `
-  Consider extracting shared code to break cycles.
-`;
-    return output;
-  }
-}
-export function resetMadgeManagedPathMemo() {
-  DependencyChecker.resetMadgeManagedPathMemo();
-}

package/extensions/dm-lens/dist/clients/deps/ast-grep-napi.js

@@ -1,17 +0,0 @@
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
-import { getDmHostModule, getDmHostModulePath } from "./dm-host-deps.js";
-const fallbackRequire = createRequire(import.meta.url);
-export function loadAstGrepNapi() {
-  const bundled = getDmHostModule("@ast-grep/napi");
-  if (bundled)
-    return Promise.resolve(bundled);
-  const bundledPath = getDmHostModulePath("@ast-grep/napi");
-  if (bundledPath)
-    return import(pathToFileURL(bundledPath).href);
-  try {
-    return import(pathToFileURL(fallbackRequire.resolve("@ast-grep/napi")).href);
-  } catch {
-    return import("@ast-grep/napi");
-  }
-}

package/extensions/dm-lens/dist/clients/deps/dm-host-deps.js

@@ -1,10 +0,0 @@
-const DM_EXTENSION_MODULES = Symbol.for("duckmind.dm.extension-modules");
-function registry() {
-  return globalThis[DM_EXTENSION_MODULES];
-}
-export function getDmHostModule(specifier) {
-  return registry()?.modules?.[specifier];
-}
-export function getDmHostModulePath(specifier) {
-  return registry()?.paths?.[specifier];
-}

package/extensions/dm-lens/dist/clients/deps/dm-tui-compat.js

@@ -1,58 +0,0 @@
-const ANSI_ESCAPE = /\x1b\[[0-?]*[ -/]*[@-~]/g;
-function printableWidth(character) {
-  const codePoint = character.codePointAt(0) ?? 0;
-  if (codePoint === 0 || codePoint >= 768 && codePoint <= 879)
-    return 0;
-  return codePoint >= 4352 && codePoint <= 4447 || codePoint >= 11904 && codePoint <= 42191 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 ? 2 : 1;
-}
-export function visibleWidth(text) {
-  return Array.from(text.replace(ANSI_ESCAPE, "")).reduce((width, character) => width + printableWidth(character), 0);
-}
-export function truncateToWidth(text, maxWidth, ellipsis = "...", pad = false) {
-  if (maxWidth <= 0)
-    return "";
-  if (visibleWidth(text) <= maxWidth) {
-    return pad ? text + " ".repeat(Math.max(0, maxWidth - visibleWidth(text))) : text;
-  }
-  const suffix = visibleWidth(ellipsis) < maxWidth ? ellipsis : "";
-  const limit = maxWidth - visibleWidth(suffix);
-  let output = "";
-  let width = 0;
-  for (const character of text.replace(ANSI_ESCAPE, "")) {
-    const nextWidth = printableWidth(character);
-    if (width + nextWidth > limit)
-      break;
-    output += character;
-    width += nextWidth;
-  }
-  output += suffix;
-  return pad ? output + " ".repeat(Math.max(0, maxWidth - visibleWidth(output))) : output;
-}
-
-export class Text {
-  text;
-  paddingX;
-  paddingY;
-  constructor(text = "", paddingX = 1, paddingY = 1) {
-    this.text = text;
-    this.paddingX = paddingX;
-    this.paddingY = paddingY;
-  }
-  setText(text) {
-    this.text = text;
-  }
-  invalidate() {}
-  render(width) {
-    if (!this.text.trim())
-      return [];
-    const contentWidth = Math.max(1, width - this.paddingX * 2);
-    const margin = " ".repeat(this.paddingX);
-    const lines = this.text.replace(/\t/g, "   ").split(`
-`).map((line) => {
-      const rendered = truncateToWidth(line, contentWidth, "", true);
-      return truncateToWidth(`${margin}${rendered}${margin}`, width, "", true);
-    });
-    const padding = Array.from({ length: this.paddingY }, () => " ".repeat(width));
-    return [...padding, ...lines, ...padding];
-  }
-}

package/extensions/dm-lens/dist/clients/deps/js-yaml.js

@@ -1,7 +0,0 @@
-import { createRequire } from "node:module";
-import { getDmHostModule } from "./dm-host-deps.js";
-const fallbackRequire = createRequire(import.meta.url);
-const yaml = getDmHostModule("js-yaml") ?? fallbackRequire("js-yaml");
-export default yaml;
-export const dump = yaml.dump;
-export const load = yaml.load;

package/extensions/dm-lens/dist/clients/deps/minimatch.js

@@ -1,6 +0,0 @@
-import { createRequire } from "node:module";
-import { getDmHostModule } from "./dm-host-deps.js";
-const fallbackRequire = createRequire(import.meta.url);
-const minimatchModule = getDmHostModule("minimatch") ?? fallbackRequire("minimatch");
-export const minimatch = minimatchModule.minimatch;
-export const Minimatch = minimatchModule.Minimatch;

package/extensions/dm-lens/dist/clients/deps/pidusage.js

@@ -1,5 +0,0 @@
-import { createRequire } from "node:module";
-import { getDmHostModule } from "./dm-host-deps.js";
-const fallbackRequire = createRequire(import.meta.url);
-const pidusageModule = getDmHostModule("pidusage") ?? fallbackRequire("pidusage");
-export default pidusageModule;

package/extensions/dm-lens/dist/clients/deps/typebox.js

@@ -1,5 +0,0 @@
-import { createRequire } from "node:module";
-import { getDmHostModule } from "./dm-host-deps.js";
-const fallbackRequire = createRequire(import.meta.url);
-const typebox = getDmHostModule("typebox") ?? fallbackRequire("typebox");
-export const Type = typebox.Type;

package/extensions/dm-lens/dist/clients/deps/vscode-jsonrpc.js

@@ -1,8 +0,0 @@
-import { createRequire } from "node:module";
-import { getDmHostModule } from "./dm-host-deps.js";
-const fallbackRequire = createRequire(import.meta.url);
-const jsonrpc = getDmHostModule("vscode-jsonrpc/node") ?? fallbackRequire("vscode-jsonrpc/node");
-export const CancellationTokenSource = jsonrpc.CancellationTokenSource;
-export const createMessageConnection = jsonrpc.createMessageConnection;
-export const StreamMessageReader = jsonrpc.StreamMessageReader;
-export const StreamMessageWriter = jsonrpc.StreamMessageWriter;

package/extensions/dm-lens/dist/clients/deps/web-tree-sitter.js

@@ -1,11 +0,0 @@
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
-const _require = createRequire(import.meta.url);
-export function loadWebTreeSitter() {
-  try {
-    const entry = _require.resolve("web-tree-sitter");
-    return import(pathToFileURL(entry).href);
-  } catch {
-    return import("web-tree-sitter");
-  }
-}