chore: optimize types for JSR (Fast Check)

Author: flyingrobots

package.json

@@ -4,14 +4,14 @@
 "description": "Why do we fall, Bruce? Resilience patterns for async operations.",
   "type": "module",
   "main": "src/index.js",
-  "types": "./index.d.ts",
+  "types": "./src/index.d.ts",
   "exports": {
     ".": {
-      "types": "./index.d.ts",
+      "types": "./src/index.d.ts",
       "default": "./src/index.js"
     },
     "./testing": {
-      "types": "./index.d.ts",
+      "types": "./src/testing.d.ts",
       "default": "./src/testing.js"
     }
   },

index.d.ts src/index.d.tsindex.d.ts renamed to src/index.d.ts

@@ -3,6 +3,8 @@
  * Exports all public APIs for building resilient applications.
  */
 
+// @ts-self-types="./index.d.ts"
+
 // Error types
 export { 
   RetryExhaustedError, 

src/index.js

@@ -0,0 +1,136 @@
+export interface RetryOptions {
+  retries?: number;
+  delay?: number;
+  maxDelay?: number;
+  backoff?: 'constant' | 'linear' | 'exponential';
+  jitter?: 'none' | 'full' | 'equal' | 'decorrelated';
+  shouldRetry?: (error: Error) => boolean;
+  onRetry?: (error: Error, attempt: number, delay: number) => void;
+  telemetry?: TelemetrySink;
+  clock?: any;
+}
+
+export interface CircuitBreakerOptions {
+  threshold: number;
+  duration: number;
+  successThreshold?: number;
+  shouldTrip?: (error: Error) => boolean;
+  onOpen?: () => void;
+  onClose?: () => void;
+  onHalfOpen?: () => void;
+  telemetry?: TelemetrySink;
+  clock?: any;
+}
+
+export interface TimeoutOptions {
+  onTimeout?: (elapsed: number) => void;
+  telemetry?: TelemetrySink;
+}
+
+export interface BulkheadOptions {
+  limit: number;
+  queueLimit?: number;
+  telemetry?: TelemetrySink;
+  clock?: any;
+}
+
+export interface TelemetryEvent {
+  type: string;
+  timestamp: number;
+  [key: string]: any;
+}
+
+export interface TelemetrySink {
+  emit(event: TelemetryEvent): void;
+}
+
+export class InMemorySink implements TelemetrySink {
+  events: TelemetryEvent[];
+  emit(event: TelemetryEvent): void;
+  clear(): void;
+}
+
+export class ConsoleSink implements TelemetrySink {
+  emit(event: TelemetryEvent): void;
+}
+
+export class NoopSink implements TelemetrySink {
+  emit(event: TelemetryEvent): void;
+}
+
+export class MultiSink implements TelemetrySink {
+  constructor(sinks: TelemetrySink[]);
+  emit(event: TelemetryEvent): void;
+}
+
+export class RetryExhaustedError extends Error {
+  attempts: number;
+  cause: Error;
+  constructor(attempts: number, cause: Error);
+}
+
+export class CircuitOpenError extends Error {
+  openedAt: Date;
+  failureCount: number;
+  constructor(openedAt: Date, failureCount: number);
+}
+
+export class TimeoutError extends Error {
+  timeout: number;
+  elapsed: number;
+  constructor(timeout: number, elapsed: number);
+}
+
+export class BulkheadRejectedError extends Error {
+  limit: number;
+  queueLimit: number;
+  constructor(limit: number, queueLimit: number);
+}
+
+export function retry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+
+export interface CircuitBreaker {
+  execute<T>(fn: () => Promise<T>): Promise<T>;
+  readonly state: 'CLOSED' | 'OPEN' | 'HALF_OPEN';
+}
+
+export function circuitBreaker(options: CircuitBreakerOptions): CircuitBreaker;
+
+export function timeout<T>(ms: number, fn: ((signal: AbortSignal) => Promise<T>) | (() => Promise<T>), options?: TimeoutOptions): Promise<T>;
+
+export interface Bulkhead {
+  execute<T>(fn: () => Promise<T>): Promise<T>;
+  readonly stats: { active: number; pending: number; available: number };
+}
+
+export function bulkhead(options: BulkheadOptions): Bulkhead;
+
+export function compose(...policies: any[]): { execute<T>(fn: () => Promise<T>): Promise<T> };
+export function fallback(primary: any, secondary: any): { execute<T>(fn: () => Promise<T>): Promise<T> };
+export function race(primary: any, secondary: any): { execute<T>(fn: () => Promise<T>): Promise<T> };
+
+export class Policy {
+  constructor(executor: (fn: () => Promise<any>) => Promise<any>);
+  static retry(options?: RetryOptions): Policy;
+  static circuitBreaker(options: CircuitBreakerOptions): Policy;
+  static timeout(ms: number, options?: TimeoutOptions): Policy;
+  static bulkhead(options: BulkheadOptions): Policy;
+  static noop(): Policy;
+
+  wrap(otherPolicy: Policy): Policy;
+  or(otherPolicy: Policy): Policy;
+  race(otherPolicy: Policy): Policy;
+  execute<T>(fn: () => Promise<T>): Promise<T>;
+}
+
+export class SystemClock {
+  now(): number;
+  sleep(ms: number): Promise<void>;
+}
+
+export class TestClock {
+  now(): number;
+  sleep(ms: number): Promise<void>;
+  tick(ms?: number): Promise<void>;
+  advance(ms: number): Promise<void>;
+}

src/testing.d.ts

@@ -3,4 +3,6 @@
  * Provides tools for deterministic testing of resilience policies.
  */
 
+// @ts-self-types="./testing.d.ts"
+
 export { TestClock } from './utils/clock.js';