vitral 0.3.0 → 0.4.0

package/dist/cli.js

@@ -1,8 +1,63 @@
 #!/usr/bin/env node
 
+// src/cli.ts
+import { createRequire } from "module";
+
+// src/cli/canal.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname } from "path";
+function editChannel(current, edit) {
+  const stable = edit.stable ?? current?.stable;
+  if (!stable) throw new Error("[vitral] o canal ainda n\xE3o existe: use --stable");
+  const { canary: old, ...rest } = current ?? {};
+  const out = { ...rest, stable };
+  if (edit.percent !== void 0 && !(edit.percent >= 0 && edit.percent <= 100)) throw new Error("[vitral] --percent vai de 0 a 100");
+  if (edit.canary === "off") {
+    if (edit.percent !== void 0) throw new Error("[vitral] --percent n\xE3o vale com --canary off");
+    return out;
+  }
+  const version2 = edit.canary ?? old?.version;
+  const percent = edit.percent ?? old?.percent;
+  if (version2 === void 0) {
+    if (edit.percent !== void 0) throw new Error("[vitral] o canal n\xE3o tem canary: use --canary");
+    return out;
+  }
+  if (percent === void 0) throw new Error("[vitral] canary nova precisa de --percent");
+  out.canary = { version: version2, percent };
+  return out;
+}
+function canal(o) {
+  const current = existsSync(o.file) ? JSON.parse(readFileSync(o.file, "utf8")) : void 0;
+  const changes = o.stable !== void 0 || o.canary !== void 0 || o.percent !== void 0;
+  if (!changes && !current) throw new Error(`[vitral] ${o.file} n\xE3o existe: use --stable para criar`);
+  const next = changes ? editChannel(current, o) : current;
+  const text2 = JSON.stringify(next, null, 2) + "\n";
+  if (changes) {
+    mkdirSync(dirname(o.file), { recursive: true });
+    writeFileSync(o.file, text2);
+  }
+  ;
+  (o.log ?? console.log)(text2.trimEnd());
+  return next;
+}
+
+// src/cli/mcp.ts
+import { createInterface } from "readline";
+
+// src/cli/registry.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve2 } from "path";
+
 // src/cli/types.ts
