vite dev
  ↓
spin up esbuild/Rolldown
  ↓
plugin chain: TS plugin → JSX plugin → output
  ↓
main.tsx      → transform → output
utils.ts      → transform → output  
index.css     → transform → output
[every file]  → transform → output

uild paths into a single execution graph.

Core Solution

Ionify replaces the stateless transform loop with a persistent, four-layer memory architecture. Instead of re-transforming files, the engine addresses them via content hashes. Identical content + identical configuration = identical hash = transform skipped entirely.

The invalidation workflow operates as follows:

module changes → BFS over reverse dependency index
→ find exactly which modules are affected
→ transform only those
→ everything else: CAS hit, served instantly

The Four Layers of Memory:

1. Module Transform Cache: Transformed modules stored by content hash. Persists across sessions, branches, and team members.
2. Deps Artifact Store: node_modules pre-optimized and partitioned by depsHash. Single dependency updates bypass full tree re-optimization.
3. Compression CAS: Brotli-11 + gzip-9 computed once. Compression overhead vanishes after initial generation.
4. Chunk-Output CAS: Final build chunks stored by hash. CI pipelines assemble outputs from cache when source hashes remain unchanged.

Configuration & Architecture Decisions: Framework support is handled natively by the engine, eliminating plugin-chain hooks. The dev server and production build share a unified pipeline, removing environment-specific divergence.

import { defineConfig } from "@ionify/ionify";

export default defineConfig({
  entry: "/src/main.tsx",
  optimizeDeps: {
    sharedChunks: "auto",
    vendorPacks: "auto",
    packSlimming: "auto",
  },
});

Future-Proofing: Cross-project CAS sharing is already in development. When a new engineer clones a repository and runs ionify dev, the engine queries a shared remote CAS. If teammates have already built matching content hashes, transform artifacts are pulled instantly, eliminating cold starts at the architectural level.

Pitfall Guide

1. Assuming Stateless Simplicity Scales: Stateless pipelines trade initial simplicity for linear compute costs. At 10K+ modules, redundant transforms dominate startup time. Adopt content-addressed persistence once plugin overhead exceeds acceptable thresholds.
2. Relying on Filesystem-Level CI Caching for Module Invalidation: Directory-level caching cannot track granular file changes. A single modified file triggers a full cache miss and rebuild. Implement module-level CAS to isolate invalidation to affected dependency subgraphs.
3. Over-Engineering Plugin Chains for Framework Support: Interception hooks (e.g., @vitejs/plugin-react) add latency on every run. Native engine support for JSX, HMR, and Fast Refresh eliminates hook overhead and guarantees consistent transform behavior across environments.
4. Ignoring Content-Addressed Dependency Partitioning: Treating node_modules as a monolithic cache block forces full re-optimization on minor dependency updates. Partition dependencies by depsHash to isolate and cache optimized vendor artifacts independently.
5. Maintaining Separate Dev and Production Pipelines: Divergent dev/build configurations create "works locally, breaks in CI" failure modes. Unify the execution graph so that dev server transforms, HMR boundaries, and production chunking share identical logic and cache layers.
6. Neglecting Cross-Project Cache Sharing: Cold starts drain onboarding velocity and CI throughput. Deploy shared remote CAS endpoints to allow teams to pull pre-computed transform artifacts across repositories, branches, and developer machines.

Deliverables

• 📘 Ionify Architecture & Migration Blueprint: Step-by-step guide for transitioning from stateless bundlers to persistent CAS engines, including dependency graph mapping, cache layer configuration, and CI pipeline integration patterns.
• ✅ Build Tool Evaluation & Migration Checklist: 24-point audit covering invalidation granularity, plugin overhead measurement, CAS hit-rate monitoring, and unified pipeline validation before and after migration.
• ⚙️ Configuration Templates: Production-ready ionify.config.ts scaffolds for React, Vue, and TypeScript monorepos, complete with optimized optimizeDeps presets, chunk-splitting strategies, and remote CAS endpoint configurations.