@mizen-labs/cli 0.0.0-stage → 0.1.0

package/dist/init/theme.js

@@ -0,0 +1,176 @@
+import { documentFunction, imports, isNode, jsxName, literal, literalTrue, nameOf, nodes, parseSource, } from "../doctor/syntax.js";
+import { changes, conflict, position, wrapElement, } from "./edit.js";
+import { bindingName, importEdit, importedName, specifier } from "./imports.js";
+const SELF_CLOSING = /\/\s*>$/u;
+const LINE_LEAD = /^\r?\n[ \t]*/u;
+function single(elements, tag) {
+    const matches = elements.filter((node) => jsxName(node) === tag);
+    if (matches.length !== 1) {
+        return conflict(`Setup requires exactly one ${tag} in the root document.`);
+    }
+    return matches[0];
+}
+function inside(parent, node) {
+    return (position(node, "start") > position(parent, "start") &&
+        position(node, "end") < position(parent, "end"));
+}
+function themeBinding(ast, exported) {
+    const existing = importedName(ast, exported, "@mizen-labs/ui/theme") ??
+        importedName(ast, exported, "@mizen-labs/ui");
+    return {
+        imported: existing !== null,
+        name: existing ?? bindingName(ast, exported),
+    };
+}
+function hydrationChange(html) {
+    const opening = html.openingElement;
+    if (!(isNode(opening) && Array.isArray(opening.attributes))) {
+        return conflict("The html element is not editable.");
+    }
+    if (opening.attributes.some((node) => isNode(node) && node.type === "JSXSpreadAttribute")) {
+        return conflict("Spread html attributes need manual hydration-warning review.");
+    }
+    const attributes = opening.attributes.filter((node) => isNode(node) && nameOf(node.name) === "suppressHydrationWarning");
+    if (attributes.length) {
+        const { value } = attributes[0];
+        if (!hydrationEnabled(value)) {
+            return conflict("Keep an explicit boolean suppressHydrationWarning on html before setup.");
+        }
+        return [];
+    }
+    const at = position(opening, "end") - 1;
+    return [{ end: at, start: at, text: " suppressHydrationWarning" }];
+}
+function providerChanges(source, elements, body, name) {
+    const existing = elements.filter((node) => jsxName(node) === name);
+    if (existing.length) {
+        if (existing.length !== 1 || !inside(body, existing[0])) {
+            return conflict("Existing ThemeProvider placement requires manual review.");
+        }
+        return [];
+    }
+    if (!isNode(body.closingElement)) {
+        return conflict("Self-closing body elements need manual setup.");
+    }
+    const start = position(body.openingElement, "end");
+    const end = position(body.closingElement, "start");
+    if (start === end) {
+        return [{ end, start, text: `<${name}>{null}</${name}>` }];
+    }
+    const inner = source.slice(start, end);
+    if (!inner.includes("\n")) {
+        return [
+            { end: start, start, text: `<${name}>` },
+            { end, start: end, text: `</${name}>` },
+        ];
+    }
+    // Children on their own lines get the provider as a block around them.
+    const first = start + inner.length - inner.trimStart().length;
+    const last = start + inner.trimEnd().length;
+    return [wrapElement(source, first, last, name)];
+}
+// A new head before body: on its own lines when body starts its line.
+function headBefore(source, at, name) {
+    const lineStart = source.lastIndexOf("\n", at - 1) + 1;
+    const indent = source.slice(lineStart, at);
+    if (indent.trim()) {
+        return `<head><${name} /></head>`;
+    }
+    const unit = indent.includes("\t") ? "\t" : "  ";
+    const newline = source.includes("\r\n") ? "\r\n" : "\n";
+    return `<head>${newline}${indent}${unit}<${name} />${newline}${indent}</head>${newline}${indent}`;
+}
+// An existing ThemeScript must be the first child of the only head.
+function existingScript(heads, existing) {
+    if (existing.length !== 1 ||
+        heads.length !== 1 ||
+        !inside(heads[0], existing[0])) {
+        return conflict("Existing ThemeScript placement requires manual review.");
+    }
+    const first = nodes(heads[0])
+        .filter((node) => jsxName(node))
+        .at(1);
+    if (first !== existing[0]) {
+        return conflict("Place ThemeScript first in head before setup.");
+    }
+    return [];
+}
+function scriptChanges(source, elements, html, body, name) {
+    const existing = elements.filter((node) => jsxName(node) === name);
+    const heads = elements.filter((node) => jsxName(node) === "head");
+    if (existing.length) {
+        return existingScript(heads, existing);
+    }
+    if (!heads.length) {
+        if (!inside(html, body)) {
+            return conflict("The root body is not inside html.");
+        }
+        const at = position(body, "start");
+        return [{ end: at, start: at, text: headBefore(source, at, name) }];
+    }
+    const head = single(elements, "head");
+    if (isNode(head.closingElement)) {
+        const at = position(head.openingElement, "end");
+        // Keep the head's own line break and indent before the new child.
+        const lead = LINE_LEAD.exec(source.slice(at))?.[0] ?? "";
+        return [{ end: at, start: at, text: `${lead}<${name} />` }];
+    }
+    const opening = source
+        .slice(position(head, "start"), position(head, "end"))
+        .replace(SELF_CLOSING, ">");
+    return [
+        {
+            end: position(head, "end"),
+            start: position(head, "start"),
+            text: `${opening}<${name} /></head>`,
+        },
+    ];
+}
+export function themeSource(source, framework) {
+    const ast = parseSource(source);
+    const document = documentFunction(ast, framework);
+    if (!document) {
+        return conflict("The root document is delegated or computed. Configure theme setup manually before init.");
+    }
+    const elements = nodes(document).filter((node) => jsxName(node));
+    const html = single(elements, "html");
+    const body = single(elements, "body");
+    const provider = themeBinding(ast, "ThemeProvider");
+    const script = themeBinding(ast, "ThemeScript");
+    assertBindings(ast, document, [provider.name, script.name]);
+    const edits = [
+        ...hydrationChange(html),
+        ...providerChanges(source, elements, body, provider.name),
+        ...scriptChanges(source, elements, html, body, script.name),
+    ];
+    const needed = [provider, script].filter((binding) => !binding.imported);
+    if (needed.length) {
+        const names = [
+            provider.imported ? "" : specifier("ThemeProvider", provider.name),
+            script.imported ? "" : specifier("ThemeScript", script.name),
+        ].filter(Boolean);
+        edits.push(importEdit(ast, `import { ${names.join(", ")} } from "@mizen-labs/ui/theme";`, source));
+    }
+    return changes(source, edits);
+}
+function assertBindings(ast, document, bindings) {
+    const themeImports = imports(ast).filter((node) => ["@mizen-labs/ui", "@mizen-labs/ui/theme"].includes(literal(node.source) ?? ""));
+    const namespaces = themeImports
+        .flatMap((node) => (Array.isArray(node.specifiers) ? node.specifiers : []))
+        .filter((node) => isNode(node) && node.type === "ImportNamespaceSpecifier");
+    if (namespaces.length) {
+        conflict("Namespace Mizen imports require manual theme setup; init will not risk duplicating providers.");
+    }
+    const declared = nodes(document)
+        .flatMap((node) => node.type === "VariableDeclarator" ? nodes(node.id) : nodes(node.params))
+        .map(nameOf);
+    if (bindings.some((name) => declared.includes(name))) {
+        conflict("A theme import is shadowed in the root document. Resolve the binding before setup.");
+    }
+}
+function hydrationEnabled(value) {
+    return (value === null ||
+        (isNode(value) &&
+            value.type === "JSXExpressionContainer" &&
+            literalTrue(value.expression)));
+}

