@csszyx/unplugin 0.12.0 → 0.14.0

package/dist/shared/unplugin.DKcwO8O4.mjs

@@ -0,0 +1,490 @@
+import * as path from 'node:path';
+import { extractCrossModuleRegistryEntries } from '@csszyx/compiler';
+import * as fs from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+
+const WINDOWS_PATH_SEPARATOR = String.fromCodePoint(92);
+function normalizePathSeparators(value) {
+  return value.split(WINDOWS_PATH_SEPARATOR).join("/");
+}
+
+const TSCONFIG_CANDIDATES = ["tsconfig.json", "jsconfig.json", "tsconfig.app.json"];
+const MAX_EXTENDS_DEPTH = 8;
+function collectSpecifierAliases(rootDir, resolveAlias) {
+  return [...aliasesFromResolveConfig(rootDir, resolveAlias), ...aliasesFromTsconfig(rootDir)];
+}
+function aliasesFromResolveConfig(rootDir, raw) {
+  const aliases = [];
+  if (Array.isArray(raw)) {
+    for (const entry of raw) {
+      const find = entry.find;
+      const replacement = entry.replacement;
+      if (typeof find !== "string" || typeof replacement !== "string") continue;
+      aliases.push(makeAlias(rootDir, find, replacement));
+    }
+    return aliases;
+  }
+  if (raw === null || typeof raw !== "object") return aliases;
+  for (const [find, target] of Object.entries(raw)) {
+    for (const value of Array.isArray(target) ? target : [target]) {
+      if (typeof value !== "string") continue;
+      aliases.push(makeAlias(rootDir, find, value));
+    }
+  }
+  return aliases;
+}
+function makeAlias(rootDir, find, replacement) {
+  const exact = find.endsWith("$");
+  return {
+    find: exact ? find.slice(0, -1) : find,
+    replacement: absolute(rootDir, replacement),
+    exact
+  };
+}
+function aliasesFromTsconfig(rootDir) {
+  for (const candidate of TSCONFIG_CANDIDATES) {
+    const loaded = loadPathsConfig(path.join(rootDir, candidate), 0);
+    if (loaded === void 0) continue;
+    const aliases = pathsToAliases(loaded.base, loaded.paths);
+    if (aliases.length > 0) return aliases;
+  }
+  return [];
+}
+function loadPathsConfig(configPath, depth) {
+  if (depth > MAX_EXTENDS_DEPTH) return void 0;
+  let parsed;
+  try {
+    parsed = parseJsonc(fs.readFileSync(configPath, "utf-8"));
+  } catch {
+    return void 0;
+  }
+  const directory = path.dirname(configPath);
+  const compilerOptions = asRecord(parsed.compilerOptions);
+  const paths = asRecord(compilerOptions?.paths);
+  if (paths !== void 0) {
+    const baseUrl = compilerOptions?.baseUrl;
+    return {
+      base: typeof baseUrl === "string" ? absolute(directory, baseUrl) : absolute(directory, "."),
+      paths
+    };
+  }
+  const extended = parsed.extends;
+  if (typeof extended !== "string" || !extended.startsWith(".")) return void 0;
+  const resolved = path.resolve(directory, extended);
+  return loadPathsConfig(resolved, depth + 1) ?? loadPathsConfig(`${resolved}.json`, depth + 1);
+}
+function pathsToAliases(base, paths) {
+  return Object.entries(paths).flatMap(
+    ([pattern, targets]) => patternToAliases(base, pattern, targets)
+  );
+}
+function patternToAliases(base, pattern, targets) {
+  const wildcard = pattern.indexOf("*");
+  if (wildcard !== -1 && wildcard !== pattern.length - 1) return [];
+  const exact = wildcard === -1;
+  const find = exact ? pattern : pattern.slice(0, -1);
+  const declared = Array.isArray(targets) ? targets : [targets];
+  return declared.filter((target) => typeof target === "string").map((target) => ({
+    find,
+    replacement: absolute(base, target.endsWith("*") ? target.slice(0, -1) : target),
+    exact
+  }));
+}
+function aliasedSpecifierBases(specifier, aliases) {
+  const bases = [];
+  for (const alias of aliases) {
+    if (alias.exact) {
+      if (specifier === alias.find) bases.push(alias.replacement);
+      continue;
+    }
+    if (!specifier.startsWith(alias.find)) continue;
+    bases.push(normalizePathSeparators(alias.replacement + specifier.slice(alias.find.length)));
+  }
+  return bases;
+}
+function absolute(directory, target) {
+  const resolved = normalizePathSeparators(path.resolve(directory, target));
+  const declaredTrailingSlash = target.endsWith("/") || target.endsWith("\\");
+  return declaredTrailingSlash && !resolved.endsWith("/") ? `${resolved}/` : resolved;
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function parseJsonc(text) {
+  const parsed = JSON.parse(stripComments(text).replace(/,(\s*[}\]])/g, "$1"));
+  return asRecord(parsed) ?? {};
+}
+function stripComments(text) {
+  const out = [];
+  let index = 0;
+  while (index < text.length) {
+    const run = consumeString(text, index) ?? consumeComment(text, index);
+    if (run === void 0) {
+      out.push(text[index]);
+      index += 1;
+      continue;
+    }
+    out.push(run.keep);
+    index = run.next;
+  }
+  return out.join("");
+}
+function consumeString(text, start) {
+  if (text[start] !== '"') return void 0;
+  let index = start + 1;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === "\\") {
+      index += 2;
+      continue;
+    }
+    index += 1;
+    if (char === '"') break;
+  }
+  return { keep: text.slice(start, index), next: index };
+}
+function consumeComment(text, start) {
+  if (text[start] !== "/") return void 0;
+  if (text[start + 1] === "/") {
+    const end = text.indexOf("\n", start);
+    return { keep: "", next: end === -1 ? text.length : end };
+  }
+  if (text[start + 1] === "*") {
+    const end = text.indexOf("*/", start + 2);
+    return { keep: "", next: end === -1 ? text.length : end + 2 };
+  }
+  return void 0;
+}
+
+function mayExportSzvFactories(content) {
+  return content.includes("szv(") && content.includes("export");
+}
+function recordSzvRegistryFile(registry, filePath, content) {
+  const entries = mayExportSzvFactories(content) ? extractCrossModuleRegistryEntries(content, filePath) : [];
+  replaceEntriesOfKind(registry, filePath, "szv-config", entries);
+}
+function recordSzObjectRegistryFile(registry, filePath, content) {
+  replaceEntriesOfKind(
+    registry,
+    filePath,
+    "sz-object",
+    extractCrossModuleRegistryEntries(content, filePath)
+  );
+}
+function replaceEntriesOfKind(registry, filePath, kind, entries) {
+  const key = normalizePathSeparators(filePath);
+  const byName = emptyNameIndex();
+  for (const [name, recorded] of Object.entries(registry.get(key) ?? {})) {
+    if (recorded.kind !== kind) byName[name] = recorded;
+  }
+  for (const entry of entries) {
+    if (entry.kind === kind) byName[entry.exportName] = { kind, value: entry.value };
+  }
+  if (Object.keys(byName).length === 0) registry.delete(key);
+  else registry.set(key, byName);
+}
+function emptyNameIndex() {
+  return /* @__PURE__ */ Object.create(null);
+}
+const SPECIFIER_PROBES = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx"];
+const EMITTED_EXTENSION_SOURCES = [
+  [".js", [".ts", ".tsx"]],
+  [".jsx", [".tsx"]],
+  [".mjs", [".mts"]],
+  [".cjs", [".cts"]]
+];
+function resolveCrossModuleStaticsFor(registry, filename, source, aliases = []) {
+  if (registry.size === 0 || !source.includes("from")) return {};
+  const directory = path.dirname(filename);
+  const resolved = {};
+  const seen = /* @__PURE__ */ new Set();
+  for (const specifier of importedSpecifiersIn(source)) {
+    if (seen.has(specifier)) continue;
+    seen.add(specifier);
+    const entries = firstRegistryHit(registry, specifier, directory, aliases);
+    if (entries !== void 0) fileUnderSpecifier(resolved, specifier, entries);
+  }
+  return resolved;
+}
+function firstRegistryHit(registry, specifier, directory, aliases) {
+  for (const base of specifierBases(specifier, directory, aliases)) {
+    const entries = lookupRegistryKey(registry, base);
+    if (entries !== void 0) return entries;
+  }
+  return void 0;
+}
+function recordResolvedEntry(resolved, kind, specifier, name, value) {
+  if (specifier === "__proto__" || name === "__proto__") return;
+  const channel = kind === "szv-config" ? "szvConfigs" : "szObjects";
+  let bySpecifier = resolved[channel];
+  if (bySpecifier === void 0) {
+    bySpecifier = emptyNameIndex();
+    resolved[channel] = bySpecifier;
+  }
+  let byName = bySpecifier[specifier];
+  if (byName === void 0) {
+    byName = emptyNameIndex();
+    bySpecifier[specifier] = byName;
+  }
+  byName[name] = value;
+}
+function fileUnderSpecifier(resolved, specifier, entries) {
+  for (const [name, recorded] of Object.entries(entries)) {
+    recordResolvedEntry(resolved, recorded.kind, specifier, name, recorded.value);
+  }
+}
+function importedSpecifiersIn(source) {
+  if (!source.includes("from")) return [];
+  return [...source.matchAll(/from\s*['"]([^'"]*)['"]/g)].map((match) => match[1]);
+}
+function specifierBases(specifier, directory, aliases) {
+  if (specifier.startsWith(".")) {
+    return [normalizePathSeparators(path.resolve(directory, specifier))];
+  }
+  return aliasedSpecifierBases(specifier, aliases);
+}
+function resolveProviderPath(seenPaths, base) {
+  return resolveProviderPathWith(base, (candidate) => seenPaths.has(candidate));
+}
+function resolveProviderPathWith(base, exists) {
+  return probeSpecifier(base, (candidate) => exists(candidate) ? candidate : void 0);
+}
+function probeSpecifier(base, lookup) {
+  for (const probe of SPECIFIER_PROBES) {
+    const found = lookup(`${base}${probe}`);
+    if (found !== void 0) return found;
+  }
+  for (const [emitted, sources] of EMITTED_EXTENSION_SOURCES) {
+    if (!base.endsWith(emitted)) continue;
+    const stem = base.slice(0, -emitted.length);
+    for (const extension of sources) {
+      const found = lookup(`${stem}${extension}`);
+      if (found !== void 0) return found;
+    }
+    break;
+  }
+  return void 0;
+}
+function lookupRegistryKey(registry, base) {
+  return probeSpecifier(base, (candidate) => registry.get(candidate));
+}
+
+function isReadableProviderFile(candidate) {
+  try {
+    return existsSync(candidate) && statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+}
+
+const CACHE_SCHEMA_VERSION = 17;
+function resolveTransformCacheDir(rootDir, cacheDir) {
+  return path.resolve(rootDir, cacheDir ?? ".csszyx/cache", "transform");
+}
+function createTransformCacheKey(input) {
+  const inputSha256 = createHash("sha256").update(input.source).digest("hex");
+  const globalVarAliases = normalizeGlobalVarAliasEntries(input.globalVarAliases);
+  const keyMaterial = [
+    `schema=${CACHE_SCHEMA_VERSION}`,
+    `plugin=${input.pluginVersion}`,
+    `compiler=${input.compilerVersion}`,
+    `native=${input.nativeIdentity ?? "none"}`,
+    `parser=${input.parserMode}`,
+    `producer=${input.producer}`,
+    `astBudget=${input.astBudget ?? "default"}`,
+    `mangleVars=${input.mangleVars === true}`,
+    `mangleVarHoistMaxDepth=${input.mangleVarHoistMaxDepth ?? "default"}`,
+    `globalVarAliases=${JSON.stringify(globalVarAliases)}`,
+    `crossModuleStatics=${input.crossModuleStatics ?? "none"}`,
+    `crossModuleSzObjects=${input.crossModuleSzObjects ?? "none"}`,
+    `filename=${input.filename}`,
+    `source=${inputSha256}`
+  ].join("\n");
+  return {
+    key: createHash("sha256").update(keyMaterial).digest("hex").slice(0, 16),
+    inputSha256
+  };
+}
+function readTransformCache(cacheRoot, input, precomputedKey) {
+  const { key, inputSha256 } = precomputedKey ?? createTransformCacheKey(input);
+  const globalVarAliases = normalizeGlobalVarAliasEntries(input.globalVarAliases);
+  const file = cacheEntryPath(cacheRoot, key);
+  let entry;
+  try {
+    entry = JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+  if (entry.version !== CACHE_SCHEMA_VERSION || entry.pluginVersion !== input.pluginVersion || entry.compilerVersion !== input.compilerVersion || entry.nativeIdentity !== (input.nativeIdentity ?? null) || entry.parserMode !== input.parserMode || entry.producer !== input.producer || entry.astBudget !== (input.astBudget ?? null) || entry.mangleVars !== (input.mangleVars === true) || entry.mangleVarHoistMaxDepth !== (input.mangleVarHoistMaxDepth ?? null) || !sameGlobalVarAliases(entry.globalVarAliases, globalVarAliases) || entry.filename !== input.filename || entry.inputSha256 !== inputSha256) {
+    return null;
+  }
+  return deserializeResult(entry.result);
+}
+function writeTransformCache(cacheRoot, input, result, precomputedKey) {
+  const { key, inputSha256 } = precomputedKey ?? createTransformCacheKey(input);
+  const globalVarAliases = normalizeGlobalVarAliasEntries(input.globalVarAliases);
+  const file = cacheEntryPath(cacheRoot, key);
+  const dir = path.dirname(file);
+  const tmp = path.join(dir, `.tmp-${process.pid}-${Date.now()}-${randomUUID()}.json`);
+  const entry = {
+    version: CACHE_SCHEMA_VERSION,
+    pluginVersion: input.pluginVersion,
+    compilerVersion: input.compilerVersion,
+    nativeIdentity: input.nativeIdentity ?? null,
+    parserMode: input.parserMode,
+    producer: input.producer,
+    astBudget: input.astBudget ?? null,
+    mangleVars: input.mangleVars === true,
+    mangleVarHoistMaxDepth: input.mangleVarHoistMaxDepth ?? null,
+    globalVarAliases,
+    filename: input.filename,
+    inputSha256,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    result: serializeResult(result)
+  };
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(tmp, JSON.stringify(entry), "utf8");
+    fs.renameSync(tmp, file);
+  } catch {
+    try {
+      fs.rmSync(tmp, { force: true });
+    } catch {
+    }
+  }
+}
+function evictOldTransformCacheEntries(cacheRoot, options) {
+  let deleted = 0;
+  const now = options.now ?? Date.now();
+  const survivors = [];
+  for (const file of listJsonFiles(cacheRoot)) {
+    try {
+      const entry = JSON.parse(fs.readFileSync(file, "utf8"));
+      const timestamp = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : 0;
+      if (!Number.isFinite(timestamp) || now - timestamp > options.maxAgeMs) {
+        fs.rmSync(file, { force: true });
+        deleted++;
+      } else {
+        survivors.push({ file, timestamp });
+      }
+    } catch {
+      fs.rmSync(file, { force: true });
+      deleted++;
+    }
+  }
+  const overflow = survivors.length - options.maxEntries ;
+  if (overflow > 0) {
+    survivors.sort((a, b) => a.timestamp - b.timestamp);
+    for (const survivor of survivors.slice(0, overflow)) {
+      fs.rmSync(survivor.file, { force: true });
+      deleted++;
+    }
+  }
+  return deleted;
+}
+function cacheEntryPath(cacheRoot, key) {
+  return path.join(cacheRoot, key.slice(0, 2), `${key.slice(2)}.json`);
+}
+function serializeResult(result) {
+  return {
+    code: result.code,
+    transformed: result.transformed,
+    usesRuntime: result.usesRuntime,
+    usesMerge: result.usesMerge,
+    usesSzcn: result.usesSzcn,
+    usesSzPart: result.usesSzPart,
+    usesSzvPick: result.usesSzvPick,
+    usesSzvPick1: result.usesSzvPick1,
+    szPartArgsProvable: result.szPartArgsProvable,
+    usesColorVar: result.usesColorVar,
+    usesSpacingVar: result.usesSpacingVar,
+    usesUnitVar: result.usesUnitVar,
+    usesBoolClass: result.usesBoolClass,
+    classes: [...result.classes],
+    rawClassNames: [...result.rawClassNames],
+    diagnostics: [...result.diagnostics],
+    recoveryTokens: [...result.recoveryTokens],
+    cssVariableMap: [...result.cssVariableMap ?? /* @__PURE__ */ new Map()]
+  };
+}
+function deserializeResult(result) {
+  return {
+    code: result.code,
+    transformed: result.transformed,
+    usesRuntime: result.usesRuntime,
+    usesMerge: result.usesMerge,
+    usesSzcn: result.usesSzcn,
+    usesSzPart: result.usesSzPart,
+    usesSzvPick: result.usesSzvPick,
+    usesSzvPick1: result.usesSzvPick1,
+    szPartArgsProvable: result.szPartArgsProvable,
+    usesColorVar: result.usesColorVar,
+    usesSpacingVar: result.usesSpacingVar,
+    usesUnitVar: result.usesUnitVar,
+    usesBoolClass: result.usesBoolClass,
+    classes: new Set(result.classes),
+    rawClassNames: new Set(result.rawClassNames),
+    diagnostics: [...result.diagnostics],
+    recoveryTokens: new Map(result.recoveryTokens),
+    cssVariableMap: new Map(result.cssVariableMap ?? [])
+  };
+}
+function normalizeGlobalVarAliasEntries(aliases) {
+  if (!aliases || aliases.length === 0) {
+    return [];
+  }
+  const normalized = /* @__PURE__ */ new Map();
+  for (const [original, alias] of aliases) {
+    if (typeof original === "string" && typeof alias === "string") {
+      normalized.set(original, alias);
+    }
+  }
+  return [...normalized].sort(([left], [right]) => left.localeCompare(right));
+}
+function sameGlobalVarAliases(left, right) {
+  if (!Array.isArray(left) || left.length !== right.length) {
+    return false;
+  }
+  for (let index = 0; index < left.length; index++) {
+    const leftEntry = left[index];
+    const rightEntry = right[index];
+    if (leftEntry?.[0] !== rightEntry?.[0] || leftEntry?.[1] !== rightEntry?.[1]) {
+      return false;
+    }
+  }
+  return true;
+}
+function listJsonFiles(dir) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...listJsonFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".json")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function evictMemoryCacheToBudget(cache, totalCodeChars, maxEntries, maxCodeChars) {
+  let total = totalCodeChars;
+  while (cache.size > maxEntries || total > maxCodeChars && cache.size > 1) {
+    const oldest = cache.keys().next().value;
+    if (oldest === void 0) {
+      break;
+    }
+    const evicted = cache.get(oldest);
+    cache.delete(oldest);
+    total -= evicted?.code.length ?? 0;
+  }
+  return total;
+}
+
+export { resolveProviderPathWith as a, recordResolvedEntry as b, collectSpecifierAliases as c, isReadableProviderFile as d, createTransformCacheKey as e, readTransformCache as f, recordSzvRegistryFile as g, recordSzObjectRegistryFile as h, importedSpecifiersIn as i, resolveCrossModuleStaticsFor as j, evictOldTransformCacheEntries as k, evictMemoryCacheToBudget as l, mayExportSzvFactories as m, normalizePathSeparators as n, resolveProviderPath as o, resolveTransformCacheDir as r, specifierBases as s, writeTransformCache as w };

