llm-party-cli 0.11.0 → 0.11.1

package/dist/index.js

@@ -3288,6 +3288,932 @@ import { readFile as readFile6 } from "fs/promises";
 import path11 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
+// node_modules/solid-js/dist/server.js
+var sharedConfig = {
+  context: undefined,
+  registry: undefined,
+  effects: undefined,
+  done: false,
+  getContextId() {
+    return getContextId(this.context.count);
+  },
+  getNextContextId() {
+    return getContextId(this.context.count++);
+  }
+};
+function getContextId(count) {
+  const num = String(count), len = num.length - 1;
+  return sharedConfig.context.id + (len ? String.fromCharCode(96 + len) : "") + num;
+}
+function setHydrateContext(context) {
+  sharedConfig.context = context;
+}
+function nextHydrateContext() {
+  return {
+    ...sharedConfig.context,
+    id: sharedConfig.getNextContextId(),
+    count: 0
+  };
+}
+var IS_DEV = false;
+var equalFn = (a, b) => a === b;
+var $PROXY = Symbol("solid-proxy");
+var SUPPORTS_PROXY = typeof Proxy === "function";
+var $TRACK = Symbol("solid-track");
+var $DEVCOMP = Symbol("solid-dev-component");
+var signalOptions = {
+  equals: equalFn
+};
+var ERROR = null;
+var runEffects = runQueue;
+var STALE = 1;
+var PENDING = 2;
+var UNOWNED = {
+  owned: null,
+  cleanups: null,
+  context: null,
+  owner: null
+};
+var Owner = null;
+var Transition = null;
+var Scheduler = null;
+var ExternalSourceConfig = null;
+var Listener = null;
+var Updates = null;
+var Effects = null;
+var ExecCount = 0;
+function createRoot(fn, detachedOwner) {
+  const listener = Listener, owner = Owner, unowned = fn.length === 0, current = detachedOwner === undefined ? owner : detachedOwner, root = unowned ? UNOWNED : {
+    owned: null,
+    cleanups: null,
+    context: current ? current.context : null,
+    owner: current
+  }, updateFn = unowned ? fn : () => fn(() => untrack(() => cleanNode(root)));
+  Owner = root;
+  Listener = null;
+  try {
+    return runUpdates(updateFn, true);
+  } finally {
+    Listener = listener;
+    Owner = owner;
+  }
+}
+function createSignal(value, options) {
+  options = options ? Object.assign({}, signalOptions, options) : signalOptions;
+  const s = {
+    value,
+    observers: null,
+    observerSlots: null,
+    comparator: options.equals || undefined
+  };
+  const setter = (value2) => {
+    if (typeof value2 === "function") {
+      if (Transition && Transition.running && Transition.sources.has(s))
+        value2 = value2(s.tValue);
+      else
+        value2 = value2(s.value);
+    }
+    return writeSignal(s, value2);
+  };
+  return [readSignal.bind(s), setter];
+}
+function createRenderEffect(fn, value, options) {
+  const c = createComputation(fn, value, false, STALE);
+  if (Scheduler && Transition && Transition.running)
+    Updates.push(c);
+  else
+    updateComputation(c);
+}
+function createEffect(fn, value, options) {
+  runEffects = runUserEffects;
+  const c = createComputation(fn, value, false, STALE), s = SuspenseContext && useContext(SuspenseContext);
+  if (s)
+    c.suspense = s;
+  if (!options || !options.render)
+    c.user = true;
+  Effects ? Effects.push(c) : updateComputation(c);
+}
+function createMemo(fn, value, options) {
+  options = options ? Object.assign({}, signalOptions, options) : signalOptions;
+  const c = createComputation(fn, value, true, 0);
+  c.observers = null;
+  c.observerSlots = null;
+  c.comparator = options.equals || undefined;
+  if (Scheduler && Transition && Transition.running) {
+    c.tState = STALE;
+    Updates.push(c);
+  } else
+    updateComputation(c);
+  return readSignal.bind(c);
+}
+function untrack(fn) {
+  if (!ExternalSourceConfig && Listener === null)
+    return fn();
+  const listener = Listener;
+  Listener = null;
+  try {
+    if (ExternalSourceConfig)
+      return ExternalSourceConfig.untrack(fn);
+    return fn();
+  } finally {
+    Listener = listener;
+  }
+}
+function onMount(fn) {
+  createEffect(() => untrack(fn));
+}
+function onCleanup(fn) {
+  if (Owner === null)
+    ;
+  else if (Owner.cleanups === null)
+    Owner.cleanups = [fn];
+  else
+    Owner.cleanups.push(fn);
+  return fn;
+}
+function startTransition(fn) {
+  if (Transition && Transition.running) {
+    fn();
+    return Transition.done;
+  }
+  const l = Listener;
+  const o = Owner;
+  return Promise.resolve().then(() => {
+    Listener = l;
+    Owner = o;
+    let t;
+    if (Scheduler || SuspenseContext) {
+      t = Transition || (Transition = {
+        sources: new Set,
+        effects: [],
+        promises: new Set,
+        disposed: new Set,
+        queue: new Set,
+        running: true
+      });
+      t.done || (t.done = new Promise((res) => t.resolve = res));
+      t.running = true;
+    }
+    runUpdates(fn, false);
+    Listener = Owner = null;
+    return t ? t.done : undefined;
+  });
+}
+var [transPending, setTransPending] = /* @__PURE__ */ createSignal(false);
+function createContext(defaultValue, options) {
+  const id = Symbol("context");
+  return {
+    id,
+    Provider: createProvider(id),
+    defaultValue
+  };
+}
+function useContext(context) {
+  let value;
+  return Owner && Owner.context && (value = Owner.context[context.id]) !== undefined ? value : context.defaultValue;
+}
+function children(fn) {
+  const children2 = createMemo(fn);
+  const memo = createMemo(() => resolveChildren(children2()));
+  memo.toArray = () => {
+    const c = memo();
+    return Array.isArray(c) ? c : c != null ? [c] : [];
+  };
+  return memo;
+}
+var SuspenseContext;
+function readSignal() {
+  const runningTransition = Transition && Transition.running;
+  if (this.sources && (runningTransition ? this.tState : this.state)) {
+    if ((runningTransition ? this.tState : this.state) === STALE)
+      updateComputation(this);
+    else {
+      const updates = Updates;
+      Updates = null;
+      runUpdates(() => lookUpstream(this), false);
+      Updates = updates;
+    }
+  }
+  if (Listener) {
+    const sSlot = this.observers ? this.observers.length : 0;
+    if (!Listener.sources) {
+      Listener.sources = [this];
+      Listener.sourceSlots = [sSlot];
+    } else {
+      Listener.sources.push(this);
+      Listener.sourceSlots.push(sSlot);
+    }
+    if (!this.observers) {
+      this.observers = [Listener];
+      this.observerSlots = [Listener.sources.length - 1];
+    } else {
+      this.observers.push(Listener);
+      this.observerSlots.push(Listener.sources.length - 1);
+    }
+  }
+  if (runningTransition && Transition.sources.has(this))
+    return this.tValue;
+  return this.value;
+}
+function writeSignal(node, value, isComp) {
+  let current = Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value;
+  if (!node.comparator || !node.comparator(current, value)) {
+    if (Transition) {
+      const TransitionRunning = Transition.running;
+      if (TransitionRunning || !isComp && Transition.sources.has(node)) {
+        Transition.sources.add(node);
+        node.tValue = value;
+      }
+      if (!TransitionRunning)
+        node.value = value;
+    } else
+      node.value = value;
+    if (node.observers && node.observers.length) {
+      runUpdates(() => {
+        for (let i = 0;i < node.observers.length; i += 1) {
+          const o = node.observers[i];
+          const TransitionRunning = Transition && Transition.running;
+          if (TransitionRunning && Transition.disposed.has(o))
+            continue;
+          if (TransitionRunning ? !o.tState : !o.state) {
+            if (o.pure)
+              Updates.push(o);
+            else
+              Effects.push(o);
+            if (o.observers)
+              markDownstream(o);
+          }
+          if (!TransitionRunning)
+            o.state = STALE;
+          else
+            o.tState = STALE;
+        }
+        if (Updates.length > 1e6) {
+          Updates = [];
+          if (IS_DEV)
+            ;
+          throw new Error;
+        }
+      }, false);
+    }
+  }
+  return value;
+}
+function updateComputation(node) {
+  if (!node.fn)
+    return;
+  cleanNode(node);
+  const time = ExecCount;
+  runComputation(node, Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value, time);
+  if (Transition && !Transition.running && Transition.sources.has(node)) {
+    queueMicrotask(() => {
+      runUpdates(() => {
+        Transition && (Transition.running = true);
+        Listener = Owner = node;
+        runComputation(node, node.tValue, time);
+        Listener = Owner = null;
+      }, false);
+    });
+  }
+}
+function runComputation(node, value, time) {
+  let nextValue;
+  const owner = Owner, listener = Listener;
+  Listener = Owner = node;
+  try {
+    nextValue = node.fn(value);
+  } catch (err) {
+    if (node.pure) {
+      if (Transition && Transition.running) {
+        node.tState = STALE;
+        node.tOwned && node.tOwned.forEach(cleanNode);
+        node.tOwned = undefined;
+      } else {
+        node.state = STALE;
+        node.owned && node.owned.forEach(cleanNode);
+        node.owned = null;
+      }
+    }
+    node.updatedAt = time + 1;
+    return handleError(err);
+  } finally {
+    Listener = listener;
+    Owner = owner;
+  }
+  if (!node.updatedAt || node.updatedAt <= time) {
+    if (node.updatedAt != null && "observers" in node) {
+      writeSignal(node, nextValue, true);
+    } else if (Transition && Transition.running && node.pure) {
+      if (!Transition.sources.has(node))
+        node.value = nextValue;
+      Transition.sources.add(node);
+      node.tValue = nextValue;
+    } else
+      node.value = nextValue;
+    node.updatedAt = time;
+  }
+}
+function createComputation(fn, init, pure, state = STALE, options) {
+  const c = {
+    fn,
+    state,
+    updatedAt: null,
+    owned: null,
+    sources: null,
+    sourceSlots: null,
+    cleanups: null,
+    value: init,
+    owner: Owner,
+    context: Owner ? Owner.context : null,
+    pure
+  };
+  if (Transition && Transition.running) {
+    c.state = 0;
+    c.tState = state;
+  }
+  if (Owner === null)
+    ;
+  else if (Owner !== UNOWNED) {
+    if (Transition && Transition.running && Owner.pure) {
+      if (!Owner.tOwned)
+        Owner.tOwned = [c];
+      else
+        Owner.tOwned.push(c);
+    } else {
+      if (!Owner.owned)
+        Owner.owned = [c];
+      else
+        Owner.owned.push(c);
+    }
+  }
+  if (ExternalSourceConfig && c.fn) {
+    const sourceFn = c.fn;
+    const [track, trigger] = createSignal(undefined, {
+      equals: false
+    });
+    const ordinary = ExternalSourceConfig.factory(sourceFn, trigger);
+    onCleanup(() => ordinary.dispose());
+    let inTransition;
+    const triggerInTransition = () => startTransition(trigger).then(() => {
+      if (inTransition) {
+        inTransition.dispose();
+        inTransition = undefined;
+      }
+    });
+    c.fn = (x) => {
+      track();
+      if (Transition && Transition.running) {
+        if (!inTransition)
+          inTransition = ExternalSourceConfig.factory(sourceFn, triggerInTransition);
+        return inTransition.track(x);
+      }
+      return ordinary.track(x);
+    };
+  }
+  return c;
+}
+function runTop(node) {
+  const runningTransition = Transition && Transition.running;
+  if ((runningTransition ? node.tState : node.state) === 0)
+    return;
+  if ((runningTransition ? node.tState : node.state) === PENDING)
+    return lookUpstream(node);
+  if (node.suspense && untrack(node.suspense.inFallback))
+    return node.suspense.effects.push(node);
+  const ancestors = [node];
+  while ((node = node.owner) && (!node.updatedAt || node.updatedAt < ExecCount)) {
+    if (runningTransition && Transition.disposed.has(node))
+      return;
+    if (runningTransition ? node.tState : node.state)
+      ancestors.push(node);
+  }
+  for (let i = ancestors.length - 1;i >= 0; i--) {
+    node = ancestors[i];
+    if (runningTransition) {
+      let top = node, prev = ancestors[i + 1];
+      while ((top = top.owner) && top !== prev) {
+        if (Transition.disposed.has(top))
+          return;
+      }
+    }
+    if ((runningTransition ? node.tState : node.state) === STALE) {
+      updateComputation(node);
+    } else if ((runningTransition ? node.tState : node.state) === PENDING) {
+      const updates = Updates;
+      Updates = null;
+      runUpdates(() => lookUpstream(node, ancestors[0]), false);
+      Updates = updates;
+    }
+  }
+}
+function runUpdates(fn, init) {
+  if (Updates)
+    return fn();
+  let wait = false;
+  if (!init)
+    Updates = [];
+  if (Effects)
+    wait = true;
+  else
+    Effects = [];
+  ExecCount++;
+  try {
+    const res = fn();
+    completeUpdates(wait);
+    return res;
+  } catch (err) {
+    if (!wait)
+      Effects = null;
+    Updates = null;
+    handleError(err);
+  }
+}
+function completeUpdates(wait) {
+  if (Updates) {
+    if (Scheduler && Transition && Transition.running)
+      scheduleQueue(Updates);
+    else
+      runQueue(Updates);
+    Updates = null;
+  }
+  if (wait)
+    return;
+  let res;
+  if (Transition) {
+    if (!Transition.promises.size && !Transition.queue.size) {
+      const sources = Transition.sources;
+      const disposed = Transition.disposed;
+      Effects.push.apply(Effects, Transition.effects);
+      res = Transition.resolve;
+      for (const e2 of Effects) {
+        "tState" in e2 && (e2.state = e2.tState);
+        delete e2.tState;
+      }
+      Transition = null;
+      runUpdates(() => {
+        for (const d of disposed)
+          cleanNode(d);
+        for (const v of sources) {
+          v.value = v.tValue;
+          if (v.owned) {
+            for (let i = 0, len = v.owned.length;i < len; i++)
+              cleanNode(v.owned[i]);
+          }
+          if (v.tOwned)
+            v.owned = v.tOwned;
+          delete v.tValue;
+          delete v.tOwned;
+          v.tState = 0;
+        }
+        setTransPending(false);
+      }, false);
+    } else if (Transition.running) {
+      Transition.running = false;
+      Transition.effects.push.apply(Transition.effects, Effects);
+      Effects = null;
+      setTransPending(true);
+      return;
+    }
+  }
+  const e = Effects;
+  Effects = null;
+  if (e.length)
+    runUpdates(() => runEffects(e), false);
+  if (res)
+    res();
+}
+function runQueue(queue) {
+  for (let i = 0;i < queue.length; i++)
+    runTop(queue[i]);
+}
+function scheduleQueue(queue) {
+  for (let i = 0;i < queue.length; i++) {
+    const item = queue[i];
+    const tasks = Transition.queue;
+    if (!tasks.has(item)) {
+      tasks.add(item);
+      Scheduler(() => {
+        tasks.delete(item);
+        runUpdates(() => {
+          Transition.running = true;
+          runTop(item);
+        }, false);
+        Transition && (Transition.running = false);
+      });
+    }
+  }
+}
+function runUserEffects(queue) {
+  let i, userLength = 0;
+  for (i = 0;i < queue.length; i++) {
+    const e = queue[i];
+    if (!e.user)
+      runTop(e);
+    else
+      queue[userLength++] = e;
+  }
+  if (sharedConfig.context) {
+    if (sharedConfig.count) {
+      sharedConfig.effects || (sharedConfig.effects = []);
+      sharedConfig.effects.push(...queue.slice(0, userLength));
+      return;
+    }
+    setHydrateContext();
+  }
+  if (sharedConfig.effects && (sharedConfig.done || !sharedConfig.count)) {
+    queue = [...sharedConfig.effects, ...queue];
+    userLength += sharedConfig.effects.length;
+    delete sharedConfig.effects;
+  }
+  for (i = 0;i < userLength; i++)
+    runTop(queue[i]);
+}
+function lookUpstream(node, ignore) {
+  const runningTransition = Transition && Transition.running;
+  if (runningTransition)
+    node.tState = 0;
+  else
+    node.state = 0;
+  for (let i = 0;i < node.sources.length; i += 1) {
+    const source = node.sources[i];
+    if (source.sources) {
+      const state = runningTransition ? source.tState : source.state;
+      if (state === STALE) {
+        if (source !== ignore && (!source.updatedAt || source.updatedAt < ExecCount))
+          runTop(source);
+      } else if (state === PENDING)
+        lookUpstream(source, ignore);
+    }
+  }
+}
+function markDownstream(node) {
+  const runningTransition = Transition && Transition.running;
+  for (let i = 0;i < node.observers.length; i += 1) {
+    const o = node.observers[i];
+    if (runningTransition ? !o.tState : !o.state) {
+      if (runningTransition)
+        o.tState = PENDING;
+      else
+        o.state = PENDING;
+      if (o.pure)
+        Updates.push(o);
+      else
+        Effects.push(o);
+      o.observers && markDownstream(o);
+    }
+  }
+}
+function cleanNode(node) {
+  let i;
+  if (node.sources) {
+    while (node.sources.length) {
+      const source = node.sources.pop(), index = node.sourceSlots.pop(), obs = source.observers;
+      if (obs && obs.length) {
+        const n = obs.pop(), s = source.observerSlots.pop();
+        if (index < obs.length) {
+          n.sourceSlots[s] = index;
+          obs[index] = n;
+          source.observerSlots[index] = s;
+        }
+      }
+    }
+  }
+  if (node.tOwned) {
+    for (i = node.tOwned.length - 1;i >= 0; i--)
+      cleanNode(node.tOwned[i]);
+    delete node.tOwned;
+  }
+  if (Transition && Transition.running && node.pure) {
+    reset(node, true);
+  } else if (node.owned) {
+    for (i = node.owned.length - 1;i >= 0; i--)
+      cleanNode(node.owned[i]);
+    node.owned = null;
+  }
+  if (node.cleanups) {
+    for (i = node.cleanups.length - 1;i >= 0; i--)
+      node.cleanups[i]();
+    node.cleanups = null;
+  }
+  if (Transition && Transition.running)
+    node.tState = 0;
+  else
+    node.state = 0;
+}
+function reset(node, top) {
+  if (!top) {
+    node.tState = 0;
+    Transition.disposed.add(node);
+  }
+  if (node.owned) {
+    for (let i = 0;i < node.owned.length; i++)
+      reset(node.owned[i]);
+  }
+}
+function castError(err) {
+  if (err instanceof Error)
+    return err;
+  return new Error(typeof err === "string" ? err : "Unknown error", {
+    cause: err
+  });
+}
+function runErrors(err, fns, owner) {
+  try {
+    for (const f of fns)
+      f(err);
+  } catch (e) {
+    handleError(e, owner && owner.owner || null);
+  }
+}
+function handleError(err, owner = Owner) {
+  const fns = ERROR && owner && owner.context && owner.context[ERROR];
+  const error = castError(err);
+  if (!fns)
+    throw error;
+  if (Effects)
+    Effects.push({
+      fn() {
+        runErrors(error, fns, owner);
+      },
+      state: STALE
+    });
+  else
+    runErrors(error, fns, owner);
+}
+function resolveChildren(children2) {
+  if (typeof children2 === "function" && !children2.length)
+    return resolveChildren(children2());
+  if (Array.isArray(children2)) {
+    const results = [];
+    for (let i = 0;i < children2.length; i++) {
+      const result = resolveChildren(children2[i]);
+      Array.isArray(result) ? results.push.apply(results, result) : results.push(result);
+    }
+    return results;
+  }
+  return children2;
+}
+function createProvider(id, options) {
+  return function provider(props) {
+    let res;
+    createRenderEffect(() => res = untrack(() => {
+      Owner.context = {
+        ...Owner.context,
+        [id]: props.value
+      };
+      return children(() => props.children);
+    }), undefined);
+    return res;
+  };
+}
+var FALLBACK = Symbol("fallback");
+function dispose(d) {
+  for (let i = 0;i < d.length; i++)
+    d[i]();
+}
+function mapArray(list, mapFn, options = {}) {
+  let items = [], mapped = [], disposers = [], len = 0, indexes = mapFn.length > 1 ? [] : null;
+  onCleanup(() => dispose(disposers));
+  return () => {
+    let newItems = list() || [], newLen = newItems.length, i, j;
+    newItems[$TRACK];
+    return untrack(() => {
+      let newIndices, newIndicesNext, temp, tempdisposers, tempIndexes, start, end, newEnd, item;
+      if (newLen === 0) {
+        if (len !== 0) {
+          dispose(disposers);
+          disposers = [];
+          items = [];
+          mapped = [];
+          len = 0;
+          indexes && (indexes = []);
+        }
+        if (options.fallback) {
+          items = [FALLBACK];
+          mapped[0] = createRoot((disposer) => {
+            disposers[0] = disposer;
+            return options.fallback();
+          });
+          len = 1;
+        }
+      } else if (len === 0) {
+        mapped = new Array(newLen);
+        for (j = 0;j < newLen; j++) {
+          items[j] = newItems[j];
+          mapped[j] = createRoot(mapper);
+        }
+        len = newLen;
+      } else {
+        temp = new Array(newLen);
+        tempdisposers = new Array(newLen);
+        indexes && (tempIndexes = new Array(newLen));
+        for (start = 0, end = Math.min(len, newLen);start < end && items[start] === newItems[start]; start++)
+          ;
+        for (end = len - 1, newEnd = newLen - 1;end >= start && newEnd >= start && items[end] === newItems[newEnd]; end--, newEnd--) {
+          temp[newEnd] = mapped[end];
+          tempdisposers[newEnd] = disposers[end];
+          indexes && (tempIndexes[newEnd] = indexes[end]);
+        }
+        newIndices = new Map;
+        newIndicesNext = new Array(newEnd + 1);
+        for (j = newEnd;j >= start; j--) {
+          item = newItems[j];
+          i = newIndices.get(item);
+          newIndicesNext[j] = i === undefined ? -1 : i;
+          newIndices.set(item, j);
+        }
+        for (i = start;i <= end; i++) {
+          item = items[i];
+          j = newIndices.get(item);
+          if (j !== undefined && j !== -1) {
+            temp[j] = mapped[i];
+            tempdisposers[j] = disposers[i];
+            indexes && (tempIndexes[j] = indexes[i]);
+            j = newIndicesNext[j];
+            newIndices.set(item, j);
+          } else
+            disposers[i]();
+        }
+        for (j = start;j < newLen; j++) {
+          if (j in temp) {
+            mapped[j] = temp[j];
+            disposers[j] = tempdisposers[j];
+            if (indexes) {
+              indexes[j] = tempIndexes[j];
+              indexes[j](j);
+            }
+          } else
+            mapped[j] = createRoot(mapper);
+        }
+        mapped = mapped.slice(0, len = newLen);
+        items = newItems.slice(0);
+      }
+      return mapped;
+    });
+    function mapper(disposer) {
+      disposers[j] = disposer;
+      if (indexes) {
+        const [s, set] = createSignal(j);
+        indexes[j] = set;
+        return mapFn(newItems[j], s);
+      }
+      return mapFn(newItems[j]);
+    }
+  };
+}
+var hydrationEnabled = false;
+function createComponent(Comp, props) {
+  if (hydrationEnabled) {
+    if (sharedConfig.context) {
+      const c = sharedConfig.context;
+      setHydrateContext(nextHydrateContext());
+      const r = untrack(() => Comp(props || {}));
+      setHydrateContext(c);
+      return r;
+    }
+  }
+  return untrack(() => Comp(props || {}));
+}
+function trueFn() {
+  return true;
+}
+var propTraps = {
+  get(_, property, receiver) {
+    if (property === $PROXY)
+      return receiver;
+    return _.get(property);
+  },
+  has(_, property) {
+    if (property === $PROXY)
+      return true;
+    return _.has(property);
+  },
+  set: trueFn,
+  deleteProperty: trueFn,
+  getOwnPropertyDescriptor(_, property) {
+    return {
+      configurable: true,
+      enumerable: true,
+      get() {
+        return _.get(property);
+      },
+      set: trueFn,
+      deleteProperty: trueFn
+    };
+  },
+  ownKeys(_) {
+    return _.keys();
+  }
+};
+function resolveSource(s) {
+  return !(s = typeof s === "function" ? s() : s) ? {} : s;
+}
+function resolveSources() {
+  for (let i = 0, length = this.length;i < length; ++i) {
+    const v = this[i]();
+    if (v !== undefined)
+      return v;
+  }
+}
+function mergeProps(...sources) {
+  let proxy = false;
+  for (let i = 0;i < sources.length; i++) {
+    const s = sources[i];
+    proxy = proxy || !!s && $PROXY in s;
+    sources[i] = typeof s === "function" ? (proxy = true, createMemo(s)) : s;
+  }
+  if (SUPPORTS_PROXY && proxy) {
+    return new Proxy({
+      get(property) {
+        for (let i = sources.length - 1;i >= 0; i--) {
+          const v = resolveSource(sources[i])[property];
+          if (v !== undefined)
+            return v;
+        }
+      },
+      has(property) {
+        for (let i = sources.length - 1;i >= 0; i--) {
+          if (property in resolveSource(sources[i]))
+            return true;
+        }
+        return false;
+      },
+      keys() {
+        const keys = [];
+        for (let i = 0;i < sources.length; i++)
+          keys.push(...Object.keys(resolveSource(sources[i])));
+        return [...new Set(keys)];
+      }
+    }, propTraps);
+  }
+  const sourcesMap = {};
+  const defined = Object.create(null);
+  for (let i = sources.length - 1;i >= 0; i--) {
+    const source = sources[i];
+    if (!source)
+      continue;
+    const sourceKeys = Object.getOwnPropertyNames(source);
+    for (let i2 = sourceKeys.length - 1;i2 >= 0; i2--) {
+      const key = sourceKeys[i2];
+      if (key === "__proto__" || key === "constructor")
+        continue;
+      const desc = Object.getOwnPropertyDescriptor(source, key);
+      if (!defined[key]) {
+        defined[key] = desc.get ? {
+          enumerable: true,
+          configurable: true,
+          get: resolveSources.bind(sourcesMap[key] = [desc.get.bind(source)])
+        } : desc.value !== undefined ? desc : undefined;
+      } else {
+        const sources2 = sourcesMap[key];
+        if (sources2) {
+          if (desc.get)
+            sources2.push(desc.get.bind(source));
+          else if (desc.value !== undefined)
+            sources2.push(() => desc.value);
+        }
+      }
+    }
+  }
+  const target = {};
+  const definedKeys = Object.keys(defined);
+  for (let i = definedKeys.length - 1;i >= 0; i--) {
+    const key = definedKeys[i], desc = defined[key];
+    if (desc && desc.get)
+      Object.defineProperty(target, key, desc);
+    else
+      target[key] = desc ? desc.value : undefined;
+  }
+  return target;
+}
+var narrowedError = (name) => `Stale read from <${name}>.`;
+function For(props) {
+  const fallback = "fallback" in props && {
+    fallback: () => props.fallback
+  };
+  return createMemo(mapArray(() => props.each, props.children, fallback || undefined));
+}
+function Show(props) {
+  const keyed = props.keyed;
+  const conditionValue = createMemo(() => props.when, undefined, undefined);
+  const condition = keyed ? conditionValue : createMemo(conditionValue, undefined, {
+    equals: (a, b) => !a === !b
+  });
+  return createMemo(() => {
+    const c = condition();
+    if (c) {
+      const child = props.children;
+      const fn = typeof child === "function" && child.length > 0;
+      return fn ? untrack(() => child(keyed ? c : () => {
+        if (!untrack(condition))
+          throw narrowedError("Show");
+        return conditionValue();
+      })) : child;
+    }
+    return props.fallback;
+  }, undefined, undefined);
+}
+
 // node_modules/@opentui/solid/node_modules/@opentui/core/index-mdxq0qtt.js
 import { EventEmitter } from "events";
 import { Buffer as Buffer2 } from "buffer";
