@ai-ecoverse/slicc-spectrum 1.70.0 → 1.71.0

package/dist/slicc-ui.js

@@ -6605,8 +6605,8 @@ function hasFixedPositionAncestor(element2, stopNode) {
   }
   return getComputedStyle2(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
 }
-function getClippingElementAncestors(element2, cache3) {
-  const cachedResult = cache3.get(element2);
+function getClippingElementAncestors(element2, cache4) {
+  const cachedResult = cache4.get(element2);
   if (cachedResult) {
     return cachedResult;
   }
@@ -6628,7 +6628,7 @@ function getClippingElementAncestors(element2, cache3) {
     }
     currentNode = getParentNode(currentNode);
   }
-  cache3.set(element2, result);
+  cache4.set(element2, result);
   return result;
 }
 function getClippingRect(_ref) {
@@ -6929,14 +6929,14 @@ var flip2 = flip;
 var size2 = size;
 var arrow2 = arrow;
 var computePosition2 = (reference2, floating, options) => {
-  const cache3 = /* @__PURE__ */ new Map();
+  const cache4 = /* @__PURE__ */ new Map();
   const mergedOptions = {
     platform,
     ...options
   };
   const platformWithCache = {
     ...mergedOptions.platform,
-    _c: cache3
+    _c: cache4
   };
   return computePosition(reference2, floating, {
     ...mergedOptions,
@@ -9727,33 +9727,33 @@ var lights = {
   unlinked: ["negative", (owner) => `Unlinked from ${owner}`],
   failed: ["negative", (owner) => `Can\u2019t reach ${owner}`]
 };
-function followLight(state3) {
-  const [variant, text2] = lights[state3.link];
-  return { variant, text: text2(state3.owner) };
+function followLight(state2) {
+  const [variant, text2] = lights[state2.link];
+  return { variant, text: text2(state2.owner) };
 }
-function followPage(state3) {
-  if (!state3) return null;
-  const { owner } = state3;
-  if (state3.link === "connecting")
+function followPage(state2) {
+  if (!state2) return null;
+  const { owner } = state2;
+  if (state2.link === "connecting")
     return {
       kind: "connecting",
       title: `Connecting to ${owner}\u2026`,
       body: `This device follows ${owner}. Its agent shows here once it\u2019s connected.`
     };
-  if (state3.link === "unlinked")
+  if (state2.link === "unlinked")
     return {
       kind: "unlinked",
       title: `${owner} unlinked this device`,
       body: `To follow it again, open a new link from ${owner}.`
     };
-  if (state3.link === "failed")
+  if (state2.link === "failed")
     return {
       kind: "failed",
       title: `Can\u2019t follow ${owner}`,
-      body: state3.error ?? `The link to ${owner} failed.`
+      body: state2.error ?? `The link to ${owner} failed.`
     };
-  if (state3.access.view) return null;
-  const where2 = state3.name ? `next to ${state3.name}` : "for this device";
+  if (state2.access.view) return null;
+  const where2 = state2.name ? `next to ${state2.name}` : "for this device";
   return {
     kind: "waiting",
     title: `Waiting for ${owner} to allow this device`,
@@ -9764,26 +9764,26 @@ function list(items, last) {
   if (items.length < 2) return items.join("");
   return `${items.slice(0, -1).join(", ")} ${last} ${items.at(-1)}`;
 }
-function followCan(state3) {
+function followCan(state2) {
   const allowed = ["watch the agent"];
   const missing = [];
-  (state3.access.control ? allowed : missing).push("send prompts");
-  (state3.access.terminal ? allowed : missing).push("open terminals");
+  (state2.access.control ? allowed : missing).push("send prompts");
+  (state2.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 ${state3.owner}.` : can;
+  return missing.length ? `${can} To ${list(missing, "or")}, allow it on ${state2.owner}.` : can;
 }
 function following(model) {
-  const state3 = model?.follow?.state();
-  return state3 && !followPage(state3) ? state3 : null;
+  const state2 = model?.follow?.state();
+  return state2 && !followPage(state2) ? state2 : null;
 }
 function watchOnly(model) {
-  const state3 = following(model);
-  if (!state3 || state3.access.control) return "";
-  return `Watch only. To send prompts from this device, allow Control for it on ${state3.owner}.`;
+  const state2 = following(model);
+  if (!state2 || state2.access.control) return "";
+  return `Watch only. To send prompts from this device, allow Control for it on ${state2.owner}.`;
 }
 function terminalsAllowed(model) {
-  const state3 = model?.follow?.state();
-  return !state3 || !!state3.access.terminal;
+  const state2 = model?.follow?.state();
+  return !state2 || !!state2.access.terminal;
 }
 var SliccFollow = class extends ModelElement {
   static properties = {
@@ -9879,11 +9879,11 @@ var SliccFollow = class extends ModelElement {
   async leave() {
     const port = this.model?.follow;
     if (!port || this.busy) return;
-    const state3 = port.state();
-    if (state3.link !== "unlinked") {
+    const state2 = port.state();
+    if (state2.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.`,
+        title: `Stop following ${state2.owner}?`,
+        body: `This device forgets the link. To follow ${state2.owner} again, open a new link from it.`,
         action: "Leave",
         variant: "confirmation"
       });
@@ -9926,12 +9926,12 @@ var SliccFollow = class extends ModelElement {
     </div>`;
   }
   render() {
-    const state3 = this.model?.follow?.state();
-    if (!state3) return A;
-    const page = followPage(state3);
+    const state2 = this.model?.follow?.state();
+    if (!state2) return A;
+    const page = followPage(state2);
     if (this.page) return page ? this.#page(page) : A;
-    const light = followLight(state3);
-    return b`<swc-action-button id="chip" class="chip" size="s" quiet data-follow=${state3.link} accessible-label=${light.text}>
+    const light = followLight(state2);
+    return b`<swc-action-button id="chip" class="chip" size="s" quiet data-follow=${state2.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>
@@ -9939,8 +9939,8 @@ var SliccFollow = class extends ModelElement {
       <swc-popover for="chip" placement="bottom-end" accessible-label=${light.text}>
         <div class="panel">
           <h2>${light.text}</h2>
-          ${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>
+          ${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>
           ${this.#error()}
           <div class="actions">${this.#leaveButton()}</div>
         </div>
@@ -10991,6 +10991,7 @@ var SliccMonitor = class extends ModelElement {
         flex: none;
       }
       .body {
+        container: monitor / inline-size;
         flex: 1;
         min-height: 0;
         overflow-y: auto;
@@ -11005,10 +11006,65 @@ var SliccMonitor = class extends ModelElement {
         grid-template-columns: repeat(auto-fit, minmax(min(100%, var(--swc-card-default-width-extra-small)), 1fr));
         gap: var(--swc-spacing-100);
       }
+      @container monitor (min-width: 248px) {
+        .vital:last-child:nth-child(2n + 1) {
+          grid-column: 1 / -1;
+        }
+      }
+      @container monitor (min-width: 376px) {
+        .vital:last-child:nth-child(n) {
+          grid-column: auto;
+        }
+        .vital:last-child:nth-child(3n + 1) {
+          grid-column: 1 / -1;
+        }
+      }
+      @container monitor (min-width: 504px) {
+        .vital:last-child:nth-child(n) {
+          grid-column: auto;
+        }
+        .vital:last-child:nth-child(4n + 1) {
+          grid-column: 1 / -1;
+        }
+      }
+      @container monitor (min-width: 632px) {
+        .vital:last-child:nth-child(n) {
+          grid-column: auto;
+        }
+        .vital:last-child:nth-child(5n + 1) {
+          grid-column: 1 / -1;
+        }
+      }
+      @container monitor (min-width: 760px) {
+        .vital:last-child:nth-child(n) {
+          grid-column: auto;
+        }
+        .vital:last-child:nth-child(6n + 1) {
+          grid-column: 1 / -1;
+        }
+      }
+      @container monitor (min-width: 888px) {
+        .vital:last-child:nth-child(n) {
+          grid-column: auto;
+        }
+        .vital:last-child:nth-child(7n + 1) {
+          grid-column: 1 / -1;
+        }
+      }
+      @container monitor (min-width: 1016px) {
+        .vital:last-child:nth-child(n) {
+          grid-column: auto;
+        }
+        .vital:last-child:nth-child(8n + 1) {
+          grid-column: 1 / -1;
+        }
+      }
       .vital {
         display: grid;
+        grid-template-rows: auto auto 1fr;
         align-content: start;
         gap: var(--swc-spacing-50);
+        min-width: 0;
         border-radius: var(--swc-corner-radius-medium-default);
         padding: var(--swc-spacing-200);
         background: var(--swc-background-layer-1-color);
@@ -11017,20 +11073,41 @@ var SliccMonitor = class extends ModelElement {
         color: var(--swc-neutral-subdued-content-color-default);
         font-size: var(--swc-font-size-75);
       }
+      .reading {
+        display: flex;
+        align-items: baseline;
+        gap: var(--swc-spacing-75);
+        min-width: 0;
+        white-space: nowrap;
+      }
+      .value,
+      .rest {
+        min-width: 0;
+        overflow: hidden;
+        text-overflow: ellipsis;
+      }
       .value {
+        flex: none;
+        max-width: 100%;
         font-size: var(--swc-font-size-300);
         font-weight: var(--swc-bold-font-weight);
         font-variant-numeric: tabular-nums;
       }
-      .unit,
-      .delta {
+      .rest {
+        flex: 0 1 auto;
         color: var(--swc-neutral-subdued-content-color-default);
+      }
+      .unit + .delta {
         margin-inline-start: var(--swc-spacing-75);
       }
+      .spark {
+        align-self: end;
+        height: var(--swc-component-height-100);
+      }
       svg {
         display: block;
         width: 100%;
-        height: var(--swc-component-height-100);
+        height: 100%;
       }
       polyline {
         fill: none;
@@ -11040,6 +11117,13 @@ var SliccMonitor = class extends ModelElement {
       swc-meter {
         width: 100%;
       }
+      swc-meter > span {
+        display: block;
+        min-width: 0;
+        overflow: hidden;
+        white-space: nowrap;
+        text-overflow: ellipsis;
+      }
       .alerts {
         display: grid;
         gap: var(--swc-spacing-75);
@@ -11101,25 +11185,34 @@ var SliccMonitor = class extends ModelElement {
       }
       .sections {
         display: grid;
+        grid-template-columns: minmax(0, 1fr) auto auto;
+        column-gap: var(--swc-spacing-100);
         margin: 0;
         padding: 0;
         list-style: none;
       }
-      .section {
+      .section,
+      .line {
+        grid-column: 1 / -1;
         display: grid;
+        grid-template-columns: subgrid;
       }
       .line {
-        display: flex;
-        flex-wrap: wrap;
         align-items: center;
-        gap: var(--swc-spacing-100);
         min-height: var(--swc-component-height-100);
         padding: var(--swc-spacing-50) 0;
       }
+      .caption {
+        grid-column: 1;
+        min-width: 0;
+        display: flex;
+        flex-wrap: wrap;
+        align-items: center;
+        gap: var(--swc-spacing-50) var(--swc-spacing-75);
+      }
       .toggle {
         all: unset;
         box-sizing: border-box;
-        flex: 1 1 auto;
         min-width: 0;
         display: flex;
         align-items: center;
@@ -11145,14 +11238,19 @@ var SliccMonitor = class extends ModelElement {
         transform: scaleX(-1);
       }
       .line .name {
-        flex: 1 1 auto;
         min-width: 0;
       }
       .line .num {
+        grid-column: 2;
+        justify-self: end;
         font-weight: var(--swc-bold-font-weight);
         font-variant-numeric: tabular-nums;
       }
+      .line swc-action-button {
+        grid-column: 3;
+      }
       .rows {
+        grid-column: 1 / -1;
         display: grid;
         gap: var(--swc-spacing-50);
         margin: 0 0 var(--swc-spacing-100);
@@ -11208,15 +11306,15 @@ var SliccMonitor = class extends ModelElement {
           variant=${meterVariant2(vital.ratio)}
           value=${Math.round(vital.ratio * 100)}
           value-label=${vital.value}
-          ><span slot="label">${vital.label}</span>${vital.unit ? b`<span slot="description">${vital.unit}</span>` : A}</swc-meter
+          ><span slot="label">${vital.label}</span><span slot="description">${vital.unit ?? "\xA0"}</span></swc-meter
         >
       </div>`;
     }
     const line = vital.series ? sparkline(vital.series) : "";
     return b`<div class="vital" data-id=${vital.id}>
       <div class="label">${vital.label}</div>
-      <div><span class="value">${vital.value}</span>${vital.unit ? b`<span class="unit">${vital.unit}</span>` : A}${vital.delta ? b`<span class="delta">${vital.delta}</span>` : A}</div>
-      ${line ? b`<svg viewBox="0 0 120 28" preserveAspectRatio="none" aria-hidden="true">${w`<polyline points=${line}></polyline>`}</svg>` : A}
+      <div class="reading"><span class="value">${vital.value}</span>${vital.unit || vital.delta ? b`<span class="rest">${vital.unit ? b`<span class="unit">${vital.unit}</span>` : A}${vital.delta ? b`<span class="delta">${vital.delta}</span>` : A}</span>` : A}</div>
+      <div class="spark">${line ? b`<svg viewBox="0 0 120 28" preserveAspectRatio="none" aria-hidden="true">${w`<polyline points=${line}></polyline>`}</svg>` : A}</div>
     </div>`;
   }
   #alert(alert) {
@@ -11252,12 +11350,12 @@ var SliccMonitor = class extends ModelElement {
     const rows = section.rows.length > 0;
     const open = rows && (this.expanded[section.id] ?? flag !== null);
     const list5 = `rows-${section.id}`;
+    const badge = flag ? b`<swc-badge size="s" variant=${flag.variant} subtle>${flag.text}</swc-badge>` : A;
     return b`<li class="section" data-id=${section.id} data-open=${open ? "" : A}>
       <div class="line">
-        ${rows ? b`<button class="toggle" aria-expanded=${open ? "true" : "false"} aria-controls=${open ? list5 : A} @click=${() => {
+        <span class="caption">${rows ? b`<button class="toggle" aria-expanded=${open ? "true" : "false"} aria-controls=${open ? list5 : A} @click=${() => {
       this.expanded = { ...this.expanded, [section.id]: !open };
-    }}><span class="chevron"><swc-icon-chevron-right size="s" aria-hidden="true"></swc-icon-chevron-right></span><span class="name">${section.label}</span></button>` : b`<span class="chevron"></span><span class="name">${section.label}</span>`}
-        ${flag ? b`<swc-badge size="s" variant=${flag.variant} subtle>${flag.text}</swc-badge>` : A}
+    }}><span class="chevron"><swc-icon-chevron-right size="s" aria-hidden="true"></swc-icon-chevron-right></span><span class="name">${section.label}</span></button>` : b`<span class="chevron"></span><span class="name">${section.label}</span>`}${badge}</span>
         <span class="num">${section.rows.length}</span>
         ${surface2 ? b`<swc-action-button size="s" quiet accessible-label=${`Open ${section.label}`} @click=${() => this.#open(surface2)}
                 >Open</swc-action-button
@@ -11783,8 +11881,8 @@ function fallbackModel(options) {
   return offered.find((option2) => option2.default) ?? offered[0];
 }
 function controls(model) {
-  const state3 = model.follow?.state();
-  return !state3 || !!state3.access.control && state3.link === "connected";
+  const state2 = model.follow?.state();
+  return !state2 || !!state2.access.control && state2.link === "connected";
 }
 function settleModels(model) {
   if (settling.has(model) || !controls(model)) return;
@@ -12203,8 +12301,8 @@ var QrCode = class {
       for (let vert = 0; vert < this.size; vert++) {
         for (let j5 = 0; j5 < 2; j5++) {
           const x7 = right - j5;
-          const upward = (right + 1 & 2) === 0;
-          const y10 = upward ? this.size - 1 - vert : vert;
+          const upward2 = (right + 1 & 2) === 0;
+          const y10 = upward2 ? this.size - 1 - vert : vert;
           if (!this.types[y10][x7] && i26 < data.length * 8) {
             this.modules[y10][x7] = getBit(data[i26 >>> 3], 7 - (i26 & 7));
             i26++;
@@ -14665,23 +14763,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(state3) {
-  if (!state3 || state3.role === "alone") return null;
-  if (state3.skew === "newer")
+function tabsBanner(state2) {
+  if (!state2 || state2.role === "alone") return null;
+  if (state2.skew === "newer")
     return {
       kind: "skew",
       skew: "newer",
       text: "Another tab runs a newer SLICC. Reload this tab.",
       reload: true
     };
-  if (state3.skew === "older")
+  if (state2.skew === "older")
     return {
       kind: "skew",
       skew: "older",
       text: "Another tab runs an older SLICC. Reload the other SLICC tab.",
       reload: false
     };
-  if (state3.stalled)
+  if (state2.stalled)
     return {
       kind: "stalled",
       skew: null,
@@ -14690,11 +14788,11 @@ function tabsBanner(state3) {
     };
   return null;
 }
-function tabsLight(state3) {
-  if (!state3 || state3.role === "owner" || state3.role === "alone") return null;
-  const banner = tabsBanner(state3);
+function tabsLight(state2) {
+  if (!state2 || state2.role === "owner" || state2.role === "alone") return null;
+  const banner = tabsBanner(state2);
   if (banner) return { variant: "notice", text: "Another tab", tooltip: banner.text };
-  if (state3.role === "connecting")
+  if (state2.role === "connecting")
     return { variant: "info", text: "Connecting", tooltip: connecting };
   return { variant: "neutral", text: "Another tab", tooltip: following2 };
 }
@@ -21800,12 +21898,12 @@ function comparePreparedEntries(left, right) {
 function comparePreparedPaths(left, right) {
   return comparePreparedEntries(left, right);
 }
-function comparePreparedPathsWithCachedSortKeys(left, right, cache3) {
+function comparePreparedPathsWithCachedSortKeys(left, right, cache4) {
   const getCachedSortKey = (value) => {
-    const existingKey = cache3.get(value);
+    const existingKey = cache4.get(value);
     if (existingKey != null) return existingKey;
     const nextKey = createSegmentSortKey(value);
-    cache3.set(value, nextKey);
+    cache4.set(value, nextKey);
     return nextKey;
   };
   const sharedDepth = Math.min(left.segments.length, right.segments.length);
@@ -22505,40 +22603,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(state3, node) {
+function isDirectoryExpandedByDefault(state2, node) {
   if (hasNodeFlag(node, 2)) return true;
-  if (state3.defaultExpansion === "open") return true;
-  if (state3.defaultExpansion === "closed") return false;
-  return getNodeDepth(node) <= state3.defaultExpansion;
+  if (state2.defaultExpansion === "open") return true;
+  if (state2.defaultExpansion === "closed") return false;
+  return getNodeDepth(node) <= state2.defaultExpansion;
 }
-function isDirectoryExpanded(state3, nodeId, node = state3.snapshot.nodes[nodeId]) {
+function isDirectoryExpanded(state2, nodeId, node = state2.snapshot.nodes[nodeId]) {
   if (node == null || !isDirectoryNode(node)) return false;
-  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);
+  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);
 }
-function setDirectoryExpanded(state3, nodeId, expanded, node = state3.snapshot.nodes[nodeId]) {
+function setDirectoryExpanded(state2, nodeId, expanded, node = state2.snapshot.nodes[nodeId]) {
   if (node == null || !isDirectoryNode(node)) return;
-  const expandedByDefault = isDirectoryExpandedByDefault(state3, node);
+  const expandedByDefault = isDirectoryExpandedByDefault(state2, node);
   if (expanded) {
     if (expandedByDefault) {
-      state3.collapsedDirectoryIds.delete(nodeId);
-      state3.hasCollapsedDirectoryOverrides = state3.collapsedDirectoryIds.size > 0;
+      state2.collapsedDirectoryIds.delete(nodeId);
+      state2.hasCollapsedDirectoryOverrides = state2.collapsedDirectoryIds.size > 0;
       return;
     }
-    state3.expandedDirectoryIds.add(nodeId);
+    state2.expandedDirectoryIds.add(nodeId);
     return;
   }
   if (expandedByDefault) {
-    state3.collapsedDirectoryIds.add(nodeId);
-    state3.hasCollapsedDirectoryOverrides = true;
+    state2.collapsedDirectoryIds.add(nodeId);
+    state2.hasCollapsedDirectoryOverrides = true;
     return;
   }
-  state3.expandedDirectoryIds.delete(nodeId);
+  state2.expandedDirectoryIds.delete(nodeId);
 }
-function getOrCreateDirectoryLoadInfo(state3, nodeId) {
-  const existingInfo = state3.directoryLoadInfoById.get(nodeId);
+function getOrCreateDirectoryLoadInfo(state2, nodeId) {
+  const existingInfo = state2.directoryLoadInfoById.get(nodeId);
   if (existingInfo != null) return existingInfo;
   const nextInfo = {
     activeAttemptId: null,
@@ -22546,14 +22644,14 @@ function getOrCreateDirectoryLoadInfo(state3, nodeId) {
     nextAttemptId: 1,
     state: "loaded"
   };
-  state3.directoryLoadInfoById.set(nodeId, nextInfo);
+  state2.directoryLoadInfoById.set(nodeId, nextInfo);
   return nextInfo;
 }
-function getDirectoryLoadState(state3, nodeId) {
-  return state3.directoryLoadInfoById.get(nodeId)?.state ?? "loaded";
+function getDirectoryLoadState(state2, nodeId) {
+  return state2.directoryLoadInfoById.get(nodeId)?.state ?? "loaded";
 }
-function beginDirectoryLoad(state3, nodeId) {
-  const loadInfo = getOrCreateDirectoryLoadInfo(state3, nodeId);
+function beginDirectoryLoad(state2, nodeId) {
+  const loadInfo = getOrCreateDirectoryLoadInfo(state2, nodeId);
   if (loadInfo.state === "loading" && loadInfo.activeAttemptId != null) return {
     attemptId: loadInfo.activeAttemptId,
     nodeId,
@@ -22570,46 +22668,46 @@ function beginDirectoryLoad(state3, nodeId) {
     reused: false
   };
 }
-function markDirectoryUnloadedState(state3, nodeId) {
-  const loadInfo = getOrCreateDirectoryLoadInfo(state3, nodeId);
+function markDirectoryUnloadedState(state2, nodeId) {
+  const loadInfo = getOrCreateDirectoryLoadInfo(state2, nodeId);
   loadInfo.activeAttemptId = null;
   loadInfo.errorMessage = null;
   loadInfo.state = "unloaded";
 }
-function completeDirectoryLoad(state3, nodeId, attemptId) {
-  const loadInfo = state3.directoryLoadInfoById.get(nodeId);
+function completeDirectoryLoad(state2, nodeId, attemptId) {
+  const loadInfo = state2.directoryLoadInfoById.get(nodeId);
   if (loadInfo == null || loadInfo.activeAttemptId !== attemptId) return false;
   loadInfo.activeAttemptId = null;
   loadInfo.errorMessage = null;
   loadInfo.state = "loaded";
   return true;
 }
-function isDirectoryLoadAttemptCurrent(state3, nodeId, attemptId) {
-  return state3.directoryLoadInfoById.get(nodeId)?.activeAttemptId === attemptId;
+function isDirectoryLoadAttemptCurrent(state2, nodeId, attemptId) {
+  return state2.directoryLoadInfoById.get(nodeId)?.activeAttemptId === attemptId;
 }
-function failDirectoryLoad(state3, nodeId, attemptId, errorMessage) {
-  const loadInfo = state3.directoryLoadInfoById.get(nodeId);
+function failDirectoryLoad(state2, nodeId, attemptId, errorMessage) {
+  const loadInfo = state2.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(state3, nodeId) {
-  state3.directoryLoadInfoById.delete(nodeId);
+function clearDirectoryLoadInfo(state2, nodeId) {
+  state2.directoryLoadInfoById.delete(nodeId);
 }
 
 // node_modules/@pierre/trees/dist/path-store/src/events.js
-function subscribe(state3, type, handler) {
+function subscribe(state2, type, handler) {
   const rawHandler = handler;
-  const existingListeners = state3.listeners.get(type);
+  const existingListeners = state2.listeners.get(type);
   if (existingListeners != null) existingListeners.add(rawHandler);
-  else state3.listeners.set(type, /* @__PURE__ */ new Set([rawHandler]));
+  else state2.listeners.set(type, /* @__PURE__ */ new Set([rawHandler]));
   return () => {
-    const listeners = state3.listeners.get(type);
+    const listeners = state2.listeners.get(type);
     if (listeners == null) return;
     listeners.delete(rawHandler);
-    if (listeners.size === 0) state3.listeners.delete(type);
+    if (listeners.size === 0) state2.listeners.delete(type);
   };
 }
 function createAddEvent(args2) {
@@ -22759,58 +22857,58 @@ function createCleanupEvent(args2) {
     visibleCountDelta: null
   };
 }
-function finalizeEvent(state3, previousVisibleCount, event2) {
+function finalizeEvent(state2, previousVisibleCount, event2) {
   return {
     ...event2,
-    visibleCountDelta: getCurrentVisibleCount(state3) - previousVisibleCount
+    visibleCountDelta: getCurrentVisibleCount(state2) - previousVisibleCount
   };
 }
-function batchEvents(state3, run2) {
-  const previousVisibleCount = getCurrentVisibleCount(state3);
+function batchEvents(state2, run2) {
+  const previousVisibleCount = getCurrentVisibleCount(state2);
   const frame = createTransactionFrame();
-  state3.transactionStack.push(frame);
+  state2.transactionStack.push(frame);
   try {
     run2();
   } catch (error) {
-    finishTransaction(state3, frame, false);
+    finishTransaction(state2, frame, false);
     throw error;
   }
-  finishTransaction(state3, frame, true, getCurrentVisibleCount(state3) - previousVisibleCount);
+  finishTransaction(state2, frame, true, getCurrentVisibleCount(state2) - previousVisibleCount);
 }
-function recordEvent(state3, event2) {
-  const instrumentation = state3.instrumentation;
+function recordEvent(state2, event2) {
+  const instrumentation = state2.instrumentation;
   if (instrumentation == null) {
-    recordEventNow(state3, event2);
+    recordEventNow(state2, event2);
     return;
   }
-  withBenchmarkPhase(instrumentation, "store.events.record", () => recordEventNow(state3, event2));
+  withBenchmarkPhase(instrumentation, "store.events.record", () => recordEventNow(state2, event2));
 }
-function recordEventNow(state3, event2) {
-  const currentFrame = state3.transactionStack[state3.transactionStack.length - 1] ?? null;
+function recordEventNow(state2, event2) {
+  const currentFrame = state2.transactionStack[state2.transactionStack.length - 1] ?? null;
   if (currentFrame == null) {
-    emitEvent(state3, event2);
+    emitEvent(state2, event2);
     return;
   }
   currentFrame.events.push(event2);
   mergeEventMetadataIntoFrame(currentFrame, event2);
 }
-function finishTransaction(state3, frame, emit, visibleCountDelta = null) {
-  if (state3.transactionStack.pop() !== frame) throw new Error("Transaction stack underflow");
+function finishTransaction(state2, frame, emit, visibleCountDelta = null) {
+  if (state2.transactionStack.pop() !== frame) throw new Error("Transaction stack underflow");
   if (!emit) return;
-  const parentFrame = state3.transactionStack[state3.transactionStack.length - 1] ?? null;
+  const parentFrame = state2.transactionStack[state2.transactionStack.length - 1] ?? null;
   if (parentFrame != null) {
-    const instrumentation2 = state3.instrumentation;
+    const instrumentation2 = state2.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 = state3.instrumentation;
+  const instrumentation = state2.instrumentation;
   if (instrumentation == null) {
-    emitEvent(state3, batchEvent);
+    emitEvent(state2, batchEvent);
     return;
   }
-  withBenchmarkPhase(instrumentation, "store.events.batch.commit", () => emitEvent(state3, batchEvent));
+  withBenchmarkPhase(instrumentation, "store.events.batch.commit", () => emitEvent(state2, batchEvent));
 }
 function createBatchEvent(frame, visibleCountDelta) {
   return {
@@ -22835,48 +22933,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(state3, event2) {
-  const instrumentation = state3.instrumentation;
+function emitEvent(state2, event2) {
+  const instrumentation = state2.instrumentation;
   if (instrumentation == null) {
-    emitEventNow(state3, event2);
+    emitEventNow(state2, event2);
     return;
   }
-  withBenchmarkPhase(instrumentation, "store.events.emit", () => emitEventNow(state3, event2));
+  withBenchmarkPhase(instrumentation, "store.events.emit", () => emitEventNow(state2, event2));
 }
-function emitEventNow(state3, event2) {
-  state3.listeners.get(event2.operation)?.forEach((handler) => handler(event2));
-  state3.listeners.get("*")?.forEach((handler) => handler(event2));
+function emitEventNow(state2, event2) {
+  state2.listeners.get(event2.operation)?.forEach((handler) => handler(event2));
+  state2.listeners.get("*")?.forEach((handler) => handler(event2));
 }
-function getCurrentVisibleCount(state3) {
-  return state3.snapshot.nodes[state3.snapshot.rootId]?.visibleSubtreeCount ?? 0;
+function getCurrentVisibleCount(state2) {
+  return state2.snapshot.nodes[state2.snapshot.rootId]?.visibleSubtreeCount ?? 0;
 }
 
 // node_modules/@pierre/trees/dist/path-store/src/flatten.js
-function getFlattenedChildDirectoryId(state3, directoryNodeId) {
-  if (state3.snapshot.options.flattenEmptyDirectories !== true) return null;
-  const directoryNode = state3.snapshot.nodes[directoryNodeId];
+function getFlattenedChildDirectoryId(state2, directoryNodeId) {
+  if (state2.snapshot.options.flattenEmptyDirectories !== true) return null;
+  const directoryNode = state2.snapshot.nodes[directoryNodeId];
   if (directoryNode == null || !isDirectoryNode(directoryNode) || hasNodeFlag(directoryNode, 2)) return null;
-  const directoryIndex = state3.snapshot.directories.get(directoryNodeId);
+  const directoryIndex = state2.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 = state3.snapshot.nodes[childId];
+  const childNode = state2.snapshot.nodes[childId];
   if (childNode == null || !isDirectoryNode(childNode)) return null;
   return childId;
 }
-function getFlattenedTerminalDirectoryId(state3, directoryNodeId) {
+function getFlattenedTerminalDirectoryId(state2, directoryNodeId) {
   let currentDirectoryId = directoryNodeId;
   while (true) {
-    const nextDirectoryId = getFlattenedChildDirectoryId(state3, currentDirectoryId);
+    const nextDirectoryId = getFlattenedChildDirectoryId(state2, currentDirectoryId);
     if (nextDirectoryId == null) return currentDirectoryId;
     currentDirectoryId = nextDirectoryId;
   }
 }
-function collectFlattenedDirectoryChainIds(state3, directoryNodeId) {
+function collectFlattenedDirectoryChainIds(state2, directoryNodeId) {
   const chainIds = [directoryNodeId];
   let currentDirectoryId = directoryNodeId;
   while (true) {
-    const nextDirectoryId = getFlattenedChildDirectoryId(state3, currentDirectoryId);
+    const nextDirectoryId = getFlattenedChildDirectoryId(state2, currentDirectoryId);
     if (nextDirectoryId == null) return chainIds;
     chainIds.push(nextDirectoryId);
     currentDirectoryId = nextDirectoryId;
@@ -22884,144 +22982,144 @@ function collectFlattenedDirectoryChainIds(state3, directoryNodeId) {
 }
 
 // node_modules/@pierre/trees/dist/path-store/src/canonical.js
-function listPaths(state3, path) {
-  const nodeId = path == null ? state3.snapshot.rootId : findNodeId(state3, path);
+function listPaths(state2, path) {
+  const nodeId = path == null ? state2.snapshot.rootId : findNodeId(state2, path);
   if (nodeId == null) return [];
-  return collectCanonicalEntries(state3, nodeId);
+  return collectCanonicalEntries(state2, nodeId);
 }
-function addPath(state3, path) {
+function addPath(state2, path) {
   const preparedPath = parseInputPath(path);
   const parentSegments = preparedPath.isDirectory ? preparedPath.segments : preparedPath.segments.slice(0, -1);
-  const previousProjectionSignature = getCollapsedProjectionSignature(state3, findDeepestExistingDirectoryId(state3, parentSegments));
-  const { createdNodeIds, directoryId } = ensureDirectoryChain(state3, parentSegments);
+  const previousProjectionSignature = getCollapsedProjectionSignature(state2, findDeepestExistingDirectoryId(state2, parentSegments));
+  const { createdNodeIds, directoryId } = ensureDirectoryChain(state2, parentSegments);
   const affectedNodeIds = new Set(createdNodeIds);
   let addedNodeId = directoryId;
   if (preparedPath.isDirectory) {
-    const directoryNode = requireNode(state3, directoryId);
+    const directoryNode = requireNode(state2, directoryId);
     if (hasNodeFlag(directoryNode, 1)) throw new Error(`Path already exists: "${path}"`);
     addNodeFlag(directoryNode, 1);
-    state3.pathCacheByNodeId.set(directoryId, {
+    state2.pathCacheByNodeId.set(directoryId, {
       path,
-      version: state3.pathCacheVersion
+      version: state2.pathCacheVersion
     });
     affectedNodeIds.add(directoryId);
   } else {
-    addedNodeId = createFileNode(state3, directoryId, preparedPath.basename);
+    addedNodeId = createFileNode(state2, directoryId, preparedPath.basename);
     affectedNodeIds.add(addedNodeId);
   }
-  recomputeCountsUpwardFrom(state3, directoryId);
-  const nextProjectionSignature = getCollapsedProjectionSignature(state3, directoryId);
+  recomputeCountsUpwardFrom(state2, directoryId);
+  const nextProjectionSignature = getCollapsedProjectionSignature(state2, directoryId);
   return createAddEvent({
-    affectedAncestorIds: collectAncestorIds(state3, addedNodeId),
+    affectedAncestorIds: collectAncestorIds(state2, addedNodeId),
     affectedNodeIds: [...affectedNodeIds],
     path,
     projectionChanged: didProjectionChange(previousProjectionSignature, nextProjectionSignature)
   });
 }
-function removePath(state3, path, options) {
-  const nodeId = findNodeId(state3, path);
+function removePath(state2, path, options) {
+  const nodeId = findNodeId(state2, path);
   if (nodeId == null) throw new Error(`Path does not exist: "${path}"`);
-  const node = requireNode(state3, nodeId);
+  const node = requireNode(state2, nodeId);
   if (hasNodeFlag(node, 2)) throw new Error("The root node cannot be removed");
-  if (isDirectoryNode(node) && getDirectoryIndex(state3, nodeId).childIds.length > 0 && options.recursive !== true) throw new Error(`Cannot remove a non-empty directory without recursive: "${path}"`);
+  if (isDirectoryNode(node) && getDirectoryIndex(state2, 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(state3, parentId);
-  const removedNodeIds = removeSubtree(state3, nodeId);
-  removeChildReference(state3, parentId, nodeId, node.nameId);
-  promoteEmptyAncestorsToExplicit(state3, parentId);
-  recomputeCountsUpwardFrom(state3, parentId);
-  const nextProjectionSignature = getCollapsedProjectionSignature(state3, 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);
   return createRemoveEvent({
-    affectedAncestorIds: collectAncestorIds(state3, parentId),
+    affectedAncestorIds: collectAncestorIds(state2, parentId),
     affectedNodeIds: removedNodeIds,
     path,
     projectionChanged: didProjectionChange(previousProjectionSignature, nextProjectionSignature),
     recursive: options.recursive === true
   });
 }
-function movePath(state3, fromPath, toPath, options) {
-  const sourceNodeId = findNodeId(state3, fromPath);
+function movePath(state2, fromPath, toPath, options) {
+  const sourceNodeId = findNodeId(state2, fromPath);
   if (sourceNodeId == null) throw new Error(`Source path does not exist: "${fromPath}"`);
-  const sourceNode = requireNode(state3, sourceNodeId);
+  const sourceNode = requireNode(state2, sourceNodeId);
   if (hasNodeFlag(sourceNode, 2)) throw new Error("The root node cannot be moved");
   const collision = options.collision ?? "error";
-  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);
+  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);
   if (moveTarget.parentId === sourceNode.parentId && sourceName === moveTarget.basename) return null;
-  if (isDirectoryNode(sourceNode) && isAncestor(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);
+  if (isDirectoryNode(sourceNode) && isAncestor(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);
   const collisionNodeId = moveTarget.existingNodeId ?? siblingCollisionId ?? null;
   if (collisionNodeId != null && collisionNodeId !== sourceNodeId) {
-    if (handleMoveCollision(state3, collisionNodeId, collision, getNodeKind(sourceNode)) === "skip") return null;
+    if (handleMoveCollision(state2, collisionNodeId, collision, getNodeKind(sourceNode)) === "skip") return null;
   }
   const previousParentId = sourceNode.parentId;
-  removeChildReference(state3, previousParentId, sourceNodeId, sourceNode.nameId);
+  removeChildReference(state2, previousParentId, sourceNodeId, sourceNode.nameId);
   sourceNode.parentId = moveTarget.parentId;
   sourceNode.nameId = targetNameId;
-  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);
+  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);
   return createMoveEvent({
-    affectedAncestorIds: [.../* @__PURE__ */ new Set([...collectAncestorIds(state3, previousParentId), ...collectAncestorIds(state3, moveTarget.parentId)])],
+    affectedAncestorIds: [.../* @__PURE__ */ new Set([...collectAncestorIds(state2, previousParentId), ...collectAncestorIds(state2, moveTarget.parentId)])],
     affectedNodeIds: [sourceNodeId],
     from: fromPath,
     projectionChanged: didAnyProjectionChange([previousSourceProjectionSignature, previousTargetProjectionSignature], [nextSourceProjectionSignature, nextTargetProjectionSignature]),
-    to: materializeNodePath(state3, sourceNodeId)
+    to: materializeNodePath(state2, sourceNodeId)
   });
 }
-function getCachedNodePath(state3, nodeId) {
-  const cachedEntry = state3.pathCacheByNodeId.get(nodeId);
-  return cachedEntry != null && cachedEntry.version === state3.pathCacheVersion ? cachedEntry.path : null;
+function getCachedNodePath(state2, nodeId) {
+  const cachedEntry = state2.pathCacheByNodeId.get(nodeId);
+  return cachedEntry != null && cachedEntry.version === state2.pathCacheVersion ? cachedEntry.path : null;
 }
-function setCachedNodePath(state3, nodeId, path) {
-  state3.pathCacheByNodeId.set(nodeId, {
+function setCachedNodePath(state2, nodeId, path) {
+  state2.pathCacheByNodeId.set(nodeId, {
     path,
-    version: state3.pathCacheVersion
+    version: state2.pathCacheVersion
   });
   return path;
 }
-function materializeNodePath(state3, nodeId) {
-  const node = requireNode(state3, nodeId);
-  const cachedPath = getCachedNodePath(state3, nodeId);
+function materializeNodePath(state2, nodeId) {
+  const node = requireNode(state2, nodeId);
+  const cachedPath = getCachedNodePath(state2, nodeId);
   if (cachedPath != null) return cachedPath;
-  if (hasNodeFlag(node, 2)) return setCachedNodePath(state3, nodeId, "");
-  const parentPath = materializeNodePath(state3, node.parentId);
-  const nodeName = getSegmentValue(state3.snapshot.segmentTable, node.nameId);
+  if (hasNodeFlag(node, 2)) return setCachedNodePath(state2, nodeId, "");
+  const parentPath = materializeNodePath(state2, node.parentId);
+  const nodeName = getSegmentValue(state2.snapshot.segmentTable, node.nameId);
   const path = parentPath.length === 0 ? nodeName : `${parentPath}${nodeName}`;
-  return setCachedNodePath(state3, nodeId, isDirectoryNode(node) ? `${path}/` : path);
+  return setCachedNodePath(state2, nodeId, isDirectoryNode(node) ? `${path}/` : path);
 }
-function recomputeCountsUpwardFrom(state3, startNodeId) {
-  const instrumentation = state3.instrumentation;
+function recomputeCountsUpwardFrom(state2, startNodeId) {
+  const instrumentation = state2.instrumentation;
   if (instrumentation == null) {
-    recomputeCountsUpwardFromNow(state3, startNodeId);
+    recomputeCountsUpwardFromNow(state2, startNodeId);
     return;
   }
-  withBenchmarkPhase(instrumentation, "store.recomputeCountsUpwardFrom", () => recomputeCountsUpwardFromNow(state3, startNodeId));
+  withBenchmarkPhase(instrumentation, "store.recomputeCountsUpwardFrom", () => recomputeCountsUpwardFromNow(state2, startNodeId));
 }
-function recomputeCountsRecursive(state3, nodeId) {
+function recomputeCountsRecursive(state2, nodeId) {
   const stack = [[nodeId, 0]];
-  const { nodes, directories } = state3.snapshot;
+  const { nodes, directories } = state2.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(state3, nid, node, true);
+      recomputeNodeCounts(state2, nid, node, true);
       stack.pop();
       continue;
     }
     const dirIndex = directories.get(nid);
     if (dirIndex == null || frame[1] >= dirIndex.childIds.length) {
-      recomputeNodeCounts(state3, nid, node, true);
+      recomputeNodeCounts(state2, nid, node, true);
       stack.pop();
       continue;
     }
@@ -23029,51 +23127,51 @@ function recomputeCountsRecursive(state3, nodeId) {
     stack.push([childId, 0]);
   }
 }
-function collectAncestorIds(state3, nodeId) {
+function collectAncestorIds(state2, nodeId) {
   const ancestorIds = [];
   let currentNodeId = nodeId;
   while (currentNodeId != null) {
-    const currentNode = requireNode(state3, currentNodeId);
+    const currentNode = requireNode(state2, currentNodeId);
     ancestorIds.push(currentNodeId);
-    if (currentNodeId === state3.snapshot.rootId) break;
+    if (currentNodeId === state2.snapshot.rootId) break;
     currentNodeId = currentNode.parentId;
   }
   return ancestorIds;
 }
-function findNodeId(state3, path) {
-  if (path.length === 0) return state3.snapshot.rootId;
+function findNodeId(state2, path) {
+  if (path.length === 0) return state2.snapshot.rootId;
   const lookupPath = parseLookupPath(path);
-  return findNodeIdBySegments(state3, lookupPath.segments, lookupPath.requiresDirectory);
+  return findNodeIdBySegments(state2, lookupPath.segments, lookupPath.requiresDirectory);
 }
-function findNodeIdBySegments(state3, segments, requireDirectory) {
-  let currentNodeId = state3.snapshot.rootId;
+function findNodeIdBySegments(state2, segments, requireDirectory) {
+  let currentNodeId = state2.snapshot.rootId;
   for (const segment2 of segments) {
-    const segmentId = state3.snapshot.segmentTable.idByValue.get(segment2);
+    const segmentId = state2.snapshot.segmentTable.idByValue.get(segment2);
     if (segmentId === void 0) return null;
-    const currentIndex = getDirectoryIndex(state3, currentNodeId);
-    const nextNodeId = ensureChildIdByNameId(state3.snapshot.nodes, currentIndex).get(segmentId);
+    const currentIndex = getDirectoryIndex(state2, currentNodeId);
+    const nextNodeId = ensureChildIdByNameId(state2.snapshot.nodes, currentIndex).get(segmentId);
     if (nextNodeId === void 0) return null;
     currentNodeId = nextNodeId;
   }
-  const currentNode = requireNode(state3, currentNodeId);
+  const currentNode = requireNode(state2, currentNodeId);
   if (requireDirectory && !isDirectoryNode(currentNode)) return null;
   return currentNodeId;
 }
-function getDirectoryIndex(state3, directoryId) {
-  const directoryIndex = state3.snapshot.directories.get(directoryId);
+function getDirectoryIndex(state2, directoryId) {
+  const directoryIndex = state2.snapshot.directories.get(directoryId);
   if (directoryIndex === void 0) throw new Error(`Unknown directory child index for node ${String(directoryId)}`);
   return directoryIndex;
 }
-function requireNode(state3, nodeId) {
-  const node = state3.snapshot.nodes[nodeId];
+function requireNode(state2, nodeId) {
+  const node = state2.snapshot.nodes[nodeId];
   if (node === void 0 || hasNodeFlag(node, 4)) throw new Error(`Unknown node ID: ${String(nodeId)}`);
   return node;
 }
-function collectCanonicalEntries(state3, nodeId) {
-  const rootNode = state3.snapshot.nodes[nodeId];
+function collectCanonicalEntries(state2, nodeId) {
+  const rootNode = state2.snapshot.nodes[nodeId];
   if (rootNode === void 0 || hasNodeFlag(rootNode, 4)) return [];
-  if (!isDirectoryNode(rootNode)) return [materializeNodePath(state3, nodeId)];
-  if (getDirectoryIndex(state3, nodeId).childIds.length === 0) return hasNodeFlag(rootNode, 1) && !hasNodeFlag(rootNode, 2) ? [materializeNodePath(state3, nodeId)] : [];
+  if (!isDirectoryNode(rootNode)) return [materializeNodePath(state2, nodeId)];
+  if (getDirectoryIndex(state2, nodeId).childIds.length === 0) return hasNodeFlag(rootNode, 1) && !hasNodeFlag(rootNode, 2) ? [materializeNodePath(state2, nodeId)] : [];
   const entries = [];
   const stack = [{
     childIndex: 0,
@@ -23082,19 +23180,19 @@ function collectCanonicalEntries(state3, nodeId) {
   while (stack.length > 0) {
     const frame = stack[stack.length - 1];
     if (frame == null) break;
-    const currentNode = state3.snapshot.nodes[frame.nodeId];
+    const currentNode = state2.snapshot.nodes[frame.nodeId];
     if (currentNode === void 0 || hasNodeFlag(currentNode, 4)) {
       stack.pop();
       continue;
     }
     if (!isDirectoryNode(currentNode)) {
-      entries.push(materializeNodePath(state3, frame.nodeId));
+      entries.push(materializeNodePath(state2, frame.nodeId));
       stack.pop();
       continue;
     }
-    const currentIndex = getDirectoryIndex(state3, frame.nodeId);
+    const currentIndex = getDirectoryIndex(state2, frame.nodeId);
     if (currentIndex.childIds.length === 0) {
-      if (hasNodeFlag(currentNode, 1) && !hasNodeFlag(currentNode, 2)) entries.push(materializeNodePath(state3, frame.nodeId));
+      if (hasNodeFlag(currentNode, 1) && !hasNodeFlag(currentNode, 2)) entries.push(materializeNodePath(state2, frame.nodeId));
       stack.pop();
       continue;
     }
@@ -23111,19 +23209,19 @@ function collectCanonicalEntries(state3, nodeId) {
   }
   return entries;
 }
-function ensureDirectoryChain(state3, directorySegments) {
+function ensureDirectoryChain(state2, directorySegments) {
   const createdNodeIds = [];
-  let currentDirectoryId = state3.snapshot.rootId;
+  let currentDirectoryId = state2.snapshot.rootId;
   for (const segment2 of directorySegments) {
-    const segmentId = internSegment(state3.snapshot.segmentTable, segment2);
-    const currentIndex = getDirectoryIndex(state3, currentDirectoryId);
-    const existingChildId = ensureChildIdByNameId(state3.snapshot.nodes, currentIndex).get(segmentId);
+    const segmentId = internSegment(state2.snapshot.segmentTable, segment2);
+    const currentIndex = getDirectoryIndex(state2, currentDirectoryId);
+    const existingChildId = ensureChildIdByNameId(state2.snapshot.nodes, currentIndex).get(segmentId);
     if (existingChildId !== void 0) {
-      if (!isDirectoryNode(requireNode(state3, existingChildId))) throw new Error(`Cannot create a directory that collides with an existing file: "${segment2}"`);
+      if (!isDirectoryNode(requireNode(state2, existingChildId))) throw new Error(`Cannot create a directory that collides with an existing file: "${segment2}"`);
       currentDirectoryId = existingChildId;
       continue;
     }
-    currentDirectoryId = createDirectoryNode(state3, currentDirectoryId, segmentId);
+    currentDirectoryId = createDirectoryNode(state2, currentDirectoryId, segmentId);
     createdNodeIds.push(currentDirectoryId);
   }
   return {
@@ -23131,43 +23229,43 @@ function ensureDirectoryChain(state3, directorySegments) {
     directoryId: currentDirectoryId
   };
 }
-function createDirectoryNode(state3, parentId, nameId) {
-  const parentNode = requireNode(state3, parentId);
-  const nodeId = state3.snapshot.nodes.length;
-  state3.snapshot.nodes.push({
+function createDirectoryNode(state2, parentId, nameId) {
+  const parentNode = requireNode(state2, parentId);
+  const nodeId = state2.snapshot.nodes.length;
+  state2.snapshot.nodes.push({
     depthAndFlags: createNodeDepthAndFlags(getNodeDepth(parentNode) + 1, 0, 1),
     nameId,
     parentId,
     subtreeNodeCount: 1,
     visibleSubtreeCount: 1
   });
-  state3.snapshot.directories.set(nodeId, createDirectoryChildIndex());
-  insertChildReference(state3, parentId, nodeId);
-  if (state3.collapseNewDirectoriesByDefault) {
-    state3.collapsedDirectoryIds.add(nodeId);
-    state3.hasCollapsedDirectoryOverrides = true;
+  state2.snapshot.directories.set(nodeId, createDirectoryChildIndex());
+  insertChildReference(state2, parentId, nodeId);
+  if (state2.collapseNewDirectoriesByDefault) {
+    state2.collapsedDirectoryIds.add(nodeId);
+    state2.hasCollapsedDirectoryOverrides = true;
   }
-  state3.activeNodeCount++;
+  state2.activeNodeCount++;
   return nodeId;
 }
-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({
+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({
     depthAndFlags: createNodeDepthAndFlags(getNodeDepth(parentNode) + 1, 0),
     nameId,
     parentId,
     subtreeNodeCount: 1,
     visibleSubtreeCount: 1
   });
-  insertChildReference(state3, parentId, nodeId);
-  state3.activeNodeCount++;
+  insertChildReference(state2, parentId, nodeId);
+  state2.activeNodeCount++;
   return nodeId;
 }
-function findChildInsertIndex(state3, parentIndex, childId) {
+function findChildInsertIndex(state2, parentIndex, childId) {
   let low = 0;
   let high = parentIndex.childIds.length;
   while (low < high) {
@@ -23177,72 +23275,72 @@ function findChildInsertIndex(state3, parentIndex, childId) {
       high = middle;
       continue;
     }
-    if (compareSiblingNodes(state3, childId, existingChildId) < 0) high = middle;
+    if (compareSiblingNodes(state2, childId, existingChildId) < 0) high = middle;
     else low = middle + 1;
   }
   return low;
 }
-function insertChildReference(state3, parentId, childId) {
-  const parentIndex = getDirectoryIndex(state3, parentId);
-  const childNode = requireNode(state3, childId);
-  ensureChildIdByNameId(state3.snapshot.nodes, parentIndex).set(childNode.nameId, childId);
+function insertChildReference(state2, parentId, childId) {
+  const parentIndex = getDirectoryIndex(state2, parentId);
+  const childNode = requireNode(state2, childId);
+  ensureChildIdByNameId(state2.snapshot.nodes, parentIndex).set(childNode.nameId, childId);
   applyChildAggregateDelta(parentIndex, childId, childNode.subtreeNodeCount, childNode.visibleSubtreeCount);
-  const insertIndex = findChildInsertIndex(state3, parentIndex, childId);
+  const insertIndex = findChildInsertIndex(state2, parentIndex, childId);
   parentIndex.childIds.splice(insertIndex, 0, childId);
   updateChildPositionsFrom(parentIndex, insertIndex);
-  rebuildVisibleChildChunks(state3.snapshot.nodes, parentIndex);
+  rebuildVisibleChildChunks(state2.snapshot.nodes, parentIndex);
 }
-function removeChildReference(state3, parentId, childId, childNameId) {
-  const parentIndex = getDirectoryIndex(state3, parentId);
+function removeChildReference(state2, parentId, childId, childNameId) {
+  const parentIndex = getDirectoryIndex(state2, parentId);
   const positions2 = ensureChildPositions(parentIndex);
   const childIndex = positions2.get(childId) ?? -1;
-  ensureChildIdByNameId(state3.snapshot.nodes, parentIndex).delete(childNameId);
+  ensureChildIdByNameId(state2.snapshot.nodes, parentIndex).delete(childNameId);
   positions2.delete(childId);
-  const childNode = state3.snapshot.nodes[childId];
+  const childNode = state2.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(state3.snapshot.nodes, parentIndex);
+    rebuildVisibleChildChunks(state2.snapshot.nodes, parentIndex);
   }
 }
-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 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 compareSiblingNodesDefault(state3, leftId, rightId) {
-  const leftNode = requireNode(state3, leftId);
-  const rightNode = requireNode(state3, rightId);
+function compareSiblingNodesDefault(state2, leftId, rightId) {
+  const leftNode = requireNode(state2, leftId);
+  const rightNode = requireNode(state2, rightId);
   const leftIsDirectory = isDirectoryNode(leftNode);
   if (leftIsDirectory !== isDirectoryNode(rightNode)) return leftIsDirectory ? -1 : 1;
-  const comparison = compareSegmentSortKeys(getSegmentSortKey(state3.snapshot.segmentTable, leftNode.nameId), getSegmentSortKey(state3.snapshot.segmentTable, rightNode.nameId));
+  const comparison = compareSegmentSortKeys(getSegmentSortKey(state2.snapshot.segmentTable, leftNode.nameId), getSegmentSortKey(state2.snapshot.segmentTable, rightNode.nameId));
   if (comparison !== 0) return comparison;
-  const leftName = getSegmentValue(state3.snapshot.segmentTable, leftNode.nameId);
-  const rightName = getSegmentValue(state3.snapshot.segmentTable, rightNode.nameId);
+  const leftName = getSegmentValue(state2.snapshot.segmentTable, leftNode.nameId);
+  const rightName = getSegmentValue(state2.snapshot.segmentTable, rightNode.nameId);
   if (leftName !== rightName) return leftName < rightName ? -1 : 1;
   return leftId < rightId ? -1 : 1;
 }
-function createCompareEntry2(state3, nodeId) {
-  const node = requireNode(state3, nodeId);
-  const path = materializeNodePath(state3, nodeId);
+function createCompareEntry2(state2, nodeId) {
+  const node = requireNode(state2, nodeId);
+  const path = materializeNodePath(state2, nodeId);
   const isDirectory = isDirectoryNode(node);
   const normalizedPath = isDirectory ? path.slice(0, -1) : path;
   return {
-    basename: getSegmentValue(state3.snapshot.segmentTable, node.nameId),
+    basename: getSegmentValue(state2.snapshot.segmentTable, node.nameId),
     depth: getNodeDepth(node),
     isDirectory,
     path,
     segments: normalizedPath.length === 0 ? [] : normalizedPath.split("/")
   };
 }
-function resolveMoveTarget(state3, sourceNodeId, toPath) {
-  const sourceNode = requireNode(state3, sourceNodeId);
-  const existingDestinationId = findNodeId(state3, toPath);
+function resolveMoveTarget(state2, sourceNodeId, toPath) {
+  const sourceNode = requireNode(state2, sourceNodeId);
+  const existingDestinationId = findNodeId(state2, toPath);
   if (existingDestinationId != null) {
-    const existingDestination = requireNode(state3, existingDestinationId);
+    const existingDestination = requireNode(state2, existingDestinationId);
     if (isDirectoryNode(existingDestination)) return {
-      basename: getSegmentValue(state3.snapshot.segmentTable, sourceNode.nameId),
+      basename: getSegmentValue(state2.snapshot.segmentTable, sourceNode.nameId),
       existingNodeId: null,
       parentId: existingDestinationId
     };
@@ -23256,7 +23354,7 @@ function resolveMoveTarget(state3, 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 ? state3.snapshot.rootId : findNodeIdBySegments(state3, parentSegments, true);
+  const parentId = parentSegments.length === 0 ? state2.snapshot.rootId : findNodeIdBySegments(state2, parentSegments, true);
   if (parentId == null) throw new Error(`Destination parent does not exist: "${toPath}"`);
   return {
     basename: basename3,
@@ -23264,21 +23362,21 @@ function resolveMoveTarget(state3, sourceNodeId, toPath) {
     parentId
   };
 }
-function handleMoveCollision(state3, collisionNodeId, strategy, sourceKind) {
+function handleMoveCollision(state2, collisionNodeId, strategy, sourceKind) {
   if (strategy === "skip") return "skip";
-  if (strategy === "error") throw new Error(`Destination already exists: "${materializeNodePath(state3, collisionNodeId)}"`);
-  const collisionNode = requireNode(state3, collisionNodeId);
+  if (strategy === "error") throw new Error(`Destination already exists: "${materializeNodePath(state2, collisionNodeId)}"`);
+  const collisionNode = requireNode(state2, collisionNodeId);
   if (getNodeKind(collisionNode) !== sourceKind) throw new Error("replace collision requires the same source and destination kinds");
-  if (isDirectoryNode(collisionNode) && getDirectoryIndex(state3, collisionNodeId).childIds.length > 0) throw new Error("replace collision does not support non-empty directories");
+  if (isDirectoryNode(collisionNode) && getDirectoryIndex(state2, collisionNodeId).childIds.length > 0) throw new Error("replace collision does not support non-empty directories");
   const collisionParentId = collisionNode.parentId;
   const collisionNameId = collisionNode.nameId;
-  removeSubtree(state3, collisionNodeId);
-  removeChildReference(state3, collisionParentId, collisionNodeId, collisionNameId);
-  promoteEmptyAncestorsToExplicit(state3, collisionParentId);
-  recomputeCountsUpwardFrom(state3, collisionParentId);
+  removeSubtree(state2, collisionNodeId);
+  removeChildReference(state2, collisionParentId, collisionNodeId, collisionNameId);
+  promoteEmptyAncestorsToExplicit(state2, collisionParentId);
+  recomputeCountsUpwardFrom(state2, collisionParentId);
   return "handled";
 }
-function removeSubtree(state3, nodeId) {
+function removeSubtree(state2, nodeId) {
   const removedNodeIds = [];
   const stack = [{
     nodeId,
@@ -23287,15 +23385,15 @@ function removeSubtree(state3, nodeId) {
   while (stack.length > 0) {
     const frame = stack.pop();
     if (frame == null) break;
-    const node = requireNode(state3, frame.nodeId);
+    const node = requireNode(state2, frame.nodeId);
     if (frame.visitedChildren || !isDirectoryNode(node)) {
-      if (isDirectoryNode(node)) state3.snapshot.directories.delete(frame.nodeId);
+      if (isDirectoryNode(node)) state2.snapshot.directories.delete(frame.nodeId);
       addNodeFlag(node, 4);
-      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--;
+      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--;
       removedNodeIds.push(frame.nodeId);
       continue;
     }
@@ -23303,7 +23401,7 @@ function removeSubtree(state3, nodeId) {
       nodeId: frame.nodeId,
       visitedChildren: true
     });
-    const directoryIndex = getDirectoryIndex(state3, frame.nodeId);
+    const directoryIndex = getDirectoryIndex(state2, frame.nodeId);
     for (let childIndex = directoryIndex.childIds.length - 1; childIndex >= 0; childIndex--) {
       const childId = directoryIndex.childIds[childIndex];
       if (childId != null) stack.push({
@@ -23314,38 +23412,38 @@ function removeSubtree(state3, nodeId) {
   }
   return removedNodeIds;
 }
-function promoteEmptyAncestorsToExplicit(state3, startDirectoryId) {
+function promoteEmptyAncestorsToExplicit(state2, startDirectoryId) {
   let currentDirectoryId = startDirectoryId;
   while (currentDirectoryId != null) {
-    const currentNode = requireNode(state3, currentDirectoryId);
+    const currentNode = requireNode(state2, currentDirectoryId);
     if (!isDirectoryNode(currentNode) || hasNodeFlag(currentNode, 2)) return;
-    if (getDirectoryIndex(state3, currentDirectoryId).childIds.length > 0) return;
+    if (getDirectoryIndex(state2, currentDirectoryId).childIds.length > 0) return;
     addNodeFlag(currentNode, 1);
     currentDirectoryId = currentNode.parentId === currentDirectoryId ? null : currentNode.parentId;
   }
 }
-function findDeepestExistingDirectoryId(state3, segments) {
-  let currentDirectoryId = state3.snapshot.rootId;
+function findDeepestExistingDirectoryId(state2, segments) {
+  let currentDirectoryId = state2.snapshot.rootId;
   for (const segment2 of segments) {
-    const segmentId = state3.snapshot.segmentTable.idByValue.get(segment2);
+    const segmentId = state2.snapshot.segmentTable.idByValue.get(segment2);
     if (segmentId == null) break;
-    const nextNodeId = ensureChildIdByNameId(state3.snapshot.nodes, getDirectoryIndex(state3, currentDirectoryId)).get(segmentId);
+    const nextNodeId = ensureChildIdByNameId(state2.snapshot.nodes, getDirectoryIndex(state2, currentDirectoryId)).get(segmentId);
     if (nextNodeId == null) break;
-    if (!isDirectoryNode(requireNode(state3, nextNodeId))) break;
+    if (!isDirectoryNode(requireNode(state2, nextNodeId))) break;
     currentDirectoryId = nextNodeId;
   }
   return currentDirectoryId;
 }
-function getCollapsedProjectionSignature(state3, startDirectoryId) {
-  const collapsedAncestorId = findNearestCollapsedAncestor(state3, startDirectoryId);
+function getCollapsedProjectionSignature(state2, startDirectoryId) {
+  const collapsedAncestorId = findNearestCollapsedAncestor(state2, startDirectoryId);
   if (collapsedAncestorId == null) return null;
-  const terminalDirectoryId = getFlattenedTerminalDirectoryId(state3, collapsedAncestorId);
-  const terminalNode = requireNode(state3, terminalDirectoryId);
-  const flattenedSegmentPaths = collapsedAncestorId === terminalDirectoryId ? null : collectFlattenedDirectoryChainIds(state3, collapsedAncestorId).map((nodeId) => materializeNodePath(state3, nodeId));
+  const terminalDirectoryId = getFlattenedTerminalDirectoryId(state2, collapsedAncestorId);
+  const terminalNode = requireNode(state2, terminalDirectoryId);
+  const flattenedSegmentPaths = collapsedAncestorId === terminalDirectoryId ? null : collectFlattenedDirectoryChainIds(state2, collapsedAncestorId).map((nodeId) => materializeNodePath(state2, nodeId));
   return JSON.stringify({
     flattenedSegmentPaths,
-    hasChildren: getDirectoryIndex(state3, terminalDirectoryId).childIds.length > 0,
-    path: materializeNodePath(state3, terminalDirectoryId),
+    hasChildren: getDirectoryIndex(state2, terminalDirectoryId).childIds.length > 0,
+    path: materializeNodePath(state2, terminalDirectoryId),
     terminalKind: getNodeKind(terminalNode)
   });
 }
@@ -23360,67 +23458,67 @@ function didAnyProjectionChange(previousProjectionSignatures, nextProjectionSign
   }
   return false;
 }
-function findNearestCollapsedAncestor(state3, startDirectoryId) {
+function findNearestCollapsedAncestor(state2, startDirectoryId) {
   let currentDirectoryId = startDirectoryId;
   while (currentDirectoryId != null) {
-    const currentNode = requireNode(state3, currentDirectoryId);
+    const currentNode = requireNode(state2, currentDirectoryId);
     if (!isDirectoryNode(currentNode) || hasNodeFlag(currentNode, 2)) return null;
-    if (!isDirectoryExpanded(state3, currentDirectoryId, currentNode)) return currentDirectoryId;
+    if (!isDirectoryExpanded(state2, currentDirectoryId, currentNode)) return currentDirectoryId;
     currentDirectoryId = currentNode.parentId;
   }
   return null;
 }
-function recomputeDepths(state3, nodeId) {
-  const node = requireNode(state3, nodeId);
-  setNodeDepth(node, (nodeId === state3.snapshot.rootId ? -1 : getNodeDepth(requireNode(state3, node.parentId))) + 1);
+function recomputeDepths(state2, nodeId) {
+  const node = requireNode(state2, nodeId);
+  setNodeDepth(node, (nodeId === state2.snapshot.rootId ? -1 : getNodeDepth(requireNode(state2, node.parentId))) + 1);
   if (!isDirectoryNode(node)) return;
-  const directoryIndex = getDirectoryIndex(state3, nodeId);
-  for (const childId of directoryIndex.childIds) recomputeDepths(state3, childId);
+  const directoryIndex = getDirectoryIndex(state2, nodeId);
+  for (const childId of directoryIndex.childIds) recomputeDepths(state2, childId);
 }
-function isAncestor(state3, ancestorNodeId, nodeId) {
+function isAncestor(state2, ancestorNodeId, nodeId) {
   let currentNodeId = nodeId;
   while (currentNodeId != null) {
     if (currentNodeId === ancestorNodeId) return true;
-    const currentNode = requireNode(state3, currentNodeId);
-    if (currentNodeId === state3.snapshot.rootId) return false;
+    const currentNode = requireNode(state2, currentNodeId);
+    if (currentNodeId === state2.snapshot.rootId) return false;
     currentNodeId = currentNode.parentId;
   }
   return false;
 }
-function recomputeNodeCounts(state3, nodeId, currentNode = requireNode(state3, nodeId), rebuildChildAggregates = false) {
-  const instrumentation = state3.instrumentation;
+function recomputeNodeCounts(state2, nodeId, currentNode = requireNode(state2, nodeId), rebuildChildAggregates = false) {
+  const instrumentation = state2.instrumentation;
   if (instrumentation == null) {
-    recomputeNodeCountsNow(state3, nodeId, currentNode, rebuildChildAggregates);
+    recomputeNodeCountsNow(state2, nodeId, currentNode, rebuildChildAggregates);
     return;
   }
-  withBenchmarkPhase(instrumentation, "store.recomputeNodeCounts", () => recomputeNodeCountsNow(state3, nodeId, currentNode, rebuildChildAggregates));
+  withBenchmarkPhase(instrumentation, "store.recomputeNodeCounts", () => recomputeNodeCountsNow(state2, nodeId, currentNode, rebuildChildAggregates));
 }
-function recomputeCountsUpwardFromNow(state3, startNodeId) {
+function recomputeCountsUpwardFromNow(state2, startNodeId) {
   let currentNodeId = startNodeId;
   while (currentNodeId != null) {
-    const currentNode = requireNode(state3, currentNodeId);
+    const currentNode = requireNode(state2, currentNodeId);
     const previousSubtreeNodeCount = currentNode.subtreeNodeCount;
     const previousVisibleSubtreeCount = currentNode.visibleSubtreeCount;
-    recomputeNodeCounts(state3, currentNodeId, currentNode);
-    if (currentNodeId === state3.snapshot.rootId) return;
+    recomputeNodeCounts(state2, currentNodeId, currentNode);
+    if (currentNodeId === state2.snapshot.rootId) return;
     const subtreeNodeDelta = currentNode.subtreeNodeCount - previousSubtreeNodeCount;
     const visibleSubtreeDelta = currentNode.visibleSubtreeCount - previousVisibleSubtreeCount;
     const parentId = currentNode.parentId;
-    if (subtreeNodeDelta !== 0 || visibleSubtreeDelta !== 0) applyChildAggregateDelta(getDirectoryIndex(state3, parentId), currentNodeId, subtreeNodeDelta, visibleSubtreeDelta);
+    if (subtreeNodeDelta !== 0 || visibleSubtreeDelta !== 0) applyChildAggregateDelta(getDirectoryIndex(state2, parentId), currentNodeId, subtreeNodeDelta, visibleSubtreeDelta);
     currentNodeId = parentId;
   }
 }
-function recomputeNodeCountsNow(state3, nodeId, currentNode, rebuildChildAggregates) {
+function recomputeNodeCountsNow(state2, nodeId, currentNode, rebuildChildAggregates) {
   if (!isDirectoryNode(currentNode)) {
     currentNode.subtreeNodeCount = 1;
     currentNode.visibleSubtreeCount = 1;
     return;
   }
-  const currentIndex = getDirectoryIndex(state3, nodeId);
+  const currentIndex = getDirectoryIndex(state2, nodeId);
   if (rebuildChildAggregates) {
-    const instrumentation = state3.instrumentation;
-    if (instrumentation == null) rebuildDirectoryChildAggregates(state3.snapshot.nodes, currentIndex);
-    else withBenchmarkPhase(instrumentation, "store.recomputeNodeCounts.rebuildChildAggregates", () => rebuildDirectoryChildAggregates(state3.snapshot.nodes, currentIndex));
+    const instrumentation = state2.instrumentation;
+    if (instrumentation == null) rebuildDirectoryChildAggregates(state2.snapshot.nodes, currentIndex);
+    else withBenchmarkPhase(instrumentation, "store.recomputeNodeCounts.rebuildChildAggregates", () => rebuildDirectoryChildAggregates(state2.snapshot.nodes, currentIndex));
   }
   const subtreeNodeCount = 1 + currentIndex.totalChildSubtreeNodeCount;
   const visibleChildCount = currentIndex.totalChildVisibleSubtreeCount;
@@ -23429,10 +23527,10 @@ function recomputeNodeCountsNow(state3, nodeId, currentNode, rebuildChildAggrega
     currentNode.visibleSubtreeCount = visibleChildCount;
     return;
   }
-  currentNode.visibleSubtreeCount = getFlattenedChildDirectoryId(state3, nodeId) != null ? visibleChildCount : isDirectoryExpanded(state3, nodeId, currentNode) ? 1 + visibleChildCount : 1;
+  currentNode.visibleSubtreeCount = getFlattenedChildDirectoryId(state2, nodeId) != null ? visibleChildCount : isDirectoryExpanded(state2, nodeId, currentNode) ? 1 + visibleChildCount : 1;
 }
-function buildPathPreview(state3, parentId, basename3) {
-  const parentPath = materializeNodePath(state3, parentId);
+function buildPathPreview(state2, parentId, basename3) {
+  const parentPath = materializeNodePath(state2, parentId);
   return parentPath.length === 0 ? basename3 : `${parentPath}${basename3}`;
 }
 
@@ -23440,16 +23538,16 @@ function buildPathPreview(state3, parentId, basename3) {
 function isLiveNode(node) {
   return node != null && !hasNodeFlag(node, 4);
 }
-function isLiveDirectoryNode(state3, nodeId) {
-  const node = state3.snapshot.nodes[nodeId];
+function isLiveDirectoryNode(state2, nodeId) {
+  const node = state2.snapshot.nodes[nodeId];
   if (!isLiveNode(node) || !isDirectoryNode(node) || hasNodeFlag(node, 2)) return null;
   return node;
 }
-function countCachedPathEntries(state3) {
+function countCachedPathEntries(state2) {
   let cachedPathEntryCount = 0;
-  for (const [nodeId, cachedEntry] of state3.pathCacheByNodeId) {
-    if (cachedEntry.version !== state3.pathCacheVersion) continue;
-    if (!isLiveNode(state3.snapshot.nodes[nodeId])) continue;
+  for (const [nodeId, cachedEntry] of state2.pathCacheByNodeId) {
+    if (cachedEntry.version !== state2.pathCacheVersion) continue;
+    if (!isLiveNode(state2.snapshot.nodes[nodeId])) continue;
     cachedPathEntryCount += 1;
   }
   return cachedPathEntryCount;
@@ -23457,13 +23555,13 @@ function countCachedPathEntries(state3) {
 function countSegmentEntries(segmentTable) {
   return Math.max(0, segmentTable.valueById.length - 1);
 }
-function createCleanupMetricSnapshot(state3) {
+function createCleanupMetricSnapshot(state2) {
   return {
-    activeNodeCount: state3.activeNodeCount,
-    cachedPathEntryCount: countCachedPathEntries(state3),
-    loadInfoEntryCount: state3.directoryLoadInfoById.size,
-    segmentCount: countSegmentEntries(state3.snapshot.segmentTable),
-    totalNodeSlotCount: Math.max(0, state3.snapshot.nodes.length - 1)
+    activeNodeCount: state2.activeNodeCount,
+    cachedPathEntryCount: countCachedPathEntries(state2),
+    loadInfoEntryCount: state2.directoryLoadInfoById.size,
+    segmentCount: countSegmentEntries(state2.snapshot.segmentTable),
+    totalNodeSlotCount: Math.max(0, state2.snapshot.nodes.length - 1)
   };
 }
 function createCleanupResult(mode2, idsPreserved, before, after) {
@@ -23486,20 +23584,20 @@ function createCleanupResult(mode2, idsPreserved, before, after) {
     totalNodeSlotCountBefore: before.totalNodeSlotCount
   };
 }
-function collectExpansionOverridePaths(state3) {
+function collectExpansionOverridePaths(state2) {
   const collapsedPaths = [];
   const expandedPaths = [];
-  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));
+  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));
   return {
     collapsedPaths,
     expandedPaths
   };
 }
-function collectDirectoryLoadInfos(state3) {
+function collectDirectoryLoadInfos(state2) {
   const retainedInfos = [];
-  for (const [nodeId, info] of state3.directoryLoadInfoById) {
-    if (isLiveDirectoryNode(state3, nodeId) == null || getDirectoryLoadState(state3, nodeId) === "loaded") continue;
+  for (const [nodeId, info] of state2.directoryLoadInfoById) {
+    if (isLiveDirectoryNode(state2, nodeId) == null || getDirectoryLoadState(state2, nodeId) === "loaded") continue;
     retainedInfos.push({
       info: {
         activeAttemptId: null,
@@ -23507,33 +23605,33 @@ function collectDirectoryLoadInfos(state3) {
         nextAttemptId: info.nextAttemptId,
         state: info.state
       },
-      path: materializeNodePath(state3, nodeId)
+      path: materializeNodePath(state2, nodeId)
     });
   }
   return retainedInfos;
 }
-function restoreExpansionOverridePaths(state3, persistedExpansionState) {
-  state3.collapsedDirectoryIds.clear();
-  state3.hasCollapsedDirectoryOverrides = false;
-  state3.expandedDirectoryIds.clear();
+function restoreExpansionOverridePaths(state2, persistedExpansionState) {
+  state2.collapsedDirectoryIds.clear();
+  state2.hasCollapsedDirectoryOverrides = false;
+  state2.expandedDirectoryIds.clear();
   for (const path of persistedExpansionState.expandedPaths) {
-    const nodeId = findNodeId(state3, path);
+    const nodeId = findNodeId(state2, path);
     if (nodeId == null) continue;
-    setDirectoryExpanded(state3, nodeId, true, requireNode(state3, nodeId));
+    setDirectoryExpanded(state2, nodeId, true, requireNode(state2, nodeId));
   }
   for (const path of persistedExpansionState.collapsedPaths) {
-    const nodeId = findNodeId(state3, path);
+    const nodeId = findNodeId(state2, path);
     if (nodeId == null) continue;
-    setDirectoryExpanded(state3, nodeId, false, requireNode(state3, nodeId));
+    setDirectoryExpanded(state2, nodeId, false, requireNode(state2, nodeId));
   }
 }
-function restoreDirectoryLoadInfos(state3, persistedLoadInfos) {
-  state3.directoryLoadInfoById.clear();
+function restoreDirectoryLoadInfos(state2, persistedLoadInfos) {
+  state2.directoryLoadInfoById.clear();
   for (const retainedInfo of persistedLoadInfos) {
-    const nodeId = findNodeId(state3, retainedInfo.path);
+    const nodeId = findNodeId(state2, retainedInfo.path);
     if (nodeId == null) continue;
-    if (isLiveDirectoryNode(state3, nodeId) == null) continue;
-    state3.directoryLoadInfoById.set(nodeId, {
+    if (isLiveDirectoryNode(state2, nodeId) == null) continue;
+    state2.directoryLoadInfoById.set(nodeId, {
       activeAttemptId: null,
       errorMessage: retainedInfo.info.errorMessage,
       nextAttemptId: retainedInfo.info.nextAttemptId,
@@ -23541,18 +23639,18 @@ function restoreDirectoryLoadInfos(state3, persistedLoadInfos) {
     });
   }
 }
-function clearPathCaches(state3) {
-  state3.pathCacheVersion += 1;
-  state3.pathCacheByNodeId.clear();
-  state3.pathCacheByNodeId.set(state3.snapshot.rootId, {
+function clearPathCaches(state2) {
+  state2.pathCacheVersion += 1;
+  state2.pathCacheByNodeId.clear();
+  state2.pathCacheByNodeId.set(state2.snapshot.rootId, {
     path: "",
-    version: state3.pathCacheVersion
+    version: state2.pathCacheVersion
   });
 }
-function rebuildSegmentTablePreservingNodeIds(state3) {
-  const previousSegmentTable = state3.snapshot.segmentTable;
+function rebuildSegmentTablePreservingNodeIds(state2) {
+  const previousSegmentTable = state2.snapshot.segmentTable;
   const nextSegmentTable = createSegmentTable();
-  for (const node of state3.snapshot.nodes) {
+  for (const node of state2.snapshot.nodes) {
     if (!isLiveNode(node)) continue;
     if (hasNodeFlag(node, 2)) {
       node.nameId = 0;
@@ -23560,75 +23658,75 @@ function rebuildSegmentTablePreservingNodeIds(state3) {
     }
     node.nameId = internSegment(nextSegmentTable, getSegmentValue(previousSegmentTable, node.nameId));
   }
-  state3.snapshot.segmentTable = nextSegmentTable;
+  state2.snapshot.segmentTable = nextSegmentTable;
 }
-function rebuildDirectoryIndexes(state3) {
-  for (const [directoryId, directoryIndex] of state3.snapshot.directories) {
-    const directoryNode = state3.snapshot.nodes[directoryId];
+function rebuildDirectoryIndexes(state2) {
+  for (const [directoryId, directoryIndex] of state2.snapshot.directories) {
+    const directoryNode = state2.snapshot.nodes[directoryId];
     if (!isLiveNode(directoryNode) || !isDirectoryNode(directoryNode)) {
-      state3.snapshot.directories.delete(directoryId);
+      state2.snapshot.directories.delete(directoryId);
       continue;
     }
     const liveChildIds = directoryIndex.childIds.filter((childId) => {
-      const childNode = state3.snapshot.nodes[childId];
+      const childNode = state2.snapshot.nodes[childId];
       return isLiveNode(childNode) && childNode.parentId === directoryId;
     });
     directoryIndex.childIds = liveChildIds;
-    directoryIndex.childIdByNameId = new Map(liveChildIds.map((childId) => [requireNode(state3, childId).nameId, childId]));
+    directoryIndex.childIdByNameId = new Map(liveChildIds.map((childId) => [requireNode(state2, childId).nameId, childId]));
     directoryIndex.childPositionById = new Map(liveChildIds.map((childId, childIndex) => [childId, childIndex]));
-    rebuildDirectoryChildAggregates(state3.snapshot.nodes, directoryIndex);
+    rebuildDirectoryChildAggregates(state2.snapshot.nodes, directoryIndex);
   }
 }
-function trimTrailingRemovedNodeSlots(state3) {
-  let lastNodeIndex = state3.snapshot.nodes.length - 1;
-  while (lastNodeIndex > state3.snapshot.rootId) {
-    const node = state3.snapshot.nodes[lastNodeIndex];
+function trimTrailingRemovedNodeSlots(state2) {
+  let lastNodeIndex = state2.snapshot.nodes.length - 1;
+  while (lastNodeIndex > state2.snapshot.rootId) {
+    const node = state2.snapshot.nodes[lastNodeIndex];
     if (isLiveNode(node)) break;
     lastNodeIndex -= 1;
   }
-  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", () => {
+  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", () => {
     const builder = new PathStoreBuilder(builderOptions);
     builder.appendPaths(canonicalPaths);
     return builder.finish();
   });
-  state3.snapshot = rebuiltSnapshot;
-  state3.activeNodeCount = rebuiltSnapshot.nodes.length - 1;
-  state3.pathCacheByNodeId = /* @__PURE__ */ new Map([[rebuiltSnapshot.rootId, {
+  state2.snapshot = rebuiltSnapshot;
+  state2.activeNodeCount = rebuiltSnapshot.nodes.length - 1;
+  state2.pathCacheByNodeId = /* @__PURE__ */ new Map([[rebuiltSnapshot.rootId, {
     path: "",
     version: 0
   }]]);
-  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));
+  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));
 }
-function hasActiveCleanupBlockingLoads(state3) {
-  for (const loadInfo of state3.directoryLoadInfoById.values()) if (loadInfo.state === "loading" && loadInfo.activeAttemptId != null) return true;
+function hasActiveCleanupBlockingLoads(state2) {
+  for (const loadInfo of state2.directoryLoadInfoById.values()) if (loadInfo.state === "loading" && loadInfo.activeAttemptId != null) return true;
   return false;
 }
-function cleanupPathStoreState(state3, mode2) {
-  const before = createCleanupMetricSnapshot(state3);
-  if (mode2 === "stable") withBenchmarkPhase(state3.instrumentation, "store.cleanup.stable", () => runStableCleanup(state3));
-  else withBenchmarkPhase(state3.instrumentation, "store.cleanup.aggressive", () => runAggressiveCleanup(state3));
-  const after = createCleanupMetricSnapshot(state3);
+function cleanupPathStoreState(state2, mode2) {
+  const before = createCleanupMetricSnapshot(state2);
+  if (mode2 === "stable") withBenchmarkPhase(state2.instrumentation, "store.cleanup.stable", () => runStableCleanup(state2));
+  else withBenchmarkPhase(state2.instrumentation, "store.cleanup.aggressive", () => runAggressiveCleanup(state2));
+  const after = createCleanupMetricSnapshot(state2);
   return createCleanupResult(mode2, mode2 === "stable", before, after);
 }
 
@@ -23644,33 +23742,33 @@ function ensureProjectionDepthCapacity(depthTable, depth) {
   nextDepthTable.set(depthTable);
   return nextDepthTable;
 }
-function getVisibleCount(state3) {
-  return requireNode(state3, state3.snapshot.rootId).visibleSubtreeCount;
+function getVisibleCount(state2) {
+  return requireNode(state2, state2.snapshot.rootId).visibleSubtreeCount;
 }
-function getVisibleRowSubtreeEndIndex(state3, cursor, index, totalVisibleCount) {
-  const terminalNode = requireNode(state3, cursor.terminalNodeId);
+function getVisibleRowSubtreeEndIndex(state2, cursor, index, totalVisibleCount) {
+  const terminalNode = requireNode(state2, cursor.terminalNodeId);
   const subtreeSize = Math.max(1, terminalNode.visibleSubtreeCount);
   return Math.min(totalVisibleCount - 1, index + subtreeSize - 1);
 }
-function materializeVisibleAncestorRow(state3, entry, totalVisibleCount, ancestorPaths) {
+function materializeVisibleAncestorRow(state2, entry, totalVisibleCount, ancestorPaths) {
   return {
     ancestorPaths,
     index: entry.index,
     posInSet: entry.posInSet,
-    row: materializeVisibleRow(state3, entry.cursor),
+    row: materializeVisibleRow(state2, entry.cursor),
     setSize: entry.setSize,
-    subtreeEndIndex: getVisibleRowSubtreeEndIndex(state3, entry.cursor, entry.index, totalVisibleCount)
+    subtreeEndIndex: getVisibleRowSubtreeEndIndex(state2, entry.cursor, entry.index, totalVisibleCount)
   };
 }
-function selectVisibleRowContextWithinDirectory(state3, directoryNodeId, index, directoryStartIndex, parentVisibleDepth, ancestors2) {
-  const directoryIndex = getDirectoryIndex(state3, directoryNodeId);
-  const { childIndex, childVisibleIndex, localVisibleIndex } = selectChildIndexByVisibleIndex(state3.snapshot.nodes, directoryIndex, index);
+function selectVisibleRowContextWithinDirectory(state2, directoryNodeId, index, directoryStartIndex, parentVisibleDepth, ancestors2) {
+  const directoryIndex = getDirectoryIndex(state2, directoryNodeId);
+  const { childIndex, childVisibleIndex, localVisibleIndex } = selectChildIndexByVisibleIndex(state2.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(state3, childId, localVisibleIndex, directoryStartIndex + childVisibleIndex, parentVisibleDepth + 1, childIndex, directoryIndex.childIds.length, ancestors2);
+  return selectVisibleRowContextWithinSubtree(state2, childId, localVisibleIndex, directoryStartIndex + childVisibleIndex, parentVisibleDepth + 1, childIndex, directoryIndex.childIds.length, ancestors2);
 }
-function selectVisibleRowContextWithinSubtree(state3, nodeId, index, rowIndex, visibleDepth, posInSet, setSize, ancestors2) {
-  if (!isDirectoryNode(requireNode(state3, nodeId))) {
+function selectVisibleRowContextWithinSubtree(state2, nodeId, index, rowIndex, visibleDepth, posInSet, setSize, ancestors2) {
+  if (!isDirectoryNode(requireNode(state2, nodeId))) {
     if (index === 0) return {
       ancestors: ancestors2,
       cursor: {
@@ -23684,7 +23782,7 @@ function selectVisibleRowContextWithinSubtree(state3, nodeId, index, rowIndex, v
     };
     throw new Error(`Visible index ${String(index)} is out of range for file`);
   }
-  const currentCursor = createVisibleRowCursor(state3, nodeId, visibleDepth);
+  const currentCursor = createVisibleRowCursor(state2, nodeId, visibleDepth);
   if (index === 0) return {
     ancestors: ancestors2,
     cursor: currentCursor,
@@ -23692,20 +23790,20 @@ function selectVisibleRowContextWithinSubtree(state3, nodeId, index, rowIndex, v
     posInSet,
     setSize
   };
-  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, {
+  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, {
     cursor: currentCursor,
     index: rowIndex,
     posInSet,
     setSize
   }]);
 }
-function getVisibleRowContext(state3, index) {
-  const totalVisibleCount = getVisibleCount(state3);
+function getVisibleRowContext(state2, index) {
+  const totalVisibleCount = getVisibleCount(state2);
   if (index < 0 || index >= totalVisibleCount) return null;
-  const selected = selectVisibleRowContextWithinDirectory(state3, state3.snapshot.rootId, index, 0, -1, []);
-  const ancestorPaths = selected.ancestors.map((ancestor) => materializeNodePath(state3, ancestor.cursor.terminalNodeId));
+  const selected = selectVisibleRowContextWithinDirectory(state2, state2.snapshot.rootId, index, 0, -1, []);
+  const ancestorPaths = selected.ancestors.map((ancestor) => materializeNodePath(state2, ancestor.cursor.terminalNodeId));
   let cachedAncestorRows = null;
   return {
     ancestorPaths,
@@ -23714,7 +23812,7 @@ function getVisibleRowContext(state3, index) {
       const ancestorRows = [];
       const rowAncestorPaths = [];
       for (const ancestor of selected.ancestors) {
-        const ancestorRow = materializeVisibleAncestorRow(state3, ancestor, totalVisibleCount, [...rowAncestorPaths]);
+        const ancestorRow = materializeVisibleAncestorRow(state2, ancestor, totalVisibleCount, [...rowAncestorPaths]);
         ancestorRows.push(ancestorRow);
         rowAncestorPaths.push(ancestorRow.row.path);
       }
@@ -23723,121 +23821,121 @@ function getVisibleRowContext(state3, index) {
     },
     index: selected.index,
     posInSet: selected.posInSet,
-    row: materializeVisibleRow(state3, selected.cursor),
+    row: materializeVisibleRow(state2, selected.cursor),
     setSize: selected.setSize,
-    subtreeEndIndex: getVisibleRowSubtreeEndIndex(state3, selected.cursor, selected.index, totalVisibleCount)
+    subtreeEndIndex: getVisibleRowSubtreeEndIndex(state2, selected.cursor, selected.index, totalVisibleCount)
   };
 }
-function getVisibleSlice(state3, start, end) {
-  const instrumentation = state3.instrumentation;
-  const totalVisibleCount = getVisibleCount(state3);
+function getVisibleSlice(state2, start, end) {
+  const instrumentation = state2.instrumentation;
+  const totalVisibleCount = getVisibleCount(state2);
   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(state3, normalizedEnd + 1);
+    if (normalizedStart === 0) return collectVisibleRowsDFS(state2, normalizedEnd + 1);
     const rows2 = [];
-    let currentCursor2 = selectVisibleRow(state3, normalizedStart);
+    let currentCursor2 = selectVisibleRow(state2, normalizedStart);
     for (let visibleIndex = normalizedStart; visibleIndex <= normalizedEnd && currentCursor2 != null; visibleIndex++) {
-      const row = materializeVisibleRow(state3, currentCursor2);
+      const row = materializeVisibleRow(state2, currentCursor2);
       rows2.push(row);
-      currentCursor2 = getNextVisibleRowCursor(state3, currentCursor2);
+      currentCursor2 = getNextVisibleRowCursor(state2, currentCursor2);
     }
     return rows2;
   }
   const rows = [];
   let flattenedRowCount = 0;
   let flattenedSegmentCount = 0;
-  let currentCursor = withBenchmarkPhase(instrumentation, "store.getVisibleSlice.selectFirstRow", () => selectVisibleRow(state3, normalizedStart));
+  let currentCursor = withBenchmarkPhase(instrumentation, "store.getVisibleSlice.selectFirstRow", () => selectVisibleRow(state2, normalizedStart));
   for (let visibleIndex = normalizedStart; visibleIndex <= normalizedEnd && currentCursor != null; visibleIndex++) {
-    const row = withBenchmarkPhase(instrumentation, "store.getVisibleSlice.materializeRow", () => materializeVisibleRow(state3, currentCursor));
+    const row = withBenchmarkPhase(instrumentation, "store.getVisibleSlice.materializeRow", () => materializeVisibleRow(state2, currentCursor));
     rows.push(row);
     if (row.isFlattened) {
       flattenedRowCount++;
       flattenedSegmentCount += row.flattenedSegments?.length ?? 0;
     }
-    currentCursor = withBenchmarkPhase(instrumentation, "store.getVisibleSlice.advanceCursor", () => getNextVisibleRowCursor(state3, currentCursor));
+    currentCursor = withBenchmarkPhase(instrumentation, "store.getVisibleSlice.advanceCursor", () => getNextVisibleRowCursor(state2, currentCursor));
   }
   setBenchmarkCounter(instrumentation, "workload.visibleRowsRead", rows.length);
   setBenchmarkCounter(instrumentation, "workload.flattenedRowsRead", flattenedRowCount);
   setBenchmarkCounter(instrumentation, "workload.flattenedSegmentsRead", flattenedSegmentCount);
   return rows;
 }
-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 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 getVisibleTreeProjection(state3) {
-  return createVisibleTreeProjectionFromData(getVisibleTreeProjectionData(state3));
+function getVisibleTreeProjection(state2) {
+  return createVisibleTreeProjectionFromData(getVisibleTreeProjectionData(state2));
 }
-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;
+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;
   let visibleIndex = 0;
   let currentNodeId = nodeId;
-  const { nodes, rootId } = state3.snapshot;
+  const { nodes, rootId } = state2.snapshot;
   while (currentNodeId !== rootId) {
-    const parentId = requireNode(state3, currentNodeId).parentId;
-    const parentIndex = getDirectoryIndex(state3, parentId);
+    const parentId = requireNode(state2, currentNodeId).parentId;
+    const parentIndex = getDirectoryIndex(state2, 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(state3, parentId);
-      const flattenedChildDirectoryId = getFlattenedChildDirectoryId(state3, parentId);
-      if (!isDirectoryExpanded(state3, parentId, parentNode) && flattenedChildDirectoryId !== currentNodeId) return null;
-      if (getFlattenedTerminalDirectoryId(state3, parentId) === parentId) visibleIndex += 1;
+      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;
     }
     currentNodeId = parentId;
   }
   return visibleIndex;
 }
-function expandPath(state3, path) {
-  const directoryNodeId = findNodeId(state3, path);
+function expandPath(state2, path) {
+  const directoryNodeId = findNodeId(state2, path);
   if (directoryNodeId == null) throw new Error(`Path does not exist: "${path}"`);
-  const directoryNode = requireNode(state3, directoryNodeId);
+  const directoryNode = requireNode(state2, directoryNodeId);
   if (!isDirectoryNode(directoryNode)) throw new Error(`Path is not a directory: "${path}"`);
-  if (isDirectoryExpanded(state3, directoryNodeId, directoryNode)) return null;
-  setDirectoryExpanded(state3, directoryNodeId, true, directoryNode);
-  recomputeCountsUpwardFrom(state3, directoryNodeId);
+  if (isDirectoryExpanded(state2, directoryNodeId, directoryNode)) return null;
+  setDirectoryExpanded(state2, directoryNodeId, true, directoryNode);
+  recomputeCountsUpwardFrom(state2, directoryNodeId);
   return createExpandEvent({
-    affectedAncestorIds: collectAncestorIds(state3, directoryNodeId),
+    affectedAncestorIds: collectAncestorIds(state2, directoryNodeId),
     affectedNodeIds: [directoryNodeId],
     path,
     projectionChanged: true
   });
 }
-function collapsePath(state3, path) {
-  const directoryNodeId = findNodeId(state3, path);
+function collapsePath(state2, path) {
+  const directoryNodeId = findNodeId(state2, path);
   if (directoryNodeId == null) throw new Error(`Path does not exist: "${path}"`);
-  const directoryNode = requireNode(state3, directoryNodeId);
+  const directoryNode = requireNode(state2, directoryNodeId);
   if (!isDirectoryNode(directoryNode)) throw new Error(`Path is not a directory: "${path}"`);
-  if (!isDirectoryExpanded(state3, directoryNodeId, directoryNode)) return null;
-  setDirectoryExpanded(state3, directoryNodeId, false, directoryNode);
-  recomputeCountsUpwardFrom(state3, directoryNodeId);
+  if (!isDirectoryExpanded(state2, directoryNodeId, directoryNode)) return null;
+  setDirectoryExpanded(state2, directoryNodeId, false, directoryNode);
+  recomputeCountsUpwardFrom(state2, directoryNodeId);
   return createCollapseEvent({
-    affectedAncestorIds: collectAncestorIds(state3, directoryNodeId),
+    affectedAncestorIds: collectAncestorIds(state2, directoryNodeId),
     affectedNodeIds: [directoryNodeId],
     path,
     projectionChanged: true
   });
 }
-function selectVisibleRow(state3, index) {
-  if (index < 0 || index >= getVisibleCount(state3)) return null;
-  return selectVisibleRowWithinDirectory(state3, state3.snapshot.rootId, index, -1);
+function selectVisibleRow(state2, index) {
+  if (index < 0 || index >= getVisibleCount(state2)) return null;
+  return selectVisibleRowWithinDirectory(state2, state2.snapshot.rootId, index, -1);
 }
-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));
+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));
   const childId = directoryIndex.childIds[childIndex];
-  if (childId != null) return selectVisibleRowWithinSubtree(state3, childId, localVisibleIndex, parentVisibleDepth + 1);
+  if (childId != null) return selectVisibleRowWithinSubtree(state2, childId, localVisibleIndex, parentVisibleDepth + 1);
   throw new Error(`Visible index ${String(index)} is out of range`);
 }
-function selectVisibleRowWithinSubtree(state3, nodeId, index, visibleDepth) {
-  if (!isDirectoryNode(requireNode(state3, nodeId))) {
+function selectVisibleRowWithinSubtree(state2, nodeId, index, visibleDepth) {
+  if (!isDirectoryNode(requireNode(state2, nodeId))) {
     if (index === 0) return {
       headNodeId: nodeId,
       terminalNodeId: nodeId,
@@ -23845,57 +23943,57 @@ function selectVisibleRowWithinSubtree(state3, nodeId, index, visibleDepth) {
     };
     throw new Error(`Visible index ${String(index)} is out of range for file`);
   }
-  const currentCursor = createVisibleRowCursor(state3, nodeId, visibleDepth);
+  const currentCursor = createVisibleRowCursor(state2, nodeId, visibleDepth);
   if (index === 0) return currentCursor;
-  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);
+  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);
 }
-function createVisibleRowCursor(state3, nodeId, visibleDepth) {
-  if (!isDirectoryNode(requireNode(state3, nodeId))) return {
+function createVisibleRowCursor(state2, nodeId, visibleDepth) {
+  if (!isDirectoryNode(requireNode(state2, nodeId))) return {
     headNodeId: nodeId,
     terminalNodeId: nodeId,
     visibleDepth
   };
-  if (state3.instrumentation == null) return {
+  if (state2.instrumentation == null) return {
     headNodeId: nodeId,
-    terminalNodeId: getFlattenedTerminalDirectoryId(state3, nodeId),
+    terminalNodeId: getFlattenedTerminalDirectoryId(state2, nodeId),
     visibleDepth
   };
   return {
     headNodeId: nodeId,
-    terminalNodeId: withBenchmarkPhase(state3.instrumentation, "store.getVisibleSlice.flatten.resolveTerminalDirectory", () => getFlattenedTerminalDirectoryId(state3, nodeId)),
+    terminalNodeId: withBenchmarkPhase(state2.instrumentation, "store.getVisibleSlice.flatten.resolveTerminalDirectory", () => getFlattenedTerminalDirectoryId(state2, nodeId)),
     visibleDepth
   };
 }
-function isVisibleRowHeadNode(state3, nodeId) {
-  const node = requireNode(state3, nodeId);
+function isVisibleRowHeadNode(state2, nodeId) {
+  const node = requireNode(state2, nodeId);
   if (!isDirectoryNode(node)) return true;
   const parentId = node.parentId;
-  if (parentId === state3.snapshot.rootId) return true;
-  return getFlattenedChildDirectoryId(state3, parentId) !== nodeId;
+  if (parentId === state2.snapshot.rootId) return true;
+  return getFlattenedChildDirectoryId(state2, parentId) !== nodeId;
 }
-function getNextVisibleRowCursor(state3, currentCursor) {
-  const terminalNode = requireNode(state3, currentCursor.terminalNodeId);
+function getNextVisibleRowCursor(state2, currentCursor) {
+  const terminalNode = requireNode(state2, currentCursor.terminalNodeId);
   if (isDirectoryNode(terminalNode)) {
-    const currentIndex = getDirectoryIndex(state3, currentCursor.terminalNodeId);
-    if (isDirectoryExpanded(state3, currentCursor.terminalNodeId, terminalNode) && currentIndex.childIds.length > 0) {
+    const currentIndex = getDirectoryIndex(state2, currentCursor.terminalNodeId);
+    if (isDirectoryExpanded(state2, currentCursor.terminalNodeId, terminalNode) && currentIndex.childIds.length > 0) {
       const firstChildId = currentIndex.childIds[0];
-      return firstChildId == null ? null : selectVisibleRowWithinSubtree(state3, firstChildId, 0, currentCursor.visibleDepth + 1);
+      return firstChildId == null ? null : selectVisibleRowWithinSubtree(state2, firstChildId, 0, currentCursor.visibleDepth + 1);
     }
   }
   let currentNodeId = currentCursor.terminalNodeId;
   let currentVisibleDepth = currentCursor.visibleDepth;
   while (true) {
-    const currentNode = requireNode(state3, currentNodeId);
-    if (currentNodeId === state3.snapshot.rootId) return null;
+    const currentNode = requireNode(state2, currentNodeId);
+    if (currentNodeId === state2.snapshot.rootId) return null;
     const parentId = currentNode.parentId;
-    const parentIndex = getDirectoryIndex(state3, parentId);
+    const parentIndex = getDirectoryIndex(state2, 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(state3, nextSiblingId, 0, currentVisibleDepth);
-    if (isVisibleRowHeadNode(state3, currentNodeId)) currentVisibleDepth--;
+    if (nextSiblingId != null) return selectVisibleRowWithinSubtree(state2, nextSiblingId, 0, currentVisibleDepth);
+    if (isVisibleRowHeadNode(state2, currentNodeId)) currentVisibleDepth--;
     currentNodeId = parentId;
   }
 }
@@ -23920,7 +24018,7 @@ function createVisibleTreeProjectionFromData(projection) {
     }
   };
 }
-function buildVisibleTreeProjectionDataDFS(state3, maxRows) {
+function buildVisibleTreeProjectionDataDFS(state2, maxRows) {
   const paths = new Array(maxRows);
   const parentRowIndex = new Int32Array(maxRows);
   const posInSetByIndex = new Int32Array(maxRows);
@@ -23928,16 +24026,16 @@ function buildVisibleTreeProjectionDataDFS(state3, maxRows) {
   let lastRowAtDepth = new Int32Array(INITIAL_PROJECTION_DEPTH_CAPACITY);
   lastRowAtDepth.fill(-1);
   let rowCount = 0;
-  const { nodes, directories, segmentTable } = state3.snapshot;
+  const { nodes, directories, segmentTable } = state2.snapshot;
   const stack = [[
-    directories.get(state3.snapshot.rootId),
+    directories.get(state2.snapshot.rootId),
     0,
     -1,
     ""
   ]];
-  const flattenEnabled = state3.snapshot.options.flattenEmptyDirectories;
-  const pathCacheByNodeId = state3.pathCacheByNodeId;
-  const pathCacheVersion = state3.pathCacheVersion;
+  const flattenEnabled = state2.snapshot.options.flattenEmptyDirectories;
+  const pathCacheByNodeId = state2.pathCacheByNodeId;
+  const pathCacheVersion = state2.pathCacheVersion;
   const segmentValues = segmentTable.valueById;
   while (stack.length > 0 && rowCount < maxRows) {
     const frame = stack[stack.length - 1];
@@ -23958,8 +24056,8 @@ function buildVisibleTreeProjectionDataDFS(state3, maxRows) {
       const cachedPathEntry = pathCacheByNodeId.get(childId);
       path = cachedPathEntry != null && cachedPathEntry.version === pathCacheVersion ? cachedPathEntry.path : `${parentPath}${segmentValues[childNode.nameId]}`;
     } else {
-      terminalNodeId = flattenEnabled ? getFlattenedTerminalDirectoryId(state3, childId) : childId;
-      path = terminalNodeId === childId ? `${parentPath}${segmentValues[childNode.nameId]}/` : materializeNodePath(state3, terminalNodeId);
+      terminalNodeId = flattenEnabled ? getFlattenedTerminalDirectoryId(state2, childId) : childId;
+      path = terminalNodeId === childId ? `${parentPath}${segmentValues[childNode.nameId]}/` : materializeNodePath(state2, terminalNodeId);
     }
     parentRowIndex[rowCount] = lastRowAtDepth[visibleDepth];
     paths[rowCount] = path;
@@ -23968,7 +24066,7 @@ function buildVisibleTreeProjectionDataDFS(state3, maxRows) {
     lastRowAtDepth[visibleDepth + 1] = rowCount;
     rowCount += 1;
     const terminalNode = nodes[terminalNodeId];
-    if (terminalNode != null && isDirectoryNode(terminalNode) && isDirectoryExpanded(state3, terminalNodeId, terminalNode)) stack.push([
+    if (terminalNode != null && isDirectoryNode(terminalNode) && isDirectoryExpanded(state2, terminalNodeId, terminalNode)) stack.push([
       directories.get(terminalNodeId),
       0,
       visibleDepth,
@@ -23996,19 +24094,19 @@ function buildVisibleTreeProjectionDataDFS(state3, maxRows) {
     }
   };
 }
-function collectVisibleRowsDFS(state3, maxRows) {
+function collectVisibleRowsDFS(state2, maxRows) {
   const rows = new Array(maxRows);
   let rowCount = 0;
-  const { nodes, directories, segmentTable } = state3.snapshot;
+  const { nodes, directories, segmentTable } = state2.snapshot;
   const stack = [[
-    directories.get(state3.snapshot.rootId),
+    directories.get(state2.snapshot.rootId),
     0,
     -1
   ]];
   const segmentValues = segmentTable.valueById;
-  const flattenEnabled = state3.snapshot.options.flattenEmptyDirectories;
-  const pathCacheByNodeId = state3.pathCacheByNodeId;
-  const pathCacheVersion = state3.pathCacheVersion;
+  const flattenEnabled = state2.snapshot.options.flattenEmptyDirectories;
+  const pathCacheByNodeId = state2.pathCacheByNodeId;
+  const pathCacheVersion = state2.pathCacheVersion;
   while (stack.length > 0 && rowCount < maxRows) {
     const frame = stack[stack.length - 1];
     const dirIndex = frame[0];
@@ -24032,19 +24130,19 @@ function collectVisibleRowsDFS(state3, maxRows) {
         kind: "file",
         loadState: void 0,
         name: segmentValues[childNode.nameId],
-        path: cachedPathEntry != null && cachedPathEntry.version === pathCacheVersion ? cachedPathEntry.path : materializeNodePath(state3, childId)
+        path: cachedPathEntry != null && cachedPathEntry.version === pathCacheVersion ? cachedPathEntry.path : materializeNodePath(state2, childId)
       };
       continue;
     }
-    const terminalNodeId = flattenEnabled ? getFlattenedTerminalDirectoryId(state3, childId) : childId;
+    const terminalNodeId = flattenEnabled ? getFlattenedTerminalDirectoryId(state2, childId) : childId;
     const cursor = {
       headNodeId: childId,
       terminalNodeId,
       visibleDepth
     };
-    rows[rowCount++] = materializeVisibleRow(state3, cursor);
+    rows[rowCount++] = materializeVisibleRow(state2, cursor);
     const terminalNode = nodes[terminalNodeId];
-    if (terminalNode != null && isDirectoryNode(terminalNode) && isDirectoryExpanded(state3, terminalNodeId, terminalNode)) stack.push([
+    if (terminalNode != null && isDirectoryNode(terminalNode) && isDirectoryExpanded(state2, terminalNodeId, terminalNode)) stack.push([
       directories.get(terminalNodeId),
       0,
       visibleDepth
@@ -24053,29 +24151,29 @@ function collectVisibleRowsDFS(state3, maxRows) {
   if (rowCount < maxRows) rows.length = rowCount;
   return rows;
 }
-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;
+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;
   const isFlattened = cursor.headNodeId !== cursor.terminalNodeId;
-  const instrumentation = state3.instrumentation;
-  const flattenedSegments = isFlattened ? instrumentation == null ? collectFlattenedDirectoryChainIds(state3, cursor.headNodeId).map((nodeId) => {
-    const node = requireNode(state3, nodeId);
+  const instrumentation = state2.instrumentation;
+  const flattenedSegments = isFlattened ? instrumentation == null ? collectFlattenedDirectoryChainIds(state2, cursor.headNodeId).map((nodeId) => {
+    const node = requireNode(state2, nodeId);
     return {
       isTerminal: nodeId === cursor.terminalNodeId,
-      name: getSegmentValue(state3.snapshot.segmentTable, node.nameId),
+      name: getSegmentValue(state2.snapshot.segmentTable, node.nameId),
       nodeId,
-      path: materializeNodePath(state3, nodeId)
+      path: materializeNodePath(state2, nodeId)
     };
-  }) : withBenchmarkPhase(instrumentation, "store.getVisibleSlice.flatten.collectSegments", () => collectFlattenedDirectoryChainIds(state3, cursor.headNodeId).map((nodeId) => {
-    const node = requireNode(state3, nodeId);
+  }) : withBenchmarkPhase(instrumentation, "store.getVisibleSlice.flatten.collectSegments", () => collectFlattenedDirectoryChainIds(state2, cursor.headNodeId).map((nodeId) => {
+    const node = requireNode(state2, nodeId);
     return {
       isTerminal: nodeId === cursor.terminalNodeId,
-      name: getSegmentValue(state3.snapshot.segmentTable, node.nameId),
+      name: getSegmentValue(state2.snapshot.segmentTable, node.nameId),
       nodeId,
-      path: materializeNodePath(state3, nodeId)
+      path: materializeNodePath(state2, nodeId)
     };
   })) : void 0;
   return {
@@ -24083,7 +24181,7 @@ function materializeVisibleRow(state3, cursor) {
     flattenedSegments,
     hasChildren,
     id: cursor.terminalNodeId,
-    isExpanded: isDirectoryNode(terminalNode) && isDirectoryExpanded(state3, cursor.terminalNodeId, terminalNode),
+    isExpanded: isDirectoryNode(terminalNode) && isDirectoryExpanded(state2, cursor.terminalNodeId, terminalNode),
     isFlattened,
     isLoading: loadState === "loading",
     kind: isDirectoryNode(terminalNode) ? "directory" : "file",
@@ -24092,13 +24190,13 @@ function materializeVisibleRow(state3, cursor) {
     path
   };
 }
-function getVisibleRowLoadState(state3, cursor) {
-  if (cursor.headNodeId === cursor.terminalNodeId) return getDirectoryLoadState(state3, cursor.terminalNodeId);
-  const chainNodeIds = collectFlattenedDirectoryChainIds(state3, cursor.headNodeId);
+function getVisibleRowLoadState(state2, cursor) {
+  if (cursor.headNodeId === cursor.terminalNodeId) return getDirectoryLoadState(state2, cursor.terminalNodeId);
+  const chainNodeIds = collectFlattenedDirectoryChainIds(state2, cursor.headNodeId);
   let hasUnloaded = false;
   let hasError = false;
   for (const nodeId of chainNodeIds) {
-    const loadState = getDirectoryLoadState(state3, nodeId);
+    const loadState = getDirectoryLoadState(state2, nodeId);
     if (loadState === "loading") return "loading";
     if (loadState === "error") {
       hasError = true;
@@ -24192,8 +24290,8 @@ function sweepOpenVisibleCountsSoa(store2) {
 }
 
 // node_modules/@pierre/trees/dist/path-store/src/store.js
-function initializeOpenVisibleCounts(state3) {
-  const { directories, nodes, options, rootId, presortedDirectoryNodeIds } = state3.snapshot;
+function initializeOpenVisibleCounts(state2) {
+  const { directories, nodes, options, rootId, presortedDirectoryNodeIds } = state2.snapshot;
   const flattenEmptyDirectories = options.flattenEmptyDirectories === true;
   const walkDirectory = (nodeId) => {
     const currentNode = nodes[nodeId];
@@ -24243,9 +24341,9 @@ function initializeOpenVisibleCounts(state3) {
   rootNode.subtreeNodeCount = 1 + rootTotalChildSubtreeNodeCount;
   rootNode.visibleSubtreeCount = rootTotalChildVisibleSubtreeCount;
 }
-function initializeOpenVisibleCountsViaSoa(state3) {
-  const { directories, nodes, rootId } = state3.snapshot;
-  const soa = buildSoaNodeStore(state3.snapshot);
+function initializeOpenVisibleCountsViaSoa(state2) {
+  const { directories, nodes, rootId } = state2.snapshot;
+  const soa = buildSoaNodeStore(state2.snapshot);
   sweepOpenVisibleCountsSoa(soa);
   const subtreeNodeCount = soa.subtreeNodeCount;
   const visibleSubtreeCount = soa.visibleSubtreeCount;
@@ -27369,17 +27467,17 @@ function RenameInput({ ariaLabel, isFlattened = false, ref, value, onBlur, onInp
 
 // node_modules/@pierre/trees/dist/render/rowAttributes.js
 function computeFileTreeRowElementAttributes(input) {
-  const { row, mode: mode2, targetPath, ariaLabel, domId, isParked, itemHeight, features, state: state3, extraStyle } = input;
+  const { row, mode: mode2, targetPath, ariaLabel, domId, isParked, itemHeight, features, state: state2, extraStyle } = input;
   const isSticky = mode2 === "sticky";
   const parentPath = row.ancestorPaths.at(-1) ?? "";
   const stateAttributes = {};
-  if (state3.isFocusRinged) stateAttributes["data-item-focused"] = true;
+  if (state2.isFocusRinged) stateAttributes["data-item-focused"] = true;
   if (row.isSelected) stateAttributes["data-item-selected"] = 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";
+  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";
   return {
     "aria-expanded": !isSticky && row.kind === "directory" ? row.isExpanded : void 0,
     "aria-haspopup": features.contextMenuEnabled ? "menu" : void 0,
@@ -30189,19 +30287,10 @@ var lickLabels = {
   "sudo-request": ["Permission", "notice"]
 };
 var toolStates = {
-  running: [
-    "Running",
-    b`<swc-progress-circle size="s" label="Running" aria-hidden="true"></swc-progress-circle>`
-  ],
-  done: [
-    "Done",
-    b`<swc-icon-checkmark-circle size="s" aria-hidden="true"></swc-icon-checkmark-circle>`
-  ],
-  error: [
-    "Failed",
-    b`<swc-icon-alert-diamond size="s" aria-hidden="true"></swc-icon-alert-diamond>`
-  ],
-  cancelled: ["Cancelled", b`<swc-icon-cancel size="s" aria-hidden="true"></swc-icon-cancel>`]
+  running: "Running",
+  done: "Done",
+  error: "Failed",
+  cancelled: "Cancelled"
 };
 var stepStates = {
   running: "active",
@@ -30291,11 +30380,8 @@ function toolSummary(calls) {
   }
   return [...counts].sort((a23, b13) => b13[1] - a23[1]).map(([kind, count]) => `${count} ${count === 1 ? kind.one : kind.many}`).join(", ");
 }
-function state2(status2, label = toolStates[status2][0]) {
-  return b`<span class="state" data-state=${status2}>${toolStates[status2][1]}<span>${label}</span></span>`;
-}
 function statusLabel2(status2) {
-  return toolStates[status2][0];
+  return toolStates[status2];
 }
 function overall(calls) {
   const count = (status3) => calls.filter((call) => call.status === status3).length;
@@ -30418,32 +30504,31 @@ function notes(list5) {
 }
 function tool(call, color = "light", options = {}) {
   const kind = toolKind(call.name);
-  return b`<details class=${options.run ? "tool run" : "tool"} id=${`run-${call.id}`} data-id=${options.owner?.id ?? A} data-status=${call.status} data-tool=${call.name} data-kind=${kind.id} ?open=${!!options.open} @toggle=${options.toggle ?? A}>
-    <summary aria-label=${`${call.title}, ${statusLabel2(call.status)}`}>
-      <span class="head">
-        <swc-icon-chevron-right class="chevron" size="s" aria-hidden="true"></swc-icon-chevron-right>
-        ${chip(call, options.model ?? null)}
-        <span class="title">${call.title}</span>
-        <span class="name">${call.name}</span>
-        ${call.meta ? b`<span class="tool-meta">${call.meta}</span>` : A}
-        ${state2(call.status)}
-      </span>
-      ${call.image ? b`<span class="thumb"><img src=${call.image} alt="" /></span>` : A}
-    </summary>
-    <div class="call">
+  const label = `${call.title}, ${statusLabel2(call.status)}`;
+  const content = b`<div class="call">
       ${body(call, color)}
       ${call.output ? b`<pre class="output">${call.output}</pre>` : A}
       ${call.notes?.length ? notes(call.notes) : A}
       ${call.image ? b`<img class="shot" src=${call.image} alt=${call.title} />` : A}
+      ${call.meta ? b`<span class="tool-meta">${call.meta}</span>` : A}
       ${options.owner ? b`<span class="ran">Ran at ${when(options.owner.at)}</span>` : A}
-    </div>
+    </div>`;
+  if (!options.run) {
+    return b`<div class="tool" id=${`run-${call.id}`} role="region" aria-label=${label} data-id=${options.owner?.id ?? A} data-status=${call.status} data-tool=${call.name} data-kind=${kind.id}>${content}</div>`;
+  }
+  return b`<details class="tool run" id=${`run-${call.id}`} data-id=${options.owner?.id ?? A} data-status=${call.status} data-tool=${call.name} data-kind=${kind.id} ?open=${!!options.open} @toggle=${options.toggle ?? A}>
+    <summary class="strip" aria-label=${label}>
+      <span class="icons"><span class="run">${chip(call, options.model ?? null)}</span></span>
+      <span class="label">${call.title}</span>
+    </summary>
+    ${content}
   </details>`;
 }
 var clusterSize = 3;
 function runs(calls, handlers) {
   const groups2 = calls.length >= clusterSize ? [calls] : calls.map((call) => [call]);
   return groups2.map(
-    (group) => b`<slicc-tool-runs .calls=${group} .model=${handlers.model} .owners=${handlers.owners ?? null} .color=${handlers.color}></slicc-tool-runs>`
+    (group) => b`<slicc-tool-runs .calls=${group} .agent=${handlers.agentId ?? ""} .model=${handlers.model} .owners=${handlers.owners ?? null} .color=${handlers.color}></slicc-tool-runs>`
   );
 }
 function media(items) {
@@ -30981,21 +31066,6 @@ var messageCss = i`
   summary::-webkit-details-marker {
     display: none;
   }
-  details.tool > summary {
-    padding-inline: var(--swc-spacing-100);
-  }
-  details.tool > summary {
-    flex-direction: column;
-    align-items: stretch;
-    justify-content: center;
-    gap: 0;
-  }
-  details.tool > summary > .head {
-    display: flex;
-    align-items: center;
-    gap: var(--swc-spacing-100);
-    min-inline-size: 0;
-  }
   details.tool > summary:hover,
   .runs button:hover {
     background: var(--swc-gray-100);
@@ -31014,75 +31084,39 @@ var messageCss = i`
   details[open] > summary .chevron {
     transform: rotate(90deg);
   }
-  .tool .title,
-  .tool .name,
-  .runs .names,
-  .lick .text {
+  .lick .text,
+  .runs .label {
     min-inline-size: 0;
     overflow: hidden;
     text-overflow: ellipsis;
     white-space: nowrap;
   }
-  .tool .title {
-    flex: 0 1 auto;
-    font-weight: var(--swc-medium-font-weight);
-  }
   .lick .text {
     flex: 1;
   }
-  .tool .name {
-    flex: 0 0.001 auto;
-    max-inline-size: 50%;
-    font-family: var(--swc-code-font-family-stack);
-    color: var(--swc-neutral-subdued-content-color-default);
-  }
-  .tool-meta {
-    flex: none;
-    color: var(--swc-neutral-subdued-content-color-default);
-  }
-  .runs .summary .names {
-    flex: 0 1 auto;
-  }
-  .state {
-    display: inline-flex;
-    align-items: center;
-    gap: var(--swc-spacing-75);
-    flex: none;
-    margin-inline-start: auto;
-    padding-inline-start: var(--swc-spacing-100);
-    color: var(--swc-neutral-subdued-content-color-default);
-  }
-  .state[data-state='done'] swc-icon-checkmark-circle {
-    color: var(--swc-positive-visual-color);
-  }
-  .state[data-state='running'] {
-    color: var(--swc-neutral-content-color-default);
-  }
-  .state[data-state='error'] {
-    color: var(--swc-negative-content-color-default);
-    font-weight: var(--swc-bold-font-weight);
-  }
   swc-system-message > slicc-tool-runs + slicc-tool-runs {
     margin-block-start: var(--swc-spacing-75);
   }
   slicc-tool-runs {
     display: block;
+    container-type: inline-size;
   }
   .runs {
+    --run-size: var(--swc-spacing-500);
+    --run-gap: var(--swc-spacing-25);
+    --run-icons: calc(5 * var(--run-size) + 4 * var(--run-gap));
     display: flex;
     flex-direction: column;
-    align-items: center;
     min-inline-size: 0;
+    margin-inline: var(--swc-spacing-700);
   }
-  .runs > details.tool.run,
-  .runs > .cards {
-    align-self: stretch;
-  }
-  details.run > summary {
-    inline-size: fit-content;
-    max-inline-size: 100%;
-    margin-inline: auto;
-    padding-inline: var(--swc-spacing-100) var(--swc-spacing-200);
+  .strip {
+    display: grid;
+    grid-template-columns: var(--run-icons) minmax(0, 1fr);
+    align-items: center;
+    gap: var(--swc-spacing-50) var(--swc-spacing-200);
+    min-block-size: 0;
+    padding: var(--swc-spacing-50);
     border: var(--swc-border-width-100) solid var(--swc-gray-200);
     border-radius: var(--swc-corner-radius-500);
     background: var(--swc-background-layer-1-color);
@@ -31091,39 +31125,28 @@ var messageCss = i`
   details.run[open] > summary {
     margin-block-end: var(--swc-spacing-75);
   }
-  details.run > summary :is(.name, .tool-meta, .state[data-state='done'], .state[data-state='running']),
-  details.run > summary .thumb {
-    display: none;
-  }
-  details.run > summary .state {
-    padding-inline-start: 0;
-  }
-  details.run > .call {
-    padding-inline-start: var(--swc-spacing-100);
-  }
-  .strip {
+  .icons {
     display: flex;
-    flex-wrap: wrap;
+    gap: var(--run-gap);
+    overflow-x: auto;
+    scrollbar-width: none;
+  }
+  .icons > .run {
+    display: inline-flex;
+    flex: none;
     align-items: center;
     justify-content: center;
-    gap: var(--swc-spacing-50) var(--swc-spacing-100);
-    max-inline-size: 100%;
-    padding: var(--swc-spacing-50) var(--swc-spacing-75);
-    border: var(--swc-border-width-100) solid var(--swc-gray-200);
-    border-radius: var(--swc-corner-radius-500);
-    background: var(--swc-background-layer-1-color);
-    box-sizing: border-box;
+    inline-size: var(--run-size);
+    block-size: var(--run-size);
   }
-  .icons {
-    display: flex;
-    flex-wrap: wrap;
-    justify-content: center;
-    gap: var(--swc-spacing-25);
+  .runs .label {
+    block-size: var(--run-size);
+    padding-inline: var(--swc-spacing-100);
+    line-height: var(--run-size);
+    text-align: end;
+    font-weight: var(--swc-medium-font-weight);
   }
   .runs button {
-    display: inline-flex;
-    align-items: center;
-    gap: var(--swc-spacing-75);
     margin: 0;
     padding: 0;
     border: 0;
@@ -31137,25 +31160,21 @@ var messageCss = i`
     outline: var(--swc-focus-indicator-thickness) solid var(--swc-focus-indicator-color);
     outline-offset: calc(-1 * var(--swc-focus-indicator-thickness));
   }
-  button.run {
-    justify-content: center;
-    inline-size: var(--swc-spacing-500);
-    block-size: var(--swc-spacing-500);
-  }
   button.run[aria-expanded='true'] {
     background: var(--swc-accent-subtle-background-color-default);
   }
-  button.summary {
-    min-block-size: var(--swc-spacing-500);
-    min-inline-size: 0;
-    padding-inline: var(--swc-spacing-75) var(--swc-spacing-100);
-    color: var(--swc-neutral-subdued-content-color-default);
-  }
-  button.summary .state {
-    padding-inline-start: 0;
-  }
-  button.summary[aria-expanded='true'] .chevron {
-    transform: rotate(90deg);
+  @container (inline-size < 480px) {
+    .runs {
+      margin-inline: var(--swc-spacing-300);
+    }
+    .strip {
+      grid-template-columns: minmax(0, 1fr);
+    }
+    .icons {
+      inline-size: calc(
+        round(down, 100% + var(--run-gap), var(--run-size) + var(--run-gap)) - var(--run-gap)
+      );
+    }
   }
   .cards {
     margin-block-start: var(--swc-spacing-75);
@@ -31237,12 +31256,12 @@ var messageCss = i`
     display: flex;
     flex-direction: column;
     gap: var(--swc-spacing-100);
-    padding: var(--swc-spacing-75) var(--swc-spacing-100) var(--swc-spacing-200) var(--swc-spacing-500);
+    padding-block: var(--swc-spacing-75) var(--swc-spacing-200);
   }
   .call:empty {
     display: none;
   }
-  .call > .ran {
+  .call > :is(.ran, .tool-meta) {
     font-size: var(--swc-font-size-75);
     color: var(--swc-neutral-subdued-content-color-default);
   }
@@ -31302,19 +31321,6 @@ var messageCss = i`
     white-space: pre-wrap;
     overflow-wrap: anywhere;
   }
-  .thumb {
-    padding-inline-start: calc(var(--swc-spacing-100) + var(--swc-spacing-300));
-    padding-block: var(--swc-spacing-75);
-  }
-  .thumb img {
-    display: block;
-    max-inline-size: min(100%, calc(var(--swc-spacing-1000) * 2));
-    max-block-size: calc(var(--swc-spacing-1000) * 1.25);
-    border-radius: var(--swc-corner-radius-75);
-  }
-  details[open] > summary .thumb {
-    display: none;
-  }
   .shot {
     display: block;
     max-inline-size: min(100%, calc(var(--swc-spacing-1000) * 5));
@@ -31661,7 +31667,7 @@ function requiresText(item2, all2) {
   ].filter(Boolean);
   return parts2.length ? parts2.join("; ") : null;
 }
-var snapshot = (items) => new Map(items.map(({ id, state: state3, error }) => [id, { state: state3, error }]));
+var snapshot = (items) => new Map(items.map(({ id, state: state2, error }) => [id, { state: state2, error }]));
 function settled2(failures, before, after) {
   return new Map(
     [...failures].filter(([id]) => {
@@ -32077,8 +32083,8 @@ var SliccUpdates = class extends ModelElement {
     return b`<span>Checked <time datetime=${date.toISOString()}>${shown4}</time></span>`;
   }
   #item(item2) {
-    const [variant, state3] = states[item2.state];
-    const label = item2.state === "failed" && item2.from !== null ? "Update failed" : state3;
+    const [variant, state2] = states[item2.state];
+    const label = item2.state === "failed" && item2.from !== null ? "Update failed" : state2;
     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}>
@@ -33026,10 +33032,10 @@ var SliccApp = class extends ThemedElement {
       <swc-tooltip for="updates" placement="bottom">${text2}</swc-tooltip>`;
   }
   #tabsIndicator() {
-    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}`}>
+    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}`}>
         <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>`;
@@ -33048,9 +33054,9 @@ var SliccApp = class extends ThemedElement {
     const port = this.model?.network;
     if (!port || !this.#offers("network")) return A;
     const status2 = networkStatus(port);
-    const [variant, state3] = networkHealth[status2.health];
+    const [variant, state2] = 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"> ${state3.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"> ${state2.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>`;
   }
@@ -33349,6 +33355,10 @@ function origin() {
   const active = focused();
   return active?.closest("slicc-terminal") ?? active;
 }
+var inCwd = (approval) => approval.alwaysScope === "cwd" && !!approval.cwd;
+function alwaysHint(approval) {
+  return inCwd(approval) ? `Always allow lets ${approval.requester.name} run exactly this command with sudo, in ${approval.cwd}, without asking again.` : `Always allow lets ${approval.requester.name} run exactly this command with sudo without asking again.`;
+}
 function waiting(model, now) {
   return [...model?.approvals?.list() ?? []].filter((approval) => approval.expiresAt > now).sort((a23, b13) => a23.createdAt - b13.createdAt);
 }
@@ -33606,12 +33616,12 @@ var SliccApprovals = class extends ModelElement {
           ${this.#request(approval)}
           ${approval.cwd ? b`<p class="cwd">In ${approval.cwd}</p>` : A}
           ${rules ? b`<div class="rules" data-secret-rules=${rules}><swc-icon-alert-triangle size="s" aria-hidden="true"></swc-icon-alert-triangle><p>${verdict.certain ? b`<strong>This changes secret rules.</strong> It names <code>${rules}</code>, where SLICC keeps which secrets programs may use and where they may be sent.` : b`<strong>This may change secret rules.</strong> SLICC can't tell where <code>${rules}</code> leads, and it could reach the files where SLICC keeps which secrets programs may use and where they may be sent.`} Allow it only if you asked for this change.</p></div>` : A}
-          ${always ? b`<p class="hint">Always allow lets ${approval.requester.name} run exactly this command with sudo without asking again.</p>` : A}
+          ${always ? b`<p class="hint">${alwaysHint(approval)}</p>` : A}
           ${failure2 ? b`<p class="problem" role="alert" data-error><swc-icon-alert-triangle size="s" aria-hidden="true"></swc-icon-alert-triangle><span>${failure2}</span></p>` : A}
           <p class="timer" data-timer>Denied automatically in ${countdown(approval.expiresAt - this.now)}.</p>
           ${rest.length ? b`<p class="more" data-more>${rest.length === 1 ? "1 more request is waiting." : `${rest.length} more requests are waiting.`}</p>` : A}
           ${this.#button(approval, "deny", "Deny", "secondary")}
-          ${always ? this.#button(approval, "always", "Always allow", "secondary") : A}
+          ${always ? this.#button(approval, "always", inCwd(approval) ? "Always allow in this directory" : "Always allow", "secondary") : A}
           ${this.#button(approval, "once", "Allow once", "accent")}
         </sp-alert-dialog>`
     );
@@ -35727,6 +35737,7 @@ var navigation = /* @__PURE__ */ new Set([
   "PageUp",
   "PageDown"
 ]);
+var upward = /* @__PURE__ */ new Set(["ArrowUp", "PageUp", "Home"]);
 var compactWidth = 560;
 var failed = (message) => message.role === "assistant" ? message.status === "error" : message.role === "system" && message.kind === "error";
 function carriesFiles(event2) {
@@ -35923,7 +35934,7 @@ var SliccChat = class extends ThemedElement {
     model: null,
     readOnly: false,
     answer: (questionId, answer) => this.model?.agent.answer(this.#id(), questionId, answer),
-    resolve: (messageId, state3) => this.model?.agent.resolveLick(this.#id(), messageId, state3),
+    resolve: (messageId, state2) => this.model?.agent.resolveLick(this.#id(), messageId, state2),
     action: (action, messageId) => this.#action(action, messageId),
     dropping: (messageId) => failedTurns(this.model.agent.messages(this.#id()), messageId).length,
     open: (path) => this.dispatchEvent(
@@ -35974,6 +35985,12 @@ var SliccChat = class extends ThemedElement {
   }
   #stuck = true;
   #last = 0;
+  #height = 0;
+  #input = Number.NEGATIVE_INFINITY;
+  #up = Number.NEGATIVE_INFINITY;
+  #from = 0;
+  #start = 0;
+  #settle;
   #tail = "";
   #sent(agentId) {
     const last = this.model?.agent.messages(agentId).at(-1);
@@ -35988,12 +36005,42 @@ var SliccChat = class extends ThemedElement {
     const log = this.#log();
     log.scrollTop = log.scrollHeight;
     this.#last = log.scrollTop;
+    this.#height = log.scrollHeight;
   }
   #scroll = () => {
     const log = this.#log();
-    if (log.scrollHeight - log.scrollTop - log.clientHeight < 48) this.#stuck = true;
-    else if (log.scrollTop < this.#last) this.#stuck = false;
+    const reader = log.scrollHeight <= this.#height || this.#height - log.scrollTop - log.clientHeight >= 48 || performance.now() - this.#input < 1e3;
+    const rising = performance.now() - this.#up < 1e3 && log.scrollTop <= this.#from;
+    if (log.scrollHeight - log.scrollTop - log.clientHeight < 48) this.#stuck ||= !rising;
+    else if (reader && log.scrollTop < this.#last) this.#stuck = false;
     this.#last = log.scrollTop;
+    this.#height = log.scrollHeight;
+  };
+  #intent = {
+    passive: true,
+    handleEvent: (event2) => {
+      this.#input = performance.now();
+      const up = event2 instanceof WheelEvent ? event2.deltaY < 0 && !event2.ctrlKey : event2 instanceof KeyboardEvent && (upward.has(event2.key) || event2.key === " " && event2.shiftKey);
+      const at = this.#log().scrollTop;
+      if (!up || at <= 0) return;
+      this.#from = at;
+      this.#up = this.#input;
+      if (this.#settle === void 0) this.#start = Math.max(at, this.#last);
+      this.#stuck = false;
+      clearTimeout(this.#settle);
+      this.#settle = setTimeout(() => {
+        this.#settle = void 0;
+        if (this.#start - this.#log().scrollTop >= 48) return;
+        this.#stuck = true;
+        this.#pin();
+      }, 400);
+    }
+  };
+  #hold = (event2) => {
+    if (event2.target === event2.currentTarget) this.#input = Number.POSITIVE_INFINITY;
+  };
+  #release = () => {
+    if (this.#input === Number.POSITIVE_INFINITY) this.#input = performance.now();
   };
   #refresh(jump) {
     if (jump) this.#stuck = true;
@@ -36008,11 +36055,16 @@ var SliccChat = class extends ThemedElement {
   }
   connectedCallback() {
     super.connectedCallback();
+    globalThis.addEventListener("pointerup", this.#release, true);
+    globalThis.addEventListener("pointercancel", this.#release, true);
     if (this.hasUpdated) this.#observe();
   }
   disconnectedCallback() {
     super.disconnectedCallback();
+    globalThis.removeEventListener("pointerup", this.#release, true);
+    globalThis.removeEventListener("pointercancel", this.#release, true);
     this.#resize.disconnect();
+    clearTimeout(this.#settle);
   }
   firstUpdated() {
     this.#observe();
@@ -36184,6 +36236,7 @@ var SliccChat = class extends ThemedElement {
     const agent = this.#agent();
     const watch = watchOnly(this.model);
     this.#handlers.readOnly = !!agent?.frozen || !!watch;
+    this.#handlers.agentId = agent?.id;
     const messages = agent ? this.model?.agent.messages(agent.id) ?? [] : [];
     this.#tail = messages.at(-1)?.id ?? "";
     return b`
@@ -36198,6 +36251,11 @@ var SliccChat = class extends ThemedElement {
         aria-label="Conversation"
         tabindex="-1"
         @scroll=${this.#scroll}
+        @wheel=${this.#intent}
+        @touchstart=${this.#intent}
+        @touchmove=${this.#intent}
+        @keydown=${this.#intent}
+        @pointerdown=${this.#hold}
       >
         <div class="column" @keydown=${this.#keys}>
           ${agent && messages.length > 0 ? b`<swc-conversation-thread>${c(
@@ -37140,8 +37198,8 @@ function fieldOf(error, field) {
   return isVaultFailure(error) && error.code === "EINVAL" ? field : null;
 }
 function away(vault) {
-  const state3 = vault.availability?.() ?? (vault.status() ? "ready" : "waiting");
-  return state3 === "connecting" || state3 === "waiting";
+  const state2 = vault.availability?.() ?? (vault.status() ? "ready" : "waiting");
+  return state2 === "connecting" || state2 === "waiting";
 }
 function take(input) {
   const value = input.value;
@@ -37321,10 +37379,10 @@ var SliccVaultButton = class extends i2 {
       const at = order.indexOf(null);
       order[event2.direction === "next" ? at + 1 : at - 1]?.focus();
     } else if (event2.event === "popup") {
-      const { intent, state: state3 } = event2;
+      const { intent, state: state2 } = event2;
       this.dispatchEvent(
         new CustomEvent("vault-popup", {
-          detail: { intent, state: state3 },
+          detail: { intent, state: state2 },
           bubbles: true,
           composed: true
         })
@@ -37795,8 +37853,8 @@ var SliccComposer = class extends ThemedElement {
     ];
   }
   #held() {
-    const state3 = this.model?.follow?.state();
-    return state3?.link === "reconnecting" ? state3.owner : null;
+    const state2 = this.model?.follow?.state();
+    return state2?.link === "reconnecting" ? state2.owner : null;
   }
   #switch(id) {
     if (this.#agent)
@@ -38958,7 +39016,7 @@ var SliccNotices = class extends ModelElement {
 // src/app/secrets.ts
 var kinds = { secret: null, grant: "Sign-in", model: "Model key", mcp: "MCP server" };
 var lockModes = {
-  auto: "Unlocks with this browser",
+  auto: "Unlocks automatically in this browser",
   passkey: "Unlocks with a passkey",
   passphrase: "Unlocks with a passphrase"
 };
@@ -39219,6 +39277,7 @@ var SliccSecrets = class extends ThemedElement {
         font-weight: var(--swc-bold-font-weight);
       }
       .box .actions,
+      .locked,
       .buttons {
         display: flex;
         flex-wrap: wrap;
@@ -39782,7 +39841,7 @@ var SliccSecrets = class extends ThemedElement {
     </div>`;
   }
   #locked(locked) {
-    return locked ? b`<p class="muted" data-locked>Unlock the vault first</p>` : A;
+    return locked ? b`<div class="locked"><p class="muted" data-locked>Unlock the vault first</p>${this.#button({ intent: { kind: "unlock" }, label: "Unlock", size: "s", variant: "accent" }, "unlock")}</div>` : A;
   }
   #valueForm(vault, form, locked) {
     const save = () => this.save(vault);
@@ -40806,9 +40865,9 @@ function literal(value) {
     return "null";
   }
 }
-function store(state3) {
+function store(state2) {
   return `(() => {
-  let state = ${literal(state3)};
+  let state = ${literal(state2)};
   const tag = Math.random().toString(36).slice(2);
   const pending = new Map();
   let next = 0;
@@ -40846,11 +40905,11 @@ function store(state3) {
   });
 })();`;
 }
-function frameDocument(source, color, name, state3) {
+function frameDocument(source, color, name, state2) {
   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 + (state3 ? `<script>${store(state3.value)}<\/script>` : "");
+  const injection = light + scheme + script + (state2 ? `<script>${store(state2.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;
@@ -41112,12 +41171,12 @@ var SliccSprinkle = class extends ThemedElement {
     return this.model?.sprinkles.list().find((candidate) => candidate.id === this.sprinkle);
   }
   #frame = { key: "", doc: "" };
-  #document(data, state3) {
-    const key2 = `${!!state3}
+  #document(data, state2) {
+    const key2 = `${!!state2}
 ${data.name}
 ${data.html}`;
     if (this.#frame.key !== key2)
-      this.#frame = { key: key2, doc: frameDocument(data.html, this.color, data.name, state3) };
+      this.#frame = { key: key2, doc: frameDocument(data.html, this.color, data.name, state2) };
     return this.#frame.doc;
   }
   updated(changed) {
@@ -41141,13 +41200,13 @@ ${data.html}`;
     }
     const bridged = !!this.model?.sprinkles.call;
     if (bridged && !this.#held.ready) return b``;
-    const state3 = bridged ? this.#held : void 0;
+    const state2 = bridged ? this.#held : void 0;
     const watch = !!watchOnly(this.model);
     const caption = watch ? b`<span class="view-only" data-view-only>View only on this device</span>` : A;
     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" ?inert=${watch} style=${style} .srcdoc=${this.#document(data, state3)}></iframe>`
+      b`<iframe title=${data.title} sandbox="allow-scripts" ?inert=${watch} style=${style} .srcdoc=${this.#document(data, state2)}></iframe>`
     )}`;
     if (!this.inline)
       return watch ? b`<div class="panel"><div class="bar">${caption}</div>${frame}</div>` : frame;
@@ -41165,16 +41224,29 @@ ${data.html}`;
 
 // src/app/tool-runs.ts
 var opened = /* @__PURE__ */ new Map();
+var caches = /* @__PURE__ */ new WeakMap();
+function cache(port) {
+  const found = caches.get(port);
+  if (found) return found;
+  const fresh2 = { done: /* @__PURE__ */ new Map(), latest: /* @__PURE__ */ new Map(), asked: /* @__PURE__ */ new Set() };
+  caches.set(port, fresh2);
+  return fresh2;
+}
 var SliccToolRuns = class extends i2 {
   static properties = {
     calls: { attribute: false },
+    agent: { attribute: false },
     color: { attribute: false },
     model: { attribute: false },
     owners: { attribute: false }
   };
+  #icons = null;
+  #count = 0;
+  #resize = new ResizeObserver(() => this.#end());
   constructor() {
     super();
     this.calls = [];
+    this.agent = "";
     this.color = "light";
     this.model = null;
     this.owners = null;
@@ -41182,9 +41254,20 @@ var SliccToolRuns = class extends i2 {
   createRenderRoot() {
     return this;
   }
+  connectedCallback() {
+    super.connectedCallback();
+    if (this.#icons) this.#resize.observe(this.#icons);
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.#resize.disconnect();
+  }
   get #anchor() {
     return this.calls[0]?.id ?? "";
   }
+  get #key() {
+    return this.calls.map((call) => call.id).join(" ");
+  }
   get #open() {
     return opened.get(this.#anchor) ?? "";
   }
@@ -41195,9 +41278,55 @@ var SliccToolRuns = class extends i2 {
   }
   #toggled(call, event2) {
     const open = event2.currentTarget.open;
-    const current = this.#open;
-    if (open && current !== "all") this.#set(call.id);
-    if (!open && current === call.id) this.#set("");
+    if (open) this.#set(call.id);
+    else if (this.#open === call.id) this.#set("");
+  }
+  #ask() {
+    const port = this.model?.agent;
+    if (this.calls.length < 2 || !port?.toolLabel) return;
+    const store2 = cache(port);
+    const key2 = `${this.agent} ${this.#key}`;
+    const anchor = `${this.agent} ${this.#anchor}`;
+    if (store2.asked.has(key2)) return;
+    store2.asked.add(key2);
+    port.toolLabel(
+      this.agent,
+      this.calls.map((call) => call.id)
+    ).then(
+      (text2) => {
+        const label = text2?.trim();
+        if (!label) return;
+        store2.done.set(key2, label);
+        store2.latest.set(anchor, label);
+        this.requestUpdate();
+      },
+      () => void 0
+    );
+  }
+  #label() {
+    const port = this.model?.agent;
+    const store2 = port ? caches.get(port) : void 0;
+    if (!store2) return "";
+    return store2.done.get(`${this.agent} ${this.#key}`) ?? store2.latest.get(`${this.agent} ${this.#anchor}`) ?? "";
+  }
+  #end() {
+    const icons3 = this.#icons;
+    const rtl = getComputedStyle(icons3).direction === "rtl";
+    icons3.scrollLeft = rtl ? -icons3.scrollWidth : icons3.scrollWidth;
+  }
+  willUpdate() {
+    this.#ask();
+  }
+  updated() {
+    const icons3 = this.querySelector(".icons");
+    if (icons3 !== this.#icons) {
+      this.#resize.disconnect();
+      this.#resize.observe(icons3);
+      this.#icons = icons3;
+    }
+    if (this.calls.length === this.#count) return;
+    this.#count = this.calls.length;
+    this.#end();
   }
   #card(call, run2) {
     const open = this.#open;
@@ -41216,17 +41345,15 @@ var SliccToolRuns = class extends i2 {
     }
     const open = this.#open;
     const [status2, label] = overall(calls);
+    const summary = `${toolSummary(calls)}. ${label}`;
+    const text2 = this.#label();
     const pick = (id) => this.#set(open === id ? "" : id);
     return b`<div class="runs" data-runs="cluster" data-status=${status2} data-count=${calls.length}>
-      <div class="strip">
-        <span class="icons" role="group" aria-label=${`${calls.length} tool runs`}>${calls.map(
+      <div class="strip" title=${summary}>
+        <span class="icons" role="group" aria-label=${summary}>${calls.map(
       (call) => b`<button type="button" class="run" data-action="open-run" data-target=${call.id} data-status=${call.status} aria-expanded=${open === call.id ? "true" : "false"} aria-controls=${`run-${call.id}`} aria-label=${`${call.title}, ${statusLabel2(call.status)}`} title=${call.title} @click=${() => pick(call.id)}>${chip(call, this.model)}</button>`
     )}</span>
-        <button type="button" class="summary" data-action="open-cluster" aria-expanded=${open === "all" ? "true" : "false"} @click=${() => pick("all")}>
-          <swc-icon-chevron-right class="chevron" size="s" aria-hidden="true"></swc-icon-chevron-right>
-          <span class="names">${toolSummary(calls)}</span>
-          ${state2(status2, label)}
-        </button>
+        <button type="button" class="label" data-action="open-cluster" aria-expanded=${open === "all" ? "true" : "false"} aria-label=${text2 ? A : "Show all runs"} @click=${() => pick("all")}>${text2}</button>
       </div>
       <div class="cards" ?hidden=${!open}>${calls.map(
       (call) => b`<div class="slot" ?hidden=${open !== "all" && open !== call.id}>${this.#card(call, false)}</div>`
@@ -47415,8 +47542,8 @@ async function createShikiPrimitiveAsync(options) {
   });
 }
 var _grammarStateMap = /* @__PURE__ */ new WeakMap();
-function setLastGrammarStateToMap(keys, state3) {
-  _grammarStateMap.set(keys, state3);
+function setLastGrammarStateToMap(keys, state2) {
+  _grammarStateMap.set(keys, state2);
 }
 function getLastGrammarStateFromMap(keys) {
   return _grammarStateMap.get(keys);
@@ -47485,9 +47612,9 @@ function getScopes(stack) {
   pushScope(stack);
   return scopes;
 }
-function getGrammarStack(state3, theme3) {
-  if (!(state3 instanceof GrammarState)) throw new ShikiError2("Invalid grammar state");
-  return state3.getInternalStack(theme3);
+function getGrammarStack(state2, theme3) {
+  if (!(state2 instanceof GrammarState)) throw new ShikiError2("Invalid grammar state");
+  return state2.getInternalStack(theme3);
 }
 var RE_COMMA = /,/;
 var RE_SPACE = / /;
@@ -49490,17 +49617,17 @@ function stringifyEntities(value, options) {
 var htmlCommentRegex = /^>|^->|<!--|-->|--!>|<!-$/g;
 var bogusCommentEntitySubset = [">"];
 var commentEntitySubset = ["<", ">"];
-function comment(node, _1, _22, state3) {
-  return state3.settings.bogusComments ? "<?" + stringifyEntities(
+function comment(node, _1, _22, state2) {
+  return state2.settings.bogusComments ? "<?" + stringifyEntities(
     node.value,
-    Object.assign({}, state3.settings.characterReferences, {
+    Object.assign({}, state2.settings.characterReferences, {
       subset: bogusCommentEntitySubset
     })
   ) + ">" : "<!--" + node.value.replace(htmlCommentRegex, encode2) + "-->";
   function encode2($0) {
     return stringifyEntities(
       $0,
-      Object.assign({}, state3.settings.characterReferences, {
+      Object.assign({}, state2.settings.characterReferences, {
         subset: commentEntitySubset
       })
     );
@@ -49508,8 +49635,8 @@ function comment(node, _1, _22, state3) {
 }
 
 // node_modules/hast-util-to-html/lib/handle/doctype.js
-function doctype(_1, _22, _32, state3) {
-  return "<!" + (state3.settings.upperDoctype ? "DOCTYPE" : "doctype") + (state3.settings.tightDoctype ? "" : " ") + "html>";
+function doctype(_1, _22, _32, state2) {
+  return "<!" + (state2.settings.upperDoctype ? "DOCTYPE" : "doctype") + (state2.settings.tightDoctype ? "" : " ") + "html>";
 }
 
 // node_modules/ccount/index.js
@@ -49734,26 +49861,26 @@ var constants = {
     ['\0"&'.split(""), "\0\"&'`".split("")]
   ]
 };
-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());
+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());
   const parts2 = [];
   let last;
   if (schema.space === "html" && node.tagName === "svg") {
-    state3.schema = svg3;
+    state2.schema = svg3;
   }
-  const attributes = serializeAttributes(state3, node.properties);
-  const content = state3.all(
+  const attributes = serializeAttributes(state2, node.properties);
+  const content = state2.all(
     schema.space === "html" && node.tagName === "template" ? node.content : node
   );
-  state3.schema = schema;
+  state2.schema = schema;
   if (content) selfClosing = false;
   if (attributes || !omit || !opening(node, index, parent)) {
     parts2.push("<", node.tagName, attributes ? " " + attributes : "");
-    if (selfClosing && (schema.space === "svg" || state3.settings.closeSelfClosing)) {
+    if (selfClosing && (schema.space === "svg" || state2.settings.closeSelfClosing)) {
       last = attributes.charAt(attributes.length - 1);
-      if (!state3.settings.tightSelfClosing || last === "/" || last && last !== '"' && last !== "'") {
+      if (!state2.settings.tightSelfClosing || last === "/" || last && last !== '"' && last !== "'") {
         parts2.push(" ");
       }
       parts2.push("/");
@@ -49766,31 +49893,31 @@ function element(node, index, parent, state3) {
   }
   return parts2.join("");
 }
-function serializeAttributes(state3, properties) {
+function serializeAttributes(state2, 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(state3, key2, properties[key2]);
+        const value = serializeAttribute(state2, key2, properties[key2]);
         if (value) values.push(value);
       }
     }
   }
   while (++index < values.length) {
-    const last = state3.settings.tightAttributes ? values[index].charAt(values[index].length - 1) : void 0;
+    const last = state2.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(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;
+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;
   let result;
   if (info.overloadedBoolean && (value === info.attribute || value === "")) {
     value = true;
@@ -49802,32 +49929,32 @@ function serializeAttribute(state3, key2, value) {
   }
   const name = stringifyEntities(
     info.attribute,
-    Object.assign({}, state3.settings.characterReferences, {
+    Object.assign({}, state2.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: !state3.settings.tightCommaSeparatedLists
+    padLeft: !state2.settings.tightCommaSeparatedLists
   }) : String(value);
-  if (state3.settings.collapseEmptyAttributes && !value) return name;
-  if (state3.settings.preferUnquoted) {
+  if (state2.settings.collapseEmptyAttributes && !value) return name;
+  if (state2.settings.preferUnquoted) {
     result = stringifyEntities(
       value,
-      Object.assign({}, state3.settings.characterReferences, {
+      Object.assign({}, state2.settings.characterReferences, {
         attribute: true,
         subset: constants.unquoted[x7][y10]
       })
     );
   }
   if (result !== value) {
-    if (state3.settings.quoteSmart && ccount(value, quote) > ccount(value, state3.alternative)) {
-      quote = state3.alternative;
+    if (state2.settings.quoteSmart && ccount(value, quote) > ccount(value, state2.alternative)) {
+      quote = state2.alternative;
     }
     result = quote + stringifyEntities(
       value,
-      Object.assign({}, state3.settings.characterReferences, {
+      Object.assign({}, state2.settings.characterReferences, {
         // Always encode without parse errors in non-HTML.
         subset: (quote === "'" ? constants.single : constants.double)[x7][y10],
         attribute: true
@@ -49839,23 +49966,23 @@ function serializeAttribute(state3, key2, value) {
 
 // node_modules/hast-util-to-html/lib/handle/text.js
 var textEntitySubset = ["<", "&"];
-function text(node, _9, parent, state3) {
+function text(node, _9, parent, state2) {
   return parent && parent.type === "element" && (parent.tagName === "script" || parent.tagName === "style") ? node.value : stringifyEntities(
     node.value,
-    Object.assign({}, state3.settings.characterReferences, {
+    Object.assign({}, state2.settings.characterReferences, {
       subset: textEntitySubset
     })
   );
 }
 
 // node_modules/hast-util-to-html/lib/handle/raw.js
-function raw(node, index, parent, state3) {
-  return state3.settings.allowDangerousHtml ? node.value : text(node, index, parent, state3);
+function raw(node, index, parent, state2) {
+  return state2.settings.allowDangerousHtml ? node.value : text(node, index, parent, state2);
 }
 
 // node_modules/hast-util-to-html/lib/handle/root.js
-function root(node, _1, _22, state3) {
-  return state3.all(node);
+function root(node, _1, _22, state2) {
+  return state2.all(node);
 }
 
 // node_modules/hast-util-to-html/lib/handle/index.js
@@ -49886,7 +50013,7 @@ function toHtml(tree, options) {
   if (quote !== '"' && quote !== "'") {
     throw new Error("Invalid quote `" + quote + "`, expected `'` or `\"`");
   }
-  const state3 = {
+  const state2 = {
     one,
     all,
     settings: {
@@ -49912,7 +50039,7 @@ function toHtml(tree, options) {
     quote,
     alternative
   };
-  return state3.one(
+  return state2.one(
     Array.isArray(tree) ? { type: "root", children: tree } : tree,
     void 0,
     void 0
@@ -51073,11 +51200,11 @@ var JavaScriptScanner = class {
   constructor(patterns, options = {}) {
     this.patterns = patterns;
     this.options = options;
-    const { forgiving = false, cache: cache3, regexConstructor } = options;
+    const { forgiving = false, cache: cache4, regexConstructor } = options;
     if (!regexConstructor) throw new Error("Option `regexConstructor` is not provided");
     this.regexps = patterns.map((p17) => {
       if (typeof p17 !== "string") return p17;
-      const cached = cache3?.get(p17);
+      const cached = cache4?.get(p17);
       if (cached) {
         if (cached instanceof RegExp) return cached;
         if (forgiving) return null;
@@ -51085,10 +51212,10 @@ var JavaScriptScanner = class {
       }
       try {
         const regex = regexConstructor(p17);
-        cache3?.set(p17, regex);
+        cache4?.set(p17, regex);
         return regex;
       } catch (e122) {
-        cache3?.set(p17, e122);
+        cache4?.set(p17, e122);
         if (forgiving) return null;
         throw e122;
       }
@@ -52813,9 +52940,9 @@ var FirstPassVisitor = {
       }
     }
   },
-  Assertion({ node, parent, key: key2, container, root: root2, remove: remove2, replaceWith }, state3) {
+  Assertion({ node, parent, key: key2, container, root: root2, remove: remove2, replaceWith }, state2) {
     const { kind, negate } = node;
-    const { asciiWordBoundaries, avoidSubclass, supportedGNodes, wordIsAscii } = state3;
+    const { asciiWordBoundaries, avoidSubclass, supportedGNodes, wordIsAscii } = state2;
     if (kind === "text_segment_boundary") {
       throw new Error(`Unsupported text segment boundary "\\${negate ? "Y" : "y"}"`);
     } else if (kind === "line_end") {
@@ -52838,7 +52965,7 @@ var FirstPassVisitor = {
           throw new Error(r39`Uses "\G" in a way that requires a subclass`);
         } else {
           replaceWith(setParent(F5("string_start"), parent));
-          state3.strategy = "clip_search";
+          state2.strategy = "clip_search";
         }
       }
     } else if (kind === "string_end" || kind === "string_start") {
@@ -53031,10 +53158,10 @@ var FirstPassVisitor = {
     disable && !Object.keys(disable).length && delete node.flags.disable;
     !node.flags.enable && !node.flags.disable && delete node.flags;
   },
-  LookaroundAssertion({ node }, state3) {
+  LookaroundAssertion({ node }, state2) {
     const { kind } = node;
     if (kind === "lookbehind") {
-      state3.passedLookbehind = true;
+      state2.passedLookbehind = true;
     }
   },
   NamedCallout({ node, parent, replaceWith }) {
@@ -53161,17 +53288,17 @@ var SecondPassVisitor = {
     }
   },
   Group: {
-    enter({ node }, state3) {
-      state3.prevFlags = state3.currentFlags;
+    enter({ node }, state2) {
+      state2.prevFlags = state2.currentFlags;
       if (node.flags) {
-        state3.currentFlags = getNewCurrentFlags(state3.currentFlags, node.flags);
+        state2.currentFlags = getNewCurrentFlags(state2.currentFlags, node.flags);
       }
     },
-    exit(_9, state3) {
-      state3.currentFlags = state3.prevFlags;
+    exit(_9, state2) {
+      state2.currentFlags = state2.prevFlags;
     }
   },
-  Subroutine({ node, parent, replaceWith }, state3) {
+  Subroutine({ node, parent, replaceWith }, state2) {
     const { isRecursive, ref } = node;
     if (isRecursive) {
       let reffed = parent;
@@ -53180,14 +53307,14 @@ var SecondPassVisitor = {
           break;
         }
       }
-      state3.reffedNodesByReferencer.set(node, reffed);
+      state2.reffedNodesByReferencer.set(node, reffed);
       return;
     }
-    const reffedGroupNode = state3.subroutineRefMap.get(ref);
+    const reffedGroupNode = state2.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, state3.groupOriginByCopy, null)
+      cloneCapturingGroup(reffedGroupNode, state2.groupOriginByCopy, null)
     );
     let replacement = expandedSubroutine;
     if (!isGlobalRecursion) {
@@ -53195,8 +53322,8 @@ var SecondPassVisitor = {
         reffedGroupNode,
         (p17) => p17.type === "Group" && !!p17.flags
       ));
-      const reffedGroupFlags = reffedGroupFlagMods ? getNewCurrentFlags(state3.globalFlags, reffedGroupFlagMods) : state3.globalFlags;
-      if (!areFlagsEqual(reffedGroupFlags, state3.currentFlags)) {
+      const reffedGroupFlags = reffedGroupFlagMods ? getNewCurrentFlags(state2.globalFlags, reffedGroupFlagMods) : state2.globalFlags;
+      if (!areFlagsEqual(reffedGroupFlags, state2.currentFlags)) {
         replacement = A8({
           flags: getFlagModsFromFlags(reffedGroupFlags)
         });
@@ -53207,12 +53334,12 @@ var SecondPassVisitor = {
   }
 };
 var ThirdPassVisitor = {
-  Backreference({ node, parent, replaceWith }, state3) {
+  Backreference({ node, parent, replaceWith }, state2) {
     if (node.orphan) {
-      state3.highestOrphanBackref = Math.max(state3.highestOrphanBackref, node.ref);
+      state2.highestOrphanBackref = Math.max(state2.highestOrphanBackref, node.ref);
       return;
     }
-    const reffedNodes = state3.reffedNodesByReferencer.get(node);
+    const reffedNodes = state2.reffedNodesByReferencer.get(node);
     const participants = reffedNodes.filter((reffed) => canParticipateWithNode(reffed, node));
     if (!participants.length) {
       replaceWith(setParentDeep(K2({ negate: true }), parent));
@@ -53228,28 +53355,28 @@ var ThirdPassVisitor = {
       node.ref = participants[0].number;
     }
   },
-  CapturingGroup({ node }, state3) {
-    node.number = ++state3.numCapturesToLeft;
+  CapturingGroup({ node }, state2) {
+    node.number = ++state2.numCapturesToLeft;
     if (node.name) {
-      if (state3.groupsByName.get(node.name).get(node).hasDuplicateNameToRemove) {
+      if (state2.groupsByName.get(node.name).get(node).hasDuplicateNameToRemove) {
         delete node.name;
       }
     }
   },
   Regex: {
-    exit({ node }, state3) {
-      const numCapsNeeded = Math.max(state3.highestOrphanBackref - state3.numCapturesToLeft, 0);
+    exit({ node }, state2) {
+      const numCapsNeeded = Math.max(state2.highestOrphanBackref - state2.numCapturesToLeft, 0);
       for (let i26 = 0; i26 < numCapsNeeded; i26++) {
         const emptyCapture = P4();
         node.body.at(-1).body.push(emptyCapture);
       }
     }
   },
-  Subroutine({ node }, state3) {
+  Subroutine({ node }, state2) {
     if (!node.isRecursive || node.ref === 0) {
       return;
     }
-    node.ref = state3.reffedNodesByReferencer.get(node).number;
+    node.ref = state2.reffedNodesByReferencer.get(node).number;
   }
 };
 function addParentProperties(root2) {
@@ -53491,7 +53618,7 @@ function generate(ast, options) {
     ignoreCase: !!((ast.flags.ignoreCase || hasCaseInsensitiveNode) && !hasCaseSensitiveNode)
   };
   let lastNode = ast;
-  const state3 = {
+  const state2 = {
     accuracy: opts.accuracy,
     appliedGlobalFlags,
     captureMap: /* @__PURE__ */ new Map(),
@@ -53509,10 +53636,10 @@ function generate(ast, options) {
     verbose: opts.verbose
   };
   function gen(node) {
-    state3.lastNode = lastNode;
+    state2.lastNode = lastNode;
     lastNode = node;
     const fn = throwIfNullish(generator[node.type], `Unexpected node type "${node.type}"`);
-    return fn(node, state3, gen);
+    return fn(node, state2, gen);
   }
   const result = {
     pattern: ast.body.map(gen).join("|"),
@@ -53527,7 +53654,7 @@ function generate(ast, options) {
   }
   result._captureTransfers = /* @__PURE__ */ new Map();
   result._hiddenCaptures = [];
-  state3.captureMap.forEach((value, key2) => {
+  state2.captureMap.forEach((value, key2) => {
     if (value.hidden) {
       result._hiddenCaptures.push(key2);
     }
@@ -53539,37 +53666,37 @@ function generate(ast, options) {
 }
 var FlagModifierVisitor = {
   "*": {
-    enter({ node }, state3) {
+    enter({ node }, state2) {
       if (isAnyGroup(node)) {
-        const currentModI = state3.getCurrentModI();
-        state3.pushModI(
+        const currentModI = state2.getCurrentModI();
+        state2.pushModI(
           node.flags ? getNewCurrentFlags({ ignoreCase: currentModI }, node.flags).ignoreCase : currentModI
         );
       }
     },
-    exit({ node }, state3) {
+    exit({ node }, state2) {
       if (isAnyGroup(node)) {
-        state3.popModI();
+        state2.popModI();
       }
     }
   },
-  Backreference(_9, state3) {
-    state3.setHasCasedChar();
+  Backreference(_9, state2) {
+    state2.setHasCasedChar();
   },
-  Character({ node }, state3) {
+  Character({ node }, state2) {
     if (charHasCase(cp(node.value))) {
-      state3.setHasCasedChar();
+      state2.setHasCasedChar();
     }
   },
-  CharacterClassRange({ node, skip }, state3) {
+  CharacterClassRange({ node, skip }, state2) {
     skip();
     if (getCasesOutsideCharClassRange(node, { firstOnly: true }).length) {
-      state3.setHasCasedChar();
+      state2.setHasCasedChar();
     }
   },
-  CharacterSet({ node }, state3) {
+  CharacterSet({ node }, state2) {
     if (node.kind === "property" && UnicodePropertiesWithSpecificCase.has(node.value)) {
-      state3.setHasCasedChar();
+      state2.setHasCasedChar();
     }
   }
 };
@@ -53598,11 +53725,11 @@ var generator = {
   /**
   @param {BackreferenceNode} node
   */
-  Backreference({ ref }, state3) {
+  Backreference({ ref }, state2) {
     if (typeof ref !== "number") {
       throw new Error("Unexpected named backref in transformed AST");
     }
-    if (!state3.useFlagMods && state3.accuracy === "strict" && state3.currentFlags.ignoreCase && !state3.captureMap.get(ref).ignoreCase) {
+    if (!state2.useFlagMods && state2.accuracy === "strict" && state2.currentFlags.ignoreCase && !state2.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;
@@ -53610,55 +53737,55 @@ var generator = {
   /**
   @param {CapturingGroupNode} node
   */
-  CapturingGroup(node, state3, gen) {
+  CapturingGroup(node, state2, gen) {
     const { body: body4, name, number: number2 } = node;
-    const data = { ignoreCase: state3.currentFlags.ignoreCase };
-    const origin2 = state3.originMap.get(node);
+    const data = { ignoreCase: state2.currentFlags.ignoreCase };
+    const origin2 = state2.originMap.get(node);
     if (origin2) {
       data.hidden = true;
       if (number2 > origin2.number) {
         data.transferTo = origin2.number;
       }
     }
-    state3.captureMap.set(number2, data);
+    state2.captureMap.set(number2, data);
     return `(${name ? `?<${name}>` : ""}${body4.map(gen).join("|")})`;
   },
   /**
   @param {CharacterNode} node
   */
-  Character({ value }, state3) {
+  Character({ value }, state2) {
     const char = cp(value);
     const escaped = getCharEscape(value, {
-      escDigit: state3.lastNode.type === "Backreference",
-      inCharClass: state3.inCharClass,
-      useFlagV: state3.useFlagV
+      escDigit: state2.lastNode.type === "Backreference",
+      inCharClass: state2.inCharClass,
+      useFlagV: state2.useFlagV
     });
     if (escaped !== char) {
       return escaped;
     }
-    if (state3.useAppliedIgnoreCase && state3.currentFlags.ignoreCase && charHasCase(char)) {
+    if (state2.useAppliedIgnoreCase && state2.currentFlags.ignoreCase && charHasCase(char)) {
       const cases = getIgnoreCaseMatchChars(char);
-      return state3.inCharClass ? cases.join("") : cases.length > 1 ? `[${cases.join("")}]` : cases[0];
+      return state2.inCharClass ? cases.join("") : cases.length > 1 ? `[${cases.join("")}]` : cases[0];
     }
     return char;
   },
   /**
   @param {CharacterClassNode} node
   */
-  CharacterClass(node, state3, gen) {
+  CharacterClass(node, state2, gen) {
     const { kind, negate, parent } = node;
     let { body: body4 } = node;
-    if (kind === "intersection" && !state3.useFlagV) {
+    if (kind === "intersection" && !state2.useFlagV) {
       throw new Error("Use of character class intersection requires min target ES2024");
     }
-    if (envFlags.bugFlagVLiteralHyphenIsRange && state3.useFlagV && body4.some(isLiteralHyphen)) {
+    if (envFlags.bugFlagVLiteralHyphenIsRange && state2.useFlagV && body4.some(isLiteralHyphen)) {
       body4 = [m15(45), ...body4.filter((kid) => !isLiteralHyphen(kid))];
     }
     const genClass = () => `[${negate ? "^" : ""}${body4.map(gen).join(kind === "intersection" ? "&&" : "")}]`;
-    if (!state3.inCharClass) {
+    if (!state2.inCharClass) {
       if (
         // Already established `kind !== 'intersection'` if `!state.useFlagV`; don't check again
-        (!state3.useFlagV || envFlags.bugNestedClassIgnoresNegation) && !negate
+        (!state2.useFlagV || envFlags.bugNestedClassIgnoresNegation) && !negate
       ) {
         const negatedChildClasses = body4.filter(
           (kid) => kid.type === "CharacterClass" && kid.kind === "union" && kid.negate
@@ -53685,21 +53812,21 @@ var generator = {
           return gen(group);
         }
       }
-      state3.inCharClass = true;
+      state2.inCharClass = true;
       const result = genClass();
-      state3.inCharClass = false;
+      state2.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
-      ((!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
+      ((!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
       body4.length === 1 && firstEl.type !== "CharacterClassRange")
     ) {
       return body4.map(gen).join("");
     }
-    if (!state3.useFlagV && parent.type === "CharacterClass") {
+    if (!state2.useFlagV && parent.type === "CharacterClass") {
       throw new Error("Uses nested character class in a way that requires min target ES2024");
     }
     return genClass();
@@ -53707,18 +53834,18 @@ var generator = {
   /**
   @param {CharacterClassRangeNode} node
   */
-  CharacterClassRange(node, state3) {
+  CharacterClassRange(node, state2) {
     const min2 = node.min.value;
     const max2 = node.max.value;
     const escOpts = {
       escDigit: false,
       inCharClass: true,
-      useFlagV: state3.useFlagV
+      useFlagV: state2.useFlagV
     };
     const minStr = getCharEscape(min2, escOpts);
     const maxStr = getCharEscape(max2, escOpts);
     const extraChars = /* @__PURE__ */ new Set();
-    if (state3.useAppliedIgnoreCase && state3.currentFlags.ignoreCase) {
+    if (state2.useAppliedIgnoreCase && state2.currentFlags.ignoreCase) {
       const charsOutsideRange = getCasesOutsideCharClassRange(node);
       const ranges = getCodePointRangesFromChars(charsOutsideRange);
       ranges.forEach((value) => {
@@ -53732,9 +53859,9 @@ var generator = {
   /**
   @param {CharacterSetNode} node
   */
-  CharacterSet({ kind, negate, value, key: key2 }, state3) {
+  CharacterSet({ kind, negate, value, key: key2 }, state2) {
     if (kind === "dot") {
-      return state3.currentFlags.dotAll ? state3.appliedGlobalFlags.dotAll || state3.useFlagMods ? "." : "[^]" : (
+      return state2.currentFlags.dotAll ? state2.appliedGlobalFlags.dotAll || state2.useFlagMods ? "." : "[^]" : (
         // Onig's only line break char is line feed, unlike JS
         r39`[^\n]`
       );
@@ -53743,7 +53870,7 @@ var generator = {
       return negate ? r39`\D` : r39`\d`;
     }
     if (kind === "property") {
-      if (state3.useAppliedIgnoreCase && state3.currentFlags.ignoreCase && UnicodePropertiesWithSpecificCase.has(value)) {
+      if (state2.useAppliedIgnoreCase && state2.currentFlags.ignoreCase && UnicodePropertiesWithSpecificCase.has(value)) {
         throw new Error(`Unicode property "${value}" can't be case-insensitive when other chars have specific case`);
       }
       return `${negate ? r39`\P` : r39`\p`}{${key2 ? `${key2}=` : ""}${value}}`;
@@ -53756,28 +53883,28 @@ var generator = {
   /**
   @param {FlagsNode} node
   */
-  Flags(node, state3) {
+  Flags(node, state2) {
     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' : '') +
-      (state3.appliedGlobalFlags.ignoreCase ? "i" : "") + (node.dotAll ? "s" : "") + (node.sticky ? "y" : "")
+      (state2.appliedGlobalFlags.ignoreCase ? "i" : "") + (node.dotAll ? "s" : "") + (node.sticky ? "y" : "")
     );
   },
   /**
   @param {GroupNode} node
   */
-  Group({ atomic: atomic2, body: body4, flags, parent }, state3, gen) {
-    const currentFlags = state3.currentFlags;
+  Group({ atomic: atomic2, body: body4, flags, parent }, state2, gen) {
+    const currentFlags = state2.currentFlags;
     if (flags) {
-      state3.currentFlags = getNewCurrentFlags(currentFlags, flags);
+      state2.currentFlags = getNewCurrentFlags(currentFlags, flags);
     }
     const contents = body4.map(gen).join("|");
-    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;
+    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;
     return result;
   },
   /**
@@ -53796,11 +53923,11 @@ var generator = {
   /**
   @param {SubroutineNode & {isRecursive: true}} node
   */
-  Subroutine({ isRecursive, ref }, state3) {
+  Subroutine({ isRecursive, ref }, state2) {
     if (!isRecursive) {
       throw new Error("Unexpected non-recursive subroutine in transformed AST");
     }
-    const limit2 = state3.recursionLimit;
+    const limit2 = state2.recursionLimit;
     return ref === 0 ? `(?R=${limit2})` : r39`\g<${ref}&R=${limit2}>`;
   }
 };
@@ -55766,13 +55893,13 @@ var InteractionManager = class {
       }
     };
   }
-  resolveLineRenderRange(state3, split, source) {
-    if (state3.range == null) return;
-    const rowRange = this.getIndexesFromSelection(state3.range, split);
+  resolveLineRenderRange(state2, split, source) {
+    if (state2.range == null) return;
+    const rowRange = this.getIndexesFromSelection(state2.range, split);
     if (rowRange == null) {
       console.error({
         rowRange,
-        range: state3.range
+        range: state2.range
       });
       throw new Error(`InteractionManager.renderSelection: No valid ${source} rowRange`);
     }
@@ -57054,14 +57181,14 @@ function isDefaultRenderRange(renderRange) {
 }
 
 // node_modules/@pierre/diffs/dist/utils/processLine.js
-function processLine(node, line, state3) {
-  const lineInfo = typeof state3.lineInfo === "function" ? state3.lineInfo(line) : state3.lineInfo[line - 1];
+function processLine(node, line, state2) {
+  const lineInfo = typeof state2.lineInfo === "function" ? state2.lineInfo(line) : state2.lineInfo[line - 1];
   if (lineInfo == null) {
     const errorMessage = `processLine: line ${line}, contains no state.lineInfo`;
     console.error(errorMessage, {
       node,
       line,
-      state: state3
+      state: state2
     });
     throw new Error(errorMessage);
   }
@@ -57213,7 +57340,7 @@ function cyrb53(str, seed2 = 0) {
 
 // node_modules/@pierre/diffs/dist/utils/createTransformerWithState.js
 function createTransformerWithState(useTokenTransformer = false, useCSSClasses = false) {
-  const state3 = { lineInfo: [] };
+  const state2 = { lineInfo: [] };
   const transformers = [{
     line(node) {
       delete node.properties.class;
@@ -57227,7 +57354,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, state3));
+          children.push(processLine(node, index, state2));
           index++;
         }
         code2.children = children;
@@ -57269,7 +57396,7 @@ function createTransformerWithState(useTokenTransformer = false, useCSSClasses =
     return node;
   } });
   return {
-    state: state3,
+    state: state2,
     transformers,
     toClass
   };
@@ -57362,9 +57489,9 @@ function hoverWouldEraseText(hover, bg, fg) {
 }
 
 // node_modules/@pierre/theming/dist/modules/normalizeThemeColors.js
-var cache = /* @__PURE__ */ new WeakMap();
+var cache2 = /* @__PURE__ */ new WeakMap();
 function normalizeThemeColors(theme3) {
-  const cached = cache.get(theme3);
+  const cached = cache2.get(theme3);
   if (cached != null) return cached;
   const originalColors = theme3.colors ?? {};
   const colors = { ...originalColors };
@@ -57391,7 +57518,7 @@ function normalizeThemeColors(theme3) {
     ...theme3,
     colors: Object.freeze(colors)
   });
-  cache.set(theme3, result);
+  cache2.set(theme3, result);
   return result;
 }
 function fill(colors, key2, value) {
@@ -57522,14 +57649,14 @@ function renderFileWithHighlighter(file, highlighter2, { theme: theme3, tokenize
     totalLines = Infinity;
   }
   const isWindowedHighlight = startingLine > 0 || totalLines < Infinity;
-  const { state: state3, transformers } = createTransformerWithState(useTokenTransformer);
+  const { state: state2, 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
   });
-  state3.lineInfo = (shikiLineNumber) => ({
+  state2.lineInfo = (shikiLineNumber) => ({
     type: "context",
     lineIndex: shikiLineNumber - 1 + startingLine,
     lineNumber: shikiLineNumber + startingLine
@@ -57760,14 +57887,14 @@ var FileRenderer = class {
     this.file = file;
     const { options } = this.getRenderOptions(file);
     const massiveFile = isFileMassive(this.getOrCreateLineCache(file).length, this.getTokenizeMaxLength());
-    let cache3 = this.workerManager?.getFileResultCache(file);
-    if (cache3 != null && !areFileRenderOptionsEqual(options, cache3.options)) cache3 = void 0;
+    let cache4 = this.workerManager?.getFileResultCache(file);
+    if (cache4 != null && !areFileRenderOptionsEqual(options, cache4.options)) cache4 = void 0;
     this.renderCache ??= {
       file,
       hydrated: true,
       options,
       highlighted: !massiveFile && !isFilePlainText(file),
-      result: massiveFile ? void 0 : cache3?.result,
+      result: massiveFile ? void 0 : cache4?.result,
       renderRange: void 0
     };
     if (!this.editSessionActive && this.workerManager?.isWorkingPool() === true) {
@@ -58177,9 +58304,9 @@ var FileRenderer = class {
   }
   getMatchingWorkerResultCache(file, options) {
     if (this.editSessionActive) return;
-    const cache3 = this.workerManager?.getFileResultCache(file);
-    if (cache3 == null || !areFileRenderOptionsEqual(options, cache3.options)) return;
-    return cache3;
+    const cache4 = this.workerManager?.getFileResultCache(file);
+    if (cache4 == null || !areFileRenderOptionsEqual(options, cache4.options)) return;
+    return cache4;
   }
   getReadyRenderResult(file, options) {
     const { pendingHighlightResult } = this;
@@ -59330,18 +59457,18 @@ var File = class {
     if (renderAnnotation != null && lineAnnotations.length > 0) for (const [index, annotation] of lineAnnotations.entries()) {
       const name = this.getAnnotationSlotName(annotation);
       const id = `${index}-${name}`;
-      let cache3 = this.annotationCache.get(id);
-      if (cache3 == null || !areLineAnnotationsEqual(annotation, cache3.annotation)) {
-        cache3?.element.remove();
+      let cache4 = this.annotationCache.get(id);
+      if (cache4 == null || !areLineAnnotationsEqual(annotation, cache4.annotation)) {
+        cache4?.element.remove();
         const content = renderAnnotation(annotation);
         if (content == null) continue;
-        cache3 = {
+        cache4 = {
           element: createAnnotationWrapperNode(name),
           annotation
         };
-        cache3.element.appendChild(content);
-        this.fileContainer.appendChild(cache3.element);
-        this.annotationCache.set(id, cache3);
+        cache4.element.appendChild(content);
+        this.fileContainer.appendChild(cache4.element);
+        this.annotationCache.set(id, cache4);
       }
       staleAnnotations.delete(id);
     }
@@ -61732,7 +61859,7 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
     expandedHunks,
     collapsedContextThreshold
   });
-  const state3 = {
+  const state2 = {
     viewportStart: startingLine,
     viewportEnd: startingLine + totalLines,
     isWindowedHighlight: startingLine > 0 || totalLines < Infinity,
@@ -61740,44 +61867,44 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
     unifiedCount: iterationStart.unifiedCount,
     finalHunkIndex: diff.hunks.length - 1,
     shouldBreak() {
-      if (!state3.isWindowedHighlight) return false;
-      const breakUnified = state3.unifiedCount >= startingLine + totalLines;
-      const breakSplit = state3.splitCount >= startingLine + totalLines;
+      if (!state2.isWindowedHighlight) return false;
+      const breakUnified = state2.unifiedCount >= startingLine + totalLines;
+      const breakSplit = state2.splitCount >= startingLine + totalLines;
       if (diffStyle === "unified") return breakUnified;
       else if (diffStyle === "split") return breakSplit;
       else return breakUnified && breakSplit;
     },
     shouldSkip(unifiedCount, splitCount) {
-      if (!state3.isWindowedHighlight) return false;
-      const skipUnified = unifiedCount > 0 && state3.unifiedCount + unifiedCount <= startingLine;
-      const skipSplit = splitCount > 0 && state3.splitCount + splitCount <= startingLine;
+      if (!state2.isWindowedHighlight) return false;
+      const skipUnified = unifiedCount > 0 && state2.unifiedCount + unifiedCount <= startingLine;
+      const skipSplit = splitCount > 0 && state2.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") state3.unifiedCount += unifiedValue;
-      if (diffStyle === "split" || diffStyle === "both") state3.splitCount += splitValue;
+      if (diffStyle === "unified" || diffStyle === "both") state2.unifiedCount += unifiedValue;
+      if (diffStyle === "split" || diffStyle === "both") state2.splitCount += splitValue;
     },
     isInWindow(unifiedHeight, splitHeight) {
-      if (!state3.isWindowedHighlight) return true;
-      const unifiedInWindow = state3.isInUnifiedWindow(unifiedHeight);
-      const splitInWindow = state3.isInSplitWindow(splitHeight);
+      if (!state2.isWindowedHighlight) return true;
+      const unifiedInWindow = state2.isInUnifiedWindow(unifiedHeight);
+      const splitInWindow = state2.isInSplitWindow(splitHeight);
       if (diffStyle === "unified") return unifiedInWindow;
       else if (diffStyle === "split") return splitInWindow;
       else return unifiedInWindow || splitInWindow;
     },
     isInUnifiedWindow(unifiedHeight) {
-      return !state3.isWindowedHighlight || state3.unifiedCount >= startingLine - unifiedHeight && state3.unifiedCount < startingLine + totalLines;
+      return !state2.isWindowedHighlight || state2.unifiedCount >= startingLine - unifiedHeight && state2.unifiedCount < startingLine + totalLines;
     },
     isInSplitWindow(splitHeight) {
-      return !state3.isWindowedHighlight || state3.splitCount >= startingLine - splitHeight && state3.splitCount < startingLine + totalLines;
+      return !state2.isWindowedHighlight || state2.splitCount >= startingLine - splitHeight && state2.splitCount < startingLine + totalLines;
     },
     emit(props, silent2 = false) {
       if (!silent2) {
-        if (diffStyle === "unified") state3.incrementCounts(1, 0);
-        else if (diffStyle === "split") state3.incrementCounts(0, 1);
-        else state3.incrementCounts(1, 1);
+        if (diffStyle === "unified") state2.incrementCounts(1, 0);
+        else if (diffStyle === "split") state2.incrementCounts(0, 1);
+        else state2.incrementCounts(1, 1);
       }
       return callback(props) ?? false;
     }
@@ -61794,7 +61921,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 (state3.shouldBreak()) break;
+    if (state2.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;
@@ -61806,7 +61933,7 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
       hunkIndex,
       collapsedContextThreshold
     });
-    const trailingRegion = hunkIndex === state3.finalHunkIndex ? getTrailingExpandedRegion({
+    const trailingRegion = hunkIndex === state2.finalHunkIndex ? getTrailingExpandedRegion({
       fileDiff: diff,
       hunkIndex,
       expandedHunks,
@@ -61815,15 +61942,15 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
     }) : void 0;
     const expandedLineCount = leadingRegion.fromStart + leadingRegion.fromEnd;
     let consumedCollapsed = leadingRegion.collapsedLines === 0;
-    if (!state3.shouldSkip(expandedLineCount, expandedLineCount)) {
+    if (!state2.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(state3, leadingRegion.fromStart, diffStyle, (index) => {
-        return state3.emit({
+      if (walkContextLines(state2, leadingRegion.fromStart, diffStyle, (index) => {
+        return state2.emit({
           hunkIndex,
           hunk,
           collapsedBefore: 0,
@@ -61851,8 +61978,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(state3, leadingRegion.fromEnd, diffStyle, (index) => {
-        return state3.emit({
+      if (walkContextLines(state2, leadingRegion.fromEnd, diffStyle, (index) => {
+        return state2.emit({
           hunkIndex,
           hunk,
           collapsedBefore: consumePendingCollapsed(),
@@ -61877,7 +62004,7 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
         consumePendingCollapsed();
       })) break hunkIterator;
     } else {
-      state3.incrementCounts(expandedLineCount, expandedLineCount);
+      state2.incrementCounts(expandedLineCount, expandedLineCount);
       consumePendingCollapsed();
     }
     let unifiedLineIndex = hunk.unifiedLineStart;
@@ -61888,15 +62015,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 (state3.shouldBreak()) break hunkIterator;
+      if (state2.shouldBreak()) break hunkIterator;
       const isLastContent = content === lastContent;
       if (content.type === "context") {
-        if (!state3.shouldSkip(content.lines, content.lines)) {
-          if (walkContextLines(state3, content.lines, diffStyle, (index) => {
+        if (!state2.shouldSkip(content.lines, content.lines)) {
+          if (walkContextLines(state2, content.lines, diffStyle, (index) => {
             const isLastLine = isLastContent && index === content.lines - 1;
             const unifiedRowIndex = unifiedLineIndex + index;
             const splitRowIndex = splitLineIndex + index;
-            return state3.emit({
+            return state2.emit({
               hunkIndex,
               hunk,
               collapsedBefore: consumePendingCollapsed(),
@@ -61921,7 +62048,7 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
             consumePendingCollapsed();
           })) break hunkIterator;
         } else {
-          state3.incrementCounts(content.lines, content.lines);
+          state2.incrementCounts(content.lines, content.lines);
           consumePendingCollapsed();
         }
         unifiedLineIndex += content.lines;
@@ -61933,12 +62060,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 (!state3.shouldSkip(unifiedCount, splitCount)) {
-          const iterationRanges = getChangeIterationRanges(state3, content, diffStyle);
+        if (!state2.shouldSkip(unifiedCount, splitCount)) {
+          const iterationRanges = getChangeIterationRanges(state2, 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 (state3.emit(getChangeLineData({
+            if (state2.emit(getChangeLineData({
               hunkIndex,
               hunk,
               collapsedBefore: consumePendingCollapsed(),
@@ -61959,7 +62086,7 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
           }
         }
         consumePendingCollapsed();
-        state3.incrementCounts(unifiedCount, splitCount);
+        state2.incrementCounts(unifiedCount, splitCount);
         unifiedLineIndex += unifiedCount;
         splitLineIndex += splitCount;
         deletionLineIndex += content.deletions;
@@ -61971,9 +62098,9 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
     if (trailingRegion != null) {
       const { collapsedLines, fromStart, fromEnd } = trailingRegion;
       const len = fromStart + fromEnd;
-      if (walkContextLines(state3, len, diffStyle, (index) => {
+      if (walkContextLines(state2, len, diffStyle, (index) => {
         const isLastLine = index === len - 1;
-        return state3.emit({
+        return state2.emit({
           hunkIndex: diff.hunks.length,
           hunk: void 0,
           collapsedBefore: 0,
@@ -61994,7 +62121,7 @@ function iterateOverDiff({ diff, diffStyle, startingLine = 0, totalLines = Infin
             noEOFCR: false
           }
         });
-      }, void 0, () => state3.shouldBreak())) break hunkIterator;
+      }, void 0, () => state2.shouldBreak())) break hunkIterator;
     }
   }
 }
@@ -62078,16 +62205,16 @@ function getHunkPrefixCounts({ diff, expandedHunks, collapsedContextThreshold })
   }
   return prefixCounts;
 }
-function getContextLineIterationBounds(state3, count, diffStyle) {
-  if (!state3.isWindowedHighlight || count <= 0) return [0, count];
+function getContextLineIterationBounds(state2, count, diffStyle) {
+  if (!state2.isWindowedHighlight || count <= 0) return [0, count];
   const ranges = [];
   function pushRange(currentCount) {
-    const start2 = Math.max(0, state3.viewportStart - currentCount);
-    const end2 = Math.min(count, state3.viewportEnd - currentCount);
+    const start2 = Math.max(0, state2.viewportStart - currentCount);
+    const end2 = Math.min(count, state2.viewportEnd - currentCount);
     if (end2 > start2) ranges.push([start2, end2]);
   }
-  if (diffStyle !== "split") pushRange(state3.unifiedCount);
-  if (diffStyle !== "unified") pushRange(state3.splitCount);
+  if (diffStyle !== "split") pushRange(state2.unifiedCount);
+  if (diffStyle !== "unified") pushRange(state2.splitCount);
   if (ranges.length === 0) return [0, 0];
   let start = ranges[0][0];
   let end = ranges[0][1];
@@ -62098,36 +62225,36 @@ function getContextLineIterationBounds(state3, count, diffStyle) {
   }
   return [start, end];
 }
-function walkContextLines(state3, count, diffStyle, callback, onSkippedStart, shouldBreak) {
-  const [startIndex, endIndex] = getContextLineIterationBounds(state3, count, diffStyle);
+function walkContextLines(state2, count, diffStyle, callback, onSkippedStart, shouldBreak) {
+  const [startIndex, endIndex] = getContextLineIterationBounds(state2, count, diffStyle);
   if (startIndex > 0) {
-    state3.incrementCounts(startIndex, startIndex);
+    state2.incrementCounts(startIndex, startIndex);
     onSkippedStart?.();
   }
   let index = startIndex;
   while (index < count) {
     if (shouldBreak?.() === true) return true;
     if (index >= endIndex) {
-      state3.incrementCounts(count - index, count - index);
+      state2.incrementCounts(count - index, count - index);
       break;
     }
-    if (state3.isInWindow(0, 0)) {
+    if (state2.isInWindow(0, 0)) {
       if (callback(index) === true) return true;
-    } else state3.incrementCounts(1, 1);
+    } else state2.incrementCounts(1, 1);
     index++;
   }
   return false;
 }
-function getChangeIterationRanges(state3, content, diffStyle) {
-  if (!state3.isWindowedHighlight) return [[0, diffStyle === "unified" ? content.deletions + content.additions : Math.max(content.deletions, content.additions)]];
+function getChangeIterationRanges(state2, content, diffStyle) {
+  if (!state2.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 <= state3.viewportStart || start >= state3.viewportEnd) return;
-    const visibleStart = Math.max(0, state3.viewportStart - start);
-    const visibleEnd = Math.min(count, state3.viewportEnd - start);
+    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);
     return visibleEnd > visibleStart ? [visibleStart, visibleEnd] : void 0;
   }
   function mapRangeToIteration(range3, kind) {
@@ -62140,12 +62267,12 @@ function getChangeIterationRanges(state3, content, diffStyle) {
     if (end > start) iterationRanges.push([start, end]);
   }
   if (useUnified) {
-    pushRange(getVisibleRange(state3.unifiedCount, content.deletions), "deletions");
-    pushRange(getVisibleRange(state3.unifiedCount + content.deletions, content.additions), "additions");
+    pushRange(getVisibleRange(state2.unifiedCount, content.deletions), "deletions");
+    pushRange(getVisibleRange(state2.unifiedCount + content.deletions, content.additions), "additions");
   }
   if (useSplit) {
-    pushRange(getVisibleRange(state3.splitCount, content.deletions), "deletions");
-    pushRange(getVisibleRange(state3.splitCount, content.additions), "additions");
+    pushRange(getVisibleRange(state2.splitCount, content.deletions), "deletions");
+    pushRange(getVisibleRange(state2.splitCount, content.additions), "additions");
   }
   if (iterationRanges.length === 0) return iterationRanges;
   iterationRanges.sort((a23, b13) => a23[0] - b13[0]);
@@ -62461,7 +62588,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: state3, transformers } = createTransformerWithState(options.useTokenTransformer);
+  const { state: state2, transformers } = createTransformerWithState(options.useTokenTransformer);
   const hastConfig = (() => {
     return typeof themeOrThemes === "string" ? {
       ...options,
@@ -62487,7 +62614,7 @@ function renderTwoFiles({ deletionFile, additionFile, deletionInfo, additionInfo
     deletionLines: (() => {
       if (deletionFile.contents === "") return [];
       hastConfig.lang = deletionLang;
-      state3.lineInfo = deletionInfo;
+      state2.lineInfo = deletionInfo;
       hastConfig.decorations = deletionDecorations;
       return getLineNodes(highlighter2.codeToHast(cleanLastNewline(deletionFile.contents), hastConfig));
     })(),
@@ -62495,7 +62622,7 @@ function renderTwoFiles({ deletionFile, additionFile, deletionInfo, additionInfo
       if (additionFile.contents === "") return [];
       hastConfig.lang = additionLang;
       hastConfig.decorations = additionDecorations;
-      state3.lineInfo = additionInfo;
+      state2.lineInfo = additionInfo;
       return getLineNodes(highlighter2.codeToHast(cleanLastNewline(additionFile.contents), hastConfig));
     })()
   };
@@ -63544,14 +63671,14 @@ var DiffHunksRenderer = class {
     this.diff = diff;
     const { options } = this.getRenderOptions(diff);
     const massiveDiff = isDiffMassive(diff, this.getTokenizeMaxLength());
-    let cache3 = this.workerManager?.getDiffResultCache(diff);
-    if (cache3 != null && !areDiffRenderOptionsEqual(options, cache3.options)) cache3 = void 0;
+    let cache4 = this.workerManager?.getDiffResultCache(diff);
+    if (cache4 != null && !areDiffRenderOptionsEqual(options, cache4.options)) cache4 = void 0;
     this.renderCache ??= {
       diff,
       hydrated: true,
       highlighted: !massiveDiff && !isDiffPlainText(diff),
       options,
-      result: massiveDiff ? void 0 : cache3?.result,
+      result: massiveDiff ? void 0 : cache4?.result,
       renderRange: void 0
     };
     if (!this.editSessionActive && this.workerManager?.isWorkingPool() === true) {
@@ -63761,9 +63888,9 @@ var DiffHunksRenderer = class {
   }
   getMatchingWorkerResultCache(diff, options) {
     if (this.editSessionActive) return;
-    const cache3 = this.workerManager?.getDiffResultCache(diff);
-    if (cache3 == null || !areDiffRenderOptionsEqual(options, cache3.options)) return;
-    return cache3;
+    const cache4 = this.workerManager?.getDiffResultCache(diff);
+    if (cache4 == null || !areDiffRenderOptionsEqual(options, cache4.options)) return;
+    return cache4;
   }
   getReadyRenderResult(diff, options) {
     const { pendingHighlightResult } = this;
@@ -65678,20 +65805,20 @@ var FileDiff = class {
     const staleSeparators = new Map(this.separatorCache);
     for (const hunk of hunkData) {
       const id = hunk.slotName;
-      let cache3 = this.separatorCache.get(id);
-      if (cache3 == null || !areHunkDataEqual(hunk, cache3.hunkData)) {
-        cache3?.element.remove();
+      let cache4 = this.separatorCache.get(id);
+      if (cache4 == null || !areHunkDataEqual(hunk, cache4.hunkData)) {
+        cache4?.element.remove();
         const element2 = document.createElement("div");
         element2.style.display = "contents";
         element2.slot = hunk.slotName;
         const child = hunkSeparators(hunk, this);
         if (child != null) element2.appendChild(child);
         this.fileContainer.appendChild(element2);
-        cache3 = {
+        cache4 = {
           element: element2,
           hunkData: hunk
         };
-        this.separatorCache.set(id, cache3);
+        this.separatorCache.set(id, cache4);
       }
       staleSeparators.delete(id);
     }
@@ -65712,18 +65839,18 @@ var FileDiff = class {
     if (renderAnnotation != null && lineAnnotations.length > 0) for (const [index, annotation] of lineAnnotations.entries()) {
       const name = this.getAnnotationSlotName(annotation);
       const id = `${index}-${name}`;
-      let cache3 = this.annotationCache.get(id);
-      if (cache3 == null || !areDiffLineAnnotationsEqual(annotation, cache3.annotation)) {
-        cache3?.element.remove();
+      let cache4 = this.annotationCache.get(id);
+      if (cache4 == null || !areDiffLineAnnotationsEqual(annotation, cache4.annotation)) {
+        cache4?.element.remove();
         const content = renderAnnotation(annotation);
         if (content == null) continue;
-        cache3 = {
+        cache4 = {
           element: createAnnotationWrapperNode(name),
           annotation
         };
-        cache3.element.appendChild(content);
-        this.fileContainer.appendChild(cache3.element);
-        this.annotationCache.set(id, cache3);
+        cache4.element.appendChild(content);
+        this.fileContainer.appendChild(cache4.element);
+        this.annotationCache.set(id, cache4);
       }
       staleAnnotations.delete(id);
     }
@@ -66469,13 +66596,13 @@ function getElementChildren(node) {
 var code_default = ':host {\n  display: block;\n  height: 100%;\n  overflow: auto;\n  background: var(--spectrum-background-layer-2-color, #fff);\n  --diffs-font-family: var(\n    --spectrum-code-font-family-stack,\n    ui-monospace,\n    "SF Mono",\n    Menlo,\n    Consolas,\n    monospace\n  );\n  --diffs-font-size: var(--spectrum-font-size-75, 12px);\n  --diffs-bg-context-override: var(--spectrum-background-layer-2-color, #fff);\n  --diffs-bg-context-gutter-override: var(--spectrum-background-layer-1-color, #f8f8f8);\n  --diffs-bg-buffer-override: var(--spectrum-background-layer-1-color, #f8f8f8);\n  --diffs-bg-separator-override: var(--spectrum-background-layer-1-color, #f8f8f8);\n  --diffs-fg-number-override: var(--spectrum-gray-600, #717171);\n}\n\n.empty {\n  padding: 24px;\n  color: var(--spectrum-neutral-subdued-content-color-default, #505050);\n  font-family: var(--spectrum-sans-font-family-stack, system-ui, sans-serif);\n  font-size: var(--spectrum-font-size-75, 12px);\n}\n';
 
 // src/components/sheets.ts
-var cache2 = /* @__PURE__ */ new WeakMap();
+var cache3 = /* @__PURE__ */ new WeakMap();
 function adoptStyles(root2, ...texts) {
   const document2 = root2.ownerDocument;
-  let sheets = cache2.get(document2);
+  let sheets = cache3.get(document2);
   if (!sheets) {
     sheets = /* @__PURE__ */ new Map();
-    cache2.set(document2, sheets);
+    cache3.set(document2, sheets);
   }
   const adopted = texts.map((text2) => {
     let sheet2 = sheets.get(text2);
@@ -68121,11 +68248,11 @@ var Splitview = class {
       else this.updateSash(sash, 3);
     }
   }
-  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);
+  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);
   }
   createViewContainer() {
     const element2 = document.createElement("div");
@@ -70324,14 +70451,14 @@ var Droptarget = class Droptarget2 extends CompositeDisposable {
       onDrop: (e122) => {
         var _this$options$getOver7, _this$options6;
         e122.preventDefault();
-        const state3 = this._state;
+        const state2 = 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 (state3) {
+        if (state2) {
           e122.stopPropagation();
           this._onDrop.fire({
-            position: state3,
+            position: state2,
             nativeEvent: e122,
             edge
           });
@@ -70805,13 +70932,13 @@ var PointerDropTarget = class extends CompositeDisposable {
   }
   _onDropEvent(event2) {
     var _this$options$getOver5, _this$options4;
-    const state3 = this._state;
+    const state2 = 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 (state3) this._onDrop.fire({
-      position: state3,
+    if (state2) this._onDrop.fire({
+      position: state2,
       nativeEvent: event2.pointerEvent,
       edge
     });
@@ -76864,10 +76991,10 @@ var GridviewPanel = class extends BasePanelView {
     });
   }
   toJSON() {
-    const state3 = super.toJSON();
+    const state2 = super.toJSON();
     const maximum = (value) => value === Number.MAX_SAFE_INTEGER ? void 0 : value;
     const minimum = (value) => value <= 0 ? void 0 : value;
-    return _objectSpread2(_objectSpread2({}, state3), {}, {
+    return _objectSpread2(_objectSpread2({}, state2), {}, {
       minimumHeight: minimum(this.minimumHeight),
       maximumHeight: maximum(this.maximumHeight),
       minimumWidth: minimum(this.minimumWidth),
@@ -77359,17 +77486,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(state3) {
+  updateFromStateModel(state2) {
     var _state$params, _state$title, _state$renderer, _state$pinned, _this$accessor$option;
-    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._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.view.update({ params: this._params });
-    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));
+    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));
   }
   updateParentGroup(group, options) {
     this._group = group;
@@ -78647,36 +78774,36 @@ var HeaderActionsService = class {
   }
   refresh(group) {
     if (!(group === null || group === void 0 ? void 0 : group.model)) return;
-    const state3 = this._ensureState(group);
-    this._refreshSlot("left", group, state3.left);
-    this._refreshSlot("right", group, state3.right);
-    this._refreshSlot("prefix", group, state3.prefix);
+    const state2 = this._ensureState(group);
+    this._refreshSlot("left", group, state2.left);
+    this._refreshSlot("right", group, state2.right);
+    this._refreshSlot("prefix", group, state2.prefix);
   }
   refreshAll() {
     for (const group of this._host.groups) this.refresh(group);
   }
   disposeGroup(group) {
-    const state3 = this._perGroup.get(group);
-    if (!state3) return;
-    state3.left.dispose();
-    state3.right.dispose();
-    state3.prefix.dispose();
+    const state2 = this._perGroup.get(group);
+    if (!state2) return;
+    state2.left.dispose();
+    state2.right.dispose();
+    state2.prefix.dispose();
     this._perGroup.delete(group);
   }
   dispose() {
     for (const group of [...this._perGroup.keys()]) this.disposeGroup(group);
   }
   _ensureState(group) {
-    let state3 = this._perGroup.get(group);
-    if (!state3) {
-      state3 = {
+    let state2 = this._perGroup.get(group);
+    if (!state2) {
+      state2 = {
         left: new MutableDisposable(),
         right: new MutableDisposable(),
         prefix: new MutableDisposable()
       };
-      this._perGroup.set(group, state3);
+      this._perGroup.set(group, state2);
     }
-    return state3;
+    return state2;
   }
   _refreshSlot(slot, group, disposable) {
     const factory = this._host.options[SLOT_OPTION_KEY[slot]];
@@ -80375,16 +80502,16 @@ var ShellManager = class {
       "bottom"
     ]) {
       var _state$collapsed;
-      const state3 = data[position];
+      const state2 = data[position];
       const view = this._getView(position);
-      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) {
+      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) {
         this._pendingSizes.delete(position);
         this._resizeView(position, view.collapsedSize);
-      } else this.resizeEdgeGroup(position, state3.size);
-      this.setEdgeGroupVisible(position, !!state3.visible);
+      } else this.resizeEdgeGroup(position, state2.size);
+      this.setEdgeGroupVisible(position, !!state2.visible);
     }
   }
   dispose() {