@zaly/tui 0.0.4

package/dist/flex-Bguo-fUe.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"flex-Bguo-fUe.mjs","names":[],"sources":["../src/layout/flex.ts"],"sourcesContent":["import type { FlexState } from \"../core/state.ts\"\n\nimport { sliceAnsi, stringWidth } from \"@zaly/shared/ansi\"\nimport { clamp, resolveSize } from \"./size.ts\"\n\n/**\n * Items participating in a row-direction allocation. Extends the\n * `Flexible` mixin with the node's intrinsic content sizes (from\n * `Node.layout()` or fallback measurement). Box constructs these\n * before calling `allocateRow`.\n *\n * @internal\n */\nexport interface RowItem extends FlexState {\n  /** Measured natural (max-content) width — used as the flex-basis\n   *  when no fixed `width` is set. Falls back to 0 when omitted. */\n  natural?: number\n  /** Intrinsic min-content width — the smallest the node can render\n   *  without breaking content. Acts as a shrink floor below which the\n   *  allocator won't go (combined with `Flexible.minWidth`). */\n  intrinsicMin?: number\n}\n\nexport interface AllocateOpts {\n  contentWidth: number\n  gap: number\n}\n\n/**\n * Allocate widths to row-direction children with CSS-style flex\n * semantics. Each item starts at its **basis**:\n *\n *   - `width: <number | \"N%\">` → resolved fixed width.\n *   - `width: \"fill\"` → 0 (claim slack, ignore intrinsic).\n *   - any other non-fixed spec → `natural` (content size, 0 when not\n *     provided).\n *\n * Three branches:\n *\n *   - `slack > 0`: distribute by `flexGrow`. Items without grow weight\n *     stay at basis; leftover slack is *not* smeared onto siblings.\n *   - `slack < 0` (deficit): distribute the shortfall by\n *     `basis * flexShrink` (CSS shrink default = 1). Each item is\n *     clamped at its `minWidth` floor so content doesn't break.\n *   - `slack == 0`: items take their basis as-is.\n *\n * `min`/`max` (combined with `intrinsicMin`) clamp per-item; rounding\n * remainder lands on the last grower / shrinker.\n *\n * @internal\n */\nexport function allocateRow(items: readonly RowItem[], opts: AllocateOpts): number[] {\n  const { contentWidth } = opts\n  const gapTotal = opts.gap * Math.max(0, items.length - 1)\n  const available = contentWidth - gapTotal\n\n  const bases: number[] = Array.from({ length: items.length })\n  const grows: number[] = Array.from({ length: items.length })\n  const shrinks: number[] = Array.from({ length: items.length })\n  // Effective minimum per item — the larger of the user-set `minWidth`\n  // and the node's intrinsic `min-content`. Shrink can't go below this.\n  const mins: number[] = Array.from({ length: items.length })\n  let baseSum = 0\n  let growSum = 0\n\n  for (let i = 0; i < items.length; i++) {\n    const item = items[i]\n    if (isFixedWidth(item.width)) {\n      bases[i] = resolveSize(item.width, contentWidth) ?? 0\n      grows[i] = 0\n      shrinks[i] = 0 // Fixed-width items never shrink — author asked for an exact size.\n    } else if (item.width === \"fill\") {\n      // `fill` claims slack and ignores intrinsic basis (CSS `flex: 1 1 0`).\n      bases[i] = 0\n      grows[i] = item.flexGrow ?? 1\n      shrinks[i] = item.flexShrink ?? 1\n    } else {\n      bases[i] = item.natural ?? 0\n      grows[i] = item.flexGrow ?? 0\n      shrinks[i] = item.flexShrink ?? 1\n    }\n    const intrinsicMin = item.intrinsicMin ?? 0\n    const userMin = resolveSize(item.minWidth, contentWidth) ?? 0\n    mins[i] = Math.max(intrinsicMin, userMin)\n    baseSum += bases[i]\n    growSum += grows[i]\n  }\n\n  const slack = available - baseSum\n  const widths: number[] = Array.from({ length: items.length })\n  let allocated = 0\n  let lastGrowIndex = -1\n  let lastShrinkIndex = -1\n\n  if (slack >= 0) {\n    // Grow phase — distribute slack among items that asked for it.\n    for (let i = 0; i < items.length; i++) {\n      const item = items[i]\n      let w = bases[i]\n      if (growSum > 0 && grows[i] > 0) {\n        w += Math.floor((slack * grows[i]) / growSum)\n        lastGrowIndex = i\n      }\n      w = clamp(w, { available: contentWidth, max: item.maxWidth, min: mins[i] })\n      widths[i] = w\n      allocated += w\n    }\n    // Tail grower absorbs rounding remainder and any over/underflow\n    // from min/max clamps. We aim at `baseSum + slack` (i.e. exactly\n    // `available`) only when growers exist; otherwise leftover is real\n    // slack the parent will pad as end-of-row space.\n    if (lastGrowIndex !== -1) {\n      const target = baseSum + slack\n      if (allocated !== target) {\n        widths[lastGrowIndex] = Math.max(0, widths[lastGrowIndex] + (target - allocated))\n      }\n    }\n  } else {\n    // Shrink phase — distribute the deficit weighted by `basis * shrink`.\n    // Items at their `mins[i]` floor stop shrinking; the remaining\n    // deficit re-routes to the others. Iterate until stable or no\n    // shrinkable items remain.\n    for (let i = 0; i < items.length; i++) widths[i] = bases[i]\n    let deficit = -slack // positive\n    const frozen: boolean[] = Array.from({ length: items.length }, () => false)\n    // Cap loop at items.length+1 — each pass freezes at least one item\n    // or fully resolves the deficit. Bounded, no risk of looping.\n    for (let pass = 0; pass <= items.length && deficit > 0; pass++) {\n      let weightSum = 0\n      for (let i = 0; i < items.length; i++) {\n        if (!frozen[i]) weightSum += widths[i] * shrinks[i]\n      }\n      if (weightSum === 0) break // nothing left can shrink\n      let froze = false\n      for (let i = 0; i < items.length; i++) {\n        if (frozen[i]) continue\n        const share = Math.floor((deficit * widths[i] * shrinks[i]) / weightSum)\n        const next = widths[i] - share\n        if (next <= mins[i]) {\n          deficit -= widths[i] - mins[i]\n          widths[i] = mins[i]\n          frozen[i] = true\n          froze = true\n        } else {\n          widths[i] = next\n          lastShrinkIndex = i\n        }\n      }\n      if (!froze) {\n        // Apply remaining deficit proportionally one more time without\n        // freezing — the round above didn't hit any floor.\n        deficit = 0\n      }\n    }\n    for (let i = 0; i < items.length; i++) {\n      widths[i] = clamp(widths[i], {\n        available: contentWidth,\n        max: items[i].maxWidth,\n        min: mins[i],\n      })\n      allocated += widths[i]\n    }\n    // Soak any rounding-shaped over/underflow into the last shrinker so\n    // the row sums exactly to `available` (or to the minSum floor when\n    // mins force overflow).\n    if (lastShrinkIndex !== -1) {\n      const target = Math.max(\n        available,\n        mins.reduce((a, b) => a + b, 0)\n      )\n      if (allocated !== target) {\n        const adj = target - allocated\n        widths[lastShrinkIndex] = Math.max(mins[lastShrinkIndex], widths[lastShrinkIndex] + adj)\n      }\n    }\n  }\n\n  return widths\n}\n\n/**\n * Whether a `Flexible.width` spec is a fixed numeric size (number or\n * `Pct`). `\"fill\"`/`\"fit\"`/undefined are non-fixed and resolve from\n * surrounding context (slack / measurement).\n *\n * @internal\n */\nexport function isFixedWidth(w: FlexState[\"width\"]): boolean {\n  return typeof w === \"number\" || (typeof w === \"string\" && w.endsWith(\"%\"))\n}\n\nexport interface ZipOpts {\n  widths: readonly number[]\n  gap: number\n}\n\n/**\n * Zip pre-rendered child rows horizontally. Shorter children are padded with\n * blank rows of their allocated width. Rows of each child must already be\n * padded to the corresponding width in `widths`.\n *\n * @internal\n */\nexport function zipRow(children: readonly (readonly string[])[], opts: ZipOpts): string[] {\n  if (children.length === 0) return []\n  const gapStr = \" \".repeat(opts.gap)\n  const height = children.reduce((h, rows) => Math.max(h, rows.length), 0)\n  const out: string[] = []\n  for (let r = 0; r < height; r++) {\n    let line = \"\"\n    for (let c = 0; c < children.length; c++) {\n      if (c > 0) line += gapStr\n      const rows = children[c]\n      line += r < rows.length ? rows[r] : \" \".repeat(opts.widths[c])\n    }\n    out.push(line)\n  }\n  return out\n}\n\nexport interface StackOpts {\n  gap: number\n  width: number\n}\n\n/**\n * Stack pre-rendered child rows vertically. `gap` blank rows of `width`\n * spaces separate each sibling pair that *contributes rows*. Children\n * that emit no rows (e.g. `visible: false`, falsy `show()` branch) are\n * skipped along with the gap that would have surrounded them — no\n * stray blank bands. Caller must ensure each child's rows are already\n * padded to `width`.\n *\n * @internal\n */\nexport function stackColumn(children: readonly (readonly string[])[], opts: StackOpts): string[] {\n  const out: string[] = []\n  const blank = \" \".repeat(opts.width)\n  let any = false\n  for (const child of children) {\n    if (child.length === 0) continue\n    if (any) for (let g = 0; g < opts.gap; g++) out.push(blank)\n    out.push(...child)\n    any = true\n  }\n  return out\n}\n\n/**\n * Pad a row to `width` cells without injecting a `RESET`. Used by the\n * row/column zip-and-pad steps — the parent `Box`'s outer\n * `reapplyStyle` chain handles re-emitting any ambient SGR after inner\n * `[0m`s, so the pad cells stay inside the active style. Over-wide\n * rows are clipped via `sliceAnsi`, preserving SGR state.\n *\n * Distinct from `padOrClip` in `style/ansi.ts`, which is for\n * standalone (non-Box-wrapped) paths and *does* inject a `RESET`\n * before the pad.\n *\n * @internal\n */\nexport function padRow(row: string, width: number): string {\n  const w = stringWidth(row)\n  if (w === width) return row\n  if (w < width) return row + \" \".repeat(width - w)\n  return sliceAnsi(row, 0, width)\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,SAAgB,YAAY,OAA2B,MAA8B;CACnF,MAAM,EAAE,iBAAiB;CAEzB,MAAM,YAAY,eADD,KAAK,MAAM,KAAK,IAAI,GAAG,MAAM,SAAS,CAAC;CAGxD,MAAM,QAAkB,MAAM,KAAK,EAAE,QAAQ,MAAM,OAAO,CAAC;CAC3D,MAAM,QAAkB,MAAM,KAAK,EAAE,QAAQ,MAAM,OAAO,CAAC;CAC3D,MAAM,UAAoB,MAAM,KAAK,EAAE,QAAQ,MAAM,OAAO,CAAC;CAG7D,MAAM,OAAiB,MAAM,KAAK,EAAE,QAAQ,MAAM,OAAO,CAAC;CAC1D,IAAI,UAAU;CACd,IAAI,UAAU;CAEd,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,OAAO,MAAM;EACnB,IAAI,aAAa,KAAK,KAAK,GAAG;GAC5B,MAAM,KAAK,YAAY,KAAK,OAAO,YAAY,KAAK;GACpD,MAAM,KAAK;GACX,QAAQ,KAAK;EACf,OAAO,IAAI,KAAK,UAAU,QAAQ;GAEhC,MAAM,KAAK;GACX,MAAM,KAAK,KAAK,YAAY;GAC5B,QAAQ,KAAK,KAAK,cAAc;EAClC,OAAO;GACL,MAAM,KAAK,KAAK,WAAW;GAC3B,MAAM,KAAK,KAAK,YAAY;GAC5B,QAAQ,KAAK,KAAK,cAAc;EAClC;EACA,MAAM,eAAe,KAAK,gBAAgB;EAC1C,MAAM,UAAU,YAAY,KAAK,UAAU,YAAY,KAAK;EAC5D,KAAK,KAAK,KAAK,IAAI,cAAc,OAAO;EACxC,WAAW,MAAM;EACjB,WAAW,MAAM;CACnB;CAEA,MAAM,QAAQ,YAAY;CAC1B,MAAM,SAAmB,MAAM,KAAK,EAAE,QAAQ,MAAM,OAAO,CAAC;CAC5D,IAAI,YAAY;CAChB,IAAI,gBAAgB;CACpB,IAAI,kBAAkB;CAEtB,IAAI,SAAS,GAAG;EAEd,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;GACrC,MAAM,OAAO,MAAM;GACnB,IAAI,IAAI,MAAM;GACd,IAAI,UAAU,KAAK,MAAM,KAAK,GAAG;IAC/B,KAAK,KAAK,MAAO,QAAQ,MAAM,KAAM,OAAO;IAC5C,gBAAgB;GAClB;GACA,IAAI,MAAM,GAAG;IAAE,WAAW;IAAc,KAAK,KAAK;IAAU,KAAK,KAAK;GAAG,CAAC;GAC1E,OAAO,KAAK;GACZ,aAAa;EACf;EAKA,IAAI,kBAAkB,IAAI;GACxB,MAAM,SAAS,UAAU;GACzB,IAAI,cAAc,QAChB,OAAO,iBAAiB,KAAK,IAAI,GAAG,OAAO,kBAAkB,SAAS,UAAU;EAEpF;CACF,OAAO;EAKL,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,OAAO,KAAK,MAAM;EACzD,IAAI,UAAU,CAAC;EACf,MAAM,SAAoB,MAAM,KAAK,EAAE,QAAQ,MAAM,OAAO,SAAS,KAAK;EAG1E,KAAK,IAAI,OAAO,GAAG,QAAQ,MAAM,UAAU,UAAU,GAAG,QAAQ;GAC9D,IAAI,YAAY;GAChB,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAChC,IAAI,CAAC,OAAO,IAAI,aAAa,OAAO,KAAK,QAAQ;GAEnD,IAAI,cAAc,GAAG;GACrB,IAAI,QAAQ;GACZ,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;IACrC,IAAI,OAAO,IAAI;IACf,MAAM,QAAQ,KAAK,MAAO,UAAU,OAAO,KAAK,QAAQ,KAAM,SAAS;IACvE,MAAM,OAAO,OAAO,KAAK;IACzB,IAAI,QAAQ,KAAK,IAAI;KACnB,WAAW,OAAO,KAAK,KAAK;KAC5B,OAAO,KAAK,KAAK;KACjB,OAAO,KAAK;KACZ,QAAQ;IACV,OAAO;KACL,OAAO,KAAK;KACZ,kBAAkB;IACpB;GACF;GACA,IAAI,CAAC,OAGH,UAAU;EAEd;EACA,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;GACrC,OAAO,KAAK,MAAM,OAAO,IAAI;IAC3B,WAAW;IACX,KAAK,MAAM,EAAE,CAAC;IACd,KAAK,KAAK;GACZ,CAAC;GACD,aAAa,OAAO;EACtB;EAIA,IAAI,oBAAoB,IAAI;GAC1B,MAAM,SAAS,KAAK,IAClB,WACA,KAAK,QAAQ,GAAG,MAAM,IAAI,GAAG,CAAC,CAChC;GACA,IAAI,cAAc,QAAQ;IACxB,MAAM,MAAM,SAAS;IACrB,OAAO,mBAAmB,KAAK,IAAI,KAAK,kBAAkB,OAAO,mBAAmB,GAAG;GACzF;EACF;CACF;CAEA,OAAO;AACT;;;;;;;;AASA,SAAgB,aAAa,GAAgC;CAC3D,OAAO,OAAO,MAAM,YAAa,OAAO,MAAM,YAAY,EAAE,SAAS,GAAG;AAC1E;;;;;;;;AAcA,SAAgB,OAAO,UAA0C,MAAyB;CACxF,IAAI,SAAS,WAAW,GAAG,OAAO,CAAC;CACnC,MAAM,SAAS,IAAI,OAAO,KAAK,GAAG;CAClC,MAAM,SAAS,SAAS,QAAQ,GAAG,SAAS,KAAK,IAAI,GAAG,KAAK,MAAM,GAAG,CAAC;CACvE,MAAM,MAAgB,CAAC;CACvB,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,KAAK;EAC/B,IAAI,OAAO;EACX,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;GACxC,IAAI,IAAI,GAAG,QAAQ;GACnB,MAAM,OAAO,SAAS;GACtB,QAAQ,IAAI,KAAK,SAAS,KAAK,KAAK,IAAI,OAAO,KAAK,OAAO,EAAE;EAC/D;EACA,IAAI,KAAK,IAAI;CACf;CACA,OAAO;AACT;;;;;;;;;;;AAiBA,SAAgB,YAAY,UAA0C,MAA2B;CAC/F,MAAM,MAAgB,CAAC;CACvB,MAAM,QAAQ,IAAI,OAAO,KAAK,KAAK;CACnC,IAAI,MAAM;CACV,KAAK,MAAM,SAAS,UAAU;EAC5B,IAAI,MAAM,WAAW,GAAG;EACxB,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK,KAAK,IAAI,KAAK,KAAK;EAC1D,IAAI,KAAK,GAAG,KAAK;EACjB,MAAM;CACR;CACA,OAAO;AACT;;;;;;;;;;;;;;AAeA,SAAgB,OAAO,KAAa,OAAuB;CACzD,MAAM,IAAI,YAAY,GAAG;CACzB,IAAI,MAAM,OAAO,OAAO;CACxB,IAAI,IAAI,OAAO,OAAO,MAAM,IAAI,OAAO,QAAQ,CAAC;CAChD,OAAO,UAAU,KAAK,GAAG,KAAK;AAChC"}

