@dylanpiercey/work 0.2.40 → 0.2.42

package/bin/cli/stack.mjs

@@ -8,26 +8,40 @@ function recipe(branch) {
 
 Stack only when the user asks, or when a change of several hundred lines
 splits into parts each worth merging alone; never a layer per commit.
+A stack is a convention, plain branches and PRs: each layer is cut from
+the one below and its PR is based on it, which is how GitHub and work's
+review both read a stack.
 
-- The working branch (${branch}) stays the top; cut layers below it, bottom
-  first, as ${branch}-<layer>:
-    gh stack init --base <base> <layers…> ${branch}
-  (after \`gh stack unstack --local\` if a stack exists).
+- The working branch (${branch}) stays the top; cut layers below it from
+  its own commits, bottom first, as ${branch}-<layer>, each with its PR's
+  base as gh reads it:
+    git branch ${branch}-<layer> <its last commit>
+    git config branch.${branch}-<layer>.gh-merge-base <layer below, else base>
+- The user reviews it here a layer at a time, bottom first: link each as
+  [<layer>](/w/<id>/review?section=<repo>@<layer>) (\`work branches\`
+  lists them).
 - Never check a layer out. Edit one by \`git commit --fixup <sha>\` on the
-  top, then:
+  top, then (every layer moves with the commits it holds):
     GIT_SEQUENCE_EDITOR=: git rebase -i --autosquash --update-refs origin/<base>
-- \`gh stack sync\` / \`gh stack rebase\` switch branches: run them in topic
-  worktrees only. Leave the local <base> gh-stack keeps as trunk.
-- Merge a layer with \`gh stack merge <pr> --squash\` or on the web
-  (\`gh pr merge\` refuses it), then, on the top:
-    old=$(git rev-parse origin/${branch})
+  A base that moved is \`git rebase --update-refs origin/<base>\` alike.
+- Nothing goes up front. Push a layer and open its PR only when the user
+  says it is ready, after reviewing it, bottom first and never past a
+  layer still local (a PR's base must be on GitHub):
+    git push origin ${branch}-<layer>
+    gh pr create --head ${branch}-<layer> --base <layer below, else base>
+  The top goes last, its PR based on the last layer (one already open:
+  \`gh pr edit --base\`). After a rebase, force-push only what is pushed:
+    git push --force-with-lease --atomic origin <pushed branches…>
+- Land bottom first, deleting the merged branch so GitHub moves the PR
+  above onto <base> (on the web, delete it after merging):
+    cut=$(git rev-parse ${branch}-<layer>)
+    gh pr merge <pr> --squash --delete-branch
+  then, on the top, move the rest onto the squash, and force-push what of
+  it is pushed:
     git fetch
-    git branch -f <layer> origin/<layer>     # for each remaining layer
-    git branch -D <merged-layer>
-    git rebase --onto origin/${branch} $old
-- Once the top merges: \`gh stack unstack --local\`.
-- Link a layer for review as [<layer>](/w/<id>/review?section=<repo>@<layer>);
-  \`work branches\` lists every layer with its link.`;
+    git rebase --update-refs --onto origin/<base> $cut
+    git config branch.<layer above>.gh-merge-base <base>   # not the top's
+- A lane stacks the same way, in its worktree, its branch the top.`;
 }
 
 export const commands = [
@@ -35,9 +49,9 @@ export const commands = [
     name: "stack",
     summary: "how to stack branches in this workspace (prints the recipe)",
     help: `work stack [id|name]
-  Prints how to stack branches with gh-stack here, with the workspace's
-  branch filled in: when to, cutting layers, editing one without checking
-  it out, merging a layer and rebasing the rest.`,
+  Prints how to stack branches here, as plain branches and PRs, with the
+  workspace's branch filled in: when to, cutting layers, editing one
+  without checking it out, merging a layer and rebasing the rest.`,
     async run(ctx) {
       let branch = "<workspace-branch>";
       try {

package/bin/cli/topic.mjs

@@ -84,7 +84,7 @@ function mergeBases(dir) {
  * copy. This workspace's own branches (it, and the topics one stacks on)
  * go by the local one: they may never be pushed, and here is where they
  * move. Any other (the repo's base) goes by origin's: a bare cache's local
- * copy of it is as old as the clone, or as gh-stack's trunk. */
+ * copy of it is as old as the clone. */
 function baseRef(dir, name, ws, foreign) {
   const local = has(dir, `refs/heads/${name}`) ? name : null;
   const remote = has(dir, `refs/remotes/origin/${name}`)

package/bin/work.mjs

@@ -76,6 +76,7 @@ import {
   applyPlan,
   dropText,
   firewallProbe,
+  programOf,
   serviceNode,
 } from "../lib/setup/firewall.mjs";
 import { installTool, repairGhHelpers } from "../lib/setup/install.mjs";
@@ -958,6 +959,7 @@ function allowScriptsArgs() {
 
 async function update() {
   log("updating @dylanpiercey/work");
+  const before = serviceCli();
   // `--prefer-online`: npm serves `latest` from a cached packument for a
   // few minutes after a publish, so an update right behind a release
   // reinstalled the version already running.
@@ -974,8 +976,19 @@ async function update() {
     ],
     { stdio },
   );
-  // Re-exec the (possibly new) CLI to finish with fresh code.
-  sh("work", [
+  // Finish with the CLI that npm just installed, found where that npm
+  // installs, never `work` by name: the npm and the `work` first on PATH
+  // can be two nodes' (a Homebrew npm ahead of mise's shims), and the
+  // other install's setup points the service back at itself, so every
+  // update left the service on the old release.
+  const root = execFileSync("npm", ["root", "-g"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", 2],
+  }).trim();
+  const cli = path.join(root, "@dylanpiercey", "work", "bin", "work.mjs");
+  if (!fs.existsSync(cli))
+    die(`npm installed into ${root}, but there is no ${cli}`);
+  sh(cli, [
     "setup",
     ...(yes ? ["--yes"] : []),
     ...args.filter((a) =>
@@ -991,6 +1004,21 @@ async function update() {
     ...flagValues("--allow-host").flatMap((h) => ["--allow-host", h]),
     ...flagValues("--disallow-host").flatMap((h) => ["--disallow-host", h]),
   ]);
+  // The service now runs what npm updated; an install it or this shell ran
+  // before is left behind at its old release.
+  const now = realpathOr(cli);
+  const left = new Map();
+  for (const [w, was] of [
+    [before, "the service ran"],
+    [installAt(fileURLToPath(import.meta.url)), "`work` here ran"],
+  ]) {
+    if (w?.prefix && w.real !== now && !left.has(w.real))
+      left.set(
+        w.real,
+        `${was} ${tilde(w.path)} (${w.version}), not the install npm updated (${tilde(cli)}); remove it: ${removeHint(w)}`,
+      );
+  }
+  for (const note of left.values()) warn(note);
 }
 
 /** Machine readiness from lib/setup — the same probe the Settings page runs. */
@@ -1015,38 +1043,39 @@ async function doctorCmd() {
 }
 
 /**
- * This `work`, every other one on PATH (the first is what `work` runs),
- * each with its version, and the version the running service reports
- * (null when none answers). A package manager's global left behind — a
- * Homebrew node's under mise's — shadows the one kept up to date, and the
- * doctor it runs is then old code describing a machine it no longer knows.
+ * This `work`, every other one on PATH (the first is what `work` runs) or
+ * on the service's, each with the install it runs and its version, and the
+ * service: the CLI its definition runs and the release the running one
+ * reports. A package manager's global left behind — a Homebrew node's
+ * under mise's — shadows the one kept up to date, and the doctor it runs is
+ * then old code describing a machine it no longer knows.
  */
 async function workInstalls() {
-  const self = realpathOr(fileURLToPath(import.meta.url));
+  const self = installAt(fileURLToPath(import.meta.url));
+  const shell = (process.env.PATH || "").split(path.delimiter);
+  const servicePath = (installedServiceEnv().PATH || "").split(path.delimiter);
   const onPath = [];
   const seen = new Set();
-  for (const dir of (process.env.PATH || "").split(path.delimiter)) {
+  for (const dir of new Set([...shell, ...servicePath])) {
     if (!dir) continue;
-    const file = path.join(dir, "work");
-    let real;
-    try {
-      if (!fs.statSync(file).isFile()) continue;
-      real = fs.realpathSync(file);
-    } catch {
-      continue;
-    }
-    if (seen.has(real)) continue;
-    seen.add(real);
-    onPath.push({ path: file, real, version: installVersion(real, file) });
-  }
-  let service = null;
+    const w = workOnPath(path.join(dir, "work"));
+    if (!w || seen.has(w.real)) continue;
+    seen.add(w.real);
+    onPath.push(shell.includes(dir) ? w : { ...w, servicePath: true });
+  }
+  // A service that answers without a version is from before /api/boot
+  // carried one: older than any CLI that asks.
+  const service = { answered: false, version: null, cli: serviceCli() };
   try {
     const res = await fetch(`${serverUrl()}/api/boot`, {
       signal: AbortSignal.timeout(2000),
     });
-    if (res.ok) service = (await res.json()).version ?? null;
+    if (res.ok) {
+      service.version = (await res.json()).version ?? null;
+      service.answered = true;
+    }
   } catch {}
-  return { self: { path: self, version: pkg.version }, onPath, service };
+  return { self, onPath, service };
 }
 
 function realpathOr(file) {
@@ -1057,28 +1086,118 @@ function realpathOr(file) {
   }
 }
 
-/** An install's version: an npm global's bin links into the package, whose
- * package.json says; a shim (mise's) is asked. */
-function installVersion(real, file) {
+/** The package of work a file is part of, read from its package.json and
+ * never by running anything: `prefix` is the npm prefix whose global it
+ * is, null for a checkout. */
+function installAt(file) {
+  const real = realpathOr(file);
   let dir = path.dirname(real);
   for (let i = 0; i < 3; i++) {
     try {
       const p = JSON.parse(fs.readFileSync(path.join(dir, "package.json")));
-      if (p.name === "@dylanpiercey/work") return p.version ?? null;
+      if (p.name === "@dylanpiercey/work") {
+        const prefix = /^(.*)\/lib\/node_modules\/@dylanpiercey\/work$/.exec(
+          dir,
+        )?.[1];
+        return {
+          path: file,
+          real,
+          version: p.version ?? null,
+          prefix: prefix ?? null,
+        };
+      }
     } catch {}
     dir = path.dirname(dir);
   }
+  return null;
+}
+
+/** Version managers whose shims stand in for `work`. A shim is the
+ * manager's own binary (mise links every shim to itself) or a script that
+ * hands off to it, so neither its path nor its target is the install: the
+ * manager's `which` names that. A global uninstalled from one of its
+ * nodes leaves the shim until a reshim. */
+function versionManagers() {
+  return [
+    {
+      id: "mise",
+      shim: (file, real) => path.basename(real) === "mise",
+      which: (real) => [real, ["which", "work"]],
+      installs: /\/mise\/installs\/node\//,
+      reshim: "mise reshim",
+    },
+    {
+      id: "asdf",
+      shim: (file) => /\/\.asdf\/shims$/.test(path.dirname(file)),
+      which: () => ["asdf", ["which", "work"]],
+      installs: /\/\.asdf\/installs\/nodejs\//,
+      reshim: "asdf reshim nodejs",
+    },
+    {
+      id: "nodenv",
+      shim: (file) => /\/\.nodenv\/shims$/.test(path.dirname(file)),
+      which: () => ["nodenv", ["which", "work"]],
+      installs: /\/\.nodenv\/versions\//,
+      reshim: "nodenv rehash",
+    },
+  ];
+}
+
+/** The install a `work` on PATH runs: an npm global's bin links into the
+ * package, a shim's is the one its manager names, and anything else is
+ * asked its version. */
+function workOnPath(file) {
+  try {
+    if (!fs.statSync(file).isFile()) return null;
+  } catch {
+    return null;
+  }
+  const own = installAt(file);
+  if (own) return own;
+  const real = realpathOr(file);
+  const manager = versionManagers().find((m) => m.shim(file, real));
+  if (manager) {
+    const [bin, argv] = manager.which(real);
+    const out = spawnSync(bin, argv, { encoding: "utf8", timeout: 5000 });
+    const target = out.status === 0 && out.stdout.trim();
+    const w = target && installAt(target);
+    if (w) return { ...w, path: file, manager: manager.id };
+  }
   const out = spawnSync(file, ["version"], { encoding: "utf8", timeout: 5000 });
-  return /^\d+\.\d+\.\d+\S*/.exec((out.stdout || "").trim())?.[0] ?? null;
+  const version = /^\d+\.\d+\.\d+\S*/.exec((out.stdout || "").trim())?.[0];
+  return { path: file, real, version: version ?? null, prefix: null };
+}
+
+/** The work the service definition runs (`[caffeinate -s] <cli> start`,
+ * or a checkout's run script under work-source local): the first program
+ * in its argv that is part of a work package. */
+function serviceCli() {
+  let text;
+  try {
+    text = fs.readFileSync(serviceFile(), "utf8");
+  } catch {
+    return null;
+  }
+  for (const arg of programOf(text)) {
+    const w = path.isAbsolute(arg) && installAt(arg);
+    if (w) return w;
+  }
+  return null;
 }
 
-/** How to remove an install: the npm beside the node whose global it is. */
-function removeHint(real) {
-  const m =
-    /^(.*)\/lib\/node_modules\/@dylanpiercey\/work\/bin\/work\.mjs$/.exec(real);
-  return m
-    ? `${m[1]}/bin/npm uninstall -g @dylanpiercey/work`
-    : `remove ${real}`;
+/** How to remove an npm global of work: npm's uninstall at the prefix it
+ * is in (named: the npm first on PATH may be another node's, whose own
+ * prefix holds some other install), then its version manager's reshim.
+ * Null for anything else, which is not this CLI's to remove. */
+function removeHint(w) {
+  if (!w.prefix) return null;
+  const manager = versionManagers().find(
+    (m) => m.id === w.manager || m.installs.test(`${w.prefix}/`),
+  );
+  const prefix = /^[\w@%+=:,./-]+$/.test(w.prefix)
+    ? w.prefix
+    : `'${w.prefix.replace(/'/g, `'\\''`)}'`;
+  return `npm uninstall -g --prefix ${prefix} @dylanpiercey/work${manager ? ` && ${manager.reshim}` : ""}`;
 }
 
 function newest(versions) {
@@ -1090,23 +1209,56 @@ function newest(versions) {
   }, null);
 }
 
-/** The doctor's warnings about which `work` this is. */
+/** The doctor's warnings about which `work` this is and which the service
+ * runs. */
 function installNotes({ self, onPath, service }) {
   const notes = [];
-  if (service && service !== self.version) {
-    const theirs = onPath.find((w) => w.version === service);
+  const runs = service.cli;
+  // The newest install here is the one to keep: an update installs it,
+  // and whatever else is here was left behind, the service's included.
+  const current = newest([self.version, ...onPath.map((w) => w.version)]);
+  const behind = (v) => v !== current && newest([v, current]) === current;
+  const keep = [...onPath.filter((w) => !w.servicePath), self].find(
+    (w) => w.prefix && w.version === current,
+  );
+  // `setup` from the install kept points the service at it, unless the
+  // service runs a checkout (work-source local), which setup would undo.
+  const move =
+    keep &&
+    runs?.prefix &&
+    `\`${keep === onPath[0] ? "work" : keep.path} setup\``;
+  if (service.answered && service.version !== self.version) {
+    const theirs = runs ?? onPath.find((w) => w.version === service.version);
+    notes.push(
+      `this work is ${self.version} (${tilde(self.path)}), but the running service is ${service.version ?? "older (it does not report its version)"}, so what this doctor says is an older or newer release's${theirs ? `: the service's is ${tilde(theirs.path)}` : ""}${move && behind(service.version) ? `; run ${move} to move it to ${current}` : ""}`,
+    );
+  } else if (!service.answered && runs && runs.version !== self.version) {
     notes.push(
-      `this work is ${self.version} (${tilde(self.path)}), but the running service is ${service}, so what this doctor says is an older or newer release's${theirs ? `: the service's is ${tilde(theirs.path)}` : ""}`,
+      `the service is set to run ${tilde(runs.path)} (${runs.version ?? "unknown version"}), not this work (${self.version}, ${tilde(self.path)})${move && behind(runs.version) ? `; run ${move} to move it to ${current}` : ""}`,
     );
   }
   if (onPath.length > 1) {
-    // A stray is one at another release than the service's (or, with no
-    // service answering, than the newest here).
-    const current = service ?? newest(onPath.map((w) => w.version));
-    const lines = onPath.map(
-      (w, i) =>
-        `  ${tilde(w.path)} → ${w.version ?? "unknown version"}${i === 0 ? "  (what \`work\` runs)" : ""}${w.version === current ? "" : `\n      remove: ${removeHint(w.real)}`}`,
-    );
+    const lines = onPath.map((w, i) => {
+      const tags = [
+        i === 0 && !w.servicePath && "what `work` runs",
+        w.servicePath && "on the service's PATH",
+        w.real === runs?.real && "the service's",
+      ].filter(Boolean);
+      const hint = removeHint(w);
+      // The service's own install goes only once the service is off it:
+      // removed first, it would stop the service.
+      const fix =
+        w.version === current
+          ? ""
+          : !hint
+            ? "not an npm global: remove it the way it was installed"
+            : w.real !== runs?.real
+              ? `remove: ${hint}`
+              : move
+                ? `remove, once ${move} has moved the service off it: ${hint}`
+                : "";
+      return `  ${tilde(w.path)} → ${w.version ?? "unknown version"}${tags.length ? `  (${tags.join(", ")})` : ""}${fix ? `\n      ${fix}` : ""}`;
+    });
     notes.push(`more than one work is on PATH:\n${lines.join("\n")}`);
   }
   return notes;

package/dist/_BKkT73fv.js

@@ -0,0 +1,2 @@
+import { J as notifySessionsChanged } from "./_Cv5RrCSW.js";
+export { notifySessionsChanged };

package/dist/_BviTiVOB.js

@@ -0,0 +1,2 @@
+import { f as teamsOf } from "./_DuwPQCOE.js";
+export { teamsOf };

package/dist/_BwqJGTg-.js

@@ -0,0 +1,183 @@
+//#endregion
+//#region src/styles/tokens.css.ts
+var color = {
+	ok: "light-dark(#1a7f37, #57d364)",
+	okStrong: "light-dark(#116329, #7ee787)",
+	warn: "light-dark(#bf8700, #d4a72c)",
+	warnStrong: "light-dark(#8a5a00, #f0b84a)",
+	merged: "light-dark(#8250df, #a371f7)",
+	closed: "light-dark(#cf222e, #f85149)",
+	onAccent: "#fff",
+	onDanger: "#fff",
+	accentDefault: "light-dark(#4f5bd5, #6470e6)",
+	bg: "var(--bg)",
+	panel: "var(--panel)",
+	border: "var(--border)",
+	text: "var(--text)",
+	dim: "var(--dim)",
+	accent: "var(--accent)",
+	accentFill: "var(--accent-fill)",
+	accentText: "var(--accent-text)",
+	danger: "var(--danger)",
+	fieldBorder: "var(--field-border)",
+	raised: "color-mix(in srgb, var(--panel) 94%, var(--text))",
+	raisedHover: "color-mix(in srgb, var(--panel) 90%, var(--text))",
+	onScrim: "#fff"
+};
+var sans = "Inter, ui-sans-serif, system-ui, -apple-system, \"Segoe UI\", sans-serif";
+var iconSize = {
+	sm: 12,
+	md: 14,
+	lg: 16,
+	xl: 18
+};
+var mobile = "screen and (max-width: 899px) and (pointer: coarse), screen and (max-width: 899px) and (pointer: none)";
+var glyphBadgeNum = "_P _O";
+var usageInk = {
+	ok: "_Q",
+	mid: "_R",
+	warm: "_S",
+	hot: "_T"
+};
+var usageFill = {
+	ok: "_U",
+	mid: "_V",
+	warm: "_W",
+	hot: "_X"
+};
+var prTone = {
+	open: "_Y",
+	draft: "_Z",
+	merged: "_0",
+	closed: "_1"
+};
+var phaseIcon = {
+	working: "_bd _bc",
+	waiting: "_be _bc",
+	idle: "_bf _bc",
+	off: "_bg _bc"
+};
+var btnSm = "_bn _I";
+var btnLg = "_bo _I";
+var tone = {
+	accent: "_bs",
+	ok: "_bt",
+	warn: "_bu",
+	danger: "_bv",
+	merged: "_bw",
+	closed: "_bx"
+};
+var inputLg = "_bB _bA";
+var iconBtnXs = "_bF _D";
+var iconBtnRow = "_bG _D";
+var iconBtnLg = "_bH _D";
+var chipBtn = "_bI _D";
+var toastStack = "_o _n";
+var toastKind = {
+	error: "_s",
+	warn: "_t",
+	info: "_u"
+};
+var toastTitle = {
+	error: "_v",
+	warn: "_w",
+	info: "_x"
+};
+var tocDot = "_cS _ba";
+//#endregion
+//#region src/tags/settings-agents.css.ts
+var agentRow = "_fF _em";
+var list$3 = "_eq _dj _el _eo";
+var metaChip = "_eE _bz _by";
+var sectionCount = "_dg _bp _bq";
+var usageNote = "_kb _by";
+var pop$2 = "_gh _bN";
+var spinner = "_gk _bD _bi";
+var toolLead = "_f3 _ez";
+var name$4 = "_fX _ez";
+var desc$1 = "_fY _eA";
+//#endregion
+//#region src/tags/lsp-add-dialog.css.ts
+var addDlg = "_kR _b4";
+var key$1 = "_mi _mg";
+var addTile = "_mk _mg";
+var field$2 = "_mv _bA";
+var keyField = "_mw _mv _bA";
+var labelField = "_mx _mv _bA";
+var detailsToggle = "_hi _6";
+var themeSeg = "_fj _bR";
+var checkList = "_gK _dh";
+//#endregion
+//#region src/tags/prompt-dialog.css.ts
+var promptDlg = "_b8 _b4";
+var item$1 = "_b0 _D";
+var glance = "_dG _D";
+//#endregion
+//#region src/tags/side-nav.css.ts
+var iconBtn = "_b9 _D";
+var settingsDot = "_b_ _bQ";
+var notifyBtn = "_ce _D";
+//#endregion
+//#region src/styles/session-pop.css.ts
+var sessionPop = "_cr _bN";
+var sessionPopBtn = "_cs _bk";
+var wsBtn = "_eY _bk";
+var rowIcon = "_e0 _bF _D";
+var prChip = "_mI _M _mC";
+//#endregion
+//#region src/tags/port-chip.css.ts
+var port = "_oJ _M _mC";
+var depth = {
+	"1": "_ky",
+	"2": "_kz",
+	"3": "_kA"
+};
+var open = "_kG _bk";
+var action = "_kL _bI _D";
+var toggle = "_eJ _6";
+var fold = "_eK _en";
+var statusOf = {
+	queued: "_lY",
+	starting: "_lZ",
+	working: "_l0",
+	waiting: "_l1",
+	idle: "_l2",
+	done: "_l3",
+	closed: "_l4"
+};
+var item = "_j2 _bk";
+var menu = "_nH _cr _bN";
+var menuItem = "_nJ _bk";
+var findBtn$1 = "_ir _ic _bG _D";
+var tool = "_ic _bG _D";
+var heldRefresh = "_ik _M";
+var pop$1 = "_m8 _cr _bN";
+var fileFilter = "_oN _F";
+var findInput = "_d6 _F";
+var keybarIconBtn = "_ee _bI _D";
+var input = "_du _F";
+var group = "_dx _6";
+var hint$1 = "_nq _bp _3";
+var sheetDir = "_n6 _bP";
+var upBtn = "_jh _bG _D";
+var findBtn = "_jl _ic _bG _D";
+var goBtn = "_jm _ic _bG _D";
+var note = "_nl _by";
+//#endregion
+//#region src/tags/manage-workspace.css.ts
+var procCmd = "_ht _ez";
+var factCopy = "_hA _bI _D";
+var resultRow = "_k6 _bk";
+var resultBranch = "_k7 _eE _bz _by _bF _D";
+var urlAction = "_k8 _eE _bz _by _eF";
+var curRow = "_fR _et";
+//#endregion
+//#region src/tags/join-dialog.css.ts
+var dlg = "_mX _b4";
+var hint = "_mY _by";
+var kbtn = "_cD _bH _D";
+var repeat = "_cG _cF";
+var dpadUser = "_cJ _cF";
+var dpadEsc = "_cK _cF";
+//#endregion
+export { field$2 as $, item as A, usageInk as At, wsBtn as B, fileFilter as C, iconBtnRow as Ct, findBtn$1 as D, prTone as Dt, tool as E, phaseIcon as Et, depth as F, settingsDot as G, sessionPopBtn as H, open as I, promptDlg as J, glance as K, port as L, fold as M, iconSize as Mt, toggle as N, mobile as Nt, menu as O, tone as Ot, action as P, sans as Pt, addTile as Q, prChip as R, keybarIconBtn as S, iconBtnLg as St, heldRefresh as T, inputLg as Tt, iconBtn as U, sessionPop as V, notifyBtn as W, themeSeg as X, checkList as Y, detailsToggle as Z, sheetDir as _, toastTitle as _t, dlg as a, name$4 as at, input as b, chipBtn as bt, resultBranch as c, spinner as ct, factCopy as d, list$3 as dt, key$1 as et, procCmd as f, metaChip as ft, upBtn as g, toastStack as gt, goBtn as h, toastKind as ht, repeat as i, desc$1 as it, statusOf as j, color as jt, menuItem as k, usageFill as kt, resultRow as l, usageNote as lt, findBtn as m, tocDot as mt, dpadUser as n, labelField as nt, hint as o, toolLead as ot, note as p, agentRow as pt, item$1 as q, kbtn as r, addDlg as rt, curRow as s, pop$2 as st, dpadEsc as t, keyField as tt, urlAction as u, sectionCount as ut, hint$1 as v, btnLg as vt, pop$1 as w, iconBtnXs as wt, findInput as x, glyphBadgeNum as xt, group as y, btnSm as yt, rowIcon as z };