@oharness/server 0.7.0 → 0.8.0

package/dist/page/client/pickers.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The menus that pick something: provider marks and logos, and the model,
+ * mode, effort and workspace pickers built on one shared picker.
+ *
+ * One part of the client script; see ./index.ts for how the parts join.
+ */
+export declare const PICKERS: string;

package/dist/page/client/pickers.js

@@ -0,0 +1,624 @@
+/**
+ * The menus that pick something: provider marks and logos, and the model,
+ * mode, effort and workspace pickers built on one shared picker.
+ *
+ * One part of the client script; see ./index.ts for how the parts join.
+ */
+export const PICKERS = String.raw `
+// --- pickers ---------------------------------------------------------------
+
+/**
+ * A dropdown built from ordinary elements.
+ *
+ * One open at a time, closes on outside click and on Escape, and reports the
+ * chosen value. It exists because a native select draws its popup and its
+ * focus ring with the operating system's chrome, which no stylesheet reaches.
+ */
+/**
+ * The mark for one model vendor, for the rows of the model menu.
+ *
+ * The same arrangement the connector list uses, for the same reason: the
+ * vendor's own icon when there is one, a lettered tile when there is not, and
+ * no third-party request from this page either way — the server fetches the
+ * icon once and serves it from this origin, so opening the menu does not tell
+ * two dozen vendors that this machine looked at their name.
+ *
+ * The resolution happens once per vendor rather than once per row. A vendor
+ * with four hundred models would otherwise decode the same image four hundred
+ * times and measure it four hundred times, on every repaint of the list.
+ */
+const providerMarks = new Map();
+
+const providerIconUrl = (id) => q("/provider-icon?id=" + encodeURIComponent(id));
+
+/** What is known about a vendor's icon, and who is waiting to hear. */
+function providerIconState(id) {
+  let state = providerMarks.get(id);
+  if (state) return state;
+  state = { status: "pending", invert: false, filled: false, waiting: [] };
+  providerMarks.set(id, state);
+
+  const probe = new Image();
+  probe.addEventListener("load", () => {
+    state.status = "ok";
+    const profile = markProfile(probe);
+    state.invert = profile.invert;
+    state.filled = profile.filled;
+    const waiting = state.waiting.splice(0);
+    for (const swap of waiting) swap();
+  });
+  // A vendor with no icon is ordinary: local servers have no site to ask, and
+  // plenty of sites answer nothing usable. The tile is a complete answer.
+  probe.addEventListener("error", () => {
+    state.status = "none";
+    state.waiting.length = 0;
+  });
+  probe.src = providerIconUrl(id);
+  return state;
+}
+
+/** A stable hue per vendor, so a tile is the same colour on every repaint. */
+function providerMono(id, label, extra) {
+  let hash = 0;
+  for (let i = 0; i < id.length; i++) hash = (hash * 31 + id.charCodeAt(i)) % 360;
+  const mono = el("span", "vmono" + (extra ? " " + extra : ""), (label || id || "?").trim().charAt(0));
+  mono.style.background = "hsl(" + hash + " 42% 42%)";
+  return mono;
+}
+
+function providerLogo(id, state, extra) {
+  const img = new Image();
+  // A mark that owns its whole box keeps it; one that is bare ink is inset,
+  // so a wide glyph with no margin of its own does not read as bigger and
+  // off-line next to a tile that fills the same square.
+  img.className =
+    "vmark" +
+    (state.filled ? " filled" : "") +
+    (state.invert ? " invert-dark" : "") +
+    (extra ? " " + extra : "");
+  img.alt = "";
+  img.src = providerIconUrl(id);
+  return img;
+}
+
+/**
+ * A vendor's mark, ready to put in a row.
+ *
+ * Returns something to draw now, not a promise: the menu repaints on every
+ * keystroke and cannot wait on the network. A tile goes in, and if the icon
+ * turns out to exist it takes the tile's place — but only if that tile is
+ * still on the page, since the row it was made for may already be gone.
+ */
+function providerMark(id, label, extra) {
+  // Ours is drawn from the same paths as the application icon rather than
+  // fetched from our own site: it is the one mark that has to be there
+  // offline, on the row that is being recommended.
+  if (id === "official") return svgIcon("oharness", "vglyph" + (extra ? " " + extra : ""));
+
+  const state = providerIconState(id);
+  if (state.status === "ok") return providerLogo(id, state, extra);
+
+  const mono = providerMono(id, label, extra);
+  if (state.status === "pending") {
+    state.waiting.push(() => {
+      if (mono.isConnected) mono.replaceWith(providerLogo(id, state, extra));
+    });
+  }
+  return mono;
+}
+
+/**
+ * The model id, shortened to what the bar has room for: everything after the
+ * last slash.
+ *
+ * The rule used to be a length test — over 28 characters keep the tail, under
+ * it keep the whole thing — which is how "~deepseek/deepseek-v4-flash" reached
+ * the bar at 27 characters, naming its vendor twice and then being cut
+ * mid-word by the ellipsis anyway. Length was the wrong question: what to drop
+ * does not depend on how long the string happens to be.
+ *
+ * What to drop is the namespace, every time. The vendor's mark is drawn
+ * immediately to the left of this, so the prefix is a picture repeated in
+ * words — and an aggregator's id nests, which makes the prefix the longer half
+ * of a name whose distinguishing half is at the end. The whole id stays in the
+ * title attribute and in the menu.
+ */
+function shortModel(full) {
+  const cut = full.lastIndexOf("/");
+  return cut < 0 ? full : full.slice(cut + 1);
+}
+
+function makePicker(id, onPick, extra, opts = {}) {
+  const root = document.getElementById(id);
+  const button = root.querySelector(".picker-btn");
+  const label = root.querySelector(".picker-value");
+  const menu = root.querySelector(".menu");
+
+  // The menu owns a search box and a scrolling body. Built once here rather
+  // than in the markup so every picker gets the same behaviour.
+  const searchWrap = el("div", "menu-search");
+  const search = document.createElement("input");
+  search.type = "text";
+  search.placeholder = t("menu.search");
+  search.autocomplete = "off";
+  search.spellcheck = false;
+  searchWrap.appendChild(search);
+  const body = el("div", "menu-body");
+  // A fixed footer, not the end of the scrolling list: appended to the body it
+  // sat below four hundred models and could never be reached.
+  const footer = el("div", "menu-footer");
+  menu.replaceChildren(searchWrap, body, footer);
+
+  let options = [];
+  let value = null;
+
+  let query = "";
+  let cursor = 0;
+  /** Groups the user has folded away; survives repainting. */
+  const collapsed = new Set();
+  /**
+   * Groups folded while searching. Kept apart from the browsing folds: a
+   * search opens every vendor, because a match behind a closed header looks
+   * like no result — but a header that then refuses to close is a control
+   * that does nothing, and OpenRouter's twenty matches can bury the one vendor
+   * being looked for. Cleared when the query changes, so each search starts
+   * with everything it found on screen.
+   */
+  const searchFolded = new Set();
+  const folded = (group) => (query ? searchFolded.has(group) : collapsed.has(group));
+
+  /** The options a keystroke can land on: what is actually on screen. */
+  const visible = () => matches().filter((option) => !option.group || !folded(option.group));
+
+  const close = () => {
+    menu.hidden = true;
+    root.classList.remove("open");
+    query = "";
+    searchFolded.clear();
+  };
+
+  const matches = () => options.filter((option) => matchesQuery(option, query));
+
+  const paint = () => {
+    const list = matches();
+
+    const shown = list.filter((option) => !option.group || !folded(option.group));
+    if (cursor >= shown.length) cursor = Math.max(0, shown.length - 1);
+
+    // Only the body is rebuilt: replacing the menu itself would take the
+    // search field out from under the caret on the first keystroke.
+    body.replaceChildren();
+
+    const counts = new Map();
+    for (const option of list) {
+      if (option.group) counts.set(option.group, (counts.get(option.group) || 0) + 1);
+    }
+
+    let lastGroup = null;
+    let visibleIndex = 0;
+    for (const option of list) {
+      // A flat list of four hundred models across a dozen vendors is
+      // unreadable; the vendor is the first thing anyone narrows by.
+      if (option.group && option.group !== lastGroup) {
+        lastGroup = option.group;
+        const group = option.group;
+        const header = el("button", "menu-group" + (folded(group) ? "" : " open"));
+        header.type = "button";
+        header.appendChild(el("span", "chev"));
+        // The vendor's mark leads its header, so a folded list reads as a
+        // column of vendors rather than as a column of lowercase words.
+        const groupMark = api.groupMark && api.groupMark(group);
+        if (groupMark) header.appendChild(groupMark);
+        header.appendChild(el("span", "g-name", group));
+        // A vendor may be worth marking out — the official plan is the one
+        // this project stands behind, and a group header is where someone
+        // scanning the list actually looks.
+        const tag = api.groupTag && api.groupTag(group);
+        if (tag) header.appendChild(el("span", "g-tag", tag));
+        header.appendChild(el("span", "g-count", String(counts.get(group) || 0)));
+        header.addEventListener("click", (e) => {
+          e.stopPropagation();
+          const set = query ? searchFolded : collapsed;
+          if (set.has(group)) set.delete(group);
+          else set.add(group);
+          cursor = 0;
+          paint();
+        });
+        body.appendChild(header);
+      }
+
+      if (option.group && folded(option.group)) continue;
+      const i = visibleIndex++;
+      const item = el(
+        "button",
+        "menu-item" + (option.value === value ? " on" : "") + (i === cursor ? " cursor" : ""),
+      );
+      item.type = "button";
+      item.appendChild(el("span", "tick", "✓"));
+      // Between the tick and the name: the row is "is this the one" then
+      // "whose is it" then "which model", which is the order it is read in.
+      const mark = option.mark && option.mark();
+      if (mark) item.appendChild(mark);
+      item.appendChild(el("span", "menu-label", option.label));
+      // Beside the name rather than out at the right margin where sub sits:
+      // this qualifies the model it is attached to, and a badge floated away
+      // from its name is a badge the eye has to pair up again on every row.
+      if (option.tag) item.appendChild(el("span", "m-tag", option.tag));
+      if (option.sub) item.appendChild(el("span", "sub", option.sub));
+      item.addEventListener("click", () => {
+        close();
+        if (option.value !== value) onPick(option.value);
+      });
+      body.appendChild(item);
+    }
+
+    if (!list.length) body.appendChild(el("div", "menu-empty", t("menu.none")));
+  };
+
+  const open = () => {
+    for (const other of document.querySelectorAll(".picker.open")) {
+      if (other !== root) {
+        other.classList.remove("open");
+        other.querySelector(".menu").hidden = true;
+      }
+    }
+    query = "";
+    search.value = "";
+
+    // Everything folded except the vendor holding the current model: opening
+    // onto a dozen closed headers hides the one answer the user already has.
+    // A picker may name groups that always open as well — the model picker's
+    // own plan, which is where someone looking for a model should land first.
+    collapsed.clear();
+    const current = options.find((option) => option.value === value);
+    const alwaysOpen = new Set(opts.openGroups || []);
+    for (const option of options) {
+      if (!option.group || alwaysOpen.has(option.group)) continue;
+      if (option.group !== (current && current.group)) collapsed.add(option.group);
+    }
+    cursor = Math.max(0, visible().findIndex((option) => option.value === value));
+    // Searching costs a row of chrome and is pointless below a handful of
+    // entries, so the five-item mode picker does not get one.
+    searchWrap.hidden = options.length < 8;
+    footer.replaceChildren();
+    if (extra) footer.appendChild(extra());
+    footer.hidden = !extra;
+    paint();
+    menu.hidden = false;
+    root.classList.add("open");
+    // Opened onto the model in use rather than onto the top of a vendor with
+    // four hundred entries.
+    body.scrollTop = 0;
+    const on = body.querySelector(".menu-item.on");
+    if (on) on.scrollIntoView({ block: "nearest" });
+    if (!searchWrap.hidden) search.focus();
+  };
+
+  search.addEventListener("input", () => {
+    if (search.value !== query) searchFolded.clear();
+    query = search.value;
+    cursor = 0;
+    paint();
+    // The body keeps its scroll offset across a repaint. Searching from
+    // halfway down a long vendor therefore left the first results — often the
+    // vendor whose name was just typed — above the visible window, which reads
+    // as "that vendor has no models" when its two rows are simply out of view.
+    body.scrollTop = 0;
+  });
+
+  search.addEventListener("click", (e) => e.stopPropagation());
+
+  search.addEventListener("keydown", (e) => {
+    const list = visible();
+    if (e.key === "ArrowDown" || e.key === "ArrowUp") {
+      e.preventDefault();
+      if (!list.length) return;
+      cursor = (cursor + (e.key === "ArrowDown" ? 1 : -1) + list.length) % list.length;
+      paint();
+      const active = body.querySelector(".cursor");
+      if (active) active.scrollIntoView({ block: "nearest" });
+      return;
+    }
+    if (e.key === "Enter") {
+      e.preventDefault();
+      const picked = list[cursor];
+      close();
+      if (picked && picked.value !== value) onPick(picked.value);
+    }
+  });
+
+  button.addEventListener("click", (e) => {
+    e.stopPropagation();
+    menu.hidden ? open() : close();
+  });
+  document.addEventListener("click", close);
+  document.addEventListener("keydown", (e) => {
+    if (e.key === "Escape") close();
+  });
+
+  const api = {
+    /** Optional: a badge for a group header, e.g. the recommended vendor. */
+    groupTag: null,
+    /** Optional: a mark for a group header, e.g. the vendor's own icon. */
+    groupMark: null,
+    set(list, current) {
+      options = list;
+      value = current;
+      const match = list.find((option) => option.value === current);
+      // The mark travels with the choice onto the bar. The label there is a
+      // truncated id — the tail of google/gemini-3.6-flash:batch says nothing
+      // about who is being paid for it, and that is the half of the answer
+      // somebody glances down to check.
+      const stale = button.querySelector(".picker-mark");
+      if (stale) stale.remove();
+      const mark = match && match.mark && match.mark("picker-mark");
+      if (mark) button.insertBefore(mark, label);
+      const full = match ? match.label : current || "—";
+      label.textContent = shortModel(full);
+      label.title = full;
+    },
+    get value() {
+      return value;
+    },
+  };
+  return api;
+}
+
+// Drawn glyphs rather than vendor tiles: a mode is chrome, not a party being
+// paid, so it gets the bare stroke every other menu icon has.
+const modeMark = (icon) => (extra) => svgIcon(icon, "mode-mark" + (extra ? " " + extra : ""));
+
+const MODES = [
+  { value: "default", label: "Manual", sub: "ask first", mark: modeMark("modeAsk") },
+  { value: "acceptEdits", label: "Accept edits", sub: "edits pass", mark: modeMark("modeEdits") },
+  { value: "plan", label: "Plan", sub: "read-only", mark: modeMark("modePlan") },
+  { value: "auto", label: "Auto", sub: "routine passes", mark: modeMark("modeAuto") },
+  { value: "bypassPermissions", label: "Bypass", sub: "all pass", mark: modeMark("modeBypass") },
+];
+
+const modelPicker = makePicker(
+  "model-picker",
+  (id) => {
+    // A vendor row rather than a model: there is nothing to switch to until it
+    // has credentials or a discovery pass. Both are one action, so both happen
+    // here rather than in a panel the user then has to find the vendor in
+    // again — a key gets a dialog over the menu, and a vendor that already has
+    // credentials just gets asked for its list.
+    if (String(id).indexOf("setup:") === 0) {
+      const providerId = String(id).slice(6);
+      const provider = providers.find((p) => p.id === providerId);
+      if (provider && provider.configured) return void discoverNow(providerId);
+      return void openConnect(providerId);
+    }
+
+    // A model whose vendor has no credentials would 401 on the first turn,
+    // and the picker is where the choice was made — so the key is asked for
+    // here and the switch happens once it lands.
+    const owner = providers.find((p) => p.id === (modelOptions.find((o) => o.value === id) || {}).group);
+    if (owner && !owner.configured) return void openConnect(owner.id, id);
+
+    // The whole claim of the project is that this switch is cheap, so how
+    // often it is actually made — and to what — is the one number worth having.
+    track("model_switched", { model: id, via: "picker" });
+    void api("/model", { session: activeId, id }).then(applyState);
+  },
+  () => {
+    // The catalog ships providers, not model names — vendors rename faster
+    // than this package publishes. So the picker offers the way to go ask.
+    const link = el("button", "menu-more");
+    link.type = "button";
+    // Drawn at the same weight and size as every other icon; the Unicode gear
+    // arrived from whatever font had it and sat small next to the label.
+    link.appendChild(svgIcon("settings"));
+    link.appendChild(el("span", null, t("menu.manage")));
+    link.addEventListener("click", () => {
+      setNav("nav-models");
+      // Opened for the list itself, so nothing is singled out.
+      focusProvider = null;
+      void showModels();
+    });
+    return link;
+  },
+  { openGroups: ["official"] },
+);
+const modePicker = makePicker("mode-picker", (mode) => void api("/mode", { session: activeId, mode }).then(applyState));
+
+/**
+ * Reasoning effort for the session on screen.
+ *
+ * Not built on makePicker: that draws a searchable list, and effort is one
+ * quantity on a scale. The stops are whatever the current model accepts, plus
+ * "off" where the model can be asked not to think, so a tier the model would
+ * clamp away is never offered in the first place.
+ *
+ * What the server reports is the tier the next request will carry. A pick is
+ * kept as picked on the session, so moving to a model without "max" shows the
+ * tier it lands on, and moving back shows "max" again.
+ */
+const effortPicker = (() => {
+  const root = document.getElementById("effort-picker");
+  const button = root.querySelector(".picker-btn");
+  const label = root.querySelector(".picker-value");
+  const menu = root.querySelector(".menu");
+  let stops = [];
+  let value = null;
+
+  const name = (stop) => t("effort." + stop);
+  const close = () => {
+    root.classList.remove("open");
+    menu.hidden = true;
+  };
+
+  const pick = (next) => {
+    if (!next || next === value) return;
+    value = next;
+    paint(true);
+    track("effort_changed", { effort: next });
+    void api("/effort", { session: activeId, effort: next }).then(applyState);
+  };
+
+  function paint(refocus) {
+    const index = Math.max(0, stops.indexOf(value));
+    label.textContent = value ? t("effort.short." + value) : "…";
+    button.title = t("effort.tooltip") + ": " + (value ? name(value) : "");
+    if (menu.hidden && !refocus) return;
+
+    menu.replaceChildren();
+    const head = el("div", "effort-head");
+    head.appendChild(el("span", "effort-title", t("effort.title")));
+    head.appendChild(el("span", "effort-current", value ? name(value) : ""));
+    menu.appendChild(head);
+    menu.appendChild(el("div", "effort-desc", value ? t("effort.desc." + value) : ""));
+
+    const ends = el("div", "effort-ends");
+    ends.appendChild(el("span", null, t("effort.faster")));
+    ends.appendChild(el("span", null, t("effort.smarter")));
+    menu.appendChild(ends);
+
+    const rail = el("div", "effort-rail");
+    rail.setAttribute("role", "radiogroup");
+    rail.setAttribute("aria-label", t("effort.tooltip"));
+    const fill = el("span", "effort-fill");
+    const share = stops.length > 1 ? index / (stops.length - 1) : 0;
+    // From the rail's left edge to the far side of the chosen stop.
+    fill.style.width = "calc((100% - var(--stop)) * " + share + " + var(--stop))";
+    rail.appendChild(fill);
+
+    const names = el("div", "effort-names");
+    stops.forEach((stop, i) => {
+      const on = i === index;
+      const dot = el("button", "effort-stop" + (on ? " on" : ""));
+      dot.type = "button";
+      dot.setAttribute("role", "radio");
+      dot.setAttribute("aria-checked", on ? "true" : "false");
+      dot.setAttribute("aria-label", name(stop));
+      dot.tabIndex = on ? 0 : -1;
+      dot.title = name(stop);
+      dot.appendChild(el("span", on ? "effort-knob" : "effort-dot"));
+      dot.addEventListener("click", () => pick(stop));
+      dot.addEventListener("keydown", (e) => {
+        const step = e.key === "ArrowLeft" || e.key === "ArrowDown" ? -1 : e.key === "ArrowRight" || e.key === "ArrowUp" ? 1 : 0;
+        if (!step) return;
+        e.preventDefault();
+        pick(stops[Math.min(stops.length - 1, Math.max(0, index + step))]);
+      });
+      rail.appendChild(dot);
+      names.appendChild(el("span", "effort-name" + (on ? " on" : ""), t("effort.short." + stop)));
+    });
+    menu.appendChild(rail);
+    menu.appendChild(names);
+
+    if (refocus) {
+      const active = rail.querySelector(".effort-stop.on");
+      if (active) active.focus();
+    }
+  }
+
+  const open = () => {
+    for (const other of document.querySelectorAll(".picker.open")) {
+      if (other !== root) {
+        other.classList.remove("open");
+        other.querySelector(".menu").hidden = true;
+      }
+    }
+    root.classList.add("open");
+    menu.hidden = false;
+    paint(true);
+  };
+
+  button.addEventListener("click", (e) => {
+    e.stopPropagation();
+    menu.hidden ? open() : close();
+  });
+  menu.addEventListener("click", (e) => e.stopPropagation());
+  document.addEventListener("click", close);
+  document.addEventListener("keydown", (e) => {
+    if (e.key === "Escape" && !menu.hidden) {
+      close();
+      button.focus();
+    }
+  });
+
+  return {
+    set(state) {
+      const levels = Array.isArray(state.effortLevels) ? state.effortLevels : [];
+      // A model with no tiers has nothing to set; hiding beats a control that
+      // does nothing.
+      root.hidden = levels.length === 0 || !state.effort;
+      if (root.hidden) {
+        close();
+        return;
+      }
+      stops = (state.effortOff ? ["off"] : []).concat(levels);
+      value = state.effort;
+      paint(false);
+    },
+  };
+})();
+
+/**
+ * Which tree the session about to start will run in.
+ *
+ * Offered on the composer rather than in a dialog on the way in: the answer is
+ * usually the project already open, and the one time it is not, it is a
+ * property of the task being typed. Every directory opened here is on the
+ * list, and the last row goes and finds one that is not.
+ */
+const workspacePicker = makePicker(
+  "workspace-picker",
+  (path) => void reroot(path),
+  () => {
+    const link = el("button", "menu-more");
+    link.type = "button";
+    link.appendChild(svgIcon("folder"));
+    link.appendChild(el("span", null, t("projects.other")));
+    link.addEventListener("click", () => void pickFolder((path) => reroot(path)));
+    return link;
+  },
+);
+
+const workspaceRow = document.getElementById("workspace-picker");
+
+/**
+ * Move an unstarted session to another tree.
+ *
+ * A transcript belongs to the directory it was recorded in, so this is not a
+ * session changing address: it is a new one in the right place, and the empty
+ * one it replaces is thrown away rather than filed in the sidebar for every
+ * change of mind.
+ */
+async function reroot(path) {
+  if (!path || path === currentCwd) return;
+  const leaving = activeId;
+  const record = panes.get(leaving);
+  const bare = record && (record.node.childElementCount === 0 || record.node.contains(emptyEl));
+
+  await switchTo({ action: "new", cwd: path });
+  if (bare && leaving && leaving !== activeId) {
+    const gone = panes.get(leaving);
+    if (gone) gone.node.remove();
+    panes.delete(leaving);
+    await api("/session", { action: "delete", id: leaving });
+    paintTabs();
+  }
+  await loadProjects();
+  await loadSessions();
+  input.focus();
+}
+
+/**
+ * A folder from this machine, by whatever means this machine has.
+ *
+ * The system dialog is what "choose a folder" means, and the browser cannot
+ * open one that reports a path. A host without a dialog — headless, remote, a
+ * stripped-down image — browses the server's own directories instead.
+ */
+async function pickFolder(onPick) {
+  const picked = await api("/pick", {}, 5 * 60_000);
+  if (picked && picked.path) return void onPick(picked.path);
+  if (picked && picked.cancelled) return;
+  addNotice(t("projects.pickFailed"));
+  openBrowser(undefined, { onPick });
+}
+`;
+//# sourceMappingURL=pickers.js.map

package/dist/page/client/pickers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pickers.js","sourceRoot":"","sources":["../../../src/page/client/pickers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwmBhC,CAAC"}

package/dist/page/client/routines.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The routines page, the settings page, and the permission rules page.
+ *
+ * One part of the client script; see ./index.ts for how the parts join.
+ */
+export declare const ROUTINES: string;