package/dist/image-Cm5T-uw-.mjs

@@ -0,0 +1,108 @@
+import { stripAnsi } from "@zaly/shared/ansi";
+import { basename } from "pathe";
+//#region src/markdown/image.ts
+/**
+* Image callback + post-processor for the markdown pipeline.
+*
+* The markdown renderer is synchronous (callbacks return strings), but
+* image preparation is async (sharp metadata, KGP transmit, format
+* conversion). We reconcile with a two-pass approach:
+*
+*  1. During rendering, the `image` callback pushes `{ src, alt }` into
+*     the entries array and emits a compact `<img id=N>` marker where
+*     `N` is the entry's index. The marker is plain text so any
+*     renderer (marked or `Bun.markdown.render`) emits it verbatim.
+*  2. After rendering, `resolve(ctx, rendered)` renders every unique
+*     src concurrently via cached `Image` nodes, then replaces each
+*     marker with either the rendered rows (for *block* images — ones
+*     that end up on their own line) or the markdown alt text (for
+*     inline images, which would otherwise break text flow).
+*
+* The caller passes in a persistent `cache: Map<src, Image>` owned by
+* the Markdown instance so re-renders reuse the same Image node (and
+* therefore the same KGP placement id, which the spec guarantees is a
+* flicker-free move/resize).
+*/
+function createImageCallback(host) {
+	const entries = [];
+	const cache = host.images;
+	return {
+		cb(alt, meta) {
+			const id = entries.length;
+			entries.push({
+				alt,
+				src: meta.src
+			});
+			return `<img id=${id}>`;
+		},
+		async resolve(ctx, rendered) {
+			if (entries.length === 0) return rendered;
+			const { Image } = await import("./widgets/image.mjs");
+			const ordinals = /* @__PURE__ */ new Map();
+			const rowsByEntry = [];
+			const used = /* @__PURE__ */ new Set();
+			await Promise.all(entries.map(async (entry, idx) => {
+				const ord = ordinals.get(entry.src) ?? 0;
+				ordinals.set(entry.src, ord + 1);
+				const key = `${entry.src}\u0000${ord}`;
+				used.add(key);
+				let img = cache.get(key);
+				if (img === void 0) {
+					img = new Image({
+						alt: entry.alt,
+						src: entry.src
+					});
+					host.add(img);
+					cache.set(key, img);
+				}
+				rowsByEntry[idx] = await img.render(ctx);
+			}));
+			for (const [key] of cache) if (!used.has(key)) {
+				const img = cache.get(key);
+				if (img) {
+					host.remove(img);
+					cache.delete(key);
+				}
+			}
+			const out = [];
+			for (const line of rendered.split("\n")) {
+				const matched = [];
+				for (const m of line.matchAll(MARKER_RE)) {
+					const idx = Number(m[1]);
+					matched.push({
+						entry: entries[idx],
+						rows: rowsByEntry[idx] ?? []
+					});
+				}
+				if (matched.length === 0) {
+					out.push(line);
+					continue;
+				}
+				if (matched.length === 1 && stripAnsi(line.replace(MARKER_RE, "")).trim() === "" && matched[0].rows.length > 0) {
+					out.push(...matched[0].rows);
+					continue;
+				}
+				out.push(line.replaceAll(MARKER_RE, (_, idxStr) => labelOf(entries[Number(idxStr)])));
+				for (const { rows } of matched) if (rows.some(isRealGraphics)) out.push(...rows);
+			}
+			return out.join("\n");
+		}
+	};
+}
+/** Friendly inline placeholder for an image that can't render at this
+*  position. Prefers the markdown alt text; falls back to the basename
+*  of the source path (so `[clip.png]` instead of `[/tmp/long/path/clip.png]`),
+*  and "image" for anything weirder. */
+function labelOf(entry) {
+	return `[${entry.alt !== "" ? entry.alt : basename(entry.src) || "image"}]`;
+}
+const MARKER_RE = /<img id=(\d+)>/g;
+/** True when a row contains a Kitty Graphics Protocol escape (transmit
+*  or place) — i.e. real image data, not the text alt fallback. */
+function isRealGraphics(row) {
+	return row.includes("\x1B_G");
+}
+//#endregion
+export { createImageCallback };
+
+//# sourceMappingURL=image-Cm5T-uw-.mjs.map

