@djodjonx/neo-syringe 1.2.0 → 1.2.2

package/README.md

@@ -5,821 +5,142 @@
 <p align="center">
   <a href="https://www.npmjs.com/package/@djodjonx/neo-syringe"><img src="https://img.shields.io/npm/v/@djodjonx/neo-syringe.svg?style=flat-square" alt="npm version"></a>
   <a href="https://github.com/djodjonx/neo-syringe/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/djodjonx/neo-syringe/ci.yml?style=flat-square&label=tests" alt="Tests"></a>
-  <a href="https://github.com/djodjonx/neo-syringe/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/djodjonx/neo-syringe/ci.yml?style=flat-square" alt="CI"></a>
   <a href="https://www.typescriptlang.org/"><img src="https://img.shields.io/badge/TypeScript-5.0+-blue.svg?style=flat-square" alt="TypeScript"></a>
   <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square" alt="License: MIT"></a>
+  <a href="https://djodjonx.github.io/neo-syringe/"><img src="https://img.shields.io/badge/docs-VitePress-0d9488.svg?style=flat-square" alt="Documentation"></a>
 </p>
 
 <h1 align="center">Zero-Overhead, Compile-Time Dependency Injection</h1>
 
 <p align="center">
-  <strong>Neo-Syringe</strong> is a next-generation DI system that shifts resolution from <strong>Runtime</strong> to <strong>Build-Time</strong>. It eliminates reflection and metadata in favor of generated, optimized JavaScript factories.
+  <strong>Neo-Syringe</strong> shifts DI resolution from <strong>Runtime</strong> to <strong>Build-Time</strong>.<br>
+  No reflection, no decorators, just pure TypeScript.
 </p>
 
