@duckmind/dm-linux-x64 0.65.5 → 0.65.6

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

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

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

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

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