@duckmind/dm-linux-x64 0.63.9 → 0.64.2

package/extensions/dm-lens/clients/post-autofix-notice.js

@@ -0,0 +1,19 @@
+export function renderPostAutofixNotice(notice, decision) {
+  const topFiles = notice.changedFiles.slice(0, 8).map((f) => "  - " + f).join(`
+`);
+  const overflow = notice.changedFiles.length > 8 ? `
+  - ... and ` + (notice.changedFiles.length - 8) + " more" : "";
+  const fileList = notice.changedFiles.length ? `
+Modified files:
+` + topFiles + overflow : "";
+  switch (decision) {
+    case "attached":
+      return `⚠️ **The attached full content for ${notice.targetPath} is authoritative after autofix. You MUST re-read any other modified side-effect files before editing them.**${fileList}`;
+    case "size-capped":
+      return `⚠️ **File was modified by auto-format/fix. You MUST re-read ${notice.targetPath} before making any further edits — the authoritative content is too large to attach.**${fileList}`;
+    case "aggregate-budget-degraded":
+      return `⚠️ **File was modified by auto-format/fix. You MUST re-read ${notice.targetPath} before making any further edits — the aggregate authoritative content for this command is too large to attach.**${fileList}`;
+    default:
+      return `⚠️ **File was modified by auto-format/fix. You MUST re-read modified file(s) before making any further edits — the content on disk has changed (whitespace, indentation, quotes, or code). Editing from memory will produce mismatches.**${fileList}`;
+  }
+}

package/extensions/dm-lens/clients/print-mode.js

@@ -0,0 +1,3 @@
+export function isPrintMode(argv = process.argv) {
+  return argv.includes("--print") || argv.includes("-p");
+}

package/extensions/dm-lens/clients/probe-home-state.js

@@ -0,0 +1,62 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { isUnderDir, normalizeFilePath } from "./path-utils.js";
+const RESOLUTION_SLOT = Symbol.for("dm-lens.probe-home-state.resolution");
+export function getProbeHomeResolution() {
+  return globalThis[RESOLUTION_SLOT];
+}
+export function getProbeHomeRedirectEvent() {
+  return getProbeHomeResolution()?.event;
+}
+export function getGlobalDmLensLogDir() {
+  const override = process.env.DM_LENS_HOME?.trim();
+  if (override)
+    return path.resolve(override);
+  return resolveProbeHomeDir() ?? path.join(os.homedir(), ".dm-lens");
+}
+function resolveProbeHomeDir() {
+  const slot = globalThis;
+  const cached = slot[RESOLUTION_SLOT];
+  if (cached)
+    return cached.probeHome;
+  const cwd = process.cwd();
+  const probeHome = computeProbeHomeDir(cwd);
+  slot[RESOLUTION_SLOT] = {
+    probeHome,
+    event: probeHome ? { probeHome, cwd } : undefined
+  };
+  return probeHome;
+}
+export function _resetProbeHomeRedirectStateForTests() {
+  globalThis[RESOLUTION_SLOT] = undefined;
+}
+function computeProbeHomeDir(cwd) {
+  if (process.env.PILENS_PROBE === "1") {
+    return path.join(cwd, ".dm-lens-probe-home");
+  }
+  const worktreeRoot = findAgentWorktreeRoot(cwd);
+  if (worktreeRoot)
+    return path.join(worktreeRoot, ".dm-lens-probe-home");
+  if (isUnderRealDir(cwd, os.tmpdir())) {
+    return path.join(cwd, ".dm-lens-probe-home");
+  }
+  return;
+}
+function findAgentWorktreeRoot(cwd) {
+  const normalized = normalizeFilePath(path.resolve(cwd));
+  const match = /(?:^|\/)\.claude\/worktrees\/[^/]+(?:\/|$)/.exec(normalized);
+  if (!match)
+    return;
+  return normalized.slice(0, match.index + match[0].length).replace(/\/$/, "");
+}
+function isUnderRealDir(child, parent) {
+  return isUnderDir(toRealPath(child), toRealPath(parent));
+}
+function toRealPath(target) {
+  try {
+    return fs.realpathSync.native(target);
+  } catch {
+    return target;
+  }
+}

