vitral 0.4.0 → 0.6.0

package/dist/cli.js

@@ -1,7 +1,16 @@
 #!/usr/bin/env node
+import {
+  verify
+} from "./chunk-DAESKNQ6.js";
+import {
+  loadTs
+} from "./chunk-PY7P5BF4.js";
+import {
+  dictMatch
+} from "./chunk-NZEQGRBL.js";
 
 // src/cli.ts
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 
 // src/cli/canal.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -420,10 +429,100 @@ function serveMcp(input = process.stdin, output = process.stdout, options = {})
   return new Promise((done) => lines.on("close", () => Promise.all(pending).then(() => done())));
 }
 
+// src/cli/dict.ts
+import { execFileSync } from "child_process";
+import { createHash, randomBytes } from "crypto";
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync4, statSync, writeFileSync as writeFileSync4 } from "fs";
+import { join, relative, sep } from "path";
+import * as zlib from "zlib";
+var INDEX = "vitral-dict.json";
+var TYPES = { ".js": "text/javascript", ".mjs": "text/javascript", ".css": "text/css" };
+var DCZ_MAGIC = Buffer.from([94, 42, 77, 24, 32, 0, 0, 0]);
+var DCB_MAGIC = Buffer.from([255, 68, 67, 66]);
+function files(dist) {
+  const out = /* @__PURE__ */ new Map();
+  const walk = (dir) => {
+    for (const name of readdirSync(dir).sort()) {
+      const full = join(dir, name);
+      if (statSync(full).isDirectory()) walk(full);
+      else if (TYPES[ext(name)]) out.set(relative(dist, full).split(sep).join("/"), full);
+    }
+  };
+  walk(dist);
+  return out;
+}
+var ext = (name) => name.slice(name.lastIndexOf("."));
+function nodeZstd() {
+  const z = zlib.zstdCompressSync;
+  if (!z) return void 0;
+  const sample = randomBytes(256);
+  return z(sample, { dictionary: sample }).length < 64 ? z : void 0;
+}
+function brotliBin() {
+  try {
+    execFileSync("brotli", ["--version"], { stdio: "ignore" });
+  } catch {
+    return void 0;
+  }
+  return (input, dictionary) => execFileSync("brotli", ["-q", "11", "-c", "-D", dictionary, input], { maxBuffer: 1 << 30 });
+}
+var kb = (n) => (n / 1024).toFixed(1).padStart(7) + " kB";
+function dict(o) {
+  const log = o.log ?? console.log;
+  const zstd = nodeZstd();
+  if (!zstd) throw new Error(`[vitral] dict precisa do zstd com dicion\xE1rio do Node (22.19+ ou 24.6+). Este \xE9 ${process.version}.`);
+  const brotli = o.brotli === false ? void 0 : o.brotli ?? brotliBin();
+  const level = o.level ?? 19;
+  if (!existsSync4(o.dist)) throw new Error(`[vitral] ${o.dist} n\xE3o existe`);
+  const novos = files(o.dist);
+  const antigos = /* @__PURE__ */ new Map();
+  for (const from of o.from) {
+    if (!existsSync4(from)) throw new Error(`[vitral] ${from} n\xE3o existe`);
+    for (const [rel2, full] of files(from)) {
+      const key = dictMatch("/" + rel2);
+      antigos.set(key, [...antigos.get(key) ?? [], full]);
+    }
+  }
+  const index = { version: 1, files: {} };
+  const linhas = [];
+  for (const [rel2, full] of novos) {
+    const deltas = {};
+    index.files[rel2] = { type: TYPES[ext(rel2)], deltas };
+    const input = readFileSync4(full);
+    const vistos = /* @__PURE__ */ new Set();
+    for (const old of antigos.get(dictMatch("/" + rel2)) ?? []) {
+      const dictionary = readFileSync4(old);
+      const sha = createHash("sha256").update(dictionary).digest();
+      const hash = `:${sha.toString("base64")}:`;
+      if (vistos.has(hash) || dictionary.equals(input)) continue;
+      vistos.add(hash);
+      const id = sha.toString("hex").slice(0, 12);
+      const variant = {};
+      const dcz = Buffer.concat([DCZ_MAGIC, sha, zstd(input, { dictionary, params: { [zlib.constants.ZSTD_c_compressionLevel]: level } })]);
+      writeFileSync4(join(o.dist, `${rel2}.${id}.dcz`), dcz);
+      variant.dcz = `${rel2}.${id}.dcz`;
+      let dcb;
+      if (brotli) {
+        dcb = Buffer.concat([DCB_MAGIC, sha, brotli(full, old)]);
+        writeFileSync4(join(o.dist, `${rel2}.${id}.dcb`), dcb);
+        variant.dcb = `${rel2}.${id}.dcb`;
+      }
+      deltas[hash] = variant;
+      const br = zlib.brotliCompressSync(input, { params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 11 } }).length;
+      linhas.push(`${rel2}  br ${kb(br)}  dcz ${kb(dcz.length)}${dcb ? `  dcb ${kb(dcb.length)}` : ""}  (de ${relative(process.cwd(), old) || old})`);
+    }
+  }
+  writeFileSync4(join(o.dist, INDEX), JSON.stringify(index, null, 2) + "\n");
+  const n = Object.values(index.files).reduce((s, f) => s + Object.keys(f.deltas).length, 0);
+  for (const l of linhas) log(l);
+  log(`[vitral] ${Object.keys(index.files).length} arquivos, ${n} deltas${brotli ? "" : " (s\xF3 .dcz: falta o bin\xE1rio brotli para .dcb)"}. \xCDndice: ${join(o.dist, INDEX)}`);
+  return index;
+}
+
 // 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 { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname2, join as join2, resolve as resolve3 } from "path";
 import { gzipSync } from "zlib";
 var WARN_KB = 250;
 var ANY_ORIGIN = "https://host.invalid";
