@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-lens/dist/clients/advisory-provenance.js

@@ -1,385 +0,0 @@
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { logLatency } from "./latency-logger.js";
-import { normalizeMapKey, toProjectRelativePath } from "./path-utils.js";
-import { resolveRunnerPath } from "./dispatch/runner-context.js";
-import { freshnessFromMtime } from "./freshness.js";
-export const MAX_ADVISORY_AFFECTED_FILES = 256;
-export function advisoryPathKey(filePath, cwd) {
-  return normalizeMapKey(path.resolve(cwd, filePath));
-}
-export function advisoryFileHash(filePath) {
-  try {
-    return createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
-  } catch (error) {
-    const code = error.code ?? "unknown";
-    return code === "ENOENT" ? "missing" : `unreadable:${code}`;
-  }
-}
-function snapshotOne(filePath, cwd, role) {
-  const resolved = path.resolve(cwd, filePath);
-  try {
-    const stat = fs.statSync(resolved);
-    return {
-      path: resolved,
-      role,
-      mtimeMs: stat.mtimeMs,
-      size: stat.size,
-      sha256: advisoryFileHash(resolved)
-    };
-  } catch (error) {
-    const code = error.code ?? "unknown";
-    return {
-      path: resolved,
-      role,
-      mtimeMs: -1,
-      size: -1,
-      sha256: code === "ENOENT" ? "missing" : `unreadable:${code}`
-    };
-  }
-}
-export function snapshotAdvisoryProvenance(args) {
-  const seen = new Set;
-  const files = [];
-  for (const file of args.files) {
-    const key = advisoryPathKey(file.path, args.cwd);
-    if (seen.has(key))
-      continue;
-    seen.add(key);
-    files.push(snapshotOne(file.path, args.cwd, file.role));
-  }
-  return {
-    revision: {
-      sessionId: args.runtime.telemetrySessionId,
-      projectSeq: args.runtime.projectSeq,
-      turnIndex: args.runtime.turnIndex,
-      generation: args.generation,
-      capturedAt: args.capturedAt ?? Date.now()
-    },
-    files,
-    ...args.truncated ? { truncated: true } : {}
-  };
-}
-function isFiniteNumber(value) {
-  return typeof value === "number" && Number.isFinite(value);
-}
-function isCapturedHash(value) {
-  return typeof value === "string" && (/^[a-f0-9]{64}$/.test(value) || value === "missing" || value.startsWith("unreadable:"));
-}
-function isWellFormed(value) {
-  if (!value || typeof value !== "object")
-    return false;
-  const record = value;
-  const revision = record.revision;
-  return !!revision && typeof revision.sessionId === "string" && isFiniteNumber(revision.projectSeq) && isFiniteNumber(revision.turnIndex) && isFiniteNumber(revision.generation) && isFiniteNumber(revision.capturedAt) && Array.isArray(record.files) && record.files.length > 0 && record.files.every((file) => !!file && typeof file.path === "string" && (file.role === "source" || file.role === "test" || file.role === "affected") && isFiniteNumber(file.mtimeMs) && isFiniteNumber(file.size) && isCapturedHash(file.sha256));
-}
-export function validateAdvisoryProvenance(record, cwd, runtime) {
-  if (!isWellFormed(record.provenance)) {
-    return {
-      status: "unknown",
-      reasons: ["malformed-or-legacy-provenance"],
-      allFilesDeleted: false,
-      changedPathCount: 0
-    };
-  }
-  const provenance = record.provenance;
-  const reasons = [];
-  let unknown = provenance.truncated === true;
-  if (unknown)
-    reasons.push("truncated-provenance");
-  if (runtime) {
-    if (provenance.revision.sessionId !== runtime.telemetrySessionId)
-      reasons.push("session-mismatch");
-  }
-  let deletedFiles = 0;
-  const changedPaths = new Set;
-  for (const captured of provenance.files) {
-    const resolved = path.resolve(cwd, captured.path);
-    const reasonsBefore = reasons.length;
-    let stat;
-    try {
-      stat = fs.statSync(resolved);
-    } catch (error) {
-      const code = error.code ?? "unknown";
-      if (code === "ENOENT") {
-        if (captured.sha256 !== "missing") {
-          deletedFiles += 1;
-          reasons.push(`missing:${advisoryPathKey(resolved, cwd)}`);
-          changedPaths.add(advisoryPathKey(resolved, cwd));
-        }
-      } else {
-        unknown = true;
-        reasons.push(`unreadable:${advisoryPathKey(resolved, cwd)}:${code}`);
-        changedPaths.add(advisoryPathKey(resolved, cwd));
-      }
-      continue;
-    }
-    if (captured.sha256.startsWith("unreadable:")) {
-      unknown = true;
-      reasons.push(`capture-unreadable:${advisoryPathKey(resolved, cwd)}`);
-      changedPaths.add(advisoryPathKey(resolved, cwd));
-      continue;
-    }
-    if (captured.sha256 === "missing") {
-      reasons.push(`created:${advisoryPathKey(resolved, cwd)}`);
-      changedPaths.add(advisoryPathKey(resolved, cwd));
-      continue;
-    }
-    if (stat.mtimeMs !== captured.mtimeMs || stat.size !== captured.size) {
-      reasons.push(`metadata-changed:${advisoryPathKey(resolved, cwd)}`);
-    }
-    const currentHash = advisoryFileHash(resolved);
-    if (currentHash.startsWith("unreadable:")) {
-      unknown = true;
-      reasons.push(`${currentHash}:${advisoryPathKey(resolved, cwd)}`);
-    } else if (currentHash !== captured.sha256) {
-      reasons.push(`content-changed:${advisoryPathKey(resolved, cwd)}`);
-    }
-    if (reasons.length > reasonsBefore)
-      changedPaths.add(advisoryPathKey(resolved, cwd));
-  }
-  const allFilesDeleted = deletedFiles === provenance.files.length;
-  if (unknown)
-    return {
-      status: "unknown",
-      reasons,
-      allFilesDeleted,
-      changedPathCount: changedPaths.size
-    };
-  return reasons.length > 0 ? {
-    status: "superseded",
-    reasons,
-    allFilesDeleted,
-    changedPathCount: changedPaths.size
-  } : { status: "current", reasons: [], allFilesDeleted, changedPathCount: 0 };
-}
-const MAX_FINDING_PATH_STATS = MAX_ADVISORY_AFFECTED_FILES;
-const MAX_LOGGED_DEAD_PATHS = 3;
-export function findingPathFreshness(resolvedPath, scannedAtMs) {
-  return freshnessFromFacts(statFindingPath(resolvedPath), scannedAtMs);
-}
-function statFindingPath(resolvedPath) {
-  try {
-    return { state: "present", mtimeMs: fs.statSync(resolvedPath).mtimeMs };
-  } catch (error) {
-    const code = error.code ?? "unknown";
-    return code === "ENOENT" || code === "ENOTDIR" ? { state: "missing" } : { state: "unknown" };
-  }
-}
-function freshnessFromFacts(facts, scannedAtMs) {
-  if (facts.state === "missing")
-    return "missing";
-  if (facts.state === "unknown")
-    return "unknown";
-  if (scannedAtMs === undefined)
-    return "live";
-  return freshnessFromMtime({
-    mtimeMs: facts.mtimeMs,
-    referenceMs: scannedAtMs
-  }).verdict === "stale" ? "stale" : "live";
-}
-export function findingPathExistence(resolvedPath) {
-  return findingPathFreshness(resolvedPath);
-}
-export function parseScannedAtMs(scannedAt) {
-  if (scannedAt === undefined || scannedAt === null || scannedAt === "") {
-    return;
-  }
-  const ms = typeof scannedAt === "number" ? scannedAt : Date.parse(scannedAt);
-  return Number.isFinite(ms) ? ms : undefined;
-}
-export function partitionFindingsByCitedPath(args) {
-  return partitionOneSource({ ...args, store: args.store ?? "" }, createPathFactsMemo(args));
-}
-function createPathFactsMemo(args) {
-  return {
-    facts: new Map,
-    probe: args.probePath ?? statFindingPath,
-    limit: args.maxUniquePaths ?? MAX_FINDING_PATH_STATS,
-    starved: new Map
-  };
-}
-function partitionOneSource(args, memo) {
-  const scannedAtMs = parseScannedAtMs(args.scannedAt);
-  const onMissing = args.onMissing ?? "drop";
-  const rawVerdicts = new Map;
-  const live = [];
-  const stale = [];
-  const dropped = [];
-  const deadPaths = [];
-  const stalePaths = [];
-  const seenPaths = new Set;
-  let probed = 0;
-  for (const finding of args.findings) {
-    const cited = args.citedPath(finding);
-    if (!cited) {
-      live.push(finding);
-      continue;
-    }
-    let verdict = rawVerdicts.get(cited);
-    if (verdict === undefined) {
-      const resolved = resolveRunnerPath(args.cwd, cited);
-      let facts = memo.facts.get(resolved);
-      if (facts === undefined) {
-        if (probed >= memo.limit) {
-          memo.starved.set(args.store, (memo.starved.get(args.store) ?? 0) + 1);
-          facts = { state: "unknown" };
-        } else {
-          probed += 1;
-          facts = memo.probe(resolved);
-          memo.facts.set(resolved, facts);
-        }
-      }
-      verdict = freshnessFromFacts(facts, scannedAtMs);
-      if (verdict === "missing" && onMissing === "demote")
-        verdict = "stale";
-      if (!seenPaths.has(resolved)) {
-        seenPaths.add(resolved);
-        if (verdict === "missing")
-          deadPaths.push(resolved);
-        else if (verdict === "stale")
-          stalePaths.push(resolved);
-      }
-      rawVerdicts.set(cited, verdict);
-    }
-    if (verdict === "missing")
-      dropped.push(finding);
-    else if (verdict === "stale")
-      stale.push(finding);
-    else
-      live.push(finding);
-  }
-  return {
-    live,
-    stale,
-    dropped,
-    deadPaths,
-    stalePaths,
-    statCount: memo.facts.size,
-    truncated: (memo.starved.get(args.store) ?? 0) > 0
-  };
-}
-export function dropFindingsForMissingPaths(args) {
-  const partition = partitionFindingsByCitedPath(args);
-  emitDeadPathDropRecord(args.cwd, partition, {
-    [args.store]: partition.dropped.length
-  });
-  return partition.live;
-}
-export function gateFindingsByPathFreshness(args) {
-  const memo = createPathFactsMemo(args);
-  const names = Object.keys(args.sources).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-  const gates = {};
-  const dropped = {};
-  const demoted = {};
-  const merged = {
-    live: [],
-    stale: [],
-    dropped: [],
-    deadPaths: [],
-    stalePaths: [],
-    statCount: 0,
-    truncated: false
-  };
-  const scannedAtByStore = {};
-  for (const name of names) {
-    const source = args.sources[name];
-    const partition = partitionOneSource({ ...source, store: name, cwd: args.cwd }, memo);
-    gates[name] = { live: partition.live, stale: partition.stale };
-    if (partition.dropped.length > 0)
-      dropped[name] = partition.dropped.length;
-    if (partition.stale.length > 0)
-      demoted[name] = partition.stale.length;
-    if (source.scannedAt !== undefined) {
-      scannedAtByStore[name] = String(source.scannedAt);
-    }
-    merged.live.push(...partition.live);
-    merged.stale.push(...partition.stale);
-    merged.dropped.push(...partition.dropped);
-    for (const deadPath of partition.deadPaths) {
-      if (!merged.deadPaths.includes(deadPath))
-        merged.deadPaths.push(deadPath);
-    }
-    for (const stalePath of partition.stalePaths) {
-      if (!merged.stalePaths.includes(stalePath)) {
-        merged.stalePaths.push(stalePath);
-      }
-    }
-  }
-  merged.statCount = memo.facts.size;
-  merged.truncated = memo.starved.size > 0;
-  emitDeadPathDropRecord(args.cwd, merged, dropped);
-  emitStaleLineDemoteRecord(args.cwd, scannedAtByStore, merged, demoted);
-  emitStatBudgetRecord(args.cwd, memo);
-  return gates;
-}
-function emitDeadPathDropRecord(cwd, partition, byStore) {
-  if (partition.dropped.length === 0)
-    return;
-  const stores = Object.keys(byStore);
-  logLatency({
-    type: "phase",
-    phase: "finding_dead_path_drop",
-    filePath: cwd,
-    durationMs: 0,
-    metadata: {
-      store: stores.join("+"),
-      byStore,
-      droppedDeadPaths: partition.dropped.length,
-      deadPathCount: partition.deadPaths.length,
-      deliveredCount: partition.live.length,
-      statCount: partition.statCount,
-      samplePaths: partition.deadPaths.slice(0, MAX_LOGGED_DEAD_PATHS).map((deadPath) => toProjectRelativePath(deadPath, cwd)),
-      ...partition.truncated ? { truncated: true } : {}
-    }
-  });
-}
-function emitStaleLineDemoteRecord(cwd, scannedAtByStore, partition, byStore) {
-  if (partition.stale.length === 0)
-    return;
-  const stores = Object.keys(byStore);
-  const single = stores.length === 1 ? scannedAtByStore[stores[0]] : undefined;
-  logLatency({
-    type: "phase",
-    phase: "finding_stale_line_demote",
-    filePath: cwd,
-    durationMs: 0,
-    metadata: {
-      store: stores.join("+"),
-      byStore,
-      demotedStalePaths: partition.stale.length,
-      stalePathCount: partition.stalePaths.length,
-      deliveredCount: partition.live.length,
-      statCount: partition.statCount,
-      samplePaths: partition.stalePaths.slice(0, MAX_LOGGED_DEAD_PATHS).map((stalePath) => toProjectRelativePath(stalePath, cwd)),
-      ...single === undefined ? {} : { scannedAt: single },
-      ...stores.length > 1 ? {
-        scannedAtByStore: Object.fromEntries(stores.map((name) => [name, scannedAtByStore[name] ?? ""]))
-      } : {},
-      ...partition.truncated ? { truncated: true } : {}
-    }
-  });
-}
-function emitStatBudgetRecord(cwd, memo) {
-  if (memo.starved.size === 0)
-    return;
-  const stores = [...memo.starved.keys()].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-  logLatency({
-    type: "phase",
-    phase: "finding_path_stat_budget_exhausted",
-    filePath: cwd,
-    durationMs: 0,
-    metadata: {
-      store: stores.join("+"),
-      byStore: Object.fromEntries(stores.map((name) => [name, memo.starved.get(name) ?? 0])),
-      maxUniquePaths: memo.limit,
-      statCount: memo.facts.size
-    }
-  });
-}
-export function provenanceStamp(provenance) {
-  if (!isWellFormed(provenance))
-    return "session unknown / turn unknown / generation unknown";
-  return `session ${provenance.revision.sessionId} / turn ${provenance.revision.turnIndex} / generation ${provenance.revision.generation}`;
-}

