@vscode/component-explorer 0.1.1-2 → 0.1.1-20

package/dist/viewer.js

@@ -0,0 +1,3903 @@
+var Vt = Object.defineProperty;
+var Mt = (r, e, t) => e in r ? Vt(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var l = (r, e, t) => Mt(r, typeof e != "symbol" ? e + "" : e, t);
+import { f as Re, a as Te, s as ke } from "./index-BsQr630j.js";
+import { b as as, d as ds, c as cs, e as ls, g as hs } from "./index-BsQr630j.js";
+import { createRoot as Ft } from "react-dom/client";
+import { createContext as Ye, useReducer as Et, useState as Dt, useContext as Bt, useEffect as Ie, createElement as At } from "react";
+import { jsx as a, jsxs as g, Fragment as me } from "react/jsx-runtime";
+import { unstable_batchedUpdates as et } from "react-dom";
+function ve(r) {
+  return typeof r == "object" && r !== null && ke in r && r[ke] === !0 && "_options" in r && typeof r._options == "object";
+}
+function be(r) {
+  return typeof r == "object" && r !== null && Re in r && r[Re] === !0 && "_entries" in r && typeof r._entries == "object";
+}
+function _e(r) {
+  return typeof r == "object" && r !== null && Te in r && r[Te] === !0 && "_variants" in r && typeof r._variants == "object";
+}
+function Xn(r) {
+  return ve(r) ? { success: !0, data: r } : be(r) ? { success: !0, data: r } : _e(r) ? { success: !0, data: r } : { success: !1, error: "Value is not a valid fixture export (missing brand symbol or _options/_entries/_variants)" };
+}
+function Yn(r) {
+  return ve(r) ? { success: !0, data: r } : { success: !1, error: "Value is not a SingleFixtureExport" };
+}
+function es(r) {
+  return be(r) ? { success: !0, data: r } : { success: !1, error: "Value is not a FixtureGroupExport" };
+}
+function ts(r) {
+  return _e(r) ? { success: !0, data: r } : { success: !1, error: "Value is not a FixtureVariantsExport" };
+}
+function Oe(r, e, t) {
+  const n = r._options;
+  return {
+    id: e,
+    name: t,
+    description: n.description,
+    isolation: n.isolation ?? "shadow-dom",
+    displayMode: n.displayMode ?? { type: "component" },
+    styles: n.styles,
+    background: n.background ?? "light",
+    labels: n.labels ?? [],
+    properties: n.properties ?? [],
+    render: n.render
+  };
+}
+function rs(r) {
+  return typeof r == "object" && r !== null && "render" in r && typeof r.render == "function" && "id" in r && "name" in r;
+}
+const $t = {
+  mobile: { width: 390, height: 844 },
+  tablet: { width: 768, height: 1024 },
+  desktop: { width: 1440, height: 900 }
+};
+function zt(r) {
+  return typeof r == "string" ? { name: r, ...$t[r] } : r;
+}
+function Lt(r) {
+  const e = {};
+  for (const t of r)
+    e[t.name] = t.defaultValue;
+  return e;
+}
+function Ne(r) {
+  if (r.startsWith("/"))
+    throw new Error(`Fixture path cannot start with '/': ${r}`);
+  if (r.includes("//"))
+    throw new Error(`Fixture path cannot contain empty segments: ${r}`);
+  if (r === "")
+    throw new Error("Fixture path cannot be empty (use undefined for default)");
+}
+function Ht(r, e) {
+  const t = jt(r);
+  if (e === void 0)
+    return [t];
+  if (e.endsWith("/")) {
+    const n = e.slice(0, -1);
+    if (n)
+      return Ne(n), [...n.split("/"), t];
+    throw new Error(`Fixture path cannot be just '/': ${e}`);
+  } else
+    return Ne(e), e.split("/");
+}
+function ie(r) {
+  const e = {
+    id: "",
+    name: "Components",
+    type: "folder",
+    children: [],
+    labels: []
+  };
+  for (const [t, n] of r) {
+    const s = "_path" in n ? n._path : void 0, o = Ht(t, s);
+    tt(e, o, n);
+  }
+  return e;
+}
+function jt(r) {
+  return (r.split("/").pop() ?? r).replace(/\.fixture\.(tsx?|jsx?)$/, "");
+}
+function tt(r, e, t, n = []) {
+  var c, u;
+  let s = r;
+  const o = [...n];
+  for (let h = 0; h < e.length - 1; h++) {
+    const p = e[h];
+    o.push(p);
+    const m = o.join("/");
+    let b = (c = s.children) == null ? void 0 : c.find(
+      (S) => S.type === "folder" && S.name === p
+    );
+    b || (b = {
+      id: m,
+      name: p,
+      type: "folder",
+      children: [],
+      labels: []
+    }, s.children || (s.children = []), s.children.push(b)), s = b;
+  }
+  const i = e[e.length - 1];
+  o.push(i);
+  const d = o.join("/");
+  if (ve(t)) {
+    const h = Oe(t, d, i), p = {
+      id: d,
+      name: i,
+      type: "component",
+      component: h,
+      labels: [...h.labels]
+    };
+    s.children || (s.children = []), s.children.push(p);
+  } else if (be(t)) {
+    let h = (u = s.children) == null ? void 0 : u.find(
+      (p) => p.type === "folder" && p.name === i
+    );
+    h || (h = {
+      id: d,
+      name: i,
+      type: "folder",
+      children: [],
+      labels: [...t._labels ?? []]
+    }, s.children || (s.children = []), s.children.push(h));
+    for (const [p, m] of Object.entries(t._entries))
+      tt(h, [p], m, o);
+  } else if (_e(t)) {
+    const h = {
+      id: d,
+      name: i,
+      type: "variants",
+      children: [],
+      labels: [...t._labels ?? []]
+    };
+    s.children || (s.children = []), s.children.push(h);
+    for (const [p, m] of Object.entries(t._variants)) {
+      const b = [...o, p].join("/"), S = {
+        id: b,
+        name: p,
+        type: "component",
+        component: Oe(m, b, p),
+        labels: [...m._options.labels ?? []]
+      };
+      h.children.push(S);
+    }
+  }
+}
+function Ve(r, e) {
+  if (e.length === 0)
+    return r;
+  let t = r;
+  for (const n of e) {
+    if (!t || !t.children)
+      return;
+    t = t.children.find((s) => s.name === n);
+  }
+  return t;
+}
+function Ut(r) {
+  if (r.type === "component" && r.component)
+    return [r.component];
+  const e = [];
+  for (const t of r.children ?? [])
+    e.push(...Ut(t));
+  return e;
+}
+let L;
+function Pt(r) {
+  L ? L instanceof Me ? L.loggers.push(r) : L = new Me([L, r]) : L = r;
+}
+function y() {
+  return L;
+}
+let ae;
+function Wt(r) {
+  ae = r;
+}
+function Gt(r) {
+  ae && ae(r);
+}
+class Me {
+  constructor(e) {
+    this.loggers = e;
+  }
+  handleObservableCreated(e, t) {
+    for (const n of this.loggers)
+      n.handleObservableCreated(e, t);
+  }
+  handleOnListenerCountChanged(e, t) {
+    for (const n of this.loggers)
+      n.handleOnListenerCountChanged(e, t);
+  }
+  handleObservableUpdated(e, t) {
+    for (const n of this.loggers)
+      n.handleObservableUpdated(e, t);
+  }
+  handleAutorunCreated(e, t) {
+    for (const n of this.loggers)
+      n.handleAutorunCreated(e, t);
+  }
+  handleAutorunDisposed(e) {
+    for (const t of this.loggers)
+      t.handleAutorunDisposed(e);
+  }
+  handleAutorunDependencyChanged(e, t, n) {
+    for (const s of this.loggers)
+      s.handleAutorunDependencyChanged(e, t, n);
+  }
+  handleAutorunStarted(e) {
+    for (const t of this.loggers)
+      t.handleAutorunStarted(e);
+  }
+  handleAutorunFinished(e) {
+    for (const t of this.loggers)
+      t.handleAutorunFinished(e);
+  }
+  handleDerivedDependencyChanged(e, t, n) {
+    for (const s of this.loggers)
+      s.handleDerivedDependencyChanged(e, t, n);
+  }
+  handleDerivedCleared(e) {
+    for (const t of this.loggers)
+      t.handleDerivedCleared(e);
+  }
+  handleBeginTransaction(e) {
+    for (const t of this.loggers)
+      t.handleBeginTransaction(e);
+  }
+  handleEndTransaction(e) {
+    for (const t of this.loggers)
+      t.handleEndTransaction(e);
+  }
+}
+var V;
+(function(r) {
+  let e = !1;
+  function t() {
+    e = !0;
+  }
+  r.enable = t;
+  function n() {
+    return s(1);
+  }
+  r.ofCaller = n;
+  function s(o) {
+    if (!e)
+      return;
+    const i = Error, d = i.stackTraceLimit;
+    i.stackTraceLimit = 3;
+    const c = new Error().stack;
+    return i.stackTraceLimit = d, ye.fromStack(c, o + 1);
+  }
+  r.ofNthCaller = s;
+})(V || (V = {}));
+class ye {
+  static fromStack(e, t) {
+    const n = e.split(`
+`), s = qt(n[t + 1]);
+    if (s)
+      return new ye(s.fileName, s.line, s.column, s.id);
+  }
+  constructor(e, t, n, s) {
+    this.fileName = e, this.line = t, this.column = n, this.id = s;
+  }
+}
+function qt(r) {
+  if (!r)
+    return;
+  const e = r.match(/\((.*):(\d+):(\d+)\)/);
+  if (e)
+    return {
+      fileName: e[1],
+      line: parseInt(e[2]),
+      column: parseInt(e[3]),
+      id: r
+    };
+  const t = r.match(/at ([^\(\)]*):(\d+):(\d+)/);
+  if (t)
+    return {
+      fileName: t[1],
+      line: parseInt(t[2]),
+      column: parseInt(t[3]),
+      id: r
+    };
+}
+class D {
+  constructor(e, t, n) {
+    this.owner = e, this.debugNameSource = t, this.referenceFn = n;
+  }
+  getDebugName(e) {
+    return Kt(e, this);
+  }
+}
+const Fe = /* @__PURE__ */ new Map(), de = /* @__PURE__ */ new WeakMap();
+function Kt(r, e) {
+  const t = de.get(r);
+  if (t)
+    return t;
+  const n = Jt(r, e);
+  if (n) {
+    let s = Fe.get(n) ?? 0;
+    s++, Fe.set(n, s);
+    const o = s === 1 ? n : `${n}#${s}`;
+    return de.set(r, o), o;
+  }
+}
+function Jt(r, e) {
+  const t = de.get(r);
+  if (t)
+    return t;
+  const n = e.owner ? Zt(e.owner) + "." : "";
+  let s;
+  const o = e.debugNameSource;
+  if (o !== void 0)
+    if (typeof o == "function") {
+      if (s = o(), s !== void 0)
+        return n + s;
+    } else
+      return n + o;
+  const i = e.referenceFn;
+  if (i !== void 0 && (s = xe(i), s !== void 0))
+    return n + s;
+  if (e.owner !== void 0) {
+    const d = Qt(e.owner, r);
+    if (d !== void 0)
+      return n + d;
+  }
+}
+function Qt(r, e) {
+  for (const t in r)
+    if (r[t] === e)
+      return t;
+}
+const Ee = /* @__PURE__ */ new Map(), De = /* @__PURE__ */ new WeakMap();
+function Zt(r) {
+  const e = De.get(r);
+  if (e)
+    return e;
+  const t = rt(r) ?? "Object";
+  let n = Ee.get(t) ?? 0;
+  n++, Ee.set(t, n);
+  const s = n === 1 ? t : `${t}#${n}`;
+  return De.set(r, s), s;
+}
+function rt(r) {
+  const e = r.constructor;
+  if (e)
+    return e.name === "Object" ? void 0 : e.name;
+}
+function xe(r) {
+  const e = r.toString(), n = /\/\*\*\s*@description\s*([^*]*)\*\//.exec(e), s = n ? n[1] : void 0;
+  return s == null ? void 0 : s.trim();
+}
+let ce;
+function Xt(r) {
+  ce = r;
+}
+let nt;
+function Yt(r) {
+  nt = r;
+}
+let st;
+function er(r) {
+  st = r;
+}
+let ot;
+function tr(r) {
+  ot = r;
+}
+class rr {
+  get TChange() {
+    return null;
+  }
+  reportChanges() {
+    this.get();
+  }
+  /** @sealed */
+  read(e) {
+    return e ? e.readObservable(this) : this.get();
+  }
+  map(e, t, n = V.ofCaller()) {
+    const s = t === void 0 ? void 0 : e, o = t === void 0 ? e : t;
+    return ce({
+      owner: s,
+      debugName: () => {
+        const i = xe(o);
+        if (i !== void 0)
+          return i;
+        const c = /^\s*\(?\s*([a-zA-Z_$][a-zA-Z_$0-9]*)\s*\)?\s*=>\s*\1(?:\??)\.([a-zA-Z_$][a-zA-Z_$0-9]*)\s*$/.exec(o.toString());
+        if (c)
+          return `${this.debugName}.${c[2]}`;
+        if (!s)
+          return `${this.debugName} (mapped)`;
+      },
+      debugReferenceFn: o
+    }, (i) => o(this.read(i), i), n);
+  }
+  /**
+   * @sealed
+   * Converts an observable of an observable value into a direct observable of the value.
+  */
+  flatten() {
+    return ce({
+      owner: void 0,
+      debugName: () => `${this.debugName} (flattened)`
+    }, (e) => this.read(e).read(e));
+  }
+  recomputeInitiallyAndOnChange(e, t) {
+    return e.add(nt(this, t)), this;
+  }
+  /**
+   * Ensures that this observable is observed. This keeps the cache alive.
+   * However, in case of deriveds, it does not force eager evaluation (only when the value is read/get).
+   * Use `recomputeInitiallyAndOnChange` for eager evaluation.
+   */
+  keepObserved(e) {
+    return e.add(st(this)), this;
+  }
+  get debugValue() {
+    return this.get();
+  }
+  debugGetDependencyGraph() {
+    return ot(this);
+  }
+}
+class Se extends rr {
+  constructor(e) {
+    var t;
+    super(), this._observers = /* @__PURE__ */ new Set(), (t = y()) == null || t.handleObservableCreated(this, e);
+  }
+  addObserver(e) {
+    var n;
+    const t = this._observers.size;
+    this._observers.add(e), t === 0 && this.onFirstObserverAdded(), t !== this._observers.size && ((n = y()) == null || n.handleOnListenerCountChanged(this, this._observers.size));
+  }
+  removeObserver(e) {
+    var n;
+    const t = this._observers.delete(e);
+    t && this._observers.size === 0 && this.onLastObserverRemoved(), t && ((n = y()) == null || n.handleOnListenerCountChanged(this, this._observers.size));
+  }
+  onFirstObserverAdded() {
+  }
+  onLastObserverRemoved() {
+  }
+  log() {
+    var t;
+    const e = !!y();
+    return Gt(this), e || (t = y()) == null || t.handleObservableCreated(this, V.ofCaller()), this;
+  }
+  debugGetObservers() {
+    return this._observers;
+  }
+}
+function it(r) {
+  return {
+    dispose: r
+  };
+}
+class j extends Error {
+  constructor(e) {
+    super(e || "An unexpected bug occurred."), Object.setPrototypeOf(this, j.prototype);
+  }
+}
+function re(r) {
+  throw r;
+}
+function nr(r) {
+  console.error("Unexpected error:", r);
+}
+const X = (r, e) => r === e;
+class Y {
+  constructor() {
+    this.disposables = [], this._isDisposed = !1;
+  }
+  get isDisposed() {
+    return this._isDisposed;
+  }
+  dispose() {
+    this.clear(), this._isDisposed = !0;
+  }
+  add(e) {
+    return e && this.disposables.push(e), e;
+  }
+  remove(e) {
+    if (!e)
+      return e;
+    const t = this.disposables.indexOf(e);
+    return t !== -1 && this.disposables.splice(t, 1), e;
+  }
+  clear() {
+    for (const e of this.disposables)
+      e.dispose();
+    this.disposables = [];
+  }
+  leakItems() {
+    this.disposables = [];
+  }
+}
+function sr(r) {
+  switch (r) {
+    case 0:
+      return "initial";
+    case 1:
+      return "dependenciesMightHaveChanged";
+    case 2:
+      return "stale";
+    case 3:
+      return "upToDate";
+    default:
+      return "<unknown>";
+  }
+}
+class U extends Se {
+  get debugName() {
+    return this._debugNameData.getDebugName(this) ?? "(anonymous)";
+  }
+  constructor(e, t, n, s = void 0, o, i) {
+    var d;
+    super(i), this._debugNameData = e, this._computeFn = t, this._changeTracker = n, this._handleLastObserverRemoved = s, this._equalityComparator = o, this._state = 0, this._value = void 0, this._updateCount = 0, this._dependencies = /* @__PURE__ */ new Set(), this._dependenciesToBeRemoved = /* @__PURE__ */ new Set(), this._changeSummary = void 0, this._isUpdating = !1, this._isComputing = !1, this._didReportChange = !1, this._isInBeforeUpdate = !1, this._isReaderValid = !1, this._store = void 0, this._delayedStore = void 0, this._removedObserverToCallEndUpdateOn = null, this._changeSummary = (d = this._changeTracker) == null ? void 0 : d.createChangeSummary(void 0);
+  }
+  onLastObserverRemoved() {
+    var e, t;
+    this._state = 0, this._value = void 0, (e = y()) == null || e.handleDerivedCleared(this);
+    for (const n of this._dependencies)
+      n.removeObserver(this);
+    this._dependencies.clear(), this._store !== void 0 && (this._store.dispose(), this._store = void 0), this._delayedStore !== void 0 && (this._delayedStore.dispose(), this._delayedStore = void 0), (t = this._handleLastObserverRemoved) == null || t.call(this);
+  }
+  get() {
+    var t, n;
+    if (this._isComputing, this._observers.size === 0) {
+      let s;
+      try {
+        this._isReaderValid = !0;
+        let o;
+        this._changeTracker && (o = this._changeTracker.createChangeSummary(void 0), (n = (t = this._changeTracker).beforeUpdate) == null || n.call(t, this, o)), s = this._computeFn(this, o);
+      } finally {
+        this._isReaderValid = !1;
+      }
+      return this.onLastObserverRemoved(), s;
+    } else {
+      do {
+        if (this._state === 1) {
+          for (const s of this._dependencies)
+            if (s.reportChanges(), this._state === 2)
+              break;
+        }
+        this._state === 1 && (this._state = 3), this._state !== 3 && this._recompute();
+      } while (this._state !== 3);
+      return this._value;
+    }
+  }
+  _recompute() {
+    var n, s, o, i;
+    let e = !1;
+    this._isComputing = !0, this._didReportChange = !1;
+    const t = this._dependenciesToBeRemoved;
+    this._dependenciesToBeRemoved = this._dependencies, this._dependencies = t;
+    try {
+      const d = this._changeSummary;
+      this._isReaderValid = !0, this._changeTracker && (this._isInBeforeUpdate = !0, (s = (n = this._changeTracker).beforeUpdate) == null || s.call(n, this, d), this._isInBeforeUpdate = !1, this._changeSummary = (o = this._changeTracker) == null ? void 0 : o.createChangeSummary(d));
+      const c = this._state !== 0, u = this._value;
+      this._state = 3;
+      const h = this._delayedStore;
+      h !== void 0 && (this._delayedStore = void 0);
+      try {
+        this._store !== void 0 && (this._store.dispose(), this._store = void 0), this._value = this._computeFn(this, d);
+      } finally {
+        this._isReaderValid = !1;
+        for (const p of this._dependenciesToBeRemoved)
+          p.removeObserver(this);
+        this._dependenciesToBeRemoved.clear(), h !== void 0 && h.dispose();
+      }
+      e = this._didReportChange || c && !this._equalityComparator(u, this._value), (i = y()) == null || i.handleObservableUpdated(this, {
+        oldValue: u,
+        newValue: this._value,
+        change: void 0,
+        didChange: e,
+        hadValue: c
+      });
+    } catch (d) {
+      re(d);
+    }
+    if (this._isComputing = !1, !this._didReportChange && e)
+      for (const d of this._observers)
+        d.handleChange(this, void 0);
+    else
+      this._didReportChange = !1;
+  }
+  toString() {
+    return `LazyDerived<${this.debugName}>`;
+  }
+  // IObserver Implementation
+  beginUpdate(e) {
+    if (this._isUpdating)
+      throw new j("Cyclic deriveds are not supported yet!");
+    this._updateCount++, this._isUpdating = !0;
+    try {
+      const t = this._updateCount === 1;
+      if (this._state === 3 && (this._state = 1, !t))
+        for (const n of this._observers)
+          n.handlePossibleChange(this);
+      if (t)
+        for (const n of this._observers)
+          n.beginUpdate(this);
+    } finally {
+      this._isUpdating = !1;
+    }
+  }
+  endUpdate(e) {
+    if (this._updateCount--, this._updateCount === 0) {
+      const t = [...this._observers];
+      for (const n of t)
+        n.endUpdate(this);
+      if (this._removedObserverToCallEndUpdateOn) {
+        const n = [...this._removedObserverToCallEndUpdateOn];
+        this._removedObserverToCallEndUpdateOn = null;
+        for (const s of n)
+          s.endUpdate(this);
+      }
+    }
+  }
+  handlePossibleChange(e) {
+    if (this._state === 3 && this._dependencies.has(e) && !this._dependenciesToBeRemoved.has(e)) {
+      this._state = 1;
+      for (const t of this._observers)
+        t.handlePossibleChange(this);
+    }
+  }
+  handleChange(e, t) {
+    var n;
+    if (this._dependencies.has(e) && !this._dependenciesToBeRemoved.has(e) || this._isInBeforeUpdate) {
+      (n = y()) == null || n.handleDerivedDependencyChanged(this, e, t);
+      let s = !1;
+      try {
+        s = this._changeTracker ? this._changeTracker.handleChange({
+          changedObservable: e,
+          change: t,
+          didChange: (i) => i === e
+        }, this._changeSummary) : !0;
+      } catch (i) {
+        re(i);
+      }
+      const o = this._state === 3;
+      if (s && (this._state === 1 || o) && (this._state = 2, o))
+        for (const i of this._observers)
+          i.handlePossibleChange(this);
+    }
+  }
+  // IReader Implementation
+  _ensureReaderValid() {
+    if (!this._isReaderValid)
+      throw new j("The reader object cannot be used outside its compute function!");
+  }
+  readObservable(e) {
+    this._ensureReaderValid(), e.addObserver(this);
+    const t = e.get();
+    return this._dependencies.add(e), this._dependenciesToBeRemoved.delete(e), t;
+  }
+  reportChange(e) {
+    this._ensureReaderValid(), this._didReportChange = !0;
+    for (const t of this._observers)
+      t.handleChange(this, e);
+  }
+  get store() {
+    return this._ensureReaderValid(), this._store === void 0 && (this._store = new Y()), this._store;
+  }
+  get delayedStore() {
+    return this._ensureReaderValid(), this._delayedStore === void 0 && (this._delayedStore = new Y()), this._delayedStore;
+  }
+  addObserver(e) {
+    const t = !this._observers.has(e) && this._updateCount > 0;
+    super.addObserver(e), t && (this._removedObserverToCallEndUpdateOn && this._removedObserverToCallEndUpdateOn.has(e) ? this._removedObserverToCallEndUpdateOn.delete(e) : e.beginUpdate(this));
+  }
+  removeObserver(e) {
+    this._observers.has(e) && this._updateCount > 0 && (this._removedObserverToCallEndUpdateOn || (this._removedObserverToCallEndUpdateOn = /* @__PURE__ */ new Set()), this._removedObserverToCallEndUpdateOn.add(e)), super.removeObserver(e);
+  }
+  debugGetState() {
+    return {
+      state: this._state,
+      stateStr: sr(this._state),
+      updateCount: this._updateCount,
+      isComputing: this._isComputing,
+      dependencies: this._dependencies,
+      value: this._value
+    };
+  }
+  debugSetValue(e) {
+    this._value = e;
+  }
+  debugRecompute() {
+    this._isComputing ? this._state = 2 : this._recompute();
+  }
+  setValue(e, t, n) {
+    this._value = e;
+    const s = this._observers;
+    t.updateObserver(this, this);
+    for (const o of s)
+      o.handleChange(this, n);
+  }
+}
+function O(r, e, t = V.ofCaller()) {
+  return e !== void 0 ? new U(new D(r, void 0, e), e, void 0, void 0, X, t) : new U(new D(void 0, void 0, r), r, void 0, void 0, X, t);
+}
+function or(r, e, t = V.ofCaller()) {
+  return new U(new D(r.owner, r.debugName, r.debugReferenceFn), e, void 0, r.onLastObserverRemoved, r.equalsFn ?? X, t);
+}
+Xt(or);
+function ir(r, e, t = V.ofCaller()) {
+  let n, s;
+  n = r, s = void 0;
+  let o;
+  return new U(new D(s, void 0, n), (i) => {
+    o ? o.clear() : o = new Y();
+    const d = n(i);
+    return d && o.add(d), d;
+  }, void 0, () => {
+    o && (o.dispose(), o = void 0);
+  }, X, t);
+}
+function ar(r) {
+  switch (r) {
+    case 1:
+      return "dependenciesMightHaveChanged";
+    case 2:
+      return "stale";
+    case 3:
+      return "upToDate";
+    default:
+      return "<unknown>";
+  }
+}
+class at {
+  get debugName() {
+    return this._debugNameData.getDebugName(this) ?? "(anonymous)";
+  }
+  constructor(e, t, n, s) {
+    var o, i;
+    this._debugNameData = e, this._runFn = t, this._changeTracker = n, this._state = 2, this._updateCount = 0, this._disposed = !1, this._dependencies = /* @__PURE__ */ new Set(), this._dependenciesToBeRemoved = /* @__PURE__ */ new Set(), this._isRunning = !1, this._store = void 0, this._delayedStore = void 0, this._changeSummary = (o = this._changeTracker) == null ? void 0 : o.createChangeSummary(void 0), (i = y()) == null || i.handleAutorunCreated(this, s), this._run();
+  }
+  dispose() {
+    var e;
+    if (!this._disposed) {
+      this._disposed = !0;
+      for (const t of this._dependencies)
+        t.removeObserver(this);
+      this._dependencies.clear(), this._store !== void 0 && this._store.dispose(), this._delayedStore !== void 0 && this._delayedStore.dispose(), (e = y()) == null || e.handleAutorunDisposed(this);
+    }
+  }
+  _run() {
+    var t, n, s, o;
+    const e = this._dependenciesToBeRemoved;
+    this._dependenciesToBeRemoved = this._dependencies, this._dependencies = e, this._state = 3;
+    try {
+      if (!this._disposed) {
+        (t = y()) == null || t.handleAutorunStarted(this);
+        const i = this._changeSummary, d = this._delayedStore;
+        d !== void 0 && (this._delayedStore = void 0);
+        try {
+          this._isRunning = !0, this._changeTracker && ((s = (n = this._changeTracker).beforeUpdate) == null || s.call(n, this, i), this._changeSummary = this._changeTracker.createChangeSummary(i)), this._store !== void 0 && (this._store.dispose(), this._store = void 0), this._runFn(this, i);
+        } catch (c) {
+          re(c);
+        } finally {
+          this._isRunning = !1, d !== void 0 && d.dispose();
+        }
+      }
+    } finally {
+      this._disposed || (o = y()) == null || o.handleAutorunFinished(this);
+      for (const i of this._dependenciesToBeRemoved)
+        i.removeObserver(this);
+      this._dependenciesToBeRemoved.clear();
+    }
+  }
+  toString() {
+    return `Autorun<${this.debugName}>`;
+  }
+  // IObserver implementation
+  beginUpdate(e) {
+    this._state === 3 && (this._state = 1), this._updateCount++;
+  }
+  endUpdate(e) {
+    try {
+      if (this._updateCount === 1)
+        do {
+          if (this._state === 1) {
+            this._state = 3;
+            for (const t of this._dependencies)
+              if (t.reportChanges(), this._state === 2)
+                break;
+          }
+          this._state !== 3 && this._run();
+        } while (this._state !== 3);
+    } finally {
+      this._updateCount--;
+    }
+  }
+  handlePossibleChange(e) {
+    this._state === 3 && this._isDependency(e) && (this._state = 1);
+  }
+  handleChange(e, t) {
+    var n;
+    if (this._isDependency(e)) {
+      (n = y()) == null || n.handleAutorunDependencyChanged(this, e, t);
+      try {
+        (this._changeTracker ? this._changeTracker.handleChange({
+          changedObservable: e,
+          change: t,
+          didChange: (o) => o === e
+        }, this._changeSummary) : !0) && (this._state = 2);
+      } catch (s) {
+        re(s);
+      }
+    }
+  }
+  _isDependency(e) {
+    return this._dependencies.has(e) && !this._dependenciesToBeRemoved.has(e);
+  }
+  // IReader implementation
+  _ensureNoRunning() {
+    if (!this._isRunning)
+      throw new j("The reader object cannot be used outside its compute function!");
+  }
+  readObservable(e) {
+    if (this._ensureNoRunning(), this._disposed)
+      return e.get();
+    e.addObserver(this);
+    const t = e.get();
+    return this._dependencies.add(e), this._dependenciesToBeRemoved.delete(e), t;
+  }
+  get store() {
+    if (this._ensureNoRunning(), this._disposed)
+      throw new j("Cannot access store after dispose");
+    return this._store === void 0 && (this._store = new Y()), this._store;
+  }
+  get delayedStore() {
+    if (this._ensureNoRunning(), this._disposed)
+      throw new j("Cannot access store after dispose");
+    return this._delayedStore === void 0 && (this._delayedStore = new Y()), this._delayedStore;
+  }
+  debugGetState() {
+    return {
+      isRunning: this._isRunning,
+      updateCount: this._updateCount,
+      dependencies: this._dependencies,
+      state: this._state,
+      stateStr: ar(this._state)
+    };
+  }
+  debugRerun() {
+    this._isRunning ? this._state = 2 : this._run();
+  }
+}
+function dt(r, e = V.ofCaller()) {
+  return new at(new D(void 0, void 0, r), r, void 0, e);
+}
+function Be(r) {
+  const e = new Error("BugIndicatingErrorRecovery: " + r);
+  nr(e), console.error("recovered from an error that indicates a bug", e);
+}
+function ct(r, e) {
+  const t = new lt(r, e);
+  try {
+    r(t);
+  } finally {
+    t.finish();
+  }
+}
+function dr(r, e, t) {
+  r ? e(r) : ct(e, t);
+}
+class lt {
+  constructor(e, t) {
+    var n;
+    this._fn = e, this._getDebugName = t, this._updatingObservers = [], (n = y()) == null || n.handleBeginTransaction(this);
+  }
+  getDebugName() {
+    return this._getDebugName ? this._getDebugName() : xe(this._fn);
+  }
+  updateObserver(e, t) {
+    if (!this._updatingObservers) {
+      Be("Transaction already finished!"), ct((n) => {
+        n.updateObserver(e, t);
+      });
+      return;
+    }
+    this._updatingObservers.push({ observer: e, observable: t }), e.beginUpdate(t);
+  }
+  finish() {
+    var t;
+    const e = this._updatingObservers;
+    if (!e) {
+      Be("transaction.finish() has already been called!");
+      return;
+    }
+    for (let n = 0; n < e.length; n++) {
+      const { observer: s, observable: o } = e[n];
+      s.endUpdate(o);
+    }
+    this._updatingObservers = null, (t = y()) == null || t.handleEndTransaction(this);
+  }
+  debugGetUpdatingObservers() {
+    return this._updatingObservers;
+  }
+}
+function x(r, e, t = V.ofCaller()) {
+  let n;
+  return typeof r == "string" ? n = new D(void 0, r, void 0) : n = new D(r, void 0, void 0), new ht(n, e, X, t);
+}
+class ht extends Se {
+  get debugName() {
+    return this._debugNameData.getDebugName(this) ?? "ObservableValue";
+  }
+  constructor(e, t, n, s) {
+    var o;
+    super(s), this._debugNameData = e, this._equalityComparator = n, this._value = t, (o = y()) == null || o.handleObservableUpdated(this, { hadValue: !1, newValue: t, change: void 0, didChange: !0, oldValue: void 0 });
+  }
+  get() {
+    return this._value;
+  }
+  set(e, t, n) {
+    var o;
+    if (n === void 0 && this._equalityComparator(this._value, e))
+      return;
+    let s;
+    t || (t = s = new lt(() => {
+    }, () => `Setting ${this.debugName}`));
+    try {
+      const i = this._value;
+      this._setValue(e), (o = y()) == null || o.handleObservableUpdated(this, { oldValue: i, newValue: e, change: n, didChange: !0, hadValue: !0 });
+      for (const d of this._observers)
+        t.updateObserver(d, this), d.handleChange(this, n);
+    } finally {
+      s && s.finish();
+    }
+  }
+  toString() {
+    return `${this.debugName}: ${this._value}`;
+  }
+  _setValue(e) {
+    this._value = e;
+  }
+  debugGetState() {
+    return {
+      value: this._value
+    };
+  }
+  debugSetValue(e) {
+    this._value = e;
+  }
+}
+function Ae(...r) {
+  let e, t, n, s;
+  return r.length === 2 ? [t, n] = r : [e, t, n, s] = r, new H(new D(e, void 0, n), t, n, () => H.globalTransaction, X, s ?? V.ofCaller());
+}
+class H extends Se {
+  constructor(e, t, n, s, o, i) {
+    super(i), this._debugNameData = e, this.event = t, this._getValue = n, this._getTransaction = s, this._equalityComparator = o, this._hasValue = !1, this.handleEvent = (d) => {
+      var m;
+      const c = this._getValue(d), u = this._value, h = !this._hasValue || !this._equalityComparator(u, c);
+      let p = !1;
+      h && (this._value = c, this._hasValue && (p = !0, dr(this._getTransaction(), (b) => {
+        var S;
+        (S = y()) == null || S.handleObservableUpdated(this, { oldValue: u, newValue: c, change: void 0, didChange: h, hadValue: this._hasValue });
+        for (const C of this._observers)
+          b.updateObserver(C, this), C.handleChange(this, void 0);
+      }, () => {
+        const b = this.getDebugName();
+        return "Event fired" + (b ? `: ${b}` : "");
+      })), this._hasValue = !0), p || (m = y()) == null || m.handleObservableUpdated(this, { oldValue: u, newValue: c, change: void 0, didChange: h, hadValue: this._hasValue });
+    };
+  }
+  getDebugName() {
+    return this._debugNameData.getDebugName(this);
+  }
+  get debugName() {
+    const e = this.getDebugName();
+    return "From Event" + (e ? `: ${e}` : "");
+  }
+  onFirstObserverAdded() {
+    this._subscription = this.event(this.handleEvent);
+  }
+  onLastObserverRemoved() {
+    this._subscription.dispose(), this._subscription = void 0, this._hasValue = !1, this._value = void 0;
+  }
+  get() {
+    return this._subscription ? (this._hasValue || this.handleEvent(void 0), this._value) : this._getValue(void 0);
+  }
+  debugSetValue(e) {
+    this._value = e;
+  }
+  debugGetState() {
+    return { value: this._value, hasValue: this._hasValue };
+  }
+}
+(function(r) {
+  r.Observer = H;
+  function e(t, n) {
+    let s = !1;
+    H.globalTransaction === void 0 && (H.globalTransaction = t, s = !0);
+    try {
+      n();
+    } finally {
+      s && (H.globalTransaction = void 0);
+    }
+  }
+  r.batchEventsGlobally = e;
+})(Ae || (Ae = {}));
+function cr(r) {
+  const e = new ut(!1, void 0);
+  return r.addObserver(e), it(() => {
+    r.removeObserver(e);
+  });
+}
+er(cr);
+function lr(r, e) {
+  const t = new ut(!0, e);
+  r.addObserver(t);
+  try {
+    t.beginUpdate(r);
+  } finally {
+    t.endUpdate(r);
+  }
+  return it(() => {
+    r.removeObserver(t);
+  });
+}
+Yt(lr);
+class ut {
+  constructor(e, t) {
+    this._forceRecompute = e, this._handleValue = t, this._counter = 0;
+  }
+  beginUpdate(e) {
+    this._counter++;
+  }
+  endUpdate(e) {
+    this._counter === 1 && this._forceRecompute && (this._handleValue ? this._handleValue(e.get()) : e.reportChanges()), this._counter--;
+  }
+  handlePossibleChange(e) {
+  }
+  handleChange(e, t) {
+  }
+}
+let ee;
+function hr(r) {
+  ee || (ee = new ur(), Pt(ee)), ee.addFilteredObj(r);
+}
+class ur {
+  constructor() {
+    this.indentation = 0, this.changedObservablesSets = /* @__PURE__ */ new WeakMap();
+  }
+  addFilteredObj(e) {
+    this._filteredObjects || (this._filteredObjects = /* @__PURE__ */ new Set()), this._filteredObjects.add(e);
+  }
+  _isIncluded(e) {
+    var t;
+    return ((t = this._filteredObjects) == null ? void 0 : t.has(e)) ?? !0;
+  }
+  textToConsoleArgs(e) {
+    return pr([
+      P(vr("|  ", this.indentation)),
+      e
+    ]);
+  }
+  formatInfo(e) {
+    return e.hadValue ? e.didChange ? [
+      P(" "),
+      T(Z(e.oldValue, 70), {
+        color: "red",
+        strikeThrough: !0
+      }),
+      P(" "),
+      T(Z(e.newValue, 60), {
+        color: "green"
+      })
+    ] : [P(" (unchanged)")] : [
+      P(" "),
+      T(Z(e.newValue, 60), {
+        color: "green"
+      }),
+      P(" (initial)")
+    ];
+  }
+  handleObservableCreated(e) {
+    if (e instanceof U) {
+      const t = e;
+      this.changedObservablesSets.set(t, /* @__PURE__ */ new Set());
+    }
+  }
+  handleOnListenerCountChanged(e, t) {
+  }
+  handleObservableUpdated(e, t) {
+    if (this._isIncluded(e)) {
+      if (e instanceof U) {
+        this._handleDerivedRecomputed(e, t);
+        return;
+      }
+      console.log(...this.textToConsoleArgs([
+        W("observable value changed"),
+        T(e.debugName, { color: "BlueViolet" }),
+        ...this.formatInfo(t)
+      ]));
+    }
+  }
+  formatChanges(e) {
+    if (e.size !== 0)
+      return T(" (changed deps: " + [...e].map((t) => t.debugName).join(", ") + ")", { color: "gray" });
+  }
+  handleDerivedDependencyChanged(e, t, n) {
+    var s;
+    this._isIncluded(e) && ((s = this.changedObservablesSets.get(e)) == null || s.add(t));
+  }
+  _handleDerivedRecomputed(e, t) {
+    if (!this._isIncluded(e))
+      return;
+    const n = this.changedObservablesSets.get(e);
+    n && (console.log(...this.textToConsoleArgs([
+      W("derived recomputed"),
+      T(e.debugName, { color: "BlueViolet" }),
+      ...this.formatInfo(t),
+      this.formatChanges(n),
+      { data: [{ fn: e._debugNameData.referenceFn ?? e._computeFn }] }
+    ])), n.clear());
+  }
+  handleDerivedCleared(e) {
+    this._isIncluded(e) && console.log(...this.textToConsoleArgs([
+      W("derived cleared"),
+      T(e.debugName, { color: "BlueViolet" })
+    ]));
+  }
+  handleFromEventObservableTriggered(e, t) {
+    this._isIncluded(e) && console.log(...this.textToConsoleArgs([
+      W("observable from event triggered"),
+      T(e.debugName, { color: "BlueViolet" }),
+      ...this.formatInfo(t),
+      { data: [{ fn: e._getValue }] }
+    ]));
+  }
+  handleAutorunCreated(e) {
+    this._isIncluded(e) && this.changedObservablesSets.set(e, /* @__PURE__ */ new Set());
+  }
+  handleAutorunDisposed(e) {
+  }
+  handleAutorunDependencyChanged(e, t, n) {
+    this._isIncluded(e) && this.changedObservablesSets.get(e).add(t);
+  }
+  handleAutorunStarted(e) {
+    const t = this.changedObservablesSets.get(e);
+    t && (this._isIncluded(e) && console.log(...this.textToConsoleArgs([
+      W("autorun"),
+      T(e.debugName, { color: "BlueViolet" }),
+      this.formatChanges(t),
+      { data: [{ fn: e._debugNameData.referenceFn ?? e._runFn }] }
+    ])), t.clear(), this.indentation++);
+  }
+  handleAutorunFinished(e) {
+    this.indentation--;
+  }
+  handleBeginTransaction(e) {
+    let t = e.getDebugName();
+    t === void 0 && (t = ""), this._isIncluded(e) && console.log(...this.textToConsoleArgs([
+      W("transaction"),
+      T(t, { color: "BlueViolet" }),
+      { data: [{ fn: e._fn }] }
+    ])), this.indentation++;
+  }
+  handleEndTransaction() {
+    this.indentation--;
+  }
+}
+function pr(r) {
+  const e = new Array(), t = [];
+  let n = "";
+  function s(i) {
+    if ("length" in i)
+      for (const d of i)
+        d && s(d);
+    else "text" in i ? (n += `%c${i.text}`, e.push(i.style), i.data && t.push(...i.data)) : "data" in i && t.push(...i.data);
+  }
+  s(r);
+  const o = [n, ...e];
+  return o.push(...t), o;
+}
+function P(r) {
+  return T(r, { color: "black" });
+}
+function W(r) {
+  return T(br(`${r}: `, 10), { color: "black", bold: !0 });
+}
+function T(r, e = {
+  color: "black"
+}) {
+  function t(s) {
+    return Object.entries(s).reduce((o, [i, d]) => `${o}${i}:${d};`, "");
+  }
+  const n = {
+    color: e.color
+  };
+  return e.strikeThrough && (n["text-decoration"] = "line-through"), e.bold && (n["font-weight"] = "bold"), {
+    text: r,
+    style: t(n)
+  };
+}
+function Z(r, e) {
+  try {
+    return fr(r, e);
+  } catch {
+    return "[[???]]";
+  }
+}
+function fr(r, e) {
+  switch (typeof r) {
+    case "number":
+      return "" + r;
+    case "string":
+      return r.length + 2 <= e ? `"${r}"` : `"${r.substr(0, e - 7)}"+...`;
+    case "boolean":
+      return r ? "true" : "false";
+    case "undefined":
+      return "undefined";
+    case "object":
+      return r === null ? "null" : Array.isArray(r) ? gr(r, e) : mr(r, e);
+    case "symbol":
+      return r.toString();
+    case "function":
+      return `[[Function${r.name ? " " + r.name : ""}]]`;
+    default:
+      return "" + r;
+  }
+}
+function gr(r, e) {
+  let t = "[ ", n = !0;
+  for (const s of r) {
+    if (n || (t += ", "), t.length - 5 > e) {
+      t += "...";
+      break;
+    }
+    n = !1, t += `${Z(s, e - t.length)}`;
+  }
+  return t += " ]", t;
+}
+function mr(r, e) {
+  try {
+    if (typeof r.toString == "function" && r.toString !== Object.prototype.toString) {
+      const i = r.toString();
+      return i.length <= e ? i : i.substring(0, e - 3) + "...";
+    }
+  } catch {
+    return "[[Object]]";
+  }
+  const t = rt(r);
+  let n = t ? t + "(" : "{ ", s = !0, o;
+  try {
+    o = Object.entries(r);
+  } catch {
+    return t ? `${t}(...)` : "[[Object]]";
+  }
+  for (const [i, d] of o) {
+    if (s || (n += ", "), n.length - 5 > e) {
+      n += "...";
+      break;
+    }
+    s = !1, n += `${i}: ${Z(d, e - n.length)}`;
+  }
+  return n += t ? ")" : " }", n;
+}
+function vr(r, e) {
+  let t = "";
+  for (let n = 1; n <= e; n++)
+    t += r;
+  return t;
+}
+function br(r, e) {
+  for (; r.length < e; )
+    r += " ";
+  return r;
+}
+function _r(r, e) {
+  const t = (e == null ? void 0 : e.debugNamePostProcessor) ?? ((o) => o), n = I.from(r, t);
+  return n ? pt(n, 0, /* @__PURE__ */ new Set()).trim() : "";
+}
+function pt(r, e, t) {
+  const n = "		".repeat(e), s = [];
+  if (t.has(r.sourceObj))
+    return s.push(`${n}* ${r.type} ${r.name} (already listed)`), s.join(`
+`);
+  if (t.add(r.sourceObj), s.push(`${n}* ${r.type} ${r.name}:`), s.push(`${n}  value: ${Z(r.value, 50)}`), s.push(`${n}  state: ${r.state}`), r.dependencies.length > 0) {
+    s.push(`${n}  dependencies:`);
+    for (const i of r.dependencies)
+      s.push(pt(i, e + 1, t));
+  }
+  return s.join(`
+`);
+}
+class I {
+  static from(e, t) {
+    if (e instanceof at) {
+      const n = e.debugGetState();
+      return new I(e, t(e.debugName), "autorun", void 0, n.stateStr, Array.from(n.dependencies).map((s) => I.from(s, t) || I.unknown(s)));
+    } else if (e instanceof U) {
+      const n = e.debugGetState();
+      return new I(e, t(e.debugName), "derived", n.value, n.stateStr, Array.from(n.dependencies).map((s) => I.from(s, t) || I.unknown(s)));
+    } else if (e instanceof ht) {
+      const n = e.debugGetState();
+      return new I(e, t(e.debugName), "observableValue", n.value, "upToDate", []);
+    } else if (e instanceof H) {
+      const n = e.debugGetState();
+      return new I(e, t(e.debugName), "fromEvent", n.value, n.hasValue ? "upToDate" : "initial", []);
+    }
+  }
+  static unknown(e) {
+    return new I(e, "(unknown)", "unknown", void 0, "unknown", []);
+  }
+  constructor(e, t, n, s, o, i) {
+    this.sourceObj = e, this.name = t, this.type = n, this.value = s, this.state = o, this.dependencies = i;
+  }
+}
+tr(_r);
+Wt(hr);
+class yr {
+  constructor() {
+    l(this, "_fixtures", x(this, /* @__PURE__ */ new Map()));
+    /** Observable root of the fixture tree */
+    l(this, "root", O(this, (e) => {
+      const t = this._fixtures.read(e);
+      return ie(t);
+    }));
+  }
+  /**
+   * Registers a fixture file.
+   * @param path The file path (e.g., 'components/Button.fixture.tsx')
+   * @param fixtureExport The exported fixture object
+   */
+  register(e, t) {
+    const n = new Map(this._fixtures.get());
+    n.set(e, t), this._fixtures.set(n, void 0);
+  }
+  /**
+   * Unregisters a fixture file.
+   * @param path The file path to remove
+   */
+  unregister(e) {
+    const t = new Map(this._fixtures.get());
+    t.delete(e) && this._fixtures.set(t, void 0);
+  }
+  /**
+   * Clears all registered fixtures.
+   */
+  clear() {
+    this._fixtures.set(/* @__PURE__ */ new Map(), void 0);
+  }
+  /**
+   * Gets a node by path.
+   */
+  getNode(e, t) {
+    const n = this.root.read(e);
+    return Ve(n, t);
+  }
+  /**
+   * Gets a component by path (non-reactive, for use in preview iframe).
+   * @param path Array of path segments (e.g., ['Button', 'Primary'])
+   */
+  getComponentByPath(e) {
+    const t = this._fixtures.get(), n = ie(t), s = Ve(n, e);
+    return s == null ? void 0 : s.component;
+  }
+}
+class ft {
+  constructor(e, t) {
+    l(this, "renderTarget");
+    l(this, "shadowRoot");
+    l(this, "_abortController", new AbortController());
+    l(this, "_rawResult");
+    l(this, "_resolvedResult");
+    if (this.component = t, t.isolation === "shadow-dom") {
+      let s;
+      if (e.shadowRoot) {
+        for (s = e.shadowRoot; s.firstChild; )
+          s.removeChild(s.firstChild);
+        s.adoptedStyleSheets = [];
+      } else
+        s = e.attachShadow({ mode: "open" });
+      if (t.styles)
+        for (const o of t.styles)
+          if (o.type === "css") {
+            const i = document.createElement("style");
+            i.textContent = o.content, s.appendChild(i);
+          } else if (o.type === "url") {
+            const i = document.createElement("link");
+            i.rel = "stylesheet", i.href = o.href, s.appendChild(i);
+          } else o.type === "adopted" && (s.adoptedStyleSheets = [
+            ...s.adoptedStyleSheets,
+            o.sheet
+          ]);
+      this.renderTarget = document.createElement("div"), s.appendChild(this.renderTarget), this.shadowRoot = s;
+    } else
+      this.renderTarget = document.createElement("div"), e.appendChild(this.renderTarget), this.shadowRoot = null;
+    const n = Lt(t.properties);
+    this._rawResult = t.render(this.renderTarget, {
+      props: n,
+      signal: this._abortController.signal
+    }), this._rawResult instanceof Promise ? this._rawResult.then((s) => {
+      var o;
+      this._abortController.signal.aborted ? (o = s == null ? void 0 : s.dispose) == null || o.call(s) : this._resolvedResult = s ?? void 0;
+    }).catch(() => {
+    }) : this._resolvedResult = this._rawResult ?? void 0;
+  }
+  get result() {
+    return this._rawResult;
+  }
+  dispose() {
+    var e, t;
+    this._abortController.abort(), (t = (e = this._resolvedResult) == null ? void 0 : e.dispose) == null || t.call(e), this._resolvedResult = void 0;
+  }
+}
+class ns {
+  constructor(e, t) {
+    l(this, "sessionId", Math.random().toString(36).slice(2));
+    l(this, "_updateVersion", 0);
+    l(this, "_root");
+    l(this, "_fixtureModules");
+    l(this, "_currentRendering");
+    l(this, "_currentContainer");
+    this._containerElement = e, this._fixtureModules = t, this._root = this._buildRegistry(), this._installGlobalApi();
+    const n = this._flattenFixtures(this._root).length;
+    console.log("[cli] CLI entry initialized, sessionId:", this.sessionId, "version:", this._updateVersion, "fixtures:", n);
+  }
+  get updateVersion() {
+    return this._updateVersion;
+  }
+  updateFixtures(e) {
+    this._fixtureModules = e, this._root = this._buildRegistry(), this._updateVersion++;
+    const t = this._flattenFixtures(this._root).length;
+    console.log("[cli] Registry rebuilt, version:", this._updateVersion, "fixtures:", t);
+  }
+  bumpVersion() {
+    this._updateVersion++, console.log("[cli] Version bumped:", this._updateVersion);
+  }
+  listFixtures() {
+    return this._flattenFixtures(this._root);
+  }
+  async renderFixture(e) {
+    const t = this._findFixtureNode(this._root, e);
+    if (!t || !t.component)
+      throw new Error("Fixture not found: " + e);
+    this._currentRendering && (this._currentRendering.dispose(), this._currentRendering = void 0), this._currentContainer && (this._currentContainer.remove(), this._currentContainer = void 0);
+    const n = document.createElement("div");
+    n.style.display = "inline-block", this._containerElement.appendChild(n), this._currentContainer = n;
+    const s = t.component, o = [], i = console.error, d = console.warn;
+    console.error = (...h) => {
+      o.push({ kind: "console", level: "error", message: h.map(String).join(" ") }), i.apply(console, h);
+    }, console.warn = (...h) => {
+      o.push({ kind: "console", level: "warn", message: h.map(String).join(" ") }), d.apply(console, h);
+    };
+    const c = (h) => {
+      var p;
+      o.push({ kind: "exception", message: h.message, stack: (p = h.error) == null ? void 0 : p.stack });
+    }, u = (h) => {
+      const p = h.reason, m = p instanceof Error ? p.message : String(p), b = p instanceof Error ? p.stack : void 0;
+      o.push({ kind: "exception", message: m, stack: b });
+    };
+    window.addEventListener("error", c), window.addEventListener("unhandledrejection", u);
+    try {
+      const h = new ft(n, s);
+      this._currentRendering = h;
+      const p = 3e3;
+      let m;
+      const b = h.result;
+      if (b instanceof Promise) {
+        const S = new Promise((_) => setTimeout(() => _("timeout"), p)), C = await Promise.race([b.then((_) => ({ resolved: _ })), S]);
+        C === "timeout" ? (h.dispose(), o.push({ kind: "exception", message: `Fixture render() timed out after ${p}ms` })) : m = C.resolved ?? void 0;
+      } else
+        m = b ?? void 0;
+      if (m != null && m.ready) {
+        const S = new Promise((_) => setTimeout(() => _("timeout"), p));
+        await Promise.race([m.ready.then(() => "done"), S]) === "timeout" && (h.dispose(), o.push({ kind: "exception", message: `Fixture ready promise timed out after ${p}ms` }));
+      }
+    } catch (h) {
+      const p = h instanceof Error ? h : new Error(String(h));
+      o.push({ kind: "exception", message: p.message, stack: p.stack });
+    } finally {
+      console.error = i, console.warn = d;
+    }
+    return await new Promise((h) => requestAnimationFrame(() => requestAnimationFrame(() => h()))), window.removeEventListener("error", c), window.removeEventListener("unhandledrejection", u), { errors: o };
+  }
+  _buildRegistry() {
+    const e = /* @__PURE__ */ new Map();
+    for (const [t, n] of Object.entries(this._fixtureModules)) {
+      const s = n.default;
+      s && typeof s == "object" && e.set(t, s);
+    }
+    return ie(e);
+  }
+  _flattenFixtures(e, t = [], n = []) {
+    var i;
+    const s = n.length > 0 && e.labels.length > 0 ? [.../* @__PURE__ */ new Set([...n, ...e.labels])] : e.labels.length > 0 ? [...e.labels] : [...n], o = [];
+    e.type === "component" && o.push({ fixtureId: e.id, fixtureName: e.name, groupPath: t, background: ((i = e.component) == null ? void 0 : i.background) ?? "light", labels: s });
+    for (const d of e.children ?? []) {
+      const c = e.id ? [...t, e.name] : t;
+      o.push(...this._flattenFixtures(d, c, s));
+    }
+    return o;
+  }
+  _findFixtureNode(e, t) {
+    if (e.id === t) return e;
+    for (const n of e.children ?? []) {
+      const s = this._findFixtureNode(n, t);
+      if (s) return s;
+    }
+  }
+  _installGlobalApi() {
+    window.__componentExplorerCli__ = {
+      sessionId: this.sessionId,
+      get updateVersion() {
+        return 0;
+      },
+      listFixtures: () => this.listFixtures(),
+      renderFixture: (e) => this.renderFixture(e)
+    }, Object.defineProperty(window.__componentExplorerCli__, "updateVersion", {
+      get: () => this._updateVersion
+    });
+  }
+}
+class xr {
+  constructor(e) {
+    this._run = e, this._changes = [], this._map = /* @__PURE__ */ new Map(), this._updateCounter = 0;
+  }
+  addDependency(e, t) {
+    return this._map.set(e, t), e.addObserver(this), {
+      dispose: () => {
+        this._map.delete(e), e.removeObserver(this);
+      }
+    };
+  }
+  beginUpdate(e) {
+    this._updateCounter++, this._changes.push(this._map.get(e));
+  }
+  endUpdate(e) {
+    if (this._updateCounter--, this._updateCounter === 0 && this._changes.length > 0) {
+      const t = this._changes;
+      this._changes = [], this._run(t);
+    }
+  }
+  handlePossibleChange(e) {
+    this._changes.push(this._map.get(e));
+  }
+  handleChange(e, t) {
+  }
+}
+function f() {
+  return le.instance;
+}
+function Sr() {
+  return he.instance;
+}
+function wr() {
+  return ue.instance;
+}
+f.const = Sr;
+f.obs = wr;
+class le {
+  create(e) {
+    const t = O((n) => e(n));
+    return { read: (n) => t };
+  }
+}
+le.instance = new le();
+class he {
+  create(e) {
+    const t = O((n) => e(n));
+    return { read: (n) => t.read(n) };
+  }
+}
+he.instance = new he();
+class ue {
+  create(e) {
+    const t = O((n) => {
+      const s = e(n);
+      return Cr(s) ? s.read(n) : s;
+    });
+    return { read: (n) => t };
+  }
+}
+ue.instance = new ue();
+function Cr(r) {
+  return typeof r == "object" && r !== null && "read" in r;
+}
+function J(r, e) {
+  return Object.fromEntries(Object.entries(r).map(([t, n]) => [t, e(n, t)]));
+}
+const se = Symbol("ViewModelContext");
+class Rr {
+  constructor(e) {
+    this._store = new Y(), this.props = e;
+  }
+  dispose() {
+    this._store.dispose();
+  }
+}
+function Tr(r) {
+  return r[se] || (r[se] = Ye(void 0)), r[se];
+}
+function B(r = {}) {
+  var e;
+  return e = class extends Rr {
+  }, e._props = r, e;
+}
+let pe = 0;
+const kr = new xr((r) => {
+  for (const e of r)
+    e.rendered = !1;
+  if (pe > 0) {
+    const e = r.find((t) => t.isRendering);
+    e.itemsToRender = r;
+  } else
+    et(() => {
+      for (const e of r)
+        e.rendered || e.forceUpdate();
+    });
+});
+let Ir = 0;
+class Or {
+  constructor(e, t) {
+    this.debugName = e, this.renderFactory = t, this._obsProps = void 0, this.forceUpdate = void 0, this._render = void 0, this._disposable = void 0, this.contextValues = /* @__PURE__ */ new Map(), this.cleanupEffect = () => () => {
+      var n;
+      (n = this._disposable) == null || n.dispose();
+    }, this.itemsToRender = [], this.handleAfterRender = () => {
+      et(() => {
+        for (const n of this.itemsToRender)
+          n.rendered || n.forceUpdate();
+      }), this.itemsToRender = [];
+    }, this.rendering = void 0, this.isRendering = !1, this.rendered = !1;
+  }
+  toString() {
+    return this.debugName;
+  }
+  updateProps(e) {
+    this._obsProps ? this._obsProps.set(e, void 0) : (this._obsProps = x(this, e), this._render = this.renderFactory(this._obsProps, () => this.contextValues), this.rendering = O(this, this._render), this._disposable = kr.addDependency(this.rendering, this));
+  }
+}
+function we(r, e, t) {
+  const n = (i) => i + 1, s = () => new Or(r + ++Ir, e), o = function(i) {
+    const d = Et(n, 0)[1], c = Dt(s)[0];
+    for (const u of t ?? [])
+      c.contextValues.set(u, Bt(u));
+    if (Ie(c.cleanupEffect, []), Ie(c.handleAfterRender), c.isRendering)
+      throw new Error("Component is already rendering");
+    c.isRendering = !0, pe++;
+    try {
+      c.forceUpdate = d, c.updateProps(i);
+      const u = c.rendering.get();
+      return c.rendered = !0, u;
+    } finally {
+      c.isRendering = !1, pe--;
+    }
+  };
+  return o.displayName = r, o;
+}
+we("ObsView", (r) => (e) => r.read(e).children(e));
+function k(r, e) {
+  return we("view", (t) => {
+    const n = J(r, (s, o) => s.create((i) => t.read(i)[o], void 0));
+    return (s) => {
+      const o = J(n, (i) => i.read(s));
+      return e(s, o);
+    };
+  });
+}
+function Nr(r) {
+  const e = [];
+  for (const t of Object.values(r)) {
+    const n = t._requiredContext;
+    n && !e.includes(n) && e.push(n);
+  }
+  return e;
+}
+function A(r, e, t) {
+  const n = typeof e == "function" ? {} : e, s = typeof e == "function" ? e : t, o = "_props" in r ? r._props : {}, i = Nr({ ...o, ...n }), d = Tr(r), c = [...i, d];
+  return we("viewWithModel", (u, h) => {
+    const p = h(), m = p.get(d), b = "_props" in r ? J(r._props, (_, M) => _.create((F) => u.read(F)[M], p.get(_._requiredContext))) : {}, S = m ? { read: () => m, dispose: () => {
+    } } : ir((_) => {
+      const M = J(b, (F) => F.read(_));
+      return new r(M);
+    }), C = J(n, (_, M) => _.create((F) => u.read(F)[M], p.get(_._requiredContext)));
+    return (_) => {
+      const M = S.read(_), F = J(C, (Nt) => Nt.read(_));
+      return s(_, M, F);
+    };
+  }, c.length > 0 ? c : void 0);
+}
+k({ value: f.obs() }, (r, e) => e.value.read(r));
+Ye(null);
+function gt(r) {
+  var e;
+  return {
+    id: r.id,
+    name: r.name,
+    type: r.type,
+    children: (e = r.children) == null ? void 0 : e.map(gt),
+    component: r.component,
+    labels: r.labels
+  };
+}
+function Vr(r, e) {
+  if (r.name.toLowerCase().includes(e)) return !0;
+  for (const t of r.labels)
+    if (t.toLowerCase().includes(e)) return !0;
+  return !1;
+}
+function Mr(r, e) {
+  if (!e) return r;
+  const t = e.toLowerCase();
+  return mt(r, t);
+}
+function mt(r, e) {
+  const t = Vr(r, e);
+  if (!r.children || r.children.length === 0)
+    return t ? r : void 0;
+  if (t) return r;
+  const n = [];
+  for (const s of r.children) {
+    const o = mt(s, e);
+    o && n.push(o);
+  }
+  if (n.length !== 0)
+    return {
+      ...r,
+      children: n
+    };
+}
+function te(r, e) {
+  const {
+    storageKey: t,
+    defaultValue: n,
+    serialize: s = JSON.stringify,
+    deserialize: o = JSON.parse
+  } = e;
+  let i = n;
+  try {
+    const u = localStorage.getItem(t);
+    u !== null && (i = o(u));
+  } catch {
+  }
+  const d = x(r, i), c = d.set.bind(d);
+  return d.set = (u, h) => {
+    try {
+      localStorage.setItem(t, s(u));
+    } catch {
+    }
+    c(u, h);
+  }, d;
+}
+function $e(r, e) {
+  const n = new URLSearchParams(location.search).get(e) || void 0, s = x(r, n);
+  window.addEventListener("popstate", () => {
+    const i = new URLSearchParams(location.search);
+    s.set(i.get(e) || void 0, void 0);
+  });
+  const o = s.set.bind(s);
+  return s.set = (i, d) => {
+    const c = new URLSearchParams(location.search);
+    i ? c.set(e, i) : c.delete(e);
+    const u = c.toString(), h = location.pathname + (u ? "?" + u : "") + location.hash;
+    history.replaceState(history.state, "", h), o(i, d);
+  }, s;
+}
+function vt(r, e) {
+  const t = new URLSearchParams(location.search);
+  return t.set(r, e), location.pathname + "?" + t.toString();
+}
+class Fr extends B({
+  registry: f.const(),
+  daemonModel: f.const(),
+  reportModel: f.const()
+}) {
+  constructor() {
+    super(...arguments);
+    l(this, "leftSidebarVisible", te(this, {
+      storageKey: "component-explorer:leftSidebarVisible",
+      defaultValue: !0
+    }));
+    l(this, "rightSidebarVisible", te(this, {
+      storageKey: "component-explorer:rightSidebarVisible",
+      defaultValue: !1
+    }));
+    l(this, "isDarkTheme", te(this, {
+      storageKey: "component-explorer:isDarkTheme",
+      defaultValue: !0
+    }));
+    l(this, "selectedNodeId", $e(this, "component"));
+    l(this, "expandedNodeIds", x(this, this._initialExpandedNodes()));
+    l(this, "viewMode", te(this, {
+      storageKey: "component-explorer:viewMode",
+      defaultValue: "session"
+    }));
+    l(this, "searchQuery", $e(this, "search"));
+    /** The explorer's tree derived from the registry or report */
+    l(this, "tree", O(this, (t) => {
+      const n = this.props.reportModel;
+      if (n)
+        return n.buildTree(t);
+      const s = this.props.registry.root.read(t);
+      return gt(s);
+    }));
+    l(this, "filteredTree", O(this, (t) => {
+      const n = this.tree.read(t), s = this.searchQuery.read(t);
+      return Mr(n, s) ?? { ...n, children: [] };
+    }));
+    l(this, "selectedNode", O(this, (t) => {
+      const n = this.selectedNodeId.read(t);
+      if (n === void 0) return;
+      const s = this.filteredTree.read(t);
+      return s.id === n ? s : this._findNode(s.children ?? [], n);
+    }));
+    /** List of preview rows to render based on current selection and view mode */
+    l(this, "selectedFixtures", O(this, (t) => {
+      const n = this.selectedNode.read(t);
+      return n ? this.isReportMode ? (this.props.reportModel.state.read(t), this._collectReportRows(n, n.name)) : this.viewMode.read(t) === "diff" && this.daemonAvailable && this.daemon.sessions.read(t).length > 1 ? this._collectDiffRows(n, n.name) : this._collectPreviewRows(n, n.name) : [];
+    }));
+    l(this, "setViewMode", (t) => {
+      this.viewMode.set(t, void 0);
+    });
+    l(this, "navigateToSession", (t) => {
+      const n = this.props.daemonModel;
+      if (!n) return;
+      const s = n.getSessionExplorerUrl(t);
+      s && (window.location.href = s);
+    });
+    l(this, "toggleLeftSidebar", () => {
+      this.leftSidebarVisible.set(!this.leftSidebarVisible.get(), void 0);
+    });
+    l(this, "toggleRightSidebar", () => {
+      this.rightSidebarVisible.set(!this.rightSidebarVisible.get(), void 0);
+    });
+    l(this, "toggleTheme", () => {
+      this.isDarkTheme.set(!this.isDarkTheme.get(), void 0);
+    });
+    l(this, "selectNode", (t) => {
+      this.selectedNodeId.set(t, void 0);
+    });
+    l(this, "toggleNodeExpanded", (t) => {
+      const n = this.expandedNodeIds.get(), s = new Set(n);
+      s.has(t) ? s.delete(t) : s.add(t), this.expandedNodeIds.set(s, void 0);
+    });
+  }
+  get daemonAvailable() {
+    return this.props.daemonModel !== void 0;
+  }
+  get daemon() {
+    return this.props.daemonModel;
+  }
+  get reportModel() {
+    return this.props.reportModel;
+  }
+  get isReportMode() {
+    return this.props.reportModel !== void 0;
+  }
+  isNodeExpanded(t, n) {
+    return this.searchQuery.read(n) ? !0 : this.expandedNodeIds.read(n).has(t);
+  }
+  _initialExpandedNodes() {
+    const t = this.selectedNodeId.get();
+    if (!t) return /* @__PURE__ */ new Set([""]);
+    const n = t.split("/"), s = /* @__PURE__ */ new Set([""]);
+    for (let o = 1; o <= n.length; o++)
+      s.add(n.slice(0, o).join("/"));
+    return s;
+  }
+  _findNode(t, n) {
+    for (const s of t) {
+      if (s.id === n) return s;
+      if (s.children) {
+        const o = this._findNode(s.children, n);
+        if (o) return o;
+      }
+    }
+  }
+  _collectPreviewRows(t, n) {
+    if (t.type === "component" && t.component)
+      return [{
+        type: "single",
+        fixture: {
+          id: t.id,
+          name: t.name,
+          path: n,
+          component: t.component
+        }
+      }];
+    if (t.type === "variants") {
+      const o = [];
+      for (const i of t.children ?? [])
+        i.type === "component" && i.component && o.push({
+          id: i.id,
+          name: i.name,
+          path: `${n} / ${i.name}`,
+          component: i.component
+        });
+      return o.length > 0 ? [{
+        type: "variants",
+        id: t.id,
+        name: t.name,
+        path: n,
+        fixtures: o
+      }] : [];
+    }
+    const s = [];
+    for (const o of t.children ?? []) {
+      const i = n ? `${n} / ${o.name}` : o.name;
+      s.push(...this._collectPreviewRows(o, i));
+    }
+    return s;
+  }
+  /**
+   * In diff mode: fixtures become screenshot comparison items showing current vs baseline.
+   * Variants become comparison groups.
+   */
+  _collectDiffRows(t, n) {
+    if (t.type === "component")
+      return [{
+        type: "screenshot-comparison",
+        id: t.id,
+        name: t.name,
+        path: n,
+        items: [{
+          fixtureId: t.id,
+          name: t.name,
+          path: n
+        }]
+      }];
+    if (t.type === "variants") {
+      const o = [];
+      for (const i of t.children ?? [])
+        i.type === "component" && o.push({
+          fixtureId: i.id,
+          name: i.name,
+          path: `${n} / ${i.name}`
+        });
+      return o.length > 0 ? [{
+        type: "screenshot-comparison",
+        id: t.id,
+        name: t.name,
+        path: n,
+        items: o
+      }] : [];
+    }
+    const s = [];
+    for (const o of t.children ?? []) {
+      const i = n ? `${n} / ${o.name}` : o.name;
+      s.push(...this._collectDiffRows(o, i));
+    }
+    return s;
+  }
+  _collectReportRows(t, n) {
+    const s = this.props.reportModel.state.get();
+    if (s.status !== "ready") return [];
+    const o = s.report.fixtures;
+    if (t.type === "component") {
+      const d = o[t.id];
+      return d ? [{
+        type: "report-comparison",
+        id: t.id,
+        name: t.name,
+        path: n,
+        items: [{
+          fixtureId: t.id,
+          name: t.name,
+          path: n,
+          entry: d
+        }]
+      }] : [];
+    }
+    const i = [];
+    for (const d of t.children ?? []) {
+      const c = n ? `${n} / ${d.name}` : d.name;
+      i.push(...this._collectReportRows(d, c));
+    }
+    return i;
+  }
+}
+const v = {
+  container: {
+    display: "flex",
+    flexDirection: "row",
+    height: "100%",
+    width: "100%",
+    fontFamily: "var(--vscode-font-family)",
+    fontSize: "var(--vscode-font-size)",
+    color: "var(--vscode-foreground)",
+    backgroundColor: "var(--vscode-editor-background)"
+  },
+  centerArea: {
+    display: "flex",
+    flexDirection: "column",
+    flex: 1,
+    overflow: "hidden"
+  },
+  titleBar: {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "space-between",
+    height: "35px",
+    minHeight: "35px",
+    padding: "0 10px",
+    backgroundColor: "var(--vscode-titleBar-activeBackground)",
+    color: "var(--vscode-titleBar-activeForeground)",
+    borderBottom: "1px solid var(--vscode-titleBar-border, var(--vscode-panel-border))"
+  },
+  titleBarSection: {
+    display: "flex",
+    alignItems: "center",
+    gap: "2px"
+  },
+  titleBarCenter: {
+    display: "flex",
+    alignItems: "center",
+    gap: "4px",
+    fontSize: "13px",
+    fontWeight: 400
+  },
+  titleBarButton: {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    width: "28px",
+    height: "28px",
+    border: "none",
+    background: "transparent",
+    color: "var(--vscode-titleBar-activeForeground)",
+    cursor: "pointer",
+    borderRadius: "4px"
+  },
+  titleBarButtonHover: {
+    backgroundColor: "var(--vscode-toolbar-hoverBackground)"
+  },
+  titleBarButtonActive: {
+    backgroundColor: "var(--vscode-toolbar-activeBackground)",
+    color: "var(--vscode-focusBorder)"
+  },
+  sidebar: {
+    display: "flex",
+    flexDirection: "column",
+    width: "260px",
+    minWidth: "200px",
+    backgroundColor: "var(--vscode-sideBar-background)",
+    borderRight: "1px solid var(--vscode-titleBar-border, var(--vscode-panel-border))"
+  },
+  sidebarRight: {
+    borderRight: "none",
+    borderLeft: "1px solid var(--vscode-titleBar-border, var(--vscode-panel-border))"
+  },
+  sidebarHeader: {
+    display: "flex",
+    alignItems: "center",
+    height: "35px",
+    minHeight: "35px",
+    padding: "0 12px",
+    fontSize: "11px",
+    fontWeight: 700,
+    textTransform: "uppercase",
+    letterSpacing: "0.04em",
+    color: "var(--vscode-titleBar-activeForeground)",
+    backgroundColor: "var(--vscode-titleBar-activeBackground)",
+    borderBottom: "1px solid var(--vscode-titleBar-border, var(--vscode-panel-border))"
+  },
+  sidebarContent: {
+    flex: 1,
+    overflow: "auto",
+    padding: "4px 0"
+  },
+  treeItem: {
+    display: "flex",
+    alignItems: "center",
+    height: "22px",
+    paddingRight: "8px",
+    cursor: "pointer",
+    userSelect: "none"
+  },
+  treeItemSelected: {
+    backgroundColor: "var(--vscode-list-activeSelectionBackground)",
+    color: "var(--vscode-list-activeSelectionForeground)"
+  },
+  treeItemHover: {
+    backgroundColor: "var(--vscode-list-hoverBackground)"
+  },
+  treeItemChevron: {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    width: "16px",
+    height: "16px",
+    color: "var(--vscode-foreground)",
+    opacity: 0.8,
+    cursor: "pointer"
+  },
+  treeItemChevronPlaceholder: {
+    width: "16px"
+  },
+  treeItemIcon: {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    width: "16px",
+    height: "16px",
+    marginRight: "4px"
+  },
+  treeItemLabel: {
+    flex: 1,
+    overflow: "hidden",
+    textOverflow: "ellipsis",
+    whiteSpace: "nowrap",
+    fontSize: "13px"
+  },
+  treeItemCount: {
+    marginLeft: "8px",
+    fontSize: "11px",
+    color: "var(--vscode-descriptionForeground)"
+  },
+  mainContent: {
+    flex: 1,
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    backgroundColor: "var(--vscode-editor-background)",
+    color: "var(--vscode-descriptionForeground)",
+    fontSize: "14px"
+  },
+  propertiesPanel: {
+    padding: "12px"
+  },
+  propertyRow: {
+    marginBottom: "12px"
+  },
+  propertyLabel: {
+    fontSize: "12px",
+    color: "var(--vscode-foreground)",
+    marginBottom: "4px"
+  },
+  propertyDescription: {
+    fontSize: "11px",
+    color: "var(--vscode-descriptionForeground)",
+    marginTop: "2px"
+  },
+  propertyInput: {
+    width: "100%",
+    height: "26px",
+    padding: "0 8px",
+    fontSize: "13px",
+    color: "var(--vscode-input-foreground)",
+    backgroundColor: "var(--vscode-input-background)",
+    border: "1px solid var(--vscode-input-border, transparent)",
+    borderRadius: "2px",
+    outline: "none",
+    boxSizing: "border-box"
+  },
+  propertySelect: {
+    width: "100%",
+    height: "26px",
+    padding: "0 8px",
+    fontSize: "13px",
+    color: "var(--vscode-dropdown-foreground)",
+    backgroundColor: "var(--vscode-dropdown-background)",
+    border: "1px solid var(--vscode-dropdown-border)",
+    borderRadius: "2px",
+    outline: "none",
+    boxSizing: "border-box",
+    cursor: "pointer"
+  }
+};
+function Ce(...r) {
+  return Object.assign({}, ...r.filter(Boolean));
+}
+class Er extends B({
+  active: f()
+}) {
+  constructor() {
+    super(...arguments);
+    l(this, "isHovered", x(this, !1));
+    l(this, "setHovered", (t) => {
+      this.isHovered.set(t, void 0);
+    });
+  }
+  get active() {
+    return this.props.active;
+  }
+}
+const oe = A(
+  Er,
+  {
+    onClick: f.const(),
+    title: f.const(),
+    children: f.const()
+  },
+  (r, e, t) => {
+    const n = e.isHovered.read(r), s = e.active.read(r), o = Ce(
+      v.titleBarButton,
+      n && !s && v.titleBarButtonHover,
+      s && v.titleBarButtonActive
+    );
+    return /* @__PURE__ */ a(
+      "button",
+      {
+        style: o,
+        onClick: t.onClick,
+        title: t.title,
+        onMouseEnter: () => e.setHovered(!0),
+        onMouseLeave: () => e.setHovered(!1),
+        children: t.children
+      }
+    );
+  }
+), Dr = ({ style: r }) => /* @__PURE__ */ a("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "currentColor", style: r, children: /* @__PURE__ */ a("path", { d: "M5.7 13.7L5 13l4.6-4.6L5 3.7l.7-.7 5.3 5.4-5.3 5.3z" }) }), Br = ({ style: r }) => /* @__PURE__ */ a("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "currentColor", style: r, children: /* @__PURE__ */ a("path", { d: "M11 5.5L6 10.5L5.3 9.8L9.6 5.5L5.3 1.2L6 0.5L11 5.5z", transform: "rotate(90 8 5.5)" }) }), Ar = ({ style: r }) => /* @__PURE__ */ a("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "currentColor", style: r, children: /* @__PURE__ */ a("path", { d: "M14.5 2H9l-.35.15-.65.64-.65-.64L7 2H1.5l-.5.5v10l.5.5H7l.35-.15.65-.64.65.64.35.15h5.5l.5-.5v-10l-.5-.5zm-7 10H2V3h5v.86L5.85 5l1.15 1.14V10l-1.15-1.14L7 7.72V12zm6 0H8V7.72l1.15 1.14L8 10V6.14L9.15 5 8 3.86V3h5v9z" }) }), $r = ({ style: r }) => /* @__PURE__ */ a("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "currentColor", style: r, children: /* @__PURE__ */ a("path", { d: "M14.5 3H7.71l-.85-.85L6.5 2h-5l-.5.5v11l.5.5h13l.5-.5v-10l-.5-.5zm-.5 10H2V6h12v7zm0-8H2V3h4.29l.85.85.36.15H14v1z" }) }), zr = () => /* @__PURE__ */ a("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "currentColor", children: /* @__PURE__ */ a("path", { d: "M2 2v12h12V2H2zm11 11H6V3h7v10zM3 3h2v10H3V3z" }) }), Lr = () => /* @__PURE__ */ a("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "currentColor", children: /* @__PURE__ */ a("path", { d: "M2 2v12h12V2H2zm6 11V3h5v10H8zM3 3h4v10H3V3z" }) }), Hr = () => /* @__PURE__ */ a("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "currentColor", children: /* @__PURE__ */ a("path", { d: "M8 11a3 3 0 1 1 0-6 3 3 0 0 1 0 6zm0 1a4 4 0 1 0 0-8 4 4 0 0 0 0 8zM8 0a.5.5 0 0 1 .5.5v2a.5.5 0 0 1-1 0v-2A.5.5 0 0 1 8 0zm0 13a.5.5 0 0 1 .5.5v2a.5.5 0 0 1-1 0v-2A.5.5 0 0 1 8 13zm8-5a.5.5 0 0 1-.5.5h-2a.5.5 0 0 1 0-1h2a.5.5 0 0 1 .5.5zM3 8a.5.5 0 0 1-.5.5h-2a.5.5 0 0 1 0-1h2A.5.5 0 0 1 3 8zm10.657-5.657a.5.5 0 0 1 0 .707l-1.414 1.415a.5.5 0 1 1-.707-.708l1.414-1.414a.5.5 0 0 1 .707 0zm-9.193 9.193a.5.5 0 0 1 0 .707L3.05 13.657a.5.5 0 0 1-.707-.707l1.414-1.414a.5.5 0 0 1 .707 0zm9.193 2.121a.5.5 0 0 1-.707 0l-1.414-1.414a.5.5 0 0 1 .707-.707l1.414 1.414a.5.5 0 0 1 0 .707zM4.464 4.465a.5.5 0 0 1-.707 0L2.343 3.05a.5.5 0 1 1 .707-.707l1.414 1.414a.5.5 0 0 1 0 .708z" }) }), jr = () => /* @__PURE__ */ a("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "currentColor", children: /* @__PURE__ */ a("path", { d: "M6 .278a.768.768 0 0 1 .08.858 7.208 7.208 0 0 0-.878 3.46c0 4.021 3.278 7.277 7.318 7.277.527 0 1.04-.055 1.533-.16a.787.787 0 0 1 .81.316.733.733 0 0 1-.031.893A8.349 8.349 0 0 1 8.344 16C3.734 16 0 12.286 0 7.71 0 4.266 2.114 1.312 5.124.06A.752.752 0 0 1 6 .278z" }) }), Ur = k(
+  { model: f.const() },
+  (r, e) => {
+    var d, c;
+    const t = e.model, n = t.viewMode.read(r), s = ((d = t.daemon) == null ? void 0 : d.sessions.read(r)) ?? [], o = (c = t.daemon) == null ? void 0 : c.sessionName, i = s.filter((u) => u.name !== o);
+    return s.length <= 1 ? null : /* @__PURE__ */ g("div", { style: Q.container, children: [
+      /* @__PURE__ */ g("div", { style: Q.segmentedControl, children: [
+        /* @__PURE__ */ a(ze, { label: "Live", mode: "session", active: n === "session", onClick: () => t.setViewMode("session") }),
+        /* @__PURE__ */ a(ze, { label: "Diff", mode: "diff", active: n === "diff", onClick: () => t.setViewMode("diff") })
+      ] }),
+      i.length > 0 && /* @__PURE__ */ a("div", { style: Q.sessionLinks, children: i.map((u) => /* @__PURE__ */ g(
+        "button",
+        {
+          style: Q.sessionLink,
+          onClick: () => t.navigateToSession(u.name),
+          title: `Switch to ${u.name} session`,
+          children: [
+            "→ ",
+            u.name
+          ]
+        },
+        u.name
+      )) })
+    ] });
+  }
+);
+function ze({ label: r, mode: e, active: t, onClick: n }) {
+  return /* @__PURE__ */ a(
+    "button",
+    {
+      style: t ? Q.segmentActive : Q.segment,
+      onClick: n,
+      children: r
+    }
+  );
+}
+const Pr = k(
+  {
+    model: f.const()
+  },
+  (r, e) => {
+    const t = e.model, n = t.leftSidebarVisible.read(r), s = t.rightSidebarVisible.read(r), o = t.isDarkTheme.read(r), i = t.selectedNode.read(r);
+    return /* @__PURE__ */ g("div", { style: v.titleBar, children: [
+      /* @__PURE__ */ a("div", { style: v.titleBarSection, children: /* @__PURE__ */ a(
+        oe,
+        {
+          active: n,
+          onClick: t.toggleLeftSidebar,
+          title: "Toggle left sidebar",
+          children: /* @__PURE__ */ a(zr, {})
+        }
+      ) }),
+      /* @__PURE__ */ g("div", { style: v.titleBarCenter, children: [
+        t.isReportMode ? /* @__PURE__ */ a("span", { style: { fontSize: 12, color: "var(--vscode-descriptionForeground)" }, children: "Screenshot Report" }) : t.daemonAvailable ? /* @__PURE__ */ a(Ur, { model: t }) : null,
+        i ? /* @__PURE__ */ g(me, { children: [
+          /* @__PURE__ */ a("span", { style: { color: "var(--vscode-textLink-foreground)" }, children: "<" }),
+          /* @__PURE__ */ a("span", { children: i.name }),
+          /* @__PURE__ */ a("span", { style: { color: "var(--vscode-textLink-foreground)" }, children: "/>" })
+        ] }) : /* @__PURE__ */ a("span", { style: { color: "var(--vscode-descriptionForeground)" }, children: "No component selected" })
+      ] }),
+      /* @__PURE__ */ g("div", { style: v.titleBarSection, children: [
+        /* @__PURE__ */ a(
+          oe,
+          {
+            active: !1,
+            onClick: t.toggleTheme,
+            title: o ? "Switch to light theme" : "Switch to dark theme",
+            children: o ? /* @__PURE__ */ a(Hr, {}) : /* @__PURE__ */ a(jr, {})
+          }
+        ),
+        /* @__PURE__ */ a(
+          oe,
+          {
+            active: s,
+            onClick: t.toggleRightSidebar,
+            title: "Toggle right sidebar",
+            children: /* @__PURE__ */ a(Lr, {})
+          }
+        )
+      ] })
+    ] });
+  }
+), Q = {
+  container: {
+    display: "flex",
+    alignItems: "center",
+    gap: 8,
+    marginRight: 12
+  },
+  segmentedControl: {
+    display: "flex",
+    borderRadius: 4,
+    overflow: "hidden",
+    border: "1px solid var(--vscode-panel-border)"
+  },
+  segment: {
+    padding: "2px 10px",
+    fontSize: 11,
+    fontWeight: 500,
+    border: "none",
+    background: "transparent",
+    color: "var(--vscode-descriptionForeground)",
+    cursor: "pointer"
+  },
+  segmentActive: {
+    padding: "2px 10px",
+    fontSize: 11,
+    fontWeight: 500,
+    border: "none",
+    background: "var(--vscode-button-background)",
+    color: "var(--vscode-button-foreground)",
+    cursor: "pointer"
+  },
+  sessionLinks: {
+    display: "flex",
+    gap: 4
+  },
+  sessionLink: {
+    padding: "2px 8px",
+    fontSize: 11,
+    border: "1px solid var(--vscode-panel-border)",
+    borderRadius: 4,
+    background: "transparent",
+    color: "var(--vscode-textLink-foreground)",
+    cursor: "pointer"
+  }
+}, Wr = {
+  display: "flex",
+  gap: "3px",
+  marginLeft: "6px",
+  overflow: "hidden",
+  flexShrink: 1,
+  minWidth: 0
+}, Gr = {
+  fontSize: "10px",
+  lineHeight: "14px",
+  padding: "0 4px",
+  borderRadius: "2px",
+  backgroundColor: "var(--vscode-badge-background)",
+  color: "var(--vscode-badge-foreground)",
+  whiteSpace: "nowrap",
+  overflow: "hidden",
+  textOverflow: "ellipsis",
+  maxWidth: "60px",
+  cursor: "pointer"
+}, bt = k(
+  {
+    model: f.const(),
+    nodes: f.const(),
+    depth: f.const()
+  },
+  (r, e) => /* @__PURE__ */ a(me, { children: e.nodes.map((t) => /* @__PURE__ */ a(Kr, { model: e.model, node: t, depth: e.depth }, t.id)) })
+);
+class qr extends B({
+  model: f.const(),
+  node: f.const(),
+  depth: f.const()
+}) {
+  constructor() {
+    super(...arguments);
+    l(this, "isHovered", x(this, !1));
+    l(this, "setHovered", (t) => {
+      this.isHovered.set(t, void 0);
+    });
+    l(this, "handleClick", () => {
+      this.props.model.selectNode(this.props.node.id);
+    });
+    l(this, "handleDoubleClick", () => {
+      this._hasChildren && this.props.model.toggleNodeExpanded(this.props.node.id);
+    });
+    l(this, "handleChevronClick", (t) => {
+      t.stopPropagation(), this.props.model.toggleNodeExpanded(this.props.node.id);
+    });
+  }
+  // Expose props for render function
+  get explorerModel() {
+    return this.props.model;
+  }
+  get treeNode() {
+    return this.props.node;
+  }
+  get treeDepth() {
+    return this.props.depth;
+  }
+  get _hasChildren() {
+    return !!(this.props.node.children && this.props.node.children.length > 0);
+  }
+}
+const Kr = A(qr, {}, (r, e) => {
+  const t = e.explorerModel, n = e.treeNode, s = e.treeDepth, o = !!(n.children && n.children.length > 0), i = o ? t.isNodeExpanded(n.id, r) : !1, c = t.selectedNodeId.read(r) === n.id, u = e.isHovered.read(r), h = Ce(
+    v.treeItem,
+    { paddingLeft: `${8 + s * 12}px` },
+    c && v.treeItemSelected,
+    !c && u && v.treeItemHover
+  );
+  return /* @__PURE__ */ g(me, { children: [
+    /* @__PURE__ */ g(
+      "div",
+      {
+        style: h,
+        onClick: e.handleClick,
+        onDoubleClick: e.handleDoubleClick,
+        onMouseEnter: () => e.setHovered(!0),
+        onMouseLeave: () => e.setHovered(!1),
+        children: [
+          o ? /* @__PURE__ */ a("div", { style: v.treeItemChevron, onClick: e.handleChevronClick, children: i ? /* @__PURE__ */ a(Br, {}) : /* @__PURE__ */ a(Dr, {}) }) : /* @__PURE__ */ a("div", { style: v.treeItemChevronPlaceholder }),
+          /* @__PURE__ */ a("div", { style: v.treeItemIcon, children: n.type === "folder" ? /* @__PURE__ */ a($r, { style: { color: "var(--vscode-symbolIcon-folderForeground)" } }) : /* @__PURE__ */ a(Ar, { style: { color: "#deb45b" } }) }),
+          /* @__PURE__ */ a("span", { style: v.treeItemLabel, children: n.name }),
+          n.labels.some((p) => !p.startsWith(".")) && /* @__PURE__ */ a("span", { style: Wr, children: n.labels.filter((p) => !p.startsWith(".")).map((p) => /* @__PURE__ */ a(
+            "span",
+            {
+              style: Gr,
+              onClick: (m) => {
+                m.stopPropagation(), t.searchQuery.set(p, void 0);
+              },
+              title: p,
+              children: p
+            },
+            p
+          )) }),
+          o && /* @__PURE__ */ a("span", { style: v.treeItemCount, children: n.children.length })
+        ]
+      }
+    ),
+    o && i && /* @__PURE__ */ a(bt, { model: t, nodes: n.children, depth: s + 1 })
+  ] });
+}), Jr = {
+  padding: "4px 8px",
+  borderBottom: "1px solid var(--vscode-panel-border)"
+}, Qr = {
+  width: "100%",
+  height: "24px",
+  padding: "0 22px 0 6px",
+  fontSize: "12px",
+  color: "var(--vscode-input-foreground)",
+  backgroundColor: "var(--vscode-input-background)",
+  border: "1px solid var(--vscode-input-border, transparent)",
+  borderRadius: "2px",
+  outline: "none",
+  boxSizing: "border-box"
+}, Zr = {
+  position: "relative"
+}, Xr = {
+  position: "absolute",
+  right: "2px",
+  top: "50%",
+  transform: "translateY(-50%)",
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "center",
+  width: "18px",
+  height: "18px",
+  border: "none",
+  background: "transparent",
+  color: "var(--vscode-input-foreground)",
+  cursor: "pointer",
+  borderRadius: "2px",
+  fontSize: "14px",
+  opacity: 0.7
+}, Yr = k(
+  {
+    model: f.const()
+  },
+  (r, e) => {
+    const t = e.model.searchQuery.read(r);
+    return /* @__PURE__ */ a("div", { style: Jr, children: /* @__PURE__ */ g("div", { style: Zr, children: [
+      /* @__PURE__ */ a(
+        "input",
+        {
+          type: "text",
+          placeholder: "Filter (name or label)",
+          style: Qr,
+          value: t ?? "",
+          onChange: (n) => e.model.searchQuery.set(n.target.value || void 0, void 0),
+          onFocus: (n) => n.target.style.borderColor = "var(--vscode-focusBorder)",
+          onBlur: (n) => n.target.style.borderColor = "var(--vscode-input-border, transparent)"
+        }
+      ),
+      t && /* @__PURE__ */ a(
+        "button",
+        {
+          style: Xr,
+          onClick: () => e.model.searchQuery.set(void 0, void 0),
+          title: "Clear filter",
+          children: "×"
+        }
+      )
+    ] }) });
+  }
+), en = k(
+  {
+    model: f.const()
+  },
+  (r, e) => {
+    const t = e.model.filteredTree.read(r);
+    return /* @__PURE__ */ g("div", { style: v.sidebar, children: [
+      /* @__PURE__ */ a("div", { style: v.sidebarHeader, children: "Explorer" }),
+      /* @__PURE__ */ a(Yr, { model: e.model }),
+      /* @__PURE__ */ a("div", { style: v.sidebarContent, children: /* @__PURE__ */ a(bt, { model: e.model, nodes: [t], depth: 0 }) })
+    ] });
+  }
+);
+class tn extends B({}) {
+  constructor() {
+    super(...arguments);
+    l(this, "checked", x(this, !1));
+    l(this, "toggle", () => {
+      this.checked.set(!this.checked.get(), void 0);
+    });
+  }
+}
+const rn = A(tn, {}, (r, e) => {
+  const t = e.checked.read(r), n = {
+    position: "relative",
+    width: "36px",
+    height: "18px",
+    backgroundColor: t ? "var(--vscode-button-background)" : "var(--vscode-input-background)",
+    borderRadius: "9px",
+    cursor: "pointer",
+    transition: "background-color 0.2s",
+    border: "1px solid var(--vscode-input-border, transparent)"
+  }, s = {
+    position: "absolute",
+    top: "2px",
+    left: t ? "18px" : "2px",
+    width: "12px",
+    height: "12px",
+    backgroundColor: "var(--vscode-foreground)",
+    borderRadius: "50%",
+    transition: "left 0.2s"
+  };
+  return /* @__PURE__ */ a("div", { style: n, onClick: e.toggle, children: /* @__PURE__ */ a("div", { style: s }) });
+}), nn = k(
+  {
+    node: f.const()
+  },
+  (r, e) => e.node.type !== "component" ? /* @__PURE__ */ a("div", { style: { padding: "12px", color: "var(--vscode-descriptionForeground)", fontSize: "12px" }, children: "Select a component (not a folder) to view its properties" }) : /* @__PURE__ */ g("div", { style: v.propertiesPanel, children: [
+    /* @__PURE__ */ g("div", { style: v.propertyRow, children: [
+      /* @__PURE__ */ g("div", { style: v.propertyLabel, children: [
+        "children",
+        /* @__PURE__ */ a("span", { style: { color: "var(--vscode-descriptionForeground)" }, children: " : string" })
+      ] }),
+      /* @__PURE__ */ a(
+        "input",
+        {
+          type: "text",
+          style: v.propertyInput,
+          defaultValue: "Click me",
+          placeholder: "Enter text..."
+        }
+      ),
+      /* @__PURE__ */ a("div", { style: v.propertyDescription, children: "Button text content" })
+    ] }),
+    /* @__PURE__ */ g("div", { style: v.propertyRow, children: [
+      /* @__PURE__ */ g("div", { style: v.propertyLabel, children: [
+        "variant",
+        /* @__PURE__ */ a("span", { style: { color: "var(--vscode-descriptionForeground)" }, children: " : select" })
+      ] }),
+      /* @__PURE__ */ g("select", { style: v.propertySelect, defaultValue: "default", children: [
+        /* @__PURE__ */ a("option", { value: "default", children: "default" }),
+        /* @__PURE__ */ a("option", { value: "primary", children: "primary" }),
+        /* @__PURE__ */ a("option", { value: "secondary", children: "secondary" }),
+        /* @__PURE__ */ a("option", { value: "destructive", children: "destructive" })
+      ] }),
+      /* @__PURE__ */ a("div", { style: v.propertyDescription, children: "Visual style variant" })
+    ] }),
+    /* @__PURE__ */ g("div", { style: v.propertyRow, children: [
+      /* @__PURE__ */ g("div", { style: v.propertyLabel, children: [
+        "size",
+        /* @__PURE__ */ a("span", { style: { color: "var(--vscode-descriptionForeground)" }, children: " : select" })
+      ] }),
+      /* @__PURE__ */ g("select", { style: v.propertySelect, defaultValue: "default", children: [
+        /* @__PURE__ */ a("option", { value: "sm", children: "sm" }),
+        /* @__PURE__ */ a("option", { value: "default", children: "default" }),
+        /* @__PURE__ */ a("option", { value: "lg", children: "lg" })
+      ] }),
+      /* @__PURE__ */ a("div", { style: v.propertyDescription, children: "Button size" })
+    ] }),
+    /* @__PURE__ */ g("div", { style: v.propertyRow, children: [
+      /* @__PURE__ */ g("div", { style: v.propertyLabel, children: [
+        "disabled",
+        /* @__PURE__ */ a("span", { style: { color: "var(--vscode-descriptionForeground)" }, children: " : boolean" })
+      ] }),
+      /* @__PURE__ */ a(rn, {}),
+      /* @__PURE__ */ a("div", { style: v.propertyDescription, children: "Disable the button" })
+    ] })
+  ] })
+), sn = k(
+  {
+    selectedNode: f.const()
+  },
+  (r, e) => /* @__PURE__ */ g("div", { style: Ce(v.sidebar, v.sidebarRight), children: [
+    /* @__PURE__ */ g("div", { style: v.sidebarHeader, children: [
+      /* @__PURE__ */ a("span", { style: { marginRight: "6px", color: "var(--vscode-textLink-foreground)" }, children: "</>" }),
+      "Props"
+    ] }),
+    /* @__PURE__ */ a("div", { style: v.sidebarContent, children: e.selectedNode ? /* @__PURE__ */ a(nn, { node: e.selectedNode }) : /* @__PURE__ */ a("div", { style: { padding: "12px", color: "var(--vscode-descriptionForeground)", fontSize: "12px" }, children: "Select a component to view its properties" }) })
+  ] })
+), _t = /* @__PURE__ */ new WeakSet(), Le = HTMLElement.prototype.focus;
+HTMLElement.prototype.focus = function(r) {
+  const e = this.getRootNode();
+  e instanceof ShadowRoot && _t.has(e) && !(r != null && r.preventScroll) ? Le.call(this, { ...r, preventScroll: !0 }) : Le.call(this, r);
+};
+function on(r) {
+  _t.add(r);
+}
+class an extends B({
+  fixture: f.const(),
+  compact: f.const(),
+  onSelect: f.const()
+}) {
+  constructor() {
+    super(...arguments);
+    l(this, "_containerRef", null);
+    l(this, "_rendering", null);
+    l(this, "_resizeObserver", null);
+    l(this, "measuredWidth", x(this, void 0));
+    l(this, "measuredHeight", x(this, void 0));
+    l(this, "setContainerRef", (t) => {
+      if (t === this._containerRef || (this._cleanup(), this._containerRef = t, !t)) return;
+      const n = new ft(t, this.fixture.component);
+      this._rendering = n, n.shadowRoot && on(n.shadowRoot);
+      const s = n.renderTarget;
+      this._resizeObserver = new ResizeObserver((o) => {
+        for (const i of o) {
+          const { width: d, height: c } = i.contentRect;
+          c > 0 && (this.measuredWidth.set(Math.round(d), void 0), this.measuredHeight.set(Math.round(c), void 0));
+        }
+      }), this._resizeObserver.observe(s);
+    });
+  }
+  get fixture() {
+    return this.props.fixture;
+  }
+  get compact() {
+    return this.props.compact ?? !1;
+  }
+  get onSelect() {
+    return this.props.onSelect;
+  }
+  _cleanup() {
+    var t, n;
+    (t = this._rendering) == null || t.dispose(), this._rendering = null, (n = this._resizeObserver) == null || n.disconnect(), this._resizeObserver = null;
+  }
+  dispose() {
+    this._cleanup();
+  }
+}
+const yt = A(
+  an,
+  {},
+  (r, e) => {
+    const t = e.fixture, n = t.component, s = n.displayMode, o = e.measuredWidth.read(r), i = e.measuredHeight.read(r), d = e.compact;
+    let c;
+    if (s.type === "page") {
+      const m = s.viewports[0], b = zt(m);
+      c = {
+        width: b.width,
+        height: b.height,
+        overflow: "auto"
+      };
+    } else
+      c = {
+        display: "inline-block"
+      };
+    const u = o && i ? `${o} × ${i}` : "", h = d ? q.wrapperCompact : q.wrapper, p = d ? q.nameCompact : q.name;
+    return /* @__PURE__ */ g("div", { style: h, children: [
+      /* @__PURE__ */ g("div", { style: q.labelRow, children: [
+        d && /* @__PURE__ */ a(
+          "a",
+          {
+            href: vt("component", t.id),
+            style: { ...p, textDecoration: "none", color: "inherit" },
+            onClick: (m) => {
+              e.onSelect && (m.preventDefault(), e.onSelect(t.id));
+            },
+            children: t.name
+          }
+        ),
+        !d && u && /* @__PURE__ */ a("span", { style: q.dimensions, children: u })
+      ] }),
+      /* @__PURE__ */ a("div", { style: hn(n.background), children: /* @__PURE__ */ a("div", { ref: e.setContainerRef, style: c }) })
+    ] });
+  }
+), G = 8;
+function xt(r, e) {
+  return `
+    linear-gradient(45deg, ${e} 25%, transparent 25%),
+    linear-gradient(-45deg, ${e} 25%, transparent 25%),
+    linear-gradient(45deg, transparent 75%, ${e} 75%),
+    linear-gradient(-45deg, transparent 75%, ${e} 75%)
+  `;
+}
+const dn = {
+  backgroundColor: "#ffffff",
+  backgroundImage: xt("#ffffff", "#e5e5e5")
+}, cn = {
+  backgroundColor: "#1e1e1e",
+  backgroundImage: xt("#1e1e1e", "#2d2d2d")
+}, ln = {
+  display: "inline-block",
+  padding: "12px",
+  borderRadius: "4px",
+  backgroundSize: `${G * 2}px ${G * 2}px`,
+  backgroundPosition: `0 0, 0 ${G}px, ${G}px -${G}px, -${G}px 0`,
+  boxShadow: "0 1px 3px rgba(0,0,0,0.12), 0 1px 2px rgba(0,0,0,0.08)",
+  overflow: "hidden",
+  position: "relative"
+};
+function hn(r) {
+  const e = r === "dark" ? cn : dn;
+  return {
+    ...ln,
+    backgroundColor: e.backgroundColor,
+    backgroundImage: e.backgroundImage
+  };
+}
+const q = {
+  wrapper: {
+    marginBottom: "32px"
+  },
+  wrapperCompact: {
+    marginBottom: "0"
+  },
+  labelRow: {
+    display: "flex",
+    alignItems: "baseline",
+    gap: "8px",
+    marginBottom: "8px"
+  },
+  name: {
+    fontSize: "12px",
+    fontWeight: 500,
+    color: "var(--vscode-foreground)"
+  },
+  nameCompact: {
+    fontSize: "11px",
+    fontWeight: 500,
+    color: "var(--vscode-descriptionForeground)"
+  },
+  dimensions: {
+    fontSize: "11px",
+    color: "var(--vscode-descriptionForeground)",
+    fontFamily: "var(--vscode-editor-font-family, monospace)"
+  }
+};
+class un extends B({
+  fixtureId: f.const(),
+  sessionName: f.const(),
+  daemon: f.const()
+}) {
+  constructor(t) {
+    super(t);
+    l(this, "screenshot", x(this, { status: "idle" }));
+    l(this, "_fetchVersion", 0);
+    this._store.add(dt((n) => {
+      this.props.daemon.sourceTreeIds.read(n).get(this.props.sessionName) && this._fetchScreenshot();
+    }));
+  }
+  get fixtureId() {
+    return this.props.fixtureId;
+  }
+  async _fetchScreenshot() {
+    const t = ++this._fetchVersion;
+    this.screenshot.set({ status: "loading" }, void 0);
+    try {
+      const n = await this.props.daemon.getScreenshot(this.props.sessionName, this.props.fixtureId);
+      t === this._fetchVersion && this.screenshot.set({ status: "ready", data: n }, void 0);
+    } catch (n) {
+      t === this._fetchVersion && this.screenshot.set({ status: "error", message: String(n) }, void 0);
+    }
+  }
+}
+const He = A(
+  un,
+  {},
+  (r, e) => {
+    const t = e.screenshot.read(r);
+    if (t.status === "idle" || t.status === "loading")
+      return /* @__PURE__ */ a("div", { style: $.placeholder, children: /* @__PURE__ */ a("div", { style: $.shimmer }) });
+    if (t.status === "error")
+      return /* @__PURE__ */ a("div", { style: $.error, children: /* @__PURE__ */ a("span", { style: $.errorText, children: "Screenshot failed" }) });
+    const { data: n } = t;
+    return n.image ? /* @__PURE__ */ a(
+      "img",
+      {
+        src: `data:image/png;base64,${n.image}`,
+        style: $.image,
+        alt: `Screenshot of ${e.fixtureId}`
+      }
+    ) : /* @__PURE__ */ a("div", { style: $.placeholder, children: /* @__PURE__ */ a("span", { style: $.hashText, children: n.hash.slice(0, 12) }) });
+  }
+), $ = {
+  placeholder: {
+    minHeight: 80,
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    backgroundColor: "var(--vscode-editor-background)",
+    border: "1px solid var(--vscode-panel-border)",
+    borderRadius: 4,
+    overflow: "hidden"
+  },
+  shimmer: {
+    width: "100%",
+    height: 80,
+    background: "linear-gradient(90deg, var(--vscode-editor-background) 25%, var(--vscode-list-hoverBackground) 50%, var(--vscode-editor-background) 75%)",
+    backgroundSize: "200% 100%",
+    animation: "shimmer 1.5s infinite"
+  },
+  error: {
+    minHeight: 80,
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    backgroundColor: "var(--vscode-inputValidation-errorBackground)",
+    border: "1px solid var(--vscode-inputValidation-errorBorder)",
+    borderRadius: 4
+  },
+  errorText: {
+    fontSize: 12,
+    color: "var(--vscode-errorForeground)"
+  },
+  hashText: {
+    fontSize: 11,
+    color: "var(--vscode-descriptionForeground)",
+    fontFamily: "var(--vscode-editor-font-family, monospace)"
+  },
+  image: {
+    maxWidth: "100%",
+    display: "block",
+    borderRadius: 4,
+    border: "1px solid var(--vscode-panel-border)"
+  }
+};
+class pn extends B({
+  fixtureId: f.const(),
+  daemon: f.const(),
+  baselineSession: f.const(),
+  currentSession: f.const()
+}) {
+  constructor(t) {
+    super(t);
+    l(this, "comparisonStatus", x(this, { status: "loading" }));
+    this._store.add(dt((n) => {
+      const s = this.props.daemon.sourceTreeIds.read(n), o = s.get(this.props.baselineSession), i = s.get(this.props.currentSession);
+      o && i && this._fetchComparison();
+    }));
+  }
+  get fixtureId() {
+    return this.props.fixtureId;
+  }
+  get daemon() {
+    return this.props.daemon;
+  }
+  get baselineSession() {
+    return this.props.baselineSession;
+  }
+  get currentSession() {
+    return this.props.currentSession;
+  }
+  async _fetchComparison() {
+    this.comparisonStatus.set({ status: "loading" }, void 0);
+    try {
+      const t = await this.props.daemon.compare(
+        this.props.fixtureId,
+        this.props.baselineSession,
+        this.props.currentSession
+      );
+      this.comparisonStatus.set({ status: "ready", match: t.match }, void 0);
+    } catch (t) {
+      this.comparisonStatus.set({ status: "error", message: String(t) }, void 0);
+    }
+  }
+}
+const fn = A(
+  pn,
+  {},
+  (r, e) => {
+    const t = e.comparisonStatus.read(r), n = t.status === "loading" ? /* @__PURE__ */ a("span", { style: R.badgeLoading, children: "comparing..." }) : t.status === "error" ? /* @__PURE__ */ a("span", { style: R.badgeError, children: "error" }) : t.match ? /* @__PURE__ */ a("span", { style: R.badgeMatch, children: "✓ match" }) : /* @__PURE__ */ a("span", { style: R.badgeChanged, children: "● changed" });
+    return /* @__PURE__ */ g("div", { style: R.fixtureRow, children: [
+      /* @__PURE__ */ g("div", { style: R.fixtureLabel, children: [
+        /* @__PURE__ */ a("span", { style: R.fixtureName, children: e.fixtureId }),
+        n
+      ] }),
+      /* @__PURE__ */ g("div", { style: R.sideBySide, children: [
+        /* @__PURE__ */ g("div", { style: R.screenshotColumn, children: [
+          /* @__PURE__ */ a("span", { style: R.columnLabel, children: "Current" }),
+          /* @__PURE__ */ a(
+            He,
+            {
+              fixtureId: e.fixtureId,
+              sessionName: e.currentSession,
+              daemon: e.daemon
+            }
+          )
+        ] }),
+        /* @__PURE__ */ g("div", { style: R.screenshotColumn, children: [
+          /* @__PURE__ */ a("span", { style: R.columnLabel, children: "Baseline" }),
+          /* @__PURE__ */ a(
+            He,
+            {
+              fixtureId: e.fixtureId,
+              sessionName: e.baselineSession,
+              daemon: e.daemon
+            }
+          )
+        ] })
+      ] })
+    ] });
+  }
+), gn = k(
+  {
+    name: f.const(),
+    path: f.const(),
+    items: f.const(),
+    daemon: f.const(),
+    baselineSession: f.const(),
+    currentSession: f.const()
+  },
+  (r, e) => /* @__PURE__ */ a("div", { style: R.groupContent, children: e.items.map((t) => /* @__PURE__ */ a(
+    fn,
+    {
+      fixtureId: t.fixtureId,
+      daemon: e.daemon,
+      baselineSession: e.baselineSession,
+      currentSession: e.currentSession
+    },
+    t.fixtureId
+  )) })
+), R = {
+  groupContent: {
+    display: "flex",
+    flexDirection: "column",
+    gap: 24
+  },
+  fixtureRow: {
+    display: "flex",
+    flexDirection: "column",
+    gap: 8
+  },
+  fixtureLabel: {
+    display: "flex",
+    alignItems: "center",
+    gap: 8
+  },
+  fixtureName: {
+    fontSize: 12,
+    fontWeight: 500,
+    color: "var(--vscode-foreground)"
+  },
+  sideBySide: {
+    display: "flex",
+    flexDirection: "row",
+    gap: 16
+  },
+  screenshotColumn: {
+    flex: 1,
+    display: "flex",
+    flexDirection: "column",
+    gap: 4,
+    minWidth: 0
+  },
+  columnLabel: {
+    fontSize: 11,
+    fontWeight: 500,
+    color: "var(--vscode-descriptionForeground)",
+    textTransform: "uppercase",
+    letterSpacing: "0.05em"
+  },
+  badgeMatch: {
+    fontSize: 11,
+    color: "var(--vscode-testing-iconPassed)",
+    fontWeight: 500
+  },
+  badgeChanged: {
+    fontSize: 11,
+    color: "var(--vscode-testing-iconFailed)",
+    fontWeight: 500
+  },
+  badgeLoading: {
+    fontSize: 11,
+    color: "var(--vscode-descriptionForeground)",
+    fontStyle: "italic"
+  },
+  badgeError: {
+    fontSize: 11,
+    color: "var(--vscode-errorForeground)",
+    fontWeight: 500
+  }
+}, K = 8;
+function St(r, e) {
+  return `
+    linear-gradient(45deg, ${e} 25%, transparent 25%),
+    linear-gradient(-45deg, ${e} 25%, transparent 25%),
+    linear-gradient(45deg, transparent 75%, ${e} 75%),
+    linear-gradient(-45deg, transparent 75%, ${e} 75%)
+  `;
+}
+const mn = {
+  backgroundColor: "#ffffff",
+  backgroundImage: St("#ffffff", "#e5e5e5")
+}, vn = {
+  backgroundColor: "#1e1e1e",
+  backgroundImage: St("#1e1e1e", "#2d2d2d")
+}, bn = {
+  display: "inline-block",
+  padding: "12px",
+  borderRadius: "4px",
+  backgroundSize: `${K * 2}px ${K * 2}px`,
+  backgroundPosition: `0 0, 0 ${K}px, ${K}px -${K}px, -${K}px 0`,
+  boxShadow: "0 1px 3px rgba(0,0,0,0.12), 0 1px 2px rgba(0,0,0,0.08)"
+};
+function _n(r) {
+  const e = r === "dark" ? vn : mn;
+  return {
+    ...bn,
+    backgroundColor: e.backgroundColor,
+    backgroundImage: e.backgroundImage
+  };
+}
+function je({ src: r, alt: e, background: t }) {
+  return /* @__PURE__ */ a("div", { style: _n(t), children: /* @__PURE__ */ a("img", { src: r, alt: e, style: w.image }) });
+}
+const yn = k(
+  {
+    item: f.const(),
+    reportModel: f.const()
+  },
+  (r, e) => {
+    const { item: t, reportModel: n } = e, { entry: s } = t, o = s.background ?? "light", i = s.status === "unchanged" ? /* @__PURE__ */ a("span", { style: w.badgeMatch, children: "✓ match" }) : s.status === "changed" ? /* @__PURE__ */ a("span", { style: w.badgeChanged, children: "● changed" }) : /* @__PURE__ */ a("span", { style: w.badgeAdded, children: "+ added" }), d = s.baselineScreenshot || s.currentScreenshot;
+    return /* @__PURE__ */ g("div", { style: w.fixtureRow, children: [
+      /* @__PURE__ */ g("div", { style: w.fixtureLabel, children: [
+        /* @__PURE__ */ a("span", { style: w.fixtureName, children: t.fixtureId }),
+        i
+      ] }),
+      d && /* @__PURE__ */ g("div", { style: w.sideBySide, children: [
+        s.baselineScreenshot && /* @__PURE__ */ g("div", { style: w.screenshotColumn, children: [
+          /* @__PURE__ */ a("span", { style: w.columnLabel, children: "Baseline" }),
+          /* @__PURE__ */ a(
+            je,
+            {
+              src: n.resolveScreenshotUrl(s.baselineScreenshot),
+              alt: `Baseline screenshot of ${t.fixtureId}`,
+              background: o
+            }
+          )
+        ] }),
+        s.currentScreenshot && /* @__PURE__ */ g("div", { style: w.screenshotColumn, children: [
+          /* @__PURE__ */ a("span", { style: w.columnLabel, children: "Current" }),
+          /* @__PURE__ */ a(
+            je,
+            {
+              src: n.resolveScreenshotUrl(s.currentScreenshot),
+              alt: `Current screenshot of ${t.fixtureId}`,
+              background: o
+            }
+          )
+        ] })
+      ] }),
+      !d && s.status === "unchanged" && /* @__PURE__ */ a("div", { style: w.hashRow, children: /* @__PURE__ */ g("span", { style: w.hashText, children: [
+        "hash: ",
+        s.targetHash
+      ] }) })
+    ] });
+  }
+), xn = k(
+  {
+    name: f.const(),
+    path: f.const(),
+    items: f.const(),
+    reportModel: f.const()
+  },
+  (r, e) => /* @__PURE__ */ a("div", { style: w.groupContent, children: e.items.map((t) => /* @__PURE__ */ a(
+    yn,
+    {
+      item: t,
+      reportModel: e.reportModel
+    },
+    t.fixtureId
+  )) })
+), w = {
+  groupContent: {
+    display: "flex",
+    flexDirection: "column",
+    gap: 24
+  },
+  fixtureRow: {
+    display: "flex",
+    flexDirection: "column",
+    gap: 8
+  },
+  fixtureLabel: {
+    display: "flex",
+    alignItems: "center",
+    gap: 8
+  },
+  fixtureName: {
+    fontSize: 12,
+    fontWeight: 500,
+    color: "var(--vscode-foreground)"
+  },
+  sideBySide: {
+    display: "flex",
+    flexDirection: "row",
+    gap: 16
+  },
+  screenshotColumn: {
+    display: "flex",
+    flexDirection: "column",
+    gap: 4
+  },
+  columnLabel: {
+    fontSize: 11,
+    fontWeight: 500,
+    color: "var(--vscode-descriptionForeground)",
+    textTransform: "uppercase",
+    letterSpacing: "0.05em"
+  },
+  image: {
+    display: "block"
+  },
+  hashRow: {
+    padding: "8px 0"
+  },
+  hashText: {
+    fontSize: 11,
+    color: "var(--vscode-descriptionForeground)",
+    fontFamily: "monospace"
+  },
+  badgeMatch: {
+    fontSize: 11,
+    color: "var(--vscode-testing-iconPassed)",
+    fontWeight: 500
+  },
+  badgeChanged: {
+    fontSize: 11,
+    color: "var(--vscode-testing-iconFailed)",
+    fontWeight: 500
+  },
+  badgeAdded: {
+    fontSize: 11,
+    color: "var(--vscode-testing-iconQueued)",
+    fontWeight: 500
+  }
+}, wt = "component-explorer:fixtureHeights", Ue = 500;
+let N = null;
+function Ct() {
+  if (N !== null) return N;
+  try {
+    const r = localStorage.getItem(wt);
+    if (r)
+      return N = JSON.parse(r), N;
+  } catch {
+  }
+  return N = {}, N;
+}
+function Sn() {
+  if (N !== null)
+    try {
+      const r = Object.entries(N);
+      r.length > Ue && (N = Object.fromEntries(r.slice(-Ue))), localStorage.setItem(wt, JSON.stringify(N));
+    } catch {
+    }
+}
+function wn(r, e) {
+  const t = Ct();
+  t[r] = e, Sn();
+}
+function Cn() {
+  return new Map(Object.entries(Ct()));
+}
+const Rn = 280, Tn = 32, ne = 32, Pe = 400;
+let Rt = 0;
+function z(r, e) {
+  const t = ++Rt, n = performance.now().toFixed(1);
+  console.log(
+    `%c[scroll #${t} @${n}ms] ${r}`,
+    "color: #3b82f6; font-weight: bold",
+    e
+  );
+}
+function We(r, e) {
+  const t = ++Rt, n = performance.now().toFixed(1);
+  console.warn(
+    `[scroll #${t} @${n}ms] ${r}`,
+    e
+  );
+}
+const Tt = "component-explorer:scrollAnchors", Ge = 100;
+function kt() {
+  try {
+    const r = localStorage.getItem(Tt);
+    if (r) return JSON.parse(r);
+  } catch {
+  }
+  return {};
+}
+function kn(r, e) {
+  try {
+    const t = kt();
+    t[r] = e;
+    const n = Object.entries(t), s = n.length > Ge ? Object.fromEntries(n.slice(-Ge)) : t;
+    localStorage.setItem(Tt, JSON.stringify(s));
+  } catch {
+  }
+}
+function In(r) {
+  return kt()[r];
+}
+function It(r) {
+  return r.type === "single" ? r.fixture.id : r.id;
+}
+function On(r, e) {
+  const t = new Array(r.length);
+  let n = ne;
+  for (let s = 0; s < r.length; s++) {
+    const o = e.get(It(r[s])) ?? Rn;
+    t[s] = { top: n, height: o }, n += o + Tn;
+  }
+  return t;
+}
+function fe(r) {
+  if (r.length === 0) return 0;
+  const e = r[r.length - 1];
+  return e.top + e.height + ne;
+}
+function Ot(r, e) {
+  let t = 0, n = r.length;
+  for (; t < n; ) {
+    const s = t + n >> 1;
+    r[s].top + r[s].height < e ? t = s + 1 : n = s;
+  }
+  return t;
+}
+function Nn(r, e, t) {
+  if (r.length === 0) return { start: 0, end: 0 };
+  const n = Ot(r, e - Pe);
+  let s = n;
+  const o = e + t + Pe;
+  for (; s < r.length && r[s].top < o; )
+    s++;
+  return { start: n, end: s };
+}
+function qe(r, e) {
+  if (r.length === 0) return;
+  const t = Ot(r, e), n = Math.min(t, r.length - 1);
+  return {
+    rowIndex: n,
+    offsetFromViewport: r[n].top - e
+  };
+}
+function Ke(r, e) {
+  return e.rowIndex >= r.length ? 0 : r[e.rowIndex].top - e.offsetFromViewport;
+}
+function Je(r) {
+  return r.type === "single" ? r.fixture.path : r.path;
+}
+function Qe(r) {
+  return r.split(" / ").slice(1);
+}
+function Vn(r, e, t) {
+  const n = t.split("/"), s = n.length - r.length;
+  for (let o = 0; o < r.length; o++)
+    if (!e || o >= e.length || r[o] !== e[o])
+      return r.slice(o).map((i, d) => ({
+        depth: o + d,
+        name: i,
+        nodeId: n.slice(0, s + o + d + 1).join("/")
+      }));
+  return [];
+}
+const Ze = ["h1", "h2", "h3", "h4"];
+function Mn(r) {
+  return Ze[Math.min(r, Ze.length - 1)];
+}
+const Xe = ["22px", "15px", "13px", "12px"];
+function Fn(r) {
+  return {
+    fontSize: Xe[Math.min(r, Xe.length - 1)],
+    fontWeight: r <= 1 ? 600 : 500,
+    color: "var(--vscode-foreground)",
+    margin: 0,
+    marginBottom: r === 0 ? "8px" : "4px",
+    paddingBottom: r === 0 ? "6px" : void 0,
+    borderBottom: r === 0 ? "1px solid var(--vscode-widget-border, var(--vscode-panel-border, rgba(128,128,128,0.35)))" : void 0
+  };
+}
+class En extends B({
+  model: f.const()
+}) {
+  constructor() {
+    super(...arguments);
+    l(this, "_rowHeights", x(this, Cn()));
+    l(this, "_scrollTop", x(this, 0));
+    l(this, "_viewportHeight", x(this, 0));
+    l(this, "_scrollContainerRef", null);
+    l(this, "_resizeObserver", null);
+    l(this, "_viewportResizeObserver", null);
+    l(this, "_currentNodeId");
+    l(this, "_scrollSaveTimeout", null);
+    l(this, "_suppressScrollHandler", !1);
+    l(this, "layout", O(this, (t) => {
+      const n = this.explorerModel.selectedFixtures.read(t), s = this._rowHeights.read(t);
+      return On(n, s);
+    }));
+    l(this, "visibleRowRange", O(this, (t) => {
+      const n = this.layout.read(t), s = this._scrollTop.read(t), o = this._viewportHeight.read(t);
+      return Nn(n, s, o);
+    }));
+    l(this, "setScrollContainerRef", (t) => {
+      var n;
+      this._scrollContainerRef && this._scrollContainerRef.removeEventListener("scroll", this._handleScroll), (n = this._viewportResizeObserver) == null || n.disconnect(), this._scrollContainerRef = t, t && (t.addEventListener("scroll", this._handleScroll, { passive: !0 }), this._viewportHeight.set(t.clientHeight, void 0), z("setScrollContainerRef", { clientHeight: t.clientHeight, scrollTop: t.scrollTop }), this._viewportResizeObserver = new ResizeObserver(([s]) => {
+        const o = Math.round(s.contentRect.height), i = this._viewportHeight.get();
+        o !== i && z("viewportResize", { prev: i, new: o }), this._viewportHeight.set(o, void 0);
+      }), this._viewportResizeObserver.observe(t), this._restoreScrollPosition());
+    });
+    l(this, "_handleScroll", () => {
+      if (!this._scrollContainerRef) return;
+      const t = this._scrollTop.get(), n = this._scrollContainerRef.scrollTop, s = n - t;
+      if (this._scrollTop.set(n, void 0), Math.abs(s) > 200 && We("handleScroll:LARGE_JUMP", {
+        prevObsScrollTop: t,
+        newScrollTop: n,
+        delta: s,
+        suppressed: this._suppressScrollHandler,
+        stack: new Error().stack
+      }), this._suppressScrollHandler || !this._currentNodeId) {
+        this._suppressScrollHandler && z("handleScroll:suppressed", { newScrollTop: n, delta: s });
+        return;
+      }
+      this._scrollSaveTimeout && clearTimeout(this._scrollSaveTimeout), this._scrollSaveTimeout = setTimeout(() => {
+        if (!this._currentNodeId) return;
+        const o = this.layout.get(), i = qe(o, this._scrollTop.get());
+        i && kn(this._currentNodeId, i);
+      }, 150);
+    });
+    l(this, "observeRowElement", (t, n) => {
+      t && (this._resizeObserver || (this._resizeObserver = new ResizeObserver((s) => {
+        const o = this._rowHeights.get();
+        let i;
+        const d = [];
+        for (const c of s) {
+          const u = c.target.getAttribute("data-row-id");
+          if (!u) continue;
+          const h = Math.round(c.contentRect.height);
+          h > 0 && o.get(u) !== h && (d.push({ rid: u, oldH: o.get(u), newH: h }), i || (i = new Map(o)), i.set(u, h), wn(u, h));
+        }
+        if (i) {
+          const c = this.layout.get(), u = this._scrollTop.get(), h = qe(c, u);
+          this._rowHeights.set(i, void 0);
+          const p = this.layout.get();
+          if (h && this._scrollContainerRef) {
+            const m = Ke(p, h), b = m - u;
+            Math.abs(b) > 2 && z("resizeObserver:reAnchor", {
+              changedRows: d,
+              anchor: h,
+              scrollTopBefore: u,
+              newScrollTop: m,
+              delta: b,
+              oldTotalHeight: fe(c),
+              newTotalHeight: fe(p)
+            }), Math.abs(b) > 200 && We("resizeObserver:LARGE_REANCHOR", {
+              changedRows: d,
+              anchor: h,
+              scrollTopBefore: u,
+              newScrollTop: m,
+              delta: b
+            }), this._suppressScrollHandler = !0, this._scrollContainerRef.scrollTop = m, this._scrollTop.set(m, void 0), requestAnimationFrame(() => {
+              this._suppressScrollHandler = !1;
+            });
+          }
+        }
+      })), t.setAttribute("data-row-id", n), this._resizeObserver.observe(t));
+    });
+  }
+  get explorerModel() {
+    return this.props.model;
+  }
+  get currentSessionName() {
+    var s, o;
+    const t = this.explorerModel.daemon;
+    if (!t) return "current";
+    const n = t.sessions.get();
+    return ((s = n.find((i) => i.sourceKind === "current")) == null ? void 0 : s.name) ?? ((o = n[0]) == null ? void 0 : o.name) ?? "current";
+  }
+  get baselineSessionName() {
+    var s, o;
+    const t = this.explorerModel.daemon;
+    if (!t) return "baseline";
+    const n = t.sessions.get();
+    return ((s = n.find((i) => i.sourceKind === "worktree")) == null ? void 0 : s.name) ?? ((o = n[1]) == null ? void 0 : o.name) ?? "baseline";
+  }
+  updateForSelection(t) {
+    this._currentNodeId !== t && (z("updateForSelection", { prev: this._currentNodeId, new: t }), this._currentNodeId = t, this._restoreScrollPosition());
+  }
+  _restoreScrollPosition() {
+    if (!this._scrollContainerRef || !this._currentNodeId) return;
+    const t = In(this._currentNodeId);
+    if (!t) {
+      z("restoreScroll:noAnchor", { nodeId: this._currentNodeId });
+      return;
+    }
+    const n = this.layout.get(), s = Ke(n, t), o = this._scrollContainerRef.scrollTop;
+    z("restoreScroll", {
+      nodeId: this._currentNodeId,
+      anchor: t,
+      prevScrollTop: o,
+      targetScrollTop: s,
+      delta: s - o,
+      layoutLength: n.length
+    }), this._suppressScrollHandler = !0, this._scrollContainerRef.scrollTop = s, this._scrollTop.set(s, void 0), requestAnimationFrame(() => {
+      this._suppressScrollHandler = !1;
+    });
+  }
+  dispose() {
+    var t, n;
+    (t = this._resizeObserver) == null || t.disconnect(), (n = this._viewportResizeObserver) == null || n.disconnect(), this._scrollContainerRef && this._scrollContainerRef.removeEventListener("scroll", this._handleScroll), this._scrollSaveTimeout && clearTimeout(this._scrollSaveTimeout);
+  }
+}
+const Dn = A(
+  En,
+  {},
+  (r, e) => {
+    const t = e.explorerModel.selectedFixtures.read(r), n = e.explorerModel.selectedNodeId.read(r), s = e.layout.read(r), { start: o, end: i } = e.visibleRowRange.read(r);
+    if (e.updateForSelection(n), t.length === 0) {
+      const c = e.explorerModel.reportModel;
+      if (c) {
+        const u = c.state.read(r);
+        if (u.status === "loading")
+          return /* @__PURE__ */ a("div", { style: E.emptyState, children: /* @__PURE__ */ a("span", { style: E.emptyText, children: "Loading report..." }) });
+        if (u.status === "error")
+          return /* @__PURE__ */ a("div", { style: E.emptyState, children: /* @__PURE__ */ g("span", { style: { ...E.emptyText, color: "var(--vscode-errorForeground)" }, children: [
+            "Failed to load report: ",
+            u.message
+          ] }) });
+      }
+      return /* @__PURE__ */ a("div", { style: E.emptyState, children: /* @__PURE__ */ a("span", { style: E.emptyText, children: "Select a component or folder to preview" }) });
+    }
+    const d = fe(s);
+    return /* @__PURE__ */ a("div", { ref: e.setScrollContainerRef, style: E.scrollContainer, children: /* @__PURE__ */ a("div", { style: { position: "relative", height: d }, children: t.slice(o, i).map((c, u) => {
+      const h = o + u, { top: p } = s[h], m = It(c), b = Qe(Je(c)), S = h > 0 ? Qe(Je(t[h - 1])) : void 0, C = Vn(b, S, m);
+      return /* @__PURE__ */ g(
+        "div",
+        {
+          ref: (_) => e.observeRowElement(_, m),
+          style: { position: "absolute", top: p, left: ne, right: ne },
+          children: [
+            C.map((_) => {
+              const M = Mn(_.depth);
+              return /* @__PURE__ */ a(M, { style: Fn(_.depth), children: /* @__PURE__ */ a(
+                "a",
+                {
+                  href: vt("component", _.nodeId),
+                  style: E.headingLink,
+                  onClick: (F) => {
+                    F.preventDefault(), e.explorerModel.selectNode(_.nodeId);
+                  },
+                  children: _.name
+                }
+              ) }, _.depth);
+            }),
+            c.type === "single" ? /* @__PURE__ */ a(yt, { fixture: c.fixture, compact: !1 }) : c.type === "variants" ? /* @__PURE__ */ a(Bn, { row: c, onSelect: e.explorerModel.selectNode }) : c.type === "screenshot-comparison" && e.explorerModel.daemon ? /* @__PURE__ */ a(
+              gn,
+              {
+                name: c.name,
+                path: c.path,
+                items: c.items,
+                daemon: e.explorerModel.daemon,
+                baselineSession: e.baselineSessionName,
+                currentSession: e.currentSessionName
+              }
+            ) : c.type === "report-comparison" && e.explorerModel.reportModel ? /* @__PURE__ */ a(
+              xn,
+              {
+                name: c.name,
+                path: c.path,
+                items: c.items,
+                reportModel: e.explorerModel.reportModel
+              }
+            ) : null
+          ]
+        },
+        m
+      );
+    }) }) });
+  }
+), Bn = k(
+  {
+    row: f.const(),
+    onSelect: f.const()
+  },
+  (r, e) => {
+    const t = e.row;
+    return /* @__PURE__ */ a("div", { style: E.variantsContent, children: t.fixtures.map((n) => /* @__PURE__ */ a(yt, { fixture: n, compact: !0, onSelect: e.onSelect }, n.id)) });
+  }
+), E = {
+  scrollContainer: {
+    flex: 1,
+    overflow: "auto",
+    backgroundColor: "var(--vscode-editor-background)"
+  },
+  emptyState: {
+    flex: 1,
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    backgroundColor: "var(--vscode-editor-background)"
+  },
+  emptyText: {
+    color: "var(--vscode-descriptionForeground)",
+    fontSize: "14px"
+  },
+  variantsContent: {
+    display: "flex",
+    flexDirection: "row",
+    flexWrap: "wrap",
+    gap: "16px"
+  },
+  headingLink: {
+    textDecoration: "none",
+    color: "inherit"
+  }
+}, An = A(
+  Fr,
+  { daemonModel: f.const(), reportModel: f.const() },
+  (r, e) => {
+    const t = e.leftSidebarVisible.read(r), n = e.rightSidebarVisible.read(r), s = e.isDarkTheme.read(r), o = e.selectedNode.read(r);
+    return /* @__PURE__ */ g("div", { className: s ? "vscode-theme default-dark-plus" : "vscode-theme default-light-plus", style: v.container, children: [
+      t && /* @__PURE__ */ a(en, { model: e }),
+      /* @__PURE__ */ g("div", { style: v.centerArea, children: [
+        /* @__PURE__ */ a(Pr, { model: e }),
+        /* @__PURE__ */ a(Dn, { model: e })
+      ] }),
+      n && /* @__PURE__ */ a(sn, { selectedNode: o })
+    ] });
+  }
+);
+var $n = class ge {
+  constructor(e) {
+    this.iterator = e;
+  }
+  static fromIterable(e) {
+    return new ge(e[Symbol.asyncIterator]());
+  }
+  static fromFn(e) {
+    return new ge(e());
+  }
+  [Symbol.asyncIterator]() {
+    return this.iterator;
+  }
+}, zn = class extends Error {
+  constructor(r, e, t) {
+    super(t), this.statusCode = r, this.method = e, this.name = "ApiError";
+  }
+}, Ln = class {
+  constructor(r) {
+    l(this, "methods", this._createProxy(""));
+    this._request = r;
+  }
+  _createProxy(r) {
+    return new Proxy(() => {
+    }, {
+      apply: async (e, t, n) => await this._request(r, n[0]),
+      get: (e, t) => {
+        if (typeof t != "symbol" && !(t === "then" || t === "catch" || t === "finally" || t === "toString" || t === "valueOf" || t === "toJSON" || t === "name" || t === "length" || t === "prototype" || t === "constructor" || t === "caller" || t === "arguments"))
+          return this._createProxy(`${r}${r ? "/" : ""}${t}`);
+      }
+    });
+  }
+};
+function Hn(r, e) {
+  return new Ln(async (t, n) => {
+    var d;
+    const s = await fetch(`${r}/${t}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(d = e == null ? void 0 : e.getHeaders) == null ? void 0 : d.call(e)
+      },
+      body: JSON.stringify(n)
+    });
+    if (s.status !== 200) {
+      const c = await s.json().catch(() => null);
+      let u;
+      throw c && typeof c == "object" && "errorMessage" in c ? u = `${c.errorMessage}` : u = `Error calling API method ${t}: ${JSON.stringify(c)} (Status: ${s.status}, Status Text: ${s.statusText})`, new zn(s.status, t, u);
+    }
+    const o = s.headers.get("Content-Type");
+    return o != null && o.startsWith("application/jsonl") ? $n.fromFn(async function* () {
+      var m;
+      const c = (m = s.body) == null ? void 0 : m.getReader();
+      if (!c)
+        return;
+      let u = "";
+      const h = new TextDecoder("utf-8");
+      for (; ; ) {
+        const { done: b, value: S } = await c.read();
+        if (b)
+          break;
+        u += h.decode(S, { stream: !0 });
+        let C;
+        for (; (C = u.indexOf(`
+`)) >= 0; ) {
+          const _ = u.slice(0, C).trim();
+          u = u.slice(C + 1), _.length > 0 && (yield JSON.parse(_));
+        }
+      }
+      const p = u.trim();
+      p.length > 0 && (yield JSON.parse(p));
+    }) : await s.json();
+  });
+}
+class jn {
+  constructor(e) {
+    l(this, "_sourceTreeIds", x(this, /* @__PURE__ */ new Map()));
+    l(this, "_sessions", x(this, []));
+    l(this, "_screenshotCache", /* @__PURE__ */ new Map());
+    l(this, "_client");
+    l(this, "_eventStreamAbort", null);
+    l(this, "sessionName");
+    /** Observable map of sessionName → current sourceTreeId */
+    l(this, "sourceTreeIds", this._sourceTreeIds);
+    /** Observable list of sessions from the daemon */
+    l(this, "sessions", this._sessions);
+    this.config = e, this.sessionName = e.sessionName, this._client = Hn("/__explorer/daemon-api");
+  }
+  /**
+   * Initializes the model: fetches initial session info and starts listening to events.
+   * Call this once after construction.
+   */
+  async initialize() {
+    await this._fetchSessionInfos(), this._startEventStream();
+  }
+  /**
+   * Get a screenshot for a fixture in a session, using cache when available.
+   * Cache is keyed on sessionName + fixtureId and invalidated when sourceTreeId changes.
+   */
+  async getScreenshot(e, t) {
+    const n = this._sourceTreeIds.get().get(e);
+    if (!n)
+      throw new Error(`No sourceTreeId known for session '${e}'`);
+    const s = `${e}:${t}`, o = this._screenshotCache.get(s);
+    if (o && o.sourceTreeId === n)
+      return o.data;
+    const i = await this._client.methods.screenshots.take({
+      fixtureId: t,
+      sessionName: e,
+      sourceTreeId: n,
+      includeImage: !0
+    });
+    return this._screenshotCache.set(s, { sourceTreeId: n, data: i }), i;
+  }
+  /**
+   * Compare a fixture across two sessions. Returns match status and hashes (no images).
+   */
+  async compare(e, t, n) {
+    const s = this._sourceTreeIds.get().get(t), o = this._sourceTreeIds.get().get(n);
+    if (!s || !o)
+      throw new Error("Missing sourceTreeId for sessions");
+    return this._client.methods.screenshots.compare({
+      fixtureId: e,
+      baselineSessionName: t,
+      baselineSourceTreeId: s,
+      currentSessionName: n,
+      currentSourceTreeId: o,
+      includeImages: !1
+    });
+  }
+  /**
+   * List fixtures from a session.
+   */
+  async listFixtures(e) {
+    const t = this._sourceTreeIds.get().get(e);
+    if (!t)
+      throw new Error(`No sourceTreeId known for session '${e}'`);
+    return this._client.methods.fixtures.list({ sessionName: e, sourceTreeId: t });
+  }
+  /**
+   * Get the explorer URL for a different session (for session switching via full navigation).
+   */
+  getSessionExplorerUrl(e) {
+    const t = this._sessions.get().find((n) => n.name === e);
+    if (t)
+      return t.serverUrl + "/___explorer";
+  }
+  dispose() {
+    var e;
+    (e = this._eventStreamAbort) == null || e.abort(), this._eventStreamAbort = null;
+  }
+  // ---------------------------------------------------------------------------
+  // Private
+  // ---------------------------------------------------------------------------
+  async _fetchSessionInfos() {
+    const e = await this._client.methods.sessions(), t = /* @__PURE__ */ new Map(), n = [];
+    for (const s of e)
+      t.set(s.name, s.sourceTreeId), n.push({ name: s.name, serverUrl: s.serverUrl, sourceKind: s.sourceKind });
+    this._sourceTreeIds.set(t, void 0), this._sessions.set(n, void 0);
+  }
+  async _startEventStream() {
+    this._eventStreamAbort = new AbortController();
+    const e = this._eventStreamAbort.signal;
+    try {
+      const t = await this._client.methods.events();
+      for await (const n of t) {
+        if (e.aborted) break;
+        this._handleEvent(n);
+      }
+    } catch (t) {
+      e.aborted || (console.error("[DaemonModel] Event stream error:", t), setTimeout(() => {
+        e.aborted || this._startEventStream();
+      }, 2e3));
+    }
+  }
+  _handleEvent(e) {
+    if (e.type === "source-change") {
+      const t = new Map(this._sourceTreeIds.get());
+      t.set(e.sessionName, e.sourceTreeId), this._sourceTreeIds.set(t, void 0);
+      for (const n of this._screenshotCache.keys())
+        n.startsWith(`${e.sessionName}:`) && this._screenshotCache.delete(n);
+    }
+  }
+}
+function Un() {
+  return window.__EXPLORER_DAEMON__;
+}
+class Pn {
+  constructor(e) {
+    l(this, "state", x(this, { status: "loading" }));
+    l(this, "_baseUrl");
+    this.reportUrl = e;
+    const t = e.lastIndexOf("/");
+    this._baseUrl = t >= 0 ? e.slice(0, t + 1) : "", this._fetch();
+  }
+  resolveScreenshotUrl(e) {
+    return this._baseUrl + e;
+  }
+  buildTree(e) {
+    const t = this.state.read(e);
+    return t.status !== "ready" ? { id: "", name: "Report", type: "folder", children: [], labels: [] } : Wn(t.report.fixtures);
+  }
+  async _fetch() {
+    this.state.set({ status: "loading" }, void 0);
+    try {
+      const e = await fetch(this.reportUrl);
+      if (!e.ok)
+        throw new Error(`HTTP ${e.status}: ${e.statusText}`);
+      const t = await e.json();
+      this.state.set({ status: "ready", report: t }, void 0);
+    } catch (e) {
+      this.state.set({ status: "error", message: String(e) }, void 0);
+    }
+  }
+}
+function Wn(r) {
+  const e = { id: "", name: "Components", type: "folder", children: [], labels: [] };
+  for (const [t, n] of Object.entries(r)) {
+    const s = t.split("/");
+    let o = e;
+    for (let i = 0; i < s.length; i++) {
+      const d = s[i], c = i === s.length - 1, u = s.slice(0, i + 1).join("/");
+      if (c)
+        o.children.push({
+          id: u,
+          name: d,
+          type: "component",
+          reportEntry: n,
+          labels: []
+        });
+      else {
+        let h = o.children.find((p) => p.type === "folder" && p.name === d);
+        h || (h = { id: u, name: d, type: "folder", children: [], labels: [] }, o.children.push(h)), o = h;
+      }
+    }
+  }
+  return e;
+}
+class ss {
+  constructor(e, t) {
+    l(this, "_root");
+    l(this, "_registry", new yr());
+    l(this, "_daemonModel");
+    l(this, "_reportModel");
+    this._populateRegistry(t), this._reportModel = this._initializeReportModel(), this._daemonModel = this._reportModel ? void 0 : this._initializeDaemonModel(), this._root = Ft(e), this._root.render(At(An, {
+      registry: this._registry,
+      daemonModel: this._daemonModel,
+      reportModel: this._reportModel
+    }));
+  }
+  _initializeReportModel() {
+    const t = new URLSearchParams(location.search).get("report");
+    if (t)
+      return new Pn(t);
+  }
+  _initializeDaemonModel() {
+    const e = Un();
+    if (!e)
+      return;
+    const t = new jn(e);
+    return t.initialize().catch((n) => {
+      console.error("[ExplorerApp] Failed to initialize DaemonModel:", n);
+    }), t;
+  }
+  _populateRegistry(e) {
+    this._registry.clear();
+    for (const [t, n] of Object.entries(e)) {
+      const s = n.default;
+      s && typeof s == "object" && this._registry.register(t, s);
+    }
+  }
+  /**
+   * Updates the fixtures. The UI will update automatically since the registry is observable.
+   */
+  updateFixtures(e) {
+    this._populateRegistry(e);
+  }
+  /**
+   * No-op for ExplorerApp (only meaningful for CliRuntime).
+   * Present so the plugin's HMR wiring can call it polymorphically.
+   */
+  bumpVersion() {
+  }
+  /**
+   * Unmounts the explorer and cleans up resources.
+   */
+  dispose() {
+    var e;
+    (e = this._daemonModel) == null || e.dispose(), this._root.unmount();
+  }
+}
+export {
+  Br as ChevronDownIcon,
+  Dr as ChevronRightIcon,
+  ns as CliRuntime,
+  Ar as ComponentIcon,
+  jn as DaemonModel,
+  An as Explorer,
+  ss as ExplorerApp,
+  Fr as ExplorerModel,
+  yr as FixtureRegistry,
+  $r as FolderIcon,
+  en as LeftSidebar,
+  jr as MoonIcon,
+  zr as PanelLeftIcon,
+  Lr as PanelRightIcon,
+  Pn as ReportModel,
+  sn as RightSidebar,
+  Hr as SunIcon,
+  Pr as TitleBar,
+  oe as TitleBarButton,
+  Kr as TreeItem,
+  bt as TreeView,
+  $t as VIEWPORT_SIZES,
+  as as asyncRender,
+  Ut as collectComponents,
+  Oe as createComponentDefinition,
+  ie as createFixtureTree,
+  ds as defineFixture,
+  cs as defineFixtureGroup,
+  ls as defineFixtureVariants,
+  Ve as findNodeByPath,
+  Re as fixtureGroupBrand,
+  Te as fixtureVariantsBrand,
+  Lt as getDefaultPropertyValues,
+  rs as isComponentDefinition,
+  be as isFixtureGroup,
+  _e as isFixtureVariants,
+  ve as isSingleFixture,
+  Ce as mergeStyles,
+  Xn as parseFixtureExport,
+  es as parseFixtureGroup,
+  ts as parseFixtureVariants,
+  Yn as parseSingleFixture,
+  zt as resolveViewport,
+  ke as singleFixtureBrand,
+  v as styles,
+  hs as syncRender,
+  gt as toExplorerTree
+};
+//# sourceMappingURL=viewer.js.map