@ai-ecoverse/slicc-spectrum 1.58.3 → 1.59.0

package/dist/slicc-ui.js

@@ -10171,7 +10171,7 @@ function coneLabel(model, agent) {
 }
 function watchTitles(model, update) {
   const seen = /* @__PURE__ */ new Map();
-  const check2 = (id) => {
+  const check3 = (id) => {
     const agent = model.agent.list().find((candidate) => candidate.id === id);
     if (agent?.kind !== "cone") return;
     const title = agentTitle(model, agent);
@@ -10180,8 +10180,8 @@ function watchTitles(model, update) {
     update();
   };
   const stops = [
-    model.agent.on("messages", check2),
-    model.agent.on("message", ({ agentId }) => check2(agentId))
+    model.agent.on("messages", check3),
+    model.agent.on("message", ({ agentId }) => check3(agentId))
   ];
   return () => {
     for (const stop of stops) stop();
@@ -10197,15 +10197,15 @@ function ago(at, now = Date.now()) {
   return `${Math.floor(days / 7)} weeks ago`;
 }
 async function deleteCone(model, agent, trigger2) {
-  const ok = await confirm({
+  const ok2 = await confirm({
     title: `Delete cone ${coneLabel(model, agent)}?`,
     body: "It stops, with its scoops. Its conversation stays in the Freezer, where you can thaw it.",
     action: "Delete cone",
     variant: "confirmation",
     trigger: trigger2
   });
-  if (ok) model.agent.freeze?.(agent.id);
-  return ok;
+  if (ok2) model.agent.freeze?.(agent.id);
+  return ok2;
 }
 var frozenKinds = {
   cone: ["indigo", "Cone"],
@@ -10277,14 +10277,14 @@ var SliccFreezer = class extends ModelElement {
     this.focusOn("swc-action-button");
   }
   async #remove(cone, trigger2) {
-    const ok = await confirm({
+    const ok2 = await confirm({
       title: `Remove ${this.#named(cone)} from the Freezer?`,
       body: "Its working folders are deleted. The conversation stays in the session database. You can\u2019t undo this.",
       action: "Remove",
       variant: "destructive",
       trigger: trigger2
     });
-    if (ok) this.model?.agent.discard(cone.id);
+    if (ok2) this.model?.agent.discard(cone.id);
   }
   #named(cone) {
     const rows = this.model?.agent.frozen() ?? [];
@@ -10503,14 +10503,14 @@ var SliccAgents = class extends ModelElement {
   async #drop(agent, trigger2) {
     const port = this.model?.agent;
     if (!port?.drop) return;
-    const ok = await confirm({
+    const ok2 = await confirm({
       title: `Drop scoop ${agent.name}?`,
       body: "It stops, and its working folder is deleted. Its conversation and reports are kept. You can\u2019t undo this.",
       action: "Drop",
       variant: "destructive",
       trigger: trigger2
     });
-    if (!ok) return;
+    if (!ok2) return;
     const { [agent.id]: _9, ...rest } = this.errors;
     this.errors = rest;
     try {
@@ -10858,33 +10858,33 @@ var lights = {
   unlinked: ["negative", (owner) => `Unlinked from ${owner}`],
   failed: ["negative", (owner) => `Can\u2019t reach ${owner}`]
 };
-function followLight(state2) {
-  const [variant, text2] = lights[state2.link];
-  return { variant, text: text2(state2.owner) };
+function followLight(state3) {
+  const [variant, text2] = lights[state3.link];
+  return { variant, text: text2(state3.owner) };
 }
-function followPage(state2) {
-  if (!state2) return null;
-  const { owner } = state2;
-  if (state2.link === "connecting")
+function followPage(state3) {
+  if (!state3) return null;
+  const { owner } = state3;
+  if (state3.link === "connecting")
     return {
       kind: "connecting",
       title: `Connecting to ${owner}\u2026`,
       body: `This device follows ${owner}. Its agent shows here once it\u2019s connected.`
     };
-  if (state2.link === "unlinked")
+  if (state3.link === "unlinked")
     return {
       kind: "unlinked",
       title: `${owner} unlinked this device`,
       body: `To follow it again, open a new link from ${owner}.`
     };
-  if (state2.link === "failed")
+  if (state3.link === "failed")
     return {
       kind: "failed",
       title: `Can\u2019t follow ${owner}`,
-      body: state2.error ?? `The link to ${owner} failed.`
+      body: state3.error ?? `The link to ${owner} failed.`
     };
-  if (state2.access.view) return null;
-  const where2 = state2.name ? `next to ${state2.name}` : "for this device";
+  if (state3.access.view) return null;
+  const where2 = state3.name ? `next to ${state3.name}` : "for this device";
   return {
     kind: "waiting",
     title: `Waiting for ${owner} to allow this device`,
@@ -10895,26 +10895,26 @@ function list(items, last) {
   if (items.length < 2) return items.join("");
   return `${items.slice(0, -1).join(", ")} ${last} ${items.at(-1)}`;
 }
-function followCan(state2) {
+function followCan(state3) {
   const allowed = ["watch the agent"];
   const missing = [];
-  (state2.access.control ? allowed : missing).push("send prompts");
-  (state2.access.terminal ? allowed : missing).push("open terminals");
+  (state3.access.control ? allowed : missing).push("send prompts");
+  (state3.access.terminal ? allowed : missing).push("open terminals");
   const can = `This device can ${list(allowed, "and")}.`;
-  return missing.length ? `${can} To ${list(missing, "or")}, allow it on ${state2.owner}.` : can;
+  return missing.length ? `${can} To ${list(missing, "or")}, allow it on ${state3.owner}.` : can;
 }
 function following(model) {
-  const state2 = model?.follow?.state();
-  return state2 && !followPage(state2) ? state2 : null;
+  const state3 = model?.follow?.state();
+  return state3 && !followPage(state3) ? state3 : null;
 }
 function watchOnly(model) {
-  const state2 = following(model);
-  if (!state2 || state2.access.control) return "";
-  return `${state2.owner} lets this device watch only. To send prompts, allow Control for it on ${state2.owner}.`;
+  const state3 = following(model);
+  if (!state3 || state3.access.control) return "";
+  return `${state3.owner} lets this device watch only. To send prompts, allow Control for it on ${state3.owner}.`;
 }
 function terminalsAllowed(model) {
-  const state2 = model?.follow?.state();
-  return !state2 || !!state2.access.terminal;
+  const state3 = model?.follow?.state();
+  return !state3 || !!state3.access.terminal;
 }
 var SliccFollow = class extends ModelElement {
   static properties = {
@@ -11010,15 +11010,15 @@ var SliccFollow = class extends ModelElement {
   async leave() {
     const port = this.model?.follow;
     if (!port || this.busy) return;
-    const state2 = port.state();
-    if (state2.link !== "unlinked") {
-      const ok = await confirm({
-        title: `Stop following ${state2.owner}?`,
-        body: `This device forgets the link. To follow ${state2.owner} again, open a new link from it.`,
+    const state3 = port.state();
+    if (state3.link !== "unlinked") {
+      const ok2 = await confirm({
+        title: `Stop following ${state3.owner}?`,
+        body: `This device forgets the link. To follow ${state3.owner} again, open a new link from it.`,
         action: "Leave",
         variant: "confirmation"
       });
-      if (!ok) return;
+      if (!ok2) return;
     }
     await this.#run("leave", () => port.leave());
   }
@@ -11057,12 +11057,12 @@ var SliccFollow = class extends ModelElement {
     </div>`;
   }
   render() {
-    const state2 = this.model?.follow?.state();
-    if (!state2) return A;
-    const page = followPage(state2);
+    const state3 = this.model?.follow?.state();
+    if (!state3) return A;
+    const page = followPage(state3);
     if (this.page) return page ? this.#page(page) : A;
-    const light = followLight(state2);
-    return b`<swc-action-button id="chip" class="chip" size="s" quiet data-follow=${state2.link} accessible-label=${light.text}>
+    const light = followLight(state3);
+    return b`<swc-action-button id="chip" class="chip" size="s" quiet data-follow=${state3.link} accessible-label=${light.text}>
         ${this.compact ? b`<swc-icon-user-following slot="icon" size="s" aria-hidden="true"></swc-icon-user-following>` : A}
         <swc-status-light size="s" variant=${light.variant}><span class="text">${light.text}</span></swc-status-light>
       </swc-action-button>
@@ -11070,8 +11070,8 @@ var SliccFollow = class extends ModelElement {
       <swc-popover for="chip" placement="bottom-end" accessible-label=${light.text}>
         <div class="panel">
           <h2>${light.text}</h2>
-          ${state2.link === "reconnecting" ? b`<p class="muted" data-reconnecting>The link to ${state2.owner} dropped. The conversation may be out of date until it’s back${state2.access.control ? ", and sending waits until then" : ""}.</p>` : A}
-          <p data-can>${followCan(state2)}</p>
+          ${state3.link === "reconnecting" ? b`<p class="muted" data-reconnecting>The link to ${state3.owner} dropped. The conversation may be out of date until it’s back${state3.access.control ? ", and sending waits until then" : ""}.</p>` : A}
+          <p data-can>${followCan(state3)}</p>
           ${this.#error()}
           <div class="actions">${this.#leaveButton()}</div>
         </div>
@@ -12786,9 +12786,9 @@ var SliccNetwork = class extends ModelElement {
     }
   }
   async copy() {
-    const done = await copyText(command);
-    this.copied = done;
-    this.uncopied = !done;
+    const done2 = await copyText(command);
+    this.copied = done2;
+    this.uncopied = !done2;
   }
   async #act(action, run2, area) {
     if (this.busy) return;
@@ -12835,13 +12835,13 @@ var SliccNetwork = class extends ModelElement {
     if (event2.key === "Enter") this.#sendKey(event2);
   }
   async #signOut(port) {
-    const ok = await confirm({
+    const ok2 = await confirm({
       title: "Sign out of Tailscale?",
       body: "This browser leaves your tailnet until you sign in again.",
       action: "Sign out",
       variant: "confirmation"
     });
-    if (ok) await this.#tailnet("sign-out", () => port.logoutTailnet?.());
+    if (ok2) await this.#tailnet("sign-out", () => port.logoutTailnet?.());
   }
   #copyButton(key2, what, label, value, area, hidden = false) {
     const copied = this.tailnetCopied === key2;
@@ -12949,13 +12949,13 @@ var SliccNetwork = class extends ModelElement {
   async #setControl(port, device, toggle) {
     const allowed = toggle.checked;
     if (allowed) {
-      const ok = await confirm({
+      const ok2 = await confirm({
         title: `Allow remote control from ${device.name}?`,
         body: "It can send prompts to the agent, watch its replies and stop it. Unlinking it, or a new certificate on it, turns this off again.",
         action: "Allow",
         variant: "confirmation"
       });
-      if (!ok) {
+      if (!ok2) {
         toggle.checked = false;
         return;
       }
@@ -12968,22 +12968,22 @@ var SliccNetwork = class extends ModelElement {
   }
   async #unlink(port, status2, device) {
     const isExit = status2.exit?.kind === "link" && status2.exit.id === device.id;
-    const ok = await confirm({
+    const ok2 = await confirm({
       title: `Unlink ${device.name}?`,
       body: unlinkBody(device, isExit),
       action: "Unlink",
       variant: "confirmation"
     });
-    if (ok) await this.#act(`unlink:${device.id}`, () => port.unlink?.(device.id), "linksError");
+    if (ok2) await this.#act(`unlink:${device.id}`, () => port.unlink?.(device.id), "linksError");
   }
   async #rotate(port, follow) {
-    const ok = await confirm({
+    const ok2 = await confirm({
       title: "Make a new join URL?",
       body: `Linked devices stay linked. Anyone with the old ${follow ? "join URL, follow link or QR code" : "URL"} can\u2019t link anymore.`,
       action: "New URL",
       variant: "confirmation"
     });
-    if (ok) await this.#act("rotate", () => port.rotateJoinUrl?.(), "linksError");
+    if (ok2) await this.#act("rotate", () => port.rotateJoinUrl?.(), "linksError");
   }
   #access(port, device) {
     const access = device.access;
@@ -13162,14 +13162,14 @@ var SliccNetwork = class extends ModelElement {
     </section>`;
   }
   async #disconnect(tray, name, trigger2) {
-    const ok = await confirm({
+    const ok2 = await confirm({
       title: `Disconnect from ${name}?`,
       body: "This SLICC stops syncing with the tray until you reconnect.",
       action: "Disconnect",
       variant: "confirmation",
       trigger: trigger2
     });
-    if (ok) tray.disconnect();
+    if (ok2) tray.disconnect();
   }
   #sync(tray) {
     const status2 = tray.status();
@@ -13366,8 +13366,9 @@ function create(tag3, model, params = {}) {
 function sideOf(id) {
   return surface(terminalOf(id) === null ? id : "terminal")?.side ?? "center";
 }
-function first(dock, side) {
-  return dock.api.panels.find((panel) => sideOf(panel.id) === side)?.id;
+var home = (panel) => sideOf(panel.id);
+function first(dock, side, sider, except) {
+  return dock.api.panels.find((panel) => panel.id !== except && sider(panel) === side)?.id;
 }
 var neighbours = {
   left: [
@@ -13383,26 +13384,47 @@ var neighbours = {
     ["left", "right"]
   ]
 };
-function placement(dock, side, screen) {
+function place(dock, side, screen, sider, except) {
   const anchor = (id, direction) => id ? { position: { referencePanel: id, direction } } : null;
   if (screen === "phone") return anchor(dock.api.panels[0]?.id, "within") ?? {};
-  const same = anchor(first(dock, side), "within");
+  const same = anchor(first(dock, side, sider, except), "within");
   if (same) return same;
   for (const [other, direction] of neighbours[side]) {
-    const found = anchor(first(dock, other), direction);
+    const found = anchor(first(dock, other, sider, except), direction);
     if (found) return found;
   }
   return {};
 }
-function openSurface(dock, item2, screen) {
+function placement(dock, side, screen) {
+  return place(dock, side, screen, home);
+}
+function views(node) {
+  return node.type === "leaf" ? node.data.views : node.data.flatMap(views);
+}
+function destination(dock, id, side, screen) {
+  const { grid } = dock.api.toJSON();
+  const root2 = grid.root;
+  const columns = String(grid.orientation) === "HORIZONTAL" && root2.type === "branch" ? root2.data.map(views) : [views(root2)];
+  const holds = (test) => columns.findIndex((ids) => ids.some((other) => other !== id && test(other)));
+  const chat = holds((other) => chatAgent(other) !== null);
+  const middle = chat < 0 ? holds((other) => sideOf(other) === "center") : chat;
+  const current = (panel) => {
+    if (middle < 0) return home(panel);
+    const at = columns.findIndex((ids) => ids.includes(panel.id));
+    return at < middle ? "left" : at > middle ? "right" : "center";
+  };
+  return place(dock, side, screen, current, id);
+}
+function openSurface(dock, item2, screen, focus = true) {
   if (dock.has(item2.id)) return;
-  const place2 = placement(dock, item2.side, screen);
-  const fresh2 = place2.position?.direction !== "within";
+  const place3 = placement(dock, item2.side, screen);
+  const fresh2 = place3.position?.direction !== "within";
   dock.open({
     id: item2.id,
     component: item2.id,
     title: item2.title,
-    ...place2,
+    inactive: !focus,
+    ...place3,
     ...fresh2 && item2.width && screen !== "phone" ? { initialWidth: item2.width } : {}
   });
 }
@@ -13419,35 +13441,37 @@ function openChat(dock, agent, screen, focus = true, reveal = true) {
   const id = chatId(agent.id);
   if (!dock.has(id)) {
     const sibling = chats(dock)[0];
-    const place2 = sibling ? { position: { referencePanel: sibling, direction: "within" } } : placement(dock, "center", screen);
+    const place3 = sibling ? { position: { referencePanel: sibling, direction: "within" } } : placement(dock, "center", screen);
     dock.open({
       id,
       component: "chat",
       title: agent.name,
       params: { agent: agent.id },
       inactive: !focus,
-      ...place2
+      ...place3
     });
   }
   if (focus) dock.focusPanel(id);
   else if (reveal) dock.reveal(id);
   return id;
 }
-function openDocument(dock, kind, path, screen) {
+function openDocument(dock, kind, path, screen, focus = true) {
   const id = `${kind}:${path}`;
   if (!dock.has(id)) {
     const sibling = dock.api.panels.find((panel) => /^(file|diff):/.test(panel.id));
     const chat = chats(dock)[0];
-    const place2 = sibling ? { position: { referencePanel: sibling.id, direction: "within" } } : chat && screen !== "phone" ? { position: { referencePanel: chat, direction: "right" } } : placement(dock, "center", screen);
+    const place3 = sibling ? { position: { referencePanel: sibling.id, direction: "within" } } : chat && screen !== "phone" ? { position: { referencePanel: chat, direction: "right" } } : placement(dock, "center", screen);
     dock.open({
       id,
       component: kind,
       title: documents[kind].title(path),
       params: { path },
-      ...place2
+      inactive: !focus,
+      ...place3
     });
   }
-  dock.focusPanel(id);
+  if (focus) dock.focusPanel(id);
+  else dock.reveal(id);
   return id;
 }
 function terminalPanel(terminal) {
@@ -13516,7 +13540,7 @@ var directions = {
 function dropPlacement(panel, position) {
   return panel ? { position: { referencePanel: panel, direction: directions[position] ?? "within" } } : null;
 }
-function openSprinkle(dock, sprinkle, screen, place2 = null) {
+function openSprinkle(dock, sprinkle, screen, place3 = null, focus = true) {
   const id = `sprinkle:${sprinkle.id}`;
   if (!dock.has(id)) {
     dock.open({
@@ -13524,13 +13548,364 @@ function openSprinkle(dock, sprinkle, screen, place2 = null) {
       component: "sprinkle",
       title: sprinkle.title,
       params: { sprinkle: sprinkle.id },
-      ...place2 ?? placement(dock, "right", screen)
+      inactive: !focus,
+      ...place3 ?? placement(dock, "right", screen)
     });
   }
-  dock.focusPanel(id);
+  if (focus) dock.focusPanel(id);
+  else dock.reveal(id);
   return id;
 }
 
+// src/app/panel-command.ts
+var userCloseWindow = 6e4;
+var positions = {
+  left: "left",
+  right: "right",
+  above: "top",
+  below: "bottom",
+  within: "center"
+};
+var ok = (message) => ({ code: 0, message });
+var refused = (message) => ({ code: 5, message });
+var unknown = (id) => ({
+  code: 1,
+  message: `no panel called ${id}; panel list shows the ids you can use`
+});
+var Panels = class {
+  #host;
+  #quiet = 0;
+  #closed = /* @__PURE__ */ new Map();
+  constructor(host4) {
+    this.#host = host4;
+  }
+  quietly(run2) {
+    this.#quiet++;
+    try {
+      return run2();
+    } finally {
+      this.#quiet--;
+    }
+  }
+  closed(id) {
+    if (this.#quiet === 0) this.#closed.set(id, Date.now());
+  }
+  closedAgo(id) {
+    const at = this.#closed.get(id);
+    if (at === void 0) return null;
+    const ago2 = Date.now() - at;
+    return ago2 < userCloseWindow ? ago2 : null;
+  }
+  recentClose() {
+    const dock = this.#host.dock();
+    for (const id of this.#closed.keys()) {
+      const ago2 = this.closedAgo(id);
+      if (ago2 !== null && !dock.has(id)) return { id, ago: ago2 };
+    }
+    return null;
+  }
+  typing() {
+    return this.#host.typing();
+  }
+  agents() {
+    return this.#host.model()?.agent.list() ?? [];
+  }
+  active() {
+    return this.#host.model()?.agent.active() ?? null;
+  }
+  list() {
+    const host4 = this.#host;
+    const surfaces3 = host4.surfaces();
+    const offers = (id) => surfaces3.some((item2) => item2.id === id);
+    const rows = [
+      ...surfaces3.filter((item2) => item2.id !== "chat" && item2.id !== "terminal").map((item2) => ({
+        id: item2.id,
+        title: item2.title,
+        kind: "surface",
+        side: item2.side,
+        agent: null
+      })),
+      ...(offers("chat") ? this.agents() : []).map((agent) => ({
+        id: `chat:${agent.id}`,
+        title: agent.name,
+        kind: "chat",
+        side: "center",
+        agent: agent.id
+      })),
+      ...(offers("terminal") ? host4.model()?.terminals.list() ?? [] : []).map((info) => ({
+        id: terminalPanel(info.id),
+        title: terminalTitle(info),
+        kind: "terminal",
+        side: "right",
+        agent: null
+      })),
+      ...host4.sprinkles().map((sprinkle) => ({
+        id: `sprinkle:${sprinkle.id}`,
+        title: sprinkle.title,
+        kind: "sprinkle",
+        side: "right",
+        agent: sprinkle.id.includes("/") ? sprinkle.agentId : null
+      })),
+      ...host4.dock().api.panels.filter((panel) => /^(file|diff):/.test(panel.id)).map((panel) => ({
+        id: panel.id,
+        title: panel.title ?? panel.id,
+        kind: panel.id.slice(0, panel.id.indexOf(":")),
+        side: "center",
+        agent: null
+      }))
+    ];
+    return rows.map((row) => this.#state(row));
+  }
+  #state(row) {
+    const dock = this.#host.dock();
+    const panel = dock.api.getPanel(row.id);
+    const content = dock.content(row.id);
+    return {
+      ...row,
+      open: panel !== void 0,
+      visible: panel?.api.isVisible === true,
+      active: panel !== void 0 && dock.api.activePanel?.id === row.id,
+      busy: content?.busyReason ?? null
+    };
+  }
+  find(id) {
+    const listed = this.list().find((info) => info.id === id);
+    if (listed) return listed;
+    const document2 = id.match(/^(file|diff):(.+)$/);
+    if (!document2) return void 0;
+    return this.#state({
+      id,
+      title: id,
+      kind: document2[1],
+      side: "center",
+      agent: null
+    });
+  }
+  open(id, options = {}) {
+    return this.#show(id, false, options);
+  }
+  focus(id, options = {}) {
+    return this.#show(id, true, options);
+  }
+  #show(id, focus, { place: place3, section }) {
+    const info = this.find(id);
+    if (!info) return unknown(id);
+    const bad = this.#reference(id, place3);
+    if (bad) return bad;
+    this.quietly(() => this.#host.open(id, focus, section));
+    if (place3) {
+      const moved = this.move(id, place3);
+      if (moved.code !== 0) return moved;
+    }
+    return ok(`${focus ? "focused" : info.open ? "showed" : "opened"} ${id}`);
+  }
+  close(id) {
+    const info = this.find(id);
+    if (!info) return unknown(id);
+    if (!info.open) return ok(`${id} was already closed`);
+    if (info.kind === "terminal")
+      return refused(`closing ${id} stops its shell; ask the user to close it`);
+    if (info.kind === "chat" && chats(this.#host.dock()).length === 1)
+      return refused(`${id} is the last chat, so it stays open`);
+    if (info.busy) return refused(`${id} is busy: ${info.busy}`);
+    this.quietly(() => this.#host.dock().close(id));
+    return ok(`closed ${id}`);
+  }
+  move(id, place3) {
+    const info = this.find(id);
+    if (!info) return unknown(id);
+    const bad = this.#reference(id, place3);
+    if (bad) return bad;
+    const dock = this.#host.dock();
+    if (!info.open) this.quietly(() => this.#host.open(id, false));
+    if (!dock.has(id)) return unknown(id);
+    if (this.#host.screen() === "phone")
+      return ok(`phones show one panel at a time, so ${id} stays where it is`);
+    const busy = info.open ? info.busy : this.find(id)?.busy ?? null;
+    if (busy) return refused(`${id} is busy: ${busy}`);
+    const target = typeof place3 === "string" ? destination(dock, id, place3, this.#host.screen()) : { position: { referencePanel: place3.ref, direction: place3.direction } };
+    const reference2 = target.position && dock.api.getPanel(target.position.referencePanel);
+    if (!reference2 || !target.position) return ok(`${id} is the only panel, so it stays`);
+    const position = positions[target.position.direction];
+    const panel = dock.api.getPanel(id);
+    this.quietly(() => panel?.api.moveTo({ group: reference2.group, position }));
+    return ok(`moved ${id}`);
+  }
+  #reference(id, place3) {
+    if (typeof place3 !== "object") return null;
+    if (place3.ref === id) return { code: 2, message: `can't place ${id} beside itself` };
+    if (!this.#host.dock().has(place3.ref)) return { code: 1, message: `${place3.ref} isn't open` };
+    return null;
+  }
+  reset() {
+    const busy = this.list().find((info) => info.open && info.busy);
+    if (busy) return refused(`${busy.id} is busy: ${busy.busy}`);
+    this.quietly(() => this.#host.reset());
+    return ok("restored the default layout");
+  }
+};
+var help = `usage: panel <command>
+
+  list [--json]              the panels you can reach, and their state
+  open <id> [place]          show a panel; keyboard focus stays where it is
+  focus <id> [place]         show a panel and give it keyboard focus
+  close <id>                 close a panel
+  move <id> <place>          move an open panel
+  reset                      restore the default layout
+
+place: left | center | right, or --left | --right | --above | --below | --within <id>
+open and focus also take --section <name>, e.g. panel open settings --section accounts
+
+ids: the ones panel list shows, e.g. files, changes, terminal, monitor, settings,
+     chat (your cone's chat), chat:<agent>, terminal:<n>, sprinkle:<name>,
+     file:<path>, diff:<path>
+`;
+var verbs = /* @__PURE__ */ new Set(["list", "open", "focus", "close", "move", "reset"]);
+var sides = /* @__PURE__ */ new Set(["left", "center", "right"]);
+var directions2 = /* @__PURE__ */ new Set(["left", "right", "above", "below", "within"]);
+function scan(parsed, rest, positional) {
+  for (let index = 0; index < rest.length; index++) {
+    const arg = rest[index];
+    const flag = arg.startsWith("--") ? arg.slice(2) : null;
+    if (flag === "json") parsed.json = true;
+    else if (flag === "section" || flag !== null && directions2.has(flag)) {
+      const value = rest[++index];
+      if (value === void 0) return `--${flag} needs a value`;
+      if (flag === "section") parsed.section = value;
+      else if (parsed.place) return "give one place";
+      else parsed.place = { direction: flag, ref: value };
+    } else if (arg.startsWith("-")) return `unknown option ${arg}`;
+    else positional.push(arg);
+  }
+  const [id, side, ...extra] = positional;
+  if (extra.length > 0) return `unexpected ${extra[0]}`;
+  parsed.id = id;
+  if (side === void 0) return null;
+  if (!sides.has(side)) return `${side} isn't a place; use left, center or right`;
+  if (parsed.place) return "give one place";
+  parsed.place = side;
+  return null;
+}
+function check({ verb, id, json, section, place: place3 }) {
+  const ids = verb === "list" || verb === "reset" ? 0 : 1;
+  if ((id === void 0 ? 0 : 1) !== ids)
+    return ids ? `${verb} needs an id` : `${verb} takes no id`;
+  if (json && verb !== "list") return "--json is for list";
+  if (section !== void 0 && verb !== "open" && verb !== "focus")
+    return "--section is for open and focus";
+  if (place3 && verb !== "open" && verb !== "focus" && verb !== "move")
+    return `${verb} takes no place`;
+  if (verb === "move" && !place3) return "move needs a place";
+  return null;
+}
+function parse(args2) {
+  const [verb, ...rest] = args2;
+  if (!verbs.has(verb)) return `unknown command ${verb}`;
+  const parsed = { verb, json: false };
+  return scan(parsed, rest, []) ?? check(parsed) ?? parsed;
+}
+function coneOf(agents, id) {
+  let agent = agents.find((candidate) => candidate.id === id);
+  const seen = /* @__PURE__ */ new Set();
+  while (agent && agent.kind !== "cone" && !seen.has(agent)) {
+    seen.add(agent);
+    agent = agents.find((candidate) => candidate.id === agent?.parentId);
+  }
+  return agent?.kind === "cone" ? agent.id : null;
+}
+function resolve(panels, raw2, reachable, cone) {
+  if (/^(file|diff):./.test(raw2)) return raw2;
+  if (raw2 === "chat") {
+    const agent = cone === void 0 ? panels.active() : cone;
+    return reachable.some((info) => info.id === `chat:${agent}`) ? `chat:${agent}` : null;
+  }
+  if (raw2 === "terminal") {
+    const terminals = reachable.filter((info) => info.kind === "terminal");
+    const picked = terminals.find((info) => info.active) ?? terminals.filter((info) => info.open).at(-1) ?? terminals.at(-1);
+    return picked?.id ?? null;
+  }
+  if (reachable.some((info) => info.id === raw2)) return raw2;
+  const name = raw2.startsWith("sprinkle:") ? raw2.slice(9) : raw2;
+  const sprinkles = reachable.filter((info) => info.kind === "sprinkle");
+  const found = sprinkles.find((info) => info.id === `sprinkle:${name}`) ?? sprinkles.find((info) => cone && info.id === `sprinkle:${cone}/${name}`) ?? sprinkles.find((info) => info.id.split("/").at(-1) === name);
+  return found?.id ?? null;
+}
+function state(info) {
+  const shown2 = info.active ? "active" : info.visible ? "shown" : info.open ? "open" : "closed";
+  return info.busy ? `${shown2} \xB7 busy: ${info.busy}` : shown2;
+}
+function table(rows) {
+  const lines = [["ID", "TITLE", "STATE"], ...rows.map((row) => [row.id, row.title, state(row)])];
+  const widths = [0, 1].map((column) => Math.max(...lines.map((line) => line[column].length)));
+  return lines.map(([id, title, shown2]) => `${id.padEnd(widths[0])}  ${title.padEnd(widths[1])}  ${shown2}`).join("\n");
+}
+var done = (result, note = "") => result.code === 0 ? { stdout: `${result.message}${note}
+`, stderr: "", code: 0 } : { stdout: "", stderr: `panel: ${result.message}
+`, code: result.code };
+function act(scope, parsed) {
+  const { panels, reachable, cone } = scope;
+  if (parsed.verb === "reset") {
+    const recent = scope.agent ? panels.recentClose() : null;
+    if (recent)
+      return refusedOutput(
+        `the user closed ${recent.id} ${Math.round(recent.ago / 1e3)} s ago; ask before resetting the layout`
+      );
+    return done(panels.reset());
+  }
+  const raw2 = parsed.id;
+  const id = resolve(panels, raw2, reachable, cone);
+  if (!id) return done(unknown(raw2));
+  let place3 = parsed.place;
+  if (typeof place3 === "object") {
+    const ref = resolve(panels, place3.ref, reachable, cone);
+    if (!ref) return done(unknown(place3.ref));
+    place3 = { ...place3, ref };
+  }
+  if (parsed.verb === "close") return done(panels.close(id));
+  const ago2 = scope.agent && !panels.find(id)?.open ? panels.closedAgo(id) : null;
+  if (ago2 !== null)
+    return refusedOutput(
+      `the user closed ${id} ${Math.round(ago2 / 1e3)} s ago; ask before opening it again`
+    );
+  if (parsed.verb === "move") return done(panels.move(id, place3));
+  const options = { place: place3, section: parsed.section };
+  if (parsed.verb === "open") return done(panels.open(id, options));
+  if (scope.agent && panels.typing())
+    return done(
+      panels.open(id, options),
+      "; the user is typing, so it was shown without taking focus"
+    );
+  return done(panels.focus(id, options));
+}
+function panelCommand(app, argv, caller) {
+  const panels = app.panels;
+  const args2 = argv[0] === "panel" ? argv.slice(1) : argv;
+  if (args2.length === 0 || args2[0] === "--help" || args2[0] === "-h" || args2[0] === "help")
+    return { stdout: help, stderr: "", code: 0 };
+  if (caller.readOnly && args2[0] !== "list")
+    return refusedOutput("this page only follows SLICC; panel list is all it allows");
+  const parsed = parse(args2);
+  if (typeof parsed === "string")
+    return { stdout: "", stderr: `panel: ${parsed}
+
+${help}`, code: 2 };
+  const agents = panels.agents();
+  const scoped2 = caller.agentId !== null || !!caller.cone;
+  const cone = scoped2 ? caller.cone ?? coneOf(agents, caller.agentId) : void 0;
+  const reachable = panels.list().filter(
+    (info) => !scoped2 || info.agent === null || !!cone && coneOf(agents, info.agent) === cone
+  );
+  if (parsed.verb !== "list")
+    return act({ panels, agent: caller.agentId !== null, cone, reachable }, parsed);
+  const body4 = parsed.json ? JSON.stringify(reachable, null, 2) : table(reachable);
+  return { stdout: `${body4}
+`, stderr: "", code: 0 };
+}
+function refusedOutput(message) {
+  return { stdout: "", stderr: `panel: ${message}
+`, code: 5 };
+}
+
 // node_modules/@adobe/spectrum-wc/dist/swc.css
 var swc_default = `/**
  * Copyright 2026 Adobe. All rights reserved.
@@ -13662,23 +14037,23 @@ function installProperties(document2, text2 = swc_default) {
 var following2 = "SLICC runs in another tab. This tab shows it and sends your actions there.";
 var connecting = "Connecting to the tab running SLICC\u2026";
 var alone = "SLICC is open in another tab.";
-function tabsBanner(state2) {
-  if (!state2 || state2.role === "alone") return null;
-  if (state2.skew === "newer")
+function tabsBanner(state3) {
+  if (!state3 || state3.role === "alone") return null;
+  if (state3.skew === "newer")
     return {
       kind: "skew",
       skew: "newer",
       text: "Another tab runs a newer SLICC. Reload this tab.",
       reload: true
     };
-  if (state2.skew === "older")
+  if (state3.skew === "older")
     return {
       kind: "skew",
       skew: "older",
       text: "Another tab runs an older SLICC. Reload the other SLICC tab.",
       reload: false
     };
-  if (state2.stalled)
+  if (state3.stalled)
     return {
       kind: "stalled",
       skew: null,
@@ -13687,11 +14062,11 @@ function tabsBanner(state2) {
     };
   return null;
 }
-function tabsLight(state2) {
-  if (!state2 || state2.role === "owner" || state2.role === "alone") return null;
-  const banner = tabsBanner(state2);
+function tabsLight(state3) {
+  if (!state3 || state3.role === "owner" || state3.role === "alone") return null;
+  const banner = tabsBanner(state3);
   if (banner) return { variant: "notice", text: "Another tab", tooltip: banner.text };
-  if (state2.role === "connecting")
+  if (state3.role === "connecting")
     return { variant: "info", text: "Connecting", tooltip: connecting };
   return { variant: "neutral", text: "Another tab", tooltip: following2 };
 }
@@ -13932,11 +14307,11 @@ var SliccTerminalPanel = class extends ThemedElement {
     const host4 = this.getRootNode().host;
     const panel = host4?.localName === "slicc-dock" ? host4.api.getPanel(terminalPanel(id)) : void 0;
     if (!panel || laid(panel.api)) return Promise.resolve();
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const watch = panel.api.onDidDimensionsChange((size4) => {
         if (!laid(size4)) return;
         watch.dispose();
-        resolve();
+        resolve2();
       });
     });
   }
@@ -19890,7 +20265,7 @@ function block(lines, i25) {
   const end = run(lines, i25, (l24) => l24.trim() !== "" && !starts.test(l24) && !itemPattern.test(l24));
   return [{ type: "paragraph", text: lines.slice(i25, end).join(" ") }, end];
 }
-function parse(text2) {
+function parse2(text2) {
   const lines = text2.split("\n");
   const blocks = [];
   let i25 = 0;
@@ -19931,7 +20306,7 @@ function render(entry) {
   }
 }
 function markdown(text2) {
-  return b`${parse(text2).map(render)}`;
+  return b`${parse2(text2).map(render)}`;
 }
 
 // src/app/messages.ts
@@ -20057,7 +20432,7 @@ function toolSummary(calls) {
   }
   return [...counts].sort((a22, b13) => b13[1] - a22[1]).map(([kind, count]) => `${count} ${count === 1 ? kind.one : kind.many}`).join(", ");
 }
-function state(status2, label = toolStates[status2][0]) {
+function state2(status2, label = toolStates[status2][0]) {
   return b`<span class="state" data-state=${status2}>${toolStates[status2][1]}<span>${label}</span></span>`;
 }
 var actionLabels = {
@@ -20114,7 +20489,7 @@ function tool(call, color = "light") {
         <span class="title">${call.title}</span>
         <span class="name">${call.name}</span>
         ${call.meta ? b`<span class="tool-meta">${call.meta}</span>` : A}
-        ${state(call.status)}
+        ${state2(call.status)}
       </span>
       ${call.image ? b`<span class="thumb"><img src=${call.image} alt="" /></span>` : A}
     </summary>
@@ -20139,7 +20514,7 @@ function cluster(calls, open, color) {
       <swc-icon-chevron-right class="chevron" size="s" aria-hidden="true"></swc-icon-chevron-right>
       <span class="title">${calls.length} tools</span>
       <span class="names"><span aria-hidden="true">· </span>${toolSummary(calls)}</span>
-      ${state(overall, label || void 0)}
+      ${state2(overall, label || void 0)}
     </summary>
     <div class="calls">${calls.map((call) => tool(call, color))}</div>
   </details>`;
@@ -20174,7 +20549,7 @@ function card(item2) {
   }
   return b`<div class="card light" data-tone=${item2.tone}><strong>${item2.title}</strong><span>${item2.detail}</span></div>`;
 }
-function check(items) {
+function check2(items) {
   return b`<ul class="check">
     ${items.map((entry) => b`<li data-tone=${entry.tone ?? "positive"}><span class="mark" aria-hidden="true">✓</span>${entry.text}</li>`)}
   </ul>`;
@@ -20244,7 +20619,7 @@ function part(entry, handlers, showThinking) {
     case "plan":
       return b`<div class="plan"><div class="label">Plan</div><ol>${entry.items.map((step) => b`<li>${step}</li>`)}</ol></div>`;
     case "check":
-      return check(entry.items);
+      return check2(entry.items);
     case "diff":
       return b`<div class="inline-diff">
         <button class="diff-head" @click=${() => handlers.open(entry.path)}>${entry.path}</button>
@@ -21155,7 +21530,7 @@ function requiresText(item2, all2) {
   ].filter(Boolean);
   return parts2.length ? parts2.join("; ") : null;
 }
-var snapshot = (items) => new Map(items.map(({ id, state: state2, error }) => [id, { state: state2, error }]));
+var snapshot = (items) => new Map(items.map(({ id, state: state3, error }) => [id, { state: state3, error }]));
 function settled(failures, before, after) {
   return new Map(
     [...failures].filter(([id]) => {
@@ -21218,6 +21593,11 @@ var SliccUpdates = class extends ModelElement {
     this.busy = /* @__PURE__ */ new Map();
     this.problems = /* @__PURE__ */ new Map();
   }
+  get busyReason() {
+    const packages = this.model?.updates?.packages?.() ?? [];
+    const running2 = this.busy.size > 0 || packages.some((item2) => packageRunning.has(item2.state));
+    return running2 ? "a package is installing" : null;
+  }
   static styles = [
     i`
       :host {
@@ -21566,8 +21946,8 @@ var SliccUpdates = class extends ModelElement {
     return b`<span>Checked <time datetime=${date.toISOString()}>${shown2}</time></span>`;
   }
   #item(item2) {
-    const [variant, state2] = states[item2.state];
-    const label = item2.state === "failed" && item2.from !== null ? "Update failed" : state2;
+    const [variant, state3] = states[item2.state];
+    const label = item2.state === "failed" && item2.from !== null ? "Update failed" : state3;
     const error = this.failures.get(item2.id) ?? item2.error;
     return b`<swc-divider size="s"></swc-divider>
     <article data-id=${item2.id} data-state=${item2.state} aria-label=${item2.label}>
@@ -21625,10 +22005,10 @@ var SliccUpdates = class extends ModelElement {
       accessible-label=${`${item2.label}: ${packageLight(item2)?.[1].toLowerCase()}`}
     ></swc-progress-bar>`;
   }
-  #package(item2, all2, act) {
+  #package(item2, all2, act2) {
     const light = packageLight(item2);
     const busy = this.busy.get(item2.id);
-    const shown2 = busy ? [busy] : act ? item2.actions : [];
+    const shown2 = busy ? [busy] : act2 ? item2.actions : [];
     const error = this.problems.get(item2.id) ?? item2.error;
     return b`<li data-id=${item2.id} data-state=${item2.state}>
       <div class="name">
@@ -21759,6 +22139,9 @@ function finishTransitions(root2) {
   for (const element2 of root2.querySelectorAll("*"))
     if (element2.shadowRoot) finishTransitions(element2.shadowRoot);
 }
+function editable(node) {
+  return node instanceof HTMLElement && (node.isContentEditable || node.tagName === "TEXTAREA" || node.tagName === "INPUT");
+}
 var SliccApp = class extends ThemedElement {
   static properties = {
     ...ThemedElement.properties,
@@ -21769,6 +22152,17 @@ var SliccApp = class extends ThemedElement {
   layoutKey = "slicc-ui.layout.v2";
   dips = new Dips();
   terminalPanels = new TerminalPanels();
+  panels = new Panels({
+    dock: () => this.dock,
+    screen: () => this.screen,
+    model: () => this.model,
+    surfaces: () => this.#available(),
+    sprinkles: () => this.#sprinkles(),
+    open: (id, focus, section) => this.#open(id, focus, section),
+    reset: () => this.resetLayout(),
+    typing: () => this.#typing()
+  });
+  #typedAt = Number.NEGATIVE_INFINITY;
   #fontBase = defaultFontBase;
   #variableFont = defaultVariableFont;
   #resize = null;
@@ -22111,12 +22505,15 @@ var SliccApp = class extends ThemedElement {
     }
     if (this.#painted !== color) this.#hold.paint(color);
     this.#painted = color;
-    if (!this.model) return;
-    const layout = this.#started !== this.screen;
-    if (layout) this.#start(this.model);
-    else if (changed.has("model")) this.#rebind(this.model);
-    this.#updates(layout);
-    this.#retitle();
+    const model = this.model;
+    if (!model) return;
+    this.panels.quietly(() => {
+      const layout = this.#started !== this.screen;
+      if (layout) this.#start(model);
+      else if (changed.has("model")) this.#rebind(model);
+      this.#updates(layout);
+      this.#retitle();
+    });
   }
   #retitle() {
     for (const sprinkle of this.#sprinkles()) {
@@ -22180,7 +22577,10 @@ var SliccApp = class extends ThemedElement {
     if (!this.#started) return;
     const dock = this.dock;
     dock.factories = this.#factories(model);
-    if (!terminalsAllowed(model)) for (const id of terminalPanels(dock)) dock.close(id);
+    if (!terminalsAllowed(model))
+      this.panels.quietly(() => {
+        for (const id of terminalPanels(dock)) dock.close(id);
+      });
   }
   #start(model) {
     const dock = this.dock;
@@ -22230,11 +22630,13 @@ var SliccApp = class extends ThemedElement {
     const dock = this.renderRoot.querySelector("slicc-dock");
     if (!dock || !this.#started) return;
     const known = new Set(this.model?.agent.list().map((agent) => agent.id));
-    for (const id of chats(dock)) {
-      if (!known.has(chatAgent(id))) dock.close(id);
-    }
-    if (this.model && this.#offers("terminal"))
-      this.terminalPanels.sync(dock, this.model.terminals, this.screen);
+    this.panels.quietly(() => {
+      for (const id of chats(dock)) {
+        if (!known.has(chatAgent(id))) dock.close(id);
+      }
+      if (this.model && this.#offers("terminal"))
+        this.terminalPanels.sync(dock, this.model.terminals, this.screen);
+    });
   }
   #activated(event2) {
     const { id } = event2.detail;
@@ -22245,7 +22647,9 @@ var SliccApp = class extends ThemedElement {
   }
   resetLayout() {
     const terminals = this.model?.terminals.list();
-    defaultLayout(this.dock, this.screen, this.#active(), this.#available(), terminals);
+    this.panels.quietly(
+      () => defaultLayout(this.dock, this.screen, this.#active(), this.#available(), terminals)
+    );
     this.#save();
   }
   #showSurface(event2) {
@@ -22253,14 +22657,28 @@ var SliccApp = class extends ThemedElement {
     this.show(id, section);
   }
   show(id, section) {
-    const agent = this.#active();
-    if (id === "chat" && agent && this.#offers("chat")) {
-      openChat(this.dock, agent, this.screen);
+    this.#open(id, true, section);
+  }
+  #open(id, focus, section) {
+    const agent = id === "chat" ? this.#active() : this.model?.agent.list().find((candidate) => `chat:${candidate.id}` === id);
+    if (agent && this.#offers("chat")) {
+      openChat(this.dock, agent, this.screen, focus);
       return;
     }
     const sprinkle = this.#sprinkles().find((candidate) => `sprinkle:${candidate.id}` === id);
     if (sprinkle) {
-      openSprinkle(this.dock, sprinkle, this.screen);
+      this.dips.detach(sprinkle.id);
+      openSprinkle(this.dock, sprinkle, this.screen, null, focus);
+      return;
+    }
+    const terminal = this.model?.terminals.list().find((info) => info.id === terminalOf(id));
+    if (terminal && this.#offers("terminal")) {
+      this.#reveal(openTerminal(this.dock, terminal, this.screen), focus);
+      return;
+    }
+    const document2 = id.match(/^(file|diff):(.+)$/);
+    if (document2) {
+      openDocument(this.dock, document2[1], document2[2], this.screen, focus);
       return;
     }
     const item2 = surface(id, this.#available());
@@ -22269,12 +22687,24 @@ var SliccApp = class extends ThemedElement {
       if (this.model) this.terminalPanels.show(this.dock, this.model.terminals, this.screen);
       return;
     }
-    openSurface(this.dock, item2, this.screen);
+    openSurface(this.dock, item2, this.screen, focus);
     if (id === "updates") this.dock.api.getPanel(id)?.api.updateParameters({ boot: false });
-    this.dock.focusPanel(id);
+    this.#reveal(id, focus);
     if (section)
       this.dock.content(id)?.reveal?.(section);
   }
+  #reveal(id, focus) {
+    if (focus) this.dock.focusPanel(id);
+    else this.dock.reveal(id);
+  }
+  #typing() {
+    if (Date.now() - this.#typedAt < 3e3) return true;
+    let active = this.ownerDocument.activeElement;
+    while (active?.shadowRoot?.activeElement) active = active.shadowRoot.activeElement;
+    if (!editable(active)) return false;
+    const value = "value" in active ? String(active.value) : active.textContent;
+    return (value ?? "").trim() !== "";
+  }
   #sprinkle(id) {
     return this.#sprinkles().find((candidate) => candidate.id === id);
   }
@@ -22290,11 +22720,11 @@ var SliccApp = class extends ThemedElement {
       return cone ? { ...sprinkle, title: `${cone.name} / ${sprinkle.title}` } : sprinkle;
     }).sort((a22, b13) => order.indexOf(a22.agentId) - order.indexOf(b13.agentId));
   }
-  #detach(id, place2, open) {
+  #detach(id, place3, open) {
     const sprinkle = this.#sprinkle(id);
     if (!sprinkle) return;
     this.dips.detach(id);
-    if (open) openSprinkle(this.dock, sprinkle, this.screen, place2);
+    if (open) openSprinkle(this.dock, sprinkle, this.screen, place3);
   }
   #dropped(event2) {
     const { type, data, panel, position } = event2.detail;
@@ -22373,6 +22803,7 @@ var SliccApp = class extends ThemedElement {
     this.model?.settings.update({ color: this.color === "dark" ? "light" : "dark" });
   }
   #keydown = (event2) => {
+    if (editable(event2.composedPath()[0])) this.#typedAt = Date.now();
     if (!event2.altKey || event2.ctrlKey || event2.metaKey) return;
     const digit = event2.code.match(/^Digit([1-9])$/)?.[1] ?? event2.key.match(/^[1-9]$/)?.[0];
     const surface2 = digit ? this.#available()[Number(digit) - 1] : void 0;
@@ -22469,10 +22900,10 @@ var SliccApp = class extends ThemedElement {
       <swc-tooltip for="updates" placement="bottom">${text2}</swc-tooltip>`;
   }
   #tabsIndicator() {
-    const state2 = this.model?.tabs?.state();
-    const light = tabsLight(state2);
-    if (!state2 || !light) return A;
-    return b`<span id="tabs" class="tabs" tabindex="0" role="img" data-tabs data-role=${state2.role} ?data-stalled=${state2.stalled} data-skew=${state2.skew ?? A} aria-label=${`${light.text}. ${light.tooltip}`}>
+    const state3 = this.model?.tabs?.state();
+    const light = tabsLight(state3);
+    if (!state3 || !light) return A;
+    return b`<span id="tabs" class="tabs" tabindex="0" role="img" data-tabs data-role=${state3.role} ?data-stalled=${state3.stalled} data-skew=${state3.skew ?? A} aria-label=${`${light.text}. ${light.tooltip}`}>
         <swc-status-light size="s" variant=${light.variant}>${this.screen === "phone" ? A : light.text}</swc-status-light>
       </span>
       <swc-tooltip for="tabs" placement="bottom">${light.tooltip}</swc-tooltip>`;
@@ -22491,9 +22922,9 @@ var SliccApp = class extends ThemedElement {
     const port = this.model?.network;
     if (!port || !this.#offers("network")) return A;
     const status2 = networkStatus(port);
-    const [variant, state2] = networkHealth[status2.health];
+    const [variant, state3] = networkHealth[status2.health];
     const label = networkLabel(status2);
-    const content = this.screen === "phone" ? networkIcon[status2.health] : b`<swc-status-light size="s" variant=${variant}>Network${status2.health === "ok" ? A : b`<span class="state"> ${state2.toLowerCase()}</span>`}</swc-status-light>`;
+    const content = this.screen === "phone" ? networkIcon[status2.health] : b`<swc-status-light size="s" variant=${variant}>Network${status2.health === "ok" ? A : b`<span class="state"> ${state3.toLowerCase()}</span>`}</swc-status-light>`;
     return b`<swc-action-button id="network" quiet size="s" data-network data-health=${status2.health} accessible-label=${label} @click=${() => this.show("network")}>${content}</swc-action-button>
       <swc-tooltip for="network" placement="bottom">${status2.detail ?? label}${status2.tailnet?.state === "running" ? " Tailscale is connected." : ""}</swc-tooltip>`;
   }
@@ -22555,6 +22986,7 @@ var SliccApp = class extends ThemedElement {
         <main>
           ${rails.left}
           <slicc-dock empty-text="All panels are closed. Open one from a rail or View." @layout-change=${this.#save}
+            @panel-close=${(event2) => this.panels.closed(event2.detail.id)}
             @active-panel-change=${this.#activated}
             @external-drop=${this.#dropped}
             @detach-sprinkle=${(event2) => this.#detach(event2.detail.id, null, true)}
@@ -22579,8 +23011,8 @@ function countdown(ms) {
 }
 function asking(approval) {
   const { kind, name, where: where2 } = approval.requester;
-  const place2 = where2 ? ` in ${where2}` : "";
-  return kind === "user" ? `You ran this with sudo${place2} (as ${name})` : `${name} wants to run this with sudo${place2}`;
+  const place3 = where2 ? ` in ${where2}` : "";
+  return kind === "user" ? `You ran this with sudo${place3} (as ${name})` : `${name} wants to run this with sudo${place3}`;
 }
 function sudo(approval) {
   const as = approval.target && approval.target !== "root" ? `-u ${approval.target} ` : "";
@@ -23132,7 +23564,7 @@ function host3(url) {
     return url;
   }
 }
-function place(url) {
+function place2(url) {
   try {
     const { host: host4, pathname } = new URL(url);
     return host4 ? `${host4}${pathname === "/" ? "" : pathname}` : url;
@@ -23159,9 +23591,9 @@ function typed(action) {
   const count = action.length === void 0 ? "" : ` ${action.length} ${action.length === 1 ? "character" : "characters"}`;
   return `Typed${count}${action.target ? ` into ${action.target}` : ""}`;
 }
-var verbs = {
-  open: (action) => `Opened ${place(action.value ?? "")}`.trim(),
-  goto: (action) => `Went to ${place(action.value ?? "")}`.trim(),
+var verbs2 = {
+  open: (action) => `Opened ${place2(action.value ?? "")}`.trim(),
+  goto: (action) => `Went to ${place2(action.value ?? "")}`.trim(),
   back: () => "Went back",
   reload: () => "Reloaded",
   close: () => "Closed tab",
@@ -23177,7 +23609,7 @@ var verbs = {
   request: (action) => called(action.value)
 };
 function describe(action) {
-  return verbs[action.kind](action);
+  return verbs2[action.kind](action);
 }
 var icons = {
   open: b`<swc-icon-open-in size="s"></swc-icon-open-in>`,
@@ -23908,7 +24340,7 @@ var SliccBrowser = class extends ModelElement {
           ${wide ? A : this.#picker(tabs, tab)}
         </div>
         <div class="address">
-          <span class="url" title=${tab.url}>${narrow ? place(tab.url) : tab.url}</span>
+          <span class="url" title=${tab.url}>${narrow ? place2(tab.url) : tab.url}</span>
           <swc-action-button size="s" quiet data-action="copy-url" accessible-label=${copy === "Copy" ? "Copy URL" : copy} @click=${() => this.#copy(tab.url)}><swc-icon-copy slot="icon"></swc-icon-copy>${narrow ? A : copy}</swc-action-button>
           <swc-action-button size="s" quiet data-action="open-tab" accessible-label="Show in the browser" @click=${() => this.model?.browser.activate(tab.id)}><swc-icon-open-in slot="icon"></swc-icon-open-in>${narrow ? A : "Open"}</swc-action-button>
         </div>
@@ -24734,7 +25166,7 @@ var SliccChat = class extends ThemedElement {
     model: null,
     readOnly: false,
     answer: (questionId, answer) => this.model?.agent.answer(this.#id(), questionId, answer),
-    resolve: (messageId, state2) => this.model?.agent.resolveLick(this.#id(), messageId, state2),
+    resolve: (messageId, state3) => this.model?.agent.resolveLick(this.#id(), messageId, state3),
     action: (action, messageId) => this.#action(action, messageId),
     dropping: (messageId) => failedTurns(this.model.agent.messages(this.#id()), messageId).length,
     open: (path) => this.dispatchEvent(
@@ -24823,6 +25255,14 @@ var SliccChat = class extends ThemedElement {
   #id() {
     return this.agent || (this.model?.agent.active() ?? "");
   }
+  get busyReason() {
+    const open = (this.model?.agent.messages(this.#id()) ?? []).some(
+      (message) => ("parts" in message ? message.parts : []).some(
+        (part2) => part2.type === "question" && part2.question.state === "open"
+      )
+    );
+    return open ? "a question waits for an answer" : null;
+  }
   #agent() {
     const id = this.#id();
     return this.model?.agent.list().find((agent) => agent.id === id);
@@ -25874,9 +26314,9 @@ var commands2 = [
   }
 ];
 function readFile(file) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const reader = new FileReader();
-    reader.onload = () => resolve(String(reader.result));
+    reader.onload = () => resolve2(String(reader.result));
     reader.onerror = () => reject(reader.error);
     if (file.type.startsWith("image/")) reader.readAsDataURL(file);
     else reader.readAsText(file);
@@ -26165,8 +26605,8 @@ var SliccComposer = class extends ModelElement {
     ];
   }
   #held() {
-    const state2 = this.model?.follow?.state();
-    return state2?.link === "reconnecting" ? state2.owner : null;
+    const state3 = this.model?.follow?.state();
+    return state3?.link === "reconnecting" ? state3.owner : null;
   }
   #switch(id) {
     if (this.#agent)
@@ -27699,6 +28139,11 @@ var SliccSettings = class extends ModelElement {
     this.#cancelled.add(account.id);
     this.model?.settings.cancel?.(account.id);
   }
+  get busyReason() {
+    const accounts = this.model?.settings.accounts() ?? [];
+    if (accounts.some((account) => this.#signingIn(account))) return "signing in";
+    return this.entering === null ? null : "a key is being entered";
+  }
   #signingIn(account) {
     return account.status === "signing-in" || account.auth !== "api-key" && account.status !== "connected" && this.pending.has(account.id);
   }
@@ -27942,9 +28387,9 @@ function literal(value) {
     return "null";
   }
 }
-function store(state2) {
+function store(state3) {
   return `(() => {
-  let state = ${literal(state2)};
+  let state = ${literal(state3)};
   const tag = Math.random().toString(36).slice(2);
   const pending = new Map();
   let next = 0;
@@ -27982,11 +28427,11 @@ function store(state2) {
   });
 })();`;
 }
-function frameDocument(source, color, name, state2) {
+function frameDocument(source, color, name, state3) {
   const scheme = `<style>${sprinkleTokens}${sprinkle_theme_default}</style>`;
   const light = `<script>document.documentElement.classList.toggle('theme-light', ${color === "light"});<\/script>`;
   const script = `<script data-name="${name.replace(/"/g, "&quot;")}">${bridge}<\/script>`;
-  const injection = light + scheme + script + (state2 ? `<script>${store(state2.value)}<\/script>` : "");
+  const injection = light + scheme + script + (state3 ? `<script>${store(state3.value)}<\/script>` : "");
   const head2 = source.match(/<head\b[^>]*>/i);
   if (!head2 || head2.index === void 0) return injection + source;
   const at = head2.index + head2[0].length;
@@ -28197,12 +28642,12 @@ var SliccSprinkle = class extends ThemedElement {
     return this.model?.sprinkles.list().find((candidate) => candidate.id === this.sprinkle);
   }
   #frame = { key: "", doc: "" };
-  #document(data, state2) {
-    const key2 = `${!!state2}
+  #document(data, state3) {
+    const key2 = `${!!state3}
 ${data.name}
 ${data.html}`;
     if (this.#frame.key !== key2)
-      this.#frame = { key: key2, doc: frameDocument(data.html, this.color, data.name, state2) };
+      this.#frame = { key: key2, doc: frameDocument(data.html, this.color, data.name, state3) };
     return this.#frame.doc;
   }
   updated(changed) {
@@ -28226,11 +28671,11 @@ ${data.html}`;
     }
     const bridged = !!this.model?.sprinkles.call;
     if (bridged && !this.#held.ready) return b``;
-    const state2 = bridged ? this.#held : void 0;
+    const state3 = bridged ? this.#held : void 0;
     const style = `color-scheme:${this.color};${this.inline ? `height:${this.height}px;` : ""}`;
     const frame = b`${i17(
       this.#mounts,
-      b`<iframe title=${data.title} sandbox="allow-scripts" style=${style} .srcdoc=${this.#document(data, state2)}></iframe>`
+      b`<iframe title=${data.title} sandbox="allow-scripts" style=${style} .srcdoc=${this.#document(data, state3)}></iframe>`
     )}`;
     if (!this.inline) return frame;
     return b`<div class="handle" draggable="true" title="Drag into the dock or a rail to open as a panel" @dragstart=${this.#drag}>
@@ -34138,8 +34583,8 @@ async function createShikiPrimitiveAsync(options) {
   });
 }
 var _grammarStateMap = /* @__PURE__ */ new WeakMap();
-function setLastGrammarStateToMap(keys, state2) {
-  _grammarStateMap.set(keys, state2);
+function setLastGrammarStateToMap(keys, state3) {
+  _grammarStateMap.set(keys, state3);
 }
 function getLastGrammarStateFromMap(keys) {
   return _grammarStateMap.get(keys);
@@ -34208,9 +34653,9 @@ function getScopes(stack) {
   pushScope(stack);
   return scopes;
 }
-function getGrammarStack(state2, theme3) {
-  if (!(state2 instanceof GrammarState)) throw new ShikiError2("Invalid grammar state");
-  return state2.getInternalStack(theme3);
+function getGrammarStack(state3, theme3) {
+  if (!(state3 instanceof GrammarState)) throw new ShikiError2("Invalid grammar state");
+  return state3.getInternalStack(theme3);
 }
 var RE_COMMA = /,/;
 var RE_SPACE = / /;
@@ -34583,8 +35028,8 @@ var DefinedInfo = class extends Info {
     mark(this, "space", space);
     if (typeof mask === "number") {
       while (++index < checks.length) {
-        const check2 = checks[index];
-        mark(this, checks[index], (mask & types_exports[check2]) === types_exports[check2]);
+        const check3 = checks[index];
+        mark(this, checks[index], (mask & types_exports[check3]) === types_exports[check3]);
       }
     }
   }
@@ -36213,17 +36658,17 @@ function stringifyEntities(value, options) {
 var htmlCommentRegex = /^>|^->|<!--|-->|--!>|<!-$/g;
 var bogusCommentEntitySubset = [">"];
 var commentEntitySubset = ["<", ">"];
-function comment(node, _1, _22, state2) {
-  return state2.settings.bogusComments ? "<?" + stringifyEntities(
+function comment(node, _1, _22, state3) {
+  return state3.settings.bogusComments ? "<?" + stringifyEntities(
     node.value,
-    Object.assign({}, state2.settings.characterReferences, {
+    Object.assign({}, state3.settings.characterReferences, {
       subset: bogusCommentEntitySubset
     })
   ) + ">" : "<!--" + node.value.replace(htmlCommentRegex, encode2) + "-->";
   function encode2($0) {
     return stringifyEntities(
       $0,
-      Object.assign({}, state2.settings.characterReferences, {
+      Object.assign({}, state3.settings.characterReferences, {
         subset: commentEntitySubset
       })
     );
@@ -36231,8 +36676,8 @@ function comment(node, _1, _22, state2) {
 }
 
 // node_modules/hast-util-to-html/lib/handle/doctype.js
-function doctype(_1, _22, _32, state2) {
-  return "<!" + (state2.settings.upperDoctype ? "DOCTYPE" : "doctype") + (state2.settings.tightDoctype ? "" : " ") + "html>";
+function doctype(_1, _22, _32, state3) {
+  return "<!" + (state3.settings.upperDoctype ? "DOCTYPE" : "doctype") + (state3.settings.tightDoctype ? "" : " ") + "html>";
 }
 
 // node_modules/ccount/index.js
@@ -36457,26 +36902,26 @@ var constants = {
     ['\0"&'.split(""), "\0\"&'`".split("")]
   ]
 };
-function element(node, index, parent, state2) {
-  const schema = state2.schema;
-  const omit = schema.space === "svg" ? false : state2.settings.omitOptionalTags;
-  let selfClosing = schema.space === "svg" ? state2.settings.closeEmptyElements : state2.settings.voids.includes(node.tagName.toLowerCase());
+function element(node, index, parent, state3) {
+  const schema = state3.schema;
+  const omit = schema.space === "svg" ? false : state3.settings.omitOptionalTags;
+  let selfClosing = schema.space === "svg" ? state3.settings.closeEmptyElements : state3.settings.voids.includes(node.tagName.toLowerCase());
   const parts2 = [];
   let last;
   if (schema.space === "html" && node.tagName === "svg") {
-    state2.schema = svg3;
+    state3.schema = svg3;
   }
-  const attributes = serializeAttributes(state2, node.properties);
-  const content = state2.all(
+  const attributes = serializeAttributes(state3, node.properties);
+  const content = state3.all(
     schema.space === "html" && node.tagName === "template" ? node.content : node
   );
-  state2.schema = schema;
+  state3.schema = schema;
   if (content) selfClosing = false;
   if (attributes || !omit || !opening(node, index, parent)) {
     parts2.push("<", node.tagName, attributes ? " " + attributes : "");
-    if (selfClosing && (schema.space === "svg" || state2.settings.closeSelfClosing)) {
+    if (selfClosing && (schema.space === "svg" || state3.settings.closeSelfClosing)) {
       last = attributes.charAt(attributes.length - 1);
-      if (!state2.settings.tightSelfClosing || last === "/" || last && last !== '"' && last !== "'") {
+      if (!state3.settings.tightSelfClosing || last === "/" || last && last !== '"' && last !== "'") {
         parts2.push(" ");
       }
       parts2.push("/");
@@ -36489,31 +36934,31 @@ function element(node, index, parent, state2) {
   }
   return parts2.join("");
 }
-function serializeAttributes(state2, properties) {
+function serializeAttributes(state3, properties) {
   const values = [];
   let index = -1;
   let key2;
   if (properties) {
     for (key2 in properties) {
       if (properties[key2] !== null && properties[key2] !== void 0) {
-        const value = serializeAttribute(state2, key2, properties[key2]);
+        const value = serializeAttribute(state3, key2, properties[key2]);
         if (value) values.push(value);
       }
     }
   }
   while (++index < values.length) {
-    const last = state2.settings.tightAttributes ? values[index].charAt(values[index].length - 1) : void 0;
+    const last = state3.settings.tightAttributes ? values[index].charAt(values[index].length - 1) : void 0;
     if (index !== values.length - 1 && last !== '"' && last !== "'") {
       values[index] += " ";
     }
   }
   return values.join("");
 }
-function serializeAttribute(state2, key2, value) {
-  const info = find(state2.schema, key2);
-  const x7 = state2.settings.allowParseErrors && state2.schema.space === "html" ? 0 : 1;
-  const y10 = state2.settings.allowDangerousCharacters ? 0 : 1;
-  let quote = state2.quote;
+function serializeAttribute(state3, key2, value) {
+  const info = find(state3.schema, key2);
+  const x7 = state3.settings.allowParseErrors && state3.schema.space === "html" ? 0 : 1;
+  const y10 = state3.settings.allowDangerousCharacters ? 0 : 1;
+  let quote = state3.quote;
   let result;
   if (info.overloadedBoolean && (value === info.attribute || value === "")) {
     value = true;
@@ -36525,32 +36970,32 @@ function serializeAttribute(state2, key2, value) {
   }
   const name = stringifyEntities(
     info.attribute,
-    Object.assign({}, state2.settings.characterReferences, {
+    Object.assign({}, state3.settings.characterReferences, {
       // Always encode without parse errors in non-HTML.
       subset: constants.name[x7][y10]
     })
   );
   if (value === true) return name;
   value = Array.isArray(value) ? (info.commaSeparated ? stringify : stringify2)(value, {
-    padLeft: !state2.settings.tightCommaSeparatedLists
+    padLeft: !state3.settings.tightCommaSeparatedLists
   }) : String(value);
-  if (state2.settings.collapseEmptyAttributes && !value) return name;
-  if (state2.settings.preferUnquoted) {
+  if (state3.settings.collapseEmptyAttributes && !value) return name;
+  if (state3.settings.preferUnquoted) {
     result = stringifyEntities(
       value,
-      Object.assign({}, state2.settings.characterReferences, {
+      Object.assign({}, state3.settings.characterReferences, {
         attribute: true,
         subset: constants.unquoted[x7][y10]
       })
     );
   }
   if (result !== value) {
-    if (state2.settings.quoteSmart && ccount(value, quote) > ccount(value, state2.alternative)) {
-      quote = state2.alternative;
+    if (state3.settings.quoteSmart && ccount(value, quote) > ccount(value, state3.alternative)) {
+      quote = state3.alternative;
     }
     result = quote + stringifyEntities(
       value,
-      Object.assign({}, state2.settings.characterReferences, {
+      Object.assign({}, state3.settings.characterReferences, {
         // Always encode without parse errors in non-HTML.
         subset: (quote === "'" ? constants.single : constants.double)[x7][y10],
         attribute: true
@@ -36562,35 +37007,35 @@ function serializeAttribute(state2, key2, value) {
 
 // node_modules/hast-util-to-html/lib/handle/text.js
 var textEntitySubset = ["<", "&"];
-function text(node, _9, parent, state2) {
+function text(node, _9, parent, state3) {
   return parent && parent.type === "element" && (parent.tagName === "script" || parent.tagName === "style") ? node.value : stringifyEntities(
     node.value,
-    Object.assign({}, state2.settings.characterReferences, {
+    Object.assign({}, state3.settings.characterReferences, {
       subset: textEntitySubset
     })
   );
 }
 
 // node_modules/hast-util-to-html/lib/handle/raw.js
-function raw(node, index, parent, state2) {
-  return state2.settings.allowDangerousHtml ? node.value : text(node, index, parent, state2);
+function raw(node, index, parent, state3) {
+  return state3.settings.allowDangerousHtml ? node.value : text(node, index, parent, state3);
 }
 
 // node_modules/hast-util-to-html/lib/handle/root.js
-function root(node, _1, _22, state2) {
-  return state2.all(node);
+function root(node, _1, _22, state3) {
+  return state3.all(node);
 }
 
 // node_modules/hast-util-to-html/lib/handle/index.js
 var handle = zwitch("type", {
   invalid,
-  unknown,
+  unknown: unknown2,
   handlers: { comment, doctype, element, raw, root, text }
 });
 function invalid(node) {
   throw new Error("Expected node, not `" + node + "`");
 }
-function unknown(node_) {
+function unknown2(node_) {
   const node = (
     /** @type {Nodes} */
     node_
@@ -36609,7 +37054,7 @@ function toHtml(tree, options) {
   if (quote !== '"' && quote !== "'") {
     throw new Error("Invalid quote `" + quote + "`, expected `'` or `\"`");
   }
-  const state2 = {
+  const state3 = {
     one,
     all,
     settings: {
@@ -36635,7 +37080,7 @@ function toHtml(tree, options) {
     quote,
     alternative
   };
-  return state2.one(
+  return state3.one(
     Array.isArray(tree) ? { type: "root", children: tree } : tree,
     void 0,
     void 0
@@ -39536,9 +39981,9 @@ var FirstPassVisitor = {
       }
     }
   },
-  Assertion({ node, parent, key: key2, container, root: root2, remove: remove2, replaceWith }, state2) {
+  Assertion({ node, parent, key: key2, container, root: root2, remove: remove2, replaceWith }, state3) {
     const { kind, negate } = node;
-    const { asciiWordBoundaries, avoidSubclass, supportedGNodes, wordIsAscii } = state2;
+    const { asciiWordBoundaries, avoidSubclass, supportedGNodes, wordIsAscii } = state3;
     if (kind === "text_segment_boundary") {
       throw new Error(`Unsupported text segment boundary "\\${negate ? "Y" : "y"}"`);
     } else if (kind === "line_end") {
@@ -39561,7 +40006,7 @@ var FirstPassVisitor = {
           throw new Error(r36`Uses "\G" in a way that requires a subclass`);
         } else {
           replaceWith(setParent(F3("string_start"), parent));
-          state2.strategy = "clip_search";
+          state3.strategy = "clip_search";
         }
       }
     } else if (kind === "string_end" || kind === "string_start") {
@@ -39754,10 +40199,10 @@ var FirstPassVisitor = {
     disable && !Object.keys(disable).length && delete node.flags.disable;
     !node.flags.enable && !node.flags.disable && delete node.flags;
   },
-  LookaroundAssertion({ node }, state2) {
+  LookaroundAssertion({ node }, state3) {
     const { kind } = node;
     if (kind === "lookbehind") {
-      state2.passedLookbehind = true;
+      state3.passedLookbehind = true;
     }
   },
   NamedCallout({ node, parent, replaceWith }) {
@@ -39884,17 +40329,17 @@ var SecondPassVisitor = {
     }
   },
   Group: {
-    enter({ node }, state2) {
-      state2.prevFlags = state2.currentFlags;
+    enter({ node }, state3) {
+      state3.prevFlags = state3.currentFlags;
       if (node.flags) {
-        state2.currentFlags = getNewCurrentFlags(state2.currentFlags, node.flags);
+        state3.currentFlags = getNewCurrentFlags(state3.currentFlags, node.flags);
       }
     },
-    exit(_9, state2) {
-      state2.currentFlags = state2.prevFlags;
+    exit(_9, state3) {
+      state3.currentFlags = state3.prevFlags;
     }
   },
-  Subroutine({ node, parent, replaceWith }, state2) {
+  Subroutine({ node, parent, replaceWith }, state3) {
     const { isRecursive, ref } = node;
     if (isRecursive) {
       let reffed = parent;
@@ -39903,14 +40348,14 @@ var SecondPassVisitor = {
           break;
         }
       }
-      state2.reffedNodesByReferencer.set(node, reffed);
+      state3.reffedNodesByReferencer.set(node, reffed);
       return;
     }
-    const reffedGroupNode = state2.subroutineRefMap.get(ref);
+    const reffedGroupNode = state3.subroutineRefMap.get(ref);
     const isGlobalRecursion = ref === 0;
     const expandedSubroutine = isGlobalRecursion ? createRecursion(0) : (
       // The reffed group might itself contain subroutines, which are expanded during sub-traversal
-      cloneCapturingGroup(reffedGroupNode, state2.groupOriginByCopy, null)
+      cloneCapturingGroup(reffedGroupNode, state3.groupOriginByCopy, null)
     );
     let replacement = expandedSubroutine;
     if (!isGlobalRecursion) {
@@ -39918,8 +40363,8 @@ var SecondPassVisitor = {
         reffedGroupNode,
         (p17) => p17.type === "Group" && !!p17.flags
       ));
-      const reffedGroupFlags = reffedGroupFlagMods ? getNewCurrentFlags(state2.globalFlags, reffedGroupFlagMods) : state2.globalFlags;
-      if (!areFlagsEqual(reffedGroupFlags, state2.currentFlags)) {
+      const reffedGroupFlags = reffedGroupFlagMods ? getNewCurrentFlags(state3.globalFlags, reffedGroupFlagMods) : state3.globalFlags;
+      if (!areFlagsEqual(reffedGroupFlags, state3.currentFlags)) {
         replacement = A6({
           flags: getFlagModsFromFlags(reffedGroupFlags)
         });
@@ -39930,12 +40375,12 @@ var SecondPassVisitor = {
   }
 };
 var ThirdPassVisitor = {
-  Backreference({ node, parent, replaceWith }, state2) {
+  Backreference({ node, parent, replaceWith }, state3) {
     if (node.orphan) {
-      state2.highestOrphanBackref = Math.max(state2.highestOrphanBackref, node.ref);
+      state3.highestOrphanBackref = Math.max(state3.highestOrphanBackref, node.ref);
       return;
     }
-    const reffedNodes = state2.reffedNodesByReferencer.get(node);
+    const reffedNodes = state3.reffedNodesByReferencer.get(node);
     const participants = reffedNodes.filter((reffed) => canParticipateWithNode(reffed, node));
     if (!participants.length) {
       replaceWith(setParentDeep(K2({ negate: true }), parent));
@@ -39951,28 +40396,28 @@ var ThirdPassVisitor = {
       node.ref = participants[0].number;
     }
   },
-  CapturingGroup({ node }, state2) {
-    node.number = ++state2.numCapturesToLeft;
+  CapturingGroup({ node }, state3) {
+    node.number = ++state3.numCapturesToLeft;
     if (node.name) {
-      if (state2.groupsByName.get(node.name).get(node).hasDuplicateNameToRemove) {
+      if (state3.groupsByName.get(node.name).get(node).hasDuplicateNameToRemove) {
         delete node.name;
       }
     }
   },
   Regex: {
-    exit({ node }, state2) {
-      const numCapsNeeded = Math.max(state2.highestOrphanBackref - state2.numCapturesToLeft, 0);
+    exit({ node }, state3) {
+      const numCapsNeeded = Math.max(state3.highestOrphanBackref - state3.numCapturesToLeft, 0);
       for (let i25 = 0; i25 < numCapsNeeded; i25++) {
         const emptyCapture = P3();
         node.body.at(-1).body.push(emptyCapture);
       }
     }
   },
-  Subroutine({ node }, state2) {
+  Subroutine({ node }, state3) {
     if (!node.isRecursive || node.ref === 0) {
       return;
     }
-    node.ref = state2.reffedNodesByReferencer.get(node).number;
+    node.ref = state3.reffedNodesByReferencer.get(node).number;
   }
 };
 function addParentProperties(root2) {
@@ -40214,7 +40659,7 @@ function generate(ast, options) {
     ignoreCase: !!((ast.flags.ignoreCase || hasCaseInsensitiveNode) && !hasCaseSensitiveNode)
   };
   let lastNode = ast;
-  const state2 = {
+  const state3 = {
     accuracy: opts.accuracy,
     appliedGlobalFlags,
     captureMap: /* @__PURE__ */ new Map(),
@@ -40232,10 +40677,10 @@ function generate(ast, options) {
     verbose: opts.verbose
   };
   function gen(node) {
-    state2.lastNode = lastNode;
+    state3.lastNode = lastNode;
     lastNode = node;
     const fn = throwIfNullish(generator[node.type], `Unexpected node type "${node.type}"`);
-    return fn(node, state2, gen);
+    return fn(node, state3, gen);
   }
   const result = {
     pattern: ast.body.map(gen).join("|"),
@@ -40250,7 +40695,7 @@ function generate(ast, options) {
   }
   result._captureTransfers = /* @__PURE__ */ new Map();
   result._hiddenCaptures = [];
-  state2.captureMap.forEach((value, key2) => {
+  state3.captureMap.forEach((value, key2) => {
     if (value.hidden) {
       result._hiddenCaptures.push(key2);
     }
@@ -40262,37 +40707,37 @@ function generate(ast, options) {
 }
 var FlagModifierVisitor = {
   "*": {
-    enter({ node }, state2) {
+    enter({ node }, state3) {
       if (isAnyGroup(node)) {
-        const currentModI = state2.getCurrentModI();
-        state2.pushModI(
+        const currentModI = state3.getCurrentModI();
+        state3.pushModI(
           node.flags ? getNewCurrentFlags({ ignoreCase: currentModI }, node.flags).ignoreCase : currentModI
         );
       }
     },
-    exit({ node }, state2) {
+    exit({ node }, state3) {
       if (isAnyGroup(node)) {
-        state2.popModI();
+        state3.popModI();
       }
     }
   },
-  Backreference(_9, state2) {
-    state2.setHasCasedChar();
+  Backreference(_9, state3) {
+    state3.setHasCasedChar();
   },
-  Character({ node }, state2) {
+  Character({ node }, state3) {
     if (charHasCase(cp(node.value))) {
-      state2.setHasCasedChar();
+      state3.setHasCasedChar();
     }
   },
-  CharacterClassRange({ node, skip }, state2) {
+  CharacterClassRange({ node, skip }, state3) {
     skip();
     if (getCasesOutsideCharClassRange(node, { firstOnly: true }).length) {
-      state2.setHasCasedChar();
+      state3.setHasCasedChar();
     }
   },
-  CharacterSet({ node }, state2) {
+  CharacterSet({ node }, state3) {
     if (node.kind === "property" && UnicodePropertiesWithSpecificCase.has(node.value)) {
-      state2.setHasCasedChar();
+      state3.setHasCasedChar();
     }
   }
 };
@@ -40321,11 +40766,11 @@ var generator = {
   /**
   @param {BackreferenceNode} node
   */
-  Backreference({ ref }, state2) {
+  Backreference({ ref }, state3) {
     if (typeof ref !== "number") {
       throw new Error("Unexpected named backref in transformed AST");
     }
-    if (!state2.useFlagMods && state2.accuracy === "strict" && state2.currentFlags.ignoreCase && !state2.captureMap.get(ref).ignoreCase) {
+    if (!state3.useFlagMods && state3.accuracy === "strict" && state3.currentFlags.ignoreCase && !state3.captureMap.get(ref).ignoreCase) {
       throw new Error("Use of case-insensitive backref to case-sensitive group requires target ES2025 or non-strict accuracy");
     }
     return "\\" + ref;
@@ -40333,55 +40778,55 @@ var generator = {
   /**
   @param {CapturingGroupNode} node
   */
-  CapturingGroup(node, state2, gen) {
+  CapturingGroup(node, state3, gen) {
     const { body: body4, name, number: number2 } = node;
-    const data = { ignoreCase: state2.currentFlags.ignoreCase };
-    const origin = state2.originMap.get(node);
+    const data = { ignoreCase: state3.currentFlags.ignoreCase };
+    const origin = state3.originMap.get(node);
     if (origin) {
       data.hidden = true;
       if (number2 > origin.number) {
         data.transferTo = origin.number;
       }
     }
-    state2.captureMap.set(number2, data);
+    state3.captureMap.set(number2, data);
     return `(${name ? `?<${name}>` : ""}${body4.map(gen).join("|")})`;
   },
   /**
   @param {CharacterNode} node
   */
-  Character({ value }, state2) {
+  Character({ value }, state3) {
     const char = cp(value);
     const escaped = getCharEscape(value, {
-      escDigit: state2.lastNode.type === "Backreference",
-      inCharClass: state2.inCharClass,
-      useFlagV: state2.useFlagV
+      escDigit: state3.lastNode.type === "Backreference",
+      inCharClass: state3.inCharClass,
+      useFlagV: state3.useFlagV
     });
     if (escaped !== char) {
       return escaped;
     }
-    if (state2.useAppliedIgnoreCase && state2.currentFlags.ignoreCase && charHasCase(char)) {
+    if (state3.useAppliedIgnoreCase && state3.currentFlags.ignoreCase && charHasCase(char)) {
       const cases = getIgnoreCaseMatchChars(char);
-      return state2.inCharClass ? cases.join("") : cases.length > 1 ? `[${cases.join("")}]` : cases[0];
+      return state3.inCharClass ? cases.join("") : cases.length > 1 ? `[${cases.join("")}]` : cases[0];
     }
     return char;
   },
   /**
   @param {CharacterClassNode} node
   */
-  CharacterClass(node, state2, gen) {
+  CharacterClass(node, state3, gen) {
     const { kind, negate, parent } = node;
     let { body: body4 } = node;
-    if (kind === "intersection" && !state2.useFlagV) {
+    if (kind === "intersection" && !state3.useFlagV) {
       throw new Error("Use of character class intersection requires min target ES2024");
     }
-    if (envFlags.bugFlagVLiteralHyphenIsRange && state2.useFlagV && body4.some(isLiteralHyphen)) {
+    if (envFlags.bugFlagVLiteralHyphenIsRange && state3.useFlagV && body4.some(isLiteralHyphen)) {
       body4 = [m12(45), ...body4.filter((kid) => !isLiteralHyphen(kid))];
     }
     const genClass = () => `[${negate ? "^" : ""}${body4.map(gen).join(kind === "intersection" ? "&&" : "")}]`;
-    if (!state2.inCharClass) {
+    if (!state3.inCharClass) {
       if (
         // Already established `kind !== 'intersection'` if `!state.useFlagV`; don't check again
-        (!state2.useFlagV || envFlags.bugNestedClassIgnoresNegation) && !negate
+        (!state3.useFlagV || envFlags.bugNestedClassIgnoresNegation) && !negate
       ) {
         const negatedChildClasses = body4.filter(
           (kid) => kid.type === "CharacterClass" && kid.kind === "union" && kid.negate
@@ -40408,21 +40853,21 @@ var generator = {
           return gen(group);
         }
       }
-      state2.inCharClass = true;
+      state3.inCharClass = true;
       const result = genClass();
-      state2.inCharClass = false;
+      state3.inCharClass = false;
       return result;
     }
     const firstEl = body4[0];
     if (
       // Already established that the parent is a char class via `inCharClass`; don't check again
       kind === "union" && !negate && firstEl && // Allows many nested classes to work with `target` ES2018 which doesn't support nesting
-      ((!state2.useFlagV || !state2.verbose) && parent.kind === "union" && !(envFlags.bugFlagVLiteralHyphenIsRange && state2.useFlagV) || !state2.verbose && parent.kind === "intersection" && // JS doesn't allow intersection with union or ranges
+      ((!state3.useFlagV || !state3.verbose) && parent.kind === "union" && !(envFlags.bugFlagVLiteralHyphenIsRange && state3.useFlagV) || !state3.verbose && parent.kind === "intersection" && // JS doesn't allow intersection with union or ranges
       body4.length === 1 && firstEl.type !== "CharacterClassRange")
     ) {
       return body4.map(gen).join("");
     }
-    if (!state2.useFlagV && parent.type === "CharacterClass") {
+    if (!state3.useFlagV && parent.type === "CharacterClass") {
       throw new Error("Uses nested character class in a way that requires min target ES2024");
     }
     return genClass();
@@ -40430,18 +40875,18 @@ var generator = {
   /**
   @param {CharacterClassRangeNode} node
   */
-  CharacterClassRange(node, state2) {
+  CharacterClassRange(node, state3) {
     const min2 = node.min.value;
     const max2 = node.max.value;
     const escOpts = {
       escDigit: false,
       inCharClass: true,
-      useFlagV: state2.useFlagV
+      useFlagV: state3.useFlagV
     };
     const minStr = getCharEscape(min2, escOpts);
     const maxStr = getCharEscape(max2, escOpts);
     const extraChars = /* @__PURE__ */ new Set();
-    if (state2.useAppliedIgnoreCase && state2.currentFlags.ignoreCase) {
+    if (state3.useAppliedIgnoreCase && state3.currentFlags.ignoreCase) {
       const charsOutsideRange = getCasesOutsideCharClassRange(node);
       const ranges = getCodePointRangesFromChars(charsOutsideRange);
       ranges.forEach((value) => {
@@ -40455,9 +40900,9 @@ var generator = {
   /**
   @param {CharacterSetNode} node
   */
-  CharacterSet({ kind, negate, value, key: key2 }, state2) {
+  CharacterSet({ kind, negate, value, key: key2 }, state3) {
     if (kind === "dot") {
-      return state2.currentFlags.dotAll ? state2.appliedGlobalFlags.dotAll || state2.useFlagMods ? "." : "[^]" : (
+      return state3.currentFlags.dotAll ? state3.appliedGlobalFlags.dotAll || state3.useFlagMods ? "." : "[^]" : (
         // Onig's only line break char is line feed, unlike JS
         r36`[^\n]`
       );
@@ -40466,7 +40911,7 @@ var generator = {
       return negate ? r36`\D` : r36`\d`;
     }
     if (kind === "property") {
-      if (state2.useAppliedIgnoreCase && state2.currentFlags.ignoreCase && UnicodePropertiesWithSpecificCase.has(value)) {
+      if (state3.useAppliedIgnoreCase && state3.currentFlags.ignoreCase && UnicodePropertiesWithSpecificCase.has(value)) {
         throw new Error(`Unicode property "${value}" can't be case-insensitive when other chars have specific case`);
       }
       return `${negate ? r36`\P` : r36`\p`}{${key2 ? `${key2}=` : ""}${value}}`;
@@ -40479,28 +40924,28 @@ var generator = {
   /**
   @param {FlagsNode} node
   */
-  Flags(node, state2) {
+  Flags(node, state3) {
     return (
       // The transformer should never turn on the properties for flags d, g, m since Onig doesn't
       // have equivs. Flag m is never used since Onig uses different line break chars than JS
       // (node.hasIndices ? 'd' : '') +
       // (node.global ? 'g' : '') +
       // (node.multiline ? 'm' : '') +
-      (state2.appliedGlobalFlags.ignoreCase ? "i" : "") + (node.dotAll ? "s" : "") + (node.sticky ? "y" : "")
+      (state3.appliedGlobalFlags.ignoreCase ? "i" : "") + (node.dotAll ? "s" : "") + (node.sticky ? "y" : "")
     );
   },
   /**
   @param {GroupNode} node
   */
-  Group({ atomic: atomic2, body: body4, flags, parent }, state2, gen) {
-    const currentFlags = state2.currentFlags;
+  Group({ atomic: atomic2, body: body4, flags, parent }, state3, gen) {
+    const currentFlags = state3.currentFlags;
     if (flags) {
-      state2.currentFlags = getNewCurrentFlags(currentFlags, flags);
+      state3.currentFlags = getNewCurrentFlags(currentFlags, flags);
     }
     const contents = body4.map(gen).join("|");
-    const result = !state2.verbose && body4.length === 1 && // Single alt
-    parent.type !== "Quantifier" && !atomic2 && (!state2.useFlagMods || !flags) ? contents : `(?${getGroupPrefix(atomic2, flags, state2.useFlagMods)}${contents})`;
-    state2.currentFlags = currentFlags;
+    const result = !state3.verbose && body4.length === 1 && // Single alt
+    parent.type !== "Quantifier" && !atomic2 && (!state3.useFlagMods || !flags) ? contents : `(?${getGroupPrefix(atomic2, flags, state3.useFlagMods)}${contents})`;
+    state3.currentFlags = currentFlags;
     return result;
   },
   /**
@@ -40519,11 +40964,11 @@ var generator = {
   /**
   @param {SubroutineNode & {isRecursive: true}} node
   */
-  Subroutine({ isRecursive, ref }, state2) {
+  Subroutine({ isRecursive, ref }, state3) {
     if (!isRecursive) {
       throw new Error("Unexpected non-recursive subroutine in transformed AST");
     }
-    const limit2 = state2.recursionLimit;
+    const limit2 = state3.recursionLimit;
     return ref === 0 ? `(?R=${limit2})` : r36`\g<${ref}&R=${limit2}>`;
   }
 };
@@ -42489,13 +42934,13 @@ var InteractionManager = class {
       }
     };
   }
-  resolveLineRenderRange(state2, split, source) {
-    if (state2.range == null) return;
-    const rowRange = this.getIndexesFromSelection(state2.range, split);
+  resolveLineRenderRange(state3, split, source) {
+    if (state3.range == null) return;
+    const rowRange = this.getIndexesFromSelection(state3.range, split);
     if (rowRange == null) {
       console.error({
         rowRange,
-        range: state2.range
+        range: state3.range
       });
       throw new Error(`InteractionManager.renderSelection: No valid ${source} rowRange`);
     }
@@ -43759,14 +44204,14 @@ function isDefaultRenderRange(renderRange) {
 }
 
 // node_modules/@pierre/diffs/dist/utils/processLine.js
-function processLine(node, line, state2) {
-  const lineInfo = typeof state2.lineInfo === "function" ? state2.lineInfo(line) : state2.lineInfo[line - 1];
+function processLine(node, line, state3) {
+  const lineInfo = typeof state3.lineInfo === "function" ? state3.lineInfo(line) : state3.lineInfo[line - 1];
   if (lineInfo == null) {
     const errorMessage = `processLine: line ${line}, contains no state.lineInfo`;
     console.error(errorMessage, {
       node,
       line,
-      state: state2
+      state: state3
     });
     throw new Error(errorMessage);
   }
@@ -43918,7 +44363,7 @@ function cyrb53(str, seed = 0) {
 
 // node_modules/@pierre/diffs/dist/utils/createTransformerWithState.js
 function createTransformerWithState(useTokenTransformer = false, useCSSClasses = false) {
-  const state2 = { lineInfo: [] };
+  const state3 = { lineInfo: [] };
   const transformers = [{
     line(node) {
       delete node.properties.class;
@@ -43932,7 +44377,7 @@ function createTransformerWithState(useTokenTransformer = false, useCSSClasses =
         for (const node of code2.children) {
           if (node.type !== "element") continue;
           if (useTokenTransformer) wrapTokenFragments(node);
-          children.push(processLine(node, index, state2));
+          children.push(processLine(node, index, state3));
           index++;
         }
         code2.children = children;
@@ -43974,7 +44419,7 @@ function createTransformerWithState(useTokenTransformer = false, useCSSClasses =
     return node;
   } });
   return {
-    state: state2,
+    state: state3,
     transformers,
     toClass
   };
@@ -44227,14 +44672,14 @@ function renderFileWithHighlighter(file, highlighter2, { theme: theme3, tokenize
     totalLines = Infinity;
   }
   const isWindowedHighlight = startingLine > 0 || totalLines < Infinity;
-  const { state: state2, transformers } = createTransformerWithState(useTokenTransformer);
+  const { state: state3, transformers } = createTransformerWithState(useTokenTransformer);
   const lang = forcePlainText ? "text" : file.lang ?? getFiletypeFromFileName(file.name);
   const baseThemeType = typeof theme3 === "string" ? highlighter2.getTheme(theme3).type : void 0;
   const themeStyles = getHighlighterThemeStyles({
     theme: theme3,
     highlighter: highlighter2
   });
-  state2.lineInfo = (shikiLineNumber) => ({
+  state3.lineInfo = (shikiLineNumber) => ({
     type: "context",
     lineIndex: shikiLineNumber - 1 + startingLine,
     lineNumber: shikiLineNumber + startingLine
@@ -47233,7 +47678,7 @@ var Diff = class {
   }
   diffWithOptionsObj(oldTokens, newTokens, options, callback) {
     var _a;
-    const done = (value) => {
+    const done2 = (value) => {
       value = this.postProcess(value, options);
       if (callback) {
         setTimeout(function() {
@@ -47255,7 +47700,7 @@ var Diff = class {
     const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
     let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
     if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+      return done2(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
     }
     let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
     const execEditLength = () => {
@@ -47282,7 +47727,7 @@ var Diff = class {
         }
         newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
         if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+          return done2(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
         } else {
           bestPath[diagonalPath] = basePath;
           if (basePath.oldPos + 1 >= oldLen) {
@@ -48409,7 +48854,7 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
     expandedHunks,
     collapsedContextThreshold
   });
-  const state2 = {
+  const state3 = {
     viewportStart: startingLine,
     viewportEnd: startingLine + totalLines,
     isWindowedHighlight: startingLine > 0 || totalLines < Infinity,
@@ -48417,44 +48862,44 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
     unifiedCount: iterationStart.unifiedCount,
     finalHunkIndex: diff.hunks.length - 1,
     shouldBreak() {
-      if (!state2.isWindowedHighlight) return false;
-      const breakUnified = state2.unifiedCount >= startingLine + totalLines;
-      const breakSplit = state2.splitCount >= startingLine + totalLines;
+      if (!state3.isWindowedHighlight) return false;
+      const breakUnified = state3.unifiedCount >= startingLine + totalLines;
+      const breakSplit = state3.splitCount >= startingLine + totalLines;
       if (diffStyle === "unified") return breakUnified;
       else if (diffStyle === "split") return breakSplit;
       else return breakUnified && breakSplit;
     },
     shouldSkip(unifiedCount, splitCount) {
-      if (!state2.isWindowedHighlight) return false;
-      const skipUnified = unifiedCount > 0 && state2.unifiedCount + unifiedCount <= startingLine;
-      const skipSplit = splitCount > 0 && state2.splitCount + splitCount <= startingLine;
+      if (!state3.isWindowedHighlight) return false;
+      const skipUnified = unifiedCount > 0 && state3.unifiedCount + unifiedCount <= startingLine;
+      const skipSplit = splitCount > 0 && state3.splitCount + splitCount <= startingLine;
       if (diffStyle === "unified") return skipUnified;
       else if (diffStyle === "split") return skipSplit;
       else return skipUnified && skipSplit;
     },
     incrementCounts(unifiedValue, splitValue) {
-      if (diffStyle === "unified" || diffStyle === "both") state2.unifiedCount += unifiedValue;
-      if (diffStyle === "split" || diffStyle === "both") state2.splitCount += splitValue;
+      if (diffStyle === "unified" || diffStyle === "both") state3.unifiedCount += unifiedValue;
+      if (diffStyle === "split" || diffStyle === "both") state3.splitCount += splitValue;
     },
     isInWindow(unifiedHeight, splitHeight) {
-      if (!state2.isWindowedHighlight) return true;
-      const unifiedInWindow = state2.isInUnifiedWindow(unifiedHeight);
-      const splitInWindow = state2.isInSplitWindow(splitHeight);
+      if (!state3.isWindowedHighlight) return true;
+      const unifiedInWindow = state3.isInUnifiedWindow(unifiedHeight);
+      const splitInWindow = state3.isInSplitWindow(splitHeight);
       if (diffStyle === "unified") return unifiedInWindow;
       else if (diffStyle === "split") return splitInWindow;
       else return unifiedInWindow || splitInWindow;
     },
     isInUnifiedWindow(unifiedHeight) {
-      return !state2.isWindowedHighlight || state2.unifiedCount >= startingLine - unifiedHeight && state2.unifiedCount < startingLine + totalLines;
+      return !state3.isWindowedHighlight || state3.unifiedCount >= startingLine - unifiedHeight && state3.unifiedCount < startingLine + totalLines;
     },
     isInSplitWindow(splitHeight) {
-      return !state2.isWindowedHighlight || state2.splitCount >= startingLine - splitHeight && state2.splitCount < startingLine + totalLines;
+      return !state3.isWindowedHighlight || state3.splitCount >= startingLine - splitHeight && state3.splitCount < startingLine + totalLines;
     },
     emit(props, silent = false) {
       if (!silent) {
-        if (diffStyle === "unified") state2.incrementCounts(1, 0);
-        else if (diffStyle === "split") state2.incrementCounts(0, 1);
-        else state2.incrementCounts(1, 1);
+        if (diffStyle === "unified") state3.incrementCounts(1, 0);
+        else if (diffStyle === "split") state3.incrementCounts(0, 1);
+        else state3.incrementCounts(1, 1);
       }
       return callback(props) ?? false;
     }
@@ -48471,7 +48916,7 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
     };
     const hunk = diff.hunks[hunkIndex];
     if (hunk == null) throw new Error("iterateOverDiff: invalid hunk index");
-    if (state2.shouldBreak()) break;
+    if (state3.shouldBreak()) break;
     const deletionBoundary = getHunkSideStartBoundary(hunk.deletionStart, hunk.deletionCount);
     const additionBoundary = getHunkSideStartBoundary(hunk.additionStart, hunk.additionCount);
     const deletionStartIndex = !diff.isPartial && hunk.deletionCount === 0 ? deletionBoundary : hunk.deletionLineIndex;
@@ -48483,7 +48928,7 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
       hunkIndex,
       collapsedContextThreshold
     });
-    const trailingRegion = hunkIndex === state2.finalHunkIndex ? getTrailingExpandedRegion({
+    const trailingRegion = hunkIndex === state3.finalHunkIndex ? getTrailingExpandedRegion({
       fileDiff: diff,
       hunkIndex,
       expandedHunks,
@@ -48492,15 +48937,15 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
     }) : void 0;
     const expandedLineCount = leadingRegion.fromStart + leadingRegion.fromEnd;
     let consumedCollapsed = leadingRegion.collapsedLines === 0;
-    if (!state2.shouldSkip(expandedLineCount, expandedLineCount)) {
+    if (!state3.shouldSkip(expandedLineCount, expandedLineCount)) {
       let unifiedLineIndex2 = hunk.unifiedLineStart - leadingRegion.rangeSize;
       let splitLineIndex2 = hunk.splitLineStart - leadingRegion.rangeSize;
       let deletionLineIndex2 = deletionStartIndex - leadingRegion.rangeSize;
       let additionLineIndex2 = additionStartIndex - leadingRegion.rangeSize;
       let deletionLineNumber2 = deletionBoundary + 1 - leadingRegion.rangeSize;
       let additionLineNumber2 = additionBoundary + 1 - leadingRegion.rangeSize;
-      if (walkContextLines(state2, leadingRegion.fromStart, diffStyle, (index) => {
-        return state2.emit({
+      if (walkContextLines(state3, leadingRegion.fromStart, diffStyle, (index) => {
+        return state3.emit({
           hunkIndex,
           hunk,
           collapsedBefore: 0,
@@ -48528,8 +48973,8 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
       additionLineIndex2 = additionStartIndex - leadingRegion.fromEnd;
       deletionLineNumber2 = deletionBoundary + 1 - leadingRegion.fromEnd;
       additionLineNumber2 = additionBoundary + 1 - leadingRegion.fromEnd;
-      if (walkContextLines(state2, leadingRegion.fromEnd, diffStyle, (index) => {
-        return state2.emit({
+      if (walkContextLines(state3, leadingRegion.fromEnd, diffStyle, (index) => {
+        return state3.emit({
           hunkIndex,
           hunk,
           collapsedBefore: consumePendingCollapsed(),
@@ -48554,7 +48999,7 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
         consumePendingCollapsed();
       })) break hunkIterator;
     } else {
-      state2.incrementCounts(expandedLineCount, expandedLineCount);
+      state3.incrementCounts(expandedLineCount, expandedLineCount);
       consumePendingCollapsed();
     }
     let unifiedLineIndex = hunk.unifiedLineStart;
@@ -48565,15 +49010,15 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
     let additionLineNumber = additionBoundary + 1;
     const lastContent = hunk.hunkContent.at(-1);
     for (const content of hunk.hunkContent) {
-      if (state2.shouldBreak()) break hunkIterator;
+      if (state3.shouldBreak()) break hunkIterator;
       const isLastContent = content === lastContent;
       if (content.type === "context") {
-        if (!state2.shouldSkip(content.lines, content.lines)) {
-          if (walkContextLines(state2, content.lines, diffStyle, (index) => {
+        if (!state3.shouldSkip(content.lines, content.lines)) {
+          if (walkContextLines(state3, content.lines, diffStyle, (index) => {
             const isLastLine = isLastContent && index === content.lines - 1;
             const unifiedRowIndex = unifiedLineIndex + index;
             const splitRowIndex = splitLineIndex + index;
-            return state2.emit({
+            return state3.emit({
               hunkIndex,
               hunk,
               collapsedBefore: consumePendingCollapsed(),
@@ -48598,7 +49043,7 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
             consumePendingCollapsed();
           })) break hunkIterator;
         } else {
-          state2.incrementCounts(content.lines, content.lines);
+          state3.incrementCounts(content.lines, content.lines);
           consumePendingCollapsed();
         }
         unifiedLineIndex += content.lines;
@@ -48610,12 +49055,12 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
       } else {
         const splitCount = Math.max(content.deletions, content.additions);
         const unifiedCount = content.deletions + content.additions;
-        if (!state2.shouldSkip(unifiedCount, splitCount)) {
-          const iterationRanges = getChangeIterationRanges(state2, content, diffStyle);
+        if (!state3.shouldSkip(unifiedCount, splitCount)) {
+          const iterationRanges = getChangeIterationRanges(state3, content, diffStyle);
           if ((iterationRanges[0]?.[0] ?? 0) > 0) consumePendingCollapsed();
           for (const [rangeStart, rangeEnd] of iterationRanges) for (let index = rangeStart; index < rangeEnd; index++) {
             const collapsedAfter = getTrailingCollapsedAfter(unifiedLineIndex + index, diffStyle === "unified" ? splitLineIndex + (index < content.deletions ? index : index - content.deletions) : splitLineIndex + index);
-            if (state2.emit(getChangeLineData({
+            if (state3.emit(getChangeLineData({
               hunkIndex,
               hunk,
               collapsedBefore: consumePendingCollapsed(),
@@ -48636,7 +49081,7 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
           }
         }
         consumePendingCollapsed();
-        state2.incrementCounts(unifiedCount, splitCount);
+        state3.incrementCounts(unifiedCount, splitCount);
         unifiedLineIndex += unifiedCount;
         splitLineIndex += splitCount;
         deletionLineIndex += content.deletions;
@@ -48648,9 +49093,9 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
     if (trailingRegion != null) {
       const { collapsedLines, fromStart, fromEnd } = trailingRegion;
       const len = fromStart + fromEnd;
-      if (walkContextLines(state2, len, diffStyle, (index) => {
+      if (walkContextLines(state3, len, diffStyle, (index) => {
         const isLastLine = index === len - 1;
-        return state2.emit({
+        return state3.emit({
           hunkIndex: diff.hunks.length,
           hunk: void 0,
           collapsedBefore: 0,
@@ -48671,7 +49116,7 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
             noEOFCR: false
           }
         });
-      }, void 0, () => state2.shouldBreak())) break hunkIterator;
+      }, void 0, () => state3.shouldBreak())) break hunkIterator;
     }
   }
 }
@@ -48755,16 +49200,16 @@ function getHunkPrefixCounts({ diff, expandedHunks, collapsedContextThreshold })
   }
   return prefixCounts;
 }
-function getContextLineIterationBounds(state2, count, diffStyle) {
-  if (!state2.isWindowedHighlight || count <= 0) return [0, count];
+function getContextLineIterationBounds(state3, count, diffStyle) {
+  if (!state3.isWindowedHighlight || count <= 0) return [0, count];
   const ranges = [];
   function pushRange(currentCount) {
-    const start2 = Math.max(0, state2.viewportStart - currentCount);
-    const end2 = Math.min(count, state2.viewportEnd - currentCount);
+    const start2 = Math.max(0, state3.viewportStart - currentCount);
+    const end2 = Math.min(count, state3.viewportEnd - currentCount);
     if (end2 > start2) ranges.push([start2, end2]);
   }
-  if (diffStyle !== "split") pushRange(state2.unifiedCount);
-  if (diffStyle !== "unified") pushRange(state2.splitCount);
+  if (diffStyle !== "split") pushRange(state3.unifiedCount);
+  if (diffStyle !== "unified") pushRange(state3.splitCount);
   if (ranges.length === 0) return [0, 0];
   let start = ranges[0][0];
   let end = ranges[0][1];
@@ -48775,36 +49220,36 @@ function getContextLineIterationBounds(state2, count, diffStyle) {
   }
   return [start, end];
 }
-function walkContextLines(state2, count, diffStyle, callback, onSkippedStart, shouldBreak) {
-  const [startIndex, endIndex] = getContextLineIterationBounds(state2, count, diffStyle);
+function walkContextLines(state3, count, diffStyle, callback, onSkippedStart, shouldBreak) {
+  const [startIndex, endIndex] = getContextLineIterationBounds(state3, count, diffStyle);
   if (startIndex > 0) {
-    state2.incrementCounts(startIndex, startIndex);
+    state3.incrementCounts(startIndex, startIndex);
     onSkippedStart?.();
   }
   let index = startIndex;
   while (index < count) {
     if (shouldBreak?.() === true) return true;
     if (index >= endIndex) {
-      state2.incrementCounts(count - index, count - index);
+      state3.incrementCounts(count - index, count - index);
       break;
     }
-    if (state2.isInWindow(0, 0)) {
+    if (state3.isInWindow(0, 0)) {
       if (callback(index) === true) return true;
-    } else state2.incrementCounts(1, 1);
+    } else state3.incrementCounts(1, 1);
     index++;
   }
   return false;
 }
-function getChangeIterationRanges(state2, content, diffStyle) {
-  if (!state2.isWindowedHighlight) return [[0, diffStyle === "unified" ? content.deletions + content.additions : Math.max(content.deletions, content.additions)]];
+function getChangeIterationRanges(state3, content, diffStyle) {
+  if (!state3.isWindowedHighlight) return [[0, diffStyle === "unified" ? content.deletions + content.additions : Math.max(content.deletions, content.additions)]];
   const useUnified = diffStyle !== "split";
   const useSplit = diffStyle !== "unified";
   const iterationSpace = diffStyle === "unified" ? "unified" : "split";
   const iterationRanges = [];
   function getVisibleRange(start, count) {
-    if (start + count <= state2.viewportStart || start >= state2.viewportEnd) return;
-    const visibleStart = Math.max(0, state2.viewportStart - start);
-    const visibleEnd = Math.min(count, state2.viewportEnd - start);
+    if (start + count <= state3.viewportStart || start >= state3.viewportEnd) return;
+    const visibleStart = Math.max(0, state3.viewportStart - start);
+    const visibleEnd = Math.min(count, state3.viewportEnd - start);
     return visibleEnd > visibleStart ? [visibleStart, visibleEnd] : void 0;
   }
   function mapRangeToIteration(range3, kind) {
@@ -48817,12 +49262,12 @@ function getChangeIterationRanges(state2, content, diffStyle) {
     if (end > start) iterationRanges.push([start, end]);
   }
   if (useUnified) {
-    pushRange(getVisibleRange(state2.unifiedCount, content.deletions), "deletions");
-    pushRange(getVisibleRange(state2.unifiedCount + content.deletions, content.additions), "additions");
+    pushRange(getVisibleRange(state3.unifiedCount, content.deletions), "deletions");
+    pushRange(getVisibleRange(state3.unifiedCount + content.deletions, content.additions), "additions");
   }
   if (useSplit) {
-    pushRange(getVisibleRange(state2.splitCount, content.deletions), "deletions");
-    pushRange(getVisibleRange(state2.splitCount, content.additions), "additions");
+    pushRange(getVisibleRange(state3.splitCount, content.deletions), "deletions");
+    pushRange(getVisibleRange(state3.splitCount, content.additions), "additions");
   }
   if (iterationRanges.length === 0) return iterationRanges;
   iterationRanges.sort((a22, b13) => a22[0] - b13[0]);
@@ -49138,7 +49583,7 @@ function createBucket() {
 function renderTwoFiles({ deletionFile, additionFile, deletionInfo, additionInfo, highlighter: highlighter2, deletionDecorations, additionDecorations, languageOverride, options: { theme: themeOrThemes, ...options } }) {
   const deletionLang = languageOverride ?? getFiletypeFromFileName(deletionFile.name);
   const additionLang = languageOverride ?? getFiletypeFromFileName(additionFile.name);
-  const { state: state2, transformers } = createTransformerWithState(options.useTokenTransformer);
+  const { state: state3, transformers } = createTransformerWithState(options.useTokenTransformer);
   const hastConfig = (() => {
     return typeof themeOrThemes === "string" ? {
       ...options,
@@ -49164,7 +49609,7 @@ function renderTwoFiles({ deletionFile, additionFile, deletionInfo, additionInfo
     deletionLines: (() => {
       if (deletionFile.contents === "") return [];
       hastConfig.lang = deletionLang;
-      state2.lineInfo = deletionInfo;
+      state3.lineInfo = deletionInfo;
       hastConfig.decorations = deletionDecorations;
       return getLineNodes(highlighter2.codeToHast(cleanLastNewline(deletionFile.contents), hastConfig));
     })(),
@@ -49172,7 +49617,7 @@ function renderTwoFiles({ deletionFile, additionFile, deletionInfo, additionInfo
       if (additionFile.contents === "") return [];
       hastConfig.lang = additionLang;
       hastConfig.decorations = additionDecorations;
-      state2.lineInfo = additionInfo;
+      state3.lineInfo = additionInfo;
       return getLineNodes(highlighter2.codeToHast(cleanLastNewline(additionFile.contents), hastConfig));
     })()
   };
@@ -51092,8 +51537,8 @@ function areHunkDataEqual(hunkA, hunkB) {
 async function awaitWithTimeout(callback, timeout = 300) {
   let timeoutId;
   try {
-    await Promise.race([callback(), new Promise((resolve) => {
-      timeoutId = setTimeout(resolve, timeout);
+    await Promise.race([callback(), new Promise((resolve2) => {
+      timeoutId = setTimeout(resolve2, timeout);
     })]);
   } finally {
     if (timeoutId != null) clearTimeout(timeoutId);
@@ -54020,14 +54465,14 @@ var PopoutWindow = class extends CompositeDisposable {
         id: _this.target,
         window: externalWindow
       });
-      return new Promise((resolve) => {
+      return new Promise((resolve2) => {
         const abandon = (err) => {
           _this._failure = {
             reason: "unscriptable",
             error: err instanceof Error ? err : new Error(String(err))
           };
           _this.close();
-          resolve(null);
+          resolve2(null);
         };
         try {
           externalWindow.addEventListener("unload", () => {
@@ -54039,7 +54484,7 @@ var PopoutWindow = class extends CompositeDisposable {
         disposable.addDisposables(_this.onWillClose(() => {
           var _this$_failure;
           (_this$_failure = _this._failure) !== null && _this$_failure !== void 0 || (_this._failure = { reason: "closed" });
-          resolve(null);
+          resolve2(null);
         }));
         externalWindow.addEventListener("load", () => {
           try {
@@ -54057,7 +54502,7 @@ var PopoutWindow = class extends CompositeDisposable {
             addDisposableListener(externalWindow, "beforeunload", () => {
               _this.close();
             });
-            resolve(container);
+            resolve2(container);
           } catch (err) {
             abandon(err);
           }
@@ -54771,11 +55216,11 @@ var Splitview = class {
       else this.updateSash(sash, 3);
     }
   }
-  updateSash(sash, state2) {
-    toggleClass(sash.container, "dv-disabled", state2 === 2);
-    toggleClass(sash.container, "dv-enabled", state2 === 3);
-    toggleClass(sash.container, "dv-maximum", state2 === 0);
-    toggleClass(sash.container, "dv-minimum", state2 === 1);
+  updateSash(sash, state3) {
+    toggleClass(sash.container, "dv-disabled", state3 === 2);
+    toggleClass(sash.container, "dv-enabled", state3 === 3);
+    toggleClass(sash.container, "dv-maximum", state3 === 0);
+    toggleClass(sash.container, "dv-minimum", state3 === 1);
   }
   createViewContainer() {
     const element2 = document.createElement("div");
@@ -56974,14 +57419,14 @@ var Droptarget = class Droptarget2 extends CompositeDisposable {
       onDrop: (e119) => {
         var _this$options$getOver7, _this$options6;
         e119.preventDefault();
-        const state2 = this._state;
+        const state3 = this._state;
         const edge = this._edge;
         this.removeDropTarget();
         (_this$options$getOver7 = (_this$options6 = this.options).getOverrideTarget) === null || _this$options$getOver7 === void 0 || (_this$options$getOver7 = _this$options$getOver7.call(_this$options6)) === null || _this$options$getOver7 === void 0 || _this$options$getOver7.clear();
-        if (state2) {
+        if (state3) {
           e119.stopPropagation();
           this._onDrop.fire({
-            position: state2,
+            position: state3,
             nativeEvent: e119,
             edge
           });
@@ -57455,13 +57900,13 @@ var PointerDropTarget = class extends CompositeDisposable {
   }
   _onDropEvent(event2) {
     var _this$options$getOver5, _this$options4;
-    const state2 = this._state;
+    const state3 = this._state;
     const edge = this._edge;
     const overrideTarget = (_this$options$getOver5 = (_this$options4 = this.options).getOverrideTarget) === null || _this$options$getOver5 === void 0 ? void 0 : _this$options$getOver5.call(_this$options4);
     this._removeOverlay();
     overrideTarget === null || overrideTarget === void 0 || overrideTarget.clear();
-    if (state2) this._onDrop.fire({
-      position: state2,
+    if (state3) this._onDrop.fire({
+      position: state3,
       nativeEvent: event2.pointerEvent,
       edge
     });
@@ -60168,9 +60613,9 @@ var TabReorderController = class extends CompositeDisposable {
     else this._animState.currentInsertionIndex = null;
   }
   snapshotTabPositions() {
-    const positions = /* @__PURE__ */ new Map();
-    for (const tab of this._tabs) positions.set(tab.value.panel.id, tab.value.element.getBoundingClientRect());
-    return positions;
+    const positions2 = /* @__PURE__ */ new Map();
+    for (const tab of this._tabs) positions2.set(tab.value.panel.id, tab.value.element.getBoundingClientRect());
+    return positions2;
   }
   /** Main-axis extent of a rect for this header's orientation. */
   _mainAxisSize(rect) {
@@ -63489,10 +63934,10 @@ var GridviewPanel = class extends BasePanelView {
     });
   }
   toJSON() {
-    const state2 = super.toJSON();
+    const state3 = super.toJSON();
     const maximum = (value) => value === Number.MAX_SAFE_INTEGER ? void 0 : value;
     const minimum = (value) => value <= 0 ? void 0 : value;
-    return _objectSpread2(_objectSpread2({}, state2), {}, {
+    return _objectSpread2(_objectSpread2({}, state3), {}, {
       minimumHeight: minimum(this.minimumHeight),
       maximumHeight: maximum(this.maximumHeight),
       minimumWidth: minimum(this.minimumWidth),
@@ -63984,17 +64429,17 @@ var DockviewPanel = class extends CompositeDisposable {
     for (const key2 of Object.keys(event2.params)) if (event2.params[key2] === void 0) delete this._params[key2];
     this.view.update({ params: this._params });
   }
-  updateFromStateModel(state2) {
+  updateFromStateModel(state3) {
     var _state$params, _state$title, _state$renderer, _state$pinned, _this$accessor$option;
-    this._maximumHeight = state2.maximumHeight;
-    this._minimumHeight = state2.minimumHeight;
-    this._maximumWidth = state2.maximumWidth;
-    this._minimumWidth = state2.minimumWidth;
-    this._params = (_state$params = state2.params) !== null && _state$params !== void 0 ? _state$params : {};
+    this._maximumHeight = state3.maximumHeight;
+    this._minimumHeight = state3.minimumHeight;
+    this._maximumWidth = state3.maximumWidth;
+    this._minimumWidth = state3.minimumWidth;
+    this._params = (_state$params = state3.params) !== null && _state$params !== void 0 ? _state$params : {};
     this.view.update({ params: this._params });
-    this.setTitle((_state$title = state2.title) !== null && _state$title !== void 0 ? _state$title : this.id);
-    this.setRenderer((_state$renderer = state2.renderer) !== null && _state$renderer !== void 0 ? _state$renderer : this.accessor.renderer);
-    this.setPinned(((_state$pinned = state2.pinned) !== null && _state$pinned !== void 0 ? _state$pinned : false) && !!((_this$accessor$option = this.accessor.options.pinnedTabs) === null || _this$accessor$option === void 0 ? void 0 : _this$accessor$option.enabled));
+    this.setTitle((_state$title = state3.title) !== null && _state$title !== void 0 ? _state$title : this.id);
+    this.setRenderer((_state$renderer = state3.renderer) !== null && _state$renderer !== void 0 ? _state$renderer : this.accessor.renderer);
+    this.setPinned(((_state$pinned = state3.pinned) !== null && _state$pinned !== void 0 ? _state$pinned : false) && !!((_this$accessor$option = this.accessor.options.pinnedTabs) === null || _this$accessor$option === void 0 ? void 0 : _this$accessor$option.enabled));
   }
   updateParentGroup(group, options) {
     this._group = group;
@@ -64997,20 +65442,20 @@ var PopoutWindowService = class {
   * only for the timer that starts it.
   */
   scheduleRestoration(delayMs, work, onCancel) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const cleanup = () => {
         this._restorationCleanups.delete(cleanup);
         clearTimeout(handle2);
         onCancel === null || onCancel === void 0 || onCancel();
-        resolve();
+        resolve2();
       };
       const handle2 = setTimeout(() => {
         this._restorationCleanups.delete(cleanup);
         if (this._host.isDisposed) {
-          resolve();
+          resolve2();
           return;
         }
-        Promise.resolve(work()).then(() => resolve(), () => resolve());
+        Promise.resolve(work()).then(() => resolve2(), () => resolve2());
       }, delayMs);
       this._restorationCleanups.add(cleanup);
     });
@@ -65272,36 +65717,36 @@ var HeaderActionsService = class {
   }
   refresh(group) {
     if (!(group === null || group === void 0 ? void 0 : group.model)) return;
-    const state2 = this._ensureState(group);
-    this._refreshSlot("left", group, state2.left);
-    this._refreshSlot("right", group, state2.right);
-    this._refreshSlot("prefix", group, state2.prefix);
+    const state3 = this._ensureState(group);
+    this._refreshSlot("left", group, state3.left);
+    this._refreshSlot("right", group, state3.right);
+    this._refreshSlot("prefix", group, state3.prefix);
   }
   refreshAll() {
     for (const group of this._host.groups) this.refresh(group);
   }
   disposeGroup(group) {
-    const state2 = this._perGroup.get(group);
-    if (!state2) return;
-    state2.left.dispose();
-    state2.right.dispose();
-    state2.prefix.dispose();
+    const state3 = this._perGroup.get(group);
+    if (!state3) return;
+    state3.left.dispose();
+    state3.right.dispose();
+    state3.prefix.dispose();
     this._perGroup.delete(group);
   }
   dispose() {
     for (const group of [...this._perGroup.keys()]) this.disposeGroup(group);
   }
   _ensureState(group) {
-    let state2 = this._perGroup.get(group);
-    if (!state2) {
-      state2 = {
+    let state3 = this._perGroup.get(group);
+    if (!state3) {
+      state3 = {
         left: new MutableDisposable(),
         right: new MutableDisposable(),
         prefix: new MutableDisposable()
       };
-      this._perGroup.set(group, state2);
+      this._perGroup.set(group, state3);
     }
-    return state2;
+    return state3;
   }
   _refreshSlot(slot, group, disposable) {
     const factory = this._host.options[SLOT_OPTION_KEY[slot]];
@@ -66986,16 +67431,16 @@ var ShellManager = class {
       "bottom"
     ]) {
       var _state$collapsed;
-      const state2 = data[position];
+      const state3 = data[position];
       const view = this._getView(position);
-      if (!state2 || !view) continue;
-      view.restoreExpandedSize(state2.size);
-      view.setCollapsed((_state$collapsed = state2.collapsed) !== null && _state$collapsed !== void 0 ? _state$collapsed : false);
-      if (state2.collapsed) {
+      if (!state3 || !view) continue;
+      view.restoreExpandedSize(state3.size);
+      view.setCollapsed((_state$collapsed = state3.collapsed) !== null && _state$collapsed !== void 0 ? _state$collapsed : false);
+      if (state3.collapsed) {
         this._pendingSizes.delete(position);
         this._resizeView(position, view.collapsedSize);
-      } else this.resizeEdgeGroup(position, state2.size);
-      this.setEdgeGroupVisible(position, !!state2.visible);
+      } else this.resizeEdgeGroup(position, state3.size);
+      this.setEdgeGroupVisible(position, !!state3.visible);
     }
   }
   dispose() {
@@ -68751,7 +69196,7 @@ var DockviewComponent = class extends BaseGrid {
       const width = this.width;
       const height = this.height;
       const createGroupFromSerializedState = (data2) => {
-        const { id, locked, hideHeader, headerPosition, views, activeView } = data2;
+        const { id, locked, hideHeader, headerPosition, views: views2, activeView } = data2;
         if (typeof id !== "string") throw new TypeError("dockview: group id must be of type string");
         const group = this.createGroup({
           id,
@@ -68761,7 +69206,7 @@ var DockviewComponent = class extends BaseGrid {
         });
         this._onDidAddGroup.fire(group);
         const createdPanels = [];
-        const presentViews = views.filter((child) => panels[child]);
+        const presentViews = views2.filter((child) => panels[child]);
         for (const child of presentViews) {
           const existingPanel = existingPanels.get(child);
           const temporaryGroup = temporaryGroups.get(child);
@@ -68874,9 +69319,9 @@ var DockviewComponent = class extends BaseGrid {
       const edgeData = edgeGroups[position];
       const groupState = edgeData === null || edgeData === void 0 ? void 0 : edgeData.group;
       if (groupState) {
-        const { views, activeView } = groupState;
+        const { views: views2, activeView } = groupState;
         const createdPanels = [];
-        for (const panelId of views) {
+        for (const panelId of views2) {
           if (!panels[panelId]) continue;
           const existingPanel = existingPanels.get(panelId);
           const temporaryGroup = temporaryGroups.get(panelId);
@@ -70915,13 +71360,13 @@ function ensureChildIdByNameId(nodes, index) {
 }
 function ensureChildPositions(index) {
   if (index.childPositionById != null) return index.childPositionById;
-  const positions = /* @__PURE__ */ new Map();
+  const positions2 = /* @__PURE__ */ new Map();
   for (let i25 = 0; i25 < index.childIds.length; i25++) {
     const childId = index.childIds[i25];
-    if (childId != null) positions.set(childId, i25);
+    if (childId != null) positions2.set(childId, i25);
   }
-  index.childPositionById = positions;
-  return positions;
+  index.childPositionById = positions2;
+  return positions2;
 }
 function appendChildReference(index, childId) {
   if (index.childPositionById != null) index.childPositionById.set(childId, index.childIds.length);
@@ -71884,40 +72329,40 @@ function resolveInitialExpansion(initialExpansion) {
   if (!Number.isInteger(initialExpansion) || initialExpansion < 0) throw new Error(`initialExpansion must be "open", "closed", or a non-negative integer depth. Received: ${String(initialExpansion)}`);
   return initialExpansion;
 }
-function isDirectoryExpandedByDefault(state2, node) {
+function isDirectoryExpandedByDefault(state3, node) {
   if (hasNodeFlag(node, 2)) return true;
-  if (state2.defaultExpansion === "open") return true;
-  if (state2.defaultExpansion === "closed") return false;
-  return getNodeDepth(node) <= state2.defaultExpansion;
+  if (state3.defaultExpansion === "open") return true;
+  if (state3.defaultExpansion === "closed") return false;
+  return getNodeDepth(node) <= state3.defaultExpansion;
 }
-function isDirectoryExpanded(state2, nodeId, node = state2.snapshot.nodes[nodeId]) {
+function isDirectoryExpanded(state3, nodeId, node = state3.snapshot.nodes[nodeId]) {
   if (node == null || !isDirectoryNode(node)) return false;
-  if (state2.directoriesOpenByDefault && !state2.hasCollapsedDirectoryOverrides) return true;
-  if (state2.collapsedDirectoryIds.has(nodeId)) return false;
-  if (state2.expandedDirectoryIds.has(nodeId)) return true;
-  return isDirectoryExpandedByDefault(state2, node);
+  if (state3.directoriesOpenByDefault && !state3.hasCollapsedDirectoryOverrides) return true;
+  if (state3.collapsedDirectoryIds.has(nodeId)) return false;
+  if (state3.expandedDirectoryIds.has(nodeId)) return true;
+  return isDirectoryExpandedByDefault(state3, node);
 }
-function setDirectoryExpanded(state2, nodeId, expanded, node = state2.snapshot.nodes[nodeId]) {
+function setDirectoryExpanded(state3, nodeId, expanded, node = state3.snapshot.nodes[nodeId]) {
   if (node == null || !isDirectoryNode(node)) return;
-  const expandedByDefault = isDirectoryExpandedByDefault(state2, node);
+  const expandedByDefault = isDirectoryExpandedByDefault(state3, node);
   if (expanded) {
     if (expandedByDefault) {
-      state2.collapsedDirectoryIds.delete(nodeId);
-      state2.hasCollapsedDirectoryOverrides = state2.collapsedDirectoryIds.size > 0;
+      state3.collapsedDirectoryIds.delete(nodeId);
+      state3.hasCollapsedDirectoryOverrides = state3.collapsedDirectoryIds.size > 0;
       return;
     }
-    state2.expandedDirectoryIds.add(nodeId);
+    state3.expandedDirectoryIds.add(nodeId);
     return;
   }
   if (expandedByDefault) {
-    state2.collapsedDirectoryIds.add(nodeId);
-    state2.hasCollapsedDirectoryOverrides = true;
+    state3.collapsedDirectoryIds.add(nodeId);
+    state3.hasCollapsedDirectoryOverrides = true;
     return;
   }
-  state2.expandedDirectoryIds.delete(nodeId);
+  state3.expandedDirectoryIds.delete(nodeId);
 }
-function getOrCreateDirectoryLoadInfo(state2, nodeId) {
-  const existingInfo = state2.directoryLoadInfoById.get(nodeId);
+function getOrCreateDirectoryLoadInfo(state3, nodeId) {
+  const existingInfo = state3.directoryLoadInfoById.get(nodeId);
   if (existingInfo != null) return existingInfo;
   const nextInfo = {
     activeAttemptId: null,
@@ -71925,14 +72370,14 @@ function getOrCreateDirectoryLoadInfo(state2, nodeId) {
     nextAttemptId: 1,
     state: "loaded"
   };
-  state2.directoryLoadInfoById.set(nodeId, nextInfo);
+  state3.directoryLoadInfoById.set(nodeId, nextInfo);
   return nextInfo;
 }
-function getDirectoryLoadState(state2, nodeId) {
-  return state2.directoryLoadInfoById.get(nodeId)?.state ?? "loaded";
+function getDirectoryLoadState(state3, nodeId) {
+  return state3.directoryLoadInfoById.get(nodeId)?.state ?? "loaded";
 }
-function beginDirectoryLoad(state2, nodeId) {
-  const loadInfo = getOrCreateDirectoryLoadInfo(state2, nodeId);
+function beginDirectoryLoad(state3, nodeId) {
+  const loadInfo = getOrCreateDirectoryLoadInfo(state3, nodeId);
   if (loadInfo.state === "loading" && loadInfo.activeAttemptId != null) return {
     attemptId: loadInfo.activeAttemptId,
     nodeId,
@@ -71949,46 +72394,46 @@ function beginDirectoryLoad(state2, nodeId) {
     reused: false
   };
 }
-function markDirectoryUnloadedState(state2, nodeId) {
-  const loadInfo = getOrCreateDirectoryLoadInfo(state2, nodeId);
+function markDirectoryUnloadedState(state3, nodeId) {
+  const loadInfo = getOrCreateDirectoryLoadInfo(state3, nodeId);
   loadInfo.activeAttemptId = null;
   loadInfo.errorMessage = null;
   loadInfo.state = "unloaded";
 }
-function completeDirectoryLoad(state2, nodeId, attemptId) {
-  const loadInfo = state2.directoryLoadInfoById.get(nodeId);
+function completeDirectoryLoad(state3, nodeId, attemptId) {
+  const loadInfo = state3.directoryLoadInfoById.get(nodeId);
   if (loadInfo == null || loadInfo.activeAttemptId !== attemptId) return false;
   loadInfo.activeAttemptId = null;
   loadInfo.errorMessage = null;
   loadInfo.state = "loaded";
   return true;
 }
-function isDirectoryLoadAttemptCurrent(state2, nodeId, attemptId) {
-  return state2.directoryLoadInfoById.get(nodeId)?.activeAttemptId === attemptId;
+function isDirectoryLoadAttemptCurrent(state3, nodeId, attemptId) {
+  return state3.directoryLoadInfoById.get(nodeId)?.activeAttemptId === attemptId;
 }
-function failDirectoryLoad(state2, nodeId, attemptId, errorMessage) {
-  const loadInfo = state2.directoryLoadInfoById.get(nodeId);
+function failDirectoryLoad(state3, nodeId, attemptId, errorMessage) {
+  const loadInfo = state3.directoryLoadInfoById.get(nodeId);
   if (loadInfo == null || loadInfo.activeAttemptId !== attemptId) return false;
   loadInfo.activeAttemptId = null;
   loadInfo.errorMessage = errorMessage ?? null;
   loadInfo.state = "error";
   return true;
 }
-function clearDirectoryLoadInfo(state2, nodeId) {
-  state2.directoryLoadInfoById.delete(nodeId);
+function clearDirectoryLoadInfo(state3, nodeId) {
+  state3.directoryLoadInfoById.delete(nodeId);
 }
 
 // node_modules/@pierre/trees/dist/path-store/src/events.js
-function subscribe(state2, type, handler) {
+function subscribe(state3, type, handler) {
   const rawHandler = handler;
-  const existingListeners = state2.listeners.get(type);
+  const existingListeners = state3.listeners.get(type);
   if (existingListeners != null) existingListeners.add(rawHandler);
-  else state2.listeners.set(type, /* @__PURE__ */ new Set([rawHandler]));
+  else state3.listeners.set(type, /* @__PURE__ */ new Set([rawHandler]));
   return () => {
-    const listeners = state2.listeners.get(type);
+    const listeners = state3.listeners.get(type);
     if (listeners == null) return;
     listeners.delete(rawHandler);
-    if (listeners.size === 0) state2.listeners.delete(type);
+    if (listeners.size === 0) state3.listeners.delete(type);
   };
 }
 function createAddEvent(args2) {
@@ -72138,58 +72583,58 @@ function createCleanupEvent(args2) {
     visibleCountDelta: null
   };
 }
-function finalizeEvent(state2, previousVisibleCount, event2) {
+function finalizeEvent(state3, previousVisibleCount, event2) {
   return {
     ...event2,
-    visibleCountDelta: getCurrentVisibleCount(state2) - previousVisibleCount
+    visibleCountDelta: getCurrentVisibleCount(state3) - previousVisibleCount
   };
 }
-function batchEvents(state2, run2) {
-  const previousVisibleCount = getCurrentVisibleCount(state2);
+function batchEvents(state3, run2) {
+  const previousVisibleCount = getCurrentVisibleCount(state3);
   const frame = createTransactionFrame();
-  state2.transactionStack.push(frame);
+  state3.transactionStack.push(frame);
   try {
     run2();
   } catch (error) {
-    finishTransaction(state2, frame, false);
+    finishTransaction(state3, frame, false);
     throw error;
   }
-  finishTransaction(state2, frame, true, getCurrentVisibleCount(state2) - previousVisibleCount);
+  finishTransaction(state3, frame, true, getCurrentVisibleCount(state3) - previousVisibleCount);
 }
-function recordEvent(state2, event2) {
-  const instrumentation = state2.instrumentation;
+function recordEvent(state3, event2) {
+  const instrumentation = state3.instrumentation;
   if (instrumentation == null) {
-    recordEventNow(state2, event2);
+    recordEventNow(state3, event2);
     return;
   }
-  withBenchmarkPhase(instrumentation, "store.events.record", () => recordEventNow(state2, event2));
+  withBenchmarkPhase(instrumentation, "store.events.record", () => recordEventNow(state3, event2));
 }
-function recordEventNow(state2, event2) {
-  const currentFrame = state2.transactionStack[state2.transactionStack.length - 1] ?? null;
+function recordEventNow(state3, event2) {
+  const currentFrame = state3.transactionStack[state3.transactionStack.length - 1] ?? null;
   if (currentFrame == null) {
-    emitEvent(state2, event2);
+    emitEvent(state3, event2);
     return;
   }
   currentFrame.events.push(event2);
   mergeEventMetadataIntoFrame(currentFrame, event2);
 }
-function finishTransaction(state2, frame, emit, visibleCountDelta = null) {
-  if (state2.transactionStack.pop() !== frame) throw new Error("Transaction stack underflow");
+function finishTransaction(state3, frame, emit, visibleCountDelta = null) {
+  if (state3.transactionStack.pop() !== frame) throw new Error("Transaction stack underflow");
   if (!emit) return;
-  const parentFrame = state2.transactionStack[state2.transactionStack.length - 1] ?? null;
+  const parentFrame = state3.transactionStack[state3.transactionStack.length - 1] ?? null;
   if (parentFrame != null) {
-    const instrumentation2 = state2.instrumentation;
+    const instrumentation2 = state3.instrumentation;
     if (instrumentation2 == null) mergeBatchFrameIntoParent(parentFrame, frame);
     else withBenchmarkPhase(instrumentation2, "store.events.batch.merge", () => mergeBatchFrameIntoParent(parentFrame, frame));
     return;
   }
   const batchEvent = createBatchEvent(frame, visibleCountDelta);
-  const instrumentation = state2.instrumentation;
+  const instrumentation = state3.instrumentation;
   if (instrumentation == null) {
-    emitEvent(state2, batchEvent);
+    emitEvent(state3, batchEvent);
     return;
   }
-  withBenchmarkPhase(instrumentation, "store.events.batch.commit", () => emitEvent(state2, batchEvent));
+  withBenchmarkPhase(instrumentation, "store.events.batch.commit", () => emitEvent(state3, batchEvent));
 }
 function createBatchEvent(frame, visibleCountDelta) {
   return {
@@ -72214,48 +72659,48 @@ function mergeEventMetadataIntoFrame(frame, event2) {
   for (const nodeId of event2.affectedNodeIds) frame.affectedNodeIds.add(nodeId);
   for (const nodeId of event2.affectedAncestorIds) frame.affectedAncestorIds.add(nodeId);
 }
-function emitEvent(state2, event2) {
-  const instrumentation = state2.instrumentation;
+function emitEvent(state3, event2) {
+  const instrumentation = state3.instrumentation;
   if (instrumentation == null) {
-    emitEventNow(state2, event2);
+    emitEventNow(state3, event2);
     return;
   }
-  withBenchmarkPhase(instrumentation, "store.events.emit", () => emitEventNow(state2, event2));
+  withBenchmarkPhase(instrumentation, "store.events.emit", () => emitEventNow(state3, event2));
 }
-function emitEventNow(state2, event2) {
-  state2.listeners.get(event2.operation)?.forEach((handler) => handler(event2));
-  state2.listeners.get("*")?.forEach((handler) => handler(event2));
+function emitEventNow(state3, event2) {
+  state3.listeners.get(event2.operation)?.forEach((handler) => handler(event2));
+  state3.listeners.get("*")?.forEach((handler) => handler(event2));
 }
-function getCurrentVisibleCount(state2) {
-  return state2.snapshot.nodes[state2.snapshot.rootId]?.visibleSubtreeCount ?? 0;
+function getCurrentVisibleCount(state3) {
+  return state3.snapshot.nodes[state3.snapshot.rootId]?.visibleSubtreeCount ?? 0;
 }
 
 // node_modules/@pierre/trees/dist/path-store/src/flatten.js
-function getFlattenedChildDirectoryId(state2, directoryNodeId) {
-  if (state2.snapshot.options.flattenEmptyDirectories !== true) return null;
-  const directoryNode = state2.snapshot.nodes[directoryNodeId];
+function getFlattenedChildDirectoryId(state3, directoryNodeId) {
+  if (state3.snapshot.options.flattenEmptyDirectories !== true) return null;
+  const directoryNode = state3.snapshot.nodes[directoryNodeId];
   if (directoryNode == null || !isDirectoryNode(directoryNode) || hasNodeFlag(directoryNode, 2)) return null;
-  const directoryIndex = state2.snapshot.directories.get(directoryNodeId);
+  const directoryIndex = state3.snapshot.directories.get(directoryNodeId);
   if (directoryIndex == null || directoryIndex.childIds.length !== 1) return null;
   const childId = directoryIndex.childIds[0];
   if (childId == null) return null;
-  const childNode = state2.snapshot.nodes[childId];
+  const childNode = state3.snapshot.nodes[childId];
   if (childNode == null || !isDirectoryNode(childNode)) return null;
   return childId;
 }
-function getFlattenedTerminalDirectoryId(state2, directoryNodeId) {
+function getFlattenedTerminalDirectoryId(state3, directoryNodeId) {
   let currentDirectoryId = directoryNodeId;
   while (true) {
-    const nextDirectoryId = getFlattenedChildDirectoryId(state2, currentDirectoryId);
+    const nextDirectoryId = getFlattenedChildDirectoryId(state3, currentDirectoryId);
     if (nextDirectoryId == null) return currentDirectoryId;
     currentDirectoryId = nextDirectoryId;
   }
 }
-function collectFlattenedDirectoryChainIds(state2, directoryNodeId) {
+function collectFlattenedDirectoryChainIds(state3, directoryNodeId) {
   const chainIds = [directoryNodeId];
   let currentDirectoryId = directoryNodeId;
   while (true) {
-    const nextDirectoryId = getFlattenedChildDirectoryId(state2, currentDirectoryId);
+    const nextDirectoryId = getFlattenedChildDirectoryId(state3, currentDirectoryId);
     if (nextDirectoryId == null) return chainIds;
     chainIds.push(nextDirectoryId);
     currentDirectoryId = nextDirectoryId;
@@ -72263,144 +72708,144 @@ function collectFlattenedDirectoryChainIds(state2, directoryNodeId) {
 }
 
 // node_modules/@pierre/trees/dist/path-store/src/canonical.js
-function listPaths(state2, path) {
-  const nodeId = path == null ? state2.snapshot.rootId : findNodeId(state2, path);
+function listPaths(state3, path) {
+  const nodeId = path == null ? state3.snapshot.rootId : findNodeId(state3, path);
   if (nodeId == null) return [];
-  return collectCanonicalEntries(state2, nodeId);
+  return collectCanonicalEntries(state3, nodeId);
 }
-function addPath(state2, path) {
+function addPath(state3, path) {
   const preparedPath = parseInputPath(path);
   const parentSegments = preparedPath.isDirectory ? preparedPath.segments : preparedPath.segments.slice(0, -1);
-  const previousProjectionSignature = getCollapsedProjectionSignature(state2, findDeepestExistingDirectoryId(state2, parentSegments));
-  const { createdNodeIds, directoryId } = ensureDirectoryChain(state2, parentSegments);
+  const previousProjectionSignature = getCollapsedProjectionSignature(state3, findDeepestExistingDirectoryId(state3, parentSegments));
+  const { createdNodeIds, directoryId } = ensureDirectoryChain(state3, parentSegments);
   const affectedNodeIds = new Set(createdNodeIds);
   let addedNodeId = directoryId;
   if (preparedPath.isDirectory) {
-    const directoryNode = requireNode(state2, directoryId);
+    const directoryNode = requireNode(state3, directoryId);
     if (hasNodeFlag(directoryNode, 1)) throw new Error(`Path already exists: "${path}"`);
     addNodeFlag(directoryNode, 1);
-    state2.pathCacheByNodeId.set(directoryId, {
+    state3.pathCacheByNodeId.set(directoryId, {
       path,
-      version: state2.pathCacheVersion
+      version: state3.pathCacheVersion
     });
     affectedNodeIds.add(directoryId);
   } else {
-    addedNodeId = createFileNode(state2, directoryId, preparedPath.basename);
+    addedNodeId = createFileNode(state3, directoryId, preparedPath.basename);
     affectedNodeIds.add(addedNodeId);
   }
-  recomputeCountsUpwardFrom(state2, directoryId);
-  const nextProjectionSignature = getCollapsedProjectionSignature(state2, directoryId);
+  recomputeCountsUpwardFrom(state3, directoryId);
+  const nextProjectionSignature = getCollapsedProjectionSignature(state3, directoryId);
   return createAddEvent({
-    affectedAncestorIds: collectAncestorIds(state2, addedNodeId),
+    affectedAncestorIds: collectAncestorIds(state3, addedNodeId),
     affectedNodeIds: [...affectedNodeIds],
     path,
     projectionChanged: didProjectionChange(previousProjectionSignature, nextProjectionSignature)
   });
 }
-function removePath(state2, path, options) {
-  const nodeId = findNodeId(state2, path);
+function removePath(state3, path, options) {
+  const nodeId = findNodeId(state3, path);
   if (nodeId == null) throw new Error(`Path does not exist: "${path}"`);
-  const node = requireNode(state2, nodeId);
+  const node = requireNode(state3, nodeId);
   if (hasNodeFlag(node, 2)) throw new Error("The root node cannot be removed");
-  if (isDirectoryNode(node) && getDirectoryIndex(state2, nodeId).childIds.length > 0 && options.recursive !== true) throw new Error(`Cannot remove a non-empty directory without recursive: "${path}"`);
+  if (isDirectoryNode(node) && getDirectoryIndex(state3, nodeId).childIds.length > 0 && options.recursive !== true) throw new Error(`Cannot remove a non-empty directory without recursive: "${path}"`);
   const parentId = node.parentId;
-  const previousProjectionSignature = getCollapsedProjectionSignature(state2, parentId);
-  const removedNodeIds = removeSubtree(state2, nodeId);
-  removeChildReference(state2, parentId, nodeId, node.nameId);
-  promoteEmptyAncestorsToExplicit(state2, parentId);
-  recomputeCountsUpwardFrom(state2, parentId);
-  const nextProjectionSignature = getCollapsedProjectionSignature(state2, parentId);
+  const previousProjectionSignature = getCollapsedProjectionSignature(state3, parentId);
+  const removedNodeIds = removeSubtree(state3, nodeId);
+  removeChildReference(state3, parentId, nodeId, node.nameId);
+  promoteEmptyAncestorsToExplicit(state3, parentId);
+  recomputeCountsUpwardFrom(state3, parentId);
+  const nextProjectionSignature = getCollapsedProjectionSignature(state3, parentId);
   return createRemoveEvent({
-    affectedAncestorIds: collectAncestorIds(state2, parentId),
+    affectedAncestorIds: collectAncestorIds(state3, parentId),
     affectedNodeIds: removedNodeIds,
     path,
     projectionChanged: didProjectionChange(previousProjectionSignature, nextProjectionSignature),
     recursive: options.recursive === true
   });
 }
-function movePath(state2, fromPath, toPath, options) {
-  const sourceNodeId = findNodeId(state2, fromPath);
+function movePath(state3, fromPath, toPath, options) {
+  const sourceNodeId = findNodeId(state3, fromPath);
   if (sourceNodeId == null) throw new Error(`Source path does not exist: "${fromPath}"`);
-  const sourceNode = requireNode(state2, sourceNodeId);
+  const sourceNode = requireNode(state3, sourceNodeId);
   if (hasNodeFlag(sourceNode, 2)) throw new Error("The root node cannot be moved");
   const collision = options.collision ?? "error";
-  const moveTarget = resolveMoveTarget(state2, sourceNodeId, toPath);
-  const previousSourceProjectionSignature = getCollapsedProjectionSignature(state2, sourceNode.parentId);
-  const previousTargetProjectionSignature = getCollapsedProjectionSignature(state2, moveTarget.parentId);
-  const sourceName = getSegmentValue(state2.snapshot.segmentTable, sourceNode.nameId);
-  const targetNameId = internSegment(state2.snapshot.segmentTable, moveTarget.basename);
+  const moveTarget = resolveMoveTarget(state3, sourceNodeId, toPath);
+  const previousSourceProjectionSignature = getCollapsedProjectionSignature(state3, sourceNode.parentId);
+  const previousTargetProjectionSignature = getCollapsedProjectionSignature(state3, moveTarget.parentId);
+  const sourceName = getSegmentValue(state3.snapshot.segmentTable, sourceNode.nameId);
+  const targetNameId = internSegment(state3.snapshot.segmentTable, moveTarget.basename);
   if (moveTarget.parentId === sourceNode.parentId && sourceName === moveTarget.basename) return null;
-  if (isDirectoryNode(sourceNode) && isAncestor2(state2, sourceNodeId, moveTarget.parentId)) throw new Error("Cannot move a directory into one of its descendants");
-  const siblingCollisionId = ensureChildIdByNameId(state2.snapshot.nodes, getDirectoryIndex(state2, moveTarget.parentId)).get(targetNameId);
+  if (isDirectoryNode(sourceNode) && isAncestor2(state3, sourceNodeId, moveTarget.parentId)) throw new Error("Cannot move a directory into one of its descendants");
+  const siblingCollisionId = ensureChildIdByNameId(state3.snapshot.nodes, getDirectoryIndex(state3, moveTarget.parentId)).get(targetNameId);
   const collisionNodeId = moveTarget.existingNodeId ?? siblingCollisionId ?? null;
   if (collisionNodeId != null && collisionNodeId !== sourceNodeId) {
-    if (handleMoveCollision(state2, collisionNodeId, collision, getNodeKind(sourceNode)) === "skip") return null;
+    if (handleMoveCollision(state3, collisionNodeId, collision, getNodeKind(sourceNode)) === "skip") return null;
   }
   const previousParentId = sourceNode.parentId;
-  removeChildReference(state2, previousParentId, sourceNodeId, sourceNode.nameId);
+  removeChildReference(state3, previousParentId, sourceNodeId, sourceNode.nameId);
   sourceNode.parentId = moveTarget.parentId;
   sourceNode.nameId = targetNameId;
-  state2.pathCacheByNodeId.delete(sourceNodeId);
-  recomputeDepths(state2, sourceNodeId);
-  insertChildReference(state2, moveTarget.parentId, sourceNodeId);
-  promoteEmptyAncestorsToExplicit(state2, previousParentId);
-  state2.pathCacheVersion++;
-  recomputeCountsUpwardFrom(state2, previousParentId);
-  if (moveTarget.parentId !== previousParentId) recomputeCountsUpwardFrom(state2, moveTarget.parentId);
-  const nextSourceProjectionSignature = getCollapsedProjectionSignature(state2, previousParentId);
-  const nextTargetProjectionSignature = getCollapsedProjectionSignature(state2, moveTarget.parentId);
+  state3.pathCacheByNodeId.delete(sourceNodeId);
+  recomputeDepths(state3, sourceNodeId);
+  insertChildReference(state3, moveTarget.parentId, sourceNodeId);
+  promoteEmptyAncestorsToExplicit(state3, previousParentId);
+  state3.pathCacheVersion++;
+  recomputeCountsUpwardFrom(state3, previousParentId);
+  if (moveTarget.parentId !== previousParentId) recomputeCountsUpwardFrom(state3, moveTarget.parentId);
+  const nextSourceProjectionSignature = getCollapsedProjectionSignature(state3, previousParentId);
+  const nextTargetProjectionSignature = getCollapsedProjectionSignature(state3, moveTarget.parentId);
   return createMoveEvent({
-    affectedAncestorIds: [.../* @__PURE__ */ new Set([...collectAncestorIds(state2, previousParentId), ...collectAncestorIds(state2, moveTarget.parentId)])],
+    affectedAncestorIds: [.../* @__PURE__ */ new Set([...collectAncestorIds(state3, previousParentId), ...collectAncestorIds(state3, moveTarget.parentId)])],
     affectedNodeIds: [sourceNodeId],
     from: fromPath,
     projectionChanged: didAnyProjectionChange([previousSourceProjectionSignature, previousTargetProjectionSignature], [nextSourceProjectionSignature, nextTargetProjectionSignature]),
-    to: materializeNodePath(state2, sourceNodeId)
+    to: materializeNodePath(state3, sourceNodeId)
   });
 }
-function getCachedNodePath(state2, nodeId) {
-  const cachedEntry = state2.pathCacheByNodeId.get(nodeId);
-  return cachedEntry != null && cachedEntry.version === state2.pathCacheVersion ? cachedEntry.path : null;
+function getCachedNodePath(state3, nodeId) {
+  const cachedEntry = state3.pathCacheByNodeId.get(nodeId);
+  return cachedEntry != null && cachedEntry.version === state3.pathCacheVersion ? cachedEntry.path : null;
 }
-function setCachedNodePath(state2, nodeId, path) {
-  state2.pathCacheByNodeId.set(nodeId, {
+function setCachedNodePath(state3, nodeId, path) {
+  state3.pathCacheByNodeId.set(nodeId, {
     path,
-    version: state2.pathCacheVersion
+    version: state3.pathCacheVersion
   });
   return path;
 }
-function materializeNodePath(state2, nodeId) {
-  const node = requireNode(state2, nodeId);
-  const cachedPath = getCachedNodePath(state2, nodeId);
+function materializeNodePath(state3, nodeId) {
+  const node = requireNode(state3, nodeId);
+  const cachedPath = getCachedNodePath(state3, nodeId);
   if (cachedPath != null) return cachedPath;
-  if (hasNodeFlag(node, 2)) return setCachedNodePath(state2, nodeId, "");
-  const parentPath = materializeNodePath(state2, node.parentId);
-  const nodeName = getSegmentValue(state2.snapshot.segmentTable, node.nameId);
+  if (hasNodeFlag(node, 2)) return setCachedNodePath(state3, nodeId, "");
+  const parentPath = materializeNodePath(state3, node.parentId);
+  const nodeName = getSegmentValue(state3.snapshot.segmentTable, node.nameId);
   const path = parentPath.length === 0 ? nodeName : `${parentPath}${nodeName}`;
-  return setCachedNodePath(state2, nodeId, isDirectoryNode(node) ? `${path}/` : path);
+  return setCachedNodePath(state3, nodeId, isDirectoryNode(node) ? `${path}/` : path);
 }
-function recomputeCountsUpwardFrom(state2, startNodeId) {
-  const instrumentation = state2.instrumentation;
+function recomputeCountsUpwardFrom(state3, startNodeId) {
+  const instrumentation = state3.instrumentation;
   if (instrumentation == null) {
-    recomputeCountsUpwardFromNow(state2, startNodeId);
+    recomputeCountsUpwardFromNow(state3, startNodeId);
     return;
   }
-  withBenchmarkPhase(instrumentation, "store.recomputeCountsUpwardFrom", () => recomputeCountsUpwardFromNow(state2, startNodeId));
+  withBenchmarkPhase(instrumentation, "store.recomputeCountsUpwardFrom", () => recomputeCountsUpwardFromNow(state3, startNodeId));
 }
-function recomputeCountsRecursive(state2, nodeId) {
+function recomputeCountsRecursive(state3, nodeId) {
   const stack = [[nodeId, 0]];
-  const { nodes, directories } = state2.snapshot;
+  const { nodes, directories } = state3.snapshot;
   while (stack.length > 0) {
     const frame = stack[stack.length - 1];
     const nid = frame[0];
     const node = nodes[nid];
     if (node == null || !isDirectoryNode(node)) {
-      recomputeNodeCounts(state2, nid, node, true);
+      recomputeNodeCounts(state3, nid, node, true);
       stack.pop();
       continue;
     }
     const dirIndex = directories.get(nid);
     if (dirIndex == null || frame[1] >= dirIndex.childIds.length) {
-      recomputeNodeCounts(state2, nid, node, true);
+      recomputeNodeCounts(state3, nid, node, true);
       stack.pop();
       continue;
     }
@@ -72408,51 +72853,51 @@ function recomputeCountsRecursive(state2, nodeId) {
     stack.push([childId, 0]);
   }
 }
-function collectAncestorIds(state2, nodeId) {
+function collectAncestorIds(state3, nodeId) {
   const ancestorIds = [];
   let currentNodeId = nodeId;
   while (currentNodeId != null) {
-    const currentNode = requireNode(state2, currentNodeId);
+    const currentNode = requireNode(state3, currentNodeId);
     ancestorIds.push(currentNodeId);
-    if (currentNodeId === state2.snapshot.rootId) break;
+    if (currentNodeId === state3.snapshot.rootId) break;
     currentNodeId = currentNode.parentId;
   }
   return ancestorIds;
 }
-function findNodeId(state2, path) {
-  if (path.length === 0) return state2.snapshot.rootId;
+function findNodeId(state3, path) {
+  if (path.length === 0) return state3.snapshot.rootId;
   const lookupPath = parseLookupPath(path);
-  return findNodeIdBySegments(state2, lookupPath.segments, lookupPath.requiresDirectory);
+  return findNodeIdBySegments(state3, lookupPath.segments, lookupPath.requiresDirectory);
 }
-function findNodeIdBySegments(state2, segments, requireDirectory) {
-  let currentNodeId = state2.snapshot.rootId;
+function findNodeIdBySegments(state3, segments, requireDirectory) {
+  let currentNodeId = state3.snapshot.rootId;
   for (const segment2 of segments) {
-    const segmentId = state2.snapshot.segmentTable.idByValue.get(segment2);
+    const segmentId = state3.snapshot.segmentTable.idByValue.get(segment2);
     if (segmentId === void 0) return null;
-    const currentIndex = getDirectoryIndex(state2, currentNodeId);
-    const nextNodeId = ensureChildIdByNameId(state2.snapshot.nodes, currentIndex).get(segmentId);
+    const currentIndex = getDirectoryIndex(state3, currentNodeId);
+    const nextNodeId = ensureChildIdByNameId(state3.snapshot.nodes, currentIndex).get(segmentId);
     if (nextNodeId === void 0) return null;
     currentNodeId = nextNodeId;
   }
-  const currentNode = requireNode(state2, currentNodeId);
+  const currentNode = requireNode(state3, currentNodeId);
   if (requireDirectory && !isDirectoryNode(currentNode)) return null;
   return currentNodeId;
 }
-function getDirectoryIndex(state2, directoryId) {
-  const directoryIndex = state2.snapshot.directories.get(directoryId);
+function getDirectoryIndex(state3, directoryId) {
+  const directoryIndex = state3.snapshot.directories.get(directoryId);
   if (directoryIndex === void 0) throw new Error(`Unknown directory child index for node ${String(directoryId)}`);
   return directoryIndex;
 }
-function requireNode(state2, nodeId) {
-  const node = state2.snapshot.nodes[nodeId];
+function requireNode(state3, nodeId) {
+  const node = state3.snapshot.nodes[nodeId];
   if (node === void 0 || hasNodeFlag(node, 4)) throw new Error(`Unknown node ID: ${String(nodeId)}`);
   return node;
 }
-function collectCanonicalEntries(state2, nodeId) {
-  const rootNode = state2.snapshot.nodes[nodeId];
+function collectCanonicalEntries(state3, nodeId) {
+  const rootNode = state3.snapshot.nodes[nodeId];
   if (rootNode === void 0 || hasNodeFlag(rootNode, 4)) return [];
-  if (!isDirectoryNode(rootNode)) return [materializeNodePath(state2, nodeId)];
-  if (getDirectoryIndex(state2, nodeId).childIds.length === 0) return hasNodeFlag(rootNode, 1) && !hasNodeFlag(rootNode, 2) ? [materializeNodePath(state2, nodeId)] : [];
+  if (!isDirectoryNode(rootNode)) return [materializeNodePath(state3, nodeId)];
+  if (getDirectoryIndex(state3, nodeId).childIds.length === 0) return hasNodeFlag(rootNode, 1) && !hasNodeFlag(rootNode, 2) ? [materializeNodePath(state3, nodeId)] : [];
   const entries = [];
   const stack = [{
     childIndex: 0,
@@ -72461,19 +72906,19 @@ function collectCanonicalEntries(state2, nodeId) {
   while (stack.length > 0) {
     const frame = stack[stack.length - 1];
     if (frame == null) break;
-    const currentNode = state2.snapshot.nodes[frame.nodeId];
+    const currentNode = state3.snapshot.nodes[frame.nodeId];
     if (currentNode === void 0 || hasNodeFlag(currentNode, 4)) {
       stack.pop();
       continue;
     }
     if (!isDirectoryNode(currentNode)) {
-      entries.push(materializeNodePath(state2, frame.nodeId));
+      entries.push(materializeNodePath(state3, frame.nodeId));
       stack.pop();
       continue;
     }
-    const currentIndex = getDirectoryIndex(state2, frame.nodeId);
+    const currentIndex = getDirectoryIndex(state3, frame.nodeId);
     if (currentIndex.childIds.length === 0) {
-      if (hasNodeFlag(currentNode, 1) && !hasNodeFlag(currentNode, 2)) entries.push(materializeNodePath(state2, frame.nodeId));
+      if (hasNodeFlag(currentNode, 1) && !hasNodeFlag(currentNode, 2)) entries.push(materializeNodePath(state3, frame.nodeId));
       stack.pop();
       continue;
     }
@@ -72490,19 +72935,19 @@ function collectCanonicalEntries(state2, nodeId) {
   }
   return entries;
 }
-function ensureDirectoryChain(state2, directorySegments) {
+function ensureDirectoryChain(state3, directorySegments) {
   const createdNodeIds = [];
-  let currentDirectoryId = state2.snapshot.rootId;
+  let currentDirectoryId = state3.snapshot.rootId;
   for (const segment2 of directorySegments) {
-    const segmentId = internSegment(state2.snapshot.segmentTable, segment2);
-    const currentIndex = getDirectoryIndex(state2, currentDirectoryId);
-    const existingChildId = ensureChildIdByNameId(state2.snapshot.nodes, currentIndex).get(segmentId);
+    const segmentId = internSegment(state3.snapshot.segmentTable, segment2);
+    const currentIndex = getDirectoryIndex(state3, currentDirectoryId);
+    const existingChildId = ensureChildIdByNameId(state3.snapshot.nodes, currentIndex).get(segmentId);
     if (existingChildId !== void 0) {
-      if (!isDirectoryNode(requireNode(state2, existingChildId))) throw new Error(`Cannot create a directory that collides with an existing file: "${segment2}"`);
+      if (!isDirectoryNode(requireNode(state3, existingChildId))) throw new Error(`Cannot create a directory that collides with an existing file: "${segment2}"`);
       currentDirectoryId = existingChildId;
       continue;
     }
-    currentDirectoryId = createDirectoryNode(state2, currentDirectoryId, segmentId);
+    currentDirectoryId = createDirectoryNode(state3, currentDirectoryId, segmentId);
     createdNodeIds.push(currentDirectoryId);
   }
   return {
@@ -72510,43 +72955,43 @@ function ensureDirectoryChain(state2, directorySegments) {
     directoryId: currentDirectoryId
   };
 }
-function createDirectoryNode(state2, parentId, nameId) {
-  const parentNode = requireNode(state2, parentId);
-  const nodeId = state2.snapshot.nodes.length;
-  state2.snapshot.nodes.push({
+function createDirectoryNode(state3, parentId, nameId) {
+  const parentNode = requireNode(state3, parentId);
+  const nodeId = state3.snapshot.nodes.length;
+  state3.snapshot.nodes.push({
     depthAndFlags: createNodeDepthAndFlags(getNodeDepth(parentNode) + 1, 0, 1),
     nameId,
     parentId,
     subtreeNodeCount: 1,
     visibleSubtreeCount: 1
   });
-  state2.snapshot.directories.set(nodeId, createDirectoryChildIndex());
-  insertChildReference(state2, parentId, nodeId);
-  if (state2.collapseNewDirectoriesByDefault) {
-    state2.collapsedDirectoryIds.add(nodeId);
-    state2.hasCollapsedDirectoryOverrides = true;
+  state3.snapshot.directories.set(nodeId, createDirectoryChildIndex());
+  insertChildReference(state3, parentId, nodeId);
+  if (state3.collapseNewDirectoriesByDefault) {
+    state3.collapsedDirectoryIds.add(nodeId);
+    state3.hasCollapsedDirectoryOverrides = true;
   }
-  state2.activeNodeCount++;
+  state3.activeNodeCount++;
   return nodeId;
 }
-function createFileNode(state2, parentId, basename3) {
-  const nameId = internSegment(state2.snapshot.segmentTable, basename3);
-  const parentIndex = getDirectoryIndex(state2, parentId);
-  if (ensureChildIdByNameId(state2.snapshot.nodes, parentIndex).has(nameId)) throw new Error(`Path already exists: "${buildPathPreview(state2, parentId, basename3)}"`);
-  const parentNode = requireNode(state2, parentId);
-  const nodeId = state2.snapshot.nodes.length;
-  state2.snapshot.nodes.push({
+function createFileNode(state3, parentId, basename3) {
+  const nameId = internSegment(state3.snapshot.segmentTable, basename3);
+  const parentIndex = getDirectoryIndex(state3, parentId);
+  if (ensureChildIdByNameId(state3.snapshot.nodes, parentIndex).has(nameId)) throw new Error(`Path already exists: "${buildPathPreview(state3, parentId, basename3)}"`);
+  const parentNode = requireNode(state3, parentId);
+  const nodeId = state3.snapshot.nodes.length;
+  state3.snapshot.nodes.push({
     depthAndFlags: createNodeDepthAndFlags(getNodeDepth(parentNode) + 1, 0),
     nameId,
     parentId,
     subtreeNodeCount: 1,
     visibleSubtreeCount: 1
   });
-  insertChildReference(state2, parentId, nodeId);
-  state2.activeNodeCount++;
+  insertChildReference(state3, parentId, nodeId);
+  state3.activeNodeCount++;
   return nodeId;
 }
-function findChildInsertIndex(state2, parentIndex, childId) {
+function findChildInsertIndex(state3, parentIndex, childId) {
   let low = 0;
   let high = parentIndex.childIds.length;
   while (low < high) {
@@ -72556,72 +73001,72 @@ function findChildInsertIndex(state2, parentIndex, childId) {
       high = middle;
       continue;
     }
-    if (compareSiblingNodes(state2, childId, existingChildId) < 0) high = middle;
+    if (compareSiblingNodes(state3, childId, existingChildId) < 0) high = middle;
     else low = middle + 1;
   }
   return low;
 }
-function insertChildReference(state2, parentId, childId) {
-  const parentIndex = getDirectoryIndex(state2, parentId);
-  const childNode = requireNode(state2, childId);
-  ensureChildIdByNameId(state2.snapshot.nodes, parentIndex).set(childNode.nameId, childId);
+function insertChildReference(state3, parentId, childId) {
+  const parentIndex = getDirectoryIndex(state3, parentId);
+  const childNode = requireNode(state3, childId);
+  ensureChildIdByNameId(state3.snapshot.nodes, parentIndex).set(childNode.nameId, childId);
   applyChildAggregateDelta(parentIndex, childId, childNode.subtreeNodeCount, childNode.visibleSubtreeCount);
-  const insertIndex = findChildInsertIndex(state2, parentIndex, childId);
+  const insertIndex = findChildInsertIndex(state3, parentIndex, childId);
   parentIndex.childIds.splice(insertIndex, 0, childId);
   updateChildPositionsFrom(parentIndex, insertIndex);
-  rebuildVisibleChildChunks(state2.snapshot.nodes, parentIndex);
-}
-function removeChildReference(state2, parentId, childId, childNameId) {
-  const parentIndex = getDirectoryIndex(state2, parentId);
-  const positions = ensureChildPositions(parentIndex);
-  const childIndex = positions.get(childId) ?? -1;
-  ensureChildIdByNameId(state2.snapshot.nodes, parentIndex).delete(childNameId);
-  positions.delete(childId);
-  const childNode = state2.snapshot.nodes[childId];
+  rebuildVisibleChildChunks(state3.snapshot.nodes, parentIndex);
+}
+function removeChildReference(state3, parentId, childId, childNameId) {
+  const parentIndex = getDirectoryIndex(state3, parentId);
+  const positions2 = ensureChildPositions(parentIndex);
+  const childIndex = positions2.get(childId) ?? -1;
+  ensureChildIdByNameId(state3.snapshot.nodes, parentIndex).delete(childNameId);
+  positions2.delete(childId);
+  const childNode = state3.snapshot.nodes[childId];
   if (childNode != null) applyChildAggregateDelta(parentIndex, childId, -childNode.subtreeNodeCount, -childNode.visibleSubtreeCount);
   if (childIndex >= 0) {
     parentIndex.childIds.splice(childIndex, 1);
     updateChildPositionsFrom(parentIndex, childIndex);
-    rebuildVisibleChildChunks(state2.snapshot.nodes, parentIndex);
+    rebuildVisibleChildChunks(state3.snapshot.nodes, parentIndex);
   }
 }
-function compareSiblingNodes(state2, leftId, rightId) {
-  const sortOption = state2.snapshot.options.sort;
-  if (sortOption === "default") return compareSiblingNodesDefault(state2, leftId, rightId);
-  return sortOption(createCompareEntry2(state2, leftId), createCompareEntry2(state2, rightId));
+function compareSiblingNodes(state3, leftId, rightId) {
+  const sortOption = state3.snapshot.options.sort;
+  if (sortOption === "default") return compareSiblingNodesDefault(state3, leftId, rightId);
+  return sortOption(createCompareEntry2(state3, leftId), createCompareEntry2(state3, rightId));
 }
-function compareSiblingNodesDefault(state2, leftId, rightId) {
-  const leftNode = requireNode(state2, leftId);
-  const rightNode = requireNode(state2, rightId);
+function compareSiblingNodesDefault(state3, leftId, rightId) {
+  const leftNode = requireNode(state3, leftId);
+  const rightNode = requireNode(state3, rightId);
   const leftIsDirectory = isDirectoryNode(leftNode);
   if (leftIsDirectory !== isDirectoryNode(rightNode)) return leftIsDirectory ? -1 : 1;
-  const comparison = compareSegmentSortKeys(getSegmentSortKey(state2.snapshot.segmentTable, leftNode.nameId), getSegmentSortKey(state2.snapshot.segmentTable, rightNode.nameId));
+  const comparison = compareSegmentSortKeys(getSegmentSortKey(state3.snapshot.segmentTable, leftNode.nameId), getSegmentSortKey(state3.snapshot.segmentTable, rightNode.nameId));
   if (comparison !== 0) return comparison;
-  const leftName = getSegmentValue(state2.snapshot.segmentTable, leftNode.nameId);
-  const rightName = getSegmentValue(state2.snapshot.segmentTable, rightNode.nameId);
+  const leftName = getSegmentValue(state3.snapshot.segmentTable, leftNode.nameId);
+  const rightName = getSegmentValue(state3.snapshot.segmentTable, rightNode.nameId);
   if (leftName !== rightName) return leftName < rightName ? -1 : 1;
   return leftId < rightId ? -1 : 1;
 }
-function createCompareEntry2(state2, nodeId) {
-  const node = requireNode(state2, nodeId);
-  const path = materializeNodePath(state2, nodeId);
+function createCompareEntry2(state3, nodeId) {
+  const node = requireNode(state3, nodeId);
+  const path = materializeNodePath(state3, nodeId);
   const isDirectory = isDirectoryNode(node);
   const normalizedPath = isDirectory ? path.slice(0, -1) : path;
   return {
-    basename: getSegmentValue(state2.snapshot.segmentTable, node.nameId),
+    basename: getSegmentValue(state3.snapshot.segmentTable, node.nameId),
     depth: getNodeDepth(node),
     isDirectory,
     path,
     segments: normalizedPath.length === 0 ? [] : normalizedPath.split("/")
   };
 }
-function resolveMoveTarget(state2, sourceNodeId, toPath) {
-  const sourceNode = requireNode(state2, sourceNodeId);
-  const existingDestinationId = findNodeId(state2, toPath);
+function resolveMoveTarget(state3, sourceNodeId, toPath) {
+  const sourceNode = requireNode(state3, sourceNodeId);
+  const existingDestinationId = findNodeId(state3, toPath);
   if (existingDestinationId != null) {
-    const existingDestination = requireNode(state2, existingDestinationId);
+    const existingDestination = requireNode(state3, existingDestinationId);
     if (isDirectoryNode(existingDestination)) return {
-      basename: getSegmentValue(state2.snapshot.segmentTable, sourceNode.nameId),
+      basename: getSegmentValue(state3.snapshot.segmentTable, sourceNode.nameId),
       existingNodeId: null,
       parentId: existingDestinationId
     };
@@ -72635,7 +73080,7 @@ function resolveMoveTarget(state2, sourceNodeId, toPath) {
   const destinationLookup = parseLookupPath(toPath);
   const basename3 = destinationLookup.segments[destinationLookup.segments.length - 1] ?? "";
   const parentSegments = destinationLookup.segments.slice(0, -1);
-  const parentId = parentSegments.length === 0 ? state2.snapshot.rootId : findNodeIdBySegments(state2, parentSegments, true);
+  const parentId = parentSegments.length === 0 ? state3.snapshot.rootId : findNodeIdBySegments(state3, parentSegments, true);
   if (parentId == null) throw new Error(`Destination parent does not exist: "${toPath}"`);
   return {
     basename: basename3,
@@ -72643,21 +73088,21 @@ function resolveMoveTarget(state2, sourceNodeId, toPath) {
     parentId
   };
 }
-function handleMoveCollision(state2, collisionNodeId, strategy, sourceKind) {
+function handleMoveCollision(state3, collisionNodeId, strategy, sourceKind) {
   if (strategy === "skip") return "skip";
-  if (strategy === "error") throw new Error(`Destination already exists: "${materializeNodePath(state2, collisionNodeId)}"`);
-  const collisionNode = requireNode(state2, collisionNodeId);
+  if (strategy === "error") throw new Error(`Destination already exists: "${materializeNodePath(state3, collisionNodeId)}"`);
+  const collisionNode = requireNode(state3, collisionNodeId);
   if (getNodeKind(collisionNode) !== sourceKind) throw new Error("replace collision requires the same source and destination kinds");
-  if (isDirectoryNode(collisionNode) && getDirectoryIndex(state2, collisionNodeId).childIds.length > 0) throw new Error("replace collision does not support non-empty directories");
+  if (isDirectoryNode(collisionNode) && getDirectoryIndex(state3, collisionNodeId).childIds.length > 0) throw new Error("replace collision does not support non-empty directories");
   const collisionParentId = collisionNode.parentId;
   const collisionNameId = collisionNode.nameId;
-  removeSubtree(state2, collisionNodeId);
-  removeChildReference(state2, collisionParentId, collisionNodeId, collisionNameId);
-  promoteEmptyAncestorsToExplicit(state2, collisionParentId);
-  recomputeCountsUpwardFrom(state2, collisionParentId);
+  removeSubtree(state3, collisionNodeId);
+  removeChildReference(state3, collisionParentId, collisionNodeId, collisionNameId);
+  promoteEmptyAncestorsToExplicit(state3, collisionParentId);
+  recomputeCountsUpwardFrom(state3, collisionParentId);
   return "handled";
 }
-function removeSubtree(state2, nodeId) {
+function removeSubtree(state3, nodeId) {
   const removedNodeIds = [];
   const stack = [{
     nodeId,
@@ -72666,15 +73111,15 @@ function removeSubtree(state2, nodeId) {
   while (stack.length > 0) {
     const frame = stack.pop();
     if (frame == null) break;
-    const node = requireNode(state2, frame.nodeId);
+    const node = requireNode(state3, frame.nodeId);
     if (frame.visitedChildren || !isDirectoryNode(node)) {
-      if (isDirectoryNode(node)) state2.snapshot.directories.delete(frame.nodeId);
+      if (isDirectoryNode(node)) state3.snapshot.directories.delete(frame.nodeId);
       addNodeFlag(node, 4);
-      state2.pathCacheByNodeId.delete(frame.nodeId);
-      if (state2.collapsedDirectoryIds.delete(frame.nodeId)) state2.hasCollapsedDirectoryOverrides = state2.collapsedDirectoryIds.size > 0;
-      state2.expandedDirectoryIds.delete(frame.nodeId);
-      clearDirectoryLoadInfo(state2, frame.nodeId);
-      state2.activeNodeCount--;
+      state3.pathCacheByNodeId.delete(frame.nodeId);
+      if (state3.collapsedDirectoryIds.delete(frame.nodeId)) state3.hasCollapsedDirectoryOverrides = state3.collapsedDirectoryIds.size > 0;
+      state3.expandedDirectoryIds.delete(frame.nodeId);
+      clearDirectoryLoadInfo(state3, frame.nodeId);
+      state3.activeNodeCount--;
       removedNodeIds.push(frame.nodeId);
       continue;
     }
@@ -72682,7 +73127,7 @@ function removeSubtree(state2, nodeId) {
       nodeId: frame.nodeId,
       visitedChildren: true
     });
-    const directoryIndex = getDirectoryIndex(state2, frame.nodeId);
+    const directoryIndex = getDirectoryIndex(state3, frame.nodeId);
     for (let childIndex = directoryIndex.childIds.length - 1; childIndex >= 0; childIndex--) {
       const childId = directoryIndex.childIds[childIndex];
       if (childId != null) stack.push({
@@ -72693,38 +73138,38 @@ function removeSubtree(state2, nodeId) {
   }
   return removedNodeIds;
 }
-function promoteEmptyAncestorsToExplicit(state2, startDirectoryId) {
+function promoteEmptyAncestorsToExplicit(state3, startDirectoryId) {
   let currentDirectoryId = startDirectoryId;
   while (currentDirectoryId != null) {
-    const currentNode = requireNode(state2, currentDirectoryId);
+    const currentNode = requireNode(state3, currentDirectoryId);
     if (!isDirectoryNode(currentNode) || hasNodeFlag(currentNode, 2)) return;
-    if (getDirectoryIndex(state2, currentDirectoryId).childIds.length > 0) return;
+    if (getDirectoryIndex(state3, currentDirectoryId).childIds.length > 0) return;
     addNodeFlag(currentNode, 1);
     currentDirectoryId = currentNode.parentId === currentDirectoryId ? null : currentNode.parentId;
   }
 }
-function findDeepestExistingDirectoryId(state2, segments) {
-  let currentDirectoryId = state2.snapshot.rootId;
+function findDeepestExistingDirectoryId(state3, segments) {
+  let currentDirectoryId = state3.snapshot.rootId;
   for (const segment2 of segments) {
-    const segmentId = state2.snapshot.segmentTable.idByValue.get(segment2);
+    const segmentId = state3.snapshot.segmentTable.idByValue.get(segment2);
     if (segmentId == null) break;
-    const nextNodeId = ensureChildIdByNameId(state2.snapshot.nodes, getDirectoryIndex(state2, currentDirectoryId)).get(segmentId);
+    const nextNodeId = ensureChildIdByNameId(state3.snapshot.nodes, getDirectoryIndex(state3, currentDirectoryId)).get(segmentId);
     if (nextNodeId == null) break;
-    if (!isDirectoryNode(requireNode(state2, nextNodeId))) break;
+    if (!isDirectoryNode(requireNode(state3, nextNodeId))) break;
     currentDirectoryId = nextNodeId;
   }
   return currentDirectoryId;
 }
-function getCollapsedProjectionSignature(state2, startDirectoryId) {
-  const collapsedAncestorId = findNearestCollapsedAncestor(state2, startDirectoryId);
+function getCollapsedProjectionSignature(state3, startDirectoryId) {
+  const collapsedAncestorId = findNearestCollapsedAncestor(state3, startDirectoryId);
   if (collapsedAncestorId == null) return null;
-  const terminalDirectoryId = getFlattenedTerminalDirectoryId(state2, collapsedAncestorId);
-  const terminalNode = requireNode(state2, terminalDirectoryId);
-  const flattenedSegmentPaths = collapsedAncestorId === terminalDirectoryId ? null : collectFlattenedDirectoryChainIds(state2, collapsedAncestorId).map((nodeId) => materializeNodePath(state2, nodeId));
+  const terminalDirectoryId = getFlattenedTerminalDirectoryId(state3, collapsedAncestorId);
+  const terminalNode = requireNode(state3, terminalDirectoryId);
+  const flattenedSegmentPaths = collapsedAncestorId === terminalDirectoryId ? null : collectFlattenedDirectoryChainIds(state3, collapsedAncestorId).map((nodeId) => materializeNodePath(state3, nodeId));
   return JSON.stringify({
     flattenedSegmentPaths,
-    hasChildren: getDirectoryIndex(state2, terminalDirectoryId).childIds.length > 0,
-    path: materializeNodePath(state2, terminalDirectoryId),
+    hasChildren: getDirectoryIndex(state3, terminalDirectoryId).childIds.length > 0,
+    path: materializeNodePath(state3, terminalDirectoryId),
     terminalKind: getNodeKind(terminalNode)
   });
 }
@@ -72739,67 +73184,67 @@ function didAnyProjectionChange(previousProjectionSignatures, nextProjectionSign
   }
   return false;
 }
-function findNearestCollapsedAncestor(state2, startDirectoryId) {
+function findNearestCollapsedAncestor(state3, startDirectoryId) {
   let currentDirectoryId = startDirectoryId;
   while (currentDirectoryId != null) {
-    const currentNode = requireNode(state2, currentDirectoryId);
+    const currentNode = requireNode(state3, currentDirectoryId);
     if (!isDirectoryNode(currentNode) || hasNodeFlag(currentNode, 2)) return null;
-    if (!isDirectoryExpanded(state2, currentDirectoryId, currentNode)) return currentDirectoryId;
+    if (!isDirectoryExpanded(state3, currentDirectoryId, currentNode)) return currentDirectoryId;
     currentDirectoryId = currentNode.parentId;
   }
   return null;
 }
-function recomputeDepths(state2, nodeId) {
-  const node = requireNode(state2, nodeId);
-  setNodeDepth(node, (nodeId === state2.snapshot.rootId ? -1 : getNodeDepth(requireNode(state2, node.parentId))) + 1);
+function recomputeDepths(state3, nodeId) {
+  const node = requireNode(state3, nodeId);
+  setNodeDepth(node, (nodeId === state3.snapshot.rootId ? -1 : getNodeDepth(requireNode(state3, node.parentId))) + 1);
   if (!isDirectoryNode(node)) return;
-  const directoryIndex = getDirectoryIndex(state2, nodeId);
-  for (const childId of directoryIndex.childIds) recomputeDepths(state2, childId);
+  const directoryIndex = getDirectoryIndex(state3, nodeId);
+  for (const childId of directoryIndex.childIds) recomputeDepths(state3, childId);
 }
-function isAncestor2(state2, ancestorNodeId, nodeId) {
+function isAncestor2(state3, ancestorNodeId, nodeId) {
   let currentNodeId = nodeId;
   while (currentNodeId != null) {
     if (currentNodeId === ancestorNodeId) return true;
-    const currentNode = requireNode(state2, currentNodeId);
-    if (currentNodeId === state2.snapshot.rootId) return false;
+    const currentNode = requireNode(state3, currentNodeId);
+    if (currentNodeId === state3.snapshot.rootId) return false;
     currentNodeId = currentNode.parentId;
   }
   return false;
 }
-function recomputeNodeCounts(state2, nodeId, currentNode = requireNode(state2, nodeId), rebuildChildAggregates = false) {
-  const instrumentation = state2.instrumentation;
+function recomputeNodeCounts(state3, nodeId, currentNode = requireNode(state3, nodeId), rebuildChildAggregates = false) {
+  const instrumentation = state3.instrumentation;
   if (instrumentation == null) {
-    recomputeNodeCountsNow(state2, nodeId, currentNode, rebuildChildAggregates);
+    recomputeNodeCountsNow(state3, nodeId, currentNode, rebuildChildAggregates);
     return;
   }
-  withBenchmarkPhase(instrumentation, "store.recomputeNodeCounts", () => recomputeNodeCountsNow(state2, nodeId, currentNode, rebuildChildAggregates));
+  withBenchmarkPhase(instrumentation, "store.recomputeNodeCounts", () => recomputeNodeCountsNow(state3, nodeId, currentNode, rebuildChildAggregates));
 }
-function recomputeCountsUpwardFromNow(state2, startNodeId) {
+function recomputeCountsUpwardFromNow(state3, startNodeId) {
   let currentNodeId = startNodeId;
   while (currentNodeId != null) {
-    const currentNode = requireNode(state2, currentNodeId);
+    const currentNode = requireNode(state3, currentNodeId);
     const previousSubtreeNodeCount = currentNode.subtreeNodeCount;
     const previousVisibleSubtreeCount = currentNode.visibleSubtreeCount;
-    recomputeNodeCounts(state2, currentNodeId, currentNode);
-    if (currentNodeId === state2.snapshot.rootId) return;
+    recomputeNodeCounts(state3, currentNodeId, currentNode);
+    if (currentNodeId === state3.snapshot.rootId) return;
     const subtreeNodeDelta = currentNode.subtreeNodeCount - previousSubtreeNodeCount;
     const visibleSubtreeDelta = currentNode.visibleSubtreeCount - previousVisibleSubtreeCount;
     const parentId = currentNode.parentId;
-    if (subtreeNodeDelta !== 0 || visibleSubtreeDelta !== 0) applyChildAggregateDelta(getDirectoryIndex(state2, parentId), currentNodeId, subtreeNodeDelta, visibleSubtreeDelta);
+    if (subtreeNodeDelta !== 0 || visibleSubtreeDelta !== 0) applyChildAggregateDelta(getDirectoryIndex(state3, parentId), currentNodeId, subtreeNodeDelta, visibleSubtreeDelta);
     currentNodeId = parentId;
   }
 }
-function recomputeNodeCountsNow(state2, nodeId, currentNode, rebuildChildAggregates) {
+function recomputeNodeCountsNow(state3, nodeId, currentNode, rebuildChildAggregates) {
   if (!isDirectoryNode(currentNode)) {
     currentNode.subtreeNodeCount = 1;
     currentNode.visibleSubtreeCount = 1;
     return;
   }
-  const currentIndex = getDirectoryIndex(state2, nodeId);
+  const currentIndex = getDirectoryIndex(state3, nodeId);
   if (rebuildChildAggregates) {
-    const instrumentation = state2.instrumentation;
-    if (instrumentation == null) rebuildDirectoryChildAggregates(state2.snapshot.nodes, currentIndex);
-    else withBenchmarkPhase(instrumentation, "store.recomputeNodeCounts.rebuildChildAggregates", () => rebuildDirectoryChildAggregates(state2.snapshot.nodes, currentIndex));
+    const instrumentation = state3.instrumentation;
+    if (instrumentation == null) rebuildDirectoryChildAggregates(state3.snapshot.nodes, currentIndex);
+    else withBenchmarkPhase(instrumentation, "store.recomputeNodeCounts.rebuildChildAggregates", () => rebuildDirectoryChildAggregates(state3.snapshot.nodes, currentIndex));
   }
   const subtreeNodeCount = 1 + currentIndex.totalChildSubtreeNodeCount;
   const visibleChildCount = currentIndex.totalChildVisibleSubtreeCount;
@@ -72808,10 +73253,10 @@ function recomputeNodeCountsNow(state2, nodeId, currentNode, rebuildChildAggrega
     currentNode.visibleSubtreeCount = visibleChildCount;
     return;
   }
-  currentNode.visibleSubtreeCount = getFlattenedChildDirectoryId(state2, nodeId) != null ? visibleChildCount : isDirectoryExpanded(state2, nodeId, currentNode) ? 1 + visibleChildCount : 1;
+  currentNode.visibleSubtreeCount = getFlattenedChildDirectoryId(state3, nodeId) != null ? visibleChildCount : isDirectoryExpanded(state3, nodeId, currentNode) ? 1 + visibleChildCount : 1;
 }
-function buildPathPreview(state2, parentId, basename3) {
-  const parentPath = materializeNodePath(state2, parentId);
+function buildPathPreview(state3, parentId, basename3) {
+  const parentPath = materializeNodePath(state3, parentId);
   return parentPath.length === 0 ? basename3 : `${parentPath}${basename3}`;
 }
 
@@ -72819,16 +73264,16 @@ function buildPathPreview(state2, parentId, basename3) {
 function isLiveNode(node) {
   return node != null && !hasNodeFlag(node, 4);
 }
-function isLiveDirectoryNode(state2, nodeId) {
-  const node = state2.snapshot.nodes[nodeId];
+function isLiveDirectoryNode(state3, nodeId) {
+  const node = state3.snapshot.nodes[nodeId];
   if (!isLiveNode(node) || !isDirectoryNode(node) || hasNodeFlag(node, 2)) return null;
   return node;
 }
-function countCachedPathEntries(state2) {
+function countCachedPathEntries(state3) {
   let cachedPathEntryCount = 0;
-  for (const [nodeId, cachedEntry] of state2.pathCacheByNodeId) {
-    if (cachedEntry.version !== state2.pathCacheVersion) continue;
-    if (!isLiveNode(state2.snapshot.nodes[nodeId])) continue;
+  for (const [nodeId, cachedEntry] of state3.pathCacheByNodeId) {
+    if (cachedEntry.version !== state3.pathCacheVersion) continue;
+    if (!isLiveNode(state3.snapshot.nodes[nodeId])) continue;
     cachedPathEntryCount += 1;
   }
   return cachedPathEntryCount;
@@ -72836,13 +73281,13 @@ function countCachedPathEntries(state2) {
 function countSegmentEntries(segmentTable) {
   return Math.max(0, segmentTable.valueById.length - 1);
 }
-function createCleanupMetricSnapshot(state2) {
+function createCleanupMetricSnapshot(state3) {
   return {
-    activeNodeCount: state2.activeNodeCount,
-    cachedPathEntryCount: countCachedPathEntries(state2),
-    loadInfoEntryCount: state2.directoryLoadInfoById.size,
-    segmentCount: countSegmentEntries(state2.snapshot.segmentTable),
-    totalNodeSlotCount: Math.max(0, state2.snapshot.nodes.length - 1)
+    activeNodeCount: state3.activeNodeCount,
+    cachedPathEntryCount: countCachedPathEntries(state3),
+    loadInfoEntryCount: state3.directoryLoadInfoById.size,
+    segmentCount: countSegmentEntries(state3.snapshot.segmentTable),
+    totalNodeSlotCount: Math.max(0, state3.snapshot.nodes.length - 1)
   };
 }
 function createCleanupResult(mode, idsPreserved, before, after) {
@@ -72865,20 +73310,20 @@ function createCleanupResult(mode, idsPreserved, before, after) {
     totalNodeSlotCountBefore: before.totalNodeSlotCount
   };
 }
-function collectExpansionOverridePaths(state2) {
+function collectExpansionOverridePaths(state3) {
   const collapsedPaths = [];
   const expandedPaths = [];
-  for (const nodeId of state2.collapsedDirectoryIds) if (isLiveDirectoryNode(state2, nodeId) != null) collapsedPaths.push(materializeNodePath(state2, nodeId));
-  for (const nodeId of state2.expandedDirectoryIds) if (isLiveDirectoryNode(state2, nodeId) != null) expandedPaths.push(materializeNodePath(state2, nodeId));
+  for (const nodeId of state3.collapsedDirectoryIds) if (isLiveDirectoryNode(state3, nodeId) != null) collapsedPaths.push(materializeNodePath(state3, nodeId));
+  for (const nodeId of state3.expandedDirectoryIds) if (isLiveDirectoryNode(state3, nodeId) != null) expandedPaths.push(materializeNodePath(state3, nodeId));
   return {
     collapsedPaths,
     expandedPaths
   };
 }
-function collectDirectoryLoadInfos(state2) {
+function collectDirectoryLoadInfos(state3) {
   const retainedInfos = [];
-  for (const [nodeId, info] of state2.directoryLoadInfoById) {
-    if (isLiveDirectoryNode(state2, nodeId) == null || getDirectoryLoadState(state2, nodeId) === "loaded") continue;
+  for (const [nodeId, info] of state3.directoryLoadInfoById) {
+    if (isLiveDirectoryNode(state3, nodeId) == null || getDirectoryLoadState(state3, nodeId) === "loaded") continue;
     retainedInfos.push({
       info: {
         activeAttemptId: null,
@@ -72886,33 +73331,33 @@ function collectDirectoryLoadInfos(state2) {
         nextAttemptId: info.nextAttemptId,
         state: info.state
       },
-      path: materializeNodePath(state2, nodeId)
+      path: materializeNodePath(state3, nodeId)
     });
   }
   return retainedInfos;
 }
-function restoreExpansionOverridePaths(state2, persistedExpansionState) {
-  state2.collapsedDirectoryIds.clear();
-  state2.hasCollapsedDirectoryOverrides = false;
-  state2.expandedDirectoryIds.clear();
+function restoreExpansionOverridePaths(state3, persistedExpansionState) {
+  state3.collapsedDirectoryIds.clear();
+  state3.hasCollapsedDirectoryOverrides = false;
+  state3.expandedDirectoryIds.clear();
   for (const path of persistedExpansionState.expandedPaths) {
-    const nodeId = findNodeId(state2, path);
+    const nodeId = findNodeId(state3, path);
     if (nodeId == null) continue;
-    setDirectoryExpanded(state2, nodeId, true, requireNode(state2, nodeId));
+    setDirectoryExpanded(state3, nodeId, true, requireNode(state3, nodeId));
   }
   for (const path of persistedExpansionState.collapsedPaths) {
-    const nodeId = findNodeId(state2, path);
+    const nodeId = findNodeId(state3, path);
     if (nodeId == null) continue;
-    setDirectoryExpanded(state2, nodeId, false, requireNode(state2, nodeId));
+    setDirectoryExpanded(state3, nodeId, false, requireNode(state3, nodeId));
   }
 }
-function restoreDirectoryLoadInfos(state2, persistedLoadInfos) {
-  state2.directoryLoadInfoById.clear();
+function restoreDirectoryLoadInfos(state3, persistedLoadInfos) {
+  state3.directoryLoadInfoById.clear();
   for (const retainedInfo of persistedLoadInfos) {
-    const nodeId = findNodeId(state2, retainedInfo.path);
+    const nodeId = findNodeId(state3, retainedInfo.path);
     if (nodeId == null) continue;
-    if (isLiveDirectoryNode(state2, nodeId) == null) continue;
-    state2.directoryLoadInfoById.set(nodeId, {
+    if (isLiveDirectoryNode(state3, nodeId) == null) continue;
+    state3.directoryLoadInfoById.set(nodeId, {
       activeAttemptId: null,
       errorMessage: retainedInfo.info.errorMessage,
       nextAttemptId: retainedInfo.info.nextAttemptId,
@@ -72920,18 +73365,18 @@ function restoreDirectoryLoadInfos(state2, persistedLoadInfos) {
     });
   }
 }
-function clearPathCaches(state2) {
-  state2.pathCacheVersion += 1;
-  state2.pathCacheByNodeId.clear();
-  state2.pathCacheByNodeId.set(state2.snapshot.rootId, {
+function clearPathCaches(state3) {
+  state3.pathCacheVersion += 1;
+  state3.pathCacheByNodeId.clear();
+  state3.pathCacheByNodeId.set(state3.snapshot.rootId, {
     path: "",
-    version: state2.pathCacheVersion
+    version: state3.pathCacheVersion
   });
 }
-function rebuildSegmentTablePreservingNodeIds(state2) {
-  const previousSegmentTable = state2.snapshot.segmentTable;
+function rebuildSegmentTablePreservingNodeIds(state3) {
+  const previousSegmentTable = state3.snapshot.segmentTable;
   const nextSegmentTable = createSegmentTable();
-  for (const node of state2.snapshot.nodes) {
+  for (const node of state3.snapshot.nodes) {
     if (!isLiveNode(node)) continue;
     if (hasNodeFlag(node, 2)) {
       node.nameId = 0;
@@ -72939,75 +73384,75 @@ function rebuildSegmentTablePreservingNodeIds(state2) {
     }
     node.nameId = internSegment(nextSegmentTable, getSegmentValue(previousSegmentTable, node.nameId));
   }
-  state2.snapshot.segmentTable = nextSegmentTable;
+  state3.snapshot.segmentTable = nextSegmentTable;
 }
-function rebuildDirectoryIndexes(state2) {
-  for (const [directoryId, directoryIndex] of state2.snapshot.directories) {
-    const directoryNode = state2.snapshot.nodes[directoryId];
+function rebuildDirectoryIndexes(state3) {
+  for (const [directoryId, directoryIndex] of state3.snapshot.directories) {
+    const directoryNode = state3.snapshot.nodes[directoryId];
     if (!isLiveNode(directoryNode) || !isDirectoryNode(directoryNode)) {
-      state2.snapshot.directories.delete(directoryId);
+      state3.snapshot.directories.delete(directoryId);
       continue;
     }
     const liveChildIds = directoryIndex.childIds.filter((childId) => {
-      const childNode = state2.snapshot.nodes[childId];
+      const childNode = state3.snapshot.nodes[childId];
       return isLiveNode(childNode) && childNode.parentId === directoryId;
     });
     directoryIndex.childIds = liveChildIds;
-    directoryIndex.childIdByNameId = new Map(liveChildIds.map((childId) => [requireNode(state2, childId).nameId, childId]));
+    directoryIndex.childIdByNameId = new Map(liveChildIds.map((childId) => [requireNode(state3, childId).nameId, childId]));
     directoryIndex.childPositionById = new Map(liveChildIds.map((childId, childIndex) => [childId, childIndex]));
-    rebuildDirectoryChildAggregates(state2.snapshot.nodes, directoryIndex);
+    rebuildDirectoryChildAggregates(state3.snapshot.nodes, directoryIndex);
   }
 }
-function trimTrailingRemovedNodeSlots(state2) {
-  let lastNodeIndex = state2.snapshot.nodes.length - 1;
-  while (lastNodeIndex > state2.snapshot.rootId) {
-    const node = state2.snapshot.nodes[lastNodeIndex];
+function trimTrailingRemovedNodeSlots(state3) {
+  let lastNodeIndex = state3.snapshot.nodes.length - 1;
+  while (lastNodeIndex > state3.snapshot.rootId) {
+    const node = state3.snapshot.nodes[lastNodeIndex];
     if (isLiveNode(node)) break;
     lastNodeIndex -= 1;
   }
-  state2.snapshot.nodes.length = lastNodeIndex + 1;
-}
-function runStableCleanup(state2) {
-  const persistedExpansionState = collectExpansionOverridePaths(state2);
-  const persistedLoadInfos = collectDirectoryLoadInfos(state2);
-  withBenchmarkPhase(state2.instrumentation, "store.cleanup.stable.clearPathCaches", () => clearPathCaches(state2));
-  withBenchmarkPhase(state2.instrumentation, "store.cleanup.stable.rebuildSegmentTable", () => rebuildSegmentTablePreservingNodeIds(state2));
-  withBenchmarkPhase(state2.instrumentation, "store.cleanup.stable.rebuildDirectoryIndexes", () => rebuildDirectoryIndexes(state2));
-  withBenchmarkPhase(state2.instrumentation, "store.cleanup.stable.trimTrailingRemovedNodeSlots", () => trimTrailingRemovedNodeSlots(state2));
-  withBenchmarkPhase(state2.instrumentation, "store.cleanup.stable.restoreExpansionOverrides", () => restoreExpansionOverridePaths(state2, persistedExpansionState));
-  withBenchmarkPhase(state2.instrumentation, "store.cleanup.stable.restoreDirectoryLoadInfos", () => restoreDirectoryLoadInfos(state2, persistedLoadInfos));
-  withBenchmarkPhase(state2.instrumentation, "store.cleanup.stable.recomputeCounts", () => recomputeCountsRecursive(state2, state2.snapshot.rootId));
-}
-function runAggressiveCleanup(state2) {
-  const persistedExpansionState = collectExpansionOverridePaths(state2);
-  const persistedLoadInfos = collectDirectoryLoadInfos(state2);
-  const canonicalPaths = withBenchmarkPhase(state2.instrumentation, "store.cleanup.aggressive.listPaths", () => listPaths(state2));
-  const builderOptions = attachBenchmarkInstrumentation({ ...state2.snapshot.options }, state2.instrumentation);
-  const rebuiltSnapshot = withBenchmarkPhase(state2.instrumentation, "store.cleanup.aggressive.rebuildSnapshot", () => {
+  state3.snapshot.nodes.length = lastNodeIndex + 1;
+}
+function runStableCleanup(state3) {
+  const persistedExpansionState = collectExpansionOverridePaths(state3);
+  const persistedLoadInfos = collectDirectoryLoadInfos(state3);
+  withBenchmarkPhase(state3.instrumentation, "store.cleanup.stable.clearPathCaches", () => clearPathCaches(state3));
+  withBenchmarkPhase(state3.instrumentation, "store.cleanup.stable.rebuildSegmentTable", () => rebuildSegmentTablePreservingNodeIds(state3));
+  withBenchmarkPhase(state3.instrumentation, "store.cleanup.stable.rebuildDirectoryIndexes", () => rebuildDirectoryIndexes(state3));
+  withBenchmarkPhase(state3.instrumentation, "store.cleanup.stable.trimTrailingRemovedNodeSlots", () => trimTrailingRemovedNodeSlots(state3));
+  withBenchmarkPhase(state3.instrumentation, "store.cleanup.stable.restoreExpansionOverrides", () => restoreExpansionOverridePaths(state3, persistedExpansionState));
+  withBenchmarkPhase(state3.instrumentation, "store.cleanup.stable.restoreDirectoryLoadInfos", () => restoreDirectoryLoadInfos(state3, persistedLoadInfos));
+  withBenchmarkPhase(state3.instrumentation, "store.cleanup.stable.recomputeCounts", () => recomputeCountsRecursive(state3, state3.snapshot.rootId));
+}
+function runAggressiveCleanup(state3) {
+  const persistedExpansionState = collectExpansionOverridePaths(state3);
+  const persistedLoadInfos = collectDirectoryLoadInfos(state3);
+  const canonicalPaths = withBenchmarkPhase(state3.instrumentation, "store.cleanup.aggressive.listPaths", () => listPaths(state3));
+  const builderOptions = attachBenchmarkInstrumentation({ ...state3.snapshot.options }, state3.instrumentation);
+  const rebuiltSnapshot = withBenchmarkPhase(state3.instrumentation, "store.cleanup.aggressive.rebuildSnapshot", () => {
     const builder = new PathStoreBuilder(builderOptions);
     builder.appendPaths(canonicalPaths);
     return builder.finish();
   });
-  state2.snapshot = rebuiltSnapshot;
-  state2.activeNodeCount = rebuiltSnapshot.nodes.length - 1;
-  state2.pathCacheByNodeId = /* @__PURE__ */ new Map([[rebuiltSnapshot.rootId, {
+  state3.snapshot = rebuiltSnapshot;
+  state3.activeNodeCount = rebuiltSnapshot.nodes.length - 1;
+  state3.pathCacheByNodeId = /* @__PURE__ */ new Map([[rebuiltSnapshot.rootId, {
     path: "",
     version: 0
   }]]);
-  state2.pathCacheVersion = 0;
-  withBenchmarkPhase(state2.instrumentation, "store.cleanup.aggressive.restoreExpansionOverrides", () => restoreExpansionOverridePaths(state2, persistedExpansionState));
-  withBenchmarkPhase(state2.instrumentation, "store.cleanup.aggressive.restoreDirectoryLoadInfos", () => restoreDirectoryLoadInfos(state2, persistedLoadInfos));
-  withBenchmarkPhase(state2.instrumentation, "store.cleanup.aggressive.recomputeCounts", () => recomputeCountsRecursive(state2, state2.snapshot.rootId));
+  state3.pathCacheVersion = 0;
+  withBenchmarkPhase(state3.instrumentation, "store.cleanup.aggressive.restoreExpansionOverrides", () => restoreExpansionOverridePaths(state3, persistedExpansionState));
+  withBenchmarkPhase(state3.instrumentation, "store.cleanup.aggressive.restoreDirectoryLoadInfos", () => restoreDirectoryLoadInfos(state3, persistedLoadInfos));
+  withBenchmarkPhase(state3.instrumentation, "store.cleanup.aggressive.recomputeCounts", () => recomputeCountsRecursive(state3, state3.snapshot.rootId));
 }
-function hasActiveCleanupBlockingLoads(state2) {
-  for (const loadInfo of state2.directoryLoadInfoById.values()) if (loadInfo.state === "loading" && loadInfo.activeAttemptId != null) return true;
+function hasActiveCleanupBlockingLoads(state3) {
+  for (const loadInfo of state3.directoryLoadInfoById.values()) if (loadInfo.state === "loading" && loadInfo.activeAttemptId != null) return true;
   return false;
 }
-function cleanupPathStoreState(state2, mode) {
-  const before = createCleanupMetricSnapshot(state2);
-  if (mode === "stable") withBenchmarkPhase(state2.instrumentation, "store.cleanup.stable", () => runStableCleanup(state2));
-  else withBenchmarkPhase(state2.instrumentation, "store.cleanup.aggressive", () => runAggressiveCleanup(state2));
-  const after = createCleanupMetricSnapshot(state2);
+function cleanupPathStoreState(state3, mode) {
+  const before = createCleanupMetricSnapshot(state3);
+  if (mode === "stable") withBenchmarkPhase(state3.instrumentation, "store.cleanup.stable", () => runStableCleanup(state3));
+  else withBenchmarkPhase(state3.instrumentation, "store.cleanup.aggressive", () => runAggressiveCleanup(state3));
+  const after = createCleanupMetricSnapshot(state3);
   return createCleanupResult(mode, mode === "stable", before, after);
 }
 
@@ -73023,33 +73468,33 @@ function ensureProjectionDepthCapacity(depthTable, depth) {
   nextDepthTable.set(depthTable);
   return nextDepthTable;
 }
-function getVisibleCount(state2) {
-  return requireNode(state2, state2.snapshot.rootId).visibleSubtreeCount;
+function getVisibleCount(state3) {
+  return requireNode(state3, state3.snapshot.rootId).visibleSubtreeCount;
 }
-function getVisibleRowSubtreeEndIndex(state2, cursor, index, totalVisibleCount) {
-  const terminalNode = requireNode(state2, cursor.terminalNodeId);
+function getVisibleRowSubtreeEndIndex(state3, cursor, index, totalVisibleCount) {
+  const terminalNode = requireNode(state3, cursor.terminalNodeId);
   const subtreeSize = Math.max(1, terminalNode.visibleSubtreeCount);
   return Math.min(totalVisibleCount - 1, index + subtreeSize - 1);
 }
-function materializeVisibleAncestorRow(state2, entry, totalVisibleCount, ancestorPaths) {
+function materializeVisibleAncestorRow(state3, entry, totalVisibleCount, ancestorPaths) {
   return {
     ancestorPaths,
     index: entry.index,
     posInSet: entry.posInSet,
-    row: materializeVisibleRow(state2, entry.cursor),
+    row: materializeVisibleRow(state3, entry.cursor),
     setSize: entry.setSize,
-    subtreeEndIndex: getVisibleRowSubtreeEndIndex(state2, entry.cursor, entry.index, totalVisibleCount)
+    subtreeEndIndex: getVisibleRowSubtreeEndIndex(state3, entry.cursor, entry.index, totalVisibleCount)
   };
 }
-function selectVisibleRowContextWithinDirectory(state2, directoryNodeId, index, directoryStartIndex, parentVisibleDepth, ancestors2) {
-  const directoryIndex = getDirectoryIndex(state2, directoryNodeId);
-  const { childIndex, childVisibleIndex, localVisibleIndex } = selectChildIndexByVisibleIndex(state2.snapshot.nodes, directoryIndex, index);
+function selectVisibleRowContextWithinDirectory(state3, directoryNodeId, index, directoryStartIndex, parentVisibleDepth, ancestors2) {
+  const directoryIndex = getDirectoryIndex(state3, directoryNodeId);
+  const { childIndex, childVisibleIndex, localVisibleIndex } = selectChildIndexByVisibleIndex(state3.snapshot.nodes, directoryIndex, index);
   const childId = directoryIndex.childIds[childIndex];
   if (childId == null) throw new Error(`Visible index ${String(index)} is out of range`);
-  return selectVisibleRowContextWithinSubtree(state2, childId, localVisibleIndex, directoryStartIndex + childVisibleIndex, parentVisibleDepth + 1, childIndex, directoryIndex.childIds.length, ancestors2);
+  return selectVisibleRowContextWithinSubtree(state3, childId, localVisibleIndex, directoryStartIndex + childVisibleIndex, parentVisibleDepth + 1, childIndex, directoryIndex.childIds.length, ancestors2);
 }
-function selectVisibleRowContextWithinSubtree(state2, nodeId, index, rowIndex, visibleDepth, posInSet, setSize, ancestors2) {
-  if (!isDirectoryNode(requireNode(state2, nodeId))) {
+function selectVisibleRowContextWithinSubtree(state3, nodeId, index, rowIndex, visibleDepth, posInSet, setSize, ancestors2) {
+  if (!isDirectoryNode(requireNode(state3, nodeId))) {
     if (index === 0) return {
       ancestors: ancestors2,
       cursor: {
@@ -73063,7 +73508,7 @@ function selectVisibleRowContextWithinSubtree(state2, nodeId, index, rowIndex, v
     };
     throw new Error(`Visible index ${String(index)} is out of range for file`);
   }
-  const currentCursor = createVisibleRowCursor(state2, nodeId, visibleDepth);
+  const currentCursor = createVisibleRowCursor(state3, nodeId, visibleDepth);
   if (index === 0) return {
     ancestors: ancestors2,
     cursor: currentCursor,
@@ -73071,20 +73516,20 @@ function selectVisibleRowContextWithinSubtree(state2, nodeId, index, rowIndex, v
     posInSet,
     setSize
   };
-  const terminalNode = requireNode(state2, currentCursor.terminalNodeId);
-  if (!isDirectoryNode(terminalNode) || !isDirectoryExpanded(state2, currentCursor.terminalNodeId, terminalNode)) throw new Error(`Visible index ${String(index)} is out of range for collapsed directory`);
-  return selectVisibleRowContextWithinDirectory(state2, currentCursor.terminalNodeId, index - 1, rowIndex + 1, currentCursor.visibleDepth, [...ancestors2, {
+  const terminalNode = requireNode(state3, currentCursor.terminalNodeId);
+  if (!isDirectoryNode(terminalNode) || !isDirectoryExpanded(state3, currentCursor.terminalNodeId, terminalNode)) throw new Error(`Visible index ${String(index)} is out of range for collapsed directory`);
+  return selectVisibleRowContextWithinDirectory(state3, currentCursor.terminalNodeId, index - 1, rowIndex + 1, currentCursor.visibleDepth, [...ancestors2, {
     cursor: currentCursor,
     index: rowIndex,
     posInSet,
     setSize
   }]);
 }
-function getVisibleRowContext(state2, index) {
-  const totalVisibleCount = getVisibleCount(state2);
+function getVisibleRowContext(state3, index) {
+  const totalVisibleCount = getVisibleCount(state3);
   if (index < 0 || index >= totalVisibleCount) return null;
-  const selected = selectVisibleRowContextWithinDirectory(state2, state2.snapshot.rootId, index, 0, -1, []);
-  const ancestorPaths = selected.ancestors.map((ancestor) => materializeNodePath(state2, ancestor.cursor.terminalNodeId));
+  const selected = selectVisibleRowContextWithinDirectory(state3, state3.snapshot.rootId, index, 0, -1, []);
+  const ancestorPaths = selected.ancestors.map((ancestor) => materializeNodePath(state3, ancestor.cursor.terminalNodeId));
   let cachedAncestorRows = null;
   return {
     ancestorPaths,
@@ -73093,7 +73538,7 @@ function getVisibleRowContext(state2, index) {
       const ancestorRows = [];
       const rowAncestorPaths = [];
       for (const ancestor of selected.ancestors) {
-        const ancestorRow = materializeVisibleAncestorRow(state2, ancestor, totalVisibleCount, [...rowAncestorPaths]);
+        const ancestorRow = materializeVisibleAncestorRow(state3, ancestor, totalVisibleCount, [...rowAncestorPaths]);
         ancestorRows.push(ancestorRow);
         rowAncestorPaths.push(ancestorRow.row.path);
       }
@@ -73102,121 +73547,121 @@ function getVisibleRowContext(state2, index) {
     },
     index: selected.index,
     posInSet: selected.posInSet,
-    row: materializeVisibleRow(state2, selected.cursor),
+    row: materializeVisibleRow(state3, selected.cursor),
     setSize: selected.setSize,
-    subtreeEndIndex: getVisibleRowSubtreeEndIndex(state2, selected.cursor, selected.index, totalVisibleCount)
+    subtreeEndIndex: getVisibleRowSubtreeEndIndex(state3, selected.cursor, selected.index, totalVisibleCount)
   };
 }
-function getVisibleSlice(state2, start, end) {
-  const instrumentation = state2.instrumentation;
-  const totalVisibleCount = getVisibleCount(state2);
+function getVisibleSlice(state3, start, end) {
+  const instrumentation = state3.instrumentation;
+  const totalVisibleCount = getVisibleCount(state3);
   if (totalVisibleCount <= 0 || end < start) return [];
   const normalizedStart = Math.max(0, Math.min(start, totalVisibleCount - 1));
   const normalizedEnd = Math.max(normalizedStart, Math.min(end, totalVisibleCount - 1));
   if (instrumentation == null) {
-    if (normalizedStart === 0) return collectVisibleRowsDFS(state2, normalizedEnd + 1);
+    if (normalizedStart === 0) return collectVisibleRowsDFS(state3, normalizedEnd + 1);
     const rows2 = [];
-    let currentCursor2 = selectVisibleRow(state2, normalizedStart);
+    let currentCursor2 = selectVisibleRow(state3, normalizedStart);
     for (let visibleIndex = normalizedStart; visibleIndex <= normalizedEnd && currentCursor2 != null; visibleIndex++) {
-      const row = materializeVisibleRow(state2, currentCursor2);
+      const row = materializeVisibleRow(state3, currentCursor2);
       rows2.push(row);
-      currentCursor2 = getNextVisibleRowCursor(state2, currentCursor2);
+      currentCursor2 = getNextVisibleRowCursor(state3, currentCursor2);
     }
     return rows2;
   }
   const rows = [];
   let flattenedRowCount = 0;
   let flattenedSegmentCount = 0;
-  let currentCursor = withBenchmarkPhase(instrumentation, "store.getVisibleSlice.selectFirstRow", () => selectVisibleRow(state2, normalizedStart));
+  let currentCursor = withBenchmarkPhase(instrumentation, "store.getVisibleSlice.selectFirstRow", () => selectVisibleRow(state3, normalizedStart));
   for (let visibleIndex = normalizedStart; visibleIndex <= normalizedEnd && currentCursor != null; visibleIndex++) {
-    const row = withBenchmarkPhase(instrumentation, "store.getVisibleSlice.materializeRow", () => materializeVisibleRow(state2, currentCursor));
+    const row = withBenchmarkPhase(instrumentation, "store.getVisibleSlice.materializeRow", () => materializeVisibleRow(state3, currentCursor));
     rows.push(row);
     if (row.isFlattened) {
       flattenedRowCount++;
       flattenedSegmentCount += row.flattenedSegments?.length ?? 0;
     }
-    currentCursor = withBenchmarkPhase(instrumentation, "store.getVisibleSlice.advanceCursor", () => getNextVisibleRowCursor(state2, currentCursor));
+    currentCursor = withBenchmarkPhase(instrumentation, "store.getVisibleSlice.advanceCursor", () => getNextVisibleRowCursor(state3, currentCursor));
   }
   setBenchmarkCounter(instrumentation, "workload.visibleRowsRead", rows.length);
   setBenchmarkCounter(instrumentation, "workload.flattenedRowsRead", flattenedRowCount);
   setBenchmarkCounter(instrumentation, "workload.flattenedSegmentsRead", flattenedSegmentCount);
   return rows;
 }
-function getVisibleTreeProjectionData(state2, maxRows = getVisibleCount(state2)) {
-  const instrumentation = state2.instrumentation;
-  if (instrumentation == null) return buildVisibleTreeProjectionDataDFS(state2, maxRows);
-  return withBenchmarkPhase(instrumentation, "store.getVisibleTreeProjection", () => buildVisibleTreeProjectionDataDFS(state2, maxRows));
+function getVisibleTreeProjectionData(state3, maxRows = getVisibleCount(state3)) {
+  const instrumentation = state3.instrumentation;
+  if (instrumentation == null) return buildVisibleTreeProjectionDataDFS(state3, maxRows);
+  return withBenchmarkPhase(instrumentation, "store.getVisibleTreeProjection", () => buildVisibleTreeProjectionDataDFS(state3, maxRows));
 }
-function getVisibleTreeProjection(state2) {
-  return createVisibleTreeProjectionFromData(getVisibleTreeProjectionData(state2));
+function getVisibleTreeProjection(state3) {
+  return createVisibleTreeProjectionFromData(getVisibleTreeProjectionData(state3));
 }
-function getVisibleIndexByPath(state2, path) {
-  const nodeId = findNodeId(state2, path);
-  if (nodeId == null || nodeId === state2.snapshot.rootId) return null;
-  if (isDirectoryNode(requireNode(state2, nodeId)) && getFlattenedTerminalDirectoryId(state2, nodeId) !== nodeId) return null;
+function getVisibleIndexByPath(state3, path) {
+  const nodeId = findNodeId(state3, path);
+  if (nodeId == null || nodeId === state3.snapshot.rootId) return null;
+  if (isDirectoryNode(requireNode(state3, nodeId)) && getFlattenedTerminalDirectoryId(state3, nodeId) !== nodeId) return null;
   let visibleIndex = 0;
   let currentNodeId = nodeId;
-  const { nodes, rootId } = state2.snapshot;
+  const { nodes, rootId } = state3.snapshot;
   while (currentNodeId !== rootId) {
-    const parentId = requireNode(state2, currentNodeId).parentId;
-    const parentIndex = getDirectoryIndex(state2, parentId);
+    const parentId = requireNode(state3, currentNodeId).parentId;
+    const parentIndex = getDirectoryIndex(state3, parentId);
     const childPosition = ensureChildPositions(parentIndex).get(currentNodeId);
     if (childPosition == null) throw new Error(`Child ${String(currentNodeId)} was not found in its parent index`);
     visibleIndex += getVisibleChildPrefixCount(nodes, parentIndex, childPosition);
     if (parentId !== rootId) {
-      const parentNode = requireNode(state2, parentId);
-      const flattenedChildDirectoryId = getFlattenedChildDirectoryId(state2, parentId);
-      if (!isDirectoryExpanded(state2, parentId, parentNode) && flattenedChildDirectoryId !== currentNodeId) return null;
-      if (getFlattenedTerminalDirectoryId(state2, parentId) === parentId) visibleIndex += 1;
+      const parentNode = requireNode(state3, parentId);
+      const flattenedChildDirectoryId = getFlattenedChildDirectoryId(state3, parentId);
+      if (!isDirectoryExpanded(state3, parentId, parentNode) && flattenedChildDirectoryId !== currentNodeId) return null;
+      if (getFlattenedTerminalDirectoryId(state3, parentId) === parentId) visibleIndex += 1;
     }
     currentNodeId = parentId;
   }
   return visibleIndex;
 }
-function expandPath(state2, path) {
-  const directoryNodeId = findNodeId(state2, path);
+function expandPath(state3, path) {
+  const directoryNodeId = findNodeId(state3, path);
   if (directoryNodeId == null) throw new Error(`Path does not exist: "${path}"`);
-  const directoryNode = requireNode(state2, directoryNodeId);
+  const directoryNode = requireNode(state3, directoryNodeId);
   if (!isDirectoryNode(directoryNode)) throw new Error(`Path is not a directory: "${path}"`);
-  if (isDirectoryExpanded(state2, directoryNodeId, directoryNode)) return null;
-  setDirectoryExpanded(state2, directoryNodeId, true, directoryNode);
-  recomputeCountsUpwardFrom(state2, directoryNodeId);
+  if (isDirectoryExpanded(state3, directoryNodeId, directoryNode)) return null;
+  setDirectoryExpanded(state3, directoryNodeId, true, directoryNode);
+  recomputeCountsUpwardFrom(state3, directoryNodeId);
   return createExpandEvent({
-    affectedAncestorIds: collectAncestorIds(state2, directoryNodeId),
+    affectedAncestorIds: collectAncestorIds(state3, directoryNodeId),
     affectedNodeIds: [directoryNodeId],
     path,
     projectionChanged: true
   });
 }
-function collapsePath(state2, path) {
-  const directoryNodeId = findNodeId(state2, path);
+function collapsePath(state3, path) {
+  const directoryNodeId = findNodeId(state3, path);
   if (directoryNodeId == null) throw new Error(`Path does not exist: "${path}"`);
-  const directoryNode = requireNode(state2, directoryNodeId);
+  const directoryNode = requireNode(state3, directoryNodeId);
   if (!isDirectoryNode(directoryNode)) throw new Error(`Path is not a directory: "${path}"`);
-  if (!isDirectoryExpanded(state2, directoryNodeId, directoryNode)) return null;
-  setDirectoryExpanded(state2, directoryNodeId, false, directoryNode);
-  recomputeCountsUpwardFrom(state2, directoryNodeId);
+  if (!isDirectoryExpanded(state3, directoryNodeId, directoryNode)) return null;
+  setDirectoryExpanded(state3, directoryNodeId, false, directoryNode);
+  recomputeCountsUpwardFrom(state3, directoryNodeId);
   return createCollapseEvent({
-    affectedAncestorIds: collectAncestorIds(state2, directoryNodeId),
+    affectedAncestorIds: collectAncestorIds(state3, directoryNodeId),
     affectedNodeIds: [directoryNodeId],
     path,
     projectionChanged: true
   });
 }
-function selectVisibleRow(state2, index) {
-  if (index < 0 || index >= getVisibleCount(state2)) return null;
-  return selectVisibleRowWithinDirectory(state2, state2.snapshot.rootId, index, -1);
+function selectVisibleRow(state3, index) {
+  if (index < 0 || index >= getVisibleCount(state3)) return null;
+  return selectVisibleRowWithinDirectory(state3, state3.snapshot.rootId, index, -1);
 }
-function selectVisibleRowWithinDirectory(state2, directoryNodeId, index, parentVisibleDepth) {
-  const directoryIndex = getDirectoryIndex(state2, directoryNodeId);
-  const instrumentation = state2.instrumentation;
-  const { childIndex, localVisibleIndex } = instrumentation == null ? selectChildIndexByVisibleIndex(state2.snapshot.nodes, directoryIndex, index) : withBenchmarkPhase(instrumentation, "store.getVisibleSlice.selectChildIndex", () => selectChildIndexByVisibleIndex(state2.snapshot.nodes, directoryIndex, index));
+function selectVisibleRowWithinDirectory(state3, directoryNodeId, index, parentVisibleDepth) {
+  const directoryIndex = getDirectoryIndex(state3, directoryNodeId);
+  const instrumentation = state3.instrumentation;
+  const { childIndex, localVisibleIndex } = instrumentation == null ? selectChildIndexByVisibleIndex(state3.snapshot.nodes, directoryIndex, index) : withBenchmarkPhase(instrumentation, "store.getVisibleSlice.selectChildIndex", () => selectChildIndexByVisibleIndex(state3.snapshot.nodes, directoryIndex, index));
   const childId = directoryIndex.childIds[childIndex];
-  if (childId != null) return selectVisibleRowWithinSubtree(state2, childId, localVisibleIndex, parentVisibleDepth + 1);
+  if (childId != null) return selectVisibleRowWithinSubtree(state3, childId, localVisibleIndex, parentVisibleDepth + 1);
   throw new Error(`Visible index ${String(index)} is out of range`);
 }
-function selectVisibleRowWithinSubtree(state2, nodeId, index, visibleDepth) {
-  if (!isDirectoryNode(requireNode(state2, nodeId))) {
+function selectVisibleRowWithinSubtree(state3, nodeId, index, visibleDepth) {
+  if (!isDirectoryNode(requireNode(state3, nodeId))) {
     if (index === 0) return {
       headNodeId: nodeId,
       terminalNodeId: nodeId,
@@ -73224,57 +73669,57 @@ function selectVisibleRowWithinSubtree(state2, nodeId, index, visibleDepth) {
     };
     throw new Error(`Visible index ${String(index)} is out of range for file`);
   }
-  const currentCursor = createVisibleRowCursor(state2, nodeId, visibleDepth);
+  const currentCursor = createVisibleRowCursor(state3, nodeId, visibleDepth);
   if (index === 0) return currentCursor;
-  const terminalNode = requireNode(state2, currentCursor.terminalNodeId);
-  if (!isDirectoryNode(terminalNode) || !isDirectoryExpanded(state2, currentCursor.terminalNodeId, terminalNode)) throw new Error(`Visible index ${String(index)} is out of range for collapsed directory`);
-  return selectVisibleRowWithinDirectory(state2, currentCursor.terminalNodeId, index - 1, currentCursor.visibleDepth);
+  const terminalNode = requireNode(state3, currentCursor.terminalNodeId);
+  if (!isDirectoryNode(terminalNode) || !isDirectoryExpanded(state3, currentCursor.terminalNodeId, terminalNode)) throw new Error(`Visible index ${String(index)} is out of range for collapsed directory`);
+  return selectVisibleRowWithinDirectory(state3, currentCursor.terminalNodeId, index - 1, currentCursor.visibleDepth);
 }
-function createVisibleRowCursor(state2, nodeId, visibleDepth) {
-  if (!isDirectoryNode(requireNode(state2, nodeId))) return {
+function createVisibleRowCursor(state3, nodeId, visibleDepth) {
+  if (!isDirectoryNode(requireNode(state3, nodeId))) return {
     headNodeId: nodeId,
     terminalNodeId: nodeId,
     visibleDepth
   };
-  if (state2.instrumentation == null) return {
+  if (state3.instrumentation == null) return {
     headNodeId: nodeId,
-    terminalNodeId: getFlattenedTerminalDirectoryId(state2, nodeId),
+    terminalNodeId: getFlattenedTerminalDirectoryId(state3, nodeId),
     visibleDepth
   };
   return {
     headNodeId: nodeId,
-    terminalNodeId: withBenchmarkPhase(state2.instrumentation, "store.getVisibleSlice.flatten.resolveTerminalDirectory", () => getFlattenedTerminalDirectoryId(state2, nodeId)),
+    terminalNodeId: withBenchmarkPhase(state3.instrumentation, "store.getVisibleSlice.flatten.resolveTerminalDirectory", () => getFlattenedTerminalDirectoryId(state3, nodeId)),
     visibleDepth
   };
 }
-function isVisibleRowHeadNode(state2, nodeId) {
-  const node = requireNode(state2, nodeId);
+function isVisibleRowHeadNode(state3, nodeId) {
+  const node = requireNode(state3, nodeId);
   if (!isDirectoryNode(node)) return true;
   const parentId = node.parentId;
-  if (parentId === state2.snapshot.rootId) return true;
-  return getFlattenedChildDirectoryId(state2, parentId) !== nodeId;
+  if (parentId === state3.snapshot.rootId) return true;
+  return getFlattenedChildDirectoryId(state3, parentId) !== nodeId;
 }
-function getNextVisibleRowCursor(state2, currentCursor) {
-  const terminalNode = requireNode(state2, currentCursor.terminalNodeId);
+function getNextVisibleRowCursor(state3, currentCursor) {
+  const terminalNode = requireNode(state3, currentCursor.terminalNodeId);
   if (isDirectoryNode(terminalNode)) {
-    const currentIndex = getDirectoryIndex(state2, currentCursor.terminalNodeId);
-    if (isDirectoryExpanded(state2, currentCursor.terminalNodeId, terminalNode) && currentIndex.childIds.length > 0) {
+    const currentIndex = getDirectoryIndex(state3, currentCursor.terminalNodeId);
+    if (isDirectoryExpanded(state3, currentCursor.terminalNodeId, terminalNode) && currentIndex.childIds.length > 0) {
       const firstChildId = currentIndex.childIds[0];
-      return firstChildId == null ? null : selectVisibleRowWithinSubtree(state2, firstChildId, 0, currentCursor.visibleDepth + 1);
+      return firstChildId == null ? null : selectVisibleRowWithinSubtree(state3, firstChildId, 0, currentCursor.visibleDepth + 1);
     }
   }
   let currentNodeId = currentCursor.terminalNodeId;
   let currentVisibleDepth = currentCursor.visibleDepth;
   while (true) {
-    const currentNode = requireNode(state2, currentNodeId);
-    if (currentNodeId === state2.snapshot.rootId) return null;
+    const currentNode = requireNode(state3, currentNodeId);
+    if (currentNodeId === state3.snapshot.rootId) return null;
     const parentId = currentNode.parentId;
-    const parentIndex = getDirectoryIndex(state2, parentId);
+    const parentIndex = getDirectoryIndex(state3, parentId);
     const siblingIndex = ensureChildPositions(parentIndex).get(currentNodeId) ?? -1;
     if (siblingIndex < 0) throw new Error(`Child ${String(currentNodeId)} was not found in its parent index`);
     const nextSiblingId = parentIndex.childIds[siblingIndex + 1] ?? null;
-    if (nextSiblingId != null) return selectVisibleRowWithinSubtree(state2, nextSiblingId, 0, currentVisibleDepth);
-    if (isVisibleRowHeadNode(state2, currentNodeId)) currentVisibleDepth--;
+    if (nextSiblingId != null) return selectVisibleRowWithinSubtree(state3, nextSiblingId, 0, currentVisibleDepth);
+    if (isVisibleRowHeadNode(state3, currentNodeId)) currentVisibleDepth--;
     currentNodeId = parentId;
   }
 }
@@ -73299,7 +73744,7 @@ function createVisibleTreeProjectionFromData(projection) {
     }
   };
 }
-function buildVisibleTreeProjectionDataDFS(state2, maxRows) {
+function buildVisibleTreeProjectionDataDFS(state3, maxRows) {
   const paths = new Array(maxRows);
   const parentRowIndex = new Int32Array(maxRows);
   const posInSetByIndex = new Int32Array(maxRows);
@@ -73307,16 +73752,16 @@ function buildVisibleTreeProjectionDataDFS(state2, maxRows) {
   let lastRowAtDepth = new Int32Array(INITIAL_PROJECTION_DEPTH_CAPACITY);
   lastRowAtDepth.fill(-1);
   let rowCount = 0;
-  const { nodes, directories, segmentTable } = state2.snapshot;
+  const { nodes, directories, segmentTable } = state3.snapshot;
   const stack = [[
-    directories.get(state2.snapshot.rootId),
+    directories.get(state3.snapshot.rootId),
     0,
     -1,
     ""
   ]];
-  const flattenEnabled = state2.snapshot.options.flattenEmptyDirectories;
-  const pathCacheByNodeId = state2.pathCacheByNodeId;
-  const pathCacheVersion = state2.pathCacheVersion;
+  const flattenEnabled = state3.snapshot.options.flattenEmptyDirectories;
+  const pathCacheByNodeId = state3.pathCacheByNodeId;
+  const pathCacheVersion = state3.pathCacheVersion;
   const segmentValues = segmentTable.valueById;
   while (stack.length > 0 && rowCount < maxRows) {
     const frame = stack[stack.length - 1];
@@ -73337,8 +73782,8 @@ function buildVisibleTreeProjectionDataDFS(state2, maxRows) {
       const cachedPathEntry = pathCacheByNodeId.get(childId);
       path = cachedPathEntry != null && cachedPathEntry.version === pathCacheVersion ? cachedPathEntry.path : `${parentPath}${segmentValues[childNode.nameId]}`;
     } else {
-      terminalNodeId = flattenEnabled ? getFlattenedTerminalDirectoryId(state2, childId) : childId;
-      path = terminalNodeId === childId ? `${parentPath}${segmentValues[childNode.nameId]}/` : materializeNodePath(state2, terminalNodeId);
+      terminalNodeId = flattenEnabled ? getFlattenedTerminalDirectoryId(state3, childId) : childId;
+      path = terminalNodeId === childId ? `${parentPath}${segmentValues[childNode.nameId]}/` : materializeNodePath(state3, terminalNodeId);
     }
     parentRowIndex[rowCount] = lastRowAtDepth[visibleDepth];
     paths[rowCount] = path;
@@ -73347,7 +73792,7 @@ function buildVisibleTreeProjectionDataDFS(state2, maxRows) {
     lastRowAtDepth[visibleDepth + 1] = rowCount;
     rowCount += 1;
     const terminalNode = nodes[terminalNodeId];
-    if (terminalNode != null && isDirectoryNode(terminalNode) && isDirectoryExpanded(state2, terminalNodeId, terminalNode)) stack.push([
+    if (terminalNode != null && isDirectoryNode(terminalNode) && isDirectoryExpanded(state3, terminalNodeId, terminalNode)) stack.push([
       directories.get(terminalNodeId),
       0,
       visibleDepth,
@@ -73375,19 +73820,19 @@ function buildVisibleTreeProjectionDataDFS(state2, maxRows) {
     }
   };
 }
-function collectVisibleRowsDFS(state2, maxRows) {
+function collectVisibleRowsDFS(state3, maxRows) {
   const rows = new Array(maxRows);
   let rowCount = 0;
-  const { nodes, directories, segmentTable } = state2.snapshot;
+  const { nodes, directories, segmentTable } = state3.snapshot;
   const stack = [[
-    directories.get(state2.snapshot.rootId),
+    directories.get(state3.snapshot.rootId),
     0,
     -1
   ]];
   const segmentValues = segmentTable.valueById;
-  const flattenEnabled = state2.snapshot.options.flattenEmptyDirectories;
-  const pathCacheByNodeId = state2.pathCacheByNodeId;
-  const pathCacheVersion = state2.pathCacheVersion;
+  const flattenEnabled = state3.snapshot.options.flattenEmptyDirectories;
+  const pathCacheByNodeId = state3.pathCacheByNodeId;
+  const pathCacheVersion = state3.pathCacheVersion;
   while (stack.length > 0 && rowCount < maxRows) {
     const frame = stack[stack.length - 1];
     const dirIndex = frame[0];
@@ -73411,19 +73856,19 @@ function collectVisibleRowsDFS(state2, maxRows) {
         kind: "file",
         loadState: void 0,
         name: segmentValues[childNode.nameId],
-        path: cachedPathEntry != null && cachedPathEntry.version === pathCacheVersion ? cachedPathEntry.path : materializeNodePath(state2, childId)
+        path: cachedPathEntry != null && cachedPathEntry.version === pathCacheVersion ? cachedPathEntry.path : materializeNodePath(state3, childId)
       };
       continue;
     }
-    const terminalNodeId = flattenEnabled ? getFlattenedTerminalDirectoryId(state2, childId) : childId;
+    const terminalNodeId = flattenEnabled ? getFlattenedTerminalDirectoryId(state3, childId) : childId;
     const cursor = {
       headNodeId: childId,
       terminalNodeId,
       visibleDepth
     };
-    rows[rowCount++] = materializeVisibleRow(state2, cursor);
+    rows[rowCount++] = materializeVisibleRow(state3, cursor);
     const terminalNode = nodes[terminalNodeId];
-    if (terminalNode != null && isDirectoryNode(terminalNode) && isDirectoryExpanded(state2, terminalNodeId, terminalNode)) stack.push([
+    if (terminalNode != null && isDirectoryNode(terminalNode) && isDirectoryExpanded(state3, terminalNodeId, terminalNode)) stack.push([
       directories.get(terminalNodeId),
       0,
       visibleDepth
@@ -73432,29 +73877,29 @@ function collectVisibleRowsDFS(state2, maxRows) {
   if (rowCount < maxRows) rows.length = rowCount;
   return rows;
 }
-function materializeVisibleRow(state2, cursor) {
-  const terminalNode = requireNode(state2, cursor.terminalNodeId);
-  const loadState = isDirectoryNode(terminalNode) ? getVisibleRowLoadState(state2, cursor) : null;
-  const path = materializeNodePath(state2, cursor.terminalNodeId);
-  const name = getSegmentValue(state2.snapshot.segmentTable, terminalNode.nameId);
-  const hasChildren = isDirectoryNode(terminalNode) && getDirectoryIndex(state2, cursor.terminalNodeId).childIds.length > 0;
+function materializeVisibleRow(state3, cursor) {
+  const terminalNode = requireNode(state3, cursor.terminalNodeId);
+  const loadState = isDirectoryNode(terminalNode) ? getVisibleRowLoadState(state3, cursor) : null;
+  const path = materializeNodePath(state3, cursor.terminalNodeId);
+  const name = getSegmentValue(state3.snapshot.segmentTable, terminalNode.nameId);
+  const hasChildren = isDirectoryNode(terminalNode) && getDirectoryIndex(state3, cursor.terminalNodeId).childIds.length > 0;
   const isFlattened = cursor.headNodeId !== cursor.terminalNodeId;
-  const instrumentation = state2.instrumentation;
-  const flattenedSegments = isFlattened ? instrumentation == null ? collectFlattenedDirectoryChainIds(state2, cursor.headNodeId).map((nodeId) => {
-    const node = requireNode(state2, nodeId);
+  const instrumentation = state3.instrumentation;
+  const flattenedSegments = isFlattened ? instrumentation == null ? collectFlattenedDirectoryChainIds(state3, cursor.headNodeId).map((nodeId) => {
+    const node = requireNode(state3, nodeId);
     return {
       isTerminal: nodeId === cursor.terminalNodeId,
-      name: getSegmentValue(state2.snapshot.segmentTable, node.nameId),
+      name: getSegmentValue(state3.snapshot.segmentTable, node.nameId),
       nodeId,
-      path: materializeNodePath(state2, nodeId)
+      path: materializeNodePath(state3, nodeId)
     };
-  }) : withBenchmarkPhase(instrumentation, "store.getVisibleSlice.flatten.collectSegments", () => collectFlattenedDirectoryChainIds(state2, cursor.headNodeId).map((nodeId) => {
-    const node = requireNode(state2, nodeId);
+  }) : withBenchmarkPhase(instrumentation, "store.getVisibleSlice.flatten.collectSegments", () => collectFlattenedDirectoryChainIds(state3, cursor.headNodeId).map((nodeId) => {
+    const node = requireNode(state3, nodeId);
     return {
       isTerminal: nodeId === cursor.terminalNodeId,
-      name: getSegmentValue(state2.snapshot.segmentTable, node.nameId),
+      name: getSegmentValue(state3.snapshot.segmentTable, node.nameId),
       nodeId,
-      path: materializeNodePath(state2, nodeId)
+      path: materializeNodePath(state3, nodeId)
     };
   })) : void 0;
   return {
@@ -73462,7 +73907,7 @@ function materializeVisibleRow(state2, cursor) {
     flattenedSegments,
     hasChildren,
     id: cursor.terminalNodeId,
-    isExpanded: isDirectoryNode(terminalNode) && isDirectoryExpanded(state2, cursor.terminalNodeId, terminalNode),
+    isExpanded: isDirectoryNode(terminalNode) && isDirectoryExpanded(state3, cursor.terminalNodeId, terminalNode),
     isFlattened,
     isLoading: loadState === "loading",
     kind: isDirectoryNode(terminalNode) ? "directory" : "file",
@@ -73471,13 +73916,13 @@ function materializeVisibleRow(state2, cursor) {
     path
   };
 }
-function getVisibleRowLoadState(state2, cursor) {
-  if (cursor.headNodeId === cursor.terminalNodeId) return getDirectoryLoadState(state2, cursor.terminalNodeId);
-  const chainNodeIds = collectFlattenedDirectoryChainIds(state2, cursor.headNodeId);
+function getVisibleRowLoadState(state3, cursor) {
+  if (cursor.headNodeId === cursor.terminalNodeId) return getDirectoryLoadState(state3, cursor.terminalNodeId);
+  const chainNodeIds = collectFlattenedDirectoryChainIds(state3, cursor.headNodeId);
   let hasUnloaded = false;
   let hasError = false;
   for (const nodeId of chainNodeIds) {
-    const loadState = getDirectoryLoadState(state2, nodeId);
+    const loadState = getDirectoryLoadState(state3, nodeId);
     if (loadState === "loading") return "loading";
     if (loadState === "error") {
       hasError = true;
@@ -73571,8 +74016,8 @@ function sweepOpenVisibleCountsSoa(store2) {
 }
 
 // node_modules/@pierre/trees/dist/path-store/src/store.js
-function initializeOpenVisibleCounts(state2) {
-  const { directories, nodes, options, rootId, presortedDirectoryNodeIds } = state2.snapshot;
+function initializeOpenVisibleCounts(state3) {
+  const { directories, nodes, options, rootId, presortedDirectoryNodeIds } = state3.snapshot;
   const flattenEmptyDirectories = options.flattenEmptyDirectories === true;
   const walkDirectory = (nodeId) => {
     const currentNode = nodes[nodeId];
@@ -73622,9 +74067,9 @@ function initializeOpenVisibleCounts(state2) {
   rootNode.subtreeNodeCount = 1 + rootTotalChildSubtreeNodeCount;
   rootNode.visibleSubtreeCount = rootTotalChildVisibleSubtreeCount;
 }
-function initializeOpenVisibleCountsViaSoa(state2) {
-  const { directories, nodes, rootId } = state2.snapshot;
-  const soa = buildSoaNodeStore(state2.snapshot);
+function initializeOpenVisibleCountsViaSoa(state3) {
+  const { directories, nodes, rootId } = state3.snapshot;
+  const soa = buildSoaNodeStore(state3.snapshot);
   sweepOpenVisibleCountsSoa(soa);
   const subtreeNodeCount = soa.subtreeNodeCount;
   const visibleSubtreeCount = soa.visibleSubtreeCount;
@@ -76748,17 +77193,17 @@ function RenameInput({ ariaLabel, isFlattened = false, ref, value, onBlur, onInp
 
 // node_modules/@pierre/trees/dist/render/rowAttributes.js
 function computeFileTreeRowElementAttributes(input) {
-  const { row, mode, targetPath, ariaLabel, domId, isParked, itemHeight, features, state: state2, extraStyle } = input;
+  const { row, mode, targetPath, ariaLabel, domId, isParked, itemHeight, features, state: state3, extraStyle } = input;
   const isSticky = mode === "sticky";
   const parentPath = row.ancestorPaths.at(-1) ?? "";
   const stateAttributes = {};
-  if (state2.isFocusRinged) stateAttributes["data-item-focused"] = true;
+  if (state3.isFocusRinged) stateAttributes["data-item-focused"] = true;
   if (row.isSelected) stateAttributes["data-item-selected"] = true;
-  if (state2.isContextHovered) stateAttributes["data-item-context-hover"] = "true";
-  if (state2.isDragTarget) stateAttributes["data-item-drag-target"] = true;
-  if (state2.isDragging) stateAttributes["data-item-dragging"] = true;
-  if (state2.effectiveGitStatus != null) stateAttributes["data-item-git-status"] = state2.effectiveGitStatus;
-  if (state2.containsGitChange) stateAttributes["data-item-contains-git-change"] = "true";
+  if (state3.isContextHovered) stateAttributes["data-item-context-hover"] = "true";
+  if (state3.isDragTarget) stateAttributes["data-item-drag-target"] = true;
+  if (state3.isDragging) stateAttributes["data-item-dragging"] = true;
+  if (state3.effectiveGitStatus != null) stateAttributes["data-item-git-status"] = state3.effectiveGitStatus;
+  if (state3.containsGitChange) stateAttributes["data-item-contains-git-change"] = "true";
   return {
     "aria-expanded": !isSticky && row.kind === "directory" ? row.isExpanded : void 0,
     "aria-haspopup": features.contextMenuEnabled ? "menu" : void 0,
@@ -79564,6 +80009,7 @@ function define2() {
 define2();
 export {
   Emitter,
+  Panels,
   SliccAgents,
   SliccApp,
   SliccApprovals,
@@ -79587,6 +80033,7 @@ export {
   confirm,
   define2 as define,
   grammarBase,
+  panelCommand,
   prompt,
   resolveColor,
   setGrammarBase,