package/dist/image-Cm5T-uw-.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-Cm5T-uw-.mjs","names":[],"sources":["../src/markdown/image.ts"],"sourcesContent":["import type { RenderCtx } from \"../core/ctx.ts\"\nimport type { Node } from \"../core/node.ts\"\nimport type { Image } from \"../widgets/image.ts\"\nimport type { MdCallbacks, MdImageMeta } from \"./types.ts\"\n\nimport { stripAnsi } from \"@zaly/shared/ansi\"\nimport { basename } from \"pathe\"\n\n/** Minimal host shape the image callback needs. Any Node-like parent\n *  with a per-src `Image` cache satisfies it — the `Markdown` widget is\n *  the primary caller but the interface keeps this file decoupled from\n *  widget internals (and breaks the widgets↔markdown import loop). */\nexport interface ImageHost {\n  /** Per-src cache so re-renders reuse the same `Image` — same KGP\n   *  placement id, which the spec guarantees is a flicker-free\n   *  move/resize. */\n  images: Map<string, Image>\n  /** Attach a freshly-created `Image` as a child so mount/unmount\n   *  propagate. */\n  add: (child: Node) => unknown\n  remove: (child: Node) => unknown\n}\n\n/** Per-occurrence image metadata collected during markdown rendering. */\ninterface ImageEntry {\n  src: string\n  alt: string\n}\n\n/**\n * Image callback + post-processor for the markdown pipeline.\n *\n * The markdown renderer is synchronous (callbacks return strings), but\n * image preparation is async (sharp metadata, KGP transmit, format\n * conversion). We reconcile with a two-pass approach:\n *\n *  1. During rendering, the `image` callback pushes `{ src, alt }` into\n *     the entries array and emits a compact `<img id=N>` marker where\n *     `N` is the entry's index. The marker is plain text so any\n *     renderer (marked or `Bun.markdown.render`) emits it verbatim.\n *  2. After rendering, `resolve(ctx, rendered)` renders every unique\n *     src concurrently via cached `Image` nodes, then replaces each\n *     marker with either the rendered rows (for *block* images — ones\n *     that end up on their own line) or the markdown alt text (for\n *     inline images, which would otherwise break text flow).\n *\n * The caller passes in a persistent `cache: Map<src, Image>` owned by\n * the Markdown instance so re-renders reuse the same Image node (and\n * therefore the same KGP placement id, which the spec guarantees is a\n * flicker-free move/resize).\n */\nexport function createImageCallback(host: ImageHost): {\n  cb: MdCallbacks[\"image\"]\n  resolve: (ctx: RenderCtx, rendered: string) => Promise<string>\n} {\n  const entries: ImageEntry[] = []\n  const cache = host.images\n\n  return {\n    cb(alt: string, meta: MdImageMeta): string {\n      const id = entries.length\n      entries.push({ alt, src: meta.src })\n      return `<img id=${id}>`\n    },\n\n    async resolve(ctx: RenderCtx, rendered: string): Promise<string> {\n      if (entries.length === 0) return rendered\n\n      // `Image` is heavy (pulls image-meta, sharp lazy loaders, KGP\n      // encoder) and 99% of markdown has no images. Load it only when\n      // we have something to place.\n      const { Image } = await import(\"../widgets/image.ts\")\n\n      // One Image (and therefore one KGP `placementId`) per occurrence\n      // so multiple references to the same `src` show up as distinct\n      // placements on screen. Cache key is `${src}\\0${ordinal-within-src}`\n      // — the ordinal makes each repeated reference stable across\n      // re-renders (slot 0 is always slot 0, so the placementId stays\n      // pinned and KGP gives a flicker-free move/resize). Image bytes\n      // are de-duped at a different layer (`transmitOnce` in kitty.ts),\n      // so multiple occurrences cost N placements but only one transmit.\n      const ordinals = new Map<string, number>()\n      const rowsByEntry: string[][] = []\n      const used = new Set<string>()\n      await Promise.all(\n        entries.map(async (entry, idx) => {\n          const ord = ordinals.get(entry.src) ?? 0\n          ordinals.set(entry.src, ord + 1)\n          const key = `${entry.src}\\u0000${ord}`\n          used.add(key)\n          let img = cache.get(key)\n          if (img === undefined) {\n            img = new Image({ alt: entry.alt, src: entry.src })\n            host.add(img)\n            cache.set(key, img)\n          }\n          rowsByEntry[idx] = await img.render(ctx)\n        })\n      )\n\n      for (const [key] of cache) {\n        if (!used.has(key)) {\n          const img = cache.get(key)\n          if (img) {\n            host.remove(img)\n            cache.delete(key)\n          }\n        }\n      }\n\n      // Walk the rendered output line by line:\n      //   - Marker alone on its line (whitespace + ANSI tolerated) →\n      //     replace the line with the full image rows.\n      //   - Marker mid-line → inline ref placeholder, then splice the\n      //     image rows on the next line(s) so the picture still\n      //     appears below the surrounding text.\n      // Multiple markers on one mid-line all get inline refs; their\n      // image rows stack underneath in document order.\n      const out: string[] = []\n      for (const line of rendered.split(\"\\n\")) {\n        const matched: { entry: ImageEntry; rows: string[] }[] = []\n        for (const m of line.matchAll(MARKER_RE)) {\n          const idx = Number(m[1])\n          matched.push({ entry: entries[idx], rows: rowsByEntry[idx] ?? [] })\n        }\n\n        if (matched.length === 0) {\n          out.push(line)\n          continue\n        }\n\n        const lineHasOnlyMarker =\n          matched.length === 1 && stripAnsi(line.replace(MARKER_RE, \"\")).trim() === \"\"\n\n        if (lineHasOnlyMarker && matched[0].rows.length > 0) {\n          out.push(...matched[0].rows)\n          continue\n        }\n\n        // Mid-line: replace each marker with a nice inline ref, then\n        // append every image's rows below the line in order. Skip rows\n        // that don't contain real graphics (KGP escapes) — when the\n        // terminal can't render images, `Image.render` falls back to a\n        // single-row alt-text representation, which would just\n        // duplicate the inline label we already emitted.\n        out.push(\n          line.replaceAll(MARKER_RE, (_, idxStr: string) => labelOf(entries[Number(idxStr)]))\n        )\n        for (const { rows } of matched) {\n          if (rows.some(isRealGraphics)) out.push(...rows)\n        }\n      }\n      return out.join(\"\\n\")\n    },\n  }\n}\n\n/** Friendly inline placeholder for an image that can't render at this\n *  position. Prefers the markdown alt text; falls back to the basename\n *  of the source path (so `[clip.png]` instead of `[/tmp/long/path/clip.png]`),\n *  and \"image\" for anything weirder. */\nfunction labelOf(entry: ImageEntry): string {\n  const label = entry.alt !== \"\" ? entry.alt : basename(entry.src) || \"image\"\n  return `[${label}]`\n}\n\nconst MARKER_RE = /<img id=(\\d+)>/g\n\n/** True when a row contains a Kitty Graphics Protocol escape (transmit\n *  or place) — i.e. real image data, not the text alt fallback. */\nfunction isRealGraphics(row: string): boolean {\n  return row.includes(\"\\x1b_G\")\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,SAAgB,oBAAoB,MAGlC;CACA,MAAM,UAAwB,CAAC;CAC/B,MAAM,QAAQ,KAAK;CAEnB,OAAO;EACL,GAAG,KAAa,MAA2B;GACzC,MAAM,KAAK,QAAQ;GACnB,QAAQ,KAAK;IAAE;IAAK,KAAK,KAAK;GAAI,CAAC;GACnC,OAAO,WAAW,GAAG;EACvB;EAEA,MAAM,QAAQ,KAAgB,UAAmC;GAC/D,IAAI,QAAQ,WAAW,GAAG,OAAO;GAKjC,MAAM,EAAE,UAAU,MAAM,OAAO;GAU/B,MAAM,2BAAW,IAAI,IAAoB;GACzC,MAAM,cAA0B,CAAC;GACjC,MAAM,uBAAO,IAAI,IAAY;GAC7B,MAAM,QAAQ,IACZ,QAAQ,IAAI,OAAO,OAAO,QAAQ;IAChC,MAAM,MAAM,SAAS,IAAI,MAAM,GAAG,KAAK;IACvC,SAAS,IAAI,MAAM,KAAK,MAAM,CAAC;IAC/B,MAAM,MAAM,GAAG,MAAM,IAAI,QAAQ;IACjC,KAAK,IAAI,GAAG;IACZ,IAAI,MAAM,MAAM,IAAI,GAAG;IACvB,IAAI,QAAQ,KAAA,GAAW;KACrB,MAAM,IAAI,MAAM;MAAE,KAAK,MAAM;MAAK,KAAK,MAAM;KAAI,CAAC;KAClD,KAAK,IAAI,GAAG;KACZ,MAAM,IAAI,KAAK,GAAG;IACpB;IACA,YAAY,OAAO,MAAM,IAAI,OAAO,GAAG;GACzC,CAAC,CACH;GAEA,KAAK,MAAM,CAAC,QAAQ,OAClB,IAAI,CAAC,KAAK,IAAI,GAAG,GAAG;IAClB,MAAM,MAAM,MAAM,IAAI,GAAG;IACzB,IAAI,KAAK;KACP,KAAK,OAAO,GAAG;KACf,MAAM,OAAO,GAAG;IAClB;GACF;GAWF,MAAM,MAAgB,CAAC;GACvB,KAAK,MAAM,QAAQ,SAAS,MAAM,IAAI,GAAG;IACvC,MAAM,UAAmD,CAAC;IAC1D,KAAK,MAAM,KAAK,KAAK,SAAS,SAAS,GAAG;KACxC,MAAM,MAAM,OAAO,EAAE,EAAE;KACvB,QAAQ,KAAK;MAAE,OAAO,QAAQ;MAAM,MAAM,YAAY,QAAQ,CAAC;KAAE,CAAC;IACpE;IAEA,IAAI,QAAQ,WAAW,GAAG;KACxB,IAAI,KAAK,IAAI;KACb;IACF;IAKA,IAFE,QAAQ,WAAW,KAAK,UAAU,KAAK,QAAQ,WAAW,EAAE,CAAC,CAAC,CAAC,KAAK,MAAM,MAEnD,QAAQ,EAAE,CAAC,KAAK,SAAS,GAAG;KACnD,IAAI,KAAK,GAAG,QAAQ,EAAE,CAAC,IAAI;KAC3B;IACF;IAQA,IAAI,KACF,KAAK,WAAW,YAAY,GAAG,WAAmB,QAAQ,QAAQ,OAAO,MAAM,EAAE,CAAC,CACpF;IACA,KAAK,MAAM,EAAE,UAAU,SACrB,IAAI,KAAK,KAAK,cAAc,GAAG,IAAI,KAAK,GAAG,IAAI;GAEnD;GACA,OAAO,IAAI,KAAK,IAAI;EACtB;CACF;AACF;;;;;AAMA,SAAS,QAAQ,OAA2B;CAE1C,OAAO,IADO,MAAM,QAAQ,KAAK,MAAM,MAAM,SAAS,MAAM,GAAG,KAAK,QACnD;AACnB;AAEA,MAAM,YAAY;;;AAIlB,SAAS,eAAe,KAAsB;CAC5C,OAAO,IAAI,SAAS,QAAQ;AAC9B"}

