### Start Container Instance with Scoped Container API - start()

Source: https://context7.com/moeru-ai/injeca/llms.txt

The start() function initiates a specific container instance, triggering its lifecycle hooks and invocations. This process is independent of other containers. It allows for setup and teardown logic to be managed per container, ensuring isolated resource management.

```typescript
import { createContainer, provide, invoke, start, lifecycle } from 'injeca'

async function createRequestHandler() {
  const requestContainer = createContainer()

  const requestId = provide(requestContainer, 'requestId', () =>
    crypto.randomUUID()
  )

  const database = provide(requestContainer, {
    dependsOn: { requestId, lifecycle },
    build({ dependsOn }) {
      const conn = createDbConnection()

      dependsOn.lifecycle.appHooks.onStart(async () => {
        await conn.connect()
        console.log(`DB connected for request ${dependsOn.requestId}`)
      })

      dependsOn.lifecycle.appHooks.onStop(async () => {
        await conn.close()
        console.log(`DB closed for request ${dependsOn.requestId}`)
      })

      return conn
    }
  })

  invoke(requestContainer, {
    dependsOn: { database, requestId },
    async callback({ database, requestId }) {
      const result = await database.query('SELECT NOW()')
      console.log(`Request ${requestId} result:`, result)
    }
  })

  // Start this request's container
  await start(requestContainer)

  return requestContainer
}

// Each request gets its own isolated container
const req1 = await createRequestHandler()
const req2 = await createRequestHandler()
```

--------------------------------

### Start Global Container with HTTP Server and Lifecycle Hooks

Source: https://context7.com/moeru-ai/injeca/llms.txt

Starts the global container, executing lifecycle onStart hooks in dependency order, then running all registered invocations. This example creates an HTTP server with startup and shutdown hooks, registers an invocation to log server readiness, and includes graceful shutdown handling.

```typescript
import { createServer } from 'node:http'
import { injeca, lifecycle } from 'injeca'

const server = injeca.provide({
  dependsOn: { lifecycle },
  async build({ dependsOn }) {
    const app = createServer((req, res) => {
      res.writeHead(200, { 'Content-Type': 'text/plain' })
      res.end('Hello World\n')
    })

    dependsOn.lifecycle.appHooks.onStart(() => {
      return new Promise((resolve) => {
        app.listen(3000, () => {
          console.log('Server listening on port 3000')
          resolve()
        })
      })
    })

    dependsOn.lifecycle.appHooks.onStop(() => {
      return new Promise((resolve) => {
        app.close(() => {
          console.log('Server closed')
          resolve()
        })
      })
    })

    return app
  }
})

injeca.invoke({
  dependsOn: { server },
  callback({ server }) {
    console.log('Server instance ready:', server.address())
  }
})

// Start all services in dependency order
await injeca.start()

// Graceful shutdown on SIGINT
process.once('SIGINT', async () => {
  await injeca.stop()
  process.exit(0)
})
```

--------------------------------

### Register Global Invocation with Dependencies and Start Container

Source: https://context7.com/moeru-ai/injeca/llms.txt

Registers a callback to be executed when the container starts, after all lifecycle onStart hooks. Dependencies are resolved automatically. This example defines providers for config and an API client, then registers an invocation to use them.

```typescript
import { injeca } from 'injeca'

// Define providers
const config = injeca.provide('config', () => ({ apiKey: 'secret123' }))
const apiClient = injeca.provide({
  dependsOn: { config },
  build({ dependsOn }) {
    return createApiClient(dependsOn.config.apiKey)
  }
})

// Register invocation with dependencies
injeca.invoke({
  dependsOn: { apiClient, config },
  async callback({ apiClient, config }) {
    const response = await apiClient.fetchData()
    console.log('Application started with config:', config)
    console.log('Initial data:', response)
  }
})

// Start the container to execute invocations
await injeca.start()
```

--------------------------------

### Install Injeca Package