package/extensions/dm-lens/clients/process-bridge.js

@@ -0,0 +1,20 @@
+export function registerProcessBridge(key, build) {
+  if (key in globalThis)
+    return;
+  const bridge = Object.freeze(build());
+  Object.defineProperty(globalThis, key, {
+    value: bridge,
+    writable: false,
+    configurable: false,
+    enumerable: false
+  });
+}
+export function getProcessBridge(key, version) {
+  const bridge = globalThis[key];
+  if (!bridge || typeof bridge !== "object")
+    return;
+  const candidate = bridge;
+  if (candidate.version !== version)
+    return;
+  return candidate;
+}

package/extensions/dm-lens/clients/process-singletons.js

@@ -0,0 +1,69 @@
+const SINGLETON_HOST_KEY = Symbol.for("dm-lens.process-singletons.v1");
+const SINGLETON_SCHEMA = "dm-lens.process-singletons";
+export const PROCESS_SINGLETON_RESET_KIND = "process-singleton-reset";
+const singletonHost = globalThis;
+function container() {
+  const existing = singletonHost[SINGLETON_HOST_KEY];
+  if (existing instanceof Map)
+    return existing;
+  const fresh = new Map;
+  singletonHost[SINGLETON_HOST_KEY] = fresh;
+  return fresh;
+}
+function isAdoptable(cell, version) {
+  if (!cell || typeof cell !== "object")
+    return false;
+  const candidate = cell;
+  return candidate.schema === SINGLETON_SCHEMA && candidate.version === version && candidate.value !== undefined;
+}
+export const PROCESS_SINGLETON_RESET_LOG_FAMILY = "process-singleton-reset-log";
+const RESET_LOG_FAMILY = PROCESS_SINGLETON_RESET_LOG_FAMILY;
+const RESET_LOG_VERSION = 1;
+const RESET_LOG_CAP = 16;
+function resetLog() {
+  return getProcessSingleton(RESET_LOG_FAMILY, RESET_LOG_VERSION, () => ({
+    entries: []
+  }));
+}
+function recordIncompatibleCell(family, wantedVersion, found) {
+  if (family === RESET_LOG_FAMILY)
+    return;
+  const log = resetLog();
+  if (log.entries.some((entry) => entry.family === family))
+    return;
+  if (log.entries.length >= RESET_LOG_CAP)
+    return;
+  log.entries.push({
+    family,
+    reason: `incompatible process singleton discarded (found schema=${String(found.schema)} ` + `version=${String(found.version)}, this build wants schema=${SINGLETON_SCHEMA} ` + `version=${wantedVersion})`
+  });
+}
+export function getProcessSingletonResets() {
+  return resetLog().entries.map((entry) => ({ ...entry }));
+}
+export function getProcessSingleton(family, version, create, onIncompatible) {
+  const cells = container();
+  const existing = cells.get(family);
+  if (isAdoptable(existing, version))
+    return existing.value;
+  if (existing !== undefined) {
+    recordIncompatibleCell(family, version, existing);
+    onIncompatible?.(existing.value);
+  }
+  const value = create();
+  cells.set(family, { schema: SINGLETON_SCHEMA, version, value });
+  return value;
+}
+export function _resetProcessSingletonsForTests() {
+  singletonHost[SINGLETON_HOST_KEY] = new Map;
+}
+export function _seedProcessSingletonCellForTests(family, cell) {
+  container().set(family, cell);
+}
+const EVALUATION_ORDINAL_FAMILY = "module-evaluation-ordinal";
+const EVALUATION_ORDINAL_VERSION = 1;
+export function nextModuleEvaluationOrdinal() {
+  const state = getProcessSingleton(EVALUATION_ORDINAL_FAMILY, EVALUATION_ORDINAL_VERSION, () => ({ evaluations: 0 }));
+  state.evaluations += 1;
+  return state.evaluations;
+}

package/extensions/dm-lens/clients/process-snapshot.js