package/dist/image.d.mts

@@ -0,0 +1,123 @@
+import { n as TerminalQuery, t as TerminalQueries } from "./queries-DH3bj74K.mjs";
+import { MaybePromise } from "@zaly/shared";
+import { ImageInfo } from "@zaly/shared/image";
+//#region src/image/kitty.d.ts
+type KittyPlacement = {
+  imageId: number;
+  /** Placement ID. Omitted when this is an inline placement (U=1) */
+  placementId?: number;
+  /** inline: placement using unicode placeholder (U=1) */
+  inline?: boolean;
+  /** The KGP escape sequence to place the image */
+  seq: string;
+  /** Rows to render (excluding the placement escape sequence) */
+  data: string[];
+};
+type ImageSupport = {
+  terminal?: {
+    name: string;
+    version?: string;
+  };
+  remote?: boolean;
+  wrap?: (seq: string) => string;
+  tmux?: boolean;
+} & ({
+  ok: false;
+  error: string;
+  terminal?: {
+    name: string;
+    version?: string;
+  };
+} | {
+  ok: true;
+  error?: never;
+  terminal: {
+    name: string;
+    version?: string;
+  };
+  inline?: boolean;
+});
+type KittyResponse = {
+  attrs: Record<string, string | number>;
+  ok: true;
+} | {
+  attrs: Record<string, string | number>;
+  ok: false;
+  error: {
+    code: string;
+    message: string;
+  };
+};
+type PlacementDims = {
+  /** Display width in terminal cells. */
+  cols: number;
+  /** Display height in terminal cells. */
+  rows: number;
+};
+declare const DIACRITICS: string[];
+declare const PLACEHOLDER: string;
+/** Allocate a fresh 24-bit image id (1..0xFFFFFFFE). */
+declare function allocateImageId(): number;
+/** Allocate a fresh 24-bit placement id. */
+declare function allocatePlacementId(): number;
+declare class Kitty {
+  #private;
+  constructor(support: ImageSupport);
+  get supported(): boolean;
+  get inline(): boolean;
+  /** Create a KGP request escape sequence */
+  request(attrs: Record<string, string | number>, data?: string | Uint8Array, opts?: {
+    base64?: boolean;
+  }): string;
+  /** Create a TerminalQuery that requests a KGP operation and parses the response. */
+  query(attrs: Record<string, string | number>, data?: string | Uint8Array, opts?: {
+    base64?: boolean;
+  }): TerminalQuery;
+  /** Probe the terminal for KGP support. Should return an error response. */
+  probe(): string;
+  /** Parse a KGP response escape sequence into a structured object. */
+  parse(res: string): KittyResponse | undefined;
+  placement(imageId: number, dims: PlacementDims): KittyPlacement | undefined;
+  /** Delete an image and all its placements, or ALL images if `imageId` is omitted. */
+  deleteImage(imageId?: number): string;
+  /** Delete a placement (keeps image data so it can be re-placed cheaply). */
+  deletePlacement(imageId: number, placementId: number): string;
+  /**
+   * Ensure an image has been transmitted to the terminal at least once.
+   * On the first call per `src`, returns the full `a=t,t=f` escape to be
+   * prepended to the caller's first row — the APC payload has zero display
+   * width, so layout sees through it. Subsequent calls return `transmit:
+   * ""` since the terminal already has the bytes under `imageId`.
+   *
+   * The caller is expected to combine this with `placement(...)` on every
+   * render to actually paint the image at the right cell rectangle.
+   */
+  transmitOnce(info: ImageInfo): Promise<{
+    imageId: number;
+    transmit?: string;
+  } | undefined>;
+  /**
+   * Transmit an image to the terminal by file path (`t=f`). Near-zero cost
+   * on the wire — the terminal opens and reads the file itself. `path`
+   * must be absolute and must point to a regular file; symlinks are
+   * followed by the terminal.
+   */
+  transmitFile(id: number, path: string): string;
+  /**
+   * Remote/bytes transmission fallback (`t=d`) for when the terminal can't
+   * read local files — typical of SSH sessions. Base64-encodes and chunks
+   * the PNG payload at 4KB boundaries per the protocol.
+   */
+  transmitBytes(id: number, png: Uint8Array): string;
+}
+/** Drop the per-src transmit cache. Mostly for tests. */
+declare function resetTransmitCache(): void;
+declare function resetKittyGraphics(): void;
+declare function bumpPlacements(rows: string[]): undefined | {
+  delete: () => string;
+  rows: string[];
+};
+declare function loadKittyGraphics(tq: TerminalQueries): MaybePromise<Kitty>;
+//#endregion
+export { DIACRITICS, ImageSupport, Kitty, KittyPlacement, KittyResponse, PLACEHOLDER, PlacementDims, allocateImageId, allocatePlacementId, bumpPlacements, loadKittyGraphics, resetKittyGraphics, resetTransmitCache };
+//# sourceMappingURL=image.d.mts.map

