vitral 0.4.0 → 0.5.0

package/dist/vite.js

@@ -1,7 +1,12 @@
+import {
+  extractProps,
+  typesFile
+} from "./chunk-PY7P5BF4.js";
+
 // src/vite.ts
 import { createHash as createHash3 } from "crypto";
-import { readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join6, resolve as resolve5 } from "path";
+import { readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4, resolve as resolve4 } from "path";
 
 // src/vite-exposes.ts
 import { resolve } from "path";
@@ -619,405 +624,6 @@ function findEntry(root) {
   }
 }
 
-// src/vite/types.ts
-import { createRequire as createRequire2 } from "module";
-import { join as join5 } from "path";
-
-// src/vite/oxc.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { createRequire } from "module";
-import { dirname as dirname3, join as join4, resolve as resolve4 } from "path";
-import { pathToFileURL as pathToFileURL2 } from "url";
-async function loadOxc(root) {
-  const req = createRequire(join4(root, "package.json"));
-  const ids = [() => req.resolve("oxc-transform"), () => createRequire(req.resolve("vite/package.json")).resolve("rolldown/experimental")];
-  for (const id of ids) {
-    try {
-      const mod = await import(pathToFileURL2(id()).href);
-      if (typeof mod.isolatedDeclarationSync === "function") return mod;
-    } catch {
-    }
-  }
-  return null;
-}
-var GLOBAL3 = /^(Date|RegExp|Error|Map|Set|WeakMap|WeakSet|Promise|PromiseLike|Record|Partial|Required|Readonly|Pick|Omit|URL|URLSearchParams|Blob|File|FormData|Headers|AbortSignal|EventTarget|Node|Element|Document|DocumentFragment|ShadowRoot|Window|(HTML|SVG)\w*Element|\w*Event)$/;
-var IDENT = /^[A-Za-z_$][\w$]*$/;
-var Unsupported = class extends Error {
-};
-var unsupported = () => {
-  throw new Unsupported();
-};
-function propsFromOxc(ts, oxc, file) {
-  try {
-    const reader = new Reader(ts, oxc);
-    const scope = reader.scope(file);
-    const props = reader.defaultProps(scope);
-    return props ? reader.print(props.node, props.scope, 0, { top: true }) : "Record<string, unknown>";
-  } catch {
-    return null;
-  }
-}
-var Reader = class {
-  constructor(ts, oxc) {
-    this.ts = ts;
-    this.oxc = oxc;
-    this.scopes = /* @__PURE__ */ new Map();
-    this.seen = /* @__PURE__ */ new Set();
-  }
-  /** Declarações de um arquivo: `.d.ts` como está, o resto pelo Oxc. */
-  scope(file) {
-    const cached = this.scopes.get(file);
-    if (cached) return cached;
-    const { ts } = this;
-    let code = readFileSync4(file, "utf8");
-    if (!/\.d\.[cm]?ts$/.test(file)) {
-      const out = this.oxc.isolatedDeclarationSync(file, code, {});
-      if (out.errors.length) unsupported();
-      code = out.code;
-    }
-    const source = ts.createSourceFile(file + ".d.ts", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-    const scope = { file, types: /* @__PURE__ */ new Map(), values: /* @__PURE__ */ new Map(), imports: /* @__PURE__ */ new Map() };
-    const isDefault = (n) => ts.canHaveModifiers(n) && !!ts.getModifiers(n)?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
-    let defaultName;
-    for (const st of source.statements) {
-      if (ts.isInterfaceDeclaration(st) || ts.isTypeAliasDeclaration(st)) {
-        if (scope.types.has(st.name.text)) unsupported();
-        scope.types.set(st.name.text, st);
-      } else if (ts.isImportDeclaration(st) && ts.isStringLiteral(st.moduleSpecifier)) {
-        const from = st.moduleSpecifier.text;
-        const clause = st.importClause;
-        if (clause?.name) scope.imports.set(clause.name.text, { from, name: "default" });
-        const bindings = clause?.namedBindings;
-        if (bindings && ts.isNamespaceImport(bindings)) scope.imports.set(bindings.name.text, { from, name: "*" });
-        if (bindings && ts.isNamedImports(bindings)) for (const el of bindings.elements) scope.imports.set(el.name.text, { from, name: (el.propertyName ?? el.name).text });
-      } else if (ts.isFunctionDeclaration(st) || ts.isClassDeclaration(st)) {
-        if (isDefault(st)) scope.default ??= st;
-        else if (st.name && !scope.values.has(st.name.text)) scope.values.set(st.name.text, st);
-      } else if (ts.isVariableStatement(st)) {
-        for (const d of st.declarationList.declarations) if (ts.isIdentifier(d.name)) scope.values.set(d.name.text, d);
-      } else if (ts.isExportAssignment(st) && !st.isExportEquals) {
-        defaultName = ts.isIdentifier(st.expression) ? st.expression.text : unsupported();
-      } else if (ts.isExportDeclaration(st) && !st.moduleSpecifier && st.exportClause && ts.isNamedExports(st.exportClause)) {
-        const el = st.exportClause.elements.find((e) => e.name.text === "default");
-        if (el) defaultName = (el.propertyName ?? el.name).text;
-      }
-    }
-    if (defaultName) scope.default = scope.values.get(defaultName);
-    this.scopes.set(file, scope);
-    return scope;
-  }
-  /** `mount(el, props)`, componente-função `(props)` ou classe com `props`. `undefined`: sem props. */
-  defaultProps(scope) {
-    const { ts } = this;
-    const node = scope.default ?? unsupported();
-    const param = (params, i) => {
-      const p = params[i];
-      return p && { node: p.type ?? unsupported(), scope };
-    };
-    if (ts.isFunctionDeclaration(node)) return param(node.parameters, 0);
-    if (ts.isClassDeclaration(node)) {
-      if (node.heritageClauses?.length) unsupported();
-      const props = node.members.find((m) => ts.isPropertyDeclaration(m) && m.name.getText() === "props");
-      return props && { node: props.type ?? unsupported(), scope };
-    }
-    if (ts.isVariableDeclaration(node)) return this.propsOfType(node.type ?? unsupported(), scope);
-    return unsupported();
-  }
-  propsOfType(node, scope) {
-    const { ts } = this;
-    const param = (params, i, at2) => {
-      const p = params[i];
-      return p && { node: p.type ?? unsupported(), scope: at2 };
-    };
-    if (ts.isParenthesizedTypeNode(node)) return this.propsOfType(node.type, scope);
-    if (ts.isFunctionTypeNode(node)) return param(node.parameters, 0, scope);
-    let members;
-    let at = scope;
-    if (ts.isTypeLiteralNode(node)) members = node.members;
-    else if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && !node.typeArguments) {
-      const found = this.lookup(node.typeName.text, scope);
-      if (!found || found === "package" || found.decl.typeParameters) return unsupported();
-      if (ts.isTypeAliasDeclaration(found.decl)) return this.propsOfType(found.decl.type, found.scope);
-      if (found.decl.heritageClauses?.length) unsupported();
-      members = found.decl.members;
-      at = found.scope;
-    } else return unsupported();
-    const mount = members.find((m) => m.name?.getText() === "mount");
-    if (mount) {
-      if (ts.isMethodSignature(mount)) return param(mount.parameters, 1, at);
-      if (ts.isPropertySignature(mount) && mount.type) return this.mountProps(mount.type, at);
-      return unsupported();
-    }
-    const call = members.find(ts.isCallSignatureDeclaration);
-    if (call) return param(call.parameters, 0, at);
-    if (members.some(ts.isConstructSignatureDeclaration)) unsupported();
-    return void 0;
-  }
-  mountProps(node, scope) {
-    const { ts } = this;
-    if (ts.isParenthesizedTypeNode(node)) return this.mountProps(node.type, scope);
-    if (!ts.isFunctionTypeNode(node)) return unsupported();
-    const p = node.parameters[1];
-    return p && { node: p.type ?? unsupported(), scope };
-  }
-  /** Acha um tipo pelo nome: no arquivo, num import relativo ou num pacote. */
-  lookup(name, scope) {
-    const decl = scope.types.get(name);
-    if (decl) return { decl, scope };
-    const imp = scope.imports.get(name);
-    if (!imp) return void 0;
-    if (!imp.from.startsWith(".")) return "package";
-    if (imp.name === "default" || imp.name === "*") return unsupported();
-    const found = this.lookup(imp.name, this.scope(resolveFile(scope.file, imp.from)));
-    return found ?? unsupported();
-  }
-  print(node, scope, depth, opts = {}) {
-    const { ts } = this;
-    const K = ts.SyntaxKind;
-    switch (node.kind) {
-      case K.AnyKeyword:
-      case K.UnknownKeyword:
-        return "unknown";
-      case K.StringKeyword:
-      case K.NumberKeyword:
-      case K.BooleanKeyword:
-      case K.BigIntKeyword:
-      case K.SymbolKeyword:
-      case K.UndefinedKeyword:
-      case K.VoidKeyword:
-      case K.NeverKeyword:
-        return node.getText();
-    }
-    if (ts.isLiteralTypeNode(node)) {
-      const lit = node.literal;
-      if (ts.isStringLiteral(lit)) return JSON.stringify(lit.text);
-      if (lit.kind === K.NullKeyword || lit.kind === K.TrueKeyword || lit.kind === K.FalseKeyword || ts.isNumericLiteral(lit) || ts.isPrefixUnaryExpression(lit)) return lit.getText();
-      return unsupported();
-    }
-    if (ts.isParenthesizedTypeNode(node)) return this.print(node.type, scope, depth, opts);
-    if (ts.isUnionTypeNode(node)) {
-      const types = opts.nonNull ? node.types.filter((t) => t.kind !== K.UndefinedKeyword && !(ts.isLiteralTypeNode(t) && t.literal.kind === K.NullKeyword)) : node.types;
-      const parts = [...new Set(types.map((t) => this.print(t, scope, depth)))];
-      if (parts.includes("true") && parts.includes("false")) parts.splice(parts.indexOf("true"), 1, "boolean"), parts.splice(parts.indexOf("false"), 1);
-      return parts.join(" | ");
-    }
-    if (ts.isIntersectionTypeNode(node)) {
-      return node.types.map((t) => {
-        const s = this.print(t, scope, depth);
-        return ts.isUnionTypeNode(t) ? `(${s})` : s;
-      }).join(" & ");
-    }
-    if (depth > 6) return "unknown";
-    if (ts.isArrayTypeNode(node)) return `Array<${this.print(node.elementType, scope, depth + 1)}>`;
-    if (ts.isTypeOperatorNode(node) && node.operator === K.ReadonlyKeyword && (ts.isArrayTypeNode(node.type) || ts.isTupleTypeNode(node.type))) return this.print(node.type, scope, depth);
-    if (ts.isTupleTypeNode(node)) {
-      if (node.elements.some((e) => ts.isNamedTupleMember(e) || ts.isOptionalTypeNode(e) || ts.isRestTypeNode(e))) unsupported();
-      return `[${node.elements.map((e) => this.print(e, scope, depth + 1)).join(", ")}]`;
-    }
-    if (ts.isTypeLiteralNode(node)) return this.object(node.members, scope, depth, !!opts.top);
-    if (ts.isFunctionTypeNode(node)) return this.signature(node, scope, depth);
-    if (ts.isTypeReferenceNode(node)) return this.reference(node, scope, depth, opts);
-    return unsupported();
-  }
-  reference(node, scope, depth, opts) {
-    const { ts } = this;
-    if (!ts.isIdentifier(node.typeName)) return unsupported();
-    const name = node.typeName.text;
-    const args = node.typeArguments ?? [];
-    const found = this.lookup(name, scope);
-    if (found === "package") return "unknown";
-    if (found) {
-      if (args.length || found.decl.typeParameters) unsupported();
-      if (this.seen.has(found.decl)) return "unknown";
-      this.seen.add(found.decl);
-      try {
-        const decl = found.decl;
-        if (ts.isTypeAliasDeclaration(decl)) return this.print(decl.type, found.scope, depth, opts);
-        if (decl.heritageClauses?.length) unsupported();
-        return this.object(decl.members, found.scope, depth, !!opts.top);
-      } finally {
-        this.seen.delete(found.decl);
-      }
-    }
-    if ((name === "Array" || name === "ReadonlyArray") && args.length === 1) return `Array<${this.print(args[0], scope, depth + 1)}>`;
-    if (!GLOBAL3.test(name)) return unsupported();
-    return args.length ? `${name}<${args.map((t) => this.print(t, scope, depth + 1)).join(", ")}>` : name;
-  }
-  object(members, scope, depth, top) {
-    const { ts } = this;
-    const fields = [];
-    const calls = [];
-    let index;
-    for (const m of members) {
-      if (ts.isPropertySignature(m) || ts.isMethodSignature(m)) {
-        const name = ts.isIdentifier(m.name) || ts.isStringLiteral(m.name) || ts.isNumericLiteral(m.name) ? m.name.text : unsupported();
-        if (top && name === "vitral") continue;
-        const optional = m.questionToken ? "?" : "";
-        const key = IDENT.test(name) ? name : JSON.stringify(name);
-        const type = ts.isMethodSignature(m) ? this.signature(m, scope, depth + 1) : m.type ? this.print(m.type, scope, depth + 1, { nonNull: !!optional }) : "unknown";
-        fields.push(`${key}${optional}: ${type}`);
-      } else if (ts.isIndexSignatureDeclaration(m)) {
-        const key = m.parameters[0]?.type;
-        if (!key || key.kind !== ts.SyntaxKind.StringKeyword) unsupported();
-        index = `[key: string]: ${this.print(m.type, scope, depth + 1)}`;
-      } else if (ts.isCallSignatureDeclaration(m)) {
-        calls.push(this.signature(m, scope, depth));
-      } else unsupported();
-    }
-    if (calls.length && !fields.length) return calls[0];
-    if (index) fields.push(index);
-    for (const c of calls) fields.push(c.replace(" =>", ":"));
-    return fields.length ? `{ ${fields.join("; ")} }` : "{}";
-  }
-  signature(sig, scope, depth) {
-    const { ts } = this;
-    if (sig.typeParameters?.length || !sig.type) unsupported();
-    const params = sig.parameters.map((p, i) => {
-      if (p.dotDotDotToken || ts.isIdentifier(p.name) && p.name.text === "this") unsupported();
-      const name = ts.isIdentifier(p.name) && IDENT.test(p.name.text) ? p.name.text : `a${i}`;
-      const type = p.type ? this.print(p.type, scope, depth + 1) : "unknown";
-      return `${name}: ${p.questionToken || p.initializer ? `${type} | undefined` : type}`;
-    });
-    return `(${params.join(", ")}) => ${this.print(sig.type, scope, depth + 1)}`;
-  }
-};
-function resolveFile(from, spec) {
-  const base = resolve4(dirname3(from), spec);
-  const stem = base.replace(/\.[cm]?jsx?$/, "");
-  const candidates = [base, ...[".ts", ".tsx", ".mts", ".cts", ".d.ts"].map((ext) => stem + ext), ...["index.ts", "index.tsx", "index.d.ts"].map((f) => join4(base, f))];
-  const file = candidates.find((f) => /\.[cm]?tsx?$/.test(f) && existsSync4(f));
-  return file ?? unsupported();
-}
-
-// src/vite/types.ts
-function typesFile(name, props) {
-  return `// Props do remote ${JSON.stringify(name)}, geradas pelo vitral. N\xE3o edite.
-export type Props = ${props}
-`;
-}
-async function loadTs(root) {
-  const api = (ts) => typeof ts?.createProgram === "function" ? ts : null;
-  try {
-    const ts = api(createRequire2(join5(root, "package.json"))("typescript"));
-    if (ts) return ts;
-  } catch {
-  }
-  try {
-    return api((await import("typescript")).default);
-  } catch {
-    return null;
-  }
-}
-async function extractProps(root, file) {
-  if (!/\.[cm]?[jt]sx?$/.test(file)) return null;
-  const ts = await loadTs(root);
-  if (!ts) return null;
-  const oxc = /\.[cm]?tsx?$/.test(file) ? await loadOxc(root) : null;
-  const fast = oxc && propsFromOxc(ts, oxc, file);
-  if (fast) return fast;
-  const configPath = ts.findConfigFile(root, ts.sys.fileExists);
-  const base = configPath ? ts.parseJsonConfigFileContent(ts.readConfigFile(configPath, ts.sys.readFile).config, ts.sys, root).options : {};
-  const options = {
-    target: ts.ScriptTarget.ES2022,
-    module: ts.ModuleKind.ESNext,
-    moduleResolution: ts.ModuleResolutionKind.Bundler,
-    jsx: ts.JsxEmit.Preserve,
-    strict: true,
-    ...base,
-    allowJs: true,
-    skipLibCheck: true,
-    noEmit: true
-  };
-  const program = ts.createProgram([file], options);
-  const checker = program.getTypeChecker();
-  const source = program.getSourceFile(file);
-  const moduleSymbol = source && checker.getSymbolAtLocation(source);
-  let symbol = moduleSymbol && checker.getExportsOfModule(moduleSymbol).find((s) => s.escapedName === "default");
-  if (!source || !symbol) return null;
-  if (symbol.flags & ts.SymbolFlags.Alias) symbol = checker.getAliasedSymbol(symbol);
-  const type = checker.getTypeOfSymbolAtLocation(symbol, source);
-  const props = propsOf(checker, type, source);
-  return props ? new Printer(ts, checker, program).print(props, 0, true) : "Record<string, unknown>";
-}
-function propsOf(checker, type, at) {
-  const param = (t, i) => {
-    const p = t.getCallSignatures()[0]?.parameters[i];
-    return p && checker.getTypeOfSymbolAtLocation(p, at);
-  };
-  const mount = type.getProperty("mount");
-  if (mount) return param(checker.getTypeOfSymbolAtLocation(mount, at), 1);
-  if (type.getCallSignatures().length) return param(type, 0);
-  const ctor = type.getConstructSignatures()[0];
-  const props = ctor?.getReturnType().getProperty("props");
-  return props && checker.getTypeOfSymbolAtLocation(props, at);
-}
-var Printer = class {
-  constructor(ts, checker, program) {
-    this.ts = ts;
-    this.checker = checker;
-    this.program = program;
-    this.seen = /* @__PURE__ */ new Set();
-  }
-  /** Declarado na lib padrão (Date, Map…): vale em qualquer projeto pelo nome. */
-  fromLib(type) {
-    const decl = (type.aliasSymbol ?? type.getSymbol())?.declarations?.[0];
-    return !!decl && this.program.isSourceFileDefaultLibrary(decl.getSourceFile());
-  }
-  fromPackage(type) {
-    const decl = (type.aliasSymbol ?? type.getSymbol())?.declarations?.[0];
-    return !!decl && /[/\\]node_modules[/\\]/.test(decl.getSourceFile().fileName);
-  }
-  print(type, depth, top = false) {
-    const { ts, checker } = this;
-    const f = type.flags;
-    if (f & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) return "unknown";
-    if (f & (ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BooleanLike | ts.TypeFlags.BigIntLike | ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void | ts.TypeFlags.Never | ts.TypeFlags.ESSymbolLike)) {
-      return checker.typeToString(type);
-    }
-    if (type.isUnion()) {
-      const parts = [...new Set(type.types.map((t) => this.print(t, depth)))];
-      if (parts.includes("true") && parts.includes("false")) parts.splice(parts.indexOf("true"), 1, "boolean"), parts.splice(parts.indexOf("false"), 1);
-      return parts.join(" | ");
-    }
-    if (type.isIntersection()) return type.types.map((t) => this.wrap(t, depth)).join(" & ");
-    if (depth > 6 || this.seen.has(type)) return "unknown";
-    if (checker.isArrayType(type)) return `Array<${this.print(checker.getTypeArguments(type)[0], depth + 1)}>`;
-    if (checker.isTupleType(type)) return `[${checker.getTypeArguments(type).map((t) => this.print(t, depth + 1)).join(", ")}]`;
-    if (this.fromLib(type)) {
-      const args = type.aliasTypeArguments ?? (type.objectFlags & ts.ObjectFlags.Reference ? checker.getTypeArguments(type) : []);
-      const name = (type.aliasSymbol ?? type.getSymbol()).name;
-      return args.length ? `${name}<${args.map((t) => this.print(t, depth + 1)).join(", ")}>` : checker.typeToString(type);
-    }
-    if (this.fromPackage(type)) return "unknown";
-    this.seen.add(type);
-    try {
-      const calls = type.getCallSignatures();
-      const props = checker.getPropertiesOfType(type).filter((p) => !(top && p.name === "vitral"));
-      if (calls.length && !props.length) return this.signature(calls[0], depth);
-      const fields = props.map((p) => {
-        const optional = p.flags & ts.SymbolFlags.Optional ? "?" : "";
-        const key = /^[A-Za-z_$][\w$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
-        const t = checker.getTypeOfSymbol(p);
-        return `${key}${optional}: ${this.print(optional ? checker.getNonNullableType(t) : t, depth + 1)}`;
-      });
-      const index = type.getStringIndexType();
-      if (index) fields.push(`[key: string]: ${this.print(index, depth + 1)}`);
-      for (const c of calls) fields.push(this.signature(c, depth).replace(" =>", ":"));
-      return fields.length ? `{ ${fields.join("; ")} }` : "{}";
-    } finally {
-      this.seen.delete(type);
-    }
-  }
-  wrap(type, depth) {
-    const s = this.print(type, depth);
-    return type.isUnion() ? `(${s})` : s;
-  }
-  signature(sig, depth) {
-    const params = sig.parameters.map((p, i) => `${/^[A-Za-z_$][\w$]*$/.test(p.name) ? p.name : `a${i}`}: ${this.print(this.checker.getTypeOfSymbol(p), depth + 1)}`);
-    return `(${params.join(", ")}) => ${this.print(sig.getReturnType(), depth + 1)}`;
-  }
-};
-
 // src/vite/mcp-app.ts
 var MCP_APP_PROTOCOL = "2026-01-26";
 var MCP_APP_GLOBAL = "__vitral_remote__";
@@ -1229,7 +835,7 @@ function vitral(options = {}) {
   let entry = options.entry;
   let adapter = "element";
   let framework = "element";
-  const entryFile = () => resolve5(root, entry);
+  const entryFile = () => resolve4(root, entry);
   let serve = false;
   let shared = [];
   const dedupe = !!options.dedupe?.length;
@@ -1242,8 +848,8 @@ function vitral(options = {}) {
   const mcpApp = (files, js) => {
     const css = files.filter((f) => f.type === "asset" && f.fileName.endsWith(".css")).map((f) => f.fileName);
     const read = (file) => {
-      const text = readFileSync5(join6(outDir, file), "utf8");
-      rmSync2(join6(outDir, file));
+      const text = readFileSync4(join4(outDir, file), "utf8");
+      rmSync2(join4(outDir, file));
       return text;
     };
     const scope = options.scopeCss === false ? void 0 : scopeName();
@@ -1254,12 +860,12 @@ function vitral(options = {}) {
       code: read(js),
       css: css.map((f) => transformCss(read(f), options, scopeName()))
     });
-    writeFileSync2(join6(outDir, "mcp-app.html"), html);
+    writeFileSync2(join4(outDir, "mcp-app.html"), html);
   };
   return {
     name: "vitral",
     config(user, { mode, command }) {
-      entry ??= findEntry(resolve5(user.root ?? process.cwd()));
+      entry ??= findEntry(resolve4(user.root ?? process.cwd()));
       if (!entry) throw new Error("[vitral] n\xE3o achei a entrada do remote (src/remote.* ou src/App.*). Use vitral({ entry }).");
       const rolldown = "rolldownVersion" in this.meta;
       const dir = options.versionDir ? versionDir(user.root ?? process.cwd(), user.build?.outDir, options.version) : void 0;
@@ -1292,9 +898,9 @@ function vitral(options = {}) {
       framework = detectAdapter(c.plugins);
       adapter = options.adapter || framework;
       serve = c.command === "serve";
-      outDir = resolve5(c.root, c.build.outDir);
+      outDir = resolve4(c.root, c.build.outDir);
       try {
-        pkg = JSON.parse(readFileSync5(join6(root, "package.json"), "utf8"));
+        pkg = JSON.parse(readFileSync4(join4(root, "package.json"), "utf8"));
       } catch {
       }
     },
@@ -1327,8 +933,8 @@ function vitral(options = {}) {
         if (own != null) return own;
         const exposed = options.exposes ? loadExposes(id, root, entry, options.exposes, options.adapter === false ? void 0 : ENTRY_ID) : null;
         if (exposed != null) return exposed;
-        if (id === VIRTUAL_ENTRY) return entryCode(resolve5(root, entry), adapter, scopeName());
-        if (id === VIRTUAL_DEV_ENTRY) return devEntryCode(framework, options.adapter === false ? resolve5(root, entry) : void 0);
+        if (id === VIRTUAL_ENTRY) return entryCode(resolve4(root, entry), adapter, scopeName());
+        if (id === VIRTUAL_DEV_ENTRY) return devEntryCode(framework, options.adapter === false ? resolve4(root, entry) : void 0);
         return loadPreamble(id);
       }
     },
@@ -1348,13 +954,13 @@ function vitral(options = {}) {
       const emit = (file, text, kind = "") => {
         const hash = createHash3("sha256").update(text).digest("base64url").slice(0, 8);
         const name = file.replace(/\.css$/, `${kind}-${hash}.css`);
-        writeFileSync2(join6(outDir, name), text);
+        writeFileSync2(join4(outDir, name), text);
         return name;
       };
       const shadow = { css: [] };
       const css = files.filter((f) => f.type === "asset" && f.fileName.endsWith(".css")).map((f) => {
-        const from = join6(outDir, f.fileName);
-        const text = transformCss(readFileSync5(from, "utf8"), options, scopeName());
+        const from = join4(outDir, f.fileName);
+        const text = transformCss(readFileSync4(from, "utf8"), options, scopeName());
         const name = emit(f.fileName, text);
         if (name !== f.fileName) rmSync2(from);
         const split2 = splitShadowCss(text);
@@ -1364,7 +970,7 @@ function vitral(options = {}) {
         if (split2.rebase) shadow.rebase = true;
         return name;
       });
-      const code = readFileSync5(join6(outDir, entry2.fileName));
+      const code = readFileSync4(join4(outDir, entry2.fileName));
       manifest = {
         name: options.name ?? pkg.name ?? "remote",
         version: options.version ?? pkg.version,
@@ -1381,32 +987,32 @@ function vitral(options = {}) {
       if (!manifest) return;
       const done = withSplit(manifest, outDir, split, shared);
       if (options.sbom) {
-        const bom = createSbom({ root, name: done.name, version: done.version, files: modules, entry: readFileSync5(join6(outDir, done.entry)), tool: ownVersion() });
-        writeFileSync2(join6(outDir, SBOM_FILE), JSON.stringify(bom, null, 2) + "\n");
-        done.sbom = { file: SBOM_FILE, integrity: sri(join6(outDir, SBOM_FILE)) };
+        const bom = createSbom({ root, name: done.name, version: done.version, files: modules, entry: readFileSync4(join4(outDir, done.entry)), tool: ownVersion() });
+        writeFileSync2(join4(outDir, SBOM_FILE), JSON.stringify(bom, null, 2) + "\n");
+        done.sbom = { file: SBOM_FILE, integrity: sri(join4(outDir, SBOM_FILE)) };
       }
       manifest = split = void 0;
       modules = /* @__PURE__ */ new Set();
-      writeFileSync2(join6(outDir, "vitral.json"), JSON.stringify(done, null, 2) + "\n");
+      writeFileSync2(join4(outDir, "vitral.json"), JSON.stringify(done, null, 2) + "\n");
       const props = options.types === false ? null : await extractProps(root, entryFile());
-      if (props) writeFileSync2(join6(outDir, "vitral.d.ts"), typesFile(done.name, props));
+      if (props) writeFileSync2(join4(outDir, "vitral.d.ts"), typesFile(done.name, props));
     }
   };
 }
 function ownVersion() {
   try {
-    return JSON.parse(readFileSync5(new URL("../package.json", import.meta.url), "utf8")).version;
+    return JSON.parse(readFileSync4(new URL("../package.json", import.meta.url), "utf8")).version;
   } catch {
     return void 0;
   }
 }
 function versionDir(root, outDir = "dist", version) {
   try {
-    version ??= JSON.parse(readFileSync5(join6(resolve5(root), "package.json"), "utf8")).version;
+    version ??= JSON.parse(readFileSync4(join4(resolve4(root), "package.json"), "utf8")).version;
   } catch {
   }
   if (!version) throw new Error('[vitral] versionDir precisa de uma vers\xE3o: use vitral({ version }) ou "version" no package.json.');
-  return join6(outDir, version);
+  return join4(outDir, version);
 }
 function contractOf(version, groups2) {
   const contract = {

package/dist/vue.d.ts

@@ -1,7 +1,7 @@
 import * as vue from 'vue';
 import { PropType, App, ShallowRef, WritableComputedRef, ComputedRef, Component } from 'vue';
-import { P as Props, I as Isolation, R as RemoteContext, S as Shared, a as RemoteModule } from './types-CA2p9KHC.js';
-export { e as events } from './events-Dkpkw_Sv.js';
+import { P as Props, I as Isolation, R as RemoteContext, S as Shared, a as RemoteModule } from './types-DUtcF3HO.js';
+export { e as events } from './events-0rxFlWJJ.js';
 import { L as Loading, P as Prefetch } from './host-slot-Cz6EiGsB.js';
 import './errors-kjBv6IH_.js';
 

package/dist/vue.js

@@ -1,16 +1,16 @@
 import {
   hostSlot,
   timings
-} from "./chunk-W6322KGP.js";
+} from "./chunk-4Z77XNBR.js";
 import {
   defineRemote,
   events,
   memoSelect,
   same,
   shared
-} from "./chunk-WD4CDGDZ.js";
-import "./chunk-EMSB2NVX.js";
-import "./chunk-6EX5KYT5.js";
+} from "./chunk-KZBH5MPD.js";
+import "./chunk-5JNV45BB.js";
+import "./chunk-KU6HF2EW.js";
 import {
   absolute
 } from "./chunk-TW7KYJQ6.js";