package/dist/shared/{unplugin.DXgxFHzO.mjs → unplugin.DjRylBC_.mjs}

@@ -1,9 +1,73 @@
 import { readFileSync } from 'node:fs';
-import { ensureRustTransformAvailable, transformSourceCode, transformRust, transformOxc, transform } from '@csszyx/compiler';
-import { c as createTransformCacheKey, a as readTransformCache, w as writeTransformCache, n as normalizePathSeparators, b as babelFallbackReason } from './unplugin.CDqY7kmk.mjs';
+import * as path from 'node:path';
+import { extractCrossModuleRegistryEntries, ensureRustTransformAvailable, transformRust, transformWasm, transform } from '@csszyx/compiler';
+import { DEFAULT_IMPORTED_STATIC_SZ } from '@csszyx/types';
+import { c as collectSpecifierAliases, i as importedSpecifiersIn, s as specifierBases, a as resolveProviderPathWith, n as normalizePathSeparators, b as recordResolvedEntry, d as isReadableProviderFile, e as createTransformCacheKey, f as readTransformCache, w as writeTransformCache } from './unplugin.DKcwO8O4.mjs';
 import { createHash } from 'node:crypto';
 import { s as sortStrings } from './unplugin.B3XoSRB8.mjs';
 
+function resolveImportedStaticSz(value) {
+  return value ?? DEFAULT_IMPORTED_STATIC_SZ;
+}
+const aliasesByRoot = /* @__PURE__ */ new Map();
+function resolveNextCrossModule(input) {
+  const empty = { statics: {}, providers: [] };
+  if (!input.source.includes("from")) return empty;
+  let aliases = aliasesByRoot.get(input.root);
+  if (aliases === void 0) {
+    aliases = collectSpecifierAliases(input.root);
+    aliasesByRoot.set(input.root, aliases);
+  }
+  const directory = path.dirname(input.filename);
+  const statics = {};
+  const providers = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const specifier of importedSpecifiersIn(input.source)) {
+    if (seen.has(specifier)) continue;
+    seen.add(specifier);
+    for (const base of specifierBases(specifier, directory, aliases)) {
+      const provider = resolveProviderPathWith(base, isReadableProviderFile);
+      if (provider === void 0) continue;
+      providers.push(provider);
+      recordEntries(statics, specifier, readProviderEntries(provider), input);
+      break;
+    }
+  }
+  return { statics, providers };
+}
+function readProviderEntries(provider) {
+  try {
+    return extractCrossModuleRegistryEntries(readFileSync(provider, "utf8"), provider);
+  } catch {
+    return [];
+  }
+}
+function recordEntries(statics, specifier, entries, input) {
+  for (const entry of entries) {
+    if (entry.kind === "sz-object" && !resolveImportedStaticSz(input.importedStaticSz)) {
+      continue;
+    }
+    recordResolvedEntry(statics, entry.kind, specifier, entry.exportName, entry.value);
+  }
+}
+function withCrossModuleStatics(options, statics) {
+  if (statics.szvConfigs === void 0 && statics.szObjects === void 0) return options;
+  return {
+    ...options,
+    ...statics.szvConfigs === void 0 ? {} : { crossModuleStatics: statics.szvConfigs },
+    ...statics.szObjects === void 0 ? {} : { crossModuleSzObjects: statics.szObjects }
+  };
+}
+function configWithImportedStaticSz(config, importedStaticSz) {
+  return {
+    ...config,
+    importedStaticSz: resolveImportedStaticSz(importedStaticSz)
+  };
+}
+function normalizeProviderPaths(providers) {
+  return [...new Set(providers.map(normalizePathSeparators))];
+}
+
 function readPackageVersion(relativePackageJson, fromUrl) {
   try {
     const packageJson = JSON.parse(
@@ -126,34 +190,16 @@ function isRegexLiteralStart(emitted) {
 }
 function runNextSourceTransform(input, filename) {
   const compilerOptions = input.compilerOptions;
-  if (input.parserMode === "babel") {
-    return {
-      result: transformSourceCode(input.source, filename, compilerOptions),
-      producer: "babel"
-    };
-  }
   if (input.parserMode === "rust") {
     return {
       result: transformRust(input.source, filename, compilerOptions),
       producer: "rust"
     };
   }
-  try {
-    return {
-      result: transformOxc(input.source, filename, compilerOptions),
-      producer: "oxc"
-    };
-  } catch (error) {
-    if (input.allowBabelFallback === false) {
-      throw error;
-    }
-    const result = transformSourceCode(input.source, filename, compilerOptions);
-    const reason = babelFallbackReason(error);
-    result.diagnostics.push(
-      `[csszyx] oxc parser fell back to Babel for ${filename}: ${reason}`
-    );
-    return { result, producer: "babel-fallback" };
-  }
+  return {
+    result: transformWasm(input.source, filename, compilerOptions),
+    producer: "wasm"
+  };
 }
 function createNextSourceTransformCacheInput(input, filename, producer) {
   return {
@@ -167,6 +213,12 @@ function createNextSourceTransformCacheInput(input, filename, producer) {
     globalVarAliases: normalizeGlobalVarAliasesForCache(
       input.compilerOptions?.globalVarAliases
     ),
+    // The registry slice this file was compiled against is part of its
+    // identity. Without it an edited provider serves its importers the
+    // cached output built from the value it used to have — the one failure
+    // this lane refused to risk before it resolved anything at all.
+    crossModuleStatics: input.compilerOptions?.crossModuleStatics === void 0 ? void 0 : JSON.stringify(input.compilerOptions.crossModuleStatics),
+    crossModuleSzObjects: input.compilerOptions?.crossModuleSzObjects === void 0 ? void 0 : JSON.stringify(input.compilerOptions.crossModuleSzObjects),
     filename,
     source: input.source
   };
@@ -275,4 +327,4 @@ function collectTransformClasses(result, discoveredClasses) {
   }
 }
 
-export { createNextSafelistShardFromMetadata as a, collectNextTransformMetadata as c, readPackageVersion as r, transformNextSource as t };
+export { resolveNextCrossModule as a, collectNextTransformMetadata as b, configWithImportedStaticSz as c, createNextSafelistShardFromMetadata as d, normalizeProviderPaths as n, readPackageVersion as r, transformNextSource as t, withCrossModuleStatics as w };