package/dist/image.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image.d.mts","names":[],"sources":["../src/image/kitty.ts"],"mappings":";;;;KAqBY;EACV;;EAEA;;EAEA;;EAEA;;EAEA;;KAGU;EACV;IAAa;IAAc;;EAC3B;EACA,QAAQ;EACR;;EAGI;EACA;EACA;IAAa;IAAc;;;EAG3B;EACA;EACA;IAAY;IAAc;;EAC1B;;KAIM;EAEN,OAAO;EACP;;EAGA,OAAO;EACP;EACA;IAAS;IAAc;;;KAGjB;;EAEV;;EAEA;;cAaW;cACA;;iBAgBG;;iBAKA;cAIH;;EAIX,YAAY,SAAS;MAKjB;MAIA;;EAKJ,QACE,OAAO,iCACP,gBAAgB,YAChB;IAAQ;;;EAcV,MACE,OAAO,iCACP,gBAAgB,YAChB;IAAQ;MACP;;EAaH;;EAKA,MAAM,cAAc;EAsBpB,UAAU,iBAAiB,MAAM,gBAAgB;;EA+BjD,YAAY;;EAOZ,gBAAgB,iBAAiB;;;;;;;;;;;EAc3B,aAAa,MAAM,YAAY;IAAU;IAAiB;;;;;;;;EAqChE,aAAa,YAAY;;;;;;EASzB,cAAc,YAAY,KAAK;;;iBAoBjB;iBAIA;iBAwCA,eACd;EACe;EAAsB;;iBAiFvB,kBAAkB,IAAI,kBAAkB,aAAa"}

package/dist/image.mjs

@@ -0,0 +1,2 @@
+import { a as allocatePlacementId, c as resetKittyGraphics, i as allocateImageId, l as resetTransmitCache, n as Kitty, o as bumpPlacements, r as PLACEHOLDER, s as loadKittyGraphics, t as DIACRITICS } from "./kitty-JbCJC0iQ.mjs";
+export { DIACRITICS, Kitty, PLACEHOLDER, allocateImageId, allocatePlacementId, bumpPlacements, loadKittyGraphics, resetKittyGraphics, resetTransmitCache };

package/dist/index.d.mts

