@monster-orange/den 0.2.8 → 0.4.0

package/src/ui/server/public/health-fit.js

@@ -0,0 +1,248 @@
+/**
+ * The health poll's model, shared by the rail and the top bar's status chip
+ * and drawer (0.3.0-dev.20 retired the header's dot row and its "+N" chip).
+ *
+ * Each repo's state comes from health-rollup.js, the rule the graph and
+ * `<cli> status` use too: "down", "degraded", "unknown" (nothing checked)
+ * or "ok".
+ *
+ *   buildRow(rows, groups)  the model: application units, and every repo
+ *                           flat, each in problem-first order
+ *   paintGate(…)            when health data repaints: once per first
+ *                           cycle, then debounced
+ *   healthCycle(…)          one poll: the stream, completed by /api/health
+ *                           when it breaks, painted through the gate
+ *   shellHealth(row)        the rail's Services badge and pinned dots
+ *
+ * The pure parts take plain data, so tests need no browser.
+ */
+import { compareRepos, rollupRepo } from "./health-rollup.js";
+
+/**
+ * The row's model from /api/health rows and the application grouping
+ * (`[{ app, repos }]`, app null for repos with no box of their own).
+ * Repos sort down, degraded, ok, then unknown; within a state the
+ * focused workspace's first, then by name. A box sorts by its worst repo.
+ */
+export function buildRow(rows, groups) {
+  const byRepo = new Map();
+  for (const r of rows || []) {
+    if (!byRepo.has(r.repo)) byRepo.set(r.repo, []);
+    byRepo.get(r.repo).push(r);
+  }
+  const repoOf = new Map(
+    [...byRepo].map(([repo, signals]) => {
+      const rollup = rollupRepo(repo, signals);
+      return [
+        repo,
+        {
+          repo,
+          state: rollup.state,
+          rollup,
+          focused: signals.some((s) => s.focused),
+          items: signals,
+        },
+      ];
+    }),
+  );
+  const flat = [...repoOf.values()].sort(compareRepos);
+  const units = [];
+  for (const { app, repos } of groups || [
+    { app: null, repos: [...repoOf.keys()] },
+  ]) {
+    const members = repos
+      .map((r) => repoOf.get(r))
+      .filter(Boolean)
+      .sort(compareRepos);
+    if (!members.length) continue;
+    if (!app)
+      for (const m of members) units.push({ app: null, repos: [m], ...key(m) });
+    else
+      units.push({
+        app,
+        repos: members,
+        ...key({
+          state: members[0].state,
+          focused: members.some((m) => m.focused),
+          repo: app.name,
+        }),
+      });
+  }
+  units.sort(compareRepos);
+  return { units, flat };
+}
+
+const key = (x) => ({ state: x.state, focused: x.focused, repo: x.repo });
+
+/**
+ * When health data repaints (0.3.0-dev.13; the status chip since dev.20).
+ * A fresh load streamed results in batches and the old row reshuffled with
+ * each one, three or four times in as many seconds. Now:
+ * - `hold()` starts a first cycle (a page load, an environment switch):
+ *   data paints nothing (the chip stays "Checking…") until `done()`
+ *   ends the cycle, or `cap` ms pass with a slow probe still out;
+ * - after that, data paints at most once per `delay` ms of quiet (a
+ *   trailing debounce), and so does the end of a later cycle.
+ * Each call hands in the latest paint; only the last one runs.
+ * `timers` is `{ setTimeout, clearTimeout }`, globalThis by default, so
+ * tests can use a fake clock.
+ */
+export function paintGate({
+  delay = 300,
+  cap = 8000,
+  timers = globalThis,
+} = {}) {
+  let ready = true;
+  let pending = null;
+  let timer = null;
+  let capTimer = null;
+  const stop = (t) => t !== null && timers.clearTimeout(t);
+  const fire = () => {
+    stop(timer);
+    timer = null;
+    const paint = pending;
+    pending = null;
+    paint?.();
+  };
+  const settle = () => {
+    stop(capTimer);
+    capTimer = null;
+    ready = true;
+    fire();
+  };
+  return {
+    get ready() {
+      return ready;
+    },
+    hold() {
+      ready = false;
+      stop(timer);
+      timer = null;
+      stop(capTimer);
+      capTimer = timers.setTimeout(settle, cap);
+    },
+    data(paint) {
+      pending = paint;
+      if (!ready) return;
+      stop(timer);
+      timer = timers.setTimeout(fire, delay);
+    },
+    done(paint) {
+      if (paint) pending = paint;
+      if (!ready) return settle();
+      if (!pending) return;
+      stop(timer);
+      timer = timers.setTimeout(fire, delay);
+    },
+  };
+}
+
+/**
+ * One health poll, painted through `gate` (0.3.0-dev.14).
+ *
+ * - `seed`: the last poll's rows (`[key, row]` pairs); empty on a first
+ *   cycle, which `hold()`s the gate so nothing paints until it completes.
+ * - `stream(onResult)`: /api/health/stream. Resolves "done" when the server
+ *   said so (every check answered), "partial" when it broke after some
+ *   results, "none" when it gave nothing.
+ * - `fetchAll()`: /api/health, every row or null. Only a "done" stream is a
+ *   complete cycle: a broken one is completed from here, never painted as
+ *   if it were whole (dev.13 painted a stream that broke after 0.6s).
+ * - `paint(map)`: draw these rows. `current()`: false once a newer poll
+ *   owns the row.
+ * A cycle that never completes paints only by the gate's cap, with the rows
+ * that did land; a check with no result has no row, so it is never shown
+ * as down. Resolves with the cycle's rows, or null when incomplete.
+ */
+export async function healthCycle({
+  seed = [],
+  last = null,
+  gate,
+  stream,
+  fetchAll,
+  paint,
+  current = () => true,
+}) {
+  const keyOf = (r) => `${r.repo}/${r.service}`;
+  const acc = new Map(seed);
+  if (acc.size === 0) gate.hold();
+  const paintOf = (m) => () => {
+    if (current()) paint(m);
+  };
+  // A paint before the cycle completes (0.3.0-dev.17). The rows that last
+  // painted (`last()`, read at paint time: a poll that overlapped the first
+  // started with nothing seeded) stand for checks not answered yet; a repo
+  // they don't describe gets an `awaiting` row, so health-rollup.js holds it
+  // at unknown: one answered down service must not paint its app down
+  // while the app's other checks are still out.
+  const partialOf = (m) => () => {
+    if (!current()) return;
+    const known = (last ? last() : null) ?? new Map();
+    const out = new Map(known);
+    for (const [k, r] of m) out.set(k, r);
+    const described = new Set([...known.values()].map((r) => r.repo));
+    for (const r of [...out.values()])
+      if (!described.has(r.repo)) {
+        described.add(r.repo);
+        out.set(`${r.repo}/…`, {
+          repo: r.repo,
+          service: "…",
+          ok: null,
+          awaiting: true,
+          idx: r.idx,
+          focused: r.focused,
+        });
+      }
+    paint(out);
+  };
+  const fresh = new Map();
+  const end = await stream((r) => {
+    acc.set(keyOf(r), r);
+    fresh.set(keyOf(r), r);
+    gate.data(partialOf(acc));
+  });
+  let complete = end === "done";
+  if (!complete) {
+    const rows = await fetchAll();
+    if (Array.isArray(rows)) {
+      fresh.clear();
+      for (const r of rows) fresh.set(keyOf(r), r);
+      complete = true;
+    }
+  }
+  if (!current() || !complete) return null;
+  // Settle on exactly what this poll returned, so a service removed from
+  // the workspace disappears. A first cycle that answered with nothing
+  // paints too ("no services").
+  if (fresh.size > 0 || !gate.ready) gate.done(paintOf(fresh));
+  else gate.done();
+  return fresh;
+}
+
+/**
+ * The rail's share of the health row (R13, R14): `down` for the Services
+ * badge and `health` for the pinned rows' dots (`repo` and `repo/service`
+ * → down | degraded | ok | unknown). Both read the rollup: a down service
+ * counts only once every check of its repo has answered, so a cold load
+ * never badges a service the row still shows as unknown. `row` is
+ * buildRow's.
+ */
+export function shellHealth(row) {
+  let down = 0;
+  const health = {};
+  for (const r of row.flat) {
+    health[r.repo] = r.state;
+    down += r.rollup.down.length;
+    for (const i of r.items) {
+      if (i.awaiting) continue;
+      health[`${r.repo}/${i.service}`] = r.rollup.awaiting
+        ? "unknown"
+        : i.ok === true
+          ? "ok"
+          : i.ok === false
+            ? "down"
+            : "unknown";
+    }
+  }
+  return { down, health };
+}