@@ -8446,11 +9372,11 @@ function visualizeRenderableTree(renderable, maxDepth = 10) {
       return [`${prefix}${node.id} ... (max depth reached)`];
     }
     const lines = [];
-    const children = node.getChildren();
+    const children2 = node.getChildren();
     lines.push(`${prefix}${node.id}`);
-    if (children.length > 0) {
-      const lastChildIndex = children.length - 1;
-      children.forEach((child, index) => {
+    if (children2.length > 0) {
+      const lastChildIndex = children2.length - 1;
+      children2.forEach((child, index) => {
         const childIsLast = index === lastChildIndex;
         const connector = childIsLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
         const childPrefix = parentPrefix + (isLastChild ? "    " : "\u2502   ");
@@ -18779,8 +19705,8 @@ class Renderable extends BaseRenderable {
     } catch (e) {}
   }
   destroyRecursively() {
-    const children = [...this._childrenInLayoutOrder];
-    for (const child of children) {
+    const children2 = [...this._childrenInLayoutOrder];
+    for (const child of children2) {
       child.destroyRecursively();
     }
     this.destroy();
@@ -18966,9 +19892,9 @@ var BrandedVNode = Symbol.for("@opentui/core/VNode");
 function isRenderableConstructor(value) {
   return typeof value === "function" && value.prototype && Renderable.prototype.isPrototypeOf(value.prototype);
 }
-function flattenChildren(children) {
+function flattenChildren(children2) {
   const result = [];
-  for (const child of children) {
+  for (const child of children2) {
     if (Array.isArray(child)) {
       result.push(...flattenChildren(child));
     } else if (child !== null && child !== undefined && child !== false) {
@@ -18977,7 +19903,7 @@ function flattenChildren(children) {
   }
   return result;
 }
-function h(type, props, ...children) {
+function h(type, props, ...children2) {
   if (typeof type !== "function") {
     throw new TypeError("h() received an invalid vnode type");
   }
@@ -18985,7 +19911,7 @@ function h(type, props, ...children) {
     [BrandedVNode]: true,
     type,
     props,
-    children: flattenChildren(children),
+    children: flattenChildren(children2),
     __pendingCalls: []
   };
   if (isRenderableConstructor(type)) {
@@ -19087,11 +20013,11 @@ function instantiate(ctx, node) {
   }
   const vnode = node;
   const { type, props } = vnode;
-  const children = flattenChildren(vnode.children || []);
+  const children2 = flattenChildren(vnode.children || []);
   const delegateMap = vnode.__delegateMap;
   if (isRenderableConstructor(type)) {
     const instance = new type(ctx, props || {});
-    for (const child of children) {
+    for (const child of children2) {
       if (isRenderable(child)) {
         instance.add(child);
       } else {
@@ -19112,7 +20038,7 @@ function instantiate(ctx, node) {
     }
     return delegatedInstance;
   }
-  const resolved = type(props || {}, children);
+  const resolved = type(props || {}, children2);
   const inst = instantiate(ctx, resolved);
   return wrapWithDelegates(inst, delegateMap);
 }
@@ -20249,8 +21175,8 @@ function getObjectsInViewport(viewport, objects, direction = "column", padding =
   const viewportLeft = viewport.x - padding;
   const viewportRight = viewport.x + viewport.width + padding;
   const isRow = direction === "row";
-  const children = objects;
-  const totalChildren = children.length;
+  const children2 = objects;
+  const totalChildren = children2.length;
   if (totalChildren === 0)
     return [];
   const vpStart = isRow ? viewportLeft : viewportTop;
@@ -20260,7 +21186,7 @@ function getObjectsInViewport(viewport, objects, direction = "column", padding =
   let candidate = -1;
   while (lo <= hi) {
     const mid = lo + hi >> 1;
-    const c = children[mid];
+    const c = children2[mid];
     const start = isRow ? c.x : c.y;
     const end = isRow ? c.x + c.width : c.y + c.height;
     if (end < vpStart) {
@@ -20280,7 +21206,7 @@ function getObjectsInViewport(viewport, objects, direction = "column", padding =
   let left = candidate;
   let gapCount = 0;
   while (left - 1 >= 0) {
-    const prev = children[left - 1];
+    const prev = children2[left - 1];
     const prevEnd = isRow ? prev.x + prev.width : prev.y + prev.height;
     if (prevEnd <= vpStart) {
       gapCount++;
@@ -20294,13 +21220,13 @@ function getObjectsInViewport(viewport, objects, direction = "column", padding =
   }
   let right = candidate + 1;
   while (right < totalChildren) {
-    const next = children[right];
+    const next = children2[right];
     if ((isRow ? next.x : next.y) >= vpEnd)
       break;
     right++;
   }
   for (let i = left;i < right; i++) {
-    const child = children[i];
+    const child = children2[i];
     const start = isRow ? child.x : child.y;
     const end = isRow ? child.x + child.width : child.y + child.height;
     if (end <= vpStart)
@@ -22132,8 +23058,8 @@ Captured output:
     }
   }
   walkSelectableRenderables(container, selectionBounds, selectedRenderables, touchedRenderables) {
-    const children = getObjectsInViewport(selectionBounds, container.getChildrenSortedByPrimaryAxis(), container.primaryAxis, 0, 0);
-    for (const child of children) {
+    const children2 = getObjectsInViewport(selectionBounds, container.getChildrenSortedByPrimaryAxis(), container.primaryAxis, 0, 0);
+    for (const child of children2) {
       if (child.selectable) {
         const hasSelection = child.onSelectionChanged(this.currentSelection);
         if (hasSelection) {
@@ -26874,8 +27800,8 @@ class TextNodeRenderable extends BaseRenderable {
   get children() {
     return this._children;
   }
-  set children(children) {
-    this._children = children;
+  set children(children2) {
+    this._children = children2;
     this.requestRender();
   }
   requestRender() {
@@ -27088,66 +28014,66 @@ class RootTextNodeRenderable extends TextNodeRenderable {
     this.ctx.requestRender();
   }
 }
-function Generic(props, ...children) {
-  return h(VRenderable, props || {}, ...children);
+function Generic(props, ...children2) {
+  return h(VRenderable, props || {}, ...children2);
 }
-function Box(props, ...children) {
-  return h(BoxRenderable, props || {}, ...children);
+function Box(props, ...children2) {
+  return h(BoxRenderable, props || {}, ...children2);
 }
-function Text(props, ...children) {
-  return h(TextRenderable, props || {}, ...children);
+function Text(props, ...children2) {
+  return h(TextRenderable, props || {}, ...children2);
 }
-function ASCIIFont(props, ...children) {
-  return h(ASCIIFontRenderable, props || {}, ...children);
+function ASCIIFont(props, ...children2) {
+  return h(ASCIIFontRenderable, props || {}, ...children2);
 }
-function Input(props, ...children) {
-  return h(InputRenderable, props || {}, ...children);
+function Input(props, ...children2) {
+  return h(InputRenderable, props || {}, ...children2);
 }
-function Select(props, ...children) {
-  return h(SelectRenderable, props || {}, ...children);
+function Select(props, ...children2) {
+  return h(SelectRenderable, props || {}, ...children2);
 }
-function TabSelect(props, ...children) {
-  return h(TabSelectRenderable, props || {}, ...children);
+function TabSelect(props, ...children2) {
+  return h(TabSelectRenderable, props || {}, ...children2);
 }
-function FrameBuffer(props, ...children) {
-  return h(FrameBufferRenderable, props, ...children);
+function FrameBuffer(props, ...children2) {
+  return h(FrameBufferRenderable, props, ...children2);
 }
-function Code(props, ...children) {
-  return h(CodeRenderable, props, ...children);
+function Code(props, ...children2) {
+  return h(CodeRenderable, props, ...children2);
 }
-function ScrollBox(props, ...children) {
-  return h(ScrollBoxRenderable, props || {}, ...children);
+function ScrollBox(props, ...children2) {
+  return h(ScrollBoxRenderable, props || {}, ...children2);
 }
-function StyledText2(props, ...children) {
+function StyledText2(props, ...children2) {
   const styledProps = props;
   const textNodeOptions = {
     ...styledProps,
     attributes: styledProps?.attributes ?? 0
   };
   const textNode = new TextNodeRenderable(textNodeOptions);
-  for (const child of children) {
+  for (const child of children2) {
     textNode.add(child);
   }
   return textNode;
 }
 var vstyles = {
-  bold: (...children) => StyledText2({ attributes: TextAttributes.BOLD }, ...children),
-  italic: (...children) => StyledText2({ attributes: TextAttributes.ITALIC }, ...children),
-  underline: (...children) => StyledText2({ attributes: TextAttributes.UNDERLINE }, ...children),
-  dim: (...children) => StyledText2({ attributes: TextAttributes.DIM }, ...children),
-  blink: (...children) => StyledText2({ attributes: TextAttributes.BLINK }, ...children),
-  inverse: (...children) => StyledText2({ attributes: TextAttributes.INVERSE }, ...children),
-  hidden: (...children) => StyledText2({ attributes: TextAttributes.HIDDEN }, ...children),
-  strikethrough: (...children) => StyledText2({ attributes: TextAttributes.STRIKETHROUGH }, ...children),
-  boldItalic: (...children) => StyledText2({ attributes: TextAttributes.BOLD | TextAttributes.ITALIC }, ...children),
-  boldUnderline: (...children) => StyledText2({ attributes: TextAttributes.BOLD | TextAttributes.UNDERLINE }, ...children),
-  italicUnderline: (...children) => StyledText2({ attributes: TextAttributes.ITALIC | TextAttributes.UNDERLINE }, ...children),
-  boldItalicUnderline: (...children) => StyledText2({ attributes: TextAttributes.BOLD | TextAttributes.ITALIC | TextAttributes.UNDERLINE }, ...children),
-  color: (color, ...children) => StyledText2({ fg: color }, ...children),
-  bgColor: (bgColor, ...children) => StyledText2({ bg: bgColor }, ...children),
-  fg: (color, ...children) => StyledText2({ fg: color }, ...children),
-  bg: (bgColor, ...children) => StyledText2({ bg: bgColor }, ...children),
-  styled: (attributes = 0, ...children) => StyledText2({ attributes }, ...children)
+  bold: (...children2) => StyledText2({ attributes: TextAttributes.BOLD }, ...children2),
+  italic: (...children2) => StyledText2({ attributes: TextAttributes.ITALIC }, ...children2),
+  underline: (...children2) => StyledText2({ attributes: TextAttributes.UNDERLINE }, ...children2),
+  dim: (...children2) => StyledText2({ attributes: TextAttributes.DIM }, ...children2),
+  blink: (...children2) => StyledText2({ attributes: TextAttributes.BLINK }, ...children2),
+  inverse: (...children2) => StyledText2({ attributes: TextAttributes.INVERSE }, ...children2),
+  hidden: (...children2) => StyledText2({ attributes: TextAttributes.HIDDEN }, ...children2),
+  strikethrough: (...children2) => StyledText2({ attributes: TextAttributes.STRIKETHROUGH }, ...children2),
+  boldItalic: (...children2) => StyledText2({ attributes: TextAttributes.BOLD | TextAttributes.ITALIC }, ...children2),
+  boldUnderline: (...children2) => StyledText2({ attributes: TextAttributes.BOLD | TextAttributes.UNDERLINE }, ...children2),
+  italicUnderline: (...children2) => StyledText2({ attributes: TextAttributes.ITALIC | TextAttributes.UNDERLINE }, ...children2),
+  boldItalicUnderline: (...children2) => StyledText2({ attributes: TextAttributes.BOLD | TextAttributes.ITALIC | TextAttributes.UNDERLINE }, ...children2),
+  color: (color, ...children2) => StyledText2({ fg: color }, ...children2),
+  bgColor: (bgColor, ...children2) => StyledText2({ bg: bgColor }, ...children2),
+  fg: (color, ...children2) => StyledText2({ fg: color }, ...children2),
+  bg: (bgColor, ...children2) => StyledText2({ bg: bgColor }, ...children2),
+  styled: (attributes = 0, ...children2) => StyledText2({ attributes }, ...children2)
 };
 
 class VRenderable extends Renderable {
@@ -34981,1288 +35907,362 @@ class TabSelectRenderable extends Renderable {
         this.frameBuffer.drawText(descContent, contentX + 1, descriptionY, descColor);
       }
     }
-    if (this._showScrollArrows && this._options.length > this.maxVisibleTabs) {
-      this.renderScrollArrowsToFrameBuffer(contentX, contentY, contentWidth, contentHeight);
-    }
-  }
-  truncateText(text, maxWidth) {
-    if (text.length <= maxWidth)
-      return text;
-    return text.substring(0, Math.max(0, maxWidth - 1)) + "\u2026";
-  }
-  renderScrollArrowsToFrameBuffer(contentX, contentY, contentWidth, contentHeight) {
-    if (!this.frameBuffer)
-      return;
-    const hasMoreLeft = this.scrollOffset > 0;
-    const hasMoreRight = this.scrollOffset + this.maxVisibleTabs < this._options.length;
-    if (hasMoreLeft) {
-      this.frameBuffer.drawText("\u2039", contentX, contentY, parseColor("#AAAAAA"));
-    }
-    if (hasMoreRight) {
-      this.frameBuffer.drawText("\u203A", contentX + contentWidth - 1, contentY, parseColor("#AAAAAA"));
-    }
-  }
-  setOptions(options) {
-    this._options = options;
-    this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, options.length - 1));
-    this.updateScrollOffset();
-    this.requestRender();
-  }
-  getSelectedOption() {
-    return this._options[this.selectedIndex] || null;
-  }
-  getSelectedIndex() {
-    return this.selectedIndex;
-  }
-  moveLeft() {
-    if (this.selectedIndex > 0) {
-      this.selectedIndex--;
-    } else if (this._wrapSelection && this._options.length > 0) {
-      this.selectedIndex = this._options.length - 1;
-    } else {
-      return;
-    }
-    this.updateScrollOffset();
-    this.requestRender();
-    this.emit("selectionChanged", this.selectedIndex, this.getSelectedOption());
-  }
-  moveRight() {
-    if (this.selectedIndex < this._options.length - 1) {
-      this.selectedIndex++;
-    } else if (this._wrapSelection && this._options.length > 0) {
-      this.selectedIndex = 0;
-    } else {
-      return;
-    }
-    this.updateScrollOffset();
-    this.requestRender();
-    this.emit("selectionChanged", this.selectedIndex, this.getSelectedOption());
-  }
-  selectCurrent() {
-    const selected = this.getSelectedOption();
-    if (selected) {
-      this.emit("itemSelected", this.selectedIndex, selected);
-    }
-  }
-  setSelectedIndex(index) {
-    if (index >= 0 && index < this._options.length) {
-      this.selectedIndex = index;
-      this.updateScrollOffset();
-      this.requestRender();
-      this.emit("selectionChanged", this.selectedIndex, this.getSelectedOption());
-    }
-  }
-  updateScrollOffset() {
-    const halfVisible = Math.floor(this.maxVisibleTabs / 2);
-    const newScrollOffset = Math.max(0, Math.min(this.selectedIndex - halfVisible, this._options.length - this.maxVisibleTabs));
-    if (newScrollOffset !== this.scrollOffset) {
-      this.scrollOffset = newScrollOffset;
-      this.requestRender();
-    }
-  }
-  onResize(width, height) {
-    this.maxVisibleTabs = Math.max(1, Math.floor(width / this._tabWidth));
-    this.updateScrollOffset();
-    this.requestRender();
-  }
-  setTabWidth(tabWidth) {
-    if (this._tabWidth === tabWidth)
-      return;
-    this._tabWidth = tabWidth;
-    this.maxVisibleTabs = Math.max(1, Math.floor(this.width / this._tabWidth));
-    this.updateScrollOffset();
-    this.requestRender();
-  }
-  getTabWidth() {
-    return this._tabWidth;
-  }
-  handleKeyPress(key) {
-    const bindingKey = getKeyBindingKey({
-      name: key.name,
-      ctrl: key.ctrl,
-      shift: key.shift,
-      meta: key.meta,
-      super: key.super,
-      action: "move-left"
-    });
-    const action = this._keyBindingsMap.get(bindingKey);
-    if (action) {
-      switch (action) {
-        case "move-left":
-          this.moveLeft();
-          return true;
-        case "move-right":
-          this.moveRight();
-          return true;
-        case "select-current":
-          this.selectCurrent();
-          return true;
-      }
-    }
-    return false;
-  }
-  get options() {
-    return this._options;
-  }
-  set options(options) {
-    this._options = options;
-    this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, options.length - 1));
-    this.updateScrollOffset();
-    this.requestRender();
-  }
-  set backgroundColor(color) {
-    this._backgroundColor = parseColor(color);
-    this.requestRender();
-  }
-  set textColor(color) {
-    this._textColor = parseColor(color);
-    this.requestRender();
-  }
-  set focusedBackgroundColor(color) {
-    this._focusedBackgroundColor = parseColor(color);
-    this.requestRender();
-  }
-  set focusedTextColor(color) {
-    this._focusedTextColor = parseColor(color);
-    this.requestRender();
-  }
-  set selectedBackgroundColor(color) {
-    this._selectedBackgroundColor = parseColor(color);
-    this.requestRender();
-  }
-  set selectedTextColor(color) {
-    this._selectedTextColor = parseColor(color);
-    this.requestRender();
-  }
-  set selectedDescriptionColor(color) {
-    this._selectedDescriptionColor = parseColor(color);
-    this.requestRender();
-  }
-  get showDescription() {
-    return this._showDescription;
-  }
-  set showDescription(show) {
-    if (this._showDescription !== show) {
-      this._showDescription = show;
-      const newHeight = this.calculateDynamicHeight();
-      this.height = newHeight;
-      this.requestRender();
-    }
-  }
-  get showUnderline() {
-    return this._showUnderline;
-  }
-  set showUnderline(show) {
-    if (this._showUnderline !== show) {
-      this._showUnderline = show;
-      const newHeight = this.calculateDynamicHeight();
-      this.height = newHeight;
-      this.requestRender();
-    }
-  }
-  get showScrollArrows() {
-    return this._showScrollArrows;
-  }
-  set showScrollArrows(show) {
-    if (this._showScrollArrows !== show) {
-      this._showScrollArrows = show;
-      this.requestRender();
-    }
-  }
-  get wrapSelection() {
-    return this._wrapSelection;
-  }
-  set wrapSelection(wrap) {
-    this._wrapSelection = wrap;
-  }
-  get tabWidth() {
-    return this._tabWidth;
-  }
-  set tabWidth(tabWidth) {
-    if (this._tabWidth === tabWidth)
-      return;
-    this._tabWidth = tabWidth;
-    this.maxVisibleTabs = Math.max(1, Math.floor(this.width / this._tabWidth));
-    this.updateScrollOffset();
-    this.requestRender();
-  }
-  set keyBindings(bindings) {
-    this._keyBindings = bindings;
-    const mergedBindings = mergeKeyBindings(defaultTabSelectKeybindings, bindings);
-    this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
-  }
-  set keyAliasMap(aliases) {
-    this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, aliases);
-    const mergedBindings = mergeKeyBindings(defaultTabSelectKeybindings, this._keyBindings);
-    this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
-  }
-}
-
-class TimeToFirstDrawRenderable extends Renderable {
-  _runtimeMs = null;
-  textColor;
-  label;
-  precision;
-  constructor(ctx, options = {}) {
-    super(ctx, {
-      width: "100%",
-      height: 1,
-      flexShrink: 0,
-      alignSelf: "center",
-      ...options
-    });
-    this.textColor = parseColor(options.fg ?? "#AAAAAA");
-    this.label = options.label ?? "Time to first draw";
-    this.precision = this.normalizePrecision(options.precision ?? 2);
-  }
-  get runtimeMs() {
-    return this._runtimeMs;
-  }
-  set fg(value) {
-    this.textColor = parseColor(value);
-    this.requestRender();
-  }
-  set color(value) {
-    this.fg = value;
-  }
-  set textLabel(value) {
-    if (value === this.label) {
-      return;
-    }
-    this.label = value;
-    this.requestRender();
-  }
-  set decimals(value) {
-    const nextPrecision = this.normalizePrecision(value);
-    if (nextPrecision === this.precision) {
-      return;
-    }
-    this.precision = nextPrecision;
-    this.requestRender();
-  }
-  reset() {
-    this._runtimeMs = null;
-    this.requestRender();
-  }
-  renderSelf(buffer) {
-    if (this._runtimeMs === null) {
-      this._runtimeMs = performance.now();
-    }
-    const content = `${this.label}: ${this._runtimeMs.toFixed(this.precision)}ms`;
-    const maxWidth = Math.max(this.width, 1);
-    const visibleContent = content.length > maxWidth ? content.slice(0, maxWidth) : content;
-    const centeredX = this.x + Math.max(0, Math.floor((maxWidth - visibleContent.length) / 2));
-    buffer.drawText(visibleContent, centeredX, this.y, this.textColor);
-  }
-  normalizePrecision(value) {
-    if (!Number.isFinite(value)) {
-      return 2;
-    }
-    return Math.max(0, Math.floor(value));
-  }
-}
-
-// node_modules/@opentui/solid/node_modules/@opentui/core/testing.js
-var decoder2 = new TextDecoder;
-class TestRecorder {
-  renderer;
-  frames = [];
-  recording = false;
-  frameNumber = 0;
-  startTime = 0;
-  originalRenderNative;
-  decoder = new TextDecoder;
-  recordBuffers;
-  now;
-  constructor(renderer, options) {
-    this.renderer = renderer;
-    this.recordBuffers = options?.recordBuffers || {};
-    this.now = options?.now ?? (() => performance.now());
-  }
-  rec() {
-    if (this.recording) {
-      return;
-    }
-    this.recording = true;
-    this.frames = [];
-    this.frameNumber = 0;
-    this.startTime = this.now();
-    this.originalRenderNative = this.renderer["renderNative"].bind(this.renderer);
-    this.renderer["renderNative"] = () => {
-      this.originalRenderNative();
-      this.captureFrame();
-    };
-  }
-  stop() {
-    if (!this.recording) {
-      return;
-    }
-    this.recording = false;
-    if (this.originalRenderNative) {
-      this.renderer["renderNative"] = this.originalRenderNative;
-      this.originalRenderNative = undefined;
-    }
-  }
-  get recordedFrames() {
-    return [...this.frames];
-  }
-  clear() {
-    this.frames = [];
-    this.frameNumber = 0;
-  }
-  get isRecording() {
-    return this.recording;
-  }
-  captureFrame() {
-    const currentBuffer = this.renderer.currentRenderBuffer;
-    const frameBytes = currentBuffer.getRealCharBytes(true);
-    const frame = this.decoder.decode(frameBytes);
-    const recordedFrame = {
-      frame,
-      timestamp: this.now() - this.startTime,
-      frameNumber: this.frameNumber++
-    };
-    if (this.recordBuffers.fg || this.recordBuffers.bg || this.recordBuffers.attributes) {
-      const buffers = currentBuffer.buffers;
-      recordedFrame.buffers = {};
-      if (this.recordBuffers.fg) {
-        recordedFrame.buffers.fg = new Float32Array(buffers.fg);
-      }
-      if (this.recordBuffers.bg) {
-        recordedFrame.buffers.bg = new Float32Array(buffers.bg);
-      }
-      if (this.recordBuffers.attributes) {
-        recordedFrame.buffers.attributes = new Uint8Array(buffers.attributes);
-      }
-    }
-    this.frames.push(recordedFrame);
-  }
-}
-
-// node_modules/solid-js/dist/server.js
-var sharedConfig = {
-  context: undefined,
-  registry: undefined,
-  effects: undefined,
-  done: false,
-  getContextId() {
-    return getContextId(this.context.count);
-  },
-  getNextContextId() {
-    return getContextId(this.context.count++);
-  }
-};
-function getContextId(count) {
-  const num = String(count), len = num.length - 1;
-  return sharedConfig.context.id + (len ? String.fromCharCode(96 + len) : "") + num;
-}
-function setHydrateContext(context) {
-  sharedConfig.context = context;
-}
-function nextHydrateContext() {
-  return {
-    ...sharedConfig.context,
-    id: sharedConfig.getNextContextId(),
-    count: 0
-  };
-}
-var IS_DEV = false;
-var equalFn = (a, b2) => a === b2;
-var $PROXY = Symbol("solid-proxy");
-var SUPPORTS_PROXY = typeof Proxy === "function";
-var $TRACK = Symbol("solid-track");
-var $DEVCOMP = Symbol("solid-dev-component");
-var signalOptions = {
-  equals: equalFn
-};
-var ERROR = null;
-var runEffects = runQueue;
-var STALE = 1;
-var PENDING = 2;
-var UNOWNED = {
-  owned: null,
-  cleanups: null,
-  context: null,
-  owner: null
-};
-var Owner = null;
-var Transition = null;
-var Scheduler = null;
-var ExternalSourceConfig = null;
-var Listener = null;
-var Updates = null;
-var Effects = null;
-var ExecCount = 0;
-function createRoot(fn, detachedOwner) {
-  const listener = Listener, owner = Owner, unowned = fn.length === 0, current = detachedOwner === undefined ? owner : detachedOwner, root = unowned ? UNOWNED : {
-    owned: null,
-    cleanups: null,
-    context: current ? current.context : null,
-    owner: current
-  }, updateFn = unowned ? fn : () => fn(() => untrack(() => cleanNode(root)));
-  Owner = root;
-  Listener = null;
-  try {
-    return runUpdates(updateFn, true);
-  } finally {
-    Listener = listener;
-    Owner = owner;
-  }
-}
-function createSignal(value, options) {
-  options = options ? Object.assign({}, signalOptions, options) : signalOptions;
-  const s = {
-    value,
-    observers: null,
-    observerSlots: null,
-    comparator: options.equals || undefined
-  };
-  const setter = (value2) => {
-    if (typeof value2 === "function") {
-      if (Transition && Transition.running && Transition.sources.has(s))
-        value2 = value2(s.tValue);
-      else
-        value2 = value2(s.value);
-    }
-    return writeSignal(s, value2);
-  };
-  return [readSignal.bind(s), setter];
-}
-function createRenderEffect(fn, value, options) {
-  const c = createComputation(fn, value, false, STALE);
-  if (Scheduler && Transition && Transition.running)
-    Updates.push(c);
-  else
-    updateComputation(c);
-}
-function createEffect(fn, value, options) {
-  runEffects = runUserEffects;
-  const c = createComputation(fn, value, false, STALE), s = SuspenseContext && useContext(SuspenseContext);
-  if (s)
-    c.suspense = s;
-  if (!options || !options.render)
-    c.user = true;
-  Effects ? Effects.push(c) : updateComputation(c);
-}
-function createMemo(fn, value, options) {
-  options = options ? Object.assign({}, signalOptions, options) : signalOptions;
-  const c = createComputation(fn, value, true, 0);
-  c.observers = null;
-  c.observerSlots = null;
-  c.comparator = options.equals || undefined;
-  if (Scheduler && Transition && Transition.running) {
-    c.tState = STALE;
-    Updates.push(c);
-  } else
-    updateComputation(c);
-  return readSignal.bind(c);
-}
-function untrack(fn) {
-  if (!ExternalSourceConfig && Listener === null)
-    return fn();
-  const listener = Listener;
-  Listener = null;
-  try {
-    if (ExternalSourceConfig)
-      return ExternalSourceConfig.untrack(fn);
-    return fn();
-  } finally {
-    Listener = listener;
+    if (this._showScrollArrows && this._options.length > this.maxVisibleTabs) {
+      this.renderScrollArrowsToFrameBuffer(contentX, contentY, contentWidth, contentHeight);
+    }
   }
-}
-function onMount(fn) {
-  createEffect(() => untrack(fn));
-}
-function onCleanup(fn) {
-  if (Owner === null)
-    ;
-  else if (Owner.cleanups === null)
-    Owner.cleanups = [fn];
-  else
-    Owner.cleanups.push(fn);
-  return fn;
-}
-function startTransition(fn) {
-  if (Transition && Transition.running) {
-    fn();
-    return Transition.done;
+  truncateText(text, maxWidth) {
+    if (text.length <= maxWidth)
+      return text;
+    return text.substring(0, Math.max(0, maxWidth - 1)) + "\u2026";
   }
-  const l = Listener;
-  const o = Owner;
-  return Promise.resolve().then(() => {
-    Listener = l;
-    Owner = o;
-    let t2;
-    if (Scheduler || SuspenseContext) {
-      t2 = Transition || (Transition = {
-        sources: new Set,
-        effects: [],
-        promises: new Set,
-        disposed: new Set,
-        queue: new Set,
-        running: true
-      });
-      t2.done || (t2.done = new Promise((res) => t2.resolve = res));
-      t2.running = true;
+  renderScrollArrowsToFrameBuffer(contentX, contentY, contentWidth, contentHeight) {
+    if (!this.frameBuffer)
+      return;
+    const hasMoreLeft = this.scrollOffset > 0;
+    const hasMoreRight = this.scrollOffset + this.maxVisibleTabs < this._options.length;
+    if (hasMoreLeft) {
+      this.frameBuffer.drawText("\u2039", contentX, contentY, parseColor("#AAAAAA"));
     }
-    runUpdates(fn, false);
-    Listener = Owner = null;
-    return t2 ? t2.done : undefined;
-  });
-}
-var [transPending, setTransPending] = /* @__PURE__ */ createSignal(false);
-function createContext(defaultValue, options) {
-  const id = Symbol("context");
-  return {
-    id,
-    Provider: createProvider(id),
-    defaultValue
-  };
-}
-function useContext(context) {
-  let value;
-  return Owner && Owner.context && (value = Owner.context[context.id]) !== undefined ? value : context.defaultValue;
-}
-function children(fn) {
-  const children2 = createMemo(fn);
-  const memo = createMemo(() => resolveChildren(children2()));
-  memo.toArray = () => {
-    const c = memo();
-    return Array.isArray(c) ? c : c != null ? [c] : [];
-  };
-  return memo;
-}
-var SuspenseContext;
-function readSignal() {
-  const runningTransition = Transition && Transition.running;
-  if (this.sources && (runningTransition ? this.tState : this.state)) {
-    if ((runningTransition ? this.tState : this.state) === STALE)
-      updateComputation(this);
-    else {
-      const updates = Updates;
-      Updates = null;
-      runUpdates(() => lookUpstream(this), false);
-      Updates = updates;
+    if (hasMoreRight) {
+      this.frameBuffer.drawText("\u203A", contentX + contentWidth - 1, contentY, parseColor("#AAAAAA"));
     }
   }
-  if (Listener) {
-    const sSlot = this.observers ? this.observers.length : 0;
-    if (!Listener.sources) {
-      Listener.sources = [this];
-      Listener.sourceSlots = [sSlot];
+  setOptions(options) {
+    this._options = options;
+    this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, options.length - 1));
+    this.updateScrollOffset();
+    this.requestRender();
+  }
+  getSelectedOption() {
+    return this._options[this.selectedIndex] || null;
+  }
+  getSelectedIndex() {
+    return this.selectedIndex;
+  }
+  moveLeft() {
+    if (this.selectedIndex > 0) {
+      this.selectedIndex--;
+    } else if (this._wrapSelection && this._options.length > 0) {
+      this.selectedIndex = this._options.length - 1;
     } else {
-      Listener.sources.push(this);
-      Listener.sourceSlots.push(sSlot);
+      return;
     }
-    if (!this.observers) {
-      this.observers = [Listener];
-      this.observerSlots = [Listener.sources.length - 1];
+    this.updateScrollOffset();
+    this.requestRender();
+    this.emit("selectionChanged", this.selectedIndex, this.getSelectedOption());
+  }
+  moveRight() {
+    if (this.selectedIndex < this._options.length - 1) {
+      this.selectedIndex++;
+    } else if (this._wrapSelection && this._options.length > 0) {
+      this.selectedIndex = 0;
     } else {
-      this.observers.push(Listener);
-      this.observerSlots.push(Listener.sources.length - 1);
+      return;
     }
+    this.updateScrollOffset();
+    this.requestRender();
+    this.emit("selectionChanged", this.selectedIndex, this.getSelectedOption());
   }
-  if (runningTransition && Transition.sources.has(this))
-    return this.tValue;
-  return this.value;
-}
-function writeSignal(node, value, isComp) {
-  let current = Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value;
-  if (!node.comparator || !node.comparator(current, value)) {
-    if (Transition) {
-      const TransitionRunning = Transition.running;
-      if (TransitionRunning || !isComp && Transition.sources.has(node)) {
-        Transition.sources.add(node);
-        node.tValue = value;
-      }
-      if (!TransitionRunning)
-        node.value = value;
-    } else
-      node.value = value;
-    if (node.observers && node.observers.length) {
-      runUpdates(() => {
-        for (let i = 0;i < node.observers.length; i += 1) {
-          const o = node.observers[i];
-          const TransitionRunning = Transition && Transition.running;
-          if (TransitionRunning && Transition.disposed.has(o))
-            continue;
-          if (TransitionRunning ? !o.tState : !o.state) {
-            if (o.pure)
-              Updates.push(o);
-            else
-              Effects.push(o);
-            if (o.observers)
-              markDownstream(o);
-          }
-          if (!TransitionRunning)
-            o.state = STALE;
-          else
-            o.tState = STALE;
-        }
-        if (Updates.length > 1e6) {
-          Updates = [];
-          if (IS_DEV)
-            ;
-          throw new Error;
-        }
-      }, false);
+  selectCurrent() {
+    const selected = this.getSelectedOption();
+    if (selected) {
+      this.emit("itemSelected", this.selectedIndex, selected);
     }
   }
-  return value;
-}
-function updateComputation(node) {
-  if (!node.fn)
-    return;
-  cleanNode(node);
-  const time = ExecCount;
-  runComputation(node, Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value, time);
-  if (Transition && !Transition.running && Transition.sources.has(node)) {
-    queueMicrotask(() => {
-      runUpdates(() => {
-        Transition && (Transition.running = true);
-        Listener = Owner = node;
-        runComputation(node, node.tValue, time);
-        Listener = Owner = null;
-      }, false);
-    });
+  setSelectedIndex(index) {
+    if (index >= 0 && index < this._options.length) {
+      this.selectedIndex = index;
+      this.updateScrollOffset();
+      this.requestRender();
+      this.emit("selectionChanged", this.selectedIndex, this.getSelectedOption());
+    }
   }
-}
-function runComputation(node, value, time) {
-  let nextValue;
-  const owner = Owner, listener = Listener;
-  Listener = Owner = node;
-  try {
-    nextValue = node.fn(value);
-  } catch (err) {
-    if (node.pure) {
-      if (Transition && Transition.running) {
-        node.tState = STALE;
-        node.tOwned && node.tOwned.forEach(cleanNode);
-        node.tOwned = undefined;
-      } else {
-        node.state = STALE;
-        node.owned && node.owned.forEach(cleanNode);
-        node.owned = null;
-      }
+  updateScrollOffset() {
+    const halfVisible = Math.floor(this.maxVisibleTabs / 2);
+    const newScrollOffset = Math.max(0, Math.min(this.selectedIndex - halfVisible, this._options.length - this.maxVisibleTabs));
+    if (newScrollOffset !== this.scrollOffset) {
+      this.scrollOffset = newScrollOffset;
+      this.requestRender();
     }
-    node.updatedAt = time + 1;
-    return handleError(err);
-  } finally {
-    Listener = listener;
-    Owner = owner;
   }
-  if (!node.updatedAt || node.updatedAt <= time) {
-    if (node.updatedAt != null && "observers" in node) {
-      writeSignal(node, nextValue, true);
-    } else if (Transition && Transition.running && node.pure) {
-      if (!Transition.sources.has(node))
-        node.value = nextValue;
-      Transition.sources.add(node);
-      node.tValue = nextValue;
-    } else
-      node.value = nextValue;
-    node.updatedAt = time;
+  onResize(width, height) {
+    this.maxVisibleTabs = Math.max(1, Math.floor(width / this._tabWidth));
+    this.updateScrollOffset();
+    this.requestRender();
   }
-}
-function createComputation(fn, init, pure, state = STALE, options) {
-  const c = {
-    fn,
-    state,
-    updatedAt: null,
-    owned: null,
-    sources: null,
-    sourceSlots: null,
-    cleanups: null,
-    value: init,
-    owner: Owner,
-    context: Owner ? Owner.context : null,
-    pure
-  };
-  if (Transition && Transition.running) {
-    c.state = 0;
-    c.tState = state;
+  setTabWidth(tabWidth) {
+    if (this._tabWidth === tabWidth)
+      return;
+    this._tabWidth = tabWidth;
+    this.maxVisibleTabs = Math.max(1, Math.floor(this.width / this._tabWidth));
+    this.updateScrollOffset();
+    this.requestRender();
   }
-  if (Owner === null)
-    ;
-  else if (Owner !== UNOWNED) {
-    if (Transition && Transition.running && Owner.pure) {
-      if (!Owner.tOwned)
-        Owner.tOwned = [c];
-      else
-        Owner.tOwned.push(c);
-    } else {
-      if (!Owner.owned)
-        Owner.owned = [c];
-      else
-        Owner.owned.push(c);
-    }
+  getTabWidth() {
+    return this._tabWidth;
   }
-  if (ExternalSourceConfig && c.fn) {
-    const sourceFn = c.fn;
-    const [track, trigger] = createSignal(undefined, {
-      equals: false
-    });
-    const ordinary = ExternalSourceConfig.factory(sourceFn, trigger);
-    onCleanup(() => ordinary.dispose());
-    let inTransition;
-    const triggerInTransition = () => startTransition(trigger).then(() => {
-      if (inTransition) {
-        inTransition.dispose();
-        inTransition = undefined;
-      }
+  handleKeyPress(key) {
+    const bindingKey = getKeyBindingKey({
+      name: key.name,
+      ctrl: key.ctrl,
+      shift: key.shift,
+      meta: key.meta,
+      super: key.super,
+      action: "move-left"
     });
-    c.fn = (x2) => {
-      track();
-      if (Transition && Transition.running) {
-        if (!inTransition)
-          inTransition = ExternalSourceConfig.factory(sourceFn, triggerInTransition);
-        return inTransition.track(x2);
+    const action = this._keyBindingsMap.get(bindingKey);
+    if (action) {
+      switch (action) {
+        case "move-left":
+          this.moveLeft();
+          return true;
+        case "move-right":
+          this.moveRight();
+          return true;
+        case "select-current":
+          this.selectCurrent();
+          return true;
       }
-      return ordinary.track(x2);
-    };
+    }
+    return false;
   }
-  return c;
-}
-function runTop(node) {
-  const runningTransition = Transition && Transition.running;
-  if ((runningTransition ? node.tState : node.state) === 0)
-    return;
-  if ((runningTransition ? node.tState : node.state) === PENDING)
-    return lookUpstream(node);
-  if (node.suspense && untrack(node.suspense.inFallback))
-    return node.suspense.effects.push(node);
-  const ancestors = [node];
-  while ((node = node.owner) && (!node.updatedAt || node.updatedAt < ExecCount)) {
-    if (runningTransition && Transition.disposed.has(node))
-      return;
-    if (runningTransition ? node.tState : node.state)
-      ancestors.push(node);
+  get options() {
+    return this._options;
   }
-  for (let i = ancestors.length - 1;i >= 0; i--) {
-    node = ancestors[i];
-    if (runningTransition) {
-      let top = node, prev = ancestors[i + 1];
-      while ((top = top.owner) && top !== prev) {
-        if (Transition.disposed.has(top))
-          return;
-      }
-    }
-    if ((runningTransition ? node.tState : node.state) === STALE) {
-      updateComputation(node);
-    } else if ((runningTransition ? node.tState : node.state) === PENDING) {
-      const updates = Updates;
-      Updates = null;
-      runUpdates(() => lookUpstream(node, ancestors[0]), false);
-      Updates = updates;
-    }
+  set options(options) {
+    this._options = options;
+    this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, options.length - 1));
+    this.updateScrollOffset();
+    this.requestRender();
   }
-}
-function runUpdates(fn, init) {
-  if (Updates)
-    return fn();
-  let wait = false;
-  if (!init)
-    Updates = [];
-  if (Effects)
-    wait = true;
-  else
-    Effects = [];
-  ExecCount++;
-  try {
-    const res = fn();
-    completeUpdates(wait);
-    return res;
-  } catch (err) {
-    if (!wait)
-      Effects = null;
-    Updates = null;
-    handleError(err);
+  set backgroundColor(color) {
+    this._backgroundColor = parseColor(color);
+    this.requestRender();
   }
-}
-function completeUpdates(wait) {
-  if (Updates) {
-    if (Scheduler && Transition && Transition.running)
-      scheduleQueue(Updates);
-    else
-      runQueue(Updates);
-    Updates = null;
+  set textColor(color) {
+    this._textColor = parseColor(color);
+    this.requestRender();
   }
-  if (wait)
-    return;
-  let res;
-  if (Transition) {
-    if (!Transition.promises.size && !Transition.queue.size) {
-      const sources = Transition.sources;
-      const disposed = Transition.disposed;
-      Effects.push.apply(Effects, Transition.effects);
-      res = Transition.resolve;
-      for (const e2 of Effects) {
-        "tState" in e2 && (e2.state = e2.tState);
-        delete e2.tState;
-      }
-      Transition = null;
-      runUpdates(() => {
-        for (const d2 of disposed)
-          cleanNode(d2);
-        for (const v2 of sources) {
-          v2.value = v2.tValue;
-          if (v2.owned) {
-            for (let i = 0, len = v2.owned.length;i < len; i++)
-              cleanNode(v2.owned[i]);
-          }
-          if (v2.tOwned)
-            v2.owned = v2.tOwned;
-          delete v2.tValue;
-          delete v2.tOwned;
-          v2.tState = 0;
-        }
-        setTransPending(false);
-      }, false);
-    } else if (Transition.running) {
-      Transition.running = false;
-      Transition.effects.push.apply(Transition.effects, Effects);
-      Effects = null;
-      setTransPending(true);
-      return;
-    }
+  set focusedBackgroundColor(color) {
+    this._focusedBackgroundColor = parseColor(color);
+    this.requestRender();
   }
-  const e = Effects;
-  Effects = null;
-  if (e.length)
-    runUpdates(() => runEffects(e), false);
-  if (res)
-    res();
-}
-function runQueue(queue) {
-  for (let i = 0;i < queue.length; i++)
-    runTop(queue[i]);
-}
-function scheduleQueue(queue) {
-  for (let i = 0;i < queue.length; i++) {
-    const item = queue[i];
-    const tasks = Transition.queue;
-    if (!tasks.has(item)) {
-      tasks.add(item);
-      Scheduler(() => {
-        tasks.delete(item);
-        runUpdates(() => {
-          Transition.running = true;
-          runTop(item);
-        }, false);
-        Transition && (Transition.running = false);
-      });
-    }
+  set focusedTextColor(color) {
+    this._focusedTextColor = parseColor(color);
+    this.requestRender();
+  }
+  set selectedBackgroundColor(color) {
+    this._selectedBackgroundColor = parseColor(color);
+    this.requestRender();
+  }
+  set selectedTextColor(color) {
+    this._selectedTextColor = parseColor(color);
+    this.requestRender();
+  }
+  set selectedDescriptionColor(color) {
+    this._selectedDescriptionColor = parseColor(color);
+    this.requestRender();
   }
-}
-function runUserEffects(queue) {
-  let i, userLength = 0;
-  for (i = 0;i < queue.length; i++) {
-    const e = queue[i];
-    if (!e.user)
-      runTop(e);
-    else
-      queue[userLength++] = e;
+  get showDescription() {
+    return this._showDescription;
   }
-  if (sharedConfig.context) {
-    if (sharedConfig.count) {
-      sharedConfig.effects || (sharedConfig.effects = []);
-      sharedConfig.effects.push(...queue.slice(0, userLength));
-      return;
+  set showDescription(show) {
+    if (this._showDescription !== show) {
+      this._showDescription = show;
+      const newHeight = this.calculateDynamicHeight();
+      this.height = newHeight;
+      this.requestRender();
     }
-    setHydrateContext();
   }
-  if (sharedConfig.effects && (sharedConfig.done || !sharedConfig.count)) {
-    queue = [...sharedConfig.effects, ...queue];
-    userLength += sharedConfig.effects.length;
-    delete sharedConfig.effects;
+  get showUnderline() {
+    return this._showUnderline;
   }
-  for (i = 0;i < userLength; i++)
-    runTop(queue[i]);
-}
-function lookUpstream(node, ignore) {
-  const runningTransition = Transition && Transition.running;
-  if (runningTransition)
-    node.tState = 0;
-  else
-    node.state = 0;
-  for (let i = 0;i < node.sources.length; i += 1) {
-    const source = node.sources[i];
-    if (source.sources) {
-      const state = runningTransition ? source.tState : source.state;
-      if (state === STALE) {
-        if (source !== ignore && (!source.updatedAt || source.updatedAt < ExecCount))
-          runTop(source);
-      } else if (state === PENDING)
-        lookUpstream(source, ignore);
+  set showUnderline(show) {
+    if (this._showUnderline !== show) {
+      this._showUnderline = show;
+      const newHeight = this.calculateDynamicHeight();
+      this.height = newHeight;
+      this.requestRender();
     }
   }
-}
-function markDownstream(node) {
-  const runningTransition = Transition && Transition.running;
-  for (let i = 0;i < node.observers.length; i += 1) {
-    const o = node.observers[i];
-    if (runningTransition ? !o.tState : !o.state) {
-      if (runningTransition)
-        o.tState = PENDING;
-      else
-        o.state = PENDING;
-      if (o.pure)
-        Updates.push(o);
-      else
-        Effects.push(o);
-      o.observers && markDownstream(o);
-    }
+  get showScrollArrows() {
+    return this._showScrollArrows;
   }
-}
-function cleanNode(node) {
-  let i;
-  if (node.sources) {
-    while (node.sources.length) {
-      const source = node.sources.pop(), index = node.sourceSlots.pop(), obs = source.observers;
-      if (obs && obs.length) {
-        const n = obs.pop(), s = source.observerSlots.pop();
-        if (index < obs.length) {
-          n.sourceSlots[s] = index;
-          obs[index] = n;
-          source.observerSlots[index] = s;
-        }
-      }
+  set showScrollArrows(show) {
+    if (this._showScrollArrows !== show) {
+      this._showScrollArrows = show;
+      this.requestRender();
     }
   }
-  if (node.tOwned) {
-    for (i = node.tOwned.length - 1;i >= 0; i--)
-      cleanNode(node.tOwned[i]);
-    delete node.tOwned;
+  get wrapSelection() {
+    return this._wrapSelection;
   }
-  if (Transition && Transition.running && node.pure) {
-    reset(node, true);
-  } else if (node.owned) {
-    for (i = node.owned.length - 1;i >= 0; i--)
-      cleanNode(node.owned[i]);
-    node.owned = null;
+  set wrapSelection(wrap) {
+    this._wrapSelection = wrap;
   }
-  if (node.cleanups) {
-    for (i = node.cleanups.length - 1;i >= 0; i--)
-      node.cleanups[i]();
-    node.cleanups = null;
+  get tabWidth() {
+    return this._tabWidth;
   }
-  if (Transition && Transition.running)
-    node.tState = 0;
-  else
-    node.state = 0;
-}
-function reset(node, top) {
-  if (!top) {
-    node.tState = 0;
-    Transition.disposed.add(node);
+  set tabWidth(tabWidth) {
+    if (this._tabWidth === tabWidth)
+      return;
+    this._tabWidth = tabWidth;
+    this.maxVisibleTabs = Math.max(1, Math.floor(this.width / this._tabWidth));
+    this.updateScrollOffset();
+    this.requestRender();
   }
-  if (node.owned) {
-    for (let i = 0;i < node.owned.length; i++)
-      reset(node.owned[i]);
+  set keyBindings(bindings) {
+    this._keyBindings = bindings;
+    const mergedBindings = mergeKeyBindings(defaultTabSelectKeybindings, bindings);
+    this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
   }
-}
-function castError(err) {
-  if (err instanceof Error)
-    return err;
-  return new Error(typeof err === "string" ? err : "Unknown error", {
-    cause: err
-  });
-}
-function runErrors(err, fns, owner) {
-  try {
-    for (const f of fns)
-      f(err);
-  } catch (e) {
-    handleError(e, owner && owner.owner || null);
+  set keyAliasMap(aliases) {
+    this._keyAliasMap = mergeKeyAliases(defaultKeyAliases, aliases);
+    const mergedBindings = mergeKeyBindings(defaultTabSelectKeybindings, this._keyBindings);
+    this._keyBindingsMap = buildKeyBindingsMap(mergedBindings, this._keyAliasMap);
   }
 }
-function handleError(err, owner = Owner) {
-  const fns = ERROR && owner && owner.context && owner.context[ERROR];
-  const error = castError(err);
-  if (!fns)
-    throw error;
-  if (Effects)
-    Effects.push({
-      fn() {
-        runErrors(error, fns, owner);
-      },
-      state: STALE
+
+class TimeToFirstDrawRenderable extends Renderable {
+  _runtimeMs = null;
+  textColor;
+  label;
+  precision;
+  constructor(ctx, options = {}) {
+    super(ctx, {
+      width: "100%",
+      height: 1,
+      flexShrink: 0,
+      alignSelf: "center",
+      ...options
     });
-  else
-    runErrors(error, fns, owner);
-}
-function resolveChildren(children2) {
-  if (typeof children2 === "function" && !children2.length)
-    return resolveChildren(children2());
-  if (Array.isArray(children2)) {
-    const results = [];
-    for (let i = 0;i < children2.length; i++) {
-      const result = resolveChildren(children2[i]);
-      Array.isArray(result) ? results.push.apply(results, result) : results.push(result);
+    this.textColor = parseColor(options.fg ?? "#AAAAAA");
+    this.label = options.label ?? "Time to first draw";
+    this.precision = this.normalizePrecision(options.precision ?? 2);
+  }
+  get runtimeMs() {
+    return this._runtimeMs;
+  }
+  set fg(value) {
+    this.textColor = parseColor(value);
+    this.requestRender();
+  }
+  set color(value) {
+    this.fg = value;
+  }
+  set textLabel(value) {
+    if (value === this.label) {
+      return;
     }
-    return results;
+    this.label = value;
+    this.requestRender();
   }
-  return children2;
-}
-function createProvider(id, options) {
-  return function provider(props) {
-    let res;
-    createRenderEffect(() => res = untrack(() => {
-      Owner.context = {
-        ...Owner.context,
-        [id]: props.value
-      };
-      return children(() => props.children);
-    }), undefined);
-    return res;
-  };
-}
-var FALLBACK = Symbol("fallback");
-function dispose(d2) {
-  for (let i = 0;i < d2.length; i++)
-    d2[i]();
-}
-function mapArray(list, mapFn, options = {}) {
-  let items = [], mapped = [], disposers = [], len = 0, indexes = mapFn.length > 1 ? [] : null;
-  onCleanup(() => dispose(disposers));
-  return () => {
-    let newItems = list() || [], newLen = newItems.length, i, j2;
-    newItems[$TRACK];
-    return untrack(() => {
-      let newIndices, newIndicesNext, temp, tempdisposers, tempIndexes, start, end, newEnd, item;
-      if (newLen === 0) {
-        if (len !== 0) {
-          dispose(disposers);
-          disposers = [];
-          items = [];
-          mapped = [];
-          len = 0;
-          indexes && (indexes = []);
-        }
-        if (options.fallback) {
-          items = [FALLBACK];
-          mapped[0] = createRoot((disposer) => {
-            disposers[0] = disposer;
-            return options.fallback();
-          });
-          len = 1;
-        }
-      } else if (len === 0) {
-        mapped = new Array(newLen);
-        for (j2 = 0;j2 < newLen; j2++) {
-          items[j2] = newItems[j2];
-          mapped[j2] = createRoot(mapper);
-        }
-        len = newLen;
-      } else {
-        temp = new Array(newLen);
-        tempdisposers = new Array(newLen);
-        indexes && (tempIndexes = new Array(newLen));
-        for (start = 0, end = Math.min(len, newLen);start < end && items[start] === newItems[start]; start++)
-          ;
-        for (end = len - 1, newEnd = newLen - 1;end >= start && newEnd >= start && items[end] === newItems[newEnd]; end--, newEnd--) {
-          temp[newEnd] = mapped[end];
-          tempdisposers[newEnd] = disposers[end];
-          indexes && (tempIndexes[newEnd] = indexes[end]);
-        }
-        newIndices = new Map;
-        newIndicesNext = new Array(newEnd + 1);
-        for (j2 = newEnd;j2 >= start; j2--) {
-          item = newItems[j2];
-          i = newIndices.get(item);
-          newIndicesNext[j2] = i === undefined ? -1 : i;
-          newIndices.set(item, j2);
-        }
-        for (i = start;i <= end; i++) {
-          item = items[i];
-          j2 = newIndices.get(item);
-          if (j2 !== undefined && j2 !== -1) {
-            temp[j2] = mapped[i];
-            tempdisposers[j2] = disposers[i];
-            indexes && (tempIndexes[j2] = indexes[i]);
-            j2 = newIndicesNext[j2];
-            newIndices.set(item, j2);
-          } else
-            disposers[i]();
-        }
-        for (j2 = start;j2 < newLen; j2++) {
-          if (j2 in temp) {
-            mapped[j2] = temp[j2];
-            disposers[j2] = tempdisposers[j2];
-            if (indexes) {
-              indexes[j2] = tempIndexes[j2];
-              indexes[j2](j2);
-            }
-          } else
-            mapped[j2] = createRoot(mapper);
-        }
-        mapped = mapped.slice(0, len = newLen);
-        items = newItems.slice(0);
-      }
-      return mapped;
-    });
-    function mapper(disposer) {
-      disposers[j2] = disposer;
-      if (indexes) {
-        const [s, set] = createSignal(j2);
-        indexes[j2] = set;
-        return mapFn(newItems[j2], s);
-      }
-      return mapFn(newItems[j2]);
+  set decimals(value) {
+    const nextPrecision = this.normalizePrecision(value);
+    if (nextPrecision === this.precision) {
+      return;
     }
-  };
-}
-var hydrationEnabled = false;
-function createComponent(Comp, props) {
-  if (hydrationEnabled) {
-    if (sharedConfig.context) {
-      const c = sharedConfig.context;
-      setHydrateContext(nextHydrateContext());
-      const r = untrack(() => Comp(props || {}));
-      setHydrateContext(c);
-      return r;
+    this.precision = nextPrecision;
+    this.requestRender();
+  }
+  reset() {
+    this._runtimeMs = null;
+    this.requestRender();
+  }
+  renderSelf(buffer) {
+    if (this._runtimeMs === null) {
+      this._runtimeMs = performance.now();
     }
+    const content = `${this.label}: ${this._runtimeMs.toFixed(this.precision)}ms`;
+    const maxWidth = Math.max(this.width, 1);
+    const visibleContent = content.length > maxWidth ? content.slice(0, maxWidth) : content;
+    const centeredX = this.x + Math.max(0, Math.floor((maxWidth - visibleContent.length) / 2));
+    buffer.drawText(visibleContent, centeredX, this.y, this.textColor);
+  }
+  normalizePrecision(value) {
+    if (!Number.isFinite(value)) {
+      return 2;
+    }
+    return Math.max(0, Math.floor(value));
   }
-  return untrack(() => Comp(props || {}));
-}
-function trueFn() {
-  return true;
 }
-var propTraps = {
-  get(_2, property, receiver) {
-    if (property === $PROXY)
-      return receiver;
-    return _2.get(property);
-  },
-  has(_2, property) {
-    if (property === $PROXY)
-      return true;
-    return _2.has(property);
-  },
-  set: trueFn,
-  deleteProperty: trueFn,
-  getOwnPropertyDescriptor(_2, property) {
-    return {
-      configurable: true,
-      enumerable: true,
-      get() {
-        return _2.get(property);
-      },
-      set: trueFn,
-      deleteProperty: trueFn
+
+// node_modules/@opentui/solid/node_modules/@opentui/core/testing.js
+var decoder2 = new TextDecoder;
+class TestRecorder {
+  renderer;
+  frames = [];
+  recording = false;
+  frameNumber = 0;
+  startTime = 0;
+  originalRenderNative;
+  decoder = new TextDecoder;
+  recordBuffers;
+  now;
+  constructor(renderer, options) {
+    this.renderer = renderer;
+    this.recordBuffers = options?.recordBuffers || {};
+    this.now = options?.now ?? (() => performance.now());
+  }
+  rec() {
+    if (this.recording) {
+      return;
+    }
+    this.recording = true;
+    this.frames = [];
+    this.frameNumber = 0;
+    this.startTime = this.now();
+    this.originalRenderNative = this.renderer["renderNative"].bind(this.renderer);
+    this.renderer["renderNative"] = () => {
+      this.originalRenderNative();
+      this.captureFrame();
     };
-  },
-  ownKeys(_2) {
-    return _2.keys();
   }
-};
-function resolveSource(s) {
-  return !(s = typeof s === "function" ? s() : s) ? {} : s;
-}
-function resolveSources() {
-  for (let i = 0, length = this.length;i < length; ++i) {
-    const v2 = this[i]();
-    if (v2 !== undefined)
-      return v2;
+  stop() {
+    if (!this.recording) {
+      return;
+    }
+    this.recording = false;
+    if (this.originalRenderNative) {
+      this.renderer["renderNative"] = this.originalRenderNative;
+      this.originalRenderNative = undefined;
+    }
   }
-}
-function mergeProps(...sources) {
-  let proxy = false;
-  for (let i = 0;i < sources.length; i++) {
-    const s = sources[i];
-    proxy = proxy || !!s && $PROXY in s;
-    sources[i] = typeof s === "function" ? (proxy = true, createMemo(s)) : s;
+  get recordedFrames() {
+    return [...this.frames];
   }
-  if (SUPPORTS_PROXY && proxy) {
-    return new Proxy({
-      get(property) {
-        for (let i = sources.length - 1;i >= 0; i--) {
-          const v2 = resolveSource(sources[i])[property];
-          if (v2 !== undefined)
-            return v2;
-        }
-      },
-      has(property) {
-        for (let i = sources.length - 1;i >= 0; i--) {
-          if (property in resolveSource(sources[i]))
-            return true;
-        }
-        return false;
-      },
-      keys() {
-        const keys = [];
-        for (let i = 0;i < sources.length; i++)
-          keys.push(...Object.keys(resolveSource(sources[i])));
-        return [...new Set(keys)];
-      }
-    }, propTraps);
+  clear() {
+    this.frames = [];
+    this.frameNumber = 0;
   }
-  const sourcesMap = {};
-  const defined = Object.create(null);
-  for (let i = sources.length - 1;i >= 0; i--) {
-    const source = sources[i];
-    if (!source)
-      continue;
-    const sourceKeys = Object.getOwnPropertyNames(source);
-    for (let i2 = sourceKeys.length - 1;i2 >= 0; i2--) {
-      const key = sourceKeys[i2];
-      if (key === "__proto__" || key === "constructor")
-        continue;
-      const desc = Object.getOwnPropertyDescriptor(source, key);
-      if (!defined[key]) {
-        defined[key] = desc.get ? {
-          enumerable: true,
-          configurable: true,
-          get: resolveSources.bind(sourcesMap[key] = [desc.get.bind(source)])
-        } : desc.value !== undefined ? desc : undefined;
-      } else {
-        const sources2 = sourcesMap[key];
-        if (sources2) {
-          if (desc.get)
-            sources2.push(desc.get.bind(source));
-          else if (desc.value !== undefined)
-            sources2.push(() => desc.value);
-        }
+  get isRecording() {
+    return this.recording;
+  }
+  captureFrame() {
+    const currentBuffer = this.renderer.currentRenderBuffer;
+    const frameBytes = currentBuffer.getRealCharBytes(true);
+    const frame = this.decoder.decode(frameBytes);
+    const recordedFrame = {
+      frame,
+      timestamp: this.now() - this.startTime,
+      frameNumber: this.frameNumber++
+    };
+    if (this.recordBuffers.fg || this.recordBuffers.bg || this.recordBuffers.attributes) {
+      const buffers = currentBuffer.buffers;
+      recordedFrame.buffers = {};
+      if (this.recordBuffers.fg) {
+        recordedFrame.buffers.fg = new Float32Array(buffers.fg);
+      }
+      if (this.recordBuffers.bg) {
+        recordedFrame.buffers.bg = new Float32Array(buffers.bg);
+      }
+      if (this.recordBuffers.attributes) {
+        recordedFrame.buffers.attributes = new Uint8Array(buffers.attributes);
       }
     }
+    this.frames.push(recordedFrame);
   }
-  const target = {};
-  const definedKeys = Object.keys(defined);
-  for (let i = definedKeys.length - 1;i >= 0; i--) {
-    const key = definedKeys[i], desc = defined[key];
-    if (desc && desc.get)
-      Object.defineProperty(target, key, desc);
-    else
-      target[key] = desc ? desc.value : undefined;
-  }
-  return target;
-}
-var narrowedError = (name) => `Stale read from <${name}>.`;
-function For(props) {
-  const fallback = "fallback" in props && {
-    fallback: () => props.fallback
-  };
-  return createMemo(mapArray(() => props.each, props.children, fallback || undefined));
-}
-function Show(props) {
-  const keyed = props.keyed;
-  const conditionValue = createMemo(() => props.when, undefined, undefined);
-  const condition = keyed ? conditionValue : createMemo(conditionValue, undefined, {
-    equals: (a, b2) => !a === !b2
-  });
-  return createMemo(() => {
-    const c = condition();
-    if (c) {
-      const child = props.children;
-      const fn = typeof child === "function" && child.length > 0;
-      return fn ? untrack(() => child(keyed ? c : () => {
-        if (!untrack(condition))
-          throw narrowedError("Show");
-        return conditionValue();
-      })) : child;
-    }
-    return props.fallback;
-  }, undefined, undefined);
 }
 
 // node_modules/entities/dist/esm/decode-codepoint.js
@@ -43208,17 +43208,43 @@ async function main2() {
   };
   const hasConfig = await configExists();
   if (!hasConfig) {
-    await render(() => ConfigWizard({
-      isFirstRun: true,
-      onComplete: async () => {
-        await bootApp(appRoot, rendererConfig, resumeSessionId);
+    const [boot, setBoot] = createSignal(null);
+    await render(() => Show({
+      get when() {
+        return boot();
+      },
+      get fallback() {
+        return ConfigWizard({
+          isFirstRun: true,
+          onComplete: async () => {
+            const result = await buildOrchestrator(appRoot, resumeSessionId);
+            setBoot(result);
+          }
+        });
+      },
+      get children() {
+        const b2 = boot();
+        if (!b2)
+          return null;
+        return App({
+          orchestrator: b2.orchestrator,
+          config: b2.config,
+          configPath: b2.configPath,
+          resumeSessionId
+        });
       }
     }), rendererConfig);
   } else {
-    await bootApp(appRoot, rendererConfig, resumeSessionId);
+    const result = await buildOrchestrator(appRoot, resumeSessionId);
+    await render(() => App({
+      orchestrator: result.orchestrator,
+      config: result.config,
+      configPath: result.configPath,
+      resumeSessionId
+    }), rendererConfig);
   }
 }
-async function bootApp(appRoot, rendererConfig, resumeSessionId) {
+async function buildOrchestrator(appRoot, resumeSessionId) {
   const configPath = await resolveConfigPath(appRoot);
   const config = await loadConfig2(configPath);
   const humanName = config.humanName?.trim() || "USER";
@@ -43309,7 +43335,7 @@ ${mySkills.map((s) => `- ${s}`).join(`
   const defaultTimeout = typeof config.timeout === "number" && config.timeout > 0 ? config.timeout * 1000 : 600000;
   const agentTimeouts = Object.fromEntries(activeAgents.filter((agent) => typeof agent.timeout === "number" && agent.timeout > 0).map((agent) => [agent.name, agent.timeout * 1000]));
   const orchestrator = new Orchestrator(adapters, humanName, Object.fromEntries(activeAgents.map((agent) => [agent.name, agent.tag?.trim() || toTag(agent.name)])), humanTag, defaultTimeout, agentTimeouts, { reminderInterval: config.reminderInterval, maxAutoHops });
-  await render(() => App({ orchestrator, config, configPath, resumeSessionId }), rendererConfig);
+  return { orchestrator, config, configPath };
 }
 function resolveMaxAutoHops(value) {
   if (typeof value === "number" && value === 0) {