@@ -0,0 +1,64 @@
+import { $ as Context, At as useContext, Bt as Actions, C as OverlaySurface, Ct as peek, Dt as untrack, Et as toAccessor, Ft as ActionCtx, Gt as KeyModifier, Ht as NodeAction, It as ActionDef, J as Layout, Jt as SpecialKeyName, Kt as KeyPattern, Lt as ActionFilter, Mt as withOwner, N as MountCtx, Ot as unwrap, P as RenderCtx, Pt as Action, Q as Accessor, Rt as ActionFn, S as Stream, St as onCleanup, Tt as signal, Ut as NodeActionMap, Vt as KeyBinding, Wt as KeyEvent, X as State, Xt as isKeyPattern, Y as LayoutState, Yt as canonical, Z as StyleState, Zt as keyMatches, _ as RenderStats, _t as createSuspenseBoundary, a as InputRouter, at as Signal, b as SurfaceType, bt as isAccessor, c as KeyPatterns, ct as SuspenseContext, d as RoutedPaste, dt as createIterable, et as Owner, f as BaseEvents, ft as createNode, g as RenderEvents, gt as createStore, h as NodeVisitor, ht as createRoot, i as parseAttrs, it as Setter, jt as withActiveNode, kt as useActiveOwner, l as KeymapEntry, lt as createAsync, m as isNode, mt as createRef, n as TerminalQuery, nt as Reactive, o as InputRouterEvents, ot as SignalStore, p as Node, pt as createProgressive, q as FlexState, qt as KeyPatternError, r as TerminalQueryOpts, rt as Ref, s as KeyHandler, st as SuspenseBoundary, t as TerminalQueries, tt as Progressive, u as RoutedKey, ut as createContext, v as Renderer, vt as effect, w as Terminal, wt as provideContext, x as UI, xt as memo, y as RendererOptions, yt as inRenderContextOf, zt as ActionMap } from "./queries-DH3bj74K.mjs";
+import { _ as ShikiRequest, a as AnsiStyle, b as ShikiWorkerRequest, c as Color, d as RGB, f as Style, g as ShikiOpts, h as ShikiLanguage, i as AnsiColorName, l as ColorLightness, m as ShikiJob, n as ThemeValue, o as AnyStyle, p as ThemeKey, r as AnsiColor, s as BrightAnsiColorName, t as Theme, u as HexColor, v as ShikiResult, y as ShikiTheme } from "./types-B9Eh7k2v.mjs";
+import { a as StyleBuilder, i as isMarkdown, n as inspect, r as inspectFormat, t as InspectOpts } from "./inspect-D6FW_QUo.mjs";
+import { ArgsOpts } from "@zaly/shared/args";
+//#region src/input/index.d.ts
+declare function defineAction<T extends ArgsOpts = ArgsOpts>(action: ActionDef<T>): ActionDef<T>;
+declare function defineAction<T extends ArgsOpts = ArgsOpts>(action: Action<T>): Action<T>;
+//#endregion
+//#region src/core/render.d.ts
+/** Components-facing slice of the render environment — reactive
+ *  accessors a widget body reads via `useContext(RenderContext)`. Use
+ *  this when a widget needs ambient theme/style outside an `_render`
+ *  call (the place where `RenderCtx` is threaded in). Width is
+ *  deliberately omitted — that's a per-render allotted-size concept,
+ *  not an ambient one. */
+type RenderContextValue = {
+  /** Active theme. Tracked — widgets that read it re-fire on swap. */
+  theme: Accessor<Theme>;
+  /** Theme-bound chainable style builder. Derived memo over `theme`. */
+  style: Accessor<StyleBuilder>;
+  /** Whether to render images (when supported) */
+  images: Accessor<boolean>;
+  queries: TerminalQueries;
+};
+declare const RenderContext: Context<RenderContextValue | undefined>;
+/**
+ * Render a Node, draining `createAsync` work in its subtree before
+ * returning final rows. Two shapes:
+ *
+ *   - `createRender(() => node, ctx?)` — factory form. Creates a fresh
+ *     `SuspenseBoundary` inside a new `createRoot` and runs the
+ *     factory in that scope so descendants find the boundary via
+ *     `useContext(SuspenseContext)`. For tests, benches, REPL.
+ *
+ *   - `createRender(node, { ...ctx, boundary })` — pre-built Node
+ *     with a caller-provided boundary. Used by `Stream.render`: the
+ *     boundary was installed at `append` time, so we just render +
+ *     drain without a new root scope.
+ *
+ * `ctx` defaults to `createCtx()` in the factory form.
+ *
+ * ```ts
+ * const rows = await createRender(() => markdown("**hi**"))
+ * ```
+ */
+declare function createRender(node: Node, ctx: RenderCtx & {
+  boundary: SuspenseBoundary;
+}): Promise<string[]>;
+declare function createRender(node: () => Node, ctx?: RenderCtx): Promise<string[]>;
+//#endregion
+//#region src/core/index.d.ts
+declare function createCtx(opts?: Partial<RenderCtx> & {
+  theme?: Theme;
+}): Promise<RenderCtx>;
+//#endregion
+//#region src/renderer/index.d.ts
+/** Factory shorthand for `new Renderer(opts)`. */
+declare function createRenderer(opts?: RendererOptions): Promise<Renderer>;
+//#endregion
+//#region src/shiki/shiki.d.ts
+declare function codeToAnsi(code: string, lang: string, opts?: ShikiOpts): Promise<string>;
+//#endregion
+export { Accessor, type Action, type ActionCtx, type ActionDef, type ActionFilter, type ActionFn, type ActionMap, type Actions, type AnsiColor, type AnsiColorName, type AnsiStyle, type AnyStyle, type BaseEvents, type BrightAnsiColorName, type Color, type ColorLightness, Context, type FlexState, type HexColor, type InputRouter, type InputRouterEvents, InspectOpts, type KeyBinding, KeyEvent, type KeyHandler, KeyModifier, KeyPattern, KeyPatternError, type KeyPatterns, type KeymapEntry, type Layout, type LayoutState, type MountCtx, type Node, type NodeAction, type NodeActionMap, type NodeVisitor, type OverlaySurface, Owner, Progressive, type RGB, Reactive, Ref, RenderContext, RenderContextValue, type RenderCtx, type RenderEvents, type RenderStats, type Renderer, type RendererOptions, type RoutedKey, type RoutedPaste, Setter, type ShikiJob, type ShikiLanguage, type ShikiOpts, type ShikiRequest, type ShikiResult, type ShikiTheme, type ShikiWorkerRequest, Signal, SignalStore, SpecialKeyName, type State, type Stream, type Style, type StyleState, type SurfaceType, SuspenseBoundary, SuspenseContext, type Terminal, TerminalQueries, TerminalQuery, TerminalQueryOpts, type Theme, type ThemeKey, type ThemeValue, type UI, canonical, codeToAnsi, createAsync, createContext, createCtx, createIterable, createNode, createProgressive, createRef, createRender, createRenderer, createRoot, createStore, createSuspenseBoundary, defineAction, effect, inRenderContextOf, inspect, inspectFormat, isAccessor, isKeyPattern, isMarkdown, type isNode, keyMatches, memo, onCleanup, parseAttrs, peek, provideContext, signal, toAccessor, untrack, unwrap, useActiveOwner, useContext, withActiveNode, withOwner };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/input/index.ts","../src/core/render.ts","../src/core/index.ts","../src/renderer/index.ts","../src/shiki/shiki.ts"],"mappings":";;;;;iBAGgB,aAAa,UAAU,WAAW,UAAU,QAAQ,UAAU,KAAK,UAAU;iBAC7E,aAAa,UAAU,WAAW,UAAU,QAAQ,OAAO,KAAK,OAAO;;;;;;;;;KCmB3E;;EAEV,OAAO,SAAS;;EAEhB,OAAO,SAAS;;EAEhB,QAAQ;EACR,SAAS;;cAEE,eAAa,QAAA;;;;;;;;;;;;;;;;;;;;;iBAsBJ,aACpB,MAAM,MACN,KAAK;EAAc,UAAU;IAC5B;iBACmB,aAAa,YAAY,MAAM,MAAM,YAAY;;;iBC/CjD,UACpB,OAAM,QAAQ;EAAe,QAAQ;IACpC,QAAQ;;;;iBCJW,eAAe,OAAM,kBAAuB,QAAQ;;;iBCJpD,WAAW,cAAc,cAAc,OAAO,YAAY"}

package/dist/index.mjs