package/src/ui/server/public/health-rollup.js

@@ -0,0 +1,128 @@
+/**
+ * One repo's health from its services' checks: the single rule the header
+ * row, its "+N" chip, the graph's repo cards and `<cli> status` all use, so
+ * they never disagree (0.3.0-dev.10).
+ *
+ * A signal is one service's check: `ok` true (up), false (down or failing)
+ * or null (not checked: no probe, not probed yet, or nothing to say). Only
+ * checked signals count, so a repo of 26 remote services with one probe is
+ * judged by that one probe.
+ *
+ *   down      the entry service (the repo's own health URL) is down
+ *   degraded  another checked service is down
+ *   ok        at least one signal is checked and none fails
+ *   unknown   nothing about the repo is checked (neutral, never green), or
+ *             a check hasn't answered yet (`awaiting`, 0.3.0-dev.17): until
+ *             every check has answered (a pending one has), one answered
+ *             down service never paints the repo down or degraded
+ *
+ * The entry service is the one marked `isEntrypoint` (the manifest's
+ * `entrypoint`), else the service named like the repo, else the only one.
+ *
+ * Plain ES module with no imports: the browser loads it as /health-rollup.js,
+ * and the server and CLI import it from TypeScript.
+ */
+
+/** Sort rank: problems first, then healthy, then unknown (nothing checked). */
+export const STATE_RANK = { down: 0, degraded: 1, ok: 2, unknown: 3 };
+
+/**
+ * @typedef {{ service: string, ok: boolean | null | undefined, isEntrypoint?: boolean, awaiting?: boolean }} HealthSignal
+ * @typedef {"down" | "degraded" | "ok" | "unknown"} RepoState
+ * @typedef {{ state: RepoState, entry: string | null, down: string[], checked: number, unchecked: number, awaiting: number }} RepoRollup
+ */
+
+/**
+ * The entry service among `signals`, or null.
+ * @param {string} repo
+ * @param {HealthSignal[]} signals
+ * @returns {HealthSignal | null}
+ */
+export function entrySignal(repo, signals) {
+  return (
+    signals.find((s) => s.isEntrypoint) ??
+    signals.find((s) => s.service === repo) ??
+    (signals.length === 1 ? signals[0] : null)
+  );
+}
+
+/**
+ * Roll one repo's signals up to its state.
+ * @param {string} repo
+ * @param {HealthSignal[]} signals
+ * @returns {RepoRollup}
+ */
+export function rollupRepo(repo, signals) {
+  // A check that hasn't answered yet (`awaiting`) holds the whole repo at
+  // unknown: with only some answers in, the one that did can't be judged
+  // (a lone down sidecar would even read as the entry service).
+  const awaiting = signals.filter((s) => s.awaiting).length;
+  const answered = signals.filter((s) => !s.awaiting);
+  const entry = entrySignal(repo, answered);
+  const checked = answered.filter((s) => s.ok === true || s.ok === false);
+  const down = awaiting
+    ? []
+    : checked.filter((s) => s.ok === false).map((s) => s.service);
+  const state = awaiting
+    ? "unknown"
+    : entry && entry.ok === false
+      ? "down"
+      : down.length > 0
+        ? "degraded"
+        : checked.length > 0
+          ? "ok"
+          : "unknown";
+  return {
+    state,
+    entry: entry ? entry.service : null,
+    down,
+    checked: checked.length,
+    unchecked: answered.length - checked.length,
+    awaiting,
+  };
+}
+
+/**
+ * Every repo's rollup from flat per-service rows (as /api/health sends
+ * them), in first-seen order.
+ * @param {Array<HealthSignal & { repo: string }>} rows
+ * @returns {Map<string, RepoRollup>}
+ */
+export function rollupRows(rows) {
+  const by = new Map();
+  for (const r of rows || []) {
+    if (!by.has(r.repo)) by.set(r.repo, []);
+    by.get(r.repo).push(r);
+  }
+  return new Map([...by].map(([repo, s]) => [repo, rollupRepo(repo, s)]));
+}
+
+/**
+ * "down (web down)", "degraded (mailpit down)", "healthy",
+ * "healthy, 25 not checked", "unknown (not checked)".
+ * @param {RepoRollup} r
+ * @returns {string}
+ */
+export function describeRollup(r) {
+  const notChecked = r.unchecked > 0 ? `${r.unchecked} not checked` : "";
+  if (r.awaiting) return "unknown (still checking)";
+  if (r.state === "unknown") return "unknown (not checked)";
+  if (r.state === "ok")
+    return notChecked ? `healthy, ${notChecked}` : "healthy";
+  return `${r.state} (${r.down.join(", ")} down)`;
+}
+
+/**
+ * Order repos: down, degraded, ok, then unknown; within a state
+ * the focused workspace's repos first, then by name.
+ * @param {{ state: RepoState, repo: string, focused?: boolean }} a
+ * @param {{ state: RepoState, repo: string, focused?: boolean }} b
+ * @returns {number}
+ */
+export function compareRepos(a, b) {
+  return (
+    (STATE_RANK[a.state] ?? 3) - (STATE_RANK[b.state] ?? 3) ||
+    Number(!!b.focused) - Number(!!a.focused) ||
+    String(a.repo).localeCompare(String(b.repo))
+  );
+}