Source: https://github.com/moeru-ai/injeca/blob/main/README.md

Installs the Injeca package using various package managers like npm, pnpm, bun, ni, and yarn. Ensure you have one of these package managers installed to run the command.

```sh
npm install injeca
pnpm add injeca
bun add injeca
ni injeca
yarn add injeca
```

--------------------------------

### Basic Usage: Global Container with HTTP Server

Source: https://github.com/moeru-ai/injeca/blob/main/README.md

Demonstrates basic usage of Injeca with a global singleton container. It registers a configuration provider, an HTTP server provider that depends on the config, and invokes a callback to log the server address. The application lifecycle is managed using start() and stop().

```typescript
import { createServer } from 'node:http'

import { injeca, lifecycle } from 'injeca'

// Providers return a value once and are cached inside the container.
const config = injeca.provide('config', () => ({ port: 3000 }))

const server = injeca.provide({
  dependsOn: { config, lifecycle },
  async build({ dependsOn }) {
    const { config, lifecycle } = dependsOn
    const app = createServer()

    lifecycle.appHooks.onStart(() => app.listen(config.port))
    lifecycle.appHooks.onStop(() => app.close())

    return app
  },
})

injeca.invoke({
  dependsOn: { server },
  async callback({ server }) {
    // eslint-disable-next-line no-console
    console.log('HTTP server ready:', await server.address())
  },
})

await injeca.start()

process.once('SIGINT', async () => {
  await injeca.stop()
})
```

--------------------------------

### Implementing a Custom Logger for Injeca

Source: https://context7.com/moeru-ai/injeca/llms.txt

Provides a guide to creating a custom logger by implementing the 'Logger' interface provided by Injeca. This allows full control over how and where log messages are sent, integrating with external logging services or custom logging logic.

```typescript
import { createContainer } from 'injeca'
import type { Logger } from 'injeca'

const customLogger: Logger = {
  provide: (name: string, dependencies: string[]) => {
    // Custom logic for when a provider is registered
    myLoggingService.info('Provider registered', { name, dependencies })
  },
  invoke: (dependencies: string[]) => {
    myLoggingService.info('Invocation registered', { dependencies })
  },
  beforeRun: (name: string) => {
    myLoggingService.debug('Building provider', { name })
  },
  run: (name: string, duration: number) => {
    myLoggingService.info('Provider built', { name, duration })
  },
  hookOnStart: (name: string) => {
    myLoggingService.debug('Starting service', { name })
  },
  hookOnStartComplete: (name: string, duration: number) => {
    myLoggingService.info('Service started', { name, duration })
  },
  hookOnStop: (name: string) => {
    myLoggingService.debug('Stopping service', { name })
  },
  hookOnStopComplete: (name: string, duration: number) => {
    myLoggingService.info('Service stopped', { name, duration })
  },
  running: () => {
    myLoggingService.info('Application running')
  }
}

const container = createContainer({ logger: customLogger })
```

--------------------------------

### Register Global Providers with Dependencies and Lifecycle Hooks

Source: https://context7.com/moeru-ai/injeca/llms.txt

Registers providers in the global singleton container. Providers are lazily instantiated and cached, with automatic dependency resolution. This example shows a simple config provider, a database provider with a shutdown hook, and a server provider with startup and shutdown hooks.

```typescript
import { injeca, lifecycle } from 'injeca'

// Simple provider without dependencies
const config = injeca.provide('config', () => ({
  port: 3000,
  host: 'localhost',
  dbUrl: 'postgresql://localhost/mydb'
}))

// Provider with dependencies and lifecycle hooks
const database = injeca.provide({
  dependsOn: { config, lifecycle },
  async build({ dependsOn }) {
    const db = await connectToDatabase(dependsOn.config.dbUrl)

    // Register cleanup hook
    dependsOn.lifecycle.appHooks.onStop(async () => {
      await db.close()
    })

    return db
  }
})

// Provider depending on other providers
const server = injeca.provide({
  dependsOn: { config, database, lifecycle },
  async build({ dependsOn }) {
    const app = createHttpServer({
      port: dependsOn.config.port,
      db: dependsOn.database
    })

    dependsOn.lifecycle.appHooks.onStart(() => {
      app.listen(dependsOn.config.port)
    })

    dependsOn.lifecycle.appHooks.onStop(() => {
      app.close()
    })

    return app
  }
})
```