package/dist/init/transaction.js

@@ -0,0 +1,72 @@
+import { randomUUID } from "node:crypto";
+import { lstat, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { conflict, unchanged } from "./edit.js";
+async function stage(project, edit) {
+    const path = join(project, edit.path);
+    await unchanged(path, edit.before);
+    // biome-ignore lint/suspicious/noBitwiseOperators: Preserve the existing POSIX permission bits.
+    const mode = edit.before === null ? 0o644 : (await lstat(path)).mode & 0o777;
+    const staged = `${path}.mizen-${randomUUID()}.tmp`;
+    try {
+        await writeFile(staged, edit.after, { flag: "wx", mode });
+    }
+    catch (error) {
+        await rm(staged, { force: true });
+        throw error;
+    }
+    return staged;
+}
+export async function restoreFiles(project, edits) {
+    for (const edit of edits.toReversed()) {
+        // biome-ignore lint/performance/noAwaitInLoops: Rollback preserves commit order and refuses concurrent changes.
+        await restoreFile(project, edit);
+    }
+}
+async function restoreFile(project, edit) {
+    const path = join(project, edit.path);
+    const current = await readFile(path, "utf8");
+    if (current === edit.before) {
+        return;
+    }
+    if (current !== edit.after) {
+        return conflict(`Concurrent changes prevent rollback of ${edit.path}. Use the init journal for manual recovery.`);
+    }
+    if (edit.before === null) {
+        await rm(path);
+        return;
+    }
+    const temporary = await stage(project, {
+        ...edit,
+        after: edit.before,
+        before: edit.after,
+    });
+    await rename(temporary, path);
+}
+export async function applyFiles(project, edits, replace = rename) {
+    const staged = new Map();
+    const committed = [];
+    try {
+        for (const edit of edits) {
+            // biome-ignore lint/performance/noAwaitInLoops: Stage sequentially so every temporary file is tracked for cleanup on failure.
+            staged.set(edit, await stage(project, edit));
+        }
+        for (const edit of edits) {
+            // biome-ignore lint/performance/noAwaitInLoops: Revalidate immediately before each ordered atomic replacement.
+            await unchanged(join(project, edit.path), edit.before);
+            const temporary = staged.get(edit);
+            if (!temporary) {
+                return conflict("A staged file is missing; inspect the init journal.");
+            }
+            await replace(temporary, join(project, edit.path));
+            committed.push(edit);
+        }
+    }
+    catch (error) {
+        await restoreFiles(project, committed);
+        throw error;
+    }
+    finally {
+        await Promise.all([...staged.values()].map((path) => rm(path, { force: true })));
+    }
+}

package/dist/output.js

@@ -0,0 +1,78 @@
+// Shared terminal output: semantic styles, the status gutter, aligned rows,
+// and counts. Commands format through these so every screen reads alike.
+const LABEL_WIDTH = 16;
+const GUTTER = "  ";
+const plain = (text) => text;
+function sgr(open, close) {
+    return (text) => `\u001b[${open}m${text}\u001b[${close}m`;
+}
+// --no-color and NO_COLOR win, then FORCE_COLOR, then the stream itself:
+// color only on a terminal whose TERM is not dumb.
+function colorOn(stream) {
+    if (process.env.NO_COLOR) {
+        return false;
+    }
+    const forced = process.env.FORCE_COLOR;
+    if (forced !== undefined) {
+        return forced !== "0";
+    }
+    return Boolean(stream.isTTY) && process.env.TERM !== "dumb";
+}
+/** No styling, for JSON and pipes. */
+export const unstyled = {
+    bold: plain,
+    command: plain,
+    fail: plain,
+    heading: plain,
+    pass: plain,
+    warn: plain,
+};
+/** Styles for one stream; each stream decides for itself. */
+export function styleFor(stream) {
+    if (!colorOn(stream)) {
+        return unstyled;
+    }
+    const bold = sgr(1, 22);
+    const magenta = sgr(35, 39);
+    return {
+        bold,
+        command: sgr(36, 39),
+        fail: sgr(31, 39),
+        heading: (text) => bold(magenta(text)),
+        pass: sgr(32, 39),
+        warn: sgr(33, 39),
+    };
+}
+export const glyphs = { fail: "✗", pass: "✓", warn: "!" };
+/** A status line: the glyph in column 0, the text from column 2. */
+export function status(style, kind, text) {
+    return `${style[kind](glyphs[kind])} ${text}`;
+}
+/**
+ * A label and value in the shared columns: label from column 2, value from
+ * column 18. A long label puts its value on the next line; each further
+ * line of the value aligns under the first.
+ */
+export function row(label, value) {
+    const lines = typeof value === "string" ? value.split("\n") : [...value];
+    const pad = " ".repeat(GUTTER.length + LABEL_WIDTH);
+    const head = label.length < LABEL_WIDTH
+        ? `${GUTTER}${label.padEnd(LABEL_WIDTH)}${lines[0] ?? ""}`
+        : `${GUTTER}${label}\n${pad}${lines[0] ?? ""}`;
+    return [head, ...lines.slice(1).map((line) => `${pad}${line}`)].join("\n");
+}
+/** A next step: what it gets you, then the command on its own line. */
+export function nextStep(style, benefit, command) {
+    return `${GUTTER}${benefit}:\n${GUTTER}${GUTTER}${style.command(command)}`;
+}
+export function plural(count, one, many = `${one}s`) {
+    return `${count.toLocaleString("en-US")} ${count === 1 ? one : many}`;
+}
+/** Indents every line of a block by the gutter. */
+export function indent(text, depth = 1) {
+    const prefix = GUTTER.repeat(depth);
+    return text
+        .split("\n")
+        .map((line) => (line ? `${prefix}${line}` : line))
+        .join("\n");
+}

package/dist/vite/bootstrap.js

@@ -0,0 +1,43 @@
+import { isNode, jsxName, nodes } from "../doctor/syntax.js";
+import { conflict, position } from "../init/edit.js";
+import { bindingName, importEdit, importedName, specifier, } from "../init/imports.js";
+import { bootstrapBefore, bootstrapCalls, providerNames, renderCall, } from "./render.js";
+export function bootstrapEdits(source, ast, tree) {
+    if (bootstrapBefore(ast)) {
+        return [];
+    }
+    if (bootstrapCalls(ast).length) {
+        return conflict("Call initializeTheme once before createRoot; review existing bootstrap order before init.");
+    }
+    ensureDefaultProvider(ast, tree);
+    const existing = [
+        "@mizen-labs/ui/theme/initialize",
+        "@mizen-labs/ui/theme",
+        "@mizen-labs/ui",
+    ]
+        .map((sourcePath) => importedName(ast, "initializeTheme", sourcePath))
+        .find((binding) => binding !== null);
+    const name = existing ?? bindingName(ast, "initializeTheme");
+    const call = renderCall(ast);
+    if (!call) {
+        return conflict("No conventional root render call was found.");
+    }
+    const at = position(call, "start");
+    const newline = source.includes("\r\n") ? "\r\n" : "\n";
+    const edits = [
+        { end: at, start: at, text: `${name}();${newline}` },
+    ];
+    if (!existing) {
+        edits.push(importEdit(ast, `import { ${specifier("initializeTheme", name)} } from "@mizen-labs/ui/theme/initialize";`, source));
+    }
+    return edits;
+}
+function ensureDefaultProvider(ast, tree) {
+    const provider = nodes(tree).find((node) => providerNames(ast).includes(jsxName(node) ?? ""));
+    if (provider &&
+        isNode(provider.openingElement) &&
+        Array.isArray(provider.openingElement.attributes) &&
+        provider.openingElement.attributes.length) {
+        conflict("Initialize the theme with options matching your custom ThemeProvider before init.");
+    }
+}

package/dist/vite/doctor.js

@@ -0,0 +1,50 @@
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { check } from "../doctor/report.js";
+import { imports, literal, parseSource } from "../doctor/syntax.js";
+import { viteEntry } from "./entry.js";
+import { bootstrapBefore, providerCovers, renderArgument } from "./render.js";
+export async function viteSetupChecks(project) {
+    const entry = await viteEntry(project);
+    if (!entry) {
+        return [
+            check("setup.root", "unverified", "index.html does not select one supported src/main entry.", [join(project, "index.html")], "Use a single module entry at src/main.tsx or src/main.jsx, or review custom Vite entry wiring manually."),
+        ];
+    }
+    const path = join(project, entry.path);
+    try {
+        const ast = parseSource(entry.source);
+        const css = imports(ast).some((node) => literal(node.source) === "@mizen-labs/ui/styles.css" &&
+            Array.isArray(node.specifiers) &&
+            node.specifiers.length === 0);
+        const tree = renderArgument(ast);
+        const provider = tree !== null && providerCovers(ast, tree);
+        return [
+            bootstrapCheck(project, ast, path),
+            check("setup.bundling", "pass", "Client Vite bundles package CSS imports; no SSR bundling setting is required.", [path]),
+            check("setup.stylesheet", css ? "pass" : "unverified", css
+                ? "The client entry imports Mizen's compiled stylesheet."
+                : "No direct Mizen stylesheet import was verified in the client entry.", [path], "Import @mizen-labs/ui/styles.css in the module loaded by index.html."),
+            check("setup.theme", provider ? "pass" : "unverified", provider
+                ? "ThemeProvider covers the mounted client tree. No SSR ThemeScript is needed for this client-only entry."
+                : "A ThemeProvider covering createRoot(...).render(...) was not verified.", [path], "Wrap the mounted React tree in ThemeProvider from @mizen-labs/ui/theme; keep existing StrictMode and app providers."),
+        ];
+    }
+    catch {
+        return [
+            check("setup.root", "unverified", "The Vite client entry could not be parsed; it was not executed.", [path], "Check entry syntax and review custom mounting code manually."),
+        ];
+    }
+}
+function bootstrapCheck(project, ast, path) {
+    if (!bootstrapBefore(ast)) {
+        return check("setup.bootstrap", "unverified", "A synchronous initializeTheme call before React mounting was not verified.", [path], "Call initializeTheme from @mizen-labs/ui/theme/initialize before createRoot, using options matching ThemeProvider.");
+    }
+    try {
+        createRequire(join(project, "package.json")).resolve("@mizen-labs/ui/theme/initialize");
+    }
+    catch {
+        return check("package.bootstrap", "error", "This installed UI build does not expose client theme initialization.", [join(project, "package.json")], "Rebuild and install a matching Mizen UI archive before initializing the app.");
+    }
+    return check("setup.bootstrap", "pass", "Theme initialization is declared before the client render call.", [path]);
+}

package/dist/vite/entry.js

@@ -0,0 +1,46 @@
+import { join } from "node:path";
+import { parse } from "parse5";
+import { readOptional } from "../doctor/files.js";
+const ENTRIES = new Set([
+    "src/main.tsx",
+    "src/main.jsx",
+    "src/main.ts",
+    "src/main.js",
+]);
+const DOT_PREFIX = /^\.\//u;
+function htmlNodes(node) {
+    return [
+        node,
+        ...("childNodes" in node ? node.childNodes.flatMap(htmlNodes) : []),
+    ];
+}
+function attribute(node, name) {
+    return "attrs" in node
+        ? node.attrs.find((item) => item.name === name)?.value
+        : undefined;
+}
+function htmlEntry(source) {
+    const document = htmlNodes(parse(source));
+    if (document.some((node) => node.nodeName === "base")) {
+        return null;
+    }
+    const scripts = document.filter((node) => node.nodeName === "script" && attribute(node, "type") === "module");
+    if (scripts.length !== 1) {
+        return null;
+    }
+    const src = attribute(scripts[0], "src");
+    if (!src) {
+        return null;
+    }
+    const path = src.startsWith("/") ? src.slice(1) : src.replace(DOT_PREFIX, "");
+    return ENTRIES.has(path) ? path : null;
+}
+export async function viteEntry(project) {
+    const html = await readOptional(join(project, "index.html"));
+    const path = html === null ? null : htmlEntry(html);
+    if (!path) {
+        return null;
+    }
+    const source = await readOptional(join(project, path));
+    return source === null ? null : { html, path, source };
+}

package/dist/vite/init.js

@@ -0,0 +1,66 @@
+import { lstat } from "node:fs/promises";
+import { join } from "node:path";
+import { imports, isNode, literal, parseSource } from "../doctor/syntax.js";
+import { changes, conflict, fileEdit, position, sourceFile, wrapElement, } from "../init/edit.js";
+import { bindingName, importEdit, importedName, specifier, } from "../init/imports.js";
+import { bootstrapEdits } from "./bootstrap.js";
+import { viteEntry } from "./entry.js";
+import { hasProvider, providerCovers, renderArgument } from "./render.js";
+export async function viteRootEdit(project) {
+    const entry = await viteEntry(project);
+    if (!entry) {
+        return conflict("index.html must load one conventional src/main.tsx or src/main.jsx module before init.");
+    }
+    const htmlStat = await lstat(join(project, "index.html"));
+    if (!htmlStat.isFile()) {
+        return conflict("Review the linked or custom Vite index.html before setup.");
+    }
+    const file = await sourceFile(project, [entry.path]);
+    return fileEdit(file.path, file.before, clientTheme(file.source));
+}
+function clientTheme(source) {
+    const ast = parseSource(source);
+    const tree = renderArgument(ast);
+    if (!tree) {
+        return conflict("Use a conventional top-level createRoot(...).render(<App />) entry, or configure Mizen manually.");
+    }
+    const namespace = imports(ast)
+        .filter((node) => [
+        "@mizen-labs/ui/theme",
+        "@mizen-labs/ui",
+        "@mizen-labs/ui/theme/initialize",
+    ].includes(literal(node.source) ?? ""))
+        .flatMap((node) => (Array.isArray(node.specifiers) ? node.specifiers : []))
+        .some((node) => isNode(node) && node.type === "ImportNamespaceSpecifier");
+    if (namespace) {
+        return conflict("Namespace Mizen imports require manual provider review.");
+    }
+    const provider = importedName(ast, "ThemeProvider", "@mizen-labs/ui/theme") ??
+        importedName(ast, "ThemeProvider", "@mizen-labs/ui");
+    if (hasProvider(ast, tree) && !providerCovers(ast, tree)) {
+        return conflict("An existing provider covers only part of the render tree. Review it before init.");
+    }
+    const edits = [];
+    const covered = providerCovers(ast, tree);
+    if (!covered) {
+        const name = provider ?? bindingName(ast, "ThemeProvider");
+        const start = position(tree, "start");
+        const end = position(tree, "end");
+        edits.push(wrapElement(source, start, end, name));
+        if (!provider) {
+            edits.push(importEdit(ast, `import { ${specifier("ThemeProvider", name)} } from "@mizen-labs/ui/theme";`, source));
+        }
+    }
+    edits.push(...bootstrapEdits(source, ast, tree));
+    const themed = changes(source, edits);
+    const result = parseSource(themed);
+    const css = imports(result).some((node) => literal(node.source) === "@mizen-labs/ui/styles.css" &&
+        Array.isArray(node.specifiers) &&
+        node.specifiers.length === 0);
+    const after = css
+        ? themed
+        : changes(themed, [
+            importEdit(result, 'import "@mizen-labs/ui/styles.css";', themed, "first"),
+        ]);
+    return after;
+}

package/dist/vite/render.js

@@ -0,0 +1,144 @@
+import { imports, isNode, jsxName, literal, nameOf, nodes, } from "../doctor/syntax.js";
+function bindings(ast, source, exported) {
+    return imports(ast)
+        .filter((node) => literal(node.source) === source)
+        .flatMap((node) => (Array.isArray(node.specifiers) ? node.specifiers : []))
+        .filter((node) => isNode(node) &&
+        node.importKind !== "type" &&
+        nameOf(node.imported) === exported)
+        .map((node) => (isNode(node) ? nameOf(node.local) : null))
+        .filter((name) => name !== null);
+}
+function namespaces(ast, source) {
+    return imports(ast)
+        .filter((node) => literal(node.source) === source)
+        .flatMap((node) => (Array.isArray(node.specifiers) ? node.specifiers : []))
+        .filter((node) => isNode(node) &&
+        ["ImportDefaultSpecifier", "ImportNamespaceSpecifier"].includes(node.type))
+        .map((node) => (isNode(node) ? nameOf(node.local) : null))
+        .filter((name) => name !== null);
+}
+function callsCreateRoot(ast, value) {
+    if (!isNode(value) || value.type !== "CallExpression") {
+        return false;
+    }
+    const { callee } = value;
+    if (bindings(ast, "react-dom/client", "createRoot").includes(nameOf(callee) ?? "")) {
+        return true;
+    }
+    if (!isNode(callee) ||
+        callee.type !== "MemberExpression" ||
+        callee.computed) {
+        return false;
+    }
+    return (nameOf(callee.property) === "createRoot" &&
+        namespaces(ast, "react-dom/client").includes(nameOf(callee.object) ?? ""));
+}
+export function renderCall(ast) {
+    if (!(isNode(ast.program) && Array.isArray(ast.program.body))) {
+        return null;
+    }
+    const statements = ast.program.body.filter((node) => isNode(node) && node.type === "ExpressionStatement");
+    const renders = statements
+        .map((node) => node.expression)
+        .filter((node) => {
+        if (!isNode(node) ||
+            node.type !== "CallExpression" ||
+            !isNode(node.callee)) {
+            return false;
+        }
+        const { callee } = node;
+        return (callee.type === "MemberExpression" &&
+            !callee.computed &&
+            nameOf(callee.property) === "render" &&
+            callsCreateRoot(ast, callee.object));
+    });
+    if (renders.length !== 1 ||
+        !Array.isArray(renders[0].arguments) ||
+        renders[0].arguments.length !== 1) {
+        return null;
+    }
+    return renders[0];
+}
+export function renderArgument(ast) {
+    const call = renderCall(ast);
+    if (!(call && Array.isArray(call.arguments))) {
+        return null;
+    }
+    const [tree] = call.arguments;
+    return isNode(tree) && ["JSXElement", "JSXFragment"].includes(tree.type)
+        ? tree
+        : null;
+}
+export function providerNames(ast) {
+    return ["@mizen-labs/ui/theme", "@mizen-labs/ui"].flatMap((source) => bindings(ast, source, "ThemeProvider"));
+}
+function transparentWrapper(ast, tree) {
+    if (tree.type === "JSXFragment") {
+        return true;
+    }
+    if (bindings(ast, "react", "StrictMode").includes(jsxName(tree) ?? "")) {
+        return true;
+    }
+    if (!(isNode(tree.openingElement) && isNode(tree.openingElement.name))) {
+        return false;
+    }
+    const { name } = tree.openingElement;
+    return (name.type === "JSXMemberExpression" &&
+        ["StrictMode", "Fragment"].includes(nameOf(name.property) ?? "") &&
+        namespaces(ast, "react").includes(nameOf(name.object) ?? ""));
+}
+export function providerCovers(ast, tree) {
+    if (providerNames(ast).includes(jsxName(tree) ?? "")) {
+        return true;
+    }
+    if (!(transparentWrapper(ast, tree) && Array.isArray(tree.children))) {
+        return false;
+    }
+    const children = tree.children.filter((node) => {
+        if (!isNode(node)) {
+            return false;
+        }
+        if (node.type === "JSXText") {
+            return String(node.value).trim().length > 0;
+        }
+        return !(node.type === "JSXExpressionContainer" &&
+            isNode(node.expression) &&
+            node.expression.type === "JSXEmptyExpression");
+    });
+    return (children.length === 1 &&
+        isNode(children[0]) &&
+        providerCovers(ast, children[0]));
+}
+export function hasProvider(ast, tree) {
+    return nodes(tree).some((node) => providerNames(ast).includes(jsxName(node) ?? ""));
+}
+export function bootstrapCalls(ast) {
+    if (!(isNode(ast.program) && Array.isArray(ast.program.body))) {
+        return [];
+    }
+    const names = [
+        "@mizen-labs/ui/theme/initialize",
+        "@mizen-labs/ui/theme",
+        "@mizen-labs/ui",
+    ].flatMap((source) => bindings(ast, source, "initializeTheme"));
+    return ast.program.body
+        .filter((node) => isNode(node) && node.type === "ExpressionStatement")
+        .map((node) => node.expression)
+        .filter((node) => isNode(node) &&
+        node.type === "CallExpression" &&
+        names.includes(nameOf(node.callee) ?? ""));
+}
+export function bootstrapBefore(ast) {
+    const render = renderCall(ast);
+    const calls = bootstrapCalls(ast);
+    return (render !== null &&
+        calls.length === 1 &&
+        typeof render.start === "number" &&
+        typeof calls[0].start === "number" &&
+        calls[0].start < render.start);
+}
+export function supportsInitialization(manifest) {
+    const map = manifest?.exports;
+    return !!map && typeof map === "object" && "./theme/initialize" in map;
+}