@zaly/tui 0.0.7 → 0.0.9

package/dist/queries-Cvalgu6P.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"queries-Cvalgu6P.d.mts","names":[],"sources":["../src/input/keys.ts","../src/input/decoder.ts","../src/input/actions.ts","../src/layout/size.ts","../src/core/reactive.ts","../src/core/state.ts","../src/layout/border.ts","../src/widgets/text.ts","../src/widgets/box.ts","../src/widgets/overlay.ts","../src/core/ctx.ts","../src/widgets/log.ts","../src/services/logger.ts","../src/renderer/terminal.ts","../src/renderer/frame.ts","../src/renderer/surface.ts","../src/renderer/overlay.ts","../src/renderer/selection.ts","../src/renderer/stream.ts","../src/renderer/ui.ts","../src/renderer/renderer.ts","../src/core/node.ts","../src/input/router.ts","../src/input/queries.ts"],"mappings":"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"}
+{"version":3,"file":"queries-Cvalgu6P.d.mts","names":["_$___core_state_ts0.Layout","_$__box_ts0.Box","_$__terminal_ts0.Terminal"],"sources":["../src/input/keys.ts","../src/input/decoder.ts","../src/input/actions.ts","../src/layout/size.ts","../src/core/reactive.ts","../src/core/state.ts","../src/layout/border.ts","../src/widgets/text.ts","../src/widgets/box.ts","../src/widgets/overlay.ts","../src/core/ctx.ts","../src/widgets/log.ts","../src/services/logger.ts","../src/renderer/terminal.ts","../src/renderer/frame.ts","../src/renderer/surface.ts","../src/renderer/overlay.ts","../src/renderer/selection.ts","../src/renderer/stream.ts","../src/renderer/ui.ts","../src/renderer/renderer.ts","../src/core/node.ts","../src/input/router.ts","../src/input/queries.ts"],"mappings":"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"}

