@hegemonart/get-design-done 1.54.0 → 1.56.0

package/sdk/cli/index.js

@@ -9582,6 +9582,252 @@ ${BUILD_USAGE}`);
   return typeof res.status === "number" ? res.status : 3;
 }
 
+// sdk/cli/commands/dashboard.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_module4 = require("node:module");
+var import_node_http = require("node:http");
+var import_node_fs23 = require("node:fs");
+var import_node_path21 = require("node:path");
+var DASHBOARD_FLAGS = [
+  ...COMMON_FLAGS,
+  { name: "web", type: "boolean", default: false },
+  { name: "once", type: "boolean", default: false },
+  { name: "no-open", type: "boolean", default: false },
+  { name: "root", type: "string" }
+];
+var DASHBOARD_USAGE = `gdd-sdk dashboard [flags]
+
+Open the GDD dashboard. Read-only. Dep-free (Node builtins only).
+
+Default (no --web) launches the terminal UI (bin/gdd-dashboard). With --web it
+emits a self-contained HTML graph of the design-context, serves it on an ephemeral
+local port, and opens your browser.
+
+Flags:
+  --web            Web mode: build + serve the design-context graph as HTML.
+  --once           Write the HTML to .design/dashboard.html and exit (no server). Implies --web.
+  --no-open        Web mode: serve + print the URL but do NOT open a browser (headless/CI).
+  --root <dir>     Project root to read .design/ from (default: GDD_PROJECT_ROOT or walk-up).
+  -h, --help       Show this help.
+
+Exit codes: 0 ok \xB7 3 arg error / TUI not found \xB7 (TUI exit code forwarded otherwise)
+`;
+function anchorDirs() {
+  const out = [];
+  const entry = process.argv[1];
+  if (typeof entry === "string" && entry.length > 0) out.push((0, import_node_path21.dirname)(entry));
+  out.push(process.cwd());
+  return out;
+}
+function climbToMarker(startDir) {
+  const req = (0, import_node_module4.createRequire)((0, import_node_path21.join)(startDir, "noop.js"));
+  let dir = startDir;
+  let firstWithPkg = null;
+  for (let i = 0; i < 12; i++) {
+    const pkgPath = (0, import_node_path21.join)(dir, "package.json");
+    if ((0, import_node_fs23.existsSync)(pkgPath)) {
+      if (firstWithPkg === null) firstWithPkg = dir;
+      try {
+        const pkg = req(pkgPath);
+        if (pkg && pkg.name === "get-design-done") return { root: dir, firstWithPkg };
+      } catch {
+      }
+    }
+    const parent = (0, import_node_path21.dirname)(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return { root: null, firstWithPkg };
+}
+var _cachedPkgRoot = null;
+function findPackageRoot() {
+  if (_cachedPkgRoot !== null) return _cachedPkgRoot;
+  let fallback = null;
+  for (const anchor of anchorDirs()) {
+    const { root, firstWithPkg } = climbToMarker(anchor);
+    if (root) {
+      _cachedPkgRoot = root;
+      return root;
+    }
+    if (fallback === null && firstWithPkg !== null) fallback = firstWithPkg;
+  }
+  _cachedPkgRoot = fallback ?? process.cwd();
+  return _cachedPkgRoot;
+}
+function requireFromRoot(relPath) {
+  const root = findPackageRoot();
+  const req = (0, import_node_module4.createRequire)((0, import_node_path21.join)(root, "noop.js"));
+  return req((0, import_node_path21.join)(root, relPath));
+}
+function resolveRoot(deps, flags) {
+  if (typeof deps.root === "string" && deps.root.length > 0) return deps.root;
+  const flagRoot = flags["root"];
+  if (typeof flagRoot === "string" && flagRoot.length > 0) return flagRoot;
+  if (process.env["GDD_PROJECT_ROOT"]) return process.env["GDD_PROJECT_ROOT"];
+  return findPackageRoot();
+}
+function loadGraphGraceful(root, stderr) {
+  const graphPath = (0, import_node_path21.join)(root, ".design", "context-graph.json");
+  try {
+    const query = requireFromRoot("scripts/lib/design-context-query.cjs");
+    if (typeof query.load === "function") return query.load(graphPath);
+  } catch (err) {
+    stderr.write(
+      `gdd-sdk dashboard: no design-context graph at ${graphPath} (${errMsg(err)}); rendering an empty graph.
+`
+    );
+  }
+  return { nodes: [], edges: [] };
+}
+function buildDashboardHtml(root, stderr) {
+  const graph = loadGraphGraceful(root, stderr);
+  const htmlLib = requireFromRoot("scripts/lib/dashboard/graph-html.cjs");
+  return htmlLib.buildGraphHtml(graph, { title: "GDD Design Context Graph" });
+}
+function isHeadless(deps, flags) {
+  if (typeof deps.headless === "boolean") return deps.headless;
+  if (flags["no-open"] === true) return true;
+  if (process.env["CI"]) return true;
+  if (process.platform === "linux") {
+    return !process.env["DISPLAY"] && !process.env["WAYLAND_DISPLAY"];
+  }
+  return false;
+}
+function defaultOpenBrowser(url) {
+  try {
+    if (process.platform === "darwin") {
+      (0, import_node_child_process2.spawn)("open", [url], { stdio: "ignore", detached: true }).unref();
+    } else if (process.platform === "win32") {
+      (0, import_node_child_process2.spawn)("cmd", ["/c", "start", "", url], { stdio: "ignore", detached: true }).unref();
+    } else {
+      (0, import_node_child_process2.spawn)("xdg-open", [url], { stdio: "ignore", detached: true }).unref();
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function serveHtml(html) {
+  return new Promise((resolve11, reject) => {
+    const server = (0, import_node_http.createServer)((_req, res) => {
+      res.writeHead(200, {
+        "content-type": "text/html; charset=utf-8",
+        "cache-control": "no-store"
+      });
+      res.end(html);
+    });
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (addr === null || typeof addr === "string") {
+        server.close();
+        reject(new Error("could not determine the ephemeral server port"));
+        return;
+      }
+      const port = addr.port;
+      resolve11({ server, port, url: `http://127.0.0.1:${port}/` });
+    });
+  });
+}
+function errMsg(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+async function dashboardCommand(parsed, deps = {}) {
+  const stdout = deps.stdout ?? process.stdout;
+  const stderr = deps.stderr ?? process.stderr;
+  if (parsed.flags["help"] === true || parsed.flags["h"] === true) {
+    stdout.write(DASHBOARD_USAGE);
+    return 0;
+  }
+  let flags;
+  try {
+    flags = coerceFlags(parsed, DASHBOARD_FLAGS);
+  } catch {
+    stderr.write(`gdd-sdk dashboard: invalid flags
+${DASHBOARD_USAGE}`);
+    return 3;
+  }
+  const once = flags["once"] === true;
+  const web = flags["web"] === true || once;
+  if (!web) {
+    return runTui(deps, stdout, stderr);
+  }
+  const root = resolveRoot(deps, flags);
+  const html = buildDashboardHtml(root, stderr);
+  if (once) {
+    const designDir = (0, import_node_path21.join)(root, ".design");
+    try {
+      (0, import_node_fs23.mkdirSync)(designDir, { recursive: true });
+    } catch {
+    }
+    const outFile = (0, import_node_path21.join)(designDir, "dashboard.html");
+    try {
+      (0, import_node_fs23.writeFileSync)(outFile, html, "utf8");
+    } catch (err) {
+      stderr.write(`gdd-sdk dashboard: could not write ${outFile}: ${errMsg(err)}
+`);
+      return 3;
+    }
+    stdout.write(`Wrote dashboard HTML to ${outFile}
+`);
+    return 0;
+  }
+  let served;
+  try {
+    served = await serveHtml(html);
+  } catch (err) {
+    stderr.write(`gdd-sdk dashboard: could not start the web server: ${errMsg(err)}
+`);
+    return 3;
+  }
+  const headless = isHeadless(deps, flags);
+  const opener = deps.openBrowser ?? defaultOpenBrowser;
+  stdout.write(`GDD dashboard serving at ${served.url}
+`);
+  if (headless) {
+    stdout.write("Headless environment detected \u2014 open the URL above in a browser.\n");
+    stdout.write("Press Ctrl+C to stop the server.\n");
+  } else {
+    const launched = opener(served.url);
+    if (!launched) {
+      stdout.write("Could not auto-open a browser \u2014 open the URL above manually.\n");
+    }
+    stdout.write("Press Ctrl+C to stop the server.\n");
+  }
+  await new Promise((resolve11) => {
+    const shutdown = () => {
+      served.server.close(() => resolve11());
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+    served.server.on("close", () => resolve11());
+  });
+  return 0;
+}
+function runTui(deps, _stdout, stderr) {
+  let bin = deps.tuiBin;
+  if (!bin) {
+    const root = findPackageRoot();
+    const candidate = (0, import_node_path21.join)(root, "bin", "gdd-dashboard");
+    bin = (0, import_node_fs23.existsSync)(candidate) ? candidate : void 0;
+  }
+  if (!bin || !(0, import_node_fs23.existsSync)(bin)) {
+    stderr.write(
+      "gdd-sdk dashboard: could not locate bin/gdd-dashboard (the terminal UI).\nTry `gdd dashboard --web` for the browser graph instead.\n"
+    );
+    return 3;
+  }
+  const stdio = deps.tuiStdio ?? "inherit";
+  const res = (0, import_node_child_process2.spawnSync)(process.execPath, [bin], { stdio });
+  if (res.error) {
+    stderr.write(`gdd-sdk dashboard: failed to launch the TUI: ${res.error.message}
+`);
+    return 3;
+  }
+  return typeof res.status === "number" ? res.status : 0;
+}
+
 // sdk/cli/index.ts
 var USAGE6 = `gdd-sdk <command> [flags]
 
@@ -9592,6 +9838,7 @@ Commands:
   audit            Probe connections + dry-run verify.
   init             Bootstrap a new project.
   build skills     Compile per-harness skill bundles from source/skills/.
+  dashboard        Open the GDD dashboard (TUI; --web for the browser graph).
 
 Use 'gdd-sdk <command> -h' for command-specific flags.
 
@@ -9610,7 +9857,8 @@ async function dispatch(parsed, deps = {}) {
     query: deps.commands?.query ?? queryCommand,
     audit: deps.commands?.audit ?? auditCommand,
     init: deps.commands?.init ?? initCommand,
-    build: deps.commands?.build ?? buildCommand
+    build: deps.commands?.build ?? buildCommand,
+    dashboard: deps.commands?.dashboard ?? dashboardCommand
   };
   if (parsed.subcommand === null) {
     stdout.write(USAGE6);
@@ -9636,6 +9884,8 @@ async function dispatch(parsed, deps = {}) {
       return await commands.init(parsed, { stdout, stderr });
     case "build":
       return await commands.build(parsed, { stdout, stderr });
+    case "dashboard":
+      return await commands.dashboard(parsed, { stdout, stderr });
     default:
       stderr.write(
         `gdd-sdk: unknown subcommand "${parsed.subcommand}"
@@ -9650,7 +9900,8 @@ var KNOWN_SUBCOMMANDS = /* @__PURE__ */ new Set([
   "query",
   "audit",
   "init",
-  "build"
+  "build",
+  "dashboard"
 ]);
 async function main(argv = process.argv.slice(2), deps = {}) {
   const parsed = parseArgs(argv);

package/sdk/cli/index.ts

@@ -22,6 +22,7 @@ import { queryCommand } from './commands/query.ts';
 import { auditCommand } from './commands/audit.ts';
 import { initCommand } from './commands/init.ts';
 import { buildCommand } from './commands/build.ts';
+import { dashboardCommand } from './commands/dashboard.ts';
 
 // ---------------------------------------------------------------------------
 // Top-level USAGE.
@@ -36,6 +37,7 @@ Commands:
   audit            Probe connections + dry-run verify.
   init             Bootstrap a new project.
   build skills     Compile per-harness skill bundles from source/skills/.
+  dashboard        Open the GDD dashboard (TUI; --web for the browser graph).
 
 Use 'gdd-sdk <command> -h' for command-specific flags.
 
@@ -60,6 +62,7 @@ export interface DispatcherDeps {
     readonly audit?: typeof auditCommand;
     readonly init?: typeof initCommand;
     readonly build?: typeof buildCommand;
+    readonly dashboard?: typeof dashboardCommand;
   };
 }
 
@@ -85,6 +88,7 @@ export async function dispatch(
     audit: deps.commands?.audit ?? auditCommand,
     init: deps.commands?.init ?? initCommand,
     build: deps.commands?.build ?? buildCommand,
+    dashboard: deps.commands?.dashboard ?? dashboardCommand,
   };
 
   // Bare invocation or top-level help → USAGE.
@@ -117,6 +121,8 @@ export async function dispatch(
       return await commands.init(parsed, { stdout, stderr });
     case 'build':
       return await commands.build(parsed, { stdout, stderr });
+    case 'dashboard':
+      return await commands.dashboard(parsed, { stdout, stderr });
     default:
       stderr.write(
         `gdd-sdk: unknown subcommand "${parsed.subcommand}"\n${USAGE}`,
@@ -132,6 +138,7 @@ const KNOWN_SUBCOMMANDS: ReadonlySet<string> = new Set([
   'audit',
   'init',
   'build',
+  'dashboard',
 ]);
 
 // ---------------------------------------------------------------------------

package/sdk/dashboard/data/_pkg-root.cjs

@@ -0,0 +1,92 @@
+'use strict';
+/**
+ * sdk/dashboard/data/_pkg-root.cjs — Phase 55 (GDD Dashboard, dep-free).
+ *
+ * Package-root walk-up for sibling resolution (the Phase 53/54 lesson): never
+ * resolve a cross-tree sibling via a fixed `__dirname`-relative `../../..`
+ * jump, because that breaks the moment a file is copied/moved or the layout
+ * shifts. Instead, walk UP from this file's directory until we find the GDD
+ * package.json (identified by `name === 'get-design-done'`), and resolve all
+ * in-repo siblings relative to that root.
+ *
+ * Even though these dashboard `.cjs` files are NOT esbuild-bundled (R8 — the
+ * bin trampoline runs them directly so the Phase 53 __dirname-rewrite trap
+ * does not apply), keeping the walk-up makes the data plane robust to future
+ * bundling or relocation. Pure + dependency-free; memoized per process.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/** Memoized resolved package root (computed once per process). */
+let _cachedRoot = null;
+
+/**
+ * Walk up from `startDir` looking for the GDD package root. The GDD root is
+ * the first ancestor whose package.json declares `name: "get-design-done"`;
+ * if no such marker is found (e.g. running from an unusual layout), fall back
+ * to the FIRST ancestor that has any package.json, then to `startDir`.
+ *
+ * @param {string} startDir
+ * @returns {string} absolute package-root directory
+ */
+function findPackageRoot(startDir) {
+  let dir = path.resolve(startDir);
+  let firstWithPkg = null;
+  // Bound the climb defensively (deep trees / odd mounts).
+  for (let i = 0; i < 12; i++) {
+    const pkgPath = path.join(dir, 'package.json');
+    let pkg = null;
+    try {
+      pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    } catch {
+      pkg = null;
+    }
+    if (pkg) {
+      if (firstWithPkg === null) firstWithPkg = dir;
+      if (pkg.name === 'get-design-done') return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return firstWithPkg || path.resolve(startDir);
+}
+
+/**
+ * Resolved GDD package root, memoized. Computed by walking up from THIS file's
+ * directory (`__dirname`) — which is correct regardless of the caller's cwd.
+ * @returns {string}
+ */
+function packageRoot() {
+  if (_cachedRoot === null) _cachedRoot = findPackageRoot(__dirname);
+  return _cachedRoot;
+}
+
+/**
+ * Absolute path to an in-repo file given its repo-relative path.
+ * @param {string} relPath e.g. 'scripts/lib/install/runtime-homes.cjs'
+ * @returns {string}
+ */
+function resolveFromPackageRoot(relPath) {
+  return path.join(packageRoot(), relPath);
+}
+
+/**
+ * require() an in-repo sibling .cjs module by its repo-relative path, resolved
+ * via the package-root walk-up. Use ONLY for .cjs siblings — .ts libs must be
+ * loaded via dynamic import(pathToFileURL) (a .cjs cannot static-require a .ts).
+ *
+ * @param {string} relPath e.g. 'scripts/lib/design-context-query.cjs'
+ * @returns {*} the required module
+ */
+function requireFromPackageRoot(relPath) {
+  return require(resolveFromPackageRoot(relPath));
+}
+
+module.exports = {
+  findPackageRoot,
+  packageRoot,
+  resolveFromPackageRoot,
+  requireFromPackageRoot,
+};

package/sdk/dashboard/data/cost-aggregator.cjs

@@ -0,0 +1,187 @@
+'use strict';
+/**
+ * sdk/dashboard/data/cost-aggregator.cjs — Phase 55 (GDD Dashboard, dep-free).
+ *
+ * Pure roll-up of cost events into per-runtime / cumulative / per-cycle
+ * buckets, plus a tolerant JSONL reader for `.design/telemetry/costs.jsonl`.
+ *
+ * Cost rows on disk have evolved across phases (Phase 10.1 -> 26 -> 27 -> 33.6),
+ * so this aggregator is deliberately field-shape tolerant:
+ *
+ *   - cost field:    `est_cost_usd` (the on-disk tier-resolver/budget-enforcer
+ *                    shape) OR `cost_usd` (the newer event-payload shape).
+ *   - runtime key:   `runtime` (Phase 27+) -> else `tier` -> else `agent`
+ *                    -> else "unknown". Grouping is best-effort: the dashboard
+ *                    just needs a stable label per row.
+ *   - cycle key:     `cycle` -> else "unknown".
+ *   - tokens:        `tokens_in` / `tokens_out`, coerced via Number(... || 0).
+ *
+ * NEVER throws. Pure (no FS) except `readCosts()`, which reads one file and
+ * tolerates malformed lines (skips them silently, like the event-stream reader).
+ *
+ * Public API:
+ *   aggregateCosts(costEvents) -> { byRuntime, cumulative, byCycle }
+ *   readCosts({ root?, path? }) -> cost row array (tolerant; [] when absent)
+ *
+ * Determinism: no Date.now()/Math.random(); output ordering follows input
+ * ordering of first-seen keys (object insertion order).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DEFAULT_COSTS_PATH = '.design/telemetry/costs.jsonl';
+
+/**
+ * Coerce a possibly-missing numeric field to a finite number (0 on garbage).
+ * @param {unknown} v
+ * @returns {number}
+ */
+function num(v) {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : 0;
+}
+
+/**
+ * Read the per-runtime label for a cost row. Prefers the explicit `runtime`
+ * tag (Phase 27+), then `tier`, then `agent`, then a literal "unknown".
+ * @param {Record<string, unknown>} row
+ * @returns {string}
+ */
+function runtimeKeyOf(row) {
+  if (row && typeof row.runtime === 'string' && row.runtime.length) return row.runtime;
+  if (row && typeof row.tier === 'string' && row.tier.length) return row.tier;
+  if (row && typeof row.agent === 'string' && row.agent.length) return row.agent;
+  return 'unknown';
+}
+
+/**
+ * Read the USD cost for a row, tolerant of both on-disk shapes.
+ * @param {Record<string, unknown>} row
+ * @returns {number}
+ */
+function costUsdOf(row) {
+  if (!row) return 0;
+  if (typeof row.est_cost_usd !== 'undefined') return num(row.est_cost_usd);
+  if (typeof row.cost_usd !== 'undefined') return num(row.cost_usd);
+  if (typeof row.usd !== 'undefined') return num(row.usd);
+  return 0;
+}
+
+/**
+ * Read the cycle label for a row.
+ * @param {Record<string, unknown>} row
+ * @returns {string}
+ */
+function cycleKeyOf(row) {
+  if (row && typeof row.cycle === 'string' && row.cycle.length) return row.cycle;
+  if (row && typeof row.cycle === 'number') return String(row.cycle);
+  return 'unknown';
+}
+
+/** Fresh zeroed accumulator bucket. */
+function emptyBucket() {
+  return { tokens_in: 0, tokens_out: 0, est_cost_usd: 0 };
+}
+
+/**
+ * Add one row's measures into an accumulator bucket (mutates `bucket`).
+ * @param {{tokens_in:number,tokens_out:number,est_cost_usd:number}} bucket
+ * @param {Record<string, unknown>} row
+ */
+function addInto(bucket, row) {
+  bucket.tokens_in += num(row.tokens_in);
+  bucket.tokens_out += num(row.tokens_out);
+  bucket.est_cost_usd += costUsdOf(row);
+}
+
+/**
+ * Aggregate an array (or any iterable) of cost rows into per-runtime,
+ * cumulative, and per-cycle roll-ups. Pure — never throws, never reads FS.
+ *
+ * Non-array / nullish input degrades to empty buckets.
+ *
+ * @param {Iterable<Record<string, unknown>> | null | undefined} costEvents
+ * @returns {{
+ *   byRuntime: Record<string, {tokens_in:number,tokens_out:number,est_cost_usd:number}>,
+ *   cumulative: {tokens_in:number,tokens_out:number,est_cost_usd:number},
+ *   byCycle: Record<string, {tokens_in:number,tokens_out:number,est_cost_usd:number}>,
+ * }}
+ */
+function aggregateCosts(costEvents) {
+  /** @type {Record<string, ReturnType<typeof emptyBucket>>} */
+  const byRuntime = {};
+  /** @type {Record<string, ReturnType<typeof emptyBucket>>} */
+  const byCycle = {};
+  const cumulative = emptyBucket();
+
+  if (!costEvents || typeof costEvents[Symbol.iterator] !== 'function') {
+    return { byRuntime, cumulative, byCycle };
+  }
+
+  for (const row of costEvents) {
+    if (!row || typeof row !== 'object') continue;
+    const rt = runtimeKeyOf(row);
+    const cy = cycleKeyOf(row);
+    if (!byRuntime[rt]) byRuntime[rt] = emptyBucket();
+    if (!byCycle[cy]) byCycle[cy] = emptyBucket();
+    addInto(byRuntime[rt], row);
+    addInto(byCycle[cy], row);
+    addInto(cumulative, row);
+  }
+
+  return { byRuntime, cumulative, byCycle };
+}
+
+/**
+ * Resolve the costs.jsonl path: explicit `path` wins (absolute or relative to
+ * cwd); else `<root>/.design/telemetry/costs.jsonl`; else cwd-relative default.
+ * @param {{root?: string, path?: string}} [opts]
+ * @returns {string}
+ */
+function costsPathFor(opts = {}) {
+  if (opts.path) {
+    return path.isAbsolute(opts.path) ? opts.path : path.resolve(process.cwd(), opts.path);
+  }
+  const root = opts.root || process.cwd();
+  return path.join(root, DEFAULT_COSTS_PATH);
+}
+
+/**
+ * Read + parse `.design/telemetry/costs.jsonl` into a cost-row array.
+ *
+ * Tolerant: a missing file returns []; malformed JSON lines are skipped
+ * silently (the writer guarantees well-formed output, so a bad line is a
+ * corruption signal that must not crash a read-only dashboard). NEVER throws.
+ *
+ * @param {{root?: string, path?: string}} [opts]
+ * @returns {Array<Record<string, unknown>>}
+ */
+function readCosts(opts = {}) {
+  const file = costsPathFor(opts);
+  let raw;
+  try {
+    raw = fs.readFileSync(file, 'utf8');
+  } catch {
+    return []; // absent / unreadable -> graceful empty
+  }
+  const out = [];
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (trimmed === '') continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === 'object') out.push(parsed);
+    } catch {
+      // tolerate a malformed line — skip it, keep reading
+    }
+  }
+  return out;
+}
+
+module.exports = {
+  aggregateCosts,
+  readCosts,
+  costsPathFor,
+  DEFAULT_COSTS_PATH,
+};