@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/dist/clients/config-resolve.js

@@ -0,0 +1,359 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { DEPRECATED_CONFIG_SURFACES } from "./config-diagnostic-codes.js";
+import { CANONICAL_GLOBAL_CONFIG_FILE, CANONICAL_PROJECT_CONFIG_FILE, GLOBAL_CONFIG_LOCATIONS, isResolvedGlobalConfigPath, LEGACY_ROOT_LSP_KEYS, LSP_NAMESPACE_KEY, PROJECT_CONFIG_LOCATIONS, configSearchDirs } from "./config-locations.js";
+import { resolveConfig } from "./config-core/resolve.js";
+import { finalizeRecords, migrationSubject } from "./config-core/records.js";
+import { SOURCE_TIERS } from "./config-core/provenance.js";
+import { DM_LENS_CONFIG_SCHEMA } from "./config-schema.js";
+import { normalizeParseErrorReason, warnIgnoredConfigOnce } from "./config-warn.js";
+import { homeRelativePath } from "./path-utils.js";
+export function readConfigDocument(file) {
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf-8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { status: "missing" };
+    }
+    return { status: "error", error };
+  }
+  try {
+    return { status: "ok", value: JSON.parse(text) };
+  } catch (error) {
+    return { status: "error", error, sourceText: text };
+  }
+}
+function canonicalGlobalFile(options) {
+  if (options.globalConfigPath !== undefined)
+    return options.globalConfigPath;
+  return options.globalDir === undefined ? undefined : path.join(options.globalDir, CANONICAL_GLOBAL_CONFIG_FILE);
+}
+function collectDocuments(dir, locations, tier, onReadError) {
+  const documents = [];
+  for (const location of locations) {
+    const file = path.join(dir, location.relativePath);
+    if (tier !== "global" && isResolvedGlobalConfigPath(file))
+      continue;
+    const outcome = readConfigDocument(file);
+    if (outcome.status === "missing")
+      continue;
+    if (outcome.status === "error") {
+      onReadError?.({
+        file,
+        location,
+        tier,
+        error: outcome.error,
+        sourceText: outcome.sourceText
+      });
+      continue;
+    }
+    documents.push({ tier, file, location, value: outcome.value });
+  }
+  return documents;
+}
+function collectDmLensConfigDocuments(options) {
+  const documents = [];
+  const { globalDir, onReadError } = options;
+  const globalConfigPath = canonicalGlobalFile(options);
+  if (globalDir !== undefined || globalConfigPath !== undefined) {
+    for (const location of GLOBAL_CONFIG_LOCATIONS) {
+      const file = location.relativePath === CANONICAL_GLOBAL_CONFIG_FILE ? globalConfigPath : globalDir === undefined ? undefined : path.join(globalDir, location.relativePath);
+      if (file === undefined)
+        continue;
+      const outcome = readConfigDocument(file);
+      if (outcome.status === "missing")
+        continue;
+      if (outcome.status === "error") {
+        onReadError?.({
+          file,
+          location,
+          tier: "global",
+          error: outcome.error,
+          sourceText: outcome.sourceText
+        });
+        continue;
+      }
+      documents.push({ tier: "global", file, location, value: outcome.value });
+    }
+  }
+  if (options.cwd !== undefined) {
+    const dirs = configSearchDirs(options.cwd, options.homeDir ?? os.homedir()).reverse();
+    const bearing = dirs.map((dir) => ({
+      dir,
+      found: collectDocuments(dir, PROJECT_CONFIG_LOCATIONS, "project", onReadError)
+    })).filter((entry) => entry.found.length > 0);
+    bearing.forEach((entry, index) => {
+      const tier = index === 0 ? "project" : "nested-project";
+      for (const document of entry.found)
+        documents.push({ ...document, tier });
+    });
+  }
+  return documents;
+}
+function emptyTierCounts() {
+  return Object.fromEntries(SOURCE_TIERS.map((tier) => [tier, 0]));
+}
+export function summarizeConfigResolution(resolution, homeDir) {
+  const countsByTier = emptyTierCounts();
+  for (const entry of resolution.provenance.values()) {
+    countsByTier[entry.tier] += 1;
+  }
+  return {
+    documents: resolution.documents.map((document) => ({
+      tier: document.tier,
+      file: homeRelativePath(document.file, homeDir),
+      legacy: document.location.legacy
+    })),
+    countsByTier,
+    recordCount: resolution.records.length
+  };
+}
+export function resolveDmLensConfig(options) {
+  const documents = collectDmLensConfigDocuments(options);
+  const sources = configSources(documents);
+  const resolution = resolveConfig({
+    sources,
+    schema: DM_LENS_CONFIG_SCHEMA
+  });
+  return {
+    value: resolution.resolved.value ?? {},
+    provenance: resolution.resolved.provenance,
+    records: finalizeRecords([
+      ...resolution.records,
+      ...deprecationRecords(documents, options.homeDir ?? os.homedir(), canonicalGlobalFile(options))
+    ], documentAnchor(documents), resolution.droppedRecordCount),
+    documents
+  };
+}
+export function resolveOneDmLensConfigDocument(document, homeDir = os.homedir()) {
+  const resolution = resolveConfig({
+    sources: [
+      { tier: document.tier, file: document.file, value: document.value }
+    ],
+    schema: DM_LENS_CONFIG_SCHEMA
+  });
+  return {
+    value: resolution.resolved.value ?? {},
+    records: finalizeRecords([...resolution.records, ...deprecationRecords([document], homeDir)], documentAnchor([document]), resolution.droppedRecordCount)
+  };
+}
+function documentAnchor(documents) {
+  const last = documents[documents.length - 1];
+  return last === undefined ? undefined : { file: last.file, tier: last.tier };
+}
+export function projectLocationFor(file) {
+  const base = path.basename(file);
+  return PROJECT_CONFIG_LOCATIONS.find((candidate) => path.posix.basename(candidate.relativePath) === base) ?? PROJECT_CONFIG_LOCATIONS[PROJECT_CONFIG_LOCATIONS.length - 1];
+}
+const WINDOW_BY_SURFACE = new Map(DEPRECATED_CONFIG_SURFACES.map((row) => [row.surface, row]));
+function windowSuffix(surface) {
+  const row = surface === undefined ? undefined : WINDOW_BY_SURFACE.get(surface);
+  return row ? ` (deprecated since ${row.deprecatedSince}; read for the last time before ${row.removeNotBefore})` : "";
+}
+function canonicalDestination(document, homeDir, globalFile) {
+  if (document.tier === "global") {
+    return homeRelativePath(globalFile ?? path.join(path.dirname(document.file), CANONICAL_GLOBAL_CONFIG_FILE), homeDir);
+  }
+  return CANONICAL_PROJECT_CONFIG_FILE;
+}
+function lspNamespaceKeyFor(document, key) {
+  if (key === LSP_NAMESPACE_KEY)
+    return;
+  if (document.location.lspScoped) {
+    return recognizedKeysFor(document.location).has(key) ? key : undefined;
+  }
+  return LEGACY_ROOT_LSP_KEYS.includes(key) ? key : undefined;
+}
+function assignRaw(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+}
+function configSources(documents) {
+  const sources = [];
+  for (const document of documents) {
+    const value = document.value;
+    const namespaced = {};
+    const rest = {};
+    for (const key of topLevelKeys(value)) {
+      const entry = value[key];
+      const target = lspNamespaceKeyFor(document, key);
+      if (target === undefined)
+        assignRaw(rest, key, entry);
+      else
+        assignRaw(namespaced, target, entry);
+    }
+    const base = { tier: document.tier, file: document.file };
+    if (Object.keys(namespaced).length === 0) {
+      sources.push({ ...base, value });
+      continue;
+    }
+    sources.push({ ...base, value: { [LSP_NAMESPACE_KEY]: namespaced } });
+    sources.push({ ...base, value: rest });
+  }
+  return sources;
+}
+function canonicalKeyFor(document, key) {
+  const namespaced = lspNamespaceKeyFor(document, key);
+  return namespaced === undefined ? key : `${LSP_NAMESPACE_KEY}.${namespaced}`;
+}
+function topLevelKeys(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? Object.keys(value) : [];
+}
+function schemaPropertyKeys(node) {
+  const properties = node?.properties;
+  return properties !== null && typeof properties === "object" && !Array.isArray(properties) ? Object.keys(properties) : [];
+}
+const CANONICAL_TOP_LEVEL_KEYS = new Set(schemaPropertyKeys(DM_LENS_CONFIG_SCHEMA));
+const LSP_DOCUMENT_KEYS = new Set(schemaPropertyKeys(DM_LENS_CONFIG_SCHEMA.properties?.[LSP_NAMESPACE_KEY]));
+function recognizedKeysFor(location) {
+  return location.lspScoped ? LSP_DOCUMENT_KEYS : CANONICAL_TOP_LEVEL_KEYS;
+}
+export function deprecationRecords(documents, homeDir, globalFile) {
+  const records = [];
+  for (const document of documents) {
+    if (document.location.legacy) {
+      const destination = canonicalDestination(document, homeDir, globalFile);
+      const recognized = recognizedKeysFor(document.location);
+      let unrecognized = 0;
+      for (const key of topLevelKeys(document.value)) {
+        if (!recognized.has(key)) {
+          unrecognized += 1;
+          continue;
+        }
+        const canonicalKey = canonicalKeyFor(document, key);
+        records.push(record({
+          code: "PILENS_CFG_0003",
+          file: document.file,
+          key,
+          canonicalKey,
+          tier: document.tier,
+          reason: `move "${key}" to ${destination}` + (canonicalKey === key ? "" : ` under "${canonicalKey}"`) + windowSuffix(document.location.surface)
+        }));
+      }
+      if (unrecognized > 0) {
+        const plural = unrecognized === 1 ? "it was" : "they were";
+        records.push({
+          code: "PILENS_CFG_0003",
+          file: document.file,
+          key: "",
+          ...document.location.lspScoped ? { canonicalKey: LSP_NAMESPACE_KEY } : {},
+          subject: migrationSubject(document.file, ""),
+          tier: document.tier,
+          reason: `this file is at a deprecated location; move it to ${destination}. ` + (unrecognized === 1 ? "1 of its top-level keys is not a recognized dm-lens setting" : `${unrecognized} of its top-level keys are not recognized dm-lens settings`) + `, and ${plural} not migrated${windowSuffix(document.location.surface)}`
+        });
+      }
+      continue;
+    }
+    for (const key of topLevelKeys(document.value)) {
+      if (!LEGACY_ROOT_LSP_KEYS.includes(key))
+        continue;
+      const canonicalKey = `${LSP_NAMESPACE_KEY}.${key}`;
+      records.push(record({
+        code: "PILENS_CFG_0002",
+        file: document.file,
+        key,
+        canonicalKey,
+        tier: document.tier,
+        reason: `move "${key}" to "${canonicalKey}" in the same file${windowSuffix(key)}`
+      }));
+    }
+  }
+  return records;
+}
+function record(input) {
+  return {
+    code: input.code,
+    file: input.file,
+    key: input.key,
+    canonicalKey: input.canonicalKey,
+    subject: migrationSubject(input.file, input.key),
+    reason: input.reason,
+    tier: input.tier
+  };
+}
+function configRecordOwner(record) {
+  const key = record.canonicalKey ?? record.key;
+  if (key.length === 0)
+    return;
+  const head = (key.startsWith("/") ? key.slice(1) : key).split(/[./]/)[0] ?? "";
+  if (head.length === 0)
+    return;
+  return head === LSP_NAMESPACE_KEY || LEGACY_ROOT_LSP_KEYS.includes(head) ? "lsp" : "dm-lens";
+}
+function piLensSubsystemFor(tier) {
+  if (tier === "global")
+    return "lens-config";
+  if (tier === "project" || tier === "nested-project") {
+    return "project-lens-config";
+  }
+  return;
+}
+function configRecordSubsystems(record) {
+  const owner = configRecordOwner(record);
+  const piLens = piLensSubsystemFor(record.tier);
+  const piLensSubsystems = piLens ? [piLens] : ["lens-config", "project-lens-config"];
+  if (owner === "lsp")
+    return ["lsp-config"];
+  if (owner === "dm-lens")
+    return piLensSubsystems;
+  if (piLens)
+    return [piLens];
+  return ["lsp-config", ...piLensSubsystems];
+}
+function configFileSubsystem(location, tier) {
+  if (location.lspScoped)
+    return "lsp-config";
+  return tier === "global" ? "lens-config" : "project-lens-config";
+}
+export function reportConfigReadFailure(failure) {
+  warnIgnoredConfigOnce({
+    subsystem: configFileSubsystem(failure.location, failure.tier),
+    file: failure.file,
+    reason: { parseError: failure.error, sourceText: failure.sourceText }
+  });
+}
+export function reportDmLensConfigRecords(records) {
+  for (const record of records) {
+    for (const subsystem of configRecordSubsystems(record)) {
+      warnIgnoredConfigOnce({
+        subsystem,
+        file: record.file,
+        key: record.key.length > 0 ? record.key : undefined,
+        reason: record.reason,
+        code: record.code
+      });
+    }
+  }
+}
+export function ignoredRecordCollector(configPath, tier) {
+  const noted = [];
+  const note = (reason, code = "PILENS_CFG_0001") => {
+    let notedRecord = {
+      code: "PILENS_CFG_0001",
+      file: configPath,
+      key: "",
+      subject: migrationSubject(configPath, ""),
+      reason: typeof reason === "string" ? reason : normalizeParseErrorReason(reason.parseError, {
+        sourceText: reason.sourceText
+      }),
+      tier
+    };
+    if (code !== "PILENS_CFG_0001")
+      notedRecord.code = code;
+    noted.push(notedRecord);
+  };
+  return {
+    note,
+    records: () => finalizeRecords(noted, { file: configPath, tier })
+  };
+}
+export function lspSectionOf(value) {
+  const namespace = value[LSP_NAMESPACE_KEY];
+  return namespace && typeof namespace === "object" && !Array.isArray(namespace) ? namespace : {};
+}

