@artemiskit/core 0.2.0 → 0.2.3

package/src/storage/local.test.ts

@@ -162,4 +162,247 @@ describe('LocalStorageAdapter', () => {
     const runs = await emptyStorage.list();
     expect(runs).toEqual([]);
   });
+
+  // ==================== Baseline Tests ====================
+
+  describe('Baseline Management', () => {
+    const baselineManifest: RunManifest = {
+      ...mockManifest,
+      run_id: 'baseline-test-run',
+      config: {
+        ...mockManifest.config,
+        scenario: 'baseline-test-scenario',
+      },
+    };
+
+    test('sets a baseline for a scenario', async () => {
+      await storage.save(baselineManifest);
+
+      const baseline = await storage.setBaseline('baseline-test-scenario', 'baseline-test-run');
+
+      expect(baseline.scenario).toBe('baseline-test-scenario');
+      expect(baseline.runId).toBe('baseline-test-run');
+      expect(baseline.metrics.successRate).toBe(0.8);
+      expect(baseline.metrics.totalCases).toBe(10);
+      expect(baseline.metrics.passedCases).toBe(8);
+      expect(baseline.createdAt).toBeDefined();
+    });
+
+    test('sets a baseline with a tag', async () => {
+      await storage.save(baselineManifest);
+
+      const baseline = await storage.setBaseline(
+        'baseline-test-scenario',
+        'baseline-test-run',
+        'v1.0.0-release'
+      );
+
+      expect(baseline.tag).toBe('v1.0.0-release');
+    });
+
+    test('gets a baseline for a scenario', async () => {
+      await storage.save(baselineManifest);
+      await storage.setBaseline('baseline-test-scenario', 'baseline-test-run');
+
+      const baseline = await storage.getBaseline('baseline-test-scenario');
+
+      expect(baseline).not.toBeNull();
+      expect(baseline?.runId).toBe('baseline-test-run');
+      expect(baseline?.metrics.successRate).toBe(0.8);
+    });
+
+    test('returns null for non-existent baseline', async () => {
+      const baseline = await storage.getBaseline('non-existent-scenario');
+      expect(baseline).toBeNull();
+    });
+
+    test('gets a baseline by run ID', async () => {
+      await storage.save(baselineManifest);
+      await storage.setBaseline('baseline-test-scenario', 'baseline-test-run', 'by-run-id-test');
+
+      const baseline = await storage.getBaselineByRunId('baseline-test-run');
+
+      expect(baseline).not.toBeNull();
+      expect(baseline?.scenario).toBe('baseline-test-scenario');
+      expect(baseline?.runId).toBe('baseline-test-run');
+      expect(baseline?.tag).toBe('by-run-id-test');
+    });
+
+    test('returns null for non-existent baseline by run ID', async () => {
+      const baseline = await storage.getBaselineByRunId('non-existent-run-id');
+      expect(baseline).toBeNull();
+    });
+
+    test('lists all baselines', async () => {
+      // Clear any existing baselines by creating a new storage instance
+      const freshStorage = new LocalStorageAdapter(TEST_DIR);
+
+      // Create multiple runs and baselines
+      const manifest1 = {
+        ...mockManifest,
+        run_id: 'list-baseline-1',
+        config: { ...mockManifest.config, scenario: 'scenario-1' },
+      };
+      const manifest2 = {
+        ...mockManifest,
+        run_id: 'list-baseline-2',
+        config: { ...mockManifest.config, scenario: 'scenario-2' },
+      };
+
+      await freshStorage.save(manifest1);
+      await freshStorage.save(manifest2);
+      await freshStorage.setBaseline('scenario-1', 'list-baseline-1');
+      await freshStorage.setBaseline('scenario-2', 'list-baseline-2');
+
+      const baselines = await freshStorage.listBaselines();
+
+      expect(baselines.length).toBeGreaterThanOrEqual(2);
+      expect(baselines.some((b) => b.scenario === 'scenario-1')).toBe(true);
+      expect(baselines.some((b) => b.scenario === 'scenario-2')).toBe(true);
+    });
+
+    test('removes a baseline', async () => {
+      await storage.save(baselineManifest);
+      await storage.setBaseline('baseline-test-scenario', 'baseline-test-run');
+
+      // Verify it exists
+      const before = await storage.getBaseline('baseline-test-scenario');
+      expect(before).not.toBeNull();
+
+      // Remove
+      const removed = await storage.removeBaseline('baseline-test-scenario');
+      expect(removed).toBe(true);
+
+      // Verify it's gone
+      const after = await storage.getBaseline('baseline-test-scenario');
+      expect(after).toBeNull();
+    });
+
+    test('returns false when removing non-existent baseline', async () => {
+      const removed = await storage.removeBaseline('non-existent-baseline');
+      expect(removed).toBe(false);
+    });
+
+    test('removes a baseline by run ID', async () => {
+      const removeByIdManifest = {
+        ...mockManifest,
+        run_id: 'remove-by-id-run',
+        config: { ...mockManifest.config, scenario: 'remove-by-id-scenario' },
+      };
+      await storage.save(removeByIdManifest);
+      await storage.setBaseline('remove-by-id-scenario', 'remove-by-id-run');
+
+      // Verify it exists
+      const before = await storage.getBaselineByRunId('remove-by-id-run');
+      expect(before).not.toBeNull();
+
+      // Remove by run ID
+      const removed = await storage.removeBaselineByRunId('remove-by-id-run');
+      expect(removed).toBe(true);
+
+      // Verify it's gone
+      const after = await storage.getBaselineByRunId('remove-by-id-run');
+      expect(after).toBeNull();
+    });
+
+    test('returns false when removing non-existent baseline by run ID', async () => {
+      const removed = await storage.removeBaselineByRunId('non-existent-run-id');
+      expect(removed).toBe(false);
+    });
+
+    test('updates existing baseline when set again', async () => {
+      await storage.save(baselineManifest);
+
+      // Set initial baseline
+      await storage.setBaseline('baseline-test-scenario', 'baseline-test-run', 'v1.0');
+
+      // Create a new run with different metrics
+      const newManifest = {
+        ...baselineManifest,
+        run_id: 'baseline-test-run-2',
+        metrics: {
+          ...baselineManifest.metrics,
+          success_rate: 0.95,
+          passed_cases: 9,
+          failed_cases: 1,
+        },
+      };
+      await storage.save(newManifest);
+
+      // Update baseline
+      await storage.setBaseline('baseline-test-scenario', 'baseline-test-run-2', 'v2.0');
+
+      const baseline = await storage.getBaseline('baseline-test-scenario');
+      expect(baseline?.runId).toBe('baseline-test-run-2');
+      expect(baseline?.tag).toBe('v2.0');
+      expect(baseline?.metrics.successRate).toBe(0.95);
+    });
+
+    test('compares run to baseline and detects no regression', async () => {
+      // Create baseline run
+      const baselineRun = {
+        ...mockManifest,
+        run_id: 'compare-baseline-run',
+        config: { ...mockManifest.config, scenario: 'compare-scenario' },
+        metrics: { ...mockManifest.metrics, success_rate: 0.8 },
+      };
+      await storage.save(baselineRun);
+      await storage.setBaseline('compare-scenario', 'compare-baseline-run');
+
+      // Create current run with same or better success rate
+      const currentRun = {
+        ...mockManifest,
+        run_id: 'compare-current-run',
+        config: { ...mockManifest.config, scenario: 'compare-scenario' },
+        metrics: { ...mockManifest.metrics, success_rate: 0.85 },
+      };
+      await storage.save(currentRun);
+
+      const result = await storage.compareToBaseline('compare-current-run', 0.05);
+
+      expect(result).not.toBeNull();
+      expect(result?.hasRegression).toBe(false);
+      expect(result?.comparison.delta.successRate).toBeCloseTo(0.05, 2);
+    });
+
+    test('compares run to baseline and detects regression', async () => {
+      // Create baseline run
+      const baselineRun = {
+        ...mockManifest,
+        run_id: 'regression-baseline-run',
+        config: { ...mockManifest.config, scenario: 'regression-scenario' },
+        metrics: { ...mockManifest.metrics, success_rate: 0.9 },
+      };
+      await storage.save(baselineRun);
+      await storage.setBaseline('regression-scenario', 'regression-baseline-run');
+
+      // Create current run with worse success rate (regression)
+      const currentRun = {
+        ...mockManifest,
+        run_id: 'regression-current-run',
+        config: { ...mockManifest.config, scenario: 'regression-scenario' },
+        metrics: { ...mockManifest.metrics, success_rate: 0.7 },
+      };
+      await storage.save(currentRun);
+
+      const result = await storage.compareToBaseline('regression-current-run', 0.05);
+
+      expect(result).not.toBeNull();
+      expect(result?.hasRegression).toBe(true);
+      expect(result?.comparison.delta.successRate).toBeCloseTo(-0.2, 2);
+    });
+
+    test('returns null when no baseline exists for scenario', async () => {
+      const noBaselineRun = {
+        ...mockManifest,
+        run_id: 'no-baseline-run',
+        config: { ...mockManifest.config, scenario: 'no-baseline-scenario' },
+      };
+      await storage.save(noBaselineRun);
+
+      const result = await storage.compareToBaseline('no-baseline-run');
+
+      expect(result).toBeNull();
+    });
+  });
 });