package/extensions/dm-lens/dist/clients/agent-behavior-client.js

@@ -1,94 +0,0 @@
-import { isMutatingToolName } from "./mutating-tool.js";
-import { normalizeMapKey } from "./path-utils.js";
-const READ_OPS = new Set(["read", "bash", "grep", "glob", "find", "rg"]);
-const BLIND_WRITE_WINDOW = 5;
-const THRASH_THRESHOLD = 3;
-const THRASH_TIMEOUT_MS = 30000;
-
-export class AgentBehaviorClient {
-  toolHistory = [];
-  consecutiveCount = 0;
-  lastToolName = null;
-  lastToolFilePath = null;
-  lastToolTimestamp = 0;
-  fileEditCount = new Map;
-  static FILE_EDIT_IDLE_MS = 30 * 60000;
-  recordToolCall(toolName, filePath) {
-    const warnings = [];
-    const now = Date.now();
-    const normalizedPath = filePath ? normalizeMapKey(filePath) : null;
-    if (toolName === this.lastToolName && normalizedPath === this.lastToolFilePath && now - this.lastToolTimestamp < THRASH_TIMEOUT_MS) {
-      this.consecutiveCount++;
-    } else {
-      this.consecutiveCount = 1;
-    }
-    this.lastToolName = toolName;
-    this.lastToolFilePath = normalizedPath;
-    this.lastToolTimestamp = now;
-    if (this.consecutiveCount === THRASH_THRESHOLD) {
-      const fileLabel = filePath ? ` on \`${filePath}\`` : "";
-      warnings.push({
-        type: "thrashing",
-        message: `\uD83D\uDD34 THRASHING — ${THRASH_THRESHOLD} consecutive \`${toolName}\`${fileLabel} calls with no progress. Consider fixing the root cause instead of re-running.`,
-        severity: "error",
-        details: {
-          toolName,
-          filePath,
-          callCount: this.consecutiveCount
-        }
-      });
-    }
-    if (isMutatingToolName(toolName)) {
-      const recentWindow = this.toolHistory.slice(-BLIND_WRITE_WINDOW);
-      const hasRecentRead = recentWindow.some((r) => READ_OPS.has(r.toolName) || isMutatingToolName(r.toolName) && r.filePath !== undefined && normalizedPath !== null && normalizeMapKey(r.filePath) === normalizedPath);
-      if (!hasRecentRead && recentWindow.length > 0) {
-        const writesWithoutRead = recentWindow.filter((r) => isMutatingToolName(r.toolName)).length;
-        if (writesWithoutRead >= 2) {
-          warnings.push({
-            type: "blind-write",
-            message: `⚠ BLIND WRITE — editing \`${filePath ?? "file"}\` without reading in the last ${BLIND_WRITE_WINDOW} tool calls. Read the file first to avoid assumptions.`,
-            severity: "warning",
-            details: {
-              filePath,
-              windowSize: recentWindow.length
-            }
-          });
-        }
-      }
-      if (filePath) {
-        const key = normalizeMapKey(filePath);
-        this.fileEditCount.set(key, {
-          count: (this.fileEditCount.get(key)?.count ?? 0) + 1,
-          lastUsedAt: now
-        });
-        for (const [pathKey, entry] of this.fileEditCount) {
-          if (now - entry.lastUsedAt > AgentBehaviorClient.FILE_EDIT_IDLE_MS) {
-            this.fileEditCount.delete(pathKey);
-          }
-        }
-      }
-    }
-    this.toolHistory.push({ toolName, filePath, timestamp: now });
-    if (this.toolHistory.length > 50) {
-      this.toolHistory = this.toolHistory.slice(-50);
-    }
-    return warnings;
-  }
-  formatWarnings(warnings) {
-    if (warnings.length === 0)
-      return "";
-    return warnings.map((w) => w.message).join(`
-`);
-  }
-  getEditCount(filePath) {
-    return this.fileEditCount.get(normalizeMapKey(filePath))?.count ?? 0;
-  }
-  reset() {
-    this.toolHistory = [];
-    this.consecutiveCount = 0;
-    this.lastToolName = null;
-    this.lastToolTimestamp = 0;
-    this.fileEditCount.clear();
-  }
-}
-export const agentBehaviorClient = new AgentBehaviorClient;

