@moewolf/moe-icons-cli 0.0.1 → 0.0.3

package/dist/project/project-lock.d.ts

@@ -7,5 +7,5 @@ export interface ProjectLockIo {
     readonly now: () => number;
     readonly pid: number;
 }
-export declare function withProjectLock<T>(projectRoot: string, operation: "install" | "update" | "reload", work: () => Promise<T> | T, io?: ProjectLockIo): Promise<T>;
-export declare function withProjectLockSync<T>(projectRoot: string, operation: "install" | "update" | "reload", work: () => T, io?: ProjectLockIo): T;
+export declare function withProjectLock<T>(projectRoot: string, operation: "install" | "update" | "reload" | "doctor" | "recover", work: () => Promise<T> | T, io?: ProjectLockIo): Promise<T>;
+export declare function withProjectLockSync<T>(projectRoot: string, operation: "install" | "update" | "reload" | "doctor" | "recover", work: () => T, io?: ProjectLockIo): T;

package/dist/project/project-lock.js

@@ -15,8 +15,8 @@ const defaultIo = {
         process.kill(pid, 0);
         return true;
     }
-    catch {
-        return false;
+    catch (error) {
+        return error.code !== "ESRCH";
     } },
     now: Date.now,
     pid: process.pid,
@@ -27,7 +27,7 @@ export async function withProjectLock(projectRoot, operation, work, io = default
         let stale = false;
         try {
             const value = JSON.parse(io.read(path));
-            stale = typeof value.pid === "number" && typeof value.createdAt === "number" && io.now() - value.createdAt > 30 * 60_000 && !io.isProcessAlive(value.pid);
+            stale = typeof value.pid === "number" && typeof value.createdAt === "number" && (operation === "recover" || io.now() - value.createdAt > 30 * 60_000) && !io.isProcessAlive(value.pid);
         }
         catch {
             stale = false;
@@ -56,7 +56,7 @@ export function withProjectLockSync(projectRoot, operation, work, io = defaultIo
         let stale = false;
         try {
             const value = JSON.parse(io.read(path));
-            stale = typeof value.pid === "number" && typeof value.createdAt === "number" && io.now() - value.createdAt > 30 * 60_000 && !io.isProcessAlive(value.pid);
+            stale = typeof value.pid === "number" && typeof value.createdAt === "number" && (operation === "recover" || io.now() - value.createdAt > 30 * 60_000) && !io.isProcessAlive(value.pid);
         }
         catch {
             stale = false;

package/dist/project/tailwind.d.ts

@@ -31,8 +31,8 @@ export type ContentInjectResult = {
 export declare function injectContentGlob(source: string, glob: string): ContentInjectResult;
 export declare function moeiconsContentGlob(outputDir: string, target?: "react" | "vue" | "vanilla" | "assets"): string;
 /**
- * Apply Tailwind content injection. Throws CliError(TAILWIND_VERSION_UNSUPPORTED)
- * for v4 when integration is requested.
+ * Apply Tailwind v3 content injection. Tailwind v4 discovers source files
+ * automatically, so generated components need no config rewrite.
  */
 export declare function planTailwindIntegration(projectRoot: string, outputDir: string, options: {
     readonly noTailwind: boolean;

package/dist/project/tailwind.js

@@ -1,6 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { CliError } from "../errors/index.js";
 import { CLSX_VERSION_RANGE, TAILWIND_MERGE_VERSION_RANGE } from "../generator/cn.js";
 import { applyEdits, modify } from "jsonc-parser";
 const CONFIG_CANDIDATES = [
@@ -92,8 +91,8 @@ export function moeiconsContentGlob(outputDir, target) {
     return `./${normalized}/**/*.{${extensions}}`;
 }
 /**
- * Apply Tailwind content injection. Throws CliError(TAILWIND_VERSION_UNSUPPORTED)
- * for v4 when integration is requested.
+ * Apply Tailwind v3 content injection. Tailwind v4 discovers source files
+ * automatically, so generated components need no config rewrite.
  */
 export function planTailwindIntegration(projectRoot, outputDir, options) {
     if (options.noTailwind) {
@@ -107,7 +106,7 @@ export function planTailwindIntegration(projectRoot, outputDir, options) {
         return { files: [], notes: ["no Tailwind config found; skipped content injection"] };
     }
     if (detected.kind === "v4") {
-        throw new CliError("TAILWIND_VERSION_UNSUPPORTED", "Tailwind CSS v4 was detected; this CLI release only auto-integrates Tailwind v3. Pass --no-tailwind to skip Tailwind config changes.");
+        return { files: [], notes: ["Tailwind CSS v4 detected; generated icons use explicit dimensions and need no config rewrite"] };
     }
     if (detected.kind === "unknown") {
         return {

package/dist/project/tar-gz.d.ts

@@ -1,10 +1,27 @@
+/**
+ * Combined release archives contain all four target trees. The current Pro
+ * contract is roughly 60k regular files (9 groups × 554 icons), so the former
+ * 20k cap rejected valid official packages. The six-spec bitmap matrix expands
+ * to ~205 MiB (tar stream ~257 MiB), so the expanded ceiling covers that with
+ * headroom while staying finite for zip-bomb protection. `extractTarGz` enforces
+ * the same bound during gunzip via `maxOutputLength`, before the tar stream is
+ * materialised.
+ */
+export declare const ICON_ARCHIVE_MAX_ENTRIES = 100000;
+export declare const ICON_ARCHIVE_MAX_EXPANDED_BYTES: number;
 /** Build a gzipped POSIX tar from in-memory files (test fixtures and unpacking). */
 export declare function createTarGz(files: Readonly<Record<string, string | Uint8Array>>): Uint8Array;
 export type ExtractedTarFiles = {
     readonly files: Record<string, Uint8Array>;
     readonly errors: string[];
 };
-/** Gunzip + unpack tar; reject absolute paths, `..`, and oversized archives. */
+/**
+ * Gunzip + unpack tar. Rejects absolute paths, `..`, symlinks and oversized
+ * archives. Path safety uses POSIX `/` separators (the tar format mandates `/`);
+ * a Windows-style separator would appear literally inside a name and never be
+ * treated as a path separator, so `..\evil` is inert (no traversal), which is
+ * the documented known assumption.
+ */
 export declare function extractTarGz(bytes: Uint8Array, limits: {
     maxEntries: number;
     maxExpandedBytes: number;

package/dist/project/tar-gz.js

@@ -1,5 +1,22 @@
 import { gzipSync, gunzipSync } from "node:zlib";
 const BLOCK = 512;
+/**
+ * Combined release archives contain all four target trees. The current Pro
+ * contract is roughly 60k regular files (9 groups × 554 icons), so the former
+ * 20k cap rejected valid official packages. The six-spec bitmap matrix expands
+ * to ~205 MiB (tar stream ~257 MiB), so the expanded ceiling covers that with
+ * headroom while staying finite for zip-bomb protection. `extractTarGz` enforces
+ * the same bound during gunzip via `maxOutputLength`, before the tar stream is
+ * materialised.
+ */
+export const ICON_ARCHIVE_MAX_ENTRIES = 100_000;
+export const ICON_ARCHIVE_MAX_EXPANDED_BYTES = 512 * 1024 * 1024;
+/** True when a zlib gunzip failure means the bounded output was exceeded. */
+function isOutputLimitError(error) {
+    const code = error?.code;
+    const message = error instanceof Error ? error.message : "";
+    return code === "ERR_BUFFER_TOO_LARGE" || /larger than|maxOutputLength|output length/i.test(message);
+}
 function checksumHeader(header) {
     let sum = 0;
     for (let i = 0; i < BLOCK; i += 1)
@@ -48,15 +65,25 @@ function readOctal(buf, offset, length) {
         return 0;
     return Number.parseInt(raw, 8);
 }
-/** Gunzip + unpack tar; reject absolute paths, `..`, and oversized archives. */
+/**
+ * Gunzip + unpack tar. Rejects absolute paths, `..`, symlinks and oversized
+ * archives. Path safety uses POSIX `/` separators (the tar format mandates `/`);
+ * a Windows-style separator would appear literally inside a name and never be
+ * treated as a path separator, so `..\evil` is inert (no traversal), which is
+ * the documented known assumption.
+ */
 export function extractTarGz(bytes, limits) {
     const files = {};
     const errors = [];
     let data;
     try {
-        data = gunzipSync(bytes);
+        // Bound the decompressed stream itself so a zip bomb fails during gunzip,
+        // before the tar bytes are materialised.
+        data = gunzipSync(bytes, { maxOutputLength: limits.maxExpandedBytes });
     }
-    catch {
+    catch (error) {
+        if (isOutputLimitError(error))
+            return { files, errors: ["expanded size exceeds limit"] };
         return { files, errors: ["invalid gzip"] };
     }
     let offset = 0;
@@ -73,6 +100,12 @@ export function extractTarGz(bytes, limits) {
         const padded = Math.ceil(size / BLOCK) * BLOCK;
         const content = data.subarray(offset, offset + size);
         offset += padded;
+        if (type === 0x31 || type === 0x32) {
+            // Hard-link (typeflag '1') and symlink (typeflag '2') entries are
+            // rejected with an explicit error, never silently skipped.
+            errors.push(`link entries are not allowed: ${name || "<unnamed>"}`);
+            continue;
+        }
         if (type !== 0 && type !== 0x30)
             continue;
         if (!name || name.endsWith("/"))
@@ -86,6 +119,10 @@ export function extractTarGz(bytes, limits) {
             errors.push(`unsafe path "${name}"`);
             continue;
         }
+        if (name in files) {
+            errors.push(`duplicate entry "${name}"`);
+            continue;
+        }
         expanded += content.byteLength;
         if (expanded > limits.maxExpandedBytes) {
             errors.push("expanded size exceeds limit");

package/dist/tui/components.d.ts

@@ -0,0 +1,62 @@
+import type { UiTheme } from "../ui/theme.js";
+/**
+ * W3-A/C/D/E: pure TUI component renderers.
+ *
+ * Kept dependency-free (no stream/Clack/process access) so every frame is unit
+ * testable and the adapters (`ui/clack.ts`, `ui/stream.ts`,
+ * `ui/non-interactive.ts`) only own I/O. Colour is always supplied through the
+ * shared `UiTheme` (white / brand blue / brand red + a dim intensity), never a
+ * hardcoded escape, and every renderer degrades to plain text when colour is
+ * disabled or the output is not a TTY.
+ */
+export declare const PROGRESS_GLYPHS: Readonly<{
+    filled: "█";
+    empty: "░";
+}>;
+/** W3-C running animation frames. Deterministic by frame index. */
+export declare const TASK_RUNNING_FRAMES: readonly string[];
+export type TaskState = "running" | "success" | "failure" | "timeout";
+export type HistoryState = "running" | "success" | "failure" | "timeout";
+export declare function formatRate(bytes: number, elapsedMs: number): string | undefined;
+export interface ProgressBarInput {
+    readonly label: string;
+    readonly done?: number;
+    readonly total?: number;
+    readonly detail?: string;
+    readonly columns?: number;
+    readonly theme: UiTheme;
+    /** Elapsed wall time in ms; enables the rate suffix. */
+    readonly elapsedMs?: number;
+    /** Fixed bar width override (tests); otherwise derived from `columns`. */
+    readonly barWidth?: number;
+}
+/**
+ * W3-A: one-line progress bar with percentage, transferred/total bytes, an
+ * optional rate and a detail suffix. Unknown total renders a byte-only line
+ * (never a fake percentage). `columns <= 0` (non-TTY) collapses to a log line.
+ */
+export declare function renderProgressBar(input: ProgressBarInput): string;
+export interface TaskStatusInput {
+    readonly state: TaskState;
+    readonly label: string;
+    readonly detail?: string;
+    readonly frame?: number;
+    readonly theme: UiTheme;
+}
+/** W3-C: strict four-state task status with a lightweight running animation. */
+export declare function renderTaskStatus(input: TaskStatusInput): string;
+export interface KeyHint {
+    readonly key: string;
+    readonly label: string;
+}
+export declare const SELECT_KEY_HINTS: readonly KeyHint[];
+export declare const CONFIRM_KEY_HINTS: readonly KeyHint[];
+/** W3-D: low-opacity, small key hints for a pure-keyboard workflow. */
+export declare function renderKeyHints(hints: readonly KeyHint[], theme: UiTheme): string;
+export interface HistoryEntry {
+    readonly label: string;
+    readonly state: HistoryState;
+    readonly detail?: string;
+}
+/** W3-E2: single-line recent-task preview with colour-coded state. */
+export declare function renderHistoryBar(entry: HistoryEntry | undefined, theme: UiTheme): string | undefined;

package/dist/tui/components.js

@@ -0,0 +1,100 @@
+import { formatBytes } from "../metadata/version.js";
+import { visibleWidth } from "../ui/banner.js";
+/**
+ * W3-A/C/D/E: pure TUI component renderers.
+ *
+ * Kept dependency-free (no stream/Clack/process access) so every frame is unit
+ * testable and the adapters (`ui/clack.ts`, `ui/stream.ts`,
+ * `ui/non-interactive.ts`) only own I/O. Colour is always supplied through the
+ * shared `UiTheme` (white / brand blue / brand red + a dim intensity), never a
+ * hardcoded escape, and every renderer degrades to plain text when colour is
+ * disabled or the output is not a TTY.
+ */
+export const PROGRESS_GLYPHS = Object.freeze({
+    filled: "█",
+    empty: "░",
+});
+/** W3-C running animation frames. Deterministic by frame index. */
+export const TASK_RUNNING_FRAMES = Object.freeze(["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]);
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+export function formatRate(bytes, elapsedMs) {
+    if (!Number.isFinite(bytes) || !Number.isFinite(elapsedMs) || elapsedMs <= 0 || bytes <= 0)
+        return undefined;
+    const perSecond = bytes / (elapsedMs / 1000);
+    return `${formatBytes(Math.round(perSecond))}/s`;
+}
+function progressBarWidth(columns, labelWidth, suffixWidth) {
+    const available = columns - labelWidth - suffixWidth - 4;
+    return clamp(available, 8, 40);
+}
+/**
+ * W3-A: one-line progress bar with percentage, transferred/total bytes, an
+ * optional rate and a detail suffix. Unknown total renders a byte-only line
+ * (never a fake percentage). `columns <= 0` (non-TTY) collapses to a log line.
+ */
+export function renderProgressBar(input) {
+    const { theme, label } = input;
+    const done = Math.max(0, input.done ?? 0);
+    const total = input.total !== undefined && input.total > 0 ? input.total : undefined;
+    const columns = input.columns ?? 80;
+    const detail = input.detail ? ` ${theme.dim(input.detail)}` : "";
+    const rate = input.elapsedMs !== undefined ? formatRate(done, input.elapsedMs) : undefined;
+    if (columns <= 0) {
+        const suffix = total !== undefined ? `${formatBytes(done)}/${formatBytes(total)}` : formatBytes(done);
+        return `${label} ${suffix}${rate ? ` (${rate})` : ""}${input.detail ? ` ${input.detail}` : ""}`;
+    }
+    if (total === undefined) {
+        return `${label} ${formatBytes(done)}${rate ? ` (${rate})` : ""}${detail}`;
+    }
+    const ratio = clamp(done / total, 0, 1);
+    const percent = Math.floor(ratio * 100);
+    const suffix = `${String(percent).padStart(3, " ")}% ${formatBytes(done)}/${formatBytes(total)}${rate ? ` ${rate}` : ""}`;
+    // Budget by VISIBLE width: the label/suffix may carry ANSI (e.g. a dim rate),
+    // which must not eat into the bar's column budget.
+    const width = input.barWidth ?? progressBarWidth(columns, visibleWidth(label), visibleWidth(suffix));
+    const filled = Math.round(width * ratio);
+    const bar = `${theme.blue(PROGRESS_GLYPHS.filled.repeat(filled))}${theme.dim(PROGRESS_GLYPHS.empty.repeat(width - filled))}`;
+    return `${label} ${bar} ${suffix}${detail}`;
+}
+/** W3-C: strict four-state task status with a lightweight running animation. */
+export function renderTaskStatus(input) {
+    const { theme, state, label } = input;
+    const detail = input.detail ? ` ${theme.dim(input.detail)}` : "";
+    if (state === "success")
+        return `${theme.blue(theme.symbols.success)} ${label}${detail}`;
+    if (state === "failure")
+        return `${theme.red(theme.symbols.failure)} ${label}${detail}`;
+    if (state === "timeout")
+        return `${theme.red(theme.symbols.timeout)} ${label}${detail}`;
+    const frame = TASK_RUNNING_FRAMES[Math.abs(input.frame ?? 0) % TASK_RUNNING_FRAMES.length] ?? "…";
+    return `${theme.blue(frame)} ${label}${detail}`;
+}
+export const SELECT_KEY_HINTS = Object.freeze([
+    { key: "↑/↓", label: "move" },
+    { key: "1-9", label: "select" },
+    { key: "Enter", label: "submit" },
+    { key: "Esc", label: "cancel" },
+]);
+export const CONFIRM_KEY_HINTS = Object.freeze([
+    { key: "Y/N", label: "choose" },
+    { key: "Enter", label: "submit" },
+    { key: "Esc", label: "cancel" },
+]);
+/** W3-D: low-opacity, small key hints for a pure-keyboard workflow. */
+export function renderKeyHints(hints, theme) {
+    return theme.dim(hints.map((hint) => `${hint.key} ${hint.label}`).join(" · "));
+}
+/** W3-E2: single-line recent-task preview with colour-coded state. */
+export function renderHistoryBar(entry, theme) {
+    if (!entry)
+        return undefined;
+    if (entry.state === "success")
+        return `${theme.blue(theme.symbols.success)} ${entry.label}${entry.detail ? ` ${theme.dim(entry.detail)}` : ""}`;
+    if (entry.state === "failure")
+        return `${theme.red(theme.symbols.failure)} ${entry.label}${entry.detail ? ` ${theme.dim(entry.detail)}` : ""}`;
+    if (entry.state === "timeout")
+        return `${theme.red(theme.symbols.timeout)} ${entry.label}${entry.detail ? ` ${theme.dim(entry.detail)}` : ""}`;
+    return `${theme.dim(theme.symbols.pending)} ${entry.label}${entry.detail ? ` ${theme.dim(entry.detail)}` : ""}`;
+}

package/dist/tui/primitives.d.ts

@@ -18,6 +18,7 @@ export interface TuiDeps {
 export type Choice<T> = {
     readonly value: T;
     readonly label: string;
+    readonly separatorBefore?: boolean;
 };
 export interface SelectOptions<T> {
     readonly choices: readonly Choice<T>[];

package/dist/tui/primitives.js

@@ -14,6 +14,10 @@ export function renderBanner(deps, banner) {
     deps.streams.write(banner);
     deps.streams.write("\n");
 }
+function formatIndexedLabel(index, total, label) {
+    const width = String(Math.max(total, 1)).length;
+    return `${String(index + 1).padStart(width, " ")}. ${label}`;
+}
 /** Interactive single-choice selection; non-TTY rejects with guidance. */
 export async function select(deps, prompt, options) {
     assertNotAborted(deps);
@@ -21,8 +25,11 @@ export async function select(deps, prompt, options) {
         throw new CliError("NOT_TTY", "interactive selection requires a TTY; use a specific command or --json");
     }
     deps.streams.write(`${prompt}\n`);
+    const total = options.choices.length;
     options.choices.forEach((choice, i) => {
-        deps.streams.write(`  ${i + 1}) ${choice.label}\n`);
+        if (choice.separatorBefore)
+            deps.streams.write("\n");
+        deps.streams.write(`  ${formatIndexedLabel(i, total, choice.label)}\n`);
     });
     if (options.canCancel)
         deps.streams.write("  0) Cancel\n");

package/dist/ui/banner.d.ts

@@ -1,5 +1,12 @@
-export declare const MOEICONS_BANNER: string;
-export declare const CLI_NOTICE_LINES: readonly ["Run moeicons from your project root.", "React/Vue targets require the matching framework.", "Automatic Tailwind integration supports v3 only.", "Vanilla and Assets do not require React or Vue."];
+import { MOEICONS_BANNER } from "./generated/wordmark.js";
+import { type UiTheme } from "./theme.js";
+export { MOEICONS_BANNER };
+export { MOEICONS_WORDMARK_LARGE, WORDMARK_LARGE_GLYPHS, WORDMARK_LARGE_WIDTH, } from "./generated/wordmark-large.js";
+/** Figlet / mid tier when columns are in [52, 101). */
+export declare const MIN_FIGLET_COLUMNS = 52;
+/** Large Unicode wordmark when columns >= 101. */
+export declare const MIN_LARGE_COLUMNS = 101;
+export declare const CLI_NOTICE_LINES: readonly ["Run `moeicons` from your project root.", "React/Vue targets require the matching framework.", "Automatic Tailwind integration supports v3 only.", "Vanilla and Assets do not require React or Vue."];
 /** Visible terminal width: ANSI sequences and combining marks take no columns. */
 export declare function visibleWidth(value: string): number;
 /** Render an adaptive notice box without splitting ANSI escapes or Unicode characters. */
@@ -7,5 +14,26 @@ export declare function renderNoticeBox(message: string | readonly string[], opt
     readonly width?: number;
     readonly unicode?: boolean;
 }): string;
-export declare function renderBannerText(): string;
+export interface RenderBannerOptions {
+    readonly columns: number;
+    readonly color: boolean;
+}
+export type WordmarkTier = "large" | "figlet" | "single";
+/** Left-pad lines onto a canvas. Never adds trailing spaces. */
+export declare function centerLines(lines: readonly string[], width?: number): string[];
+export declare function selectWordmarkTier(columns: number): WordmarkTier;
+/**
+ * Paint ░ runs with brand blue/red by frozen glyph intervals.
+ * ██ keep the default foreground. Disable color with theme.enabled=false.
+ */
+export declare function paintWordmarkLarge(lines: readonly string[], theme: UiTheme): string[];
+/** Wordmark only (no notices). Used by wizard startup ordering. */
+export declare function renderWordmarkText(options: RenderBannerOptions): string;
+/** Project-root / dependency notice box for the current terminal width. */
+export declare function renderProjectNotice(columns: number): string;
+/**
+ * Combined wordmark + project notice.
+ * Wizard prefers renderWordmarkText then version/update then renderProjectNotice.
+ */
+export declare function renderBannerText(options: RenderBannerOptions): string;
 export declare const CLI_VERSION: string;

package/dist/ui/banner.js

@@ -1,34 +1,33 @@
 import packageJson from "../../package.json" with { type: "json" };
-/** ASCII banner generated by scripts/generate-banner.mjs (figlet, Standard font). */
-const slash = String.fromCharCode(92);
-export const MOEICONS_BANNER = [
-    "",
-    "  __  __  ___  _____ ___ ____ ___  _   _ ____",
-    ` |  ${slash}/  |/ _ ${slash}| ____|_ _/ ___/ _ ${slash}| ${slash} | / ___|`,
-    " | |" + slash + "/| | | | |  _|  | |  | | | |  " + slash + "| " + slash + "___ " + slash,
-    ` | |  | | |_| | |___ | | |__| |_| | |${slash}  |___) |`,
-    ` |_|  |_|${slash}___/|_____|___${slash}____${slash}___/|_| ${slash}_|____/`,
-    "",
-].join("\n");
+import { MOEICONS_BANNER } from "./generated/wordmark.js";
+import { MOEICONS_WORDMARK_LARGE, WORDMARK_LARGE_GLYPHS, WORDMARK_LARGE_WIDTH, } from "./generated/wordmark-large.js";
+import { ANSI_FG_RESET, createTheme } from "./theme.js";
+export { MOEICONS_BANNER };
+export { MOEICONS_WORDMARK_LARGE, WORDMARK_LARGE_GLYPHS, WORDMARK_LARGE_WIDTH, } from "./generated/wordmark-large.js";
+const CANVAS_WIDTH = 47;
+/** Figlet / mid tier when columns are in [52, 101). */
+export const MIN_FIGLET_COLUMNS = 52;
+/** Large Unicode wordmark when columns >= 101. */
+export const MIN_LARGE_COLUMNS = WORDMARK_LARGE_WIDTH;
 const ANSI_ESCAPE = new RegExp(`${String.fromCharCode(27)}\\[[0-?]*[ -/]*[@-~]`, "g");
 const COMBINING_MARK = /\p{Mark}/u;
 const CONTROL = /[\p{Cc}\p{Cf}]/u;
 const WIDE_CODEPOINT = "[" +
-    "\u1100-\u115f" + // Hangul jamo
-    "\u2e80-\u303e" + // CJK radicals, Kangxi, punctuation
-    "\u3041-\u33ff" + // Hiragana/Katakana, CJK symbols, enclosed
-    "\u3400-\u4dbf" + // CJK ext A
-    "\u4e00-\u9fff" + // CJK unified
-    "\ua000-\ua4cf" + // Yi
-    "\uac00-\ud7a3" + // Hangul syllables
-    "\uf900-\ufaff" + // CJK compat
-    "\ufe30-\ufe4f" + // CJK compat forms
-    "\uff00-\uff60" + // fullwidth forms
-    "\uffe0-\uffe6" + // fullwidth signs
+    "\u1100-\u115f" +
+    "\u2e80-\u303e" +
+    "\u3041-\u33ff" +
+    "\u3400-\u4dbf" +
+    "\u4e00-\u9fff" +
+    "\ua000-\ua4cf" +
+    "\uac00-\ud7a3" +
+    "\uf900-\ufaff" +
+    "\ufe30-\ufe4f" +
+    "\uff00-\uff60" +
+    "\uffe0-\uffe6" +
     "]";
 const WIDE_CHAR = new RegExp(WIDE_CODEPOINT, "u");
 export const CLI_NOTICE_LINES = [
-    "Run moeicons from your project root.",
+    "Run `moeicons` from your project root.",
     "React/Vue targets require the matching framework.",
     "Automatic Tailwind integration supports v3 only.",
     "Vanilla and Assets do not require React or Vue.",
@@ -99,7 +98,103 @@ export function renderNoticeBox(message, options = {}) {
         `${bottom}${horizontal.repeat(contentWidth + 2)}${bottomRight}`,
     ].join("\n");
 }
-export function renderBannerText() {
-    return `${MOEICONS_BANNER}\n${renderNoticeBox(CLI_NOTICE_LINES)}\n`;
+function normalizeColumns(columns) {
+    if (!Number.isFinite(columns) || columns <= 0)
+        return 80;
+    return columns;
+}
+function contentLines(value) {
+    const lines = value.split("\n");
+    while (lines[0] === "")
+        lines.shift();
+    while (lines.length > 0 && lines[lines.length - 1] === "")
+        lines.pop();
+    return lines;
+}
+/** Left-pad lines onto a canvas. Never adds trailing spaces. */
+export function centerLines(lines, width = CANVAS_WIDTH) {
+    return lines.map((line) => {
+        const pad = Math.max(0, Math.floor((width - visibleWidth(line)) / 2));
+        return pad > 0 ? `${" ".repeat(pad)}${line}` : line;
+    });
+}
+export function selectWordmarkTier(columns) {
+    const normalized = normalizeColumns(columns);
+    if (normalized >= MIN_LARGE_COLUMNS)
+        return "large";
+    if (normalized >= MIN_FIGLET_COLUMNS)
+        return "figlet";
+    return "single";
+}
+function glyphShadeAt(column) {
+    for (const glyph of WORDMARK_LARGE_GLYPHS) {
+        if (column >= glyph.start && column < glyph.end)
+            return glyph.shade;
+    }
+    return undefined;
+}
+/**
+ * Paint ░ runs with brand blue/red by frozen glyph intervals.
+ * ██ keep the default foreground. Disable color with theme.enabled=false.
+ */
+export function paintWordmarkLarge(lines, theme) {
+    // Color open sequences come only from theme (no RGB/ANSI literals here).
+    const openBlue = theme.openBlue;
+    const openRed = theme.openRed;
+    return lines.map((line) => {
+        const padded = line.padEnd(WORDMARK_LARGE_WIDTH, " ");
+        if (!theme.enabled)
+            return padded.replace(/ +$/u, "");
+        let result = "";
+        let active;
+        for (let column = 0; column < WORDMARK_LARGE_WIDTH; column += 1) {
+            const character = padded[column] ?? " ";
+            if (character === "░") {
+                const shade = glyphShadeAt(column) ?? "blue";
+                if (active !== shade) {
+                    if (active !== undefined)
+                        result += ANSI_FG_RESET;
+                    result += shade === "blue" ? openBlue : openRed;
+                    active = shade;
+                }
+                result += character;
+            }
+            else {
+                if (active !== undefined) {
+                    result += ANSI_FG_RESET;
+                    active = undefined;
+                }
+                result += character;
+            }
+        }
+        if (active !== undefined)
+            result += ANSI_FG_RESET;
+        return result.replace(/ +$/u, "");
+    });
+}
+/** Wordmark only (no notices). Used by wizard startup ordering. */
+export function renderWordmarkText(options) {
+    const columns = normalizeColumns(options.columns);
+    const tier = selectWordmarkTier(columns);
+    if (tier === "single")
+        return "MOEICONS";
+    if (tier === "figlet")
+        return centerLines(contentLines(MOEICONS_BANNER)).join("\n");
+    const theme = createTheme(options.color);
+    return paintWordmarkLarge([...MOEICONS_WORDMARK_LARGE], theme).join("\n");
+}
+/** Project-root / dependency notice box for the current terminal width. */
+export function renderProjectNotice(columns) {
+    return renderNoticeBox(CLI_NOTICE_LINES, { width: Math.max(20, normalizeColumns(columns)) });
+}
+/**
+ * Combined wordmark + project notice.
+ * Wizard prefers renderWordmarkText then version/update then renderProjectNotice.
+ */
+export function renderBannerText(options) {
+    const columns = normalizeColumns(options.columns);
+    const wordmark = renderWordmarkText(options);
+    const notice = renderProjectNotice(columns);
+    return `${wordmark}\n${notice}\n`;
 }
 export const CLI_VERSION = packageJson.version;

package/dist/ui/branded-prompts.d.ts

@@ -0,0 +1,41 @@
+import { isCancel } from "@clack/core";
+import type { Readable, Writable } from "node:stream";
+import type { UiChoice } from "../core/context.js";
+import type { UiTheme } from "./theme.js";
+export { isCancel };
+export interface BrandedPromptIo {
+    readonly theme: UiTheme;
+    readonly input?: Readable;
+    readonly output?: Writable;
+    readonly signal?: AbortSignal;
+}
+export interface SelectFrameOption {
+    readonly value: string;
+    readonly label: string;
+    readonly separatorBefore?: boolean;
+}
+export interface SelectFrameState {
+    readonly state: string;
+    readonly cursor: number;
+    readonly options: readonly SelectFrameOption[];
+}
+export interface ConfirmFrameState {
+    readonly state: string;
+    readonly value: boolean;
+}
+/** W3-D: opt-in key hints so existing golden output stays stable. */
+export interface FrameRenderOptions {
+    readonly hints?: boolean;
+}
+/** Format `1. label` with stable width for lists of 10+. */
+export declare function formatChoiceNumber(index: number, total: number, label: string): string;
+/** Renders every option with 1-based numbers. Back separators are blank lines. */
+export declare function renderSelectFrame(prompt: SelectFrameState, message: string, theme: UiTheme, options?: FrameRenderOptions): string;
+export declare function renderConfirmFrame(prompt: ConfirmFrameState, message: string, theme: UiTheme, options?: FrameRenderOptions): string;
+export declare function brandedSelect(options: BrandedPromptIo & {
+    readonly message: string;
+    readonly choices: readonly UiChoice[];
+}): Promise<string | symbol>;
+export declare function brandedConfirm(options: BrandedPromptIo & {
+    readonly message: string;
+}): Promise<boolean | symbol>;