package/src/storage/local.ts

@@ -5,7 +5,13 @@
 import { mkdir, readFile, readdir, unlink, writeFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import type { AnyManifest, RedTeamManifest, RunManifest, StressManifest } from '../artifacts/types';
-import type { ComparisonResult, ListOptions, RunListItem, StorageAdapter } from './types';
+import type {
+  BaselineMetadata,
+  BaselineStorageAdapter,
+  ComparisonResult,
+  ListOptions,
+  RunListItem,
+} from './types';
 
 /**
  * Get manifest type from a manifest object
@@ -32,6 +38,21 @@ function getSuccessRate(manifest: AnyManifest): number {
   return (manifest as RunManifest).metrics.success_rate;
 }
 
+/**
+ * Get estimated cost from any manifest type
+ */
+function getEstimatedCost(manifest: AnyManifest): number | undefined {
+  const type = getManifestType(manifest);
+  if (type === 'stress') {
+    return (manifest as StressManifest).metrics.cost?.estimated_total_usd;
+  }
+  if (type === 'run') {
+    return (manifest as RunManifest).metrics.cost?.total_usd;
+  }
+  // Redteam doesn't have cost tracking yet
+  return undefined;
+}
+
 /**
  * Get scenario name from any manifest type
  */
@@ -39,11 +60,21 @@ function getScenario(manifest: AnyManifest): string {
   return manifest.config.scenario;
 }
 
-export class LocalStorageAdapter implements StorageAdapter {
+/**
+ * Baselines file structure
+ */
+interface BaselinesFile {
+  version: string;
+  baselines: Record<string, BaselineMetadata>;
+}
+
+export class LocalStorageAdapter implements BaselineStorageAdapter {
   private basePath: string;
+  private baselinesPath: string;
 
   constructor(basePath = './artemis-runs') {
     this.basePath = resolve(basePath);
+    this.baselinesPath = join(this.basePath, '.artemis', 'baselines.json');
   }
 
   async save(manifest: AnyManifest): Promise<string> {
@@ -122,13 +153,20 @@ export class LocalStorageAdapter implements StorageAdapter {
             continue;
           }
 
-          results.push({
+          const item: RunListItem = {
             runId: manifest.run_id,
             scenario: getScenario(manifest),
             successRate: getSuccessRate(manifest),
             createdAt: manifest.start_time,
             type: manifestType,
-          });
+          };
+
+          // Include cost if requested
+          if (options?.includeCost) {
+            item.estimatedCostUsd = getEstimatedCost(manifest);
+          }
+
+          results.push(item);
         } catch {}
       }
     }
@@ -191,4 +229,148 @@ export class LocalStorageAdapter implements StorageAdapter {
       return [];
     }
   }