package/dist/reactive-f7NpAi69.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"reactive-f7NpAi69.mjs","names":[],"sources":["../src/core/reactive.ts"],"sourcesContent":["import type { MaybePromise } from \"@zaly/shared\"\nimport type { Node } from \"./node.ts\"\n\nimport { AsyncLocalStorage } from \"node:async_hooks\"\n\n/**\n * Solid-style fine-grained reactivity.\n *\n * `signal(initial)` → `[read, write]` tuple. Reads inside a\n * tracking context (node render, effect, memo) auto-subscribe;\n * writes invalidate every subscriber. Cross-async-boundary tracking\n * uses `AsyncLocalStorage` so reads after an `await` still subscribe\n * the correct context.\n *\n * ```ts\n * const [status, setStatus] = signal(\"streaming\")\n * text(({ style }) => style.success(status()))   // auto-subscribes\n * setStatus(\"done\")\n * ```\n *\n * Builds on three primitives:\n *   - `signal`    — reactive value.\n *   - `memo`      — cached derived signal.\n *   - `effect`    — imperative side-effect that re-runs on dep change.\n *\n * Widgets expose `Reactive<T>` props and call `unwrap()` inside\n * `_render` to resolve them — that's the bridge from app-level\n * signals into the render tree.\n */\n\n// ---- tracking context ------------------------------------------------\n\n/** Context carried through a tracking scope. Subscribers that want to\n *  be signal-aware implement this; signals read the current context\n *  during `read()` and add `notify` to their subscriber set. `register`\n *  lets the context remember the cleanup closure so it can\n *  unsubscribe later (on unmount / dispose / re-run). */\ninterface TrackingCtx {\n  notify: () => void\n  register: (cleanup: () => void) => void\n}\n\nconst activeCtx = new AsyncLocalStorage<TrackingCtx | undefined>()\n\nfunction withTracking<T>(ctx: TrackingCtx, fn: () => T): T {\n  return activeCtx.run(ctx, fn)\n}\n\n/** Run `fn` outside any tracking scope. Signal reads inside don't\n *  subscribe the surrounding render, and async work started inside\n *  (timers, promises, intervals) doesn't capture the current ctx —\n *  callbacks fire with `getStore() === undefined`.\n *\n *  Use this when starting persistent async work from inside a render\n *  pass: a `setInterval` set up during `_render` would otherwise\n *  inherit the render's ALS context, and every timer tick would look\n *  like it's \"inside\" that render — its invalidates would be silently\n *  suppressed.\n *\n *  ```ts\n *  // inside _render() or a render-driven reconcile():\n *  untracked(() => {\n *    this.#timer = setInterval(() => this.invalidate(), speed)\n *  })\n *  ```\n *\n *  Equivalent to Solid's `untrack`. */\nexport function untrack<T>(fn: () => T): T {\n  return activeCtx.run(undefined, fn)\n}\n\n/** Resolve a `Reactive<T>` to its current `T` without subscribing to\n * any tracking context. */\nexport function peek<T>(s: Reactive<T>): T {\n  return untrack(() => unwrap(s))\n}\n\n// ---- context ---------------------------------------------------------\n\n/**\n * Solid-style context for sharing values down the owner chain without\n * prop-drilling. Widgets publish values via `provideContext` (in setup\n * or `_render`); descendants read via `useContext`.\n *\n * ```ts\n * const ThemeOverride = createContext<Theme | undefined>(undefined)\n *\n * // provider (in a widget body / setup / _render):\n * provideContext(ThemeOverride, customTheme)\n *\n * // consumer (anywhere with an active node or owner chain):\n * const theme = useContext(ThemeOverride) ?? defaultTheme\n * ```\n *\n * Implementation: each `Node` carries an optional `#contexts` map keyed\n * by context id. Lookups walk the *owner frame chain* (`OwnerFrame.owner`\n * pointers), reading the live `#contexts` of each frame's node and\n * falling back to the context's default if no ancestor provides it.\n *\n * The owner chain is the render-call ancestry captured at frame push\n * (via `withActiveNode`) — independent of mount status. Effects/memos\n * capture their creation frame and re-establish it on re-fire, so\n * detached re-runs walk the same chain they would have at creation.\n */\nexport interface Context<T> {\n  readonly id: symbol\n  readonly defaultValue: T\n}\n\nexport function createContext<T>(): Context<T | undefined>\nexport function createContext<T>(defaultValue: T): Context<T>\nexport function createContext<T>(defaultValue?: T): Context<T | undefined> {\n  return { defaultValue, id: Symbol(\"@zaly/tui/context\") }\n}\n\n/** Publish `value` for `ctx` on the active Owner. Persistent for the\n *  Owner's lifetime. Descendants (in the render-call sense) that read\n *  via `useContext` walk up the Owner chain and find it. */\nexport function provideContext<T>(ctx: Context<T>, value: T): void {\n  const owner = activeOwnerStore.getStore()\n  if (owner === undefined) {\n    throw new Error(\"provideContext: no active Owner — call from a widget body / _render\")\n  }\n  owner.setContext(ctx.id, value)\n}\n\n/** Read the current value of `ctx`. Walks the Owner chain\n *  (render-call ancestry, not mount tree). Returns the context's\n *  default when no ancestor has provided a value. */\nexport function useContext<T>(ctx: Context<T>): T {\n  for (let o = activeOwnerStore.getStore(); o !== undefined; o = o.parent) {\n    const map = o.contexts\n    if (map?.has(ctx.id)) return map.get(ctx.id) as T\n  }\n  return ctx.defaultValue\n}\n\n// ---- public types ----------------------------------------------------\n\n/** Brand tag: every accessor / setter returned by `signal` / `memo`\n *  carries this symbol so `unwrap` can tell a reactive source from a\n *  plain function-valued prop (label formatter, text callback, etc.). */\nconst REACTIVE = Symbol.for(\"@zaly/tui/reactive\")\n\nexport type Signal<T> = readonly [get: Accessor<T>, set: Setter<T>] & {\n  readonly get: Accessor<T>\n  readonly set: Setter<T>\n}\n\n/** A read-only reactive source. Branded so `isAccessor` can detect it\n *  without false positives on arbitrary callables. */\nexport type Accessor<T> = (() => T) & { readonly [REACTIVE]: \"get\" }\n\n/** A signal setter. Same branding as `Accessor` (different tag) so a\n *  setter isn't mistaken for an accessor by `unwrap`. */\nexport type Setter<T> = ((next: T | ((prev: T) => T)) => void) & { readonly [REACTIVE]: \"set\" }\n\n/** A widget prop that's either a literal value or a reactive accessor. */\nexport type Reactive<T> = T | Accessor<T>\n\n/** Runtime check: `true` when `v` was produced by `signal` / `memo`.\n *  False for plain callables (text-content functions, label formatters).\n *\n *  @internal */\nexport function isAccessor<T>(v: unknown): v is Accessor<T> {\n  return typeof v === \"function\" && (v as { [REACTIVE]?: string })[REACTIVE] === \"get\"\n}\n\n/** Resolve a `Reactive<T>` to its current `T`. Call inside `_render`\n *  so accessor reads subscribe the rendering node. Only brand-tagged\n *  accessors are invoked — other function values pass through\n *  untouched, so widgets whose `T` is itself a function type (label\n *  formatters etc.) don't need a hand-rolled guard. */\nexport function unwrap<T>(v: Reactive<T>): T {\n  return isAccessor<T>(v) ? v() : v\n}\n\nfunction brand<F extends (...args: any[]) => any>(fn: F, tag: \"get\"): Accessor<ReturnType<F>>\nfunction brand<F extends (...args: any[]) => any>(fn: F, tag: \"set\"): Setter<Parameters<F>[0]>\nfunction brand<F extends (...args: any[]) => any>(fn: F, tag: \"get\" | \"set\"): F {\n  Object.defineProperty(fn, REACTIVE, {\n    configurable: false,\n    enumerable: false,\n    value: tag,\n    writable: false,\n  })\n  return fn\n}\n\n// ---- Owner -----------------------------------------------------------\n\n/**\n * Reactive ownership scope — bundles cleanups + provided contexts\n * scoped to a single widget body (or a `createRoot` headless scope).\n *\n * Owners form a chain via `parent` mirroring the call-time widget\n * nesting: when `widget()` is invoked inside another widget's body,\n * `createNode` creates the inner Owner with `parent =\n * activeOwnerStore.getStore()` (the outer widget's Owner). That chain\n * is what `useContext` walks.\n *\n * Owners are **not** bound to Nodes anymore — a widget's `createNode`\n * pairs the Owner with the constructed Node only through\n * `Node.once(\"unmount\", () => owner.dispose())`. Primitive Nodes\n * (`text`, `box`, …) don't get their own Owner; they share whatever\n * Owner created them.\n *\n * Use `onCleanup(cb)` to register cleanups against the active Owner.\n * Disposing the Owner runs them in reverse-registration order.\n *\n * @internal\n */\nexport class Owner {\n  parent?: Owner\n  #cleanups: (() => void)[] = []\n  #contexts?: Map<symbol, unknown>\n  #disposed = false\n\n  constructor(parent?: Owner) {\n    this.parent = parent\n  }\n\n  get disposed(): boolean {\n    return this.#disposed\n  }\n\n  /** Live view of this Owner's provided contexts. Populated by\n   *  `provideContext`. Walked upward via `parent` by `useContext`. */\n  get contexts(): ReadonlyMap<symbol, unknown> | undefined {\n    return this.#contexts\n  }\n\n  setContext(id: symbol, value: unknown): void {\n    ;(this.#contexts ??= new Map()).set(id, value)\n  }\n\n  /** Register a cleanup. Runs on `dispose()`. */\n  addCleanup(fn: () => void): void {\n    if (this.#disposed) {\n      fn()\n      return\n    }\n    this.#cleanups.push(fn)\n  }\n\n  /** Fire cleanups in reverse-registration order. Idempotent. */\n  dispose(): void {\n    if (this.#disposed) return\n    this.#disposed = true\n    for (let i = this.#cleanups.length - 1; i >= 0; i--) {\n      try {\n        this.#cleanups[i]()\n      } catch (error) {\n        // Don't let one bad cleanup poison the rest.\n        // oxlint-disable-next-line no-console\n        console.error(\"Owner cleanup threw:\", error)\n      }\n    }\n    this.#cleanups = []\n    this.#contexts = undefined\n  }\n}\n\nconst activeOwnerStore = new AsyncLocalStorage<Owner | undefined>()\n\n/** Run `fn` as the `node`'s render pass. Signal reads inside subscribe\n *  the node's tracking ctx; the ctx's `notify` is `node.invalidate`,\n *  so any signal write that this render depended on invalidates the\n *  node and clears its cache. Cleanups are registered against the\n *  Node's `unmount` event.\n *\n *  Does **not** push an Owner — primitive Nodes share whatever Owner\n *  was active in their caller. Widget bodies install their own Owner\n *  via `createNode` at construction time, which is when `useContext`\n *  / `provideContext` / `effect` / `memo` care about the active scope.\n *\n *  @internal */\nexport function withActiveNode<T>(node: Node, fn: () => T): T {\n  return withTracking(getNodeTrackingCtx(node), fn)\n}\n\n/** Run `fn` with a pre-existing Owner restored. Used by `effect` /\n *  `memo` to re-establish their creation-time owner chain on re-fire,\n *  so `useContext` walks the same ancestry regardless of whether the\n *  re-fire was triggered from inside or outside a render.\n *\n *  @internal */\nexport function withOwner<T>(owner: Owner, fn: () => T): T {\n  return activeOwnerStore.run(owner, fn)\n}\n\nfunction getNodeTrackingCtx(node: Node): TrackingCtx {\n  let ctx = nodeCtx.get(node)\n  if (ctx === undefined) {\n    ctx = {\n      notify: () => node.invalidate(),\n      register: (cleanup) => {\n        node.once(\"unmount\", cleanup)\n      },\n    }\n    nodeCtx.set(node, ctx)\n  }\n  return ctx\n}\n\n/** Create a fresh Owner scope and run `fn` inside it. Returns\n *  whatever `fn` returns. The Owner's parent is whatever was active at\n *  the call site (or `undefined` at module top).\n *\n *  The Owner is *not* auto-disposed — callers manage its lifetime via\n *  the Owner returned alongside the result, or (more commonly) by\n *  binding the Owner to a Node and disposing it on that Node's\n *  unmount.\n *\n *  Typical use is via a surface's function-shape `add(fn)` API which\n *  wraps this internally:\n *\n *  ```ts\n *  ui.add(() => {\n *    const [count, setCount] = signal(0)\n *    onCleanup(() => console.log(\"gone\"))\n *    return text(() => `count: ${count()}`)\n *  })\n *  ```\n *\n *  For headless reactive scopes (tests, programmatic effects), call\n *  `createRoot` directly:\n *\n *  ```ts\n *  const { result, owner } = createRoot(() => signal(0))\n *  // ... use result ...\n *  owner.dispose()\n *  ```\n */\nexport function createRoot<T>(fn: (dispose: () => void) => T): T {\n  const parent = activeOwnerStore.getStore()\n  const owner = new Owner(parent)\n  return withOwner(owner, () => fn(() => owner.dispose()))\n}\n\n/** Run `fn` inside a fresh Owner scope and bind the returned Node to\n *  that scope — when the Node unmounts, the Owner disposes (firing\n *  every `onCleanup`, tearing down every `effect` / `memo` /\n *  `createAsync` registered in the body).\n *\n *  This is what `widget()` calls under the hood: it's the per-instance\n *  scope boundary. Surfaces also call it directly at their `add` /\n *  `append` entry points so each appended subtree gets its own root.\n *\n *  ```ts\n *  ui.add(() => {\n *    const [c, setC] = signal(0)\n *    onCleanup(() => clearInterval(timer))\n *    const timer = setInterval(() => setC(x => x + 1), 1000)\n *    return text(() => `count: ${c()}`)\n *  })\n *  ```\n */\nexport function createNode<T extends Node>(fn: () => T): T {\n  return createRoot((dispose) => fn().once(\"unmount\", dispose))\n}\n\n/** Register a cleanup against the active Owner. Fires when the Owner\n *  disposes — i.e. when the widget body's `createNode` Node unmounts,\n *  or when the surrounding `createRoot` is disposed.\n *\n *  ```ts\n *  function widgetBody() {\n *    const id = setInterval(() => tick(), 1000)\n *    onCleanup(() => clearInterval(id))\n *    return box(…)\n *  }\n *  ```\n *\n *  Throws if called outside any active Owner — the cleanup would\n *  never fire and the caller is almost certainly mistaken. */\nexport function onCleanup(fn: () => void): void {\n  const owner = activeOwnerStore.getStore()\n  if (owner === undefined) {\n    throw new Error(\"onCleanup: no active Owner — call from inside a widget body / createRoot\")\n  }\n  owner.addCleanup(fn)\n}\n\n/** Current Owner, or `undefined` outside any render. Captured by\n *  effects/memos at creation time and restored on re-fire.\n *\n *  @internal */\nexport function useActiveOwner(): Owner | undefined {\n  return activeOwnerStore.getStore()\n}\n\n/** Whether we're currently executing inside `node`'s own render call\n *  stack — i.e. this code path was reached synchronously (or via an\n *  await preserved by `AsyncLocalStorage`) from `node`'s `withActiveNode`.\n *\n *  Used by `invalidate()` to suppress *internal* cascades — e.g.\n *  Markdown mutating its child Text inside its own `_render`. External\n *  mutations (network callbacks, event handlers) run outside any\n *  render's ALS scope, so this returns `false` for them and they emit\n *  normally even when a render is in flight.\n *\n *  @internal */\nexport function inRenderContextOf(node: Node): boolean {\n  const active = activeCtx.getStore()\n  return active !== undefined && active === nodeCtx.get(node)\n}\n\nconst nodeCtx = new WeakMap<Node, TrackingCtx>()\n\n// ---- signal ----------------------------------------------------------\n\n/**\n * Reactive value. Returns a `[get, set]` tuple that's also accessible\n * as `.get` / `.set` for destructure-skipping callers. Reads inside a\n * tracking context (node render, effect, memo) auto-subscribe; writes\n * notify every subscriber synchronously.\n *\n * ```ts\n * const [count, setCount] = signal(0)\n * setCount(1)               // value form\n * setCount((prev) => prev + 1)  // updater form\n * ```\n *\n * **Storing a function as a value — gotcha**: `set` interprets any\n * function argument as the *updater* form `(prev) => next`, calls it\n * with the current value, and stores the result. To store a function\n * value (e.g. a callable `StyleBuilder` or a handler ref), wrap with\n * the updater form so the call resolves to the function you wanted:\n *\n * ```ts\n * const [style, setStyle] = signal<StyleBuilder | undefined>(undefined)\n * setStyle(ctx.style)         // ✗ stored as `ctx.style(undefined)` — a string\n * setStyle(() => ctx.style)   // ✓ stored as the StyleBuilder itself\n * ```\n *\n * Same trap exists in Solid and React's `useState`. If you find\n * yourself reaching for it, also consider whether storing a *plain*\n * value (the underlying data, not the chain/builder) and recomputing\n * the function-y derivative inside a `memo` is cleaner — usually it\n * is.\n *\n * Equality is reference-based: `set(v)` where `v === current` skips\n * the notify. Wrap mutable values you want to \"publish\" in a fresh\n * object/array, or use a counter signal to force fan-out.\n */\nexport function signal<T>(\n  initial: T,\n  opts: { equals?: false | ((prev: T, next: T) => boolean) } = {}\n): Signal<T> {\n  let value = initial\n  const subs = new Set<() => void>()\n  const equals = opts.equals === false ? () => false : (opts.equals ?? ((a, b) => a === b))\n\n  const get = brand((): T => {\n    const ctx = activeCtx.getStore()\n    if (ctx && !subs.has(ctx.notify)) {\n      subs.add(ctx.notify)\n      ctx.register(() => subs.delete(ctx.notify))\n    }\n    return value\n  }, \"get\")\n\n  const set = brand((next: T | ((prev: T) => T)): void => {\n    const resolved = typeof next === \"function\" ? (next as (prev: T) => T)(value) : next\n    if (equals(value, resolved)) return\n    value = resolved\n    // Snapshot — subscribers may mutate the set while running.\n    const snapshot = [...subs]\n    for (const notify of snapshot) notify()\n  }, \"set\")\n\n  return Object.assign([get, set] as const, { get, set }) as Signal<T>\n}\n\n/**\n * Lift a plain value to an `Accessor<T>`. The returned function always\n * returns `value`, never tracks, never notifies — useful at the boundary\n * where a static value enters a tree that otherwise expects `Accessor<T>`.\n *\n * Branded so `isAccessor` reports `true` and downstream `unwrap` calls\n * resolve to a stable function call rather than treating the value as\n * a ctx-aware thunk.\n *\n * ```ts\n * // Component expects `Accessor<Theme>` deep in the tree:\n * <CodeBlock theme={toAccessor(myStaticTheme)} />\n * ```\n */\nexport function toAccessor<T>(fn: () => T): Accessor<T> {\n  return brand(() => fn(), \"get\")\n}\n\n// ---- effect ----------------------------------------------------------\n\n/**\n * Run `fn` immediately, then re-run whenever a signal it read writes.\n * Returns a disposer that stops the effect and drops all tracked\n * subscriptions. Unlike node render, effect dependencies are re-tracked\n * from scratch on every run — reads that disappear from `fn` stop\n * triggering re-runs.\n *\n * ```ts\n * const dispose = effect(() => {\n *   console.log(\"status is\", status())\n * })\n * // ...\n * dispose()\n * ```\n *\n * **Footgun**: don't write a signal from inside an effect that reads\n * the same signal — you'll loop. Writing unrelated signals is fine.\n */\nexport function effect(fn: () => void | (() => void)): () => void {\n  let cleanups: (() => void)[] = []\n  let disposed = false\n\n  // Capture the Owner at creation time. Re-fires triggered by signal\n  // writes run in the *writer's* ALS context, which has nothing to do\n  // with where the effect was created. Restoring the captured Owner on\n  // each run keeps `useContext` walking the same ancestry regardless\n  // of who triggered the re-fire.\n  const owner = useActiveOwner()\n\n  const ctx: TrackingCtx = {\n    notify: () => {\n      if (disposed) return\n      run()\n    },\n    register: (cleanup) => {\n      cleanups.push(cleanup)\n    },\n  }\n\n  const run = (): void => {\n    // Fresh deps each run — unsubscribe from everything we saw last time.\n    const old = cleanups\n    cleanups = []\n    for (const c of old) c()\n    const tracked = (): void | (() => void) => withTracking(ctx, fn)\n    const cleanup = owner !== undefined ? withOwner(owner, tracked) : tracked()\n    if (typeof cleanup === \"function\") cleanups.push(cleanup)\n  }\n\n  // Auto-dispose on owner teardown. If there's no owner, the caller\n  // owns the returned dispose function and is responsible for cleanup.\n  const dispose = (): void => {\n    if (disposed) return\n    disposed = true\n    for (const c of cleanups) c()\n    cleanups = []\n  }\n  owner?.addCleanup(dispose)\n\n  run()\n\n  return dispose\n}\n\n// ---- memo ------------------------------------------------------------\n\n/**\n * Derived, cached signal. `fn` runs once eagerly; the cached value is\n * returned from the accessor. When any signal `fn` reads writes, the\n * memo recomputes and notifies its own subscribers — but only if the\n * new value differs from the cached one (reference equality).\n *\n * ```ts\n * const [value, setValue] = signal(0)\n * const pct = memo(() => Math.round(value() * 100))\n * text(({ style }) => `${pct()}%`)   // subscribes to pct, not value\n * ```\n *\n * Returns an `Accessor<T>`, not a `[read, write]` tuple — memos are\n * read-only by construction.\n */\nexport function memo<T>(fn: () => T): Accessor<T> {\n  const [get, set] = signal<T>(undefined as T)\n  effect(() => {\n    // Wrap in the updater form so `signal.set`'s `typeof === \"function\"`\n    // detection always picks the outer closure, never `fn()`'s return\n    // value. Without this, memoizing a callable `T` (e.g. a chainable\n    // `StyleBuilder`) would cause `set` to invoke it as an updater and\n    // cache the call result instead of the value itself.\n    set(() => fn())\n  })\n  return get\n}\n\n// ---- signal store ----------------------------------------------------\n\n/**\n * Reactive struct with fine-grained, lazy per-field tracking.\n *\n * Reads:\n *   - `store.foo` — tracked when called inside a tracking ctx; allocates\n *     a signal for `foo` on first read.\n *\n * Writes:\n *   - `store.foo = x` — direct assignment.\n *   - `store({ foo: x, bar: y })` — partial patch (merge).\n *   - `store(current => ({ foo: current.foo + 1 }))` — updater form;\n *     the function receives the current plain state (untracked) and\n *     returns a partial patch which is then merged.\n *\n * All writes are value-equality (`===`) gated; setting a field to its\n * current value is a no-op. The function-form updater receives the\n * underlying state object directly so reads inside it are NOT tracked\n * — exactly what an updater wants (\"compute next from current\").\n *\n * Spread (`{ ...store }`) yields the current values of every field via\n * the proxy's `ownKeys` + `getOwnPropertyDescriptor` traps. Be aware:\n * spreading inside a tracking ctx subscribes that ctx to every field\n * (one signal allocation per field). Outside a tracking ctx, spread is\n * cheap (no signal allocation).\n *\n * Implementation: an inner `state` object is the source of truth for\n * plain reads / spreads / the updater's `current`. A `sigs` map is a\n * lazy tracking layer; a key only gets a signal once it's read inside\n * a tracking ctx. Writes update `state` and notify the signal *if it\n * exists* — fields nobody subscribed to never allocate.\n */\nexport type SignalStore<T extends object> = T & {\n  /** Apply a partial patch (merge), or call with an updater that\n   *  receives the current plain state (untracked) and returns a\n   *  partial to merge. Each field's signal short-circuits on value-\n   *  equality, so unchanged fields don't notify subscribers. */\n  set: (patch: Partial<T> | ((current: T) => Partial<T>)) => void\n}\n\nexport function createStore<T extends object>(initial: T): SignalStore<T> {\n  const state = { ...initial }\n  const sigs = {} as { [K in keyof T]?: Signal<T[K]> }\n\n  const ensure = <K extends keyof T>(key: K): Signal<T[K]> => (sigs[key] ??= signal(state[key]))\n\n  const setKey = <K extends keyof T>(key: K, value: T[K]): void => {\n    if (state[key] === value) return\n    state[key] = value\n    // Wrap in updater form so `signal.set`'s `typeof === \"function\"`\n    // detection always picks the outer closure — necessary for storing\n    // function-typed fields without `set` invoking them as updaters.\n    sigs[key]?.set(() => value)\n  }\n\n  const set = (patch: Partial<T> | ((c: T) => Partial<T>)): void => {\n    const p = typeof patch === \"function\" ? patch(state) : patch\n    for (const k of Object.keys(p) as (keyof T)[]) {\n      const v = p[k]\n      setKey(k, v as T[typeof k])\n    }\n  }\n\n  return new Proxy({} as object, {\n    get(_, key) {\n      if (key === \"set\") return set\n      return ensure(key as keyof T).get()\n    },\n    getOwnPropertyDescriptor(_, key) {\n      if (!Object.hasOwn(state, key)) return undefined\n      return {\n        configurable: true,\n        enumerable: true,\n        value: state[key as keyof T],\n      }\n    },\n    has(_, key) {\n      return key === \"set\" || (key as keyof T) in state\n    },\n    ownKeys() {\n      return Reflect.ownKeys(state)\n    },\n    set(_, key, value) {\n      setKey(key as keyof T, value as T[keyof T])\n      return true\n    },\n  }) as SignalStore<T>\n}\n\n// ---- suspense --------------------------------------------------------\n\n/**\n * Suspense boundary handle — the value of `SuspenseContext`. Consumers\n * (`createAsync`) call `increment` / `decrement` around in-flight work\n * so providers (Stream's append, a `suspense()` widget) can observe\n * \"is anything pending below me\".\n *\n * Boundaries chain: when a `suspense()` body installs its own boundary,\n * its `parent` is the nearest ancestor boundary. Count flips at the\n * 0→1 and 1→0 transitions propagate to the parent, so the outermost\n * boundary's count is `> 0` iff *any* descendant has pending work —\n * a single integer, no walks.\n *\n * `whenIdle` resolves when count returns to 0. Used by Stream to gate\n * paint on resolved async; could be used by any other \"wait for\n * subtree to settle\" caller.\n */\nexport type SuspenseBoundary = {\n  increment: () => void\n  decrement: () => void\n  active: () => boolean\n  whenIdle: () => Promise<void>\n}\n\n/** Nearest Suspense provider in the Owner chain. `undefined` when no\n *  boundary is installed — `createAsync` runs fire-and-forget in that\n *  case (signal resolves later, normal invalidation re-renders). */\nexport const SuspenseContext = createContext<SuspenseBoundary | undefined>(undefined)\n\n/**\n * Build a boundary whose count flips propagate to `parent` on the 0→1\n * and 1→0 transitions. Used by Stream's `append` and the `suspense()`\n * widget. Internal-ish — most callers shouldn't construct boundaries\n * directly.\n *\n * @internal\n */\nexport function createSuspenseBoundary(parent?: SuspenseBoundary): SuspenseBoundary {\n  let count = 0\n  let idle: { promise: Promise<void>; resolve: () => void } | undefined\n  return {\n    active: () => count > 0,\n    decrement: () => {\n      if (count === 0) return\n      count--\n      if (count === 0) {\n        parent?.decrement()\n        idle?.resolve()\n        idle = undefined\n      }\n    },\n    increment: () => {\n      count++\n      if (count === 1) parent?.increment()\n    },\n    whenIdle: () => {\n      if (count === 0) return Promise.resolve()\n      if (idle === undefined) {\n        const { promise, resolve } = Promise.withResolvers<void>()\n        idle = { promise, resolve }\n      }\n      return idle.promise\n    },\n  }\n}\n\n// ---- async -----------------------------------------------------------\n\n/**\n * Resource-style async accessor. `fn` reads signals (tracked); the\n * effect re-fires when any of them change. Each run notifies the\n * nearest `SuspenseContext` so a surrounding boundary (Stream's\n * append, a `suspense()` widget) can observe pending work.\n *\n * ```ts\n * const highlighted = createAsync(\n *   async (prev) => highlight(unwrap(props.code)),\n *   { initialValue: unwrap(props.code) },\n * )\n * text(highlighted)\n * ```\n *\n * **Stale-write protection**: each run bumps a generation counter;\n * late `.then` callbacks check it and skip `setValue` if a newer run\n * has already fired. The boundary is decremented exactly once per\n * increment (in the settle callback, regardless of staleness).\n *\n * **`prev`** is the previously resolved value (or `initialValue`) —\n * useful for diff-based fetches. Reading it does *not* track, so\n * resolving the new value won't re-fire the effect.\n *\n * **No active boundary** → increment/decrement no-op, work is\n * fire-and-forget. Right for UI surface widgets that re-render\n * cheaply on signal change. The Stream surface installs a boundary\n * per appended subtree so committed-to-scrollback rows always reflect\n * resolved values.\n */\nexport function createAsync<T>(\n  fn: (prev: T | undefined) => Promise<T>,\n  opts: { initialValue: T }\n): Accessor<T>\nexport function createAsync<T>(\n  fn: (prev: T | undefined) => Promise<T>,\n  opts?: { initialValue?: T }\n): Accessor<T | undefined>\nexport function createAsync<T>(\n  fn: (prev: T | undefined) => Promise<T>,\n  opts?: { initialValue?: T }\n): Accessor<T | undefined> {\n  const [value, setValue] = signal<T | undefined>(opts?.initialValue)\n  const suspense = useContext(SuspenseContext)\n  let gen = 0\n  effect(() => {\n    const my = ++gen\n    let p: Promise<T>\n    try {\n      p = fn(untrack(value))\n    } catch (error) {\n      // Sync throw inside `fn` — surface as a rejected promise so the\n      // boundary increment / decrement path stays uniform.\n      p = Promise.reject(error as Error)\n    }\n    suspense?.increment()\n    p.then(\n      (v) => {\n        if (my === gen) setValue(() => v)\n      },\n      () => {\n        // Swallow — async failures leave the previous (or initial)\n        // value in place.\n      }\n    ).finally(() => suspense?.decrement())\n  })\n  return value\n}\n\nexport type Progressive<T> = Accessor<T> & {\n  readonly loading: Accessor<boolean>\n  whenIdle: () => Promise<void>\n}\n\nexport function createProgressive<T>(\n  fn: (ctx: { signal: AbortSignal; set: (value: T) => void }) => MaybePromise<T>,\n  opts: { throttle?: number; initialValue: T }\n): Progressive<T>\nexport function createProgressive<T>(\n  fn: (ctx: { signal: AbortSignal; set: (value: T) => void }) => MaybePromise<T>,\n  opts: { throttle?: number; initialValue?: T }\n): Progressive<T | undefined>\nexport function createProgressive<T>(\n  fn: (ctx: { signal: AbortSignal; set: (value: T) => void }) => MaybePromise<T>,\n  opts: { throttle?: number; initialValue?: T } = {}\n): Progressive<T | undefined> {\n  const throttle = opts.throttle ?? 16\n  const [loading, setLoading] = signal(true)\n  const [state, setState] = signal<T | undefined>(opts.initialValue, { equals: false })\n\n  const ret: Progressive<T | undefined> = Object.assign(state, {\n    get loading() {\n      return loading\n    },\n    whenIdle: () => {\n      if (!loading()) return Promise.resolve()\n      idle ??= Promise.withResolvers<void>()\n      return idle.promise\n    },\n  })\n\n  let gen = 0\n  let idle: ReturnType<typeof Promise.withResolvers<void>> | undefined\n\n  effect(() => {\n    const my = ++gen\n    const ac = new AbortController()\n\n    void (async () => {\n      try {\n        setLoading(true)\n        let prev = 0\n        const result = await fn({\n          set: (value: T) => {\n            if (ac.signal.aborted || my !== gen) return\n            const now = performance.now()\n            if (now - prev >= throttle) {\n              prev = now\n              setState(() => value)\n            }\n          },\n          signal: ac.signal,\n        })\n        if (my === gen) {\n          setState(() => result)\n          setLoading(false)\n          idle?.resolve()\n          idle = undefined\n        }\n      } catch (error) {\n        if (my === gen) {\n          setLoading(false)\n          idle?.reject(error)\n          idle = undefined\n        }\n      } finally {\n        ac.abort()\n      }\n    })()\n\n    return () => {\n      ac.abort()\n    }\n  })\n\n  return ret\n}\n\nexport function createIterable<T>(\n  fn: (ctx: { signal: AbortSignal }) => AsyncIterable<T | readonly T[]>,\n  opts: { throttle?: number; initialValue?: readonly T[] } = {}\n): Progressive<readonly T[]> {\n  return createProgressive(\n    async ({ signal: s, set }) => {\n      const results: T[] = []\n      for await (const item of fn({ signal: s })) {\n        if (s.aborted) return results\n        results.push(...(Array.isArray(item) ? item : [item]))\n        set(results)\n      }\n      return results\n    },\n    { ...opts, initialValue: opts.initialValue ?? [] }\n  )\n}\n\nexport interface Ref<T> {\n  (): T\n  get value(): T | undefined\n  set value(value: T)\n}\n\nexport function createRef<T>(\n  value?: T,\n  opts: { onSet?: (value: T, prev: T | undefined) => void | (() => void) } = {}\n): Ref<T> {\n  let current = value\n  let cleanup: (() => void) | undefined\n\n  const get = (): T => {\n    if (current === undefined) throw new Error(\"Ref value accessed before initialization\")\n    return current\n  }\n\n  Object.defineProperty(get, \"value\", {\n    get: () => current,\n    set: (v: T) => {\n      if (current === v) return\n      cleanup?.()\n      cleanup = undefined\n      const prev = current\n      current = v\n      cleanup = opts.onSet?.(v, prev) ?? undefined\n    },\n  })\n\n  return get as Ref<T>\n}\n"],"mappings":";;AA0CA,MAAM,YAAY,IAAI,kBAA2C;AAEjE,SAAS,aAAgB,KAAkB,IAAgB;CACzD,OAAO,UAAU,IAAI,KAAK,EAAE;AAC9B;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,QAAW,IAAgB;CACzC,OAAO,UAAU,IAAI,KAAA,GAAW,EAAE;AACpC;;;AAIA,SAAgB,KAAQ,GAAmB;CACzC,OAAO,cAAc,OAAO,CAAC,CAAC;AAChC;AAoCA,SAAgB,cAAiB,cAA0C;CACzE,OAAO;EAAE;EAAc,IAAI,OAAO,mBAAmB;CAAE;AACzD;;;;AAKA,SAAgB,eAAkB,KAAiB,OAAgB;CACjE,MAAM,QAAQ,iBAAiB,SAAS;CACxC,IAAI,UAAU,KAAA,GACZ,MAAM,IAAI,MAAM,qEAAqE;CAEvF,MAAM,WAAW,IAAI,IAAI,KAAK;AAChC;;;;AAKA,SAAgB,WAAc,KAAoB;CAChD,KAAK,IAAI,IAAI,iBAAiB,SAAS,GAAG,MAAM,KAAA,GAAW,IAAI,EAAE,QAAQ;EACvE,MAAM,MAAM,EAAE;EACd,IAAI,KAAK,IAAI,IAAI,EAAE,GAAG,OAAO,IAAI,IAAI,IAAI,EAAE;CAC7C;CACA,OAAO,IAAI;AACb;;;;AAOA,MAAM,WAAW,OAAO,IAAI,oBAAoB;;;;;AAsBhD,SAAgB,WAAc,GAA8B;CAC1D,OAAO,OAAO,MAAM,cAAe,EAA8B,cAAc;AACjF;;;;;;AAOA,SAAgB,OAAU,GAAmB;CAC3C,OAAO,WAAc,CAAC,IAAI,EAAE,IAAI;AAClC;AAIA,SAAS,MAAyC,IAAO,KAAuB;CAC9E,OAAO,eAAe,IAAI,UAAU;EAClC,cAAc;EACd,YAAY;EACZ,OAAO;EACP,UAAU;CACZ,CAAC;CACD,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;AAyBA,IAAa,QAAb,MAAmB;CACjB;CACA,YAA4B,CAAC;CAC7B;CACA,YAAY;CAEZ,YAAY,QAAgB;EAC1B,KAAK,SAAS;CAChB;CAEA,IAAI,WAAoB;EACtB,OAAO,KAAK;CACd;;;CAIA,IAAI,WAAqD;EACvD,OAAO,KAAK;CACd;CAEA,WAAW,IAAY,OAAsB;EAC1C,CAAC,KAAK,8BAAc,IAAI,IAAI,EAAA,CAAG,IAAI,IAAI,KAAK;CAC/C;;CAGA,WAAW,IAAsB;EAC/B,IAAI,KAAK,WAAW;GAClB,GAAG;GACH;EACF;EACA,KAAK,UAAU,KAAK,EAAE;CACxB;;CAGA,UAAgB;EACd,IAAI,KAAK,WAAW;EACpB,KAAK,YAAY;EACjB,KAAK,IAAI,IAAI,KAAK,UAAU,SAAS,GAAG,KAAK,GAAG,KAC9C,IAAI;GACF,KAAK,UAAU,EAAE,CAAC;EACpB,SAAS,OAAO;GAGd,QAAQ,MAAM,wBAAwB,KAAK;EAC7C;EAEF,KAAK,YAAY,CAAC;EAClB,KAAK,YAAY,KAAA;CACnB;AACF;AAEA,MAAM,mBAAmB,IAAI,kBAAqC;;;;;;;;;;;;;AAclE,SAAgB,eAAkB,MAAY,IAAgB;CAC5D,OAAO,aAAa,mBAAmB,IAAI,GAAG,EAAE;AAClD;;;;;;;AAQA,SAAgB,UAAa,OAAc,IAAgB;CACzD,OAAO,iBAAiB,IAAI,OAAO,EAAE;AACvC;AAEA,SAAS,mBAAmB,MAAyB;CACnD,IAAI,MAAM,QAAQ,IAAI,IAAI;CAC1B,IAAI,QAAQ,KAAA,GAAW;EACrB,MAAM;GACJ,cAAc,KAAK,WAAW;GAC9B,WAAW,YAAY;IACrB,KAAK,KAAK,WAAW,OAAO;GAC9B;EACF;EACA,QAAQ,IAAI,MAAM,GAAG;CACvB;CACA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,WAAc,IAAmC;CAE/D,MAAM,QAAQ,IAAI,MADH,iBAAiB,SACR,CAAM;CAC9B,OAAO,UAAU,aAAa,SAAS,MAAM,QAAQ,CAAC,CAAC;AACzD;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,WAA2B,IAAgB;CACzD,OAAO,YAAY,YAAY,GAAG,CAAC,CAAC,KAAK,WAAW,OAAO,CAAC;AAC9D;;;;;;;;;;;;;;;AAgBA,SAAgB,UAAU,IAAsB;CAC9C,MAAM,QAAQ,iBAAiB,SAAS;CACxC,IAAI,UAAU,KAAA,GACZ,MAAM,IAAI,MAAM,0EAA0E;CAE5F,MAAM,WAAW,EAAE;AACrB;;;;;AAMA,SAAgB,iBAAoC;CAClD,OAAO,iBAAiB,SAAS;AACnC;;;;;;;;;;;;AAaA,SAAgB,kBAAkB,MAAqB;CACrD,MAAM,SAAS,UAAU,SAAS;CAClC,OAAO,WAAW,KAAA,KAAa,WAAW,QAAQ,IAAI,IAAI;AAC5D;AAEA,MAAM,0BAAU,IAAI,QAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsC/C,SAAgB,OACd,SACA,OAA6D,CAAC,GACnD;CACX,IAAI,QAAQ;CACZ,MAAM,uBAAO,IAAI,IAAgB;CACjC,MAAM,SAAS,KAAK,WAAW,cAAc,QAAS,KAAK,YAAY,GAAG,MAAM,MAAM;CAEtF,MAAM,MAAM,YAAe;EACzB,MAAM,MAAM,UAAU,SAAS;EAC/B,IAAI,OAAO,CAAC,KAAK,IAAI,IAAI,MAAM,GAAG;GAChC,KAAK,IAAI,IAAI,MAAM;GACnB,IAAI,eAAe,KAAK,OAAO,IAAI,MAAM,CAAC;EAC5C;EACA,OAAO;CACT,GAAG,KAAK;CAER,MAAM,MAAM,OAAO,SAAqC;EACtD,MAAM,WAAW,OAAO,SAAS,aAAc,KAAwB,KAAK,IAAI;EAChF,IAAI,OAAO,OAAO,QAAQ,GAAG;EAC7B,QAAQ;EAER,MAAM,WAAW,CAAC,GAAG,IAAI;EACzB,KAAK,MAAM,UAAU,UAAU,OAAO;CACxC,GAAG,KAAK;CAER,OAAO,OAAO,OAAO,CAAC,KAAK,GAAG,GAAY;EAAE;EAAK;CAAI,CAAC;AACxD;;;;;;;;;;;;;;;AAgBA,SAAgB,WAAc,IAA0B;CACtD,OAAO,YAAY,GAAG,GAAG,KAAK;AAChC;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,OAAO,IAA2C;CAChE,IAAI,WAA2B,CAAC;CAChC,IAAI,WAAW;CAOf,MAAM,QAAQ,eAAe;CAE7B,MAAM,MAAmB;EACvB,cAAc;GACZ,IAAI,UAAU;GACd,IAAI;EACN;EACA,WAAW,YAAY;GACrB,SAAS,KAAK,OAAO;EACvB;CACF;CAEA,MAAM,YAAkB;EAEtB,MAAM,MAAM;EACZ,WAAW,CAAC;EACZ,KAAK,MAAM,KAAK,KAAK,EAAE;EACvB,MAAM,gBAAqC,aAAa,KAAK,EAAE;EAC/D,MAAM,UAAU,UAAU,KAAA,IAAY,UAAU,OAAO,OAAO,IAAI,QAAQ;EAC1E,IAAI,OAAO,YAAY,YAAY,SAAS,KAAK,OAAO;CAC1D;CAIA,MAAM,gBAAsB;EAC1B,IAAI,UAAU;EACd,WAAW;EACX,KAAK,MAAM,KAAK,UAAU,EAAE;EAC5B,WAAW,CAAC;CACd;CACA,OAAO,WAAW,OAAO;CAEzB,IAAI;CAEJ,OAAO;AACT;;;;;;;;;;;;;;;;AAmBA,SAAgB,KAAQ,IAA0B;CAChD,MAAM,CAAC,KAAK,OAAO,OAAU,KAAA,CAAc;CAC3C,aAAa;EAMX,UAAU,GAAG,CAAC;CAChB,CAAC;CACD,OAAO;AACT;AA2CA,SAAgB,YAA8B,SAA4B;CACxE,MAAM,QAAQ,EAAE,GAAG,QAAQ;CAC3B,MAAM,OAAO,CAAC;CAEd,MAAM,UAA6B,QAA0B,KAAK,SAAS,OAAO,MAAM,IAAI;CAE5F,MAAM,UAA6B,KAAQ,UAAsB;EAC/D,IAAI,MAAM,SAAS,OAAO;EAC1B,MAAM,OAAO;EAIb,KAAK,IAAI,EAAE,UAAU,KAAK;CAC5B;CAEA,MAAM,OAAO,UAAqD;EAChE,MAAM,IAAI,OAAO,UAAU,aAAa,MAAM,KAAK,IAAI;EACvD,KAAK,MAAM,KAAK,OAAO,KAAK,CAAC,GAAkB;GAC7C,MAAM,IAAI,EAAE;GACZ,OAAO,GAAG,CAAgB;EAC5B;CACF;CAEA,OAAO,IAAI,MAAM,CAAC,GAAa;EAC7B,IAAI,GAAG,KAAK;GACV,IAAI,QAAQ,OAAO,OAAO;GAC1B,OAAO,OAAO,GAAc,CAAC,CAAC,IAAI;EACpC;EACA,yBAAyB,GAAG,KAAK;GAC/B,IAAI,CAAC,OAAO,OAAO,OAAO,GAAG,GAAG,OAAO,KAAA;GACvC,OAAO;IACL,cAAc;IACd,YAAY;IACZ,OAAO,MAAM;GACf;EACF;EACA,IAAI,GAAG,KAAK;GACV,OAAO,QAAQ,SAAU,OAAmB;EAC9C;EACA,UAAU;GACR,OAAO,QAAQ,QAAQ,KAAK;EAC9B;EACA,IAAI,GAAG,KAAK,OAAO;GACjB,OAAO,KAAgB,KAAmB;GAC1C,OAAO;EACT;CACF,CAAC;AACH;;;;AA8BA,MAAa,kBAAkB,cAA4C,KAAA,CAAS;;;;;;;;;AAUpF,SAAgB,uBAAuB,QAA6C;CAClF,IAAI,QAAQ;CACZ,IAAI;CACJ,OAAO;EACL,cAAc,QAAQ;EACtB,iBAAiB;GACf,IAAI,UAAU,GAAG;GACjB;GACA,IAAI,UAAU,GAAG;IACf,QAAQ,UAAU;IAClB,MAAM,QAAQ;IACd,OAAO,KAAA;GACT;EACF;EACA,iBAAiB;GACf;GACA,IAAI,UAAU,GAAG,QAAQ,UAAU;EACrC;EACA,gBAAgB;GACd,IAAI,UAAU,GAAG,OAAO,QAAQ,QAAQ;GACxC,IAAI,SAAS,KAAA,GAAW;IACtB,MAAM,EAAE,SAAS,YAAY,QAAQ,cAAoB;IACzD,OAAO;KAAE;KAAS;IAAQ;GAC5B;GACA,OAAO,KAAK;EACd;CACF;AACF;AAyCA,SAAgB,YACd,IACA,MACyB;CACzB,MAAM,CAAC,OAAO,YAAY,OAAsB,MAAM,YAAY;CAClE,MAAM,WAAW,WAAW,eAAe;CAC3C,IAAI,MAAM;CACV,aAAa;EACX,MAAM,KAAK,EAAE;EACb,IAAI;EACJ,IAAI;GACF,IAAI,GAAG,QAAQ,KAAK,CAAC;EACvB,SAAS,OAAO;GAGd,IAAI,QAAQ,OAAO,KAAc;EACnC;EACA,UAAU,UAAU;EACpB,EAAE,MACC,MAAM;GACL,IAAI,OAAO,KAAK,eAAe,CAAC;EAClC,SACM,CAGN,CACF,CAAC,CAAC,cAAc,UAAU,UAAU,CAAC;CACvC,CAAC;CACD,OAAO;AACT;AAeA,SAAgB,kBACd,IACA,OAAgD,CAAC,GACrB;CAC5B,MAAM,WAAW,KAAK,YAAY;CAClC,MAAM,CAAC,SAAS,cAAc,OAAO,IAAI;CACzC,MAAM,CAAC,OAAO,YAAY,OAAsB,KAAK,cAAc,EAAE,QAAQ,MAAM,CAAC;CAEpF,MAAM,MAAkC,OAAO,OAAO,OAAO;EAC3D,IAAI,UAAU;GACZ,OAAO;EACT;EACA,gBAAgB;GACd,IAAI,CAAC,QAAQ,GAAG,OAAO,QAAQ,QAAQ;GACvC,SAAS,QAAQ,cAAoB;GACrC,OAAO,KAAK;EACd;CACF,CAAC;CAED,IAAI,MAAM;CACV,IAAI;CAEJ,aAAa;EACX,MAAM,KAAK,EAAE;EACb,MAAM,KAAK,IAAI,gBAAgB;EAE/B,CAAM,YAAY;GAChB,IAAI;IACF,WAAW,IAAI;IACf,IAAI,OAAO;IACX,MAAM,SAAS,MAAM,GAAG;KACtB,MAAM,UAAa;MACjB,IAAI,GAAG,OAAO,WAAW,OAAO,KAAK;MACrC,MAAM,MAAM,YAAY,IAAI;MAC5B,IAAI,MAAM,QAAQ,UAAU;OAC1B,OAAO;OACP,eAAe,KAAK;MACtB;KACF;KACA,QAAQ,GAAG;IACb,CAAC;IACD,IAAI,OAAO,KAAK;KACd,eAAe,MAAM;KACrB,WAAW,KAAK;KAChB,MAAM,QAAQ;KACd,OAAO,KAAA;IACT;GACF,SAAS,OAAO;IACd,IAAI,OAAO,KAAK;KACd,WAAW,KAAK;KAChB,MAAM,OAAO,KAAK;KAClB,OAAO,KAAA;IACT;GACF,UAAU;IACR,GAAG,MAAM;GACX;EACF,EAAA,CAAG;EAEH,aAAa;GACX,GAAG,MAAM;EACX;CACF,CAAC;CAED,OAAO;AACT;AAEA,SAAgB,eACd,IACA,OAA2D,CAAC,GACjC;CAC3B,OAAO,kBACL,OAAO,EAAE,QAAQ,GAAG,UAAU;EAC5B,MAAM,UAAe,CAAC;EACtB,WAAW,MAAM,QAAQ,GAAG,EAAE,QAAQ,EAAE,CAAC,GAAG;GAC1C,IAAI,EAAE,SAAS,OAAO;GACtB,QAAQ,KAAK,GAAI,MAAM,QAAQ,IAAI,IAAI,OAAO,CAAC,IAAI,CAAE;GACrD,IAAI,OAAO;EACb;EACA,OAAO;CACT,GACA;EAAE,GAAG;EAAM,cAAc,KAAK,gBAAgB,CAAC;CAAE,CACnD;AACF;AAQA,SAAgB,UACd,OACA,OAA2E,CAAC,GACpE;CACR,IAAI,UAAU;CACd,IAAI;CAEJ,MAAM,YAAe;EACnB,IAAI,YAAY,KAAA,GAAW,MAAM,IAAI,MAAM,0CAA0C;EACrF,OAAO;CACT;CAEA,OAAO,eAAe,KAAK,SAAS;EAClC,WAAW;EACX,MAAM,MAAS;GACb,IAAI,YAAY,GAAG;GACnB,UAAU;GACV,UAAU,KAAA;GACV,MAAM,OAAO;GACb,UAAU;GACV,UAAU,KAAK,QAAQ,GAAG,IAAI,KAAK,KAAA;EACrC;CACF,CAAC;CAED,OAAO;AACT"}
+{"version":3,"file":"reactive-f7NpAi69.mjs","names":[],"sources":["../src/core/reactive.ts"],"sourcesContent":["import type { MaybePromise } from \"@zaly/shared\"\nimport type { Node } from \"./node.ts\"\n\nimport { AsyncLocalStorage } from \"node:async_hooks\"\n\n/**\n * Solid-style fine-grained reactivity.\n *\n * `signal(initial)` → `[read, write]` tuple. Reads inside a\n * tracking context (node render, effect, memo) auto-subscribe;\n * writes invalidate every subscriber. Cross-async-boundary tracking\n * uses `AsyncLocalStorage` so reads after an `await` still subscribe\n * the correct context.\n *\n * ```ts\n * const [status, setStatus] = signal(\"streaming\")\n * text(({ style }) => style.success(status()))   // auto-subscribes\n * setStatus(\"done\")\n * ```\n *\n * Builds on three primitives:\n *   - `signal`    — reactive value.\n *   - `memo`      — cached derived signal.\n *   - `effect`    — imperative side-effect that re-runs on dep change.\n *\n * Widgets expose `Reactive<T>` props and call `unwrap()` inside\n * `_render` to resolve them — that's the bridge from app-level\n * signals into the render tree.\n */\n\n// ---- tracking context ------------------------------------------------\n\n/** Context carried through a tracking scope. Subscribers that want to\n *  be signal-aware implement this; signals read the current context\n *  during `read()` and add `notify` to their subscriber set. `register`\n *  lets the context remember the cleanup closure so it can\n *  unsubscribe later (on unmount / dispose / re-run). */\ninterface TrackingCtx {\n  notify: () => void\n  register: (cleanup: () => void) => void\n}\n\nconst activeCtx = new AsyncLocalStorage<TrackingCtx | undefined>()\n\nfunction withTracking<T>(ctx: TrackingCtx, fn: () => T): T {\n  return activeCtx.run(ctx, fn)\n}\n\n/** Run `fn` outside any tracking scope. Signal reads inside don't\n *  subscribe the surrounding render, and async work started inside\n *  (timers, promises, intervals) doesn't capture the current ctx —\n *  callbacks fire with `getStore() === undefined`.\n *\n *  Use this when starting persistent async work from inside a render\n *  pass: a `setInterval` set up during `_render` would otherwise\n *  inherit the render's ALS context, and every timer tick would look\n *  like it's \"inside\" that render — its invalidates would be silently\n *  suppressed.\n *\n *  ```ts\n *  // inside _render() or a render-driven reconcile():\n *  untracked(() => {\n *    this.#timer = setInterval(() => this.invalidate(), speed)\n *  })\n *  ```\n *\n *  Equivalent to Solid's `untrack`. */\nexport function untrack<T>(fn: () => T): T {\n  return activeCtx.run(undefined, fn)\n}\n\n/** Resolve a `Reactive<T>` to its current `T` without subscribing to\n * any tracking context. */\nexport function peek<T>(s: Reactive<T>): T {\n  return untrack(() => unwrap(s))\n}\n\n// ---- context ---------------------------------------------------------\n\n/**\n * Solid-style context for sharing values down the owner chain without\n * prop-drilling. Widgets publish values via `provideContext` (in setup\n * or `_render`); descendants read via `useContext`.\n *\n * ```ts\n * const ThemeOverride = createContext<Theme | undefined>(undefined)\n *\n * // provider (in a widget body / setup / _render):\n * provideContext(ThemeOverride, customTheme)\n *\n * // consumer (anywhere with an active node or owner chain):\n * const theme = useContext(ThemeOverride) ?? defaultTheme\n * ```\n *\n * Implementation: each `Node` carries an optional `#contexts` map keyed\n * by context id. Lookups walk the *owner frame chain* (`OwnerFrame.owner`\n * pointers), reading the live `#contexts` of each frame's node and\n * falling back to the context's default if no ancestor provides it.\n *\n * The owner chain is the render-call ancestry captured at frame push\n * (via `withActiveNode`) — independent of mount status. Effects/memos\n * capture their creation frame and re-establish it on re-fire, so\n * detached re-runs walk the same chain they would have at creation.\n */\nexport interface Context<T> {\n  readonly id: symbol\n  readonly defaultValue: T\n}\n\nexport function createContext<T>(): Context<T | undefined>\nexport function createContext<T>(defaultValue: T): Context<T>\nexport function createContext<T>(defaultValue?: T): Context<T | undefined> {\n  return { defaultValue, id: Symbol(\"@zaly/tui/context\") }\n}\n\n/** Publish `value` for `ctx` on the active Owner. Persistent for the\n *  Owner's lifetime. Descendants (in the render-call sense) that read\n *  via `useContext` walk up the Owner chain and find it. */\nexport function provideContext<T>(ctx: Context<T>, value: T): void {\n  const owner = activeOwnerStore.getStore()\n  if (owner === undefined) {\n    throw new Error(\"provideContext: no active Owner — call from a widget body / _render\")\n  }\n  owner.setContext(ctx.id, value)\n}\n\n/** Read the current value of `ctx`. Walks the Owner chain\n *  (render-call ancestry, not mount tree). Returns the context's\n *  default when no ancestor has provided a value. */\nexport function useContext<T>(ctx: Context<T>): T {\n  for (let o = activeOwnerStore.getStore(); o !== undefined; o = o.parent) {\n    const map = o.contexts\n    if (map?.has(ctx.id)) return map.get(ctx.id) as T\n  }\n  return ctx.defaultValue\n}\n\n// ---- public types ----------------------------------------------------\n\n/** Brand tag: every accessor / setter returned by `signal` / `memo`\n *  carries this symbol so `unwrap` can tell a reactive source from a\n *  plain function-valued prop (label formatter, text callback, etc.). */\nconst REACTIVE = Symbol.for(\"@zaly/tui/reactive\")\n\nexport type Signal<T> = readonly [get: Accessor<T>, set: Setter<T>] & {\n  readonly get: Accessor<T>\n  readonly set: Setter<T>\n}\n\n/** A read-only reactive source. Branded so `isAccessor` can detect it\n *  without false positives on arbitrary callables. */\nexport type Accessor<T> = (() => T) & { readonly [REACTIVE]: \"get\" }\n\n/** A signal setter. Same branding as `Accessor` (different tag) so a\n *  setter isn't mistaken for an accessor by `unwrap`. */\nexport type Setter<T> = ((next: T | ((prev: T) => T)) => void) & { readonly [REACTIVE]: \"set\" }\n\n/** A widget prop that's either a literal value or a reactive accessor. */\nexport type Reactive<T> = T | Accessor<T>\n\n/** Runtime check: `true` when `v` was produced by `signal` / `memo`.\n *  False for plain callables (text-content functions, label formatters).\n *\n *  @internal */\nexport function isAccessor<T>(v: unknown): v is Accessor<T> {\n  return typeof v === \"function\" && (v as { [REACTIVE]?: string })[REACTIVE] === \"get\"\n}\n\n/** Resolve a `Reactive<T>` to its current `T`. Call inside `_render`\n *  so accessor reads subscribe the rendering node. Only brand-tagged\n *  accessors are invoked — other function values pass through\n *  untouched, so widgets whose `T` is itself a function type (label\n *  formatters etc.) don't need a hand-rolled guard. */\nexport function unwrap<T>(v: Reactive<T>): T {\n  return isAccessor<T>(v) ? v() : v\n}\n\nfunction brand<F extends (...args: any[]) => any>(fn: F, tag: \"get\"): Accessor<ReturnType<F>>\nfunction brand<F extends (...args: any[]) => any>(fn: F, tag: \"set\"): Setter<Parameters<F>[0]>\nfunction brand<F extends (...args: any[]) => any>(fn: F, tag: \"get\" | \"set\"): F {\n  Object.defineProperty(fn, REACTIVE, {\n    configurable: false,\n    enumerable: false,\n    value: tag,\n    writable: false,\n  })\n  return fn\n}\n\n// ---- Owner -----------------------------------------------------------\n\n/**\n * Reactive ownership scope — bundles cleanups + provided contexts\n * scoped to a single widget body (or a `createRoot` headless scope).\n *\n * Owners form a chain via `parent` mirroring the call-time widget\n * nesting: when `widget()` is invoked inside another widget's body,\n * `createNode` creates the inner Owner with `parent =\n * activeOwnerStore.getStore()` (the outer widget's Owner). That chain\n * is what `useContext` walks.\n *\n * Owners are **not** bound to Nodes anymore — a widget's `createNode`\n * pairs the Owner with the constructed Node only through\n * `Node.once(\"unmount\", () => owner.dispose())`. Primitive Nodes\n * (`text`, `box`, …) don't get their own Owner; they share whatever\n * Owner created them.\n *\n * Use `onCleanup(cb)` to register cleanups against the active Owner.\n * Disposing the Owner runs them in reverse-registration order.\n *\n * @internal\n */\nexport class Owner {\n  parent?: Owner\n  #cleanups: (() => void)[] = []\n  #contexts?: Map<symbol, unknown>\n  #disposed = false\n\n  constructor(parent?: Owner) {\n    this.parent = parent\n  }\n\n  get disposed(): boolean {\n    return this.#disposed\n  }\n\n  /** Live view of this Owner's provided contexts. Populated by\n   *  `provideContext`. Walked upward via `parent` by `useContext`. */\n  get contexts(): ReadonlyMap<symbol, unknown> | undefined {\n    return this.#contexts\n  }\n\n  setContext(id: symbol, value: unknown): void {\n    ;(this.#contexts ??= new Map()).set(id, value)\n  }\n\n  /** Register a cleanup. Runs on `dispose()`. */\n  addCleanup(fn: () => void): void {\n    if (this.#disposed) {\n      fn()\n      return\n    }\n    this.#cleanups.push(fn)\n  }\n\n  /** Fire cleanups in reverse-registration order. Idempotent. */\n  dispose(): void {\n    if (this.#disposed) return\n    this.#disposed = true\n    for (let i = this.#cleanups.length - 1; i >= 0; i--) {\n      try {\n        this.#cleanups[i]()\n      } catch (error) {\n        // Don't let one bad cleanup poison the rest.\n        // oxlint-disable-next-line no-console\n        console.error(\"Owner cleanup threw:\", error)\n      }\n    }\n    this.#cleanups = []\n    this.#contexts = undefined\n  }\n}\n\nconst activeOwnerStore = new AsyncLocalStorage<Owner | undefined>()\n\n/** Run `fn` as the `node`'s render pass. Signal reads inside subscribe\n *  the node's tracking ctx; the ctx's `notify` is `node.invalidate`,\n *  so any signal write that this render depended on invalidates the\n *  node and clears its cache. Cleanups are registered against the\n *  Node's `unmount` event.\n *\n *  Does **not** push an Owner — primitive Nodes share whatever Owner\n *  was active in their caller. Widget bodies install their own Owner\n *  via `createNode` at construction time, which is when `useContext`\n *  / `provideContext` / `effect` / `memo` care about the active scope.\n *\n *  @internal */\nexport function withActiveNode<T>(node: Node, fn: () => T): T {\n  return withTracking(getNodeTrackingCtx(node), fn)\n}\n\n/** Run `fn` with a pre-existing Owner restored. Used by `effect` /\n *  `memo` to re-establish their creation-time owner chain on re-fire,\n *  so `useContext` walks the same ancestry regardless of whether the\n *  re-fire was triggered from inside or outside a render.\n *\n *  @internal */\nexport function withOwner<T>(owner: Owner, fn: () => T): T {\n  return activeOwnerStore.run(owner, fn)\n}\n\nfunction getNodeTrackingCtx(node: Node): TrackingCtx {\n  let ctx = nodeCtx.get(node)\n  if (ctx === undefined) {\n    ctx = {\n      notify: () => node.invalidate(),\n      register: (cleanup) => {\n        node.once(\"unmount\", cleanup)\n      },\n    }\n    nodeCtx.set(node, ctx)\n  }\n  return ctx\n}\n\n/** Create a fresh Owner scope and run `fn` inside it. Returns\n *  whatever `fn` returns. The Owner's parent is whatever was active at\n *  the call site (or `undefined` at module top).\n *\n *  The Owner is *not* auto-disposed — callers manage its lifetime via\n *  the Owner returned alongside the result, or (more commonly) by\n *  binding the Owner to a Node and disposing it on that Node's\n *  unmount.\n *\n *  Typical use is via a surface's function-shape `add(fn)` API which\n *  wraps this internally:\n *\n *  ```ts\n *  ui.add(() => {\n *    const [count, setCount] = signal(0)\n *    onCleanup(() => console.log(\"gone\"))\n *    return text(() => `count: ${count()}`)\n *  })\n *  ```\n *\n *  For headless reactive scopes (tests, programmatic effects), call\n *  `createRoot` directly:\n *\n *  ```ts\n *  const { result, owner } = createRoot(() => signal(0))\n *  // ... use result ...\n *  owner.dispose()\n *  ```\n */\nexport function createRoot<T>(fn: (dispose: () => void) => T): T {\n  const parent = activeOwnerStore.getStore()\n  const owner = new Owner(parent)\n  return withOwner(owner, () => fn(() => owner.dispose()))\n}\n\n/** Run `fn` inside a fresh Owner scope and bind the returned Node to\n *  that scope — when the Node unmounts, the Owner disposes (firing\n *  every `onCleanup`, tearing down every `effect` / `memo` /\n *  `createAsync` registered in the body).\n *\n *  This is what `widget()` calls under the hood: it's the per-instance\n *  scope boundary. Surfaces also call it directly at their `add` /\n *  `append` entry points so each appended subtree gets its own root.\n *\n *  ```ts\n *  ui.add(() => {\n *    const [c, setC] = signal(0)\n *    onCleanup(() => clearInterval(timer))\n *    const timer = setInterval(() => setC(x => x + 1), 1000)\n *    return text(() => `count: ${c()}`)\n *  })\n *  ```\n */\nexport function createNode<T extends Node>(fn: () => T): T {\n  return createRoot((dispose) => fn().once(\"unmount\", dispose))\n}\n\n/** Register a cleanup against the active Owner. Fires when the Owner\n *  disposes — i.e. when the widget body's `createNode` Node unmounts,\n *  or when the surrounding `createRoot` is disposed.\n *\n *  ```ts\n *  function widgetBody() {\n *    const id = setInterval(() => tick(), 1000)\n *    onCleanup(() => clearInterval(id))\n *    return box(…)\n *  }\n *  ```\n *\n *  Throws if called outside any active Owner — the cleanup would\n *  never fire and the caller is almost certainly mistaken. */\nexport function onCleanup(fn: () => void): void {\n  const owner = activeOwnerStore.getStore()\n  if (owner === undefined) {\n    throw new Error(\"onCleanup: no active Owner — call from inside a widget body / createRoot\")\n  }\n  owner.addCleanup(fn)\n}\n\n/** Current Owner, or `undefined` outside any render. Captured by\n *  effects/memos at creation time and restored on re-fire.\n *\n *  @internal */\nexport function useActiveOwner(): Owner | undefined {\n  return activeOwnerStore.getStore()\n}\n\n/** Whether we're currently executing inside `node`'s own render call\n *  stack — i.e. this code path was reached synchronously (or via an\n *  await preserved by `AsyncLocalStorage`) from `node`'s `withActiveNode`.\n *\n *  Used by `invalidate()` to suppress *internal* cascades — e.g.\n *  Markdown mutating its child Text inside its own `_render`. External\n *  mutations (network callbacks, event handlers) run outside any\n *  render's ALS scope, so this returns `false` for them and they emit\n *  normally even when a render is in flight.\n *\n *  @internal */\nexport function inRenderContextOf(node: Node): boolean {\n  const active = activeCtx.getStore()\n  return active !== undefined && active === nodeCtx.get(node)\n}\n\nconst nodeCtx = new WeakMap<Node, TrackingCtx>()\n\n// ---- signal ----------------------------------------------------------\n\n/**\n * Reactive value. Returns a `[get, set]` tuple that's also accessible\n * as `.get` / `.set` for destructure-skipping callers. Reads inside a\n * tracking context (node render, effect, memo) auto-subscribe; writes\n * notify every subscriber synchronously.\n *\n * ```ts\n * const [count, setCount] = signal(0)\n * setCount(1)               // value form\n * setCount((prev) => prev + 1)  // updater form\n * ```\n *\n * **Storing a function as a value — gotcha**: `set` interprets any\n * function argument as the *updater* form `(prev) => next`, calls it\n * with the current value, and stores the result. To store a function\n * value (e.g. a callable `StyleBuilder` or a handler ref), wrap with\n * the updater form so the call resolves to the function you wanted:\n *\n * ```ts\n * const [style, setStyle] = signal<StyleBuilder | undefined>(undefined)\n * setStyle(ctx.style)         // ✗ stored as `ctx.style(undefined)` — a string\n * setStyle(() => ctx.style)   // ✓ stored as the StyleBuilder itself\n * ```\n *\n * Same trap exists in Solid and React's `useState`. If you find\n * yourself reaching for it, also consider whether storing a *plain*\n * value (the underlying data, not the chain/builder) and recomputing\n * the function-y derivative inside a `memo` is cleaner — usually it\n * is.\n *\n * Equality is reference-based: `set(v)` where `v === current` skips\n * the notify. Wrap mutable values you want to \"publish\" in a fresh\n * object/array, or use a counter signal to force fan-out.\n */\nexport function signal<T>(\n  initial: T,\n  opts: { equals?: false | ((prev: T, next: T) => boolean) } = {}\n): Signal<T> {\n  let value = initial\n  const subs = new Set<() => void>()\n  const equals = opts.equals === false ? () => false : (opts.equals ?? ((a, b) => a === b))\n\n  const get = brand((): T => {\n    const ctx = activeCtx.getStore()\n    if (ctx && !subs.has(ctx.notify)) {\n      subs.add(ctx.notify)\n      ctx.register(() => subs.delete(ctx.notify))\n    }\n    return value\n  }, \"get\")\n\n  const set = brand((next: T | ((prev: T) => T)): void => {\n    const resolved = typeof next === \"function\" ? (next as (prev: T) => T)(value) : next\n    if (equals(value, resolved)) return\n    value = resolved\n    // Snapshot — subscribers may mutate the set while running.\n    const snapshot = [...subs]\n    for (const notify of snapshot) notify()\n  }, \"set\")\n\n  return Object.assign([get, set] as const, { get, set }) as Signal<T>\n}\n\n/**\n * Lift a plain value to an `Accessor<T>`. The returned function always\n * returns `value`, never tracks, never notifies — useful at the boundary\n * where a static value enters a tree that otherwise expects `Accessor<T>`.\n *\n * Branded so `isAccessor` reports `true` and downstream `unwrap` calls\n * resolve to a stable function call rather than treating the value as\n * a ctx-aware thunk.\n *\n * ```ts\n * // Component expects `Accessor<Theme>` deep in the tree:\n * <CodeBlock theme={toAccessor(myStaticTheme)} />\n * ```\n */\nexport function toAccessor<T>(fn: () => T): Accessor<T> {\n  return brand(() => fn(), \"get\")\n}\n\n// ---- effect ----------------------------------------------------------\n\n/**\n * Run `fn` immediately, then re-run whenever a signal it read writes.\n * Returns a disposer that stops the effect and drops all tracked\n * subscriptions. Unlike node render, effect dependencies are re-tracked\n * from scratch on every run — reads that disappear from `fn` stop\n * triggering re-runs.\n *\n * ```ts\n * const dispose = effect(() => {\n *   console.log(\"status is\", status())\n * })\n * // ...\n * dispose()\n * ```\n *\n * **Footgun**: don't write a signal from inside an effect that reads\n * the same signal — you'll loop. Writing unrelated signals is fine.\n */\nexport function effect(fn: () => void | (() => void)): () => void {\n  let cleanups: (() => void)[] = []\n  let disposed = false\n\n  // Capture the Owner at creation time. Re-fires triggered by signal\n  // writes run in the *writer's* ALS context, which has nothing to do\n  // with where the effect was created. Restoring the captured Owner on\n  // each run keeps `useContext` walking the same ancestry regardless\n  // of who triggered the re-fire.\n  const owner = useActiveOwner()\n\n  const ctx: TrackingCtx = {\n    notify: () => {\n      if (disposed) return\n      run()\n    },\n    register: (cleanup) => {\n      cleanups.push(cleanup)\n    },\n  }\n\n  const run = (): void => {\n    // Fresh deps each run — unsubscribe from everything we saw last time.\n    const old = cleanups\n    cleanups = []\n    for (const c of old) c()\n    // oxlint-disable-next-line unicorn/consistent-function-scoping\n    const tracked = (): void | (() => void) => withTracking(ctx, fn)\n    const cleanup = owner !== undefined ? withOwner(owner, tracked) : tracked()\n    if (typeof cleanup === \"function\") cleanups.push(cleanup)\n  }\n\n  // Auto-dispose on owner teardown. If there's no owner, the caller\n  // owns the returned dispose function and is responsible for cleanup.\n  const dispose = (): void => {\n    if (disposed) return\n    disposed = true\n    for (const c of cleanups) c()\n    cleanups = []\n  }\n  owner?.addCleanup(dispose)\n\n  run()\n\n  return dispose\n}\n\n// ---- memo ------------------------------------------------------------\n\n/**\n * Derived, cached signal. `fn` runs once eagerly; the cached value is\n * returned from the accessor. When any signal `fn` reads writes, the\n * memo recomputes and notifies its own subscribers — but only if the\n * new value differs from the cached one (reference equality).\n *\n * ```ts\n * const [value, setValue] = signal(0)\n * const pct = memo(() => Math.round(value() * 100))\n * text(({ style }) => `${pct()}%`)   // subscribes to pct, not value\n * ```\n *\n * Returns an `Accessor<T>`, not a `[read, write]` tuple — memos are\n * read-only by construction.\n */\nexport function memo<T>(fn: () => T): Accessor<T> {\n  const [get, set] = signal<T>(undefined as T)\n  effect(() => {\n    // Wrap in the updater form so `signal.set`'s `typeof === \"function\"`\n    // detection always picks the outer closure, never `fn()`'s return\n    // value. Without this, memoizing a callable `T` (e.g. a chainable\n    // `StyleBuilder`) would cause `set` to invoke it as an updater and\n    // cache the call result instead of the value itself.\n    set(() => fn())\n  })\n  return get\n}\n\n// ---- signal store ----------------------------------------------------\n\n/**\n * Reactive struct with fine-grained, lazy per-field tracking.\n *\n * Reads:\n *   - `store.foo` — tracked when called inside a tracking ctx; allocates\n *     a signal for `foo` on first read.\n *\n * Writes:\n *   - `store.foo = x` — direct assignment.\n *   - `store({ foo: x, bar: y })` — partial patch (merge).\n *   - `store(current => ({ foo: current.foo + 1 }))` — updater form;\n *     the function receives the current plain state (untracked) and\n *     returns a partial patch which is then merged.\n *\n * All writes are value-equality (`===`) gated; setting a field to its\n * current value is a no-op. The function-form updater receives the\n * underlying state object directly so reads inside it are NOT tracked\n * — exactly what an updater wants (\"compute next from current\").\n *\n * Spread (`{ ...store }`) yields the current values of every field via\n * the proxy's `ownKeys` + `getOwnPropertyDescriptor` traps. Be aware:\n * spreading inside a tracking ctx subscribes that ctx to every field\n * (one signal allocation per field). Outside a tracking ctx, spread is\n * cheap (no signal allocation).\n *\n * Implementation: an inner `state` object is the source of truth for\n * plain reads / spreads / the updater's `current`. A `sigs` map is a\n * lazy tracking layer; a key only gets a signal once it's read inside\n * a tracking ctx. Writes update `state` and notify the signal *if it\n * exists* — fields nobody subscribed to never allocate.\n */\nexport type SignalStore<T extends object> = T & {\n  /** Apply a partial patch (merge), or call with an updater that\n   *  receives the current plain state (untracked) and returns a\n   *  partial to merge. Each field's signal short-circuits on value-\n   *  equality, so unchanged fields don't notify subscribers. */\n  set: (patch: Partial<T> | ((current: T) => Partial<T>)) => void\n}\n\nexport function createStore<T extends object>(initial: T): SignalStore<T> {\n  const state = { ...initial }\n  const sigs = {} as { [K in keyof T]?: Signal<T[K]> }\n\n  const ensure = <K extends keyof T>(key: K): Signal<T[K]> => (sigs[key] ??= signal(state[key]))\n\n  const setKey = <K extends keyof T>(key: K, value: T[K]): void => {\n    if (state[key] === value) return\n    state[key] = value\n    // Wrap in updater form so `signal.set`'s `typeof === \"function\"`\n    // detection always picks the outer closure — necessary for storing\n    // function-typed fields without `set` invoking them as updaters.\n    sigs[key]?.set(() => value)\n  }\n\n  const set = (patch: Partial<T> | ((c: T) => Partial<T>)): void => {\n    const p = typeof patch === \"function\" ? patch(state) : patch\n    for (const k of Object.keys(p) as (keyof T)[]) {\n      const v = p[k]\n      setKey(k, v as T[typeof k])\n    }\n  }\n\n  return new Proxy({} as object, {\n    get(_, key) {\n      if (key === \"set\") return set\n      return ensure(key as keyof T).get()\n    },\n    getOwnPropertyDescriptor(_, key) {\n      if (!Object.hasOwn(state, key)) return undefined\n      return {\n        configurable: true,\n        enumerable: true,\n        value: state[key as keyof T],\n      }\n    },\n    has(_, key) {\n      return key === \"set\" || (key as keyof T) in state\n    },\n    ownKeys() {\n      return Reflect.ownKeys(state)\n    },\n    set(_, key, value) {\n      setKey(key as keyof T, value as T[keyof T])\n      return true\n    },\n  }) as SignalStore<T>\n}\n\n// ---- suspense --------------------------------------------------------\n\n/**\n * Suspense boundary handle — the value of `SuspenseContext`. Consumers\n * (`createAsync`) call `increment` / `decrement` around in-flight work\n * so providers (Stream's append, a `suspense()` widget) can observe\n * \"is anything pending below me\".\n *\n * Boundaries chain: when a `suspense()` body installs its own boundary,\n * its `parent` is the nearest ancestor boundary. Count flips at the\n * 0→1 and 1→0 transitions propagate to the parent, so the outermost\n * boundary's count is `> 0` iff *any* descendant has pending work —\n * a single integer, no walks.\n *\n * `whenIdle` resolves when count returns to 0. Used by Stream to gate\n * paint on resolved async; could be used by any other \"wait for\n * subtree to settle\" caller.\n */\nexport type SuspenseBoundary = {\n  increment: () => void\n  decrement: () => void\n  active: () => boolean\n  whenIdle: () => Promise<void>\n}\n\n/** Nearest Suspense provider in the Owner chain. `undefined` when no\n *  boundary is installed — `createAsync` runs fire-and-forget in that\n *  case (signal resolves later, normal invalidation re-renders). */\nexport const SuspenseContext = createContext<SuspenseBoundary | undefined>(undefined)\n\n/**\n * Build a boundary whose count flips propagate to `parent` on the 0→1\n * and 1→0 transitions. Used by Stream's `append` and the `suspense()`\n * widget. Internal-ish — most callers shouldn't construct boundaries\n * directly.\n *\n * @internal\n */\nexport function createSuspenseBoundary(parent?: SuspenseBoundary): SuspenseBoundary {\n  let count = 0\n  let idle: { promise: Promise<void>; resolve: () => void } | undefined\n  return {\n    active: () => count > 0,\n    decrement: () => {\n      if (count === 0) return\n      count--\n      if (count === 0) {\n        parent?.decrement()\n        idle?.resolve()\n        idle = undefined\n      }\n    },\n    increment: () => {\n      count++\n      if (count === 1) parent?.increment()\n    },\n    whenIdle: () => {\n      if (count === 0) return Promise.resolve()\n      if (idle === undefined) {\n        const { promise, resolve } = Promise.withResolvers<void>()\n        idle = { promise, resolve }\n      }\n      return idle.promise\n    },\n  }\n}\n\n// ---- async -----------------------------------------------------------\n\n/**\n * Resource-style async accessor. `fn` reads signals (tracked); the\n * effect re-fires when any of them change. Each run notifies the\n * nearest `SuspenseContext` so a surrounding boundary (Stream's\n * append, a `suspense()` widget) can observe pending work.\n *\n * ```ts\n * const highlighted = createAsync(\n *   async (prev) => highlight(unwrap(props.code)),\n *   { initialValue: unwrap(props.code) },\n * )\n * text(highlighted)\n * ```\n *\n * **Stale-write protection**: each run bumps a generation counter;\n * late `.then` callbacks check it and skip `setValue` if a newer run\n * has already fired. The boundary is decremented exactly once per\n * increment (in the settle callback, regardless of staleness).\n *\n * **`prev`** is the previously resolved value (or `initialValue`) —\n * useful for diff-based fetches. Reading it does *not* track, so\n * resolving the new value won't re-fire the effect.\n *\n * **No active boundary** → increment/decrement no-op, work is\n * fire-and-forget. Right for UI surface widgets that re-render\n * cheaply on signal change. The Stream surface installs a boundary\n * per appended subtree so committed-to-scrollback rows always reflect\n * resolved values.\n */\nexport function createAsync<T>(\n  fn: (prev: T | undefined) => Promise<T>,\n  opts: { initialValue: T }\n): Accessor<T>\nexport function createAsync<T>(\n  fn: (prev: T | undefined) => Promise<T>,\n  opts?: { initialValue?: T }\n): Accessor<T | undefined>\nexport function createAsync<T>(\n  fn: (prev: T | undefined) => Promise<T>,\n  opts?: { initialValue?: T }\n): Accessor<T | undefined> {\n  const [value, setValue] = signal<T | undefined>(opts?.initialValue)\n  const suspense = useContext(SuspenseContext)\n  let gen = 0\n  effect(() => {\n    const my = ++gen\n    let p: Promise<T>\n    try {\n      p = fn(untrack(value))\n    } catch (error) {\n      // Sync throw inside `fn` — surface as a rejected promise so the\n      // boundary increment / decrement path stays uniform.\n      p = Promise.reject(error as Error)\n    }\n    suspense?.increment()\n    p.then(\n      (v) => {\n        if (my === gen) setValue(() => v)\n      },\n      () => {\n        // Swallow — async failures leave the previous (or initial)\n        // value in place.\n      }\n    ).finally(() => suspense?.decrement())\n  })\n  return value\n}\n\nexport type Progressive<T> = Accessor<T> & {\n  readonly loading: Accessor<boolean>\n  whenIdle: () => Promise<void>\n}\n\nexport function createProgressive<T>(\n  fn: (ctx: { signal: AbortSignal; set: (value: T) => void }) => MaybePromise<T>,\n  opts: { throttle?: number; initialValue: T }\n): Progressive<T>\nexport function createProgressive<T>(\n  fn: (ctx: { signal: AbortSignal; set: (value: T) => void }) => MaybePromise<T>,\n  opts: { throttle?: number; initialValue?: T }\n): Progressive<T | undefined>\nexport function createProgressive<T>(\n  fn: (ctx: { signal: AbortSignal; set: (value: T) => void }) => MaybePromise<T>,\n  opts: { throttle?: number; initialValue?: T } = {}\n): Progressive<T | undefined> {\n  const throttle = opts.throttle ?? 16\n  const [loading, setLoading] = signal(true)\n  const [state, setState] = signal<T | undefined>(opts.initialValue, { equals: false })\n\n  const ret: Progressive<T | undefined> = Object.assign(state, {\n    get loading() {\n      return loading\n    },\n    whenIdle: () => {\n      if (!loading()) return Promise.resolve()\n      idle ??= Promise.withResolvers<void>()\n      return idle.promise\n    },\n  })\n\n  let gen = 0\n  let idle: ReturnType<typeof Promise.withResolvers<void>> | undefined\n\n  effect(() => {\n    const my = ++gen\n    const ac = new AbortController()\n\n    void (async () => {\n      try {\n        setLoading(true)\n        let prev = 0\n        const result = await fn({\n          set: (value: T) => {\n            if (ac.signal.aborted || my !== gen) return\n            const now = performance.now()\n            if (now - prev >= throttle) {\n              prev = now\n              setState(() => value)\n            }\n          },\n          signal: ac.signal,\n        })\n        if (my === gen) {\n          setState(() => result)\n          setLoading(false)\n          idle?.resolve()\n          idle = undefined\n        }\n      } catch (error) {\n        if (my === gen) {\n          setLoading(false)\n          idle?.reject(error)\n          idle = undefined\n        }\n      } finally {\n        ac.abort()\n      }\n    })()\n\n    return () => {\n      ac.abort()\n    }\n  })\n\n  return ret\n}\n\nexport function createIterable<T>(\n  fn: (ctx: { signal: AbortSignal }) => AsyncIterable<T | readonly T[]>,\n  opts: { throttle?: number; initialValue?: readonly T[] } = {}\n): Progressive<readonly T[]> {\n  return createProgressive(\n    async ({ signal: s, set }) => {\n      const results: T[] = []\n      for await (const item of fn({ signal: s })) {\n        if (s.aborted) return results\n        results.push(...(Array.isArray(item) ? item : [item]))\n        set(results)\n      }\n      return results\n    },\n    { ...opts, initialValue: opts.initialValue ?? [] }\n  )\n}\n\nexport interface Ref<T> {\n  (): T\n  get value(): T | undefined\n  set value(value: T)\n}\n\nexport function createRef<T>(\n  value?: T,\n  opts: { onSet?: (value: T, prev: T | undefined) => void | (() => void) } = {}\n): Ref<T> {\n  let current = value\n  let cleanup: (() => void) | undefined\n\n  const get = (): T => {\n    if (current === undefined) throw new Error(\"Ref value accessed before initialization\")\n    return current\n  }\n\n  Object.defineProperty(get, \"value\", {\n    get: () => current,\n    set: (v: T) => {\n      if (current === v) return\n      cleanup?.()\n      cleanup = undefined\n      const prev = current\n      current = v\n      cleanup = opts.onSet?.(v, prev) ?? undefined\n    },\n  })\n\n  return get as Ref<T>\n}\n"],"mappings":";;AA0CA,MAAM,YAAY,IAAI,kBAA2C;AAEjE,SAAS,aAAgB,KAAkB,IAAgB;CACzD,OAAO,UAAU,IAAI,KAAK,EAAE;AAC9B;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,QAAW,IAAgB;CACzC,OAAO,UAAU,IAAI,KAAA,GAAW,EAAE;AACpC;;;AAIA,SAAgB,KAAQ,GAAmB;CACzC,OAAO,cAAc,OAAO,CAAC,CAAC;AAChC;AAoCA,SAAgB,cAAiB,cAA0C;CACzE,OAAO;EAAE;EAAc,IAAI,OAAO,mBAAmB;CAAE;AACzD;;;;AAKA,SAAgB,eAAkB,KAAiB,OAAgB;CACjE,MAAM,QAAQ,iBAAiB,SAAS;CACxC,IAAI,UAAU,KAAA,GACZ,MAAM,IAAI,MAAM,qEAAqE;CAEvF,MAAM,WAAW,IAAI,IAAI,KAAK;AAChC;;;;AAKA,SAAgB,WAAc,KAAoB;CAChD,KAAK,IAAI,IAAI,iBAAiB,SAAS,GAAG,MAAM,KAAA,GAAW,IAAI,EAAE,QAAQ;EACvE,MAAM,MAAM,EAAE;EACd,IAAI,KAAK,IAAI,IAAI,EAAE,GAAG,OAAO,IAAI,IAAI,IAAI,EAAE;CAC7C;CACA,OAAO,IAAI;AACb;;;;AAOA,MAAM,WAAW,OAAO,IAAI,oBAAoB;;;;;AAsBhD,SAAgB,WAAc,GAA8B;CAC1D,OAAO,OAAO,MAAM,cAAe,EAA8B,cAAc;AACjF;;;;;;AAOA,SAAgB,OAAU,GAAmB;CAC3C,OAAO,WAAc,CAAC,IAAI,EAAE,IAAI;AAClC;AAIA,SAAS,MAAyC,IAAO,KAAuB;CAC9E,OAAO,eAAe,IAAI,UAAU;EAClC,cAAc;EACd,YAAY;EACZ,OAAO;EACP,UAAU;CACZ,CAAC;CACD,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;AAyBA,IAAa,QAAb,MAAmB;CACjB;CACA,YAA4B,CAAC;CAC7B;CACA,YAAY;CAEZ,YAAY,QAAgB;EAC1B,KAAK,SAAS;CAChB;CAEA,IAAI,WAAoB;EACtB,OAAO,KAAK;CACd;;;CAIA,IAAI,WAAqD;EACvD,OAAO,KAAK;CACd;CAEA,WAAW,IAAY,OAAsB;EAC1C,CAAC,KAAK,8BAAc,IAAI,IAAI,EAAA,CAAG,IAAI,IAAI,KAAK;CAC/C;;CAGA,WAAW,IAAsB;EAC/B,IAAI,KAAK,WAAW;GAClB,GAAG;GACH;EACF;EACA,KAAK,UAAU,KAAK,EAAE;CACxB;;CAGA,UAAgB;EACd,IAAI,KAAK,WAAW;EACpB,KAAK,YAAY;EACjB,KAAK,IAAI,IAAI,KAAK,UAAU,SAAS,GAAG,KAAK,GAAG,KAC9C,IAAI;GACF,KAAK,UAAU,EAAE,CAAC;EACpB,SAAS,OAAO;GAGd,QAAQ,MAAM,wBAAwB,KAAK;EAC7C;EAEF,KAAK,YAAY,CAAC;EAClB,KAAK,YAAY,KAAA;CACnB;AACF;AAEA,MAAM,mBAAmB,IAAI,kBAAqC;;;;;;;;;;;;;AAclE,SAAgB,eAAkB,MAAY,IAAgB;CAC5D,OAAO,aAAa,mBAAmB,IAAI,GAAG,EAAE;AAClD;;;;;;;AAQA,SAAgB,UAAa,OAAc,IAAgB;CACzD,OAAO,iBAAiB,IAAI,OAAO,EAAE;AACvC;AAEA,SAAS,mBAAmB,MAAyB;CACnD,IAAI,MAAM,QAAQ,IAAI,IAAI;CAC1B,IAAI,QAAQ,KAAA,GAAW;EACrB,MAAM;GACJ,cAAc,KAAK,WAAW;GAC9B,WAAW,YAAY;IACrB,KAAK,KAAK,WAAW,OAAO;GAC9B;EACF;EACA,QAAQ,IAAI,MAAM,GAAG;CACvB;CACA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,WAAc,IAAmC;CAE/D,MAAM,QAAQ,IAAI,MADH,iBAAiB,SACR,CAAM;CAC9B,OAAO,UAAU,aAAa,SAAS,MAAM,QAAQ,CAAC,CAAC;AACzD;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,WAA2B,IAAgB;CACzD,OAAO,YAAY,YAAY,GAAG,CAAC,CAAC,KAAK,WAAW,OAAO,CAAC;AAC9D;;;;;;;;;;;;;;;AAgBA,SAAgB,UAAU,IAAsB;CAC9C,MAAM,QAAQ,iBAAiB,SAAS;CACxC,IAAI,UAAU,KAAA,GACZ,MAAM,IAAI,MAAM,0EAA0E;CAE5F,MAAM,WAAW,EAAE;AACrB;;;;;AAMA,SAAgB,iBAAoC;CAClD,OAAO,iBAAiB,SAAS;AACnC;;;;;;;;;;;;AAaA,SAAgB,kBAAkB,MAAqB;CACrD,MAAM,SAAS,UAAU,SAAS;CAClC,OAAO,WAAW,KAAA,KAAa,WAAW,QAAQ,IAAI,IAAI;AAC5D;AAEA,MAAM,0BAAU,IAAI,QAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsC/C,SAAgB,OACd,SACA,OAA6D,CAAC,GACnD;CACX,IAAI,QAAQ;CACZ,MAAM,uBAAO,IAAI,IAAgB;CACjC,MAAM,SAAS,KAAK,WAAW,cAAc,QAAS,KAAK,YAAY,GAAG,MAAM,MAAM;CAEtF,MAAM,MAAM,YAAe;EACzB,MAAM,MAAM,UAAU,SAAS;EAC/B,IAAI,OAAO,CAAC,KAAK,IAAI,IAAI,MAAM,GAAG;GAChC,KAAK,IAAI,IAAI,MAAM;GACnB,IAAI,eAAe,KAAK,OAAO,IAAI,MAAM,CAAC;EAC5C;EACA,OAAO;CACT,GAAG,KAAK;CAER,MAAM,MAAM,OAAO,SAAqC;EACtD,MAAM,WAAW,OAAO,SAAS,aAAc,KAAwB,KAAK,IAAI;EAChF,IAAI,OAAO,OAAO,QAAQ,GAAG;EAC7B,QAAQ;EAER,MAAM,WAAW,CAAC,GAAG,IAAI;EACzB,KAAK,MAAM,UAAU,UAAU,OAAO;CACxC,GAAG,KAAK;CAER,OAAO,OAAO,OAAO,CAAC,KAAK,GAAG,GAAY;EAAE;EAAK;CAAI,CAAC;AACxD;;;;;;;;;;;;;;;AAgBA,SAAgB,WAAc,IAA0B;CACtD,OAAO,YAAY,GAAG,GAAG,KAAK;AAChC;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,OAAO,IAA2C;CAChE,IAAI,WAA2B,CAAC;CAChC,IAAI,WAAW;CAOf,MAAM,QAAQ,eAAe;CAE7B,MAAM,MAAmB;EACvB,cAAc;GACZ,IAAI,UAAU;GACd,IAAI;EACN;EACA,WAAW,YAAY;GACrB,SAAS,KAAK,OAAO;EACvB;CACF;CAEA,MAAM,YAAkB;EAEtB,MAAM,MAAM;EACZ,WAAW,CAAC;EACZ,KAAK,MAAM,KAAK,KAAK,EAAE;EAEvB,MAAM,gBAAqC,aAAa,KAAK,EAAE;EAC/D,MAAM,UAAU,UAAU,KAAA,IAAY,UAAU,OAAO,OAAO,IAAI,QAAQ;EAC1E,IAAI,OAAO,YAAY,YAAY,SAAS,KAAK,OAAO;CAC1D;CAIA,MAAM,gBAAsB;EAC1B,IAAI,UAAU;EACd,WAAW;EACX,KAAK,MAAM,KAAK,UAAU,EAAE;EAC5B,WAAW,CAAC;CACd;CACA,OAAO,WAAW,OAAO;CAEzB,IAAI;CAEJ,OAAO;AACT;;;;;;;;;;;;;;;;AAmBA,SAAgB,KAAQ,IAA0B;CAChD,MAAM,CAAC,KAAK,OAAO,OAAU,KAAA,CAAc;CAC3C,aAAa;EAMX,UAAU,GAAG,CAAC;CAChB,CAAC;CACD,OAAO;AACT;AA2CA,SAAgB,YAA8B,SAA4B;CACxE,MAAM,QAAQ,EAAE,GAAG,QAAQ;CAC3B,MAAM,OAAO,CAAC;CAEd,MAAM,UAA6B,QAA0B,KAAK,SAAS,OAAO,MAAM,IAAI;CAE5F,MAAM,UAA6B,KAAQ,UAAsB;EAC/D,IAAI,MAAM,SAAS,OAAO;EAC1B,MAAM,OAAO;EAIb,KAAK,IAAI,EAAE,UAAU,KAAK;CAC5B;CAEA,MAAM,OAAO,UAAqD;EAChE,MAAM,IAAI,OAAO,UAAU,aAAa,MAAM,KAAK,IAAI;EACvD,KAAK,MAAM,KAAK,OAAO,KAAK,CAAC,GAAkB;GAC7C,MAAM,IAAI,EAAE;GACZ,OAAO,GAAG,CAAgB;EAC5B;CACF;CAEA,OAAO,IAAI,MAAM,CAAC,GAAa;EAC7B,IAAI,GAAG,KAAK;GACV,IAAI,QAAQ,OAAO,OAAO;GAC1B,OAAO,OAAO,GAAc,CAAC,CAAC,IAAI;EACpC;EACA,yBAAyB,GAAG,KAAK;GAC/B,IAAI,CAAC,OAAO,OAAO,OAAO,GAAG,GAAG,OAAO,KAAA;GACvC,OAAO;IACL,cAAc;IACd,YAAY;IACZ,OAAO,MAAM;GACf;EACF;EACA,IAAI,GAAG,KAAK;GACV,OAAO,QAAQ,SAAU,OAAmB;EAC9C;EACA,UAAU;GACR,OAAO,QAAQ,QAAQ,KAAK;EAC9B;EACA,IAAI,GAAG,KAAK,OAAO;GACjB,OAAO,KAAgB,KAAmB;GAC1C,OAAO;EACT;CACF,CAAC;AACH;;;;AA8BA,MAAa,kBAAkB,cAA4C,KAAA,CAAS;;;;;;;;;AAUpF,SAAgB,uBAAuB,QAA6C;CAClF,IAAI,QAAQ;CACZ,IAAI;CACJ,OAAO;EACL,cAAc,QAAQ;EACtB,iBAAiB;GACf,IAAI,UAAU,GAAG;GACjB;GACA,IAAI,UAAU,GAAG;IACf,QAAQ,UAAU;IAClB,MAAM,QAAQ;IACd,OAAO,KAAA;GACT;EACF;EACA,iBAAiB;GACf;GACA,IAAI,UAAU,GAAG,QAAQ,UAAU;EACrC;EACA,gBAAgB;GACd,IAAI,UAAU,GAAG,OAAO,QAAQ,QAAQ;GACxC,IAAI,SAAS,KAAA,GAAW;IACtB,MAAM,EAAE,SAAS,YAAY,QAAQ,cAAoB;IACzD,OAAO;KAAE;KAAS;IAAQ;GAC5B;GACA,OAAO,KAAK;EACd;CACF;AACF;AAyCA,SAAgB,YACd,IACA,MACyB;CACzB,MAAM,CAAC,OAAO,YAAY,OAAsB,MAAM,YAAY;CAClE,MAAM,WAAW,WAAW,eAAe;CAC3C,IAAI,MAAM;CACV,aAAa;EACX,MAAM,KAAK,EAAE;EACb,IAAI;EACJ,IAAI;GACF,IAAI,GAAG,QAAQ,KAAK,CAAC;EACvB,SAAS,OAAO;GAGd,IAAI,QAAQ,OAAO,KAAc;EACnC;EACA,UAAU,UAAU;EACpB,EAAE,MACC,MAAM;GACL,IAAI,OAAO,KAAK,eAAe,CAAC;EAClC,SACM,CAGN,CACF,CAAC,CAAC,cAAc,UAAU,UAAU,CAAC;CACvC,CAAC;CACD,OAAO;AACT;AAeA,SAAgB,kBACd,IACA,OAAgD,CAAC,GACrB;CAC5B,MAAM,WAAW,KAAK,YAAY;CAClC,MAAM,CAAC,SAAS,cAAc,OAAO,IAAI;CACzC,MAAM,CAAC,OAAO,YAAY,OAAsB,KAAK,cAAc,EAAE,QAAQ,MAAM,CAAC;CAEpF,MAAM,MAAkC,OAAO,OAAO,OAAO;EAC3D,IAAI,UAAU;GACZ,OAAO;EACT;EACA,gBAAgB;GACd,IAAI,CAAC,QAAQ,GAAG,OAAO,QAAQ,QAAQ;GACvC,SAAS,QAAQ,cAAoB;GACrC,OAAO,KAAK;EACd;CACF,CAAC;CAED,IAAI,MAAM;CACV,IAAI;CAEJ,aAAa;EACX,MAAM,KAAK,EAAE;EACb,MAAM,KAAK,IAAI,gBAAgB;EAE/B,CAAM,YAAY;GAChB,IAAI;IACF,WAAW,IAAI;IACf,IAAI,OAAO;IACX,MAAM,SAAS,MAAM,GAAG;KACtB,MAAM,UAAa;MACjB,IAAI,GAAG,OAAO,WAAW,OAAO,KAAK;MACrC,MAAM,MAAM,YAAY,IAAI;MAC5B,IAAI,MAAM,QAAQ,UAAU;OAC1B,OAAO;OACP,eAAe,KAAK;MACtB;KACF;KACA,QAAQ,GAAG;IACb,CAAC;IACD,IAAI,OAAO,KAAK;KACd,eAAe,MAAM;KACrB,WAAW,KAAK;KAChB,MAAM,QAAQ;KACd,OAAO,KAAA;IACT;GACF,SAAS,OAAO;IACd,IAAI,OAAO,KAAK;KACd,WAAW,KAAK;KAChB,MAAM,OAAO,KAAK;KAClB,OAAO,KAAA;IACT;GACF,UAAU;IACR,GAAG,MAAM;GACX;EACF,EAAA,CAAG;EAEH,aAAa;GACX,GAAG,MAAM;EACX;CACF,CAAC;CAED,OAAO;AACT;AAEA,SAAgB,eACd,IACA,OAA2D,CAAC,GACjC;CAC3B,OAAO,kBACL,OAAO,EAAE,QAAQ,GAAG,UAAU;EAC5B,MAAM,UAAe,CAAC;EACtB,WAAW,MAAM,QAAQ,GAAG,EAAE,QAAQ,EAAE,CAAC,GAAG;GAC1C,IAAI,EAAE,SAAS,OAAO;GACtB,QAAQ,KAAK,GAAI,MAAM,QAAQ,IAAI,IAAI,OAAO,CAAC,IAAI,CAAE;GACrD,IAAI,OAAO;EACb;EACA,OAAO;CACT,GACA;EAAE,GAAG;EAAM,cAAc,KAAK,gBAAgB,CAAC;CAAE,CACnD;AACF;AAQA,SAAgB,UACd,OACA,OAA2E,CAAC,GACpE;CACR,IAAI,UAAU;CACd,IAAI;CAEJ,MAAM,YAAe;EACnB,IAAI,YAAY,KAAA,GAAW,MAAM,IAAI,MAAM,0CAA0C;EACrF,OAAO;CACT;CAEA,OAAO,eAAe,KAAK,SAAS;EAClC,WAAW;EACX,MAAM,MAAS;GACb,IAAI,YAAY,GAAG;GACnB,UAAU;GACV,UAAU,KAAA;GACV,MAAM,OAAO;GACb,UAAU;GACV,UAAU,KAAK,QAAQ,GAAG,IAAI,KAAK,KAAA;EACrC;CACF,CAAC;CAED,OAAO;AACT"}

