vitral 0.3.0 → 0.5.0

package/dist/{chunk-I3VSKSAZ.js → chunk-KZBH5MPD.js}

@@ -3,20 +3,21 @@ import {
   loadFile,
   registerSrc,
   resolveEntry
-} from "./chunk-TD4S3IHA.js";
+} from "./chunk-5JNV45BB.js";
 import {
   injectStyles
-} from "./chunk-ZAC6QQI6.js";
+} from "./chunk-KU6HF2EW.js";
 import {
   metric
-} from "./chunk-GNHCZRQP.js";
+} from "./chunk-TW7KYJQ6.js";
 import {
   RemoteError,
+  ctxHooks,
   fail,
   isRemoteError,
   mounted,
   report
-} from "./chunk-AKNNHQ2H.js";
+} from "./chunk-463H6B56.js";
 import {
   protocol
 } from "./chunk-GNPFWISJ.js";
@@ -47,9 +48,6 @@ function scopedEvents() {
   };
 }
 
-// src/core/hooks.ts
-var ctxHooks = {};
-
 // src/core/navigate.ts
 function navigate(url, options = {}) {
   const target = new URL(url, location.href);
@@ -121,7 +119,7 @@ var noop = () => {
 async function checkUpdates() {
   const p = protocol();
   const found = [];
-  const { splitName } = await import("./expose-JUOUN5N5.js");
+  const { splitName } = await import("./expose-IAKYHJXF.js");
   const remotes = /* @__PURE__ */ new Map();
   for (const name of live.keys()) {
     const root = splitName(name)[0];
@@ -165,27 +163,26 @@ function setFrameMounter(mounter) {
 async function mountOnce(target, name, props, options) {
   const p = protocol();
   await p.pending();
-  if ((options.isolate ?? registered(name)?.isolate ?? p.settings().isolate) === "iframe") {
-    if (!frames) throw report(new RemoteError("MOUNT_FAILED", name, 'isolate="iframe" precisa de enableIframe(), de vitral/iframe'));
-    return frames(target, name, props, options).catch(fail);
-  }
-  const { module: mod, ...resolved } = await load(name, options.isolate, options.priority);
+  const isolate = options.isolate ?? registered(name)?.isolate ?? p.settings().isolate;
+  if (isolate === "iframe") return (frames ?? (await import("./reframe-LQL4DZYP.js")).noFrames)(target, name, props, options).catch(fail);
+  const { module: mod, ...resolved } = await (isolate == "reframe" ? (await import("./reframe-LQL4DZYP.js")).load : load)(name, isolate, options.priority);
   const untrack = track(name, resolved);
-  const isolate = options.isolate ?? resolved.isolate ?? protocol().settings().isolate;
+  ctxHooks.watch?.(name);
   const label = resolved.name ?? name;
-  let shadowRoot = null;
-  const el = document.createElement("div");
-  el.setAttribute("data-vitral-root", label);
-  if (resolved.scope) el.setAttribute("data-vitral-scope", resolved.scope);
-  el.style.display = "contents";
-  if (isolate === "shadow") {
-    shadowRoot = target.shadowRoot ?? target.attachShadow({ mode: "open" });
-    shadowRoot.appendChild(el);
-  } else {
-    target.appendChild(el);
-  }
+  const make = (options2) => {
+    const el2 = document.createElement("div", options2);
+    el2.setAttribute("data-vitral-root", label);
+    if (resolved.scope) el2.setAttribute("data-vitral-scope", resolved.scope);
+    el2.style.display = "contents";
+    return el2;
+  };
   let t = performance.now();
-  const [release, portal = document.body] = await injectStyles(resolved, shadowRoot, el, options.styles);
+  const [release, portal = document.body, shadowRoot = null, registry = customElements, el = target.appendChild(make())] = await injectStyles(
+    resolved,
+    isolate > "q" && target,
+    make,
+    options.styles
+  );
   metric(name, "css", t);
   t = performance.now();
   const scoped = scopedEvents();
@@ -196,13 +193,14 @@ async function mountOnce(target, name, props, options) {
     events: scoped.bus,
     shadowRoot,
     portalContainer: portal,
+    customElements: registry,
     reportError(e) {
       const err = report(isRemoteError(e) ? e : new RemoteError("RENDER_FAILED", label, String(e?.message ?? e), e), resolved);
       if (options.onError) options.onError(err);
       else console.error(err);
     },
     navigate,
-    protocol: protocol().protocol,
+    protocol: p.protocol,
     onActivate: on("vitral:activate"),
     onDeactivate: on("vitral:deactivate")
   };
@@ -610,13 +608,17 @@ function serializeShared(values) {
 
 export {
   events,
+  scopedEvents,
   navigate,
   track,
   refresh,
+  refreshable,
   checkUpdates,
   watchUpdates,
   mountRemote,
   setFrameMounter,
+  mountOnce,
+  registered,
   createSlot,
   defineRemote,
   html,

package/dist/chunk-NZEQGRBL.js

@@ -0,0 +1,93 @@
+// src/dict.ts
+var VARY = "Accept-Encoding, Available-Dictionary";
+var HASH = /-[\w-]{8}(\.[a-z]+)$/;
+var ESPECIAIS = /[\\+*?:{}()]/g;
+function dictMatch(pathname) {
+  const i = pathname.lastIndexOf("/") + 1;
+  const dir = pathname.slice(0, i).replace(ESPECIAIS, "\\$&");
+  const name = pathname.slice(i);
+  const m = HASH.exec(name);
+  if (!m) return dir + name.replace(ESPECIAIS, "\\$&");
+  return dir + name.slice(0, m.index).replace(ESPECIAIS, "\\$&") + "-*" + m[1];
+}
+function accepted(header) {
+  const out = /* @__PURE__ */ new Set();
+  for (const part of (header ?? "").split(",")) {
+    const [name, ...params] = part.trim().toLowerCase().split(";");
+    if (!name || params.some((p) => /^\s*q\s*=\s*0(\.0*)?\s*$/.test(p))) continue;
+    out.add(name.trim());
+  }
+  return out;
+}
+function createDict(o) {
+  const base = (o.base ?? "/").replace(/\/?$/, "/");
+  const cacheControl = o.cacheControl ?? "public, max-age=31536000, immutable";
+  const lookup = (pathname) => {
+    if (!pathname.startsWith(base)) return void 0;
+    let rel;
+    try {
+      rel = decodeURIComponent(pathname.slice(base.length));
+    } catch {
+      return void 0;
+    }
+    return Object.prototype.hasOwnProperty.call(o.index.files, rel) ? o.index.files[rel] : void 0;
+  };
+  const headers = (pathname) => lookup(pathname) ? { "Use-As-Dictionary": `match="${dictMatch(pathname)}"`, Vary: VARY } : void 0;
+  const choose = (pathname, method, available, encoding) => {
+    if (method && method !== "GET" && method !== "HEAD") return void 0;
+    const file = lookup(pathname);
+    const hash = available?.trim();
+    if (!file || !hash || !Object.prototype.hasOwnProperty.call(file.deltas, hash)) return void 0;
+    const variant = file.deltas[hash];
+    const ok = accepted(encoding);
+    const enc = variant.dcz && ok.has("dcz") ? "dcz" : variant.dcb && ok.has("dcb") ? "dcb" : void 0;
+    if (!enc) return void 0;
+    return {
+      path: variant[enc],
+      head: {
+        "Content-Type": file.type,
+        "Content-Encoding": enc,
+        "Cache-Control": cacheControl,
+        "Use-As-Dictionary": `match="${dictMatch(pathname)}"`,
+        Vary: VARY
+      }
+    };
+  };
+  return {
+    headers,
+    async fetch(request) {
+      const url = new URL(request.url);
+      const hit = choose(url.pathname, request.method, request.headers.get("available-dictionary"), request.headers.get("accept-encoding"));
+      if (!hit) return void 0;
+      const body = await o.read(hit.path);
+      if (body == null) return void 0;
+      const init = { headers: hit.head, encodeBody: "manual" };
+      return new Response(request.method === "HEAD" ? null : body, init);
+    },
+    node(req, res, next) {
+      const pathname = new URL(req.url ?? "/", "http://x").pathname;
+      const one = (v) => Array.isArray(v) ? v.join(",") : v;
+      const hit = choose(pathname, req.method, one(req.headers["available-dictionary"]), one(req.headers["accept-encoding"]));
+      if (!hit) {
+        const h = headers(pathname);
+        if (h) for (const [k, v] of Object.entries(h)) res.setHeader(k, v);
+        return next();
+      }
+      Promise.resolve(o.read(hit.path)).then(async (body) => {
+        if (body == null) {
+          const h = headers(pathname);
+          for (const [k, v] of Object.entries(h)) res.setHeader(k, v);
+          return next();
+        }
+        const bytes = typeof body === "string" || body instanceof Uint8Array ? body : new Uint8Array(await new Response(body).arrayBuffer());
+        res.writeHead(200, hit.head);
+        res.end(req.method === "HEAD" ? void 0 : bytes);
+      }).catch(next);
+    }
+  };
+}
+
+export {
+  dictMatch,
+  createDict
+};

package/dist/chunk-PY7P5BF4.js

@@ -0,0 +1,404 @@
+// src/vite/types.ts
+import { createRequire as createRequire2 } from "module";
+import { join as join2 } from "path";
+
+// src/vite/oxc.ts
+import { existsSync, readFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join, resolve } from "path";
+import { pathToFileURL } from "url";
+async function loadOxc(root) {
+  const req = createRequire(join(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(pathToFileURL(id()).href);
+      if (typeof mod.isolatedDeclarationSync === "function") return mod;
+    } catch {
+    }
+  }
+  return null;
+}
+var GLOBAL = /^(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 = readFileSync(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 (!GLOBAL.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 = resolve(dirname(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) => join(base, f))];
+  const file = candidates.find((f) => /\.[cm]?tsx?$/.test(f) && existsSync(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(join2(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)}`;
+  }
+};
+
+export {
+  typesFile,
+  loadTs,
+  extractProps
+};

package/dist/{chunk-GNHCZRQP.js → chunk-TW7KYJQ6.js}

@@ -1,7 +1,7 @@
 import {
   RemoteError,
   isRemoteError
-} from "./chunk-AKNNHQ2H.js";
+} from "./chunk-463H6B56.js";
 import {
   protocol
 } from "./chunk-GNPFWISJ.js";

package/dist/{chunk-AH7KNMBW.js → chunk-UYOPJ4XQ.js}

@@ -1,6 +1,6 @@
 import {
   RemoteError
-} from "./chunk-AKNNHQ2H.js";
+} from "./chunk-463H6B56.js";
 
 // src/core/integrity.ts
 var clean = (b64) => b64.replace(/-/g, "+").replace(/_/g, "/").replace(/=/g, "");