package/extensions/dm-lens/dist/clients/config-schema.js

@@ -0,0 +1,128 @@
+import { CONFIG_SCHEMA_ANCHOR_KEY, CONFIG_SCHEMA_ID, STABILITY_TIER_KEY } from "./config-diagnostic-codes.js";
+import { LEGACY_ROOT_LSP_KEYS, LSP_NAMESPACE_KEY } from "./config-locations.js";
+import { DENY_KEY } from "./config-core/schema.js";
+import { flagConfigSectionKeys, GLOBAL_NON_FLAG_CONFIG_SECTIONS, LENS_FLAGS, PROJECT_FOREIGN_CONFIG_NAMESPACES, PROJECT_NON_FLAG_CONFIG_SECTIONS } from "./lens-flag-registry.js";
+import { LENS_TOOL_NAMES } from "./tool-config.js";
+const CONFIG_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+function opaque(tier) {
+  return { [STABILITY_TIER_KEY]: tier };
+}
+const LSP_KEY_TYPES = {
+  servers: "object",
+  serverOverrides: "object",
+  disabledServers: "array",
+  warmFiles: "array"
+};
+
+export { LSP_KEY_TYPES };
+const LSP_KEY_DENY = {
+  disabledServers: "array-union"
+};
+function denyAnnotation(key) {
+  const policy = LSP_KEY_DENY[key];
+  return policy === undefined ? {} : { [DENY_KEY]: policy };
+}
+function lspNamespace() {
+  const properties = {
+    enabled: { [STABILITY_TIER_KEY]: "stable" }
+  };
+  for (const key of LEGACY_ROOT_LSP_KEYS) {
+    const declared = LSP_KEY_TYPES[key];
+    properties[key] = {
+      ...declared ? { type: declared } : {},
+      [STABILITY_TIER_KEY]: "experimental",
+      ...declared === "object" ? { additionalProperties: true } : {},
+      ...denyAnnotation(key)
+    };
+  }
+  return {
+    type: "object",
+    additionalProperties: true,
+    [STABILITY_TIER_KEY]: "stable",
+    properties
+  };
+}
+function buildConfigSchema() {
+  const properties = {};
+  for (const key of [
+    ...flagConfigSectionKeys(LENS_FLAGS),
+    ...GLOBAL_NON_FLAG_CONFIG_SECTIONS,
+    ...PROJECT_NON_FLAG_CONFIG_SECTIONS
+  ]) {
+    properties[key] = opaque("stable");
+  }
+  properties.tools = {
+    type: "object",
+    additionalProperties: true,
+    properties: Object.fromEntries(LENS_TOOL_NAMES.map((name) => [
+      name,
+      {
+        type: "object",
+        additionalProperties: true,
+        properties: {
+          enabled: { type: "boolean", [STABILITY_TIER_KEY]: "experimental" }
+        },
+        [STABILITY_TIER_KEY]: "experimental"
+      }
+    ])),
+    [STABILITY_TIER_KEY]: "stable"
+  };
+  for (const key of PROJECT_FOREIGN_CONFIG_NAMESPACES) {
+    properties[key] ??= opaque("experimental");
+  }
+  for (const key of [
+    "knip",
+    "jscpd",
+    "madge",
+    "gitleaks",
+    "govulncheck",
+    "deadCode",
+    "complexity"
+  ]) {
+    properties[key] = {
+      type: "object",
+      additionalProperties: true,
+      properties: {
+        enabled: { type: "boolean", [STABILITY_TIER_KEY]: "experimental" }
+      },
+      [STABILITY_TIER_KEY]: "stable"
+    };
+  }
+  properties.startup = {
+    type: "object",
+    additionalProperties: true,
+    properties: {
+      mode: {
+        type: "string",
+        enum: ["quick", "full", "minimal"],
+        [STABILITY_TIER_KEY]: "experimental"
+      },
+      scans: {
+        type: "object",
+        additionalProperties: true,
+        properties: {
+          enabled: { type: "boolean", [STABILITY_TIER_KEY]: "experimental" }
+        },
+        [STABILITY_TIER_KEY]: "experimental"
+      }
+    },
+    [STABILITY_TIER_KEY]: "stable"
+  };
+  for (const key of LEGACY_ROOT_LSP_KEYS) {
+    properties[key] = opaque("experimental");
+  }
+  properties[LSP_NAMESPACE_KEY] = lspNamespace();
+  properties[CONFIG_SCHEMA_ANCHOR_KEY] = {
+    type: "string",
+    description: "Identity anchor naming the schema version this config was written against.",
+    [STABILITY_TIER_KEY]: "stable"
+  };
+  return {
+    $schema: CONFIG_SCHEMA_DIALECT,
+    $id: CONFIG_SCHEMA_ID,
+    type: "object",
+    additionalProperties: true,
+    properties
+  };
+}
+export const DM_LENS_CONFIG_SCHEMA = buildConfigSchema();

