@skillcdn/console-plugin-messenger 0.0.0-stage → 0.1.0

package/dist/web/index.js

@@ -0,0 +1,1660 @@
+// ../../node_modules/.pnpm/@skillcdn+console@0.4.6_@types+react@19.3.0_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/@skillcdn/console/dist/vocabulary.js
+var WEEK_STARTS = ["auto", "monday", "sunday"];
+
+// ../../node_modules/.pnpm/@skillcdn+console@0.4.6_@types+react@19.3.0_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/@skillcdn/console/dist/plugin/bridge.js
+var PLUGIN_BRIDGE_VERSION = 1;
+var PLUGIN_WIDGET_SIZE_NAMES = ["small", "medium", "large", "wide", "full"];
+var BRIDGE_METHODS = [
+  "command",
+  "query",
+  "records.list",
+  "records.get",
+  "records.versions",
+  "files.get",
+  "files.put",
+  "people.picture"
+];
+var BRIDGE_EVENT_KINDS = ["records", "command", "plugin"];
+var MAX_BRIDGE_PATH_LENGTH = 2048;
+var MAX_BRIDGE_TITLE_LENGTH = 200;
+var MAX_ID_LENGTH = 128;
+var MAX_THEME_TOKENS = 500;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isLine(value, max) {
+  return typeof value === "string" && value.length > 0 && value.length <= max && !/[\r\n]/.test(value);
+}
+function isBridgePath(value) {
+  return typeof value === "string" && value.length <= MAX_BRIDGE_PATH_LENGTH && value.startsWith("/") && !value.startsWith("//") && !/[\s\\]/.test(value);
+}
+var OPENABLE_SCHEMES = /* @__PURE__ */ new Set(["https:", "http:", "mailto:"]);
+var MAX_BRIDGE_URL_LENGTH = 2048;
+function isBridgeUrl(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > MAX_BRIDGE_URL_LENGTH || /\s/.test(value) || [...value].some((character) => {
+    const code = character.codePointAt(0) ?? 0;
+    return code < 32 || code === 127;
+  }) || !URL.canParse(value)) {
+    return false;
+  }
+  return OPENABLE_SCHEMES.has(new URL(value).protocol);
+}
+function isTheme(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  const entries = Object.entries(value);
+  return entries.length <= MAX_THEME_TOKENS && entries.every(([token, text]) => /^--sc-[a-z0-9-]+$/.test(token) && typeof text === "string" && text.length <= 200);
+}
+function isWorkspace(value) {
+  return isRecord(value) && typeof value.name === "string" && Array.isArray(value.languages) && value.languages.every((language) => typeof language === "string") && isLine(value.timeZone, 100) && WEEK_STARTS.includes(value.weekStart) && typeof value.firstDay === "number" && Number.isInteger(value.firstDay) && value.firstDay >= 1 && value.firstDay <= 7;
+}
+function isEnvelope(value) {
+  return isRecord(value) && value.v === PLUGIN_BRIDGE_VERSION && typeof value.t === "string";
+}
+function isBridgeToFrame(value) {
+  if (!isEnvelope(value)) {
+    return false;
+  }
+  switch (value.t) {
+    case "init":
+      return isRecord(value.plugin) && isLine(value.plugin.key, 32) && isLine(value.plugin.version, 64) && (value.page === void 0 || isLine(value.page, 32)) && (value.widget === void 0 || isLine(value.widget, 32)) && (value.size === void 0 || PLUGIN_WIDGET_SIZE_NAMES.includes(value.size)) && (value.project === null || isRecord(value.project) && isLine(value.project.key, 64) && typeof value.project.name === "string") && isRecord(value.person) && typeof value.person.id === "string" && typeof value.person.login === "string" && (value.person.name === null || typeof value.person.name === "string") && typeof value.person.language === "string" && typeof value.person.admin === "boolean" && (value.workspace === void 0 || isWorkspace(value.workspace)) && Array.isArray(value.roles) && value.roles.every((role) => typeof role === "string") && typeof value.path === "string" && value.path.length <= MAX_BRIDGE_PATH_LENGTH && typeof value.language === "string" && isTheme(value.theme);
+    case "result":
+      return isLine(value.id, MAX_ID_LENGTH) && typeof value.ok === "boolean" && (value.error === void 0 || isRecord(value.error) && typeof value.error.code === "string" && typeof value.error.message === "string");
+    case "event":
+      return typeof value.kind === "string" && BRIDGE_EVENT_KINDS.includes(value.kind);
+    case "theme":
+      return isTheme(value.theme);
+    case "path":
+      return typeof value.path === "string" && value.path.length <= MAX_BRIDGE_PATH_LENGTH;
+    case "size":
+      return PLUGIN_WIDGET_SIZE_NAMES.includes(value.size);
+    default:
+      return false;
+  }
+}
+
+// ../../node_modules/.pnpm/@skillcdn+console@0.4.6_@types+react@19.3.0_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/@skillcdn/console/dist/plugin/web.js
+var PluginBridgeError = class extends Error {
+  code;
+  data;
+  constructor(error) {
+    super(error.message);
+    this.name = "PluginBridgeError";
+    this.code = error.code;
+    this.data = error.data;
+  }
+};
+var DEFAULT_CONNECT_MS = 1e4;
+var NO_PICTURE = /* @__PURE__ */ new Set([
+  "plugin.not_found",
+  "picture.refused",
+  "picture.unavailable"
+]);
+function globalWindow() {
+  const candidate = globalThis.window;
+  if (candidate === void 0) {
+    throw new PluginBridgeError({
+      code: "plugin.no_window",
+      message: "connect() runs in a plugin's frame, where window is"
+    });
+  }
+  return candidate;
+}
+function globalDocument() {
+  const candidate = globalThis.document;
+  if (candidate === void 0) {
+    throw new PluginBridgeError({
+      code: "plugin.no_window",
+      message: "connect() runs in a plugin's frame, where document is"
+    });
+  }
+  return candidate;
+}
+function applyTheme(document2, theme) {
+  for (const [token, value] of Object.entries(theme)) {
+    if (token.startsWith("--sc-")) {
+      document2.documentElement.style.setProperty(token, value);
+    }
+  }
+}
+function startHeightWatch(document2, post) {
+  const body = document2.body;
+  if (body === null) {
+    return () => {
+    };
+  }
+  let last = -1;
+  const say2 = () => {
+    const height = Math.ceil(body.scrollHeight);
+    if (height !== last) {
+      last = height;
+      post(height);
+    }
+  };
+  say2();
+  const observerClass = globalThis.ResizeObserver;
+  const elementClass = globalThis.Element;
+  if (observerClass !== void 0 && elementClass !== void 0 && body instanceof elementClass) {
+    const observer = new observerClass(say2);
+    observer.observe(body);
+    return () => observer.disconnect();
+  }
+  const timer = setInterval(say2, 500);
+  return () => clearInterval(timer);
+}
+function connect(options = {}) {
+  const win = options.window ?? globalWindow();
+  const doc = options.document ?? globalDocument();
+  const origin = doc.documentElement.dataset.console;
+  if (origin === void 0 || origin.length === 0) {
+    return Promise.reject(new PluginBridgeError({
+      code: "plugin.no_console",
+      message: "the document names no console in data-console; this is not a plugin's frame"
+    }));
+  }
+  const post = (message, transfer) => {
+    win.parent.postMessage(message, origin, transfer);
+  };
+  const pending = /* @__PURE__ */ new Map();
+  const eventHandlers = /* @__PURE__ */ new Set();
+  const themeHandlers = /* @__PURE__ */ new Set();
+  const pathHandlers = /* @__PURE__ */ new Set();
+  const sizeHandlers = /* @__PURE__ */ new Set();
+  const subscribed = /* @__PURE__ */ new Set();
+  const pictures = /* @__PURE__ */ new Map();
+  let counter = 0;
+  let stopHeight;
+  return new Promise((resolveConnect, rejectConnect) => {
+    let connected = false;
+    const timer = setTimeout(() => {
+      if (!connected) {
+        win.removeEventListener("message", listener);
+        rejectConnect(new PluginBridgeError({
+          code: "plugin.no_init",
+          message: `the console's page did not answer within ${options.timeoutMs ?? DEFAULT_CONNECT_MS} ms`
+        }));
+      }
+    }, options.timeoutMs ?? DEFAULT_CONNECT_MS);
+    const call = (method, params, transfer) => {
+      if (!BRIDGE_METHODS.includes(method)) {
+        return Promise.reject(new PluginBridgeError({
+          code: "plugin.forbidden",
+          message: `${method} is not a method of the bridge`
+        }));
+      }
+      counter += 1;
+      const id = String(counter);
+      return new Promise((resolve, reject) => {
+        pending.set(id, { resolve, reject });
+        post({ v: PLUGIN_BRIDGE_VERSION, t: "call", id, method, params }, transfer);
+      });
+    };
+    const listener = (event) => {
+      if (event.source !== win.parent || event.origin !== origin || !isBridgeToFrame(event.data)) {
+        return;
+      }
+      const message = event.data;
+      switch (message.t) {
+        case "init": {
+          if (connected) {
+            return;
+          }
+          connected = true;
+          clearTimeout(timer);
+          applyTheme(doc, message.theme);
+          doc.documentElement.lang = message.language;
+          const { v: _v, t: _t, ...context } = message;
+          const frame = {
+            context,
+            call: (method, params) => call(method, params),
+            command: (name, args = {}) => call("command", { name, args }),
+            query: (name, args = {}) => call("query", { name, args }),
+            records: {
+              list: (collection, query = {}) => call("records.list", { collection, ...query }),
+              get: (collection, id, version) => call("records.get", version === void 0 ? { collection, id } : { collection, id, version }),
+              versions: (collection, id) => call("records.versions", { collection, id })
+            },
+            files: {
+              get: (id) => call("files.get", { id }),
+              put: (bytes, name, type) => {
+                const buffer = bytes instanceof Uint8Array ? bytes.slice().buffer : bytes;
+                return call("files.put", { bytes: buffer, name, type }, [buffer]);
+              }
+            },
+            people: {
+              picture: (id) => {
+                const kept = pictures.get(id);
+                if (kept !== void 0) {
+                  return kept;
+                }
+                const asked = call("people.picture", { id }).then(({ type, bytes }) => URL.createObjectURL(new Blob([bytes], { type })), (error) => {
+                  if (error instanceof PluginBridgeError && NO_PICTURE.has(error.code)) {
+                    return null;
+                  }
+                  pictures.delete(id);
+                  throw error;
+                });
+                pictures.set(id, asked);
+                return asked;
+              }
+            },
+            navigate: (path) => {
+              if (!isBridgePath(path)) {
+                throw new PluginBridgeError({
+                  code: "plugin.forbidden",
+                  message: "navigate takes a path of the console's, never a URL"
+                });
+              }
+              post({ v: PLUGIN_BRIDGE_VERSION, t: "navigate", path });
+            },
+            open: (url) => {
+              if (!isBridgeUrl(url)) {
+                throw new PluginBridgeError({
+                  code: "plugin.forbidden",
+                  message: "open takes a web or a mail address; navigate takes a path of the console's"
+                });
+              }
+              if (win.navigator?.userActivation?.isActive === false) {
+                throw new PluginBridgeError({
+                  code: "plugin.forbidden",
+                  message: "open opens a link right after a person pressed in the frame, and not otherwise"
+                });
+              }
+              win.open?.(url, "_blank", "noopener,noreferrer");
+            },
+            download: (id) => post({ v: PLUGIN_BRIDGE_VERSION, t: "download", id }),
+            setTitle: (text) => {
+              const title = text.slice(0, MAX_BRIDGE_TITLE_LENGTH).replace(/[\r\n]+/g, " ");
+              doc.title = title;
+              post({ v: PLUGIN_BRIDGE_VERSION, t: "title", text: title });
+            },
+            onEvent: (kinds, handler) => {
+              eventHandlers.add(handler);
+              let added = false;
+              for (const kind of kinds) {
+                if (!subscribed.has(kind)) {
+                  subscribed.add(kind);
+                  added = true;
+                }
+              }
+              if (added) {
+                post({ v: PLUGIN_BRIDGE_VERSION, t: "subscribe", kinds: [...subscribed] });
+              }
+              return () => eventHandlers.delete(handler);
+            },
+            onTheme: (handler) => {
+              themeHandlers.add(handler);
+              return () => themeHandlers.delete(handler);
+            },
+            onPath: (handler) => {
+              pathHandlers.add(handler);
+              return () => pathHandlers.delete(handler);
+            },
+            onSize: (handler) => {
+              sizeHandlers.add(handler);
+              return () => sizeHandlers.delete(handler);
+            },
+            close: () => {
+              win.removeEventListener("message", listener);
+              stopHeight?.();
+              for (const { reject } of pending.values()) {
+                reject(new PluginBridgeError({
+                  code: "plugin.closed",
+                  message: "the frame closed its connection"
+                }));
+              }
+              pending.clear();
+            }
+          };
+          if (options.resize !== false) {
+            stopHeight = startHeightWatch(doc, (height) => post({ v: PLUGIN_BRIDGE_VERSION, t: "resize", height }));
+          }
+          resolveConnect(frame);
+          return;
+        }
+        case "result": {
+          const waiting = pending.get(message.id);
+          if (waiting === void 0) {
+            return;
+          }
+          pending.delete(message.id);
+          if (message.ok) {
+            waiting.resolve(message.value);
+          } else {
+            waiting.reject(new PluginBridgeError(message.error ?? { code: "plugin.failed", message: "the call failed" }));
+          }
+          return;
+        }
+        case "event":
+          for (const handler of eventHandlers) {
+            handler(message.kind, message.data);
+          }
+          return;
+        case "theme":
+          applyTheme(doc, message.theme);
+          for (const handler of themeHandlers) {
+            handler(message.theme);
+          }
+          return;
+        case "path":
+          for (const handler of pathHandlers) {
+            handler(message.path);
+          }
+          return;
+        case "size":
+          for (const handler of sizeHandlers) {
+            handler(message.size);
+          }
+          return;
+        default:
+          return;
+      }
+    };
+    win.addEventListener("message", listener);
+    post({ v: PLUGIN_BRIDGE_VERSION, t: "ready" });
+  });
+}
+
+// src/shared/contracts.ts
+var LANGUAGES = ["en", "ko"];
+function languageOf(tag) {
+  const primary = (tag ?? "").toLowerCase().split("-")[0] ?? "";
+  return LANGUAGES.includes(primary) ? primary : "en";
+}
+var ROUTE_KINDS = ["hr:leave-approved"];
+var ROUTE_AS = ["person", "app"];
+var SECRETS = [
+  "slackConfigToken",
+  "slackConfigRefreshToken",
+  "slackClientSecret",
+  "slackSigningSecret",
+  "slackBotToken"
+];
+var NOTES = [
+  "thread",
+  "nobody",
+  "next_step",
+  "approved",
+  "approved_partly",
+  "rejected",
+  "returned",
+  "cancel_asked",
+  "cancelled",
+  "kept",
+  "no_thread",
+  "not_leave",
+  "not_connected",
+  "no_capability",
+  "outside",
+  "no_grant",
+  "hidden",
+  "slack",
+  "console",
+  "rate_limited",
+  "failed"
+];
+
+// src/web/ui.ts
+var PREFIX = "pl-messenger-";
+var DASH = "\u2014";
+function el(tag, classes = "", text) {
+  const node = document.createElement(tag);
+  if (classes.length > 0) {
+    node.className = classes.split(/\s+/).filter((name) => name.length > 0).map((name) => name.startsWith("sc-") ? name : `${PREFIX}${name}`).join(" ");
+  }
+  if (text !== void 0) {
+    node.textContent = text;
+  }
+  return node;
+}
+function button(label, onClick, kind = "secondary", small = false) {
+  const node = el("button", `sc-button sc-button-${kind}${small ? " sc-button-sm" : ""}`, label);
+  node.type = "button";
+  node.addEventListener("click", onClick);
+  return node;
+}
+function submitButton(label, kind = "primary") {
+  const node = el("button", `sc-button sc-button-${kind}`, label);
+  node.type = "submit";
+  return node;
+}
+function input(type, attributes = {}) {
+  const node = el("input", "sc-input control");
+  node.type = type;
+  if (attributes.value !== void 0) {
+    node.value = attributes.value;
+  }
+  if (attributes.placeholder !== void 0) {
+    node.placeholder = attributes.placeholder;
+  }
+  if (attributes.maxLength !== void 0) {
+    node.maxLength = attributes.maxLength;
+  }
+  return node;
+}
+function select(options, value) {
+  const node = el("select", "sc-input control");
+  for (const option of options) {
+    const item = document.createElement("option");
+    item.value = option.value;
+    item.textContent = option.label;
+    node.append(item);
+  }
+  if (value !== void 0) {
+    node.value = value;
+  }
+  return node;
+}
+var groupCount = 0;
+function pills(options, initial, label, onChange) {
+  groupCount += 1;
+  const name = `${PREFIX}choice-${groupCount}`;
+  const node = el("fieldset", "sc-toggle-chips pills");
+  node.setAttribute("aria-label", label);
+  const boxes = /* @__PURE__ */ new Map();
+  for (const option of options) {
+    const chip = el("label", "sc-toggle-chip pill");
+    const box = document.createElement("input");
+    box.type = "radio";
+    box.name = name;
+    box.checked = option.value === initial;
+    box.addEventListener("change", () => {
+      if (box.checked) {
+        onChange?.(option.value);
+      }
+    });
+    boxes.set(option.value, box);
+    chip.append(box, el("span", "", option.label));
+    node.append(chip);
+  }
+  return {
+    node,
+    value: () => {
+      for (const [key, box] of boxes) {
+        if (box.checked) {
+          return key;
+        }
+      }
+      return initial;
+    }
+  };
+}
+function optionCards(options, initial, label) {
+  groupCount += 1;
+  const name = `${PREFIX}choice-${groupCount}`;
+  const node = el("fieldset", "option-cards");
+  node.setAttribute("aria-label", label);
+  const boxes = /* @__PURE__ */ new Map();
+  for (const option of options) {
+    const card = el("label", "option-card");
+    const box = document.createElement("input");
+    box.type = "radio";
+    box.name = name;
+    box.checked = option.value === initial;
+    boxes.set(option.value, box);
+    const text = el("span", "option-card-text");
+    text.append(el("span", "option-card-label", option.label));
+    if (option.hint !== void 0) {
+      text.append(el("span", "option-card-hint", option.hint));
+    }
+    card.append(box, text);
+    node.append(card);
+  }
+  return {
+    node,
+    value: () => {
+      for (const [key, box] of boxes) {
+        if (box.checked) {
+          return key;
+        }
+      }
+      return initial;
+    }
+  };
+}
+function field(label, control, hint) {
+  const wrapper = el("label", "sc-field");
+  wrapper.append(el("span", "sc-field-label", label), control);
+  if (hint !== void 0) {
+    wrapper.append(el("span", "sc-field-hint", hint));
+  }
+  return wrapper;
+}
+function group(label, ...controls) {
+  const wrapper = el("div", "sc-field");
+  wrapper.append(el("span", "sc-field-label", label), ...controls);
+  return wrapper;
+}
+function form(...children) {
+  const node = el("form", "sc-form");
+  node.append(...children);
+  return node;
+}
+function actions(...children) {
+  const node = el("div", "sc-form-actions");
+  node.append(...children);
+  return node;
+}
+function badge(text, tone) {
+  return el("span", `sc-badge sc-badge-${tone}`, text);
+}
+function pageHead(title, lead, ...buttons) {
+  const node = el("div", "sc-page-head head");
+  const heading = el("div", "sc-page-heading");
+  heading.append(el("h1", "sc-page-title", title));
+  if (lead.length > 0) {
+    heading.append(el("p", "sc-page-lead", lead));
+  }
+  node.append(heading);
+  if (buttons.length > 0) {
+    const side = el("div", "sc-page-actions");
+    side.append(...buttons);
+    node.append(side);
+  }
+  return node;
+}
+function panel(title, ...children) {
+  const node = el("section", "sc-panel panel");
+  if (title !== null) {
+    node.append(el("h2", "panel-title", title));
+  }
+  node.append(...children);
+  return node;
+}
+function panelWith(title, controls, ...children) {
+  const node = el("section", "sc-panel panel");
+  const head = el("div", "panel-head");
+  head.append(el("h2", "panel-title", title), ...controls);
+  node.append(head, ...children);
+  return node;
+}
+function empty(text, title) {
+  const node = el("div", "sc-empty");
+  if (title !== void 0) {
+    node.append(el("p", "sc-empty-title", title));
+  }
+  node.append(el("p", "sc-empty-body", text));
+  return node;
+}
+function callout(title, body, tone = "info") {
+  const node = el("div", `sc-callout callout${tone === "info" ? "" : ` sc-callout-${tone}`}`);
+  const text = el("div", "");
+  text.append(el("p", "sc-callout-title", title));
+  if (body !== void 0) {
+    text.append(el("p", "sc-callout-body", body));
+  }
+  node.append(text);
+  return node;
+}
+function muted(text) {
+  return el("p", "sc-muted line", text);
+}
+function factsRow(pairs) {
+  const node = el("dl", "sc-facts-row");
+  for (const [label, value] of pairs) {
+    const item = el("div", "");
+    const detail = el("dd", "");
+    detail.append(value);
+    item.append(el("dt", "", label), detail);
+    node.append(item);
+  }
+  return node;
+}
+function table(headers, rows) {
+  const wrapper = el("div", "scroll");
+  const node = el("table", "table");
+  const head = document.createElement("thead");
+  const headRow = document.createElement("tr");
+  for (const header of headers) {
+    headRow.append(el("th", "", header));
+  }
+  head.append(headRow);
+  const body = document.createElement("tbody");
+  body.append(...rows);
+  node.append(head, body);
+  wrapper.append(node);
+  return wrapper;
+}
+function row(cells) {
+  const node = document.createElement("tr");
+  for (const content of cells) {
+    const cellNode = document.createElement("td");
+    cellNode.append(content);
+    node.append(cellNode);
+  }
+  return node;
+}
+function personLabel(person) {
+  return person.name ?? person.login;
+}
+function avatar(frame, person) {
+  const node = el(
+    "span",
+    "sc-avatar sc-avatar-sm sc-avatar-initial avatar",
+    personLabel(person).trim().slice(0, 1).toUpperCase()
+  );
+  node.title = personLabel(person);
+  void frame.people.picture(person.id).then((address) => {
+    if (address !== null) {
+      const image = el("img", "sc-avatar sc-avatar-sm avatar");
+      image.src = address;
+      image.alt = "";
+      image.title = personLabel(person);
+      node.replaceWith(image);
+    }
+  }).catch(() => {
+  });
+  return node;
+}
+function who(frame, person) {
+  const node = el("span", "who");
+  const text = el("span", "who-text");
+  text.append(el("span", "who-name", personLabel(person)));
+  if (person.name !== null) {
+    text.append(el("span", "who-sub", person.login));
+  }
+  node.append(avatar(frame, person), text);
+  return node;
+}
+function intlLanguage(language) {
+  try {
+    return Intl.getCanonicalLocales(language)[0] ?? "en";
+  } catch {
+    return "en";
+  }
+}
+function dateTimeIn(language) {
+  const format = new Intl.DateTimeFormat(intlLanguage(language), {
+    dateStyle: "medium",
+    timeStyle: "short"
+  });
+  return (iso) => {
+    if (iso === null) {
+      return DASH;
+    }
+    const at = new Date(iso);
+    return Number.isNaN(at.getTime()) ? iso : format.format(at);
+  };
+}
+function errorText(error, words) {
+  return error instanceof Error && error.message.length > 0 ? error.message : words.failed;
+}
+function statusLine() {
+  return el("p", "status");
+}
+function say(status, text, kind) {
+  status.textContent = text;
+  status.className = kind === "error" ? `${PREFIX}status sc-form-error` : `${PREFIX}status ${PREFIX}ok`;
+}
+function clear(status) {
+  status.textContent = "";
+  status.className = `${PREFIX}status`;
+}
+async function runCommand(frame, trigger, status, words, name, args = {}) {
+  trigger.disabled = true;
+  clear(status);
+  try {
+    const result = await frame.command(name, args);
+    say(status, result.text, "ok");
+    return result;
+  } catch (error) {
+    say(status, errorText(error, words), "error");
+    return null;
+  } finally {
+    trigger.disabled = false;
+  }
+}
+function onSubmit(target, handler) {
+  target.addEventListener("submit", (event) => {
+    event.preventDefault();
+    void handler();
+  });
+}
+function watch(frame, refresh) {
+  let timer;
+  frame.onEvent(["records", "command", "plugin"], () => {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      void refresh();
+    }, 150);
+  });
+}
+function sequenced(load) {
+  let current = 0;
+  return async () => {
+    current += 1;
+    const mine = current;
+    await load(() => mine === current);
+  };
+}
+function page() {
+  return el("div", "page");
+}
+function toolbar(...children) {
+  const node = el("div", "toolbar");
+  node.append(...children);
+  return node;
+}
+function errorBlock(error, words) {
+  const node = el("div", "sc-callout sc-callout-danger callout");
+  node.append(el("p", "sc-callout-body", errorText(error, words)));
+  return node;
+}
+
+// src/web/pages/activity.ts
+var OUTCOMES = ["sent", "skipped", "failed"];
+function noteIn(words, note) {
+  const at = note.indexOf(":");
+  const code = at < 0 ? note : note.slice(0, at);
+  const detail = at < 0 ? "" : note.slice(at + 1);
+  return NOTES.includes(code) ? words.activity.notes[code](detail) : note;
+}
+var TONES = {
+  sent: "success",
+  skipped: "neutral",
+  failed: "danger"
+};
+async function renderActivity(root2, frame, words) {
+  const w = words.activity;
+  const when = dateTimeIn(frame.context.language);
+  const node = page();
+  root2.replaceChildren(node);
+  let chosen = "all";
+  const draw = sequenced(async (fresh) => {
+    let rows;
+    try {
+      rows = await frame.query("activity", {
+        ...chosen === "all" ? {} : { outcome: chosen },
+        limit: 100
+      });
+    } catch (error) {
+      node.replaceChildren(errorBlock(error, words));
+      return;
+    }
+    if (!fresh()) {
+      return;
+    }
+    const filter = pills(
+      [
+        { value: "all", label: w.all },
+        ...OUTCOMES.map((outcome) => ({ value: outcome, label: w.outcomes[outcome] }))
+      ],
+      chosen,
+      w.outcome,
+      (value) => {
+        chosen = value;
+        void draw();
+      }
+    );
+    const lines = rows.map(
+      (line) => row([
+        when(line.at),
+        w.kinds[line.kind] ?? line.kind,
+        badge(w.outcomes[line.outcome], TONES[line.outcome]),
+        noteIn(words, line.note),
+        String(line.attempt)
+      ])
+    );
+    node.replaceChildren(
+      pageHead(w.title, w.lead),
+      panelWith(
+        w.title,
+        [filter.node],
+        lines.length === 0 ? empty(w.none) : table([w.when, w.event, w.outcome, w.note, w.attempt], lines)
+      )
+    );
+  });
+  await draw();
+  watch(frame, draw);
+}
+
+// src/web/pages/connection.ts
+var SETTINGS = "/settings/plugins/messenger";
+function step(done, title, words, ...body) {
+  const item = el("li", `step${done ? " step-done" : ""}`);
+  const head = el("div", "step-head");
+  head.append(
+    el("span", "step-title", title),
+    badge(done ? words.connection.done : words.connection.todo, done ? "success" : "neutral")
+  );
+  const content = el("div", "step-body");
+  content.append(...body);
+  item.append(head, content);
+  return item;
+}
+function build(frame, words, status) {
+  const w = words.connection;
+  const when = dateTimeIn(frame.context.language);
+  const connection = status.connection;
+  const connected = connection?.phase === "connected";
+  const parts = [pageHead(w.title, w.lead)];
+  if (connection?.problem !== null && connection?.problem !== void 0) {
+    parts.push(
+      callout(w.problem, `${connection.problem} (${when(connection.problemAt)})`, "warning")
+    );
+  }
+  if (status.failures > 0) {
+    parts.push(callout(w.failures(String(status.failures)), void 0, "warning"));
+  }
+  const addressOk = status.address.state === "ok";
+  const addressStep = step(
+    addressOk,
+    w.address,
+    words,
+    toolbar(
+      el("span", "mono", status.address.url ?? DASH),
+      badge(w.addressState[status.address.state], addressOk ? "success" : "warning")
+    ),
+    muted(w.addressHint[status.address.state])
+  );
+  const token = status.secrets.slackConfigToken;
+  const tokenText = !token.set ? w.tokenMissing : token.expiresAt === null ? w.tokenPasted : w.tokenSet(when(token.expiresAt));
+  const tokenStep = step(
+    token.set,
+    w.token,
+    words,
+    muted(tokenText),
+    toolbar(button(words.openSettings, () => frame.navigate(SETTINGS), "secondary", true))
+  );
+  const made = connection !== null && connection.appId !== null;
+  const language = pills(
+    LANGUAGES.map((value) => ({ value, label: words.languages[value] })),
+    connection?.language ?? languageOf(frame.context.workspace?.languages?.[0]),
+    w.appLanguage
+  );
+  const makeStatus = statusLine();
+  const make = button(
+    made ? w.update : w.make,
+    () => {
+      void runCommand(frame, make, makeStatus, words, "connect", { language: language.value() });
+    },
+    made ? "secondary" : "primary"
+  );
+  make.disabled = !addressOk || !token.set;
+  const appStep = step(
+    made,
+    w.app,
+    words,
+    muted(
+      made && connection?.appId !== null && connection?.appId !== void 0 ? w.appMade(connection.appId) : w.appMissing
+    ),
+    field(w.appLanguage, language.node),
+    toolbar(make),
+    makeStatus
+  );
+  const installBody = [];
+  if (connected) {
+    installBody.push(muted(w.installed(connection?.teamName ?? connection?.teamId ?? DASH)));
+    if (connection?.connectedBy !== null && connection?.connectedBy !== void 0) {
+      installBody.push(
+        muted(
+          w.installedBy(
+            connection.connectedBy.name ?? connection.connectedBy.login,
+            when(connection.connectedAt)
+          )
+        )
+      );
+    }
+  } else {
+    installBody.push(muted(w.notInstalled));
+    const installStatus = statusLine();
+    if (status.authorizeUrl !== null) {
+      const url = status.authorizeUrl;
+      installBody.push(toolbar(button(w.installOpen, () => frame.open(url), "primary")));
+    } else {
+      const prepare = button(w.installPrepare, () => {
+        void runCommand(frame, prepare, installStatus, words, "connect", {
+          language: language.value()
+        });
+      });
+      prepare.disabled = !made || !addressOk || !token.set;
+      installBody.push(toolbar(prepare));
+    }
+    installBody.push(muted(w.installHint), installStatus);
+  }
+  const installStep = step(connected, w.install, words, ...installBody);
+  const steps = el("ol", "steps");
+  steps.append(addressStep, tokenStep, appStep, installStep);
+  parts.push(panel(w.steps, steps));
+  if (connection !== null && connection.appId !== null) {
+    const secrets = SECRETS.map((name) => {
+      const secret = status.secrets[name];
+      const stood = !secret.set ? w.secretUnset : secret.source === "administrator" ? w.secretPasted : w.secretFrom(secret.source ?? DASH);
+      return row([
+        w.secretNames[name],
+        badge(stood, secret.set ? "success" : "neutral"),
+        secret.expiresAt === null ? DASH : w.expires(when(secret.expiresAt))
+      ]);
+    });
+    parts.push(
+      panel(
+        w.details,
+        factsRow([
+          [w.workspace, connection.teamName ?? DASH],
+          [w.bot, connection.botUserId ?? DASH],
+          [w.shortcut, connection.shortcut ? w.shortcutOn : w.shortcutOff],
+          [w.renewed, when(connection.rotatedAt)]
+        ]),
+        el("h3", "subheading", w.secrets),
+        table(["", "", ""], secrets)
+      )
+    );
+  }
+  const hr = status.hr;
+  const granted = hr.asked.every((role) => hr.granted.includes(role));
+  const hrParts = [
+    toolbar(badge(w.hrState[hr.state], hr.state === "on" ? "success" : "neutral")),
+    muted(w.hrHint[hr.state])
+  ];
+  if (hr.version !== null) {
+    hrParts.push(muted(w.hrVersion(hr.version, hr.range)));
+  }
+  hrParts.push(
+    toolbar(
+      el("span", "label", w.hrRole),
+      badge(granted ? w.hrGranted : w.hrNotGranted, granted ? "success" : "warning")
+    )
+  );
+  if (!granted || hr.state === "no_capability") {
+    hrParts.push(
+      muted(w.hrGrantHint),
+      toolbar(button(words.openSettings, () => frame.navigate(SETTINGS), "secondary", true))
+    );
+  }
+  parts.push(panel(w.hr, ...hrParts));
+  if (connection !== null && connection.appId !== null) {
+    const tryParts = [];
+    if (connected) {
+      const channel = input("text", { placeholder: "C0123ABCD", maxLength: 40 });
+      const testStatus = statusLine();
+      const send = button(w.test, () => {
+        const value = channel.value.trim();
+        void runCommand(
+          frame,
+          send,
+          testStatus,
+          words,
+          "test",
+          value.length > 0 ? { channel: value } : {}
+        );
+      });
+      tryParts.push(
+        field(w.testChannel, channel, w.testChannelHint),
+        toolbar(send),
+        testStatus,
+        el("hr", "rule")
+      );
+    }
+    const outStatus = statusLine();
+    let armed = false;
+    const out = button(
+      w.disconnect,
+      () => {
+        if (!armed) {
+          armed = true;
+          out.textContent = w.disconnectSure;
+          return;
+        }
+        void runCommand(frame, out, outStatus, words, "disconnect");
+      },
+      "danger"
+    );
+    parts.push(
+      panel(
+        connected ? w.tryIt : w.disconnect,
+        ...tryParts,
+        muted(w.disconnectHint),
+        toolbar(out),
+        outStatus
+      )
+    );
+  }
+  return parts;
+}
+async function renderConnection(root2, frame, words) {
+  const node = page();
+  root2.replaceChildren(node);
+  const draw = sequenced(async (fresh) => {
+    let status;
+    try {
+      status = await frame.query("status");
+    } catch (error) {
+      node.replaceChildren(errorBlock(error, words));
+      return;
+    }
+    if (fresh()) {
+      node.replaceChildren(...build(frame, words, status));
+    }
+  });
+  await draw();
+  watch(frame, draw);
+}
+
+// src/web/pages/people.ts
+var STATES = ["no_email", "no_account", "not_checked", "matched"];
+var TONES2 = {
+  matched: "success",
+  no_email: "warning",
+  no_account: "neutral",
+  not_checked: "neutral"
+};
+async function renderPeople(root2, frame, words) {
+  const w = words.people;
+  const when = dateTimeIn(frame.context.language);
+  const node = page();
+  root2.replaceChildren(node);
+  let chosen = "all";
+  const draw = sequenced(async (fresh) => {
+    let report;
+    try {
+      report = await frame.query("people", {
+        ...chosen === "all" ? {} : { state: chosen },
+        limit: 200
+      });
+    } catch (error) {
+      node.replaceChildren(errorBlock(error, words));
+      return;
+    }
+    if (!fresh()) {
+      return;
+    }
+    const matchStatus = statusLine();
+    const matchNow = button(w.matchNow, () => {
+      void runCommand(frame, matchNow, matchStatus, words, "match");
+    });
+    matchNow.disabled = !report.connected;
+    const parts = [pageHead(w.title, w.lead, matchNow)];
+    parts.push(matchStatus);
+    if (!report.connected) {
+      parts.push(callout(w.notConnected, void 0, "warning"));
+    }
+    parts.push(
+      factsRow([
+        [
+          w.lastMatched,
+          report.matchedAt === null ? w.neverMatched : w.matchedAt(when(report.matchedAt))
+        ],
+        ...STATES.map((state) => [w.states[state], String(report.counts[state])])
+      ])
+    );
+    const filter = pills(
+      [
+        { value: "all", label: w.all },
+        ...STATES.map((state) => ({
+          value: state,
+          label: `${w.states[state]} ${report.counts[state]}`
+        }))
+      ],
+      chosen,
+      w.state,
+      (value) => {
+        chosen = value;
+        void draw();
+      }
+    );
+    const rows = report.people.map(
+      (match) => row([
+        who(frame, match.person),
+        badge(w.states[match.state], TONES2[match.state]),
+        match.slack === null ? muted(w.stateHints[match.state]) : match.slack.name
+      ])
+    );
+    parts.push(
+      panelWith(
+        w.title,
+        [filter.node],
+        rows.length === 0 ? empty(w.nobody) : table([w.person, w.state, w.account], rows),
+        ...report.total > report.people.length ? [muted(w.more(String(report.people.length), String(report.total)))] : []
+      )
+    );
+    node.replaceChildren(...parts);
+  });
+  await draw();
+  watch(frame, draw);
+}
+
+// src/web/pages/routes.ts
+function routeRows(frame, words, routes) {
+  const w = words.routes;
+  return routes.map((route) => {
+    const status = statusLine();
+    const remove = button(
+      w.remove,
+      () => {
+        void runCommand(frame, remove, status, words, "unroute", { id: route.id });
+      },
+      "ghost",
+      true
+    );
+    const cellContent = document.createElement("span");
+    cellContent.append(remove, status);
+    return row([
+      w.kinds[route.kind],
+      `#${route.channelName}`,
+      words.languages[route.language],
+      w.asNames[route.as],
+      cellContent
+    ]);
+  });
+}
+function addForm(frame, words, language, connected) {
+  const w = words.routes;
+  const kind = select(
+    ROUTE_KINDS.map((value) => ({ value, label: w.kinds[value] })),
+    ROUTE_KINDS[0]
+  );
+  const kindHint = muted(w.kindHints[ROUTE_KINDS[0]]);
+  kind.addEventListener("change", () => {
+    kindHint.textContent = w.kindHints[kind.value] ?? "";
+  });
+  const channel = select([{ value: "", label: connected ? w.channelPick : w.connectFirst }], "");
+  channel.disabled = true;
+  const said = statusLine();
+  if (connected) {
+    void frame.query("channels").then((answer) => {
+      const channels = answer;
+      channel.replaceChildren();
+      const first = document.createElement("option");
+      first.value = "";
+      first.textContent = channels.length === 0 ? w.noChannels : w.channelPick;
+      channel.append(first);
+      for (const found of channels) {
+        const option = document.createElement("option");
+        option.value = found.id;
+        option.textContent = found.private ? `#${found.name} (${w.channelPrivate})` : `#${found.name}`;
+        channel.append(option);
+      }
+      channel.disabled = channels.length === 0;
+    }).catch((error) => {
+      say(said, errorText(error, words), "error");
+    });
+  }
+  const languages = pills(
+    LANGUAGES.map((value) => ({ value, label: words.languages[value] })),
+    language,
+    w.language
+  );
+  const as = optionCards(
+    ROUTE_AS.map((value) => ({ value, label: w.asNames[value], hint: w.asHints[value] })),
+    "person",
+    w.as
+  );
+  const submit = submitButton(w.save);
+  submit.disabled = !connected;
+  const node = form(
+    field(w.kind, kind),
+    kindHint,
+    field(w.channel, channel),
+    group(w.language, languages.node),
+    group(w.as, as.node),
+    actions(submit),
+    said
+  );
+  onSubmit(node, async () => {
+    if (channel.value === "") {
+      say(said, w.channelPick, "error");
+      return;
+    }
+    await runCommand(frame, submit, said, words, "route", {
+      channel: channel.value,
+      kind: kind.value,
+      language: languages.value(),
+      as: as.value()
+    });
+  });
+  return panel(w.add, node);
+}
+async function renderRoutes(root2, frame, words) {
+  const w = words.routes;
+  const node = page();
+  root2.replaceChildren(node);
+  const draw = sequenced(async (fresh) => {
+    let routes;
+    let status;
+    try {
+      [routes, status] = await Promise.all([
+        frame.query("routes"),
+        frame.query("status")
+      ]);
+    } catch (error) {
+      node.replaceChildren(errorBlock(error, words));
+      return;
+    }
+    if (!fresh()) {
+      return;
+    }
+    const connected = status.connection?.phase === "connected";
+    const parts = [pageHead(w.title, w.lead)];
+    if (!connected) {
+      parts.push(callout(w.notConnected, void 0, "warning"));
+    }
+    parts.push(
+      panel(
+        w.list,
+        routes.length === 0 ? empty(w.none) : table([w.kind, w.channel, w.language, w.as, ""], routeRows(frame, words, routes))
+      )
+    );
+    parts.push(
+      addForm(frame, words, languageOf(frame.context.workspace?.languages?.[0]), connected)
+    );
+    node.replaceChildren(...parts);
+  });
+  await draw();
+  watch(frame, draw);
+}
+
+// src/web/words.ts
+var EN = {
+  failed: "Something went wrong.",
+  yes: "Yes",
+  no: "No",
+  never: "Never",
+  refresh: "Refresh",
+  openSettings: "Open the plugin's settings",
+  languages: { en: "English", ko: "Korean" },
+  connection: {
+    title: "Slack",
+    lead: "The workspace's Slack, connected through an app the console makes and keeps.",
+    problem: "Something went wrong",
+    steps: "Getting connected",
+    address: "The console's address",
+    addressState: {
+      ok: "Reachable",
+      none: "None",
+      not_https: "Not https",
+      private: "Private"
+    },
+    addressHint: {
+      ok: "Slack reaches the console at this address.",
+      none: "The deployment names no public address (PUBLIC_URL), so Slack cannot reach the console.",
+      not_https: "Slack reaches an app over https alone; the deployment serves the console over https first.",
+      private: "This address is on this machine or a private network, where Slack cannot reach it. Slack needs a public https address."
+    },
+    token: "App configuration token",
+    tokenSet: (expires) => `Set; renewed by the plugin, next before ${expires}`,
+    tokenPasted: "Set by an administrator; the plugin renews it within the hour",
+    tokenMissing: "Not set. At api.slack.com/apps, under Your App Configuration Tokens, generate a token for the workspace; an administrator pastes the access token and the refresh token on the plugin's settings page.",
+    app: "The app",
+    appMissing: "Not made yet. The plugin makes it from its manifest, with the configuration token.",
+    appMade: (appId) => `Made in Slack (${appId}).`,
+    appLanguage: "Names in Slack",
+    make: "Make the app",
+    update: "Update the app",
+    install: "Installed in the workspace",
+    installed: (team) => `Installed in ${team}.`,
+    notInstalled: "Not installed yet.",
+    installOpen: "Install in Slack",
+    installPrepare: "Prepare the installation",
+    installHint: "Someone who may install apps in the workspace presses it; Slack's page opens in a new tab and comes back here.",
+    installedBy: (who2, when) => `By ${who2}, ${when}`,
+    done: "Done",
+    todo: "To do",
+    details: "The connection",
+    workspace: "Workspace",
+    bot: "Bot user",
+    shortcut: "Leave shortcut",
+    shortcutOn: "In the app",
+    shortcutOff: "Not in the app",
+    renewed: "Token renewed",
+    secrets: "Secrets",
+    secretNames: {
+      slackConfigToken: "App configuration token",
+      slackConfigRefreshToken: "Configuration refresh token",
+      slackClientSecret: "Client secret",
+      slackSigningSecret: "Signing secret",
+      slackBotToken: "Bot token"
+    },
+    secretFrom: (source) => `Sealed from ${source}`,
+    secretPasted: "Set by an administrator",
+    secretUnset: "Not set",
+    expires: (when) => `expires ${when}`,
+    hr: "HR",
+    hrState: {
+      on: "Connected",
+      off: "Off",
+      no_capability: "Not allowed",
+      outside: "Other version"
+    },
+    hrHint: {
+      on: "Leave is requested from Slack with the shortcut, and each request's thread follows HR's events.",
+      off: "HR is not enabled, so the shortcut is not in the app and no thread is begun.",
+      no_capability: "HR's api is not turned on for the messenger: an administrator turns on plugins:hr on the plugin's settings page.",
+      outside: "This version of HR is not one the messenger was written for, so it leaves HR alone."
+    },
+    hrVersion: (version, range) => `HR ${version}; the messenger reads ${range}`,
+    hrRole: "Role asked of HR",
+    hrGranted: "Granted",
+    hrNotGranted: "Not granted",
+    hrGrantHint: "Without HR's role the messenger cannot read a request, and no thread is begun. An administrator grants it on the plugin's settings page.",
+    tryIt: "Try it",
+    testChannel: "Channel",
+    testChannelHint: "A channel's id (C0123ABCD); left empty, a direct message to you.",
+    test: "Send a test message",
+    disconnect: "Disconnect",
+    disconnectSure: "Press again to uninstall and delete",
+    disconnectHint: "Uninstalls the app from the workspace and deletes it. Connecting again makes a new app: in this workspace, the routes and the matched accounts stay; in another, they go, and its people are matched within the hour.",
+    failures: (count) => `${count} deliveries failed in the last day; the Activity page says why.`
+  },
+  routes: {
+    title: "Routes",
+    lead: "Which events go to which channel, in which language, under whose name.",
+    notConnected: "Connect Slack first: a route names a channel of the workspace.",
+    list: "Routes",
+    none: "No route yet: nothing goes to a channel.",
+    kind: "What",
+    channel: "Channel",
+    language: "Language",
+    as: "Under whose name",
+    kinds: { "hr:leave-approved": "Leave, once approved" },
+    kindHints: {
+      "hr:leave-approved": "Who is out, when, and the kind of leave; never the reason. Struck through if it is cancelled."
+    },
+    asNames: { person: "The person's", app: "The app's" },
+    asHints: {
+      person: "In the person's name and picture, under the app's mark; the app's, naming them, where their account is not matched.",
+      app: "Always the app's, naming the person."
+    },
+    remove: "Remove",
+    add: "Add a route",
+    save: "Save the route",
+    channelPick: "Choose a channel",
+    channelPrivate: "private",
+    noChannels: "Slack lists no channel the app can post to.",
+    connectFirst: "Connect Slack to choose a channel",
+    saved: "Saved."
+  },
+  people: {
+    title: "People",
+    lead: "Each person matched to their Slack account by email: the console's address against the workspace's members.",
+    notConnected: "Connect Slack first; then the people are matched within the hour, and every day after.",
+    matchNow: "Match now",
+    lastMatched: "Last matched",
+    matchedAt: (when) => when,
+    neverMatched: "Not matched yet",
+    states: {
+      matched: "Matched",
+      no_email: "No email",
+      no_account: "No account",
+      not_checked: "Not checked"
+    },
+    stateHints: {
+      matched: "Messages about them carry their name; they may use the shortcut and the buttons.",
+      no_email: "The console knows no address for them: an administrator writes it on the console's People page.",
+      no_account: "No member of the workspace has their address.",
+      not_checked: "Matched at the next run."
+    },
+    all: "Everyone",
+    person: "Person",
+    state: "State",
+    account: "Slack account",
+    nobody: "Nobody here.",
+    more: (shown, total) => `${shown} of ${total} shown.`
+  },
+  activity: {
+    title: "Activity",
+    lead: "What the messenger did with each event it heard, kept for a month.",
+    all: "All",
+    outcomes: { sent: "Sent", skipped: "Passed over", failed: "Failed" },
+    when: "When",
+    event: "Event",
+    outcome: "Outcome",
+    note: "What happened",
+    attempt: "Try",
+    none: "Nothing yet.",
+    kinds: {
+      "plugin:hr:leave-requested": "Leave requested",
+      "plugin:hr:leave-advanced": "Next step",
+      "plugin:hr:leave-approved": "Leave approved",
+      "plugin:hr:leave-rejected": "Leave rejected",
+      "plugin:hr:leave-returned": "Sent back",
+      "plugin:hr:leave-cancelling": "Cancellation asked",
+      "plugin:hr:leave-cancelled": "Leave cancelled",
+      "plugin:hr:leave-kept": "Leave kept"
+    },
+    notes: {
+      thread: () => "The conversation is begun and the step asked.",
+      nobody: () => "Nobody of this request is in Slack.",
+      next_step: () => "The step is closed and the next asked.",
+      approved: (posts) => `Said in the thread; ${posts} channel posts.`,
+      approved_partly: (channels) => `Said in the thread; not posted to ${channels}.`,
+      rejected: () => "The rejection is said in the thread.",
+      returned: () => "The request sent back is said in the thread.",
+      cancel_asked: () => "The cancellation is asked in the thread.",
+      cancelled: (places) => `Struck through in ${places} places.`,
+      kept: () => "The leave kept is said in the thread.",
+      no_thread: () => "Nothing was told of this request before.",
+      not_leave: () => "Not an event the messenger tells.",
+      not_connected: () => "Slack is not connected.",
+      no_capability: () => "HR's api is not turned on for the messenger.",
+      outside: (version) => `HR ${version} is not a version the messenger reads.`,
+      no_grant: () => "The messenger holds no role in HR to read the request.",
+      hidden: () => "HR does not show the messenger the request.",
+      slack: (code) => `Slack refused: ${code}.`,
+      console: (code) => `The console refused: ${code}.`,
+      rate_limited: () => "Slack asked to wait; the console tries again.",
+      failed: () => "Something went wrong."
+    }
+  }
+};
+var KO = {
+  failed: "\uBB38\uC81C\uAC00 \uC0DD\uACBC\uC2B5\uB2C8\uB2E4.",
+  yes: "\uC608",
+  no: "\uC544\uB2C8\uC694",
+  never: "\uC5C6\uC74C",
+  refresh: "\uC0C8\uB85C\uACE0\uCE68",
+  openSettings: "\uD50C\uB7EC\uADF8\uC778 \uC124\uC815 \uC5F4\uAE30",
+  languages: { en: "\uC601\uC5B4", ko: "\uD55C\uAD6D\uC5B4" },
+  connection: {
+    title: "Slack",
+    lead: "\uCF58\uC194\uC774 \uB9CC\uB4E4\uACE0 \uAD00\uB9AC\uD558\uB294 \uC571\uC73C\uB85C \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uC758 Slack\uC744 \uC5F0\uACB0\uD569\uB2C8\uB2E4.",
+    problem: "\uBB38\uC81C\uAC00 \uC0DD\uACBC\uC2B5\uB2C8\uB2E4",
+    steps: "\uC5F0\uACB0\uD558\uAE30",
+    address: "\uCF58\uC194 \uC8FC\uC18C",
+    addressState: {
+      ok: "\uC5F0\uACB0 \uAC00\uB2A5",
+      none: "\uC5C6\uC74C",
+      not_https: "https \uC544\uB2D8",
+      private: "\uC0AC\uC124 \uC8FC\uC18C"
+    },
+    addressHint: {
+      ok: "Slack\uC774 \uC774 \uC8FC\uC18C\uB85C \uCF58\uC194\uC5D0 \uB2FF\uC2B5\uB2C8\uB2E4.",
+      none: "\uBC30\uD3EC\uC5D0 \uACF5\uAC1C \uC8FC\uC18C(PUBLIC_URL)\uAC00 \uC5C6\uC5B4 Slack\uC774 \uCF58\uC194\uC5D0 \uB2FF\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.",
+      not_https: "Slack\uC740 https\uB85C\uB9CC \uC571\uC5D0 \uB2FF\uC2B5\uB2C8\uB2E4. \uBC30\uD3EC\uC5D0\uC11C \uBA3C\uC800 \uCF58\uC194\uC744 https\uB85C \uC11C\uBE44\uC2A4\uD574\uC57C \uD569\uB2C8\uB2E4.",
+      private: "\uC774 \uC8FC\uC18C\uB294 \uC774 \uCEF4\uD4E8\uD130\uB098 \uC0AC\uC124\uB9DD\uC5D0 \uC788\uC5B4 Slack\uC774 \uB2FF\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. Slack\uC5D0\uB294 \uACF5\uAC1C\uB41C https \uC8FC\uC18C\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4."
+    },
+    token: "\uC571 \uC124\uC815 \uD1A0\uD070",
+    tokenSet: (expires) => `\uC124\uC815\uB428. \uD50C\uB7EC\uADF8\uC778\uC774 \uAC31\uC2E0\uD558\uBA70, \uB2E4\uC74C \uAC31\uC2E0\uC740 ${expires} \uC804`,
+    tokenPasted: "\uAD00\uB9AC\uC790\uAC00 \uC124\uC815\uD568. \uD50C\uB7EC\uADF8\uC778\uC774 \uD55C \uC2DC\uAC04 \uC548\uC5D0 \uAC31\uC2E0\uD569\uB2C8\uB2E4",
+    tokenMissing: "\uC124\uC815\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. api.slack.com/apps\uC758 Your App Configuration Tokens\uC5D0\uC11C \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uC758 \uD1A0\uD070\uC744 \uB9CC\uB4E4\uACE0, \uAD00\uB9AC\uC790\uAC00 Access Token\uACFC Refresh Token\uC744 \uD50C\uB7EC\uADF8\uC778 \uC124\uC815 \uD398\uC774\uC9C0\uC5D0 \uBD99\uC5EC \uB123\uC73C\uC138\uC694.",
+    app: "\uC571",
+    appMissing: "\uC544\uC9C1 \uB9CC\uB4E4\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uD50C\uB7EC\uADF8\uC778\uC774 \uC124\uC815 \uD1A0\uD070\uC73C\uB85C \uB9E4\uB2C8\uD398\uC2A4\uD2B8\uC5D0\uC11C \uC571\uC744 \uB9CC\uB4ED\uB2C8\uB2E4.",
+    appMade: (appId) => `Slack\uC5D0 \uB9CC\uB4E4\uC5B4\uC9D0 (${appId}).`,
+    appLanguage: "Slack\uC5D0 \uBCF4\uC774\uB294 \uC774\uB984",
+    make: "\uC571 \uB9CC\uB4E4\uAE30",
+    update: "\uC571 \uC5C5\uB370\uC774\uD2B8",
+    install: "\uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uC5D0 \uC124\uCE58",
+    installed: (team) => `${team}\uC5D0 \uC124\uCE58\uB428.`,
+    notInstalled: "\uC544\uC9C1 \uC124\uCE58\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.",
+    installOpen: "Slack\uC5D0 \uC124\uCE58",
+    installPrepare: "\uC124\uCE58 \uC900\uBE44",
+    installHint: "\uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uC5D0 \uC571\uC744 \uC124\uCE58\uD560 \uC218 \uC788\uB294 \uC0AC\uB78C\uC774 \uB204\uB974\uC138\uC694. \uC0C8 \uD0ED\uC5D0 Slack \uD398\uC774\uC9C0\uAC00 \uC5F4\uB9AC\uACE0, \uC124\uCE58\uD558\uBA74 \uC774 \uD398\uC774\uC9C0\uB85C \uB3CC\uC544\uC635\uB2C8\uB2E4.",
+    installedBy: (who2, when) => `${who2}, ${when}`,
+    done: "\uC644\uB8CC",
+    todo: "\uD560 \uC77C",
+    details: "\uC5F0\uACB0",
+    workspace: "\uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4",
+    bot: "\uBD07 \uC0AC\uC6A9\uC790",
+    shortcut: "\uD734\uAC00 \uB2E8\uCD95\uD0A4",
+    shortcutOn: "\uC571\uC5D0 \uC788\uC74C",
+    shortcutOff: "\uC571\uC5D0 \uC5C6\uC74C",
+    renewed: "\uD1A0\uD070 \uAC31\uC2E0",
+    secrets: "\uBE44\uBC00 \uAC12",
+    secretNames: {
+      slackConfigToken: "\uC571 \uC124\uC815 \uD1A0\uD070",
+      slackConfigRefreshToken: "\uC124\uC815 \uAC31\uC2E0 \uD1A0\uD070",
+      slackClientSecret: "\uD074\uB77C\uC774\uC5B8\uD2B8 \uC2DC\uD06C\uB9BF",
+      slackSigningSecret: "\uC11C\uBA85 \uC2DC\uD06C\uB9BF",
+      slackBotToken: "\uBD07 \uD1A0\uD070"
+    },
+    secretFrom: (source) => `${source}\uC5D0\uC11C \uBD09\uC778`,
+    secretPasted: "\uAD00\uB9AC\uC790\uAC00 \uC124\uC815",
+    secretUnset: "\uC5C6\uC74C",
+    expires: (when) => `${when} \uB9CC\uB8CC`,
+    hr: "HR",
+    hrState: {
+      on: "\uC5F0\uACB0\uB428",
+      off: "\uAEBC\uC9D0",
+      no_capability: "\uD5C8\uC6A9 \uC548 \uB428",
+      outside: "\uB2E4\uB978 \uBC84\uC804"
+    },
+    hrHint: {
+      on: "Slack\uC5D0\uC11C \uB2E8\uCD95\uD0A4\uB85C \uD734\uAC00\uB97C \uC2E0\uCCAD\uD558\uACE0, \uC2E0\uCCAD\uB9C8\uB2E4 HR\uC758 \uC54C\uB9BC\uC744 \uB530\uB77C \uC2A4\uB808\uB4DC\uAC00 \uC774\uC5B4\uC9D1\uB2C8\uB2E4.",
+      off: "HR\uC774 \uCF1C\uC838 \uC788\uC9C0 \uC54A\uC544 \uB2E8\uCD95\uD0A4\uAC00 \uC571\uC5D0 \uC5C6\uACE0 \uC2A4\uB808\uB4DC\uB3C4 \uB9CC\uB4E4\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.",
+      no_capability: "\uBA54\uC2E0\uC800\uC5D0 HR\uC758 api\uAC00 \uCF1C\uC838 \uC788\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. \uAD00\uB9AC\uC790\uAC00 \uD50C\uB7EC\uADF8\uC778 \uC124\uC815 \uD398\uC774\uC9C0\uC5D0\uC11C plugins:hr\uC744 \uCF1C\uC57C \uD569\uB2C8\uB2E4.",
+      outside: "\uBA54\uC2E0\uC800\uAC00 \uC77D\uB3C4\uB85D \uB9CC\uB4E4\uC5B4\uC9C4 HR \uBC84\uC804\uC774 \uC544\uB2C8\uB77C HR\uC744 \uAC74\uB4DC\uB9AC\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4."
+    },
+    hrVersion: (version, range) => `HR ${version}, \uBA54\uC2E0\uC800\uAC00 \uC77D\uB294 \uBC94\uC704 ${range}`,
+    hrRole: "HR\uC5D0 \uC694\uCCAD\uD55C \uC5ED\uD560",
+    hrGranted: "\uBD80\uC5EC\uB428",
+    hrNotGranted: "\uBD80\uC5EC\uB418\uC9C0 \uC54A\uC74C",
+    hrGrantHint: "HR\uC758 \uC5ED\uD560\uC774 \uC5C6\uC73C\uBA74 \uBA54\uC2E0\uC800\uAC00 \uC2E0\uCCAD\uC744 \uC77D\uC9C0 \uBABB\uD574 \uC2A4\uB808\uB4DC\uB97C \uB9CC\uB4E4\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. \uAD00\uB9AC\uC790\uAC00 \uD50C\uB7EC\uADF8\uC778 \uC124\uC815 \uD398\uC774\uC9C0\uC5D0\uC11C \uBD80\uC5EC\uD569\uB2C8\uB2E4.",
+    tryIt: "\uC2DC\uD5D8\uD574 \uBCF4\uAE30",
+    testChannel: "\uCC44\uB110",
+    testChannelHint: "\uCC44\uB110 ID(C0123ABCD). \uBE44\uC6CC \uB450\uBA74 \uB098\uC5D0\uAC8C DM\uC73C\uB85C \uBCF4\uB0C5\uB2C8\uB2E4.",
+    test: "\uC2DC\uD5D8 \uBA54\uC2DC\uC9C0 \uBCF4\uB0B4\uAE30",
+    disconnect: "\uC5F0\uACB0 \uD574\uC81C",
+    disconnectSure: "\uD55C \uBC88 \uB354 \uB204\uB974\uBA74 \uC81C\uAC70\uD558\uACE0 \uC9C0\uC6C1\uB2C8\uB2E4",
+    disconnectHint: "\uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uC5D0\uC11C \uC571\uC744 \uC81C\uAC70\uD558\uACE0 \uC9C0\uC6C1\uB2C8\uB2E4. \uB2E4\uC2DC \uC5F0\uACB0\uD558\uBA74 \uC0C8 \uC571\uC744 \uB9CC\uB4ED\uB2C8\uB2E4. \uAC19\uC740 \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uBA74 \uCC44\uB110 \uC54C\uB9BC\uACFC \uACC4\uC815 \uC5F0\uACB0\uC774 \uADF8\uB300\uB85C \uB0A8\uACE0, \uB2E4\uB978 \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uBA74 \uC9C0\uC6CC\uC9C0\uBA70 \uADF8\uACF3 \uC0AC\uB78C\uB4E4\uC758 \uACC4\uC815\uC740 \uD55C \uC2DC\uAC04 \uC548\uC5D0 \uB2E4\uC2DC \uC5F0\uACB0\uB429\uB2C8\uB2E4.",
+    failures: (count) => `\uC9C0\uB09C \uD558\uB8E8 \uB3D9\uC548 ${count}\uAC74\uC744 \uBCF4\uB0B4\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4. \uC804\uC1A1 \uAE30\uB85D\uC5D0\uC11C \uC774\uC720\uB97C \uBCF4\uC138\uC694.`
+  },
+  routes: {
+    title: "\uCC44\uB110 \uC54C\uB9BC",
+    lead: "\uC5B4\uB5A4 \uC54C\uB9BC\uC744 \uC5B4\uB290 \uCC44\uB110\uC5D0, \uC5B4\uB290 \uC5B8\uC5B4\uB85C, \uB204\uAD6C \uC774\uB984\uC73C\uB85C \uBCF4\uB0BC\uC9C0 \uC815\uD569\uB2C8\uB2E4.",
+    notConnected: "\uBA3C\uC800 Slack\uC744 \uC5F0\uACB0\uD558\uC138\uC694. \uACBD\uB85C\uB294 \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uC758 \uCC44\uB110\uC744 \uAC00\uB9AC\uD0B5\uB2C8\uB2E4.",
+    list: "\uACBD\uB85C",
+    none: "\uC544\uC9C1 \uACBD\uB85C\uAC00 \uC5C6\uC5B4 \uCC44\uB110\uB85C \uAC00\uB294 \uC54C\uB9BC\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.",
+    kind: "\uC54C\uB9BC",
+    channel: "\uCC44\uB110",
+    language: "\uC5B8\uC5B4",
+    as: "\uB204\uAD6C \uC774\uB984\uC73C\uB85C",
+    kinds: { "hr:leave-approved": "\uC2B9\uC778\uB41C \uD734\uAC00" },
+    kindHints: {
+      "hr:leave-approved": "\uB204\uAC00, \uC5B8\uC81C, \uC5B4\uB5A4 \uD734\uAC00\uB85C \uC26C\uB294\uC9C0. \uC0AC\uC720\uB294 \uB123\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. \uCDE8\uC18C\uB418\uBA74 \uCDE8\uC18C\uC120\uC744 \uAE0B\uC2B5\uB2C8\uB2E4."
+    },
+    asNames: { person: "\uB2F9\uC0AC\uC790 \uC774\uB984", app: "\uC571 \uC774\uB984" },
+    asHints: {
+      person: "\uB2F9\uC0AC\uC790\uC758 \uC774\uB984\uACFC \uC0AC\uC9C4\uC73C\uB85C, \uC571 \uD45C\uC2DC\uC640 \uD568\uAED8 \uC62C\uB9BD\uB2C8\uB2E4. \uACC4\uC815\uC774 \uC5F0\uACB0\uB418\uC9C0 \uC54A\uC740 \uC0AC\uB78C\uC740 \uC571 \uC774\uB984\uC73C\uB85C \uC62C\uB9AC\uACE0 \uBCF8\uBB38\uC5D0 \uC774\uB984\uC744 \uC801\uC2B5\uB2C8\uB2E4.",
+      app: "\uD56D\uC0C1 \uC571 \uC774\uB984\uC73C\uB85C \uC62C\uB9AC\uACE0 \uBCF8\uBB38\uC5D0 \uC774\uB984\uC744 \uC801\uC2B5\uB2C8\uB2E4."
+    },
+    remove: "\uC0AD\uC81C",
+    add: "\uACBD\uB85C \uCD94\uAC00",
+    save: "\uACBD\uB85C \uC800\uC7A5",
+    channelPick: "\uCC44\uB110 \uC120\uD0DD",
+    channelPrivate: "\uBE44\uACF5\uAC1C",
+    noChannels: "\uC571\uC774 \uAE00\uC744 \uC62C\uB9B4 \uC218 \uC788\uB294 \uCC44\uB110\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.",
+    connectFirst: "Slack\uC744 \uC5F0\uACB0\uD558\uBA74 \uCC44\uB110\uC744 \uACE0\uB97C \uC218 \uC788\uC2B5\uB2C8\uB2E4",
+    saved: "\uC800\uC7A5\uD588\uC2B5\uB2C8\uB2E4."
+  },
+  people: {
+    title: "\uACC4\uC815 \uC5F0\uACB0",
+    lead: "\uCF58\uC194\uC758 \uC774\uBA54\uC77C\uACFC \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 \uBA64\uBC84\uB97C \uB9DE\uCDB0, \uC0AC\uB78C\uB9C8\uB2E4 Slack \uACC4\uC815\uC744 \uC5F0\uACB0\uD569\uB2C8\uB2E4.",
+    notConnected: "\uBA3C\uC800 Slack\uC744 \uC5F0\uACB0\uD558\uC138\uC694. \uC5F0\uACB0\uD558\uBA74 \uD55C \uC2DC\uAC04 \uC548\uC5D0, \uADF8 \uB4A4\uB85C\uB294 \uB9E4\uC77C \uB9DE\uCDA5\uB2C8\uB2E4.",
+    matchNow: "\uC9C0\uAE08 \uB9DE\uCD94\uAE30",
+    lastMatched: "\uB9C8\uC9C0\uB9C9\uC73C\uB85C \uB9DE\uCD98 \uB54C",
+    matchedAt: (when) => when,
+    neverMatched: "\uC544\uC9C1 \uB9DE\uCD94\uC9C0 \uC54A\uC74C",
+    states: {
+      matched: "\uC5F0\uACB0\uB428",
+      no_email: "\uC774\uBA54\uC77C \uC5C6\uC74C",
+      no_account: "\uACC4\uC815 \uC5C6\uC74C",
+      not_checked: "\uD655\uC778 \uC804"
+    },
+    stateHints: {
+      matched: "\uC774 \uC0AC\uB78C\uC5D0 \uAD00\uD55C \uBA54\uC2DC\uC9C0\uC5D0 \uC774\uB984\uC774 \uC2E4\uB9AC\uACE0, \uB2E8\uCD95\uD0A4\uC640 \uBC84\uD2BC\uC744 \uC4F8 \uC218 \uC788\uC2B5\uB2C8\uB2E4.",
+      no_email: "\uCF58\uC194\uC5D0 \uC774\uBA54\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uAD00\uB9AC\uC790\uAC00 \uCF58\uC194\uC758 \uC0AC\uB78C \uD398\uC774\uC9C0\uC5D0\uC11C \uC801\uC5B4\uC57C \uD569\uB2C8\uB2E4.",
+      no_account: "\uC774 \uC774\uBA54\uC77C\uC744 \uC4F0\uB294 \uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 \uBA64\uBC84\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.",
+      not_checked: "\uB2E4\uC74C \uB9DE\uCD94\uAE30\uC5D0\uC11C \uD655\uC778\uD569\uB2C8\uB2E4."
+    },
+    all: "\uBAA8\uB450",
+    person: "\uC0AC\uB78C",
+    state: "\uC0C1\uD0DC",
+    account: "Slack \uACC4\uC815",
+    nobody: "\uD574\uB2F9\uD558\uB294 \uC0AC\uB78C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.",
+    more: (shown, total) => `${total}\uBA85 \uC911 ${shown}\uBA85\uC744 \uBCF4\uC5EC \uC90D\uB2C8\uB2E4.`
+  },
+  activity: {
+    title: "\uC804\uC1A1 \uAE30\uB85D",
+    lead: "\uBA54\uC2E0\uC800\uAC00 \uBC1B\uC740 \uC54C\uB9BC\uB9C8\uB2E4 \uD55C \uC77C\uC744 \uD55C \uB2EC \uB3D9\uC548 \uBCF4\uAD00\uD569\uB2C8\uB2E4.",
+    all: "\uBAA8\uB450",
+    outcomes: { sent: "\uBCF4\uB0C4", skipped: "\uAC74\uB108\uB700", failed: "\uC2E4\uD328" },
+    when: "\uC2DC\uAC01",
+    event: "\uC54C\uB9BC",
+    outcome: "\uACB0\uACFC",
+    note: "\uB0B4\uC6A9",
+    attempt: "\uC2DC\uB3C4",
+    none: "\uC544\uC9C1 \uC5C6\uC2B5\uB2C8\uB2E4.",
+    kinds: {
+      "plugin:hr:leave-requested": "\uD734\uAC00 \uC2E0\uCCAD",
+      "plugin:hr:leave-advanced": "\uB2E4\uC74C \uACB0\uC7AC",
+      "plugin:hr:leave-approved": "\uD734\uAC00 \uC2B9\uC778",
+      "plugin:hr:leave-rejected": "\uD734\uAC00 \uBC18\uB824",
+      "plugin:hr:leave-returned": "\uBCF4\uC644 \uC694\uCCAD",
+      "plugin:hr:leave-cancelling": "\uCDE8\uC18C \uACB0\uC7AC \uC694\uCCAD",
+      "plugin:hr:leave-cancelled": "\uD734\uAC00 \uCDE8\uC18C",
+      "plugin:hr:leave-kept": "\uD734\uAC00 \uC720\uC9C0"
+    },
+    notes: {
+      thread: () => "\uB300\uD654\uB97C \uC5F4\uACE0 \uACB0\uC7AC\uB97C \uC694\uCCAD\uD588\uC2B5\uB2C8\uB2E4.",
+      nobody: () => "\uC774 \uC2E0\uCCAD\uC5D0 \uAD00\uB828\uB41C \uC0AC\uB78C\uC774 Slack\uC5D0 \uC5C6\uC2B5\uB2C8\uB2E4.",
+      next_step: () => "\uACB0\uC7AC \uB2E8\uACC4\uB97C \uB2EB\uACE0 \uB2E4\uC74C \uB2E8\uACC4\uB97C \uC694\uCCAD\uD588\uC2B5\uB2C8\uB2E4.",
+      approved: (posts) => `\uC2A4\uB808\uB4DC\uC5D0 \uC54C\uB9AC\uACE0 \uCC44\uB110\uC5D0 ${posts}\uAC74 \uC62C\uB838\uC2B5\uB2C8\uB2E4.`,
+      approved_partly: (channels) => `\uC2A4\uB808\uB4DC\uC5D0 \uC54C\uB838\uC9C0\uB9CC ${channels}\uC5D0\uB294 \uC62C\uB9AC\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.`,
+      rejected: () => "\uBC18\uB824\uB97C \uC2A4\uB808\uB4DC\uC5D0 \uC54C\uB838\uC2B5\uB2C8\uB2E4.",
+      returned: () => "\uBCF4\uC644 \uC694\uCCAD\uC744 \uC2A4\uB808\uB4DC\uC5D0 \uC54C\uB838\uC2B5\uB2C8\uB2E4.",
+      cancel_asked: () => "\uCDE8\uC18C \uACB0\uC7AC\uB97C \uC2A4\uB808\uB4DC\uC5D0\uC11C \uC694\uCCAD\uD588\uC2B5\uB2C8\uB2E4.",
+      cancelled: (places) => `${places}\uACF3\uC5D0 \uCDE8\uC18C\uC120\uC744 \uADF8\uC5C8\uC2B5\uB2C8\uB2E4.`,
+      kept: () => "\uD734\uAC00 \uC720\uC9C0\uB97C \uC2A4\uB808\uB4DC\uC5D0 \uC54C\uB838\uC2B5\uB2C8\uB2E4.",
+      no_thread: () => "\uC774 \uC2E0\uCCAD\uC740 \uC804\uC5D0 \uC54C\uB9B0 \uAC83\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.",
+      not_leave: () => "\uBA54\uC2E0\uC800\uAC00 \uC54C\uB9AC\uB294 \uC54C\uB9BC\uC774 \uC544\uB2D9\uB2C8\uB2E4.",
+      not_connected: () => "Slack\uC774 \uC5F0\uACB0\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.",
+      no_capability: () => "\uBA54\uC2E0\uC800\uC5D0 HR\uC758 api\uAC00 \uCF1C\uC838 \uC788\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.",
+      outside: (version) => `\uBA54\uC2E0\uC800\uAC00 \uC77D\uC9C0 \uC54A\uB294 HR \uBC84\uC804\uC785\uB2C8\uB2E4(${version}).`,
+      no_grant: () => "\uBA54\uC2E0\uC800\uC5D0 \uC2E0\uCCAD\uC744 \uC77D\uC744 HR \uC5ED\uD560\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.",
+      hidden: () => "HR\uC774 \uBA54\uC2E0\uC800\uC5D0\uAC8C \uC774 \uC2E0\uCCAD\uC744 \uBCF4\uC5EC \uC8FC\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.",
+      slack: (code) => `Slack\uC774 \uAC70\uC808\uD588\uC2B5\uB2C8\uB2E4: ${code}.`,
+      console: (code) => `\uCF58\uC194\uC774 \uAC70\uC808\uD588\uC2B5\uB2C8\uB2E4: ${code}.`,
+      rate_limited: () => "Slack\uC774 \uAE30\uB2E4\uB824 \uB2EC\uB77C\uACE0 \uD574\uC11C \uCF58\uC194\uC774 \uB2E4\uC2DC \uC2DC\uB3C4\uD569\uB2C8\uB2E4.",
+      failed: () => "\uBB38\uC81C\uAC00 \uC0DD\uACBC\uC2B5\uB2C8\uB2E4."
+    }
+  }
+};
+var PACKS = { en: EN, ko: KO };
+function wordsFor(language) {
+  const tag = language.toLowerCase();
+  return PACKS[tag] ?? PACKS[tag.split("-")[0] ?? ""] ?? EN;
+}
+
+// src/web/index.ts
+async function render(root2, frame, words) {
+  switch (frame.context.page) {
+    case "routes":
+      return renderRoutes(root2, frame, words);
+    case "people":
+      return renderPeople(root2, frame, words);
+    case "activity":
+      return renderActivity(root2, frame, words);
+    default:
+      return renderConnection(root2, frame, words);
+  }
+}
+var root = document.getElementById("root");
+if (root !== null) {
+  const frame = await connect();
+  const words = wordsFor(frame.context.language);
+  try {
+    await render(root, frame, words);
+  } catch (error) {
+    root.replaceChildren(errorBlock(error, words));
+  }
+}