@moewolf/moe-icons-cli 0.0.1 → 0.0.2

package/dist/metadata/manifest.d.ts

@@ -0,0 +1,33 @@
+import type { ReleaseTarget } from "../core/release-descriptor.js";
+export interface MetadataFileDigest {
+    readonly size: number;
+    readonly sha256: string;
+}
+export interface MetadataManifest {
+    readonly schemaVersion: 1;
+    readonly tier: "free" | "pro";
+    readonly libraryVersion: string;
+    readonly manualVersion: string;
+    readonly catalogVersion: string;
+    readonly cliVersion: string;
+    readonly generatedAt: {
+        readonly sourceCommit: string;
+        readonly generatorCommit: string;
+    };
+    readonly targets: readonly ReleaseTarget[];
+    readonly dependencies: Readonly<Partial<Record<ReleaseTarget, Readonly<Record<string, string>>>>>;
+    readonly files: {
+        readonly "MANUAL.md": MetadataFileDigest;
+        readonly "catalog.json": MetadataFileDigest;
+    };
+    /** ICON-E2E-0907 / E2E-E2: local-test candidates only. */
+    readonly channel?: "local-test";
+    readonly publishable?: boolean;
+}
+/**
+ * Strict parse of a metadata manifest. Unknown fields, unknown schemaVersion,
+ * a tier/version/hash mismatch or malformed file digests are hard errors.
+ */
+export declare function parseMetadataManifest(raw: string | Uint8Array, opts?: {
+    readonly allowLocalTest?: boolean;
+}): MetadataManifest;

package/dist/metadata/manifest.js