--------------------------------

### Global Container API - injeca.resolve()

Source: https://context7.com/moeru-ai/injeca/llms.txt

Resolves dependencies directly from the global container without starting it or invoking any lifecycle hooks. This is useful for testing specific components or manually accessing dependencies.

```APIDOC
## Global Container API - injeca.resolve()

### Description
Resolve dependencies directly without starting the container or executing invocations, useful for testing or manual dependency access.

### Method
`await`

### Endpoint
N/A (Global function)

### Parameters
- **dependencies** (object) - Required - An object where keys are the desired dependency names and values are their providers or factory functions.

### Request Example
```typescript
import { injeca } from 'injeca';

const database = injeca.provide('db', () => ({ query: async (sql: string) => [{ id: 1, name: 'User' }] }));
const userRepository = injeca.provide({
  dependsOn: { database },
  build({ dependsOn }) {
    return { findAll: () => dependsOn.database.query('SELECT * FROM users') };
  }
});

// Resolve without starting container
const { userRepository: repo } = await injeca.resolve({ userRepository });

const users = await repo.findAll();
console.log('Users:', users);
```

### Response
- **resolvedDependencies** (object) - An object containing the resolved dependencies.
```

--------------------------------

### Resolve Dependencies Without Starting Container - injeca.resolve()

Source: https://context7.com/moeru-ai/injeca/llms.txt

Resolves dependencies directly from the global Injeca container without initiating the container's start sequence or triggering lifecycle hooks. This is ideal for testing scenarios or when manual access to dependencies is required. It takes an object mapping desired dependency names to their configurations.

```typescript
import { injeca } from 'injeca'

const database = injeca.provide('db', () => ({
  query: async (sql: string) => [{ id: 1, name: 'User' }]
}))

const userRepository = injeca.provide({
  dependsOn: { database },
  build({ dependsOn }) {
    return {
      findAll: () => dependsOn.database.query('SELECT * FROM users')
    }
  }
})

// Resolve without starting container (no lifecycle hooks triggered)
const { userRepository: repo } = await injeca.resolve({ userRepository })

const users = await repo.findAll()
console.log('Users:', users) // [{ id: 1, name: 'User' }]
```

--------------------------------

### Register Callbacks with Scoped Container API - invoke()

Source: https://context7.com/moeru-ai/injeca/llms.txt

The invoke() function registers a callback to be executed when a specific container starts. This is useful for performing container-specific initialization logic. It depends on services provided within the container and can be called multiple times to register several invocation callbacks.

```typescript
import { createContainer, provide, invoke, start } from 'injeca'

const requestContainer = createContainer()

const userId = provide(requestContainer, 'userId', () => 'user-123')
const requestLogger = provide(requestContainer, 'logger', () => ({
  log: (msg: string) => console.log(`[user-123] ${msg}`)
}))

const session = provide(requestContainer, {
  dependsOn: { userId, requestLogger },
  build({ dependsOn }) {
    dependsOn.requestLogger.log('Creating session')
    return {
      userId: dependsOn.userId,
      createdAt: new Date()
    }
  }
})

// Multiple invocations can be registered
invoke(requestContainer, {
  dependsOn: { session, requestLogger },
  callback({ session, requestLogger }) {
    requestLogger.log(`Session created at ${session.createdAt}`)
  }
})

invoke(requestContainer, {
  dependsOn: { session },
  callback({ session }) {
    console.log('Session ready for user:', session.userId)
  }
})

await start(requestContainer)
```

--------------------------------

### Manual Containers: Creating and Using Custom Containers

