@vscode/component-explorer 0.1.1-0 → 0.1.1-10

package/dist/viewer.js

@@ -0,0 +1,3713 @@
+var wt = Object.defineProperty;
+var St = (s, e, t) => e in s ? wt(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var l = (s, e, t) => St(s, typeof e != "symbol" ? e + "" : e, t);
+import { fixtureGroupBrand as Ve, fixtureVariantsBrand as ke, singleFixtureBrand as Ne, defineFixtureGroup as ae, defineFixture as L } from "./index.js";
+import { defineFixtureVariants as Ds } from "./index.js";
+import { createRoot as It } from "react-dom/client";
+import { createContext as Ke, useReducer as Ot, useState as Tt, useContext as Rt, useEffect as De, createElement as Vt } from "react";
+import { jsx as a, jsxs as g, Fragment as ye } from "react/jsx-runtime";
+import { unstable_batchedUpdates as Je } from "react-dom";
+function xe(s) {
+  return typeof s == "object" && s !== null && Ne in s && s[Ne] === !0 && "_options" in s && typeof s._options == "object";
+}
+function Ce(s) {
+  return typeof s == "object" && s !== null && Ve in s && s[Ve] === !0 && "_entries" in s && typeof s._entries == "object";
+}
+function we(s) {
+  return typeof s == "object" && s !== null && ke in s && s[ke] === !0 && "_variants" in s && typeof s._variants == "object";
+}
+function Cs(s) {
+  return xe(s) ? { success: !0, data: s } : Ce(s) ? { success: !0, data: s } : we(s) ? { success: !0, data: s } : { success: !1, error: "Value is not a valid fixture export (missing brand symbol or _options/_entries/_variants)" };
+}
+function ws(s) {
+  return xe(s) ? { success: !0, data: s } : { success: !1, error: "Value is not a SingleFixtureExport" };
+}
+function Ss(s) {
+  return Ce(s) ? { success: !0, data: s } : { success: !1, error: "Value is not a FixtureGroupExport" };
+}
+function Is(s) {
+  return we(s) ? { success: !0, data: s } : { success: !1, error: "Value is not a FixtureVariantsExport" };
+}
+function Ee(s, e, t) {
+  const n = s._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",
+    properties: n.properties ?? [],
+    render: n.render
+  };
+}
+function Os(s) {
+  return typeof s == "object" && s !== null && "render" in s && typeof s.render == "function" && "id" in s && "name" in s;
+}
+const kt = {
+  mobile: { width: 390, height: 844 },
+  tablet: { width: 768, height: 1024 },
+  desktop: { width: 1440, height: 900 }
+};
+function Nt(s) {
+  return typeof s == "string" ? { name: s, ...kt[s] } : s;
+}
+function Dt(s) {
+  const e = {};
+  for (const t of s)
+    e[t.name] = t.defaultValue;
+  return e;
+}
+function le(s) {
+  const e = {
+    id: "",
+    name: "Components",
+    type: "folder",
+    children: []
+  };
+  for (const [t, n] of s) {
+    const r = Et(t);
+    Ze(e, [r], n);
+  }
+  return e;
+}
+function Et(s) {
+  return (s.split("/").pop() ?? s).replace(/\.fixture\.(tsx?|jsx?)$/, "");
+}
+function Ze(s, e, t) {
+  var n;
+  if (xe(t)) {
+    const r = e.join("/"), i = e[e.length - 1], o = {
+      id: r,
+      name: i,
+      type: "component",
+      component: Ee(t, r, i)
+    };
+    s.children || (s.children = []), s.children.push(o);
+  } else if (Ce(t)) {
+    const r = e[e.length - 1], i = e.join("/");
+    let o = (n = s.children) == null ? void 0 : n.find(
+      (d) => d.type === "folder" && d.name === r
+    );
+    o || (o = {
+      id: i,
+      name: r,
+      type: "folder",
+      children: []
+    }, s.children || (s.children = []), s.children.push(o));
+    for (const [d, c] of Object.entries(t._entries))
+      Ze(o, [...e, d], c);
+  } else if (we(t)) {
+    const r = e[e.length - 1], o = {
+      id: e.join("/"),
+      name: r,
+      type: "variants",
+      children: []
+    };
+    s.children || (s.children = []), s.children.push(o);
+    for (const [d, c] of Object.entries(t._variants)) {
+      const m = [...e, d].join("/"), v = {
+        id: m,
+        name: d,
+        type: "component",
+        component: Ee(c, m, d)
+      };
+      o.children.push(v);
+    }
+  }
+}
+function Fe(s, e) {
+  if (e.length === 0)
+    return s;
+  let t = s;
+  for (const n of e) {
+    if (!t || !t.children)
+      return;
+    t = t.children.find((r) => r.name === n);
+  }
+  return t;
+}
+function Ft(s) {
+  if (s.type === "component" && s.component)
+    return [s.component];
+  const e = [];
+  for (const t of s.children ?? [])
+    e.push(...Ft(t));
+  return e;
+}
+let j;
+function Xe(s) {
+  j ? j instanceof Ae ? j.loggers.push(s) : j = new Ae([j, s]) : j = s;
+}
+function b() {
+  return j;
+}
+let he;
+function At(s) {
+  he = s;
+}
+function Mt(s) {
+  he && he(s);
+}
+class Ae {
+  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 r of this.loggers)
+      r.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 r of this.loggers)
+      r.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 T;
+(function(s) {
+  let e = !1;
+  function t() {
+    e = !0;
+  }
+  s.enable = t;
+  function n() {
+    return r(1);
+  }
+  s.ofCaller = n;
+  function r(i) {
+    if (!e)
+      return;
+    const o = Error, d = o.stackTraceLimit;
+    o.stackTraceLimit = 3;
+    const c = new Error().stack;
+    return o.stackTraceLimit = d, Se.fromStack(c, i + 1);
+  }
+  s.ofNthCaller = r;
+})(T || (T = {}));
+class Se {
+  static fromStack(e, t) {
+    const n = e.split(`
+`), r = Bt(n[t + 1]);
+    if (r)
+      return new Se(r.fileName, r.line, r.column, r.id);
+  }
+  constructor(e, t, n, r) {
+    this.fileName = e, this.line = t, this.column = n, this.id = r;
+  }
+}
+function Bt(s) {
+  if (!s)
+    return;
+  const e = s.match(/\((.*):(\d+):(\d+)\)/);
+  if (e)
+    return {
+      fileName: e[1],
+      line: parseInt(e[2]),
+      column: parseInt(e[3]),
+      id: s
+    };
+  const t = s.match(/at ([^\(\)]*):(\d+):(\d+)/);
+  if (t)
+    return {
+      fileName: t[1],
+      line: parseInt(t[2]),
+      column: parseInt(t[3]),
+      id: s
+    };
+}
+class A {
+  constructor(e, t, n) {
+    this.owner = e, this.debugNameSource = t, this.referenceFn = n;
+  }
+  getDebugName(e) {
+    return zt(e, this);
+  }
+}
+const Me = /* @__PURE__ */ new Map(), ue = /* @__PURE__ */ new WeakMap();
+function zt(s, e) {
+  const t = ue.get(s);
+  if (t)
+    return t;
+  const n = Ht(s, e);
+  if (n) {
+    let r = Me.get(n) ?? 0;
+    r++, Me.set(n, r);
+    const i = r === 1 ? n : `${n}#${r}`;
+    return ue.set(s, i), i;
+  }
+}
+function Ht(s, e) {
+  const t = ue.get(s);
+  if (t)
+    return t;
+  const n = e.owner ? $t(e.owner) + "." : "";
+  let r;
+  const i = e.debugNameSource;
+  if (i !== void 0)
+    if (typeof i == "function") {
+      if (r = i(), r !== void 0)
+        return n + r;
+    } else
+      return n + i;
+  const o = e.referenceFn;
+  if (o !== void 0 && (r = Ie(o), r !== void 0))
+    return n + r;
+  if (e.owner !== void 0) {
+    const d = Lt(e.owner, s);
+    if (d !== void 0)
+      return n + d;
+  }
+}
+function Lt(s, e) {
+  for (const t in s)
+    if (s[t] === e)
+      return t;
+}
+const Be = /* @__PURE__ */ new Map(), ze = /* @__PURE__ */ new WeakMap();
+function $t(s) {
+  const e = ze.get(s);
+  if (e)
+    return e;
+  const t = Ye(s) ?? "Object";
+  let n = Be.get(t) ?? 0;
+  n++, Be.set(t, n);
+  const r = n === 1 ? t : `${t}#${n}`;
+  return ze.set(s, r), r;
+}
+function Ye(s) {
+  const e = s.constructor;
+  if (e)
+    return e.name === "Object" ? void 0 : e.name;
+}
+function Ie(s) {
+  const e = s.toString(), n = /\/\*\*\s*@description\s*([^*]*)\*\//.exec(e), r = n ? n[1] : void 0;
+  return r == null ? void 0 : r.trim();
+}
+let fe;
+function jt(s) {
+  fe = s;
+}
+let Qe;
+function Ut(s) {
+  Qe = s;
+}
+let et;
+function Pt(s) {
+  et = s;
+}
+let tt;
+function Gt(s) {
+  tt = s;
+}
+class Wt {
+  get TChange() {
+    return null;
+  }
+  reportChanges() {
+    this.get();
+  }
+  /** @sealed */
+  read(e) {
+    return e ? e.readObservable(this) : this.get();
+  }
+  map(e, t, n = T.ofCaller()) {
+    const r = t === void 0 ? void 0 : e, i = t === void 0 ? e : t;
+    return fe({
+      owner: r,
+      debugName: () => {
+        const o = Ie(i);
+        if (o !== void 0)
+          return o;
+        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(i.toString());
+        if (c)
+          return `${this.debugName}.${c[2]}`;
+        if (!r)
+          return `${this.debugName} (mapped)`;
+      },
+      debugReferenceFn: i
+    }, (o) => i(this.read(o), o), n);
+  }
+  /**
+   * @sealed
+   * Converts an observable of an observable value into a direct observable of the value.
+  */
+  flatten() {
+    return fe({
+      owner: void 0,
+      debugName: () => `${this.debugName} (flattened)`
+    }, (e) => this.read(e).read(e));
+  }
+  recomputeInitiallyAndOnChange(e, t) {
+    return e.add(Qe(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(et(this)), this;
+  }
+  get debugValue() {
+    return this.get();
+  }
+  debugGetDependencyGraph() {
+    return tt(this);
+  }
+}
+class Oe extends Wt {
+  constructor(e) {
+    var t;
+    super(), this._observers = /* @__PURE__ */ new Set(), (t = b()) == 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 = b()) == 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 = b()) == null || n.handleOnListenerCountChanged(this, this._observers.size));
+  }
+  onFirstObserverAdded() {
+  }
+  onLastObserverRemoved() {
+  }
+  log() {
+    var t;
+    const e = !!b();
+    return Mt(this), e || (t = b()) == null || t.handleObservableCreated(this, T.ofCaller()), this;
+  }
+  debugGetObservers() {
+    return this._observers;
+  }
+}
+function nt(s) {
+  return {
+    dispose: s
+  };
+}
+class I extends Error {
+  constructor(e) {
+    super(e || "An unexpected bug occurred."), Object.setPrototypeOf(this, I.prototype);
+  }
+}
+function ne(s) {
+  throw s;
+}
+function pe(s) {
+  console.error("Unexpected error:", s);
+}
+const X = (s, e) => s === e;
+function Q(s) {
+  return s != null;
+}
+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 qt(s) {
+  switch (s) {
+    case 0:
+      return "initial";
+    case 1:
+      return "dependenciesMightHaveChanged";
+    case 2:
+      return "stale";
+    case 3:
+      return "upToDate";
+    default:
+      return "<unknown>";
+  }
+}
+class w extends Oe {
+  get debugName() {
+    return this._debugNameData.getDebugName(this) ?? "(anonymous)";
+  }
+  constructor(e, t, n, r = void 0, i, o) {
+    var d;
+    super(o), this._debugNameData = e, this._computeFn = t, this._changeTracker = n, this._handleLastObserverRemoved = r, this._equalityComparator = i, 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 = b()) == 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 r;
+      try {
+        this._isReaderValid = !0;
+        let i;
+        this._changeTracker && (i = this._changeTracker.createChangeSummary(void 0), (n = (t = this._changeTracker).beforeUpdate) == null || n.call(t, this, i)), r = this._computeFn(this, i);
+      } finally {
+        this._isReaderValid = !1;
+      }
+      return this.onLastObserverRemoved(), r;
+    } else {
+      do {
+        if (this._state === 1) {
+          for (const r of this._dependencies)
+            if (r.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, r, i, o;
+    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, (r = (n = this._changeTracker).beforeUpdate) == null || r.call(n, this, d), this._isInBeforeUpdate = !1, this._changeSummary = (i = this._changeTracker) == null ? void 0 : i.createChangeSummary(d));
+      const c = this._state !== 0, h = this._value;
+      this._state = 3;
+      const m = this._delayedStore;
+      m !== 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 v of this._dependenciesToBeRemoved)
+          v.removeObserver(this);
+        this._dependenciesToBeRemoved.clear(), m !== void 0 && m.dispose();
+      }
+      e = this._didReportChange || c && !this._equalityComparator(h, this._value), (o = b()) == null || o.handleObservableUpdated(this, {
+        oldValue: h,
+        newValue: this._value,
+        change: void 0,
+        didChange: e,
+        hadValue: c
+      });
+    } catch (d) {
+      ne(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 I("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 r of n)
+          r.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 = b()) == null || n.handleDerivedDependencyChanged(this, e, t);
+      let r = !1;
+      try {
+        r = this._changeTracker ? this._changeTracker.handleChange({
+          changedObservable: e,
+          change: t,
+          didChange: (o) => o === e
+        }, this._changeSummary) : !0;
+      } catch (o) {
+        ne(o);
+      }
+      const i = this._state === 3;
+      if (r && (this._state === 1 || i) && (this._state = 2, i))
+        for (const o of this._observers)
+          o.handlePossibleChange(this);
+    }
+  }
+  // IReader Implementation
+  _ensureReaderValid() {
+    if (!this._isReaderValid)
+      throw new I("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: qt(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 r = this._observers;
+    t.updateObserver(this, this);
+    for (const i of r)
+      i.handleChange(this, n);
+  }
+}
+function N(s, e, t = T.ofCaller()) {
+  return e !== void 0 ? new w(new A(s, void 0, e), e, void 0, void 0, X, t) : new w(new A(void 0, void 0, s), s, void 0, void 0, X, t);
+}
+function Kt(s, e, t = T.ofCaller()) {
+  return new w(new A(s.owner, s.debugName, s.debugReferenceFn), e, void 0, s.onLastObserverRemoved, s.equalsFn ?? X, t);
+}
+jt(Kt);
+function Jt(s, e, t = T.ofCaller()) {
+  let n, r;
+  n = s, r = void 0;
+  let i;
+  return new w(new A(r, void 0, n), (o) => {
+    i ? i.clear() : i = new Y();
+    const d = n(o);
+    return d && i.add(d), d;
+  }, void 0, () => {
+    i && (i.dispose(), i = void 0);
+  }, X, t);
+}
+function Zt(s) {
+  switch (s) {
+    case 1:
+      return "dependenciesMightHaveChanged";
+    case 2:
+      return "stale";
+    case 3:
+      return "upToDate";
+    default:
+      return "<unknown>";
+  }
+}
+class se {
+  get debugName() {
+    return this._debugNameData.getDebugName(this) ?? "(anonymous)";
+  }
+  constructor(e, t, n, r) {
+    var i, o;
+    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 = (i = this._changeTracker) == null ? void 0 : i.createChangeSummary(void 0), (o = b()) == null || o.handleAutorunCreated(this, r), 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 = b()) == null || e.handleAutorunDisposed(this);
+    }
+  }
+  _run() {
+    var t, n, r, i;
+    const e = this._dependenciesToBeRemoved;
+    this._dependenciesToBeRemoved = this._dependencies, this._dependencies = e, this._state = 3;
+    try {
+      if (!this._disposed) {
+        (t = b()) == null || t.handleAutorunStarted(this);
+        const o = this._changeSummary, d = this._delayedStore;
+        d !== void 0 && (this._delayedStore = void 0);
+        try {
+          this._isRunning = !0, this._changeTracker && ((r = (n = this._changeTracker).beforeUpdate) == null || r.call(n, this, o), this._changeSummary = this._changeTracker.createChangeSummary(o)), this._store !== void 0 && (this._store.dispose(), this._store = void 0), this._runFn(this, o);
+        } catch (c) {
+          ne(c);
+        } finally {
+          this._isRunning = !1, d !== void 0 && d.dispose();
+        }
+      }
+    } finally {
+      this._disposed || (i = b()) == null || i.handleAutorunFinished(this);
+      for (const o of this._dependenciesToBeRemoved)
+        o.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 = b()) == null || n.handleAutorunDependencyChanged(this, e, t);
+      try {
+        (this._changeTracker ? this._changeTracker.handleChange({
+          changedObservable: e,
+          change: t,
+          didChange: (i) => i === e
+        }, this._changeSummary) : !0) && (this._state = 2);
+      } catch (r) {
+        ne(r);
+      }
+    }
+  }
+  _isDependency(e) {
+    return this._dependencies.has(e) && !this._dependenciesToBeRemoved.has(e);
+  }
+  // IReader implementation
+  _ensureNoRunning() {
+    if (!this._isRunning)
+      throw new I("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 I("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 I("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: Zt(this._state)
+    };
+  }
+  debugRerun() {
+    this._isRunning ? this._state = 2 : this._run();
+  }
+}
+function st(s, e = T.ofCaller()) {
+  return new se(new A(void 0, void 0, s), s, void 0, e);
+}
+function He(s) {
+  const e = new Error("BugIndicatingErrorRecovery: " + s);
+  pe(e), console.error("recovered from an error that indicates a bug", e);
+}
+function rt(s, e) {
+  const t = new it(s, e);
+  try {
+    s(t);
+  } finally {
+    t.finish();
+  }
+}
+function Xt(s, e, t) {
+  s ? e(s) : rt(e, t);
+}
+class it {
+  constructor(e, t) {
+    var n;
+    this._fn = e, this._getDebugName = t, this._updatingObservers = [], (n = b()) == null || n.handleBeginTransaction(this);
+  }
+  getDebugName() {
+    return this._getDebugName ? this._getDebugName() : Ie(this._fn);
+  }
+  updateObserver(e, t) {
+    if (!this._updatingObservers) {
+      He("Transaction already finished!"), rt((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) {
+      He("transaction.finish() has already been called!");
+      return;
+    }
+    for (let n = 0; n < e.length; n++) {
+      const { observer: r, observable: i } = e[n];
+      r.endUpdate(i);
+    }
+    this._updatingObservers = null, (t = b()) == null || t.handleEndTransaction(this);
+  }
+  debugGetUpdatingObservers() {
+    return this._updatingObservers;
+  }
+}
+function y(s, e, t = T.ofCaller()) {
+  let n;
+  return typeof s == "string" ? n = new A(void 0, s, void 0) : n = new A(s, void 0, void 0), new re(n, e, X, t);
+}
+class re extends Oe {
+  get debugName() {
+    return this._debugNameData.getDebugName(this) ?? "ObservableValue";
+  }
+  constructor(e, t, n, r) {
+    var i;
+    super(r), this._debugNameData = e, this._equalityComparator = n, this._value = t, (i = b()) == null || i.handleObservableUpdated(this, { hadValue: !1, newValue: t, change: void 0, didChange: !0, oldValue: void 0 });
+  }
+  get() {
+    return this._value;
+  }
+  set(e, t, n) {
+    var i;
+    if (n === void 0 && this._equalityComparator(this._value, e))
+      return;
+    let r;
+    t || (t = r = new it(() => {
+    }, () => `Setting ${this.debugName}`));
+    try {
+      const o = this._value;
+      this._setValue(e), (i = b()) == null || i.handleObservableUpdated(this, { oldValue: o, newValue: e, change: n, didChange: !0, hadValue: !0 });
+      for (const d of this._observers)
+        t.updateObserver(d, this), d.handleChange(this, n);
+    } finally {
+      r && r.finish();
+    }
+  }
+  toString() {
+    return `${this.debugName}: ${this._value}`;
+  }
+  _setValue(e) {
+    this._value = e;
+  }
+  debugGetState() {
+    return {
+      value: this._value
+    };
+  }
+  debugSetValue(e) {
+    this._value = e;
+  }
+}
+function Le(...s) {
+  let e, t, n, r;
+  return s.length === 2 ? [t, n] = s : [e, t, n, r] = s, new F(new A(e, void 0, n), t, n, () => F.globalTransaction, X, r ?? T.ofCaller());
+}
+class F extends Oe {
+  constructor(e, t, n, r, i, o) {
+    super(o), this._debugNameData = e, this.event = t, this._getValue = n, this._getTransaction = r, this._equalityComparator = i, this._hasValue = !1, this.handleEvent = (d) => {
+      var p;
+      const c = this._getValue(d), h = this._value, m = !this._hasValue || !this._equalityComparator(h, c);
+      let v = !1;
+      m && (this._value = c, this._hasValue && (v = !0, Xt(this._getTransaction(), (_) => {
+        var E;
+        (E = b()) == null || E.handleObservableUpdated(this, { oldValue: h, newValue: c, change: void 0, didChange: m, hadValue: this._hasValue });
+        for (const R of this._observers)
+          _.updateObserver(R, this), R.handleChange(this, void 0);
+      }, () => {
+        const _ = this.getDebugName();
+        return "Event fired" + (_ ? `: ${_}` : "");
+      })), this._hasValue = !0), v || (p = b()) == null || p.handleObservableUpdated(this, { oldValue: h, newValue: c, change: void 0, didChange: m, 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(s) {
+  s.Observer = F;
+  function e(t, n) {
+    let r = !1;
+    F.globalTransaction === void 0 && (F.globalTransaction = t, r = !0);
+    try {
+      n();
+    } finally {
+      r && (F.globalTransaction = void 0);
+    }
+  }
+  s.batchEventsGlobally = e;
+})(Le || (Le = {}));
+function Yt(s) {
+  const e = new ot(!1, void 0);
+  return s.addObserver(e), nt(() => {
+    s.removeObserver(e);
+  });
+}
+Pt(Yt);
+function Qt(s, e) {
+  const t = new ot(!0, e);
+  s.addObserver(t);
+  try {
+    t.beginUpdate(s);
+  } finally {
+    t.endUpdate(s);
+  }
+  return nt(() => {
+    s.removeObserver(t);
+  });
+}
+Ut(Qt);
+class ot {
+  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 te;
+function en(s) {
+  te || (te = new tn(), Xe(te)), te.addFilteredObj(s);
+}
+class tn {
+  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 nn([
+      P(on("|  ", this.indentation)),
+      e
+    ]);
+  }
+  formatInfo(e) {
+    return e.hadValue ? e.didChange ? [
+      P(" "),
+      S(k(e.oldValue, 70), {
+        color: "red",
+        strikeThrough: !0
+      }),
+      P(" "),
+      S(k(e.newValue, 60), {
+        color: "green"
+      })
+    ] : [P(" (unchanged)")] : [
+      P(" "),
+      S(k(e.newValue, 60), {
+        color: "green"
+      }),
+      P(" (initial)")
+    ];
+  }
+  handleObservableCreated(e) {
+    if (e instanceof w) {
+      const t = e;
+      this.changedObservablesSets.set(t, /* @__PURE__ */ new Set());
+    }
+  }
+  handleOnListenerCountChanged(e, t) {
+  }
+  handleObservableUpdated(e, t) {
+    if (this._isIncluded(e)) {
+      if (e instanceof w) {
+        this._handleDerivedRecomputed(e, t);
+        return;
+      }
+      console.log(...this.textToConsoleArgs([
+        G("observable value changed"),
+        S(e.debugName, { color: "BlueViolet" }),
+        ...this.formatInfo(t)
+      ]));
+    }
+  }
+  formatChanges(e) {
+    if (e.size !== 0)
+      return S(" (changed deps: " + [...e].map((t) => t.debugName).join(", ") + ")", { color: "gray" });
+  }
+  handleDerivedDependencyChanged(e, t, n) {
+    var r;
+    this._isIncluded(e) && ((r = this.changedObservablesSets.get(e)) == null || r.add(t));
+  }
+  _handleDerivedRecomputed(e, t) {
+    if (!this._isIncluded(e))
+      return;
+    const n = this.changedObservablesSets.get(e);
+    n && (console.log(...this.textToConsoleArgs([
+      G("derived recomputed"),
+      S(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([
+      G("derived cleared"),
+      S(e.debugName, { color: "BlueViolet" })
+    ]));
+  }
+  handleFromEventObservableTriggered(e, t) {
+    this._isIncluded(e) && console.log(...this.textToConsoleArgs([
+      G("observable from event triggered"),
+      S(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([
+      G("autorun"),
+      S(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([
+      G("transaction"),
+      S(t, { color: "BlueViolet" }),
+      { data: [{ fn: e._fn }] }
+    ])), this.indentation++;
+  }
+  handleEndTransaction() {
+    this.indentation--;
+  }
+}
+function nn(s) {
+  const e = new Array(), t = [];
+  let n = "";
+  function r(o) {
+    if ("length" in o)
+      for (const d of o)
+        d && r(d);
+    else "text" in o ? (n += `%c${o.text}`, e.push(o.style), o.data && t.push(...o.data)) : "data" in o && t.push(...o.data);
+  }
+  r(s);
+  const i = [n, ...e];
+  return i.push(...t), i;
+}
+function P(s) {
+  return S(s, { color: "black" });
+}
+function G(s) {
+  return S(an(`${s}: `, 10), { color: "black", bold: !0 });
+}
+function S(s, e = {
+  color: "black"
+}) {
+  function t(r) {
+    return Object.entries(r).reduce((i, [o, d]) => `${i}${o}:${d};`, "");
+  }
+  const n = {
+    color: e.color
+  };
+  return e.strikeThrough && (n["text-decoration"] = "line-through"), e.bold && (n["font-weight"] = "bold"), {
+    text: s,
+    style: t(n)
+  };
+}
+function k(s, e) {
+  switch (typeof s) {
+    case "number":
+      return "" + s;
+    case "string":
+      return s.length + 2 <= e ? `"${s}"` : `"${s.substr(0, e - 7)}"+...`;
+    case "boolean":
+      return s ? "true" : "false";
+    case "undefined":
+      return "undefined";
+    case "object":
+      return s === null ? "null" : Array.isArray(s) ? sn(s, e) : rn(s, e);
+    case "symbol":
+      return s.toString();
+    case "function":
+      return `[[Function${s.name ? " " + s.name : ""}]]`;
+    default:
+      return "" + s;
+  }
+}
+function sn(s, e) {
+  let t = "[ ", n = !0;
+  for (const r of s) {
+    if (n || (t += ", "), t.length - 5 > e) {
+      t += "...";
+      break;
+    }
+    n = !1, t += `${k(r, e - t.length)}`;
+  }
+  return t += " ]", t;
+}
+function rn(s, e) {
+  if (typeof s.toString == "function" && s.toString !== Object.prototype.toString) {
+    const i = s.toString();
+    return i.length <= e ? i : i.substring(0, e - 3) + "...";
+  }
+  const t = Ye(s);
+  let n = t ? t + "(" : "{ ", r = !0;
+  for (const [i, o] of Object.entries(s)) {
+    if (r || (n += ", "), n.length - 5 > e) {
+      n += "...";
+      break;
+    }
+    r = !1, n += `${i}: ${k(o, e - n.length)}`;
+  }
+  return n += t ? ")" : " }", n;
+}
+function on(s, e) {
+  let t = "";
+  for (let n = 1; n <= e; n++)
+    t += s;
+  return t;
+}
+function an(s, e) {
+  for (; s.length < e; )
+    s += " ";
+  return s;
+}
+class ie {
+  static createHost(e, t) {
+    return new ie(e, t);
+  }
+  static createClient(e, t) {
+    return new ie(e, t);
+  }
+  constructor(e, t) {
+    this._channelFactory = e, this._getHandler = t, this._channel = this._channelFactory({
+      handleNotification: (i) => {
+        const o = i, d = this._getHandler().notifications[o[0]];
+        if (!d)
+          throw new Error(`Unknown notification "${o[0]}"!`);
+        d(...o[1]);
+      },
+      handleRequest: (i) => {
+        const o = i;
+        try {
+          return { type: "result", value: this._getHandler().requests[o[0]](...o[1]) };
+        } catch (d) {
+          return { type: "error", value: d };
+        }
+      }
+    });
+    const n = new Proxy({}, {
+      get: (i, o) => async (...d) => {
+        const c = await this._channel.sendRequest([o, d]);
+        if (c.type === "error")
+          throw c.value;
+        return c.value;
+      }
+    }), r = new Proxy({}, {
+      get: (i, o) => (...d) => {
+        this._channel.sendNotification([o, d]);
+      }
+    });
+    this.api = { notifications: r, requests: n };
+  }
+}
+function dn(s, e) {
+  const t = globalThis;
+  let n = [], r;
+  const { channel: i, handler: o } = cn({
+    sendNotification: (c) => {
+      r ? r.sendNotification(c) : n.push(c);
+    }
+  });
+  let d;
+  return (t.$$debugValueEditor_debugChannels ?? (t.$$debugValueEditor_debugChannels = {}))[s] = (c) => {
+    d = e(), r = c;
+    for (const h of n)
+      c.sendNotification(h);
+    return n = [], o;
+  }, ie.createClient(i, () => {
+    if (!d)
+      throw new Error("Not supported");
+    return d;
+  });
+}
+function cn(s) {
+  let e;
+  return {
+    channel: (n) => (e = n, {
+      sendNotification: (r) => {
+        s.sendNotification(r);
+      },
+      sendRequest: (r) => {
+        throw new Error("not supported");
+      }
+    }),
+    handler: {
+      handleRequest: (n) => n.type === "notification" ? e == null ? void 0 : e.handleNotification(n.data) : e == null ? void 0 : e.handleRequest(n.data)
+    }
+  };
+}
+class ln {
+  constructor() {
+    this._timeout = void 0;
+  }
+  throttle(e, t) {
+    this._timeout === void 0 && (this._timeout = setTimeout(() => {
+      this._timeout = void 0, e();
+    }, t));
+  }
+  dispose() {
+    this._timeout !== void 0 && clearTimeout(this._timeout);
+  }
+}
+function at(s, e) {
+  for (const t in e)
+    s[t] && typeof s[t] == "object" && e[t] && typeof e[t] == "object" ? at(s[t], e[t]) : s[t] = e[t];
+}
+function dt(s, e) {
+  for (const t in e)
+    e[t] === null ? delete s[t] : s[t] && typeof s[t] == "object" && e[t] && typeof e[t] == "object" ? dt(s[t], e[t]) : s[t] = e[t];
+}
+class U {
+  static getInstance() {
+    return U._instance === void 0 && (U._instance = new U()), U._instance;
+  }
+  getTransactionState() {
+    const e = [], t = [...this._activeTransactions];
+    if (t.length === 0)
+      return;
+    const n = t.flatMap((i) => i.debugGetUpdatingObservers() ?? []).map((i) => i.observer), r = /* @__PURE__ */ new Set();
+    for (; n.length > 0; ) {
+      const i = n.shift();
+      if (r.has(i))
+        continue;
+      r.add(i);
+      const o = this._getInfo(i, (d) => {
+        r.has(d) || n.push(d);
+      });
+      o && e.push(o);
+    }
+    return { names: t.map((i) => i.getDebugName() ?? "tx"), affected: e };
+  }
+  _getObservableInfo(e) {
+    const t = this._instanceInfos.get(e);
+    if (!t) {
+      pe(new I("No info found"));
+      return;
+    }
+    return t;
+  }
+  _getAutorunInfo(e) {
+    const t = this._instanceInfos.get(e);
+    if (!t) {
+      pe(new I("No info found"));
+      return;
+    }
+    return t;
+  }
+  _getInfo(e, t) {
+    if (e instanceof w) {
+      const n = [...e.debugGetObservers()];
+      for (const c of n)
+        t(c);
+      const r = this._getObservableInfo(e);
+      if (!r)
+        return;
+      const i = e.debugGetState(), o = { name: e.debugName, instanceId: r.instanceId, updateCount: i.updateCount }, d = [...r.changedObservables].map((c) => {
+        var h;
+        return (h = this._instanceInfos.get(c)) == null ? void 0 : h.instanceId;
+      }).filter(Q);
+      if (i.isComputing)
+        return { ...o, type: "observable/derived", state: "updating", changedDependencies: d, initialComputation: !1 };
+      switch (i.state) {
+        case 0:
+          return { ...o, type: "observable/derived", state: "noValue" };
+        case 3:
+          return { ...o, type: "observable/derived", state: "upToDate" };
+        case 2:
+          return { ...o, type: "observable/derived", state: "stale", changedDependencies: d };
+        case 1:
+          return { ...o, type: "observable/derived", state: "possiblyStale" };
+      }
+    } else if (e instanceof se) {
+      const n = this._getAutorunInfo(e);
+      if (!n)
+        return;
+      const r = { name: e.debugName, instanceId: n.instanceId, updateCount: n.updateCount }, i = [...n.changedObservables].map((o) => this._instanceInfos.get(o).instanceId);
+      if (e.debugGetState().isRunning)
+        return { ...r, type: "autorun", state: "updating", changedDependencies: i };
+      switch (e.debugGetState().state) {
+        case 3:
+          return { ...r, type: "autorun", state: "upToDate" };
+        case 2:
+          return { ...r, type: "autorun", state: "stale", changedDependencies: i };
+        case 1:
+          return { ...r, type: "autorun", state: "possiblyStale" };
+      }
+    }
+  }
+  _formatObservable(e) {
+    const t = this._getObservableInfo(e);
+    if (t)
+      return { name: e.debugName, instanceId: t.instanceId };
+  }
+  _formatObserver(e) {
+    var n;
+    if (e instanceof w)
+      return { name: e.toString(), instanceId: (n = this._getObservableInfo(e)) == null ? void 0 : n.instanceId };
+    const t = this._getAutorunInfo(e);
+    if (t)
+      return { name: e.toString(), instanceId: t.instanceId };
+  }
+  constructor() {
+    this._declarationId = 0, this._instanceId = 0, this._declarations = /* @__PURE__ */ new Map(), this._instanceInfos = /* @__PURE__ */ new WeakMap(), this._aliveInstances = /* @__PURE__ */ new Map(), this._activeTransactions = /* @__PURE__ */ new Set(), this._channel = dn("observableDevTools", () => ({
+      notifications: {
+        setDeclarationIdFilter: (e) => {
+        },
+        logObservableValue: (e) => {
+          console.log("logObservableValue", e);
+        },
+        flushUpdates: () => {
+          this._flushUpdates();
+        },
+        resetUpdates: () => {
+          this._pendingChanges = null, this._channel.api.notifications.handleChange(this._fullState, !0);
+        }
+      },
+      requests: {
+        getDeclarations: () => {
+          const e = {};
+          for (const t of this._declarations.values())
+            e[t.id] = t;
+          return { decls: e };
+        },
+        getSummarizedInstances: () => null,
+        getObservableValueInfo: (e) => ({
+          observers: [...this._aliveInstances.get(e).debugGetObservers()].map((n) => this._formatObserver(n)).filter(Q)
+        }),
+        getDerivedInfo: (e) => {
+          const t = this._aliveInstances.get(e);
+          return {
+            dependencies: [...t.debugGetState().dependencies].map((n) => this._formatObservable(n)).filter(Q),
+            observers: [...t.debugGetObservers()].map((n) => this._formatObserver(n)).filter(Q)
+          };
+        },
+        getAutorunInfo: (e) => ({
+          dependencies: [...this._aliveInstances.get(e).debugGetState().dependencies].map((n) => this._formatObservable(n)).filter(Q)
+        }),
+        getTransactionState: () => this.getTransactionState(),
+        setValue: (e, t) => {
+          const n = this._aliveInstances.get(e);
+          if (n instanceof w)
+            n.debugSetValue(t);
+          else if (n instanceof re)
+            n.debugSetValue(t);
+          else if (n instanceof F)
+            n.debugSetValue(t);
+          else
+            throw new I("Observable is not supported");
+          const r = [...n.debugGetObservers()];
+          for (const i of r)
+            i.beginUpdate(n);
+          for (const i of r)
+            i.handleChange(n, void 0);
+          for (const i of r)
+            i.endUpdate(n);
+        },
+        getValue: (e) => {
+          const t = this._aliveInstances.get(e);
+          if (t instanceof w)
+            return k(t.debugGetState().value, 200);
+          if (t instanceof re)
+            return k(t.debugGetState().value, 200);
+        },
+        logValue: (e) => {
+          const t = this._aliveInstances.get(e);
+          if (t && "get" in t)
+            console.log("Logged Value:", t.get());
+          else
+            throw new I("Observable is not supported");
+        },
+        rerun: (e) => {
+          const t = this._aliveInstances.get(e);
+          if (t instanceof w)
+            t.debugRecompute();
+          else if (t instanceof se)
+            t.debugRerun();
+          else
+            throw new I("Observable is not supported");
+        }
+      }
+    })), this._pendingChanges = null, this._changeThrottler = new ln(), this._fullState = {}, this._flushUpdates = () => {
+      this._pendingChanges !== null && (this._channel.api.notifications.handleChange(this._pendingChanges, !1), this._pendingChanges = null);
+    }, T.enable();
+  }
+  _handleChange(e) {
+    dt(this._fullState, e), this._pendingChanges === null ? this._pendingChanges = e : at(this._pendingChanges, e), this._changeThrottler.throttle(this._flushUpdates, 10);
+  }
+  _getDeclarationId(e, t) {
+    if (!t)
+      return -1;
+    let n = this._declarations.get(t.id);
+    return n === void 0 && (n = {
+      id: this._declarationId++,
+      type: e,
+      url: t.fileName,
+      line: t.line,
+      column: t.column
+    }, this._declarations.set(t.id, n), this._handleChange({ decls: { [n.id]: n } })), n.id;
+  }
+  handleObservableCreated(e, t) {
+    const r = {
+      declarationId: this._getDeclarationId("observable/value", t),
+      instanceId: this._instanceId++,
+      listenerCount: 0,
+      lastValue: void 0,
+      updateCount: 0,
+      changedObservables: /* @__PURE__ */ new Set()
+    };
+    this._instanceInfos.set(e, r);
+  }
+  handleOnListenerCountChanged(e, t) {
+    const n = this._getObservableInfo(e);
+    if (n) {
+      if (n.listenerCount === 0 && t > 0) {
+        const r = e instanceof w ? "observable/derived" : "observable/value";
+        this._aliveInstances.set(n.instanceId, e), this._handleChange({
+          instances: {
+            [n.instanceId]: {
+              instanceId: n.instanceId,
+              declarationId: n.declarationId,
+              formattedValue: n.lastValue,
+              type: r,
+              name: e.debugName
+            }
+          }
+        });
+      } else n.listenerCount > 0 && t === 0 && (this._handleChange({
+        instances: { [n.instanceId]: null }
+      }), this._aliveInstances.delete(n.instanceId));
+      n.listenerCount = t;
+    }
+  }
+  handleObservableUpdated(e, t) {
+    if (e instanceof w) {
+      this._handleDerivedRecomputed(e, t);
+      return;
+    }
+    const n = this._getObservableInfo(e);
+    n && t.didChange && (n.lastValue = k(t.newValue, 30), n.listenerCount > 0 && this._handleChange({
+      instances: { [n.instanceId]: { formattedValue: n.lastValue } }
+    }));
+  }
+  handleAutorunCreated(e, t) {
+    const r = {
+      declarationId: this._getDeclarationId("autorun", t),
+      instanceId: this._instanceId++,
+      updateCount: 0,
+      changedObservables: /* @__PURE__ */ new Set()
+    };
+    this._instanceInfos.set(e, r), this._aliveInstances.set(r.instanceId, e), r && this._handleChange({
+      instances: {
+        [r.instanceId]: {
+          instanceId: r.instanceId,
+          declarationId: r.declarationId,
+          runCount: 0,
+          type: "autorun",
+          name: e.debugName
+        }
+      }
+    });
+  }
+  handleAutorunDisposed(e) {
+    const t = this._getAutorunInfo(e);
+    t && (this._handleChange({
+      instances: { [t.instanceId]: null }
+    }), this._instanceInfos.delete(e), this._aliveInstances.delete(t.instanceId));
+  }
+  handleAutorunDependencyChanged(e, t, n) {
+    const r = this._getAutorunInfo(e);
+    r && r.changedObservables.add(t);
+  }
+  handleAutorunStarted(e) {
+  }
+  handleAutorunFinished(e) {
+    const t = this._getAutorunInfo(e);
+    t && (t.changedObservables.clear(), t.updateCount++, this._handleChange({
+      instances: { [t.instanceId]: { runCount: t.updateCount } }
+    }));
+  }
+  handleDerivedDependencyChanged(e, t, n) {
+    const r = this._getObservableInfo(e);
+    r && r.changedObservables.add(t);
+  }
+  _handleDerivedRecomputed(e, t) {
+    const n = this._getObservableInfo(e);
+    if (!n)
+      return;
+    const r = k(t.newValue, 30);
+    n.updateCount++, n.changedObservables.clear(), n.lastValue = r, n.listenerCount > 0 && this._handleChange({
+      instances: { [n.instanceId]: { formattedValue: r, recomputationCount: n.updateCount } }
+    });
+  }
+  handleDerivedCleared(e) {
+    const t = this._getObservableInfo(e);
+    t && (t.lastValue = void 0, t.changedObservables.clear(), t.listenerCount > 0 && this._handleChange({
+      instances: {
+        [t.instanceId]: {
+          formattedValue: void 0
+        }
+      }
+    }));
+  }
+  handleBeginTransaction(e) {
+    this._activeTransactions.add(e);
+  }
+  handleEndTransaction(e) {
+    this._activeTransactions.delete(e);
+  }
+}
+U._instance = void 0;
+function hn(s, e) {
+  const t = (e == null ? void 0 : e.debugNamePostProcessor) ?? ((i) => i), n = O.from(s, t);
+  return n ? ct(n, 0, /* @__PURE__ */ new Set()).trim() : "";
+}
+function ct(s, e, t) {
+  const n = "		".repeat(e), r = [];
+  if (t.has(s.sourceObj))
+    return r.push(`${n}* ${s.type} ${s.name} (already listed)`), r.join(`
+`);
+  if (t.add(s.sourceObj), r.push(`${n}* ${s.type} ${s.name}:`), r.push(`${n}  value: ${k(s.value, 50)}`), r.push(`${n}  state: ${s.state}`), s.dependencies.length > 0) {
+    r.push(`${n}  dependencies:`);
+    for (const o of s.dependencies)
+      r.push(ct(o, e + 1, t));
+  }
+  return r.join(`
+`);
+}
+class O {
+  static from(e, t) {
+    if (e instanceof se) {
+      const n = e.debugGetState();
+      return new O(e, t(e.debugName), "autorun", void 0, n.stateStr, Array.from(n.dependencies).map((r) => O.from(r, t) || O.unknown(r)));
+    } else if (e instanceof w) {
+      const n = e.debugGetState();
+      return new O(e, t(e.debugName), "derived", n.value, n.stateStr, Array.from(n.dependencies).map((r) => O.from(r, t) || O.unknown(r)));
+    } else if (e instanceof re) {
+      const n = e.debugGetState();
+      return new O(e, t(e.debugName), "observableValue", n.value, "upToDate", []);
+    } else if (e instanceof F) {
+      const n = e.debugGetState();
+      return new O(e, t(e.debugName), "fromEvent", n.value, n.hasValue ? "upToDate" : "initial", []);
+    }
+  }
+  static unknown(e) {
+    return new O(e, "(unknown)", "unknown", void 0, "unknown", []);
+  }
+  constructor(e, t, n, r, i, o) {
+    this.sourceObj = e, this.name = t, this.type = n, this.value = r, this.state = i, this.dependencies = o;
+  }
+}
+Gt(hn);
+At(en);
+Xe(U.getInstance());
+class lt {
+  constructor() {
+    l(this, "_fixtures", y(this, /* @__PURE__ */ new Map()));
+    /** Observable root of the fixture tree */
+    l(this, "root", N(this, (e) => {
+      const t = this._fixtures.read(e);
+      return le(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 Fe(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 = le(t), r = Fe(n, e);
+    return r == null ? void 0 : r.component;
+  }
+}
+class Ts {
+  constructor(e, t) {
+    l(this, "sessionId", Math.random().toString(36).slice(2));
+    l(this, "_updateVersion", 0);
+    l(this, "_root");
+    l(this, "_fixtureModules");
+    l(this, "_currentDisposable");
+    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._currentDisposable && (this._currentDisposable.dispose(), this._currentDisposable = 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 r = t.component, i = Dt(r.properties);
+    let o = n;
+    if (r.isolation === "shadow-dom") {
+      const p = n.attachShadow({ mode: "open" });
+      o = document.createElement("div"), p.appendChild(o);
+    }
+    const d = [], c = console.error, h = console.warn;
+    console.error = (...p) => {
+      d.push({ kind: "console", level: "error", message: p.map(String).join(" ") }), c.apply(console, p);
+    }, console.warn = (...p) => {
+      d.push({ kind: "console", level: "warn", message: p.map(String).join(" ") }), h.apply(console, p);
+    };
+    const m = (p) => {
+      var _;
+      d.push({ kind: "exception", message: p.message, stack: (_ = p.error) == null ? void 0 : _.stack });
+    }, v = (p) => {
+      const _ = p.reason, E = _ instanceof Error ? _.message : String(_), R = _ instanceof Error ? _.stack : void 0;
+      d.push({ kind: "exception", message: E, stack: R });
+    };
+    window.addEventListener("error", m), window.addEventListener("unhandledrejection", v);
+    try {
+      const p = r.render(o, i);
+      this._currentDisposable = p && typeof p == "object" && "dispose" in p ? p : void 0;
+    } catch (p) {
+      const _ = p instanceof Error ? p : new Error(String(p));
+      d.push({ kind: "exception", message: _.message, stack: _.stack });
+    } finally {
+      console.error = c, console.warn = h;
+    }
+    return await new Promise((p) => requestAnimationFrame(() => requestAnimationFrame(() => p()))), window.removeEventListener("error", m), window.removeEventListener("unhandledrejection", v), { errors: d };
+  }
+  _buildRegistry() {
+    const e = /* @__PURE__ */ new Map();
+    for (const [t, n] of Object.entries(this._fixtureModules)) {
+      const r = n.default;
+      r && typeof r == "object" && e.set(t, r);
+    }
+    return le(e);
+  }
+  _flattenFixtures(e, t = []) {
+    const n = [];
+    e.type === "component" && n.push({ fixtureId: e.id, fixtureName: e.name, groupPath: t });
+    for (const r of e.children ?? []) {
+      const i = e.id ? [...t, e.name] : t;
+      n.push(...this._flattenFixtures(r, i));
+    }
+    return n;
+  }
+  _findFixtureNode(e, t) {
+    if (e.id === t) return e;
+    for (const n of e.children ?? []) {
+      const r = this._findFixtureNode(n, t);
+      if (r) return r;
+    }
+  }
+  _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 un {
+  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 ge.instance;
+}
+function fn() {
+  return me.instance;
+}
+function pn() {
+  return _e.instance;
+}
+f.const = fn;
+f.obs = pn;
+class ge {
+  create(e) {
+    const t = N((n) => e(n));
+    return { read: (n) => t };
+  }
+}
+ge.instance = new ge();
+class me {
+  create(e) {
+    const t = N((n) => e(n));
+    return { read: (n) => t.read(n) };
+  }
+}
+me.instance = new me();
+class _e {
+  create(e) {
+    const t = N((n) => {
+      const r = e(n);
+      return gn(r) ? r.read(n) : r;
+    });
+    return { read: (n) => t };
+  }
+}
+_e.instance = new _e();
+function gn(s) {
+  return typeof s == "object" && s !== null && "read" in s;
+}
+function K(s, e) {
+  return Object.fromEntries(Object.entries(s).map(([t, n]) => [t, e(n, t)]));
+}
+const de = Symbol("ViewModelContext");
+class mn {
+  constructor(e) {
+    this._store = new Y(), this.props = e;
+  }
+  dispose() {
+    this._store.dispose();
+  }
+}
+function _n(s) {
+  return s[de] || (s[de] = Ke(void 0)), s[de];
+}
+function M(s = {}) {
+  var e;
+  return e = class extends mn {
+  }, e._props = s, e;
+}
+let ve = 0;
+const vn = new un((s) => {
+  for (const e of s)
+    e.rendered = !1;
+  if (ve > 0) {
+    const e = s.find((t) => t.isRendering);
+    e.itemsToRender = s;
+  } else
+    Je(() => {
+      for (const e of s)
+        e.rendered || e.forceUpdate();
+    });
+});
+let bn = 0;
+class yn {
+  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 = () => {
+      Je(() => {
+        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 = y(this, e), this._render = this.renderFactory(this._obsProps, () => this.contextValues), this.rendering = N(this, this._render), this._disposable = vn.addDependency(this.rendering, this));
+  }
+}
+function Te(s, e, t) {
+  const n = (o) => o + 1, r = () => new yn(s + ++bn, e), i = function(o) {
+    const d = Ot(n, 0)[1], c = Tt(r)[0];
+    for (const h of t ?? [])
+      c.contextValues.set(h, Rt(h));
+    if (De(c.cleanupEffect, []), De(c.handleAfterRender), c.isRendering)
+      throw new Error("Component is already rendering");
+    c.isRendering = !0, ve++;
+    try {
+      c.forceUpdate = d, c.updateProps(o);
+      const h = c.rendering.get();
+      return c.rendered = !0, h;
+    } finally {
+      c.isRendering = !1, ve--;
+    }
+  };
+  return i.displayName = s, i;
+}
+Te("ObsView", (s) => (e) => s.read(e).children(e));
+function D(s, e) {
+  return Te("view", (t) => {
+    const n = K(s, (r, i) => r.create((o) => t.read(o)[i], void 0));
+    return (r) => {
+      const i = K(n, (o) => o.read(r));
+      return e(r, i);
+    };
+  });
+}
+function xn(s) {
+  const e = [];
+  for (const t of Object.values(s)) {
+    const n = t._requiredContext;
+    n && !e.includes(n) && e.push(n);
+  }
+  return e;
+}
+function B(s, e, t) {
+  const n = typeof e == "function" ? {} : e, r = typeof e == "function" ? e : t, i = "_props" in s ? s._props : {}, o = xn({ ...i, ...n }), d = _n(s), c = [...o, d];
+  return Te("viewWithModel", (h, m) => {
+    const v = m(), p = v.get(d), _ = "_props" in s ? K(s._props, (C, z) => C.create((H) => h.read(H)[z], v.get(C._requiredContext))) : {}, E = p ? { read: () => p, dispose: () => {
+    } } : Jt((C) => {
+      const z = K(_, (H) => H.read(C));
+      return new s(z);
+    }), R = K(n, (C, z) => C.create((H) => h.read(H)[z], v.get(C._requiredContext)));
+    return (C) => {
+      const z = E.read(C), H = K(R, (Ct) => Ct.read(C));
+      return r(C, z, H);
+    };
+  }, c.length > 0 ? c : void 0);
+}
+D({ value: f.obs() }, (s, e) => e.value.read(s));
+Ke(null);
+function ht(s) {
+  var e;
+  return {
+    id: s.id,
+    name: s.name,
+    type: s.type,
+    children: (e = s.children) == null ? void 0 : e.map(ht),
+    component: s.component
+  };
+}
+function ee(s, e) {
+  const {
+    storageKey: t,
+    defaultValue: n,
+    serialize: r = JSON.stringify,
+    deserialize: i = JSON.parse
+  } = e;
+  let o = n;
+  try {
+    const h = localStorage.getItem(t);
+    h !== null && (o = i(h));
+  } catch {
+  }
+  const d = y(s, o), c = d.set.bind(d);
+  return d.set = (h, m) => {
+    try {
+      localStorage.setItem(t, r(h));
+    } catch {
+    }
+    c(h, m);
+  }, d;
+}
+class Cn extends M({
+  registry: f.const(),
+  daemonModel: f.const()
+}) {
+  constructor() {
+    super(...arguments);
+    l(this, "leftSidebarVisible", ee(this, {
+      storageKey: "component-explorer:leftSidebarVisible",
+      defaultValue: !0
+    }));
+    l(this, "rightSidebarVisible", ee(this, {
+      storageKey: "component-explorer:rightSidebarVisible",
+      defaultValue: !0
+    }));
+    l(this, "isDarkTheme", ee(this, {
+      storageKey: "component-explorer:isDarkTheme",
+      defaultValue: !0
+    }));
+    l(this, "selectedNodeId", ee(this, {
+      storageKey: "component-explorer:selectedNodeId",
+      defaultValue: void 0
+    }));
+    l(this, "expandedNodeIds", y(this, /* @__PURE__ */ new Set()));
+    l(this, "viewMode", ee(this, {
+      storageKey: "component-explorer:viewMode",
+      defaultValue: "session"
+    }));
+    /** The explorer's tree derived from the registry */
+    l(this, "tree", N(this, (t) => {
+      const n = this.props.registry.root.read(t);
+      return ht(n);
+    }));
+    l(this, "selectedNode", N(this, (t) => {
+      const n = this.selectedNodeId.read(t);
+      if (!n) return;
+      const r = this.tree.read(t);
+      return this._findNode(r.children ?? [], n);
+    }));
+    /** List of preview rows to render based on current selection and view mode */
+    l(this, "selectedFixtures", N(this, (t) => {
+      const n = this.selectedNode.read(t);
+      return n ? this.viewMode.read(t) === "diff" && this.daemonAvailable ? 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 r = n.getSessionExplorerUrl(t);
+      r && (window.location.href = r);
+    });
+    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(), r = new Set(n);
+      r.has(t) ? r.delete(t) : r.add(t), this.expandedNodeIds.set(r, void 0);
+    });
+  }
+  get daemonAvailable() {
+    return this.props.daemonModel !== void 0;
+  }
+  get daemon() {
+    return this.props.daemonModel;
+  }
+  isNodeExpanded(t, n) {
+    return this.expandedNodeIds.read(n).has(t);
+  }
+  _findNode(t, n) {
+    for (const r of t) {
+      if (r.id === n) return r;
+      if (r.children) {
+        const i = this._findNode(r.children, n);
+        if (i) return i;
+      }
+    }
+  }
+  _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 i = [];
+      for (const o of t.children ?? [])
+        o.type === "component" && o.component && i.push({
+          id: o.id,
+          name: o.name,
+          path: `${n} / ${o.name}`,
+          component: o.component
+        });
+      return i.length > 0 ? [{
+        type: "variants",
+        id: t.id,
+        name: t.name,
+        path: n,
+        fixtures: i
+      }] : [];
+    }
+    const r = [];
+    for (const i of t.children ?? []) {
+      const o = n ? `${n} / ${i.name}` : i.name;
+      r.push(...this._collectPreviewRows(i, o));
+    }
+    return r;
+  }
+  /**
+   * 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 i = [];
+      for (const o of t.children ?? [])
+        o.type === "component" && i.push({
+          fixtureId: o.id,
+          name: o.name,
+          path: `${n} / ${o.name}`
+        });
+      return i.length > 0 ? [{
+        type: "screenshot-comparison",
+        id: t.id,
+        name: t.name,
+        path: n,
+        items: i
+      }] : [];
+    }
+    const r = [];
+    for (const i of t.children ?? []) {
+      const o = n ? `${n} / ${i.name}` : i.name;
+      r.push(...this._collectDiffRows(i, o));
+    }
+    return r;
+  }
+}
+const u = {
+  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 Re(...s) {
+  return Object.assign({}, ...s.filter(Boolean));
+}
+class wn extends M({
+  active: f()
+}) {
+  constructor() {
+    super(...arguments);
+    l(this, "isHovered", y(this, !1));
+    l(this, "setHovered", (t) => {
+      this.isHovered.set(t, void 0);
+    });
+  }
+  get active() {
+    return this.props.active;
+  }
+}
+const ce = B(
+  wn,
+  {
+    onClick: f.const(),
+    title: f.const(),
+    children: f.const()
+  },
+  (s, e, t) => {
+    const n = e.isHovered.read(s), r = e.active.read(s), i = Re(
+      u.titleBarButton,
+      n && !r && u.titleBarButtonHover,
+      r && u.titleBarButtonActive
+    );
+    return /* @__PURE__ */ a(
+      "button",
+      {
+        style: i,
+        onClick: t.onClick,
+        title: t.title,
+        onMouseEnter: () => e.setHovered(!0),
+        onMouseLeave: () => e.setHovered(!1),
+        children: t.children
+      }
+    );
+  }
+), Sn = ({ style: s }) => /* @__PURE__ */ a("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "currentColor", style: s, 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" }) }), In = ({ style: s }) => /* @__PURE__ */ a("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "currentColor", style: s, 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)" }) }), On = ({ style: s }) => /* @__PURE__ */ a("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "currentColor", style: s, 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" }) }), Tn = ({ style: s }) => /* @__PURE__ */ a("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "currentColor", style: s, 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" }) }), Rn = () => /* @__PURE__ */ a("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "currentColor", children: /* @__PURE__ */ a("path", { d: "M2 2v12h12V2H2zm11 11H6V3h7v10zM3 3h2v10H3V3z" }) }), Vn = () => /* @__PURE__ */ a("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "currentColor", children: /* @__PURE__ */ a("path", { d: "M2 2v12h12V2H2zm6 11V3h5v10H8zM3 3h4v10H3V3z" }) }), kn = () => /* @__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" }) }), Nn = () => /* @__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" }) }), Dn = D(
+  { model: f.const() },
+  (s, e) => {
+    var d, c;
+    const t = e.model, n = t.viewMode.read(s), r = ((d = t.daemon) == null ? void 0 : d.sessions.read(s)) ?? [], i = (c = t.daemon) == null ? void 0 : c.sessionName, o = r.filter((h) => h.name !== i);
+    return /* @__PURE__ */ g("div", { style: J.container, children: [
+      /* @__PURE__ */ g("div", { style: J.segmentedControl, children: [
+        /* @__PURE__ */ a($e, { label: "Live", mode: "session", active: n === "session", onClick: () => t.setViewMode("session") }),
+        /* @__PURE__ */ a($e, { label: "Diff", mode: "diff", active: n === "diff", onClick: () => t.setViewMode("diff") })
+      ] }),
+      o.length > 0 && /* @__PURE__ */ a("div", { style: J.sessionLinks, children: o.map((h) => /* @__PURE__ */ g(
+        "button",
+        {
+          style: J.sessionLink,
+          onClick: () => t.navigateToSession(h.name),
+          title: `Switch to ${h.name} session`,
+          children: [
+            "→ ",
+            h.name
+          ]
+        },
+        h.name
+      )) })
+    ] });
+  }
+);
+function $e({ label: s, mode: e, active: t, onClick: n }) {
+  return /* @__PURE__ */ a(
+    "button",
+    {
+      style: t ? J.segmentActive : J.segment,
+      onClick: n,
+      children: s
+    }
+  );
+}
+const En = D(
+  {
+    model: f.const()
+  },
+  (s, e) => {
+    const t = e.model, n = t.leftSidebarVisible.read(s), r = t.rightSidebarVisible.read(s), i = t.isDarkTheme.read(s), o = t.selectedNode.read(s);
+    return /* @__PURE__ */ g("div", { style: u.titleBar, children: [
+      /* @__PURE__ */ a("div", { style: u.titleBarSection, children: /* @__PURE__ */ a(
+        ce,
+        {
+          active: n,
+          onClick: t.toggleLeftSidebar,
+          title: "Toggle left sidebar",
+          children: /* @__PURE__ */ a(Rn, {})
+        }
+      ) }),
+      /* @__PURE__ */ g("div", { style: u.titleBarCenter, children: [
+        t.daemonAvailable && /* @__PURE__ */ a(Dn, { model: t }),
+        o ? /* @__PURE__ */ g(ye, { children: [
+          /* @__PURE__ */ a("span", { style: { color: "var(--vscode-textLink-foreground)" }, children: "<" }),
+          /* @__PURE__ */ a("span", { children: o.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: u.titleBarSection, children: [
+        /* @__PURE__ */ a(
+          ce,
+          {
+            active: !1,
+            onClick: t.toggleTheme,
+            title: i ? "Switch to light theme" : "Switch to dark theme",
+            children: i ? /* @__PURE__ */ a(kn, {}) : /* @__PURE__ */ a(Nn, {})
+          }
+        ),
+        /* @__PURE__ */ a(
+          ce,
+          {
+            active: r,
+            onClick: t.toggleRightSidebar,
+            title: "Toggle right sidebar",
+            children: /* @__PURE__ */ a(Vn, {})
+          }
+        )
+      ] })
+    ] });
+  }
+), J = {
+  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"
+  }
+}, ut = D(
+  {
+    model: f.const(),
+    nodes: f.const(),
+    depth: f.const()
+  },
+  (s, e) => /* @__PURE__ */ a(ye, { children: e.nodes.map((t) => /* @__PURE__ */ a(An, { model: e.model, node: t, depth: e.depth }, t.id)) })
+);
+class Fn extends M({
+  model: f.const(),
+  node: f.const(),
+  depth: f.const()
+}) {
+  constructor() {
+    super(...arguments);
+    l(this, "isHovered", y(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 An = B(Fn, {}, (s, e) => {
+  const t = e.explorerModel, n = e.treeNode, r = e.treeDepth, i = !!(n.children && n.children.length > 0), o = i ? t.isNodeExpanded(n.id, s) : !1, c = t.selectedNodeId.read(s) === n.id, h = e.isHovered.read(s), m = Re(
+    u.treeItem,
+    { paddingLeft: `${8 + r * 12}px` },
+    c && u.treeItemSelected,
+    !c && h && u.treeItemHover
+  );
+  return /* @__PURE__ */ g(ye, { children: [
+    /* @__PURE__ */ g(
+      "div",
+      {
+        style: m,
+        onClick: e.handleClick,
+        onDoubleClick: e.handleDoubleClick,
+        onMouseEnter: () => e.setHovered(!0),
+        onMouseLeave: () => e.setHovered(!1),
+        children: [
+          i ? /* @__PURE__ */ a("div", { style: u.treeItemChevron, onClick: e.handleChevronClick, children: o ? /* @__PURE__ */ a(In, {}) : /* @__PURE__ */ a(Sn, {}) }) : /* @__PURE__ */ a("div", { style: u.treeItemChevronPlaceholder }),
+          /* @__PURE__ */ a("div", { style: u.treeItemIcon, children: n.type === "folder" ? /* @__PURE__ */ a(Tn, { style: { color: "var(--vscode-symbolIcon-folderForeground)" } }) : /* @__PURE__ */ a(On, { style: { color: "#deb45b" } }) }),
+          /* @__PURE__ */ a("span", { style: u.treeItemLabel, children: n.name }),
+          i && /* @__PURE__ */ a("span", { style: u.treeItemCount, children: n.children.length })
+        ]
+      }
+    ),
+    i && o && /* @__PURE__ */ a(ut, { model: t, nodes: n.children, depth: r + 1 })
+  ] });
+}), Mn = D(
+  {
+    model: f.const()
+  },
+  (s, e) => {
+    const t = e.model.tree.read(s);
+    return /* @__PURE__ */ g("div", { style: u.sidebar, children: [
+      /* @__PURE__ */ a("div", { style: u.sidebarHeader, children: "Explorer" }),
+      /* @__PURE__ */ a("div", { style: u.sidebarContent, children: /* @__PURE__ */ a(ut, { model: e.model, nodes: t.children ?? [], depth: 0 }) })
+    ] });
+  }
+);
+class Bn extends M({}) {
+  constructor() {
+    super(...arguments);
+    l(this, "checked", y(this, !1));
+    l(this, "toggle", () => {
+      this.checked.set(!this.checked.get(), void 0);
+    });
+  }
+}
+const zn = B(Bn, {}, (s, e) => {
+  const t = e.checked.read(s), 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)"
+  }, r = {
+    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: r }) });
+}), Hn = D(
+  {
+    node: f.const()
+  },
+  (s, 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: u.propertiesPanel, children: [
+    /* @__PURE__ */ g("div", { style: u.propertyRow, children: [
+      /* @__PURE__ */ g("div", { style: u.propertyLabel, children: [
+        "children",
+        /* @__PURE__ */ a("span", { style: { color: "var(--vscode-descriptionForeground)" }, children: " : string" })
+      ] }),
+      /* @__PURE__ */ a(
+        "input",
+        {
+          type: "text",
+          style: u.propertyInput,
+          defaultValue: "Click me",
+          placeholder: "Enter text..."
+        }
+      ),
+      /* @__PURE__ */ a("div", { style: u.propertyDescription, children: "Button text content" })
+    ] }),
+    /* @__PURE__ */ g("div", { style: u.propertyRow, children: [
+      /* @__PURE__ */ g("div", { style: u.propertyLabel, children: [
+        "variant",
+        /* @__PURE__ */ a("span", { style: { color: "var(--vscode-descriptionForeground)" }, children: " : select" })
+      ] }),
+      /* @__PURE__ */ g("select", { style: u.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: u.propertyDescription, children: "Visual style variant" })
+    ] }),
+    /* @__PURE__ */ g("div", { style: u.propertyRow, children: [
+      /* @__PURE__ */ g("div", { style: u.propertyLabel, children: [
+        "size",
+        /* @__PURE__ */ a("span", { style: { color: "var(--vscode-descriptionForeground)" }, children: " : select" })
+      ] }),
+      /* @__PURE__ */ g("select", { style: u.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: u.propertyDescription, children: "Button size" })
+    ] }),
+    /* @__PURE__ */ g("div", { style: u.propertyRow, children: [
+      /* @__PURE__ */ g("div", { style: u.propertyLabel, children: [
+        "disabled",
+        /* @__PURE__ */ a("span", { style: { color: "var(--vscode-descriptionForeground)" }, children: " : boolean" })
+      ] }),
+      /* @__PURE__ */ a(zn, {}),
+      /* @__PURE__ */ a("div", { style: u.propertyDescription, children: "Disable the button" })
+    ] })
+  ] })
+), Ln = D(
+  {
+    selectedNode: f.const()
+  },
+  (s, e) => /* @__PURE__ */ g("div", { style: Re(u.sidebar, u.sidebarRight), children: [
+    /* @__PURE__ */ g("div", { style: u.sidebarHeader, children: [
+      /* @__PURE__ */ a("span", { style: { marginRight: "6px", color: "var(--vscode-textLink-foreground)" }, children: "</>" }),
+      "Props"
+    ] }),
+    /* @__PURE__ */ a("div", { style: u.sidebarContent, children: e.selectedNode ? /* @__PURE__ */ a(Hn, { node: e.selectedNode }) : /* @__PURE__ */ a("div", { style: { padding: "12px", color: "var(--vscode-descriptionForeground)", fontSize: "12px" }, children: "Select a component to view its properties" }) })
+  ] })
+);
+class $n extends M({
+  fixture: f.const(),
+  compact: f.const()
+}) {
+  constructor() {
+    super(...arguments);
+    l(this, "_containerRef", null);
+    l(this, "_shadowRoot", null);
+    l(this, "_renderContainer", null);
+    l(this, "_disposable", null);
+    l(this, "_resizeObserver", null);
+    l(this, "measuredWidth", y(this, void 0));
+    l(this, "measuredHeight", y(this, void 0));
+    l(this, "setContainerRef", (t) => {
+      if (t === this._containerRef || (this._cleanup(), this._containerRef = t, !t)) return;
+      const n = this.fixture.component;
+      n.isolation === "shadow-dom" ? this._renderInShadowDom(t, n) : this._renderDirect(t, n);
+      const r = this._renderContainer ?? t;
+      this._resizeObserver = new ResizeObserver((i) => {
+        for (const o of i) {
+          const { width: d, height: c } = o.contentRect;
+          c > 0 && (this.measuredWidth.set(Math.round(d), void 0), this.measuredHeight.set(Math.round(c), void 0));
+        }
+      }), this._resizeObserver.observe(r);
+    });
+  }
+  get fixture() {
+    return this.props.fixture;
+  }
+  get compact() {
+    return this.props.compact ?? !1;
+  }
+  _renderInShadowDom(t, n) {
+    if (t.shadowRoot) {
+      for (this._shadowRoot = t.shadowRoot; this._shadowRoot.firstChild; )
+        this._shadowRoot.removeChild(this._shadowRoot.firstChild);
+      this._shadowRoot.adoptedStyleSheets = [];
+    } else
+      this._shadowRoot = t.attachShadow({ mode: "open" });
+    if (n.styles)
+      for (const o of n.styles)
+        if (o.type === "css") {
+          const d = document.createElement("style");
+          d.textContent = o.content, this._shadowRoot.appendChild(d);
+        } else if (o.type === "url") {
+          const d = document.createElement("link");
+          d.rel = "stylesheet", d.href = o.href, this._shadowRoot.appendChild(d);
+        } else o.type === "adopted" && (this._shadowRoot.adoptedStyleSheets = [
+          ...this._shadowRoot.adoptedStyleSheets,
+          o.sheet
+        ]);
+    const r = document.createElement("div");
+    r.style.display = "inline-block", this._renderContainer = r, this._shadowRoot.appendChild(r);
+    const i = this._getDefaultProps(n);
+    this._disposable = n.render(r, i);
+  }
+  _renderDirect(t, n) {
+    this._renderContainer = t;
+    const r = this._getDefaultProps(n);
+    this._disposable = n.render(t, r);
+  }
+  _getDefaultProps(t) {
+    const n = {};
+    for (const r of t.properties)
+      n[r.name] = r.defaultValue;
+    return n;
+  }
+  _cleanup() {
+    var t;
+    this._disposable && (typeof this._disposable == "function" ? this._disposable() : typeof this._disposable.dispose == "function" && this._disposable.dispose()), this._disposable = null, (t = this._resizeObserver) == null || t.disconnect(), this._resizeObserver = null, this._shadowRoot = null, this._renderContainer = null;
+  }
+  dispose() {
+    this._cleanup();
+  }
+}
+const ft = B(
+  $n,
+  {},
+  (s, e) => {
+    const t = e.fixture, n = t.component, r = n.displayMode, i = e.measuredWidth.read(s), o = e.measuredHeight.read(s), d = e.compact;
+    let c;
+    if (r.type === "page") {
+      const p = r.viewports[0], _ = Nt(p);
+      c = {
+        width: _.width,
+        height: _.height,
+        overflow: "auto"
+      };
+    } else
+      c = {
+        display: "inline-block"
+      };
+    const h = i && o ? `${i} × ${o}` : "", m = d ? q.wrapperCompact : q.wrapper, v = d ? q.nameCompact : q.name;
+    return /* @__PURE__ */ g("div", { style: m, children: [
+      /* @__PURE__ */ g("div", { style: q.labelRow, children: [
+        /* @__PURE__ */ a("span", { style: v, children: t.name }),
+        !d && h && /* @__PURE__ */ a("span", { style: q.dimensions, children: h })
+      ] }),
+      /* @__PURE__ */ a("div", { style: Gn(n.background), children: /* @__PURE__ */ a("div", { ref: e.setContainerRef, style: c }) })
+    ] });
+  }
+), W = 8;
+function pt(s, 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 jn = {
+  backgroundColor: "#ffffff",
+  backgroundImage: pt("#ffffff", "#e5e5e5")
+}, Un = {
+  backgroundColor: "#1e1e1e",
+  backgroundImage: pt("#1e1e1e", "#2d2d2d")
+}, Pn = {
+  display: "inline-block",
+  padding: "12px",
+  borderRadius: "4px",
+  backgroundSize: `${W * 2}px ${W * 2}px`,
+  backgroundPosition: `0 0, 0 ${W}px, ${W}px -${W}px, -${W}px 0`,
+  boxShadow: "0 1px 3px rgba(0,0,0,0.12), 0 1px 2px rgba(0,0,0,0.08)"
+};
+function Gn(s) {
+  const e = s === "dark" ? Un : jn;
+  return {
+    ...Pn,
+    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 Wn extends M({
+  fixtureId: f.const(),
+  sessionName: f.const(),
+  daemon: f.const()
+}) {
+  constructor(t) {
+    super(t);
+    l(this, "screenshot", y(this, { status: "idle" }));
+    l(this, "_fetchVersion", 0);
+    this._store.add(st((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 je = B(
+  Wn,
+  {},
+  (s, e) => {
+    const t = e.screenshot.read(s);
+    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 qn extends M({
+  fixtureId: f.const(),
+  daemon: f.const(),
+  baselineSession: f.const(),
+  currentSession: f.const()
+}) {
+  constructor(t) {
+    super(t);
+    l(this, "comparisonStatus", y(this, { status: "loading" }));
+    this._store.add(st((n) => {
+      const r = this.props.daemon.sourceTreeIds.read(n), i = r.get(this.props.baselineSession), o = r.get(this.props.currentSession);
+      i && o && 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 Kn = B(
+  qn,
+  {},
+  (s, e) => {
+    const t = e.comparisonStatus.read(s), n = t.status === "loading" ? /* @__PURE__ */ a("span", { style: x.badgeLoading, children: "comparing..." }) : t.status === "error" ? /* @__PURE__ */ a("span", { style: x.badgeError, children: "error" }) : t.match ? /* @__PURE__ */ a("span", { style: x.badgeMatch, children: "✓ match" }) : /* @__PURE__ */ a("span", { style: x.badgeChanged, children: "● changed" });
+    return /* @__PURE__ */ g("div", { style: x.fixtureRow, children: [
+      /* @__PURE__ */ g("div", { style: x.fixtureLabel, children: [
+        /* @__PURE__ */ a("span", { style: x.fixtureName, children: e.fixtureId }),
+        n
+      ] }),
+      /* @__PURE__ */ g("div", { style: x.sideBySide, children: [
+        /* @__PURE__ */ g("div", { style: x.screenshotColumn, children: [
+          /* @__PURE__ */ a("span", { style: x.columnLabel, children: "Current" }),
+          /* @__PURE__ */ a(
+            je,
+            {
+              fixtureId: e.fixtureId,
+              sessionName: e.currentSession,
+              daemon: e.daemon
+            }
+          )
+        ] }),
+        /* @__PURE__ */ g("div", { style: x.screenshotColumn, children: [
+          /* @__PURE__ */ a("span", { style: x.columnLabel, children: "Baseline" }),
+          /* @__PURE__ */ a(
+            je,
+            {
+              fixtureId: e.fixtureId,
+              sessionName: e.baselineSession,
+              daemon: e.daemon
+            }
+          )
+        ] })
+      ] })
+    ] });
+  }
+), Jn = D(
+  {
+    name: f.const(),
+    path: f.const(),
+    items: f.const(),
+    daemon: f.const(),
+    baselineSession: f.const(),
+    currentSession: f.const()
+  },
+  (s, e) => /* @__PURE__ */ g("div", { children: [
+    /* @__PURE__ */ a("div", { style: x.groupHeader, children: /* @__PURE__ */ a("span", { style: x.groupTitle, children: e.path }) }),
+    /* @__PURE__ */ a("div", { style: x.groupContent, children: e.items.map((t) => /* @__PURE__ */ a(
+      Kn,
+      {
+        fixtureId: t.fixtureId,
+        daemon: e.daemon,
+        baselineSession: e.baselineSession,
+        currentSession: e.currentSession
+      },
+      t.fixtureId
+    )) })
+  ] })
+), x = {
+  groupHeader: {
+    marginBottom: 12
+  },
+  groupTitle: {
+    fontSize: 13,
+    fontWeight: 500,
+    color: "var(--vscode-foreground)"
+  },
+  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
+  }
+}, gt = "component-explorer:fixtureHeights", Ue = 500;
+let V = null;
+function mt() {
+  if (V !== null) return V;
+  try {
+    const s = localStorage.getItem(gt);
+    if (s)
+      return V = JSON.parse(s), V;
+  } catch {
+  }
+  return V = {}, V;
+}
+function Zn() {
+  if (V !== null)
+    try {
+      const s = Object.entries(V);
+      s.length > Ue && (V = Object.fromEntries(s.slice(-Ue))), localStorage.setItem(gt, JSON.stringify(V));
+    } catch {
+    }
+}
+function Xn(s, e) {
+  const t = mt();
+  t[s] = e, Zn();
+}
+function Yn() {
+  return new Map(Object.entries(mt()));
+}
+const Qn = 280, es = 32, oe = 32, Pe = 400, _t = "component-explorer:scrollAnchors", Ge = 100;
+function vt() {
+  try {
+    const s = localStorage.getItem(_t);
+    if (s) return JSON.parse(s);
+  } catch {
+  }
+  return {};
+}
+function ts(s, e) {
+  try {
+    const t = vt();
+    t[s] = e;
+    const n = Object.entries(t), r = n.length > Ge ? Object.fromEntries(n.slice(-Ge)) : t;
+    localStorage.setItem(_t, JSON.stringify(r));
+  } catch {
+  }
+}
+function ns(s) {
+  return vt()[s];
+}
+function bt(s) {
+  return s.type === "single" ? s.fixture.id : s.id;
+}
+function ss(s, e) {
+  const t = new Array(s.length);
+  let n = oe;
+  for (let r = 0; r < s.length; r++) {
+    const i = e.get(bt(s[r])) ?? Qn;
+    t[r] = { top: n, height: i }, n += i + es;
+  }
+  return t;
+}
+function rs(s) {
+  if (s.length === 0) return 0;
+  const e = s[s.length - 1];
+  return e.top + e.height + oe;
+}
+function yt(s, e) {
+  let t = 0, n = s.length;
+  for (; t < n; ) {
+    const r = t + n >> 1;
+    s[r].top + s[r].height < e ? t = r + 1 : n = r;
+  }
+  return t;
+}
+function is(s, e, t) {
+  if (s.length === 0) return { start: 0, end: 0 };
+  const n = yt(s, e - Pe);
+  let r = n;
+  const i = e + t + Pe;
+  for (; r < s.length && s[r].top < i; )
+    r++;
+  return { start: n, end: r };
+}
+function We(s, e) {
+  if (s.length === 0) return;
+  const t = yt(s, e), n = Math.min(t, s.length - 1);
+  return {
+    rowIndex: n,
+    offsetFromViewport: s[n].top - e
+  };
+}
+function qe(s, e) {
+  return e.rowIndex >= s.length ? 0 : s[e.rowIndex].top - e.offsetFromViewport;
+}
+class os extends M({
+  model: f.const()
+}) {
+  constructor() {
+    super(...arguments);
+    l(this, "_rowHeights", y(this, Yn()));
+    l(this, "_scrollTop", y(this, 0));
+    l(this, "_viewportHeight", y(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", N(this, (t) => {
+      const n = this.explorerModel.selectedFixtures.read(t), r = this._rowHeights.read(t);
+      return ss(n, r);
+    }));
+    l(this, "visibleRowRange", N(this, (t) => {
+      const n = this.layout.read(t), r = this._scrollTop.read(t), i = this._viewportHeight.read(t);
+      return is(n, r, i);
+    }));
+    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), this._viewportResizeObserver = new ResizeObserver(([r]) => {
+        this._viewportHeight.set(Math.round(r.contentRect.height), void 0);
+      }), this._viewportResizeObserver.observe(t), this._restoreScrollPosition());
+    });
+    l(this, "_handleScroll", () => {
+      this._scrollContainerRef && (this._scrollTop.set(this._scrollContainerRef.scrollTop, void 0), !(this._suppressScrollHandler || !this._currentNodeId) && (this._scrollSaveTimeout && clearTimeout(this._scrollSaveTimeout), this._scrollSaveTimeout = setTimeout(() => {
+        if (!this._currentNodeId) return;
+        const t = this.layout.get(), n = We(t, this._scrollTop.get());
+        n && ts(this._currentNodeId, n);
+      }, 150)));
+    });
+    l(this, "observeRowElement", (t, n) => {
+      t && (this._resizeObserver || (this._resizeObserver = new ResizeObserver((r) => {
+        const i = this._rowHeights.get();
+        let o;
+        for (const d of r) {
+          const c = d.target.getAttribute("data-row-id");
+          if (!c) continue;
+          const h = Math.round(d.contentRect.height);
+          h > 0 && i.get(c) !== h && (o || (o = new Map(i)), o.set(c, h), Xn(c, h));
+        }
+        if (o) {
+          const d = this.layout.get(), c = We(d, this._scrollTop.get());
+          if (this._rowHeights.set(o, void 0), c && this._scrollContainerRef) {
+            const h = this.layout.get(), m = qe(h, c);
+            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;
+  }
+  updateForSelection(t) {
+    this._currentNodeId !== t && (this._currentNodeId = t, this._restoreScrollPosition());
+  }
+  _restoreScrollPosition() {
+    if (!this._scrollContainerRef || !this._currentNodeId) return;
+    const t = ns(this._currentNodeId);
+    if (!t) return;
+    const n = this.layout.get(), r = qe(n, t);
+    this._suppressScrollHandler = !0, this._scrollContainerRef.scrollTop = r, this._scrollTop.set(r, 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 as = B(
+  os,
+  {},
+  (s, e) => {
+    const t = e.explorerModel.selectedFixtures.read(s), n = e.explorerModel.selectedNodeId.read(s), r = e.layout.read(s), { start: i, end: o } = e.visibleRowRange.read(s);
+    if (e.updateForSelection(n), t.length === 0)
+      return /* @__PURE__ */ a("div", { style: Z.emptyState, children: /* @__PURE__ */ a("span", { style: Z.emptyText, children: "Select a component or folder to preview" }) });
+    const d = rs(r);
+    return /* @__PURE__ */ a("div", { ref: e.setScrollContainerRef, style: Z.scrollContainer, children: /* @__PURE__ */ a("div", { style: { position: "relative", height: d }, children: t.slice(i, o).map((c, h) => {
+      const m = i + h, { top: v } = r[m], p = bt(c);
+      return /* @__PURE__ */ a(
+        "div",
+        {
+          ref: (_) => e.observeRowElement(_, p),
+          style: { position: "absolute", top: v, left: oe, right: oe },
+          children: c.type === "single" ? /* @__PURE__ */ a(ft, { fixture: c.fixture, compact: !1 }) : c.type === "variants" ? /* @__PURE__ */ a(ds, { row: c }) : c.type === "screenshot-comparison" && e.explorerModel.daemon ? /* @__PURE__ */ a(
+            Jn,
+            {
+              name: c.name,
+              path: c.path,
+              items: c.items,
+              daemon: e.explorerModel.daemon,
+              baselineSession: "baseline",
+              currentSession: "current"
+            }
+          ) : null
+        },
+        p
+      );
+    }) }) });
+  }
+), ds = D(
+  { row: f.const() },
+  (s, e) => {
+    const t = e.row;
+    return /* @__PURE__ */ g("div", { children: [
+      /* @__PURE__ */ a("div", { style: Z.variantsHeader, children: /* @__PURE__ */ a("span", { style: Z.variantsTitle, children: t.path }) }),
+      /* @__PURE__ */ a("div", { style: Z.variantsContent, children: t.fixtures.map((n) => /* @__PURE__ */ a(ft, { fixture: n, compact: !0 }, n.id)) })
+    ] });
+  }
+), Z = {
+  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"
+  },
+  variantsHeader: {
+    marginBottom: "12px"
+  },
+  variantsTitle: {
+    fontSize: "13px",
+    fontWeight: 500,
+    color: "var(--vscode-foreground)"
+  },
+  variantsContent: {
+    display: "flex",
+    flexDirection: "row",
+    flexWrap: "wrap",
+    gap: "16px"
+  }
+}, xt = B(
+  Cn,
+  { daemonModel: f.const() },
+  (s, e) => {
+    const t = e.leftSidebarVisible.read(s), n = e.rightSidebarVisible.read(s), r = e.isDarkTheme.read(s), i = e.selectedNode.read(s);
+    return /* @__PURE__ */ g("div", { className: r ? "vscode-theme default-dark-plus" : "vscode-theme default-light-plus", style: u.container, children: [
+      t && /* @__PURE__ */ a(Mn, { model: e }),
+      /* @__PURE__ */ g("div", { style: u.centerArea, children: [
+        /* @__PURE__ */ a(En, { model: e }),
+        /* @__PURE__ */ a(as, { model: e })
+      ] }),
+      n && /* @__PURE__ */ a(Ln, { selectedNode: i })
+    ] });
+  }
+);
+function cs() {
+  const s = new lt();
+  return s.register("components/Button.fixture.tsx", ae({
+    Primary: L({
+      render: (e) => (e.innerHTML = "<button>Primary Button</button>", { dispose: () => {
+        e.innerHTML = "";
+      } })
+    }),
+    Icon: L({
+      render: (e) => (e.innerHTML = "<button>🔔 Icon Button</button>", { dispose: () => {
+        e.innerHTML = "";
+      } })
+    })
+  })), s.register("components/Input.fixture.tsx", ae({
+    Text: L({
+      render: (e) => (e.innerHTML = '<input type="text" placeholder="Text Input" />', { dispose: () => {
+        e.innerHTML = "";
+      } })
+    }),
+    Search: L({
+      render: (e) => (e.innerHTML = '<input type="search" placeholder="Search..." />', { dispose: () => {
+        e.innerHTML = "";
+      } })
+    })
+  })), s.register("components/Card.fixture.tsx", L({
+    render: (e) => (e.innerHTML = '<div style="border: 1px solid #ccc; padding: 16px;">Basic Card</div>', { dispose: () => {
+      e.innerHTML = "";
+    } })
+  })), s.register("components/Feedback.fixture.tsx", ae({
+    Badge: L({
+      render: (e) => (e.innerHTML = '<span style="background: blue; color: white; padding: 2px 8px; border-radius: 4px;">Badge</span>', { dispose: () => {
+        e.innerHTML = "";
+      } })
+    }),
+    Alert: L({
+      render: (e) => (e.innerHTML = '<div style="background: #ffffcc; padding: 8px; border: 1px solid #cc0;">Alert message</div>', { dispose: () => {
+        e.innerHTML = "";
+      } })
+    })
+  })), s;
+}
+function Rs() {
+  const s = cs();
+  return /* @__PURE__ */ a(xt, { registry: s, daemonModel: void 0 });
+}
+var ls = class be {
+  constructor(e) {
+    this.iterator = e;
+  }
+  static fromIterable(e) {
+    return new be(e[Symbol.asyncIterator]());
+  }
+  static fromFn(e) {
+    return new be(e());
+  }
+  [Symbol.asyncIterator]() {
+    return this.iterator;
+  }
+}, hs = class extends Error {
+  constructor(s, e, t) {
+    super(t), this.statusCode = s, this.method = e, this.name = "ApiError";
+  }
+}, us = class {
+  constructor(s) {
+    l(this, "methods", this._createProxy(""));
+    this._request = s;
+  }
+  _createProxy(s) {
+    return new Proxy(() => {
+    }, {
+      apply: async (e, t, n) => await this._request(s, n[0]),
+      get: (e, t) => this._createProxy(`${s}${s ? "/" : ""}${t}`)
+    });
+  }
+};
+function fs(s, e) {
+  return new us(async (t, n) => {
+    var d;
+    const r = await fetch(`${s}/${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 (r.status !== 200) {
+      const c = await r.json().catch(() => null);
+      let h;
+      throw c && typeof c == "object" && "errorMessage" in c ? h = `${c.errorMessage}` : h = `Error calling API method ${t}: ${JSON.stringify(c)} (Status: ${r.status}, Status Text: ${r.statusText})`, new hs(r.status, t, h);
+    }
+    const i = r.headers.get("Content-Type");
+    return i != null && i.startsWith("application/jsonl") ? ls.fromFn(async function* () {
+      var p;
+      const c = (p = r.body) == null ? void 0 : p.getReader();
+      if (!c)
+        return;
+      let h = "";
+      const m = new TextDecoder("utf-8");
+      for (; ; ) {
+        const { done: _, value: E } = await c.read();
+        if (_)
+          break;
+        h += m.decode(E, { stream: !0 });
+        let R;
+        for (; (R = h.indexOf(`
+`)) >= 0; ) {
+          const C = h.slice(0, R).trim();
+          h = h.slice(R + 1), C.length > 0 && (yield JSON.parse(C));
+        }
+      }
+      const v = h.trim();
+      v.length > 0 && (yield JSON.parse(v));
+    }) : await r.json();
+  });
+}
+class ps {
+  constructor(e) {
+    l(this, "_sourceTreeIds", y(this, /* @__PURE__ */ new Map()));
+    l(this, "_sessions", y(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 = fs("/__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 r = `${e}:${t}`, i = this._screenshotCache.get(r);
+    if (i && i.sourceTreeId === n)
+      return i.data;
+    const o = await this._client.methods.screenshots.take({
+      fixtureId: t,
+      sessionName: e,
+      sourceTreeId: n,
+      includeImage: !0
+    });
+    return this._screenshotCache.set(r, { sourceTreeId: n, data: o }), o;
+  }
+  /**
+   * Compare a fixture across two sessions. Returns match status and hashes (no images).
+   */
+  async compare(e, t, n) {
+    const r = this._sourceTreeIds.get().get(t), i = this._sourceTreeIds.get().get(n);
+    if (!r || !i)
+      throw new Error("Missing sourceTreeId for sessions");
+    return this._client.methods.screenshots.compare({
+      fixtureId: e,
+      baselineSessionName: t,
+      baselineSourceTreeId: r,
+      currentSessionName: n,
+      currentSourceTreeId: i,
+      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 r of e)
+      t.set(r.name, r.sourceTreeId), n.push({ name: r.name, serverUrl: r.serverUrl });
+    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 gs() {
+  return window.__EXPLORER_DAEMON__;
+}
+class Vs {
+  constructor(e, t) {
+    l(this, "_root");
+    l(this, "_registry", new lt());
+    l(this, "_daemonModel");
+    this._populateRegistry(t), this._daemonModel = this._initializeDaemonModel(), this._root = It(e), this._root.render(Vt(xt, { registry: this._registry, daemonModel: this._daemonModel }));
+  }
+  _initializeDaemonModel() {
+    const e = gs();
+    if (!e)
+      return;
+    const t = new ps(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 r = n.default;
+      r && typeof r == "object" && this._registry.register(t, r);
+    }
+  }
+  /**
+   * 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 {
+  In as ChevronDownIcon,
+  Sn as ChevronRightIcon,
+  Ts as CliRuntime,
+  On as ComponentIcon,
+  ps as DaemonModel,
+  xt as Explorer,
+  Vs as ExplorerApp,
+  Cn as ExplorerModel,
+  Rs as ExplorerWithDefaults,
+  lt as FixtureRegistry,
+  Tn as FolderIcon,
+  Mn as LeftSidebar,
+  Nn as MoonIcon,
+  Rn as PanelLeftIcon,
+  Vn as PanelRightIcon,
+  Ln as RightSidebar,
+  kn as SunIcon,
+  En as TitleBar,
+  ce as TitleBarButton,
+  An as TreeItem,
+  ut as TreeView,
+  kt as VIEWPORT_SIZES,
+  Ft as collectComponents,
+  Ee as createComponentDefinition,
+  le as createFixtureTree,
+  L as defineFixture,
+  ae as defineFixtureGroup,
+  Ds as defineFixtureVariants,
+  Fe as findNodeByPath,
+  Ve as fixtureGroupBrand,
+  ke as fixtureVariantsBrand,
+  Dt as getDefaultPropertyValues,
+  Os as isComponentDefinition,
+  Ce as isFixtureGroup,
+  we as isFixtureVariants,
+  xe as isSingleFixture,
+  Re as mergeStyles,
+  Cs as parseFixtureExport,
+  Ss as parseFixtureGroup,
+  Is as parseFixtureVariants,
+  ws as parseSingleFixture,
+  Nt as resolveViewport,
+  Ne as singleFixtureBrand,
+  u as styles,
+  ht as toExplorerTree
+};
+//# sourceMappingURL=viewer.js.map