@@ -0,0 +1,136 @@
+const SHA256_HEX = /^[a-f0-9]{64}$/;
+const VERSION = /^\d+\.\d+\.\d+(?:-(?:alpha|beta))?$/;
+const LOCAL_TEST_VERSION = /^\d+\.\d+\.\d+-test$/;
+const COMMIT = /^[0-9a-f]{40}$/;
+const RELEASE_TARGETS = ["react", "vue", "vanilla", "assets"];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseFileDigest(value, field) {
+    if (!isRecord(value))
+        throw new Error(`${field} must be an object`);
+    if (typeof value.size !== "number" || !Number.isSafeInteger(value.size) || value.size < 1) {
+        throw new Error(`${field}.size must be a positive integer`);
+    }
+    if (typeof value.sha256 !== "string" || !SHA256_HEX.test(value.sha256)) {
+        throw new Error(`${field}.sha256 must be a 64-char sha256 hex`);
+    }
+    return { size: value.size, sha256: value.sha256.toLowerCase() };
+}
+/**
+ * Strict parse of a metadata manifest. Unknown fields, unknown schemaVersion,
+ * a tier/version/hash mismatch or malformed file digests are hard errors.
+ */
+export function parseMetadataManifest(raw, opts = {}) {
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.from(raw).toString("utf8"));
+    }
+    catch {
+        throw new Error("manifest.json is not valid JSON");
+    }
+    if (!isRecord(parsed))
+        throw new Error("manifest.json must be an object");
+    const allowLocalTest = opts.allowLocalTest === true;
+    const allowed = new Set([
+        "schemaVersion",
+        "tier",
+        "libraryVersion",
+        "manualVersion",
+        "catalogVersion",
+        "cliVersion",
+        "generatedAt",
+        "targets",
+        "dependencies",
+        "files",
+        "channel",
+        "publishable",
+    ]);
+    for (const key of Object.keys(parsed)) {
+        if (!allowed.has(key))
+            throw new Error(`manifest.json has an unknown field: ${key}`);
+    }
+    if (parsed.schemaVersion !== 1)
+        throw new Error(`unsupported manifest schemaVersion: ${String(parsed.schemaVersion)}`);
+    if (parsed.tier !== "free" && parsed.tier !== "pro") {
+        throw new Error(`manifest.json has an invalid tier: ${String(parsed.tier)}`);
+    }
+    const channel = parsed.channel === "local-test" ? "local-test" : undefined;
+    const publishable = parsed.publishable === true || parsed.publishable === false
+        ? parsed.publishable
+        : undefined;
+    const localTestMarked = channel === "local-test" && publishable === false;
+    if (allowLocalTest && !localTestMarked && parsed.channel !== undefined) {
+        throw new Error("manifest.json local context requires channel local-test and publishable: false");
+    }
+    const versionAllowed = (value) => {
+        if (typeof value !== "string")
+            return false;
+        if (VERSION.test(value))
+            return true;
+        return allowLocalTest && localTestMarked && LOCAL_TEST_VERSION.test(value);
+    };
+    for (const field of ["libraryVersion", "manualVersion", "catalogVersion", "cliVersion"]) {
+        if (!versionAllowed(parsed[field])) {
+            throw new Error(`manifest.json ${field} must be a valid semver string`);
+        }
+    }
+    if (!isRecord(parsed.generatedAt))
+        throw new Error("manifest.json generatedAt must be an object");
+    const generatedAt = parsed.generatedAt;
+    for (const field of ["sourceCommit", "generatorCommit"]) {
+        if (typeof generatedAt[field] !== "string" || !COMMIT.test(generatedAt[field])) {
+            throw new Error(`manifest.json generatedAt.${field} must be a 40-char commit sha`);
+        }
+    }
+    if (!Array.isArray(parsed.targets) ||
+        parsed.targets.length === 0 ||
+        !parsed.targets.every((target) => RELEASE_TARGETS.includes(target))) {
+        throw new Error("manifest.json targets must be a non-empty array of release targets");
+    }
+    const targets = parsed.targets;
+    if (!isRecord(parsed.dependencies))
+        throw new Error("manifest.json dependencies must be an object");
+    const dependencies = {
+        react: {},
+        vue: {},
+        vanilla: {},
+        assets: {},
+    };
+    for (const [target, value] of Object.entries(parsed.dependencies)) {
+        if (!RELEASE_TARGETS.includes(target)) {
+            throw new Error(`manifest.json has an unknown target dependency: ${target}`);
+        }
+        if (!isRecord(value))
+            throw new Error(`manifest.json dependencies.${target} must be an object`);
+        dependencies[target] = Object.fromEntries(Object.entries(value).map(([name, range]) => [name, String(range)]));
+    }
+    if (!isRecord(parsed.files))
+        throw new Error("manifest.json files must be an object");
+    const files = {
+        "MANUAL.md": parseFileDigest(parsed.files["MANUAL.md"], "files.MANUAL.md"),
+        "catalog.json": parseFileDigest(parsed.files["catalog.json"], "files.catalog.json"),
+    };
+    for (const key of Object.keys(parsed.files)) {
+        if (key !== "MANUAL.md" && key !== "catalog.json") {
+            throw new Error(`manifest.json files has an unknown entry: ${key}`);
+        }
+    }
+    return {
+        schemaVersion: 1,
+        tier: parsed.tier,
+        libraryVersion: parsed.libraryVersion,
+        manualVersion: parsed.manualVersion,
+        catalogVersion: parsed.catalogVersion,
+        cliVersion: parsed.cliVersion,
+        generatedAt: {
+            sourceCommit: generatedAt.sourceCommit,
+            generatorCommit: generatedAt.generatorCommit,
+        },
+        targets,
+        dependencies,
+        files,
+        ...(channel ? { channel } : {}),
+        ...(publishable !== undefined ? { publishable } : {}),
+    };
+}

package/dist/metadata/version.d.ts