Source: https://github.com/moeru-ai/injeca/blob/main/README.md

Illustrates how to create and use manual containers in Injeca for scenarios requiring multiple independent containers, such as in testing. It shows how to create a container, register a token provider, invoke a callback with the token, and manage the container's lifecycle.

```typescript
import { createContainer, invoke, provide, start, stop } from 'injeca'

const container = createContainer()

const token = provide(container, 'token', () => crypto.randomUUID())

invoke(container, {
  dependsOn: { token },
  // eslint-disable-next-line no-console
  callback: ({ token }) => console.log('token', token),
})

await start(container)
await stop(container)
```

--------------------------------

### Registering Service Lifecycle Hooks with Injeca

Source: https://context7.com/moeru-ai/injeca/llms.txt

Demonstrates how to use the 'lifecycle' provider to register startup and shutdown callbacks for services. This allows for graceful initialization and cleanup of resources like databases or message queues. The hooks execute in reverse order of registration during shutdown.

```typescript
import { injeca, lifecycle } from 'injeca'

const redisCache = injeca.provide({
  dependsOn: { lifecycle },
  build({ dependsOn }) {
    const redis = createRedisClient()

    // Startup hook
    dependsOn.lifecycle.appHooks.onStart(async () => {
      await redis.connect()
      await redis.ping()
      console.log('Redis connected and ready')
    })

    // Shutdown hook
    dependsOn.lifecycle.appHooks.onStop(async () => {
      await redis.quit()
      console.log('Redis connection closed')
    })

    return redis
  }
})

const messageQueue = injeca.provide({
  dependsOn: { lifecycle, redisCache },
  build({ dependsOn }) {
    const queue = createQueue(dependsOn.redisCache)

    dependsOn.lifecycle.appHooks.onStart(async () => {
      await queue.start()
      console.log('Message queue started')
    })

    dependsOn.lifecycle.appHooks.onStop(async () => {
      await queue.drain()
      await queue.stop()
      console.log('Message queue stopped')
    })

    return queue
  }
})

await injeca.start()
// Logs:
// Redis connected and ready
// Message queue started

await injeca.stop()
// Logs:
// Message queue stopped (stops first, reverse order)
// Redis connection closed
```

--------------------------------

### Scoped Container API - provide()

Source: https://context7.com/moeru-ai/injeca/llms.txt

Registers a provider within a specific container instance. This function is analogous to `injeca.provide()` but allows for explicit control over which container the provider is registered in.

```APIDOC
## Scoped Container API - provide()

### Description
Register a provider in a specific container instance, identical to injeca.provide() but with explicit container control.

### Method
`provide(container: Container, nameOrOptions: string | ProviderOptions, providerFn?: ProviderFn): ProviderInstance`

### Endpoint
N/A (Global function)

### Parameters
- **container** (Container) - Required - The specific container instance to register the provider in.
- **nameOrOptions** (string | ProviderOptions) - Required - Either the name of the provider (string) or an options object for more complex configurations.
- **providerFn** (ProviderFn) - Optional - The function that builds the dependency. Only required if `nameOrOptions` is a string.

### Request Example
```typescript
import { createContainer, provide, lifecycle } from 'injeca';

const testContainer = createContainer({ enabled: false });

// Named provider registration
const config = provide(testContainer, 'config', () => ({
  environment: 'test',
  timeout: 5000
}));

// Provider with dependencies and build function
const httpClient = provide(testContainer, 'httpClient', {
  dependsOn: { config },
  build({ dependsOn }) {
    return {
      timeout: dependsOn.config.timeout,
      get: async (url: string) => fetch(url)
    };
  }
});

// Provider with lifecycle hooks and auto-generated name
const worker = provide(testContainer, {
  dependsOn: { httpClient, lifecycle },
  async build({ dependsOn }) {
    const worker = {
      start: () => console.log('Worker started'),
      stop: () => console.log('Worker stopped')
    };

    dependsOn.lifecycle.appHooks.onStart(() => worker.start());
    dependsOn.lifecycle.appHooks.onStop(() => worker.stop());

    return worker;
  }
});
```

### Response
- **providerInstance** (ProviderInstance) - The registered provider instance.
```

