@moewolf/moe-icons-cli 0.0.1 → 0.0.2

package/dist/core/target-subtree.d.ts

@@ -1,5 +1,7 @@
 import type { ReleaseTarget, ReleaseTargetMetadata } from "./release-descriptor.js";
 import type { Target } from "../commands/parser.js";
+import type { MoeiconsConfigFile } from "../project/config.js";
+import { type IconCatalog } from "../catalog/catalog.js";
 /**
  * Select the target subtree the CLI must install. Mirrors the archive layout
  * frozen in the code-library contract: each tier archive contains
@@ -27,6 +29,12 @@ export type TargetSubtreeFailure = {
     readonly message: string;
 };
 export type TargetSubtreeResult = TargetSubtreeSelection | TargetSubtreeFailure;
+/** Keep only the component modules reachable from configured icon proxies.
+ * The full target subtree must be verified against its release descriptor
+ * before this projection is called; this is a local installation filter, not
+ * a replacement for the immutable archive digest.
+ */
+export declare function configuredComponentFiles(files: Readonly<Record<string, Uint8Array>>, target: Target, config: MoeiconsConfigFile | undefined, catalog: IconCatalog): Readonly<Record<string, Uint8Array>>;
 /**
  * Deterministic subtree hash over subtree-relative files. Files and directories
  * are visited depth-first sorted by `localeCompare`, and each file contributes

package/dist/core/target-subtree.js

@@ -1,5 +1,56 @@
 import { createHash } from "node:crypto";
-import { extractTarGz } from "../project/tar-gz.js";
+import { extractTarGz, ICON_ARCHIVE_MAX_ENTRIES, ICON_ARCHIVE_MAX_EXPANDED_BYTES } from "../project/tar-gz.js";
+import { posix } from "node:path";
+import { toProxyName } from "./icon-names.js";
+import { findCatalogStyleGroup } from "../catalog/catalog.js";
+import { resolveIconTheme } from "./icon-selection.js";
+/** Keep only the component modules reachable from configured icon proxies.
+ * The full target subtree must be verified against its release descriptor
+ * before this projection is called; this is a local installation filter, not
+ * a replacement for the immutable archive digest.
+ */
+export function configuredComponentFiles(files, target, config, catalog) {
+    if (!config || (target !== "react" && target !== "vue"))
+        return files;
+    const selected = new Set();
+    const visit = (file) => {
+        if (selected.has(file))
+            return;
+        const bytes = files[file];
+        if (!bytes)
+            throw new Error(`verified ${target} archive is missing configured module: ${file}`);
+        selected.add(file);
+        const source = Buffer.from(bytes).toString("utf8");
+        const imports = /(?:\b(?:import|export)\s+(?:[^'";]*?\s+from\s*)?|\bimport\s*\()\s*["'](\.[^"']+)["']/g;
+        for (const match of source.matchAll(imports)) {
+            const specifier = match[1];
+            if (!specifier)
+                continue;
+            const resolved = posix.normalize(posix.join(posix.dirname(file), specifier));
+            if (resolved.startsWith("../") || resolved === "..")
+                throw new Error(`component import escapes target: ${file} → ${specifier}`);
+            const dependency = files[resolved] ? resolved : files[`${resolved}.d.ts`] ? `${resolved}.d.ts` : undefined;
+            if (!dependency)
+                throw new Error(`verified ${target} archive is missing dependency: ${file} → ${specifier}`);
+            visit(dependency);
+        }
+    };
+    visit("types.d.ts");
+    for (const iconId of config.icons) {
+        for (const theme of Object.keys(config.themes)) {
+            const actual = resolveIconTheme(config, catalog, theme, iconId);
+            if (!actual)
+                throw new Error(`icon "${iconId}" has no selected variant for theme "${theme}"`);
+            const group = config.themes[actual].styleGroup;
+            if (findCatalogStyleGroup(group, catalog)?.type === "bitmap")
+                continue;
+            const basename = `${group}/${toProxyName(iconId)}${target === "vue" ? ".vue" : ""}`;
+            visit(`${basename}.js`);
+            visit(`${basename}.d.ts`);
+        }
+    }
+    return Object.fromEntries([...selected].sort().map((file) => [file, files[file]]));
+}
 /**
  * Deterministic subtree hash over subtree-relative files. Files and directories
  * are visited depth-first sorted by `localeCompare`, and each file contributes
@@ -65,8 +116,8 @@ function hasModernTargetContract(source) {
  */
 export function selectTargetSubtree(archiveBytes, source, target) {
     const extracted = extractTarGz(archiveBytes, {
-        maxEntries: 20_000,
-        maxExpandedBytes: 64 * 1024 * 1024,
+        maxEntries: ICON_ARCHIVE_MAX_ENTRIES,
+        maxExpandedBytes: ICON_ARCHIVE_MAX_EXPANDED_BYTES,
     });
     if (extracted.errors.length > 0) {
         return { ok: false, reason: "validation", message: extracted.errors[0] ?? "invalid archive" };

package/dist/core/version-service.d.ts

@@ -1,7 +1,16 @@
+/**
+ * Test seam (candidate acceptance): `MOEICONS_LIBRARY_VERSIONS_URL` overrides
+ * the public versions endpoint. Only an https URL or a loopback http URL is
+ * accepted, so production behavior is unchanged.
+ */
+export declare function resolveVersionsEndpoint(env: Readonly<Record<string, string | undefined>>): string;
 export interface PublicTierVersion {
     readonly version: string;
     readonly releasedAt: string;
     readonly descriptorSha256: string;
+    /** A-1b: present only for an accepted local-test candidate. */
+    readonly channel?: "local-test";
+    readonly publishable?: boolean;
 }
 export interface PublicLibraryVersions {
     readonly schemaVersion: 1;
@@ -12,6 +21,8 @@ export declare function fetchLibraryVersions(deps?: {
     fetch?: typeof fetch;
     signal?: AbortSignal;
     timeoutMs?: number;
+    env?: Readonly<Record<string, string | undefined>>;
+    allowLocalTest?: boolean;
 }): Promise<PublicLibraryVersions>;
 export declare function fetchMoeiconsVersions(deps?: {
     fetch?: typeof fetch;

package/dist/core/version-service.js

@@ -3,19 +3,93 @@ import { parseVersion } from "./update-policy.js";
 const LIBRARY_VERSIONS_URL = "https://api.moeicons.com/v1/icon-library/versions";
 const NPM_PACKAGE_URL = "https://registry.npmjs.org/@moewolf%2fmoe-icons-cli";
 const SHA256 = /^[a-f0-9]{64}$/;
+/** A-1b: local-test candidate versions; only accepted with an explicit local context. */
+const LOCAL_TEST_VERSION = /^\d+\.\d+\.\d+-test$/;
 const CLI_VERSION_CACHE_TTL_MS = 5 * 60 * 1_000;
 let cliVersionCache;
-async function fixedFetch(url, fetchFn, signal, timeoutMs = 5_000) {
+/**
+ * Test seam (candidate acceptance): `MOEICONS_LIBRARY_VERSIONS_URL` overrides
+ * the public versions endpoint. Only an https URL or a loopback http URL is
+ * accepted, so production behavior is unchanged.
+ */
+export function resolveVersionsEndpoint(env) {
+    const override = env.MOEICONS_LIBRARY_VERSIONS_URL;
+    if (!override)
+        return LIBRARY_VERSIONS_URL;
+    let parsed;
+    try {
+        parsed = new URL(override);
+    }
+    catch {
+        throw new CliError("VALIDATION_ERROR", "MOEICONS_LIBRARY_VERSIONS_URL is not a valid URL");
+    }
+    const loopback = parsed.protocol === "http:" && ["127.0.0.1", "localhost", "::1"].includes(parsed.hostname);
+    if (parsed.protocol !== "https:" && !loopback) {
+        throw new CliError("VALIDATION_ERROR", "MOEICONS_LIBRARY_VERSIONS_URL must be https or loopback http");
+    }
+    return override;
+}
+async function fixedJson(url, fetchFn, maxBytes, signal, timeoutMs = 5_000) {
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    const abort = () => controller.abort();
-    if (signal?.aborted)
+    let reader;
+    let rejectAbort = () => { };
+    const interrupted = new Promise((_resolve, reject) => {
+        rejectAbort = reject;
+    });
+    const abort = () => {
         controller.abort();
+        void reader?.cancel().catch(() => { });
+        rejectAbort(new CliError(signal?.aborted ? "CANCELLED" : "NETWORK_ERROR", signal?.aborted ? "version check cancelled" : "version check timed out"));
+    };
+    const timer = setTimeout(abort, timeoutMs);
     signal?.addEventListener("abort", abort, { once: true });
+    const operation = async () => {
+        if (signal?.aborted)
+            throw new CliError("CANCELLED", "version check cancelled");
+        const response = await fetchFn(url, {
+            method: "GET",
+            headers: { accept: "application/json" },
+            signal: controller.signal,
+            redirect: "error",
+        });
+        if (!response.ok) {
+            void response.body?.cancel().catch(() => { });
+            throw new CliError("NETWORK_ERROR", `version check failed with ${response.status}`);
+        }
+        const declared = response.headers.get("content-length");
+        if (declared && (!/^\d+$/.test(declared) || Number(declared) > maxBytes)) {
+            void response.body?.cancel().catch(() => { });
+            throw new CliError("VALIDATION_ERROR", "version response exceeds size limit");
+        }
+        if (!response.body)
+            throw new CliError("VALIDATION_ERROR", "empty version response");
+        reader = response.body.getReader();
+        const chunks = [];
+        let total = 0;
+        for (;;) {
+            const part = await reader.read();
+            if (part.done)
+                break;
+            total += part.value.byteLength;
+            if (total > maxBytes) {
+                void reader.cancel().catch(() => { });
+                throw new CliError("VALIDATION_ERROR", "version response exceeds size limit");
+            }
+            chunks.push(part.value);
+        }
+        try {
+            return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        }
+        catch {
+            throw new CliError("VALIDATION_ERROR", "invalid version response JSON");
+        }
+    };
     try {
-        return await fetchFn(url, { method: "GET", headers: { accept: "application/json" }, signal: controller.signal, redirect: "error" });
+        return await Promise.race([operation(), interrupted]);
     }
-    catch {
+    catch (error) {
+        if (error instanceof CliError)
+            throw error;
         throw new CliError(signal?.aborted ? "CANCELLED" : "NETWORK_ERROR", signal?.aborted ? "version check cancelled" : "version check failed");
     }
     finally {
@@ -23,34 +97,61 @@ async function fixedFetch(url, fetchFn, signal, timeoutMs = 5_000) {
         signal?.removeEventListener("abort", abort);
     }
 }
-function tier(value) {
+function tier(value, allowLocalTest) {
     if (value === null)
         return null;
     if (typeof value !== "object" || value === null || Array.isArray(value))
         return undefined;
     const item = value;
-    return typeof item.version === "string" && parseVersion(item.version) && typeof item.releasedAt === "string" &&
-        /^\d{4}-\d{2}-\d{2}T.*Z$/.test(item.releasedAt) && typeof item.descriptorSha256 === "string" && SHA256.test(item.descriptorSha256)
-        ? item : undefined;
+    const baseValid = typeof item.version === "string" &&
+        typeof item.releasedAt === "string" &&
+        /^\d{4}-\d{2}-\d{2}T.*Z$/.test(item.releasedAt) &&
+        typeof item.descriptorSha256 === "string" &&
+        SHA256.test(item.descriptorSha256);
+    if (!baseValid)
+        return undefined;
+    const version = item.version;
+    if (parseVersion(version)) {
+        // A formal (stable/alpha/beta) version must never carry the local-test marker.
+        if (item.channel !== undefined || item.publishable !== undefined)
+            return undefined;
+        return item;
+    }
+    // A-1b: an `X.Y.Z-test` version is only accepted when the caller proved a
+    // local-only context and the release explicitly declares the local-test model.
+    if (allowLocalTest &&
+        LOCAL_TEST_VERSION.test(version) &&
+        item.channel === "local-test" &&
+        item.publishable === false) {
+        return item;
+    }
+    return undefined;
 }
 export async function fetchLibraryVersions(deps = {}) {
-    const response = await fixedFetch(LIBRARY_VERSIONS_URL, deps.fetch ?? fetch, deps.signal, deps.timeoutMs);
-    if (!response.ok)
-        throw new CliError("NETWORK_ERROR", `version check failed with ${response.status}`);
-    const value = await response.json();
-    const free = tier(value.free);
-    const pro = tier(value.pro);
-    if (value.schemaVersion !== 1 || free === undefined || pro === undefined || Object.keys(value).some((key) => !["schemaVersion", "free", "pro"].includes(key))) {
+    const url = resolveVersionsEndpoint(deps.env ?? {});
+    const allowLocalTest = deps.allowLocalTest === true;
+    const raw = await fixedJson(url, deps.fetch ?? fetch, 32 * 1024, deps.signal, deps.timeoutMs);
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        throw new CliError("VALIDATION_ERROR", "invalid icon library versions response");
+    const value = raw;
+    const free = tier(value.free, allowLocalTest);
+    const pro = tier(value.pro, allowLocalTest);
+    if (value.schemaVersion !== 1 ||
+        free === undefined ||
+        pro === undefined ||
+        Object.keys(value).some((key) => !["schemaVersion", "free", "pro"].includes(key))) {
         throw new CliError("VALIDATION_ERROR", "invalid icon library versions response");
     }
     return { schemaVersion: 1, free, pro };
 }
 export async function fetchMoeiconsVersions(deps = {}) {
-    const response = await fixedFetch(NPM_PACKAGE_URL, deps.fetch ?? fetch, deps.signal, deps.timeoutMs);
-    if (!response.ok)
-        throw new CliError("NETWORK_ERROR", `CLI version check failed with ${response.status}`);
-    const value = await response.json();
-    if (typeof value.versions !== "object" || value.versions === null || Array.isArray(value.versions))
+    const raw = await fixedJson(NPM_PACKAGE_URL, deps.fetch ?? fetch, 8 * 1024 * 1024, deps.signal, deps.timeoutMs);
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        throw new CliError("VALIDATION_ERROR", "invalid npm package metadata");
+    const value = raw;
+    if (typeof value.versions !== "object" ||
+        value.versions === null ||
+        Array.isArray(value.versions))
         throw new CliError("VALIDATION_ERROR", "invalid npm package metadata");
     return Object.keys(value.versions).filter((version) => parseVersion(version));
 }
@@ -66,6 +167,10 @@ export function latestInChannel(current, versions) {
     const parsed = parseVersion(current);
     if (!parsed)
         return undefined;
-    return versions.map((version) => ({ version, parsed: parseVersion(version) })).filter((item) => item.parsed?.channel === parsed.channel)
-        .sort((a, b) => (b.parsed.major - a.parsed.major) || (b.parsed.minor - a.parsed.minor) || (b.parsed.patch - a.parsed.patch))[0]?.version;
+    return versions
+        .map((version) => ({ version, parsed: parseVersion(version) }))
+        .filter((item) => item.parsed?.channel === parsed.channel)
+        .sort((a, b) => b.parsed.major - a.parsed.major ||
+        b.parsed.minor - a.parsed.minor ||
+        b.parsed.patch - a.parsed.patch)[0]?.version;
 }

package/dist/core/wizard.d.ts

@@ -1,4 +1,4 @@
-import type { CommandContext } from "./context.js";
+import type { CommandContext, UiChoice } from "./context.js";
 export type WizardResult = {
     readonly ok: true;
     readonly action: "json-hint";
@@ -12,6 +12,9 @@ export type WizardResult = {
     readonly ok: true;
     readonly action: "pending";
     readonly flow: "login";
+} | {
+    readonly ok: true;
+    readonly action: "pro-resources";
 } | {
     readonly ok: true;
     readonly action: "manage";
@@ -20,30 +23,30 @@ export type WizardResult = {
     readonly ok: true;
     readonly action: "settings";
     readonly flow: "logout" | "cli-update";
+} | {
+    readonly ok: true;
+    readonly action: "back";
+} | {
+    readonly ok: true;
+    readonly action: "exit";
+    readonly via: "menu" | "cancel";
 } | {
     readonly ok: false;
     readonly reason: "cancelled";
 };
 export type WizardSessionState = "authenticated" | "signed-out" | "unknown";
-export declare function homeChoices(session: WizardSessionState): readonly [{
-    readonly value: "pro";
-    readonly label: "Install moeicons pro";
-}, {
-    readonly value: "free";
-    readonly label: "Install moeicons free";
-}, {
-    readonly value: "manage";
-    readonly label: "Manage project icons";
-}, ...{
-    value: string;
-    label: string;
-}[], {
-    readonly value: "settings";
-    readonly label: "Settings";
-}];
+export declare function homeChoices(session: WizardSessionState, proResourcesLabel?: string): UiChoice[];
+export declare function settingsChoices(session: WizardSessionState): UiChoice[];
+export declare function manageChoices(status?: string): UiChoice[];
+export declare function targetChoices(): UiChoice[];
+export declare function loginRecoveryChoices(): UiChoice[];
 /** Wizard state machine. No Clack/Commander/process imports. */
+export declare const HOME_MESSAGE = "Choose an option";
 export declare function runWizardUseCase(context: CommandContext, options: {
     readonly json: boolean;
     readonly session?: WizardSessionState;
     readonly getLibraryStatus?: () => Promise<string>;
+    readonly getProResourceLabel?: () => Promise<string | undefined>;
+    /** W3-E2: optional single-line recent-task status shown above the menu. */
+    readonly historyLine?: string;
 }): Promise<WizardResult>;

package/dist/core/wizard.js

@@ -1,10 +1,15 @@
 import { detectProject } from "../project/detect.js";
 import { CliError } from "../errors/index.js";
 const JSON_HINT = "interactive wizard unavailable in JSON mode; use install/login/account/groups/generate";
-export function homeChoices(session) {
+const BACK = { value: "back", label: "Back", separatorBefore: true };
+const EXIT = { value: "exit", label: "Exit" };
+export function homeChoices(session, proResourcesLabel) {
     return [
         { value: "pro", label: "Install moeicons pro" },
         { value: "free", label: "Install moeicons free" },
+        ...(session === "authenticated" && proResourcesLabel
+            ? [{ value: "pro-resources", label: proResourcesLabel }]
+            : []),
         { value: "manage", label: "Manage project icons" },
         ...(session === "authenticated"
             ? []
@@ -15,56 +20,89 @@ export function homeChoices(session) {
                 },
             ]),
         { value: "settings", label: "Settings" },
+        EXIT,
+    ];
+}
+export function settingsChoices(session) {
+    return [
+        ...(session === "authenticated" ? [{ value: "logout", label: "Log out" }] : []),
+        { value: "cli-update", label: "Check for CLI updates" },
+        BACK,
+    ];
+}
+export function manageChoices(status) {
+    return [
+        { value: "reload", label: "Update project resources" },
+        {
+            value: "library-update",
+            label: `Update icon library version${status ? ` — ${status}` : ""}`,
+        },
+        BACK,
+    ];
+}
+export function targetChoices() {
+    return [
+        { value: "react", label: "React" },
+        { value: "vue", label: "Vue" },
+        { value: "vanilla", label: "Vanilla" },
+        { value: "assets", label: "Static assets" },
+        BACK,
+    ];
+}
+export function loginRecoveryChoices() {
+    return [
+        { value: "retry", label: "Retry login" },
+        BACK,
     ];
 }
 /** Wizard state machine. No Clack/Commander/process imports. */
+export const HOME_MESSAGE = "Choose an option";
 export async function runWizardUseCase(context, options) {
     if (options.json) {
         return { ok: true, action: "json-hint", message: JSON_HINT };
     }
-    const choice = await context.ui.select("Choose an option", homeChoices(options.session ?? "signed-out"), context.signal);
+    const session = options.session ?? "signed-out";
+    const proLabel = session === "authenticated" ? await options.getProResourceLabel?.().catch(() => undefined) : undefined;
+    const message = options.historyLine ? `${options.historyLine}\n\n${HOME_MESSAGE}` : HOME_MESSAGE;
+    const choice = await context.ui.select(message, homeChoices(session, proLabel), context.signal);
+    // Esc on home == Exit (cancel path); explicit Exit menu item uses via=menu.
     if (choice === undefined)
-        return { ok: false, reason: "cancelled" };
+        return { ok: true, action: "exit", via: "cancel" };
+    if (choice === "exit")
+        return { ok: true, action: "exit", via: "menu" };
     if (choice === "login")
         return { ok: true, action: "pending", flow: "login" };
+    if (choice === "pro-resources")
+        return { ok: true, action: "pro-resources" };
     if (choice === "settings") {
-        const setting = await context.ui.select("Settings", [
-            ...(options.session === "authenticated" ? [{ value: "logout", label: "Log out" }] : []),
-            { value: "cli-update", label: "Check for CLI updates" },
-        ], context.signal);
-        return setting === undefined
-            ? { ok: false, reason: "cancelled" }
-            : { ok: true, action: "settings", flow: setting };
+        const setting = await context.ui.select("Settings", settingsChoices(session), context.signal);
+        if (setting === undefined || setting === "back")
+            return { ok: true, action: "back" };
+        return { ok: true, action: "settings", flow: setting };
     }
     const project = detectProject(context.cwd);
     if (!project)
         throw new CliError("VALIDATION_ERROR", "no package.json found in the current directory or parents; run inside a project");
     if (choice === "manage") {
         const status = await options.getLibraryStatus?.();
-        const management = await context.ui.select("Manage project icons", [
-            { value: "reload", label: "Update project resources" },
-            {
-                value: "library-update",
-                label: `Update icon library version${status ? ` — ${status}` : ""}`,
-            },
-        ], context.signal);
-        return management === undefined
-            ? { ok: false, reason: "cancelled" }
-            : { ok: true, action: "manage", flow: management };
+        const management = await context.ui.select("Manage project icons", manageChoices(status), context.signal);
+        if (management === undefined || management === "back")
+            return { ok: true, action: "back" };
+        return { ok: true, action: "manage", flow: management };
     }
     if (choice === "free" || choice === "pro") {
-        const target = await context.ui.select("Choose an output target", [
-            { value: "react", label: "React" },
-            { value: "vue", label: "Vue" },
-            { value: "vanilla", label: "Vanilla" },
-            { value: "assets", label: "Static assets" },
-        ], context.signal);
+        const target = await context.ui.select("Choose an output target", targetChoices(), context.signal);
+        if (target === undefined || target === "back")
+            return { ok: true, action: "back" };
         if (target !== "react" && target !== "vue" && target !== "vanilla" && target !== "assets") {
-            return { ok: false, reason: "cancelled" };
+            return { ok: true, action: "back" };
         }
         const confirmed = await context.ui.confirm(`Install ${choice} ${target} into ${project.root}?`, context.signal);
-        if (confirmed !== true)
+        // Esc / Ctrl+C on confirm exits; No returns to home (back)
+        if (confirmed === undefined)
             return { ok: false, reason: "cancelled" };
+        if (confirmed !== true)
+            return { ok: true, action: "back" };
         return { ok: true, action: "install", group: choice, target };
     }
     throw new CliError("VALIDATION_ERROR", `unknown wizard choice: ${choice}`);

package/dist/errors/errors.d.ts

@@ -3,7 +3,7 @@
  * 0 success/cancel, 1 validation error, 2 auth error, 3 network error,
  * 4 not found, 5 unexpected.
  */
-export type CliErrorCode = "HELP" | "VERSION" | "CANCELLED" | "VALIDATION_ERROR" | "TAILWIND_VERSION_UNSUPPORTED" | "AUTH_ERROR" | "NETWORK_ERROR" | "NOT_FOUND" | "FORBIDDEN" | "NOT_TTY" | "NOT_IMPLEMENTED" | "UNEXPECTED";
+export type CliErrorCode = "HELP" | "VERSION" | "CANCELLED" | "VALIDATION_ERROR" | "TAILWIND_VERSION_UNSUPPORTED" | "AUTH_ERROR" | "NETWORK_ERROR" | "NOT_FOUND" | "FORBIDDEN" | "NOT_TTY" | "NOT_IMPLEMENTED" | "DISK_FULL" | "UNEXPECTED";
 /** Frozen CliErrorCode → process exit code. Register new codes here before use. */
 export declare const CLI_ERROR_EXIT_MAP: {
     readonly HELP: 0;
@@ -17,6 +17,7 @@ export declare const CLI_ERROR_EXIT_MAP: {
     readonly FORBIDDEN: 2;
     readonly NETWORK_ERROR: 3;
     readonly NOT_FOUND: 4;
+    readonly DISK_FULL: 5;
     readonly UNEXPECTED: 5;
 };
 export type JsonErrorBody = {

package/dist/errors/errors.js

@@ -16,6 +16,7 @@ export const CLI_ERROR_EXIT_MAP = {
     FORBIDDEN: 2,
     NETWORK_ERROR: 3,
     NOT_FOUND: 4,
+    DISK_FULL: 5,
     UNEXPECTED: 5,
 };
 export class CliError extends Error {

package/dist/generator/generate.d.ts

@@ -6,7 +6,7 @@ export { toLibraryExportName, toProxyName };
 export declare const toPascalCase: typeof toProxyName;
 /**
  * React/Vue proxy generation. Purely returns owned file paths/content for
- * types, registry, provider/plugin, proxies and barrel exports. Rejects
+ * types, provider/plugin, per-icon proxies and barrel exports. Rejects
  * duplicate PascalCase names and missing fallback. Bitmap themes use local
  * img wrappers + static asset imports (G1/G4); SVG themes import moe-icons.
  */