----
-
-`neo-syringe` allows you to:
-
-- ✨ **Use Interfaces as Tokens**: Native support for `useInterface<ILogger>()` without manual Symbols
-- 🚀 **Zero Runtime Overhead**: No reflection, no `reflect-metadata`, just pure factory functions
-- 🛡️ **Compile-Time Safety**: Detect circular dependencies, missing bindings, and type mismatches instantly
-- 🔄 **Migrate Gradually**: Use `useContainer` to bridge existing containers (like `tsyringe`)
-- 🤖 **Validate in CI**: Standalone CLI to verify your dependency graph before deployment
-
-## 📚 Documentation
-
-- **[Quick Start](#quick-start)** - Wire your first application in 5 minutes
-- **[Injection Types](#injection-types)** - All ways to define dependencies
-- **[Generated Code](#generated-code-example)** - See what the compiler produces
-- **[Parent Container](#parent-container-usecontainer)** - SharedKernel and modular architecture
-- **[Legacy Migration](#legacy-migration-usecontainer-1)** - Bridge existing containers (tsyringe, etc.)
-- **[CLI Validator](#cli-validator)** - Ensure graph integrity in CI/CD
-- **[IDE Support](#ide-plugin-for-real-time-validation)** - Get real-time errors in VS Code
-
-## Why Neo-Syringe?
-
-Traditional containers (InversifyJS, tsyringe) or modern wrappers (WireDI) rely on **Runtime Resolution**. This means:
-
-- ❌ You ship the DI container logic to the browser
-- ❌ Errors (missing bindings) happen at runtime
-- ❌ Interfaces are erased, requiring manual Symbols
-
-**Neo-Syringe is different.** It works as a **Compiler Plugin**:
-
-### 1. Code Generation
-Neo-Syringe analyzes your configuration and generates a specialized TypeScript class with hardcoded `new Service(new Dep())` calls. **Zero runtime resolution overhead**.
+<p align="center">
+  <a href="https://djodjonx.github.io/neo-syringe/"><strong>📚 Read the Documentation →</strong></a>
+</p>
 
-### 2. Interface Support
-It automatically generates unique IDs for interfaces at build time. Write `useInterface<ILogger>()` instead of managing Symbols manually.
+<p align="center">
+  <a href="https://djodjonx.github.io/neo-syringe/guide/getting-started">Getting Started</a> •
+  <a href="https://djodjonx.github.io/neo-syringe/guide/why-neo-syringe">Why Neo-Syringe?</a> •
+  <a href="https://djodjonx.github.io/neo-syringe/api/types">API Reference</a>
+</p>
 
-### 3. Pure Classes
-Your business classes stay **100% pure** - no decorators, no DI imports, no framework coupling.
+---
 
-### 4. Real-Time Validation
-Errors are detected **in your IDE** instantly:
+## ✨ Features
 
-```typescript
-// ❌ Error detected in IDE: "ILogger" has no registered provider
-const config = defineBuilderConfig({
-    injections: [
-        { token: UserService }, // UserService depends on ILogger
-    ],
-})
-```
+- **Use Interfaces as Tokens** - `useInterface<ILogger>()` without manual Symbols
+- **Zero Runtime Overhead** - Generated factory functions, no DI library shipped
+- **Compile-Time Safety** - Errors detected in your IDE, not at runtime
+- **Pure Classes** - No decorators, no DI imports in your business code
+- **Gradual Migration** - Bridge existing containers (tsyringe, InversifyJS)
+- **CI Validation** - CLI to verify your dependency graph
 
-## Installation
+## 📦 Installation
 
 ```bash
-# With npm
+# npm
 npm install @djodjonx/neo-syringe
 npm install -D unplugin
 
-# With pnpm
+# pnpm
 pnpm add @djodjonx/neo-syringe
 pnpm add -D unplugin
 ```
 
-> **Note**: `typescript` (>=5.0.0) and `unplugin` are required peer dependencies.
-
-### Build System Integration
-
-Configure the plugin in your bundler to enable compile-time code generation.
-
-<details>
-<summary><strong>Vite</strong></summary>
-
-```typescript
-// vite.config.ts
-import { defineConfig } from 'vite';
-import { neoSyringePlugin } from '@djodjonx/neo-syringe/plugin';
-
-export default defineConfig({
-  plugins: [neoSyringePlugin.vite()]
-});
-```
-
-</details>
-
-<details>
-<summary><strong>Rollup</strong></summary>
-
-```typescript
-// rollup.config.js
-import { neoSyringePlugin } from '@djodjonx/neo-syringe/plugin';
-
-export default {
-  plugins: [neoSyringePlugin.rollup()]
-};
-```
-
-</details>
-
-<details>
-<summary><strong>Webpack</strong></summary>
-
-```typescript
-// webpack.config.js
-module.exports = {
-  plugins: [require('@djodjonx/neo-syringe/plugin').webpack()]
-};
-```
-
-</details>
-
-### Dev Mode & HMR Support
-
-✅ **The plugin works in dev mode** (Vite, Rollup watch, Webpack dev server).
-
-The `transform` hook is called on every file change, so your container is regenerated instantly during development with full Hot Module Replacement (HMR) support.
-
-> ⚠️ **Best Practice**: Put your container configuration in a **dedicated file** (e.g., `container.ts`). The plugin replaces the entire file content with generated code, so mixing container config with other exports may cause issues.
-
-```
-src/
-├── container.ts      # ✅ Dedicated file for defineBuilderConfig
-├── services/
-│   ├── logger.ts
-│   └── user.service.ts
-└── main.ts
-```
-
-## Quick Start
-
-### 1. Define Services (Pure TypeScript)
-
-No decorators required. Just plain classes and interfaces.
+## 🚀 Quick Example
 
 ```typescript
-// logger.ts
-export interface ILogger {
+// Pure TypeScript - no decorators!
+interface ILogger {
   log(msg: string): void;
 }
 
-export class ConsoleLogger implements ILogger {
+class ConsoleLogger implements ILogger {
   log(msg: string) { console.log(msg); }
 }
 
-// user.service.ts
-export class UserService {
-  constructor(private logger: ILogger) {} // Dependency is an Interface!
+class UserService {
+  constructor(private logger: ILogger) {}
 }
 ```
 
-### 2. Configure the Container
-
-Use `defineBuilderConfig` to wire your graph.
-
 ```typescript
-// config.ts
+// container.ts
 import { defineBuilderConfig, useInterface } from '@djodjonx/neo-syringe';
-import { ILogger, ConsoleLogger } from './logger';
-import { UserService } from './user.service';
-
-export const appConfig = defineBuilderConfig({
-  name: 'AppModule',
-  injections: [
-    // Bind Interface -> Implementation
-    { token: useInterface<ILogger>(), provider: ConsoleLogger },
-    
-    // Autowire Class
-    { token: UserService }
-  ]
-});
-```
-
-### 3. Use the Container
-
-The compiler plugin replaces the configuration with a generated container class.
-
-```typescript
-// main.ts
-import { appConfig } from './config';
-
-const container = appConfig; // This IS the container at runtime!
-const userService = container.resolve(UserService);
-```
-
----
-
-## Injection Types
-
-### Class Token (Autowire)
-
-```typescript
-{ token: UserService }
-```
-
-### Interface Token
-
-```typescript
-{ token: useInterface<ILogger>(), provider: ConsoleLogger }
-```
-
-### Explicit Provider
-
-```typescript
-{ token: UserService, provider: MockUserService }
-```
-
-### Factory Provider
-
-Use factory functions for dynamic instantiation or container access.
-
-```typescript
-// Auto-detected: arrow functions are treated as factories
-{ 
-  token: useInterface<IConfig>(), 
-  provider: (container) => ({
-    apiUrl: process.env.API_URL ?? 'http://localhost',
-    timeout: 5000
-  })
-}
-
-// Explicit factory flag
-{ 
-  token: useInterface<IDatabase>(), 
-  provider: createDatabaseConnection,
-  useFactory: true
-}
-
-// Factory with dependencies
-{ 
-  token: useInterface<IService>(), 
-  provider: (container) => {
-    const logger = container.resolve(useInterface<ILogger>());
-    return new MyService(logger);
-  }
-}
-```
-
-### Primitive Values with `useProperty`
-
-Inject primitives (string, number, boolean) while keeping classes **pure**.
-
-```typescript
-import { defineBuilderConfig, useProperty } from '@djodjonx/neo-syringe';
-
-// Pure class - no DI imports!
-class ApiService {
-  constructor(
-    private apiUrl: string,
-    private maxRetries: number
-  ) {}
-}
-
-// Define property tokens
-const apiUrl = useProperty<string>(ApiService, 'apiUrl');
-const maxRetries = useProperty<number>(ApiService, 'maxRetries');
-
-export const config = defineBuilderConfig({
-  injections: [
-    { token: apiUrl, provider: () => process.env.API_URL ?? 'http://localhost' },
-    { token: maxRetries, provider: () => 5 },
-    { token: ApiService }  // Auto-wires primitives!
-  ]
-});
-```
-
-**Benefits:**
-- ✅ No collision: `useProperty(ApiService, 'url')` ≠ `useProperty(AuthService, 'url')`
-- ✅ LSP validation: Detects if parameter doesn't exist
-- ✅ Refactoring-friendly: Rename parameter → LSP error
-
-### Lifecycle
-
-```typescript
-{ token: UserService, lifecycle: 'transient' } // Default is 'singleton'
-
-// Factories support lifecycle too
-{
-  token: useInterface<IRequest>(),
-  provider: () => ({ id: crypto.randomUUID() }),
-  lifecycle: 'transient'
-}
-```
-
-### Scoped Injections (`scoped: true`)
-
-Override a token from a parent container **without causing a duplicate error**. Useful for testing or module-specific overrides.
-
-```typescript
-// SharedKernel - Production logger
-const sharedKernel = defineBuilderConfig({
-  name: 'SharedKernel',
-  injections: [
-    { token: useInterface<ILogger>(), provider: ConsoleLogger, lifecycle: 'singleton' }
-  ]
-});
-
-// TestModule - Override with MockLogger, scoped to this container
-const testModule = defineBuilderConfig({
-  name: 'TestModule',
-  useContainer: sharedKernel,
-  injections: [
-    { 
-      token: useInterface<ILogger>(), 
-      provider: MockLogger,
-      lifecycle: 'transient',  // Can use different lifecycle than parent
-      scoped: true         // 👈 Allows override without duplicate error
-    },
-    { token: UserService }  // Uses MockLogger from this container
-  ]
-});
-```
-
-**Behavior:**
-
-| Scenario | Without `scoped` | With `scoped: true` |
-|----------|------------------|---------------------|
-| Token exists in parent | ❌ Duplicate error | ✅ Override locally |
-| Token does not exist in parent | ✅ OK | ✅ OK |
-| Resolution | Delegates to parent | Uses local instance |
-
-**Use Cases:**
-- 🧪 **Testing**: Override production services with mocks
-- 🔧 **Module isolation**: Each module has its own instance
-- ⚙️ **Different lifecycle**: Parent uses singleton, child uses transient
-
----
-
-## Generated Code Example
-
-To understand how Neo-Syringe works, here's what your code looks like **before** and **after** compilation.
-
-### Before (Your Configuration)
-
-```typescript
-// config.ts
-import { defineBuilderConfig, useInterface, useProperty } from '@djodjonx/neo-syringe';
-
-interface ILogger { log(msg: string): void; }
-class ConsoleLogger implements ILogger { 
-  log(msg: string) { console.log(msg); } 
-}
-
-class ApiService {
-  constructor(
-    private logger: ILogger,
-    private apiUrl: string
-  ) {}
-}
-
-const apiUrl = useProperty<string>(ApiService, 'apiUrl');
 
 export const container = defineBuilderConfig({
-  name: 'AppContainer',
-  injections: [
-    { token: useInterface<ILogger>(), provider: ConsoleLogger },
-    { token: apiUrl, provider: () => process.env.API_URL ?? 'http://localhost' },
-    { token: ApiService }
-  ]
-});
-```
-
-### After (Generated Code)
-
-The build plugin replaces `defineBuilderConfig(...)` with an optimized container class:
-
-```typescript
-// config.ts (after build)
-import * as Import_0 from './services';
-
-// -- Factories (generated) --
-function create_ILogger(container: NeoContainer) {
-  return new Import_0.ConsoleLogger();
-}
-
-function create_ApiService_apiUrl(container: NeoContainer) {
-  const userFactory = () => process.env.API_URL ?? 'http://localhost';
-  return userFactory(container);
-}
-
-function create_ApiService(container: NeoContainer) {
-  return new Import_0.ApiService(
-    container.resolve("ILogger"),
-    container.resolve("PropertyToken:ApiService.apiUrl")
-  );
-}
-
-// -- Container (generated) --
-export class NeoContainer {
-  private instances = new Map<any, any>();
-
-  constructor(
-    private parent?: any,
-    private legacy?: any[],
-    private name: string = 'AppContainer'
-  ) {}
-
-  public resolve(token: any): any {
-    const result = this.resolveLocal(token);
-    if (result !== undefined) return result;
-
-    if (this.parent) {
-      try { return this.parent.resolve(token); } 
-      catch (e) { /* fallback */ }
-    }
-
-    throw new Error(`[${this.name}] Service not found: ${token}`);
-  }
-
-  private resolveLocal(token: any): any {
-    // Interface token (string)
-    if (token === "ILogger") {
-      if (!this.instances.has("ILogger")) {
-        this.instances.set("ILogger", create_ILogger(this));
-      }
-      return this.instances.get("ILogger");
-    }
-
-    // PropertyToken (string)
-    if (token === "PropertyToken:ApiService.apiUrl") {
-      if (!this.instances.has("PropertyToken:ApiService.apiUrl")) {
-        this.instances.set("PropertyToken:ApiService.apiUrl", create_ApiService_apiUrl(this));
-      }
-      return this.instances.get("PropertyToken:ApiService.apiUrl");
-    }
-
-    // Class token (reference)
-    if (token === Import_0.ApiService) {
-      if (!this.instances.has(Import_0.ApiService)) {
-        this.instances.set(Import_0.ApiService, create_ApiService(this));
-      }
-      return this.instances.get(Import_0.ApiService);
-    }
-
-    return undefined;
-  }
-}
-
-export const container = new NeoContainer();
-```
-
-### Key Observations
-
-| Aspect | Before | After |
-|--------|--------|-------|
-| **Resolution** | Runtime lookup | Direct `new` calls |
-| **Interfaces** | Type-erased | String IDs generated |
-| **Dependencies** | Analyzed at runtime | Hardcoded in factories |
-| **Container size** | Full DI library | ~50 lines of code |
-| **Performance** | Map lookups + reflection | Direct instantiation |
-
-> 💡 **The generated code has zero dependencies** - no DI library shipped to production!
-
----
-
-## Advanced Features
-
-### Parent Container (`useContainer`)
-
-Neo-Syringe supports **hierarchical containers**. A child container can delegate resolution to a parent container for tokens it doesn't define locally.
-
-#### Example: SharedKernel Architecture
-
-Perfect for modular applications where core services are shared across bounded contexts.
-
-```typescript
-// shared-kernel/container.ts
-import { defineBuilderConfig, useInterface } from '@djodjonx/neo-syringe';
-
-// Shared interfaces
-export interface ILogger { log(msg: string): void; }
-export interface IEventBus { publish(event: any): void; }
-
-class ConsoleLogger implements ILogger {
-  log(msg: string) { console.log(`[LOG] ${msg}`); }
-}
-
-class InMemoryEventBus implements IEventBus {
-  publish(event: any) { console.log('Event:', event); }
-}
-
-// SharedKernel container - reusable across modules
-export const sharedKernel = defineBuilderConfig({
-  name: 'SharedKernel',
   injections: [
     { token: useInterface<ILogger>(), provider: ConsoleLogger },
-    { token: useInterface<IEventBus>(), provider: InMemoryEventBus }
-  ]
-});
-```
-
-```typescript
-// user-module/container.ts
-import { defineBuilderConfig, useInterface } from '@djodjonx/neo-syringe';
-import { sharedKernel, ILogger, IEventBus } from '../shared-kernel/container';
-
-// User module services
-class UserRepository {
-  findById(id: string) { return { id, name: 'John' }; }
-}
-
-class UserService {
-  constructor(
-    private logger: ILogger,      // From SharedKernel!
-    private eventBus: IEventBus,  // From SharedKernel!
-    private repo: UserRepository  // Local to this module
-  ) {}
-}
-
-export const userModule = defineBuilderConfig({
-  name: 'UserModule',
-  useContainer: sharedKernel,  // 👈 Inherit from SharedKernel
-  injections: [
-    { token: UserRepository },
     { token: UserService }
   ]
 });
-```
-
-```typescript
-// order-module/container.ts
-import { defineBuilderConfig, useInterface } from '@djodjonx/neo-syringe';
-import { sharedKernel, ILogger } from '../shared-kernel/container';
-
-class OrderService {
-  constructor(private logger: ILogger) {}  // From SharedKernel!
-}
-
-export const orderModule = defineBuilderConfig({
-  name: 'OrderModule',
-  useContainer: sharedKernel,  // 👈 Same SharedKernel, different module
-  injections: [
-    { token: OrderService }
-  ]
-});
-```
-
-```typescript
-// main.ts
-import { userModule } from './user-module/container';
-import { orderModule } from './order-module/container';
-
-// Both modules share the same ILogger and IEventBus instances!
-const userService = userModule.resolve(UserService);
-const orderService = orderModule.resolve(OrderService);
-```
-
-#### Multi-Level Hierarchy
-
-You can chain containers for complex architectures:
 
-```typescript
-// Level 1: Infrastructure
-const infrastructure = defineBuilderConfig({
-  name: 'Infrastructure',
-  injections: [
-    { token: useInterface<ILogger>(), provider: ConsoleLogger },
-    { token: useInterface<IDatabase>(), provider: PostgresDatabase }
-  ]
-});
-
-// Level 2: Domain (inherits Infrastructure)
-const domain = defineBuilderConfig({
-  name: 'Domain',
-  useContainer: infrastructure,
-  injections: [
-    { token: UserRepository },
-    { token: OrderRepository }
-  ]
-});
-
-// Level 3: Application (inherits Domain + Infrastructure)
-const application = defineBuilderConfig({
-  name: 'Application',
-  useContainer: domain,  // Gets Domain AND Infrastructure!
-  injections: [
-    { token: UserService },
-    { token: OrderService }
-  ]
-});
-```
-
----
-
-### Legacy Migration (`useContainer`)
-
-The same `useContainer` mechanism works with legacy DI containers (tsyringe, InversifyJS, Awilix). Neo-Syringe can delegate resolution to any container that has a `resolve()` method.
-
-#### Example with tsyringe
-
-```typescript
-// legacy-container.ts (existing tsyringe setup)
-import 'reflect-metadata';
-import { container, injectable } from 'tsyringe';
-
-@injectable()
-export class AuthService {
-  validateToken(token: string) { return true; }
-}
-
-@injectable()
-export class LegacyUserRepository {
-  findById(id: string) { return { id, name: 'John' }; }
-}
-
-// Register in tsyringe
-container.registerSingleton(AuthService);
-container.registerSingleton(LegacyUserRepository);
-
-export { container as legacyContainer };
-```
-
-```typescript
-// container.ts (neo-syringe bridging to tsyringe)
-import { defineBuilderConfig, declareContainerTokens, useInterface } from '@djodjonx/neo-syringe';
-import { legacyContainer, AuthService, LegacyUserRepository } from './legacy-container';
-
-// Declare what the legacy container provides (for type-safety)
-const legacy = declareContainerTokens<{
-  AuthService: AuthService;
-  LegacyUserRepository: LegacyUserRepository;
-}>(legacyContainer);
-
-// New services using Neo-Syringe
-interface ILogger { log(msg: string): void; }
-class ConsoleLogger implements ILogger {
-  log(msg: string) { console.log(msg); }
-}
-
-class UserService {
-  constructor(
-    private auth: AuthService,           // From legacy container!
-    private repo: LegacyUserRepository,  // From legacy container!
-    private logger: ILogger              // From neo-syringe
-  ) {}
-}
-
-export const appContainer = defineBuilderConfig({
-  name: 'AppContainer',
-  useContainer: legacy,  // 👈 Bridge to legacy container
-  injections: [
-    { token: useInterface<ILogger>(), provider: ConsoleLogger },
-    { token: UserService }  // Dependencies resolved from both containers!
-  ]
-});
-```
-
-```typescript
-// main.ts
-import { appContainer } from './container';
-
-const userService = appContainer.resolve(UserService);
-// ✅ AuthService and LegacyUserRepository come from tsyringe
-// ✅ ILogger comes from neo-syringe
+// Use it
+const userService = container.resolve(UserService);
 ```
 
-#### Example with InversifyJS
+At build time, this generates optimized factory functions. **Zero DI library shipped to production!**
 
-```typescript
-// legacy-inversify.ts
-import 'reflect-metadata';
-import { Container, injectable } from 'inversify';
+## 📖 Documentation
 
-@injectable()
-class DatabaseConnection {
-  query(sql: string) { return []; }
-}
+For complete documentation, visit **[djodjonx.github.io/neo-syringe](https://djodjonx.github.io/neo-syringe/)**
 
-const inversifyContainer = new Container();
-inversifyContainer.bind(DatabaseConnection).toSelf().inSingletonScope();
+| Topic | Description |
+|-------|-------------|
+| [Getting Started](https://djodjonx.github.io/neo-syringe/guide/getting-started) | Installation and first container |
+| [Why Neo-Syringe?](https://djodjonx.github.io/neo-syringe/guide/why-neo-syringe) | Comparison with traditional DI |
+| [Injection Types](https://djodjonx.github.io/neo-syringe/guide/injection-types) | Classes, interfaces, factories, primitives |
+| [Lifecycle](https://djodjonx.github.io/neo-syringe/guide/lifecycle) | Singleton vs transient |
+| [Scoped Injections](https://djodjonx.github.io/neo-syringe/guide/scoped-injections) | Override parent container tokens |
+| [Parent Container](https://djodjonx.github.io/neo-syringe/guide/parent-container) | SharedKernel architecture |
+| [Legacy Migration](https://djodjonx.github.io/neo-syringe/guide/legacy-migration) | Bridge tsyringe, InversifyJS |
+| [Generated Code](https://djodjonx.github.io/neo-syringe/guide/generated-code) | What the compiler produces |
+| [CLI Validator](https://djodjonx.github.io/neo-syringe/guide/cli) | Validate in CI/CD |
+| [IDE Plugin](https://djodjonx.github.io/neo-syringe/guide/ide-plugin) | Real-time error detection |
+| [API Reference](https://djodjonx.github.io/neo-syringe/api/types) | Types and functions |
+
+## 🔧 Build Plugin Setup
 
-export { inversifyContainer, DatabaseConnection };
-```
+<details>
+<summary><strong>Vite</strong></summary>
 
 ```typescript
-// container.ts
-import { defineBuilderConfig, declareContainerTokens } from '@djodjonx/neo-syringe';
-import { inversifyContainer, DatabaseConnection } from './legacy-inversify';
-
-const legacy = declareContainerTokens<{
-  DatabaseConnection: DatabaseConnection;
-}>(inversifyContainer);
-
-class ReportService {
-  constructor(private db: DatabaseConnection) {} // From Inversify!
-}
+import { neoSyringePlugin } from '@djodjonx/neo-syringe/plugin';
 
-export const container = defineBuilderConfig({
-  useContainer: legacy,
-  injections: [
-    { token: ReportService }
-  ]
+export default defineConfig({
+  plugins: [neoSyringePlugin.vite()]
 });
 ```
+</details>
 
-#### How Resolution Works
-
-When `container.resolve(Token)` is called:
-
-```
-1. Neo-Syringe checks its own registrations
-   └── Found? → Return instance
-   └── Not found? ↓
-
-2. Delegate to parent container (useContainer)
-   └── Found? → Return instance
-   └── Not found? ↓
-
-3. Throw "Service not found" error
-```
-
-> 💡 **Migration Strategy**: Start by bridging your entire legacy container, then gradually move services to Neo-Syringe. Once all services are migrated, remove `useContainer`.
-
-#### How Legacy Bridging Works Internally
-
-**At Compile-Time:**
-
-1. `declareContainerTokens<T>()` is analyzed
-2. The type `T` properties are extracted (e.g., `{ AuthService, UserRepo }`)
-3. These tokens are added to `parentProvidedTokens`
-4. The GraphValidator accepts these as valid dependencies
-5. The Generator outputs: `new NeoContainer(undefined, [legacyContainer], 'MyApp')`
-
-**At Runtime:**
-
-```typescript
-// Generated code (simplified)
-class NeoContainer {
-  constructor(
-    private parent?: any,
-    private legacy?: any[],  // ← Your tsyringe/inversify container
-    private name?: string
-  ) {}
-
-  resolve(token: any): any {
-    // 1. Try local resolution
-    const local = this.resolveLocal(token);
-    if (local !== undefined) return local;
-
-    // 2. Delegate to legacy containers
-    if (this.legacy) {
-      for (const container of this.legacy) {
-        try {
-          return container.resolve(token);  // ← Calls tsyringe.resolve()!
-        } catch (e) { /* try next */ }
-      }
-    }
-
-    throw new Error(`Service not found: ${token}`);
-  }
-}
-```
-
-**Validation Features:**
-
-| Check | Description |
-|-------|-------------|
-| ✅ Missing binding | Error if dependency not in local OR legacy container |
-| ✅ Duplicate detection | Error if token already registered in parent/legacy |
-| ✅ Type safety | `declareContainerTokens<T>()` provides TypeScript types |
-
-### Partials (Modular Config)
-
-Split configuration into reusable blocks.
+<details>
+<summary><strong>Rollup</strong></summary>
 
 ```typescript
-// logging.partial.ts
-export const loggingConfig = definePartialConfig({
-  injections: [
-    { token: useInterface<ILogger>(), provider: ConsoleLogger }
-  ]
-});
+import { neoSyringePlugin } from '@djodjonx/neo-syringe/plugin';
 
-// app.config.ts
-export const appConfig = defineBuilderConfig({
-  extends: [loggingConfig], // Inherit injections
-  injections: [
-    { token: UserService }
-  ]
-});
+export default {
+  plugins: [neoSyringePlugin.rollup()]
+};
 ```
+</details>
 
-### CLI Validator
-
-Validate your dependency graph in CI/CD pipelines.
-
-```bash
-npx neo-syringe
-```
+<details>
+<summary><strong>Webpack</strong></summary>
 
-**Output:**
-```
-Analyzing project: /path/to/tsconfig.json
-🔍 Extracting dependency graph...
-   Found 45 services.
-🛡️  Validating graph...
-✅ Validation passed! No circular dependencies or missing bindings found.
+```javascript
+module.exports = {
+  plugins: [require('@djodjonx/neo-syringe/plugin').webpack()]
+};
 ```
+</details>
 
----
-
-## IDE Plugin for Real-Time Validation
-
-Get immediate feedback on configuration errors.
+## 🛡️ IDE Support
 
-### 1. Add the plugin to `tsconfig.json`
+Add to `tsconfig.json` for real-time error detection:
 
 ```json
 {
@@ -831,35 +152,7 @@ Get immediate feedback on configuration errors.
 }
 ```
 
-### 2. Use Workspace TypeScript
-
-In VS Code: `Ctrl+Shift+P` → "TypeScript: Select TypeScript Version" → "Use Workspace Version"
-
-### Detected Errors
-
-| Error | Message |
-| :--- | :--- |
-| 🔴 **Circular Dependency** | `[Neo-Syringe] Circular dependency detected: A -> B -> A` |
-| 🔴 **Missing Binding** | `[Neo-Syringe] Missing binding: 'Service' depends on 'I', but no provider registered.` |
-| 🔴 **Duplicate** | `[Neo-Syringe] Duplicate registration: 'Service' is already registered.` |
-
----
-
-## Troubleshooting
-
-### The plugin doesn't detect errors
-
-1. Verify TypeScript uses the workspace version
-2. Restart the TypeScript server (`Cmd+Shift+P` → "TypeScript: Restart TS Server")
-3. Check that `@djodjonx/neo-syringe/lsp` is in your `tsconfig.json` plugins
-
-### Build plugin not working
-
-Ensure `unplugin` is installed and the plugin is correctly configured in your bundler.
-
----
-
-## License
+## 📄 License
 
 MIT