--------------------------------

### Integrating @guiiai/logg with Injeca Logger

Source: https://context7.com/moeru-ai/injeca/llms.txt

Sets up Injeca to use a logger compatible with the '@guiiai/logg' library for structured logging. This allows leveraging Logg's advanced features like custom levels, pretty printing, and context propagation for all Injeca-related logs.

```typescript
import { createContainer, createLoggLogger } from 'injeca'
import { Logg } from '@guiiai/logg'

const logg = new Logg({
  name: 'my-application',
  level: 'debug',
  pretty: true
})

const logger = createLoggLogger(logg)

const container = createContainer({ logger })

// All injeca logs will go through the Logg instance
// with proper formatting and log levels
```

--------------------------------

### Register Provider in Scoped Container - provide()

Source: https://context7.com/moeru-ai/injeca/llms.txt

Registers a provider within a specific container instance, offering explicit control over dependency management, similar to the global `injeca.provide()`. Supports named providers, providers with dependencies, and providers integrated with the lifecycle. Providers registered this way are local to the specified container.

```typescript
import { createContainer, provide, lifecycle } from 'injeca'

const testContainer = createContainer({ enabled: false })

// Named provider
const config = provide(testContainer, 'config', () => ({
  environment: 'test',
  timeout: 5000
}))

// Provider with dependencies (typed)
const httpClient = provide(testContainer, 'httpClient', {
  dependsOn: { config },
  build({ dependsOn }) {
    return {
      timeout: dependsOn.config.timeout,
      get: async (url: string) => fetch(url)
    }
  }
})

// Provider with lifecycle and auto-generated name
const worker = provide(testContainer, {
  dependsOn: { httpClient, lifecycle },
  async build({ dependsOn }) {
    const worker = {
      start: () => console.log('Worker started'),
      stop: () => console.log('Worker stopped')
    }

    dependsOn.lifecycle.appHooks.onStart(() => worker.start())
    dependsOn.lifecycle.appHooks.onStop(() => worker.stop())

    return worker
  }
})
```

--------------------------------

### Creating Default Console Logger for Injeca Container

Source: https://context7.com/moeru-ai/injeca/llms.txt

Configures Injeca to use a default logger that outputs formatted messages to the console for all container lifecycle events. This logger is suitable for development and debugging, providing visibility into the DI process.

```typescript
import { createContainer, createDefaultLogger } from 'injeca'

// Default logger outputs to console with formatted messages
const logger = createDefaultLogger()

const container = createContainer({ logger })

// Logger will output:
// [injeca] PROVIDE    config
// [injeca] BEFORE RUN provide: config()
// [injeca] RUN        provide: config() in 0.123ms
// [injeca] HOOK OnStart        server() executing
// [injeca] HOOK OnStart        server() ran successfully in 45.678ms
// [injeca] RUNNING
```

--------------------------------

### Configure Global Logger with injeca.setLogger() in TypeScript

Source: https://context7.com/moeru-ai/injeca/llms.txt

Sets a custom logger for the global injeca container. This allows for runtime configuration of logging behavior, which is useful for observing dependency resolution and lifecycle events. It requires importing 'injeca' and a logger implementation like '@guiiai/logg'. The output is the configured global container that uses the specified logger.

```typescript
import { injeca, createLoggLogger } from 'injeca'
import { Logg } from '@guiiai/logg'

// Configure custom logger for global container
const logg = new Logg({ name: 'app', level: 'info' })
injeca.setLogger(createLoggLogger(logg))

// All subsequent global container operations use the custom logger
injeca.provide('service', () => ({ active: true }))
await injeca.start()
```

--------------------------------

### Create Scoped Container Instance - createContainer()