package/extensions/dm-lens/dist/clients/agent-nudge.js

@@ -1,151 +0,0 @@
-import { logLatency } from "./latency-logger.js";
-import { normalizeMapKey } from "./path-utils.js";
-const BUS_FILES_TOUCHED_EVENT = "dmlens:files:touched";
-const MAX_NAMES_SHOWN = 5;
-const _touched = new Map;
-let _relevanceFilteredCount = 0;
-export function _resetAgentNudgeForTests() {
-  _touched.clear();
-  _relevanceFilteredCount = 0;
-  _enabledCache = undefined;
-}
-let _enabledCache;
-export function isAgentNudgeEnabled() {
-  if (_enabledCache === undefined) {
-    _enabledCache = process.env.DM_LENS_AGENT_NUDGE !== "0";
-  }
-  return _enabledCache;
-}
-function isValidPayload(data) {
-  if (!data || typeof data !== "object")
-    return false;
-  const p = data;
-  return p.v === 1 && p.source === "dm-lens" && (p.reason === "autofix" || p.reason === "format") && Array.isArray(p.paths);
-}
-function recordTouchedEvent(payload, getReadGuard) {
-  const readGuard = getReadGuard();
-  if (!readGuard)
-    return;
-  for (const rawPath of payload.paths) {
-    const isRelevant = readGuard.getReadHistory(rawPath).length > 0 || readGuard.getEditHistory(rawPath).length > 0;
-    if (!isRelevant) {
-      _relevanceFilteredCount++;
-      continue;
-    }
-    const mapKey = normalizeMapKey(rawPath);
-    const existing = _touched.get(mapKey);
-    if (existing) {
-      existing.reasons.add(payload.reason);
-      existing.origin = "local";
-      existing.contentDelivered = false;
-    } else {
-      _touched.set(mapKey, {
-        displayPath: rawPath,
-        reasons: new Set([payload.reason]),
-        origin: "local",
-        contentDelivered: false
-      });
-    }
-  }
-}
-export function recordCrossProcessTouches(entries) {
-  if (!isAgentNudgeEnabled())
-    return;
-  for (const entry of entries) {
-    const mapKey = normalizeMapKey(entry.path);
-    const existing = _touched.get(mapKey);
-    if (existing) {
-      existing.reasons.add(entry.reason);
-      existing.contentDelivered = false;
-    } else {
-      _touched.set(mapKey, {
-        displayPath: entry.path,
-        reasons: new Set([entry.reason]),
-        origin: "cross-process",
-        contentDelivered: false
-      });
-    }
-  }
-}
-export function noteAuthoritativeContentAttachment(filePath, attached) {
-  const entry = _touched.get(normalizeMapKey(filePath));
-  if (entry)
-    entry.contentDelivered = attached;
-}
-export function wireAgentNudgeSubscriber(args) {
-  const { events, getReadGuard, dbg } = args;
-  if (!events?.on)
-    return;
-  try {
-    events.on(BUS_FILES_TOUCHED_EVENT, (data) => {
-      if (!isAgentNudgeEnabled())
-        return;
-      if (!isValidPayload(data))
-        return;
-      try {
-        recordTouchedEvent(data, getReadGuard);
-      } catch (err) {
-        dbg?.(`agent-nudge: failed to record touched event: ${err}`);
-      }
-    });
-  } catch (err) {
-    dbg?.(`agent-nudge: subscribe failed (older pi host?): ${err}`);
-  }
-}
-export function consumeAgentNudge(dbg) {
-  const drained = Array.from(_touched.values());
-  _touched.clear();
-  const filesFiltered = _relevanceFilteredCount;
-  _relevanceFilteredCount = 0;
-  if (!isAgentNudgeEnabled())
-    return;
-  if (drained.length === 0)
-    return;
-  try {
-    const entries = drained.filter((e) => !e.contentDelivered);
-    const filesContentDelivered = drained.length - entries.length;
-    const filesTotal = entries.length;
-    const shown = entries.slice(0, MAX_NAMES_SHOWN);
-    const remaining = filesTotal - shown.length;
-    const allReasons = new Set;
-    for (const e of entries) {
-      for (const r of e.reasons)
-        allReasons.add(r);
-    }
-    const verbLabel = allReasons.size > 1 ? "autofixed/reformatted" : allReasons.has("format") ? "reformatted" : "autofixed";
-    const names = shown.map((e) => e.displayPath);
-    const nameList = remaining > 0 ? `${names.join(", ")}, and ${remaining} more` : names.join(", ");
-    const crossProcessCount = entries.filter((e) => e.origin === "cross-process").length;
-    const localCount = filesTotal - crossProcessCount;
-    logLatency({
-      type: "phase",
-      filePath: "<dm-lens>",
-      phase: "agent_nudge",
-      durationMs: 0,
-      metadata: {
-        filesTotal,
-        filesShown: shown.length,
-        filesFiltered,
-        filesContentDelivered,
-        reasonMix: Array.from(allReasons),
-        originLocal: localCount,
-        originCrossProcess: crossProcessCount
-      }
-    });
-    if (filesTotal === 0)
-      return;
-    const attribution = localCount === 0 ? "by an automatic run outside your turn" : crossProcessCount === 0 ? "after your last turn" : `after your last turn (${crossProcessCount} of them by an automatic run outside it)`;
-    const message = `dm-lens: ${filesTotal} file(s) were ${verbLabel} ${attribution}: ${nameList} — working-tree changes to these are expected; re-read before editing.`;
-    return {
-      messages: [
-        {
-          role: "user",
-          content: `[dm-lens automated context — not a user request] ${message}`
-        }
-      ]
-    };
-  } catch (err) {
-    dbg?.(`agent-nudge: consume failed: ${err}`);
-    return;
-  }
-}

package/extensions/dm-lens/dist/clients/analysed-root.js

@@ -1 +0,0 @@
-export {};