@@ -0,0 +1,27 @@
+import {
+  spawnCollectStdoutResult
+} from "./child-unref.js";
+import {
+  buildProcessQuery,
+  parseProcessTable
+} from "../scripts/lib/process-scan.mjs";
+export { windowsExe } from "../scripts/lib/process-scan.mjs";
+export async function queryProcessTable(request, options) {
+  let query;
+  try {
+    query = buildProcessQuery(request.fields, {
+      filter: request.filter,
+      excludeSelfPid: request.excludeSelfPid
+    });
+  } catch {
+    return { rows: [], status: "spawn-error", serverSideFiltered: false };
+  }
+  const result = await spawnCollectStdoutResult(query.command, query.args, { shell: false, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] }, { timeoutMs: options.timeoutMs, onTimeout: options.onTimeout });
+  return {
+    rows: parseProcessTable(result.stdout, query.tabSeparated, query.fields),
+    status: result.status,
+    exitCode: result.exitCode,
+    timeoutKill: result.timeoutKill,
+    serverSideFiltered: query.serverSideFiltered
+  };
+}

package/extensions/dm-lens/clients/project-changes.js

@@ -0,0 +1,112 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getProjectDataDir } from "./file-utils.js";
+import { normalizeMapKey } from "./path-utils.js";
+export function getProjectChangeLogPath(cwd) {
+  return path.join(getProjectDataDir(cwd), "change-log.jsonl");
+}
+function parseChangeLine(line) {
+  try {
+    const parsed = JSON.parse(line);
+    if (typeof parsed.seq !== "number" || typeof parsed.fileSeq !== "number" || typeof parsed.filePath !== "string" || typeof parsed.source !== "string") {
+      return;
+    }
+    return {
+      seq: parsed.seq,
+      timestamp: parsed.timestamp ?? new Date(0).toISOString(),
+      sessionId: parsed.sessionId ?? "unknown",
+      turnIndex: parsed.turnIndex ?? 0,
+      source: parsed.source,
+      filePath: parsed.filePath,
+      fileSeq: parsed.fileSeq,
+      changedRange: parsed.changedRange
+    };
+  } catch {
+    return;
+  }
+}
+export function readProjectChanges(cwd) {
+  const logPath = getProjectChangeLogPath(cwd);
+  try {
+    const content = fs.readFileSync(logPath, "utf-8");
+    return content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map(parseChangeLine).filter((entry) => Boolean(entry));
+  } catch {
+    return [];
+  }
+}
+export async function readProjectChangesAsync(cwd) {
+  const logPath = getProjectChangeLogPath(cwd);
+  try {
+    const content = await fs.promises.readFile(logPath, "utf-8");
+    return content.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map(parseChangeLine).filter((entry) => Boolean(entry));
+  } catch {
+    return [];
+  }
+}
+export function readChangesSince(cwd, seq, maxEntries = 200) {
+  const limit = Math.max(1, maxEntries);
+  return readProjectChanges(cwd).filter((entry) => entry.seq > seq).sort((a, b) => a.seq - b.seq).slice(-limit);
+}
+let _sequenceFoldCountForTests = 0;
+export function getSequenceFoldCountForTests() {
+  return _sequenceFoldCountForTests;
+}
+export function resetSequenceFoldCountForTests() {
+  _sequenceFoldCountForTests = 0;
+}
+function foldEntry(entry, fileSeqByPath) {
+  _sequenceFoldCountForTests++;
+  const key = normalizeMapKey(path.resolve(entry.filePath));
+  fileSeqByPath.set(key, Math.max(fileSeqByPath.get(key) ?? 0, entry.fileSeq));
+}
+function fullReplay(entries) {
+  let projectSeq = 0;
+  const fileSeqByPath = new Map;
+  for (const entry of entries) {
+    projectSeq = Math.max(projectSeq, entry.seq);
+    foldEntry(entry, fileSeqByPath);
+  }
+  return { projectSeq, fileSeqByPath };
+}
+function partialReplay(entries, base) {
+  let logMaxSeq = 0;
+  for (const entry of entries) {
+    if (entry.seq > logMaxSeq)
+      logMaxSeq = entry.seq;
+  }
+  if (base.sinceSeq > logMaxSeq)
+    return null;
+  const fileSeqByPath = new Map(base.fileSeqByPath);
+  let projectSeq = Math.max(0, base.projectSeq);
+  for (const entry of entries) {
+    if (entry.seq <= base.sinceSeq)
+      continue;
+    projectSeq = Math.max(projectSeq, entry.seq);
+    foldEntry(entry, fileSeqByPath);
+  }
+  return { projectSeq, fileSeqByPath };
+}
+export function readLatestProjectSequence(cwd, base) {
+  const entries = readProjectChanges(cwd);
+  if (base) {
+    const partial = partialReplay(entries, base);
+    if (partial)
+      return partial;
+  }
+  return fullReplay(entries);
+}
+export async function readLatestProjectSequenceAsync(cwd, base) {
+  const entries = await readProjectChangesAsync(cwd);
+  if (base) {
+    const partial = partialReplay(entries, base);
+    if (partial)
+      return partial;
+  }
+  return fullReplay(entries);
+}
+export function appendProjectChange(cwd, entry) {
+  const logPath = getProjectChangeLogPath(cwd);
+  fs.mkdirSync(path.dirname(logPath), { recursive: true });
+  fs.appendFileSync(logPath, `${JSON.stringify(entry)}
+`, "utf-8");
+}