@@ -0,0 +1,222 @@
+import { C as useActiveOwner, E as withOwner, S as unwrap, T as withActiveNode, _ as peek, a as createIterable, b as toAccessor, c as createRef, d as createSuspenseBoundary, f as effect, g as onCleanup, h as memo, i as createContext, l as createRoot, m as isAccessor, n as SuspenseContext, o as createNode, p as inRenderContextOf, r as createAsync, s as createProgressive, t as Owner, u as createStore, v as provideContext, w as useContext, x as untrack, y as signal } from "./reactive-f7NpAi69.mjs";
+import { n as inspectFormat, r as isMarkdown, t as inspect } from "./inspect-D1d9t-ni.mjs";
+import { n as createRender, t as RenderContext } from "./render-DxVLqqB9.mjs";
+import { t as codeToAnsi } from "./shiki-BrjVUkeh.mjs";
+//#region src/input/index.ts
+function defineAction(action) {
+	return action;
+}
+//#endregion
+//#region src/core/index.ts
+async function createCtx(opts = {}) {
+	const { createCtx: create } = await import("./render-DxVLqqB9.mjs").then((n) => n.i);
+	return create(opts);
+}
+//#endregion
+//#region src/renderer/index.ts
+/** Factory shorthand for `new Renderer(opts)`. */
+async function createRenderer(opts = {}) {
+	const { Renderer } = await import("./renderer-CxL4xbkl.mjs");
+	return new Renderer(opts);
+}
+//#endregion
+//#region src/input/keys.ts
+const MOD_NAMES = /* @__PURE__ */ new Set([
+	"ctrl",
+	"alt",
+	"shift",
+	"meta"
+]);
+const SPECIAL_KEY_NAMES = /* @__PURE__ */ new Set([
+	"enter",
+	"tab",
+	"backspace",
+	"delete",
+	"space",
+	"esc",
+	"up",
+	"down",
+	"left",
+	"right",
+	"home",
+	"end",
+	"pageup",
+	"pagedown",
+	"insert",
+	"f1",
+	"f2",
+	"f3",
+	"f4",
+	"f5",
+	"f6",
+	"f7",
+	"f8",
+	"f9",
+	"f10",
+	"f11",
+	"f12"
+]);
+var KeyPatternError = class extends Error {
+	constructor(pattern, reason) {
+		super(`invalid key pattern ${JSON.stringify(pattern)}: ${reason}`);
+		this.name = "KeyPatternError";
+	}
+};
+function parsePattern(pattern) {
+	const mods = {
+		alt: false,
+		ctrl: false,
+		meta: false,
+		shift: false
+	};
+	let name = pattern;
+	while (name.length > 0) {
+		const dash = name.indexOf("-");
+		if (dash <= 0) break;
+		const mod = name.slice(0, dash);
+		if (!MOD_NAMES.has(mod)) throw new KeyPatternError(pattern, `unknown modifier: ${mod}`);
+		if (mods[mod]) throw new KeyPatternError(pattern, `duplicate modifier: ${mod}`);
+		mods[mod] = true;
+		name = name.slice(dash + 1);
+	}
+	const ret = normalizeKey({
+		...mods,
+		name
+	});
+	name = ret.name;
+	if (name === "") throw new KeyPatternError(pattern, "missing key name");
+	if (name.includes("-") && name !== "-") throw new KeyPatternError(pattern, "too many keys");
+	if (!isPrintableKeyName(name)) throw new KeyPatternError(pattern, `unknown key name: ${name}`);
+	if (mods.shift && !canUseShiftModifier(name)) throw new KeyPatternError(pattern, `shift-${name} will not trigger; bind the shifted character instead`);
+	return ret;
+}
+function normalizeKey(p) {
+	if (/^[A-Z]$/.test(p.name)) return {
+		...p,
+		name: p.name.toLowerCase(),
+		shift: true
+	};
+	if (p.name === " ") return {
+		...p,
+		name: "space"
+	};
+	return p;
+}
+function isPrintableKeyName(s) {
+	return SPECIAL_KEY_NAMES.has(s) || [...s].length === 1 && !/[\p{C}]/u.test(s);
+}
+function canUseShiftModifier(name) {
+	return /^[a-zA-Z]$/.test(name) || SPECIAL_KEY_NAMES.has(name);
+}
+function isKeyPattern(s) {
+	try {
+		canonical(s);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Canonical string form of a pattern or event — modifiers in a fixed
+* alphabetical order, then the key name, joined by `-`. Used by the
+* router to build a pattern index whose keys match regardless of how
+* the user spelled the modifier order (`"ctrl-shift-a"` and
+* `"shift-ctrl-a"` both canonicalize to `"ctrl-shift-a"`).
+*/
+function canonical(patternOrEvent) {
+	const p = typeof patternOrEvent === "string" ? parsePattern(patternOrEvent) : normalizeKey(patternOrEvent);
+	const parts = [];
+	if (p.alt) parts.push("alt");
+	if (p.ctrl) parts.push("ctrl");
+	if (p.meta) parts.push("meta");
+	if (p.shift) parts.push("shift");
+	parts.push(p.name);
+	return parts.join("-");
+}
+/**
+* Test whether an event matches a pattern (or any of a list of patterns).
+* Unspecified modifiers in the pattern must be *absent* on the event —
+* matching is strict, not inclusive, so `"a"` only matches a bare `a`
+* (no ctrl/alt/etc.).
+*/
+function keyMatches(ev, pattern) {
+	if (Array.isArray(pattern)) {
+		for (const p of pattern) if (keyMatches(ev, p)) return true;
+		return false;
+	}
+	const p = parsePattern(pattern);
+	const e = normalizeKey(ev);
+	return e.name === p.name && e.ctrl === p.ctrl && e.alt === p.alt && e.shift === p.shift && e.meta === p.meta;
+}
+//#endregion
+//#region src/input/queries.ts
+var TerminalQueries = class {
+	#router;
+	#terminal;
+	constructor(router, terminal) {
+		this.#router = router;
+		this.#terminal = terminal;
+	}
+	query(query) {
+		const timeout = query.timeout ?? 200;
+		const ac = new AbortController();
+		return new Promise((resolve) => {
+			const finish = (value) => {
+				if (ac.signal.aborted) return;
+				ac.abort();
+				clearTimeout(timer);
+				resolve(value);
+			};
+			const timer = setTimeout(() => finish(), timeout);
+			timer.unref();
+			this.#router.on("term-response", ({ event }) => {
+				const value = query.match(event);
+				if (value !== void 0) finish(value);
+			}, { signal: ac.signal });
+			this.#terminal.write(query.wrap?.(query.request) ?? query.request);
+		});
+	}
+	primaryDeviceAttributes(opts = {}) {
+		return this.query({
+			match: (ev) => ev.kind === "csi" && ev.final === "c" && ev.params.startsWith("?") ? {
+				...ev,
+				attrs: parseAttrs(ev.params)
+			} : void 0,
+			request: "\x1B[c",
+			...opts
+		});
+	}
+	secondaryDeviceAttributes(opts = {}) {
+		return this.query({
+			match: (ev) => ev.kind === "csi" && ev.final === "c" && ev.params.startsWith(">") ? {
+				...ev,
+				attrs: parseAttrs(ev.params)
+			} : void 0,
+			request: "\x1B[>c",
+			...opts
+		});
+	}
+	xtVersion(opts = {}) {
+		return this.query({
+			match: (ev) => {
+				if (ev.kind !== "dcs" || !ev.payload.startsWith(">|")) return;
+				const payload = ev.payload.slice(2);
+				const m = payload.match(/^([^\s]+)\(([^\s]+)\)$/) ?? payload.match(/^([^\s]+)\s+([^\s]+)$/);
+				return {
+					...ev,
+					name: m?.[1] ?? payload,
+					version: m?.[2]
+				};
+			},
+			request: "\x1B[>q",
+			...opts
+		});
+	}
+};
+function parseAttrs(params) {
+	return params.slice(1).split(";").map((n) => Number.parseInt(n, 10)).filter(Number.isFinite);
+}
+//#endregion
+export { KeyPatternError, Owner, RenderContext, SuspenseContext, TerminalQueries, canonical, codeToAnsi, createAsync, createContext, createCtx, createIterable, createNode, createProgressive, createRef, createRender, createRenderer, createRoot, createStore, createSuspenseBoundary, defineAction, effect, inRenderContextOf, inspect, inspectFormat, isAccessor, isKeyPattern, isMarkdown, keyMatches, memo, onCleanup, parseAttrs, peek, provideContext, signal, toAccessor, untrack, unwrap, useActiveOwner, useContext, withActiveNode, withOwner };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["#router","#terminal"],"sources":["../src/input/index.ts","../src/core/index.ts","../src/renderer/index.ts","../src/input/keys.ts","../src/input/queries.ts"],"sourcesContent":["import type { ArgsOpts } from \"@zaly/shared/args\"\nimport type { Action, ActionDef } from \"./actions.ts\"\n\nexport function defineAction<T extends ArgsOpts = ArgsOpts>(action: ActionDef<T>): ActionDef<T>\nexport function defineAction<T extends ArgsOpts = ArgsOpts>(action: Action<T>): Action<T>\nexport function defineAction<T extends ArgsOpts = ArgsOpts>(\n  action: ActionDef<T> | Action<T>\n): ActionDef<T> | Action<T> {\n  return action\n}\n","import type { Theme } from \"../themes/types.ts\"\nimport type { RenderCtx } from \"./ctx.ts\"\n\nexport type { RenderCtx, MountCtx } from \"./ctx.ts\"\n\nexport type * from \"./node.ts\"\nexport type * from \"./state.ts\"\n\nexport * from \"./reactive.ts\"\nexport * from \"./render.ts\"\n\nexport async function createCtx(\n  opts: Partial<RenderCtx> & { theme?: Theme } = {}\n): Promise<RenderCtx> {\n  const { createCtx: create } = await import(\"./ctx.ts\")\n  return create(opts)\n}\n","import type { Renderer, RendererOptions } from \"./renderer.ts\"\n\nexport type * from \"./renderer.ts\"\nexport type { OverlaySurface } from \"./overlay.ts\"\nexport type { Stream } from \"./stream.ts\"\nexport type { Terminal } from \"./terminal.ts\"\nexport type { UI } from \"./ui.ts\"\n\n/** Factory shorthand for `new Renderer(opts)`. */\nexport async function createRenderer(opts: RendererOptions = {}): Promise<Renderer> {\n  const { Renderer } = await import(\"./renderer.ts\")\n  return new Renderer(opts)\n}\n","/**\n * Keyboard event shape + pattern-based matcher.\n *\n * `KeyEvent.name` is a canonical name:\n *   - Single characters for printable keys: `\"a\"`, `\"A\"`, `\" \"`, `\"!\"`. The\n *     `name` reflects the raw character the decoder produced — so `Shift+A`\n *     arrives as `{ name: \"A\", shift: true }` (terminals already fold\n *     shift into the uppercase byte for letters).\n *   - Named constants for non-printing keys: `\"enter\"`, `\"tab\"`, `\"esc\"`,\n *     `\"backspace\"`, `\"delete\"`, `\"space\"`, arrows `\"up\"/\"down\"/\"left\"/\n *     \"right\"`, navigation `\"home\"/\"end\"/\"pageup\"/\"pagedown\"/\"insert\"`,\n *     function keys `\"f1\"` .. `\"f12\"`.\n *\n * Patterns for `keyMatches` are dash-separated modifier prefixes plus the\n * name: `\"a\"`, `\"ctrl-c\"`, `\"shift-tab\"`, `\"ctrl-shift-x\"`. Unknown\n * prefixes are treated as literal characters in the name, so\n * `\"something-foo\"` is interpreted as the name `\"something-foo\"` rather\n * than a missing-modifier error.\n *\n * Modifier prefixes (order-independent):\n *   - `ctrl-`\n *   - `alt-`\n *   - `shift-`\n *   - `meta-`  (a.k.a. super / cmd)\n */\n\nexport interface KeyEvent {\n  /** Canonical key name — raw character or one of the named constants above. */\n  name: string\n  /**\n   * The literal text the keystroke would insert, when that makes sense.\n   * For printable chars this is the char itself; for Enter, Tab, etc. it's\n   * undefined. Widgets use this to decide whether to insert content vs.\n   * treat the key as a command.\n   */\n  text?: string\n  ctrl: boolean\n  alt: boolean\n  shift: boolean\n  meta: boolean\n}\n\n/** Canonical modifier names used in `KeyPattern`. */\nexport type KeyModifier = \"ctrl\" | \"alt\" | \"shift\" | \"meta\"\n\n/**\n * Named keys the decoder emits for non-printable keystrokes. Bindings\n * reference these directly (`\"enter\"`, `\"f5\"`, `\"pageup\"`, …).\n */\nexport type SpecialKeyName = (typeof specialKeys)[number]\n\ndeclare const KeyPatternBrand: unique symbol\n\n/** A validated, canonical key binding string. */\nexport type KeyPattern = string & { readonly [KeyPatternBrand]: true }\n\nconst MOD_NAMES = new Set<string>([\"ctrl\", \"alt\", \"shift\", \"meta\"])\nconst specialKeys = [\n  \"enter\",\n  \"tab\",\n  \"backspace\",\n  \"delete\",\n  \"space\",\n  \"esc\",\n  \"up\",\n  \"down\",\n  \"left\",\n  \"right\",\n  \"home\",\n  \"end\",\n  \"pageup\",\n  \"pagedown\",\n  \"insert\",\n  \"f1\",\n  \"f2\",\n  \"f3\",\n  \"f4\",\n  \"f5\",\n  \"f6\",\n  \"f7\",\n  \"f8\",\n  \"f9\",\n  \"f10\",\n  \"f11\",\n  \"f12\",\n] as const\nconst SPECIAL_KEY_NAMES = new Set<string>(specialKeys)\n\ninterface ParsedPattern {\n  name: string\n  ctrl: boolean\n  alt: boolean\n  shift: boolean\n  meta: boolean\n}\n\nexport class KeyPatternError extends Error {\n  constructor(pattern: string, reason: string) {\n    super(`invalid key pattern ${JSON.stringify(pattern)}: ${reason}`)\n    this.name = \"KeyPatternError\"\n  }\n}\n\nfunction parsePattern(pattern: string): ParsedPattern {\n  const mods = { alt: false, ctrl: false, meta: false, shift: false }\n  let name = pattern\n  while (name.length > 0) {\n    const dash = name.indexOf(\"-\")\n    if (dash <= 0) break\n    const mod = name.slice(0, dash)\n    if (!MOD_NAMES.has(mod)) throw new KeyPatternError(pattern, `unknown modifier: ${mod}`)\n    if (mods[mod as KeyModifier]) throw new KeyPatternError(pattern, `duplicate modifier: ${mod}`)\n    mods[mod as KeyModifier] = true\n    name = name.slice(dash + 1)\n  }\n\n  const ret = normalizeKey({ ...mods, name })\n  name = ret.name\n  if (name === \"\") throw new KeyPatternError(pattern, \"missing key name\")\n  if (name.includes(\"-\") && name !== \"-\") throw new KeyPatternError(pattern, \"too many keys\")\n  if (!isPrintableKeyName(name)) throw new KeyPatternError(pattern, `unknown key name: ${name}`)\n  if (mods.shift && !canUseShiftModifier(name)) {\n    throw new KeyPatternError(\n      pattern,\n      `shift-${name} will not trigger; bind the shifted character instead`\n    )\n  }\n  return ret\n}\n\nfunction normalizeKey(p: ParsedPattern): ParsedPattern {\n  if (/^[A-Z]$/.test(p.name)) return { ...p, name: p.name.toLowerCase(), shift: true }\n  if (p.name === \" \") return { ...p, name: \"space\" }\n  return p\n}\n\nfunction isPrintableKeyName(s: string): boolean {\n  // oxlint-disable-next-line typescript/no-misused-spread\n  return SPECIAL_KEY_NAMES.has(s) || ([...s].length === 1 && !/[\\p{C}]/u.test(s))\n}\n\nfunction canUseShiftModifier(name: string): boolean {\n  return /^[a-zA-Z]$/.test(name) || SPECIAL_KEY_NAMES.has(name)\n}\n\nexport function isKeyPattern(s: string): s is KeyPattern {\n  try {\n    canonical(s)\n    return true\n  } catch {\n    return false\n  }\n}\n\n/**\n * Canonical string form of a pattern or event — modifiers in a fixed\n * alphabetical order, then the key name, joined by `-`. Used by the\n * router to build a pattern index whose keys match regardless of how\n * the user spelled the modifier order (`\"ctrl-shift-a\"` and\n * `\"shift-ctrl-a\"` both canonicalize to `\"ctrl-shift-a\"`).\n */\nexport function canonical(patternOrEvent: string | KeyEvent): KeyPattern {\n  const p =\n    typeof patternOrEvent === \"string\" ? parsePattern(patternOrEvent) : normalizeKey(patternOrEvent)\n  const parts: string[] = []\n  if (p.alt) parts.push(\"alt\")\n  if (p.ctrl) parts.push(\"ctrl\")\n  if (p.meta) parts.push(\"meta\")\n  if (p.shift) parts.push(\"shift\")\n  parts.push(p.name)\n  return parts.join(\"-\") as KeyPattern\n}\n\n/**\n * Test whether an event matches a pattern (or any of a list of patterns).\n * Unspecified modifiers in the pattern must be *absent* on the event —\n * matching is strict, not inclusive, so `\"a\"` only matches a bare `a`\n * (no ctrl/alt/etc.).\n */\nexport function keyMatches(ev: KeyEvent, pattern: string | readonly string[]): boolean {\n  if (Array.isArray(pattern)) {\n    for (const p of pattern) if (keyMatches(ev, p)) return true\n    return false\n  }\n  const p = parsePattern(pattern as string)\n  const e = normalizeKey(ev)\n  return (\n    e.name === p.name &&\n    e.ctrl === p.ctrl &&\n    e.alt === p.alt &&\n    e.shift === p.shift &&\n    e.meta === p.meta\n  )\n}\n","import type { TerminalResponseEvent } from \"./decoder.ts\"\nimport type { InputRouter } from \"./router.ts\"\n\nexport type TerminalQuery<T = TerminalResponseEvent> = TerminalQueryOpts & {\n  request: string\n  match: (event: TerminalResponseEvent) => T | undefined\n}\n\nexport type TerminalQueryOpts = {\n  timeout?: number\n  wrap?: (seq: string) => string\n}\n\ntype TerminalQueryWriter = {\n  write: (seq: string) => void\n}\n\nexport class TerminalQueries {\n  readonly #router: InputRouter\n  readonly #terminal: TerminalQueryWriter\n\n  constructor(router: InputRouter, terminal: TerminalQueryWriter) {\n    this.#router = router\n    this.#terminal = terminal\n  }\n\n  query<T>(query: TerminalQuery<T>): Promise<T | undefined> {\n    const timeout = query.timeout ?? 200\n    const ac = new AbortController()\n    return new Promise((resolve) => {\n      const finish = (value?: T) => {\n        if (ac.signal.aborted) return\n        ac.abort()\n        clearTimeout(timer)\n        resolve(value)\n      }\n      const timer = setTimeout(() => finish(), timeout)\n      timer.unref()\n      this.#router.on(\n        \"term-response\",\n        ({ event }) => {\n          const value = query.match(event)\n          if (value !== undefined) finish(value)\n        },\n        { signal: ac.signal }\n      )\n      this.#terminal.write(query.wrap?.(query.request) ?? query.request)\n    })\n  }\n\n  primaryDeviceAttributes(opts: TerminalQueryOpts = {}) {\n    return this.query<TerminalResponseEvent & { attrs: number[] }>({\n      match: (ev) =>\n        ev.kind === \"csi\" && ev.final === \"c\" && ev.params.startsWith(\"?\")\n          ? { ...ev, attrs: parseAttrs(ev.params) }\n          : undefined,\n      request: \"\\x1b[c\",\n      ...opts,\n    })\n  }\n\n  secondaryDeviceAttributes(opts: TerminalQueryOpts = {}) {\n    return this.query<TerminalResponseEvent & { attrs: number[] }>({\n      match: (ev) =>\n        ev.kind === \"csi\" && ev.final === \"c\" && ev.params.startsWith(\">\")\n          ? { ...ev, attrs: parseAttrs(ev.params) }\n          : undefined,\n      request: \"\\x1b[>c\",\n      ...opts,\n    })\n  }\n\n  xtVersion(opts: TerminalQueryOpts = {}) {\n    return this.query<TerminalResponseEvent & { name: string; version?: string }>({\n      match: (ev) => {\n        if (ev.kind !== \"dcs\" || !ev.payload.startsWith(\">|\")) return\n        const payload = ev.payload.slice(2)\n        const m = payload.match(/^([^\\s]+)\\(([^\\s]+)\\)$/) ?? payload.match(/^([^\\s]+)\\s+([^\\s]+)$/)\n        return { ...ev, name: m?.[1] ?? payload, version: m?.[2] }\n      },\n      request: \"\\x1b[>q\",\n      ...opts,\n    })\n  }\n}\n\nexport function parseAttrs(params: string): number[] {\n  return params\n    .slice(1)\n    .split(\";\")\n    .map((n) => Number.parseInt(n, 10))\n    .filter(Number.isFinite)\n}\n"],"mappings":"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"}