@@ -431,7 +530,7 @@ 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`;
+var kb2 = (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) });
@@ -503,8 +602,8 @@ async function hostPolicies(f, cwd, host, timeout, out) {
     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}`));
+    const file = ["index.html", "public/index.html", "src/index.html"].map((p) => resolve3(cwd, p)).find((p) => existsSync5(p));
+    if (file) for (const c of meta(readFileSync5(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)"}`)
@@ -552,7 +651,7 @@ function matchesIntegrity(bytes, integrity) {
   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"));
+  const actual = clean2(createHash2(`sha${bits}`).update(bytes).digest("base64"));
   return hashes.some((m) => +m[1] === bits && clean2(m[2]) === actual);
 }
 var FRAMEWORKS = {
@@ -561,8 +660,8 @@ var FRAMEWORKS = {
 };
 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;
+    const file = join2(dir, "node_modules", pkg, "package.json");
+    if (existsSync5(file)) return JSON.parse(readFileSync5(file, "utf8")).version;
     if (dir === dirname2(dir)) return;
   }
 }
@@ -655,7 +754,7 @@ async function checkRemote(name, e, ctx, seen) {
     }
     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)`;
+    const size = `tamanho do JS: ${kb2(bytes.length)} (${kb2(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."));
@@ -672,9 +771,9 @@ async function checkRemote(name, e, ctx, seen) {
       );
     }
   }
-  const files = Object.entries(m.files ?? {}).filter(([f]) => abs(f) !== js);
+  const files2 = Object.entries(m.files ?? {}).filter(([f]) => abs(f) !== js);
   const bad = [];
-  for (const [file, integrity] of files) {
+  for (const [file, integrity] of files2) {
     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)`);
@@ -685,7 +784,7 @@ async function checkRemote(name, e, ctx, seen) {
   }
   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`));
+  else if (files2.length) out.push(ok(`${files2.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`));
@@ -804,8 +903,8 @@ async function doctorCli(argv, options = {}, log = console.log) {
 }
 
 // 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";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { basename, dirname as dirname3, extname, join as join3, relative as relative2, 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()"] },