-import { existsSync, readFileSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { resolve } from "path";
+function flag(args2, name) {
+  const i = args2.indexOf(name);
+  if (i < 0) return void 0;
+  const value = args2[i + 1];
+  args2.splice(i, 2);
+  return value;
+}
 var PROPS = /export type Props =\s*([\s\S]*?)\s*$/;
 function parseProps(dts) {
   return PROPS.exec(dts.replace(/^\s*\/\/.*$/gm, "").trim())?.[1]?.replace(/;$/, "") || null;
@@ -25,9 +80,9 @@ ${lines.join("\n")}
 function readHashes(env) {
   return Object.fromEntries([...env.matchAll(HASH)].map((m) => [JSON.parse(m[1]), m[2]]));
 }
-async function manifestHash(get, url) {
+async function manifestHash(get2, url) {
   try {
-    const res = await get(url);
+    const res = await get2(url);
     if (!res.ok) return void 0;
     const { integrity } = await res.json();
     return typeof integrity === "string" ? integrity : void 0;
@@ -35,15 +90,15 @@ async function manifestHash(get, url) {
     return void 0;
   }
 }
-async function check(remotes, out, get, log) {
-  if (!existsSync(out)) {
+async function check(remotes, out, get2, log) {
+  if (!existsSync2(out)) {
     log(`[vitral] ${out} n\xE3o existe. Rode \`npx vitral types\`.`);
     return 1;
   }
-  const recorded = readHashes(readFileSync(out, "utf8"));
+  const recorded = readHashes(readFileSync2(out, "utf8"));
   let stale = 0;
   for (const [name, url] of Object.entries(remotes)) {
-    const hash = await manifestHash(get, url);
+    const hash = await manifestHash(get2, url);
     if (!hash) log(`[vitral] ${name}: manifesto sem hash, n\xE3o deu para conferir.`);
     else if (recorded[name] !== hash) {
       log(`[vitral] ${name}: tipos desatualizados (${recorded[name] ? "o manifesto mudou" : "sem hash registrado"}).`);
@@ -59,33 +114,38 @@ async function check(remotes, out, get, log) {
   log(stale ? `[vitral] ${stale} remote(s) com tipos desatualizados. Rode \`npx vitral types\`.` : `[vitral] tipos em dia com os manifestos.`);
   return stale;
 }
-function readRemotes(cwd, args2, base) {
-  const pairs = args2.filter((a) => a.includes("="));
-  if (pairs.length) return Object.fromEntries(pairs.map((p) => [p.slice(0, p.indexOf("=")), p.slice(p.indexOf("=") + 1)]));
-  const file = [args2[0], "public/remotes.json", "remotes.json"].find((f) => f && existsSync(resolve(cwd, f)));
+function readEntries(cwd, args2, base) {
+  const pairs2 = args2.filter((a) => a.includes("="));
+  if (pairs2.length) return Object.fromEntries(pairs2.map((p) => [p.slice(0, p.indexOf("=")), { url: p.slice(p.indexOf("=") + 1) }]));
+  const file = [args2[0], "public/remotes.json", "remotes.json"].find((f) => f && existsSync2(resolve(cwd, f)));
   if (!file) throw new Error("[vitral] remotes.json n\xE3o encontrado. Passe o caminho ou pares nome=url.");
-  const map = JSON.parse(readFileSync(resolve(cwd, file), "utf8"));
-  return Object.fromEntries(
-    Object.entries(map).map(([name, v]) => {
-      const url = typeof v === "string" ? v : v.url;
-      return [name, base ? new URL(url, base).href : url];
-    })
-  );
+  return entriesOf(JSON.parse(readFileSync2(resolve(cwd, file), "utf8")), base);
+}
+function entriesOf(map, base) {
+  const out = {};
+  for (const [name, v] of Object.entries(map)) {
+    const entry = typeof v === "string" ? { url: v } : v;
+    if (typeof entry?.url === "string") out[name] = { ...entry, url: base ? new URL(entry.url, base).href : entry.url };
+  }
+  return out;
+}
+function readRemotes(cwd, args2, base) {
+  return Object.fromEntries(Object.entries(readEntries(cwd, args2, base)).map(([name, e]) => [name, e.url]));
 }
 async function types(options = {}) {
   const cwd = options.cwd ?? process.cwd();
-  const get = options.fetch ?? fetch;
+  const get2 = options.fetch ?? fetch;
   const log = options.log ?? console.log;
   const remotes = readRemotes(cwd, options.args ?? [], options.base);
   const out = resolve(cwd, options.out ?? "vitral-env.d.ts");
-  if (options.check) return check(remotes, out, get, log);
+  if (options.check) return check(remotes, out, get2, log);
   const props = {};
   const hashes = {};
   let falhas = 0;
   for (const [name, url] of Object.entries(remotes)) {
     let dts;
     try {
-      const res = await get(new URL("vitral.d.ts", url).href);
+      const res = await get2(new URL("vitral.d.ts", url).href);
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
       dts = await res.text();
     } catch (err) {
@@ -99,39 +159,1094 @@ async function types(options = {}) {
       continue;
     }
     props[name] = type;
-    const hash = await manifestHash(get, url);
+    const hash = await manifestHash(get2, url);
     if (hash) hashes[name] = hash;
   }
-  writeFileSync(out, envFile(props, hashes));
+  writeFileSync2(out, envFile(props, hashes));
   log(`[vitral] ${Object.keys(props).length} remote(s) em ${out}`);
   return falhas;
 }
 
+// src/cli/registry.ts
+var REGISTRY_SCHEMA = "https://joaogabriel15.github.io/vitral/schema/vitral-registry.json";
+var ITEM_FIELDS = ["name", "url", "version", "props", "owner", "integrity", "framework", "description"];
+var NAME = /^[^/\s]+$/;
+function checkRegistry(data) {
+  const errors = [];
+  const reg = data;
+  if (!reg || typeof reg !== "object" || !Array.isArray(reg.remotes)) return ['falta a lista "remotes"'];
+  for (const key of Object.keys(reg)) if (!["$schema", "name", "remotes"].includes(key)) errors.push(`campo desconhecido "${key}"`);
+  const seen = /* @__PURE__ */ new Set();
+  reg.remotes.forEach((item, i) => {
+    const at = `remotes[${i}]`;
+    if (!item || typeof item !== "object") return errors.push(`${at}: n\xE3o \xE9 um objeto`);
+    if (typeof item.name !== "string" || !NAME.test(item.name)) errors.push(`${at}: "name" inv\xE1lido`);
+    else if (seen.has(item.name)) errors.push(`${at}: "${item.name}" repetido`);
+    else seen.add(item.name);
+    if (typeof item.url !== "string" || !item.url) errors.push(`${at}: falta "url"`);
+    for (const key of Object.keys(item)) {
+      if (!ITEM_FIELDS.includes(key)) errors.push(`${at}: campo desconhecido "${key}"`);
+      else if (typeof item[key] !== "string") errors.push(`${at}: "${key}" deve ser texto`);
+    }
+  });
+  return errors;
+}
+var isUrl = (s) => /^https?:\/\//.test(s);
+async function loadRegistry(source, cwd = process.cwd(), get2 = fetch) {
+  let data;
+  if (isUrl(source)) {
+    const res = await get2(source);
+    if (!res.ok) throw new Error(`[vitral] registro ${source}: HTTP ${res.status}`);
+    data = await res.json();
+  } else {
+    const file = resolve2(cwd, source);
+    if (!existsSync3(file)) throw new Error(`[vitral] registro ${source} n\xE3o encontrado.`);
+    data = JSON.parse(readFileSync3(file, "utf8"));
+  }
+  const errors = checkRegistry(data);
+  if (errors.length) throw new Error(`[vitral] registro ${source} inv\xE1lido:
+  ${errors.join("\n  ")}`);
+  const reg = data;
+  if (isUrl(source)) for (const item of reg.remotes) item.url = new URL(item.url, source).href;
+  return reg;
+}
+var defaultRegistry = () => process.env.VITRAL_REGISTRY || "vitral-registry.json";
+async function registry(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const get2 = options.fetch ?? fetch;
+  const log = options.log ?? console.log;
+  const out = resolve2(cwd, options.out ?? "vitral-registry.json");
+  const before = existsSync3(out) ? JSON.parse(readFileSync3(out, "utf8")) : void 0;
+  const old = new Map((before?.remotes ?? []).map((item) => [item.name, item]));
+  const remotes = [];
+  let falhas = 0;
+  for (const [name, url] of Object.entries(readRemotes(cwd, options.args ?? [], options.base))) {
+    let manifest;
+    try {
+      const res = await get2(url);
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      manifest = await res.json();
+    } catch (err) {
+      log(`[vitral] ${name}: manifesto indispon\xEDvel (${err.message}).`);
+      falhas++;
+      continue;
+    }
+    let props = null;
+    try {
+      const res = await get2(new URL("vitral.d.ts", url).href);
+      if (res.ok) props = parseProps(await res.text());
+    } catch {
+    }
+    const { owner, framework, description } = old.get(name) ?? {};
+    remotes.push(
+      clean({
+        name,
+        url,
+        version: typeof manifest.version === "string" ? manifest.version : void 0,
+        props: props ?? void 0,
+        owner,
+        integrity: typeof manifest.integrity === "string" ? manifest.integrity : void 0,
+        framework,
+        description
+      })
+    );
+  }
+  const result = { $schema: REGISTRY_SCHEMA, ...(options.name ?? before?.name) && { name: options.name ?? before?.name }, remotes };
+  writeFileSync3(out, JSON.stringify(result, null, 2) + "\n");
+  log(`[vitral] ${remotes.length} remote(s) em ${out}`);
+  return falhas;
+}
+var clean = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
+function remotesFile(cwd, to) {
+  if (to) return resolve2(cwd, to);
+  const found = ["public/remotes.json", "remotes.json"].find((f) => existsSync3(resolve2(cwd, f)));
+  return resolve2(cwd, found ?? (existsSync3(resolve2(cwd, "public")) ? "public/remotes.json" : "remotes.json"));
+}
+async function add(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const get2 = options.fetch ?? fetch;
+  const log = options.log ?? console.log;
+  if (!options.names.length) throw new Error("[vitral] informe o nome do remote: npx vitral add <remote>");
+  const reg = await loadRegistry(options.registry ?? defaultRegistry(), cwd, get2);
+  const file = remotesFile(cwd, options.to);
+  const map = existsSync3(file) ? JSON.parse(readFileSync3(file, "utf8")) : {};
+  let falhas = 0;
+  let added = 0;
+  for (const name of options.names) {
+    const item = reg.remotes.find((r) => r.name === name);
+    if (!item) {
+      log(`[vitral] ${name}: n\xE3o est\xE1 no registro. Dispon\xEDveis: ${reg.remotes.map((r) => r.name).join(", ") || "nenhum"}.`);
+      falhas++;
+      continue;
+    }
+    const current = map[name];
+    const currentUrl = typeof current === "string" ? current : current?.url;
+    if (currentUrl && currentUrl !== item.url && !options.force) {
+      log(`[vitral] ${name}: j\xE1 est\xE1 no remotes.json com ${currentUrl}. Use --force para trocar.`);
+      falhas++;
+      continue;
+    }
+    if (item.integrity) {
+      const hash = await manifestHash(get2, options.base ? new URL(item.url, options.base).href : item.url);
+      if (hash && hash !== item.integrity) log(`[vitral] ${name}: o manifesto publicado mudou desde que o registro foi gerado.`);
+    }
+    map[name] = current && typeof current === "object" ? { ...current, url: item.url } : item.url;
+    added++;
+    log(`[vitral] ${name}${item.version ? `@${item.version}` : ""} adicionado em ${file}`);
+  }
+  if (added) {
+    writeFileSync3(file, JSON.stringify(map, null, 2) + "\n");
+    if (options.types !== false) falhas += await types({ cwd, args: [file], base: options.base, out: options.out, fetch: get2, log });
+  }
+  return falhas;
+}
+
+// src/cli/mcp.ts
+var PROTOCOL = "2025-06-18";
+var registryArg = { registry: { type: "string", description: "URL ou arquivo do vitral-registry.json. Padr\xE3o: o do servidor." } };
+var TOOLS = [
+  {
+    name: "list_remotes",
+    description: "Lista os remotes (micro-frontends) do registro vitral: nome, vers\xE3o, dono, framework e descri\xE7\xE3o.",
+    inputSchema: {
+      type: "object",
+      properties: { ...registryArg, query: { type: "string", description: "Filtra por trecho do nome, dono, framework ou descri\xE7\xE3o." } }
+    }
+  },
+  {
+    name: "get_remote",
+    description: "Mostra um remote do registro: URL do manifesto, vers\xE3o, hash e o tipo TypeScript das props, com um exemplo de uso no host.",
+    inputSchema: { type: "object", properties: { ...registryArg, name: { type: "string", description: "Nome do remote." } }, required: ["name"] }
+  },
+  {
+    name: "add_remote",
+    description: "Adiciona um remote do registro ao remotes.json do host e gera os tipos das props (vitral-env.d.ts), como `npx vitral add`.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        ...registryArg,
+        name: { type: "string", description: "Nome do remote." },
+        force: { type: "boolean", description: "Troca a URL se o remote j\xE1 est\xE1 no remotes.json com outra." }
+      },
+      required: ["name"]
+    }
+  }
+];
+var text = (value, isError = false) => ({
+  content: [{ type: "text", text: typeof value === "string" ? value : JSON.stringify(value, null, 2) }],
+  ...isError && { isError: true }
+});
+function usage(item) {
+  return [
+    `import { Remote } from 'vitral/react'`,
+    `<Remote name=${JSON.stringify(item.name)} props={props} />`,
+    "",
+    `// ou, sem framework:`,
+    `import { mountRemote } from 'vitral'`,
+    `await mountRemote(elemento, ${JSON.stringify(item.name)}, props)`,
+    "",
+    `// props: ${item.props ?? "sem tipo publicado (o remote n\xE3o publica vitral.d.ts)"}`
+  ].join("\n");
+}
+function mcpServer(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const get2 = options.fetch ?? fetch;
+  const source = (args2) => typeof args2.registry === "string" && args2.registry || options.registry || defaultRegistry();
+  async function call(name, args2) {
+    const reg = await loadRegistry(source(args2), cwd, get2);
+    if (name === "list_remotes") {
+      const q = typeof args2.query === "string" ? args2.query.toLowerCase() : "";
+      const items = reg.remotes.filter((r) => !q || [r.name, r.owner, r.framework, r.description].some((v) => v?.toLowerCase().includes(q))).map(({ name: name2, version: version2, owner, framework, description }) => ({ name: name2, version: version2, owner, framework, description }));
+      return text(items);
+    }
+    const item = reg.remotes.find((r) => r.name === args2.name);
+    if (!item) return text(`"${args2.name}" n\xE3o est\xE1 no registro. Dispon\xEDveis: ${reg.remotes.map((r) => r.name).join(", ") || "nenhum"}.`, true);
+    if (name === "get_remote") return text(`${JSON.stringify(item, null, 2)}
+
+Uso:
+${usage(item)}`);
+    const logs = [];
+    const falhas = await add({ cwd, names: [item.name], registry: source(args2), force: args2.force === true, fetch: get2, log: (m) => logs.push(m) });
+    return text(logs.join("\n"), falhas > 0);
+  }
+  return {
+    async handle(msg) {
+      const { id, method, params = {} } = msg;
+      if (id === void 0) return void 0;
+      const ok2 = (result) => ({ jsonrpc: "2.0", id, result });
+      const fail = (code, message) => ({ jsonrpc: "2.0", id, error: { code, message } });
+      switch (method) {
+        case "initialize":
+          return ok2({
+            protocolVersion: typeof params.protocolVersion === "string" ? params.protocolVersion : PROTOCOL,
+            capabilities: { tools: {} },
+            serverInfo: { name: "vitral", version: options.version ?? "0.0.0" },
+            instructions: "Registro de micro-frontends vitral. Use list_remotes para achar um remote, get_remote para ver as props e add_remote para adicion\xE1-lo ao host."
+          });
+        case "ping":
+          return ok2({});
+        case "tools/list":
+          return ok2({ tools: TOOLS });
+        case "tools/call": {
+          if (!TOOLS.some((t) => t.name === params.name)) return fail(-32602, `ferramenta desconhecida: ${params.name}`);
+          try {
+            return ok2(await call(params.name, params.arguments ?? {}));
+          } catch (err) {
+            return ok2(text(err.message, true));
+          }
+        }
+        default:
+          return fail(-32601, `m\xE9todo desconhecido: ${method}`);
+      }
+    }
+  };
+}
+function serveMcp(input = process.stdin, output = process.stdout, options = {}) {
+  const server = mcpServer(options);
+  const lines = createInterface({ input });
+  const write = (res) => res && output.write(JSON.stringify(res) + "\n");
+  const pending = [];
+  lines.on("line", (line) => {
+    if (!line.trim()) return;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      write({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "JSON inv\xE1lido" } });
+      return;
+    }
+    pending.push(server.handle(msg).then(write));
+  });
+  return new Promise((done) => lines.on("close", () => Promise.all(pending).then(() => done())));
+}
+
+// src/cli/doctor.ts
+import { createHash } from "crypto";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname2, join, resolve as resolve3 } from "path";
+import { gzipSync } from "zlib";
+var WARN_KB = 250;
+var ANY_ORIGIN = "https://host.invalid";
+var satisfies;
+var ok = (title) => ({ status: "ok", title });
+var warn = (title, cause, fix) => ({ status: "warn", title, cause, fix });
+var error = (title, cause, fix) => ({ status: "error", title, cause, fix });
+var kb = (bytes) => `${(bytes / 1024).toFixed(1)} kB`;
+async function get(f, url, origin, timeout) {
+  try {
+    const res = await f(url, { headers: { Origin: origin }, signal: AbortSignal.timeout(timeout) });
+    return { res, bytes: new Uint8Array(await res.arrayBuffer()) };
+  } catch (e) {
+    const err = e;
+    return { failure: err.name === "TimeoutError" ? `sem resposta em ${timeout} ms` : err.cause?.code ?? err.cause?.message ?? err.message };
+  }
+}
+function cors(what, url, res, origin, known) {
+  if (new URL(url).origin === origin) return;
+  const allow = res.headers.get("access-control-allow-origin");
+  if (allow === "*" || allow === origin) return ok(`CORS do ${what}: Access-Control-Allow-Origin ${allow}`);
+  if (!allow)
+    return error(
+      `CORS do ${what}: a resposta n\xE3o tem Access-Control-Allow-Origin`,
+      `o navegador bloqueia ${url} lido a partir de ${known ? origin : "outra origem"}.`,
+      `configure o servidor de ${new URL(url).origin} para responder Access-Control-Allow-Origin: ${known ? origin : "*"} (ou *).`
+    );
+  return (known ? error : warn)(
+    `CORS do ${what}: Access-Control-Allow-Origin \xE9 ${allow}`,
+    `o navegador s\xF3 libera ${url} para ${allow}${known ? `, e o host est\xE1 em ${origin}` : ""}.`,
+    known ? `inclua ${origin} na resposta do servidor (ou use *).` : "confira se \xE9 a origem do host, ou rode com --host/--origin."
+  );
+}
+function parseCsp(text2, source) {
+  const directives = /* @__PURE__ */ new Map();
+  for (const part of text2.split(";")) {
+    const [name, ...values] = part.trim().split(/\s+/);
+    if (name && !directives.has(name.toLowerCase())) directives.set(name.toLowerCase(), values);
+  }
+  return { source, directives };
+}
+function sources(p, ...chain) {
+  for (const name of [...chain, "default-src"]) {
+    const list = p.directives.get(name);
+    if (list) return { name, list };
+  }
+}
+function cspAllows(list, url, self) {
+  const u = new URL(url);
+  return list.some((raw) => {
+    const s = raw.toLowerCase();
+    if (s === "'none'") return false;
+    if (s === "'self'") return !!self && u.origin === new URL(self).origin;
+    if (s === "*") return /^(https?|wss?):$/.test(u.protocol);
+    if (/^[a-z][a-z0-9+.-]*:$/.test(s)) return u.protocol === s || s === "http:" && u.protocol === "https:";
+    const m = /^(?:([a-z][a-z0-9+.-]*):\/\/)?(\*\.)?([^/:]+|\*)(?::(\d+|\*))?(\/.*)?$/.exec(s);
+    if (!m || s.startsWith("'")) return false;
+    const [, scheme, wild, host, port, path] = m;
+    if (scheme && u.protocol !== `${scheme}:` && !(scheme === "http" && u.protocol === "https:")) return false;
+    if (!scheme && self && new URL(self).protocol === "https:" && u.protocol !== "https:") return false;
+    if (wild ? !u.hostname.endsWith(`.${host}`) : host !== "*" && u.hostname !== host) return false;
+    const def = u.protocol === "https:" ? "443" : "80";
+    if (port !== "*" && (port ?? def) !== (u.port || def)) return false;
+    if (path) return path.endsWith("/") ? u.pathname.startsWith(path) : u.pathname === path;
+    return true;
+  });
+}
+async function hostPolicies(f, cwd, host, timeout, out) {
+  const meta = (html) => [...html.matchAll(/<meta\s[^>]*http-equiv=["']?content-security-policy["']?[^>]*>/gi)].map((m) => /content=(["'])([\s\S]*?)\1/i.exec(m[0])?.[2] ?? "");
+  const policies = [];
+  if (host) {
+    const { res, bytes, failure } = await get(f, host, new URL(host).origin, timeout);
+    if (!res?.ok) {
+      out.push(warn(`CSP: n\xE3o foi poss\xEDvel abrir ${host} (${failure ?? `HTTP ${res.status}`})`, void 0, "confira a URL de --host."));
+      return policies;
+    }
+    for (const h of (res.headers.get("content-security-policy") ?? "").split(",")) if (h.trim()) policies.push(parseCsp(h, `header de ${host}`));
+    for (const c of meta(new TextDecoder().decode(bytes))) policies.push(parseCsp(c, `<meta> de ${host}`));
+  } else {
+    const file = ["index.html", "public/index.html", "src/index.html"].map((p) => resolve3(cwd, p)).find((p) => existsSync4(p));
+    if (file) for (const c of meta(readFileSync4(file, "utf8"))) policies.push(parseCsp(c, `<meta> de ${file}`));
+  }
+  out.push(
+    policies.length ? ok(`CSP encontrada (${policies.map((p) => p.source).join(", ")})`) : ok(`CSP: nenhuma encontrada ${host ? `em ${host}` : "no index.html"}${host ? "" : " (passe --host para ler o header da p\xE1gina)"}`)
+  );
+  return policies;
+}
+function cspChecks(policies, self, m, manifestUrl, js, css) {
+  const out = [];
+  for (const p of policies) {
+    const missing = [];
+    const script = sources(p, "script-src-elem", "script-src");
+    const connect = sources(p, "connect-src");
+    const strict = script?.list.includes("'strict-dynamic'");
+    if (script && !strict && !cspAllows(script.list, js, self)) missing.push(`${script.name} n\xE3o inclui ${new URL(js).origin} (JS do remote)`);
+    if (connect && manifestUrl.endsWith(".json") && !cspAllows(connect.list, manifestUrl, self))
+      missing.push(`${connect.name} n\xE3o inclui ${new URL(manifestUrl).origin} (o manifesto \xE9 baixado com fetch)`);
+    if (connect && m.integrity && !cspAllows(connect.list, js, self)) missing.push(`${connect.name} n\xE3o inclui ${new URL(js).origin} (o JS com integrity \xE9 conferido com fetch)`);
+    if (missing.length) {
+      out.push(error(`CSP (${p.source}) bloqueia o remote`, missing.join("; ") + ".", `acrescente ${new URL(js).origin} a script-src e connect-src.`));
+      continue;
+    }
+    out.push(ok(`CSP (${p.source}) libera o manifesto e o JS`));
+    if (m.integrity && script && !strict && !script.list.includes("blob:"))
+      out.push(
+        warn(
+          `CSP (${p.source}): ${script.name} sem blob:`,
+          "navegadores que n\xE3o conferem o hash de cada m\xF3dulo executam o JS verificado a partir de uma URL blob:, e a\xED o remote n\xE3o roda.",
+          `acrescente blob: a ${script.name}.`
+        )
+      );
+    const style = sources(p, "style-src-elem", "style-src");
+    const blocked = style ? css.filter((u) => !cspAllows(style.list, u, self)) : [];
+    if (blocked.length)
+      out.push(warn(`CSP (${p.source}): ${style.name} n\xE3o inclui ${new URL(blocked[0]).origin}`, "o CSS do remote n\xE3o carrega fora do Shadow DOM.", `acrescente ${new URL(blocked[0]).origin} a ${style.name}.`));
+  }
+  return out;
+}
+function exportsMount(code) {
+  if (/export\s+(async\s+)?function\s*\*?\s*mount\b|export\s+(const|let|var)\s+mount\b|export\s*\{[^}]*\b(as\s+)?mount\s*[,}]/.test(code)) return "mount";
+  if (/export\s+default\b|export\s*\{[^}]*\bas\s+default\b/.test(code) && /\bmount\b/.test(code)) return "default";
+  return "missing";
+}
+function matchesIntegrity(bytes, integrity) {
+  const hashes = integrity.split(/\s+/).map((t) => /^sha(256|384|512)-([\w+/=-]+)/.exec(t)).filter((m) => !!m);
+  if (!hashes.length) return void 0;
+  const bits = Math.max(...hashes.map((m) => +m[1]));
+  const clean2 = (b) => b.replace(/-/g, "+").replace(/_/g, "/").replace(/=/g, "");
+  const actual = clean2(createHash(`sha${bits}`).update(bytes).digest("base64"));
+  return hashes.some((m) => +m[1] === bits && clean2(m[2]) === actual);
+}
+var FRAMEWORKS = {
+  react: /__(SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED|CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE)/,
+  vue: /__vue_app__/
+};
+function installed(cwd, pkg) {
+  for (let dir = resolve3(cwd); ; dir = dirname2(dir)) {
+    const file = join(dir, "node_modules", pkg, "package.json");
+    if (existsSync4(file)) return JSON.parse(readFileSync4(file, "utf8")).version;
+    if (dir === dirname2(dir)) return;
+  }
+}
+async function checkRemote(name, e, ctx, seen) {
+  const out = [];
+  const isJson = new URL(e.url).pathname.endsWith(".json");
+  let m;
+  if (isJson) {
+    const { res: res2, bytes: bytes2, failure: failure2 } = await get(ctx.f, e.url, ctx.origin, ctx.timeout);
+    if (!res2) return [error(`manifesto: n\xE3o foi poss\xEDvel baixar (${failure2})`, `${e.url} n\xE3o respondeu.`, "confira a URL e se o servidor est\xE1 no ar.")];
+    if (!res2.ok) return [error(`manifesto: HTTP ${res2.status}`, `${e.url} n\xE3o existe ou n\xE3o est\xE1 publicado.`, "confira a URL no remotes.json e se o deploy do remote publicou o vitral.json.")];
+    const c = cors("manifesto", e.url, res2, ctx.origin, ctx.known);
+    if (c) out.push(c);
+    const text2 = new TextDecoder().decode(bytes2);
+    try {
+      m = JSON.parse(text2);
+    } catch {
+      const html = /^\s*</.test(text2);
+      out.push(
+        error(
+          "manifesto inv\xE1lido: n\xE3o \xE9 JSON",
+          html ? "o servidor devolveu HTML no lugar do vitral.json (fallback de SPA ou p\xE1gina de erro)." : `${e.url} n\xE3o tem um JSON v\xE1lido.`,
+          "abra a URL no navegador; publique o vitral.json gerado pelo build (dist/vitral.json)."
+        )
+      );
+      return out;
+    }
+    if (typeof m?.entry !== "string") {
+      out.push(error("manifesto inv\xE1lido: falta o campo entry", "sem entry o host n\xE3o sabe qual JS carregar (INVALID_MODULE).", 'gere o vitral.json com o plugin vitral/vite, ou escreva { "name", "entry" }.'));
+      return out;
+    }
+    out.push(ok(`manifesto v\xE1lido: ${m.name ?? name}${m.version ? ` ${m.version}` : ""}`));
+  } else {
+    m = { name, entry: e.url };
+    out.push(ok("sem manifesto: a URL \xE9 o pr\xF3prio JS"));
+  }
+  seen.manifest = m;
+  const abs = (u) => new URL(u, e.url).href;
+  const js = abs(m.entry);
+  if (new URL(js).origin !== new URL(e.url).origin)
+    out.push(
+      warn(
+        `o entry est\xE1 em ${new URL(js).origin}, outra origem que o manifesto`,
+        "sem allowedOrigins, o host s\xF3 aceita as origens das URLs registradas (ORIGIN_BLOCKED).",
+        `inclua ${new URL(js).origin} em configure({ allowedOrigins }).`
+      )
+    );
+  const { res, bytes, failure } = await get(ctx.f, js, ctx.origin, ctx.timeout);
+  if (!res) out.push(error(`JS: n\xE3o foi poss\xEDvel baixar (${failure})`, `${js} n\xE3o respondeu.`, "confira o entry do manifesto e se o servidor est\xE1 no ar."));
+  else if (!res.ok) out.push(error(`JS: HTTP ${res.status} em ${js}`, "o manifesto aponta para um arquivo que n\xE3o foi publicado (LOAD_FAILED).", "publique a pasta dist inteira, n\xE3o s\xF3 o vitral.json."));
+  if (res?.ok && bytes) {
+    const c = cors("JS", js, res, ctx.origin, ctx.known);
+    if (c) out.push(c);
+    const type = res.headers.get("content-type") ?? "";
+    if (!/javascript|ecmascript/i.test(type))
+      out.push(
+        error(
+          `JS servido como ${type || "sem Content-Type"}`,
+          "o navegador s\xF3 executa m\xF3dulo ES com Content-Type de JavaScript.",
+          "sirva os .js com Content-Type: text/javascript."
+        )
+      );
+    const code = new TextDecoder().decode(bytes);
+    const exp = exportsMount(code);
+    if (exp === "missing")
+      out.push(
+        (m.exposes?.length ? warn : error)(
+          "o JS n\xE3o exporta mount (nem default com mount)",
+          m.exposes?.length ? "s\xF3 as partes expostas podem ser usadas (loadModule)." : "o host recusa o m\xF3dulo (INVALID_MODULE).",
+          "exporte com defineRemote() ou com um adaptador (reactRemote, vueRemote...): export default defineRemote({ mount })."
+        )
+      );
+    else out.push(ok(exp === "mount" ? "exporta mount" : "exporta default com mount"));
+    for (const [who, integrity] of [
+      ["host (remotes.json)", e.integrity],
+      ["manifesto", m.integrity]
+    ]) {
+      if (!integrity) continue;
+      const match = matchesIntegrity(bytes, integrity);
+      if (match === void 0) out.push(error(`integrity do ${who} em formato inv\xE1lido: ${integrity}`, "o host recusa o remote (INTEGRITY).", "use sha256-, sha384- ou sha512- seguido do hash em base64."));
+      else if (!match)
+        out.push(
+          error(
+            `integrity do ${who} n\xE3o confere com o JS publicado`,
+            who === "manifesto" ? "o JS foi trocado sem gerar o vitral.json de novo, ou um cache serve uma vers\xE3o antiga." : "o remote foi publicado de novo e o hash fixado no host ficou velho.",
+            who === "manifesto" ? "publique o JS e o vitral.json do mesmo build; limpe o cache do CDN." : "atualize o integrity no remotes.json com o do vitral.json novo."
+          )
+        );
+      else out.push(ok(`integrity do ${who} confere`));
+    }
+    if (!e.integrity && !m.integrity) out.push(warn("sem integrity: o JS roda sem confer\xEAncia", void 0, "gere o manifesto com o plugin vitral/vite ou fixe integrity no host."));
+    const gz = gzipSync(bytes).length;
+    const size = `tamanho do JS: ${kb(bytes.length)} (${kb(gz)} com gzip)`;
+    if (ctx.maxKb !== void 0 && gz > ctx.maxKb * 1024)
+      out.push(error(size, `passa do limite de ${ctx.maxKb} kB.`, "veja o que entrou no bundle (vite build --mode production com rollup-plugin-visualizer) e use dedupe para o framework."));
+    else if (ctx.maxKb === void 0 && gz > WARN_KB * 1024) out.push(warn(size, `acima de ${WARN_KB} kB com gzip, o remote atrasa a p\xE1gina.`, "confira o que entrou no bundle; use dedupe para o framework; passe --max-kb para tornar isto um erro."));
+    else out.push(ok(size));
+    const deduped = /* @__PURE__ */ new Set([...(m.dedupe ?? []).map((d) => d.name), ...Object.keys(m.contract?.peers ?? {})]);
+    for (const [fw, mark] of Object.entries(FRAMEWORKS)) {
+      if (deduped.has(fw) || !ctx.deps[fw] || !mark.test(code)) continue;
+      out.push(
+        warn(
+          `o remote leva o pr\xF3prio ${fw} e o host tamb\xE9m tem ${fw} ${ctx.deps[fw]}`,
+          "s\xE3o duas c\xF3pias na p\xE1gina: mais download, e estado ou contexto de uma c\xF3pia n\xE3o \xE9 visto pela outra.",
+          `no remote: vitral({ dedupe: ['${fw}'] }).`
+        )
+      );
+    }
+  }
+  const files = Object.entries(m.files ?? {}).filter(([f]) => abs(f) !== js);
+  const bad = [];
+  for (const [file, integrity] of files) {
+    const got = await get(ctx.f, abs(file), ctx.origin, ctx.timeout);
+    if (!got.res?.ok) bad.push(`${file} (${got.failure ?? `HTTP ${got.res.status}`})`);
+    else if (!matchesIntegrity(got.bytes, integrity)) bad.push(`${file} (hash n\xE3o confere)`);
+    else if (/\.js$/.test(file)) {
+      const c = cors(`arquivo ${file}`, abs(file), got.res, ctx.origin, ctx.known);
+      if (c?.status !== "ok" && c) out.push(c);
+    }
+  }
+  if (bad.length)
+    out.push(error(`arquivos do manifesto com problema: ${bad.join(", ")}`, "o host n\xE3o carrega o CSS ou o build dividido (INTEGRITY ou LOAD_FAILED).", "publique todos os arquivos do mesmo build junto com o vitral.json."));
+  else if (files.length) out.push(ok(`${files.length} arquivo(s) do manifesto conferem com o hash`));
+  const range = e.contract ?? ctx.contract;
+  if (m.contract?.version && range) {
+    if (satisfies(m.contract.version, range)) out.push(ok(`contrato ${m.contract.version} na faixa ${range} do host`));
+    else
+      out.push(
+        error(
+          `contrato incompat\xEDvel: o host aceita ${range}, o remote publica ${m.contract.version}`,
+          "o host recusa o remote antes de executar (CONTRACT_MISMATCH).",
+          "publique uma vers\xE3o do remote compat\xEDvel, ou atualize o host para aceitar a nova vers\xE3o do contrato."
+        )
+      );
+  } else if (m.contract?.version) out.push(ok(`contrato ${m.contract.version} (o host n\xE3o declarou faixa; passe --contract para conferir)`));
+  else if (range && isJson) out.push(warn(`o host aceita contrato ${range}, mas o manifesto n\xE3o declara vers\xE3o`, "nada \xE9 conferido para este remote.", "no remote: vitral({ contract: { version: '\u2026' } })."));
+  for (const [dep, want] of Object.entries(m.contract?.peers ?? {})) {
+    const have = ctx.deps[dep];
+    if (!have) continue;
+    if (satisfies(have, want)) out.push(ok(`${dep} ${have} do host serve para o remote (${want})`));
+    else
+      out.push(
+        (range ? error : warn)(
+          `${dep}: o remote espera ${want}, o host tem ${have}`,
+          range ? "com contrato ligado e o host oferecendo essa vers\xE3o, o remote n\xE3o monta (CONTRACT_MISMATCH)." : "o remote baixa a pr\xF3pria c\xF3pia: duas c\xF3pias na p\xE1gina.",
+          `alinhe ${dep} nos dois projetos.`
+        )
+      );
+  }
+  if (ctx.policies.length) out.push(...cspChecks(ctx.policies, ctx.self, m, e.url, js, [...m.css ?? []].map(abs)));
+  return out;
+}
+function divergent(seen, deps) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const s of seen) for (const d of s.manifest?.dedupe ?? []) groups.set(d.name, [...groups.get(d.name) ?? [], { who: s.name, range: d.range, version: d.version }]);
+  const out = [];
+  for (const [dep, list] of groups) {
+    const candidates = [deps[dep], ...list.map((l) => l.version)].filter((v) => !!v);
+    if (list.length < 2 || candidates.some((v) => list.every((l) => satisfies(v, l.range)))) continue;
+    out.push(
+      warn(
+        `${dep} em vers\xF5es divergentes: ${list.map((l) => `${l.who} ${l.range}`).join(", ")}`,
+        `nenhuma vers\xE3o serve para todos os remotes, ent\xE3o a p\xE1gina baixa mais de uma c\xF3pia de ${dep}.`,
+        `alinhe ${dep} nos remotes (mesmo major).`
+      )
+    );
+  }
+  return out;
+}
+async function remotesOf(o, f, cwd, timeout) {
+  const args2 = o.args ?? [];
+  const url = args2.find((a) => /^https?:\/\//.test(a) && !a.includes("="));
+  if (!url) return readEntries(cwd, args2, o.base ?? o.host);
+  const res = await f(url, { signal: AbortSignal.timeout(timeout) }).catch(() => void 0);
+  const data = res?.ok ? await res.json().catch(() => void 0) : void 0;
+  if (!data || typeof data !== "object") throw new Error(`[vitral] n\xE3o foi poss\xEDvel ler ${url}.`);
+  if (typeof data.entry === "string") return { [data.name ?? url]: { url } };
+  return entriesOf(data, o.base ?? url);
+}
+async function doctor(options = {}) {
+  ;
+  ({ satisfies } = await import("./dedupe-S7BHQMOZ.js"));
+  const cwd = options.cwd ?? process.cwd();
+  const f = options.fetch ?? fetch;
+  const timeout = options.timeout ?? 15e3;
+  const remotes = await remotesOf(options, f, cwd, timeout);
+  const known = !!(options.origin ?? options.host);
+  const origin = known ? new URL(options.origin ?? options.host).origin : ANY_ORIGIN;
+  const host = [];
+  const policies = await hostPolicies(f, cwd, options.host, timeout, host);
+  const deps = Object.fromEntries(Object.keys(FRAMEWORKS).map((d) => [d, installed(cwd, d)]));
+  const ctx = { f, cwd, origin, known, self: known ? origin : void 0, contract: options.contract, maxKb: options.maxKb, timeout, policies, deps };
+  if (!known) host.push(warn("origem do host desconhecida: o CORS \xE9 conferido com uma origem qualquer", void 0, "passe --host url (ou --origin) para conferir com a origem certa."));
+  const seen = [];
+  const list = await Promise.all(
+    Object.entries(remotes).map(async ([name, e]) => {
+      const s = { name };
+      seen.push(s);
+      return { name, url: e.url, checks: await checkRemote(name, e, ctx, s) };
+    })
+  );
+  host.push(...divergent(seen, deps));
+  const all = [...host, ...list.flatMap((r) => r.checks)];
+  const errors = all.filter((c) => c.status === "error").length;
+  return { ok: !errors, errors, warnings: all.filter((c) => c.status === "warn").length, host, remotes: list };
+}
+var MARK = { ok: "\u2713", warn: "!", error: "\u2717" };
+function format(r) {
+  const lines = [];
+  const add2 = (c) => {
+    lines.push(`  ${MARK[c.status]} ${c.title}`);
+    if (c.cause) lines.push(`      Causa: ${c.cause}`);
+    if (c.fix) lines.push(`      O que fazer: ${c.fix}`);
+  };
+  lines.push("Host");
+  r.host.forEach(add2);
+  for (const rem of r.remotes) {
+    lines.push("", `${rem.name} (${rem.url})`);
+    rem.checks.forEach(add2);
+  }
+  lines.push("", r.errors || r.warnings ? `${r.errors} erro(s), ${r.warnings} aviso(s).` : "Tudo certo.");
+  return lines.join("\n");
+}
+async function doctorCli(argv, options = {}, log = console.log) {
+  const args2 = [...argv];
+  const json = args2.includes("--json");
+  const maxKb = flag(args2, "--max-kb");
+  const r = await doctor({
+    ...options,
+    base: flag(args2, "--base"),
+    host: flag(args2, "--host"),
+    origin: flag(args2, "--origin"),
+    contract: flag(args2, "--contract"),
+    maxKb: maxKb === void 0 ? void 0 : Number(maxKb),
+    args: args2.filter((a) => a !== "--json")
+  });
+  log(json ? JSON.stringify(r, null, 2) : format(r));
+  return r.ok ? 0 : 1;
+}
+
+// src/cli/migrate.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { basename, dirname as dirname3, extname, join as join2, relative, resolve as resolve4 } from "path";
+var FRAMEWORKS2 = {
+  preact: { wrap: ["vitral/preact", "preactRemote"], plugin: ["@preact/preset-vite", "preact", "preact()"] },
+  react: { wrap: ["vitral/react", "reactRemote"], plugin: ["@vitejs/plugin-react", "react", "react()"] },
+  vue: { wrap: ["vitral/vue", "vueRemote"], plugin: ["@vitejs/plugin-vue", "vue", "vue()"] },
+  svelte: { wrap: ["vitral/svelte", "svelteRemote"], plugin: ["@sveltejs/vite-plugin-svelte", "{ svelte }", "svelte()"] },
+  solid: { wrap: ["vitral/solid", "solidRemote"], plugin: ["vite-plugin-solid", "solid", "solid()"] },
+  angular: { wrap: ["vitral/angular", "angularRemote"], plugin: ["@analogjs/vite-plugin-angular", "angular", "angular()"] }
+};
+var DETECT = [
+  ["preact", "preact"],
+  ["react", "react"],
+  ["vue", "vue"],
+  ["svelte", "svelte"],
+  ["solid-js", "solid"],
+  ["@angular/core", "angular"]
+];
+var SOURCE_EXT = [".tsx", ".ts", ".jsx", ".js", ".mjs", ".vue", ".svelte"];
+var CONFIGS = ["webpack.config", "rspack.config", "rsbuild.config", "vite.config", "module-federation.config"].flatMap(
+  (b) => [".js", ".cjs", ".mjs", ".ts", ".mts", ".cts"].map((e) => b + e)
+);
+var MF_CALL = /new\s+(?:[\w$]+\.)*ModuleFederationPlugin\s*\(|\b(?:federation|pluginModuleFederation|createModuleFederationConfig)\s*\(/;
+var VITE_CONFIG = (ts) => `vite.vitral.config.${ts ? "mts" : "mjs"}`;
+var OUT_DIR = "dist-vitral";
+function read(file) {
+  try {
+    return readFileSync5(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+function rel(from, to) {
+  const r = relative(from, to).replace(/\\/g, "/");
+  return r.startsWith(".") ? r : "./" + r;
+}
+function spec(from, to) {
+  return rel(from, to).replace(/\.(tsx?|jsx?|mjs)$/, "");
+}
+function balanced(text2, start) {
+  const open = text2[start];
+  const close = open === "{" ? "}" : open === "(" ? ")" : open === "[" ? "]" : "";
+  if (!close) return null;
+  let depth = 0;
+  for (let i = start; i < text2.length; i++) {
+    const c = text2[i];
+    if (c === '"' || c === "'" || c === "`") {
+      for (i++; i < text2.length && text2[i] !== c; i++) if (text2[i] === "\\") i++;
+    } else if (c === "/" && text2[i + 1] === "/") i = text2.indexOf("\n", i) < 0 ? text2.length : text2.indexOf("\n", i);
+    else if (c === "/" && text2[i + 1] === "*") i = text2.indexOf("*/", i) < 0 ? text2.length : text2.indexOf("*/", i) + 1;
+    else if (c === open) depth++;
+    else if (c === close && --depth === 0) return text2.slice(start, i + 1);
+  }
+  return null;
+}
+function objectOf(text2, key) {
+  const m = new RegExp(`\\b${key}\\s*:\\s*\\{`).exec(text2);
+  return m ? balanced(text2, m.index + m[0].length - 1) : null;
+}
+function pairs(obj) {
+  const re = /(['"`]?)([\w@./-]+)\1\s*:\s*(?:(['"`])([^'"`]+)\3|\{[^}]*?\bimport\s*:\s*(['"`])([^'"`]+)\5[^}]*\})/g;
+  return [...obj.matchAll(re)].map((m) => [m[2], m[4] ?? m[6]]);
+}
+function project(cwd) {
+  const raw = read(join2(cwd, "package.json"));
+  const pkg = raw ? JSON.parse(raw) : null;
+  const deps = { ...pkg?.dependencies, ...pkg?.devDependencies, ...pkg?.peerDependencies };
+  return { cwd, pkg, deps, ts: existsSync5(join2(cwd, "tsconfig.json")), framework: DETECT.find(([d]) => d in deps)?.[1] ?? null };
+}
+function sources2(dir, out = []) {
+  let list;
+  try {
+    list = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of list) {
+    if (e.isDirectory()) {
+      if (!/^(node_modules|dist|build|\..*)$/.test(e.name)) sources2(join2(dir, e.name), out);
+    } else if (/\.(tsx?|jsx?|mjs)$/.test(e.name) && !/\.(test|spec|d)\./.test(e.name)) out.push(join2(dir, e.name));
+  }
+  return out;
+}
+var LIFECYCLE_EXPORT = /export\s+(?:(?:async\s+)?function\s*\*?\s*mount\b|(?:const|let|var)\s+mount\b|(?:const|let|var)\s*\{[^}]*\bmount\b[^}]*\}|\{[^}]*\bmount\b[^}]*\})/;
+function configs(cwd) {
+  return CONFIGS.map((f) => ({ file: f, text: read(join2(cwd, f)) })).filter((c) => c.text !== null);
+}
+function detect(p) {
+  if (configs(p.cwd).some((c) => MF_CALL.test(c.text) && /\bexposes\s*:/.test(c.text))) return "module-federation";
+  if (Object.keys(p.deps).some((d) => d === "single-spa" || d.startsWith("single-spa-"))) return "single-spa";
+  if (configs(p.cwd).some((c) => MF_CALL.test(c.text))) return "module-federation";
+  return null;
+}
+function viteConfig(p, vitral, notes) {
+  const path = VITE_CONFIG(p.ts);
+  if (existsSync5(join2(p.cwd, path))) {
+    notes.push(`${path} j\xE1 existe e n\xE3o foi alterado. Confira se ele usa: ${vitral}`);
+    return null;
+  }
+  const fw = p.framework && FRAMEWORKS2[p.framework].plugin;
+  const lines = [
+    ...fw ? [`import ${fw[1]} from '${fw[0]}'`] : [],
+    `import { defineConfig } from 'vite'`,
+    `import vitral from 'vitral/vite'`,
+    ``,
+    `// Build do remote vitral (\`npm run build:vitral\`). Gera ${OUT_DIR}/vitral.json, ao lado do build atual.`,
+    `export default defineConfig({`,
+    `  plugins: [${fw ? fw[2] + ", " : ""}${vitral}],`,
+    `  build: { outDir: '${OUT_DIR}' },`,
+    `})`,
+    ``
+  ];
+  const missing = ["vite", "vitral", ...fw ? [fw[0]] : []].filter((d) => !(d in p.deps) && !(d === "@vitejs/plugin-react" && "@vitejs/plugin-react-swc" in p.deps));
+  if (missing.length) notes.push(`Instale as depend\xEAncias do build novo: npm i -D ${missing.join(" ")}`);
+  return { path, before: null, after: lines.join("\n") };
+}
+function buildScript(p) {
+  if (!p.pkg || p.pkg.scripts?.["build:vitral"]) return null;
+  const before = read(join2(p.cwd, "package.json"));
+  const indent = /^(\s+)"/m.exec(before)?.[1] ?? "  ";
+  const pkg = { ...p.pkg, scripts: { ...p.pkg.scripts, "build:vitral": `vite build -c ${VITE_CONFIG(p.ts)}` } };
+  return { path: "package.json", before, after: JSON.stringify(pkg, null, indent) + (before.endsWith("\n") ? "\n" : "") };
+}
+function resolveSource(base, file) {
+  const abs = resolve4(base, file);
+  if (extname(abs) && existsSync5(abs)) return abs;
+  for (const ext of SOURCE_EXT) if (existsSync5(abs + ext)) return abs + ext;
+  for (const ext of SOURCE_EXT) if (existsSync5(join2(abs, "index" + ext))) return join2(abs, "index" + ext);
+  return abs;
+}
+function reactRoot(text2, file) {
+  const call = /\bsingleSpaReact\s*\(/.exec(text2);
+  const args2 = call && balanced(text2, call.index + call[0].length - 1);
+  const obj = args2 && /^\(\s*(\{[\s\S]*\})\s*\)$/.exec(args2)?.[1];
+  if (!obj) return null;
+  const body = obj.slice(1, -1).replace(/\/\/.*$|\/\*[\s\S]*?\*\//gm, "");
+  const keys = body.split(",").map((k) => k.split(":")[0].trim()).filter(Boolean);
+  if (keys.some((k) => !["React", "ReactDOM", "ReactDOMClient", "rootComponent"].includes(k))) return null;
+  const root = /\brootComponent\s*:\s*([\w$]+)\s*(?:,|$)/.exec(body)?.[1];
+  const from = root && new RegExp(`import\\s+${root.replace("$", "\\$")}\\s+from\\s+(['"])([^'"]+)\\1`).exec(text2)?.[2];
+  if (!from) return null;
+  return from.startsWith(".") ? resolve4(dirname3(file), from) : from;
+}
+function singleSpa(p) {
+  const changes = [];
+  const notes = [];
+  const src = existsSync5(join2(p.cwd, "src")) ? join2(p.cwd, "src") : p.cwd;
+  const files = sources2(src);
+  const found = files.filter((f) => {
+    const t = read(f);
+    return LIFECYCLE_EXPORT.test(t) && /\bunmount\b/.test(t);
+  });
+  const roots = files.filter((f) => /\bregisterApplication\s*\(/.test(read(f)));
+  if (roots.length) {
+    notes.push(
+      `Root config em ${roots.map((f) => rel(p.cwd, f)).join(", ")}: troque cada registerApplication por configure({ remotes }) e o activeWhen por uma rota do host ou routes() de vitral/routes. Veja https://joaogabriel15.github.io/vitral/migracao/single-spa`
+    );
+  }
+  if (!found.length) {
+    if (!roots.length) notes.push("Nenhum arquivo exporta os lifecycles mount e unmount do single-spa.");
+    return { from: "single-spa", changes, notes };
+  }
+  const [file, ...others] = found;
+  if (others.length) notes.push(`Outros arquivos tamb\xE9m exportam lifecycles e n\xE3o foram migrados: ${others.map((f) => rel(p.cwd, f)).join(", ")}`);
+  const out = join2(src, `vitral-remote.${p.ts ? "ts" : "js"}`);
+  const outRel = rel(p.cwd, out).replace(/^\.\//, "");
+  const text2 = read(file);
+  const root = /single-spa-react/.test(text2) ? reactRoot(text2, file) : null;
+  let code;
+  if (root) {
+    const imp = root.startsWith("/") || /^[A-Za-z]:/.test(root) ? spec(src, resolveSource(dirname3(root), root)) : root;
+    code = `import { reactRemote } from 'vitral/react'
+import Root from '${imp}'
+
+export default reactRemote(Root)
+`;
+    notes.push(`${rel(p.cwd, file)} usava singleSpaReact s\xF3 com rootComponent: ${outRel} usa reactRemote. Quando nenhum host single-spa usar mais o app, remova single-spa-react e o arquivo antigo.`);
+  } else {
+    code = `import { singleSpaRemote } from 'vitral/single-spa'
+import * as lifecycles from '${spec(src, file)}'
+
+export default singleSpaRemote(lifecycles)
+`;
+    notes.push(
+      `${outRel} embrulha os lifecycles de ${rel(p.cwd, file)} sem mudar o app. Para tirar o single-spa do bundle, troque por reactRemote, vueRemote etc. Veja https://joaogabriel15.github.io/vitral/migracao/single-spa`
+    );
+  }
+  if (existsSync5(out)) notes.push(`${outRel} j\xE1 existe e n\xE3o foi alterado.`);
+  else changes.push({ path: outRel, before: null, after: code });
+  const vite = viteConfig(p, `vitral({ entry: '${outRel}' })`, notes);
+  if (vite) changes.push(vite);
+  const script = buildScript(p);
+  if (script) changes.push(script);
+  if (/\b(navigateToUrl|mountParcel|mountRootParcel)\b/.test(files.map((f) => read(f)).join("\n"))) {
+    notes.push("O c\xF3digo usa navigateToUrl ou parcels do single-spa: fora de um host single-spa, troque navigateToUrl por ctx.navigate e parcels por <Remote> ou createSlot.");
+  }
+  if (/vite-plugin-single-spa|webpack-config-single-spa|systemjs/.test(Object.keys(p.deps).join(" "))) {
+    notes.push("O build atual (SystemJS, vite-plugin-single-spa ou webpack-config-single-spa) continua para os hosts single-spa. Remova-o quando nenhum host usar mais o app.");
+  }
+  return { from: "single-spa", changes, notes };
+}
+function moduleFederation(p) {
+  const changes = [];
+  const notes = [];
+  const found = configs(p.cwd).map((c) => {
+    const m = MF_CALL.exec(c.text);
+    return m ? { ...c, call: balanced(c.text, m.index + m[0].length - 1) ?? "" } : null;
+  }).filter((c) => !!c);
+  for (const c of found) {
+    const remotes = objectOf(c.call, "remotes");
+    const list = remotes ? pairs(remotes) : [];
+    if (list.length) {
+      const sugestoes = list.map(([n, v]) => {
+        const url = v.includes("@") ? v.slice(v.indexOf("@") + 1) : v;
+        return `    ${n}: federationRemote('${url.replace(/[^/]*$/, "mf-manifest.json")}'),`;
+      });
+      notes.push(
+        `${c.file} consome remotes (${list.map(([n]) => n).join(", ")}). Para usar no host vitral antes de eles migrarem:
+  configure({ remotes: {
+${sugestoes.join("\n")}
+  } })
+  com federationRemote de vitral/federation. Quando cada remote migrar, troque pela URL do vitral.json dele.`
+      );
+    }
+  }
+  const remote = found.find((c) => /\bexposes\s*:/.test(c.call));
+  if (!remote) {
+    if (!found.some((c) => objectOf(c.call, "remotes"))) notes.push("Nenhuma configura\xE7\xE3o do Module Federation com exposes encontrada.");
+    return { from: "module-federation", changes, notes };
+  }
+  const obj = objectOf(remote.call, "exposes");
+  const exposes = obj ? pairs(obj) : [];
+  if (!exposes.length) {
+    notes.push(`${remote.file}: exposes n\xE3o \xE9 um objeto literal com caminhos. Configure exposes do vitral \xE0 m\xE3o. Veja https://joaogabriel15.github.io/vitral/aprender/exposes`);
+    return { from: "module-federation", changes, notes };
+  }
+  const name = /\bname\s*:\s*(['"`])([^'"`]+)\1/.exec(remote.call)?.[2];
+  const base = join2(p.cwd, dirname3(remote.file));
+  const wrapDir = join2(p.cwd, "src", "vitral");
+  const fw = p.framework && p.framework !== "angular" ? FRAMEWORKS2[p.framework] : null;
+  const entries = [];
+  let entry;
+  const modules = [];
+  for (const [k, f] of exposes) {
+    const key = "./" + k.replace(/^\.?\/?/, "");
+    const file = resolveSource(base, f);
+    const fileRel = rel(p.cwd, file).replace(/^\.\//, "");
+    const component = /\.(jsx|tsx|vue|svelte)$/.test(file) || /^[A-Z]/.test(basename(file).replace(/^index\./, basename(dirname3(file))));
+    if (!component || !fw) {
+      entries.push([key, fileRel]);
+      modules.push(key);
+      continue;
+    }
+    const wrapper = join2(wrapDir, `${key.slice(2).replace(/[^\w-]/g, "-")}.${p.ts ? "ts" : "js"}`);
+    const wrapperRel = rel(p.cwd, wrapper).replace(/^\.\//, "");
+    const imp = spec(wrapDir, file);
+    const [from, fn] = fw.wrap;
+    const code = `import { ${fn} } from '${from}'
+import Componente from '${imp}'
+
+export * from '${imp}'
+export default ${fn}(Componente)
+`;
+    if (existsSync5(wrapper)) notes.push(`${wrapperRel} j\xE1 existe e n\xE3o foi alterado.`);
+    else changes.push({ path: wrapperRel, before: null, after: code });
+    entries.push([key, wrapperRel]);
+    entry ??= wrapperRel;
+  }
+  if (!fw) notes.push(`Framework ${p.framework ?? "n\xE3o identificado"}: cada parte de exposes aponta para o arquivo original. Um componente precisa exportar default com mount (ex.: ${p.framework === "angular" ? "angularRemote(Componente)" : "defineRemote({ mount })"}).`);
+  if (modules.length && fw) notes.push(`Tratados como m\xF3dulos sem UI (host usa loadModule): ${modules.join(", ")}. Se algum for componente, embrulhe com ${fw.wrap[1]} como em src/vitral/.`);
+  entry ??= entries[0][1];
+  const lines = entries.map(([k, f]) => `      '${k}': '${f}',`);
+  const vitral = `vitral({
+    ${name ? `name: '${name}',
+    ` : ""}entry: '${entry}',
+    exposes: {
+${lines.join("\n")}
+    },
+  })`;
+  const vite = viteConfig(p, vitral, notes);
+  if (vite) changes.push(vite);
+  const script = buildScript(p);
+  if (script) changes.push(script);
+  if (objectOf(remote.call, "shared") || /\bshared\s*:/.test(remote.call)) {
+    notes.push("shared n\xE3o migra: cada remote vitral leva as pr\xF3prias depend\xEAncias. Para usar as do host, veja a op\xE7\xE3o dedupe do plugin: https://joaogabriel15.github.io/vitral/aprender/dedupe");
+  }
+  notes.push(`${remote.file} continua gerando o remoteEntry.js para os hosts Module Federation. Remova o plugin quando nenhum host usar mais o remote.`);
+  notes.push(`No host vitral: configure({ remotes: { ${name ?? "nome"}: 'https://\u2026/${OUT_DIR}/vitral.json' } }) e <Remote name="${name ?? "nome"}${exposes[0][0].replace(/^\.?\//, "/")}" />.`);
+  return { from: "module-federation", changes, notes };
+}
+function diff(path, before, after, context = 2) {
+  const a = before === null ? [] : before.replace(/\n$/, "").split("\n");
+  const b = after.replace(/\n$/, "").split("\n");
+  const head = before === null ? `--- /dev/null
++++ ${path}` : `--- ${path}
++++ ${path}`;
+  const lcs = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+  for (let i2 = a.length - 1; i2 >= 0; i2--) for (let j2 = b.length - 1; j2 >= 0; j2--) lcs[i2][j2] = a[i2] === b[j2] ? lcs[i2 + 1][j2 + 1] + 1 : Math.max(lcs[i2 + 1][j2], lcs[i2][j2 + 1]);
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length || j < b.length) {
+    if (i < a.length && j < b.length && a[i] === b[j]) ops.push([" ", a[i++]]), j++;
+    else if (i < a.length && (j >= b.length || lcs[i + 1][j] >= lcs[i][j + 1])) ops.push(["-", a[i++]]);
+    else ops.push(["+", b[j++]]);
+  }
+  const keep = ops.map((_, k) => ops.slice(Math.max(0, k - context), k + context + 1).some(([op]) => op !== " "));
+  const out = [];
+  ops.forEach(([op, line], k) => {
+    if (keep[k] && k > 0 && !keep[k - 1]) out.push("@@");
+    if (keep[k]) out.push(op + line);
+  });
+  return `${head}
+${out.join("\n")}`;
+}
+function plan(cwd, from) {
+  const p = project(cwd);
+  const source = from ?? detect(p);
+  if (source === "single-spa") return singleSpa(p);
+  if (source === "module-federation") return moduleFederation(p);
+  return { from: null, changes: [], notes: ["N\xE3o achei single-spa nem Module Federation neste projeto. Use --from single-spa ou --from module-federation."] };
+}
+function migrate(options = {}) {
+  const cwd = resolve4(options.cwd ?? process.cwd());
+  const log = options.log ?? console.log;
+  const result = plan(cwd, options.from);
+  if (result.from) log(`[vitral] migrate: ${result.from === "single-spa" ? "single-spa" : "Module Federation"} em ${cwd}`);
+  for (const c of result.changes) log(`  ${c.before === null ? "+" : "~"} ${c.path}${c.before === null ? " (novo)" : ""}`);
+  for (const c of result.changes) log("\n" + diff(c.path, c.before, c.after));
+  if (result.notes.length) log(`
+Fa\xE7a \xE0 m\xE3o:
+${result.notes.map((n) => `  - ${n}`).join("\n")}`);
+  if (options.dryRun) {
+    log("\n[vitral] --dry-run: nada foi escrito.");
+    return result;
+  }
+  for (const c of result.changes) {
+    const file = join2(cwd, c.path);
+    mkdirSync2(dirname3(file), { recursive: true });
+    writeFileSync4(file, c.after);
+  }
+  if (result.changes.length) log(`
+[vitral] ${result.changes.length} arquivo(s) escrito(s). Rode \`npm run build:vitral\`.`);
+  return result;
+}
+
 // src/cli.ts
-var AJUDA = `Uso: vitral types [remotes.json | nome=url ...] [--base url] [--out arquivo] [--check]
+var AJUDA = `Uso:
+  vitral types [remotes.json | nome=url ...] [--base url] [--out arquivo] [--check]
+  vitral registry [remotes.json | nome=url ...] [--base url] [--out arquivo] [--name nome]
+  vitral add <remote ...> [--registry url|arquivo] [--to remotes.json] [--base url] [--out arquivo] [--force] [--no-types]
+  vitral mcp [--registry url|arquivo]
+  vitral doctor [remotes.json | url | nome=url ...] [--host url] [--origin url] [--base url]
+                [--contract faixa] [--max-kb n] [--json]
+  vitral migrate [pasta] [--from single-spa|module-federation] [--dry-run]
+  vitral canal <canal.json> [--stable x.y.z] [--canary x.y.z | off] [--percent n]
 
-  Baixa o vitral.d.ts de cada remote e gera vitral-env.d.ts.
-  --check  s\xF3 confere se o hash de cada manifesto ainda \xE9 o registrado;
-           sai com erro se algum mudou (\xFAtil no CI).`;
-function flag(args2, name) {
+  types     Baixa o vitral.d.ts de cada remote e gera vitral-env.d.ts.
+            --check s\xF3 confere se o hash de cada manifesto ainda \xE9 o
+            registrado; sai com erro se algum mudou (\xFAtil no CI).
+  registry  Gera vitral-registry.json a partir dos manifestos.
+  add       Copia remotes do registro para o remotes.json e roda types.
+            Registro padr\xE3o: VITRAL_REGISTRY ou vitral-registry.json.
+  mcp       Servidor MCP por stdio para agentes (list_remotes, get_remote,
+            add_remote).
+  doctor    Confere cada remote como o host faria (manifesto, CORS, CSP, mount,
+            integrity, contrato, dedupe, tamanho) e explica o que fazer.
+            Sai com erro se alguma confer\xEAncia falhar (\xFAtil no CI).
+  migrate   Converte um app do single-spa ou um remote do Module Federation num
+            remote vitral. Mostra o diff de cada arquivo.
+            --dry-run s\xF3 mostra o que mudaria, sem escrever.
+  canal     Cria ou edita o canal de um remote (canary e rollback) e mostra
+            como ficou. --stable \xE9 obrigat\xF3ria ao criar; --canary off tira a
+            canary; --percent vai de 0 a 100.`;
+var falhou = (err) => {
+  console.error(err.message);
+  process.exitCode = 1;
+};
+function bool(args2, name) {
   const i = args2.indexOf(name);
-  if (i < 0) return void 0;
-  const value = args2[i + 1];
-  args2.splice(i, 2);
-  return value;
+  if (i >= 0) args2.splice(i, 1);
+  return i >= 0;
+}
+function version() {
+  try {
+    return createRequire(import.meta.url)("../package.json").version;
+  } catch {
+    return "0.0.0";
+  }
 }
+var finish = (run) => run.then(
+  (falhas) => process.exitCode = falhas ? 1 : 0,
+  (err) => {
+    console.error(err.message);
+    process.exitCode = 1;
+  }
+);
 var [command, ...args] = process.argv.slice(2);
 if (command === "types") {
   const base = flag(args, "--base");
   const out = flag(args, "--out");
-  const check2 = args.includes("--check");
-  types({ args: args.filter((a) => a !== "--check"), base, out, check: check2 }).then(
-    (falhas) => process.exitCode = falhas ? 1 : 0,
-    (err) => {
+  const check2 = bool(args, "--check");
+  finish(types({ args, base, out, check: check2 }));
+} else if (command === "registry") {
+  const base = flag(args, "--base");
+  const out = flag(args, "--out");
+  const name = flag(args, "--name");
+  finish(registry({ args, base, out, name }));
+} else if (command === "add") {
+  const reg = flag(args, "--registry");
+  const to = flag(args, "--to");
+  const base = flag(args, "--base");
+  const out = flag(args, "--out");
+  const force = bool(args, "--force");
+  const noTypes = bool(args, "--no-types");
+  finish(add({ names: args, registry: reg, to, base, out, force, types: !noTypes }));
+} else if (command === "mcp") {
+  serveMcp(process.stdin, process.stdout, { registry: flag(args, "--registry"), version: version() });
+} else if (command === "doctor") {
+  doctorCli(args).then((code) => process.exitCode = code, falhou);
+} else if (command === "migrate") {
+  const from = flag(args, "--from");
+  if (from && from !== "single-spa" && from !== "module-federation") {
+    console.error(`[vitral] --from inv\xE1lido: ${from}. Use single-spa ou module-federation.`);
+    process.exitCode = 1;
+  } else {
+    try {
+      const plan2 = migrate({ cwd: args.find((a) => !a.startsWith("--")), from, dryRun: args.includes("--dry-run") });
+      process.exitCode = plan2.from ? 0 : 1;
+    } catch (err) {
       console.error(err.message);
       process.exitCode = 1;
     }
-  );
+  }
+} else if (command === "canal" && args.length) {
+  const stable = flag(args, "--stable");
+  const canary = flag(args, "--canary");
+  const percent = flag(args, "--percent");
+  try {
+    canal({ file: args[0], stable, canary, percent: percent === void 0 ? void 0 : Number(percent) });
+  } catch (err) {
+    falhou(err);
+  }
 } else {
   console.log(AJUDA);
   process.exitCode = command && command !== "--help" ? 1 : 0;