svg-terminal 1.0.0

package/dist/chunk-IVINEQLU.js

@@ -0,0 +1,4603 @@
+// src/index.ts
+import { z as z50 } from "zod";
+
+// src/core/config.ts
+import { readFileSync } from "fs";
+import { z as z2 } from "zod";
+
+// src/themes/dracula.ts
+var dracula = {
+  name: "dracula",
+  colors: {
+    text: "#e4e4e4",
+    comment: "#6272a4",
+    background: "#0a0e27",
+    titleBarBackground: "#151b2e",
+    titleBarText: "#e0e6ed",
+    prompt: "#00ff9f",
+    cursor: "#00ff41",
+    red: "#ff5555",
+    green: "#50fa7b",
+    yellow: "#f1fa8c",
+    blue: "#729fcf",
+    magenta: "#ff79c6",
+    cyan: "#8be9fd",
+    white: "#ffffff",
+    orange: "#ffb86c",
+    purple: "#bd93f9",
+    pink: "#ff79c6",
+    brightRed: "#ff6e6e",
+    brightGreen: "#69ff94",
+    brightYellow: "#ffffa5",
+    brightBlue: "#d6acff",
+    brightMagenta: "#ff92df",
+    brightCyan: "#a4ffff",
+    brightWhite: "#ffffff",
+    brightBlack: "#6272a4"
+  },
+  buttons: {
+    close: "#ff5f57",
+    minimize: "#ffbd2e",
+    maximize: "#28ca42"
+  }
+};
+
+// src/themes/nord.ts
+var nord = {
+  name: "nord",
+  colors: {
+    text: "#d8dee9",
+    // Upstream Nord uses #4c566a (Polar Night 3) — visually invisible on the
+    // #2e3440 terminal background (~1.7:1). Lifted to a Polar Night / Snow Storm
+    // midpoint so [[fg:comment]] / [[dim]] text stays legible.
+    comment: "#7c8ba8",
+    background: "#2e3440",
+    titleBarBackground: "#3b4252",
+    titleBarText: "#d8dee9",
+    prompt: "#a3be8c",
+    cursor: "#88c0d0",
+    red: "#bf616a",
+    green: "#a3be8c",
+    yellow: "#ebcb8b",
+    blue: "#5e81ac",
+    magenta: "#b48ead",
+    cyan: "#88c0d0",
+    white: "#eceff4",
+    orange: "#d08770",
+    purple: "#b48ead",
+    pink: "#b48ead",
+    brightRed: "#bf616a",
+    brightGreen: "#a3be8c",
+    brightYellow: "#ebcb8b",
+    brightBlue: "#81a1c1",
+    brightMagenta: "#b48ead",
+    brightCyan: "#8fbcbb",
+    brightWhite: "#eceff4",
+    brightBlack: "#4c566a"
+  },
+  buttons: {
+    close: "#bf616a",
+    minimize: "#ebcb8b",
+    maximize: "#a3be8c"
+  }
+};
+
+// src/themes/monokai.ts
+var monokai = {
+  name: "monokai",
+  colors: {
+    text: "#f8f8f2",
+    comment: "#75715e",
+    background: "#272822",
+    titleBarBackground: "#1e1f1c",
+    // Quieter title text (canonical Monokai comment color) so the chrome
+    // reads differently from dracula at gallery-thumbnail size. Both themes
+    // ship with the same macOS chrome + similar warm-dark backgrounds; the
+    // title color is the cheapest place to differentiate.
+    titleBarText: "#75715e",
+    prompt: "#a6e22e",
+    cursor: "#f8f8f2",
+    red: "#f92672",
+    green: "#a6e22e",
+    yellow: "#e6db74",
+    blue: "#66d9ef",
+    magenta: "#ae81ff",
+    cyan: "#66d9ef",
+    white: "#f8f8f2",
+    orange: "#fd971f",
+    purple: "#ae81ff",
+    pink: "#f92672",
+    brightRed: "#f92672",
+    brightGreen: "#a6e22e",
+    brightYellow: "#e6db74",
+    brightBlue: "#66d9ef",
+    brightMagenta: "#ae81ff",
+    brightCyan: "#66d9ef",
+    brightWhite: "#f8f8f0",
+    brightBlack: "#75715e"
+  },
+  buttons: {
+    close: "#f92672",
+    minimize: "#e6db74",
+    maximize: "#a6e22e"
+  }
+};
+
+// src/themes/amber.ts
+var amber = {
+  name: "amber",
+  colors: {
+    text: "#ffb000",
+    comment: "#996600",
+    background: "#1a0f00",
+    titleBarBackground: "#2a1a00",
+    titleBarText: "#ffb000",
+    prompt: "#ffd700",
+    cursor: "#ffd700",
+    red: "#ff6600",
+    green: "#ffb000",
+    yellow: "#ffd700",
+    blue: "#cc8800",
+    magenta: "#ff8c00",
+    cyan: "#ffcc00",
+    white: "#ffe0a0",
+    orange: "#ff9900",
+    purple: "#cc7700",
+    pink: "#ff8c00",
+    brightRed: "#ff8800",
+    brightGreen: "#ffc000",
+    brightYellow: "#ffe000",
+    brightBlue: "#ddaa00",
+    brightMagenta: "#ffaa00",
+    brightCyan: "#ffdd00",
+    brightWhite: "#fff0c0",
+    brightBlack: "#664400"
+  },
+  // Canonical macOS triad (red/yellow/green) rather than amber-tinted dots.
+  // The monochrome version read as "decorative ornament" — viewers couldn't
+  // tell they were window controls. The triad is universal language.
+  buttons: {
+    close: "#ff5f57",
+    minimize: "#ffbd2e",
+    maximize: "#28ca42"
+  }
+};
+
+// src/themes/green-phosphor.ts
+var greenPhosphor = {
+  name: "green-phosphor",
+  colors: {
+    text: "#00ff41",
+    comment: "#008020",
+    background: "#001100",
+    titleBarBackground: "#002200",
+    titleBarText: "#00ff41",
+    prompt: "#33ff77",
+    cursor: "#33ff77",
+    red: "#00cc33",
+    green: "#00ff41",
+    yellow: "#66ff66",
+    blue: "#00cc66",
+    magenta: "#00ff88",
+    cyan: "#00ffaa",
+    white: "#aaffaa",
+    orange: "#33ff33",
+    purple: "#00dd55",
+    pink: "#00ff77",
+    brightRed: "#44ff44",
+    brightGreen: "#55ff77",
+    brightYellow: "#88ff88",
+    brightBlue: "#33dd88",
+    brightMagenta: "#44ffaa",
+    brightCyan: "#66ffcc",
+    brightWhite: "#ccffcc",
+    brightBlack: "#006600"
+  },
+  // Canonical macOS triad — same rationale as amber. Three slightly-
+  // different greens were unreadable as window controls.
+  buttons: {
+    close: "#ff5f57",
+    minimize: "#ffbd2e",
+    maximize: "#28ca42"
+  }
+};
+
+// src/themes/cyberpunk.ts
+var cyberpunk = {
+  name: "cyberpunk",
+  colors: {
+    text: "#e0e0ff",
+    comment: "#6060a0",
+    background: "#0a0014",
+    titleBarBackground: "#150028",
+    // Switched from canonical hot-pink #ff0080 to body text color. Saturated
+    // hot-pink on deep violet passes WCAG AA (~5.24:1) but visually buzzes
+    // (perceptual vibration on the saturated boundary). Body color reads as
+    // part of the chrome instead of a glow accent.
+    titleBarText: "#e0e0ff",
+    prompt: "#ff0080",
+    cursor: "#00ffff",
+    red: "#ff0055",
+    green: "#00ff88",
+    yellow: "#ffff00",
+    blue: "#0088ff",
+    magenta: "#ff00ff",
+    cyan: "#00ffff",
+    white: "#ffffff",
+    orange: "#ff8800",
+    purple: "#aa00ff",
+    pink: "#ff0080",
+    brightRed: "#ff3377",
+    brightGreen: "#33ffaa",
+    brightYellow: "#ffff55",
+    brightBlue: "#33aaff",
+    brightMagenta: "#ff55ff",
+    brightCyan: "#55ffff",
+    brightWhite: "#ffffff",
+    brightBlack: "#404060"
+  },
+  buttons: {
+    close: "#ff0055",
+    minimize: "#ffff00",
+    maximize: "#00ff88"
+  }
+};
+
+// src/themes/solarized-dark.ts
+var solarizedDark = {
+  name: "solarized-dark",
+  colors: {
+    text: "#839496",
+    // Solarized's canonical base01 (#586e75) fails WCAG AA on base03 by a
+    // wide margin (2.79:1; need 4.5). Lifted to a slightly brighter base01-ish
+    // value that clears AA while staying in the Solarized hue family.
+    comment: "#7d9499",
+    background: "#002b36",
+    titleBarBackground: "#073642",
+    titleBarText: "#93a1a1",
+    // Solarized's canonical blue (#268bd2) also fails AA on base03 (4.08:1).
+    // Lifted to a brighter Solarized-family blue.
+    prompt: "#4eb3e8",
+    cursor: "#2aa198",
+    red: "#dc322f",
+    green: "#859900",
+    yellow: "#b58900",
+    blue: "#268bd2",
+    magenta: "#d33682",
+    cyan: "#2aa198",
+    white: "#eee8d5",
+    orange: "#cb4b16",
+    purple: "#6c71c4",
+    pink: "#d33682",
+    brightRed: "#cb4b16",
+    brightGreen: "#859900",
+    brightYellow: "#b58900",
+    brightBlue: "#268bd2",
+    brightMagenta: "#6c71c4",
+    brightCyan: "#2aa198",
+    brightWhite: "#fdf6e3",
+    brightBlack: "#657b83"
+  },
+  buttons: {
+    close: "#dc322f",
+    minimize: "#b58900",
+    maximize: "#859900"
+  }
+};
+
+// src/themes/win95.ts
+var win95 = {
+  name: "win95",
+  colors: {
+    text: "#c0c0c0",
+    comment: "#808080",
+    background: "#000000",
+    titleBarBackground: "#000080",
+    titleBarText: "#ffffff",
+    prompt: "#c0c0c0",
+    cursor: "#ffffff",
+    red: "#ff0000",
+    green: "#00ff00",
+    yellow: "#ffff00",
+    blue: "#0000ff",
+    magenta: "#ff00ff",
+    cyan: "#00ffff",
+    white: "#ffffff",
+    orange: "#ff8800",
+    purple: "#8800ff",
+    pink: "#ff00ff",
+    brightRed: "#ff5555",
+    brightGreen: "#55ff55",
+    brightYellow: "#ffff55",
+    brightBlue: "#5555ff",
+    brightMagenta: "#ff55ff",
+    brightCyan: "#55ffff",
+    brightWhite: "#ffffff",
+    brightBlack: "#555555"
+  },
+  buttons: {
+    close: "#c0c0c0",
+    minimize: "#c0c0c0",
+    maximize: "#c0c0c0"
+  }
+};
+
+// src/themes/catppuccin.ts
+var catppuccin = {
+  name: "catppuccin",
+  colors: {
+    text: "#cdd6f4",
+    // Text
+    comment: "#9399b2",
+    // Overlay2 — lifted from canonical Surface2 (#585b70 = 3.0:1 on base) to clear AA
+    background: "#1e1e2e",
+    // Base
+    titleBarBackground: "#181825",
+    // Mantle
+    titleBarText: "#cdd6f4",
+    // Text
+    prompt: "#a6e3a1",
+    // Green
+    cursor: "#f5e0dc",
+    // Rosewater
+    red: "#f38ba8",
+    // Red
+    green: "#a6e3a1",
+    // Green
+    yellow: "#f9e2af",
+    // Yellow
+    blue: "#89b4fa",
+    // Blue
+    magenta: "#cba6f7",
+    // Mauve
+    cyan: "#94e2d5",
+    // Teal
+    white: "#bac2de",
+    // Subtext1
+    orange: "#fab387",
+    // Peach
+    purple: "#cba6f7",
+    // Mauve
+    pink: "#f5c2e7",
+    // Pink
+    brightRed: "#f38ba8",
+    brightGreen: "#a6e3a1",
+    brightYellow: "#f9e2af",
+    brightBlue: "#89b4fa",
+    brightMagenta: "#cba6f7",
+    brightCyan: "#94e2d5",
+    brightWhite: "#a6adc8",
+    // Subtext0
+    brightBlack: "#585b70"
+    // Surface2
+  },
+  buttons: {
+    close: "#f38ba8",
+    minimize: "#f9e2af",
+    maximize: "#a6e3a1"
+  }
+};
+
+// src/themes/tokyo-night.ts
+var tokyoNight = {
+  name: "tokyo-night",
+  colors: {
+    text: "#c0caf5",
+    comment: "#7986b7",
+    // Lifted from canonical #565f89 (~3.5:1) to clear AA on bg
+    background: "#1a1b26",
+    titleBarBackground: "#16161e",
+    titleBarText: "#c0caf5",
+    prompt: "#9ece6a",
+    // green
+    cursor: "#7aa2f7",
+    // blue
+    red: "#f7768e",
+    green: "#9ece6a",
+    yellow: "#e0af68",
+    blue: "#7aa2f7",
+    magenta: "#bb9af7",
+    cyan: "#7dcfff",
+    white: "#a9b1d6",
+    orange: "#ff9e64",
+    purple: "#bb9af7",
+    pink: "#f7768e",
+    brightRed: "#f7768e",
+    brightGreen: "#9ece6a",
+    brightYellow: "#e0af68",
+    brightBlue: "#7aa2f7",
+    brightMagenta: "#bb9af7",
+    brightCyan: "#7dcfff",
+    brightWhite: "#c0caf5",
+    brightBlack: "#414868"
+  },
+  buttons: {
+    close: "#f7768e",
+    minimize: "#e0af68",
+    maximize: "#9ece6a"
+  }
+};
+
+// src/themes/gruvbox.ts
+var gruvbox = {
+  name: "gruvbox",
+  colors: {
+    text: "#ebdbb2",
+    // fg
+    comment: "#a89984",
+    // gray (canonical) — passes AA (~4.9:1) on bg0
+    background: "#282828",
+    // bg0
+    titleBarBackground: "#1d2021",
+    // bg0_h (hard variant — slightly darker chrome)
+    titleBarText: "#ebdbb2",
+    prompt: "#b8bb26",
+    // bright_green
+    cursor: "#fabd2f",
+    // bright_yellow
+    red: "#cc241d",
+    // red
+    green: "#98971a",
+    // green
+    yellow: "#d79921",
+    // yellow
+    blue: "#458588",
+    // blue
+    magenta: "#b16286",
+    // purple
+    cyan: "#689d6a",
+    // aqua
+    white: "#a89984",
+    // gray
+    orange: "#d65d0e",
+    // orange
+    purple: "#b16286",
+    // purple
+    pink: "#fb4934",
+    // bright_red (closest to pink in the palette)
+    brightRed: "#fb4934",
+    brightGreen: "#b8bb26",
+    brightYellow: "#fabd2f",
+    brightBlue: "#83a598",
+    brightMagenta: "#d3869b",
+    brightCyan: "#8ec07c",
+    brightWhite: "#ebdbb2",
+    brightBlack: "#928374"
+  },
+  buttons: {
+    close: "#cc241d",
+    minimize: "#d79921",
+    maximize: "#98971a"
+  }
+};
+
+// src/themes/high-contrast.ts
+var highContrast = {
+  name: "high-contrast",
+  colors: {
+    text: "#ffffff",
+    comment: "#aaaaaa",
+    // 9.1:1 — clears AAA at the dim end
+    background: "#000000",
+    titleBarBackground: "#1a1a1a",
+    titleBarText: "#ffffff",
+    prompt: "#00ff00",
+    // 15.3:1
+    cursor: "#ffff00",
+    red: "#ff5555",
+    green: "#00ff00",
+    yellow: "#ffff00",
+    blue: "#aaaaff",
+    magenta: "#ff00ff",
+    cyan: "#00ffff",
+    white: "#ffffff",
+    orange: "#ffaa00",
+    purple: "#cc88ff",
+    pink: "#ff99cc",
+    brightRed: "#ff8888",
+    brightGreen: "#88ff88",
+    brightYellow: "#ffff88",
+    brightBlue: "#ccccff",
+    brightMagenta: "#ff88ff",
+    brightCyan: "#88ffff",
+    brightWhite: "#ffffff",
+    brightBlack: "#888888"
+    // 5.9:1 — explicitly the dimmest legible value
+  },
+  buttons: {
+    close: "#ff5555",
+    minimize: "#ffff00",
+    maximize: "#00ff00"
+  }
+};
+
+// src/themes/index.ts
+var themes = {
+  dracula,
+  nord,
+  monokai,
+  amber,
+  "green-phosphor": greenPhosphor,
+  cyberpunk,
+  "solarized-dark": solarizedDark,
+  win95,
+  catppuccin,
+  "tokyo-night": tokyoNight,
+  gruvbox,
+  "high-contrast": highContrast
+};
+var customThemes = /* @__PURE__ */ new Map();
+function registerTheme(theme) {
+  if (theme.name === "random") {
+    throw new Error(
+      `"random" is a reserved theme name (it triggers the daily-rotation behavior). Pick a different name for your custom theme.`
+    );
+  }
+  customThemes.set(theme.name, theme);
+}
+function getTheme(name) {
+  return customThemes.get(name) ?? themes[name];
+}
+function listThemes() {
+  const names = new Set(customThemes.keys());
+  for (const name of Object.keys(themes)) names.add(name);
+  return Array.from(names);
+}
+var THEME_NAMES = Object.keys(themes);
+function resolveTheme(nameOrTheme) {
+  if (typeof nameOrTheme === "object") {
+    return nameOrTheme;
+  }
+  if (nameOrTheme === "random") {
+    const names = listThemes();
+    const dayOfYear = Math.floor(
+      (Date.now() - new Date((/* @__PURE__ */ new Date()).getFullYear(), 0, 0).getTime()) / 864e5
+    );
+    const idx = dayOfYear % names.length;
+    const selected = names[idx];
+    if (process.env.SVG_TERMINAL_VERBOSE) {
+      console.error(`[svg-terminal] Theme rotation: day ${dayOfYear} \u2192 ${selected}`);
+    }
+    return getTheme(selected);
+  }
+  const theme = getTheme(nameOrTheme);
+  if (!theme) {
+    const available = listThemes().join(", ");
+    throw new Error(`Unknown theme "${nameOrTheme}". Available: ${available}, random`);
+  }
+  return theme;
+}
+
+// src/blocks/registry.ts
+var registry = /* @__PURE__ */ new Map();
+function registerBlock(block) {
+  registry.set(block.name, block);
+}
+function getBlock(name) {
+  return registry.get(name);
+}
+function listBlocks() {
+  return Array.from(registry.keys());
+}
+function registerBlocks(blocks) {
+  for (const block of blocks) {
+    registerBlock(block);
+  }
+}
+
+// src/core/defaults.ts
+var DEFAULT_WINDOW = {
+  width: 1e3,
+  height: 560,
+  borderRadius: 12,
+  titleBarHeight: 40,
+  title: "user@terminal:~",
+  style: "macos",
+  autoHeight: false,
+  minHeight: 300,
+  maxHeight: 1200
+};
+var DEFAULT_TERMINAL = {
+  fontFamily: "JetBrains Mono, Fira Code, Ubuntu Mono, Consolas, Monaco, monospace",
+  fontSize: 14,
+  lineHeight: 1.8,
+  padding: 12,
+  paddingTop: 14,
+  prompt: "user@host:~$ "
+};
+var DEFAULT_EFFECTS = {
+  textGlow: false,
+  shadow: true,
+  scanlines: true,
+  vignette: false
+};
+var DEFAULT_ANIMATION = {
+  cursorBlinkCycle: 1e3,
+  charAppearDuration: 10,
+  outputLineStagger: 50,
+  commandOutputPause: 300,
+  scrollDelay: 10,
+  outputEndPause: 200,
+  defaultTypingDuration: 2e3,
+  defaultSequencePause: 1e3,
+  loop: true
+};
+var DEFAULT_ACCESSIBILITY = {
+  describe: true
+};
+var DEFAULT_CHROME = {
+  titleFontFamily: "-apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif",
+  titleFontSize: 13,
+  buttonRadius: 6,
+  buttonSpacing: 20,
+  dimOpacity: 0.6,
+  buttonY: 16
+};
+var DEFAULT_CONFIG = {
+  window: DEFAULT_WINDOW,
+  text: DEFAULT_TERMINAL,
+  theme: dracula,
+  effects: DEFAULT_EFFECTS,
+  animation: DEFAULT_ANIMATION,
+  chrome: DEFAULT_CHROME,
+  accessibility: DEFAULT_ACCESSIBILITY,
+  maxDuration: 90,
+  scrollDuration: 100,
+  fetchTimeout: 1e4,
+  cacheTTL: 86400,
+  cachePath: ".svg-terminal-cache.json"
+};
+var CHAR_WIDTH_RATIO = 0.6;
+function getMaxColumns(windowWidth, fontSize, padding) {
+  const contentWidth = windowWidth - padding * 2;
+  const charWidth = fontSize * CHAR_WIDTH_RATIO;
+  return Math.floor(contentWidth / charWidth);
+}
+function getDefaultBoxWidth(maxCols) {
+  return Math.min(maxCols - 4, 90);
+}
+var CURSOR_Y_OFFSET_RATIO = -0.85;
+var SHADOW_PARAMS = { dy: 6, blur: 8, opacity: 0.55 };
+var SCANLINE_PARAMS = { height: 2, opacity: 0.02 };
+var SCROLL_ANIM_DURATION = 100;
+var TYPING_PRESETS = {
+  instant: 400,
+  fast: 500,
+  quick: 800,
+  medium: 1200,
+  standard: 1400,
+  slow: 1800,
+  long: 2200
+};
+var PAUSE_PRESETS = {
+  minimal: 300,
+  short: 500,
+  quick: 600,
+  medium: 800,
+  standard: 1e3,
+  long: 1400,
+  dramatic: 1800,
+  showcase: 2800
+};
+function resolveTyping(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") return TYPING_PRESETS[value] ?? 1200;
+  return 1200;
+}
+function resolvePause(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") return PAUSE_PRESETS[value] ?? 1e3;
+  return 1e3;
+}
+function resolveBoxWidth(configWidth, context) {
+  if (configWidth !== void 0) return configWidth;
+  const { width } = context.config.window;
+  const { fontSize, padding } = context.config.text;
+  return getDefaultBoxWidth(getMaxColumns(width, fontSize, padding));
+}
+
+// src/core/schema.ts
+import { z } from "zod";
+var HEX_COLOR_RE = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
+var THEME_COLOR_NAMES = /* @__PURE__ */ new Set([
+  "red",
+  "green",
+  "yellow",
+  "blue",
+  "magenta",
+  "cyan",
+  "white",
+  "orange",
+  "purple",
+  "pink",
+  "brightRed",
+  "brightGreen",
+  "brightYellow",
+  "brightBlue",
+  "brightMagenta",
+  "brightCyan",
+  "brightWhite",
+  "brightBlack",
+  "text",
+  "comment",
+  "background",
+  "prompt",
+  "cursor",
+  "titleBarBackground",
+  "titleBarText"
+]);
+var ColorRefSchema = z.string().refine(
+  (v) => HEX_COLOR_RE.test(v) || THEME_COLOR_NAMES.has(v),
+  { message: 'color must be a hex string (#abc / #aabbcc) or a theme palette name (e.g. "cyan", "comment")' }
+);
+var FontFamilySchema = z.string().refine(
+  (v) => /^[A-Za-z0-9 ,'"\-_]+$/.test(v) && !/[<>;{}]/.test(v),
+  { message: "fontFamily must contain only letters, digits, spaces, commas, quotes, hyphens, underscores" }
+);
+var BlockEntrySchema = z.object({
+  block: z.string().min(1, "Block name is required"),
+  config: z.record(z.string(), z.unknown()).optional(),
+  command: z.string().optional(),
+  color: ColorRefSchema.optional(),
+  typing: z.string().optional(),
+  pause: z.string().optional()
+});
+var InlineThemeColorsSchema = z.object({
+  text: ColorRefSchema,
+  comment: ColorRefSchema,
+  background: ColorRefSchema,
+  titleBarBackground: ColorRefSchema,
+  titleBarText: ColorRefSchema,
+  prompt: ColorRefSchema,
+  cursor: ColorRefSchema,
+  red: ColorRefSchema,
+  green: ColorRefSchema,
+  yellow: ColorRefSchema,
+  blue: ColorRefSchema,
+  magenta: ColorRefSchema,
+  cyan: ColorRefSchema,
+  white: ColorRefSchema,
+  orange: ColorRefSchema,
+  purple: ColorRefSchema,
+  pink: ColorRefSchema,
+  brightRed: ColorRefSchema,
+  brightGreen: ColorRefSchema,
+  brightYellow: ColorRefSchema,
+  brightBlue: ColorRefSchema,
+  brightMagenta: ColorRefSchema,
+  brightCyan: ColorRefSchema,
+  brightWhite: ColorRefSchema,
+  brightBlack: ColorRefSchema
+}).strict();
+var InlineThemeSchema = z.object({
+  name: z.string().min(1),
+  colors: InlineThemeColorsSchema,
+  buttons: z.object({
+    close: ColorRefSchema,
+    minimize: ColorRefSchema,
+    maximize: ColorRefSchema
+  }).strict()
+}).strict();
+var WindowSchema = z.object({
+  width: z.number().positive("width must be positive").optional(),
+  height: z.number().positive("height must be positive").optional(),
+  borderRadius: z.number().min(0).optional(),
+  titleBarHeight: z.number().positive().optional(),
+  title: z.string().optional(),
+  style: z.enum(["macos", "win95", "floating", "minimal", "none"]).optional(),
+  autoHeight: z.boolean().optional(),
+  minHeight: z.number().positive().optional(),
+  maxHeight: z.number().positive().optional()
+}).strict().optional();
+var TerminalSchema = z.object({
+  fontFamily: FontFamilySchema.optional(),
+  fontSize: z.number().positive("fontSize must be positive").optional(),
+  lineHeight: z.number().positive("lineHeight must be positive").optional(),
+  padding: z.number().min(0).optional(),
+  paddingTop: z.number().min(0).optional(),
+  prompt: z.string().optional()
+}).strict().optional();
+var EffectsSchema = z.object({
+  textGlow: z.boolean().optional(),
+  shadow: z.boolean().optional(),
+  scanlines: z.boolean().optional(),
+  vignette: z.boolean().optional()
+}).strict().optional();
+var AnimationSchema = z.object({
+  cursorBlinkCycle: z.number().positive("cursorBlinkCycle must be positive").optional(),
+  charAppearDuration: z.number().positive("charAppearDuration must be positive").optional(),
+  outputLineStagger: z.number().min(0).optional(),
+  commandOutputPause: z.number().min(0).optional(),
+  scrollDelay: z.number().min(0).optional(),
+  outputEndPause: z.number().min(0).optional(),
+  defaultTypingDuration: z.number().positive().optional(),
+  defaultSequencePause: z.number().min(0).optional(),
+  loop: z.union([z.boolean(), z.number().int().positive()]).optional()
+}).strict().optional();
+var AccessibilitySchema = z.object({
+  describe: z.boolean().optional()
+}).strict().optional();
+var ChromeSchema = z.object({
+  titleFontFamily: FontFamilySchema.optional(),
+  titleFontSize: z.number().positive("titleFontSize must be positive").optional(),
+  buttonRadius: z.number().min(0).optional(),
+  buttonSpacing: z.number().positive().optional(),
+  dimOpacity: z.number().min(0).max(1, "dimOpacity must be between 0 and 1").optional(),
+  buttonY: z.number().min(0).optional()
+}).strict().optional();
+var UserConfigSchema = z.object({
+  theme: z.union([z.string(), InlineThemeSchema]).optional(),
+  window: WindowSchema,
+  terminal: TerminalSchema,
+  effects: EffectsSchema,
+  animation: AnimationSchema,
+  chrome: ChromeSchema,
+  accessibility: AccessibilitySchema,
+  blocks: z.array(BlockEntrySchema).min(1, "At least one block is required"),
+  variables: z.record(z.string(), z.unknown()).optional(),
+  maxDuration: z.number().positive().optional(),
+  scrollDuration: z.number().positive().optional(),
+  accessibilityLabel: z.string().optional(),
+  fetchTimeout: z.number().positive().optional(),
+  cacheTTL: z.number().int().min(0, "cacheTTL must be \u2265 0").optional(),
+  cachePath: z.string().min(1).optional()
+}).strict();
+function validateConfig(raw) {
+  return UserConfigSchema.parse(raw);
+}
+
+// src/core/errors.ts
+var ConfigError = class extends Error {
+  /** Pre-formatted multi-line message ready for stderr. */
+  formatted;
+  constructor(formatted) {
+    super(formatted);
+    this.name = "ConfigError";
+    this.formatted = formatted;
+  }
+};
+var BlockConfigError = class extends Error {
+  formatted;
+  blockName;
+  entryIndex;
+  constructor(blockName, entryIndex, formatted) {
+    super(formatted);
+    this.name = "BlockConfigError";
+    this.formatted = formatted;
+    this.blockName = blockName;
+    this.entryIndex = entryIndex;
+  }
+};
+
+// src/core/config.ts
+async function loadConfig(filePath) {
+  let raw;
+  try {
+    raw = readFileSync(filePath, "utf-8");
+  } catch (err) {
+    throw new ConfigError(`Cannot read config file: ${filePath}
+  ${err.message}`);
+  }
+  const { default: yaml } = await import("js-yaml");
+  let parsed;
+  try {
+    parsed = yaml.load(raw);
+  } catch (err) {
+    const e = err;
+    const where = e.mark ? `:${e.mark.line + 1}:${e.mark.column + 1}` : "";
+    throw new ConfigError(`YAML parse error in ${filePath}${where}
+  ${e.message}`);
+  }
+  let config;
+  try {
+    config = validateConfig(parsed);
+  } catch (err) {
+    if (err instanceof z2.ZodError) {
+      const issues = err.issues.map((i) => {
+        const path = i.path.length ? i.path.join(".") : "<root>";
+        return `  ${path}: ${i.message}`;
+      }).join("\n");
+      throw new ConfigError(`Invalid config in ${filePath}:
+${issues}${hintForIssues(err)}`);
+    }
+    throw err;
+  }
+  validateNames(config, filePath);
+  return config;
+}
+function hintForIssues(err) {
+  const hints = [];
+  for (const issue of err.issues) {
+    if (issue.path[0] === "accessibility" && issue.path.length === 1) {
+      hints.push("  hint: to disable accessibility descriptions, use `accessibility: { describe: false }` (not a boolean).");
+    }
+    if (issue.code === "unrecognized_keys") {
+      const pathKey = issue.path.length === 0 ? "<root>" : issue.path.join(".");
+      const known = KNOWN_KEYS[pathKey];
+      const unknown = issue.keys ?? [];
+      if (known) {
+        for (const key of unknown) {
+          const suggestion = closestKey(key, known);
+          if (suggestion) {
+            const where = pathKey === "<root>" ? "" : ` at ${pathKey}`;
+            hints.push(`  hint: unknown key "${key}"${where} \u2014 did you mean "${suggestion}"?`);
+          }
+        }
+      }
+    }
+  }
+  return hints.length > 0 ? "\n" + hints.join("\n") : "";
+}
+var KNOWN_KEYS = {
+  "<root>": ["theme", "window", "terminal", "effects", "animation", "chrome", "accessibility", "blocks", "variables", "maxDuration", "scrollDuration", "accessibilityLabel", "fetchTimeout", "cacheTTL", "cachePath"],
+  window: ["width", "height", "borderRadius", "titleBarHeight", "title", "style", "autoHeight", "minHeight", "maxHeight"],
+  terminal: ["fontFamily", "fontSize", "lineHeight", "padding", "paddingTop", "prompt"],
+  effects: ["textGlow", "shadow", "scanlines", "vignette"],
+  animation: ["cursorBlinkCycle", "charAppearDuration", "outputLineStagger", "commandOutputPause", "scrollDelay", "outputEndPause", "defaultTypingDuration", "defaultSequencePause", "loop"],
+  chrome: ["titleFontFamily", "titleFontSize", "buttonRadius", "buttonSpacing", "dimOpacity", "buttonY"],
+  accessibility: ["describe"]
+};
+function closestKey(input, candidates) {
+  const maxDist = input.length <= 3 ? 1 : 2;
+  let best = null;
+  for (const c of candidates) {
+    const d = levenshtein(input.toLowerCase(), c.toLowerCase());
+    if (d <= maxDist && (best === null || d < best.dist)) {
+      best = { name: c, dist: d };
+    }
+  }
+  return best?.name ?? null;
+}
+function levenshtein(a, b) {
+  if (a === b) return 0;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  let curr = new Array(b.length + 1);
+  for (let i = 1; i <= a.length; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[b.length];
+}
+function validateNames(config, filePath) {
+  if (typeof config.theme === "string") {
+    if (config.theme !== "random" && !getTheme(config.theme)) {
+      const available = listThemes().join(", ");
+      throw new ConfigError(
+        `Unknown theme "${config.theme}" in ${filePath}
+  Available: ${available}, random`
+      );
+    }
+  } else if (config.theme && typeof config.theme === "object" && config.theme.name === "random") {
+    throw new ConfigError(
+      `Inline theme uses the reserved name "random" in ${filePath}
+  "random" triggers daily rotation; pick a different name for your inline theme.`
+    );
+  }
+  for (let i = 0; i < config.blocks.length; i++) {
+    const entry = config.blocks[i];
+    if (!entry) continue;
+    if (!getBlock(entry.block)) {
+      throw new ConfigError(
+        `Unknown block "${entry.block}" at blocks[${i}] in ${filePath}
+  Run "svg-terminal blocks" to list available block types.`
+      );
+    }
+  }
+}
+function mergeConfig(userConfig) {
+  const theme = resolveTheme(userConfig.theme ?? "dracula");
+  const isWin95 = theme.name === "win95";
+  const autoStyle = isWin95 && !userConfig.window?.style ? "win95" : void 0;
+  const autoTitleBarHeight = isWin95 && userConfig.window?.titleBarHeight === void 0 ? 22 : void 0;
+  const isCrt = theme.name === "amber" || theme.name === "green-phosphor" || theme.name === "cyberpunk";
+  const userVignetteSet = userConfig.effects?.vignette !== void 0;
+  const autoEffects = isWin95 && !userConfig.effects ? { textGlow: false, scanlines: false, shadow: true } : isCrt && !userVignetteSet ? { vignette: true } : void 0;
+  return {
+    window: {
+      ...DEFAULT_WINDOW,
+      ...userConfig.window,
+      ...autoStyle ? { style: autoStyle } : {},
+      ...autoTitleBarHeight !== void 0 ? { titleBarHeight: autoTitleBarHeight } : {}
+    },
+    text: {
+      ...DEFAULT_TERMINAL,
+      ...userConfig.terminal
+    },
+    theme,
+    effects: {
+      ...DEFAULT_EFFECTS,
+      ...autoEffects ?? {},
+      ...userConfig.effects
+    },
+    animation: {
+      ...DEFAULT_ANIMATION,
+      ...userConfig.animation
+    },
+    chrome: {
+      ...DEFAULT_CHROME,
+      ...userConfig.chrome
+    },
+    accessibility: {
+      ...DEFAULT_ACCESSIBILITY,
+      ...userConfig.accessibility
+    },
+    maxDuration: userConfig.maxDuration ?? DEFAULT_CONFIG.maxDuration,
+    scrollDuration: userConfig.scrollDuration ?? DEFAULT_CONFIG.scrollDuration,
+    fetchTimeout: userConfig.fetchTimeout ?? DEFAULT_CONFIG.fetchTimeout,
+    cacheTTL: userConfig.cacheTTL ?? DEFAULT_CONFIG.cacheTTL,
+    cachePath: userConfig.cachePath ?? DEFAULT_CONFIG.cachePath,
+    // Optional aria-label override (#97). Unset means the auto-generated
+    // command-summary / line-count label wins downstream.
+    accessibilityLabel: userConfig.accessibilityLabel
+  };
+}
+
+// src/core/effects.ts
+function generateDefs(effects, windowStyle) {
+  const parts = [];
+  if (effects.scanlines) {
+    parts.push(`
+    <pattern id="scanlines" patternUnits="userSpaceOnUse" width="1" height="${SCANLINE_PARAMS.height}">
+      <rect width="1" height="1" fill="transparent"/>
+      <rect y="1" width="1" height="1" fill="rgba(255,255,255,${SCANLINE_PARAMS.opacity})"/>
+    </pattern>`);
+  }
+  if (windowStyle === "win95") {
+    parts.push(`
+    <linearGradient id="win95Caption" x1="0" y1="0" x2="1" y2="0">
+      <stop offset="0" stop-color="#000080"/>
+      <stop offset="1" stop-color="#1084d0"/>
+    </linearGradient>`);
+  }
+  if (effects.vignette) {
+    parts.push(`
+    <radialGradient id="vignette" cx="50%" cy="50%" r="75%">
+      <stop offset="0%" stop-color="black" stop-opacity="0"/>
+      <stop offset="60%" stop-color="black" stop-opacity="0"/>
+      <stop offset="100%" stop-color="black" stop-opacity="0.25"/>
+    </radialGradient>`);
+  }
+  return parts.join("\n");
+}
+function generateFilters(effects, _glowColor) {
+  const parts = [];
+  if (effects.textGlow) {
+    parts.push(`
+    <filter id="textGlow" x="-10%" y="-10%" width="120%" height="120%">
+      <feGaussianBlur in="SourceGraphic" stdDeviation="0.6" result="core"/>
+      <feGaussianBlur in="SourceGraphic" stdDeviation="2" result="halo"/>
+      <feMerge>
+        <feMergeNode in="halo"/>
+        <feMergeNode in="core"/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>`);
+  }
+  if (effects.shadow) {
+    parts.push(`
+    <filter id="shadow" x="-8%" y="-8%" width="116%" height="120%">
+      <feGaussianBlur in="SourceAlpha" stdDeviation="${SHADOW_PARAMS.blur}"/>
+      <feOffset dx="0" dy="${SHADOW_PARAMS.dy}" result="offsetblur"/>
+      <feFlood flood-color="#000000" flood-opacity="${SHADOW_PARAMS.opacity}"/>
+      <feComposite in2="offsetblur" operator="in"/>
+      <feMerge>
+        <feMergeNode/>
+        <feMergeNode in="SourceGraphic"/>
+      </feMerge>
+    </filter>`);
+  }
+  return parts.join("\n");
+}
+
+// src/core/markup-parser.ts
+function buildColorMap(colors) {
+  return {
+    // Standard terminal colors — black uses theme background
+    black: colors.background,
+    red: colors.red,
+    green: colors.green,
+    yellow: colors.yellow,
+    blue: colors.blue,
+    magenta: colors.magenta,
+    cyan: colors.cyan,
+    white: colors.white,
+    // Bright variants
+    bright_black: colors.brightBlack,
+    bright_red: colors.brightRed,
+    bright_green: colors.brightGreen,
+    bright_yellow: colors.brightYellow,
+    bright_blue: colors.brightBlue,
+    bright_magenta: colors.brightMagenta,
+    bright_cyan: colors.brightCyan,
+    bright_white: colors.brightWhite,
+    // Extended
+    purple: colors.purple,
+    pink: colors.pink,
+    orange: colors.orange,
+    comment: colors.comment,
+    neon_green: colors.prompt,
+    matrix_green: colors.cursor
+  };
+}
+var HEX_COLOR_RE2 = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
+function resolveColor(colorName, colorMap, fallback) {
+  if (colorName.startsWith("#")) {
+    return HEX_COLOR_RE2.test(colorName) ? colorName : fallback;
+  }
+  return colorMap[colorName.toLowerCase()] ?? fallback;
+}
+function parseMarkup(text, colorMap, fallbackColor) {
+  if (!text) {
+    return [{ text: "", fg: null, bg: null, bold: false, dim: false }];
+  }
+  if (!text.includes("[[")) {
+    return [{ text, fg: null, bg: null, bold: false, dim: false }];
+  }
+  const spans = [];
+  let pos = 0;
+  let currentStyle = { fg: null, bg: null, bold: false, dim: false };
+  const styleStack = [];
+  while (pos < text.length) {
+    const openStart = text.indexOf("[[", pos);
+    if (openStart === -1) {
+      const remaining = text.slice(pos);
+      if (remaining) spans.push({ text: remaining, ...currentStyle });
+      break;
+    }
+    if (openStart > pos) {
+      spans.push({ text: text.slice(pos, openStart), ...currentStyle });
+    }
+    const openEnd = text.indexOf("]]", openStart);
+    if (openEnd === -1) {
+      spans.push({ text: text.slice(openStart), ...currentStyle });
+      break;
+    }
+    const tag = text.slice(openStart + 2, openEnd);
+    pos = openEnd + 2;
+    if (tag.startsWith("/")) {
+      if (styleStack.length > 0) {
+        currentStyle = { ...styleStack.pop() };
+      }
+    } else {
+      styleStack.push({ ...currentStyle });
+      if (tag === "bold") {
+        currentStyle.bold = true;
+      } else if (tag === "dim") {
+        currentStyle.dim = true;
+      } else if (tag.startsWith("fg:")) {
+        currentStyle.fg = resolveColor(tag.slice(3), colorMap, fallbackColor);
+      } else if (tag.startsWith("bg:")) {
+        currentStyle.bg = resolveColor(tag.slice(3), colorMap, fallbackColor);
+      }
+    }
+  }
+  return mergeSpans(spans);
+}
+function mergeSpans(spans) {
+  if (spans.length <= 1) return spans;
+  const merged = [];
+  let current = { ...spans[0] };
+  for (let i = 1; i < spans.length; i++) {
+    const next = spans[i];
+    if (current.fg === next.fg && current.bg === next.bg && current.bold === next.bold && current.dim === next.dim) {
+      current.text += next.text;
+    } else {
+      if (current.text) merged.push(current);
+      current = { ...next };
+    }
+  }
+  if (current.text) merged.push(current);
+  return merged;
+}
+function hasMarkup(text) {
+  return typeof text === "string" && text.includes("[[");
+}
+function stripMarkup(text) {
+  if (!text) return "";
+  return text.replace(/\[\[[^\]]{1,256}\]\]/g, "");
+}
+
+// src/core/xml.ts
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function roundCoord(value, decimals = 0) {
+  if (decimals === 0) return Math.round(value);
+  const factor = 10 ** decimals;
+  return Math.round(value * factor) / factor;
+}
+function getTextWidth(text, fontSize) {
+  return roundCoord(text.length * (fontSize * 0.6));
+}
+
+// src/core/line-renderer.ts
+function setHold(attr, value, untilMs) {
+  if (untilMs <= 0) return "";
+  return `<set attributeName="${attr}" to="${value}" begin="0s" end="${untilMs}ms"/>`;
+}
+function fadeInStyle(startTimeMs) {
+  return ` class="fade-in" style="animation-delay: ${startTimeMs}ms"`;
+}
+function roundLineY(n) {
+  return +n.toFixed(1);
+}
+function generateStyledText(spans, defaultColor, dimOpacity) {
+  return spans.map((span) => {
+    const color = span.fg ?? defaultColor;
+    const attrs = [`fill="${escapeXml(color)}"`];
+    if (span.bold) attrs.push('font-weight="bold"');
+    if (span.dim) attrs.push(`opacity="${dimOpacity}"`);
+    return `<tspan ${attrs.join(" ")}>${escapeXml(span.text)}</tspan>`;
+  }).join("");
+}
+function generateCursor(prompt, command, startTime, typingDuration, terminal, cursorColor, _cursorBlinkCycle, charAppearDuration) {
+  const promptWidth = getTextWidth(prompt, terminal.fontSize);
+  const charWidth = roundCoord(terminal.fontSize * CHAR_WIDTH_RATIO);
+  const cursorY = roundCoord(terminal.fontSize * CURSOR_Y_OFFSET_RATIO);
+  const typingEndTime = startTime + typingDuration;
+  const moveAnim = command.length > 0 ? buildCursorWalk(command.length, promptWidth, charWidth, startTime, typingDuration) : "";
+  return `
+    <rect x="${promptWidth}" y="${cursorY}" width="${charWidth}" height="${terminal.fontSize}"
+          fill="${escapeXml(cursorColor)}" opacity="0">
+      <animate attributeName="opacity" from="0" to="1" begin="${startTime}ms" dur="${charAppearDuration}ms" fill="freeze"/>
+      <animate attributeName="opacity" to="0" begin="${typingEndTime}ms" dur="${charAppearDuration}ms" fill="freeze"/>
+      ${moveAnim}
+    </rect>`;
+}
+function buildCursorWalk(charCount, promptWidth, charWidth, startTime, typingDuration) {
+  const values = [];
+  const keyTimes = [];
+  for (let i = 0; i <= charCount; i++) {
+    const col = Math.max(0, i - 1);
+    values.push(String(roundCoord(promptWidth + col * charWidth)));
+    keyTimes.push((i / charCount).toFixed(4));
+  }
+  return `<animate attributeName="x" values="${values.join(";")}" keyTimes="${keyTimes.join(";")}" calcMode="discrete" begin="${startTime}ms" dur="${typingDuration}ms" fill="freeze"/>`;
+}
+function generateCommandLine(lineIndex, y, prompt, command, startTime, typingDuration, terminal, promptColor, cursorColor, cursorBlinkCycle, charAppearDuration) {
+  const promptWidth = getTextWidth(prompt, terminal.fontSize);
+  const charWidth = roundCoord(terminal.fontSize * CHAR_WIDTH_RATIO);
+  const clipId = `cmdrev-${lineIndex}`;
+  const revealClip = command.length > 0 ? buildRevealClip(clipId, promptWidth, charWidth, command.length, terminal.fontSize, startTime, typingDuration) : "";
+  const cmdWidth = command.length * charWidth;
+  return `
+    <g transform="translate(0, ${y})">
+      ${revealClip}
+      <text class="tt fade-in" style="animation-delay: ${startTime}ms" fill="${escapeXml(promptColor)}" textLength="${promptWidth}" lengthAdjust="spacingAndGlyphs">${escapeXml(prompt)}</text>
+      <text class="tt" x="${promptWidth}" fill="${escapeXml(promptColor)}"${command.length > 0 ? ` textLength="${cmdWidth}" lengthAdjust="spacingAndGlyphs" clip-path="url(#${clipId})"` : ""}>${escapeXml(command)}</text>
+      ${generateCursor(prompt, command, startTime, typingDuration, terminal, cursorColor, cursorBlinkCycle, charAppearDuration)}
+    </g>`;
+}
+function buildRevealClip(clipId, startX, charWidth, charCount, fontSize, startTime, typingDuration) {
+  const values = [];
+  const keyTimes = [];
+  for (let i = 0; i <= charCount; i++) {
+    values.push(String(roundCoord(i * charWidth)));
+    keyTimes.push((i / charCount).toFixed(4));
+  }
+  const finalWidth = roundCoord(charCount * charWidth);
+  return `<defs><clipPath id="${clipId}"><rect x="${startX}" y="${-fontSize}" width="${finalWidth}" height="${fontSize * 2}">${setHold("width", 0, startTime)}<animate attributeName="width" values="${values.join(";")}" keyTimes="${keyTimes.join(";")}" calcMode="discrete" begin="${startTime}ms" dur="${typingDuration}ms" fill="freeze"/></rect></clipPath></defs>`;
+}
+function generateAnimatedOutputLine(y, frames, color, startTime, colorMap, chrome, fps, loop) {
+  const n = frames.length;
+  const frameDurMs = 1e3 / fps;
+  const cycleMs = Math.round(n * frameDurMs);
+  const iter = loop ? "infinite" : "1";
+  const textElements = frames.map((frame, i) => {
+    const styled = hasMarkup(frame);
+    const textContent = styled ? generateStyledText(parseMarkup(frame, colorMap, color), color, chrome.dimOpacity) : escapeXml(frame);
+    const textFill = styled ? "" : ` fill="${escapeXml(color)}"`;
+    const delayMs = Math.round(i * frameDurMs);
+    const anim = `animation: frame-cycle-${n} ${cycleMs}ms linear ${delayMs}ms ${iter}`;
+    return `<text class="tt frame-cycle-${n}"${textFill} opacity="${i === 0 ? "1" : "0"}" style="${anim}">${textContent}</text>`;
+  }).join("");
+  return `
+    <g transform="translate(0, ${y})"${fadeInStyle(startTime)}>
+      ${textElements}
+    </g>`;
+}
+function generateOutputLine(y, content, color, startTime, colorMap, chrome, pinWidth, fontSize) {
+  const styled = hasMarkup(content);
+  const textContent = styled ? generateStyledText(parseMarkup(content, colorMap, color), color, chrome.dimOpacity) : escapeXml(content);
+  const textFill = styled ? "" : ` fill="${escapeXml(color)}"`;
+  const pin = pinWidth && !styled && content.length > 0 ? ` textLength="${content.length * roundCoord(fontSize * CHAR_WIDTH_RATIO)}" lengthAdjust="spacingAndGlyphs"` : "";
+  return `
+    <g transform="translate(0, ${y})"${fadeInStyle(startTime)}>
+      <text class="tt"${textFill}${pin}>
+        ${textContent}
+      </text>
+    </g>`;
+}
+function generateAllLines(frames, terminal, lineHeight, colors, chrome, animation) {
+  const chromeConfig = chrome ?? DEFAULT_CHROME;
+  const animConfig = animation ?? DEFAULT_ANIMATION;
+  const colorMap = buildColorMap(colors);
+  const processedLines = /* @__PURE__ */ new Map();
+  for (const frame of frames) {
+    if (frame.type === "add-command" && frame.lineIndex !== void 0) {
+      const y = roundLineY(frame.lineIndex * lineHeight);
+      processedLines.set(
+        frame.lineIndex,
+        generateCommandLine(
+          frame.lineIndex,
+          y,
+          frame.prompt ?? terminal.prompt,
+          frame.command ?? "",
+          frame.time,
+          frame.typingDuration ?? animConfig.defaultTypingDuration,
+          terminal,
+          colors.prompt,
+          colors.cursor,
+          animConfig.cursorBlinkCycle,
+          animConfig.charAppearDuration
+        )
+      );
+    } else if (frame.type === "add-output" && frame.lineIndex !== void 0) {
+      const y = roundLineY(frame.lineIndex * lineHeight);
+      if (frame.frames && frame.frames.length > 0) {
+        processedLines.set(
+          frame.lineIndex,
+          generateAnimatedOutputLine(
+            y,
+            frame.frames,
+            frame.color ?? colors.text,
+            frame.time,
+            colorMap,
+            chromeConfig,
+            frame.framesFps ?? 4,
+            frame.framesLoop ?? true
+          )
+        );
+      } else {
+        processedLines.set(
+          frame.lineIndex,
+          generateOutputLine(
+            y,
+            frame.content ?? "",
+            frame.color ?? colors.text,
+            frame.time,
+            colorMap,
+            chromeConfig,
+            frame.pinWidth ?? false,
+            terminal.fontSize
+          )
+        );
+      }
+    }
+  }
+  return Array.from(processedLines.entries()).sort((a, b) => a[0] - b[0]).map(([, content]) => content).join("\n");
+}
+
+// src/core/svg-generator.ts
+function countTotalLines(sequences) {
+  let total = 0;
+  for (const seq of sequences) {
+    if (seq.type === "command") {
+      total += 1;
+    } else {
+      total += seq.content.split("\n").length;
+    }
+  }
+  return total;
+}
+function calculateAutoHeight(sequences, window, terminal) {
+  const lineHeight = terminal.fontSize * terminal.lineHeight;
+  const totalLines = countTotalLines(sequences);
+  const contentHeight = totalLines * lineHeight;
+  const chromeHeight = window.titleBarHeight + terminal.paddingTop + terminal.padding * 2;
+  const calculated = Math.ceil(contentHeight + chromeHeight);
+  return Math.max(window.minHeight, Math.min(window.maxHeight, calculated));
+}
+function generateSvg(sequences, config) {
+  const { text: terminal, theme, effects, animation, chrome } = config;
+  const window = { ...config.window };
+  if (window.autoHeight) {
+    window.height = calculateAutoHeight(sequences, window, terminal);
+  }
+  const lineHeight = terminal.fontSize * terminal.lineHeight;
+  const titleBarHeight = getTitleBarHeight(window);
+  const topPadding = terminal.paddingTop;
+  const viewportHeight = window.height - titleBarHeight - topPadding - terminal.padding;
+  const maxVisibleLines = Math.floor(viewportHeight / lineHeight);
+  const maxDurationMs = config.maxDuration * 1e3;
+  const { frames, totalDuration } = createAnimationFrames(sequences, terminal, maxVisibleLines, config.scrollDuration, animation);
+  if (totalDuration > maxDurationMs) {
+    console.warn(`[svg-terminal] Animation duration (${(totalDuration / 1e3).toFixed(1)}s) exceeds maxDuration (${config.maxDuration}s)`);
+  }
+  const accessibilityLabel = config.accessibilityLabel ?? buildAccessibilityLabel(sequences);
+  const showShadow = effects.shadow && window.style !== "none";
+  const a11yChildren = renderAccessibilityChildren(accessibilityLabel, sequences, terminal.prompt, config.accessibility);
+  const frameCounts = /* @__PURE__ */ new Set();
+  for (const seq of sequences) {
+    if (seq.type === "output" && seq.frames && seq.frames.length > 1) {
+      frameCounts.add(seq.frames.length);
+    }
+  }
+  const frameCycleKeyframes = [...frameCounts].sort((a, b) => a - b).map((n) => {
+    const slot = (100 / n).toFixed(4);
+    return `    @keyframes frame-cycle-${n} { 0%, ${slot}% { opacity: 1; } ${(parseFloat(slot) + 0.01).toFixed(4)}%, 100% { opacity: 0; } }`;
+  }).join("\n");
+  return `<svg width="${window.width}" height="${window.height}" viewBox="0 0 ${window.width} ${window.height}" xmlns="http://www.w3.org/2000/svg"
+  role="img" aria-label="${escapeXml(accessibilityLabel)}">${a11yChildren}
+  <style>
+    .tt { font-family: ${escapeXml(terminal.fontFamily)}; font-size: ${terminal.fontSize}px; white-space: pre; }
+    @keyframes scanlineScroll {
+      from { transform: translateY(0); }
+      to { transform: translateY(4px); }
+    }
+    .scanline-overlay { animation: scanlineScroll 1.2s linear infinite; }
+    /* fadeIn drives all opacity fade-ins (prompt + output lines + animated frame
+       wrappers). Lives in CSS rather than SMIL so the @media block below kills
+       it under prefers-reduced-motion. fill-mode: backwards keeps the element
+       at opacity 0 during the animation-delay window so it doesn't pop in
+       before its scheduled time. */
+    @keyframes fadeIn { from { opacity: 0; } to { opacity: 1; } }
+    .fade-in { animation: fadeIn 10ms linear backwards; }
+    /* frame-cycle-N (closes #69): one rule per unique frame count across the
+       animated blocks in this render. Each frame text element carries the
+       class + an inline animation-delay = i*frameDur. The static opacity
+       attribute (frame 0 = 1, others = 0) is the SMIL-stripped AND
+       reduced-motion fallback \u2014 frame 0 visible, rest invisible. Under
+       prefers-reduced-motion the @media block kills animation-duration so
+       the underlying opacity attribute applies. */
+${frameCycleKeyframes}
+    @media (prefers-reduced-motion: reduce) {
+      *, *::before, *::after {
+        animation-duration: 0.01ms !important;
+        animation-iteration-count: 1 !important;
+        transition-duration: 0.01ms !important;
+      }
+    }
+  </style>
+  <defs>
+    ${generateDefs(effects, window.style)}
+    ${generateFilters(effects, theme.colors.cursor)}
+    <clipPath id="terminalViewport">
+      <rect x="0" y="${getTitleBarHeight(window)}" width="${window.width}" height="${window.height - getTitleBarHeight(window)}"/>
+    </clipPath>
+  </defs>
+
+  <g${showShadow ? ' filter="url(#shadow)"' : ""}>
+    ${renderWindow(window, theme)}
+    ${renderTitleBarForStyle(window, terminal, theme, chrome)}
+    ${renderTerminalContent(window, terminal, theme, effects, chrome, animation, frames, lineHeight)}
+    ${renderVignetteOverlay(effects, window)}
+    ${renderScanlineOverlay(effects, window)}
+  </g>
+</svg>`;
+}
+function renderVignetteOverlay(effects, window) {
+  if (!effects.vignette) return "";
+  const titleBarHeight = getTitleBarHeight(window);
+  const contentHeight = window.height - titleBarHeight;
+  return `<rect x="0" y="${titleBarHeight}" width="${window.width}" height="${contentHeight}" fill="url(#vignette)" pointer-events="none"/>`;
+}
+function renderScanlineOverlay(effects, window, animated = true) {
+  if (!effects.scanlines) return "";
+  const titleBarHeight = getTitleBarHeight(window);
+  const contentHeight = window.height - titleBarHeight;
+  const classAttr = animated ? ' class="scanline-overlay"' : "";
+  return `<rect x="0" y="${titleBarHeight}" width="${window.width}" height="${contentHeight}" fill="url(#scanlines)" pointer-events="none" opacity="0.5"${classAttr}/>`;
+}
+function buildAccessibilityLabel(sequences) {
+  const commands = sequences.filter((s) => s.type === "command").map((s) => s.content).slice(0, 5);
+  if (commands.length === 0) return "Animated terminal";
+  return `Animated terminal showing: ${commands.join(", ")}`;
+}
+function renderAccessibilityChildren(label, sequences, prompt, a11y) {
+  const title = `
+  <title>${escapeXml(label)}</title>`;
+  if (!a11y.describe) return title;
+  const lines = [];
+  for (const seq of sequences) {
+    if (seq.type === "command") {
+      lines.push(`${prompt}${seq.content}`);
+    } else if (seq.content) {
+      for (const line of seq.content.split("\n")) {
+        const stripped = stripMarkup(line);
+        if (isBoxDrawingOnly(stripped)) continue;
+        lines.push(stripBoxFraming(stripped));
+      }
+    }
+  }
+  if (lines.length === 0) return title;
+  return `${title}
+  <desc>${escapeXml(lines.join("\n"))}</desc>`;
+}
+function isBoxDrawingOnly(line) {
+  if (line.length === 0) return false;
+  return /^[─-╿\s]+$/.test(line);
+}
+function stripBoxFraming(line) {
+  return line.replace(/^[─-╿\s]+|[─-╿\s]+$/g, "");
+}
+function renderStaticAccessibilityChildren(label, lines, a11y) {
+  const title = `
+  <title>${escapeXml(label)}</title>`;
+  if (!a11y.describe || lines.length === 0) return title;
+  const stripped = lines.map(stripMarkup).filter((line) => !isBoxDrawingOnly(line)).map(stripBoxFraming).join("\n");
+  if (stripped.length === 0) return title;
+  return `${title}
+  <desc>${escapeXml(stripped)}</desc>`;
+}
+function getTitleBarHeight(window) {
+  if (window.style === "none" || window.style === "floating" || window.style === "minimal") {
+    return 0;
+  }
+  return window.titleBarHeight;
+}
+function renderWin95TitleBar(window) {
+  const h = window.titleBarHeight;
+  const w = window.width;
+  const silver = "#c0c0c0";
+  const darkGray = "#808080";
+  const white = "#ffffff";
+  const black = "#000000";
+  const btnW = Math.max(12, h - 6);
+  const btnH = Math.round(btnW * 14 / 16);
+  const btnY = (h - btnH) / 2;
+  const btnGap = 2;
+  const btnsTotal = btnW * 3 + btnGap * 2;
+  const btnsX = w - btnsTotal - 4;
+  const captionTextY = (h + 11) / 2;
+  return `
+    <!-- Win95 title bar -->
+    <rect x="0" y="0" width="${w}" height="${h}" fill="${silver}"/>
+    <!-- 3D raised border: top/left white, bottom/right dark -->
+    <line x1="0" y1="0" x2="${w}" y2="0" stroke="${white}" stroke-width="2"/>
+    <line x1="0" y1="0" x2="0" y2="${h}" stroke="${white}" stroke-width="2"/>
+    <line x1="${w}" y1="0" x2="${w}" y2="${h}" stroke="${black}" stroke-width="1"/>
+    <line x1="0" y1="${h}" x2="${w}" y2="${h}" stroke="${darkGray}" stroke-width="1"/>
+    <!-- Blue caption (gradient defined in defs) -->
+    <rect x="3" y="3" width="${w - 6 - btnsTotal - 6}" height="${h - 6}" fill="url(#win95Caption)"/>
+    <!-- Caption text \u2014 sans-serif chrome font, not the terminal monospace -->
+    <text x="8" y="${captionTextY}"
+          font-family="Tahoma, 'MS Sans Serif', Geneva, sans-serif" font-size="11" font-weight="bold"
+          fill="${white}">
+      ${escapeXml(window.title)}
+    </text>
+    <!-- Win95 buttons: minimize, maximize, close -->
+    <g transform="translate(${btnsX}, ${btnY})">
+      <rect x="0" y="0" width="${btnW}" height="${btnH}" fill="${silver}" stroke="${black}" stroke-width="1"/>
+      <line x1="${btnW * 0.2}" y1="${btnH - 3}" x2="${btnW * 0.75}" y2="${btnH - 3}" stroke="${black}" stroke-width="1.5"/>
+      <rect x="${btnW + btnGap}" y="0" width="${btnW}" height="${btnH}" fill="${silver}" stroke="${black}" stroke-width="1"/>
+      <rect x="${btnW + btnGap + 3}" y="3" width="${btnW - 6}" height="${btnH - 6}" fill="none" stroke="${black}" stroke-width="1.2"/>
+      <rect x="${(btnW + btnGap) * 2}" y="0" width="${btnW}" height="${btnH}" fill="${silver}" stroke="${black}" stroke-width="1"/>
+      <line x1="${(btnW + btnGap) * 2 + 3}" y1="3" x2="${(btnW + btnGap) * 2 + btnW - 3}" y2="${btnH - 3}" stroke="${black}" stroke-width="1.2"/>
+      <line x1="${(btnW + btnGap) * 2 + btnW - 3}" y1="3" x2="${(btnW + btnGap) * 2 + 3}" y2="${btnH - 3}" stroke="${black}" stroke-width="1.2"/>
+    </g>`;
+}
+function renderTitleBarForStyle(window, terminal, theme, chrome) {
+  if (window.style === "none" || window.style === "floating" || window.style === "minimal") {
+    return "";
+  }
+  if (window.style === "win95") {
+    return renderWin95TitleBar(window);
+  }
+  return renderTitleBar(window, terminal, theme, chrome);
+}
+function createAnimationFrames(sequences, terminal, maxVisibleLines, scrollDuration, anim) {
+  let currentTime = 0;
+  const frames = [];
+  const buffer = [];
+  let bufferStart = 0;
+  for (const seq of sequences) {
+    currentTime += seq.delay ?? 0;
+    if (seq.type === "command") {
+      buffer.push({ type: "command" });
+      const typingDur = seq.typingDuration ?? anim.defaultTypingDuration;
+      if (buffer.length - bufferStart > maxVisibleLines) {
+        frames.push({
+          time: currentTime,
+          type: "scroll",
+          scrollLines: 1,
+          bufferStart: ++bufferStart
+        });
+        frames.push({
+          time: currentTime + scrollDuration + anim.scrollDelay,
+          type: "add-command",
+          lineIndex: buffer.length - 1,
+          prompt: seq.prompt ?? terminal.prompt,
+          command: seq.content,
+          typingDuration: typingDur
+        });
+        currentTime += scrollDuration + anim.scrollDelay;
+      } else {
+        frames.push({
+          time: currentTime,
+          type: "add-command",
+          lineIndex: buffer.length - 1,
+          prompt: seq.prompt ?? terminal.prompt,
+          command: seq.content,
+          typingDuration: typingDur
+        });
+      }
+      currentTime += typingDur;
+    } else {
+      if (!seq.content) {
+        currentTime += seq.pause ?? anim.defaultSequencePause;
+        continue;
+      }
+      if (seq.frames && seq.frames.length > 0) {
+        buffer.push({ type: "output" });
+        frames.push({
+          time: currentTime,
+          type: "add-output",
+          lineIndex: buffer.length - 1,
+          content: seq.frames[0],
+          // frame 0 acts as the static fallback
+          color: seq.color,
+          frames: seq.frames,
+          framesFps: seq.framesFps,
+          framesLoop: seq.framesLoop,
+          pinWidth: seq.pinWidth
+        });
+        currentTime += anim.outputEndPause;
+      } else {
+        const lines = seq.content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          const baseTime = currentTime + i * anim.outputLineStagger;
+          buffer.push({ type: "output" });
+          if (buffer.length - bufferStart > maxVisibleLines) {
+            frames.push({
+              time: baseTime,
+              type: "scroll",
+              scrollLines: 1,
+              bufferStart: ++bufferStart
+            });
+            frames.push({
+              time: baseTime + scrollDuration + anim.scrollDelay,
+              type: "add-output",
+              lineIndex: buffer.length - 1,
+              content: lines[i],
+              color: seq.color,
+              pinWidth: seq.pinWidth
+            });
+          } else {
+            frames.push({
+              time: baseTime,
+              type: "add-output",
+              lineIndex: buffer.length - 1,
+              content: lines[i],
+              color: seq.color,
+              pinWidth: seq.pinWidth
+            });
+          }
+        }
+        currentTime += lines.length * anim.outputLineStagger + anim.outputEndPause;
+      }
+    }
+    currentTime += seq.pause ?? anim.defaultSequencePause;
+  }
+  frames.push({ time: currentTime, type: "final" });
+  return { frames, totalDuration: currentTime };
+}
+function renderWindow(window, theme) {
+  const isSquare = window.style === "none" || window.style === "win95";
+  const radius = isSquare ? 0 : window.borderRadius;
+  const bg = `
+    <rect x="0" y="0" width="${window.width}" height="${window.height}"
+          rx="${radius}" ry="${radius}"
+          fill="${escapeXml(theme.colors.background)}"/>`;
+  if (window.style === "win95") {
+    const w = window.width;
+    const h = window.height;
+    return `${bg}
+    <line x1="0" y1="0" x2="${w}" y2="0" stroke="#ffffff" stroke-width="2"/>
+    <line x1="0" y1="0" x2="0" y2="${h}" stroke="#ffffff" stroke-width="2"/>
+    <line x1="${w - 1}" y1="0" x2="${w - 1}" y2="${h}" stroke="#000000" stroke-width="2"/>
+    <line x1="0" y1="${h - 1}" x2="${w}" y2="${h - 1}" stroke="#000000" stroke-width="2"/>
+    <line x1="1" y1="${h - 2}" x2="${w - 1}" y2="${h - 2}" stroke="#808080" stroke-width="1"/>
+    <line x1="${w - 2}" y1="1" x2="${w - 2}" y2="${h - 1}" stroke="#808080" stroke-width="1"/>`;
+  }
+  return bg;
+}
+function renderTitleBar(window, terminal, theme, chrome) {
+  const { buttonRadius: r, buttonSpacing: s, buttonY: y, titleFontSize, titleFontFamily } = chrome;
+  return `
+    <rect x="0" y="0" width="${window.width}" height="${window.titleBarHeight}"
+          rx="${window.borderRadius}" ry="${window.borderRadius}"
+          fill="${escapeXml(theme.colors.titleBarBackground)}"/>
+    <rect x="0" y="${y}" width="${window.width}" height="${y}"
+          fill="${escapeXml(theme.colors.titleBarBackground)}"/>
+    <g id="window-controls">
+      <circle cx="${terminal.padding + 2}" cy="${y}" r="${r}" fill="${escapeXml(theme.buttons.close)}" stroke="rgba(0,0,0,0.18)" stroke-width="0.5"/>
+      <circle cx="${terminal.padding + 2 + s}" cy="${y}" r="${r}" fill="${escapeXml(theme.buttons.minimize)}" stroke="rgba(0,0,0,0.18)" stroke-width="0.5"/>
+      <circle cx="${terminal.padding + 2 + s * 2}" cy="${y}" r="${r}" fill="${escapeXml(theme.buttons.maximize)}" stroke="rgba(0,0,0,0.18)" stroke-width="0.5"/>
+    </g>
+    <text x="${window.width / 2}" y="${(window.titleBarHeight + titleFontSize * 0.7) / 2}"
+          font-family="${escapeXml(titleFontFamily)}" font-size="${titleFontSize}"
+          fill="${escapeXml(theme.colors.titleBarText)}" text-anchor="middle">
+      ${escapeXml(window.title)}
+    </text>`;
+}
+function renderTerminalContent(window, terminal, theme, effects, chrome, animation, frames, lineHeight) {
+  const titleBarHeight = getTitleBarHeight(window);
+  const contentY = titleBarHeight + terminal.paddingTop;
+  const viewportHeight = window.height - titleBarHeight;
+  const scrollAnimations = renderScrollAnimations(frames, terminal, window, lineHeight);
+  const allLines = generateAllLines(frames, terminal, lineHeight, theme.colors, chrome, animation);
+  const glow = effects.textGlow ? ' filter="url(#textGlow)"' : "";
+  return `
+    <rect x="0" y="${titleBarHeight}" width="${window.width}"
+          height="${viewportHeight}" fill="${escapeXml(theme.colors.background)}"/>
+    <g clip-path="url(#terminalViewport)">
+      <g id="scrollContainer" transform="translate(${terminal.padding}, ${contentY})"${glow}>
+        ${scrollAnimations}
+        ${allLines}
+      </g>
+    </g>`;
+}
+function renderScrollAnimations(frames, terminal, window, lineHeight) {
+  const scrollFrames = frames.filter((f) => f.type === "scroll");
+  if (scrollFrames.length === 0) return "";
+  const roundedLineHeight = roundCoord(lineHeight);
+  const titleBarHeight = getTitleBarHeight(window);
+  const scrollOriginY = titleBarHeight + terminal.paddingTop;
+  const values = [`${terminal.padding} ${roundCoord(scrollOriginY)}`];
+  const keyTimesMs = [0];
+  let totalScroll = 0;
+  for (const frame of scrollFrames) {
+    const fromY = roundCoord(scrollOriginY - totalScroll);
+    const scrollAmount = (frame.scrollLines ?? 1) * roundedLineHeight;
+    totalScroll += scrollAmount;
+    const toY = roundCoord(scrollOriginY - totalScroll);
+    const startT = frame.time;
+    const endT = frame.time + SCROLL_ANIM_DURATION;
+    if (keyTimesMs[keyTimesMs.length - 1] < startT) {
+      values.push(`${terminal.padding} ${fromY}`);
+      keyTimesMs.push(startT);
+    }
+    values.push(`${terminal.padding} ${toY}`);
+    keyTimesMs.push(endT);
+  }
+  const totalDur = keyTimesMs[keyTimesMs.length - 1];
+  const keyTimes = keyTimesMs.map((t) => (t / totalDur).toFixed(4)).join(";");
+  return `
+        <animateTransform
+          attributeName="transform" type="translate"
+          values="${values.join(";")}" keyTimes="${keyTimes}"
+          dur="${totalDur}ms" fill="freeze"/>`;
+}
+function renderStaticStyledText(text, colorMap, defaultColor, dimOpacity) {
+  const spans = parseMarkup(text, colorMap, defaultColor);
+  return spans.map((span) => {
+    const color = span.fg ?? defaultColor;
+    const attrs = [`fill="${escapeXml(color)}"`];
+    if (span.bold) attrs.push('font-weight="bold"');
+    if (span.dim) attrs.push(`opacity="${dimOpacity}"`);
+    return `<tspan ${attrs.join(" ")}>${escapeXml(span.text)}</tspan>`;
+  }).join("");
+}
+function generateStaticSvg(lines, config) {
+  const { text: terminal, theme, effects, chrome } = config;
+  const window = { ...config.window };
+  if (window.autoHeight) {
+    const lineHeight2 = terminal.fontSize * terminal.lineHeight;
+    const contentHeight = lines.length * lineHeight2;
+    const titleBarHeight2 = getTitleBarHeight(window);
+    const chromeHeight = titleBarHeight2 + terminal.paddingTop + terminal.padding * 2;
+    const calculated = Math.ceil(contentHeight + chromeHeight);
+    window.height = Math.max(window.minHeight, Math.min(window.maxHeight, calculated));
+  }
+  const lineHeight = terminal.fontSize * terminal.lineHeight;
+  const titleBarHeight = getTitleBarHeight(window);
+  const contentY = titleBarHeight + terminal.paddingTop;
+  const viewportHeight = window.height - titleBarHeight;
+  const accessibilityLabel = config.accessibilityLabel ?? `Static terminal showing ${lines.length} lines`;
+  const a11yChildren = renderStaticAccessibilityChildren(accessibilityLabel, lines, config.accessibility);
+  const colorMap = buildColorMap(theme.colors);
+  const glow = effects.textGlow ? ' filter="url(#textGlow)"' : "";
+  const showShadow = effects.shadow && window.style !== "none";
+  const lineElements = lines.map((line, i) => {
+    const y = roundCoord(i * lineHeight);
+    const hasMarkupTags = line.includes("[[");
+    const textContent = hasMarkupTags ? renderStaticStyledText(line, colorMap, theme.colors.text, chrome.dimOpacity) : escapeXml(line);
+    const fill = hasMarkupTags ? "" : ` fill="${escapeXml(theme.colors.text)}"`;
+    return `
+      <text class="tt" y="${y}"${fill}>
+        ${textContent}
+      </text>`;
+  }).join("");
+  return `<svg width="${window.width}" height="${window.height}" viewBox="0 0 ${window.width} ${window.height}" xmlns="http://www.w3.org/2000/svg"
+  role="img" aria-label="${escapeXml(accessibilityLabel)}">${a11yChildren}
+  <style>.tt { font-family: ${escapeXml(terminal.fontFamily)}; font-size: ${terminal.fontSize}px; white-space: pre; }</style>
+  <defs>
+    ${generateDefs(effects, window.style)}
+    ${generateFilters(effects, theme.colors.cursor)}
+    <clipPath id="terminalViewport">
+      <rect x="0" y="${titleBarHeight}" width="${window.width}" height="${viewportHeight}"/>
+    </clipPath>
+  </defs>
+
+  <g${showShadow ? ' filter="url(#shadow)"' : ""}>
+    ${renderWindow(window, theme)}
+    ${renderTitleBarForStyle(window, terminal, theme, chrome)}
+    <rect x="0" y="${titleBarHeight}" width="${window.width}"
+          height="${viewportHeight}" fill="${escapeXml(theme.colors.background)}"/>
+    <g clip-path="url(#terminalViewport)">
+      <g transform="translate(${terminal.padding}, ${contentY})"${glow}>
+        ${lineElements}
+      </g>
+    </g>
+    ${renderVignetteOverlay(effects, window)}
+    ${renderScanlineOverlay(effects, window, false)}
+  </g>
+</svg>`;
+}
+
+// src/blocks/custom.ts
+import { z as z3 } from "zod";
+var customConfigSchema = z3.object({
+  command: z3.string().optional(),
+  lines: z3.array(z3.string()).optional(),
+  color: z3.string().optional()
+}).strict();
+var customBlock = {
+  name: "custom",
+  description: "Display custom text with optional [[fg:color]] markup",
+  configSchema: customConfigSchema,
+  render(_context, config) {
+    const command = config["command"] ?? 'echo "Hello, World!"';
+    const lines = config["lines"] ?? ["Hello, World!"];
+    const color = config["color"];
+    return { command, lines, color };
+  }
+};
+
+// src/blocks/neofetch.ts
+import { z as z4 } from "zod";
+var neofetchConfigSchema = z4.object({
+  username: z4.string().optional(),
+  hostname: z4.string().optional(),
+  title: z4.string().optional(),
+  os: z4.string().optional(),
+  shell: z4.string().optional(),
+  uptime: z4.string().optional(),
+  role: z4.string().optional(),
+  location: z4.string().optional(),
+  languages: z4.string().optional(),
+  editor: z4.string().optional(),
+  command: z4.string().optional()
+}).strict();
+var neofetchBlock = {
+  name: "neofetch",
+  description: "Display system-info style output like neofetch",
+  configSchema: neofetchConfigSchema,
+  render(_context, config) {
+    const username = config["username"] ?? "user";
+    const hostname = config["hostname"] ?? "terminal";
+    const title = config["title"] ?? `${username}@${hostname}`;
+    const os = config["os"] ?? "TerminalOS v1.0";
+    const shell = config["shell"] ?? "bash 5.2";
+    const uptime = config["uptime"] ?? "a long time";
+    const role = config["role"] ?? "Developer";
+    const location = config["location"] ?? "localhost";
+    const languages = config["languages"] ?? "TypeScript, Python, Go";
+    const editor = config["editor"] ?? "neovim";
+    const separator = "\u2500".repeat(title.length);
+    const command = config["command"] ?? `neofetch --ascii_distro ${hostname}`;
+    const lines = [
+      `[[fg:cyan]]${title}[[/fg]]`,
+      `[[fg:cyan]]${separator}[[/fg]]`,
+      `[[fg:cyan]]OS[[/fg]]:        ${os}`,
+      `[[fg:cyan]]Shell[[/fg]]:     ${shell}`,
+      `[[fg:cyan]]Uptime[[/fg]]:    ${uptime}`,
+      `[[fg:cyan]]Role[[/fg]]:      ${role}`,
+      `[[fg:cyan]]Location[[/fg]]:  ${location}`,
+      `[[fg:cyan]]Languages[[/fg]]: ${languages}`,
+      `[[fg:cyan]]Editor[[/fg]]:    ${editor}`,
+      "",
+      // Color palette row
+      "[[fg:red]]\u25CF[[/fg]] [[fg:green]]\u25CF[[/fg]] [[fg:yellow]]\u25CF[[/fg]] [[fg:blue]]\u25CF[[/fg]] [[fg:magenta]]\u25CF[[/fg]] [[fg:cyan]]\u25CF[[/fg]] [[fg:white]]\u25CF[[/fg]] [[fg:orange]]\u25CF[[/fg]]"
+    ];
+    return { command, lines };
+  }
+};
+
+// src/blocks/fortune.ts
+import { z as z5 } from "zod";
+
+// src/core/box-generator.ts
+var BOX_OVERHEAD = 4;
+var BOX_STYLES = {
+  double: {
+    topLeft: "\u2554",
+    topRight: "\u2557",
+    bottomLeft: "\u255A",
+    bottomRight: "\u255D",
+    horizontal: "\u2550",
+    vertical: "\u2551",
+    separatorLeft: "\u2560",
+    separatorRight: "\u2563"
+  },
+  rounded: {
+    topLeft: "\u256D",
+    topRight: "\u256E",
+    bottomLeft: "\u2570",
+    bottomRight: "\u256F",
+    horizontal: "\u2500",
+    vertical: "\u2502",
+    separatorLeft: "\u251C",
+    separatorRight: "\u2524"
+  },
+  single: {
+    topLeft: "\u250C",
+    topRight: "\u2510",
+    bottomLeft: "\u2514",
+    bottomRight: "\u2518",
+    horizontal: "\u2500",
+    vertical: "\u2502",
+    separatorLeft: "\u251C",
+    separatorRight: "\u2524"
+  },
+  heavy: {
+    topLeft: "\u250F",
+    topRight: "\u2513",
+    bottomLeft: "\u2517",
+    bottomRight: "\u251B",
+    horizontal: "\u2501",
+    vertical: "\u2503",
+    separatorLeft: "\u2523",
+    separatorRight: "\u252B"
+  },
+  dashed: {
+    topLeft: "\u250C",
+    topRight: "\u2510",
+    bottomLeft: "\u2514",
+    bottomRight: "\u2518",
+    horizontal: "\u2504",
+    vertical: "\u2506",
+    separatorLeft: "\u251C",
+    separatorRight: "\u2524"
+  }
+};
+function getDisplayWidth(str) {
+  if (!str) return 0;
+  const cleaned = stripMarkup(str).replace(/\x1b\[[0-9;]*m/g, "");
+  let width = 0;
+  for (const char of cleaned) {
+    const code = char.codePointAt(0) ?? 0;
+    if (code >= 127744 && code <= 129535 || code >= 9728 && code <= 9983 || code >= 9984 && code <= 10175 || code >= 128512 && code <= 128591 || code >= 128640 && code <= 128767) {
+      width += 2;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
+function padToWidth(str, targetWidth, padChar = " ") {
+  const padding = Math.max(0, targetWidth - getDisplayWidth(str));
+  return str + padChar.repeat(padding);
+}
+function truncateToWidth(str, maxWidth) {
+  if (getDisplayWidth(str) <= maxWidth) return str;
+  let width = 0;
+  let result = "";
+  for (const char of str) {
+    const charWidth = getDisplayWidth(char);
+    if (width + charWidth + 3 > maxWidth) return result + "...";
+    result += char;
+    width += charWidth;
+  }
+  return result;
+}
+function breakLongWord(word, maxWidth) {
+  const chunks = [];
+  let chunk = "";
+  let chunkWidth = 0;
+  for (const char of word) {
+    const charWidth = getDisplayWidth(char);
+    if (chunkWidth + charWidth > maxWidth && chunk !== "") {
+      chunks.push(chunk);
+      chunk = char;
+      chunkWidth = charWidth;
+    } else {
+      chunk += char;
+      chunkWidth += charWidth;
+    }
+  }
+  if (chunk) chunks.push(chunk);
+  return chunks;
+}
+function wrapText(text, maxWidth, indent = "") {
+  if (!text || getDisplayWidth(text) <= maxWidth) return [text || ""];
+  const words = text.split(/\s+/);
+  const lines = [];
+  let currentLine = "";
+  for (const word of words) {
+    const wordWidth = getDisplayWidth(word);
+    if (wordWidth > maxWidth) {
+      if (currentLine !== "") {
+        lines.push(currentLine);
+        currentLine = "";
+      }
+      const chunks = breakLongWord(word, maxWidth);
+      for (const chunk of chunks) {
+        if (lines.length === 0 && currentLine === "") {
+          currentLine = chunk;
+        } else {
+          if (currentLine !== "") lines.push(currentLine);
+          currentLine = indent + chunk;
+        }
+      }
+      continue;
+    }
+    const lineWidth = getDisplayWidth(currentLine);
+    if (currentLine === "") {
+      currentLine = lines.length > 0 ? indent + word : word;
+    } else if (lineWidth + 1 + wordWidth <= maxWidth) {
+      currentLine += " " + word;
+    } else {
+      lines.push(currentLine);
+      currentLine = indent + word;
+    }
+  }
+  if (currentLine) lines.push(currentLine);
+  return lines;
+}
+function createBox(config) {
+  const {
+    style = "double",
+    width = 56,
+    lines = [],
+    separatorAfter = [],
+    truncate = true,
+    wrap: wrap2 = false
+  } = config;
+  const chars = BOX_STYLES[style];
+  const innerWidth = width - BOX_OVERHEAD;
+  const result = [];
+  result.push(chars.topLeft + chars.horizontal.repeat(width - 2) + chars.topRight);
+  const expanded = [];
+  lines.forEach((line, index) => {
+    const isSep = separatorAfter?.includes(index) ?? false;
+    if (wrap2 && getDisplayWidth(line) > innerWidth) {
+      const wrapped = wrapText(line, innerWidth);
+      wrapped.forEach((wl, wi) => {
+        expanded.push({ content: wl, separateAfter: wi === wrapped.length - 1 && isSep });
+      });
+    } else {
+      let content = line;
+      if (truncate && getDisplayWidth(content) > innerWidth) {
+        content = truncateToWidth(content, innerWidth);
+      }
+      expanded.push({ content, separateAfter: isSep });
+    }
+  });
+  for (const { content, separateAfter } of expanded) {
+    const padded = padToWidth(content, innerWidth);
+    result.push(chars.vertical + " " + padded + " " + chars.vertical);
+    if (separateAfter) {
+      result.push(chars.separatorLeft + chars.horizontal.repeat(width - 2) + chars.separatorRight);
+    }
+  }
+  result.push(chars.bottomLeft + chars.horizontal.repeat(width - 2) + chars.bottomRight);
+  return result.join("\n");
+}
+function createDoubleBox(lines, width = 56, separatorAfter) {
+  return createBox({ style: "double", width, lines, separatorAfter });
+}
+function createRoundedBox(lines, width = 48, separatorAfter) {
+  return createBox({ style: "rounded", width, lines, separatorAfter });
+}
+function createTitledBox(opts) {
+  const { title, subtitle, content = [], width = 56, style = "double" } = opts;
+  const lines = ["", title];
+  if (subtitle) lines.push(subtitle);
+  const separatorIndex = lines.length - 1;
+  lines.push(...content);
+  return createBox({ style, width, lines, separatorAfter: [separatorIndex] });
+}
+function createAutoBox(config) {
+  const { lines, style = "double", minWidth = 0, maxWidth = 120, separatorAfter } = config;
+  let longestLine = 0;
+  for (const line of lines) {
+    const w = getDisplayWidth(line);
+    if (w > longestLine) longestLine = w;
+  }
+  let boxWidth = longestLine + BOX_OVERHEAD;
+  boxWidth = Math.max(boxWidth, minWidth);
+  if (boxWidth > maxWidth) {
+    return createBox({ style, width: maxWidth, lines, separatorAfter, wrap: true });
+  }
+  return createBox({ style, width: boxWidth, lines, separatorAfter });
+}
+
+// src/blocks/fortune.ts
+var fortuneConfigSchema = z5.object({
+  fortunes: z5.array(z5.string()).optional(),
+  command: z5.string().optional(),
+  width: z5.number().positive().optional(),
+  color: z5.string().optional()
+}).strict();
+var DEFAULT_FORTUNES = [
+  "The best code is no code at all.",
+  "Talk is cheap. Show me the code. \u2014 Linus Torvalds",
+  "First, solve the problem. Then, write the code.",
+  "Premature optimization is the root of all evil. \u2014 Donald Knuth",
+  "Walking on water and developing software from a specification are easy if both are frozen. \u2014 Edward Berard",
+  "Simplicity is the soul of efficiency. \u2014 Austin Freeman",
+  "Any fool can write code that a computer can understand. Good programmers write code that humans can understand. \u2014 Martin Fowler",
+  "Programs must be written for people to read, and only incidentally for machines to execute. \u2014 Harold Abelson",
+  "It is not enough for code to work. \u2014 Robert C. Martin",
+  "There are only two hard things in Computer Science: cache invalidation and naming things. \u2014 Phil Karlton",
+  "The most important property of a program is whether it accomplishes the intention of its user. \u2014 C.A.R. Hoare",
+  "Code is like humor. When you have to explain it, it is bad. \u2014 Cory House",
+  "Make it work, make it right, make it fast. \u2014 Kent Beck",
+  "Debugging is twice as hard as writing the code. \u2014 Brian Kernighan",
+  "Everybody should learn to program a computer, because it teaches you how to think. \u2014 Steve Jobs",
+  "A language that doesn't affect the way you think about programming is not worth knowing. \u2014 Alan Perlis",
+  "Software is a great combination between artistry and engineering. \u2014 Bill Gates",
+  "Programming isn't about what you know; it's about what you can figure out. \u2014 Chris Pine",
+  "The function of good software is to make the complex appear to be simple. \u2014 Grady Booch",
+  "Truth can only be found in one place: the code. \u2014 Robert C. Martin",
+  "Sometimes it pays to stay in bed on Monday, rather than spending the rest of the week debugging Monday's code. \u2014 Christopher Thompson",
+  "In order to be irreplaceable, one must always be different. \u2014 Coco Chanel",
+  "When in doubt, use brute force. \u2014 Ken Thompson",
+  "Controlling complexity is the essence of computer programming. \u2014 Brian Kernighan",
+  "A good programmer is someone who always looks both ways before crossing a one-way street. \u2014 Doug Linder",
+  "The computer was born to solve problems that did not exist before. \u2014 Bill Gates",
+  "First, solve the problem. Then write the code. \u2014 John Johnson",
+  "Programs are meant to be read by humans and only incidentally for computers to execute. \u2014 Donald Knuth"
+];
+var fortuneBlock = {
+  name: "fortune",
+  description: "Display a random fortune or quote in an ASCII box",
+  configSchema: fortuneConfigSchema,
+  render(context, config) {
+    const fortunes = config["fortunes"] ?? DEFAULT_FORTUNES;
+    const command = config["command"] ?? "fortune";
+    const width = resolveBoxWidth(config["width"], context);
+    const index = Math.floor(context.now.getTime() / 864e5) % fortunes.length;
+    const fortune = fortunes[index] ?? fortunes[0] ?? "";
+    const box = createRoundedBox(["", ` ${fortune}`, ""], width);
+    const lines = box.split("\n");
+    return { command, lines, color: config["color"] };
+  }
+};
+
+// src/blocks/motd.ts
+import { z as z7 } from "zod";
+
+// src/blocks/weather.ts
+import { z as z6 } from "zod";
+
+// src/core/http.ts
+var DEFAULT_FETCH_TIMEOUT = 1e4;
+function safeUrlForLog(url) {
+  try {
+    const u = new URL(url);
+    return `${u.protocol}//${u.host}${u.pathname}`;
+  } catch {
+    return url.split("?")[0] ?? url;
+  }
+}
+var MAX_RESPONSE_BYTES = 1024 * 1024;
+async function readCappedText(response, url) {
+  const contentLength = response.headers.get("content-length");
+  if (contentLength && Number(contentLength) > MAX_RESPONSE_BYTES) {
+    console.warn(`[svg-terminal] Response too large (${contentLength} bytes, cap ${MAX_RESPONSE_BYTES}) from ${safeUrlForLog(url)}`);
+    return null;
+  }
+  const reader = response.body?.getReader();
+  if (!reader) return response.text();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.length;
+      if (total > MAX_RESPONSE_BYTES) {
+        await reader.cancel();
+        console.warn(`[svg-terminal] Response exceeded ${MAX_RESPONSE_BYTES}-byte cap mid-stream from ${safeUrlForLog(url)}`);
+        return null;
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return new TextDecoder().decode(Buffer.concat(chunks));
+}
+var USER_AGENT = `svg-terminal/${true ? "1.0.0" : "0.0.0-dev"}`;
+async function fetchWithTimeout(url, timeoutMs = DEFAULT_FETCH_TIMEOUT) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: { "User-Agent": USER_AGENT }
+    });
+    if (!response.ok) {
+      console.warn(`[svg-terminal] HTTP ${response.status} from ${safeUrlForLog(url)}`);
+      return null;
+    }
+    return response;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("abort")) {
+      console.warn(`[svg-terminal] Timeout after ${timeoutMs}ms fetching ${safeUrlForLog(url)}`);
+    } else {
+      console.warn(`[svg-terminal] Fetch failed for ${safeUrlForLog(url)}: ${message}`);
+    }
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function fetchJson(url, timeoutMs = DEFAULT_FETCH_TIMEOUT) {
+  const response = await fetchWithTimeout(url, timeoutMs);
+  if (!response) return null;
+  const text = await readCappedText(response, url);
+  if (text === null) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    console.warn(`[svg-terminal] Invalid JSON from ${safeUrlForLog(url)}`);
+    return null;
+  }
+}
+async function fetchText(url, timeoutMs = DEFAULT_FETCH_TIMEOUT) {
+  const response = await fetchWithTimeout(url, timeoutMs);
+  if (!response) return null;
+  try {
+    return await readCappedText(response, url);
+  } catch {
+    console.warn(`[svg-terminal] Failed to read text from ${safeUrlForLog(url)}`);
+    return null;
+  }
+}
+
+// src/core/cache.ts
+import { createHash, randomBytes } from "crypto";
+import { readFileSync as readFileSync2, realpathSync, renameSync, writeFileSync, unlinkSync } from "fs";
+import { dirname, isAbsolute, join, resolve, sep } from "path";
+var CACHE_VERSION = 1;
+function hashConfig(config) {
+  const json = canonicalize(config);
+  return createHash("sha256").update(json).digest("hex").slice(0, 16);
+}
+function canonicalize(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (ancestors.has(value)) {
+    throw new Error("cache: config contains a circular reference (YAML anchor or programmatic cycle) \u2014 cannot hash");
+  }
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) return `[${value.map((v) => canonicalize(v, ancestors)).join(",")}]`;
+    const obj = value;
+    const keys = Object.keys(obj).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalize(obj[k], ancestors)}`).join(",")}}`;
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function resolveCachePath(configPath, cachePath) {
+  if (isAbsolute(cachePath)) return resolve(cachePath);
+  const configDirRaw = dirname(resolve(configPath));
+  const resolvedRaw = resolve(configDirRaw, cachePath);
+  const configDir = safeRealpath(configDirRaw);
+  const resolvedCanonical = safeRealpath(dirname(resolvedRaw));
+  const resolvedBasename = resolvedRaw.slice(dirname(resolvedRaw).length);
+  const resolved = resolvedCanonical + resolvedBasename;
+  if (resolved !== configDir && !resolved.startsWith(configDir + sep)) {
+    throw new Error(`cachePath "${cachePath}" escapes the config directory`);
+  }
+  return resolved;
+}
+function safeRealpath(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function loadCacheFile(filePath) {
+  let raw;
+  try {
+    raw = readFileSync2(filePath, "utf-8");
+  } catch {
+    return { version: CACHE_VERSION, entries: {} };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== CACHE_VERSION || typeof parsed.entries !== "object" || parsed.entries === null) {
+      console.warn(`[svg-terminal] cache: ignoring file at ${filePath} (incompatible schema)`);
+      return { version: CACHE_VERSION, entries: {} };
+    }
+    return parsed;
+  } catch {
+    console.warn(`[svg-terminal] cache: ignoring corrupt JSON at ${filePath}`);
+    return { version: CACHE_VERSION, entries: {} };
+  }
+}
+function persistCacheFile(filePath, data) {
+  const dir = dirname(filePath);
+  const tmp = join(dir, `.svg-terminal-cache.${randomBytes(6).toString("hex")}.tmp`);
+  writeFileSync(tmp, JSON.stringify(data, null, 2), { encoding: "utf-8", mode: 384 });
+  try {
+    renameSync(tmp, filePath);
+  } catch (err) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+function makeUseCache(runtime, onEvent) {
+  if (!Number.isFinite(runtime.ttl) || runtime.ttl < 0) {
+    throw new Error(`CacheRuntime.ttl must be \u2265 0, got ${runtime.ttl}`);
+  }
+  return async (key, getter, opts) => {
+    if (runtime.mode === "off") {
+      onEvent?.("miss", key);
+      return getter();
+    }
+    if (!runtime.data) runtime.data = loadCacheFile(runtime.filePath);
+    const ttl = Math.max(0, opts?.ttl ?? runtime.ttl);
+    const now = Date.now();
+    const entry = runtime.data.entries[key];
+    if (runtime.mode === "frozen") {
+      if (entry) {
+        onEvent?.("hit", key);
+        return entry.payload;
+      }
+      throw new Error(`cache: frozen mode but no entry for "${key}" \u2014 re-run without --frozen-cache to populate`);
+    }
+    if (runtime.mode === "normal" && entry) {
+      const ageMs = now - Date.parse(entry.fetchedAt);
+      if (ageMs >= 0 && ageMs < ttl * 1e3) {
+        onEvent?.("hit", key);
+        return entry.payload;
+      }
+    }
+    onEvent?.(runtime.mode === "refresh" ? "refreshed" : "miss", key);
+    const payload = await getter();
+    runtime.data.entries[key] = {
+      fetchedAt: new Date(now).toISOString(),
+      payload
+    };
+    runtime.dirty = true;
+    return payload;
+  };
+}
+function flushCache(runtime) {
+  if (runtime.mode === "off" || runtime.mode === "frozen" || !runtime.dirty || !runtime.data) return;
+  pruneStaleEntries(runtime.data, runtime.ttl);
+  persistCacheFile(runtime.filePath, runtime.data);
+}
+function pruneStaleEntries(data, ttl) {
+  if (ttl <= 0) return;
+  const cutoffMs = Date.now() - ttl * 1e3;
+  for (const [key, entry] of Object.entries(data.entries)) {
+    if (Date.parse(entry.fetchedAt) < cutoffMs) {
+      delete data.entries[key];
+    }
+  }
+}
+function checkCache(input) {
+  let data;
+  try {
+    data = JSON.parse(readFileSync2(input.filePath, "utf-8"));
+    if (data.version !== CACHE_VERSION || typeof data.entries !== "object" || data.entries === null) {
+      data = { version: CACHE_VERSION, entries: {} };
+    }
+  } catch {
+    data = { version: CACHE_VERSION, entries: {} };
+  }
+  const now = Date.now();
+  return input.entries.map(({ blockName, entryIndex, key }) => {
+    const entry = data.entries[key];
+    if (!entry) return { key, blockName, entryIndex, status: "MISSING" };
+    const ageMs = now - Date.parse(entry.fetchedAt);
+    const ageSeconds = Math.max(0, Math.round(ageMs / 1e3));
+    if (ageMs >= 0 && ageMs < input.ttl * 1e3) {
+      return { key, blockName, entryIndex, status: "OK", ageSeconds };
+    }
+    return { key, blockName, entryIndex, status: "STALE", ageSeconds };
+  });
+}
+
+// src/blocks/weather.ts
+var weatherSchema = z6.object({
+  location: z6.string().optional(),
+  units: z6.enum(["imperial", "metric", "both"]).optional(),
+  compact: z6.boolean().optional(),
+  width: z6.number().positive().optional(),
+  command: z6.string().optional()
+}).strict();
+function encodeWttrLocation(location) {
+  return encodeURIComponent(location).replace(/%20/g, "+");
+}
+function formatWeather(data, units, compact) {
+  const current = data.current_condition[0];
+  const area = data.nearest_area?.[0];
+  if (!current) return ["Weather data unavailable"];
+  const desc = current.weatherDesc?.[0]?.value ?? "Unknown";
+  const locationName = area?.areaName?.[0]?.value ?? "Unknown";
+  const region = area?.region?.[0]?.value;
+  const locationStr = region ? `${locationName}, ${region}` : locationName;
+  const tempF = `${current.temp_F}\xB0F`;
+  const tempC = `${current.temp_C}\xB0C`;
+  const feelsF = `${current.FeelsLikeF}\xB0F`;
+  const feelsC = `${current.FeelsLikeC}\xB0C`;
+  const temp = units === "imperial" ? tempF : units === "metric" ? tempC : `${tempF} / ${tempC}`;
+  const feels = units === "imperial" ? feelsF : units === "metric" ? feelsC : `${feelsF} / ${feelsC}`;
+  const wind = units === "metric" ? `${current.windspeedKmph} km/h ${current.winddir16Point}` : `${current.windspeedMiles} mph ${current.winddir16Point}`;
+  if (compact) {
+    return [
+      `[[fg:cyan]]${locationStr}[[/fg]]`,
+      `${desc}  ${temp}  Humidity: ${current.humidity}%`
+    ];
+  }
+  return [
+    "",
+    `[[fg:cyan]]WEATHER: ${locationStr}[[/fg]]`,
+    `${desc}  [[bold]]${temp}[[/bold]]`,
+    `Humidity: ${current.humidity}%   Wind: ${wind}`,
+    `Feels Like: ${feels}   UV: ${current.uvIndex}`,
+    ""
+  ];
+}
+var weatherBlock = {
+  name: "weather",
+  description: "Display current weather conditions from wttr.in",
+  configSchema: weatherSchema,
+  cacheable: true,
+  async render(context, config) {
+    const location = config["location"] ?? "";
+    const units = config["units"] ?? "both";
+    const compact = config["compact"] ?? false;
+    const width = resolveBoxWidth(config["width"], context);
+    const timeout = context.config.fetchTimeout;
+    if (!location) {
+      return {
+        command: config["command"] ?? "curl wttr.in",
+        lines: ["[[fg:yellow]]Weather: no location configured[[/fg]]"],
+        typing: "fast",
+        pause: "short",
+        fallback: true
+      };
+    }
+    const url = `https://wttr.in/${encodeWttrLocation(location)}?format=j1`;
+    const cacheKey = `weather:${hashConfig(config)}`;
+    const data = context.useCache ? await context.useCache(cacheKey, () => fetchJson(url, timeout)) : await fetchJson(url, timeout);
+    let lines;
+    let isFallback = false;
+    if (data?.current_condition?.length) {
+      lines = formatWeather(data, units, compact);
+    } else {
+      lines = [
+        "",
+        "[[fg:yellow]]Weather data unavailable[[/fg]]",
+        `Location: ${location}`,
+        ""
+      ];
+      isFallback = true;
+    }
+    const box = compact ? void 0 : createDoubleBox(lines, width);
+    return {
+      command: config["command"] ?? `curl wttr.in/${location}`,
+      lines: box ? box.split("\n") : lines,
+      typing: "fast",
+      pause: "medium",
+      fallback: isFallback
+    };
+  }
+};
+async function fetchWeatherSummary(location, units, timeout) {
+  if (!location) return null;
+  const url = `https://wttr.in/${encodeWttrLocation(location)}?format=j1`;
+  const data = await fetchJson(url, timeout);
+  if (!data?.current_condition?.length) return null;
+  const current = data.current_condition[0];
+  const desc = current.weatherDesc?.[0]?.value ?? "";
+  const temp = units === "metric" ? `${current.temp_C}\xB0C` : units === "imperial" ? `${current.temp_F}\xB0F` : `${current.temp_F}\xB0F/${current.temp_C}\xB0C`;
+  return `${desc} ${temp} | Humidity: ${current.humidity}%`;
+}
+
+// src/blocks/motd.ts
+var motdConfigSchema = z7.object({
+  title: z7.string().optional(),
+  subtitle: z7.string().optional(),
+  width: z7.number().positive().optional(),
+  command: z7.string().optional(),
+  lines: z7.array(z7.string()).optional(),
+  weather: z7.object({
+    location: z7.string().optional(),
+    units: z7.enum(["imperial", "metric", "both"]).optional()
+  }).strict().optional()
+}).strict();
+var motdBlock = {
+  name: "motd",
+  description: "Display a welcome banner / message of the day",
+  configSchema: motdConfigSchema,
+  async render(context, config) {
+    const title = config["title"] ?? "DEV TERMINAL";
+    const subtitle = config["subtitle"] ?? "Powered by coffee & late-night debugging";
+    const width = resolveBoxWidth(config["width"], context);
+    const timeout = context.config.fetchTimeout;
+    const date = context.now;
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const version = `v${year}.${month}`;
+    const lines = [
+      "",
+      `${title} ${version}`,
+      subtitle
+    ];
+    const weatherConfig = config["weather"];
+    if (weatherConfig) {
+      const location = weatherConfig["location"] ?? "";
+      const units = weatherConfig["units"] ?? "both";
+      const weatherLine = await fetchWeatherSummary(location, units, timeout);
+      if (weatherLine) {
+        lines.push(`[[fg:cyan]]${weatherLine}[[/fg]]`);
+      }
+    }
+    lines.push("");
+    const extra = config["lines"];
+    if (extra) {
+      for (const line of extra) {
+        lines.push(line);
+      }
+      lines.push("");
+    }
+    const box = createDoubleBox(lines, width);
+    return {
+      command: config["command"] ?? "cat /etc/motd",
+      lines: box.split("\n"),
+      typing: "fast",
+      pause: "medium"
+    };
+  }
+};
+
+// src/blocks/dad-joke.ts
+import { z as z8 } from "zod";
+var jokeSchema = z8.object({
+  q: z8.string(),
+  a: z8.string(),
+  category: z8.string().optional()
+}).strict();
+var dadJokeSchema = z8.object({
+  jokes: z8.array(jokeSchema).optional(),
+  width: z8.number().positive().optional(),
+  command: z8.string().optional()
+}).strict();
+var dadJokeBlock = {
+  name: "dad-joke",
+  description: "Display a dad joke in a fancy ASCII box",
+  configSchema: dadJokeSchema,
+  render(context, config) {
+    const jokes = config["jokes"] ?? [
+      { q: "Why do programmers prefer dark mode?", a: "Because light attracts bugs!", category: "classic" }
+    ];
+    const width = resolveBoxWidth(config["width"], context);
+    const dayOfYear = Math.floor(
+      (context.now.getTime() - new Date(context.now.getFullYear(), 0, 0).getTime()) / 864e5
+    );
+    const joke = jokes[dayOfYear % jokes.length] ?? jokes[0];
+    if (!joke) {
+      return { command: "./dad-joke", lines: ["No jokes configured!"] };
+    }
+    const category = (joke.category ?? "classic").toUpperCase();
+    const dateStr = context.now.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+    const lines = [
+      "",
+      `DAD JOKE OF THE DAY - ${dateStr}`,
+      `Category: ${category}`,
+      "",
+      `Q: ${joke.q}`,
+      "",
+      `A: ${joke.a}`,
+      ""
+    ];
+    const box = createDoubleBox(lines, width);
+    return {
+      command: config["command"] ?? "./dad-joke --random --format=fancy",
+      lines: box.split("\n"),
+      typing: "slow",
+      pause: "long"
+    };
+  }
+};
+
+// src/blocks/htop.ts
+import { z as z9 } from "zod";
+var processSchema = z9.object({
+  pid: z9.string(),
+  user: z9.string(),
+  cpu: z9.string(),
+  mem: z9.string(),
+  command: z9.string(),
+  state: z9.string().optional()
+}).strict();
+var htopConfigSchema = z9.object({
+  cpu: z9.number().min(0).max(100).optional(),
+  mem: z9.number().min(0).max(100).optional(),
+  processes: z9.array(processSchema).optional(),
+  /** Total task count. Defaults to processes.length + 10 (some not in the displayed table). */
+  tasks: z9.number().int().min(0).optional(),
+  /** Load average shown next to memory bar. Defaults to "0.42 0.37 0.31". */
+  load: z9.string().optional(),
+  command: z9.string().optional()
+}).strict();
+var htopBlock = {
+  name: "htop",
+  description: "Display an htop-style process and resource monitor",
+  configSchema: htopConfigSchema,
+  render(_context, config) {
+    const cpuPercent = config["cpu"] ?? 80.5;
+    const memPercent = config["mem"] ?? 50;
+    const processes = config["processes"] ?? [
+      { pid: "1337", user: "dev", cpu: "99.9", mem: "5.0", command: "coding --premium", state: "R" },
+      { pid: "2048", user: "dev", cpu: "42.0", mem: "3.7", command: "family --priority=max", state: "S" },
+      { pid: "4096", user: "dev", cpu: "15.2", mem: "2.1", command: "security-scanner", state: "S" }
+    ];
+    const cpuBar = makeBar(cpuPercent);
+    const memBar = makeBar(memPercent);
+    const runningCount = processes.filter((p) => (p.state ?? "S") === "R").length;
+    const totalTasks = config["tasks"] ?? processes.length + 10;
+    const loadStr = config["load"] ?? "0.42 0.37 0.31";
+    const lines = [
+      `  [[fg:cyan]]CPU[[/fg]][${colorBar(cpuBar, "green")}  [[fg:white]]${cpuPercent.toFixed(1)}%[[/fg]]]   [[fg:yellow]]Tasks:[[/fg]] ${totalTasks}, [[fg:green]]${runningCount} running[[/fg]]`,
+      `  [[fg:cyan]]Mem[[/fg]][${colorBar(memBar, "blue")}  [[fg:white]]${memPercent.toFixed(1)}%[[/fg]]]   [[fg:yellow]]Load:[[/fg]] ${loadStr}`,
+      "",
+      `  [[fg:cyan]]PID[[/fg]]  [[fg:cyan]]USER[[/fg]]     [[fg:cyan]]S[[/fg]] [[fg:cyan]]CPU%[[/fg]] [[fg:cyan]]MEM%[[/fg]]  [[fg:cyan]]Command[[/fg]]`
+    ];
+    for (const proc of processes) {
+      const state = proc.state ?? "S";
+      const stateColor = state === "R" ? "green" : "yellow";
+      lines.push(
+        ` [[fg:white]]${proc.pid.padEnd(6)}[[/fg]] [[fg:green]]${proc.user.padEnd(8)}[[/fg]] [[fg:${stateColor}]]${state}[[/fg]] ${proc.cpu.padStart(5)} ${proc.mem.padStart(5)}  [[fg:white]]${proc.command}[[/fg]]`
+      );
+    }
+    return {
+      command: config["command"] ?? "htop --sort-key=PERCENT_CPU",
+      lines,
+      typing: "slow",
+      pause: "long"
+    };
+  }
+};
+function makeBar(percent) {
+  const filled = Math.round(percent / 5);
+  const empty = 20 - filled;
+  return "\u2588".repeat(filled) + "\u2591".repeat(empty);
+}
+function colorBar(bar, color) {
+  return `[[fg:${color}]]${bar}[[/fg]]`;
+}
+
+// src/blocks/profile.ts
+import { z as z10 } from "zod";
+var profileConfigSchema = z10.object({
+  name: z10.string().optional(),
+  github: z10.string().optional(),
+  web: z10.string().optional(),
+  focus: z10.string().optional(),
+  motto: z10.string().optional(),
+  width: z10.number().positive().optional(),
+  command: z10.string().optional()
+}).strict();
+var profileBlock = {
+  name: "profile",
+  description: "Display a developer profile info card",
+  configSchema: profileConfigSchema,
+  render(context, config) {
+    const name = config["name"] ?? "Developer";
+    const github = config["github"];
+    const web = config["web"];
+    const focus = config["focus"];
+    const motto = config["motto"];
+    const width = resolveBoxWidth(config["width"], context);
+    const lines = ["", `\u{1F464} ${name.toUpperCase()}`, ""];
+    if (github) lines.push(`GitHub:  ${github}`);
+    if (web) lines.push(`Web:     ${web}`);
+    if (focus) lines.push(`Focus:   ${focus}`);
+    if (motto) lines.push(`Motto:   "${motto}"`);
+    lines.push("");
+    const box = createRoundedBox(lines, width);
+    return {
+      command: config["command"] ?? "cat /etc/profile",
+      lines: box.split("\n"),
+      typing: "medium",
+      pause: "medium"
+    };
+  }
+};
+
+// src/blocks/goodbye.ts
+import { z as z11 } from "zod";
+var goodbyeSchema = z11.object({
+  lines: z11.array(z11.string()).optional(),
+  width: z11.number().positive().optional(),
+  command: z11.string().optional()
+}).strict();
+var goodbyeBlock = {
+  name: "goodbye",
+  description: "Display a farewell message",
+  configSchema: goodbyeSchema,
+  render(context, config) {
+    const lines = config["lines"] ?? [
+      "",
+      "Thanks for visiting!",
+      "",
+      "May your:",
+      "  - Code compile without warnings",
+      "  - Tests pass on first try",
+      "  - Bugs be easily reproducible",
+      "  - Coffee stay hot",
+      "  - Git conflicts be minimal",
+      "",
+      "See you in the commits!",
+      ""
+    ];
+    const width = resolveBoxWidth(config["width"], context);
+    const box = createDoubleBox(lines, width);
+    return {
+      command: config["command"] ?? "cat /etc/goodbye.txt",
+      lines: box.split("\n"),
+      typing: "medium",
+      pause: "long"
+    };
+  }
+};
+
+// src/blocks/npm-install.ts
+import { z as z12 } from "zod";
+var npmInstallSchema = z12.object({
+  package: z12.string().optional(),
+  command: z12.string().optional()
+}).strict();
+var npmInstallBlock = {
+  name: "npm-install",
+  description: "Display a humorous npm install dependency tree",
+  configSchema: npmInstallSchema,
+  render(_context, config) {
+    const pkg = config["package"] ?? "left-pad";
+    const lines = [
+      `added 847 packages in 42.0s`,
+      "",
+      "Dependencies resolved:",
+      `\u251C\u2500\u2500 ${pkg}@1.0.0`,
+      "\u2502   \u251C\u2500\u2500 is-string@1.0.0",
+      "\u2502   \u2502   \u251C\u2500\u2500 is-object@1.0.0",
+      "\u2502   \u2502   \u2502   \u251C\u2500\u2500 is-thing@1.0.0",
+      "\u2502   \u2502   \u2502   \u2502   \u2514\u2500\u2500 is-anything@1.0.0",
+      "\u2502   \u2502   \u2502   \u2502       \u2514\u2500\u2500 universe@\u221E",
+      "\u2502   \u2514\u2500\u2500 string-utils@1.0.0",
+      "\u2502       \u2514\u2500\u2500 ... 842 more packages",
+      "\u2502",
+      "[[fg:yellow]]\u26A0 3 vulnerabilities (1 moderate, 2 high)[[/fg]]",
+      "  Run `npm audit fix` to fix them",
+      "",
+      `Package size: 2.3 MB for a function that pads strings`,
+      "Worth it? [[fg:red]]Absolutely not.[[/fg]] Did we do it anyway? [[fg:green]]Yes.[[/fg]]"
+    ];
+    return {
+      command: config["command"] ?? `npm install ${pkg}`,
+      lines,
+      typing: "medium",
+      pause: "long"
+    };
+  }
+};
+
+// src/blocks/blog-post.ts
+import { z as z13 } from "zod";
+var blogPostSchema = z13.object({
+  title: z13.string().optional(),
+  url: z13.string().optional(),
+  width: z13.number().positive().optional(),
+  command: z13.string().optional()
+}).strict();
+var blogPostBlock = {
+  name: "blog-post",
+  description: "Display a blog post title in a box",
+  configSchema: blogPostSchema,
+  render(context, config) {
+    const title = config["title"] ?? "My Latest Post";
+    const url = config["url"] ?? "";
+    const width = resolveBoxWidth(config["width"], context);
+    const lines = ["", "\u{1F4DD} LATEST FROM THE BLOG", "", title];
+    if (url) lines.push("", `\u{1F517} ${url}`);
+    lines.push("");
+    const box = createRoundedBox(lines, width);
+    return {
+      command: config["command"] ?? "curl -s blog/feed.xml | grep -m1 title",
+      lines: box.split("\n"),
+      typing: "slow",
+      pause: "medium"
+    };
+  }
+};
+
+// src/blocks/national-day.ts
+import { z as z14 } from "zod";
+var dayEntrySchema = z14.object({
+  name: z14.string(),
+  desc: z14.string(),
+  emoji: z14.string()
+}).strict();
+var nationalDaySchema = z14.object({
+  days: z14.array(dayEntrySchema).optional(),
+  width: z14.number().positive().optional(),
+  command: z14.string().optional()
+}).strict();
+var nationalDayBlock = {
+  name: "national-day",
+  description: "Display a fun national day celebration",
+  configSchema: nationalDaySchema,
+  render(context, config) {
+    const days = config["days"] ?? [];
+    const width = resolveBoxWidth(config["width"], context);
+    const dayOfYear = Math.floor(
+      (context.now.getTime() - new Date(context.now.getFullYear(), 0, 0).getTime()) / 864e5
+    );
+    const day = days.length > 0 ? days[dayOfYear % days.length] : { name: "National Coding Day", desc: "Write some code!", emoji: "\u{1F4BB}" };
+    if (!day) {
+      return { command: "curl -s whatday.today/api | jq .today", lines: ["No days configured"] };
+    }
+    const nameMax = Math.max(10, width - 14);
+    const descMax = Math.max(10, width - 8);
+    const name = day.name.length > nameMax ? day.name.substring(0, nameMax - 3) + "..." : day.name;
+    const desc = day.desc.length > descMax ? day.desc.substring(0, descMax - 3) + "..." : day.desc;
+    const lines = ["", `${day.emoji} Today is ${name}`, `  "${desc}"`, ""];
+    const box = createRoundedBox(lines, width);
+    return {
+      command: config["command"] ?? "curl -s whatday.today/api | jq .today",
+      lines: box.split("\n"),
+      typing: "medium",
+      pause: "medium"
+    };
+  }
+};
+
+// src/blocks/systemctl.ts
+import { z as z15 } from "zod";
+var systemctlSchema = z15.object({
+  service: z15.string().optional(),
+  description: z15.string().optional(),
+  pid: z15.string().optional(),
+  memory: z15.string().optional(),
+  logs: z15.array(z15.string()).optional(),
+  command: z15.string().optional()
+}).strict();
+var systemctlBlock = {
+  name: "systemctl",
+  description: "Display a systemd-style service status",
+  configSchema: systemctlSchema,
+  render(context, config) {
+    const service = config["service"] ?? "dev-mode.service";
+    const description = config["description"] ?? "Development Mode Service";
+    const pid = config["pid"] ?? "1337";
+    const memory = config["memory"] ?? "42.0M";
+    const statusLines = config["logs"] ?? [
+      "Service started successfully",
+      "Maximum productivity achieved"
+    ];
+    const timestamp = context.now.toISOString().slice(0, 19).replace("T", " ");
+    const lines = [
+      `\u25CF [[fg:cyan]]${service}[[/fg]] - ${description}`,
+      `     [[fg:purple]]Loaded:[[/fg]] loaded (/etc/systemd/${service}; [[fg:green]]enabled[[/fg]])`,
+      `     [[fg:purple]]Active:[[/fg]] [[fg:green]]active (running)[[/fg]] since boot`,
+      `   [[fg:purple]]Main PID:[[/fg]] ${pid} (${service.replace(".service", "")})`,
+      `      [[fg:purple]]Tasks:[[/fg]] \u221E`,
+      `     [[fg:purple]]Memory:[[/fg]] ${memory}`
+    ];
+    for (const log of statusLines) {
+      lines.push(`${timestamp} ${service}[${pid}]: [[fg:green]]\u2713[[/fg]] ${log}`);
+    }
+    return {
+      command: config["command"] ?? `systemctl status ${service}`,
+      lines,
+      typing: "slow",
+      pause: "long"
+    };
+  }
+};
+
+// src/blocks/github-stats.ts
+import { z as z16 } from "zod";
+var githubStatsSchema = z16.object({
+  username: z16.string().optional(),
+  width: z16.number().positive().optional(),
+  command: z16.string().optional()
+}).strict();
+function formatCount(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+  return String(n);
+}
+var githubStatsBlock = {
+  name: "github-stats",
+  description: "Display live GitHub user statistics",
+  configSchema: githubStatsSchema,
+  cacheable: true,
+  async render(context, config) {
+    const username = config["username"] ?? "";
+    const width = resolveBoxWidth(config["width"], context);
+    const timeout = context.config.fetchTimeout;
+    if (!username) {
+      return {
+        command: "gh api users/???",
+        lines: ["[[fg:yellow]]github-stats: no username configured[[/fg]]"],
+        typing: "fast",
+        pause: "short"
+      };
+    }
+    const url = `https://api.github.com/users/${encodeURIComponent(username)}`;
+    const cacheKey = `github-stats:${hashConfig(config)}`;
+    const data = context.useCache ? await context.useCache(cacheKey, () => fetchJson(url, timeout)) : await fetchJson(url, timeout);
+    let lines;
+    if (data) {
+      const since = new Date(data.created_at);
+      const sinceStr = `${since.toLocaleString("en-US", { month: "short" })} ${since.getFullYear()}`;
+      lines = [
+        "",
+        `[[fg:cyan]]GITHUB: @${username}[[/fg]]`,
+        `Repos: [[bold]]${formatCount(data.public_repos)}[[/bold]]    Followers: [[bold]]${formatCount(data.followers)}[[/bold]]`,
+        `Following: ${formatCount(data.following)}    Gists: ${formatCount(data.public_gists)}`,
+        `Member since: ${sinceStr}`,
+        ""
+      ];
+    } else {
+      lines = [
+        "",
+        `[[fg:yellow]]GitHub stats unavailable for @${username}[[/fg]]`,
+        ""
+      ];
+    }
+    const box = createDoubleBox(lines, width);
+    return {
+      command: config["command"] ?? `gh api users/${username} --jq '.public_repos,.followers'`,
+      lines: box.split("\n"),
+      typing: "fast",
+      pause: "medium",
+      fallback: !data
+    };
+  }
+};
+
+// src/blocks/github-languages.ts
+import { z as z17 } from "zod";
+var githubLanguagesSchema = z17.object({
+  username: z17.string().optional(),
+  top: z17.number().int().min(1).max(10).optional(),
+  command: z17.string().optional(),
+  barWidth: z17.number().int().min(5).max(40).optional(),
+  fallback: z17.array(z17.object({
+    name: z17.string(),
+    percent: z17.number()
+  })).optional()
+}).strict();
+var ROW_COLORS = ["cyan", "green", "yellow", "magenta", "blue"];
+var STATIC_FALLBACK = [
+  { name: "TypeScript", percent: 65 },
+  { name: "JavaScript", percent: 20 },
+  { name: "Rust", percent: 10 },
+  { name: "Go", percent: 5 }
+];
+function aggregate(repos, top) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const repo of repos) {
+    if (!repo.language) continue;
+    counts.set(repo.language, (counts.get(repo.language) ?? 0) + 1);
+  }
+  const total = Array.from(counts.values()).reduce((a, b) => a + b, 0);
+  if (total === 0) return [];
+  const sorted = Array.from(counts.entries()).sort((a, b) => b[1] - a[1]).slice(0, top).map(([name, count]) => ({
+    name,
+    percent: Math.round(count / total * 100)
+  }));
+  return sorted;
+}
+function renderSlices(slices, barWidth) {
+  if (slices.length === 0) {
+    return ["[[fg:yellow]]github-languages: no language data available[[/fg]]"];
+  }
+  const nameWidth = Math.max(...slices.map((s) => s.name.length));
+  return slices.map((slice, i) => {
+    const color = ROW_COLORS[i % ROW_COLORS.length];
+    const filled = Math.round(slice.percent / 100 * barWidth);
+    const bar = "\u2588".repeat(filled) + "\u2591".repeat(barWidth - filled);
+    const namePadded = slice.name.padEnd(nameWidth, " ");
+    const pctPadded = `${slice.percent}%`.padStart(4, " ");
+    return `[[fg:${color}]]${namePadded}[[/fg]]  [[fg:${color}]]${bar}[[/fg]] ${pctPadded}`;
+  });
+}
+var githubLanguagesBlock = {
+  name: "github-languages",
+  description: "Top languages in a user's public repos, with percentage bars",
+  configSchema: githubLanguagesSchema,
+  cacheable: true,
+  async render(context, config) {
+    const username = config["username"] ?? "";
+    const top = config["top"] ?? 5;
+    const barWidth = config["barWidth"] ?? 20;
+    const userFallback = config["fallback"];
+    const timeout = context.config.fetchTimeout;
+    const fallbackSlices = (userFallback && userFallback.length > 0 ? userFallback : STATIC_FALLBACK).slice(0, top);
+    if (!username) {
+      return {
+        command: config["command"] ?? 'gh api users/???/repos --jq "[.[].language] | group_by(.) | ..."',
+        lines: renderSlices(fallbackSlices, barWidth),
+        typing: "fast",
+        pause: "medium",
+        fallback: true
+      };
+    }
+    const url = `https://api.github.com/users/${encodeURIComponent(username)}/repos?per_page=100`;
+    const cacheKey = `github-languages:${hashConfig({ username, top })}`;
+    const repos = context.useCache ? await context.useCache(cacheKey, () => fetchJson(url, timeout)) : await fetchJson(url, timeout);
+    let slices;
+    let usedFallback = false;
+    if (repos && Array.isArray(repos)) {
+      const aggregated = aggregate(repos, top);
+      if (aggregated.length > 0) {
+        slices = aggregated;
+      } else {
+        slices = fallbackSlices;
+        usedFallback = true;
+      }
+    } else {
+      slices = fallbackSlices;
+      usedFallback = true;
+    }
+    return {
+      command: config["command"] ?? `gh api users/${username}/repos --jq '[.[].language] | group_by(.) | map({k: .[0], n: length})'`,
+      lines: renderSlices(slices, barWidth),
+      typing: "fast",
+      pause: "medium",
+      fallback: usedFallback
+    };
+  }
+};
+
+// src/blocks/quote.ts
+import { z as z18 } from "zod";
+var quoteSchema = z18.object({
+  fallback: z18.string().optional(),
+  fallbackAuthor: z18.string().optional(),
+  width: z18.number().positive().optional(),
+  command: z18.string().optional()
+}).strict();
+var quoteBlock = {
+  name: "quote",
+  description: "Display a random inspirational quote",
+  configSchema: quoteSchema,
+  cacheable: true,
+  async render(context, config) {
+    const width = resolveBoxWidth(config["width"], context);
+    const userFallback = config["fallback"];
+    const userFallbackAuthor = config["fallbackAuthor"];
+    const timeout = context.config.fetchTimeout;
+    const url = "https://dummyjson.com/quotes/random";
+    const cacheKey = `quote:${hashConfig(config)}`;
+    const data = context.useCache ? await context.useCache(cacheKey, () => fetchJson(url, timeout)) : await fetchJson(url, timeout);
+    let quote;
+    let author;
+    const isFallback = !data;
+    if (data) {
+      quote = data.quote;
+      author = data.author;
+    } else if (userFallback) {
+      quote = userFallback;
+      author = userFallbackAuthor ?? "";
+    } else {
+      const idx = Math.floor(context.now.getTime() / 864e5) % DEFAULT_FORTUNES.length;
+      const entry = DEFAULT_FORTUNES[idx] ?? DEFAULT_FORTUNES[0];
+      const m = /^(.*?)\s*—\s*(.+)$/.exec(entry);
+      if (m) {
+        quote = m[1];
+        author = m[2];
+      } else {
+        quote = entry;
+        author = "Unknown";
+      }
+    }
+    const maxLineWidth = width - 6;
+    const words = quote.split(" ");
+    const quoteLines = [];
+    let currentLine = "";
+    for (const word of words) {
+      if (currentLine.length + word.length + 1 > maxLineWidth) {
+        quoteLines.push(currentLine);
+        currentLine = word;
+      } else {
+        currentLine = currentLine ? `${currentLine} ${word}` : word;
+      }
+    }
+    if (currentLine) quoteLines.push(currentLine);
+    const lines = [
+      "",
+      ...quoteLines.map((l, i) => i === 0 ? `[[fg:green]]"${l}` : `[[fg:green]] ${l}`)
+    ];
+    const lastIdx = lines.length - 1;
+    lines[lastIdx] = `${lines[lastIdx]}"[[/fg]]`;
+    lines.push(`[[fg:comment]]  \u2014 ${author}[[/fg]]`);
+    lines.push("");
+    const box = createDoubleBox(lines, width);
+    return {
+      command: config["command"] ?? "fortune",
+      lines: box.split("\n"),
+      typing: "fast",
+      pause: "long",
+      fallback: isFallback
+    };
+  }
+};
+
+// src/blocks/fun-fact.ts
+import { z as z19 } from "zod";
+var funFactSchema = z19.object({
+  language: z19.string().optional(),
+  fallback: z19.string().optional(),
+  width: z19.number().positive().optional(),
+  command: z19.string().optional()
+}).strict();
+var funFactBlock = {
+  name: "fun-fact",
+  description: "Display a random fun fact",
+  configSchema: funFactSchema,
+  cacheable: true,
+  async render(context, config) {
+    const width = resolveBoxWidth(config["width"], context);
+    const language = config["language"] ?? "en";
+    const fallback = config["fallback"] ?? "Honey never spoils. Archaeologists have found 3000-year-old honey that was still edible.";
+    const timeout = context.config.fetchTimeout;
+    const url = `https://uselessfacts.jsph.pl/api/v2/facts/random?language=${encodeURIComponent(language)}`;
+    const cacheKey = `fun-fact:${hashConfig(config)}`;
+    const data = context.useCache ? await context.useCache(cacheKey, () => fetchJson(url, timeout)) : await fetchJson(url, timeout);
+    const factText = data?.text ?? fallback;
+    const isFallback = !data?.text;
+    const maxLineWidth = width - 6;
+    const words = factText.split(" ");
+    const factLines = [];
+    let currentLine = "";
+    for (const word of words) {
+      if (currentLine.length + word.length + 1 > maxLineWidth) {
+        factLines.push(currentLine);
+        currentLine = word;
+      } else {
+        currentLine = currentLine ? `${currentLine} ${word}` : word;
+      }
+    }
+    if (currentLine) factLines.push(currentLine);
+    const lines = [
+      "",
+      "[[fg:yellow]]DID YOU KNOW?[[/fg]]",
+      "",
+      ...factLines,
+      ""
+    ];
+    const box = createDoubleBox(lines, width);
+    return {
+      command: config["command"] ?? "curl -s uselessfacts.jsph.pl/api/v2/facts/random | jq .text",
+      lines: box.split("\n"),
+      typing: "fast",
+      pause: "medium",
+      fallback: isFallback
+    };
+  }
+};
+
+// src/blocks/vim-exit.ts
+import { z as z20 } from "zod";
+var vimExitSchema = z20.object({
+  command: z20.string().optional()
+}).strict();
+var vimExitBlock = {
+  name: "vim-exit",
+  description: 'The classic "how do I exit vim?" message',
+  configSchema: vimExitSchema,
+  render(_context, config) {
+    const command = config["command"] ?? "vim";
+    return {
+      command,
+      lines: [
+        "[[fg:comment]]~                              VIM - Vi IMproved[[/fg]]",
+        "[[fg:comment]]~                                                [[/fg]]",
+        "[[fg:comment]]~                version 9.1.0                   [[/fg]]",
+        "[[fg:comment]]~       by Bram Moolenaar et al.                 [[/fg]]",
+        "[[fg:comment]]~                                                [[/fg]]",
+        "[[fg:yellow]]How do you exit this thing?[[/fg]]",
+        "",
+        "  type  [[fg:cyan]]:q[[/fg]]   to quit",
+        "  type  [[fg:cyan]]:q![[/fg]]  to force-quit without saving",
+        "  type  [[fg:cyan]]:wq[[/fg]]  to save and quit",
+        "",
+        "[[dim]]  (you were never in insert mode anyway)[[/dim]]"
+      ],
+      pause: "medium"
+    };
+  }
+};
+
+// src/blocks/sudo-sandwich.ts
+import { z as z21 } from "zod";
+var sudoSandwichSchema = z21.object({
+  user: z21.string().optional(),
+  command: z21.string().optional()
+}).strict();
+var sudoSandwichBlock = {
+  name: "sudo-sandwich",
+  description: 'xkcd 149 "make me a sandwich" callback',
+  configSchema: sudoSandwichSchema,
+  render(_context, config) {
+    const user = config["user"] ?? "dev";
+    const command = config["command"] ?? "sudo make me a sandwich";
+    return {
+      command,
+      lines: [
+        `[sudo] password for ${user}:`,
+        "",
+        "[[fg:green]]OK.[[/fg]]",
+        "",
+        "[[dim]]  (Reference: https://xkcd.com/149/)[[/dim]]"
+      ]
+    };
+  }
+};
+
+// src/blocks/rm-rf.ts
+import { z as z22 } from "zod";
+var rmRfSchema = z22.object({
+  command: z22.string().optional()
+}).strict();
+var rmRfBlock = {
+  name: "rm-rf",
+  description: "Fake `rm -rf /` with dramatic narration",
+  configSchema: rmRfSchema,
+  render(_context, config) {
+    const command = config["command"] ?? "sudo rm -rf / --no-preserve-root";
+    return {
+      command,
+      lines: [
+        "[[fg:red]]rm: WARNING: recursively removing root filesystem[[/fg]]",
+        "",
+        "  removed /etc                \u2713",
+        "  removed /usr/bin            \u2713",
+        "  removed /home               \u2713  [[dim]](you are still reading this how)[[/dim]]",
+        "  removed /var/log            \u2713",
+        "  removed [[fg:yellow]]/dev/sanity[[/fg]]      \u2713  [[dim]](no such file)[[/dim]]",
+        "",
+        "[[fg:red]]System integrity: 0%[[/fg]]",
+        "[[dim]]  Hint: update your r\xE9sum\xE9 before the next standup.[[/dim]]"
+      ],
+      pause: "long"
+    };
+  }
+};
+
+// src/blocks/fork-bomb.ts
+import { z as z23 } from "zod";
+var forkBombSchema = z23.object({
+  command: z23.string().optional()
+}).strict();
+var forkBombBlock = {
+  name: "fork-bomb",
+  description: "Mock fork-bomb warning with practical consequences",
+  configSchema: forkBombSchema,
+  render(_context, config) {
+    const command = config["command"] ?? ":(){ :|:& };:";
+    return {
+      command,
+      lines: [
+        "[[fg:red]]bash: fork-bomb pattern detected[[/fg]]",
+        "",
+        "Running this will:",
+        "  \u2022 spawn processes until the kernel gives up",
+        "  \u2022 turn your laptop fan into a leaf blower",
+        "  \u2022 leave only [[fg:cyan]]REISUB[[/fg]] as escape",
+        "",
+        "[[fg:yellow]]Proceed? [y/N][[/fg]] [[dim]]_[[/dim]]",
+        "",
+        "[[dim]]  (just kidding, nothing was actually executed)[[/dim]]"
+      ]
+    };
+  }
+};
+
+// src/blocks/kernel-panic.ts
+import { z as z24 } from "zod";
+var kernelPanicSchema = z24.object({
+  command: z24.string().optional()
+}).strict();
+var kernelPanicBlock = {
+  name: "kernel-panic",
+  description: "A friendly kernel panic / BSOD spoof",
+  configSchema: kernelPanicSchema,
+  render(_context, config) {
+    const command = config["command"] ?? "dmesg | tail";
+    return {
+      command,
+      lines: [
+        "[[fg:blue]][[bold]]:( [[/bold]][[/fg]]",
+        "",
+        "[[fg:white]]Your terminal ran into a problem and needs to think things over.[[/fg]]",
+        "",
+        "  Stop code:  [[fg:cyan]]CRITICAL_PROCESS_DIED[[/fg]]",
+        "  Process:    [[fg:cyan]]hopes_and_dreams.exe[[/fg]]",
+        "  Started:    Monday 09:01",
+        "  Crashed:    Monday 09:02",
+        "",
+        "[[fg:white]]What you can try:[[/fg]]",
+        "  \u2022 Reduce coffee intake (not recommended)",
+        "  \u2022 Recompile with [[fg:cyan]]-O0[[/fg]] and pray",
+        "  \u2022 [[fg:green]]git commit --all[[/fg]] just in case",
+        "",
+        "[[dim]]  collecting error info... 100%[[/dim]]"
+      ],
+      pause: "long"
+    };
+  }
+};
+
+// src/blocks/segfault.ts
+import { z as z25 } from "zod";
+var segfaultSchema = z25.object({
+  program: z25.string().optional(),
+  command: z25.string().optional()
+}).strict();
+var segfaultBlock = {
+  name: "segfault",
+  description: "Fake segmentation fault with a corrupted backtrace",
+  configSchema: segfaultSchema,
+  render(_context, config) {
+    const command = config["command"] ?? "./a.out";
+    const program = config["program"] ?? "a.out";
+    return {
+      command,
+      lines: [
+        `[[fg:red]]Segmentation fault (core dumped)[[/fg]]  [[dim]](${program})[[/dim]]`,
+        "",
+        "  fault address:  [[fg:cyan]]0xDEADBEEF[[/fg]]",
+        "  rip:            [[fg:cyan]]0xCAFEBABE[[/fg]]",
+        "  rsp:            [[fg:red]]CORRUPTED[[/fg]]",
+        "",
+        "[[fg:yellow]]backtrace:[[/fg]]",
+        "  #0  0x4141414141 in [[fg:cyan]]main[[/fg]] ()",
+        "  #1  0x4242424242 in [[fg:cyan]]definitely_not_a_bug[[/fg]] ()",
+        "  #2  0x???        in [[fg:red]]<corrupted>[[/fg]]",
+        "",
+        "[[dim]]  Tip: it was a null pointer. it is always a null pointer.[[/dim]]"
+      ]
+    };
+  }
+};
+
+// src/blocks/whoami.ts
+import { z as z26 } from "zod";
+var whoamiSchema = z26.object({
+  user: z26.string().optional(),
+  /** UID, GID, and group memberships for the default 1-line `whoami -a` style. */
+  uid: z26.number().int().nonnegative().optional(),
+  gid: z26.number().int().nonnegative().optional(),
+  groups: z26.array(z26.string()).optional(),
+  /** Opt into the previous existential-bullets render (multi-line). */
+  verbose: z26.boolean().optional(),
+  /** Override the bullets shown in verbose mode. */
+  bullets: z26.array(z26.string()).optional(),
+  command: z26.string().optional()
+}).strict();
+var whoamiBlock = {
+  name: "whoami",
+  description: "Real `whoami -a` style (default) or existential bullets via `verbose: true`",
+  configSchema: whoamiSchema,
+  render(_context, config) {
+    const user = config["user"] ?? "dev";
+    const command = config["command"] ?? "whoami";
+    const verbose = config["verbose"] ?? false;
+    if (!verbose) {
+      const uid = config["uid"] ?? 1e3;
+      const gid = config["gid"] ?? 1e3;
+      const groups = config["groups"] ?? [`${uid}(${user})`, "100(users)", "27(sudo)", "999(docker)"];
+      return {
+        command,
+        lines: [
+          `uid=${uid}([[fg:green]]${user}[[/fg]]) gid=${gid}(${user}) groups=${groups.join(",")}`
+        ]
+      };
+    }
+    const bullets = config["bullets"] ?? [
+      "a developer?            [[fg:green]]sort of[[/fg]]",
+      "a debugger?             [[fg:green]]always[[/fg]]",
+      "awake?                  [[fg:yellow]]debatable[[/fg]]",
+      "productive?             [[fg:red]]ask after coffee[[/fg]]"
+    ];
+    return {
+      command,
+      lines: [
+        user,
+        "",
+        "[[dim]]but who are you really?[[/dim]]",
+        ...bullets.map((b) => `  \u2022 ${b}`)
+      ]
+    };
+  }
+};
+
+// src/blocks/last-login.ts
+import { z as z27 } from "zod";
+var loginEntrySchema = z27.object({
+  user: z27.string().optional(),
+  tty: z27.string().optional(),
+  when: z27.string(),
+  note: z27.string().optional()
+}).strict();
+var lastLoginSchema = z27.object({
+  user: z27.string().optional(),
+  entries: z27.array(loginEntrySchema).optional(),
+  command: z27.string().optional()
+}).strict();
+var lastLoginBlock = {
+  name: "last-login",
+  description: "`last` output with embarrassing timestamps and parentheticals",
+  configSchema: lastLoginSchema,
+  render(_context, config) {
+    const user = config["user"] ?? "dev";
+    const command = config["command"] ?? "last -n 4";
+    const entries = config["entries"] ?? [
+      { tty: "pts/0", when: "Tue  03:47 - still logged in", note: "debugging sleep.c" },
+      { tty: "pts/1", when: "Mon  23:12 - 23:13  (00:01)", note: "oops wrong button" },
+      { tty: "pts/0", when: "Mon  14:33 - 14:34  (00:01)", note: "left slack open" },
+      { tty: "pts/0", when: "Fri  09:00 - still logged in", note: "actually working?" }
+    ];
+    const lines = entries.map((e) => {
+      const u = (e.user ?? user).padEnd(8);
+      const tty = (e.tty ?? "pts/0").padEnd(7);
+      const note = e.note ? `   [[dim]](${e.note})[[/dim]]` : "";
+      return `${u} ${tty} ${e.when}${note}`;
+    });
+    return { command, lines };
+  }
+};
+
+// src/blocks/finger.ts
+import { z as z28 } from "zod";
+var fingerSchema = z28.object({
+  user: z28.string().optional(),
+  shell: z28.string().optional(),
+  directory: z28.string().optional(),
+  lastLogin: z28.string().optional(),
+  mail: z28.number().int().min(0).optional(),
+  plan: z28.array(z28.string()).optional(),
+  command: z28.string().optional()
+}).strict();
+var fingerBlock = {
+  name: "finger",
+  description: "Faux finger(1) user info card",
+  configSchema: fingerSchema,
+  render(_context, config) {
+    const user = config["user"] ?? "dev";
+    const command = config["command"] ?? `finger ${user}`;
+    const shell = config["shell"] ?? "/bin/bash (and vim, and screaming)";
+    const directory = config["directory"] ?? `/home/${user}`;
+    const lastLogin = config["lastLogin"] ?? "2 minutes ago, from keyboard";
+    const mail = config["mail"] ?? 842;
+    const plan = config["plan"] ?? [
+      "too many tabs open",
+      "coffee dependency: critical",
+      "debugger of broken dreams"
+    ];
+    return {
+      command,
+      lines: [
+        `Login:     ${user}`,
+        `Directory: ${directory}`,
+        `Shell:     ${shell}`,
+        `Last login: ${lastLogin}`,
+        `New mail:  [[fg:red]]${mail}[[/fg]] [[dim]](unread since 2019)[[/dim]]`,
+        "",
+        "Plan:",
+        ...plan.map((p) => `  \u2022 ${p}`)
+      ]
+    };
+  }
+};
+
+// src/blocks/who.ts
+import { z as z29 } from "zod";
+var whoEntrySchema = z29.object({
+  user: z29.string(),
+  tty: z29.string().optional(),
+  when: z29.string(),
+  note: z29.string().optional()
+}).strict();
+var whoSchema = z29.object({
+  user: z29.string().optional(),
+  entries: z29.array(whoEntrySchema).optional(),
+  command: z29.string().optional()
+}).strict();
+var whoBlock = {
+  name: "who",
+  description: "`who` output with ghost users (debugger, coffee, sanity)",
+  configSchema: whoSchema,
+  render(_context, config) {
+    const user = config["user"] ?? "dev";
+    const command = config["command"] ?? "who";
+    const entries = config["entries"] ?? [
+      { user, tty: "pts/0", when: "today 09:14" },
+      { user: "debugger", tty: "pts/1", when: "today 09:14", note: "the ghost in the machine" },
+      { user: "coffee", tty: "pts/2", when: "today 03:47", note: "stimulant.exe is running" },
+      { user: "sanity", tty: "?", when: "last seen Friday", note: "checked out of reality" }
+    ];
+    const lines = entries.map((e) => {
+      const u = e.user.padEnd(9);
+      const tty = (e.tty ?? "?").padEnd(7);
+      const note = e.note ? `   [[dim]](${e.note})[[/dim]]` : "";
+      return `${u} ${tty} ${e.when}${note}`;
+    });
+    return { command, lines };
+  }
+};
+
+// src/blocks/uptime.ts
+import { z as z30 } from "zod";
+var uptimeSchema = z30.object({
+  days: z30.number().int().min(0).optional(),
+  users: z30.number().int().min(0).optional(),
+  load: z30.tuple([z30.number(), z30.number(), z30.number()]).optional(),
+  lastIncident: z30.string().optional(),
+  command: z30.string().optional()
+}).strict();
+var uptimeBlock = {
+  name: "uptime",
+  description: "Fake uptime with absurd numbers and SRE commentary",
+  configSchema: uptimeSchema,
+  render(context, config) {
+    const days = config["days"] ?? 632;
+    const users = config["users"] ?? 1;
+    const load = config["load"] ?? [0.42, 0.37, 0.31];
+    const lastIncident = config["lastIncident"] ?? "that one incident";
+    const command = config["command"] ?? "uptime";
+    const time = context.now.toLocaleTimeString("en-GB", { hour12: false });
+    const loadStr = load.map((n) => n.toFixed(2)).join(", ");
+    return {
+      command,
+      lines: [
+        ` ${time}  up ${days} days,  3:14,  ${users} user,  load average: ${loadStr}`,
+        "",
+        `[[dim]](last reboot: ${lastIncident} \u2014 don't touch it)[[/dim]]`,
+        "",
+        "System health: [[fg:green]]STABLE[[/fg]]"
+      ]
+    };
+  }
+};
+
+// src/blocks/matrix-rain.ts
+import { z as z31 } from "zod";
+var matrixRainSchema = z31.object({
+  rows: z31.number().int().min(1).max(40).optional(),
+  cols: z31.number().int().min(1).max(200).optional(),
+  message: z31.string().optional(),
+  command: z31.string().optional()
+}).strict();
+var KATAKANA = "\u30F2\u30A2\u30A4\u30A6\u30A8\u30AA\u30AB\u30AD\u30AF\u30B1\u30B3\u30B5\u30B7\u30B9\u30BB\u30BD\u30BF\u30C1\u30C4\u30C6\u30C8\u30CA\u30CB\u30CC\u30CD\u30CE\u30CF\u30D2\u30D5\u30D8\u30DB\u30DE\u30DF\u30E0\u30E1\u30E2\u30E4\u30E6\u30E8\u30E9\u30EA\u30EB\u30EC\u30ED\u30EF\u30F3";
+var DIGITS = "0123456789";
+var SYMBOLS = "*+-=<>:;[](){}/\\|";
+var POOL = (KATAKANA + DIGITS + SYMBOLS).split("");
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var matrixRainBlock = {
+  name: "matrix-rain",
+  description: "Single-frame Matrix rain screen with ACCESS GRANTED footer",
+  configSchema: matrixRainSchema,
+  render(context, config) {
+    const command = config["command"] ?? "./neo.sh";
+    const rows = config["rows"] ?? 6;
+    const cols = config["cols"] ?? 56;
+    const message = config["message"] ?? "access granted.";
+    const dayOfYear = Math.floor(context.now.getTime() / 864e5);
+    const rand = mulberry32(dayOfYear);
+    const lines = [];
+    for (let r = 0; r < rows; r++) {
+      let row = "";
+      for (let c = 0; c < cols; c++) {
+        row += POOL[Math.floor(rand() * POOL.length)] ?? " ";
+      }
+      lines.push(`[[fg:green]]${row}[[/fg]]`);
+    }
+    lines.push("");
+    lines.push(`[[fg:green]][[bold]]> ${message}[[/bold]][[/fg]]`);
+    return { command, lines, color: "green" };
+  }
+};
+
+// src/blocks/cowsay.ts
+import { z as z32 } from "zod";
+var cowsaySchema = z32.object({
+  say: z32.string().optional(),
+  width: z32.number().int().min(8).max(200).optional(),
+  command: z32.string().optional()
+}).strict();
+function wrap(text, width) {
+  const out = [];
+  for (const para of text.split("\n")) {
+    if (para.length === 0) {
+      out.push("");
+      continue;
+    }
+    let line = "";
+    for (const word of para.split(/\s+/)) {
+      if (word.length === 0) continue;
+      if (word.length > width) {
+        if (line) out.push(line);
+        for (let i = 0; i < word.length; i += width) out.push(word.slice(i, i + width));
+        line = "";
+        continue;
+      }
+      const next = line ? `${line} ${word}` : word;
+      if (next.length > width) {
+        out.push(line);
+        line = word;
+      } else {
+        line = next;
+      }
+    }
+    if (line) out.push(line);
+  }
+  return out;
+}
+function bubble(lines, inner) {
+  if (lines.length === 0) return [];
+  const out = [];
+  out.push(" " + "_".repeat(inner + 2));
+  if (lines.length === 1) {
+    out.push(`< ${lines[0].padEnd(inner)} >`);
+  } else {
+    for (let i = 0; i < lines.length; i++) {
+      const left = i === 0 ? "/" : i === lines.length - 1 ? "\\" : "|";
+      const right = i === 0 ? "\\" : i === lines.length - 1 ? "/" : "|";
+      out.push(`${left} ${lines[i].padEnd(inner)} ${right}`);
+    }
+  }
+  out.push(" " + "-".repeat(inner + 2));
+  return out;
+}
+var COW = [
+  "        \\   ^__^",
+  "         \\  (oo)\\_______",
+  "            (__)\\       )\\/\\",
+  "                ||----w |",
+  "                ||     ||"
+];
+var cowsayBlock = {
+  name: "cowsay",
+  description: "A cow says something. The cow is always right.",
+  configSchema: cowsaySchema,
+  render(_context, config) {
+    const command = config["command"] ?? "cowsay";
+    const say = config["say"] ?? "moo. I am a cow.";
+    const width = Math.max(8, config["width"] ?? 40);
+    const wrapped = wrap(say, width);
+    const inner = Math.max(...wrapped.map((l) => l.length), 1);
+    return {
+      command,
+      lines: [...bubble(wrapped, inner), ...COW]
+    };
+  }
+};
+
+// src/blocks/loading-spinner.ts
+import { z as z33 } from "zod";
+var BRAILLE_FRAMES = ["\u28F7", "\u28EF", "\u28DF", "\u287F", "\u28BF", "\u28FB", "\u28FD", "\u28FE"];
+var loadingSpinnerSchema = z33.object({
+  label: z33.string().optional(),
+  fps: z33.number().int().min(1).max(30).optional(),
+  command: z33.string().optional(),
+  color: z33.string().optional()
+}).strict();
+var loadingSpinnerBlock = {
+  name: "loading-spinner",
+  description: "A Braille spinner that cycles continuously",
+  configSchema: loadingSpinnerSchema,
+  render(_context, config) {
+    const label = config["label"] ?? "loading";
+    const fps = config["fps"] ?? 8;
+    const command = config["command"] ?? "npm install";
+    const color = config["color"] ?? "cyan";
+    const frames = BRAILLE_FRAMES.map((g) => [`[[fg:${color}]]${g}[[/fg]] ${label}...`]);
+    return {
+      command,
+      lines: frames[0],
+      // static fallback (first frame)
+      animation: { frames, fps }
+    };
+  }
+};
+
+// src/blocks/heartbeat.ts
+import { z as z34 } from "zod";
+var HEART_FRAMES = ["   ", " \u2665 ", " \u2665 ", " \u2665 ", "   "];
+var heartbeatSchema = z34.object({
+  label: z34.string().optional(),
+  color: z34.string().optional(),
+  fps: z34.number().int().min(1).max(30).optional(),
+  command: z34.string().optional()
+}).strict();
+var heartbeatBlock = {
+  name: "heartbeat",
+  description: "Pulsing heart for a project you love",
+  configSchema: heartbeatSchema,
+  render(_context, config) {
+    const label = config["label"] ?? "with love";
+    const color = config["color"] ?? "red";
+    const fps = config["fps"] ?? 4;
+    const command = config["command"] ?? "made-with --love";
+    const frames = HEART_FRAMES.map((g) => [`[[fg:${color}]]${g}[[/fg]] ${label}`]);
+    return {
+      command,
+      lines: frames[0],
+      animation: { frames, fps }
+    };
+  }
+};
+
+// src/blocks/spinning-gear.ts
+import { z as z35 } from "zod";
+var GEAR_FRAMES = ["|", "/", "-", "\\"];
+var spinningGearSchema = z35.object({
+  label: z35.string().optional(),
+  color: z35.string().optional(),
+  fps: z35.number().int().min(1).max(30).optional(),
+  command: z35.string().optional()
+}).strict();
+var spinningGearBlock = {
+  name: "spinning-gear",
+  description: 'Rotating ASCII gear \u2014 the "machinery working" feel',
+  configSchema: spinningGearSchema,
+  render(_context, config) {
+    const label = config["label"] ?? "processing";
+    const color = config["color"] ?? "yellow";
+    const fps = config["fps"] ?? 6;
+    const command = config["command"] ?? "service status";
+    const frames = GEAR_FRAMES.map((g) => [`[[fg:${color}]]${g}[[/fg]] ${label}`]);
+    return {
+      command,
+      lines: frames[0],
+      animation: { frames, fps }
+    };
+  }
+};
+
+// src/blocks/blinking-eyes.ts
+import { z as z36 } from "zod";
+var EYE_FRAMES = [
+  "( \u25C9 \u25E1 \u25C9 )",
+  "( \u25C9 \u25E1 \u25C9 )",
+  "( \u25C9 \u25E1 \u25C9 )",
+  "( \u25C9 \u25E1 \u25C9 )",
+  "( - \u25E1 - )",
+  "( \u25C9 \u25E1 \u25C9 )"
+];
+var blinkingEyesSchema = z36.object({
+  label: z36.string().optional(),
+  color: z36.string().optional(),
+  fps: z36.number().int().min(1).max(30).optional(),
+  command: z36.string().optional()
+}).strict();
+var blinkingEyesBlock = {
+  name: "blinking-eyes",
+  description: "Kaomoji eyes that blink \u2014 README mascot that feels alive",
+  configSchema: blinkingEyesSchema,
+  render(_context, config) {
+    const label = config["label"] ?? "I'm watching";
+    const color = config["color"] ?? "cyan";
+    const fps = config["fps"] ?? 2;
+    const command = config["command"] ?? "whoami";
+    const frames = EYE_FRAMES.map((g) => [`[[fg:${color}]]${g}[[/fg]]  ${label}`]);
+    return {
+      command,
+      lines: frames[0],
+      animation: { frames, fps }
+    };
+  }
+};
+
+// src/blocks/countdown.ts
+import { z as z37 } from "zod";
+var countdownSchema = z37.object({
+  from: z37.number().int().min(1).max(60).optional(),
+  go: z37.string().optional(),
+  color: z37.string().optional(),
+  fps: z37.number().int().min(1).max(10).optional(),
+  command: z37.string().optional()
+}).strict();
+var countdownBlock = {
+  name: "countdown",
+  description: "T-minus N..0..go! launch stinger",
+  configSchema: countdownSchema,
+  render(_context, config) {
+    const from = config["from"] ?? 5;
+    const go = config["go"] ?? "\u{1F680} LIFT-OFF";
+    const color = config["color"] ?? "yellow";
+    const fps = config["fps"] ?? 1;
+    const command = config["command"] ?? "./launch.sh";
+    const frames = [];
+    for (let n = from; n >= 1; n--) {
+      frames.push([`[[fg:${color}]]T-${String(n).padStart(2)}...[[/fg]]`]);
+    }
+    frames.push([`[[fg:green]][[bold]]${go}[[/bold]][[/fg]]`]);
+    return {
+      command,
+      lines: frames[0],
+      animation: { frames, fps, loop: false }
+      // play once, then freeze on GO
+    };
+  }
+};
+
+// src/blocks/sparkline.ts
+import { z as z38 } from "zod";
+var SPARK_GLYPHS = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
+var sparklineSchema = z38.object({
+  values: z38.array(z38.number()).min(1).optional(),
+  label: z38.string().optional(),
+  color: z38.string().optional(),
+  min: z38.number().optional(),
+  max: z38.number().optional(),
+  command: z38.string().optional()
+}).strict();
+var sparklineBlock = {
+  name: "sparkline",
+  description: "ASCII sparkline (\u2581\u2582\u2584\u2587\u2586\u2585\u2583\u2582) for a metric trend",
+  configSchema: sparklineSchema,
+  render(_context, config) {
+    const values = config["values"] ?? [3, 5, 2, 8, 6, 9, 7, 4, 6, 8];
+    const label = config["label"] ?? "trend";
+    const color = config["color"] ?? "green";
+    const command = config["command"] ?? "metrics --tail";
+    const min = config["min"] ?? Math.min(...values);
+    const max = config["max"] ?? Math.max(...values);
+    const span = max - min || 1;
+    const glyphs = values.map((v) => {
+      const idx = Math.min(SPARK_GLYPHS.length - 1, Math.max(0, Math.floor((v - min) / span * SPARK_GLYPHS.length)));
+      return SPARK_GLYPHS[idx];
+    }).join("");
+    return {
+      command,
+      lines: [
+        `${label}: [[fg:${color}]]${glyphs}[[/fg]]  (min ${min}, max ${max}, n=${values.length})`
+      ]
+    };
+  }
+};
+
+// src/blocks/bbs-login.ts
+import { z as z39 } from "zod";
+var bbsLoginSchema = z39.object({
+  name: z39.string().optional(),
+  baud: z39.number().int().optional(),
+  motd: z39.string().optional(),
+  command: z39.string().optional()
+}).strict();
+var bbsLoginBlock = {
+  name: "bbs-login",
+  description: "Retro 1980s BBS welcome banner \u2014 pairs with amber / green-phosphor",
+  configSchema: bbsLoginSchema,
+  render(_context, config) {
+    const name = config["name"] ?? "TWA-BBS";
+    const baud = config["baud"] ?? 9600;
+    const motd = config["motd"] ?? "No new mail. 1 user online.";
+    const command = config["command"] ?? "atdt 555-0123";
+    return {
+      command,
+      lines: [
+        "CONNECT 9600/ARQ/V.32",
+        "",
+        `[[fg:cyan]]   _______ _    _ ____  ____  _____[[/fg]]`,
+        `[[fg:cyan]]  |__   __| |  | |  _ \\|  _ \\/ ____|[[/fg]]`,
+        `[[fg:cyan]]     | |  | |  | | |_) | |_) | (___[[/fg]]`,
+        `[[fg:cyan]]     | |  | |__| |  __/|  _ < \\___ \\[[/fg]]`,
+        `[[fg:cyan]]     |_|   \\____/|_|   |_| \\_\\____/[[/fg]]`,
+        "",
+        `[[fg:yellow]]Welcome to ${name}, ${baud} baud.[[/fg]]`,
+        `[[dim]]${motd}[[/dim]]`,
+        "",
+        "[[fg:green]]login:[[/fg]] _"
+      ],
+      typing: "slow",
+      pause: "long"
+    };
+  }
+};
+
+// src/blocks/build-badge.ts
+import { z as z40 } from "zod";
+var badgeEntrySchema = z40.object({
+  label: z40.string(),
+  status: z40.string(),
+  value: z40.string().optional()
+}).strict();
+var buildBadgeSchema = z40.object({
+  badges: z40.array(badgeEntrySchema).optional(),
+  command: z40.string().optional()
+}).strict();
+var STATE_GLYPH = {
+  ok: { glyph: "\u2713", color: "green" },
+  warn: { glyph: "\u26A0", color: "yellow" },
+  fail: { glyph: "\u2717", color: "red" }
+};
+var buildBadgeBlock = {
+  name: "build-badge",
+  description: "Terminal-style project status card (tests / lint / coverage)",
+  configSchema: buildBadgeSchema,
+  render(_context, config) {
+    const badges = config["badges"] ?? [
+      { label: "tests", status: "ok", value: "243 passing" },
+      { label: "lint", status: "ok" },
+      { label: "coverage", status: "warn", value: "82%" },
+      { label: "build", status: "ok" }
+    ];
+    const command = config["command"] ?? "npm run ci";
+    const lines = badges.map((b) => {
+      const meta = STATE_GLYPH[b.status] ?? { glyph: "\xB7", color: "comment" };
+      const val = b.value ? ` ${b.value}` : "";
+      return `  [[fg:${meta.color}]]${meta.glyph}[[/fg]] ${b.label.padEnd(10)}${val}`;
+    });
+    return {
+      command,
+      lines: ["", ...lines, ""]
+    };
+  }
+};
+
+// src/blocks/license-card.ts
+import { z as z41 } from "zod";
+var licenseCardSchema = z41.object({
+  license: z41.string().optional(),
+  holder: z41.string().optional(),
+  year: z41.number().int().min(1900).max(2100).optional(),
+  url: z41.string().optional(),
+  width: z41.number().positive().optional(),
+  command: z41.string().optional()
+}).strict();
+var licenseCardBlock = {
+  name: "license-card",
+  description: "Boxed License / Copyright card \u2014 saves a README section",
+  configSchema: licenseCardSchema,
+  render(context, config) {
+    const license = config["license"] ?? "MIT";
+    const holder = config["holder"] ?? "You";
+    const year = config["year"] ?? context.now.getFullYear();
+    const url = config["url"] ?? "";
+    const width = resolveBoxWidth(config["width"], context);
+    const command = config["command"] ?? "cat LICENSE";
+    const lines = [
+      "",
+      `[[fg:cyan]]License:[[/fg]]   ${license}`,
+      `[[fg:cyan]]Copyright:[[/fg]] \xA9 ${year} ${holder}`
+    ];
+    if (url) lines.push(`[[fg:cyan]]Details:[[/fg]]   ${url}`);
+    lines.push("");
+    const box = createRoundedBox(lines, width);
+    return {
+      command,
+      lines: box.split("\n"),
+      typing: "fast",
+      pause: "medium"
+    };
+  }
+};
+
+// src/blocks/ascii-clock.ts
+import { z as z42 } from "zod";
+var asciiClockSchema = z42.object({
+  format: z42.enum(["12h", "24h"]).optional(),
+  color: z42.string().optional(),
+  label: z42.string().optional(),
+  command: z42.string().optional()
+}).strict();
+var asciiClockBlock = {
+  name: "ascii-clock",
+  description: "HH:MM:SS clock with pulsing colon separators",
+  configSchema: asciiClockSchema,
+  render(context, config) {
+    const format = config["format"] ?? "24h";
+    const color = config["color"] ?? "cyan";
+    const label = config["label"] ?? "";
+    const command = config["command"] ?? "date +%H:%M:%S";
+    const h24 = context.now.getHours();
+    const m = String(context.now.getMinutes()).padStart(2, "0");
+    const s = String(context.now.getSeconds()).padStart(2, "0");
+    let hh;
+    let suffix = "";
+    if (format === "12h") {
+      const h12 = h24 % 12 || 12;
+      hh = String(h12).padStart(2, "0");
+      suffix = h24 >= 12 ? " PM" : " AM";
+    } else {
+      hh = String(h24).padStart(2, "0");
+    }
+    const labelPart = label ? `${label}  ` : "";
+    const frameWithColons = [`${labelPart}[[fg:${color}]]${hh}:${m}:${s}${suffix}[[/fg]]`];
+    const frameWithDots = [`${labelPart}[[fg:${color}]]${hh}\xB7${m}\xB7${s}${suffix}[[/fg]]`];
+    return {
+      command,
+      lines: frameWithColons,
+      animation: { frames: [frameWithColons, frameWithDots], fps: 1 }
+    };
+  }
+};
+
+// src/blocks/progress-bar.ts
+import { z as z43 } from "zod";
+var progressBarSchema = z43.object({
+  label: z43.string().optional(),
+  width: z43.number().int().min(4).max(80).optional(),
+  fps: z43.number().int().min(1).max(10).optional(),
+  color: z43.string().optional(),
+  command: z43.string().optional()
+}).strict();
+var progressBarBlock = {
+  name: "progress-bar",
+  description: "Fake build/install progress bar that fills 0% \u2192 100%",
+  configSchema: progressBarSchema,
+  render(_context, config) {
+    const label = config["label"] ?? "building";
+    const width = config["width"] ?? 20;
+    const fps = config["fps"] ?? 4;
+    const color = config["color"] ?? "green";
+    const command = config["command"] ?? "./build.sh";
+    const steps = 21;
+    const frames = [];
+    for (let i = 0; i < steps; i++) {
+      const pct = Math.round(i / (steps - 1) * 100);
+      const filled = Math.round(i / (steps - 1) * width);
+      const empty = width - filled;
+      const bar = `[[fg:${color}]]${"\u2588".repeat(filled)}[[/fg]]${"\u2591".repeat(empty)}`;
+      frames.push([`${label}  [${bar}] ${String(pct).padStart(3)}%`]);
+    }
+    return {
+      command,
+      lines: frames[0],
+      animation: { frames, fps, loop: false }
+    };
+  }
+};
+
+// src/blocks/bouncing-dot.ts
+import { z as z44 } from "zod";
+var bouncingDotSchema = z44.object({
+  width: z44.number().int().min(8).max(80).optional(),
+  glyph: z44.string().min(1).max(2).optional(),
+  color: z44.string().optional(),
+  fps: z44.number().int().min(1).max(30).optional(),
+  command: z44.string().optional()
+}).strict();
+var bouncingDotBlock = {
+  name: "bouncing-dot",
+  description: "A single glyph bouncing left \u2194 right",
+  configSchema: bouncingDotSchema,
+  render(_context, config) {
+    const width = config["width"] ?? 24;
+    const glyph = config["glyph"] ?? "\u25CF";
+    const color = config["color"] ?? "magenta";
+    const fps = config["fps"] ?? 8;
+    const command = config["command"] ?? "./bounce";
+    const positions = [];
+    for (let i = 0; i < width; i++) positions.push(i);
+    for (let i = width - 2; i > 0; i--) positions.push(i);
+    const frames = positions.map((pos) => {
+      const left = " ".repeat(pos);
+      const right = " ".repeat(width - pos - 1);
+      return [`${left}[[fg:${color}]]${glyph}[[/fg]]${right}`];
+    });
+    return {
+      command,
+      lines: frames[0],
+      animation: { frames, fps }
+    };
+  }
+};
+
+// src/blocks/dice-roll.ts
+import { z as z45 } from "zod";
+var DIE_FACES = ["\u2680", "\u2681", "\u2682", "\u2683", "\u2684", "\u2685"];
+var diceRollSchema = z45.object({
+  count: z45.number().int().min(1).max(8).optional(),
+  result: z45.array(z45.number().int().min(1).max(6)).optional(),
+  color: z45.string().optional(),
+  fps: z45.number().int().min(1).max(30).optional(),
+  command: z45.string().optional()
+}).strict();
+function mulberry322(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+var diceRollBlock = {
+  name: "dice-roll",
+  description: "Roll N d6 dice with a tumble animation that lands on a result",
+  configSchema: diceRollSchema,
+  render(context, config) {
+    const count = config["count"] ?? 3;
+    const color = config["color"] ?? "yellow";
+    const fps = config["fps"] ?? 6;
+    const command = config["command"] ?? `roll ${count}d6`;
+    const dayOfYear = Math.floor(context.now.getTime() / 864e5);
+    const rand = mulberry322(dayOfYear);
+    const result = config["result"] ?? Array.from({ length: count }, () => 1 + Math.floor(rand() * 6));
+    const tumbleFrames = [];
+    for (let i = 0; i < 6; i++) {
+      const faces = Array.from({ length: count }, () => DIE_FACES[Math.floor(rand() * 6)]);
+      tumbleFrames.push([`[[fg:${color}]]${faces.join(" ")}[[/fg]]  tumbling\u2026`]);
+    }
+    const finalFaces = result.map((n) => DIE_FACES[Math.max(0, Math.min(5, n - 1))]).join(" ");
+    const total = result.reduce((a, b) => a + b, 0);
+    tumbleFrames.push([`[[fg:${color}]]${finalFaces}[[/fg]]  \u2192 ${total}`]);
+    return {
+      command,
+      lines: tumbleFrames[tumbleFrames.length - 1],
+      // static fallback = final roll
+      animation: { frames: tumbleFrames, fps, loop: false }
+    };
+  }
+};
+
+// src/blocks/palette-swatch.ts
+import { z as z46 } from "zod";
+var COLOR_NAMES = [
+  "red",
+  "green",
+  "yellow",
+  "blue",
+  "magenta",
+  "cyan",
+  "white",
+  "orange",
+  "bright_red",
+  "bright_green",
+  "bright_yellow",
+  "bright_blue",
+  "bright_magenta",
+  "bright_cyan",
+  "bright_white",
+  "comment"
+];
+var paletteSwatchSchema = z46.object({
+  glyph: z46.string().min(1).max(2).optional(),
+  label: z46.string().optional(),
+  command: z46.string().optional()
+}).strict();
+var paletteSwatchBlock = {
+  name: "palette-swatch",
+  description: "One-line render of the theme palette \u2014 useful for theme docs",
+  configSchema: paletteSwatchSchema,
+  render(_context, config) {
+    const glyph = config["glyph"] ?? "\u2588";
+    const label = config["label"] ?? "palette:";
+    const command = config["command"] ?? "palette";
+    const swatches = COLOR_NAMES.map((c) => `[[fg:${c}]]${glyph}[[/fg]]`).join(" ");
+    return {
+      command,
+      lines: [`${label} ${swatches}`]
+    };
+  }
+};
+
+// src/blocks/semver-bump.ts
+import { z as z47 } from "zod";
+var semverBumpSchema = z47.object({
+  current: z47.string().regex(/^\d+\.\d+\.\d+$/, "current must be a semver triple like 1.2.3").optional(),
+  highlight: z47.enum(["major", "minor", "patch", "none"]).optional(),
+  command: z47.string().optional()
+}).strict();
+var semverBumpBlock = {
+  name: "semver-bump",
+  description: "Current semver + bump preview (major/minor/patch)",
+  configSchema: semverBumpSchema,
+  render(_context, config) {
+    const current = config["current"] ?? "1.2.3";
+    const highlight = config["highlight"] ?? "none";
+    const command = config["command"] ?? "npm version --preview";
+    const [maj, min, patch] = current.split(".").map(Number);
+    const bumps = {
+      major: `${maj + 1}.0.0`,
+      minor: `${maj}.${min + 1}.0`,
+      patch: `${maj}.${min}.${patch + 1}`
+    };
+    const tag = (kind) => {
+      const color = kind === highlight ? "green" : "comment";
+      const arrow = kind === highlight ? "\u2192" : " ";
+      return `  [[fg:${color}]]${arrow} ${kind.padEnd(5)} ${bumps[kind]}[[/fg]]`;
+    };
+    return {
+      command,
+      lines: [
+        `[[fg:cyan]]current[[/fg]]   ${current}`,
+        "",
+        tag("major"),
+        tag("minor"),
+        tag("patch")
+      ]
+    };
+  }
+};
+
+// src/blocks/ascii-calendar.ts
+import { z as z48 } from "zod";
+var MONTH_NAMES = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var asciiCalendarSchema = z48.object({
+  highlightColor: z48.string().optional(),
+  weekStart: z48.enum(["sun", "mon"]).optional(),
+  command: z48.string().optional()
+}).strict();
+var asciiCalendarBlock = {
+  name: "ascii-calendar",
+  description: "Current-month calendar grid with today highlighted",
+  configSchema: asciiCalendarSchema,
+  render(context, config) {
+    const highlightColor = config["highlightColor"] ?? "green";
+    const weekStart = config["weekStart"] ?? "sun";
+    const command = config["command"] ?? "cal";
+    const today = context.now;
+    const year = today.getFullYear();
+    const month = today.getMonth();
+    const todayDate = today.getDate();
+    const firstDow = new Date(year, month, 1).getDay();
+    const daysInMonth = new Date(year, month + 1, 0).getDate();
+    const startOffset = weekStart === "mon" ? (firstDow + 6) % 7 : firstDow;
+    const header = weekStart === "mon" ? "Mo Tu We Th Fr Sa Su" : "Su Mo Tu We Th Fr Sa";
+    const title = `[[fg:cyan]]${MONTH_NAMES[month]} ${year}[[/fg]]`;
+    const cells = [];
+    for (let i = 0; i < startOffset; i++) cells.push("  ");
+    for (let d = 1; d <= daysInMonth; d++) {
+      const cell = String(d).padStart(2, " ");
+      cells.push(d === todayDate ? `[[fg:${highlightColor}]][[bold]]${cell}[[/bold]][[/fg]]` : cell);
+    }
+    while (cells.length % 7 !== 0) cells.push("  ");
+    const rows = [];
+    for (let i = 0; i < cells.length; i += 7) {
+      rows.push(cells.slice(i, i + 7).join(" "));
+    }
+    return {
+      command,
+      lines: [title, header, ...rows],
+      typing: "fast",
+      pause: "medium"
+    };
+  }
+};
+
+// src/blocks/toc.ts
+import { z as z49 } from "zod";
+var tocSchema = z49.object({
+  title: z49.string().optional(),
+  sections: z49.array(z49.string()).min(1).optional(),
+  color: z49.string().optional(),
+  command: z49.string().optional()
+}).strict();
+function slugify(title) {
+  return title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").trim().replace(/\s/g, "-");
+}
+var tocBlock = {
+  name: "toc",
+  description: "Auto-generates a markdown anchor-link table of contents",
+  configSchema: tocSchema,
+  render(_context, config) {
+    const title = config["title"] ?? "Table of Contents";
+    const color = config["color"] ?? "cyan";
+    const sections = config["sections"] ?? [
+      "Introduction",
+      "Getting Started",
+      "Configuration",
+      "Examples",
+      "Contributing"
+    ];
+    const command = config["command"] ?? "cat TOC.md";
+    const lines = [`[[fg:${color}]][[bold]]${title}[[/bold]][[/fg]]`, ""];
+    for (const s of sections) {
+      lines.push(`  \u2022 ${s}  [[dim]]\u2192 #${slugify(s)}[[/dim]]`);
+    }
+    return {
+      command,
+      lines,
+      typing: "fast",
+      pause: "medium"
+    };
+  }
+};
+
+// src/blocks/index.ts
+function registerBuiltinBlocks() {
+  registerBlocks([
+    customBlock,
+    neofetchBlock,
+    fortuneBlock,
+    motdBlock,
+    dadJokeBlock,
+    htopBlock,
+    profileBlock,
+    goodbyeBlock,
+    npmInstallBlock,
+    blogPostBlock,
+    nationalDayBlock,
+    systemctlBlock,
+    weatherBlock,
+    githubStatsBlock,
+    githubLanguagesBlock,
+    quoteBlock,
+    funFactBlock,
+    vimExitBlock,
+    sudoSandwichBlock,
+    rmRfBlock,
+    forkBombBlock,
+    kernelPanicBlock,
+    segfaultBlock,
+    whoamiBlock,
+    lastLoginBlock,
+    fingerBlock,
+    whoBlock,
+    uptimeBlock,
+    matrixRainBlock,
+    cowsayBlock,
+    loadingSpinnerBlock,
+    heartbeatBlock,
+    spinningGearBlock,
+    blinkingEyesBlock,
+    countdownBlock,
+    sparklineBlock,
+    bbsLoginBlock,
+    buildBadgeBlock,
+    licenseCardBlock,
+    asciiClockBlock,
+    progressBarBlock,
+    bouncingDotBlock,
+    diceRollBlock,
+    paletteSwatchBlock,
+    semverBumpBlock,
+    asciiCalendarBlock,
+    tocBlock
+  ]);
+}
+
+// src/index.ts
+registerBuiltinBlocks();
+var STRICT_BLOCK_CONFIG = false;
+function setStrictBlockConfig(enabled) {
+  STRICT_BLOCK_CONFIG = enabled;
+}
+function validateBlockEntry(block, entry, index) {
+  const cfg = entry.config ?? {};
+  if (block.configSchema) {
+    try {
+      block.configSchema.parse(cfg);
+    } catch (err) {
+      if (err instanceof z50.ZodError) {
+        const issues = err.issues.map((i) => {
+          const path = i.path.length ? i.path.join(".") : "<root>";
+          return `  ${path}: ${i.message}`;
+        }).join("\n");
+        throw new BlockConfigError(
+          block.name,
+          index,
+          `Invalid config for block "${block.name}" at blocks[${index}]:
+${issues}`
+        );
+      }
+      throw err;
+    }
+    return;
+  }
+  if (block.allowedKeys) {
+    const allow = /* @__PURE__ */ new Set([
+      ...block.allowedKeys,
+      // These four are universal entry-level keys handled by index.ts itself.
+      "command",
+      "color",
+      "typing",
+      "pause"
+    ]);
+    const unknown = Object.keys(cfg).filter((k) => !allow.has(k));
+    if (unknown.length === 0) return;
+    const list = unknown.join(", ");
+    const known = block.allowedKeys.join(", ");
+    const msg = `Unknown config key(s) [${list}] for block "${block.name}" at blocks[${index}]
+  Known keys: ${known}`;
+    if (STRICT_BLOCK_CONFIG) {
+      throw new BlockConfigError(block.name, index, msg);
+    }
+    console.warn(`[svg-terminal] warning: ${msg}`);
+  }
+}
+async function generate(userConfig, options = {}) {
+  assertHasBlocks(userConfig);
+  const config = mergeConfig(userConfig);
+  const sequences = [];
+  const { context, cacheRuntime } = buildContext(userConfig, config, options);
+  for (let i = 0; i < userConfig.blocks.length; i++) {
+    const entry = userConfig.blocks[i];
+    const block = getBlock(entry.block);
+    if (!block) {
+      throw new Error(
+        `Unknown block "${entry.block}". Register it with registerBlock() or use a built-in block.`
+      );
+    }
+    validateBlockEntry(block, entry, i);
+    const result = await block.render(context, entry.config ?? {});
+    if (result.fallback) options.onCacheEvent?.("fallback", entry.block);
+    sequences.push({
+      type: "command",
+      content: entry.command ?? result.command,
+      typingDuration: resolveTyping(entry.typing ?? result.typing),
+      pause: config.animation.commandOutputPause
+    });
+    sequences.push({
+      type: "output",
+      content: result.lines.join("\n"),
+      color: entry.color ?? result.color,
+      pause: resolvePause(entry.pause ?? result.pause),
+      pinWidth: result.pinWidth,
+      ...result.animation ? {
+        frames: result.animation.frames.map((f) => f.join("\n")),
+        framesFps: Math.min(30, Math.max(1, result.animation.fps ?? 4)),
+        framesLoop: result.animation.loop ?? true
+      } : {}
+    });
+  }
+  if (cacheRuntime) flushCache(cacheRuntime);
+  return generateSvg(sequences, config);
+}
+function inspectCache(userConfig, configPath) {
+  const merged = mergeConfig(userConfig);
+  const filePath = resolveCachePath(configPath, merged.cachePath);
+  const entries = [];
+  for (let i = 0; i < userConfig.blocks.length; i++) {
+    const entry = userConfig.blocks[i];
+    const block = getBlock(entry.block);
+    if (!block?.cacheable) continue;
+    entries.push({
+      blockName: entry.block,
+      entryIndex: i,
+      key: `${entry.block}:${hashConfig(entry.config ?? {})}`
+    });
+  }
+  return { filePath, results: checkCache({ filePath, ttl: merged.cacheTTL, entries }) };
+}
+function buildContext(userConfig, config, options) {
+  const cacheRuntime = makeCacheRuntime(config, options);
+  const cacheEventForUseCache = options.onCacheEvent ? (evt, key) => options.onCacheEvent(evt, key) : void 0;
+  const context = {
+    now: options.now ?? /* @__PURE__ */ new Date(),
+    config,
+    variables: userConfig.variables ?? {},
+    useCache: cacheRuntime ? makeUseCache(cacheRuntime, cacheEventForUseCache) : void 0
+  };
+  return { context, cacheRuntime };
+}
+function makeCacheRuntime(config, options) {
+  const mode = options.cacheMode ?? "normal";
+  if (mode === "off") {
+    return { mode, filePath: "", ttl: config.cacheTTL, dirty: false };
+  }
+  if (!options.configPath) return void 0;
+  let filePath;
+  try {
+    filePath = resolveCachePath(options.configPath, config.cachePath);
+  } catch (err) {
+    console.warn(`[svg-terminal] cache: disabled \u2014 ${err.message}`);
+    return void 0;
+  }
+  return { mode, filePath, ttl: config.cacheTTL, dirty: false };
+}
+function assertHasBlocks(userConfig) {
+  if (!Array.isArray(userConfig.blocks) || userConfig.blocks.length === 0) {
+    throw new Error("generate() requires at least one block in userConfig.blocks");
+  }
+}
+async function generateStatic(userConfig, options = {}) {
+  assertHasBlocks(userConfig);
+  const config = mergeConfig(userConfig);
+  const allLines = [];
+  const { context, cacheRuntime } = buildContext(userConfig, config, options);
+  for (let i = 0; i < userConfig.blocks.length; i++) {
+    const entry = userConfig.blocks[i];
+    const block = getBlock(entry.block);
+    if (!block) {
+      throw new Error(
+        `Unknown block "${entry.block}". Register it with registerBlock() or use a built-in block.`
+      );
+    }
+    validateBlockEntry(block, entry, i);
+    const result = await block.render(context, entry.config ?? {});
+    if (result.fallback) options.onCacheEvent?.("fallback", entry.block);
+    const prompt = config.text.prompt;
+    allLines.push(`${prompt}${entry.command ?? result.command}`);
+    allLines.push(...result.lines);
+  }
+  if (cacheRuntime) flushCache(cacheRuntime);
+  return generateStaticSvg(allLines, config);
+}
+
+export {
+  dracula,
+  nord,
+  monokai,
+  amber,
+  greenPhosphor,
+  cyberpunk,
+  solarizedDark,
+  win95,
+  catppuccin,
+  tokyoNight,
+  gruvbox,
+  highContrast,
+  themes,
+  registerTheme,
+  getTheme,
+  listThemes,
+  resolveTheme,
+  registerBlock,
+  getBlock,
+  listBlocks,
+  registerBlocks,
+  TYPING_PRESETS,
+  PAUSE_PRESETS,
+  resolveTyping,
+  resolvePause,
+  ConfigError,
+  BlockConfigError,
+  loadConfig,
+  mergeConfig,
+  buildColorMap,
+  parseMarkup,
+  hasMarkup,
+  stripMarkup,
+  generateSvg,
+  generateStaticSvg,
+  createBox,
+  createDoubleBox,
+  createRoundedBox,
+  createTitledBox,
+  createAutoBox,
+  fetchWithTimeout,
+  fetchJson,
+  fetchText,
+  registerBuiltinBlocks,
+  setStrictBlockConfig,
+  generate,
+  inspectCache,
+  generateStatic
+};
+//# sourceMappingURL=chunk-IVINEQLU.js.map