Source: https://context7.com/moeru-ai/injeca/llms.txt

Creates an isolated Injeca container instance, suitable for testing, managing per-request scopes, or supporting multi-tenant applications. Options include enabling/disabling logging and providing a custom logger instance. Providers and lifecycle hooks are scoped to this container.

```typescript
import { createContainer, provide, invoke, start, stop, lifecycle } from 'injeca'

// Create container with logging enabled (default)
const container1 = createContainer()

// Create container with logging disabled
const container2 = createContainer({ enabled: false })

// Create container with custom logger
import { createLoggLogger } from 'injeca'
import { Logg } from '@guiiai/logg'

const customLogger = createLoggLogger(new Logg({ name: 'my-app' }))
const container3 = createContainer({ logger: customLogger })

// Use the scoped container
const config = provide(container1, 'config', () => ({ env: 'test' }))

const service = provide(container1, {
  dependsOn: { config, lifecycle },
  build({ dependsOn }) {
    dependsOn.lifecycle.appHooks.onStart(() => {
      console.log('Service starting with env:', dependsOn.config.env)
    })
    return { name: 'TestService' }
  }
})

invoke(container1, {
  dependsOn: { service },
  callback({ service }) {
    console.log('Service ready:', service.name)
  }
})

await start(container1)
await stop(container1)
```

--------------------------------

### Scoped Container API - createContainer()

Source: https://context7.com/moeru-ai/injeca/llms.txt

Creates a new, isolated container instance. These instances are useful for scenarios like testing, per-request scopes, or managing dependencies in multi-tenant applications.

```APIDOC
## Scoped Container API - createContainer()

### Description
Create a new isolated container instance for testing, per-request scopes, or multi-tenant applications.

### Method
`createContainer(options?: CreateContainerOptions)`

### Endpoint
N/A (Global function)

### Parameters
- **options** (object) - Optional - Configuration options for the container.
  - **enabled** (boolean) - Optional - Whether logging is enabled for this container. Defaults to `true`.
  - **logger** (Logger) - Optional - A custom logger instance to use. If not provided and `enabled` is `true`, a default logger is created.

### Request Example
```typescript
import { createContainer, provide, invoke, start, stop, lifecycle } from 'injeca';

// Create container with default logging enabled
const container1 = createContainer();

// Create container with logging disabled
const container2 = createContainer({ enabled: false });

// Create container with a custom logger
import { createLoggLogger } from 'injeca';
import { Logg } from '@guiiai/logg';
const customLogger = createLoggLogger(new Logg({ name: 'my-app' }));
const container3 = createContainer({ logger: customLogger });

// Example usage within a container
const config = provide(container1, 'config', () => ({ env: 'test' }));
const service = provide(container1, {
  dependsOn: { config, lifecycle },
  build({ dependsOn }) {
    dependsOn.lifecycle.appHooks.onStart(() => {
      console.log('Service starting with env:', dependsOn.config.env);
    });
    return { name: 'TestService' };
  }
});

invoke(container1, {
  dependsOn: { service },
  callback({ service }) {
    console.log('Service ready:', service.name);
  }
});

await start(container1);
await stop(container1);
```

### Response
- **containerInstance** (Container) - A new instance of an isolated dependency injection container.
```

--------------------------------

### Creating a No-Operation Logger for Injeca

Source: https://context7.com/moeru-ai/injeca/llms.txt

Initializes Injeca with a no-operation logger that discards all log output. This is useful for minimizing logging overhead in production or for specific testing scenarios where logs are not needed. An alternative is to disable logging entirely by setting 'enabled: false'.

```typescript
import { createContainer, createNoopLogger } from 'injeca'

// Completely silent logger
const logger = createNoopLogger()

const silentContainer = createContainer({ logger })

// No logs will be emitted, even during start/stop
// Alternatively, disable logging entirely:
const alsoSilent = createContainer({ enabled: false })
```

--------------------------------

### Global Container API - injeca.stop()