package/src/ui/server/public/i18n/es.js

@@ -0,0 +1,287 @@
+/**
+ * The UI's Spanish catalog (R19, 0.3.0-dev.39). A classic script the
+ * server loads before shell.js for a page in Spanish (ui-language.ts); it
+ * adds its table to window.denMessages, and shell.js's t() reads it. Every
+ * key of shell.js's en is here (tests/unit/server/i18n.test.ts). A `.one`
+ * key is the form for n = 1 (Intl.PluralRules("es")).
+ */
+(function (m) {
+  m.es = {
+    "g.pinned": "Fijados",
+    "g.develop": "Desarrollo",
+    "g.verify": "Verificación",
+    "g.ship": "Entrega",
+    "n.workspaces": "Espacios de trabajo",
+    "n.graph": "Grafo",
+    "n.services": "Servicios",
+    "n.logs": "Registros",
+    "n.tests": "Pruebas",
+    "n.environments": "Entornos",
+    "n.releases": "Versiones",
+    "n.edge": "Edge",
+    "n.settings": "Ajustes",
+    "k.org": "Org",
+    "k.ws": "Espacio",
+    "k.env": "Entorno",
+    scope: "Ámbito",
+    "org.title": "Org: {title}",
+    "org.titleId": "Org: {title} ({id})",
+    "ws.all": "Todos los activos",
+    "ws.focus": "foco",
+    "ws.none": "No hay espacios de trabajo activos",
+    "ws.manage": "Gestionar espacios de trabajo…",
+    "ws.allN": "Todos los activos ({n})",
+    "ws.allTip":
+      "Todos los espacios de trabajo activos; un servicio que definen varios aparece una sola vez",
+    "ws.noneLabel": "ninguno",
+    "ws.viewTitle":
+      "Vista: lo que muestra cada página ({ws}). Es solo un filtro: no inicia, detiene ni enruta nada.",
+    "ws.viewTitleFocus":
+      "Vista: lo que muestra cada página ({ws}). Es solo un filtro: no inicia, detiene ni enruta nada, y el foco ({focus}) sigue siendo el destino de los comandos.",
+    "ws.setFocus": "Poner el foco en {ws}",
+    "ws.setFocusTip":
+      "Lo convierte en el destino por defecto de los comandos (escribe workspaces.yml)",
+    "ws.viewFailed": "No se pudo cambiar la vista: {msg}",
+    "ws.focusFailed": "No se pudo poner el foco: {msg}",
+    "org.n": "{n} espacios de trabajo",
+    "org.n.one": "{n} espacio de trabajo",
+    from: "de {d}",
+    "b.logs": "{n} abiertos",
+    "b.logs.one": "{n} abierto",
+    "b.down": "{n} caídos",
+    "b.down.one": "{n} caído",
+    "act.pin": "Fijar",
+    "act.unpin": "Quitar",
+    "act.pinX": "Fijar {s}",
+    "act.unpinX": "Quitar {s}",
+    "toast.pinned": "{s} fijado",
+    "toast.unpinned": "{s} ya no está fijado",
+    collapse: "Contraer",
+    expand: "Expandir",
+    menu: "Menú",
+    skip: "Saltar al contenido",
+    pages: "Páginas",
+    "search.ph": "Buscar páginas, servicios, acciones…",
+    "status.checking": "Comprobando…",
+    "status.none": "Sin servicios",
+    "status.unchecked": "{n} sin comprobar",
+    "status.all": "Los {n} en buen estado",
+    "status.all.one": "{n} en buen estado",
+    "status.some": "{ok}/{n} en buen estado",
+    "status.down": "{n} caídos",
+    "status.down.one": "{n} caído",
+    "status.title": "{n} comprobados",
+    "status.title.one": "{n} comprobado",
+    "status.pending": "{n} pendientes",
+    "status.pending.one": "{n} pendiente",
+    "status.awaiting": "{n} aún comprobándose",
+    "status.unknown": "Estado desconocido",
+    "status.unknownTip":
+      "El servidor de Den no responde, así que no se sabe el estado de los servicios",
+    "chk.awaiting": "aún comprobándose",
+    "chk.pending": "{what} — pendiente",
+    "chk.check": "comprobación",
+    "chk.unchecked": "sin comprobar",
+    "chk.healthy": "en buen estado",
+    "chk.down": "caído",
+    "chk.pendingWord": "pendiente",
+    "chk.checking": "comprobando…",
+    ms: "{n} ms",
+    "fix.failedAt": "{line} · falló a las {at}",
+    "fix.start": "Iniciar",
+    "fix.startX": "Iniciar {s}",
+    "fix.logs": "Registros",
+    "fix.logsX": "Registros de {s}",
+    "row.name": "{id}, {state}",
+    "row.nameMs": "{id}, {state}, {ms}",
+    "drawer.title": "Estado",
+    "drawer.refresh": "Comprobar de nuevo",
+    "drawer.close": "Cerrar",
+    "drawer.attention": "Requiere atención",
+    "drawer.nothing": "Nada requiere atención.",
+    "drawer.everything": "Todo",
+    "drawer.okTip": "{ok} de {n} servicios comprobados en buen estado",
+    "drawer.okTip.one": "{ok} de {n} servicio comprobado en buen estado",
+    "toast.openWs": "Abre Espacios de trabajo para ejecutarlo",
+    "kind.page": "Página",
+    "kind.service": "Servicio",
+    "kind.app": "App",
+    "kind.action": "Acción",
+    "kind.setting": "Ajuste",
+    "pal.repos": "{n} repositorios",
+    "pal.repos.one": "{n} repositorio",
+    "pal.restart": "Reiniciar {s}",
+    "pal.results": "Resultados",
+    "pal.move": "↑↓ para moverte",
+    "pal.open": "↵ para abrir",
+    "pal.close": "esc para cerrar",
+    "pal.none": "Sin coincidencias",
+    "pal.count": "{n} resultados",
+    "pal.count.one": "{n} resultado",
+    "runs.title": "Ejecuciones",
+    "runs.n": "{n} en ejecución",
+    "runs.aria": "Ejecuciones, {n} en ejecución",
+    "runs.last": "Última ejecución: {s}",
+    "runs.none": "Sin ejecuciones",
+    "runs.empty":
+      "Aún no se ha ejecutado nada. La salida de cualquier página aparece aquí.",
+    "runs.toast":
+      "Aún no se ha ejecutado nada. La salida de una página aparece aquí.",
+    "runs.all": "Todas",
+    "runs.allTip": "Se muestran las ejecuciones de {ws}; pulsa para ver todas",
+    "runs.allOn":
+      "Se muestran todas las ejecuciones; pulsa para ver solo las de {ws}",
+    "dock.done": "terminó en {s} s",
+    "dock.failed": "falló en {s} s",
+    "dock.close": "Ocultar ejecuciones",
+    "dock.show": "Mostrar ejecuciones",
+    "dock.copy": "Copiar",
+    "dock.copied": "¡Copiado!",
+    "dock.clear": "Borrar",
+    "dock.closeRun": "Cerrar {s}",
+    "dock.err": "falló",
+    "dock.last": "Última ejecución: {s} ↗",
+    "dock.resize": "Arrastra para cambiar el tamaño",
+    "lock.locked": "Bloqueado",
+    "lock.unlocked": "Desbloqueado",
+    "lock.title": "Desbloquea para iniciar, detener y reiniciar servicios",
+    "lock.nopw":
+      "sudo sin contraseña (NOPASSWD): no hace falta la contraseña de administrador",
+    "lock.session": "Desbloqueado durante esta sesión",
+    "lock.sessionDesc":
+      "Desbloqueado durante esta sesión: iniciar, detener y reiniciar funcionan en todas las páginas.",
+    "lock.cfg":
+      "Guardar la contraseña está desactivado: define secrets.provider y secrets.refs.sudo en {file}.",
+    "lock.update": "Actualizar la contraseña guardada",
+    "lock.saveTo": "Guardar en {s}",
+    "lock.pw": "Contraseña de administrador",
+    "lock.go": "Desbloquear",
+    "lock.checking": "Comprobando…",
+    "lock.note":
+      "Den la pide una vez por sesión. Los agentes no pueden desbloquear.",
+    "lock.again": "Escribir la contraseña de nuevo…",
+    "lock.saveFailed": "Desbloqueado, pero no se pudo guardar en {s}: {err}",
+    "lock.wrong": "Contraseña incorrecta; inténtalo de nuevo",
+    "lock.reqFailed": "La solicitud falló: ¿está en marcha el servidor?",
+    "v.title": "Ver el registro de cambios",
+    "cl.title": "Novedades",
+    "cl.close": "Cerrar",
+    "cl.gotIt": "Entendido",
+    "cl.none": "No hay entradas.",
+    "cl.copyMd": "Copiar como Markdown",
+    "cl.copyMdX": "Copiar v{v} como Markdown",
+    "cl.copySlack": "Copiar para Slack",
+    "cl.copySlackX": "Copiar v{v} para Slack",
+    "cl.copyFailed": "No se pudo copiar; inténtalo de nuevo",
+    "cl.latest": "Mostrar solo la última",
+    "cl.all": "Mostrar todas las versiones ({n} anteriores)",
+    "cl.all.one": "Mostrar todas las versiones ({n} anterior)",
+    "stale.title":
+      "Este servidor web de {cli} ejecuta código más antiguo que tu copia de trabajo: haz clic para reiniciarlo y cargar tus cambios. Los despliegues en curso siguen en GitHub; un registro de despliegue abierto se reconecta tras recargar.",
+    "stale.aria": "Servidor desactualizado: reiniciar",
+    "stale.label": "servidor desactualizado",
+    "stale.restart": "Reiniciar",
+    "restart.msg": "Reiniciando {cli} web…",
+    "restart.hint": "Reconectando: esta página se recargará sola.",
+    "restart.still":
+      "Sigue reiniciándose… si persiste, ejecuta {cmd} en una terminal y recarga.",
+    "um.label": "Apariencia",
+    "um.title": "Apariencia y tema",
+    "um.appearance": "Apariencia",
+    "um.system": "Sistema",
+    "um.dark": "Oscuro",
+    "um.light": "Claro",
+    "um.theme": "Tema",
+    "um.language": "Idioma",
+    "um.all": "Todos los ajustes",
+    "cmd.appearance": "Apariencia: {mode}",
+    "cmd.theme": "Tema: {name}",
+    "cmd.language": "Idioma: {name}",
+    "theme.orgDefault": "Predeterminado de la org ({name})",
+    "theme.pinned": "{name} (fijado)",
+    "theme.notInstalled":
+      "Tu tema {id} no está instalado, así que se usa {inUse}",
+    "theme.invalid":
+      "Tu tema {id} no es válido ({why}), así que se usa {inUse}",
+    "theme.invalidBare": "Tu tema {id} no es válido, así que se usa {inUse}",
+    "api.network": "El servidor de Den no respondió a {what}",
+    "api.failed": "{what} falló",
+    "api.request": "Solicitud {id}",
+    "api.retry": "Reintentar",
+    "api.copy": "Copiar detalles",
+    "api.copied": "Copiado",
+    "api.close": "Descartar",
+    "api.retried": "Hecho",
+    "net.down": "El servidor de Den no responde; reintentando",
+    "net.next": "próximo intento en {s} s",
+    "net.now": "Reintentar ahora",
+    "engine.stale":
+      "Den se actualizó a {onDisk}. Este servidor sigue ejecutando {loaded}. Reinícialo: {cli} web restart (o el reinicio de tu servicio).",
+    "engine.title": "Hay que reiniciar",
+    "err.404.title": "Página no encontrada",
+    "err.404.sub": "No hay nada en {path}",
+    "err.404.lead": "No hay ninguna página en esta dirección.",
+    "err.404.mean": "¿Querías decir {page}?",
+    "err.404.stale":
+      "Puede que esta página sea nueva en Den {onDisk}: el servidor sigue ejecutando {loaded}.",
+    "err.404.plugin":
+      "Esta página pertenece al plugin {name}, que no está instalado en esta distribución.",
+    "err.404.pluginLocked":
+      "Esta página pertenece al plugin {name}. Está en plugins.lock.json, pero faltan sus archivos.",
+    "err.404.pluginNoPage":
+      "El plugin {name} está instalado, pero no tiene ninguna página aquí.",
+    "err.404.workspaces": "Ir a Espacios de trabajo",
+    "err.404.search": "Buscar",
+    "err.404.pages": "Páginas",
+    "err.500.title": "Algo salió mal",
+    "err.500.sub": "{what} falló en el servidor",
+    "err.500.lead":
+      "El servidor tuvo un error al responder a esta página. Reintenta o copia los detalles para un informe: el registro del servidor tiene el error completo con el mismo id de solicitud.",
+    "err.500.what": "Qué falló",
+    "err.500.time": "Hora",
+    "err.500.id": "Id de solicitud",
+    "err.500.version": "Versión",
+    "err.422.title": "La configuración no es válida",
+    "err.422.sub": "La configuración de la distribución no pasa la validación",
+    "err.422.lead":
+      "Las páginas que leen la configuración esperan hasta que sea válida. Corrige cada clave de abajo; mientras tanto, Ajustes y Registros siguen funcionando.",
+    "err.422.file": "Archivo",
+    "err.422.key": "Clave",
+    "err.422.problem": "Problema",
+    "err.422.cmd": "Para ver lo mismo en una terminal, ejecuta:",
+    "err.422.reload": "Recargar cuando esté corregido",
+    "err.422.logs": "Abrir Registros",
+    "err.422.settings": "Abrir Ajustes",
+    "set.appearance.mode": "Modo",
+    "set.appearance.theme": "Tema",
+    "set.language": "Idioma",
+    "set.appearance.org-theme": "Tema predeterminado de la org",
+    "set.editor": "IDE predeterminado",
+    "set.editor_overrides": "IDE por lenguaje",
+    "set.terminal": "Terminal predeterminada",
+    "set.shell.pages": "Páginas",
+    "set.shell.pins": "Fijados",
+    "set.shell.collapsed": "Contraer la barra lateral",
+    "set.shell.dock": "Abrir el panel de ejecuciones",
+    "set.graph.workspaces": "Lista de espacios de trabajo",
+    "set.graph.groupBy": "Agrupar repositorios por",
+    "set.graph.direction": "Dirección",
+    "set.graph.group": "Marcos",
+    "set.graph.density": "Tarjetas",
+    "set.graph.panelWidth": "Panel de detalles",
+    "set.workspace.editor": "IDE de este espacio de trabajo",
+    "set.cli.local_dev": "Entorno local",
+    "set.cli.cli_tabs": "Pestañas de terminal",
+    "set.cli.log_window_lines": "Líneas del panel de registros",
+    "set.cli.web_port": "Tu puerto web",
+    "set.distribution.brand": "Nombre del producto",
+    "set.distribution.github_org": "Org de GitHub",
+    "set.distribution.orgs": "Etiquetas de org",
+    "set.distribution.web_port": "Puerto web",
+    "set.distribution.environments": "Entornos",
+    "set.distribution.domain": "Dominio de edge",
+    "err.retry": "Reintentar",
+    "err.copy": "Copiar detalles",
+    "err.copied": "Copiado",
+  };
+})((window.denMessages = window.denMessages || {}));