@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-lens/dist/clients/sgconfig.js

@@ -1,280 +0,0 @@
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { recordDegradationOnce } from "./degradation-ledger.js";
-import { load as loadYaml } from "./deps/js-yaml.js";
-import { resolvePackagePath } from "./package-root.js";
-import { findLocalToolConfig } from "./path-utils.js";
-const SGCONFIG_NAMES = ["sgconfig.yml", "sgconfig.yaml"];
-export function findLocalSgconfig(startDir) {
-  return findLocalToolConfig(startDir, SGCONFIG_NAMES);
-}
-function canonicalDir(dir) {
-  try {
-    return fs.realpathSync.native(dir);
-  } catch {
-    return path.resolve(dir);
-  }
-}
-export function getAstGrepRuleSources(projectRoot = process.cwd()) {
-  const root = path.resolve(projectRoot || process.cwd());
-  const packageRoot = resolvePackagePath(import.meta.url);
-  const candidates = [];
-  if (canonicalDir(root) !== canonicalDir(packageRoot)) {
-    candidates.push({
-      dir: path.join(root, "rules", "ast-grep-rules", "rules"),
-      origin: "project",
-      tier: "primary"
-    }, {
-      dir: path.join(root, "rules", "ast-grep-rules", "coderabbit", "rules"),
-      origin: "project",
-      tier: "secondary"
-    });
-  }
-  candidates.push({
-    dir: path.join(packageRoot, "rules", "ast-grep-rules", "rules"),
-    origin: "bundled",
-    tier: "primary"
-  }, {
-    dir: path.join(packageRoot, "rules", "ast-grep-rules", "coderabbit", "rules"),
-    origin: "bundled",
-    tier: "secondary"
-  });
-  const seen = new Set;
-  return candidates.filter((source) => {
-    if (!fs.existsSync(source.dir))
-      return false;
-    const key = canonicalDir(source.dir);
-    if (seen.has(key))
-      return false;
-    seen.add(key);
-    return true;
-  });
-}
-function findYamlFiles(dir) {
-  const files = [];
-  let entries;
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
-  } catch {
-    return files;
-  }
-  for (const entry of entries) {
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...findYamlFiles(full));
-    } else if (entry.isFile() && /\.ya?ml$/i.test(entry.name)) {
-      files.push(full);
-    }
-  }
-  return files;
-}
-function parseRuleId(raw) {
-  const scalar = raw.match(/^id:\s*(.*?)\s*$/m)?.[1];
-  if (!scalar)
-    return;
-  const withoutComment = scalar.replace(/\s+#.*$/, "").trim();
-  const unquoted = withoutComment.startsWith('"') && withoutComment.endsWith('"') || withoutComment.startsWith("'") && withoutComment.endsWith("'") ? withoutComment.slice(1, -1) : withoutComment;
-  if (/^[A-Za-z0-9_.:-]+$/.test(unquoted))
-    return unquoted;
-  try {
-    const parsed = loadYaml(raw);
-    if (!parsed || typeof parsed !== "object" || !("id" in parsed)) {
-      return;
-    }
-    const id = parsed.id;
-    return typeof id === "string" ? id : undefined;
-  } catch {
-    return;
-  }
-}
-function parseRuleDocuments(content) {
-  return content.split(/^---\s*$/m).filter((document) => document.trim()).map((raw) => ({ raw, id: parseRuleId(raw) }));
-}
-const bundledSnapshots = new Map;
-function snapshotRuleSource(source) {
-  const cacheKey = canonicalDir(source.dir);
-  if (source.origin === "bundled") {
-    const cached = bundledSnapshots.get(cacheKey);
-    if (cached)
-      return cached;
-  }
-  const hash = createHash("sha256");
-  const files = [];
-  for (const file of findYamlFiles(source.dir)) {
-    const relativePath = path.relative(source.dir, file);
-    hash.update(relativePath);
-    hash.update("\x00");
-    let content;
-    try {
-      content = fs.readFileSync(file, "utf8");
-    } catch {
-      hash.update("missing");
-      hash.update("\x00");
-      continue;
-    }
-    hash.update(content);
-    hash.update("\x00");
-    files.push({ file, relativePath, documents: parseRuleDocuments(content) });
-  }
-  const snapshot = { ...source, files, digest: hash.digest("hex") };
-  if (source.origin === "bundled")
-    bundledSnapshots.set(cacheKey, snapshot);
-  return snapshot;
-}
-function sourceFingerprint(sources) {
-  const hash = createHash("sha256");
-  for (const source of sources) {
-    hash.update(source.origin);
-    hash.update("\x00");
-    hash.update(source.tier);
-    hash.update("\x00");
-    hash.update(canonicalDir(source.dir));
-    hash.update("\x00");
-    hash.update(source.digest);
-    hash.update("\x00");
-  }
-  return hash.digest("hex");
-}
-function materializeMergedRuleDir(sources, mergedDir) {
-  fs.rmSync(mergedDir, { recursive: true, force: true });
-  fs.mkdirSync(mergedDir, { recursive: true });
-  const claimedByEarlierSource = new Set;
-  for (const [sourceIndex, source] of sources.entries()) {
-    const claimedThisSource = new Set;
-    for (const [fileIndex, file] of source.files.entries()) {
-      const survivingDocuments = file.documents.filter((document) => {
-        if (!document.id)
-          return true;
-        if (claimedByEarlierSource.has(document.id))
-          return false;
-        claimedThisSource.add(document.id);
-        return true;
-      });
-      if (survivingDocuments.length === 0)
-        continue;
-      const destination = path.join(mergedDir, `source${sourceIndex}-${String(fileIndex).padStart(5, "0")}.yml`);
-      if (survivingDocuments.length === file.documents.length) {
-        fs.copyFileSync(file.file, destination);
-      } else {
-        fs.writeFileSync(destination, `${survivingDocuments.map((document) => document.raw.trim()).join(`
----
-`)}
-`);
-      }
-    }
-    for (const id of claimedThisSource)
-      claimedByEarlierSource.add(id);
-  }
-}
-const cachedBaselines = new Map;
-function rootArtifactKey(root) {
-  return createHash("sha256").update(root).digest("hex").slice(0, 12);
-}
-export function resolveBaselineSgconfig(projectRoot = process.cwd()) {
-  const root = canonicalDir(path.resolve(projectRoot || process.cwd()));
-  const sources = getAstGrepRuleSources(root).map(snapshotRuleSource);
-  if (sources.length === 0)
-    return;
-  const fingerprint = sourceFingerprint(sources);
-  const cached = cachedBaselines.get(root);
-  if (cached?.fingerprint === fingerprint && fs.existsSync(cached.path) && fs.existsSync(cached.mergedDir)) {
-    return cached.path;
-  }
-  const dir = path.join(os.tmpdir(), "dm-lens-ast-grep");
-  fs.mkdirSync(dir, { recursive: true });
-  const artifactKey = rootArtifactKey(root);
-  const file = path.join(dir, `baseline-${process.pid}-${artifactKey}.sgconfig.yml`);
-  const mergedDir = path.join(dir, `baseline-${process.pid}-${artifactKey}.rules`);
-  const protectedArtifacts = new Set([file, mergedDir]);
-  for (const baseline of cachedBaselines.values()) {
-    protectedArtifacts.add(baseline.path);
-    protectedArtifacts.add(baseline.mergedDir);
-  }
-  cleanupStaleBaselines(dir, protectedArtifacts);
-  materializeMergedRuleDir(sources, mergedDir);
-  const ruleDirForYaml = mergedDir.split(path.sep).join("/");
-  fs.writeFileSync(file, `ruleDirs:
-  - ${JSON.stringify(ruleDirForYaml)}
-`);
-  cachedBaselines.set(root, { fingerprint, path: file, mergedDir });
-  enforceBaselineEntryCap(dir, new Set([file, mergedDir]));
-  return file;
-}
-const SG_BASELINE_RETAINED_ENTRIES = 24;
-function enforceBaselineEntryCap(dir, keep) {
-  let names;
-  try {
-    names = fs.readdirSync(dir);
-  } catch {
-    return;
-  }
-  const candidates = [];
-  for (const name of names) {
-    const isConfig = /^baseline(?:-\d+(?:-[a-f0-9]+)?)?\.sgconfig\.yml$/.test(name);
-    const isMergedDir = /^baseline-\d+(?:-[a-f0-9]+)?\.rules$/.test(name);
-    if (!isConfig && !isMergedDir)
-      continue;
-    const full = path.join(dir, name);
-    if (keep.has(full))
-      continue;
-    try {
-      candidates.push({
-        full,
-        mtimeMs: fs.statSync(full).mtimeMs,
-        recursive: isMergedDir
-      });
-    } catch {}
-  }
-  const over = candidates.length + keep.size - SG_BASELINE_RETAINED_ENTRIES;
-  if (over <= 0)
-    return;
-  candidates.sort((a, b) => a.mtimeMs - b.mtimeMs);
-  let evicted = 0;
-  for (const candidate of candidates.slice(0, over)) {
-    try {
-      fs.rmSync(candidate.full, {
-        recursive: candidate.recursive,
-        force: true
-      });
-      evicted += 1;
-      for (const [root, baseline] of cachedBaselines) {
-        if (baseline.path === candidate.full || baseline.mergedDir === candidate.full) {
-          cachedBaselines.delete(root);
-        }
-      }
-    } catch {}
-  }
-  if (evicted > 0) {
-    recordDegradationOnce({
-      kind: "sgconfig-baseline-cap-evict",
-      subject: dir,
-      reason: `evicted ${evicted} oldest baseline entries over the ${SG_BASELINE_RETAINED_ENTRIES}-entry cap`
-    });
-  }
-}
-function cleanupStaleBaselines(dir, keep) {
-  try {
-    const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
-    for (const name of fs.readdirSync(dir)) {
-      const isConfig = /^baseline(?:-\d+(?:-[a-f0-9]+)?)?\.sgconfig\.yml$/.test(name);
-      const isMergedDir = /^baseline-\d+(?:-[a-f0-9]+)?\.rules$/.test(name);
-      if (!isConfig && !isMergedDir)
-        continue;
-      const full = path.join(dir, name);
-      if (keep.has(full))
-        continue;
-      try {
-        const stat = fs.statSync(full);
-        if (stat.mtimeMs < cutoff) {
-          fs.rmSync(full, { recursive: stat.isDirectory(), force: true });
-        }
-      } catch {}
-    }
-  } catch {}
-}
-export function _resetBaselineSgconfigForTests() {
-  cachedBaselines.clear();
-  bundledSnapshots.clear();
-}

package/extensions/dm-lens/dist/clients/shared-checkout-guard.js

@@ -1,177 +0,0 @@
-import { emitBounded } from "./bounded-telemetry.js";
-import { collectGitInvocations, detectGuardedGitVerb, matchGitVerbAtCommandPosition, resolveGitTargetDirectory } from "./git-guard.js";
-import { getInstanceRoots, readInstanceRegistry, selectLivePeerInstances } from "./instance-registry.js";
-import { realIsPidAlive } from "./instance-reaper.js";
-import { logLatency } from "./latency-logger.js";
-import { resolveGitToplevel } from "./opaque-mutation-scan.js";
-import { normalizeFilePath } from "./path-utils.js";
-import { safeSpawnAsync } from "./safe-spawn.js";
-import { truncatedByOutputCap } from "./spawn-output-cap.js";
-const ALWAYS_MUTATING_VERBS = new Set([
-  "checkout",
-  "switch",
-  "restore",
-  "merge",
-  "rebase",
-  "pull",
-  "cherry-pick",
-  "revert"
-]);
-const RESET_WORKTREE_MODES = new Set([
-  "--hard",
-  "--merge",
-  "--keep"
-]);
-const READ_ONLY_STASH_SUBCOMMANDS = new Set([
-  "list",
-  "show"
-]);
-function isCleanDryRun(argsAfterVerb) {
-  return argsAfterVerb.some((arg) => arg === "--dry-run" || arg.startsWith("-") && !arg.startsWith("--") && arg.includes("n"));
-}
-const WORKTREE_MUTATING_GIT_MATCHER = {
-  id: "worktree-mutating",
-  indirectAlwaysMatches: false,
-  suppressPostVerbHelp: true,
-  matchesVerb(verb, argsAfterVerb) {
-    if (ALWAYS_MUTATING_VERBS.has(verb))
-      return true;
-    if (verb === "reset") {
-      return argsAfterVerb.some((arg) => RESET_WORKTREE_MODES.has(arg));
-    }
-    if (verb === "stash") {
-      const subcommand = argsAfterVerb.find((arg) => !arg.startsWith("-"));
-      return subcommand === undefined || !READ_ONLY_STASH_SUBCOMMANDS.has(subcommand);
-    }
-    if (verb === "clean")
-      return !isCleanDryRun(argsAfterVerb);
-    return false;
-  }
-};
-function matchesWorktreeMutatingVerb(gitTokens) {
-  return matchGitVerbAtCommandPosition(gitTokens, WORKTREE_MUTATING_GIT_MATCHER);
-}
-export function isWorktreeMutatingGitAttempt(toolName, input) {
-  return detectGuardedGitVerb(toolName, input, WORKTREE_MUTATING_GIT_MATCHER);
-}
-const MAX_GIT_STATUS_OUTPUT_BYTES = 16 * 1024 * 1024;
-export async function probeWorkingTreeState(root) {
-  const result = await safeSpawnAsync("git", ["status", "--porcelain", "--untracked-files=all"], { cwd: root, timeout: 5000, maxOutputBytes: MAX_GIT_STATUS_OUTPUT_BYTES });
-  if (truncatedByOutputCap(result))
-    return "dirty";
-  if (result.error || result.status !== 0 && result.status !== null) {
-    return "unknown";
-  }
-  return (result.stdout ?? "").trim().length > 0 ? "dirty" : "clean";
-}
-function logAllow(root, reasonCategory) {
-  logLatency({
-    type: "phase",
-    toolName: "shared-checkout-guard",
-    phase: "shared_checkout_guard_allow",
-    filePath: root,
-    durationMs: 0,
-    metadata: { decision: "allowed", reasonCategory }
-  });
-}
-function describePeers(peers) {
-  const pids = peers.slice(0, 4).map((peer) => peer.pid);
-  const suffix = peers.length > pids.length ? ", …" : "";
-  return `${peers.length} other live dm-lens session${peers.length === 1 ? "" : "s"} (pid ${pids.join(", ")}${suffix})`;
-}
-export async function evaluateSharedCheckoutGuard(toolName, input, cwd, deps = {}) {
-  if (!isWorktreeMutatingGitAttempt(toolName, input))
-    return { block: false };
-  const targets = resolveGuardTargets(toolName, input, cwd);
-  let entries;
-  try {
-    entries = await (deps.readRegistry ?? readInstanceRegistry)();
-  } catch {
-    logAllow(normalizeFilePath(cwd), "registry_unreadable");
-    return { block: false };
-  }
-  for (const target of targets) {
-    const decision = await evaluateOneTarget(target, entries, deps);
-    if (decision.block)
-      return decision;
-  }
-  return { block: false };
-}
-function resolveGuardTargets(toolName, input, cwd) {
-  const targets = new Set;
-  for (const gitTokens of collectGitInvocations(toolName, input)) {
-    if (!matchesWorktreeMutatingVerb(gitTokens))
-      continue;
-    targets.add(resolveGitTargetDirectory(gitTokens, cwd));
-  }
-  if (targets.size === 0)
-    targets.add(cwd);
-  return [...targets];
-}
-async function evaluateOneTarget(cwd, entries, deps) {
-  const root = normalizeFilePath(cwd);
-  const resolveToplevel = deps.resolveToplevel ?? resolveGitToplevel;
-  const toplevel = await resolveToplevel(cwd);
-  if (toplevel === undefined) {
-    logAllow(root, "not_a_git_worktree");
-    return { block: false };
-  }
-  const normalizedToplevel = normalizeFilePath(toplevel);
-  const candidates = selectLivePeerInstances(entries, normalizedToplevel, deps.now ?? Date.now(), deps.isPidAlive ?? realIsPidAlive, "containment");
-  const toplevelMemo = new Map;
-  const resolveToplevelOnce = async (dir) => {
-    if (toplevelMemo.has(dir))
-      return toplevelMemo.get(dir);
-    const resolved = await resolveToplevel(dir);
-    toplevelMemo.set(dir, resolved);
-    return resolved;
-  };
-  const peers = [];
-  for (const candidate of candidates) {
-    for (const candidateRoot of getInstanceRoots(candidate)) {
-      const peerToplevel = await resolveToplevelOnce(candidateRoot);
-      if (peerToplevel !== undefined && normalizeFilePath(peerToplevel) === normalizedToplevel) {
-        peers.push(candidate);
-        break;
-      }
-    }
-  }
-  if (peers.length === 0) {
-    logAllow(root, "no_peer_session");
-    return { block: false };
-  }
-  const state = await (deps.probeWorkingTree ?? probeWorkingTreeState)(cwd);
-  if (state === "clean") {
-    logAllow(root, "working_tree_clean");
-    return { block: false };
-  }
-  if (state === "unknown") {
-    emitBounded("shared_checkout_probe_failed", root, {
-      toolName: "shared-checkout-guard",
-      durationMs: 0,
-      metadata: { decision: "blocked", peerCount: peers.length }
-    }, {
-      ledgerKind: "shared-checkout-probe",
-      risingEdgePer: "identity",
-      reason: "git status could not report working-tree state"
-    });
-    return {
-      block: true,
-      unknown: true,
-      reason: "\uD83D\uDD34 WORKING-TREE CHANGE BLOCKED (--lens-checkout-guard): git could not report whether this checkout has uncommitted work, and it is shared with " + `${describePeers(peers)}. Re-run the command once git answers, or take a dedicated git worktree.`
-    };
-  }
-  emitBounded("shared_checkout_switch_blocked", root, {
-    toolName: "shared-checkout-guard",
-    durationMs: 0,
-    metadata: { decision: "blocked", peerCount: peers.length }
-  }, {
-    ledgerKind: "shared-checkout-wip",
-    risingEdgePer: "identity",
-    reason: "worktree-mutating git command declined on a shared checkout"
-  });
-  return {
-    block: true,
-    reason: "\uD83D\uDD34 WORKING-TREE CHANGE BLOCKED (--lens-checkout-guard): this checkout has uncommitted changes and is shared with " + `${describePeers(peers)}. The command would discard work that may not be yours. ` + "Commit the changes first, or run this in a dedicated git worktree."
-  };
-}

package/extensions/dm-lens/dist/clients/single-flight.js

@@ -1,52 +0,0 @@
-export function createSingleFlight(options = {}) {
-  const { generation: readGeneration, coalesceTrailing = false } = options;
-  const flights = new Map;
-  const currentGeneration = () => readGeneration?.() ?? 0;
-  const release = (key, flight) => {
-    if (flights.get(key) !== flight)
-      return;
-    flights.delete(key);
-  };
-  const run = (key, fn) => {
-    const existing = flights.get(key);
-    if (existing && existing.generation === currentGeneration()) {
-      if (coalesceTrailing)
-        existing.rerunRequested = true;
-      return existing.promise;
-    }
-    let settle;
-    let fail;
-    const promise = new Promise((resolve, reject) => {
-      settle = resolve;
-      fail = reject;
-    });
-    const flight = {
-      promise,
-      generation: currentGeneration(),
-      rerunRequested: false
-    };
-    const chain = async () => {
-      let result = await fn();
-      while (flight.rerunRequested) {
-        flight.rerunRequested = false;
-        result = await fn();
-      }
-      return result;
-    };
-    flights.set(key, flight);
-    chain().then((value) => {
-      release(key, flight);
-      settle(value);
-    }, (error) => {
-      release(key, flight);
-      fail(error);
-    });
-    return flight.promise;
-  };
-  return {
-    run,
-    has: (key) => flights.has(key),
-    size: () => flights.size,
-    clear: () => flights.clear()
-  };
-}

package/extensions/dm-lens/dist/clients/situational-tool-telemetry.js

@@ -1,85 +0,0 @@
-import { logExtension } from "./extension-log.js";
-import { TOOL_REGISTRY } from "./tool-config.js";
-const situationalTools = TOOL_REGISTRY.filter((tool) => ("situational" in tool) && tool.situational === true).map((tool) => tool.name);
-const situationalToolSet = new Set(situationalTools);
-const activated = new Set;
-const called = new Set;
-let sessionStarted = false;
-let emitted = false;
-let connectionEnded = false;
-let sessionHost = "mcp";
-function observe(set, name) {
-  if (situationalToolSet.has(name)) {
-    set.add(name);
-  }
-}
-function clearObservations() {
-  activated.clear();
-  called.clear();
-}
-export function observeSituationalToolActivation(names) {
-  for (const name of names)
-    observe(activated, name);
-}
-export function observeSituationalToolCall(name) {
-  observe(called, name);
-}
-export function resetSituationalToolTelemetry() {
-  if (sessionStarted)
-    return;
-  clearObservations();
-  emitted = false;
-}
-export function startSituationalToolTelemetrySession(host) {
-  if (host === "mcp") {
-    if (connectionEnded)
-      return;
-    if (sessionStarted)
-      return;
-    sessionHost = "mcp";
-    clearObservations();
-    emitted = false;
-    sessionStarted = true;
-    return;
-  }
-  if (sessionStarted) {
-    sessionHost = "pi";
-    return;
-  }
-  sessionHost = "pi";
-  clearObservations();
-  emitted = false;
-  sessionStarted = true;
-}
-export function endSituationalToolTelemetry() {
-  if (!sessionStarted)
-    return;
-  emitSituationalDeadWeight();
-  if (sessionHost === "mcp")
-    connectionEnded = true;
-  clearObservations();
-  emitted = false;
-  sessionStarted = false;
-}
-export function emitSituationalDeadWeight() {
-  if (emitted)
-    return;
-  emitted = true;
-  const used = new Set([...activated, ...called]);
-  logExtension({
-    subsystem: "tools",
-    level: "debug",
-    message: "situational tool dead weight",
-    metadata: {
-      tools: situationalTools.filter((name) => !used.has(name))
-    }
-  });
-}
-export function _getSituationalToolTelemetryStateForTests() {
-  return {
-    activated: activated.size,
-    called: called.size,
-    emitted,
-    sessionStarted
-  };
-}

package/extensions/dm-lens/dist/clients/skills-resolver.js

@@ -1,38 +0,0 @@
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import * as fs from "node:fs";
-import { scanEntriesForSkills } from "../scripts/lib/skills-predicate.mjs";
-import { classifyBundledResourceDir, describeBundledResourceHealth, reportBundledResourceDirHealth } from "./bundled-resource-health.js";
-import { logLatency } from "./latency-logger.js";
-import { getPackageRoot } from "./package-root.js";
-const SKILLS_DIR_MISSING_KIND = "skills-dir-missing";
-function checkSkillsHealth(skillsDir) {
-  return classifyBundledResourceDir(skillsDir, (dir) => {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    return scanEntriesForSkills(dir, entries, true).length;
-  });
-}
-export function resolveSkillPaths(importMetaUrl) {
-  const packageRoot = getPackageRoot(importMetaUrl);
-  const skillsDir = path.join(packageRoot, "skills");
-  const health = checkSkillsHealth(skillsDir);
-  logLatency({
-    type: "phase",
-    phase: "skills_resolved",
-    filePath: skillsDir,
-    durationMs: 0,
-    metadata: {
-      status: health.status,
-      entryCount: health.status === "healthy" ? health.entryCount : 0
-    }
-  });
-  if (health.status !== "healthy") {
-    const entryDir = path.dirname(fileURLToPath(importMetaUrl));
-    const healthDescription = describeBundledResourceHealth(health, skillsDir, `no SKILL.md (or loadable .md) found under ${skillsDir}`);
-    const notifyReason = `${healthDescription} (entry loaded from ${entryDir})`;
-    const classification = health.status === "unreadable" ? `cannot read (${health.fsErrorCode})` : health.status === "empty" ? "no SKILL.md found" : "no such directory";
-    const ledgerReason = `${classification} (entry loaded from ${entryDir})`;
-    reportBundledResourceDirHealth(SKILLS_DIR_MISSING_KIND, skillsDir, health, "skills", ledgerReason, `dm-lens: registers zero skills — ${notifyReason}.`);
-  }
-  return [skillsDir];
-}