@asaidimu/utils-artifacts 3.1.8 → 4.0.0

package/README.md

@@ -3,10 +3,12 @@
 A powerful, reactive dependency injection container for managing application artifacts and their lifecycles. It provides a robust framework for building modular, maintainable, and highly responsive applications by decoupling components and managing their state-driven dependencies.
 
 [![npm version](https://img.shields.io/npm/v/@asaidimu/utils-artifacts.svg?style=flat-square)](https://www.npmjs.com/package/@asaidimu/utils-artifacts)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
-[![Build Status](https://img.shields.io/github/actions/workflow/status/asaidimu/utils/ci.yml?branch=main&style=flat-square)](https://github.com/asaidimu/utils/actions?query=workflow%3ACI)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://github.com/asaidimu/erp-utils/blob/main/LICENSE)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/asaidimu/erp-utils/ci.yml?branch=main&label=Build&style=flat-square)](https://github.com/asaidimu/erp-utils/actions?query=workflow%3ACI)
 
-## 🚀 Quick Links
+---
+
+### 🚀 Quick Links
 
 *   [Overview & Features](#-overview--features)
 *   [Installation & Setup](#-installation--setup)
@@ -16,7 +18,7 @@ A powerful, reactive dependency injection container for managing application art
     *   [Artifact-to-Artifact Dependencies](#artifact-to-artifact-dependencies)
     *   [Lifecycle Hooks: `onCleanup` & `onDispose`](#lifecycle-hooks-oncleanup--ondispose)
     *   [Watching Artifacts for Changes](#watching-artifacts-for-changes)
-    *   [Updating Intermediate Values with `ctx.update`](#updating-intermediate-values-with-ctxupdate)
+    *   [Streaming Artifacts with `ctx.stream()`](#streaming-artifacts-with-ctxstream)
     *   [Debugging Information](#debugging-information)
 *   [Project Architecture](#-project-architecture)
 *   [Development & Contributing](#-development--contributing)
@@ -35,16 +37,16 @@ This package is ideal for building complex, event-driven systems, front-end appl
 
 ### ✨ Key Features
 
-*   **Reactive Dependency Injection**: Automatically invalidates and rebuilds artifacts when their declared dependencies (other artifacts or global state slices) change.
+*   **Reactive Dependency Injection**: Automatically invalidates and rebuilds `Singleton` artifacts when their declared dependencies (other artifacts or global state slices) change, ensuring reactive updates throughout your application.
 *   **Singleton & Transient Scopes**: Control whether an artifact is instantiated once and reused (`Singleton`) or created fresh on every request (`Transient`).
-*   **State-Driven Invalidation with Debouncing**: Integrates with a `DataStore` to track state dependencies, triggering artifact rebuilds only when relevant state paths change, with configurable debouncing.
-*   **Fine-grained Dependency Tracking**: Explicitly declare dependencies on other artifacts using `ctx.resolve()` and on state slices using `ctx.select()`.
-*   **Robust Error Handling**: Built-in detection and specific error types for circular dependencies, missing artifacts, and illegal operations, distinguishing between `system` (structural) and `external` (runtime) errors.
-*   **Lifecycle Hooks**: Register `onCleanup` callbacks for instance-specific resource release and `onDispose` for final resource teardown.
-*   **Asynchronous Artifact Resolution**: Supports `async`/`await` in artifact factories, with configurable retries for external failures and timeouts.
-*   **`ArtifactObserver` for Reactive Observation**: Observe changes to an artifact's resolved value over time, subscribing to updates without repeatedly resolving.
-*   **Live Updates via `ctx.update()`**: Singleton artifacts can proactively update their value from within their factory, immediately notifying dependents and watchers.
-*   **Comprehensive Debugging Info**: `debugInfo()` provides a snapshot of the container's state, including artifact statuses, dependencies, and dependents.
+*   **State-Driven Invalidation with Debouncing**: Integrates with a `DataStore` (e.g., `@asaidimu/utils-store`) to track state dependencies, triggering artifact rebuilds only when relevant state paths change, with configurable debouncing to prevent excessive rebuilds.
+*   **Fine-grained Dependency Tracking**: Explicitly declare dependencies on other artifacts using `ctx.use(({ resolve }) => resolve('someKey'))` and on state slices using `ctx.use(({ select }) => select(state => state.somePath))`.
+*   **Robust Error Handling**: Built-in detection and specific error types for circular dependencies (`CircularDependencyError`), missing artifacts (`ArtifactNotFoundError`), illegal operations (`IllegalScopeError`), and timeouts (`TimeoutError`), distinguishing between `system` (structural) and `external` (runtime) errors.
+*   **Lifecycle Hooks**: Register `onCleanup` callbacks for instance-specific resource release (executed before a `Singleton` instance is rebuilt) and `onDispose` for final resource teardown (executed when the artifact is unregistered).
+*   **Asynchronous Artifact Resolution**: Supports `async`/`await` in artifact factories, with configurable `retries` for external failures and `timeout` settings for long-running operations.
+*   **`ArtifactObserver` for Reactive Observation**: Use `container.watch(key)` to get an observer that allows subscribing to an artifact's resolved value over time, providing reactive updates to UI components or other systems.
+*   **Live Streaming with `ctx.stream()`**: `Singleton` artifacts can emit multiple values over their lifetime from within their factory using `ctx.stream()`, immediately notifying dependents and watchers of new data. This is ideal for continuous data sources like WebSockets or background processes.
+*   **Comprehensive Debugging Info**: `container.debugInfo()` provides a runtime snapshot of the container's state, including artifact statuses, dependencies (artifact-to-artifact and state-to-artifact), and dependents.
 
 ---
 
@@ -52,9 +54,9 @@ This package is ideal for building complex, event-driven systems, front-end appl
 
 ### Prerequisites
 
-*   Node.js (v18 or higher recommended)
-*   A package manager like Bun, npm, or Yarn.
-*   An implementation of the `DataStore` interface for reactive state management. We highly recommend using [`@asaidimu/utils-store`](https://www.npmjs.com/package/@asaidimu/utils-store).
+*   **Node.js**: (v18 or higher recommended)
+*   **Package Manager**: `Bun`, `npm`, or `Yarn`.
+*   **DataStore Implementation**: An external implementation of a `DataStore` interface with `get` and `watch` methods. We highly recommend using [`@asaidimu/utils-store`](https://www.npmjs.com/package/@asaidimu/utils-store) as it is designed for seamless integration.
 
 ### Installation Steps
 
@@ -73,13 +75,13 @@ yarn add @asaidimu/utils-artifacts
 
 ### Configuration
 
-To use the `ArtifactContainer`, you need to initialize it with an object that provides `get` and `watch` methods conforming to the `DataStore` interface. This allows the container to read the current application state and subscribe to state changes for reactive invalidation.
+To use the `ArtifactContainer`, you need to initialize it with an object that provides `watch` (for reactive subscriptions to state changes), `get` (for reading the current state), and `set` (for allowing artifacts to update state, e.g., via `ctx.stream` or `ctx.set`).
 
 If you're using `@asaidimu/utils-store` as your `DataStore`:
 
 ```typescript
-import { ArtifactContainer, ArtifactScopes } from '@asaidimu/utils-artifacts';
-import { ReactiveDataStore } from '@asaidimu/utils-store'; // Assuming this provides DataStore interface
+import { ArtifactContainer } from '@asaidimu/utils-artifacts';
+import { ReactiveDataStore } from '@asaidimu/utils-store'; // Recommended DataStore
 
 interface AppState {
   config: { theme: string; debugMode: boolean };
@@ -96,6 +98,7 @@ const initialAppState: AppState = {
 const store = new ReactiveDataStore<AppState>(initialAppState);
 
 // Initialize the ArtifactContainer
+// The generic arguments <TRegistry, TState> are inferred or can be explicitly provided.
 const container = new ArtifactContainer<Record<string, any>, AppState>(store);
 
 // Now you can start registering artifacts
@@ -111,6 +114,7 @@ import { ArtifactContainer } from '@asaidimu/utils-artifacts';
 const mockStore = {
   get: () => ({}), // Returns an empty object for state
   watch: () => () => {}, // Returns a no-op unsubscribe function
+  set: async () => ({}), // Returns a no-op set function
 };
 const container = new ArtifactContainer(mockStore);
 console.log('ArtifactContainer initialized successfully!');
@@ -123,11 +127,11 @@ console.log('ArtifactContainer initialized successfully!');
 
 ### Basic Artifacts (Singleton & Transient)
 
-Artifacts can be registered with different scopes, controlling their lifecycle.
+Artifacts can be registered with different scopes, controlling their lifecycle and instantiation behavior.
 
 #### Singleton Scope
 
-A singleton artifact is created only once. Subsequent `resolve` calls return the same instance.
+A `Singleton` artifact is created only once. Subsequent `resolve` calls or reactive updates will return or use the same instance, unless its dependencies change, which triggers a rebuild. This is the default scope.
 
 ```typescript
 import { ArtifactContainer, ArtifactScopes } from '@asaidimu/utils-artifacts';
@@ -149,7 +153,7 @@ container.register({
     };
   },
   scope: ArtifactScopes.Singleton,
-  lazy: false, // Build immediately on registration
+  lazy: false, // Build immediately on registration if it's a Singleton
 });
 
 async function runSingletonExample() {
@@ -174,7 +178,7 @@ runSingletonExample();
 
 #### Transient Scope
 
-A transient artifact creates a new instance every time it is resolved.
+A `Transient` artifact creates a new instance every time it is resolved. These artifacts do not participate in caching, reactive invalidation, or lifecycle hooks like `onCleanup` and `onDispose`.
 
 ```typescript
 import { ArtifactContainer, ArtifactScopes } from '@asaidimu/utils-artifacts';
@@ -217,7 +221,7 @@ runTransientExample();
 
 ### Reactive State Dependencies
 
-Artifacts can react to changes in your global `DataStore` state by using `ctx.select()` within their factory's `use` block.
+Artifacts can react to changes in your global `DataStore` state by using `ctx.use(({ select }) => ...)` within their factory. When the selected state slice changes, the `Singleton` artifact is automatically invalidated and rebuilt.
 
 ```typescript
 import { ArtifactContainer, ArtifactScopes } from '@asaidimu/utils-artifacts';
@@ -287,7 +291,7 @@ runReactiveStateExample();
 
 ### Artifact-to-Artifact Dependencies
 
-Artifacts can depend on other artifacts using `ctx.resolve()` within their factory's `use` block. Changes to a dependency will invalidate the dependent artifact.
+Artifacts can depend on other artifacts using `ctx.use(({ resolve }) => resolve('otherArtifactKey'))` or `ctx.use(({ require }) => require('otherArtifactKey'))` within their factory. Changes (invalidations) to a dependency will automatically invalidate the dependent artifact.
 
 ```typescript
 import { ArtifactContainer, ArtifactScopes } from '@asaidimu/utils-artifacts';
@@ -314,10 +318,10 @@ container.register({
   factory: async ({ use }) => {
     userRepositoryBuilds++;
     console.log(`Building UserRepository (${userRepositoryBuilds})...`);
-    const db = await use((ctx) => ctx.resolve('dbConnection'));
+    const db = await use((ctx) => ctx.require('dbConnection')); // Using 'require' for direct instance
     return {
-      dbClient: db.instance?.client,
-      findUser: (id: string) => `User ${id} from ${db.instance?.client}`
+      dbClient: db.client,
+      findUser: (id: string) => `User ${id} from ${db.client}`
     };
   },
   scope: ArtifactScopes.Singleton,
@@ -357,10 +361,10 @@ runArtifactDependencyExample();
 
 ### Lifecycle Hooks: `onCleanup` & `onDispose`
 
-Artifacts can register cleanup functions to manage resources.
+Artifacts can register cleanup functions to manage resources, ensuring proper release when instances are no longer needed.
 
-*   `onCleanup`: Executed *before* a new instance of a `Singleton` artifact is built (due to invalidation) or when the artifact is explicitly unregistered. Ideal for releasing resources tied to a specific instance.
-*   `onDispose`: Executed *only* when the artifact is unregistered or the container itself is disposed. Ideal for final, permanent resource release.
+*   `onCleanup(callback)`: Registered callbacks are executed *before* a `Singleton` artifact's instance is replaced (due to invalidation/rebuild). Ideal for releasing resources tied to that specific *instance* (e.g., stopping timers, closing old connections).
+*   `onDispose(callback)`: Registered callbacks are executed *only* when the artifact is explicitly `unregister()`ed from the container or the container itself is `dispose()`d. Ideal for final, permanent resource release associated with the *artifact definition itself*.
 
 ```typescript
 import { ArtifactContainer, ArtifactScopes } from '@asaidimu/utils-artifacts';
@@ -388,7 +392,7 @@ container.register({
 
     onDispose(() => {
       console.log('Disposing Ticker artifact (final cleanup)...');
-      // Additional final cleanup could go here
+      // Additional final cleanup could go here, e.g., closing file handles
     });
 
     return { start: Date.now() };
@@ -421,10 +425,10 @@ runLifecycleHooksExample();
 
 ### Watching Artifacts for Changes
 
-The `watch()` method provides a reactive way to observe an artifact's value without repeatedly calling `resolve()`. This is particularly useful for UI frameworks or reactive data flows.
+The `container.watch(key)` method provides a reactive way to observe an artifact's value without repeatedly calling `resolve()`. This is particularly useful for UI frameworks or reactive data flows where you want to be notified of changes as they occur.
 
 ```typescript
-import { ArtifactContainer, ArtifactScopes } from '@asaidimu/utils-artifacts';
+import { ArtifactContainer, ArtifactScopes, WatcherDisposedError } from '@asaidimu/utils-artifacts';
 import { ReactiveDataStore } from '@asaidimu/utils-store';
 
 interface AppState {
@@ -434,11 +438,13 @@ interface AppState {
 const store = new ReactiveDataStore<AppState>({ counter: 0 });
 const container = new ArtifactContainer<any, AppState>(store);
 
+let reactiveCounterBuilds = 0;
 container.register({
   key: 'reactiveCounter',
   factory: async ({ use }) => {
+    reactiveCounterBuilds++;
     const count = await use((ctx) => ctx.select((state) => state.counter));
-    return `Current count: ${count}`;
+    return `Current count: ${count} (Build: ${reactiveCounterBuilds})`;
   },
   scope: ArtifactScopes.Singleton,
 });
@@ -447,18 +453,18 @@ async function runWatcherExample() {
   console.log('Setting up watcher...');
   const watcher = container.watch('reactiveCounter');
 
-  let unsubscribe = watcher.subscribe(() => {
+  let unsubscribe = watcher.subscribe((resolved) => {
     if (resolved.ready) {
       console.log('Watcher received update:', resolved.instance);
     } else if (resolved.error) {
       console.error('Watcher received error:', resolved.error.message);
     } else {
-      console.log('Watcher received pending update (artifact not ready yet).');
+      console.log('Watcher received pending update (artifact not yet ready).');
     }
   });
 
-  // Initial state should trigger a notification (pending, then ready)
-  await new Promise(res => setTimeout(res, 10)); // Give watcher time to resolve
+  // Give watcher time to resolve the artifact initially
+  await new Promise(res => setTimeout(res, 10)); 
 
   console.log('\n--- Incrementing counter ---');
   await store.set({ counter: 1 });
@@ -468,141 +474,182 @@ async function runWatcherExample() {
   await store.set({ counter: 2 });
   await new Promise(res => setTimeout(res, 10));
 
-  console.log('\n--- Disposing watcher ---');
-  unsubscribe(); // Unsubscribe first
-  await watcher.dispose(); // Then dispose the watcher itself
-
-  // After dispose, attempts to get will yield WatcherDisposedError
-  console.log('Watcher after dispose:', watcher.get().error.message);
+  console.log('\n--- Unsubscribing & Disposing watcher ---');
+  unsubscribe(); // Unsubscribe from updates
+  
+  // After all subscribers are gone, the underlying artifact instance for watching transients is cleaned up.
+  // The watcher itself can then be disposed, making it unusable.
+  await new Promise(res => setTimeout(res, 10)); // Give cleanup a moment
+  // For singletons, watcher.dispose() is effectively a no-op as the underlying artifact remains
+  // For transients, it would clean up the internal singleton clone.
+  
+  try {
+    watcher.get(); // Attempt to access after dispose
+  } catch (e) {
+    if (e instanceof WatcherDisposedError) {
+      console.error('Caught expected error after watcher dispose:', e.message);
+    } else {
+      throw e;
+    }
+  }
 
   // Output:
   // Setting up watcher...
-  // Watcher received pending update (artifact not ready yet).
-  // Watcher received update: Current count: 0
+  // Watcher received pending update (artifact not yet ready).
+  // Watcher received update: Current count: 0 (Build: 1)
   //
   // --- Incrementing counter ---
-  // Watcher received pending update (artifact not ready yet).
-  // Watcher received update: Current count: 1
+  // Watcher received update: Current count: 1 (Build: 2)
   //
   // --- Incrementing counter again ---
-  // Watcher received pending update (artifact not ready yet).
-  // Watcher received update: Current count: 2
+  // Watcher received update: Current count: 2 (Build: 3)
   //
-  // --- Disposing watcher ---
-  // Watcher after dispose: [ArtifactContainer] Artifact with key:reactiveCounter has already been disposed
+  // --- Unsubscribing & Disposing watcher ---
+  // Caught expected error after watcher dispose: [ArtifactContainer] Artifact with key:reactiveCounter has already been disposed
 }
 
 runWatcherExample();
 ```
 
-### Updating Intermediate Values with `ctx.update`
+### Streaming Artifacts with `ctx.stream()`
 
-For long-running or multi-stage artifact factories, `ctx.update()` allows a Singleton artifact to publish intermediate values. This updates the artifact's current instance and notifies dependents/watchers without fully completing the factory execution.
+`Singleton` artifacts can leverage `ctx.stream(callback)` to become continuous sources of data. The `callback` receives an `ArtifactStreamContext` which allows emitting new values over time via `ctx.emit(value)`. Each emission updates the artifact's instance, notifying all dependents and watchers immediately. This is ideal for scenarios like WebSocket clients, background workers, or long-running computations that produce intermediate results.
 
 ```typescript
 import { ArtifactContainer, ArtifactScopes } from "@asaidimu/utils-artifacts";
 import { ReactiveDataStore } from "@asaidimu/utils-store";
 
 const store = new ReactiveDataStore({});
-const container = new ArtifactContainer(store);
+const container = new ArtifactContainer<{ producer: number; consumer: string }, {}>(store);
 
-container.register({
-  key: "longProcessArtifact",
-  factory: async ({ update: publish }) => { // `update` is renamed to `publish` for clarity in this example
-    async function process() {
-      await new Promise((res) => setTimeout(res, 100));
-      console.log("Starting long process...");
-
-      await publish("Step 1: Initializing...");
-      await new Promise((res) => setTimeout(res, 100));
-
-      await publish("Step 2: Loading data...");
-      await new Promise((res) => setTimeout(res, 100));
+const PRODUCER_TIMEOUT = 50; // ms
+const PRODUCER_LIMIT = 3;
 
-      await publish("Step 3: Processing data...");
-      await new Promise((res) => setTimeout(res, 100));
+container.register({
+  key: "producer",
+  factory: ({ stream }) => {
+    let value = 0;
+
+    // The stream callback is executed in the background
+    stream(async ({ emit, signal }) => {
+      console.log("Producer: Stream started.");
+      while (!signal.aborted) {
+        await new Promise((res) => setTimeout(res, PRODUCER_TIMEOUT)); // Simulate async work
+        value++;
+        console.log(`Producer: Emitting value: ${value}`);
+        await emit(value); // Emit new value, notifying dependents and watchers
+        if (value >= PRODUCER_LIMIT) {
+          console.log("Producer: Reached limit, stopping stream.");
+          break;
+        }
+      }
+    });
 
-      console.log("Long process complete.");
-    }
+    return value; // Initial value returned by the factory
+  },
+  scope: ArtifactScopes.Singleton,
+});
 
-    queueMicrotask(process); // Start the process in the background,
-    return "Factory Starting"; 
+container.register({
+  key: "consumer",
+  factory: async ({ use }) => {
+    // This artifact depends on the 'producer'
+    const producerValue = await use(({ require }) => require("producer"));
+    return `Consumed: ${producerValue}`;
   },
   scope: ArtifactScopes.Singleton,
 });
 
-async function runUpdateExample() {
-  const watcher = container.watch("longProcessArtifact");
+async function runStreamExample() {
+  const watcher = container.watch("consumer");
+  const receivedValues: string[] = [];
 
-  const unsubscribe = watcher.subscribe(() => {
-    const resolved = watcher.get();
-    if (resolved.instance) {
-      console.log("Watcher observed update:", resolved.instance);
+  const unsubscribe = watcher.subscribe((resolved) => {
+    if (resolved.instance && !receivedValues.includes(resolved.instance)) {
+      receivedValues.push(resolved.instance);
+      console.log(`Watcher: Received "${resolved.instance}"`);
     }
   });
 
-  // Resolve the artifact to trigger its factory and the background process
-  await container.resolve("longProcessArtifact");
+  // Initial resolve to kick-start the producer factory and stream
+  await container.resolve("consumer");
 
-  // Give some time for the process to run and yield updates
-  await new Promise((res) => setTimeout(res, 600));
+  // Give enough time for the stream to run and emit all values
+  // (PRODUCER_LIMIT * PRODUCER_TIMEOUT) + some buffer for processing
+  await new Promise((res) => setTimeout(res, (PRODUCER_LIMIT * PRODUCER_TIMEOUT) + 100));
 
-  unsubscribe();
-  await watcher.dispose();
+  console.log('\n--- Stream Complete ---');
+  console.log('All received values:', receivedValues);
+  // Expected: ["Consumed: 0", "Consumed: 1", "Consumed: 2", "Consumed: 3"]
 
-  // Output will show intermediate values from `ctx.update` as they occur,
-  // then the final result once the factory completes.
+  unsubscribe(); // Clean up the watcher
 }
 
-runUpdateExample();
+runStreamExample();
 ```
 
 ### Debugging Information
 
-Use `debugInfo()` to inspect the current state of artifacts within a container, including their status, dependencies, and dependents.
+Use `container.debugInfo()` to inspect the current state of all registered artifacts within a container, including their status, direct dependencies (artifact-to-artifact and state), and dependents. This is an invaluable tool for understanding your application's dependency graph at runtime.
 
 ```typescript
 import { ArtifactContainer, ArtifactScopes } from '@asaidimu/utils-artifacts';
 import { ReactiveDataStore } from '@asaidimu/utils-store';
 
-const store = new ReactiveDataStore({});
-const container = new ArtifactContainer(store);
+interface AppState {
+  configVersion: number;
+}
+
+const store = new ReactiveDataStore<AppState>({ configVersion: 1 });
+const container = new ArtifactContainer<any, AppState>(store);
 
 container.register({
-  key: 'serviceA',
-  factory: () => 'Service A Instance',
+  key: 'configService',
+  factory: async ({ use }) => {
+    const version = await use((ctx) => ctx.select((state) => state.configVersion));
+    return `Config v${version}`;
+  },
   scope: ArtifactScopes.Singleton,
 });
 
 container.register({
-  key: 'serviceB',
+  key: 'dataProcessor',
   factory: async ({ use }) => {
-    await use((ctx) => ctx.resolve('serviceA'));
-    return 'Service B Instance';
+    const config = await use((ctx) => ctx.resolve('configService'));
+    return `Processing with ${config.instance}`;
   },
   scope: ArtifactScopes.Singleton,
 });
 
+container.register({
+  key: 'ephemeralTool',
+  factory: () => 'A transient tool',
+  scope: ArtifactScopes.Transient,
+});
+
 async function runDebugInfoExample() {
-  await container.resolve('serviceB'); // Resolve to build dependencies
+  await container.resolve('dataProcessor'); // Resolve to build dependencies
+  await container.resolve('ephemeralTool'); // Resolve a transient (doesn't cache, but will show up if just resolved)
 
   const debugInfo = container.debugInfo();
   console.log('--- Artifact Debug Information ---');
   debugInfo.forEach(node => {
-    console.log(`ID: ${node.id}`);
+    console.log(`\nID: ${node.id}`);
     console.log(`  Scope: ${node.scope}`);
     console.log(`  Status: ${node.status}`);
-    console.log(`  Dependencies: ${node.dependencies.join(', ') || 'None'}`);
+    console.log(`  Dependencies (Artifacts): ${node.dependencies.join(', ') || 'None'}`);
+    console.log(`  Dependencies (State Paths): ${node.stateDependencies.join(', ') || 'None'}`);
     console.log(`  Dependents: ${node.dependents.join(', ') || 'None'}`);
     console.log(`  Render Count: ${node.renderCount}`);
     console.log('---');
   });
 
-  // Example output for 'serviceB':
-  // ID: serviceB
+  // Example output for 'dataProcessor':
+  // ID: dataProcessor
   //   Scope: singleton
   //   Status: active
-  //   Dependencies: serviceA
+  //   Dependencies (Artifacts): configService
+  //   Dependencies (State Paths): None
   //   Dependents: None
   //   Render Count: 1
 }
@@ -614,39 +661,44 @@ runDebugInfoExample();
 
 ## 🏛️ Project Architecture
 
-The `@asaidimu/utils-artifacts` package is built around the central `ArtifactContainer` class, which orchestrates the lifecycle and dependencies of various "artifacts" (any component or value you register).
+The `@asaidimu/utils-artifacts` package is built around the central `ArtifactContainer` class, which orchestrates the lifecycle and dependencies of various "artifacts" (any component or value you register). It is designed to be modular and extensible, promoting maintainability and testability.
 
 ### Core Components
 
-*   **`ArtifactContainer`**: The public-facing entry point of the system. It orchestrates the registration, resolution, lifecycle management (Singleton/Transient), and reactive updates of all artifacts. It provides methods like `register`, `resolve`, `watch`, `invalidate`, and `debugInfo`.
-*   **`ArtifactRegistry`**: Manages the definitions of all registered artifacts, storing their factory functions and configuration options (scope, lazy loading, retries, debounce, timeout).
-*   **`ArtifactCache`**: Stores the runtime state of resolved singleton artifacts, including their instances, errors, cleanup functions, state dependencies, and internal synchronization primitives (`Once`, `Serializer`). It's responsible for packaging cached data into the public `ResolvedArtifact` format.
-*   **`ArtifactDependencyGraph`**: A specialized wrapper around a generic `DependencyGraph` that tracks artifact-to-artifact dependencies and state path dependencies. It's crucial for detecting circular dependencies and determining the cascade order during invalidation.
-*   **`ArtifactManager`**: The core engine responsible for the actual building, invalidation, and disposal of artifact instances. It interacts heavily with the `Registry`, `Cache`, `DependencyGraph`, and `DataStore`. It implements retry logic, timeouts, and manages lifecycle hooks.
-*   **`ArtifactObserverManager`**: Handles the creation and management of `ArtifactObserver` instances, allowing external code to subscribe to artifact changes. It also manages reference counting for watchers and notifies them of updates.
-*   **`DataStore` (External Dependency)**: The container relies on an external data store (e.g., `@asaidimu/utils-store`) to manage global application state. The container interacts with it via `watch` (for reactive subscriptions to state changes) and `get` (for reading the current state).
-*   **Synchronization Primitives (`Mutex`, `Once`, `Serializer`)**: These internal utilities provide robust mechanisms for managing concurrency, ensuring single execution of tasks, and processing operations sequentially. They are fundamental building blocks for the `ArtifactManager` and `ArtifactCache`.
+*   **`ArtifactContainer`**: The public-facing entry point of the system. It orchestrates the registration, resolution, lifecycle management (`Singleton`/`Transient`), and reactive updates of all artifacts. It provides methods like `register`, `resolve`, `watch`, `invalidate`, and `debugInfo`.
+*   **`ArtifactRegistry`**: Manages the definitions of all registered artifacts, storing their factory functions and configuration options (scope, lazy loading, retries, debounce, timeout). It ensures unique keys and provides basic CRUD for artifact templates.
+*   **`ArtifactCache`**: Stores the runtime state of resolved `Singleton` artifacts, including their instances, errors, cleanup functions, state dependencies, and internal synchronization primitives (`Once`, `Serializer`). It's responsible for packaging cached data into the public `ResolvedArtifact` format, maintaining reference stability.
+*   **`ArtifactDependencyGraph`**: A specialized wrapper around a generic `DependencyGraph` that tracks artifact-to-artifact dependencies and state path dependencies. It's crucial for detecting circular dependencies, managing the dependency graph, and determining the cascade order during invalidation.
+*   **`ArtifactManager`**: The core engine responsible for the actual building, invalidation, and disposal of artifact instances. It interacts heavily with the `Registry`, `Cache`, `DependencyGraph`, and `DataStore`. It implements retry logic, timeouts, and manages lifecycle hooks (`onCleanup`, `onDispose`) and `ctx.stream` functionality.
+*   **`ArtifactObserverManager`**: Handles the creation and management of `ArtifactObserver` instances, allowing external code to subscribe to artifact changes. It also manages reference counting for watchers and notifies them of updates, including special handling for `Transient` artifacts to ensure they are watched via a temporary `Singleton` clone.
+*   **`DataStore` (External Dependency)**: The container relies on an external data store (e.g., `@asaidimu/utils-store`) to manage global application state. The container interacts with it via `watch` (for reactive subscriptions to state changes), `get` (for reading the current state), and `set` (allowing artifacts to dispatch state updates).
+*   **Synchronization Primitives (`Mutex`, `Once`, `Serializer`)**: These internal utilities (`src/artifacts/sync.ts`) provide robust mechanisms for managing concurrency, ensuring single execution of tasks, and processing operations sequentially. They are fundamental building blocks for the `ArtifactManager` and `ArtifactCache`.
+*   **Error Handling (`ArtifactError` hierarchy)**: A dedicated set of custom error classes (`src/artifacts/errors.ts`) provides clear, categorized error messages for system-level issues (e.g., circular dependencies, missing artifacts, illegal operations), simplifying debugging and error handling.
 
 ### Data Flow
 
 1.  **Registration (`container.register`)**: An `ArtifactTemplate` (containing an `ArtifactFactory` and its `options`) is stored in the `ArtifactRegistry`. A corresponding node is added to the `ArtifactDependencyGraph`.
-2.  **Resolution (`container.resolve`)**:
+2.  **Resolution (`container.resolve` or `container.require`)**:
     *   If the artifact is a `Singleton` and already built, its cached instance from `ArtifactCache` is returned.
     *   If not built (or `Transient`), the `ArtifactManager` invokes the `ArtifactFactory` within a specialized `ArtifactFactoryContext`.
     *   **Dependency Declaration (`ctx.use`)**: Inside the factory, `ctx.use` provides methods to declare dependencies:
-        *   `ctx.resolve(key)`: Recursively triggers resolution of another artifact. The relationship is added to the `ArtifactDependencyGraph`.
+        *   `ctx.resolve(key)`/`ctx.require(key)`: Recursively triggers resolution of another artifact. The relationship is added to the `ArtifactDependencyGraph`.
         *   `ctx.select(selector)`: Extracts specific state paths from the global `DataStore`. These paths are registered as state dependencies for the artifact.
-3.  **Dependency Graph Construction**: As dependencies are declared (via `ctx.resolve` or `ctx.select`), the `ArtifactDependencyGraph` constructs a precise, bidirectional graph, linking artifacts and their state dependencies.
+3.  **Dependency Graph Construction**: As dependencies are declared (via `ctx.resolve`/`ctx.require` or `ctx.select`), the `ArtifactDependencyGraph` constructs a precise, bidirectional graph, linking artifacts and their state dependencies.
 4.  **Reactive Invalidation**:
-    *   **State Changes**: When a `DataStore` value changes, `ArtifactManager` identifies affected artifacts (those subscribed to the changed state paths) and calls `container.invalidate()` for them.
-    *   **Artifact Changes**: When an artifact is rebuilt, invalidated, or proactively `update()`s its value, its direct and transitive `dependents` are identified by the `ArtifactDependencyGraph`, and `container.invalidate()` is called for each.
+    *   **State Changes**: When a `DataStore` value changes, `ArtifactManager` identifies affected `Singleton` artifacts (those subscribed to the changed state paths) and calls `container.invalidate()` for them.
+    *   **Artifact Changes**: When a `Singleton` artifact is rebuilt, explicitly `invalidate()`d, or proactively `stream()`s a new value, its direct and transitive `dependents` are identified by the `ArtifactDependencyGraph`, and `container.invalidate()` is called for each, cascading updates.
 5.  **Rebuild Process**: `container.invalidate()` triggers:
-    *   **Debouncing**: If configured, rebuilds are debounced (`activeDebounceMs`) to consolidate multiple rapid invalidations.
+    *   **Debouncing**: If configured (`debounce` option), rebuilds are debounced (`activeDebounceMs`) to consolidate multiple rapid invalidations, preventing excessive factory executions.
     *   **Cleanup**: `onCleanup` hooks for the *old* instance are executed.
     *   **New Instance**: The `ArtifactFactory` is re-executed by the `ArtifactManager`, creating a new instance.
     *   **Graph Update**: The dependency graph is updated based on any *new* dependencies declared by the re-executed factory.
     *   **Notification**: `ArtifactObserver` subscribers are notified of the new instance via `ArtifactObserverManager`.
-6.  **Disposal (`container.dispose` / `container.unregister`)**: All resources associated with an artifact (`onDispose` hooks, state subscriptions, cache entry, graph links) are released. Full container disposal clears everything.
+6.  **Streaming Updates (`ctx.stream`)**: If a `Singleton` artifact uses `ctx.stream`, subsequent `ctx.emit(value)` calls from within its factory:
+    *   Update the artifact's cached instance in `ArtifactCache`.
+    *   Increment the artifact's internal version.
+    *   Trigger `invalidate()` on all its dependents and `notifyObservers()`, effectively propagating the streamed value reactively.
+7.  **Disposal (`container.dispose` / `container.unregister`)**: All resources associated with an artifact (`onDispose` hooks, state subscriptions, cache entry, graph links) are released. Full container disposal clears everything.
 
 ### Extension Points
 
@@ -656,7 +708,7 @@ The primary extension point is the **`ArtifactFactory` function**. By implementi
 *   Manage external resources like database connections, API clients, or message queues, ensuring they are properly initialized and cleaned up using `onCleanup` and `onDispose`.
 *   Provide custom logging, monitoring, or telemetry by injecting those services as dependencies.
 
-The `ArtifactContainer` itself is designed to be highly configurable via `ArtifactTemplate` options, allowing fine-tuning of scope, lazy loading, error handling, and reactive behavior. 
+The `ArtifactContainer` itself is designed to be highly configurable via `ArtifactTemplate` options, allowing fine-tuning of scope, lazy loading, error handling, and reactive behavior.
 
 ---
 
@@ -668,8 +720,8 @@ We welcome contributions! Please read the guidelines below.
 
 1.  **Clone the repository**:
     ```bash
-    git clone https://github.com/asaidimu/utils.git
-    cd utils/src/artifacts
+    git clone https://github.com/asaidimu/erp-utils.git
+    cd erp-utils/src/artifacts # Navigate to this package's directory
     ```
 2.  **Install dependencies**:
     ```bash
@@ -684,15 +736,17 @@ We welcome contributions! Please read the guidelines below.
 
 ### Scripts
 
+The `package.json` for this package includes the following scripts:
+
 *   `bun install`: Installs project dependencies.
 *   `bun run test`: Runs the test suite using Vitest.
 *   `bun run test:watch`: Runs tests in watch mode for continuous feedback.
-*   `bun run test:browser`: Runs tests in a browser environment.
+*   `bun run test:browser`: Runs tests in a browser environment using Playwright.
 *   `bun run build`: Compiles the TypeScript source code into JavaScript.
 
 ### Testing
 
-This project uses [Vitest](https://vitest.dev/) for testing.
+This project uses [Vitest](https://vitest.dev/) for testing, with support for browser-based tests via Playwright.
 
 *   To run all tests:
     ```bash
@@ -702,21 +756,25 @@ This project uses [Vitest](https://vitest.dev/) for testing.
     ```bash
     bun run test --watch
     ```
+*   To run tests in a browser environment:
+    ```bash
+    bun run test:browser
+    ```
 *   Ensure all new features or bug fixes are accompanied by appropriate unit and/or integration tests.
 
 ### Contributing Guidelines
 
 We appreciate your interest in contributing to `@asaidimu/utils-artifacts`!
-Please refer to the main repository's [CONTRIBUTING.md](https://github.com/asaidimu/utils/blob/main/CONTRIBUTING.md) for detailed guidelines on:
+Please refer to the main repository's [CONTRIBUTING.md](https://github.com/asaidimu/erp-utils/blob/main/CONTRIBUTING.md) for detailed guidelines on:
 
 *   Reporting issues
 *   Submitting pull requests
 *   Coding standards
-*   Commit message conventions (we follow Conventional Commits)
+*   Commit message conventions (we follow [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/))
 
 ### Issue Reporting
 
-Found a bug or have a feature request? Please open an issue on our [GitHub Issues page](https://github.com/asaidimu/utils/issues).
+Found a bug or have a feature request? Please open an issue on our [GitHub Issues page](https://github.com/asaidimu/erp-utils/issues).
 Provide as much detail as possible, including steps to reproduce, expected behavior, and your environment.
 
 ---
@@ -728,12 +786,12 @@ Provide as much detail as possible, including steps to reproduce, expected behav
 *   **`ArtifactNotFoundError`**: This typically means you're trying to `resolve` or `watch` an artifact that hasn't been `register`ed in the current container. Double-check your `key`s and registration calls.
 *   **`CircularDependencyError`**: Occurs when artifact A depends on B, and B depends back on A (directly or indirectly). This indicates a structural problem in your dependency graph. Redesign your artifacts to break the cycle. The error message will show the path of the cycle.
 *   **Artifact Not Updating Reactively**:
-    *   Ensure your artifact is a `Singleton` (Transient artifacts don't cache or react to invalidations).
-    *   Verify you are using `ctx.use()` and `ctx.select()` (for state) or `ctx.resolve()` (for other artifacts) inside your factory to declare dependencies.
-    *   Check that your `DataStore` implementation is correctly triggering its `watch` callbacks.
-*   **`IllegalScopeError`**: You might be trying to `update` a value from a `Transient` artifact. `update` is only meaningful for `Singleton` artifacts, which maintain a persistent instance.
-*   **`TimeoutError`**: Your artifact factory took longer than its configured `timeout` to complete, or a `Mutex` lock operation exceeded its timeout. Consider increasing the `timeout` or optimizing your factory's logic.
-*   **`WatcherDisposedError`**: You are attempting to access a watcher's state (`watcher.get()`) after `watcher.dispose()` has been called. Ensure you unsubscribe and dispose of watchers when no longer needed, and avoid using them afterward.
+    *   Ensure your artifact is a `Singleton` (Transient artifacts do not cache, react to invalidations, or support streaming).
+    *   Verify you are using `ctx.use()` and `ctx.select()` (for state dependencies) or `ctx.use(({ resolve }) => resolve('otherKey'))` (for artifact dependencies) inside your factory to properly declare dependencies.
+    *   Check that your `DataStore` implementation is correctly triggering its `watch` callbacks when state changes.
+*   **`IllegalScopeError`**: You might be trying to `stream` a value from a `Transient` artifact. The `stream` method is only meaningful for `Singleton` artifacts, which maintain a persistent, updateable instance.
+*   **`TimeoutError`**: Your artifact factory took longer than its configured `timeout` to complete, or an internal `Mutex` lock operation exceeded its timeout. Consider increasing the `timeout` in the artifact's `ArtifactTemplate` or optimizing your factory's logic.
+*   **`WatcherDisposedError`**: You are attempting to access a watcher's state (`watcher.get()`) after `watcher.dispose()` has been called. Ensure you unsubscribe from all callbacks (`unsubscribe()`) and dispose of watchers when no longer needed (`watcher.dispose()`), and avoid using them afterward.
 
 ### FAQ
 
@@ -742,22 +800,23 @@ Provide as much detail as possible, including steps to reproduce, expected behav
 *   **Why use this over a simpler DI library?**
     `@asaidimu/utils-artifacts` goes beyond basic DI by adding a powerful reactive layer. It automatically handles the propagation of changes from global state or other artifacts, making it easier to build self-updating components and reactive systems without manual subscription management.
 *   **When should I use `Singleton` vs. `Transient`?**
-    *   **Singleton**: For services, database connections, configuration objects, or any resource that should be shared and consistently available throughout your application. They are efficient as they are built once and reused.
-    *   **Transient**: For objects that need a fresh instance every time they are requested, such as temporary calculators, request-scoped contexts, or factory functions that produce unique outputs.
+    *   **Singleton**: For services, database connections, configuration objects, or any resource that should be shared and consistently available throughout your application. They are efficient as they are built once and reused, and they react to dependency changes.
+    *   **Transient**: For objects that need a fresh instance every time they are requested, such as temporary calculators, request-scoped contexts, or factory functions that produce unique, short-lived outputs. They do not react to dependencies or retain state.
 *   **How does `debounce` work?**
-    `debounce` prevents an artifact from rebuilding too frequently. If multiple invalidations occur within the specified `debounce` time, they are consolidated, and the artifact's factory is only run once after the activity ceases. This is crucial for performance with rapid state changes, especially when many state changes might trigger the same artifact rebuild.
+    The `debounce` option (part of `ArtifactTemplate`) prevents a `Singleton` artifact from rebuilding too frequently. If multiple invalidations occur within the specified `debounce` time, they are consolidated, and the artifact's factory is only run once after the activity ceases (or after the last invalidation within the debounce window). This is crucial for performance with rapid state changes, especially when many state changes might trigger the same artifact rebuild.
 
 ### Changelog / Roadmap
 
-*   **Changelog**: For a detailed list of changes, please refer to the [CHANGELOG.md](https://github.com/asaidimu/utils/blob/main/CHANGELOG.md) file in the main repository.
-*   **Roadmap**: Future plans and upcoming features are typically outlined in the main repository's [issue tracker](https://github.com/asaidimu/utils/issues) or project boards.
+*   **Changelog**: For a detailed list of changes, please refer to the [CHANGELOG.md](https://github.com/asaidimu/erp-utils/blob/main/CHANGELOG.md) file in the main repository.
+*   **Roadmap**: Future plans and upcoming features for `@asaidimu/utils-artifacts` are typically outlined in the main repository's [issue tracker](https://github.com/asaidimu/erp-utils/issues) or project boards.
 
 ### License
 
-This project is licensed under the MIT License. See the [LICENSE](https://github.com/asaidimu/utils/blob/main/LICENSE) file for details.
+This project is licensed under the [MIT License](https://github.com/asaidimu/erp-utils/blob/main/LICENSE).
 
 ### Acknowledgments
 
 *   Developed as part of the `@asaidimu` utilities collection.
+*   Leverages foundational packages like [`@asaidimu/utils-store`](https://www.npmjs.com/package/@asaidimu/utils-store) and `@asaidimu/events` within the `erp-utils` monorepo.
 *   Uses [Semantic Release](https://semantic-release.gitbook.io/semantic-release/) for automated versioning and publishing.
-*   Leverages [Vitest](https://vitest.dev/) for fast and reliable testing.
+*   Utilizes [Vitest](https://vitest.dev/) for fast and reliable testing.

package/index.d.mts

@@ -244,6 +244,16 @@ interface UseDependencyContext<TRegistry extends Record<string, any>, TState ext
      * @throws {SystemError} if the key is missing or if resolving creates a circular dependency.
      */
     resolve<K extends keyof TRegistry>(key: K): Promise<ResolvedArtifact<TRegistry[K]>>;
+    /**
+     * Resolves another artifact from the container and registers a dependency on it.
+     * If the dependency changes, the current artifact will be invalidated and rebuilt.
+     * @template K The key of the artifact to resolve.
+     * @param key The key of the artifact to resolve.
+     * @returns A Promise that resolves to a the resolved instance, unlike
+     * resolve, this will throw an error if resolution fails.
+     * @throws {SystemError} if any error occurs during resolution.
+     */
+    require<K extends keyof TRegistry>(key: K): Promise<TRegistry[K]>;
     /**
      * Selects a slice of the global state and registers a dependency on it.
      * If the selected state slice changes (based on a deep comparison), the current
@@ -460,11 +470,13 @@ interface ArtifactObserver<TArtifact> {
      */
     subscribe(callback: (artifact: ResolvedArtifact<TArtifact>) => void): () => void;
     /**
-     * Disposes of this specific observer reference, decrementing the reference count.
-     * When the count reaches zero, associated resources (like cloned singletons for Transient artifacts)
-     * are cleaned up.
+     * Resolves another artifact from the container and registers a dependency on it.
+     * If the dependency changes, the current artifact will be invalidated and rebuilt.
+     * @returns A Promise that resolves to a `ResolvedArtifact` containing the instance
+     * or an external error.
+     * @throws {SystemError} if resolution fails.
      */
-    dispose(): Promise<void>;
+    resolve(): Promise<ResolvedArtifact<TArtifact>>;
 }
 /**
  * Configuration options for defining an artifact. These options control
@@ -621,6 +633,16 @@ declare class ArtifactContainer<TRegistry extends Record<string, any> = Record<s
      * @throws {ArtifactError} if a cycle is detected or other system errors occur
      */
     resolve<K extends keyof TRegistry>(key: K): Promise<ResolvedArtifact<TRegistry[K]>>;
+    /**
+     * Resolves an artifact by its key, returning its instance directly.
+     * This is a wrapper around resolve to prevent defensive programming
+     *
+     * @param key The unique identifier for the artifact
+     * @returns A Promise that resolves to a ResolvedArtifact
+     * @throws {ArtifactNotFoundError} if the artifact is not found
+     * @throws {ArtifactError} if a cycle is detected or other system errors occur
+     */
+    require<K extends keyof TRegistry>(key: K): Promise<TRegistry[K]>;
     /**
      * Returns an ArtifactWatcher for a given artifact key.
      * The watcher allows subscribing to changes in the artifact's resolved value.

package/index.d.ts

@@ -244,6 +244,16 @@ interface UseDependencyContext<TRegistry extends Record<string, any>, TState ext
      * @throws {SystemError} if the key is missing or if resolving creates a circular dependency.
      */
     resolve<K extends keyof TRegistry>(key: K): Promise<ResolvedArtifact<TRegistry[K]>>;
+    /**
+     * Resolves another artifact from the container and registers a dependency on it.
+     * If the dependency changes, the current artifact will be invalidated and rebuilt.
+     * @template K The key of the artifact to resolve.
+     * @param key The key of the artifact to resolve.
+     * @returns A Promise that resolves to a the resolved instance, unlike
+     * resolve, this will throw an error if resolution fails.
+     * @throws {SystemError} if any error occurs during resolution.
+     */
+    require<K extends keyof TRegistry>(key: K): Promise<TRegistry[K]>;
     /**
      * Selects a slice of the global state and registers a dependency on it.
      * If the selected state slice changes (based on a deep comparison), the current
@@ -460,11 +470,13 @@ interface ArtifactObserver<TArtifact> {
      */
     subscribe(callback: (artifact: ResolvedArtifact<TArtifact>) => void): () => void;
     /**
-     * Disposes of this specific observer reference, decrementing the reference count.
-     * When the count reaches zero, associated resources (like cloned singletons for Transient artifacts)
-     * are cleaned up.
+     * Resolves another artifact from the container and registers a dependency on it.
+     * If the dependency changes, the current artifact will be invalidated and rebuilt.
+     * @returns A Promise that resolves to a `ResolvedArtifact` containing the instance
+     * or an external error.
+     * @throws {SystemError} if resolution fails.
      */
-    dispose(): Promise<void>;
+    resolve(): Promise<ResolvedArtifact<TArtifact>>;
 }
 /**
  * Configuration options for defining an artifact. These options control
@@ -621,6 +633,16 @@ declare class ArtifactContainer<TRegistry extends Record<string, any> = Record<s
      * @throws {ArtifactError} if a cycle is detected or other system errors occur
      */
     resolve<K extends keyof TRegistry>(key: K): Promise<ResolvedArtifact<TRegistry[K]>>;
+    /**
+     * Resolves an artifact by its key, returning its instance directly.
+     * This is a wrapper around resolve to prevent defensive programming
+     *
+     * @param key The unique identifier for the artifact
+     * @returns A Promise that resolves to a ResolvedArtifact
+     * @throws {ArtifactNotFoundError} if the artifact is not found
+     * @throws {ArtifactError} if a cycle is detected or other system errors occur
+     */
+    require<K extends keyof TRegistry>(key: K): Promise<TRegistry[K]>;
     /**
      * Returns an ArtifactWatcher for a given artifact key.
      * The watcher allows subscribing to changes in the artifact's resolved value.

package/index.js

@@ -1 +1 @@
-"use strict";var e,t,r=Object.create,s=Object.defineProperty,n=Object.getOwnPropertyDescriptor,i=Object.getOwnPropertyNames,a=Object.getPrototypeOf,o=Object.prototype.hasOwnProperty,c=(e={"src/store/node_modules/@asaidimu/events/index.js"(e,t){var r,s=Object.defineProperty,n=Object.getOwnPropertyDescriptor,i=Object.getOwnPropertyNames,a=Object.prototype.hasOwnProperty,o={};((e,t)=>{for(var r in t)s(e,r,{get:t[r],enumerable:!0})})(o,{createEventBus:()=>c}),t.exports=(r=o,((e,t,r,o)=>{if(t&&"object"==typeof t||"function"==typeof t)for(let c of i(t))a.call(e,c)||c===r||s(e,c,{get:()=>t[c],enumerable:!(o=n(t,c))||o.enumerable});return e})(s({},"__esModule",{value:!0}),r));var c=(e={async:!1,batchSize:1e3,batchDelay:16,errorHandler:e=>console.error("EventBus Error:",e),crossTab:!1,channelName:"event-bus-channel"})=>{const t=new Map;let r=[],s=0,n=0;const i=new Map,a=new Map;let o=null;e.crossTab&&"undefined"!=typeof BroadcastChannel?o=new BroadcastChannel(e.channelName):e.crossTab&&console.warn("BroadcastChannel is not supported in this browser. Cross-tab notifications are disabled.");const c=(e,t)=>{s++,n+=t,i.set(e,(i.get(e)||0)+1)},h=()=>{const t=r;r=[],t.forEach((({name:t,payload:r})=>{const s=performance.now();try{(a.get(t)||[]).forEach((e=>e(r)))}catch(s){e.errorHandler({...s,eventName:t,payload:r})}c(t,performance.now()-s)}))},d=(()=>{let t;return()=>{clearTimeout(t),t=setTimeout(h,e.batchDelay)}})(),l=e=>{const r=t.get(e);r?a.set(e,Array.from(r)):a.delete(e)};return o&&(o.onmessage=e=>{const{name:t,payload:r}=e.data;(a.get(t)||[]).forEach((e=>e(r)))}),{subscribe:(e,r)=>{t.has(e)||t.set(e,new Set);const s=t.get(e);return s.add(r),l(e),()=>{s.delete(r),0===s.size?(t.delete(e),a.delete(e)):l(e)}},emit:({name:t,payload:s})=>{if(e.async)return r.push({name:t,payload:s}),r.length>=e.batchSize?h():d(),void(o&&o.postMessage({name:t,payload:s}));const n=performance.now();try{(a.get(t)||[]).forEach((e=>e(s))),o&&o.postMessage({name:t,payload:s})}catch(r){e.errorHandler({...r,eventName:t,payload:s})}c(t,performance.now()-n)},getMetrics:()=>({totalEvents:s,activeSubscriptions:Array.from(t.values()).reduce(((e,t)=>e+t.size),0),eventCounts:i,averageEmitDuration:s>0?n/s:0}),clear:()=>{t.clear(),a.clear(),r=[],s=0,n=0,i.clear(),o&&(o.close(),o=null)}}}}},function(){return t||(0,e[i(e)[0]])((t={exports:{}}).exports,t),t.exports}),h=(e=>(e.Singleton="singleton",e.Transient="transient",e))(h||{}),d=class e extends Error{category;constructor(t,r,s){super(t,{cause:s}),this.name="ArtifactError",this.category=r,Object.setPrototypeOf(this,e.prototype)}},l=class extends d{constructor(e){super(`[ArtifactContainer] Artifact "${e}" not found.`,"system")}},u=class extends d{constructor(e){super(`[ArtifactContainer] Artifact with key:${e} has already been disposed`,"system")}},p=class extends d{constructor(e){super(`[ArtifactContainer] Operation timed out: ${e}`,"system")}},g=class extends d{constructor(e){super(`[ArtifactContainer] An artifact with key:${e} already exists!`,"system")}},f=class extends d{constructor(){super("[Serializer] The serializer has been marked as done!","system")}},y=class{artifacts=new Map;register({key:e,factory:t,lazy:r,...s}){if(this.artifacts.has(e))throw new g(String(e));const{scope:n,...i}=s,a={key:e,factory:t,scope:s.scope??"singleton",lazy:void 0===r||r,...i};return this.artifacts.set(e,a),()=>this.unregister(e)}get(e){if(!this.has(e))throw new l(String(e));return this.artifacts.get(e)}has(e){return this.artifacts.has(e)}async unregister(e){this.artifacts.has(e)&&this.artifacts.delete(e)}size(){return this.artifacts.size}keys(){return Array.from(this.artifacts.keys())}clear(){this.artifacts.clear()}};((e,t,c)=>{c=null!=e?r(a(e)):{},((e,t,r,a)=>{if(t&&"object"==typeof t||"function"==typeof t)for(let c of i(t))o.call(e,c)||c===r||s(e,c,{get:()=>t[c],enumerable:!(a=n(t,c))||a.enumerable})})(e&&e.__esModule?c:s(c,"default",{value:e,enumerable:!0}),e)})(c());var m=class{_locked=!1;_capacity;waiters=[];constructor(e){this._capacity=e?.capacity??1/0}async lock(e){if(!this._locked)return void(this._locked=!0);if(this.waiters.length>=this._capacity)throw new Error(`Mutex queue is full (capacity: ${this._capacity})`);let t;const r=new Promise((e=>t=e));if(this.waiters.push(t),null!=e)try{await Promise.race([r,new Promise(((r,s)=>setTimeout((()=>{const e=this.waiters.indexOf(t);-1!==e&&this.waiters.splice(e,1),s(new p("Mutex lock timed out"))}),e)))])}catch(e){throw e}else await r}tryLock(){return!this._locked&&(this._locked=!0,!0)}unlock(){if(!this._locked)throw new Error("Mutex is not locked");const e=this.waiters.shift();e?setTimeout(e,0):this._locked=!1}locked(){return this._locked}pending(){return this.waiters.length}},w=class{constructor(e=!1,t=!1){this.retry=e,this.throws=t}mutex=new m;promise=null;_value=null;_error;_done=!1;async do(e,t){return this._done?this.peek():this.promise?this._awaitWithTimeout(this.promise,t,"Once do() timed out"):(await this.mutex.lock(),this.promise?(this.mutex.unlock(),this._awaitWithTimeout(this.promise,t,"Once do() timed out")):(this.promise=(async()=>{try{const t=await e();this._value=t,this._done=!0}catch(e){if(this._error=e,this.retry||(this._done=!0),this.throws)throw e}finally{this.retry&&!this._done&&(this.promise=null)}return this.peek()})(),this.mutex.unlock(),this._awaitWithTimeout(this.promise,t,"Once do() timed out")))}running(){return null!==this.promise&&!this._done}peek(){return{value:this._value,error:this._error}}get(){if(!this._done)throw new Error("Once operation is not yet complete");if(this._error)throw this._error;return this._value}reset(){this._done=!1,this.promise=null,this._value=null,this._error=void 0}resolved(){return this.promise}done(){return this._done}_awaitWithTimeout(e,t,r="Operation timed out"){return null==t?e:Promise.race([e,new Promise(((e,s)=>setTimeout((()=>s(new p(r))),t)))])}},v=class{mutex;_done=!1;_lastValue=null;_lastError=void 0;constructor(e){this.mutex=new m({capacity:e?.capacity??1e3})}async do(e,t){if(this._done)return{value:null,error:new f};try{await this.mutex.lock(t)}catch(e){return{value:null,error:e}}let r,s=null;try{if(this._done)throw new f;s=await e(),this._lastValue=s,this._lastError=void 0}catch(e){r=e,this._lastError=e}finally{this.mutex.unlock()}return{value:s,error:r}}peek(){return{value:this._lastValue,error:this._lastError}}close(){this._done=!0}pending(){return this.mutex.pending()}running(){return this.mutex.locked()}},b=class{constructor(e,t,r,s,n){this.registry=e,this.cache=t,this.graph=r,this.store=s,this.observer=n}async build(e,t){const r=this.registry.get(e);if(!r)throw new d(`Template not found for artifact "${String(e)}"`,"system");const s=t?new Set(t):new Set;if(s.has(e))throw new d(`Cycle detected: Artifact "${String(e)}" depends on itself via path: ${Array.from(s).join(" -> ")}`,"system");s.add(e);let n=this.cache.get(e);n||(n=this.createCachedArtifact(r),this.cache.set(e,n));const i=await("transient"===r.scope?this.executeBuild(r,n,s):n.buildOnce.do((()=>this.executeBuild(r,n,s))));if("transient"===r.scope)return i;const a=this.cache.package(e,((t,r)=>this.invalidate(e,t,r)));return n.stream&&n.streamOnce.do(n.stream),a}async executeBuild(e,t,r){const s=e.key;t.buildCount++;const n=[],i=[];let a=!0;t.activeDebounceMs=e.debounce??0,n.push((()=>{a=!1}));const o=new Set,c=new Set,h=new Map,l={state:()=>this.store.get(!0),previous:t.instance,onCleanup:e=>n.push(e),onDispose:e=>i.push(e),use:async e=>e({resolve:async e=>{if(e===s)throw new d(`Artifact "${String(s)}" depends on itself.`,"system");const t=this.graph.wouldCreateCycle(s,e,r);if(t)throw new d(`Adding dependency "${String(e)}" to "${String(s)}" would create a cycle: ${t.join(" -> ")}`,"system");c.add(e);const n=await this.build(e,r),i=this.cache.get(e);return i&&h.set(e,i.version),n},select:e=>(function(e,t="."){const r=new Set,s=(e=[])=>new Proxy({},{get:(n,i)=>{if("symbol"==typeof i)return;const a=[...e,i],o=a.join(t);return r.add(o),s(a)}});try{e(s())}catch(e){throw new Error(`Selector failed during path analysis. This usually means the selector is too complex. Selectors must be simple property accessors only. Error: ${e instanceof Error?e.message:String(e)}`)}const n=Array.from(r);return n.filter((e=>!n.some((r=>r!==e&&r.startsWith(e+t)))))}(e).forEach((e=>o.add(e))),e(this.store.get(!0)))}),stream:async r=>{if("transient"===e.scope)throw new d(`[ArtifactManager] Illegal stream on transient artifact "${String(s)}"`,"system");const n=async(e,r=void 0)=>{await t.streamSerializer.do((async()=>{void 0!==t.stream&&(t.instance=e,t.error=r,t.version++,this.cache.invalidatePackage(s),await this.processStream(s))}))},i={value:()=>t.instance,signal:t.streamController.signal,set:(...e)=>this.store.set(...e),emit:e=>n(e)};t.stream=async()=>{try{await r(i)}catch(e){await n(void 0,e),this.invalidate(s,!1,!0)}}}};let u,p,g=0;const f=(e.retries??0)+1;for(;g<f;)try{const t=e.factory(l);if(e.timeout){const r=new Promise(((t,r)=>setTimeout((()=>r(new Error(`Timeout: ${e.timeout}ms`))),e.timeout)));u=await Promise.race([t,r])}else u=await t;break}catch(e){if(e instanceof d)throw e;g++,g>=f&&(p=e)}if(a){for(const[e,t]of h){const r=this.cache.get(e);r&&r.version!==t&&(p=new d(`Build stale on arrival: Dependency "${String(e)}" changed during build.`,"system"))}if("singleton"===e.scope&&this.updateDependencyGraph(s,c,o),"singleton"===e.scope&&(t.cleanupFunctions=n,t.disposeFunctions=i),p?t.error=p:t.instance=u,t.version++,this.cache.invalidatePackage(s),"transient"===e.scope)return{instance:u,cleanup:this.createCompositeCleanup(n),error:p,ready:!0,invalidate:async()=>console.warn(`[ArtifactManager] Cannot invalidate transient "${String(s)}"`)}}else{const e=this.createCompositeCleanup(n);e&&await e()}}async invalidate(e,t=!1,r=!1){const s=this.cache.get(e);if(s)return s.debounceTimer&&(clearTimeout(s.debounceTimer),s.debounceTimer=void 0),!t&&s.activeDebounceMs>0?new Promise((n=>{s.debounceTimer=setTimeout((()=>{s.debounceTimer=void 0,this.executeInvalidation(e,t,r).then(n).catch(n)}),s.activeDebounceMs)})):this.executeInvalidation(e,t,r)}async executeInvalidation(e,t,r=!1){const s=this.cache.get(e);s&&(await s.invalidationOnce.do((async()=>{s.version++,await this.cache.invalidateInstance(e);const n=this.graph.getDependents(e);await Promise.all(n.map((e=>this.invalidate(e).catch((t=>{console.error(`[ArtifactManager] Cascade failed for "${String(e)}":`,t)})))));const i=this.registry.get(e);!i||!t&&i.lazy&&!this.hasWatchers(e)||r||await this.build(e),this.observer.notify(e)})),s.invalidationOnce.reset())}async dispose(e){const t=this.cache.get(e);t&&(t.streamController.abort(),t.buildOnce.running()&&await t.buildOnce.resolved(),t.invalidationOnce.running()&&await t.invalidationOnce.resolved(),t.streamOnce.running()&&await t.streamOnce.resolved(),await this.cache.invalidateInstance(e),this.graph.removeNode(e),this.cache.delete(e))}async processStream(e){try{const t=this.graph.getDependents(e);await Promise.all(t.map((e=>this.invalidate(e).catch((t=>{console.error(`[ArtifactManager] Failed to invalidate dependent "${String(e)}":`,t)}))))),this.observer.notify(e)}catch(t){console.error(`[ArtifactManager] Stream propagation error "${e}":`,t)}}updateDependencyGraph(e,t,r){const s=this.cache.get(e);s&&(this.graph.hasNode(e)||this.graph.registerNode(e),this.graph.setDependencies(e,t),s.stateUnsubscribe&&s.stateUnsubscribe(),s.stateDependencies=r,r.size>0&&(s.stateUnsubscribe=this.store.watch(Array.from(r),(async()=>{await this.invalidate(e)}))))}createCachedArtifact(e){return{instance:void 0,version:0,streamController:new AbortController,error:void 0,cleanupFunctions:[],disposeFunctions:[],buildCount:0,stateDependencies:new Set,buildOnce:new w(!0,!0),streamOnce:new w(!0,!0),streamSerializer:new v,activeDebounceMs:e.debounce??0,invalidationOnce:new w(!0,!1)}}createCompositeCleanup(e){if(e.length)return async()=>{for(let t=e.length-1;t>=0;t--)try{await e[t]()}catch(e){console.error("[ArtifactManager] Cleanup error:",e)}}}hasWatchers(e){return this.observer.hasWatchers(e)??!1}},C=class{dependencies=new Map;dependents=new Map;metadata=new Map;registerNode(e,t){this.dependencies.has(e)||this.dependencies.set(e,new Set),this.dependents.has(e)||this.dependents.set(e,new Set),void 0!==t&&this.metadata.set(e,t)}removeNode(e){if(!this.hasNode(e))return;const t=this.dependencies.get(e);if(t)for(const r of t)this.dependents.get(r)?.delete(e);const r=this.dependents.get(e);if(r)for(const t of r)this.dependencies.get(t)?.delete(e);this.dependencies.delete(e),this.dependents.delete(e),this.metadata.delete(e)}hasNode(e){return this.dependencies.has(e)}addDependency(e,t){this.registerNode(e),this.registerNode(t),this.dependencies.get(e).add(t),this.dependents.get(t).add(e)}removeDependency(e,t){this.dependencies.get(e)?.delete(t),this.dependents.get(t)?.delete(e)}getDependencies(e){const t=this.dependencies.get(e);return t?new Set(t):new Set}getDependents(e){const t=this.dependents.get(e);return t?new Set(t):new Set}getMetadata(e){return this.metadata.get(e)}setMetadata(e,t){this.registerNode(e),this.metadata.set(e,t)}setDependencies(e,t){this.registerNode(e);const r=this.dependencies.get(e),s=new Set(t);for(const t of r)s.has(t)||this.removeDependency(e,t);for(const t of s)r.has(t)||this.addDependency(e,t)}wouldCreateCycle(e,t){if(e===t)return[e,t];const r=[t],s=new Set([t]),n=new Map;for(;r.length>0;){const i=r.shift();if(i===e){const r=[];let s=e;for(;void 0!==s&&(r.push(s),s!==t);)s=n.get(s);return r.reverse(),[e,...r]}const a=this.dependencies.get(i);if(a)for(const e of a)s.has(e)||(s.add(e),n.set(e,i),r.push(e))}return null}topologicalSort(){const e=new Map,t=Array.from(this.dependencies.keys());for(const r of t)e.set(r,this.dependencies.get(r)?.size??0);const r=[];for(const[t,s]of e)0===s&&r.push(t);const s=[];for(;r.length>0;){const t=r.shift();s.push(t);const n=this.dependents.get(t);if(n)for(const t of n){const s=(e.get(t)||0)-1;e.set(t,s),0===s&&r.push(t)}}if(s.length!==t.length)throw new Error("Cycle detected in graph; topological sort impossible.");return s}getTransitiveDependencies(e,t=!1){return this.bfs(e,"dependencies",t)}getTransitiveDependents(e,t=!1){return this.bfs(e,"dependents",t)}bfs(e,t,r){const s=new Set,n=new Set,i=[e];n.add(e),r&&s.add(e);const a="dependencies"===t?this.dependencies:this.dependents;for(;i.length>0;){const e=i.shift(),t=a.get(e);if(t)for(const e of t)n.has(e)||(n.add(e),s.add(e),i.push(e))}return s}getAllNodes(){return Array.from(this.dependencies.keys())}size(){return this.dependencies.size}clear(){this.dependencies.clear(),this.dependents.clear(),this.metadata.clear()}toDebugString(){return Array.from(this.dependencies.entries()).map((([e,t])=>{const r=Array.from(t).join(", ");return`${String(e)} → [${r||"∅"}]`})).join("\n")}},A=class{graph;constructor(){this.graph=new C}registerNode(e){this.graph.registerNode(e)}removeNode(e){this.graph.removeNode(e)}addDependency(e,t){this.graph.addDependency(e,t)}removeDependency(e,t){this.graph.removeDependency(e,t)}getDependents(e){const t=this.graph.getDependents(e);return Array.from(t)}getDependencies(e){const t=this.graph.getDependencies(e);return Array.from(t)}getTransitiveDependents(e){const t=this.graph.getTransitiveDependents(e,!1);return new Set(Array.from(t))}setDependencies(e,t){const r=Array.from(t).map((e=>e));this.graph.setDependencies(e,r)}wouldCreateCycle(e,t,r){if(r?.has(t)){const e=Array.from(r),s=e.indexOf(t),n=e.slice(s);return n.push(t),n}const s=this.graph.wouldCreateCycle(e,t);return s||null}hasNode(e){return this.graph.hasNode(e)}getAllNodes(){return this.graph.getAllNodes()}clear(){this.graph.clear()}size(){return this.graph.size()}toDebugString(){return this.graph.toDebugString()}},_=class{cache=new Map;emptyInstance={instance:void 0,error:void 0,ready:!1,cleanup:void 0,invalidate:async(e,t)=>{}};get(e){return this.cache.get(e)}set(e,t){this.cache.set(e,t)}delete(e){this.cache.delete(e)}has(e){return this.cache.has(e)}clear(){this.cache.clear()}size(){return this.cache.size}keys(){return Array.from(this.cache.keys())}package(e,t){const r=this.get(e);if(!r)return this.emptyInstance;if(r.packagedArtifact)return this.updatePackagedArtifact(r,r.packagedArtifact,t),r.packagedArtifact;const s={instance:r.instance,error:r.error,ready:r.buildOnce.done()&&!r.buildOnce.running(),cleanup:this.createCompositeCleanup(r.cleanupFunctions),invalidate:t};return r.packagedArtifact=s,s}async invalidatePackage(e){const t=this.get(e);t&&(t.packagedArtifact=void 0)}async invalidateInstance(e){const t=this.get(e);if(t){t.stateUnsubscribe&&(t.stateUnsubscribe(),t.stateUnsubscribe=void 0),t.debounceTimer&&(clearTimeout(t.debounceTimer),t.debounceTimer=void 0),t.streamController.abort(),await t.streamOnce.resolved(),t.streamOnce.reset(),t.streamSerializer.close();for(let e=t.cleanupFunctions.length-1;e>=0;e--)try{await t.cleanupFunctions[e]()}catch(e){console.error("[ArtifactManager] Cleanup error:",e)}for(let e=t.disposeFunctions.length-1;e>=0;e--)try{await t.disposeFunctions[e]()}catch(e){console.error("[ArtifactManager] Dispose error:",e)}t.instance=void 0,t.error=void 0,t.cleanupFunctions=[],t.disposeFunctions=[],t.buildOnce.reset(),t.stream=void 0,t.streamSerializer=new v,t.streamController=new AbortController}}updatePackagedArtifact(e,t,r){t.instance=e.instance,t.error=e.error,t.ready=e.buildOnce.done()&&!e.buildOnce.running(),t.cleanup=this.createCompositeCleanup(e.cleanupFunctions),t.invalidate=r}createCompositeCleanup(e){if(e.length)return async()=>{for(let t=e.length-1;t>=0;t--)try{await e[t]()}catch(e){console.error("[ArtifactCache] Cleanup error:",e)}}}},k=class{constructor(e,t,r){this.registry=e,this.cache=t,this.container=r}listeners=new Map;watcherCache=new Map;watch(e){const t=String(e),r=this.registry.get(e);if(!r)throw new Error(`Artifact "${t}" not registered`);let s=t;if("transient"===r.scope&&(s=`${t}__watched`,this.registry.has(s)||this.registry.register({key:s,factory:r.factory,scope:"singleton",lazy:r.lazy,timeout:r.timeout,retries:r.retries,debounce:r.debounce})),this.watcherCache.has(s)){const e=this.watcherCache.get(s);return e.count++,e}let n=!1;const i={id:t,count:1,get:()=>{if(!this.cache.get(s))return this.cache.package(s,(e=>this.container.invalidate(s,e)));const e=this.cache.package(s,(e=>this.container.invalidate(s,e)));return n?{...e,ready:!1,instance:void 0,error:new u(t),cleanup:()=>{},invalidate:()=>Promise.resolve()}:e},subscribe:e=>{this.listeners.has(s)||this.listeners.set(s,new Set);const t=()=>e(i.get());return this.listeners.get(s).add(t),this.container.resolve(s).catch((e=>{console.error(`[ArtifactObserver] Background resolution failed for "${s}":`,e)})).then(t),()=>this.listeners.get(s)?.delete(t)},dispose:async()=>{i.count--,i.count<=0&&(this.watcherCache.delete(s),"transient"===r.scope&&(await this.registry.unregister(s),this.cache.delete(s)),n=!0,this.notify(s),this.listeners.delete(s))}};return this.watcherCache.set(s,i),i}notify(e){const t=this.listeners.get(e);t&&t.forEach((t=>{try{t()}catch(t){console.error(`[ArtifactObserver] Listener error for "${e}":`,t)}}))}hasWatchers(e){return this.watcherCache.has(e)||this.watcherCache.has(`${e}__watched`)}getWatcherCount(e){const t=this.watcherCache.get(e)||this.watcherCache.get(`${e}__watched`);return t?.count??0}clear(){this.watcherCache.clear(),this.listeners.clear()}};exports.ArtifactContainer=class{registry;cache;graph;manager;observer;store;constructor(e){this.store={watch:(...t)=>e.watch(...t),get:()=>e.get(!0),set:(...t)=>e.set(...t)},this.registry=new y,this.cache=new _,this.graph=new A,this.observer=new k(this.registry,this.cache,this),this.manager=new b(this.registry,this.cache,this.graph,this.store,this.observer)}debugInfo(){const e=[];return this.registry.keys().forEach((t=>{const r=this.registry.get(t),s=this.cache.get(t);if(!r)return;const n=s?s.buildOnce.running()?"pending":s.error?"error":void 0!==s.instance?"active":"idle":"idle";e.push({id:t,scope:r.scope??"singleton",status:n,dependencies:this.graph.getDependencies(t).map((e=>String(e))),dependents:this.graph.getDependents(t).map((e=>String(e))),stateDependencies:s?Array.from(s.stateDependencies):[],renderCount:s?.buildCount??0})})),e}register(e){const{key:t}=e,r=t;this.registry.has(t)&&(console.warn(`[ArtifactContainer] Overwriting "${r}".`),this.manager.dispose(t).catch((e=>{console.error(`[ArtifactContainer] Failed to dispose existing artifact "${r}":`,e)}))),this.registry.register(e),this.graph.registerNode(t);const s=e.scope??"singleton";return(e.lazy??!0)||"singleton"!==s||this.resolve(t).catch((e=>{console.error(`[ArtifactContainer] Eager load failed for "${r}":`,e)})),()=>this.unregister(t)}async unregister(e){await this.manager.dispose(e),await this.registry.unregister(e)}async resolve(e){if(!this.registry.has(e))throw new l(e);return this.manager.build(e)}watch(e){if(!this.registry.has(e))throw new l(e);return this.observer.watch(e)}peek(e){const t=this.cache.get(e);if(void 0!==t?.instance)return t?.instance}async invalidate(e,t=!1){return this.manager.invalidate(e,t)}notifyObservers(e){this.observer.notify(e)}hasWatchers(e){return this.observer.hasWatchers(e)}dispose(){this.registry.keys().forEach((e=>{this.manager.dispose(e).catch((t=>{console.error(`[ArtifactContainer] Failed to dispose artifact "${String(e)}":`,t)}))})),this.registry.clear(),this.cache.clear(),this.graph.clear(),this.observer.clear()}},exports.ArtifactScopes=h;
+"use strict";var e,t,r=Object.create,s=Object.defineProperty,n=Object.getOwnPropertyDescriptor,i=Object.getOwnPropertyNames,a=Object.getPrototypeOf,o=Object.prototype.hasOwnProperty,c=(e={"node_modules/@asaidimu/events/index.js"(e,t){var r,s=Object.defineProperty,n=Object.getOwnPropertyDescriptor,i=Object.getOwnPropertyNames,a=Object.prototype.hasOwnProperty,o={};((e,t)=>{for(var r in t)s(e,r,{get:t[r],enumerable:!0})})(o,{createEventBus:()=>c}),t.exports=(r=o,((e,t,r,o)=>{if(t&&"object"==typeof t||"function"==typeof t)for(let c of i(t))a.call(e,c)||c===r||s(e,c,{get:()=>t[c],enumerable:!(o=n(t,c))||o.enumerable});return e})(s({},"__esModule",{value:!0}),r));var c=(e={async:!1,batchSize:1e3,batchDelay:16,errorHandler:e=>console.error("EventBus Error:",e),crossTab:!1,channelName:"event-bus-channel"})=>{const t=new Map;let r=[],s=0,n=0;const i=new Map,a=new Map;let o=null;e.crossTab&&"undefined"!=typeof BroadcastChannel?o=new BroadcastChannel(e.channelName):e.crossTab&&console.warn("BroadcastChannel is not supported in this browser. Cross-tab notifications are disabled.");const c=(e,t)=>{s++,n+=t,i.set(e,(i.get(e)||0)+1)},h=()=>{const t=r;r=[],t.forEach((({name:t,payload:r})=>{const s=performance.now();try{(a.get(t)||[]).forEach((e=>e(r)))}catch(s){e.errorHandler({...s,eventName:t,payload:r})}c(t,performance.now()-s)}))},d=(()=>{let t;return()=>{clearTimeout(t),t=setTimeout(h,e.batchDelay)}})(),l=e=>{const r=t.get(e);r?a.set(e,Array.from(r)):a.delete(e)};return o&&(o.onmessage=e=>{const{name:t,payload:r}=e.data;(a.get(t)||[]).forEach((e=>e(r)))}),{subscribe:(e,r)=>{t.has(e)||t.set(e,new Set);const s=t.get(e);return s.add(r),l(e),()=>{s.delete(r),0===s.size?(t.delete(e),a.delete(e)):l(e)}},emit:({name:t,payload:s})=>{if(e.async)return r.push({name:t,payload:s}),r.length>=e.batchSize?h():d(),void(o&&o.postMessage({name:t,payload:s}));const n=performance.now();try{(a.get(t)||[]).forEach((e=>e(s))),o&&o.postMessage({name:t,payload:s})}catch(r){e.errorHandler({...r,eventName:t,payload:s})}c(t,performance.now()-n)},getMetrics:()=>({totalEvents:s,activeSubscriptions:Array.from(t.values()).reduce(((e,t)=>e+t.size),0),eventCounts:i,averageEmitDuration:s>0?n/s:0}),clear:()=>{t.clear(),a.clear(),r=[],s=0,n=0,i.clear(),o&&(o.close(),o=null)}}}}},function(){return t||(0,e[i(e)[0]])((t={exports:{}}).exports,t),t.exports}),h=(e=>(e.Singleton="singleton",e.Transient="transient",e))(h||{}),d=class e extends Error{category;constructor(t,r,s){super(t,{cause:s}),this.name="ArtifactError",this.category=r,Object.setPrototypeOf(this,e.prototype)}},l=class extends d{constructor(e){super(`[ArtifactContainer] Artifact "${e}" not found.`,"system")}},u=class extends d{constructor(e){super(`[ArtifactContainer] Operation timed out: ${e}`,"system")}},p=class extends d{constructor(e){super(`[ArtifactContainer] An artifact with key:${e} already exists!`,"system")}},g=class extends d{constructor(){super("[Serializer] The serializer has been marked as done!","system")}},f=class{artifacts=new Map;register({key:e,factory:t,lazy:r,...s}){if(this.artifacts.has(e))throw new p(String(e));const{scope:n,...i}=s,a={key:e,factory:t,scope:s.scope??"singleton",lazy:void 0===r||r,...i};return this.artifacts.set(e,a),()=>this.unregister(e)}get(e){if(!this.has(e))throw new l(String(e));return this.artifacts.get(e)}has(e){return this.artifacts.has(e)}async unregister(e){this.artifacts.has(e)&&this.artifacts.delete(e)}size(){return this.artifacts.size}keys(){return Array.from(this.artifacts.keys())}clear(){this.artifacts.clear()}};((e,t,c)=>{c=null!=e?r(a(e)):{},((e,t,r,a)=>{if(t&&"object"==typeof t||"function"==typeof t)for(let c of i(t))o.call(e,c)||c===r||s(e,c,{get:()=>t[c],enumerable:!(a=n(t,c))||a.enumerable})})(e&&e.__esModule?c:s(c,"default",{value:e,enumerable:!0}),e)})(c());var y=class{_locked=!1;_capacity;waiters=[];constructor(e){this._capacity=e?.capacity??1/0}async lock(e){if(!this._locked)return void(this._locked=!0);if(this.waiters.length>=this._capacity)throw new Error(`Mutex queue is full (capacity: ${this._capacity})`);let t;const r=new Promise((e=>t=e));if(this.waiters.push(t),null!=e)try{await Promise.race([r,new Promise(((r,s)=>setTimeout((()=>{const e=this.waiters.indexOf(t);-1!==e&&this.waiters.splice(e,1),s(new u("Mutex lock timed out"))}),e)))])}catch(e){throw e}else await r}tryLock(){return!this._locked&&(this._locked=!0,!0)}unlock(){if(!this._locked)throw new Error("Mutex is not locked");const e=this.waiters.shift();e?setTimeout(e,0):this._locked=!1}locked(){return this._locked}pending(){return this.waiters.length}},m=class{constructor(e=!1,t=!1){this.retry=e,this.throws=t}mutex=new y;promise=null;_value=null;_error;_done=!1;async do(e,t){return this._done?this.peek():this.promise?this._awaitWithTimeout(this.promise,t,"Once do() timed out"):(await this.mutex.lock(),this.promise?(this.mutex.unlock(),this._awaitWithTimeout(this.promise,t,"Once do() timed out")):(this.promise=(async()=>{try{const t=await e();this._value=t,this._done=!0}catch(e){if(this._error=e,this.retry||(this._done=!0),this.throws)throw e}finally{this.retry&&!this._done&&(this.promise=null)}return this.peek()})(),this.mutex.unlock(),this._awaitWithTimeout(this.promise,t,"Once do() timed out")))}running(){return null!==this.promise&&!this._done}peek(){return{value:this._value,error:this._error}}get(){if(!this._done)throw new Error("Once operation is not yet complete");if(this._error)throw this._error;return this._value}reset(){this._done=!1,this.promise=null,this._value=null,this._error=void 0}resolved(){return this.promise}done(){return this._done}_awaitWithTimeout(e,t,r="Operation timed out"){return null==t?e:Promise.race([e,new Promise(((e,s)=>setTimeout((()=>s(new u(r))),t)))])}},w=class{mutex;_done=!1;_lastValue=null;_lastError=void 0;constructor(e){this.mutex=new y({capacity:e?.capacity??1e3})}async do(e,t){if(this._done)return{value:null,error:new g};try{await this.mutex.lock(t)}catch(e){return{value:null,error:e}}let r,s=null;try{if(this._done)throw new g;s=await e(),this._lastValue=s,this._lastError=void 0}catch(e){r=e,this._lastError=e}finally{this.mutex.unlock()}return{value:s,error:r}}peek(){return{value:this._lastValue,error:this._lastError}}close(){this._done=!0}pending(){return this.mutex.pending()}running(){return this.mutex.locked()}},v=class{constructor(e,t,r,s,n){this.registry=e,this.cache=t,this.graph=r,this.store=s,this.observer=n}async build(e,t){const r=this.registry.get(e);if(!r)throw new d(`Template not found for artifact "${String(e)}"`,"system");const s=t?new Set(t):new Set;if(s.has(e))throw new d(`Cycle detected: Artifact "${String(e)}" depends on itself via path: ${Array.from(s).join(" -> ")}`,"system");s.add(e);let n=this.cache.get(e);n||(n=this.createCachedArtifact(r),this.cache.set(e,n));const i=await("transient"===r.scope?this.executeBuild(r,n,s):n.buildOnce.do((()=>this.executeBuild(r,n,s))));if("transient"===r.scope)return i;const a=this.cache.package(e,((t,r)=>this.invalidate(e,t,r)));return n.stream&&n.streamOnce.do(n.stream),a}async executeBuild(e,t,r){const s=e.key;t.buildCount++;const n=[],i=[];let a=!0;t.activeDebounceMs=e.debounce??0,n.push((()=>{a=!1}));const o=new Set,c=new Set,h=new Map,l=this.graph,u=this.cache,p=this.build.bind(this);async function g(e){if(e===s)throw new d(`Artifact "${String(s)}" depends on itself.`,"system");const t=l.wouldCreateCycle(s,e,r);if(t)throw new d(`Adding dependency "${String(e)}" to "${String(s)}" would create a cycle: ${t.join(" -> ")}`,"system");c.add(e);const n=await p(e,r),i=u.get(e);return i&&h.set(e,i.version),n}const f={state:()=>this.store.get(!0),previous:t.instance,onCleanup:e=>n.push(e),onDispose:e=>i.push(e),use:async e=>e({resolve:g,require:async e=>{const t=await g(e);if(t.error)throw t.error;return t.instance},select:e=>(function(e,t="."){const r=new Set,s=(e=[])=>new Proxy({},{get:(n,i)=>{if("symbol"==typeof i)return;const a=[...e,i],o=a.join(t);return r.add(o),s(a)}});try{e(s())}catch(e){throw new Error(`Selector failed during path analysis. This usually means the selector is too complex. Selectors must be simple property accessors only. Error: ${e instanceof Error?e.message:String(e)}`)}const n=Array.from(r);return n.filter((e=>!n.some((r=>r!==e&&r.startsWith(e+t)))))}(e).forEach((e=>o.add(e))),e(this.store.get(!0)))}),stream:async r=>{if("transient"===e.scope)throw new d(`[ArtifactManager] Illegal stream on transient artifact "${String(s)}"`,"system");const n=async(e,r=void 0)=>{await t.streamSerializer.do((async()=>{void 0!==t.stream&&(t.instance=e,t.error=r,t.version++,this.cache.invalidatePackage(s),await this.processStream(s))}))},i={value:()=>t.instance,signal:t.streamController.signal,set:(...e)=>this.store.set(...e),emit:e=>n(e)};t.stream=async()=>{try{await r(i)}catch(e){await n(void 0,e),this.invalidate(s,!1,!0)}}}};let y,m,w=0;const v=(e.retries??0)+1;for(;w<v;)try{const t=e.factory(f);if(e.timeout){const r=new Promise(((t,r)=>setTimeout((()=>r(new Error(`Timeout: ${e.timeout}ms`))),e.timeout)));y=await Promise.race([t,r])}else y=await t;break}catch(e){if(e instanceof d)throw e;w++,w>=v&&(m=e)}if(a){for(const[e,t]of h){const r=this.cache.get(e);r&&r.version!==t&&(m=new d(`Build stale on arrival: Dependency "${String(e)}" changed during build.`,"system"))}if("singleton"===e.scope&&this.updateDependencyGraph(s,c,o),"singleton"===e.scope&&(t.cleanupFunctions=n,t.disposeFunctions=i),m?t.error=m:t.instance=y,t.version++,this.cache.invalidatePackage(s),"transient"===e.scope)return{instance:y,cleanup:this.createCompositeCleanup(n),error:m,ready:!0,invalidate:async()=>console.warn(`[ArtifactManager] Cannot invalidate transient "${String(s)}"`)}}else{const e=this.createCompositeCleanup(n);e&&await e()}}async invalidate(e,t=!1,r=!1){const s=this.cache.get(e);if(s)return s.debounceTimer&&(clearTimeout(s.debounceTimer),s.debounceTimer=void 0),!t&&s.activeDebounceMs>0?new Promise((n=>{s.debounceTimer=setTimeout((()=>{s.debounceTimer=void 0,this.executeInvalidation(e,t,r).then(n).catch(n)}),s.activeDebounceMs)})):this.executeInvalidation(e,t,r)}async executeInvalidation(e,t,r=!1){const s=this.cache.get(e);s&&(await s.invalidationOnce.do((async()=>{s.version++,await this.cache.invalidateInstance(e);const n=this.graph.getDependents(e);await Promise.all(n.map((e=>this.invalidate(e).catch((t=>{console.error(`[ArtifactManager] Cascade failed for "${String(e)}":`,t)})))));const i=this.registry.get(e);!i||!t&&i.lazy&&!this.hasWatchers(e)||r||await this.build(e),this.observer.notify(e)})),s.invalidationOnce.reset())}async dispose(e){const t=this.cache.get(e);t&&(t.streamController.abort(),t.buildOnce.running()&&await t.buildOnce.resolved(),t.invalidationOnce.running()&&await t.invalidationOnce.resolved(),t.streamOnce.running()&&await t.streamOnce.resolved(),await this.cache.invalidateInstance(e),this.graph.removeNode(e),this.cache.delete(e))}async processStream(e){try{const t=this.graph.getDependents(e);await Promise.all(t.map((e=>this.invalidate(e).catch((t=>{console.error(`[ArtifactManager] Failed to invalidate dependent "${String(e)}":`,t)}))))),this.observer.notify(e)}catch(t){console.error(`[ArtifactManager] Stream propagation error "${e}":`,t)}}updateDependencyGraph(e,t,r){const s=this.cache.get(e);s&&(this.graph.hasNode(e)||this.graph.registerNode(e),this.graph.setDependencies(e,t),s.stateUnsubscribe&&s.stateUnsubscribe(),s.stateDependencies=r,r.size>0&&(s.stateUnsubscribe=this.store.watch(Array.from(r),(async()=>{await this.invalidate(e)}))))}createCachedArtifact(e){return{instance:void 0,version:0,streamController:new AbortController,error:void 0,cleanupFunctions:[],disposeFunctions:[],buildCount:0,stateDependencies:new Set,buildOnce:new m(!0,!0),streamOnce:new m(!0,!0),streamSerializer:new w,activeDebounceMs:e.debounce??0,invalidationOnce:new m(!0,!1)}}createCompositeCleanup(e){if(e.length)return async()=>{for(let t=e.length-1;t>=0;t--)try{await e[t]()}catch(e){console.error("[ArtifactManager] Cleanup error:",e)}}}hasWatchers(e){return this.observer.hasWatchers(e)??!1}},b=class{dependencies=new Map;dependents=new Map;metadata=new Map;registerNode(e,t){this.dependencies.has(e)||this.dependencies.set(e,new Set),this.dependents.has(e)||this.dependents.set(e,new Set),void 0!==t&&this.metadata.set(e,t)}removeNode(e){if(!this.hasNode(e))return;const t=this.dependencies.get(e);if(t)for(const r of t)this.dependents.get(r)?.delete(e);const r=this.dependents.get(e);if(r)for(const t of r)this.dependencies.get(t)?.delete(e);this.dependencies.delete(e),this.dependents.delete(e),this.metadata.delete(e)}hasNode(e){return this.dependencies.has(e)}addDependency(e,t){this.registerNode(e),this.registerNode(t),this.dependencies.get(e).add(t),this.dependents.get(t).add(e)}removeDependency(e,t){this.dependencies.get(e)?.delete(t),this.dependents.get(t)?.delete(e)}getDependencies(e){const t=this.dependencies.get(e);return t?new Set(t):new Set}getDependents(e){const t=this.dependents.get(e);return t?new Set(t):new Set}getMetadata(e){return this.metadata.get(e)}setMetadata(e,t){this.registerNode(e),this.metadata.set(e,t)}setDependencies(e,t){this.registerNode(e);const r=this.dependencies.get(e),s=new Set(t);for(const t of r)s.has(t)||this.removeDependency(e,t);for(const t of s)r.has(t)||this.addDependency(e,t)}wouldCreateCycle(e,t){if(e===t)return[e,t];const r=[t],s=new Set([t]),n=new Map;for(;r.length>0;){const i=r.shift();if(i===e){const r=[];let s=e;for(;void 0!==s&&(r.push(s),s!==t);)s=n.get(s);return r.reverse(),[e,...r]}const a=this.dependencies.get(i);if(a)for(const e of a)s.has(e)||(s.add(e),n.set(e,i),r.push(e))}return null}topologicalSort(){const e=new Map,t=Array.from(this.dependencies.keys());for(const r of t)e.set(r,this.dependencies.get(r)?.size??0);const r=[];for(const[t,s]of e)0===s&&r.push(t);const s=[];for(;r.length>0;){const t=r.shift();s.push(t);const n=this.dependents.get(t);if(n)for(const t of n){const s=(e.get(t)||0)-1;e.set(t,s),0===s&&r.push(t)}}if(s.length!==t.length)throw new Error("Cycle detected in graph; topological sort impossible.");return s}getTransitiveDependencies(e,t=!1){return this.bfs(e,"dependencies",t)}getTransitiveDependents(e,t=!1){return this.bfs(e,"dependents",t)}bfs(e,t,r){const s=new Set,n=new Set,i=[e];n.add(e),r&&s.add(e);const a="dependencies"===t?this.dependencies:this.dependents;for(;i.length>0;){const e=i.shift(),t=a.get(e);if(t)for(const e of t)n.has(e)||(n.add(e),s.add(e),i.push(e))}return s}getAllNodes(){return Array.from(this.dependencies.keys())}size(){return this.dependencies.size}clear(){this.dependencies.clear(),this.dependents.clear(),this.metadata.clear()}toDebugString(){return Array.from(this.dependencies.entries()).map((([e,t])=>{const r=Array.from(t).join(", ");return`${String(e)} → [${r||"∅"}]`})).join("\n")}},C=class{graph;constructor(){this.graph=new b}registerNode(e){this.graph.registerNode(e)}removeNode(e){this.graph.removeNode(e)}addDependency(e,t){this.graph.addDependency(e,t)}removeDependency(e,t){this.graph.removeDependency(e,t)}getDependents(e){const t=this.graph.getDependents(e);return Array.from(t)}getDependencies(e){const t=this.graph.getDependencies(e);return Array.from(t)}getTransitiveDependents(e){const t=this.graph.getTransitiveDependents(e,!1);return new Set(Array.from(t))}setDependencies(e,t){const r=Array.from(t).map((e=>e));this.graph.setDependencies(e,r)}wouldCreateCycle(e,t,r){if(r?.has(t)){const e=Array.from(r),s=e.indexOf(t),n=e.slice(s);return n.push(t),n}const s=this.graph.wouldCreateCycle(e,t);return s||null}hasNode(e){return this.graph.hasNode(e)}getAllNodes(){return this.graph.getAllNodes()}clear(){this.graph.clear()}size(){return this.graph.size()}toDebugString(){return this.graph.toDebugString()}},A=class{cache=new Map;emptyInstance={instance:void 0,error:void 0,ready:!1,cleanup:void 0,invalidate:async(e,t)=>{}};get(e){return this.cache.get(e)}set(e,t){this.cache.set(e,t)}delete(e){this.cache.delete(e)}has(e){return this.cache.has(e)}clear(){this.cache.clear()}size(){return this.cache.size}keys(){return Array.from(this.cache.keys())}package(e,t){const r=this.get(e);if(!r)return this.emptyInstance;if(r.packagedArtifact)return this.updatePackagedArtifact(r,r.packagedArtifact,t),r.packagedArtifact;const s={instance:r.instance,error:r.error,ready:r.buildOnce.done()&&!r.buildOnce.running(),cleanup:this.createCompositeCleanup(r.cleanupFunctions),invalidate:t};return r.packagedArtifact=s,s}async invalidatePackage(e){const t=this.get(e);t&&(t.packagedArtifact=void 0)}async invalidateInstance(e){const t=this.get(e);if(t){t.stateUnsubscribe&&(t.stateUnsubscribe(),t.stateUnsubscribe=void 0),t.debounceTimer&&(clearTimeout(t.debounceTimer),t.debounceTimer=void 0),t.streamController.abort(),await t.streamOnce.resolved(),t.streamOnce.reset(),t.streamSerializer.close();for(let e=t.cleanupFunctions.length-1;e>=0;e--)try{await t.cleanupFunctions[e]()}catch(e){console.error("[ArtifactManager] Cleanup error:",e)}for(let e=t.disposeFunctions.length-1;e>=0;e--)try{await t.disposeFunctions[e]()}catch(e){console.error("[ArtifactManager] Dispose error:",e)}t.instance=void 0,t.error=void 0,t.cleanupFunctions=[],t.disposeFunctions=[],t.buildOnce.reset(),t.stream=void 0,t.streamSerializer=new w,t.streamController=new AbortController}}updatePackagedArtifact(e,t,r){t.instance=e.instance,t.error=e.error,t.ready=e.buildOnce.done()&&!e.buildOnce.running(),t.cleanup=this.createCompositeCleanup(e.cleanupFunctions),t.invalidate=r}createCompositeCleanup(e){if(e.length)return async()=>{for(let t=e.length-1;t>=0;t--)try{await e[t]()}catch(e){console.error("[ArtifactCache] Cleanup error:",e)}}}},_=class{constructor(e,t,r){this.registry=e,this.cache=t,this.container=r}listeners=new Map;watcherCache=new Map;watch(e){const t=String(e),r=this.registry.get(e);if(!r)throw new Error(`Artifact "${t}" not registered`);const s="transient"===r.scope?`${t}__watched`:t;if(this.watcherCache.has(s))return this.watcherCache.get(s).watcher;const n={count:0,init:new m(!1,!0),watcher:null},i=()=>n.init.do((async()=>{"transient"!==r.scope||this.registry.has(s)||this.registry.register({key:s,factory:r.factory,scope:"singleton",lazy:r.lazy,timeout:r.timeout,retries:r.retries,debounce:r.debounce})}));return n.watcher={id:t,get count(){return n.count},get:()=>{this.cache.get(s);return this.cache.package(s,(e=>this.container.invalidate(s,e)))},resolve:async()=>(await i(),this.container.resolve(s)),subscribe:e=>{0===n.count&&i(),n.count++,this.listeners.has(s)||this.listeners.set(s,new Set);const t=()=>e(n.watcher.get());return this.listeners.get(s).add(t),this.container.resolve(s).catch((e=>{console.error(`[ArtifactObserver] Background resolution failed for "${s}":`,e)})).then(t),()=>{this.listeners.get(s)?.delete(t),n.count--,0===n.count&&(this.listeners.delete(s),"transient"===r.scope&&(this.registry.unregister(s).catch((e=>{console.error(`[ArtifactObserver] Cleanup failed for "${s}":`,e)})),this.cache.delete(s)),n.init.reset())}}},this.watcherCache.set(s,n),n.watcher}notify(e){const t=this.listeners.get(e);t&&t.forEach((t=>{try{t()}catch(t){console.error(`[ArtifactObserver] Listener error for "${e}":`,t)}}))}hasWatchers(e){return this.watcherCache.has(e)||this.watcherCache.has(`${e}__watched`)}getWatcherCount(e){const t=this.watcherCache.get(e)||this.watcherCache.get(`${e}__watched`);return t?.count??0}clear(){this.watcherCache.clear(),this.listeners.clear()}};exports.ArtifactContainer=class{registry;cache;graph;manager;observer;store;constructor(e){this.store={watch:(...t)=>e.watch(...t),get:()=>e.get(!0),set:(...t)=>e.set(...t)},this.registry=new f,this.cache=new A,this.graph=new C,this.observer=new _(this.registry,this.cache,this),this.manager=new v(this.registry,this.cache,this.graph,this.store,this.observer)}debugInfo(){const e=[];return this.registry.keys().forEach((t=>{const r=this.registry.get(t),s=this.cache.get(t);if(!r)return;const n=s?s.buildOnce.running()?"pending":s.error?"error":void 0!==s.instance?"active":"idle":"idle";e.push({id:t,scope:r.scope??"singleton",status:n,dependencies:this.graph.getDependencies(t).map((e=>String(e))),dependents:this.graph.getDependents(t).map((e=>String(e))),stateDependencies:s?Array.from(s.stateDependencies):[],renderCount:s?.buildCount??0})})),e}register(e){const{key:t}=e,r=t;this.registry.has(t)&&(console.warn(`[ArtifactContainer] Overwriting "${r}".`),this.manager.dispose(t).catch((e=>{console.error(`[ArtifactContainer] Failed to dispose existing artifact "${r}":`,e)}))),this.registry.register(e),this.graph.registerNode(t);const s=e.scope??"singleton";return(e.lazy??!0)||"singleton"!==s||this.resolve(t).catch((e=>{console.error(`[ArtifactContainer] Eager load failed for "${r}":`,e)})),()=>this.unregister(t)}async unregister(e){await this.manager.dispose(e),await this.registry.unregister(e)}async resolve(e){if(!this.registry.has(e))throw new l(e);return this.manager.build(e)}async require(e){const t=await this.resolve(e);if(t.error)throw t.error;return t.instance}watch(e){if(!this.registry.has(e))throw new l(e);return this.observer.watch(e)}peek(e){const t=this.cache.get(e);if(void 0!==t?.instance)return t?.instance}async invalidate(e,t=!1){return this.manager.invalidate(e,t)}notifyObservers(e){this.observer.notify(e)}hasWatchers(e){return this.observer.hasWatchers(e)}dispose(){this.registry.keys().forEach((e=>{this.manager.dispose(e).catch((t=>{console.error(`[ArtifactContainer] Failed to dispose artifact "${String(e)}":`,t)}))})),this.registry.clear(),this.cache.clear(),this.graph.clear(),this.observer.clear()}},exports.ArtifactScopes=h;

package/index.mjs

@@ -1 +1 @@
-var e,t,r=Object.create,s=Object.defineProperty,n=Object.getOwnPropertyDescriptor,i=Object.getOwnPropertyNames,a=Object.getPrototypeOf,o=Object.prototype.hasOwnProperty,c=(e={"src/store/node_modules/@asaidimu/events/index.js"(e,t){var r,s=Object.defineProperty,n=Object.getOwnPropertyDescriptor,i=Object.getOwnPropertyNames,a=Object.prototype.hasOwnProperty,o={};((e,t)=>{for(var r in t)s(e,r,{get:t[r],enumerable:!0})})(o,{createEventBus:()=>c}),t.exports=(r=o,((e,t,r,o)=>{if(t&&"object"==typeof t||"function"==typeof t)for(let c of i(t))a.call(e,c)||c===r||s(e,c,{get:()=>t[c],enumerable:!(o=n(t,c))||o.enumerable});return e})(s({},"__esModule",{value:!0}),r));var c=(e={async:!1,batchSize:1e3,batchDelay:16,errorHandler:e=>console.error("EventBus Error:",e),crossTab:!1,channelName:"event-bus-channel"})=>{const t=new Map;let r=[],s=0,n=0;const i=new Map,a=new Map;let o=null;e.crossTab&&"undefined"!=typeof BroadcastChannel?o=new BroadcastChannel(e.channelName):e.crossTab&&console.warn("BroadcastChannel is not supported in this browser. Cross-tab notifications are disabled.");const c=(e,t)=>{s++,n+=t,i.set(e,(i.get(e)||0)+1)},h=()=>{const t=r;r=[],t.forEach((({name:t,payload:r})=>{const s=performance.now();try{(a.get(t)||[]).forEach((e=>e(r)))}catch(s){e.errorHandler({...s,eventName:t,payload:r})}c(t,performance.now()-s)}))},d=(()=>{let t;return()=>{clearTimeout(t),t=setTimeout(h,e.batchDelay)}})(),l=e=>{const r=t.get(e);r?a.set(e,Array.from(r)):a.delete(e)};return o&&(o.onmessage=e=>{const{name:t,payload:r}=e.data;(a.get(t)||[]).forEach((e=>e(r)))}),{subscribe:(e,r)=>{t.has(e)||t.set(e,new Set);const s=t.get(e);return s.add(r),l(e),()=>{s.delete(r),0===s.size?(t.delete(e),a.delete(e)):l(e)}},emit:({name:t,payload:s})=>{if(e.async)return r.push({name:t,payload:s}),r.length>=e.batchSize?h():d(),void(o&&o.postMessage({name:t,payload:s}));const n=performance.now();try{(a.get(t)||[]).forEach((e=>e(s))),o&&o.postMessage({name:t,payload:s})}catch(r){e.errorHandler({...r,eventName:t,payload:s})}c(t,performance.now()-n)},getMetrics:()=>({totalEvents:s,activeSubscriptions:Array.from(t.values()).reduce(((e,t)=>e+t.size),0),eventCounts:i,averageEmitDuration:s>0?n/s:0}),clear:()=>{t.clear(),a.clear(),r=[],s=0,n=0,i.clear(),o&&(o.close(),o=null)}}}}},function(){return t||(0,e[i(e)[0]])((t={exports:{}}).exports,t),t.exports}),h=(e=>(e.Singleton="singleton",e.Transient="transient",e))(h||{}),d=class e extends Error{category;constructor(t,r,s){super(t,{cause:s}),this.name="ArtifactError",this.category=r,Object.setPrototypeOf(this,e.prototype)}},l=class extends d{constructor(e){super(`[ArtifactContainer] Artifact "${e}" not found.`,"system")}},u=class extends d{constructor(e){super(`[ArtifactContainer] Artifact with key:${e} has already been disposed`,"system")}},p=class extends d{constructor(e){super(`[ArtifactContainer] Operation timed out: ${e}`,"system")}},g=class extends d{constructor(e){super(`[ArtifactContainer] An artifact with key:${e} already exists!`,"system")}},f=class extends d{constructor(){super("[Serializer] The serializer has been marked as done!","system")}},y=class{artifacts=new Map;register({key:e,factory:t,lazy:r,...s}){if(this.artifacts.has(e))throw new g(String(e));const{scope:n,...i}=s,a={key:e,factory:t,scope:s.scope??"singleton",lazy:void 0===r||r,...i};return this.artifacts.set(e,a),()=>this.unregister(e)}get(e){if(!this.has(e))throw new l(String(e));return this.artifacts.get(e)}has(e){return this.artifacts.has(e)}async unregister(e){this.artifacts.has(e)&&this.artifacts.delete(e)}size(){return this.artifacts.size}keys(){return Array.from(this.artifacts.keys())}clear(){this.artifacts.clear()}};((e,t,c)=>{c=null!=e?r(a(e)):{},((e,t,r,a)=>{if(t&&"object"==typeof t||"function"==typeof t)for(let c of i(t))o.call(e,c)||c===r||s(e,c,{get:()=>t[c],enumerable:!(a=n(t,c))||a.enumerable})})(e&&e.__esModule?c:s(c,"default",{value:e,enumerable:!0}),e)})(c());var m=class{_locked=!1;_capacity;waiters=[];constructor(e){this._capacity=e?.capacity??1/0}async lock(e){if(!this._locked)return void(this._locked=!0);if(this.waiters.length>=this._capacity)throw new Error(`Mutex queue is full (capacity: ${this._capacity})`);let t;const r=new Promise((e=>t=e));if(this.waiters.push(t),null!=e)try{await Promise.race([r,new Promise(((r,s)=>setTimeout((()=>{const e=this.waiters.indexOf(t);-1!==e&&this.waiters.splice(e,1),s(new p("Mutex lock timed out"))}),e)))])}catch(e){throw e}else await r}tryLock(){return!this._locked&&(this._locked=!0,!0)}unlock(){if(!this._locked)throw new Error("Mutex is not locked");const e=this.waiters.shift();e?setTimeout(e,0):this._locked=!1}locked(){return this._locked}pending(){return this.waiters.length}},w=class{constructor(e=!1,t=!1){this.retry=e,this.throws=t}mutex=new m;promise=null;_value=null;_error;_done=!1;async do(e,t){return this._done?this.peek():this.promise?this._awaitWithTimeout(this.promise,t,"Once do() timed out"):(await this.mutex.lock(),this.promise?(this.mutex.unlock(),this._awaitWithTimeout(this.promise,t,"Once do() timed out")):(this.promise=(async()=>{try{const t=await e();this._value=t,this._done=!0}catch(e){if(this._error=e,this.retry||(this._done=!0),this.throws)throw e}finally{this.retry&&!this._done&&(this.promise=null)}return this.peek()})(),this.mutex.unlock(),this._awaitWithTimeout(this.promise,t,"Once do() timed out")))}running(){return null!==this.promise&&!this._done}peek(){return{value:this._value,error:this._error}}get(){if(!this._done)throw new Error("Once operation is not yet complete");if(this._error)throw this._error;return this._value}reset(){this._done=!1,this.promise=null,this._value=null,this._error=void 0}resolved(){return this.promise}done(){return this._done}_awaitWithTimeout(e,t,r="Operation timed out"){return null==t?e:Promise.race([e,new Promise(((e,s)=>setTimeout((()=>s(new p(r))),t)))])}},v=class{mutex;_done=!1;_lastValue=null;_lastError=void 0;constructor(e){this.mutex=new m({capacity:e?.capacity??1e3})}async do(e,t){if(this._done)return{value:null,error:new f};try{await this.mutex.lock(t)}catch(e){return{value:null,error:e}}let r,s=null;try{if(this._done)throw new f;s=await e(),this._lastValue=s,this._lastError=void 0}catch(e){r=e,this._lastError=e}finally{this.mutex.unlock()}return{value:s,error:r}}peek(){return{value:this._lastValue,error:this._lastError}}close(){this._done=!0}pending(){return this.mutex.pending()}running(){return this.mutex.locked()}},b=class{constructor(e,t,r,s,n){this.registry=e,this.cache=t,this.graph=r,this.store=s,this.observer=n}async build(e,t){const r=this.registry.get(e);if(!r)throw new d(`Template not found for artifact "${String(e)}"`,"system");const s=t?new Set(t):new Set;if(s.has(e))throw new d(`Cycle detected: Artifact "${String(e)}" depends on itself via path: ${Array.from(s).join(" -> ")}`,"system");s.add(e);let n=this.cache.get(e);n||(n=this.createCachedArtifact(r),this.cache.set(e,n));const i=await("transient"===r.scope?this.executeBuild(r,n,s):n.buildOnce.do((()=>this.executeBuild(r,n,s))));if("transient"===r.scope)return i;const a=this.cache.package(e,((t,r)=>this.invalidate(e,t,r)));return n.stream&&n.streamOnce.do(n.stream),a}async executeBuild(e,t,r){const s=e.key;t.buildCount++;const n=[],i=[];let a=!0;t.activeDebounceMs=e.debounce??0,n.push((()=>{a=!1}));const o=new Set,c=new Set,h=new Map,l={state:()=>this.store.get(!0),previous:t.instance,onCleanup:e=>n.push(e),onDispose:e=>i.push(e),use:async e=>e({resolve:async e=>{if(e===s)throw new d(`Artifact "${String(s)}" depends on itself.`,"system");const t=this.graph.wouldCreateCycle(s,e,r);if(t)throw new d(`Adding dependency "${String(e)}" to "${String(s)}" would create a cycle: ${t.join(" -> ")}`,"system");c.add(e);const n=await this.build(e,r),i=this.cache.get(e);return i&&h.set(e,i.version),n},select:e=>(function(e,t="."){const r=new Set,s=(e=[])=>new Proxy({},{get:(n,i)=>{if("symbol"==typeof i)return;const a=[...e,i],o=a.join(t);return r.add(o),s(a)}});try{e(s())}catch(e){throw new Error(`Selector failed during path analysis. This usually means the selector is too complex. Selectors must be simple property accessors only. Error: ${e instanceof Error?e.message:String(e)}`)}const n=Array.from(r);return n.filter((e=>!n.some((r=>r!==e&&r.startsWith(e+t)))))}(e).forEach((e=>o.add(e))),e(this.store.get(!0)))}),stream:async r=>{if("transient"===e.scope)throw new d(`[ArtifactManager] Illegal stream on transient artifact "${String(s)}"`,"system");const n=async(e,r=void 0)=>{await t.streamSerializer.do((async()=>{void 0!==t.stream&&(t.instance=e,t.error=r,t.version++,this.cache.invalidatePackage(s),await this.processStream(s))}))},i={value:()=>t.instance,signal:t.streamController.signal,set:(...e)=>this.store.set(...e),emit:e=>n(e)};t.stream=async()=>{try{await r(i)}catch(e){await n(void 0,e),this.invalidate(s,!1,!0)}}}};let u,p,g=0;const f=(e.retries??0)+1;for(;g<f;)try{const t=e.factory(l);if(e.timeout){const r=new Promise(((t,r)=>setTimeout((()=>r(new Error(`Timeout: ${e.timeout}ms`))),e.timeout)));u=await Promise.race([t,r])}else u=await t;break}catch(e){if(e instanceof d)throw e;g++,g>=f&&(p=e)}if(a){for(const[e,t]of h){const r=this.cache.get(e);r&&r.version!==t&&(p=new d(`Build stale on arrival: Dependency "${String(e)}" changed during build.`,"system"))}if("singleton"===e.scope&&this.updateDependencyGraph(s,c,o),"singleton"===e.scope&&(t.cleanupFunctions=n,t.disposeFunctions=i),p?t.error=p:t.instance=u,t.version++,this.cache.invalidatePackage(s),"transient"===e.scope)return{instance:u,cleanup:this.createCompositeCleanup(n),error:p,ready:!0,invalidate:async()=>console.warn(`[ArtifactManager] Cannot invalidate transient "${String(s)}"`)}}else{const e=this.createCompositeCleanup(n);e&&await e()}}async invalidate(e,t=!1,r=!1){const s=this.cache.get(e);if(s)return s.debounceTimer&&(clearTimeout(s.debounceTimer),s.debounceTimer=void 0),!t&&s.activeDebounceMs>0?new Promise((n=>{s.debounceTimer=setTimeout((()=>{s.debounceTimer=void 0,this.executeInvalidation(e,t,r).then(n).catch(n)}),s.activeDebounceMs)})):this.executeInvalidation(e,t,r)}async executeInvalidation(e,t,r=!1){const s=this.cache.get(e);s&&(await s.invalidationOnce.do((async()=>{s.version++,await this.cache.invalidateInstance(e);const n=this.graph.getDependents(e);await Promise.all(n.map((e=>this.invalidate(e).catch((t=>{console.error(`[ArtifactManager] Cascade failed for "${String(e)}":`,t)})))));const i=this.registry.get(e);!i||!t&&i.lazy&&!this.hasWatchers(e)||r||await this.build(e),this.observer.notify(e)})),s.invalidationOnce.reset())}async dispose(e){const t=this.cache.get(e);t&&(t.streamController.abort(),t.buildOnce.running()&&await t.buildOnce.resolved(),t.invalidationOnce.running()&&await t.invalidationOnce.resolved(),t.streamOnce.running()&&await t.streamOnce.resolved(),await this.cache.invalidateInstance(e),this.graph.removeNode(e),this.cache.delete(e))}async processStream(e){try{const t=this.graph.getDependents(e);await Promise.all(t.map((e=>this.invalidate(e).catch((t=>{console.error(`[ArtifactManager] Failed to invalidate dependent "${String(e)}":`,t)}))))),this.observer.notify(e)}catch(t){console.error(`[ArtifactManager] Stream propagation error "${e}":`,t)}}updateDependencyGraph(e,t,r){const s=this.cache.get(e);s&&(this.graph.hasNode(e)||this.graph.registerNode(e),this.graph.setDependencies(e,t),s.stateUnsubscribe&&s.stateUnsubscribe(),s.stateDependencies=r,r.size>0&&(s.stateUnsubscribe=this.store.watch(Array.from(r),(async()=>{await this.invalidate(e)}))))}createCachedArtifact(e){return{instance:void 0,version:0,streamController:new AbortController,error:void 0,cleanupFunctions:[],disposeFunctions:[],buildCount:0,stateDependencies:new Set,buildOnce:new w(!0,!0),streamOnce:new w(!0,!0),streamSerializer:new v,activeDebounceMs:e.debounce??0,invalidationOnce:new w(!0,!1)}}createCompositeCleanup(e){if(e.length)return async()=>{for(let t=e.length-1;t>=0;t--)try{await e[t]()}catch(e){console.error("[ArtifactManager] Cleanup error:",e)}}}hasWatchers(e){return this.observer.hasWatchers(e)??!1}},C=class{dependencies=new Map;dependents=new Map;metadata=new Map;registerNode(e,t){this.dependencies.has(e)||this.dependencies.set(e,new Set),this.dependents.has(e)||this.dependents.set(e,new Set),void 0!==t&&this.metadata.set(e,t)}removeNode(e){if(!this.hasNode(e))return;const t=this.dependencies.get(e);if(t)for(const r of t)this.dependents.get(r)?.delete(e);const r=this.dependents.get(e);if(r)for(const t of r)this.dependencies.get(t)?.delete(e);this.dependencies.delete(e),this.dependents.delete(e),this.metadata.delete(e)}hasNode(e){return this.dependencies.has(e)}addDependency(e,t){this.registerNode(e),this.registerNode(t),this.dependencies.get(e).add(t),this.dependents.get(t).add(e)}removeDependency(e,t){this.dependencies.get(e)?.delete(t),this.dependents.get(t)?.delete(e)}getDependencies(e){const t=this.dependencies.get(e);return t?new Set(t):new Set}getDependents(e){const t=this.dependents.get(e);return t?new Set(t):new Set}getMetadata(e){return this.metadata.get(e)}setMetadata(e,t){this.registerNode(e),this.metadata.set(e,t)}setDependencies(e,t){this.registerNode(e);const r=this.dependencies.get(e),s=new Set(t);for(const t of r)s.has(t)||this.removeDependency(e,t);for(const t of s)r.has(t)||this.addDependency(e,t)}wouldCreateCycle(e,t){if(e===t)return[e,t];const r=[t],s=new Set([t]),n=new Map;for(;r.length>0;){const i=r.shift();if(i===e){const r=[];let s=e;for(;void 0!==s&&(r.push(s),s!==t);)s=n.get(s);return r.reverse(),[e,...r]}const a=this.dependencies.get(i);if(a)for(const e of a)s.has(e)||(s.add(e),n.set(e,i),r.push(e))}return null}topologicalSort(){const e=new Map,t=Array.from(this.dependencies.keys());for(const r of t)e.set(r,this.dependencies.get(r)?.size??0);const r=[];for(const[t,s]of e)0===s&&r.push(t);const s=[];for(;r.length>0;){const t=r.shift();s.push(t);const n=this.dependents.get(t);if(n)for(const t of n){const s=(e.get(t)||0)-1;e.set(t,s),0===s&&r.push(t)}}if(s.length!==t.length)throw new Error("Cycle detected in graph; topological sort impossible.");return s}getTransitiveDependencies(e,t=!1){return this.bfs(e,"dependencies",t)}getTransitiveDependents(e,t=!1){return this.bfs(e,"dependents",t)}bfs(e,t,r){const s=new Set,n=new Set,i=[e];n.add(e),r&&s.add(e);const a="dependencies"===t?this.dependencies:this.dependents;for(;i.length>0;){const e=i.shift(),t=a.get(e);if(t)for(const e of t)n.has(e)||(n.add(e),s.add(e),i.push(e))}return s}getAllNodes(){return Array.from(this.dependencies.keys())}size(){return this.dependencies.size}clear(){this.dependencies.clear(),this.dependents.clear(),this.metadata.clear()}toDebugString(){return Array.from(this.dependencies.entries()).map((([e,t])=>{const r=Array.from(t).join(", ");return`${String(e)} → [${r||"∅"}]`})).join("\n")}},A=class{graph;constructor(){this.graph=new C}registerNode(e){this.graph.registerNode(e)}removeNode(e){this.graph.removeNode(e)}addDependency(e,t){this.graph.addDependency(e,t)}removeDependency(e,t){this.graph.removeDependency(e,t)}getDependents(e){const t=this.graph.getDependents(e);return Array.from(t)}getDependencies(e){const t=this.graph.getDependencies(e);return Array.from(t)}getTransitiveDependents(e){const t=this.graph.getTransitiveDependents(e,!1);return new Set(Array.from(t))}setDependencies(e,t){const r=Array.from(t).map((e=>e));this.graph.setDependencies(e,r)}wouldCreateCycle(e,t,r){if(r?.has(t)){const e=Array.from(r),s=e.indexOf(t),n=e.slice(s);return n.push(t),n}const s=this.graph.wouldCreateCycle(e,t);return s||null}hasNode(e){return this.graph.hasNode(e)}getAllNodes(){return this.graph.getAllNodes()}clear(){this.graph.clear()}size(){return this.graph.size()}toDebugString(){return this.graph.toDebugString()}},_=class{cache=new Map;emptyInstance={instance:void 0,error:void 0,ready:!1,cleanup:void 0,invalidate:async(e,t)=>{}};get(e){return this.cache.get(e)}set(e,t){this.cache.set(e,t)}delete(e){this.cache.delete(e)}has(e){return this.cache.has(e)}clear(){this.cache.clear()}size(){return this.cache.size}keys(){return Array.from(this.cache.keys())}package(e,t){const r=this.get(e);if(!r)return this.emptyInstance;if(r.packagedArtifact)return this.updatePackagedArtifact(r,r.packagedArtifact,t),r.packagedArtifact;const s={instance:r.instance,error:r.error,ready:r.buildOnce.done()&&!r.buildOnce.running(),cleanup:this.createCompositeCleanup(r.cleanupFunctions),invalidate:t};return r.packagedArtifact=s,s}async invalidatePackage(e){const t=this.get(e);t&&(t.packagedArtifact=void 0)}async invalidateInstance(e){const t=this.get(e);if(t){t.stateUnsubscribe&&(t.stateUnsubscribe(),t.stateUnsubscribe=void 0),t.debounceTimer&&(clearTimeout(t.debounceTimer),t.debounceTimer=void 0),t.streamController.abort(),await t.streamOnce.resolved(),t.streamOnce.reset(),t.streamSerializer.close();for(let e=t.cleanupFunctions.length-1;e>=0;e--)try{await t.cleanupFunctions[e]()}catch(e){console.error("[ArtifactManager] Cleanup error:",e)}for(let e=t.disposeFunctions.length-1;e>=0;e--)try{await t.disposeFunctions[e]()}catch(e){console.error("[ArtifactManager] Dispose error:",e)}t.instance=void 0,t.error=void 0,t.cleanupFunctions=[],t.disposeFunctions=[],t.buildOnce.reset(),t.stream=void 0,t.streamSerializer=new v,t.streamController=new AbortController}}updatePackagedArtifact(e,t,r){t.instance=e.instance,t.error=e.error,t.ready=e.buildOnce.done()&&!e.buildOnce.running(),t.cleanup=this.createCompositeCleanup(e.cleanupFunctions),t.invalidate=r}createCompositeCleanup(e){if(e.length)return async()=>{for(let t=e.length-1;t>=0;t--)try{await e[t]()}catch(e){console.error("[ArtifactCache] Cleanup error:",e)}}}},k=class{constructor(e,t,r){this.registry=e,this.cache=t,this.container=r}listeners=new Map;watcherCache=new Map;watch(e){const t=String(e),r=this.registry.get(e);if(!r)throw new Error(`Artifact "${t}" not registered`);let s=t;if("transient"===r.scope&&(s=`${t}__watched`,this.registry.has(s)||this.registry.register({key:s,factory:r.factory,scope:"singleton",lazy:r.lazy,timeout:r.timeout,retries:r.retries,debounce:r.debounce})),this.watcherCache.has(s)){const e=this.watcherCache.get(s);return e.count++,e}let n=!1;const i={id:t,count:1,get:()=>{if(!this.cache.get(s))return this.cache.package(s,(e=>this.container.invalidate(s,e)));const e=this.cache.package(s,(e=>this.container.invalidate(s,e)));return n?{...e,ready:!1,instance:void 0,error:new u(t),cleanup:()=>{},invalidate:()=>Promise.resolve()}:e},subscribe:e=>{this.listeners.has(s)||this.listeners.set(s,new Set);const t=()=>e(i.get());return this.listeners.get(s).add(t),this.container.resolve(s).catch((e=>{console.error(`[ArtifactObserver] Background resolution failed for "${s}":`,e)})).then(t),()=>this.listeners.get(s)?.delete(t)},dispose:async()=>{i.count--,i.count<=0&&(this.watcherCache.delete(s),"transient"===r.scope&&(await this.registry.unregister(s),this.cache.delete(s)),n=!0,this.notify(s),this.listeners.delete(s))}};return this.watcherCache.set(s,i),i}notify(e){const t=this.listeners.get(e);t&&t.forEach((t=>{try{t()}catch(t){console.error(`[ArtifactObserver] Listener error for "${e}":`,t)}}))}hasWatchers(e){return this.watcherCache.has(e)||this.watcherCache.has(`${e}__watched`)}getWatcherCount(e){const t=this.watcherCache.get(e)||this.watcherCache.get(`${e}__watched`);return t?.count??0}clear(){this.watcherCache.clear(),this.listeners.clear()}},S=class{registry;cache;graph;manager;observer;store;constructor(e){this.store={watch:(...t)=>e.watch(...t),get:()=>e.get(!0),set:(...t)=>e.set(...t)},this.registry=new y,this.cache=new _,this.graph=new A,this.observer=new k(this.registry,this.cache,this),this.manager=new b(this.registry,this.cache,this.graph,this.store,this.observer)}debugInfo(){const e=[];return this.registry.keys().forEach((t=>{const r=this.registry.get(t),s=this.cache.get(t);if(!r)return;const n=s?s.buildOnce.running()?"pending":s.error?"error":void 0!==s.instance?"active":"idle":"idle";e.push({id:t,scope:r.scope??"singleton",status:n,dependencies:this.graph.getDependencies(t).map((e=>String(e))),dependents:this.graph.getDependents(t).map((e=>String(e))),stateDependencies:s?Array.from(s.stateDependencies):[],renderCount:s?.buildCount??0})})),e}register(e){const{key:t}=e,r=t;this.registry.has(t)&&(console.warn(`[ArtifactContainer] Overwriting "${r}".`),this.manager.dispose(t).catch((e=>{console.error(`[ArtifactContainer] Failed to dispose existing artifact "${r}":`,e)}))),this.registry.register(e),this.graph.registerNode(t);const s=e.scope??"singleton";return(e.lazy??!0)||"singleton"!==s||this.resolve(t).catch((e=>{console.error(`[ArtifactContainer] Eager load failed for "${r}":`,e)})),()=>this.unregister(t)}async unregister(e){await this.manager.dispose(e),await this.registry.unregister(e)}async resolve(e){if(!this.registry.has(e))throw new l(e);return this.manager.build(e)}watch(e){if(!this.registry.has(e))throw new l(e);return this.observer.watch(e)}peek(e){const t=this.cache.get(e);if(void 0!==t?.instance)return t?.instance}async invalidate(e,t=!1){return this.manager.invalidate(e,t)}notifyObservers(e){this.observer.notify(e)}hasWatchers(e){return this.observer.hasWatchers(e)}dispose(){this.registry.keys().forEach((e=>{this.manager.dispose(e).catch((t=>{console.error(`[ArtifactContainer] Failed to dispose artifact "${String(e)}":`,t)}))})),this.registry.clear(),this.cache.clear(),this.graph.clear(),this.observer.clear()}};export{S as ArtifactContainer,h as ArtifactScopes};
+var e,t,r=Object.create,s=Object.defineProperty,n=Object.getOwnPropertyDescriptor,i=Object.getOwnPropertyNames,a=Object.getPrototypeOf,o=Object.prototype.hasOwnProperty,c=(e={"node_modules/@asaidimu/events/index.js"(e,t){var r,s=Object.defineProperty,n=Object.getOwnPropertyDescriptor,i=Object.getOwnPropertyNames,a=Object.prototype.hasOwnProperty,o={};((e,t)=>{for(var r in t)s(e,r,{get:t[r],enumerable:!0})})(o,{createEventBus:()=>c}),t.exports=(r=o,((e,t,r,o)=>{if(t&&"object"==typeof t||"function"==typeof t)for(let c of i(t))a.call(e,c)||c===r||s(e,c,{get:()=>t[c],enumerable:!(o=n(t,c))||o.enumerable});return e})(s({},"__esModule",{value:!0}),r));var c=(e={async:!1,batchSize:1e3,batchDelay:16,errorHandler:e=>console.error("EventBus Error:",e),crossTab:!1,channelName:"event-bus-channel"})=>{const t=new Map;let r=[],s=0,n=0;const i=new Map,a=new Map;let o=null;e.crossTab&&"undefined"!=typeof BroadcastChannel?o=new BroadcastChannel(e.channelName):e.crossTab&&console.warn("BroadcastChannel is not supported in this browser. Cross-tab notifications are disabled.");const c=(e,t)=>{s++,n+=t,i.set(e,(i.get(e)||0)+1)},h=()=>{const t=r;r=[],t.forEach((({name:t,payload:r})=>{const s=performance.now();try{(a.get(t)||[]).forEach((e=>e(r)))}catch(s){e.errorHandler({...s,eventName:t,payload:r})}c(t,performance.now()-s)}))},d=(()=>{let t;return()=>{clearTimeout(t),t=setTimeout(h,e.batchDelay)}})(),l=e=>{const r=t.get(e);r?a.set(e,Array.from(r)):a.delete(e)};return o&&(o.onmessage=e=>{const{name:t,payload:r}=e.data;(a.get(t)||[]).forEach((e=>e(r)))}),{subscribe:(e,r)=>{t.has(e)||t.set(e,new Set);const s=t.get(e);return s.add(r),l(e),()=>{s.delete(r),0===s.size?(t.delete(e),a.delete(e)):l(e)}},emit:({name:t,payload:s})=>{if(e.async)return r.push({name:t,payload:s}),r.length>=e.batchSize?h():d(),void(o&&o.postMessage({name:t,payload:s}));const n=performance.now();try{(a.get(t)||[]).forEach((e=>e(s))),o&&o.postMessage({name:t,payload:s})}catch(r){e.errorHandler({...r,eventName:t,payload:s})}c(t,performance.now()-n)},getMetrics:()=>({totalEvents:s,activeSubscriptions:Array.from(t.values()).reduce(((e,t)=>e+t.size),0),eventCounts:i,averageEmitDuration:s>0?n/s:0}),clear:()=>{t.clear(),a.clear(),r=[],s=0,n=0,i.clear(),o&&(o.close(),o=null)}}}}},function(){return t||(0,e[i(e)[0]])((t={exports:{}}).exports,t),t.exports}),h=(e=>(e.Singleton="singleton",e.Transient="transient",e))(h||{}),d=class e extends Error{category;constructor(t,r,s){super(t,{cause:s}),this.name="ArtifactError",this.category=r,Object.setPrototypeOf(this,e.prototype)}},l=class extends d{constructor(e){super(`[ArtifactContainer] Artifact "${e}" not found.`,"system")}},u=class extends d{constructor(e){super(`[ArtifactContainer] Operation timed out: ${e}`,"system")}},p=class extends d{constructor(e){super(`[ArtifactContainer] An artifact with key:${e} already exists!`,"system")}},g=class extends d{constructor(){super("[Serializer] The serializer has been marked as done!","system")}},f=class{artifacts=new Map;register({key:e,factory:t,lazy:r,...s}){if(this.artifacts.has(e))throw new p(String(e));const{scope:n,...i}=s,a={key:e,factory:t,scope:s.scope??"singleton",lazy:void 0===r||r,...i};return this.artifacts.set(e,a),()=>this.unregister(e)}get(e){if(!this.has(e))throw new l(String(e));return this.artifacts.get(e)}has(e){return this.artifacts.has(e)}async unregister(e){this.artifacts.has(e)&&this.artifacts.delete(e)}size(){return this.artifacts.size}keys(){return Array.from(this.artifacts.keys())}clear(){this.artifacts.clear()}};((e,t,c)=>{c=null!=e?r(a(e)):{},((e,t,r,a)=>{if(t&&"object"==typeof t||"function"==typeof t)for(let c of i(t))o.call(e,c)||c===r||s(e,c,{get:()=>t[c],enumerable:!(a=n(t,c))||a.enumerable})})(e&&e.__esModule?c:s(c,"default",{value:e,enumerable:!0}),e)})(c());var y=class{_locked=!1;_capacity;waiters=[];constructor(e){this._capacity=e?.capacity??1/0}async lock(e){if(!this._locked)return void(this._locked=!0);if(this.waiters.length>=this._capacity)throw new Error(`Mutex queue is full (capacity: ${this._capacity})`);let t;const r=new Promise((e=>t=e));if(this.waiters.push(t),null!=e)try{await Promise.race([r,new Promise(((r,s)=>setTimeout((()=>{const e=this.waiters.indexOf(t);-1!==e&&this.waiters.splice(e,1),s(new u("Mutex lock timed out"))}),e)))])}catch(e){throw e}else await r}tryLock(){return!this._locked&&(this._locked=!0,!0)}unlock(){if(!this._locked)throw new Error("Mutex is not locked");const e=this.waiters.shift();e?setTimeout(e,0):this._locked=!1}locked(){return this._locked}pending(){return this.waiters.length}},m=class{constructor(e=!1,t=!1){this.retry=e,this.throws=t}mutex=new y;promise=null;_value=null;_error;_done=!1;async do(e,t){return this._done?this.peek():this.promise?this._awaitWithTimeout(this.promise,t,"Once do() timed out"):(await this.mutex.lock(),this.promise?(this.mutex.unlock(),this._awaitWithTimeout(this.promise,t,"Once do() timed out")):(this.promise=(async()=>{try{const t=await e();this._value=t,this._done=!0}catch(e){if(this._error=e,this.retry||(this._done=!0),this.throws)throw e}finally{this.retry&&!this._done&&(this.promise=null)}return this.peek()})(),this.mutex.unlock(),this._awaitWithTimeout(this.promise,t,"Once do() timed out")))}running(){return null!==this.promise&&!this._done}peek(){return{value:this._value,error:this._error}}get(){if(!this._done)throw new Error("Once operation is not yet complete");if(this._error)throw this._error;return this._value}reset(){this._done=!1,this.promise=null,this._value=null,this._error=void 0}resolved(){return this.promise}done(){return this._done}_awaitWithTimeout(e,t,r="Operation timed out"){return null==t?e:Promise.race([e,new Promise(((e,s)=>setTimeout((()=>s(new u(r))),t)))])}},w=class{mutex;_done=!1;_lastValue=null;_lastError=void 0;constructor(e){this.mutex=new y({capacity:e?.capacity??1e3})}async do(e,t){if(this._done)return{value:null,error:new g};try{await this.mutex.lock(t)}catch(e){return{value:null,error:e}}let r,s=null;try{if(this._done)throw new g;s=await e(),this._lastValue=s,this._lastError=void 0}catch(e){r=e,this._lastError=e}finally{this.mutex.unlock()}return{value:s,error:r}}peek(){return{value:this._lastValue,error:this._lastError}}close(){this._done=!0}pending(){return this.mutex.pending()}running(){return this.mutex.locked()}},v=class{constructor(e,t,r,s,n){this.registry=e,this.cache=t,this.graph=r,this.store=s,this.observer=n}async build(e,t){const r=this.registry.get(e);if(!r)throw new d(`Template not found for artifact "${String(e)}"`,"system");const s=t?new Set(t):new Set;if(s.has(e))throw new d(`Cycle detected: Artifact "${String(e)}" depends on itself via path: ${Array.from(s).join(" -> ")}`,"system");s.add(e);let n=this.cache.get(e);n||(n=this.createCachedArtifact(r),this.cache.set(e,n));const i=await("transient"===r.scope?this.executeBuild(r,n,s):n.buildOnce.do((()=>this.executeBuild(r,n,s))));if("transient"===r.scope)return i;const a=this.cache.package(e,((t,r)=>this.invalidate(e,t,r)));return n.stream&&n.streamOnce.do(n.stream),a}async executeBuild(e,t,r){const s=e.key;t.buildCount++;const n=[],i=[];let a=!0;t.activeDebounceMs=e.debounce??0,n.push((()=>{a=!1}));const o=new Set,c=new Set,h=new Map,l=this.graph,u=this.cache,p=this.build.bind(this);async function g(e){if(e===s)throw new d(`Artifact "${String(s)}" depends on itself.`,"system");const t=l.wouldCreateCycle(s,e,r);if(t)throw new d(`Adding dependency "${String(e)}" to "${String(s)}" would create a cycle: ${t.join(" -> ")}`,"system");c.add(e);const n=await p(e,r),i=u.get(e);return i&&h.set(e,i.version),n}const f={state:()=>this.store.get(!0),previous:t.instance,onCleanup:e=>n.push(e),onDispose:e=>i.push(e),use:async e=>e({resolve:g,require:async e=>{const t=await g(e);if(t.error)throw t.error;return t.instance},select:e=>(function(e,t="."){const r=new Set,s=(e=[])=>new Proxy({},{get:(n,i)=>{if("symbol"==typeof i)return;const a=[...e,i],o=a.join(t);return r.add(o),s(a)}});try{e(s())}catch(e){throw new Error(`Selector failed during path analysis. This usually means the selector is too complex. Selectors must be simple property accessors only. Error: ${e instanceof Error?e.message:String(e)}`)}const n=Array.from(r);return n.filter((e=>!n.some((r=>r!==e&&r.startsWith(e+t)))))}(e).forEach((e=>o.add(e))),e(this.store.get(!0)))}),stream:async r=>{if("transient"===e.scope)throw new d(`[ArtifactManager] Illegal stream on transient artifact "${String(s)}"`,"system");const n=async(e,r=void 0)=>{await t.streamSerializer.do((async()=>{void 0!==t.stream&&(t.instance=e,t.error=r,t.version++,this.cache.invalidatePackage(s),await this.processStream(s))}))},i={value:()=>t.instance,signal:t.streamController.signal,set:(...e)=>this.store.set(...e),emit:e=>n(e)};t.stream=async()=>{try{await r(i)}catch(e){await n(void 0,e),this.invalidate(s,!1,!0)}}}};let y,m,w=0;const v=(e.retries??0)+1;for(;w<v;)try{const t=e.factory(f);if(e.timeout){const r=new Promise(((t,r)=>setTimeout((()=>r(new Error(`Timeout: ${e.timeout}ms`))),e.timeout)));y=await Promise.race([t,r])}else y=await t;break}catch(e){if(e instanceof d)throw e;w++,w>=v&&(m=e)}if(a){for(const[e,t]of h){const r=this.cache.get(e);r&&r.version!==t&&(m=new d(`Build stale on arrival: Dependency "${String(e)}" changed during build.`,"system"))}if("singleton"===e.scope&&this.updateDependencyGraph(s,c,o),"singleton"===e.scope&&(t.cleanupFunctions=n,t.disposeFunctions=i),m?t.error=m:t.instance=y,t.version++,this.cache.invalidatePackage(s),"transient"===e.scope)return{instance:y,cleanup:this.createCompositeCleanup(n),error:m,ready:!0,invalidate:async()=>console.warn(`[ArtifactManager] Cannot invalidate transient "${String(s)}"`)}}else{const e=this.createCompositeCleanup(n);e&&await e()}}async invalidate(e,t=!1,r=!1){const s=this.cache.get(e);if(s)return s.debounceTimer&&(clearTimeout(s.debounceTimer),s.debounceTimer=void 0),!t&&s.activeDebounceMs>0?new Promise((n=>{s.debounceTimer=setTimeout((()=>{s.debounceTimer=void 0,this.executeInvalidation(e,t,r).then(n).catch(n)}),s.activeDebounceMs)})):this.executeInvalidation(e,t,r)}async executeInvalidation(e,t,r=!1){const s=this.cache.get(e);s&&(await s.invalidationOnce.do((async()=>{s.version++,await this.cache.invalidateInstance(e);const n=this.graph.getDependents(e);await Promise.all(n.map((e=>this.invalidate(e).catch((t=>{console.error(`[ArtifactManager] Cascade failed for "${String(e)}":`,t)})))));const i=this.registry.get(e);!i||!t&&i.lazy&&!this.hasWatchers(e)||r||await this.build(e),this.observer.notify(e)})),s.invalidationOnce.reset())}async dispose(e){const t=this.cache.get(e);t&&(t.streamController.abort(),t.buildOnce.running()&&await t.buildOnce.resolved(),t.invalidationOnce.running()&&await t.invalidationOnce.resolved(),t.streamOnce.running()&&await t.streamOnce.resolved(),await this.cache.invalidateInstance(e),this.graph.removeNode(e),this.cache.delete(e))}async processStream(e){try{const t=this.graph.getDependents(e);await Promise.all(t.map((e=>this.invalidate(e).catch((t=>{console.error(`[ArtifactManager] Failed to invalidate dependent "${String(e)}":`,t)}))))),this.observer.notify(e)}catch(t){console.error(`[ArtifactManager] Stream propagation error "${e}":`,t)}}updateDependencyGraph(e,t,r){const s=this.cache.get(e);s&&(this.graph.hasNode(e)||this.graph.registerNode(e),this.graph.setDependencies(e,t),s.stateUnsubscribe&&s.stateUnsubscribe(),s.stateDependencies=r,r.size>0&&(s.stateUnsubscribe=this.store.watch(Array.from(r),(async()=>{await this.invalidate(e)}))))}createCachedArtifact(e){return{instance:void 0,version:0,streamController:new AbortController,error:void 0,cleanupFunctions:[],disposeFunctions:[],buildCount:0,stateDependencies:new Set,buildOnce:new m(!0,!0),streamOnce:new m(!0,!0),streamSerializer:new w,activeDebounceMs:e.debounce??0,invalidationOnce:new m(!0,!1)}}createCompositeCleanup(e){if(e.length)return async()=>{for(let t=e.length-1;t>=0;t--)try{await e[t]()}catch(e){console.error("[ArtifactManager] Cleanup error:",e)}}}hasWatchers(e){return this.observer.hasWatchers(e)??!1}},b=class{dependencies=new Map;dependents=new Map;metadata=new Map;registerNode(e,t){this.dependencies.has(e)||this.dependencies.set(e,new Set),this.dependents.has(e)||this.dependents.set(e,new Set),void 0!==t&&this.metadata.set(e,t)}removeNode(e){if(!this.hasNode(e))return;const t=this.dependencies.get(e);if(t)for(const r of t)this.dependents.get(r)?.delete(e);const r=this.dependents.get(e);if(r)for(const t of r)this.dependencies.get(t)?.delete(e);this.dependencies.delete(e),this.dependents.delete(e),this.metadata.delete(e)}hasNode(e){return this.dependencies.has(e)}addDependency(e,t){this.registerNode(e),this.registerNode(t),this.dependencies.get(e).add(t),this.dependents.get(t).add(e)}removeDependency(e,t){this.dependencies.get(e)?.delete(t),this.dependents.get(t)?.delete(e)}getDependencies(e){const t=this.dependencies.get(e);return t?new Set(t):new Set}getDependents(e){const t=this.dependents.get(e);return t?new Set(t):new Set}getMetadata(e){return this.metadata.get(e)}setMetadata(e,t){this.registerNode(e),this.metadata.set(e,t)}setDependencies(e,t){this.registerNode(e);const r=this.dependencies.get(e),s=new Set(t);for(const t of r)s.has(t)||this.removeDependency(e,t);for(const t of s)r.has(t)||this.addDependency(e,t)}wouldCreateCycle(e,t){if(e===t)return[e,t];const r=[t],s=new Set([t]),n=new Map;for(;r.length>0;){const i=r.shift();if(i===e){const r=[];let s=e;for(;void 0!==s&&(r.push(s),s!==t);)s=n.get(s);return r.reverse(),[e,...r]}const a=this.dependencies.get(i);if(a)for(const e of a)s.has(e)||(s.add(e),n.set(e,i),r.push(e))}return null}topologicalSort(){const e=new Map,t=Array.from(this.dependencies.keys());for(const r of t)e.set(r,this.dependencies.get(r)?.size??0);const r=[];for(const[t,s]of e)0===s&&r.push(t);const s=[];for(;r.length>0;){const t=r.shift();s.push(t);const n=this.dependents.get(t);if(n)for(const t of n){const s=(e.get(t)||0)-1;e.set(t,s),0===s&&r.push(t)}}if(s.length!==t.length)throw new Error("Cycle detected in graph; topological sort impossible.");return s}getTransitiveDependencies(e,t=!1){return this.bfs(e,"dependencies",t)}getTransitiveDependents(e,t=!1){return this.bfs(e,"dependents",t)}bfs(e,t,r){const s=new Set,n=new Set,i=[e];n.add(e),r&&s.add(e);const a="dependencies"===t?this.dependencies:this.dependents;for(;i.length>0;){const e=i.shift(),t=a.get(e);if(t)for(const e of t)n.has(e)||(n.add(e),s.add(e),i.push(e))}return s}getAllNodes(){return Array.from(this.dependencies.keys())}size(){return this.dependencies.size}clear(){this.dependencies.clear(),this.dependents.clear(),this.metadata.clear()}toDebugString(){return Array.from(this.dependencies.entries()).map((([e,t])=>{const r=Array.from(t).join(", ");return`${String(e)} → [${r||"∅"}]`})).join("\n")}},C=class{graph;constructor(){this.graph=new b}registerNode(e){this.graph.registerNode(e)}removeNode(e){this.graph.removeNode(e)}addDependency(e,t){this.graph.addDependency(e,t)}removeDependency(e,t){this.graph.removeDependency(e,t)}getDependents(e){const t=this.graph.getDependents(e);return Array.from(t)}getDependencies(e){const t=this.graph.getDependencies(e);return Array.from(t)}getTransitiveDependents(e){const t=this.graph.getTransitiveDependents(e,!1);return new Set(Array.from(t))}setDependencies(e,t){const r=Array.from(t).map((e=>e));this.graph.setDependencies(e,r)}wouldCreateCycle(e,t,r){if(r?.has(t)){const e=Array.from(r),s=e.indexOf(t),n=e.slice(s);return n.push(t),n}const s=this.graph.wouldCreateCycle(e,t);return s||null}hasNode(e){return this.graph.hasNode(e)}getAllNodes(){return this.graph.getAllNodes()}clear(){this.graph.clear()}size(){return this.graph.size()}toDebugString(){return this.graph.toDebugString()}},_=class{cache=new Map;emptyInstance={instance:void 0,error:void 0,ready:!1,cleanup:void 0,invalidate:async(e,t)=>{}};get(e){return this.cache.get(e)}set(e,t){this.cache.set(e,t)}delete(e){this.cache.delete(e)}has(e){return this.cache.has(e)}clear(){this.cache.clear()}size(){return this.cache.size}keys(){return Array.from(this.cache.keys())}package(e,t){const r=this.get(e);if(!r)return this.emptyInstance;if(r.packagedArtifact)return this.updatePackagedArtifact(r,r.packagedArtifact,t),r.packagedArtifact;const s={instance:r.instance,error:r.error,ready:r.buildOnce.done()&&!r.buildOnce.running(),cleanup:this.createCompositeCleanup(r.cleanupFunctions),invalidate:t};return r.packagedArtifact=s,s}async invalidatePackage(e){const t=this.get(e);t&&(t.packagedArtifact=void 0)}async invalidateInstance(e){const t=this.get(e);if(t){t.stateUnsubscribe&&(t.stateUnsubscribe(),t.stateUnsubscribe=void 0),t.debounceTimer&&(clearTimeout(t.debounceTimer),t.debounceTimer=void 0),t.streamController.abort(),await t.streamOnce.resolved(),t.streamOnce.reset(),t.streamSerializer.close();for(let e=t.cleanupFunctions.length-1;e>=0;e--)try{await t.cleanupFunctions[e]()}catch(e){console.error("[ArtifactManager] Cleanup error:",e)}for(let e=t.disposeFunctions.length-1;e>=0;e--)try{await t.disposeFunctions[e]()}catch(e){console.error("[ArtifactManager] Dispose error:",e)}t.instance=void 0,t.error=void 0,t.cleanupFunctions=[],t.disposeFunctions=[],t.buildOnce.reset(),t.stream=void 0,t.streamSerializer=new w,t.streamController=new AbortController}}updatePackagedArtifact(e,t,r){t.instance=e.instance,t.error=e.error,t.ready=e.buildOnce.done()&&!e.buildOnce.running(),t.cleanup=this.createCompositeCleanup(e.cleanupFunctions),t.invalidate=r}createCompositeCleanup(e){if(e.length)return async()=>{for(let t=e.length-1;t>=0;t--)try{await e[t]()}catch(e){console.error("[ArtifactCache] Cleanup error:",e)}}}},A=class{constructor(e,t,r){this.registry=e,this.cache=t,this.container=r}listeners=new Map;watcherCache=new Map;watch(e){const t=String(e),r=this.registry.get(e);if(!r)throw new Error(`Artifact "${t}" not registered`);const s="transient"===r.scope?`${t}__watched`:t;if(this.watcherCache.has(s))return this.watcherCache.get(s).watcher;const n={count:0,init:new m(!1,!0),watcher:null},i=()=>n.init.do((async()=>{"transient"!==r.scope||this.registry.has(s)||this.registry.register({key:s,factory:r.factory,scope:"singleton",lazy:r.lazy,timeout:r.timeout,retries:r.retries,debounce:r.debounce})}));return n.watcher={id:t,get count(){return n.count},get:()=>{this.cache.get(s);return this.cache.package(s,(e=>this.container.invalidate(s,e)))},resolve:async()=>(await i(),this.container.resolve(s)),subscribe:e=>{0===n.count&&i(),n.count++,this.listeners.has(s)||this.listeners.set(s,new Set);const t=()=>e(n.watcher.get());return this.listeners.get(s).add(t),this.container.resolve(s).catch((e=>{console.error(`[ArtifactObserver] Background resolution failed for "${s}":`,e)})).then(t),()=>{this.listeners.get(s)?.delete(t),n.count--,0===n.count&&(this.listeners.delete(s),"transient"===r.scope&&(this.registry.unregister(s).catch((e=>{console.error(`[ArtifactObserver] Cleanup failed for "${s}":`,e)})),this.cache.delete(s)),n.init.reset())}}},this.watcherCache.set(s,n),n.watcher}notify(e){const t=this.listeners.get(e);t&&t.forEach((t=>{try{t()}catch(t){console.error(`[ArtifactObserver] Listener error for "${e}":`,t)}}))}hasWatchers(e){return this.watcherCache.has(e)||this.watcherCache.has(`${e}__watched`)}getWatcherCount(e){const t=this.watcherCache.get(e)||this.watcherCache.get(`${e}__watched`);return t?.count??0}clear(){this.watcherCache.clear(),this.listeners.clear()}},k=class{registry;cache;graph;manager;observer;store;constructor(e){this.store={watch:(...t)=>e.watch(...t),get:()=>e.get(!0),set:(...t)=>e.set(...t)},this.registry=new f,this.cache=new _,this.graph=new C,this.observer=new A(this.registry,this.cache,this),this.manager=new v(this.registry,this.cache,this.graph,this.store,this.observer)}debugInfo(){const e=[];return this.registry.keys().forEach((t=>{const r=this.registry.get(t),s=this.cache.get(t);if(!r)return;const n=s?s.buildOnce.running()?"pending":s.error?"error":void 0!==s.instance?"active":"idle":"idle";e.push({id:t,scope:r.scope??"singleton",status:n,dependencies:this.graph.getDependencies(t).map((e=>String(e))),dependents:this.graph.getDependents(t).map((e=>String(e))),stateDependencies:s?Array.from(s.stateDependencies):[],renderCount:s?.buildCount??0})})),e}register(e){const{key:t}=e,r=t;this.registry.has(t)&&(console.warn(`[ArtifactContainer] Overwriting "${r}".`),this.manager.dispose(t).catch((e=>{console.error(`[ArtifactContainer] Failed to dispose existing artifact "${r}":`,e)}))),this.registry.register(e),this.graph.registerNode(t);const s=e.scope??"singleton";return(e.lazy??!0)||"singleton"!==s||this.resolve(t).catch((e=>{console.error(`[ArtifactContainer] Eager load failed for "${r}":`,e)})),()=>this.unregister(t)}async unregister(e){await this.manager.dispose(e),await this.registry.unregister(e)}async resolve(e){if(!this.registry.has(e))throw new l(e);return this.manager.build(e)}async require(e){const t=await this.resolve(e);if(t.error)throw t.error;return t.instance}watch(e){if(!this.registry.has(e))throw new l(e);return this.observer.watch(e)}peek(e){const t=this.cache.get(e);if(void 0!==t?.instance)return t?.instance}async invalidate(e,t=!1){return this.manager.invalidate(e,t)}notifyObservers(e){this.observer.notify(e)}hasWatchers(e){return this.observer.hasWatchers(e)}dispose(){this.registry.keys().forEach((e=>{this.manager.dispose(e).catch((t=>{console.error(`[ArtifactContainer] Failed to dispose artifact "${String(e)}":`,t)}))})),this.registry.clear(),this.cache.clear(),this.graph.clear(),this.observer.clear()}};export{k as ArtifactContainer,h as ArtifactScopes};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asaidimu/utils-artifacts",
-  "version": "3.1.8",
+  "version": "4.0.0",
   "description": "Reactive artifact container.",
   "main": "index.js",
   "module": "index.mjs",