@@ -831,13 +930,13 @@ var VITE_CONFIG = (ts) => `vite.vitral.config.${ts ? "mts" : "mjs"}`;
 var OUT_DIR = "dist-vitral";
 function read(file) {
   try {
-    return readFileSync5(file, "utf8");
+    return readFileSync6(file, "utf8");
   } catch {
     return null;
   }
 }
 function rel(from, to) {
-  const r = relative(from, to).replace(/\\/g, "/");
+  const r = relative2(from, to).replace(/\\/g, "/");
   return r.startsWith(".") ? r : "./" + r;
 }
 function spec(from, to) {
@@ -868,28 +967,28 @@ function pairs(obj) {
   return [...obj.matchAll(re)].map((m) => [m[2], m[4] ?? m[6]]);
 }
 function project(cwd) {
-  const raw = read(join2(cwd, "package.json"));
+  const raw = read(join3(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 };
+  return { cwd, pkg, deps, ts: existsSync6(join3(cwd, "tsconfig.json")), framework: DETECT.find(([d]) => d in deps)?.[1] ?? null };
 }
 function sources2(dir, out = []) {
   let list;
   try {
-    list = readdirSync(dir, { withFileTypes: true });
+    list = readdirSync2(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));
+      if (!/^(node_modules|dist|build|\..*)$/.test(e.name)) sources2(join3(dir, e.name), out);
+    } else if (/\.(tsx?|jsx?|mjs)$/.test(e.name) && !/\.(test|spec|d)\./.test(e.name)) out.push(join3(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);
+  return CONFIGS.map((f) => ({ file: f, text: read(join3(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";
@@ -899,7 +998,7 @@ function detect(p) {
 }
 function viteConfig(p, vitral, notes) {
   const path = VITE_CONFIG(p.ts);
-  if (existsSync5(join2(p.cwd, path))) {
+  if (existsSync6(join3(p.cwd, path))) {
     notes.push(`${path} j\xE1 existe e n\xE3o foi alterado. Confira se ele usa: ${vitral}`);
     return null;
   }
@@ -922,16 +1021,16 @@ function viteConfig(p, vitral, notes) {
 }
 function buildScript(p) {
   if (!p.pkg || p.pkg.scripts?.["build:vitral"]) return null;
-  const before = read(join2(p.cwd, "package.json"));
+  const before = read(join3(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);
+  if (extname(abs) && existsSync6(abs)) return abs;
+  for (const ext2 of SOURCE_EXT) if (existsSync6(abs + ext2)) return abs + ext2;
+  for (const ext2 of SOURCE_EXT) if (existsSync6(join3(abs, "index" + ext2))) return join3(abs, "index" + ext2);
   return abs;
 }
 function reactRoot(text2, file) {
@@ -950,13 +1049,13 @@ function reactRoot(text2, file) {
 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 src = existsSync6(join3(p.cwd, "src")) ? join3(p.cwd, "src") : p.cwd;
+  const files2 = sources2(src);
+  const found = files2.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)));
+  const roots = files2.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`
@@ -968,7 +1067,7 @@ function singleSpa(p) {
   }
   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 out = join3(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;
@@ -991,13 +1090,13 @@ export default singleSpaRemote(lifecycles)
       `${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.`);
+  if (existsSync6(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"))) {
+  if (/\b(navigateToUrl|mountParcel|mountRootParcel)\b/.test(files2.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(" "))) {
@@ -1041,8 +1140,8 @@ ${sugestoes.join("\n")}
     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 base = join3(p.cwd, dirname3(remote.file));
+  const wrapDir = join3(p.cwd, "src", "vitral");
   const fw = p.framework && p.framework !== "angular" ? FRAMEWORKS2[p.framework] : null;
   const entries = [];
   let entry;
@@ -1057,7 +1156,7 @@ ${sugestoes.join("\n")}
       modules.push(key);
       continue;
     }
-    const wrapper = join2(wrapDir, `${key.slice(2).replace(/[^\w-]/g, "-")}.${p.ts ? "ts" : "js"}`);
+    const wrapper = join3(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;
@@ -1067,7 +1166,7 @@ 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.`);
+    if (existsSync6(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;
@@ -1141,15 +1240,259 @@ ${result.notes.map((n) => `  - ${n}`).join("\n")}`);
     return result;
   }
   for (const c of result.changes) {
-    const file = join2(cwd, c.path);
+    const file = join3(cwd, c.path);
     mkdirSync2(dirname3(file), { recursive: true });
-    writeFileSync4(file, c.after);
+    writeFileSync5(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/test.ts
+import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync7, statSync as statSync2 } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname4, join as join4, resolve as resolve5 } from "path";
+import { pathToFileURL } from "url";
+var FILE = "/__vitral_check__.ts";
+function typeErrors(ts, snippets) {
+  let code = "";
+  const starts = [];
+  snippets.forEach((s, i) => {
+    starts.push(code.length);
+    code += `namespace __c${i} {
+${s}
+}
+`;
+  });
+  const options = { strict: true, noEmit: true, target: ts.ScriptTarget.ES2022, skipLibCheck: true, types: [] };
+  const host = ts.createCompilerHost(options);
+  const getSourceFile = host.getSourceFile;
+  host.getSourceFile = (name, lang, ...rest) => name === FILE ? ts.createSourceFile(name, code, lang) : getSourceFile.call(host, name, lang, ...rest);
+  const fileExists = host.fileExists;
+  host.fileExists = (name) => name === FILE || fileExists.call(host, name);
+  const program = ts.createProgram([FILE], options, host);
+  const out = snippets.map(() => []);
+  for (const d of [...program.getSyntacticDiagnostics(), ...program.getSemanticDiagnostics()]) {
+    if (d.file?.fileName !== FILE || d.start === void 0) continue;
+    let i = starts.length - 1;
+    while (i > 0 && starts[i] > d.start) i--;
+    out[i].push({ code: d.code, text: ts.flattenDiagnosticMessageText(d.messageText, " ") });
+  }
+  return out;
+}
+function propFields(ts, type) {
+  const src = ts.createSourceFile("p.ts", `type P = ${type}`, ts.ScriptTarget.ES2022, true);
+  const alias = src.statements[0];
+  if (!alias || !ts.isTypeAliasDeclaration(alias) || !ts.isTypeLiteralNode(alias.type)) return null;
+  const fields = /* @__PURE__ */ new Map();
+  for (const m of alias.type.members) {
+    if (!ts.isPropertySignature(m) || !m.type) return null;
+    const name = ts.isIdentifier(m.name) || ts.isStringLiteral(m.name) ? m.name.text : m.name.getText(src);
+    fields.set(name, { optional: !!m.questionToken, type: m.type.getText(src) });
+  }
+  return fields;
+}
+function diffProps(before, after, ts) {
+  const breaking = [];
+  const compatible = [];
+  const norm = (s) => s.replace(/\s+/g, " ").replace(/;\s*}/g, " }").trim();
+  if (norm(before) === norm(after)) return { breaking, compatible };
+  if (!ts) return { breaking: [`Props mudou (sem TypeScript para detalhar): ${norm(before)} \u2192 ${norm(after)}`], compatible };
+  const old = propFields(ts, before);
+  const now = propFields(ts, after);
+  if (!old || !now) {
+    const [errors] = typeErrors(ts, [`type O = ${before}
+type N = ${after}
+declare const o: O
+export const n: N = o`]);
+    (errors.length ? breaking : compatible).push(`Props mudou: ${norm(before)} \u2192 ${norm(after)}`);
+    return { breaking, compatible };
+  }
+  const changed = [];
+  for (const [name, f] of now) {
+    const was = old.get(name);
+    if (!was) (f.optional ? compatible : breaking).push(`${f.optional ? "prop opcional nova" : "prop obrigat\xF3ria nova"}: ${name}: ${f.type}`);
+    else {
+      if (was.optional && !f.optional) breaking.push(`${name} virou obrigat\xF3ria`);
+      if (!was.optional && f.optional) compatible.push(`${name} virou opcional`);
+      if (norm(was.type) !== norm(f.type)) changed.push([name, was, f]);
+    }
+  }
+  for (const [name, f] of old) if (!now.has(name)) breaking.push(`prop removida: ${name}: ${f.type} (o host que ainda passa ${name} n\xE3o compila)`);
+  const results = typeErrors(
+    ts,
+    changed.map(([, was, f]) => `type O = ${was.type}
+type N = ${f.type}
+declare const o: O
+export const n: N = o`)
+  );
+  changed.forEach(([name, was, f], i) => {
+    if (results[i].length) breaking.push(`tipo de ${name} mudou: ${norm(was.type)} \u2192 ${norm(f.type)} (${results[i][0].text})`);
+    else compatible.push(`tipo de ${name} aceita mais valores: ${norm(was.type)} \u2192 ${norm(f.type)}`);
+  });
+  return { breaking, compatible };
+}
+function tsLiteral(value) {
+  if (value === null || typeof value !== "object") return value === void 0 ? "undefined" : JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(tsLiteral).join(", ")}]`;
+  const v = value;
+  if (v.$fn === true) return "((..._a: any[]): any => undefined)";
+  if (typeof v.$date === "string") return `new Date(${JSON.stringify(v.$date)})`;
+  if (typeof v.$unknown === "string") return "(undefined as any)";
+  return `{ ${Object.entries(v).map(([k, x]) => `${JSON.stringify(k)}: ${tsLiteral(x)}`).join(", ")} }`;
+}
+var EXCESS = /* @__PURE__ */ new Set([2353, 2561]);
+function checkCaseProps(contract, props, ts) {
+  const failures = [];
+  const warnings = [];
+  const fields = propFields(ts, props);
+  const all = [];
+  contract.cases.forEach((c, i) => {
+    all.push({ at: `caso ${i + 1}`, value: c.props });
+    c.updates?.forEach((u, j) => all.push({ at: `caso ${i + 1}, update ${j + 1}`, value: u }));
+  });
+  const extra = (at, what) => warnings.push(`${at}: o host passa uma prop que o remote n\xE3o declara: ${what}`);
+  const values = all.map(({ at, value }) => {
+    if (!fields || !value || typeof value !== "object") return value;
+    const known = Object.entries(value).filter(([k]) => fields.has(k) || (extra(at, k), false));
+    return Object.fromEntries(known);
+  });
+  const results = typeErrors(
+    ts,
+    values.map((value) => `type Props = ${props}
+export const p: Props = ${tsLiteral(value)}`)
+  );
+  results.forEach((errors, i) => {
+    for (const e of errors) {
+      if (EXCESS.has(e.code)) extra(all[i].at, e.text);
+      else failures.push(`${all[i].at}: props n\xE3o batem com o Props local: ${e.text}`);
+    }
+  });
+  return { failures, warnings };
+}
+async function installDom(cwd) {
+  let mod;
+  try {
+    mod = await import(pathToFileURL(createRequire(join4(cwd, "package.json")).resolve("happy-dom")).href);
+  } catch {
+    try {
+      mod = await import("happy-dom");
+    } catch {
+      throw new Error("[vitral] vitral test precisa do happy-dom: npm i -D happy-dom");
+    }
+  }
+  const win = new mod.Window({ url: "http://localhost/" });
+  const g = globalThis;
+  const dom = /* @__PURE__ */ new Set(["Event", "EventTarget", "CustomEvent", "MessageEvent", "DOMException", "navigator", "window", "self"]);
+  const before = /* @__PURE__ */ new Map();
+  for (const key of Object.getOwnPropertyNames(win)) {
+    if (key in g && !dom.has(key)) continue;
+    const desc = Object.getOwnPropertyDescriptor(g, key);
+    if (desc && !desc.configurable) continue;
+    before.set(key, desc);
+    Object.defineProperty(g, key, { value: win[key], configurable: true, writable: true });
+  }
+  return async () => {
+    await win.happyDOM?.close?.();
+    for (const [key, desc] of before) {
+      if (desc) Object.defineProperty(g, key, desc);
+      else delete g[key];
+    }
+  };
+}
+function contractFiles(cwd, paths) {
+  return paths.flatMap((p) => {
+    const abs = resolve5(cwd, p);
+    if (!existsSync7(abs)) throw new Error(`[vitral] contrato n\xE3o encontrado: ${p}`);
+    return statSync2(abs).isDirectory() ? readdirSync3(abs).filter((f) => f.endsWith(".contract.json")).sort().map((f) => join4(abs, f)) : [abs];
+  });
+}
+function sourcesIn(dir) {
+  const out = [];
+  const walk = (d) => {
+    for (const f of readdirSync3(d, { withFileTypes: true })) {
+      if (f.name === "node_modules") continue;
+      const p = join4(d, f.name);
+      if (f.isDirectory()) walk(p);
+      else if (/\.[cm]?js$/.test(f.name)) out.push(readFileSync7(p, "utf8"));
+    }
+  };
+  walk(dir);
+  return out;
+}
+function publishedTypes(since, cwd) {
+  if (/^https?:\/\//.test(since)) {
+    if (since.endsWith(".d.ts")) return since;
+    return new URL("vitral.d.ts", since.endsWith(".json") || since.endsWith("/") ? since : since + "/").href;
+  }
+  const abs = resolve5(cwd, since);
+  return existsSync7(abs) && statSync2(abs).isDirectory() ? join4(abs, "vitral.d.ts") : abs;
+}
+async function readText(where, get2) {
+  if (!/^https?:\/\//.test(where)) return readFileSync7(where, "utf8");
+  const res = await get2(where);
+  if (!res.ok) throw new Error(`HTTP ${res.status} em ${where}`);
+  return res.text();
+}
+async function test(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const log = options.log ?? console.log;
+  const get2 = options.fetch ?? fetch;
+  const dir = resolve5(cwd, options.dir ?? "dist");
+  if (!options.contracts?.length && !options.since) throw new Error("[vitral] passe --contract arquivo e/ou --since url. Veja `vitral --help`.");
+  const localFile = resolve5(cwd, options.types ?? join4(dir, "vitral.d.ts"));
+  const local = existsSync7(localFile) ? parseProps(readFileSync7(localFile, "utf8")) : null;
+  let ts;
+  const typescript = async () => ts === void 0 ? ts = await loadTs(cwd) : ts;
+  let failures = 0;
+  if (options.since) {
+    const where = publishedTypes(options.since, cwd);
+    if (!local) throw new Error(`[vitral] sem Props local em ${localFile}. Rode o build com o plugin, ou passe --types.`);
+    const before = parseProps(await readText(where, get2));
+    if (!before) throw new Error(`[vitral] ${where} sem "export type Props".`);
+    const diff2 = diffProps(before, local, await typescript());
+    for (const c of diff2.breaking) log(`\u2717 quebra: ${c}`);
+    for (const c of diff2.compatible) log(`\u2713 compat\xEDvel: ${c}`);
+    log(diff2.breaking.length ? `[vitral] ${diff2.breaking.length} mudan\xE7a(s) nas props que quebram o host (desde ${where}).` : `[vitral] props compat\xEDveis com ${where}.`);
+    failures += diff2.breaking.length;
+  }
+  if (options.contracts?.length) {
+    const files2 = contractFiles(cwd, options.contracts);
+    let entry = options.entry && resolve5(cwd, options.entry);
+    if (!entry) {
+      const manifest = join4(dir, "vitral.json");
+      if (!existsSync7(manifest)) throw new Error(`[vitral] ${manifest} n\xE3o existe. Rode o build ou passe --entry.`);
+      entry = resolve5(dir, JSON.parse(readFileSync7(manifest, "utf8")).entry);
+    }
+    const close = typeof document === "undefined" ? await installDom(cwd) : void 0;
+    try {
+      const mod = await import(pathToFileURL(entry).href);
+      const sources3 = sourcesIn(dirname4(entry));
+      const tsApi = local ? await typescript() : null;
+      if (!local) log(`[vitral] sem Props local em ${localFile}: as props gravadas n\xE3o foram conferidas pelo tipo.`);
+      else if (!tsApi) log("[vitral] sem TypeScript no projeto: as props gravadas n\xE3o foram conferidas pelo tipo.");
+      for (const file of files2) {
+        const contract = JSON.parse(readFileSync7(file, "utf8"));
+        const result = await verify(contract, mod, { sources: sources3 });
+        if (local && tsApi) {
+          const typed = checkCaseProps(contract, local, tsApi);
+          result.failures.push(...typed.failures);
+          result.warnings.push(...typed.warnings);
+        }
+        const who = `${contract.remote}${contract.host ? ` (host ${contract.host})` : ""}`;
+        for (const w of result.warnings) log(`! ${who}: ${w}`);
+        for (const f of result.failures) log(`\u2717 ${who}: ${f}`);
+        log(result.failures.length ? `[vitral] ${file}: ${result.failures.length} falha(s) em ${result.cases} caso(s).` : `[vitral] ${file}: ${result.cases} caso(s) passaram.`);
+        failures += result.failures.length;
+      }
+    } finally {
+      await close?.();
+    }
+  }
+  return failures;
+}
+
 // src/cli.ts
 var AJUDA = `Uso:
   vitral types [remotes.json | nome=url ...] [--base url] [--out arquivo] [--check]
@@ -1160,6 +1503,9 @@ var AJUDA = `Uso:
                 [--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]
+  vitral test [--contract arquivo|pasta ...] [--since url|arquivo] [--dir dist] [--entry arquivo]
+              [--types vitral.d.ts]
+  vitral dict <dist> --from <dist-anterior> [--from ...] [--level n] [--no-dcb]
 
   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
@@ -1177,7 +1523,16 @@ var AJUDA = `Uso:
             --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.`;
+            canary; --percent vai de 0 a 100.
+  test      No CI do remote. --contract monta o build em happy-dom com cada
+            caso gravado pelo host (record() de vitral/testing) e falha se o
+            mount quebrar, se um evento que o host escuta sumir ou se as props
+            gravadas n\xE3o baterem com o Props local. --since compara o Props
+            do vitral.d.ts publicado com o local e falha nas mudan\xE7as que
+            quebram o host.
+  dict      Pr\xE9-comprime cada arquivo do dist com a vers\xE3o anterior dele
+            como dicion\xE1rio (.dcz e, com o bin\xE1rio brotli, .dcb) e grava
+            vitral-dict.json para o middleware vitral/dict.`;
 var falhou = (err) => {
   console.error(err.message);
   process.exitCode = 1;
@@ -1189,7 +1544,7 @@ function bool(args2, name) {
 }
 function version() {
   try {
-    return createRequire(import.meta.url)("../package.json").version;
+    return createRequire2(import.meta.url)("../package.json").version;
   } catch {
     return "0.0.0";
   }
@@ -1247,6 +1602,21 @@ if (command === "types") {
   } catch (err) {
     falhou(err);
   }
+} else if (command === "test") {
+  const contracts = [];
+  for (let c = flag(args, "--contract"); c !== void 0; c = flag(args, "--contract")) contracts.push(c);
+  finish(test({ contracts, since: flag(args, "--since"), dir: flag(args, "--dir"), entry: flag(args, "--entry"), types: flag(args, "--types") }));
+} else if (command === "dict" && args.length) {
+  const from = [];
+  for (let f = flag(args, "--from"); f !== void 0; f = flag(args, "--from")) from.push(f);
+  const level = flag(args, "--level");
+  const noDcb = bool(args, "--no-dcb");
+  try {
+    if (!from.length) throw new Error("[vitral] dict precisa de --from <dist-anterior>");
+    dict({ dist: args[0], from, level: level === void 0 ? void 0 : Number(level), brotli: noDcb ? false : void 0 });
+  } catch (err) {
+    falhou(err);
+  }
 } else {
   console.log(AJUDA);
   process.exitCode = command && command !== "--help" ? 1 : 0;