@@ -0,0 +1,22 @@
+export interface ParsedVersion {
+    readonly major: number;
+    readonly minor: number;
+    readonly patch: number;
+    readonly channel: "stable" | "alpha" | "beta";
+}
+export declare function parseVersion(value: string): ParsedVersion;
+/** Three-way semver comparison; never string-dictionary compares prerelease tags. */
+export declare function compareVersions(a: string, b: string): -1 | 0 | 1;
+export declare function isVersionNewer(candidate: string, current: string): boolean;
+/**
+ * Per-resource version state for code and metadata. Distinguishes a CLI that is
+ * too old to consume the remote (incompatible), a corrupt local install, and a
+ * plain missing/current/update state.
+ */
+export type ResourceStatus = "missing" | "current" | "update-available" | "incompatible" | "corrupt";
+export declare function cliCompatible(minRequiredCli: string, cliVersion: string): boolean;
+/**
+ * Format a byte count for user-facing size hints (MiB, 1024-based, one decimal;
+ * KiB/B below one MiB). Frozen contract shared by the free and pro flows.
+ */
+export declare function formatBytes(bytes: number): string;

package/dist/metadata/version.js

@@ -0,0 +1,53 @@
+const VERSION = /^(\d+)\.(\d+)\.(\d+)(?:-(alpha|beta))?$/;
+export function parseVersion(value) {
+    const match = VERSION.exec(value);
+    if (!match)
+        throw new Error(`invalid version: ${value}`);
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        channel: match[4] === "alpha" ? "alpha" : match[4] === "beta" ? "beta" : "stable",
+    };
+}
+/** Three-way semver comparison; never string-dictionary compares prerelease tags. */
+export function compareVersions(a, b) {
+    const left = parseVersion(a);
+    const right = parseVersion(b);
+    if (left.major !== right.major)
+        return left.major < right.major ? -1 : 1;
+    if (left.minor !== right.minor)
+        return left.minor < right.minor ? -1 : 1;
+    if (left.patch !== right.patch)
+        return left.patch < right.patch ? -1 : 1;
+    const channelRank = (channel) => channel === "alpha" ? 0 : channel === "beta" ? 1 : 2;
+    const l = channelRank(left.channel);
+    const r = channelRank(right.channel);
+    if (l !== r)
+        return l < r ? -1 : 1;
+    return 0;
+}
+export function isVersionNewer(candidate, current) {
+    return compareVersions(candidate, current) > 0;
+}
+export function cliCompatible(minRequiredCli, cliVersion) {
+    try {
+        return compareVersions(cliVersion, minRequiredCli) >= 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Format a byte count for user-facing size hints (MiB, 1024-based, one decimal;
+ * KiB/B below one MiB). Frozen contract shared by the free and pro flows.
+ */
+export function formatBytes(bytes) {
+    const kib = 1024;
+    const mib = kib * 1024;
+    if (bytes >= mib)
+        return `${(bytes / mib).toFixed(1)} MiB`;
+    if (bytes >= kib)
+        return `${(bytes / kib).toFixed(1)} KiB`;
+    return `${bytes} B`;
+}

package/dist/project/anchors/application.d.ts

@@ -0,0 +1,13 @@
+import type { AnchorResult, PlannedFileChange } from "./types.js";
+import type { DetectorIo } from "./helpers.js";
+export type { PlannedFileChange };
+export interface ApplicationAnchorOptions {
+    readonly root: string;
+    readonly adapter?: string;
+    readonly io: DetectorIo;
+    /** true when the target is assets-only and application registration is not required. */
+    readonly assetsOnly?: boolean;
+    readonly outputDir?: string;
+    readonly confirmedEntry?: string;
+}
+export declare function inspectApplicationAnchor(options: ApplicationAnchorOptions): AnchorResult;

package/dist/project/anchors/application.js

@@ -0,0 +1,377 @@
+import { dirname, join, posix } from "node:path";
+import { parseSource } from "./parse.js";
+/**
+ * Application anchor (E2E-B3).
+ *
+ * Only three auto-patchable shapes are supported and each gets its own
+ * analyzer/plan in this file:
+ *   - Vite React  `createRoot(...).render(<App />)`
+ *   - Vite Vue    `createApp(App).mount(...)`
+ *   - Vanilla     a single module entry
+ * Next App/Pages, Nuxt and custom bootstrap are `unsupported` (detection +
+ * manual instructions only, fixes empty). Detectors never write; they return a
+ * plan of PlannedFileChange built from parsed AST positions.
+ */
+const ENTRY_CANDIDATES = {
+    "vite-react": ["src/main.tsx", "src/main.jsx", "src/index.tsx", "src/index.jsx"],
+    "vite-vue": ["src/main.ts", "src/main.js"],
+    vanilla: ["src/main.ts", "src/main.js", "main.ts", "main.js"],
+    "next-app": ["app/layout.tsx", "src/app/layout.tsx"],
+    "next-pages": ["pages/_app.tsx", "src/pages/_app.tsx"],
+    nuxt: ["plugins/moeicons.ts", "app.vue"],
+};
+const isRecord = (v) => typeof v === "object" && v !== null;
+function namedImportBinding(source, rel, specifier, imported) {
+    const parsed = parseSource(source, rel);
+    if (!parsed.ok)
+        return undefined;
+    for (const node of parsed.ast.program.body) {
+        if (node.type !== "ImportDeclaration" || node.source.value !== specifier)
+            continue;
+        for (const item of node.specifiers) {
+            if (item.type === "ImportSpecifier" &&
+                (item.imported.type === "Identifier" ? item.imported.name : item.imported.value) === imported)
+                return item.local.name;
+        }
+    }
+    return undefined;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Find the single `createRoot(...).render(...)` statement text region. */
+function readEntry(io, root, rel) {
+    const full = join(root, rel);
+    if (!io.existsSync(full))
+        return undefined;
+    try {
+        return { source: io.readFileSync(full) };
+    }
+    catch {
+        return undefined;
+    }
+}
+function locateCandidate(io, root, candidates) {
+    const present = candidates.filter((c) => readEntry(io, root, c) !== undefined);
+    if (present.length === 0)
+        return { ambiguous: true };
+    if (present.length > 1)
+        return { ambiguous: true };
+    return { rel: present[0] ?? "", source: readEntry(io, root, present[0] ?? "")?.source ?? "" };
+}
+function unsupportedManual(adapter) {
+    return {
+        kind: "application",
+        status: "unsupported",
+        candidates: ENTRY_CANDIDATES[adapter] ?? [],
+        evidence: [
+            `${adapter} registration is detect-only in this CLI release; a manual patch is required`,
+        ],
+        fixes: [],
+    };
+}
+/**
+ * Vite React plan: wrap the unique root in `MoeiconsProvider`. The plan is
+ * generated from a parsed AST but applied as a small deterministic text patch so
+ * it survives formatting differences.
+ */
+function planViteReact(source, rel, specifier) {
+    const binding = namedImportBinding(source, rel, specifier, "MoeiconsProvider");
+    const parsed = parseSource(source, rel);
+    if (!parsed.ok) {
+        return {
+            kind: "application",
+            status: "invalid",
+            path: rel,
+            candidates: [rel],
+            evidence: [`cannot parse ${rel}: ${parsed.error}`],
+            fixes: [],
+        };
+    }
+    const root = findUniqueRender(parsed.ast);
+    if (root === "multiple") {
+        return {
+            kind: "application",
+            status: "ambiguous",
+            path: rel,
+            candidates: [rel],
+            evidence: ["multiple createRoot(...).render(...) calls found"],
+            fixes: [],
+        };
+    }
+    if (root === undefined) {
+        return {
+            kind: "application",
+            status: "unsupported",
+            path: rel,
+            candidates: [rel],
+            evidence: ["no unique createRoot(...).render(<App />) shape found"],
+            fixes: [],
+        };
+    }
+    const { childStart, childEnd } = root;
+    const child = source.slice(childStart, childEnd);
+    if (binding && new RegExp(`^\\s*<${escapeRegExp(binding)}(?:\\s|>)`).test(child)) {
+        return { kind: "application", status: "ok", path: rel, candidates: [rel], evidence: ["render root is wrapped in the generated Provider"], fixes: [] };
+    }
+    const providerName = binding ?? "MoeiconsProvider";
+    const after = source.slice(0, childStart) + `<${providerName}>${child}</${providerName}>` + source.slice(childEnd);
+    const imported = binding ? after : insertImport(after, `import { MoeiconsProvider } from "${specifier}";`, rel);
+    const valid = parseSource(imported, rel);
+    if (!valid.ok)
+        return { kind: "application", status: "invalid", path: rel, candidates: [rel], evidence: [`generated React patch is invalid: ${valid.error}`], fixes: [] };
+    return {
+        kind: "application",
+        status: "missing",
+        path: rel,
+        candidates: [rel],
+        evidence: ["unique createRoot render found; Provider wrap plan generated"],
+        fixes: [{ kind: "replace", path: rel, before: source, after: imported }],
+    };
+}
+/** Find the unique JSX child range of a `.render(...)` call. */
+function findUniqueRender(ast) {
+    const renders = [];
+    const visit = (node) => {
+        if (!isRecord(node) || typeof node !== "object")
+            return;
+        const type = typeof node.type === "string" ? node.type : "";
+        if (type === "CallExpression" &&
+            isRecord(node.callee) &&
+            node.callee.type === "MemberExpression" &&
+            isRecord(node.callee.object) &&
+            node.callee.object.type === "CallExpression" &&
+            isRecord(node.callee.object.callee) &&
+            node.callee.object.callee.type === "Identifier" &&
+            node.callee.object.callee.name === "createRoot" &&
+            isRecord(node.callee.property) &&
+            node.callee.property.type === "Identifier" &&
+            node.callee.property.name === "render" &&
+            Array.isArray(node.arguments) &&
+            node.arguments.length === 1) {
+            const child = node.arguments[0];
+            if (child && typeof child.start === "number" && typeof child.end === "number") {
+                renders.push({ start: child.start, end: child.end });
+            }
+        }
+        for (const value of Object.values(node)) {
+            if (Array.isArray(value))
+                for (const item of value)
+                    visit(item);
+            else if (value && typeof value === "object")
+                visit(value);
+        }
+    };
+    visit(ast);
+    if (renders.length === 0)
+        return undefined;
+    if (renders.length > 1)
+        return "multiple";
+    const only = renders[0];
+    return only ? { childStart: only.start, childEnd: only.end } : undefined;
+}
+function insertImport(source, line, rel = "src/main.tsx") {
+    if (source.includes(line))
+        return source;
+    const parsed = parseSource(source, rel);
+    if (!parsed.ok)
+        return source;
+    const declarations = parsed.ast.program.body.filter((node) => node.type === "ImportDeclaration");
+    const anchor = declarations.length ? declarations[declarations.length - 1]?.end ?? 0 : 0;
+    return `${source.slice(0, anchor)}${anchor ? "\n" : ""}${line}\n${source.slice(anchor)}`;
+}
+/** Vite Vue plan: create a Provider host and use it as the app root (no app.use). */
+function planViteVue(source, rel, specifier) {
+    const binding = namedImportBinding(source, rel, specifier, "MoeiconsProvider");
+    const hBinding = namedImportBinding(source, rel, "vue", "h");
+    const hName = hBinding ?? "h";
+    const parsed = parseSource(source, rel);
+    if (!parsed.ok) {
+        return {
+            kind: "application",
+            status: "invalid",
+            path: rel,
+            candidates: [rel],
+            evidence: [`cannot parse ${rel}: ${parsed.error}`],
+            fixes: [],
+        };
+    }
+    const mount = findCreateAppMount(parsed.ast);
+    if (mount === "multiple") {
+        return {
+            kind: "application",
+            status: "ambiguous",
+            path: rel,
+            candidates: [rel],
+            evidence: ["multiple createApp(...).mount(...) calls found"],
+            fixes: [],
+        };
+    }
+    if (mount === undefined) {
+        return {
+            kind: "application",
+            status: "unsupported",
+            path: rel,
+            candidates: [rel],
+            evidence: ["no unique createApp(...).mount(...) shape found"],
+            fixes: [],
+        };
+    }
+    const { rootStart, rootEnd } = mount;
+    const rootText = source.slice(rootStart, rootEnd);
+    if (binding && new RegExp(`${escapeRegExp(hName)}\\(${escapeRegExp(binding)}\\b`).test(rootText)) {
+        return { kind: "application", status: "ok", path: rel, candidates: [rel], evidence: ["createApp root renders the generated Provider"], fixes: [] };
+    }
+    // Host component renders the original root inside MoeiconsProvider.
+    const providerName = binding ?? "MoeiconsProvider";
+    const after = source.slice(0, rootStart) +
+        `{ render: () => ${hName}(${providerName}, null, { default: () => ${hName}(${rootText}) }) }` +
+        source.slice(rootEnd);
+    const withProvider = binding ? after : insertImport(after, `import { MoeiconsProvider } from "${specifier}";`, rel);
+    const withH = hBinding ? withProvider : insertImport(withProvider, `import { h } from "vue";`, rel);
+    const valid = parseSource(withH, rel);
+    if (!valid.ok)
+        return { kind: "application", status: "invalid", path: rel, candidates: [rel], evidence: [`generated Vue patch is invalid: ${valid.error}`], fixes: [] };
+    return {
+        kind: "application",
+        status: "missing",
+        path: rel,
+        candidates: [rel],
+        evidence: ["unique createApp found; Provider-host plan generated (no app.use plugin)"],
+        fixes: [
+            {
+                kind: "replace",
+                path: rel,
+                before: source,
+                after: withH,
+            },
+        ],
+    };
+}
+function findCreateAppMount(ast) {
+    const found = [];
+    const visit = (node) => {
+        if (!isRecord(node))
+            return;
+        const type = typeof node.type === "string" ? node.type : "";
+        if (type === "CallExpression" &&
+            isRecord(node.callee) &&
+            node.callee.type === "MemberExpression" &&
+            isRecord(node.callee.property) &&
+            node.callee.property.name === "mount" &&
+            isRecord(node.callee.object) &&
+            node.callee.object.type === "CallExpression" &&
+            isRecord(node.callee.object.callee) &&
+            node.callee.object.callee.type === "Identifier" &&
+            node.callee.object.callee.name === "createApp" &&
+            Array.isArray(node.callee.object.arguments) &&
+            node.callee.object.arguments.length >= 1) {
+            const root = node.callee.object.arguments[0];
+            if (root && typeof root.start === "number" && typeof root.end === "number") {
+                found.push({ start: root.start, end: root.end });
+            }
+        }
+        for (const value of Object.values(node)) {
+            if (Array.isArray(value))
+                for (const item of value)
+                    visit(item);
+            else if (value && typeof value === "object")
+                visit(value);
+        }
+    };
+    visit(ast);
+    if (found.length === 0)
+        return undefined;
+    if (found.length > 1)
+        return "multiple";
+    const only = found[0];
+    return only ? { rootStart: only.start, rootEnd: only.end } : undefined;
+}
+function planVanilla(source, rel, specifier) {
+    const parsed = parseSource(source, rel);
+    if (!parsed.ok) {
+        return {
+            kind: "application",
+            status: "invalid",
+            path: rel,
+            candidates: [rel],
+            evidence: [`cannot parse ${rel}: ${parsed.error}`],
+            fixes: [],
+        };
+    }
+    if (/createMoeiconsRuntime|mountIcon/.test(source)) {
+        return {
+            kind: "application",
+            status: "ok",
+            path: rel,
+            candidates: [rel],
+            evidence: ["Vanilla runtime init is present"],
+            fixes: [],
+        };
+    }
+    return {
+        kind: "application",
+        status: "missing",
+        path: rel,
+        candidates: [rel],
+        evidence: ["Vanilla module entry found; runtime init plan generated"],
+        fixes: [
+            {
+                kind: "replace",
+                path: rel,
+                before: source,
+                after: `${source}\nimport { createMoeiconsRuntime } from "${specifier}";\ncreateMoeiconsRuntime();\n`,
+            },
+        ],
+    };
+}
+export function inspectApplicationAnchor(options) {
+    const { io, root, adapter, assetsOnly } = options;
+    if (assetsOnly) {
+        return {
+            kind: "application",
+            status: "not-required",
+            candidates: [],
+            evidence: ["assets-only target requires no application registration"],
+            fixes: [],
+        };
+    }
+    if (!adapter) {
+        return {
+            kind: "application",
+            status: "unsupported",
+            candidates: [],
+            evidence: ["adapter is unknown; no application entry can be located"],
+            fixes: [],
+        };
+    }
+    if (adapter === "next-app" || adapter === "next-pages" || adapter === "nuxt") {
+        return unsupportedManual(adapter);
+    }
+    const candidates = options.confirmedEntry ? [options.confirmedEntry] : ENTRY_CANDIDATES[adapter] ?? [];
+    const located = locateCandidate(io, root, candidates);
+    if ("ambiguous" in located) {
+        const present = candidates.filter((c) => readEntry(io, root, c) !== undefined);
+        const path = present.length === 1 ? join(root, present[0] ?? "") : undefined;
+        return {
+            kind: "application",
+            status: present.length === 0 ? "missing" : "ambiguous",
+            ...(path !== undefined ? { path } : {}),
+            candidates: present.length ? present : candidates,
+            evidence: present.length
+                ? [`multiple entry candidates: ${present.join(", ")}`]
+                : [`no entry candidate found among: ${candidates.join(", ")}`],
+            fixes: [],
+        };
+    }
+    const outputDir = (options.outputDir ?? "src/moeicons").replace(/\\/g, "/").replace(/\/$/, "");
+    const importPath = posix.relative(dirname(located.rel.replace(/\\/g, "/")), outputDir);
+    const specifier = importPath.startsWith(".") ? importPath : `./${importPath}`;
+    if (adapter === "vite-react")
+        return planViteReact(located.source, located.rel, specifier);
+    if (adapter === "vite-vue")
+        return planViteVue(located.source, located.rel, specifier);
+    if (adapter === "vanilla")
+        return planVanilla(located.source, located.rel, specifier);
+    return unsupportedManual(adapter);
+}

package/dist/project/anchors/apply.d.ts

@@ -0,0 +1,28 @@
+import type { PlannedFileChange } from "./types.js";
+/**
+ * Transactional application of PlannedFileChange set (E2E-B5). Writes all
+ * changes atomically and restores originals on any failure. A second identical
+ * apply is a no-op and reports `alreadyConfigured`.
+ */
+export interface ApplyFs {
+    readonly existsSync: (path: string) => boolean;
+    readonly readTextFileSync: (path: string) => string;
+    readonly mkdirSync: (path: string, options?: {
+        recursive?: boolean;
+    }) => void;
+    readonly writeTextFileSync: (path: string, content: string) => void;
+    readonly renameSync: (from: string, to: string) => void;
+    readonly rmSync: (path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }) => void;
+}
+export type ApplyOutcome = {
+    readonly ok: true;
+    readonly alreadyConfigured: boolean;
+    readonly written: readonly string[];
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+export declare function applyPlannedChanges(projectRoot: string, changes: readonly PlannedFileChange[], fs_: ApplyFs): ApplyOutcome;