package/extensions/dm-lens/dist/clients/config-warn.js

@@ -0,0 +1,146 @@
+import { DEPRECATED_CONFIG_SURFACES, withConfigDiagnosticCode } from "./config-diagnostic-codes.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { errorClassName } from "./error-class.js";
+import { logExtension } from "./extension-log.js";
+import { redactSecrets } from "./redact/secrets.js";
+import { notifyUserDegradation } from "./user-notify.js";
+const SUBSYSTEM_CONFIG_LABEL = {
+  "lsp-config": "LSP config",
+  "lens-config": "global config",
+  "project-lens-config": "project config"
+};
+const IGNORED_CONFIG_CODE = "PILENS_CFG_0001";
+const IGNORED_CONFIG_KIND = "config-ignored";
+const DEPRECATED_CONFIG_KIND = "config-deprecated";
+const SUPPRESSED_NOTICE_CODE = "PILENS_CFG_0007";
+const SUPPRESSED_NOTICE_KIND = "config-notice-suppressed";
+const DEPRECATION_NOUN_BY_CODE = new Map(DEPRECATED_CONFIG_SURFACES.map((row) => [
+  row.code,
+  row.kind === "file" ? "location" : "key"
+]));
+const warnedIgnoredConfigs = new Set;
+const JSON_PARSE_POSITION = /at position (\d+) \(line (\d+) column (\d+)\)/;
+function isSyntaxError(error) {
+  return typeof error === "object" && error !== null && error.name === "SyntaxError" && typeof error.message === "string";
+}
+function lineColAt(sourceText, offset) {
+  let line = 1;
+  let lastNewline = -1;
+  for (let i = 0;i < offset; i++) {
+    if (sourceText[i] === `
+`) {
+      line++;
+      lastNewline = i;
+    }
+  }
+  return { line, col: offset - lastNewline };
+}
+function parseUnexpectedTokenMessage(message) {
+  const prefix = "Unexpected token '";
+  if (!message.startsWith(prefix))
+    return;
+  const closeIdx = message.indexOf("', ", prefix.length);
+  const token = message.slice(prefix.length, closeIdx);
+  let rest = message.slice(closeIdx + 3);
+  if (rest.startsWith("..."))
+    rest = rest.slice(3);
+  if (!rest.startsWith('"'))
+    return;
+  rest = rest.slice(1);
+  const truncatedSuffix = '"... is not valid JSON';
+  const plainSuffix = '" is not valid JSON';
+  const snippet = rest.endsWith(truncatedSuffix) ? rest.slice(0, -truncatedSuffix.length) : rest.endsWith(plainSuffix) ? rest.slice(0, -plainSuffix.length) : undefined;
+  return snippet === undefined ? undefined : { token, snippet };
+}
+function locateSyntaxErrorOffset(message, sourceText) {
+  const stated = JSON_PARSE_POSITION.exec(message);
+  if (stated)
+    return Number(stated[1]);
+  const parsed = parseUnexpectedTokenMessage(message);
+  if (!parsed)
+    return;
+  const { token, snippet } = parsed;
+  const snippetAt = sourceText.indexOf(snippet);
+  if (snippetAt === -1 || sourceText.indexOf(snippet, snippetAt + 1) !== -1) {
+    return;
+  }
+  const tokenAt = snippet.indexOf(token);
+  const onlyTokenOccurrence = tokenAt !== -1 && snippet.indexOf(token, tokenAt + 1) === -1;
+  return snippetAt + (onlyTokenOccurrence ? tokenAt : 0);
+}
+export function normalizeParseErrorReason(error, options = {}) {
+  if (options.classOnly) {
+    return errorClassName(error);
+  }
+  if (isSyntaxError(error)) {
+    if (options.sourceText !== undefined) {
+      const offset = locateSyntaxErrorOffset(error.message, options.sourceText);
+      if (offset !== undefined) {
+        const { line, col } = lineColAt(options.sourceText, offset);
+        return `${error.name} at line ${line} col ${col}`;
+      }
+      return error.name;
+    }
+    const match = JSON_PARSE_POSITION.exec(error.message);
+    return match ? `${error.name} at line ${match[2]} col ${match[3]}` : error.name;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return redactSecrets(message);
+}
+function degradationKindFor(suppressedNotice, deprecationNoun) {
+  if (suppressedNotice)
+    return SUPPRESSED_NOTICE_KIND;
+  return deprecationNoun ? DEPRECATED_CONFIG_KIND : IGNORED_CONFIG_KIND;
+}
+function noticeMessage(options) {
+  const label = SUBSYSTEM_CONFIG_LABEL[options.subsystem];
+  if (options.suppressedNotice) {
+    return `${label} notices for ${options.file} were summarised: ${options.reason}`;
+  }
+  return options.deprecationNoun ? `deprecated ${label} ${options.deprecationNoun} in ${options.file}: ${options.reason}` : `ignoring invalid ${label} ${options.file}: ${options.reason}`;
+}
+export function warnIgnoredConfigOnce(options) {
+  const { subsystem, file, key } = options;
+  const code = options.code ?? IGNORED_CONFIG_CODE;
+  const reason = redactSecrets(typeof options.reason === "string" ? options.reason : normalizeParseErrorReason(options.reason.parseError, {
+    sourceText: options.reason.sourceText
+  }));
+  const suppressedNotice = code === SUPPRESSED_NOTICE_CODE;
+  const deprecationNoun = suppressedNotice ? undefined : DEPRECATION_NOUN_BY_CODE.get(code);
+  recordDegradationOnce({
+    kind: degradationKindFor(suppressedNotice, deprecationNoun),
+    subject: key ? `${file}\x00${key}` : file,
+    reason,
+    metadata: { subsystem, configPath: file },
+    code
+  });
+  const latchKey = `${subsystem}\x00${file}\x00${key ?? ""}\x00${reason}`;
+  if (warnedIgnoredConfigs.has(latchKey))
+    return;
+  warnedIgnoredConfigs.add(latchKey);
+  const message = noticeMessage({
+    subsystem,
+    file,
+    reason,
+    suppressedNotice,
+    deprecationNoun
+  });
+  logExtension({
+    subsystem,
+    level: "warn",
+    message: withConfigDiagnosticCode(message, code),
+    metadata: { configPath: file, reason, code, ...key ? { key } : {} }
+  });
+  notifyUserDegradation(`dm-lens: ${message}`, "warning", { code });
+}
+export function resetIgnoredConfigWarnCache(subsystem) {
+  if (!subsystem) {
+    warnedIgnoredConfigs.clear();
+    return;
+  }
+  for (const latchKey of warnedIgnoredConfigs) {
+    if (latchKey.startsWith(`${subsystem}\x00`)) {
+      warnedIgnoredConfigs.delete(latchKey);
+    }
+  }
+}

package/extensions/dm-lens/dist/clients/console-guard-install.js

@@ -0,0 +1,4 @@
+import { DM_LENS_EVAL_STARTED_MS } from "./eval-timestamp.js";
+import { installConsoleGuard, openModuleLoadConsoleWindow } from "./extension-log.js";
+installConsoleGuard();
+openModuleLoadConsoleWindow();

package/extensions/dm-lens/dist/clients/cooperative-budget.js

@@ -0,0 +1,36 @@
+export function createDeadline(budgetMs) {
+  const boundedBudget = Math.max(0, budgetMs);
+  let startedAt = performance.now();
+  return {
+    expired: () => performance.now() - startedAt >= boundedBudget,
+    reset: () => {
+      startedAt = performance.now();
+    }
+  };
+}
+export async function yieldIfOverBudget(deadline) {
+  if (!deadline.expired())
+    return false;
+  await new Promise((resolve) => setImmediate(resolve));
+  deadline.reset();
+  return true;
+}
+export async function forEachCooperatively(items, fn, options) {
+  const deadline = createDeadline(options.budgetMs);
+  const assertContinuing = () => {
+    if (options.shouldContinue?.() === false) {
+      throw new Error(options.abortMessage ?? "cooperative work superseded");
+    }
+  };
+  let index = 0;
+  for (const item of items) {
+    assertContinuing();
+    const result = fn(item, index++);
+    if (result !== undefined && typeof result.then === "function") {
+      await result;
+    }
+    if (deadline.expired() && await yieldIfOverBudget(deadline)) {
+      assertContinuing();
+    }
+  }
+}