+
+  // ==================== Baseline Methods ====================
+
+  /**
+   * Load baselines file
+   */
+  private async loadBaselinesFile(): Promise<BaselinesFile> {
+    try {
+      const content = await readFile(this.baselinesPath, 'utf-8');
+      return JSON.parse(content);
+    } catch {
+      return { version: '1.0', baselines: {} };
+    }
+  }
+
+  /**
+   * Save baselines file
+   */
+  private async saveBaselinesFile(data: BaselinesFile): Promise<void> {
+    const dir = join(this.basePath, '.artemis');
+    await mkdir(dir, { recursive: true });
+    await writeFile(this.baselinesPath, JSON.stringify(data, null, 2));
+  }
+
+  /**
+   * Set a baseline for a scenario
+   */
+  async setBaseline(scenario: string, runId: string, tag?: string): Promise<BaselineMetadata> {
+    // Load the run to extract metrics
+    const manifest = await this.loadRun(runId);
+    const scenarioName = scenario || getScenario(manifest);
+
+    const baseline: BaselineMetadata = {
+      scenario: scenarioName,
+      runId,
+      createdAt: new Date().toISOString(),
+      metrics: {
+        successRate: manifest.metrics.success_rate,
+        medianLatencyMs: manifest.metrics.median_latency_ms,
+        totalTokens: manifest.metrics.total_tokens,
+        passedCases: manifest.metrics.passed_cases,
+        failedCases: manifest.metrics.failed_cases,
+        totalCases: manifest.metrics.total_cases,
+      },
+      tag,
+    };
+
+    // Load existing baselines and add/update
+    const data = await this.loadBaselinesFile();
+    data.baselines[scenarioName] = baseline;
+    await this.saveBaselinesFile(data);
+
+    return baseline;
+  }
+
+  /**
+   * Get the baseline for a scenario
+   */
+  async getBaseline(scenario: string): Promise<BaselineMetadata | null> {
+    const data = await this.loadBaselinesFile();
+    return data.baselines[scenario] || null;
+  }
+
+  /**
+   * Get a baseline by run ID
+   */
+  async getBaselineByRunId(runId: string): Promise<BaselineMetadata | null> {
+    const data = await this.loadBaselinesFile();
+    const baselines = Object.values(data.baselines);
+    return baselines.find((b) => b.runId === runId) || null;
+  }
+
+  /**
+   * List all baselines
+   */
+  async listBaselines(): Promise<BaselineMetadata[]> {
+    const data = await this.loadBaselinesFile();
+    return Object.values(data.baselines).sort(
+      (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+    );
+  }
+
+  /**
+   * Remove a baseline by scenario name
+   */
+  async removeBaseline(scenario: string): Promise<boolean> {
+    const data = await this.loadBaselinesFile();
+    if (data.baselines[scenario]) {
+      delete data.baselines[scenario];
+      await this.saveBaselinesFile(data);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Remove a baseline by run ID
+   */
+  async removeBaselineByRunId(runId: string): Promise<boolean> {
+    const data = await this.loadBaselinesFile();
+    const entry = Object.entries(data.baselines).find(([_, b]) => b.runId === runId);
+    if (entry) {
+      delete data.baselines[entry[0]];
+      await this.saveBaselinesFile(data);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Compare a run against its baseline (if exists)
+   */
+  async compareToBaseline(
+    runId: string,
+    regressionThreshold = 0.05
+  ): Promise<{
+    baseline: BaselineMetadata;
+    comparison: ComparisonResult;
+    hasRegression: boolean;
+    regressionThreshold: number;
+  } | null> {
+    // Load the current run
+    const currentManifest = await this.loadRun(runId);
+    const scenario = getScenario(currentManifest);
+
+    // Get baseline for this scenario
+    const baseline = await this.getBaseline(scenario);
+    if (!baseline) {
+      return null;
+    }
+
+    // Load baseline manifest for full comparison
+    const comparison = await this.compare(baseline.runId, runId);
+
+    // Check for regression (negative delta in success rate)
+    const hasRegression = comparison.delta.successRate < -regressionThreshold;
+
+    return {
+      baseline,
+      comparison,
+      hasRegression,
+      regressionThreshold,
+    };
+  }
 }

package/src/storage/types.ts

@@ -14,6 +14,8 @@ export interface RunListItem {
   createdAt: string;
   /** Type of manifest (run, redteam, stress) */
   type?: 'run' | 'redteam' | 'stress';
+  /** Estimated cost in USD (optional, included when --show-cost is used) */
+  estimatedCostUsd?: number;
 }
 
 /**
@@ -39,6 +41,8 @@ export interface ListOptions {
   offset?: number;
   /** Filter by manifest type */
   type?: 'run' | 'redteam' | 'stress';
+  /** Include cost information in results */
+  includeCost?: boolean;
 }
 
 /**
@@ -96,3 +100,76 @@ export interface StorageConfig {
   bucket?: string;
   basePath?: string;
 }
+
+/**
+ * Baseline metadata for regression comparison
+ */
+export interface BaselineMetadata {
+  /** Scenario name or identifier */
+  scenario: string;
+  /** Run ID of the baseline */
+  runId: string;
+  /** ISO timestamp when baseline was set */
+  createdAt: string;
+  /** Key metrics captured at baseline time */
+  metrics: {
+    successRate: number;
+    medianLatencyMs: number;
+    totalTokens: number;
+    passedCases: number;
+    failedCases: number;
+    totalCases: number;
+  };
+  /** Optional description or tag */
+  tag?: string;
+}
+
+/**
+ * Extended storage adapter with baseline support
+ */
+export interface BaselineStorageAdapter extends StorageAdapter {
+  /**
+   * Set a baseline for a scenario
+   */
+  setBaseline(scenario: string, runId: string, tag?: string): Promise<BaselineMetadata>;
+
+  /**
+   * Get the baseline by scenario name
+   */
+  getBaseline(scenario: string): Promise<BaselineMetadata | null>;
+
+  /**
+   * Get the baseline by run ID
+   */
+  getBaselineByRunId(runId: string): Promise<BaselineMetadata | null>;
+
+  /**
+   * List all baselines
+   */
+  listBaselines(): Promise<BaselineMetadata[]>;
+
+  /**
+   * Remove a baseline by scenario name
+   */
+  removeBaseline(scenario: string): Promise<boolean>;
+
+  /**
+   * Remove a baseline by run ID
+   */
+  removeBaselineByRunId(runId: string): Promise<boolean>;
+
+  /**
+   * Compare a run against its baseline (if exists)
+   * @param runId - The run ID to compare
+   * @param regressionThreshold - Threshold for regression detection (0-1), default 0.05
+   */
+  compareToBaseline?(
+    runId: string,
+    regressionThreshold?: number
+  ): Promise<{
+    baseline: BaselineMetadata;
+    comparison: ComparisonResult;
+    hasRegression: boolean;
+    regressionThreshold: number;
+  } | null>;
+}

package/dist/events/emitter.d.ts

@@ -1,111 +0,0 @@
-/**
- * Event emitter for observability
- *
- * A lightweight typed event emitter that allows the observability package
- * to subscribe to events from the core runner.
- */
-import type { ArtemisEvent, ArtemisEventMap, ArtemisEventType } from './types';
-/**
- * Event handler function type
- */
-export type EventHandler<T extends ArtemisEventType> = (event: ArtemisEventMap[T]) => void;
-/**
- * Async event handler function type
- */
-export type AsyncEventHandler<T extends ArtemisEventType> = (event: ArtemisEventMap[T]) => void | Promise<void>;
-/**
- * Subscriber interface for observability integrations
- */
-export interface EventSubscriber {
-    /** Unique identifier for this subscriber */
-    id: string;
-    /** Handle an event */
-    handleEvent(event: ArtemisEvent): void | Promise<void>;
-    /** Optional: called when subscriber is removed */
-    dispose?(): void | Promise<void>;
-}
-/**
- * Global event emitter instance
- *
- * This singleton allows the observability package to subscribe to events
- * without tight coupling to the core runner.
- */
-declare class ArtemisEventEmitter {
-    private subscribers;
-    private handlers;
-    private enabled;
-    /**
-     * Enable or disable event emission
-     * When disabled, no events are emitted (zero overhead)
-     */
-    setEnabled(enabled: boolean): void;
-    /**
-     * Check if any subscribers are registered
-     */
-    hasSubscribers(): boolean;
-    /**
-     * Register a subscriber that receives all events
-     */
-    subscribe(subscriber: EventSubscriber): () => void;
-    /**
-     * Remove a subscriber by ID
-     */
-    unsubscribe(subscriberId: string): Promise<void>;
-    /**
-     * Register a handler for a specific event type
-     */
-    on<T extends ArtemisEventType>(eventType: T, handler: AsyncEventHandler<T>): () => void;
-    /**
-     * Remove a handler for a specific event type
-     */
-    off<T extends ArtemisEventType>(eventType: T, handler: AsyncEventHandler<T>): void;
-    /**
-     * Emit an event to all subscribers and type-specific handlers
-     *
-     * Events are emitted asynchronously but errors are caught and logged
-     * to prevent observability from breaking the test runner.
-     */
-    emit<T extends ArtemisEventType>(event: ArtemisEventMap[T]): void;
-    /**
-     * Emit an event and wait for all handlers to complete
-     * Useful for testing or when you need to ensure handlers have run
-     */
-    emitAsync<T extends ArtemisEventType>(event: ArtemisEventMap[T]): Promise<void>;
-    /**
-     * Remove all subscribers and handlers
-     */
-    clear(): Promise<void>;
-    /**
-     * Get the number of registered subscribers
-     */
-    get subscriberCount(): number;
-    /**
-     * Get the number of registered handlers (across all event types)
-     */
-    get handlerCount(): number;
-}
-/**
- * Global event emitter singleton
- *
- * Usage in core:
- * ```typescript
- * import { events } from '@artemiskit/core';
- * events.emit({ type: 'test:start', ... });
- * ```
- *
- * Usage in observability:
- * ```typescript
- * import { events } from '@artemiskit/core';
- * events.subscribe({
- *   id: 'metrics',
- *   handleEvent: (event) => { ... }
- * });
- * ```
- */
-export declare const events: ArtemisEventEmitter;
-/**
- * Helper to create a timestamp for events
- */
-export declare function createTimestamp(): number;
-export {};
-//# sourceMappingURL=emitter.d.ts.map

package/dist/events/emitter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../../src/events/emitter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE/E;;GAEG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,gBAAgB,IAAI,CAAC,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;AAE3F;;GAEG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,gBAAgB,IAAI,CAC1D,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,KACtB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,4CAA4C;IAC5C,EAAE,EAAE,MAAM,CAAC;IACX,sBAAsB;IACtB,WAAW,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD,kDAAkD;IAClD,OAAO,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAClC;AAED;;;;;GAKG;AACH,cAAM,mBAAmB;IACvB,OAAO,CAAC,WAAW,CAA2C;IAC9D,OAAO,CAAC,QAAQ,CAAiE;IACjF,OAAO,CAAC,OAAO,CAAiB;IAEhC;;;OAGG;IACH,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIlC;;OAEG;IACH,cAAc,IAAI,OAAO;IAIzB;;OAEG;IACH,SAAS,CAAC,UAAU,EAAE,eAAe,GAAG,MAAM,IAAI;IASlD;;OAEG;IACG,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQtD;;OAEG;IACH,EAAE,CAAC,CAAC,SAAS,gBAAgB,EAAE,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI;IAYvF;;OAEG;IACH,GAAG,CAAC,CAAC,SAAS,gBAAgB,EAAE,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,IAAI;IAUlF;;;;;OAKG;IACH,IAAI,CAAC,CAAC,SAAS,gBAAgB,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,IAAI;IAWjE;;;OAGG;IACG,SAAS,CAAC,CAAC,SAAS,gBAAgB,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAoCrF;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAS5B;;OAEG;IACH,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED;;OAEG;IACH,IAAI,YAAY,IAAI,MAAM,CAMzB;CACF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,MAAM,qBAA4B,CAAC;AAEhD;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAExC"}

package/dist/events/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * Events module - for observability integration
- */
-export * from './types';
-export { events, createTimestamp, type EventSubscriber, type EventHandler, type AsyncEventHandler } from './emitter';
-//# sourceMappingURL=index.d.ts.map

package/dist/events/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/events/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,KAAK,eAAe,EAAE,KAAK,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,WAAW,CAAC"}