Source: https://context7.com/moeru-ai/injeca/llms.txt

Stops the global container, triggering onStop lifecycle hooks in reverse dependency order for graceful cleanup of all registered services and resources.

```APIDOC
## Global Container API - injeca.stop()

### Description
Stop the global container, executing lifecycle onStop hooks in reverse dependency order to ensure proper cleanup.

### Method
`await`

### Endpoint
N/A (Global function)

### Parameters
None

### Request Example
```typescript
// Assuming services are already provided and started
await injeca.stop();
```

### Response
None (Executes lifecycle hooks)

#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Stop Global Container and Execute Lifecycle Hooks - injeca.stop()

Source: https://context7.com/moeru-ai/injeca/llms.txt

Stops the global Injeca container, executing 'onStop' lifecycle hooks in reverse dependency order for graceful cleanup. This ensures resources like databases and caches are properly disconnected or closed. It requires the 'injeca' and 'lifecycle' modules.

```typescript
import { injeca, lifecycle } from 'injeca'

const cache = injeca.provide({
  dependsOn: { lifecycle },
  build({ dependsOn }) {
    const redis = connectRedis()

    dependsOn.lifecycle.appHooks.onStop(async () => {
      await redis.disconnect()
      console.log('Redis disconnected')
    })

    return redis
  }
})

const database = injeca.provide({
  dependsOn: { lifecycle },
  build({ dependsOn }) {
    const db = connectDatabase()

    dependsOn.lifecycle.appHooks.onStop(async () => {
      await db.close()
      console.log('Database closed')
    })

    return db
  }
})

await injeca.start()

// Later, gracefully shutdown all services
// onStop hooks execute in reverse dependency order
await injeca.stop()
```

--------------------------------

### Resolve Dependencies with Scoped Container API - resolve()

Source: https://context7.com/moeru-ai/injeca/llms.txt

The resolve() function allows direct access to dependencies within a specific container without invoking lifecycle hooks. This is particularly useful for unit testing components or when needing to access services directly. It bypasses the standard startup sequence, enabling controlled dependency resolution.

```typescript
import { createContainer, provide, resolve } from 'injeca'

describe('UserService', () => {
  it('should create users', async () => {
    const testContainer = createContainer({ enabled: false })

    const mockDb = provide(testContainer, 'db', () => ({
      users: [] as any[],
      insert: async (user: any) => {
        mockDb.users.push(user)
        return user
      }
    }))

    const userService = provide(testContainer, {
      dependsOn: { db: mockDb },
      build({ dependsOn }) {
        return {
          createUser: async (name: string) => {
            return dependsOn.db.insert({ id: Date.now(), name })
          }
        }
      }
    })

    // Resolve without starting (no lifecycle hooks)
    const { userService: service } = await resolve(testContainer, {
      userService
    })

    const user = await service.createUser('Alice')
    expect(user.name).toBe('Alice')
  })
})
```

--------------------------------

### Stop Container Instance with Scoped Container API - stop()

Source: https://context7.com/moeru-ai/injeca/llms.txt

The stop() function gracefully terminates a specific container instance, ensuring its resources are cleaned up in the reverse order of their dependencies. This operation does not impact other active containers. It is essential for managing resource deallocation and preventing memory leaks.

```typescript
import { createContainer, provide, start, stop, lifecycle } from 'injeca'

async function handleRequest() {
  const container = createContainer()

  const connection = provide(container, {
    dependsOn: { lifecycle },
    build({ dependsOn }) {
      const conn = { id: crypto.randomUUID(), active: true }

      dependsOn.lifecycle.appHooks.onStop(() => {
        conn.active = false
        console.log(`Connection ${conn.id} closed`)
      })

      return conn
    }
  })

  await start(container)

  // Do work with connection
  const { connection: conn } = await injeca.resolve({ connection })
  console.log('Using connection:', conn.id)

  // Cleanup after request
  await stop(container)
}

await handleRequest()
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.