package/extensions/dm-lens/clients/project-conventions.js

@@ -0,0 +1,152 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+function readPackageJson(cwd) {
+  const pkgPath = path.join(cwd, "package.json");
+  try {
+    const raw = fs.readFileSync(pkgPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return;
+  }
+}
+function hasDep(pkg, name) {
+  if (!pkg)
+    return false;
+  return Boolean(pkg.dependencies?.[name] ?? pkg.devDependencies?.[name] ?? pkg.peerDependencies?.[name]);
+}
+function fileExists(cwd, ...segments) {
+  try {
+    return fs.existsSync(path.join(cwd, ...segments));
+  } catch {
+    return false;
+  }
+}
+function dirExists(cwd, ...segments) {
+  try {
+    const target = path.join(cwd, ...segments);
+    const stat = fs.statSync(target);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function detectReact(_cwd, pkg) {
+  const signals = [];
+  if (hasDep(pkg, "react"))
+    signals.push("package.json:dependencies.react");
+  if (hasDep(pkg, "react-dom"))
+    signals.push("package.json:dependencies.react-dom");
+  if (hasDep(pkg, "@types/react"))
+    signals.push("package.json:devDependencies.@types/react");
+  if (signals.length === 0)
+    return;
+  const confidence = hasDep(pkg, "react-dom") ? "high" : "medium";
+  return { id: "react", confidence, signals };
+}
+function detectNext(cwd, pkg) {
+  const signals = [];
+  if (hasDep(pkg, "next"))
+    signals.push("package.json:dependencies.next");
+  for (const candidate of [
+    "next.config.js",
+    "next.config.mjs",
+    "next.config.ts"
+  ]) {
+    if (fileExists(cwd, candidate))
+      signals.push(candidate);
+  }
+  if (dirExists(cwd, "src", "pages"))
+    signals.push("src/pages/");
+  else if (dirExists(cwd, "pages"))
+    signals.push("pages/");
+  if (dirExists(cwd, "src", "app"))
+    signals.push("src/app/");
+  else if (dirExists(cwd, "app"))
+    signals.push("app/");
+  if (signals.length === 0)
+    return;
+  const confidence = hasDep(pkg, "next") && signals.some((s) => s.startsWith("next.config.")) ? "high" : hasDep(pkg, "next") ? "medium" : "low";
+  return { id: "next", confidence, signals };
+}
+function detectVite(cwd, pkg) {
+  const signals = [];
+  if (hasDep(pkg, "vite"))
+    signals.push("package.json:devDependencies.vite");
+  for (const candidate of [
+    "vite.config.ts",
+    "vite.config.js",
+    "vite.config.mjs",
+    "vite.config.mts"
+  ]) {
+    if (fileExists(cwd, candidate))
+      signals.push(candidate);
+  }
+  if (signals.length === 0)
+    return;
+  const confidence = hasDep(pkg, "vite") && signals.some((s) => s.startsWith("vite.config.")) ? "high" : "medium";
+  return { id: "vite", confidence, signals };
+}
+function detectVitest(cwd, pkg) {
+  const signals = [];
+  if (hasDep(pkg, "vitest"))
+    signals.push("package.json:devDependencies.vitest");
+  for (const candidate of [
+    "vitest.config.ts",
+    "vitest.config.js",
+    "vitest.config.mjs",
+    "vitest.config.mts"
+  ]) {
+    if (fileExists(cwd, candidate))
+      signals.push(candidate);
+  }
+  if (signals.length === 0)
+    return;
+  const confidence = hasDep(pkg, "vitest") ? "high" : "medium";
+  return { id: "vitest", confidence, signals };
+}
+const AGENT_DOC_CANDIDATES = [
+  "AGENTS.md",
+  "CLAUDE.md",
+  ".cursorrules"
+];
+function summarizeAgentDocs(cwd) {
+  const docs = [];
+  for (const candidate of AGENT_DOC_CANDIDATES) {
+    const abs = path.join(cwd, candidate);
+    try {
+      const raw = fs.readFileSync(abs, "utf-8");
+      const lineCount = raw.split(/\r?\n/).length;
+      docs.push({ filePath: candidate, lineCount });
+    } catch {}
+  }
+  return docs;
+}
+export function detectProjectConventions(cwd) {
+  let cwdExists = false;
+  try {
+    cwdExists = fs.statSync(cwd).isDirectory();
+  } catch {
+    cwdExists = false;
+  }
+  if (!cwdExists) {
+    return { frameworks: [], testRunners: [], buildTools: [], agentDocs: [] };
+  }
+  const pkg = readPackageJson(cwd);
+  const detectors = [detectReact, detectNext, detectVite, detectVitest];
+  const frameworks = [];
+  for (const detector of detectors) {
+    const detection = detector(cwd, pkg);
+    if (detection)
+      frameworks.push(detection);
+  }
+  const testRunners = [];
+  if (frameworks.some((f) => f.id === "vitest"))
+    testRunners.push("vitest");
+  const buildTools = [];
+  if (frameworks.some((f) => f.id === "vite"))
+    buildTools.push("vite");
+  if (frameworks.some((f) => f.id === "next"))
+    buildTools.push("next");
+  const agentDocs = summarizeAgentDocs(cwd);
+  return { frameworks, testRunners, buildTools, agentDocs };
+}

package/extensions/dm-lens/clients/project-diagnostics/cache.js

@@ -0,0 +1,77 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getProjectDataDir } from "../file-utils.js";
+import { writeFileAtomic } from "../atomic-write.js";
+import { readJsonCache } from "../json-cache-read.js";
+import { freshnessFromMtime } from "../freshness.js";
+export const PROJECT_DIAGNOSTICS_CACHE_VERSION = 2;
+const SNAPSHOT_CACHE_FILE = "project-diagnostics.json";
+const DELTA_CACHE_FILE = "project-diagnostics-delta.json";
+function cachePath(cwd, fileName) {
+  return path.join(getProjectDataDir(cwd), "cache", fileName);
+}
+export function loadProjectDiagnosticsSnapshot(cwd) {
+  return readJsonCache(cachePath(cwd, SNAPSHOT_CACHE_FILE), (parsed) => {
+    if (!parsed || typeof parsed !== "object")
+      return;
+    const snapshot = parsed;
+    if (snapshot.version !== PROJECT_DIAGNOSTICS_CACHE_VERSION)
+      return;
+    if (!Array.isArray(snapshot.diagnostics))
+      return;
+    return snapshot;
+  });
+}
+export function saveProjectDiagnosticsSnapshot(cwd, snapshot) {
+  const filePath = cachePath(cwd, SNAPSHOT_CACHE_FILE);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  writeFileAtomic(filePath, JSON.stringify(snapshot, null, 2));
+}
+export function loadProjectDiagnosticsDeltaReport(cwd) {
+  return readJsonCache(cachePath(cwd, DELTA_CACHE_FILE), (parsed) => {
+    if (!parsed || typeof parsed !== "object")
+      return;
+    const report = parsed;
+    if (report.version !== PROJECT_DIAGNOSTICS_CACHE_VERSION)
+      return;
+    if (!Array.isArray(report.diagnostics))
+      return;
+    return report;
+  });
+}
+export function writeProjectDiagnosticsDeltaReport(cwd, report) {
+  const filePath = cachePath(cwd, DELTA_CACHE_FILE);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  writeFileAtomic(filePath, JSON.stringify(report, null, 2));
+}
+export function reconcileProjectDiagnosticsSnapshot(snapshot) {
+  const scannedAtMs = Date.parse(snapshot.scannedAt);
+  if (!Number.isFinite(scannedAtMs))
+    return { snapshot, staleDropped: 0 };
+  const staleByFile = new Map;
+  const isStale = (filePath) => {
+    const cached = staleByFile.get(filePath);
+    if (cached !== undefined)
+      return cached;
+    let stale;
+    let mtimeMs;
+    try {
+      mtimeMs = fs.statSync(filePath).mtimeMs;
+    } catch {
+      mtimeMs = undefined;
+    }
+    const verdict = freshnessFromMtime({
+      mtimeMs,
+      referenceMs: scannedAtMs
+    });
+    stale = verdict.verdict !== "fresh";
+    staleByFile.set(filePath, stale);
+    return stale;
+  };
+  const kept = snapshot.diagnostics.filter((d) => !isStale(d.filePath));
+  if (kept.length === snapshot.diagnostics.length) {
+    return { snapshot, staleDropped: 0 };
+  }
+  const staleDropped = [...staleByFile.values()].filter(Boolean).length;
+  return { snapshot: { ...snapshot, diagnostics: kept }, staleDropped };
+}

package/extensions/dm-lens/clients/project-diagnostics/extractors.js

@@ -0,0 +1,53 @@
+const WARM_TRIGGER = {
+  knip: "runs at session-start",
+  jscpd: "runs at session-start",
+  madge: "runs at session-start",
+  gitleaks: "runs at session-start (config opt-in), or on any git repo via mode=full (#608)",
+  govulncheck: "runs at session-start (Go projects only)",
+  opengrep: "runs at session-start",
+  trivy: "runs at session-start",
+  "dead-code": "runs at session-start (Python projects only)",
+  "test-runner": "fires per-edit at turn_end (only after a source file with a discoverable test companion is edited)"
+};
+export function warmTriggerFor(analyzerId) {
+  return WARM_TRIGGER[analyzerId] ?? "runs at session-start";
+}
+export function formatNotRunEntry(analyzerId, coldReasons) {
+  const reason = coldReasons?.[analyzerId];
+  return reason ? `${analyzerId} — not run (${reason})` : `${analyzerId} — not run (${warmTriggerFor(analyzerId)})`;
+}
+export function formatCacheAge(ms) {
+  if (!Number.isFinite(ms))
+    return "age unknown";
+  if (ms < 0)
+    return "0m";
+  const totalMinutes = Math.round(ms / 60000);
+  if (totalMinutes < 1)
+    return "under 1m";
+  if (totalMinutes < 60)
+    return `${totalMinutes}m`;
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  return minutes > 0 ? `${hours}h${minutes}m` : `${hours}h`;
+}
+export function formatCacheAgeOld(ms) {
+  const age = formatCacheAge(ms);
+  return Number.isFinite(ms) ? `${age} old` : age;
+}
+export function reasonFromAvailabilityVerdict(tool, verdict) {
+  if (!verdict || verdict.outcome === null)
+    return `${tool} binary unavailable`;
+  const { outcome, cause } = verdict;
+  if (outcome === "transient") {
+    if (cause === "install-retry-exhausted") {
+      return `${tool} install kept timing out and hit its retry ceiling this session (not reported missing)`;
+    }
+    const remainingMs = verdict.retryAtMs - Date.now();
+    const remainingS = remainingMs > 0 ? Math.round(remainingMs / 1000) : 0;
+    return `${tool} availability probe — retry cooldown (${remainingS}s), not a missing install`;
+  }
+  if (outcome === "non-installable") {
+    return `${tool} unavailable on this host (non-installable)`;
+  }
+  return `${tool} binary unavailable`;
+}