@ecrindigital/facetpack 0.1.9 → 0.2.0

package/dist/index.cjs

@@ -33,9 +33,12 @@ __export(exports_src, {
   transform: () => transform,
   setTransformerOptions: () => setTransformerOptions,
   resolveSync: () => import_facetpack_native4.resolveSync,
+  resetStats: () => resetStats,
+  printStats: () => printStats,
   minifyCode: () => minifyCode,
   minify: () => minify,
   getStoredOptions: () => getStoredOptions,
+  getStats: () => getStats,
   getCacheStats: () => getCacheStats,
   createTransformer: () => createTransformer,
   createResolver: () => createResolver,
@@ -84,15 +87,277 @@ function getCacheStats() {
 
 // src/serializer.ts
 var import_facetpack_native = require("@ecrindigital/facetpack-native");
+
+// src/stats.ts
+var import_fs = require("fs");
+var import_os = require("os");
+var import_path = require("path");
+var ANSI = {
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  reset: "\x1B[0m"
+};
+var STATS_DIR = import_path.join(import_os.tmpdir(), "facetpack-stats");
+var STATS_FILE_PREFIX = "stats-";
+var LOCK_FILE = import_path.join(STATS_DIR, ".print-lock");
+var PRINT_DELAY = 1000;
+function getStatsFilePath() {
+  const workerId = process.env.METRO_WORKER_ID || process.pid.toString();
+  return import_path.join(STATS_DIR, `${STATS_FILE_PREFIX}${workerId}.json`);
+}
+function ensureStatsDir() {
+  if (!import_fs.existsSync(STATS_DIR)) {
+    import_fs.mkdirSync(STATS_DIR, { recursive: true });
+  }
+}
+function acquirePrintLock() {
+  try {
+    ensureStatsDir();
+    if (import_fs.existsSync(LOCK_FILE)) {
+      const lockTime = parseInt(import_fs.readFileSync(LOCK_FILE, "utf-8"), 10);
+      if (Date.now() - lockTime < 5000) {
+        return false;
+      }
+    }
+    import_fs.writeFileSync(LOCK_FILE, Date.now().toString());
+    return true;
+  } catch {
+    return false;
+  }
+}
+function releasePrintLock() {
+  try {
+    if (import_fs.existsSync(LOCK_FILE)) {
+      import_fs.unlinkSync(LOCK_FILE);
+    }
+  } catch {}
+}
+
+class GlobalStats {
+  stats = this.createEmptyStats();
+  exitHandlerRegistered = false;
+  hasPrinted = false;
+  printTimer = null;
+  createEmptyStats() {
+    return {
+      transformer: { oxc: 0, babel: 0 },
+      resolver: { facetpack: 0, metro: 0 },
+      minifier: { files: 0, originalSize: 0, minifiedSize: 0 },
+      treeShaking: { modulesAnalyzed: 0, modulesRemoved: 0, exportsRemoved: 0 },
+      startTime: Date.now()
+    };
+  }
+  recordTransform(engine) {
+    this.stats.transformer[engine]++;
+    this.persistStats();
+    this.schedulePrint();
+  }
+  adjustTransformFallback() {
+    this.stats.transformer.oxc--;
+    this.stats.transformer.babel++;
+    this.persistStats();
+  }
+  recordResolve(engine) {
+    this.stats.resolver[engine]++;
+  }
+  flush() {
+    this.persistStats();
+  }
+  schedulePrint() {
+    if (this.printTimer) {
+      clearTimeout(this.printTimer);
+    }
+    this.printTimer = setTimeout(() => {
+      if (acquirePrintLock()) {
+        this.print();
+        releasePrintLock();
+      }
+    }, PRINT_DELAY);
+  }
+  recordMinify(originalSize, minifiedSize) {
+    this.stats.minifier.files++;
+    this.stats.minifier.originalSize += originalSize;
+    this.stats.minifier.minifiedSize += minifiedSize;
+  }
+  recordTreeShaking(analyzed, removed, exports2) {
+    this.stats.treeShaking.modulesAnalyzed += analyzed;
+    this.stats.treeShaking.modulesRemoved += removed;
+    this.stats.treeShaking.exportsRemoved += exports2;
+  }
+  get() {
+    return JSON.parse(JSON.stringify(this.stats));
+  }
+  reset() {
+    this.stats = this.createEmptyStats();
+    this.hasPrinted = false;
+    this.cleanupStatsFiles();
+  }
+  persistStats() {
+    try {
+      ensureStatsDir();
+      import_fs.writeFileSync(getStatsFilePath(), JSON.stringify(this.stats));
+    } catch {}
+  }
+  cleanupStatsFiles() {
+    try {
+      if (import_fs.existsSync(STATS_DIR)) {
+        const { readdirSync } = require("fs");
+        const files = readdirSync(STATS_DIR);
+        for (const file of files) {
+          if (file.startsWith(STATS_FILE_PREFIX)) {
+            try {
+              import_fs.unlinkSync(import_path.join(STATS_DIR, file));
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+  }
+  aggregateWorkerStats() {
+    const aggregated = this.createEmptyStats();
+    aggregated.startTime = this.stats.startTime;
+    try {
+      if (import_fs.existsSync(STATS_DIR)) {
+        const { readdirSync } = require("fs");
+        const files = readdirSync(STATS_DIR);
+        for (const file of files) {
+          if (file.startsWith(STATS_FILE_PREFIX)) {
+            try {
+              const content = import_fs.readFileSync(import_path.join(STATS_DIR, file), "utf-8");
+              const workerStats = JSON.parse(content);
+              aggregated.transformer.oxc += workerStats.transformer.oxc;
+              aggregated.transformer.babel += workerStats.transformer.babel;
+              aggregated.resolver.facetpack += workerStats.resolver.facetpack;
+              aggregated.resolver.metro += workerStats.resolver.metro;
+              if (workerStats.startTime < aggregated.startTime) {
+                aggregated.startTime = workerStats.startTime;
+              }
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+    aggregated.minifier = this.stats.minifier;
+    aggregated.treeShaking = this.stats.treeShaking;
+    return aggregated;
+  }
+  formatPercent(value, total) {
+    if (total === 0)
+      return "0.0";
+    return (value / total * 100).toFixed(1);
+  }
+  formatSize(bytes) {
+    if (bytes < 1024)
+      return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+      return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+  }
+  formatDuration(ms) {
+    if (ms < 1000)
+      return `${ms}ms`;
+    return `${(ms / 1000).toFixed(2)}s`;
+  }
+  print() {
+    if (!process.env.FACETPACK_DEBUG || this.hasPrinted)
+      return;
+    const aggregated = this.aggregateWorkerStats();
+    const { transformer, resolver, minifier, treeShaking, startTime } = aggregated;
+    const duration = Date.now() - startTime;
+    const transformTotal = transformer.oxc + transformer.babel;
+    const resolveTotal = resolver.facetpack + resolver.metro;
+    if (transformTotal === 0 && resolveTotal === 0 && minifier.files === 0)
+      return;
+    this.hasPrinted = true;
+    const { cyan, green, yellow, white, gray, bold, dim, reset } = ANSI;
+    console.log(`
+`);
+    console.log(`${bold}${cyan}╔════════════════════════════════════════════════════════════════════╗${reset}`);
+    console.log(`${bold}${cyan}║${reset}                    ${bold}FACETPACK BUNDLE STATS${reset}                         ${cyan}║${reset}`);
+    console.log(`${bold}${cyan}╠════════════════════════════════════════════════════════════════════╣${reset}`);
+    if (transformTotal > 0) {
+      const oxcPct = this.formatPercent(transformer.oxc, transformTotal);
+      const babelPct = this.formatPercent(transformer.babel, transformTotal);
+      console.log(`${cyan}║${reset}                                                                    ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${bold}TRANSFORMER${reset}                                                      ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${green}●${reset} OXC (native)    ${bold}${green}${transformer.oxc.toString().padStart(6)}${reset} files   ${green}${oxcPct.padStart(6)}%${reset}                 ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${yellow}●${reset} Babel           ${bold}${yellow}${transformer.babel.toString().padStart(6)}${reset} files   ${yellow}${babelPct.padStart(6)}%${reset}                 ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${dim}${white}  Total           ${transformTotal.toString().padStart(6)} files${reset}                            ${cyan}║${reset}`);
+    }
+    if (resolveTotal > 0) {
+      const fpPct = this.formatPercent(resolver.facetpack, resolveTotal);
+      const metroPct = this.formatPercent(resolver.metro, resolveTotal);
+      console.log(`${cyan}║${reset}                                                                    ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${bold}RESOLVER${reset}                                                         ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${green}●${reset} Facetpack       ${bold}${green}${resolver.facetpack.toString().padStart(6)}${reset} hits    ${green}${fpPct.padStart(6)}%${reset}                 ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${yellow}●${reset} Metro           ${bold}${yellow}${resolver.metro.toString().padStart(6)}${reset} hits    ${yellow}${metroPct.padStart(6)}%${reset}                 ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${dim}${white}  Total           ${resolveTotal.toString().padStart(6)} resolutions${reset}                      ${cyan}║${reset}`);
+    }
+    if (minifier.files > 0) {
+      const savings = minifier.originalSize - minifier.minifiedSize;
+      const savingsPct = this.formatPercent(savings, minifier.originalSize);
+      console.log(`${cyan}║${reset}                                                                    ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${bold}MINIFIER${reset}                                                         ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${green}●${reset} Files minified  ${bold}${green}${minifier.files.toString().padStart(6)}${reset}                                   ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${gray}●${reset} Original size   ${this.formatSize(minifier.originalSize).padStart(12)}                             ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${green}●${reset} Minified size   ${this.formatSize(minifier.minifiedSize).padStart(12)}  ${green}-${savingsPct}%${reset}                    ${cyan}║${reset}`);
+    }
+    if (treeShaking.modulesAnalyzed > 0) {
+      console.log(`${cyan}║${reset}                                                                    ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${bold}TREE SHAKING${reset}                                                     ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${gray}●${reset} Modules analyzed ${bold}${treeShaking.modulesAnalyzed.toString().padStart(5)}${reset}                                   ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${green}●${reset} Modules removed  ${bold}${green}${treeShaking.modulesRemoved.toString().padStart(5)}${reset}                                   ${cyan}║${reset}`);
+      console.log(`${cyan}║${reset}  ${green}●${reset} Exports removed  ${bold}${green}${treeShaking.exportsRemoved.toString().padStart(5)}${reset}                                   ${cyan}║${reset}`);
+    }
+    console.log(`${cyan}║${reset}                                                                    ${cyan}║${reset}`);
+    console.log(`${cyan}║${reset}  ${dim}Duration: ${this.formatDuration(duration)}${reset}                                             ${cyan}║${reset}`);
+    console.log(`${bold}${cyan}╚════════════════════════════════════════════════════════════════════╝${reset}`);
+    console.log(`
+`);
+    this.cleanupStatsFiles();
+  }
+  registerExitHandler() {
+    if (this.exitHandlerRegistered)
+      return;
+    this.exitHandlerRegistered = true;
+    process.on("SIGINT", () => {
+      this.print();
+      process.exit(0);
+    });
+    process.on("beforeExit", () => this.print());
+  }
+}
+var globalStats = new GlobalStats;
+function printStats() {
+  globalStats.print();
+}
+function resetStats() {
+  globalStats.reset();
+}
+function getStats() {
+  return globalStats.get();
+}
+
+// src/serializer.ts
 function createFacetpackSerializer(existingSerializer, config = {}) {
   return async (entryPoint, preModules, graph, options) => {
     if (options.dev || config.treeShake === false) {
+      let result2;
       if (existingSerializer) {
-        return existingSerializer(entryPoint, preModules, graph, options);
+        result2 = await existingSerializer(entryPoint, preModules, graph, options);
+      } else {
+        result2 = defaultSerialize(entryPoint, preModules, graph, options);
       }
-      return defaultSerialize(entryPoint, preModules, graph, options);
+      globalStats.print();
+      return result2;
     }
     const analyses = new Map;
+    let modulesAnalyzed = 0;
     for (const [path, module2] of graph.dependencies) {
       if (path.includes("node_modules")) {
         continue;
@@ -101,6 +366,7 @@ function createFacetpackSerializer(existingSerializer, config = {}) {
         const code = module2.output[0]?.data?.code ?? "";
         const analysis = import_facetpack_native.analyzeSync(path, code);
         analyses.set(path, analysis);
+        modulesAnalyzed++;
       } catch {
         analyses.set(path, {
           exports: [],
@@ -111,7 +377,8 @@ function createFacetpackSerializer(existingSerializer, config = {}) {
     }
     const usedExports = computeUsedExports(entryPoint, analyses, graph);
     const shakenModules = new Map;
-    let totalRemoved = 0;
+    let modulesRemoved = 0;
+    let exportsRemoved = 0;
     for (const [path, module2] of graph.dependencies) {
       if (path.includes("node_modules")) {
         const code = module2.output[0]?.data?.code ?? "";
@@ -121,28 +388,30 @@ function createFacetpackSerializer(existingSerializer, config = {}) {
       const used = usedExports.get(path);
       const analysis = analyses.get(path);
       if ((!used || used.size === 0) && analysis && !analysis.hasSideEffects) {
-        totalRemoved++;
+        modulesRemoved++;
         continue;
       }
       try {
         const code = module2.output[0]?.data?.code ?? "";
         const usedArray = used ? Array.from(used) : ["*"];
-        const result = import_facetpack_native.shakeSync(path, code, usedArray);
-        shakenModules.set(path, { code: result.code, map: result.map ?? undefined });
-        totalRemoved += result.removedExports.length;
+        const result2 = import_facetpack_native.shakeSync(path, code, usedArray);
+        shakenModules.set(path, { code: result2.code, map: result2.map ?? undefined });
+        exportsRemoved += result2.removedExports.length;
       } catch {
         const code = module2.output[0]?.data?.code ?? "";
         shakenModules.set(path, { code });
       }
     }
-    if (totalRemoved > 0) {
-      console.log(`[facetpack] Tree-shaking removed ${totalRemoved} unused exports`);
-    }
+    globalStats.recordTreeShaking(modulesAnalyzed, modulesRemoved, exportsRemoved);
+    let result;
     if (existingSerializer) {
       const shakenGraph = createShakenGraph(graph, shakenModules);
-      return existingSerializer(entryPoint, preModules, shakenGraph, options);
+      result = await existingSerializer(entryPoint, preModules, shakenGraph, options);
+    } else {
+      result = defaultSerialize(entryPoint, preModules, graph, options, shakenModules);
     }
-    return defaultSerialize(entryPoint, preModules, graph, options, shakenModules);
+    globalStats.print();
+    return result;
   };
 }
 function computeUsedExports(entryPoint, analyses, graph) {
@@ -246,15 +515,15 @@ function wrapModule(id, code) {
 
 // src/withFacetpack.ts
 var import_module = require("module");
-var import_path = require("path");
+var import_path2 = require("path");
 var DEFAULT_SOURCE_EXTS = ["ts", "tsx", "js", "jsx", "mjs", "cjs"];
 function getPackageDir() {
-  const projectRequire = import_module.createRequire(import_path.join(process.cwd(), "package.json"));
+  const projectRequire = import_module.createRequire(import_path2.join(process.cwd(), "package.json"));
   const packageJsonPath = projectRequire.resolve("@ecrindigital/facetpack/package.json");
-  return import_path.dirname(packageJsonPath);
+  return import_path2.dirname(packageJsonPath);
 }
 function findFallbackTransformer(projectRoot) {
-  const projectRequire = import_module.createRequire(import_path.join(projectRoot, "package.json"));
+  const projectRequire = import_module.createRequire(import_path2.join(projectRoot, "package.json"));
   const transformerPaths = [
     "@expo/metro-config/babel-transformer",
     "@react-native/metro-babel-transformer",
@@ -270,17 +539,18 @@ function findFallbackTransformer(projectRoot) {
 function withFacetpack(config, options = {}) {
   const sourceExts = options.sourceExts ?? DEFAULT_SOURCE_EXTS;
   const packageDir = getPackageDir();
-  const transformerPath = import_path.join(packageDir, "dist", "transformer.js");
+  const transformerPath = import_path2.join(packageDir, "dist", "transformer.js");
   const useMinifier = options.minifier !== false;
-  const minifierPath = useMinifier ? import_path.join(packageDir, "dist", "minifier.js") : config.transformer?.minifierPath;
+  const minifierPath = useMinifier ? import_path2.join(packageDir, "dist", "minifier.js") : config.transformer?.minifierPath;
   const minifierConfig = typeof options.minifier === "object" ? options.minifier : {};
-  const useTreeShake = options.treeShake !== false;
+  const useTreeShake = options.treeShake === true;
   const existingSerializer = config.serializer?.customSerializer;
   const customSerializer = useTreeShake ? createFacetpackSerializer(existingSerializer, { treeShake: true }) : existingSerializer;
   const projectRoot = config.projectRoot || process.cwd();
   const originalTransformerPath = config.transformer?.babelTransformerPath;
   const fallbackTransformerPath = originalTransformerPath || findFallbackTransformer(projectRoot);
   storeTransformerOptions(options, fallbackTransformerPath);
+  const existingResolver = config.resolver?.resolveRequest;
   return {
     ...config,
     transformer: {
@@ -309,15 +579,16 @@ function withFacetpack(config, options = {}) {
         ])
       ],
       resolveRequest: (context, moduleName, platform) => {
+        const fallbackResolver = existingResolver ?? context.resolveRequest;
         if (context.originModulePath.includes("node_modules")) {
-          return context.resolveRequest(context, moduleName, platform);
+          return fallbackResolver(context, moduleName, platform);
         }
         const cached = getCachedResolution(context.originModulePath, moduleName);
         if (cached !== undefined) {
           if (cached) {
             return { type: "sourceFile", filePath: cached };
           }
-          return context.resolveRequest(context, moduleName, platform);
+          return fallbackResolver(context, moduleName, platform);
         }
         const directory = context.originModulePath.substring(0, context.originModulePath.lastIndexOf("/"));
         const result = import_facetpack_native2.resolveSync(directory, moduleName, {
@@ -328,7 +599,7 @@ function withFacetpack(config, options = {}) {
         if (result.path) {
           return { type: "sourceFile", filePath: result.path };
         }
-        return context.resolveRequest(context, moduleName, platform);
+        return fallbackResolver(context, moduleName, platform);
       }
     },
     serializer: {
@@ -355,8 +626,112 @@ function getStoredOptions() {
 // src/transformer.ts
 var import_facetpack_native3 = require("@ecrindigital/facetpack-native");
 var import_parser = require("@babel/parser");
+var ANSI2 = {
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  bold: "\x1B[1m",
+  reset: "\x1B[0m"
+};
 var IMPORT_REGEX = /(?:import|export)\s+(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g;
 var REQUIRE_REGEX = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+var BABEL_REQUIRED_PATTERNS = [
+  /'worklet'/,
+  /"worklet"/,
+  /require\.context\s*\(/,
+  /useAnimatedStyle/,
+  /useAnimatedProps/,
+  /useAnimatedScrollHandler/,
+  /useAnimatedGestureHandler/,
+  /useAnimatedReaction/,
+  /useDerivedValue/,
+  /useAnimatedSensor/,
+  /useFrameCallback/,
+  /useScrollViewOffset/,
+  /runOnUI/,
+  /runOnJS/
+];
+var DEFAULT_OPTIONS = {
+  jsx: true,
+  jsxRuntime: "automatic",
+  jsxImportSource: "react",
+  jsxPragma: "React.createElement",
+  jsxPragmaFrag: "React.Fragment",
+  typescript: true,
+  sourceExts: ["ts", "tsx", "js", "jsx", "mjs", "cjs"],
+  minifier: true,
+  treeShake: true,
+  noAst: false
+};
+
+class Logger {
+  startupLogged = false;
+  logStartup() {
+    if (this.startupLogged || !process.env.FACETPACK_DEBUG)
+      return;
+    this.startupLogged = true;
+    console.log(`${ANSI2.cyan}${ANSI2.bold}[Facetpack]${ANSI2.reset} Transformer loaded`);
+  }
+  logTransform(decision, filename) {
+    if (!process.env.FACETPACK_DEBUG)
+      return;
+    const color = decision === "oxc" ? ANSI2.green : ANSI2.yellow;
+    console.log(`${color}[Facetpack]${ANSI2.reset} ${decision.toUpperCase()}: ${filename}`);
+  }
+  logFallback(filename, error) {
+    if (!process.env.FACETPACK_DEBUG)
+      return;
+    const message = error instanceof Error ? error.message : String(error);
+    console.log(`${ANSI2.yellow}[Facetpack]${ANSI2.reset} OXC failed, falling back to Babel: ${filename}`);
+    console.log(`${ANSI2.yellow}[Facetpack]${ANSI2.reset} Error: ${message}`);
+  }
+}
+
+class OptionsManager {
+  globalOptions = {};
+  setGlobal(options) {
+    this.globalOptions = options;
+  }
+  get() {
+    return { ...DEFAULT_OPTIONS, ...this.globalOptions, ...this.getFromEnv() };
+  }
+  merge(options) {
+    return { ...DEFAULT_OPTIONS, ...options };
+  }
+  getFromEnv() {
+    try {
+      const json = process.env.FACETPACK_OPTIONS;
+      return json ? JSON.parse(json) : {};
+    } catch {
+      return {};
+    }
+  }
+}
+
+class FallbackTransformerManager {
+  instance = null;
+  get() {
+    if (this.instance)
+      return this.instance;
+    const envPath = process.env.FACETPACK_FALLBACK_TRANSFORMER;
+    if (envPath) {
+      try {
+        this.instance = require(envPath);
+        return this.instance;
+      } catch (e) {
+        console.warn(`[Facetpack] Failed to load fallback transformer from ${envPath}:`, e);
+      }
+    }
+    this.instance = {
+      transform: ({ src }) => ({ code: src, map: null })
+    };
+    return this.instance;
+  }
+}
+var logger = new Logger;
+var options = new OptionsManager;
+var fallback = new FallbackTransformerManager;
+logger.logStartup();
 function extractSpecifiers(code) {
   const specifiers = new Set;
   let match;
@@ -385,178 +760,141 @@ function preResolveImports(filename, code, sourceExts) {
     const specifier = specifiers[i];
     if (specifier) {
       resolutions.set(specifier, results[i]?.path ?? null);
+      if (results[i]?.path) {
+        globalStats.recordResolve("facetpack");
+      }
     }
   }
   setCachedResolutions(filename, resolutions);
 }
-var defaultOptions = {
-  jsx: true,
-  jsxRuntime: "automatic",
-  jsxImportSource: "react",
-  jsxPragma: "React.createElement",
-  jsxPragmaFrag: "React.Fragment",
-  typescript: true,
-  sourceExts: ["ts", "tsx", "js", "jsx", "mjs", "cjs"],
-  minifier: true,
-  treeShake: true,
-  noAst: false
-};
-var globalOptions = {};
-var fallbackTransformer = null;
-function getFallbackTransformer() {
-  if (fallbackTransformer) {
-    return fallbackTransformer;
-  }
-  const fallbackPath = process.env.FACETPACK_FALLBACK_TRANSFORMER;
-  if (fallbackPath) {
-    try {
-      fallbackTransformer = require(fallbackPath);
-      return fallbackTransformer;
-    } catch (e) {
-      console.warn(`[Facetpack] Failed to load fallback transformer from ${fallbackPath}:`, e);
-    }
-  }
-  fallbackTransformer = {
-    transform: ({ src }) => ({ code: src, map: null })
-  };
-  return fallbackTransformer;
-}
-function setTransformerOptions(options) {
-  globalOptions = options;
-}
-function getStoredOptions2() {
-  try {
-    const optionsJson = process.env.FACETPACK_OPTIONS;
-    if (optionsJson) {
-      return JSON.parse(optionsJson);
-    }
-  } catch {}
-  return {};
-}
-function getOptions() {
-  const storedOptions = getStoredOptions2();
-  return { ...defaultOptions, ...globalOptions, ...storedOptions };
+function requiresBabelTransform(src) {
+  return BABEL_REQUIRED_PATTERNS.some((pattern) => pattern.test(src));
 }
 function isNodeModules(filename) {
   return filename.includes("node_modules");
 }
-var BABEL_REQUIRED_PATTERNS = [
-  /'worklet'/,
-  /"worklet"/,
-  /useAnimatedStyle/,
-  /useAnimatedProps/,
-  /useDerivedValue/,
-  /useAnimatedReaction/,
-  /useAnimatedScrollHandler/,
-  /useAnimatedGestureHandler/,
-  /runOnUI/,
-  /runOnJS/
-];
-function requiresBabelTransform(src) {
-  return BABEL_REQUIRED_PATTERNS.some((pattern) => pattern.test(src));
+function getFileExtension(filename) {
+  return filename.split(".").pop()?.toLowerCase();
 }
-function shouldTransform(filename, src, options) {
-  if (isNodeModules(filename)) {
-    return false;
-  }
-  if (requiresBabelTransform(src)) {
-    if (process.env.FACETPACK_DEBUG) {
-      console.log(`[Facetpack] Babel required for worklets: ${filename}`);
+function getTransformDecision(filename, src, opts) {
+  if (requiresBabelTransform(src))
+    return "babel";
+  if (isNodeModules(filename))
+    return "babel";
+  const ext = getFileExtension(filename);
+  if (!ext || !opts.sourceExts.includes(ext))
+    return "babel";
+  return "oxc";
+}
+function formatDiagnostics(diagnostics) {
+  return diagnostics.map((d) => {
+    if (d.formatted)
+      return d.formatted;
+    if (!d.message)
+      return "";
+    let output = `
+  × ${d.message}
+`;
+    if (d.snippet) {
+      output += `   ╭─[${d.filename}:${d.line}:${d.column}]
+`;
+      output += ` ${d.line} │ ${d.snippet}
+`;
+      output += `   ╰────
+`;
     }
-    return false;
+    if (d.help)
+      output += `  help: ${d.help}
+`;
+    return output;
+  }).join(`
+`);
+}
+function transformWithOxc(filename, src, opts, isDev) {
+  const parseResult = import_facetpack_native3.parseSync(filename, src);
+  if (parseResult.errors.length > 0) {
+    const error = parseResult.diagnostics.length > 0 ? new Error(`
+${formatDiagnostics(parseResult.diagnostics)}`) : new Error(`Parse error in ${filename}:
+${parseResult.errors.join(`
+`)}`);
+    error.isParseError = true;
+    throw error;
   }
-  const ext = filename.split(".").pop()?.toLowerCase();
-  if (!ext)
-    return false;
-  return options.sourceExts.includes(ext);
+  const isClassic = opts.jsxRuntime === "classic";
+  const result = import_facetpack_native3.transformSync(filename, src, {
+    jsx: opts.jsx,
+    jsxRuntime: isClassic ? import_facetpack_native3.JsxRuntime.Classic : import_facetpack_native3.JsxRuntime.Automatic,
+    ...isClassic ? { jsxPragma: opts.jsxPragma, jsxPragmaFrag: opts.jsxPragmaFrag } : { jsxImportSource: opts.jsxImportSource },
+    typescript: opts.typescript,
+    sourcemap: isDev
+  });
+  if (result.errors.length > 0) {
+    throw new Error(`Facetpack transform error in ${filename}:
+${result.errors.join(`
+`)}`);
+  }
+  preResolveImports(filename, result.code, opts.sourceExts);
+  globalStats.flush();
+  const ast = import_parser.parse(result.code, {
+    sourceType: "unambiguous",
+    plugins: ["jsx"]
+  });
+  return {
+    ast,
+    code: result.code,
+    map: result.map ? JSON.parse(result.map) : null
+  };
+}
+function setTransformerOptions(opts) {
+  options.setGlobal(opts);
 }
 function transform(params) {
   const { filename, src, options: metroOptions } = params;
-  const opts = getOptions();
-  if (process.env.FACETPACK_DEBUG) {
-    console.log(`[Facetpack] Processing: ${filename}`);
-  }
-  if (!shouldTransform(filename, src, opts)) {
-    if (process.env.FACETPACK_DEBUG) {
-      console.log(`[Facetpack] Fallback: ${filename}`);
-    }
-    return getFallbackTransformer().transform(params);
-  }
-  if (process.env.FACETPACK_DEBUG) {
-    console.log(`[Facetpack] OXC Transform: ${filename}`);
+  const opts = options.get();
+  globalStats.registerExitHandler();
+  const decision = getTransformDecision(filename, src, opts);
+  globalStats.recordTransform(decision);
+  logger.logTransform(decision, filename);
+  if (decision === "babel") {
+    return fallback.get().transform(params);
   }
   try {
-    const isClassic = opts.jsxRuntime === "classic";
-    const result = import_facetpack_native3.transformSync(filename, src, {
-      jsx: opts.jsx,
-      jsxRuntime: isClassic ? import_facetpack_native3.JsxRuntime.Classic : import_facetpack_native3.JsxRuntime.Automatic,
-      ...isClassic ? { jsxPragma: opts.jsxPragma, jsxPragmaFrag: opts.jsxPragmaFrag } : { jsxImportSource: opts.jsxImportSource },
-      typescript: opts.typescript,
-      sourcemap: metroOptions.dev
-    });
-    if (result.errors.length > 0) {
-      const errorMessage = result.errors.join(`
-`);
-      throw new Error(`Facetpack transform error in ${filename}:
-${errorMessage}`);
-    }
-    preResolveImports(filename, result.code, opts.sourceExts);
-    const ast = opts.noAst ? undefined : import_parser.parse(result.code, {
-      sourceType: "unambiguous",
-      plugins: ["jsx"]
-    });
-    const output = {
-      ast,
-      code: result.code,
-      map: result.map ? JSON.parse(result.map) : null
-    };
-    if (process.env.FACETPACK_DEBUG) {
-      console.log(`[Facetpack] Output for ${filename}:`);
-      console.log(result.code.slice(0, 500));
-    }
-    return output;
+    return transformWithOxc(filename, src, opts, metroOptions.dev);
   } catch (error) {
-    if (error instanceof Error) {
-      error.message = `[Facetpack] ${error.message}`;
+    if (error.isParseError) {
+      throw error;
     }
-    throw error;
+    logger.logFallback(filename, error);
+    globalStats.adjustTransformFallback();
+    return fallback.get().transform(params);
   }
 }
-function createTransformer(options = {}) {
-  const opts = { ...defaultOptions, ...options };
+function createTransformer(customOptions = {}) {
+  const opts = options.merge(customOptions);
   return {
     transform(params) {
       const { filename, src, options: metroOptions } = params;
-      if (!shouldTransform(filename, src, opts)) {
-        return getFallbackTransformer().transform(params);
-      }
-      const isClassic = opts.jsxRuntime === "classic";
-      const result = import_facetpack_native3.transformSync(filename, src, {
-        jsx: opts.jsx,
-        jsxRuntime: isClassic ? import_facetpack_native3.JsxRuntime.Classic : import_facetpack_native3.JsxRuntime.Automatic,
-        ...isClassic ? { jsxPragma: opts.jsxPragma, jsxPragmaFrag: opts.jsxPragmaFrag } : { jsxImportSource: opts.jsxImportSource },
-        typescript: opts.typescript,
-        sourcemap: metroOptions.dev
-      });
-      if (result.errors.length > 0) {
-        throw new Error(`Facetpack transform error in ${filename}:
-${result.errors.join(`
-`)}`);
+      const decision = getTransformDecision(filename, src, opts);
+      globalStats.recordTransform(decision);
+      if (decision === "babel") {
+        return fallback.get().transform(params);
       }
-      return {
-        code: result.code,
-        map: result.map ? JSON.parse(result.map) : null
-      };
+      return transformWithOxc(filename, src, opts, metroOptions.dev);
     }
   };
 }
 // src/resolver.ts
 var import_facetpack_native4 = require("@ecrindigital/facetpack-native");
-function createResolver(options) {
+function createResolver(options2) {
   return {
     resolve(originModulePath, moduleName) {
       const directory = originModulePath.substring(0, originModulePath.lastIndexOf("/"));
-      const result = import_facetpack_native4.resolveSync(directory, moduleName, options);
+      const result = import_facetpack_native4.resolveSync(directory, moduleName, options2);
+      if (result.path) {
+        globalStats.recordResolve("facetpack");
+      } else {
+        globalStats.recordResolve("metro");
+      }
       return result.path ?? null;
     }
   };
@@ -564,7 +902,7 @@ function createResolver(options) {
 // src/minifier.ts
 var import_facetpack_native5 = require("@ecrindigital/facetpack-native");
 function minify(input) {
-  const options = {
+  const options2 = {
     compress: input.config.compress ?? true,
     mangle: input.config.mangle ?? true,
     keepFnames: input.config.keep_fnames ?? false,
@@ -572,22 +910,28 @@ function minify(input) {
     dropDebugger: input.config.drop_debugger ?? true,
     sourcemap: input.map !== undefined
   };
-  const result = import_facetpack_native5.minifySync(input.code, input.filename, options);
+  const originalSize = Buffer.byteLength(input.code, "utf8");
+  const result = import_facetpack_native5.minifySync(input.code, input.filename, options2);
+  const minifiedSize = Buffer.byteLength(result.code, "utf8");
+  globalStats.recordMinify(originalSize, minifiedSize);
   return {
     code: result.code,
     map: result.map ?? undefined
   };
 }
-function minifyCode(code, filename, options) {
+function minifyCode(code, filename, options2) {
   const nativeOptions = {
-    compress: options?.compress ?? true,
-    mangle: options?.mangle ?? true,
-    keepFnames: options?.keep_fnames ?? false,
-    dropConsole: options?.drop_console ?? false,
-    dropDebugger: options?.drop_debugger ?? true,
+    compress: options2?.compress ?? true,
+    mangle: options2?.mangle ?? true,
+    keepFnames: options2?.keep_fnames ?? false,
+    dropConsole: options2?.drop_console ?? false,
+    dropDebugger: options2?.drop_debugger ?? true,
     sourcemap: false
   };
+  const originalSize = Buffer.byteLength(code, "utf8");
   const result = import_facetpack_native5.minifySync(code, filename, nativeOptions);
+  const minifiedSize = Buffer.byteLength(result.code, "utf8");
+  globalStats.recordMinify(originalSize, minifiedSize);
   return {
     code: result.code,
     map: result.map ?? undefined