@duckmind/dm-linux-x64 0.65.5 → 0.65.7

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

@@ -0,0 +1,525 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,11 @@
+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");
+  }
+}