package/dist/{registry-CEpHcTa2.mjs → registry-3hLzS4ks.mjs}

@@ -343,7 +343,7 @@ function resolveTheme(theme, id) {
 async function loadThemeFile(path) {
 	const raw = withError(() => readFileSync(path, "utf8"), `Failed to read theme file at ${path}`);
 	const data = withError(() => JSON.parse(raw), `Failed to parse theme JSON at ${path}`);
-	const { validateTheme } = await import("./theme.config-DoW6LIcl.mjs");
+	const { validateTheme } = await import("./theme.config-BKXX_noZ.mjs");
 	return resolveTheme(validateTheme(data), basename(path, ".json"));
 }
 /** TokyoNight Moon — the default. Sourced from `assets/themes/tokyonight-moon.json`. */
@@ -351,4 +351,4 @@ const defaultTheme = resolveTheme(tokyonight_moon_default, "tokyonight-moon");
 //#endregion
 export { loadTheme as n, themeRegistry as r, defaultTheme as t };
 
-//# sourceMappingURL=registry-CEpHcTa2.mjs.map
+//# sourceMappingURL=registry-3hLzS4ks.mjs.map

package/dist/{registry-CEpHcTa2.mjs.map → registry-3hLzS4ks.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"registry-CEpHcTa2.mjs","names":["moonJson"],"sources":["../assets/themes/tokyonight-moon.json","../src/themes/builtin.ts","../src/themes/default.ts","../src/themes/registry.ts"],"sourcesContent":["","// AUTO-GENERATED by `scripts/gen-themes.ts`. DO NOT EDIT.\n// Re-run `bun scripts/gen-themes.ts` after adding/renaming a theme.\n\nimport type { ThemeLoader } from \"./registry.ts\"\nimport type { Theme } from \"./types.ts\"\n\nconst importTheme = (path: string): Promise<Partial<Theme>> =>\n  import(`#assets/themes/${path}.json`, { with: { type: \"json\" } }).then(\n    (m) => m.default as Partial<Theme>\n  )\n\n/**\n * Async loader map for every built-in theme. Each entry returns the\n * raw JSON; `themes/index.ts` wraps these with `resolveTheme` to\n * produce a fully-resolved `Theme` from the registry. Bundlers\n * code-split each `import(\"…json\")` into its own chunk, so apps only\n * pull the theme they actually load.\n *\n * `as const satisfies Record<string, ThemeLoader>` keeps the keys\n * narrow (so `BuiltinThemeName` is a literal union) but lets the\n * value type widen to `Partial<Theme>` — themes have no per-key\n * narrow types worth preserving, and the satisfies clause means\n * `themes/index.ts` can pass this map straight to `themeRegistry`\n * with no cast.\n */\nexport const builtin = {\n  \"ayu-dark\": () => importTheme(\"ayu-dark\"),\n  \"catppuccin-frappe\": () => importTheme(\"catppuccin-frappe\"),\n  \"catppuccin-latte\": () => importTheme(\"catppuccin-latte\"),\n  \"catppuccin-macchiato\": () => importTheme(\"catppuccin-macchiato\"),\n  \"catppuccin-mocha\": () => importTheme(\"catppuccin-mocha\"),\n  dracula: () => importTheme(\"dracula\"),\n  \"dracula-soft\": () => importTheme(\"dracula-soft\"),\n  \"everforest-dark\": () => importTheme(\"everforest-dark\"),\n  \"everforest-light\": () => importTheme(\"everforest-light\"),\n  \"github-dark\": () => importTheme(\"github-dark\"),\n  \"github-light\": () => importTheme(\"github-light\"),\n  \"gruvbox-dark-medium\": () => importTheme(\"gruvbox-dark-medium\"),\n  \"kanagawa-dragon\": () => importTheme(\"kanagawa-dragon\"),\n  \"kanagawa-wave\": () => importTheme(\"kanagawa-wave\"),\n  \"material-theme-palenight\": () => importTheme(\"material-theme-palenight\"),\n  \"min-dark\": () => importTheme(\"min-dark\"),\n  \"min-light\": () => importTheme(\"min-light\"),\n  monokai: () => importTheme(\"monokai\"),\n  \"night-owl\": () => importTheme(\"night-owl\"),\n  nord: () => importTheme(\"nord\"),\n  \"one-dark-pro\": () => importTheme(\"one-dark-pro\"),\n  \"one-light\": () => importTheme(\"one-light\"),\n  poimandres: () => importTheme(\"poimandres\"),\n  \"rose-pine\": () => importTheme(\"rose-pine\"),\n  \"solarized-dark\": () => importTheme(\"solarized-dark\"),\n  \"solarized-light\": () => importTheme(\"solarized-light\"),\n  \"synthwave-84\": () => importTheme(\"synthwave-84\"),\n  \"tokyonight-day\": () => importTheme(\"tokyonight-day\"),\n  \"tokyonight-moon\": () => importTheme(\"tokyonight-moon\"),\n  \"tokyonight-night\": () => importTheme(\"tokyonight-night\"),\n  \"tokyonight-storm\": () => importTheme(\"tokyonight-storm\"),\n  vesper: () => importTheme(\"vesper\"),\n  \"vitesse-dark\": () => importTheme(\"vitesse-dark\"),\n  \"vitesse-light\": () => importTheme(\"vitesse-light\"),\n} as const satisfies Record<string, ThemeLoader>\n","import type { Theme } from \"./types.ts\"\n\n/**\n * Slot-level fallbacks. Every Theme value is shallow-merged on top of\n * this record by `resolveTheme`, so partial JSON themes only need to\n * declare slots that diverge from these defaults.\n *\n * Distinct from `defaultTheme` — that's the precomputed `tokyonight-moon`\n * Theme bundled as the default palette for `createCtx()` etc.\n */\n// oxlint-disable-next-line sort-keys\nexport const defaults: Omit<Theme, \"id\"> = {\n  // base colors\n  primary: \"blue\",\n  accent: \"brightMagenta\",\n\n  // text\n  text: \"inherit\",\n  muted: { dim: true },\n  quiet: { dim: true, fg: \"muted\", italic: true },\n  comment: { fg: \"muted\", italic: true },\n  title: { bold: true, fg: \"primary\" },\n  delim: \"muted\",\n\n  // surface & structure\n  subtle: \"brightBlack\",\n  ui: { bg: \"subtle\" },\n  overlay: { bg: \"subtle\" },\n  highlight: { bg: \"subtle\" },\n\n  // ui primitives\n  divider: \"subtle\",\n  selection: { bg: \"brightBlue\", fg: \"black\" },\n  gutter: \"subtle\",\n  prompt: \"inherit\",\n  border: \"black\",\n  borderTitle: \"title\",\n\n  // code\n  code: { bg: \"subtle\" },\n  codeTitle: \"title\",\n\n  // log levels\n  success: \"green\",\n  info: \"cyan\",\n  warn: \"yellow\",\n  error: \"red\",\n\n  // syntax\n  syntaxNumber: \"brightBlue\",\n  syntaxString: \"green\",\n  syntaxBoolean: \"yellow\",\n  syntaxFunction: \"blue\",\n  syntaxField: \"white\",\n  syntaxConstant: \"magenta\",\n  syntaxSpecial: \"red\",\n  syntaxDelimiter: \"delim\",\n  syntaxBracket: \"delim\",\n\n  // markdown\n  mdBold: { bold: true },\n  mdCode: { bg: \"primary+10\", fg: \"black\" },\n  mdCodeBlock: { bg: \"highlight\", fg: \"primary\" },\n  mdCodeBlockTitle: \"title\",\n  mdHeading1: \"mdHeading\",\n  mdHeading2: { bold: true, fg: \"accent\" },\n  mdHeading3: \"mdHeading2\",\n  mdHeading4: \"mdHeading2\",\n  mdHeading5: \"mdHeading2\",\n  mdHeading6: \"mdHeading2\",\n  mdHeading: \"title\",\n  mdHr: \"accent\",\n  mdItalic: { italic: true },\n  mdLink: { fg: \"primary\", underline: true },\n  mdListBullet: \"accent\",\n  mdListChecked: \"primary\",\n  mdListUnchecked: \"primary\",\n  mdQuote: \"muted\",\n  mdStrikethrough: { strikethrough: true },\n  mdTable: \"accent\",\n  mdTableHeader: \"title\",\n\n  // menu\n  optionActive: \"selection\",\n  optionDesc: \"muted\",\n  optionName: \"primary\",\n\n  // diff\n  diffAdd: { bg: \"success-50\", fg: \"success\" },\n  diffContext: \"muted\",\n  diffDel: { bg: \"error-50\", fg: \"error\" },\n  diffLine: \"gutter\",\n  diffTitle: \"title\",\n}\n\n// oxlint-disable-next-line sort-keys\nexport const ansi: Theme = {\n  id: \"ansi\",\n  name: \"ANSI\",\n  ...defaults,\n  subtle: \"inherit\",\n  divider: \"brightBlue\",\n  border: \"brightBlue\",\n  highlight: { bg: \"brightBlack\" },\n  ui: { bg: \"brightBlack\" },\n  selection: { inverse: true },\n  diffAdd: { fg: \"success\" },\n  diffDel: { fg: \"error\" },\n}\n","import type { Theme } from \"./types.ts\"\n\nimport { withError } from \"@zaly/shared\"\nimport { createRegistry } from \"@zaly/shared/registry\"\nimport { readFileSync } from \"node:fs\"\nimport { basename } from \"pathe\"\nimport moonJson from \"../../assets/themes/tokyonight-moon.json\" with { type: \"json\" }\nimport { builtin } from \"./builtin.ts\"\nimport { defaults, ansi } from \"./default.ts\"\n\n/** Built-in theme names plus the synthetic `\"ansi\"` palette (no JSON\n *  — falls back to `defaults` only). */\nexport type BuiltinTheme = keyof typeof builtin | \"ansi\"\nexport type AnyTheme = BuiltinTheme | (string & {})\nexport type ThemeLoader = () => Promise<Partial<Theme>>\n\nconst DEFAULT_THEME: BuiltinTheme = \"tokyonight-moon\"\n\n/**\n * Registry of built-in themes plus any registered at runtime. The\n * registry never awaits — loaders return `Promise<Partial<Theme>>` so\n * callers `await` explicitly.\n */\nexport const themeRegistry = createRegistry<ThemeLoader>(\"theme\").from(builtin)\n// NOTE: remove the ansi theme for now, since it looks kinda broken and not really possible\n// to fix properly\nthemeRegistry.register(\"ansi\", async () => ({ ...ansi }))\n\n/**\n * Load a theme by name or path.\n */\nexport async function loadTheme(name?: string): Promise<Theme>\nexport async function loadTheme(opts: { name?: string; path?: string }): Promise<Theme>\nexport async function loadTheme(o?: string | { name?: string; path?: string }): Promise<Theme> {\n  o ??= DEFAULT_THEME\n  const opts = typeof o === \"string\" ? { name: o } : o\n\n  if (opts.name?.endsWith(\".json\")) return loadTheme({ path: opts.name })\n  if (opts.path) return loadThemeFile(opts.path)\n  if (opts.name) {\n    if (opts.name === DEFAULT_THEME) return defaultTheme\n    if (themeRegistry.has(opts.name))\n      return resolveTheme(await themeRegistry.load(opts.name), opts.name)\n    throw new Error(`Theme \"${opts.name}\" not found.`)\n  }\n\n  return defaultTheme\n}\n\n/**\n * Fill defaults on a raw theme object. Built-in JSON is dev-controlled\n * so we don't pay typia's ~3MB of generated assertions at startup;\n * user-supplied JSON goes through `loadThemeFile` which validates.\n */\nfunction resolveTheme(theme: unknown, id: string): Theme {\n  const { $schema: _, ...rest } = theme as Partial<Theme> & { $schema?: unknown }\n  return { ...defaults, id, name: id, ...rest }\n}\n\n/**\n * Load a theme directly from a file path. No directory search happens —\n * this is the escape hatch for CLIs that accept an explicit `--theme\n * /path/to/theme.json` argument.\n *\n * Async because typia's generated `validateTheme` (a few thousand\n * unrolled assertions) is dynamically imported here — it's only needed\n * for user-supplied JSON and should stay off the main startup path.\n */\nasync function loadThemeFile(path: string): Promise<Theme> {\n  const raw = withError(() => readFileSync(path, \"utf8\"), `Failed to read theme file at ${path}`)\n  const data = withError(() => JSON.parse(raw), `Failed to parse theme JSON at ${path}`)\n  const { validateTheme } = await import(\"../schemas/gen/theme.config.ts\")\n  return resolveTheme(validateTheme(data), basename(path, \".json\"))\n}\n\n/** TokyoNight Moon — the default. Sourced from `assets/themes/tokyonight-moon.json`. */\nexport const defaultTheme = resolveTheme(moonJson, \"tokyonight-moon\")\n"],"mappings":"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"}
+{"version":3,"file":"registry-3hLzS4ks.mjs","names":["moonJson"],"sources":["../assets/themes/tokyonight-moon.json","../src/themes/builtin.ts","../src/themes/default.ts","../src/themes/registry.ts"],"sourcesContent":["","// AUTO-GENERATED by `scripts/gen-themes.ts`. DO NOT EDIT.\n// Re-run `bun scripts/gen-themes.ts` after adding/renaming a theme.\n\nimport type { ThemeLoader } from \"./registry.ts\"\nimport type { Theme } from \"./types.ts\"\n\nconst importTheme = (path: string): Promise<Partial<Theme>> =>\n  import(`#assets/themes/${path}.json`, { with: { type: \"json\" } }).then(\n    (m) => m.default as Partial<Theme>\n  )\n\n/**\n * Async loader map for every built-in theme. Each entry returns the\n * raw JSON; `themes/index.ts` wraps these with `resolveTheme` to\n * produce a fully-resolved `Theme` from the registry. Bundlers\n * code-split each `import(\"…json\")` into its own chunk, so apps only\n * pull the theme they actually load.\n *\n * `as const satisfies Record<string, ThemeLoader>` keeps the keys\n * narrow (so `BuiltinThemeName` is a literal union) but lets the\n * value type widen to `Partial<Theme>` — themes have no per-key\n * narrow types worth preserving, and the satisfies clause means\n * `themes/index.ts` can pass this map straight to `themeRegistry`\n * with no cast.\n */\nexport const builtin = {\n  \"ayu-dark\": () => importTheme(\"ayu-dark\"),\n  \"catppuccin-frappe\": () => importTheme(\"catppuccin-frappe\"),\n  \"catppuccin-latte\": () => importTheme(\"catppuccin-latte\"),\n  \"catppuccin-macchiato\": () => importTheme(\"catppuccin-macchiato\"),\n  \"catppuccin-mocha\": () => importTheme(\"catppuccin-mocha\"),\n  dracula: () => importTheme(\"dracula\"),\n  \"dracula-soft\": () => importTheme(\"dracula-soft\"),\n  \"everforest-dark\": () => importTheme(\"everforest-dark\"),\n  \"everforest-light\": () => importTheme(\"everforest-light\"),\n  \"github-dark\": () => importTheme(\"github-dark\"),\n  \"github-light\": () => importTheme(\"github-light\"),\n  \"gruvbox-dark-medium\": () => importTheme(\"gruvbox-dark-medium\"),\n  \"kanagawa-dragon\": () => importTheme(\"kanagawa-dragon\"),\n  \"kanagawa-wave\": () => importTheme(\"kanagawa-wave\"),\n  \"material-theme-palenight\": () => importTheme(\"material-theme-palenight\"),\n  \"min-dark\": () => importTheme(\"min-dark\"),\n  \"min-light\": () => importTheme(\"min-light\"),\n  monokai: () => importTheme(\"monokai\"),\n  \"night-owl\": () => importTheme(\"night-owl\"),\n  nord: () => importTheme(\"nord\"),\n  \"one-dark-pro\": () => importTheme(\"one-dark-pro\"),\n  \"one-light\": () => importTheme(\"one-light\"),\n  poimandres: () => importTheme(\"poimandres\"),\n  \"rose-pine\": () => importTheme(\"rose-pine\"),\n  \"solarized-dark\": () => importTheme(\"solarized-dark\"),\n  \"solarized-light\": () => importTheme(\"solarized-light\"),\n  \"synthwave-84\": () => importTheme(\"synthwave-84\"),\n  \"tokyonight-day\": () => importTheme(\"tokyonight-day\"),\n  \"tokyonight-moon\": () => importTheme(\"tokyonight-moon\"),\n  \"tokyonight-night\": () => importTheme(\"tokyonight-night\"),\n  \"tokyonight-storm\": () => importTheme(\"tokyonight-storm\"),\n  vesper: () => importTheme(\"vesper\"),\n  \"vitesse-dark\": () => importTheme(\"vitesse-dark\"),\n  \"vitesse-light\": () => importTheme(\"vitesse-light\"),\n} as const satisfies Record<string, ThemeLoader>\n","import type { Theme } from \"./types.ts\"\n\n/**\n * Slot-level fallbacks. Every Theme value is shallow-merged on top of\n * this record by `resolveTheme`, so partial JSON themes only need to\n * declare slots that diverge from these defaults.\n *\n * Distinct from `defaultTheme` — that's the precomputed `tokyonight-moon`\n * Theme bundled as the default palette for `createCtx()` etc.\n */\n// oxlint-disable-next-line sort-keys\nexport const defaults: Omit<Theme, \"id\"> = {\n  // base colors\n  primary: \"blue\",\n  accent: \"brightMagenta\",\n\n  // text\n  text: \"inherit\",\n  muted: { dim: true },\n  quiet: { dim: true, fg: \"muted\", italic: true },\n  comment: { fg: \"muted\", italic: true },\n  title: { bold: true, fg: \"primary\" },\n  delim: \"muted\",\n\n  // surface & structure\n  subtle: \"brightBlack\",\n  ui: { bg: \"subtle\" },\n  overlay: { bg: \"subtle\" },\n  highlight: { bg: \"subtle\" },\n\n  // ui primitives\n  divider: \"subtle\",\n  selection: { bg: \"brightBlue\", fg: \"black\" },\n  gutter: \"subtle\",\n  prompt: \"inherit\",\n  border: \"black\",\n  borderTitle: \"title\",\n\n  // code\n  code: { bg: \"subtle\" },\n  codeTitle: \"title\",\n\n  // log levels\n  success: \"green\",\n  info: \"cyan\",\n  warn: \"yellow\",\n  error: \"red\",\n\n  // syntax\n  syntaxNumber: \"brightBlue\",\n  syntaxString: \"green\",\n  syntaxBoolean: \"yellow\",\n  syntaxFunction: \"blue\",\n  syntaxField: \"white\",\n  syntaxConstant: \"magenta\",\n  syntaxSpecial: \"red\",\n  syntaxDelimiter: \"delim\",\n  syntaxBracket: \"delim\",\n\n  // markdown\n  mdBold: { bold: true },\n  mdCode: { bg: \"primary+10\", fg: \"black\" },\n  mdCodeBlock: { bg: \"highlight\", fg: \"primary\" },\n  mdCodeBlockTitle: \"title\",\n  mdHeading1: \"mdHeading\",\n  mdHeading2: { bold: true, fg: \"accent\" },\n  mdHeading3: \"mdHeading2\",\n  mdHeading4: \"mdHeading2\",\n  mdHeading5: \"mdHeading2\",\n  mdHeading6: \"mdHeading2\",\n  mdHeading: \"title\",\n  mdHr: \"accent\",\n  mdItalic: { italic: true },\n  mdLink: { fg: \"primary\", underline: true },\n  mdListBullet: \"accent\",\n  mdListChecked: \"primary\",\n  mdListUnchecked: \"primary\",\n  mdQuote: \"muted\",\n  mdStrikethrough: { strikethrough: true },\n  mdTable: \"accent\",\n  mdTableHeader: \"title\",\n\n  // menu\n  optionActive: \"selection\",\n  optionDesc: \"muted\",\n  optionName: \"primary\",\n\n  // diff\n  diffAdd: { bg: \"success-50\", fg: \"success\" },\n  diffContext: \"muted\",\n  diffDel: { bg: \"error-50\", fg: \"error\" },\n  diffLine: \"gutter\",\n  diffTitle: \"title\",\n}\n\n// oxlint-disable-next-line sort-keys\nexport const ansi: Theme = {\n  id: \"ansi\",\n  name: \"ANSI\",\n  ...defaults,\n  subtle: \"inherit\",\n  divider: \"brightBlue\",\n  border: \"brightBlue\",\n  highlight: { bg: \"brightBlack\" },\n  ui: { bg: \"brightBlack\" },\n  selection: { inverse: true },\n  diffAdd: { fg: \"success\" },\n  diffDel: { fg: \"error\" },\n}\n","import type { Theme } from \"./types.ts\"\n\nimport { withError } from \"@zaly/shared\"\nimport { createRegistry } from \"@zaly/shared/registry\"\nimport { readFileSync } from \"node:fs\"\nimport { basename } from \"pathe\"\nimport moonJson from \"../../assets/themes/tokyonight-moon.json\" with { type: \"json\" }\nimport { builtin } from \"./builtin.ts\"\nimport { defaults, ansi } from \"./default.ts\"\n\n/** Built-in theme names plus the synthetic `\"ansi\"` palette (no JSON\n *  — falls back to `defaults` only). */\nexport type BuiltinTheme = keyof typeof builtin | \"ansi\"\nexport type AnyTheme = BuiltinTheme | (string & {})\nexport type ThemeLoader = () => Promise<Partial<Theme>>\n\nconst DEFAULT_THEME: BuiltinTheme = \"tokyonight-moon\"\n\n/**\n * Registry of built-in themes plus any registered at runtime. The\n * registry never awaits — loaders return `Promise<Partial<Theme>>` so\n * callers `await` explicitly.\n */\nexport const themeRegistry = createRegistry<ThemeLoader>(\"theme\").from(builtin)\n// NOTE: remove the ansi theme for now, since it looks kinda broken and not really possible\n// to fix properly\nthemeRegistry.register(\"ansi\", async () => ({ ...ansi }))\n\n/**\n * Load a theme by name or path.\n */\nexport async function loadTheme(name?: string): Promise<Theme>\nexport async function loadTheme(opts: { name?: string; path?: string }): Promise<Theme>\nexport async function loadTheme(o?: string | { name?: string; path?: string }): Promise<Theme> {\n  o ??= DEFAULT_THEME\n  const opts = typeof o === \"string\" ? { name: o } : o\n\n  if (opts.name?.endsWith(\".json\")) return loadTheme({ path: opts.name })\n  if (opts.path) return loadThemeFile(opts.path)\n  if (opts.name) {\n    if (opts.name === DEFAULT_THEME) return defaultTheme\n    if (themeRegistry.has(opts.name))\n      return resolveTheme(await themeRegistry.load(opts.name), opts.name)\n    throw new Error(`Theme \"${opts.name}\" not found.`)\n  }\n\n  return defaultTheme\n}\n\n/**\n * Fill defaults on a raw theme object. Built-in JSON is dev-controlled\n * so we don't pay typia's ~3MB of generated assertions at startup;\n * user-supplied JSON goes through `loadThemeFile` which validates.\n */\nfunction resolveTheme(theme: unknown, id: string): Theme {\n  const { $schema: _, ...rest } = theme as Partial<Theme> & { $schema?: unknown }\n  return { ...defaults, id, name: id, ...rest }\n}\n\n/**\n * Load a theme directly from a file path. No directory search happens —\n * this is the escape hatch for CLIs that accept an explicit `--theme\n * /path/to/theme.json` argument.\n *\n * Async because typia's generated `validateTheme` (a few thousand\n * unrolled assertions) is dynamically imported here — it's only needed\n * for user-supplied JSON and should stay off the main startup path.\n */\nasync function loadThemeFile(path: string): Promise<Theme> {\n  const raw = withError(() => readFileSync(path, \"utf8\"), `Failed to read theme file at ${path}`)\n  const data = withError(() => JSON.parse(raw), `Failed to parse theme JSON at ${path}`)\n  const { validateTheme } = await import(\"../schemas/gen/theme.config.ts\")\n  return resolveTheme(validateTheme(data), basename(path, \".json\"))\n}\n\n/** TokyoNight Moon — the default. Sourced from `assets/themes/tokyonight-moon.json`. */\nexport const defaultTheme = resolveTheme(moonJson, \"tokyonight-moon\")\n"],"mappings":"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"}

package/dist/{render-DxIHVH9Y.mjs → render-f7M2856V.mjs}

@@ -1,5 +1,5 @@
 import { d as createSuspenseBoundary, i as createContext, l as createRoot, n as SuspenseContext, v as provideContext } from "./reactive-f7NpAi69.mjs";
-import { t as createCtx } from "./ctx-ChO3St_a.mjs";
+import { t as createCtx } from "./ctx-8Nuf5BrN.mjs";
 //#region src/core/render.ts
 const RenderContext = createContext();
 async function createRender(node, ctx = createCtx()) {
@@ -30,4 +30,4 @@ async function renderWithDrain(node, boundary, ctx) {
 //#endregion
 export { createRender as n, RenderContext as t };
 
-//# sourceMappingURL=render-DxIHVH9Y.mjs.map
+//# sourceMappingURL=render-f7M2856V.mjs.map

package/dist/{render-DxIHVH9Y.mjs.map → render-f7M2856V.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"render-DxIHVH9Y.mjs","names":[],"sources":["../src/core/render.ts"],"sourcesContent":["import type { TerminalQueries } from \"../input/queries.ts\"\nimport type { StyleBuilder } from \"../style/builder.ts\"\nimport type { Theme } from \"../themes/types.ts\"\nimport type { RenderCtx } from \"./ctx.ts\"\n// oxlint-disable no-await-in-loop\nimport type { Node } from \"./node.ts\"\nimport type { Accessor, SuspenseBoundary } from \"./reactive.ts\"\n\nimport { createCtx } from \"./ctx.ts\"\nimport {\n  createContext,\n  createRoot,\n  createSuspenseBoundary,\n  provideContext,\n  SuspenseContext,\n} from \"./reactive.ts\"\n\n/** Components-facing slice of the render environment — reactive\n *  accessors a widget body reads via `useContext(RenderContext)`. Use\n *  this when a widget needs ambient theme/style outside an `_render`\n *  call (the place where `RenderCtx` is threaded in). Width is\n *  deliberately omitted — that's a per-render allotted-size concept,\n *  not an ambient one. */\nexport type RenderContextValue = {\n  /** Active theme. Tracked — widgets that read it re-fire on swap. */\n  theme: Accessor<Theme>\n  /** Theme-bound chainable style builder. Derived memo over `theme`. */\n  style: Accessor<StyleBuilder>\n  /** Whether to render images (when supported) */\n  images: Accessor<boolean>\n  queries: TerminalQueries\n}\nexport const RenderContext = createContext<RenderContextValue>()\n\n/**\n * Render a Node, draining `createAsync` work in its subtree before\n * returning final rows. Two shapes:\n *\n *   - `createRender(() => node, ctx?)` — factory form. Creates a fresh\n *     `SuspenseBoundary` inside a new `createRoot` and runs the\n *     factory in that scope so descendants find the boundary via\n *     `useContext(SuspenseContext)`. For tests, benches, REPL.\n *\n *   - `createRender(node, { ...ctx, boundary })` — pre-built Node\n *     with a caller-provided boundary. Used by `Stream.render`: the\n *     boundary was installed at `append` time, so we just render +\n *     drain without a new root scope.\n *\n * `ctx` defaults to `createCtx()` in the factory form.\n *\n * ```ts\n * const rows = await createRender(() => markdown(\"**hi**\"))\n * ```\n */\nexport async function createRender(\n  node: Node,\n  ctx: RenderCtx & { boundary: SuspenseBoundary }\n): Promise<string[]>\nexport async function createRender(node: () => Node, ctx?: RenderCtx): Promise<string[]>\nexport async function createRender(\n  node: Node | (() => Node),\n  ctx: RenderCtx & { boundary?: SuspenseBoundary } = createCtx()\n): Promise<string[]> {\n  if (ctx.boundary) return renderWithDrain(node as Node, ctx.boundary, ctx)\n  const boundary = createSuspenseBoundary()\n  const nodeFn = node as () => Node\n  return createRoot(async () => {\n    provideContext(SuspenseContext, boundary)\n    return renderWithDrain(nodeFn(), boundary, ctx)\n  })\n}\n\n/** Wait for any pending work first, then render. On warm caches the\n *  initial `whenIdle` resolves on the same microtask tick — no real\n *  wait — and we render exactly once with final values. On cold the\n *  wait blocks until `createAsync` settles. The follow-up `while`\n *  catches the in-render case: a `_render` that fires a fresh\n *  `createAsync` (signal write subscribes a new effect) bumps the\n *  boundary back above zero, requiring another pass. */\nasync function renderWithDrain(\n  node: Node,\n  boundary: SuspenseBoundary,\n  ctx: RenderCtx\n): Promise<string[]> {\n  if (boundary.active()) await boundary.whenIdle()\n  let rows = await node.render(ctx)\n  while (boundary.active()) {\n    await boundary.whenIdle()\n    rows = await node.render(ctx)\n  }\n  return rows\n}\n"],"mappings":";;;AAgCA,MAAa,gBAAgB,cAAkC;AA2B/D,eAAsB,aACpB,MACA,MAAmD,UAAU,GAC1C;CACnB,IAAI,IAAI,UAAU,OAAO,gBAAgB,MAAc,IAAI,UAAU,GAAG;CACxE,MAAM,WAAW,uBAAuB;CACxC,MAAM,SAAS;CACf,OAAO,WAAW,YAAY;EAC5B,eAAe,iBAAiB,QAAQ;EACxC,OAAO,gBAAgB,OAAO,GAAG,UAAU,GAAG;CAChD,CAAC;AACH;;;;;;;;AASA,eAAe,gBACb,MACA,UACA,KACmB;CACnB,IAAI,SAAS,OAAO,GAAG,MAAM,SAAS,SAAS;CAC/C,IAAI,OAAO,MAAM,KAAK,OAAO,GAAG;CAChC,OAAO,SAAS,OAAO,GAAG;EACxB,MAAM,SAAS,SAAS;EACxB,OAAO,MAAM,KAAK,OAAO,GAAG;CAC9B;CACA,OAAO;AACT"}
+{"version":3,"file":"render-f7M2856V.mjs","names":[],"sources":["../src/core/render.ts"],"sourcesContent":["import type { TerminalQueries } from \"../input/queries.ts\"\nimport type { StyleBuilder } from \"../style/builder.ts\"\nimport type { Theme } from \"../themes/types.ts\"\nimport type { RenderCtx } from \"./ctx.ts\"\n// oxlint-disable no-await-in-loop\nimport type { Node } from \"./node.ts\"\nimport type { Accessor, SuspenseBoundary } from \"./reactive.ts\"\n\nimport { createCtx } from \"./ctx.ts\"\nimport {\n  createContext,\n  createRoot,\n  createSuspenseBoundary,\n  provideContext,\n  SuspenseContext,\n} from \"./reactive.ts\"\n\n/** Components-facing slice of the render environment — reactive\n *  accessors a widget body reads via `useContext(RenderContext)`. Use\n *  this when a widget needs ambient theme/style outside an `_render`\n *  call (the place where `RenderCtx` is threaded in). Width is\n *  deliberately omitted — that's a per-render allotted-size concept,\n *  not an ambient one. */\nexport type RenderContextValue = {\n  /** Active theme. Tracked — widgets that read it re-fire on swap. */\n  theme: Accessor<Theme>\n  /** Theme-bound chainable style builder. Derived memo over `theme`. */\n  style: Accessor<StyleBuilder>\n  /** Whether to render images (when supported) */\n  images: Accessor<boolean>\n  queries: TerminalQueries\n}\nexport const RenderContext = createContext<RenderContextValue>()\n\n/**\n * Render a Node, draining `createAsync` work in its subtree before\n * returning final rows. Two shapes:\n *\n *   - `createRender(() => node, ctx?)` — factory form. Creates a fresh\n *     `SuspenseBoundary` inside a new `createRoot` and runs the\n *     factory in that scope so descendants find the boundary via\n *     `useContext(SuspenseContext)`. For tests, benches, REPL.\n *\n *   - `createRender(node, { ...ctx, boundary })` — pre-built Node\n *     with a caller-provided boundary. Used by `Stream.render`: the\n *     boundary was installed at `append` time, so we just render +\n *     drain without a new root scope.\n *\n * `ctx` defaults to `createCtx()` in the factory form.\n *\n * ```ts\n * const rows = await createRender(() => markdown(\"**hi**\"))\n * ```\n */\nexport async function createRender(\n  node: Node,\n  ctx: RenderCtx & { boundary: SuspenseBoundary }\n): Promise<string[]>\nexport async function createRender(node: () => Node, ctx?: RenderCtx): Promise<string[]>\nexport async function createRender(\n  node: Node | (() => Node),\n  ctx: RenderCtx & { boundary?: SuspenseBoundary } = createCtx()\n): Promise<string[]> {\n  if (ctx.boundary) return renderWithDrain(node as Node, ctx.boundary, ctx)\n  const boundary = createSuspenseBoundary()\n  const nodeFn = node as () => Node\n  return createRoot(async () => {\n    provideContext(SuspenseContext, boundary)\n    return renderWithDrain(nodeFn(), boundary, ctx)\n  })\n}\n\n/** Wait for any pending work first, then render. On warm caches the\n *  initial `whenIdle` resolves on the same microtask tick — no real\n *  wait — and we render exactly once with final values. On cold the\n *  wait blocks until `createAsync` settles. The follow-up `while`\n *  catches the in-render case: a `_render` that fires a fresh\n *  `createAsync` (signal write subscribes a new effect) bumps the\n *  boundary back above zero, requiring another pass. */\nasync function renderWithDrain(\n  node: Node,\n  boundary: SuspenseBoundary,\n  ctx: RenderCtx\n): Promise<string[]> {\n  if (boundary.active()) await boundary.whenIdle()\n  let rows = await node.render(ctx)\n  while (boundary.active()) {\n    await boundary.whenIdle()\n    rows = await node.render(ctx)\n  }\n  return rows\n}\n"],"mappings":";;;AAgCA,MAAa,gBAAgB,cAAkC;AA2B/D,eAAsB,aACpB,MACA,MAAmD,UAAU,GAC1C;CACnB,IAAI,IAAI,UAAU,OAAO,gBAAgB,MAAc,IAAI,UAAU,GAAG;CACxE,MAAM,WAAW,uBAAuB;CACxC,MAAM,SAAS;CACf,OAAO,WAAW,YAAY;EAC5B,eAAe,iBAAiB,QAAQ;EACxC,OAAO,gBAAgB,OAAO,GAAG,UAAU,GAAG;CAChD,CAAC;AACH;;;;;;;;AASA,eAAe,gBACb,MACA,UACA,KACmB;CACnB,IAAI,SAAS,OAAO,GAAG,MAAM,SAAS,SAAS;CAC/C,IAAI,OAAO,MAAM,KAAK,OAAO,GAAG;CAChC,OAAO,SAAS,OAAO,GAAG;EACxB,MAAM,SAAS,SAAS;EACxB,OAAO,MAAM,KAAK,OAAO,GAAG;CAC9B;CACA,OAAO;AACT"}

package/dist/renderer-BSMOuiLM.mjs

@@ -0,0 +1 @@
+export { t as MarkdownRenderer } from "./renderer-DesbRwjQ.mjs";

package/dist/{renderer-Bz3tc2IT.mjs → renderer-V6AGjbyf.mjs}

@@ -1,11 +1,11 @@
 import { C as useActiveOwner, E as withOwner, S as unwrap, _ as peek, d as createSuspenseBoundary, h as memo, l as createRoot, n as SuspenseContext, o as createNode, v as provideContext, x as untrack, y as signal } from "./reactive-f7NpAi69.mjs";
-import { t as defaultTheme } from "./registry-CEpHcTa2.mjs";
+import { t as defaultTheme } from "./registry-3hLzS4ks.mjs";
 import { s as stripAnsiBg } from "./ansi-Clq0ozyA.mjs";
-import { t as styleBuilder } from "./builder-BgEcjj8Z.mjs";
+import { t as styleBuilder } from "./builder-DC9byAmK.mjs";
 import { n as box } from "./box-DLEcEvDH.mjs";
-import { t as createCtx } from "./ctx-ChO3St_a.mjs";
-import { t as RenderContext } from "./render-DxIHVH9Y.mjs";
-import { t as TuiReporter } from "./logger-ClSgGf-a.mjs";
+import { t as createCtx } from "./ctx-8Nuf5BrN.mjs";
+import { t as RenderContext } from "./render-f7M2856V.mjs";
+import { t as TuiReporter } from "./logger-DvuX9DPS.mjs";
 import { o as bumpPlacements } from "./kitty-JbCJC0iQ.mjs";
 import { i as canonical, t as TerminalQueries } from "./queries-B_lOwEiE.mjs";
 import { Emitter } from "@zaly/shared";
@@ -2642,4 +2642,4 @@ var Renderer = class extends Emitter {
 //#endregion
 export { Renderer };
 
-//# sourceMappingURL=renderer-Bz3tc2IT.mjs.map
+//# sourceMappingURL=renderer-V6AGjbyf.mjs.map