@docker-harpoon/core 0.1.3 → 0.1.5

package/dist/services/DockerRateLimiter.js

@@ -0,0 +1,93 @@
+/**
+ * DockerRateLimiter Service
+ *
+ * Provides semaphore-based rate limiting for Docker API operations.
+ * Prevents overwhelming the Docker daemon with too many concurrent requests.
+ */
+import { Context, Effect, Layer, Schedule, Duration } from 'effect';
+import { HarpoonConfig } from './HarpoonConfig';
+/**
+ * DockerRateLimiter service tag for dependency injection.
+ */
+export class DockerRateLimiter extends Context.Tag('@harpoon/DockerRateLimiter')() {
+}
+// ============ Retry Schedules (Step 2) ============
+/**
+ * Exponential backoff schedule for transient Docker API errors.
+ *
+ * - 5 retries maximum
+ * - Base delay: 100ms, exponentially increasing
+ * - Max delay: 30 seconds
+ * - Includes jitter to prevent thundering herd
+ */
+export const dockerRetrySchedule = Schedule.exponential(Duration.millis(100), 2).pipe(Schedule.jittered, Schedule.either(Schedule.recurs(5)), Schedule.upTo(Duration.seconds(30)));
+/**
+ * Aggressive retry schedule for cleanup operations.
+ *
+ * - 3 retries maximum
+ * - Base delay: 200ms
+ * - Max delay: 10 seconds
+ * - Quick cleanup attempts with short delays
+ */
+export const cleanupRetrySchedule = Schedule.exponential(Duration.millis(200), 2).pipe(Schedule.jittered, Schedule.either(Schedule.recurs(3)), Schedule.upTo(Duration.seconds(10)));
+/**
+ * Health check schedule with fixed intervals.
+ *
+ * - 1 second between checks
+ * - Used for container readiness polling
+ */
+export const healthCheckSchedule = Schedule.spaced(Duration.seconds(1));
+// ============ Live Implementation ============
+/**
+ * Creates a simple semaphore-based rate limiter using Effect.
+ */
+const makeSemaphore = (permits) => Effect.gen(function* () {
+    // Use Effect.makeSemaphore for a simple counting semaphore
+    const semaphore = yield* Effect.makeSemaphore(permits);
+    return {
+        withPermit: (effect) => semaphore.withPermits(1)(effect),
+        withPermits: (count) => (effect) => semaphore.withPermits(count)(effect),
+        // Return the current permits - Effect semaphores don't expose available count
+        // so we just return the configured limit as an approximation
+        available: () => Effect.succeed(permits),
+    };
+});
+/**
+ * Live implementation of DockerRateLimiter.
+ *
+ * Uses HarpoonConfig.parallelLimit to determine semaphore size.
+ */
+export const DockerRateLimiterLive = Layer.scoped(DockerRateLimiter, Effect.gen(function* () {
+    const config = yield* HarpoonConfig;
+    const semaphore = yield* makeSemaphore(config.parallelLimit);
+    yield* Effect.logDebug('DockerRateLimiter initialized').pipe(Effect.annotateLogs({ permits: config.parallelLimit }));
+    return {
+        _tag: 'DockerRateLimiter',
+        withPermit: semaphore.withPermit,
+        withPermits: semaphore.withPermits,
+        available: semaphore.available,
+    };
+}));
+/**
+ * Test implementation with unlimited permits.
+ *
+ * Useful for unit tests that don't need rate limiting.
+ */
+export const DockerRateLimiterTest = Layer.succeed(DockerRateLimiter, {
+    _tag: 'DockerRateLimiter',
+    withPermit: (effect) => effect,
+    withPermits: () => (effect) => effect,
+    available: () => Effect.succeed(Infinity),
+});
+/**
+ * Create a custom test rate limiter with specific permit count.
+ */
+export const makeDockerRateLimiterTest = (permits) => Layer.scoped(DockerRateLimiter, Effect.gen(function* () {
+    const semaphore = yield* makeSemaphore(permits);
+    return {
+        _tag: 'DockerRateLimiter',
+        withPermit: semaphore.withPermit,
+        withPermits: semaphore.withPermits,
+        available: semaphore.available,
+    };
+}));

package/dist/services/EventBus.d.ts

@@ -0,0 +1,126 @@
+/**
+ * EventBus Service
+ *
+ * Provides a publish/subscribe event system for Harpoon resource lifecycle events.
+ * Uses Effect's PubSub for type-safe, concurrent event distribution.
+ */
+import { Context, Effect, Layer, Stream, Scope } from 'effect';
+/**
+ * Container lifecycle event types.
+ */
+export type ContainerEventType = 'Created' | 'Started' | 'Stopped' | 'Destroyed' | 'Error';
+/**
+ * Network lifecycle event types.
+ */
+export type NetworkEventType = 'Created' | 'Destroyed' | 'Connected' | 'Disconnected';
+/**
+ * Container lifecycle event.
+ */
+export interface ContainerEvent {
+    readonly _tag: 'ContainerEvent';
+    readonly type: ContainerEventType;
+    readonly containerId: string;
+    readonly containerName: string;
+    readonly timestamp: Date;
+    readonly metadata?: Record<string, unknown>;
+    readonly error?: Error;
+}
+/**
+ * Network lifecycle event.
+ */
+export interface NetworkEvent {
+    readonly _tag: 'NetworkEvent';
+    readonly type: NetworkEventType;
+    readonly networkId: string;
+    readonly networkName: string;
+    readonly timestamp: Date;
+    readonly metadata?: Record<string, unknown>;
+}
+/**
+ * Database lifecycle event (extends container events with DB-specific info).
+ */
+export interface DatabaseEvent {
+    readonly _tag: 'DatabaseEvent';
+    readonly type: ContainerEventType;
+    readonly containerId: string;
+    readonly databaseName: string;
+    readonly databaseType: string;
+    readonly timestamp: Date;
+    readonly connectionString?: string;
+    readonly metadata?: Record<string, unknown>;
+}
+/**
+ * Union type of all Harpoon events.
+ */
+export type HarpoonEvent = ContainerEvent | NetworkEvent | DatabaseEvent;
+/**
+ * Create a container event.
+ */
+export declare const containerEvent: (type: ContainerEventType, containerId: string, containerName: string, options?: {
+    metadata?: Record<string, unknown>;
+    error?: Error;
+} | undefined) => ContainerEvent;
+/**
+ * Create a network event.
+ */
+export declare const networkEvent: (type: NetworkEventType, networkId: string, networkName: string, options?: {
+    metadata?: Record<string, unknown>;
+} | undefined) => NetworkEvent;
+/**
+ * Create a database event.
+ */
+export declare const databaseEvent: (type: ContainerEventType, containerId: string, databaseName: string, databaseType: string, options?: {
+    connectionString?: string;
+    metadata?: Record<string, unknown>;
+} | undefined) => DatabaseEvent;
+/**
+ * EventBus service interface.
+ */
+export interface EventBusService {
+    readonly _tag: 'EventBus';
+    /**
+     * Publish an event to all subscribers.
+     */
+    readonly publish: (event: HarpoonEvent) => Effect.Effect<boolean>;
+    /**
+     * Subscribe to all events.
+     * Returns a Stream that emits events as they are published.
+     * Requires Scope for queue management.
+     */
+    readonly subscribe: () => Effect.Effect<Stream.Stream<HarpoonEvent, never>, never, Scope.Scope>;
+    /**
+     * Subscribe to container events only.
+     * Requires Scope for queue management.
+     */
+    readonly subscribeContainers: () => Effect.Effect<Stream.Stream<ContainerEvent, never>, never, Scope.Scope>;
+    /**
+     * Subscribe to network events only.
+     * Requires Scope for queue management.
+     */
+    readonly subscribeNetworks: () => Effect.Effect<Stream.Stream<NetworkEvent, never>, never, Scope.Scope>;
+    /**
+     * Subscribe to database events only.
+     * Requires Scope for queue management.
+     */
+    readonly subscribeDatabases: () => Effect.Effect<Stream.Stream<DatabaseEvent, never>, never, Scope.Scope>;
+    /**
+     * Get the number of current subscribers.
+     */
+    readonly subscriberCount: () => Effect.Effect<number>;
+}
+declare const EventBus_base: Context.TagClass<EventBus, "@harpoon/EventBus", EventBusService>;
+/**
+ * EventBus service tag for dependency injection.
+ */
+export declare class EventBus extends EventBus_base {
+}
+/**
+ * Live implementation using Effect PubSub.
+ */
+export declare const EventBusLive: Layer.Layer<EventBus, never, never>;
+/**
+ * Test implementation that collects all events for verification.
+ */
+export declare const EventBusTest: Layer.Layer<EventBus, never, never>;
+export {};
+//# sourceMappingURL=EventBus.d.ts.map

package/dist/services/EventBus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventBus.d.ts","sourceRoot":"","sources":["../../src/services/EventBus.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAU,MAAM,EAAe,KAAK,EAAE,MAAM,QAAQ,CAAC;AAIpF;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,OAAO,CAAC;AAE3F;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,WAAW,GAAG,WAAW,GAAG,cAAc,CAAC;AAEtF;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5C,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC7C;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IACzB,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC7C;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,cAAc,GAAG,YAAY,GAAG,aAAa,CAAC;AAIzE;;GAEG;AACH,eAAO,MAAM,cAAc;;;gCAazB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY;;8BAYvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa;;;+BAexB,CAAC;AAIH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAE1B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAElE;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;IAEhG;;;OAGG;IACH,QAAQ,CAAC,mBAAmB,EAAE,MAAM,MAAM,CAAC,MAAM,CAC/C,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,KAAK,CAAC,EACpC,KAAK,EACL,KAAK,CAAC,KAAK,CACZ,CAAC;IAEF;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,EAAE,MAAM,MAAM,CAAC,MAAM,CAC7C,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,KAAK,CAAC,EAClC,KAAK,EACL,KAAK,CAAC,KAAK,CACZ,CAAC;IAEF;;;OAGG;IACH,QAAQ,CAAC,kBAAkB,EAAE,MAAM,MAAM,CAAC,MAAM,CAC9C,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,KAAK,CAAC,EACnC,KAAK,EACL,KAAK,CAAC,KAAK,CACZ,CAAC;IAEF;;OAEG;IACH,QAAQ,CAAC,eAAe,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;CACvD;;AAED;;GAEG;AACH,qBAAa,QAAS,SAAQ,aAA6D;CAAG;AAE9F;;GAEG;AACH,eAAO,MAAM,YAAY,qCA6DxB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,qCA2CxB,CAAC"}

package/dist/services/EventBus.js

@@ -0,0 +1,111 @@
+/**
+ * EventBus Service
+ *
+ * Provides a publish/subscribe event system for Harpoon resource lifecycle events.
+ * Uses Effect's PubSub for type-safe, concurrent event distribution.
+ */
+import { Context, Effect, Layer, PubSub, Stream } from 'effect';
+// ============ Event Constructors ============
+/**
+ * Create a container event.
+ */
+export const containerEvent = (type, containerId, containerName, options) => ({
+    _tag: 'ContainerEvent',
+    type,
+    containerId,
+    containerName,
+    timestamp: new Date(),
+    ...(options?.metadata !== undefined && { metadata: options.metadata }),
+    ...(options?.error !== undefined && { error: options.error }),
+});
+/**
+ * Create a network event.
+ */
+export const networkEvent = (type, networkId, networkName, options) => ({
+    _tag: 'NetworkEvent',
+    type,
+    networkId,
+    networkName,
+    timestamp: new Date(),
+    ...(options?.metadata !== undefined && { metadata: options.metadata }),
+});
+/**
+ * Create a database event.
+ */
+export const databaseEvent = (type, containerId, databaseName, databaseType, options) => ({
+    _tag: 'DatabaseEvent',
+    type,
+    containerId,
+    databaseName,
+    databaseType,
+    timestamp: new Date(),
+    ...(options?.connectionString !== undefined && { connectionString: options.connectionString }),
+    ...(options?.metadata !== undefined && { metadata: options.metadata }),
+});
+/**
+ * EventBus service tag for dependency injection.
+ */
+export class EventBus extends Context.Tag('@harpoon/EventBus')() {
+}
+/**
+ * Live implementation using Effect PubSub.
+ */
+export const EventBusLive = Layer.scoped(EventBus, Effect.gen(function* () {
+    // Create an unbounded PubSub for events
+    const pubsub = yield* PubSub.unbounded();
+    yield* Effect.logDebug('EventBus initialized');
+    const service = {
+        _tag: 'EventBus',
+        publish: (event) => PubSub.publish(pubsub, event).pipe(Effect.tap(() => Effect.logDebug('Event published').pipe(Effect.annotateLogs({
+            eventTag: event._tag,
+            eventType: event._tag === 'ContainerEvent' || event._tag === 'DatabaseEvent'
+                ? event.type
+                : event.type,
+        })))),
+        subscribe: () => Effect.gen(function* () {
+            const queue = yield* PubSub.subscribe(pubsub);
+            return Stream.fromQueue(queue);
+        }),
+        subscribeContainers: () => Effect.gen(function* () {
+            const queue = yield* PubSub.subscribe(pubsub);
+            return Stream.fromQueue(queue).pipe(Stream.filter((event) => event._tag === 'ContainerEvent'));
+        }),
+        subscribeNetworks: () => Effect.gen(function* () {
+            const queue = yield* PubSub.subscribe(pubsub);
+            return Stream.fromQueue(queue).pipe(Stream.filter((event) => event._tag === 'NetworkEvent'));
+        }),
+        subscribeDatabases: () => Effect.gen(function* () {
+            const queue = yield* PubSub.subscribe(pubsub);
+            return Stream.fromQueue(queue).pipe(Stream.filter((event) => event._tag === 'DatabaseEvent'));
+        }),
+        subscriberCount: () => PubSub.size(pubsub),
+    };
+    return service;
+}));
+/**
+ * Test implementation that collects all events for verification.
+ */
+export const EventBusTest = Layer.scoped(EventBus, Effect.gen(function* () {
+    const pubsub = yield* PubSub.unbounded();
+    return {
+        _tag: 'EventBus',
+        publish: (event) => PubSub.publish(pubsub, event),
+        subscribe: () => Effect.gen(function* () {
+            const queue = yield* PubSub.subscribe(pubsub);
+            return Stream.fromQueue(queue);
+        }),
+        subscribeContainers: () => Effect.gen(function* () {
+            const queue = yield* PubSub.subscribe(pubsub);
+            return Stream.fromQueue(queue).pipe(Stream.filter((event) => event._tag === 'ContainerEvent'));
+        }),
+        subscribeNetworks: () => Effect.gen(function* () {
+            const queue = yield* PubSub.subscribe(pubsub);
+            return Stream.fromQueue(queue).pipe(Stream.filter((event) => event._tag === 'NetworkEvent'));
+        }),
+        subscribeDatabases: () => Effect.gen(function* () {
+            const queue = yield* PubSub.subscribe(pubsub);
+            return Stream.fromQueue(queue).pipe(Stream.filter((event) => event._tag === 'DatabaseEvent'));
+        }),
+        subscriberCount: () => PubSub.size(pubsub),
+    };
+}));

package/dist/services/Harpoon.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Harpoon Unified Layer
+ *
+ * Provides pre-composed layers for all Harpoon services.
+ * Makes it easy to use Harpoon with a single layer provision.
+ */
+import { Layer } from 'effect';
+import { HarpoonConfig } from './HarpoonConfig';
+import { DockerRateLimiter } from './DockerRateLimiter';
+import { CircuitBreaker } from './CircuitBreaker';
+import { DockerClient } from './DockerClient';
+import { DockerBatcher } from './DockerBatcher';
+import { ResourceTracker } from './ResourceTracker';
+import { EventBus } from './EventBus';
+import { ReadinessCoordinator } from './ReadinessCoordinator';
+/**
+ * Core configuration layer.
+ * Provides HarpoonConfig.
+ */
+export declare const CoreLive: Layer.Layer<HarpoonConfig, import("effect/ConfigError").ConfigError, never>;
+/**
+ * Infrastructure layer with rate limiting and circuit breaker.
+ * Provides: DockerRateLimiter, CircuitBreaker
+ * Requires: HarpoonConfig
+ */
+export declare const InfrastructureLive: Layer.Layer<CircuitBreaker | DockerRateLimiter, import("effect/ConfigError").ConfigError, never>;
+/**
+ * Docker client layer with all integrations.
+ * Provides: DockerClient
+ * Requires: HarpoonConfig, DockerRateLimiter
+ */
+export declare const DockerLive: Layer.Layer<DockerClient, import("./DockerErrors").DockerConnectionError | import("effect/ConfigError").ConfigError, never>;
+/**
+ * Batching layer for Docker requests.
+ * Provides: DockerBatcher
+ * Requires: DockerClient
+ */
+export declare const BatcherLive: Layer.Layer<DockerBatcher, import("./DockerErrors").DockerConnectionError | import("effect/ConfigError").ConfigError, never>;
+/**
+ * Resource management layer.
+ * Provides: ResourceTracker
+ * Requires: HarpoonConfig
+ */
+export declare const ResourcesLive: Layer.Layer<ResourceTracker, import("effect/ConfigError").ConfigError, never>;
+/**
+ * Event bus layer.
+ * Provides: EventBus
+ */
+export declare const EventsLive: Layer.Layer<EventBus, never, never>;
+/**
+ * Readiness coordination layer.
+ * Provides: ReadinessCoordinator
+ */
+export declare const ReadinessLive: Layer.Layer<ReadinessCoordinator, never, never>;
+/**
+ * Services layer combining all coordination services.
+ * Provides: ResourceTracker, EventBus, ReadinessCoordinator
+ * Requires: HarpoonConfig
+ */
+export declare const ServicesLive: Layer.Layer<EventBus | ReadinessCoordinator | ResourceTracker, import("effect/ConfigError").ConfigError, never>;
+/**
+ * Full Harpoon layer for production use.
+ * Provides all services needed for Docker resource management.
+ *
+ * Includes:
+ * - HarpoonConfig
+ * - DockerRateLimiter
+ * - CircuitBreaker
+ * - DockerClient
+ * - DockerBatcher
+ * - ResourceTracker
+ * - EventBus
+ * - ReadinessCoordinator
+ *
+ * @example
+ * ```typescript
+ * import { HarpoonLive } from '@docker-harpoon/core/services';
+ *
+ * const program = Effect.gen(function* () {
+ *   const docker = yield* DockerClient;
+ *   const tracker = yield* ResourceTracker;
+ *   // ... use services
+ * });
+ *
+ * Effect.runPromise(
+ *   program.pipe(Effect.provide(HarpoonLive))
+ * );
+ * ```
+ */
+export declare const HarpoonLive: Layer.Layer<CircuitBreaker | DockerBatcher | DockerClient | DockerRateLimiter | EventBus | HarpoonConfig | ReadinessCoordinator | ResourceTracker, import("./DockerErrors").DockerConnectionError | import("effect/ConfigError").ConfigError, never>;
+/**
+ * Core test configuration layer.
+ */
+export declare const CoreTest: Layer.Layer<HarpoonConfig, never, never>;
+/**
+ * Infrastructure test layer.
+ */
+export declare const InfrastructureTest: Layer.Layer<CircuitBreaker | DockerRateLimiter, never, never>;
+/**
+ * Docker client test layer.
+ */
+export declare const DockerTest: Layer.Layer<DockerClient, never, never>;
+/**
+ * Batcher test layer.
+ */
+export declare const BatcherTest: Layer.Layer<DockerBatcher, never, never>;
+/**
+ * Resources test layer.
+ */
+export declare const ResourcesTest: Layer.Layer<ResourceTracker, never, never>;
+/**
+ * Events test layer.
+ */
+export declare const EventsTest: Layer.Layer<EventBus, never, never>;
+/**
+ * Readiness test layer.
+ */
+export declare const ReadinessTest: Layer.Layer<ReadinessCoordinator, never, never>;
+/**
+ * Services test layer.
+ */
+export declare const ServicesTest: Layer.Layer<EventBus | ReadinessCoordinator | ResourceTracker, never, never>;
+/**
+ * Full Harpoon test layer for unit testing.
+ * All services use mock implementations that don't require Docker.
+ *
+ * @example
+ * ```typescript
+ * import { HarpoonTest } from '@docker-harpoon/core/services';
+ *
+ * const test = Effect.gen(function* () {
+ *   const docker = yield* DockerClient;
+ *   // Uses mock Docker client
+ * });
+ *
+ * Effect.runPromise(
+ *   test.pipe(Effect.provide(HarpoonTest))
+ * );
+ * ```
+ */
+export declare const HarpoonTest: Layer.Layer<CircuitBreaker | DockerBatcher | DockerClient | DockerRateLimiter | EventBus | HarpoonConfig | ReadinessCoordinator | ResourceTracker, never, never>;
+/**
+ * All services provided by HarpoonLive.
+ */
+export type HarpoonServices = HarpoonConfig | DockerRateLimiter | CircuitBreaker | DockerClient | DockerBatcher | ResourceTracker | EventBus | ReadinessCoordinator;
+/**
+ * Requirements for running a program with Harpoon.
+ * Use with Effect.provide(HarpoonLive) to satisfy.
+ */
+export type HarpoonRequirements = HarpoonServices;
+//# sourceMappingURL=Harpoon.d.ts.map

package/dist/services/Harpoon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Harpoon.d.ts","sourceRoot":"","sources":["../../src/services/Harpoon.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,KAAK,EAAU,MAAM,QAAQ,CAAC;AAGvC,OAAO,EAAE,aAAa,EAAwC,MAAM,iBAAiB,CAAC;AAItF,OAAO,EACL,iBAAiB,EAGlB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,cAAc,EAA0C,MAAM,kBAAkB,CAAC;AAG1F,OAAO,EAAE,YAAY,EAAsC,MAAM,gBAAgB,CAAC;AAClF,OAAO,EAAE,aAAa,EAAwC,MAAM,iBAAiB,CAAC;AAGtF,OAAO,EAAE,eAAe,EAA4C,MAAM,mBAAmB,CAAC;AAG9F,OAAO,EAAE,QAAQ,EAA8B,MAAM,YAAY,CAAC;AAClE,OAAO,EACL,oBAAoB,EAGrB,MAAM,wBAAwB,CAAC;AAIhC;;;GAGG;AACH,eAAO,MAAM,QAAQ,6EAAoB,CAAC;AAE1C;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,kGAE9B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,6HAAiD,CAAC;AAEzE;;;;GAIG;AACH,eAAO,MAAM,WAAW,8HAAoD,CAAC;AAE7E;;;;GAIG;AACH,eAAO,MAAM,aAAa,+EAAoD,CAAC;AAE/E;;;GAGG;AACH,eAAO,MAAM,UAAU,qCAAe,CAAC;AAEvC;;;GAGG;AACH,eAAO,MAAM,aAAa,iDAA2B,CAAC;AAEtD;;;;GAIG;AACH,eAAO,MAAM,YAAY,iHAA2D,CAAC;AAErF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,WAAW,sPAMvB,CAAC;AAIF;;GAEG;AACH,eAAO,MAAM,QAAQ,0CAAoB,CAAC;AAE1C;;GAEG;AACH,eAAO,MAAM,kBAAkB,+DAA4D,CAAC;AAE5F;;GAEG;AACH,eAAO,MAAM,UAAU,yCAAmB,CAAC;AAE3C;;GAEG;AACH,eAAO,MAAM,WAAW,0CAAoD,CAAC;AAE7E;;GAEG;AACH,eAAO,MAAM,aAAa,4CAAsB,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,UAAU,qCAAe,CAAC;AAEvC;;GAEG;AACH,eAAO,MAAM,aAAa,iDAA2B,CAAC;AAEtD;;GAEG;AACH,eAAO,MAAM,YAAY,8EAA2D,CAAC;AAErF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,WAAW,kKAMvB,CAAC;AAIF;;GAEG;AACH,MAAM,MAAM,eAAe,GACvB,aAAa,GACb,iBAAiB,GACjB,cAAc,GACd,YAAY,GACZ,aAAa,GACb,eAAe,GACf,QAAQ,GACR,oBAAoB,CAAC;AAEzB;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,eAAe,CAAC"}

package/dist/services/Harpoon.js

@@ -0,0 +1,148 @@
+/**
+ * Harpoon Unified Layer
+ *
+ * Provides pre-composed layers for all Harpoon services.
+ * Makes it easy to use Harpoon with a single layer provision.
+ */
+import { Layer } from 'effect';
+// Core services
+import { HarpoonConfigLive, HarpoonConfigTest } from './HarpoonConfig';
+// Infrastructure services
+import { DockerRateLimiterLive, DockerRateLimiterTest, } from './DockerRateLimiter';
+import { CircuitBreakerLive, CircuitBreakerTest } from './CircuitBreaker';
+// Docker services
+import { DockerClientLive, DockerClientTest } from './DockerClient';
+import { DockerBatcherLive, DockerBatcherTest } from './DockerBatcher';
+// Resource management
+import { ResourceTrackerLive, ResourceTrackerTest } from './ResourceTracker';
+// Event and coordination
+import { EventBusLive, EventBusTest } from './EventBus';
+import { ReadinessCoordinatorLive, ReadinessCoordinatorTest, } from './ReadinessCoordinator';
+// ============ Live Layers ============
+/**
+ * Core configuration layer.
+ * Provides HarpoonConfig.
+ */
+export const CoreLive = HarpoonConfigLive;
+/**
+ * Infrastructure layer with rate limiting and circuit breaker.
+ * Provides: DockerRateLimiter, CircuitBreaker
+ * Requires: HarpoonConfig
+ */
+export const InfrastructureLive = Layer.mergeAll(DockerRateLimiterLive, CircuitBreakerLive).pipe(Layer.provide(CoreLive));
+/**
+ * Docker client layer with all integrations.
+ * Provides: DockerClient
+ * Requires: HarpoonConfig, DockerRateLimiter
+ */
+export const DockerLive = DockerClientLive.pipe(Layer.provide(CoreLive));
+/**
+ * Batching layer for Docker requests.
+ * Provides: DockerBatcher
+ * Requires: DockerClient
+ */
+export const BatcherLive = DockerBatcherLive.pipe(Layer.provide(DockerLive));
+/**
+ * Resource management layer.
+ * Provides: ResourceTracker
+ * Requires: HarpoonConfig
+ */
+export const ResourcesLive = ResourceTrackerLive.pipe(Layer.provide(CoreLive));
+/**
+ * Event bus layer.
+ * Provides: EventBus
+ */
+export const EventsLive = EventBusLive;
+/**
+ * Readiness coordination layer.
+ * Provides: ReadinessCoordinator
+ */
+export const ReadinessLive = ReadinessCoordinatorLive;
+/**
+ * Services layer combining all coordination services.
+ * Provides: ResourceTracker, EventBus, ReadinessCoordinator
+ * Requires: HarpoonConfig
+ */
+export const ServicesLive = Layer.mergeAll(ResourcesLive, EventsLive, ReadinessLive);
+/**
+ * Full Harpoon layer for production use.
+ * Provides all services needed for Docker resource management.
+ *
+ * Includes:
+ * - HarpoonConfig
+ * - DockerRateLimiter
+ * - CircuitBreaker
+ * - DockerClient
+ * - DockerBatcher
+ * - ResourceTracker
+ * - EventBus
+ * - ReadinessCoordinator
+ *
+ * @example
+ * ```typescript
+ * import { HarpoonLive } from '@docker-harpoon/core/services';
+ *
+ * const program = Effect.gen(function* () {
+ *   const docker = yield* DockerClient;
+ *   const tracker = yield* ResourceTracker;
+ *   // ... use services
+ * });
+ *
+ * Effect.runPromise(
+ *   program.pipe(Effect.provide(HarpoonLive))
+ * );
+ * ```
+ */
+export const HarpoonLive = Layer.mergeAll(CoreLive, InfrastructureLive, DockerLive, BatcherLive, ServicesLive);
+// ============ Test Layers ============
+/**
+ * Core test configuration layer.
+ */
+export const CoreTest = HarpoonConfigTest;
+/**
+ * Infrastructure test layer.
+ */
+export const InfrastructureTest = Layer.mergeAll(DockerRateLimiterTest, CircuitBreakerTest);
+/**
+ * Docker client test layer.
+ */
+export const DockerTest = DockerClientTest;
+/**
+ * Batcher test layer.
+ */
+export const BatcherTest = DockerBatcherTest.pipe(Layer.provide(DockerTest));
+/**
+ * Resources test layer.
+ */
+export const ResourcesTest = ResourceTrackerTest;
+/**
+ * Events test layer.
+ */
+export const EventsTest = EventBusTest;
+/**
+ * Readiness test layer.
+ */
+export const ReadinessTest = ReadinessCoordinatorTest;
+/**
+ * Services test layer.
+ */
+export const ServicesTest = Layer.mergeAll(ResourcesTest, EventsTest, ReadinessTest);
+/**
+ * Full Harpoon test layer for unit testing.
+ * All services use mock implementations that don't require Docker.
+ *
+ * @example
+ * ```typescript
+ * import { HarpoonTest } from '@docker-harpoon/core/services';
+ *
+ * const test = Effect.gen(function* () {
+ *   const docker = yield* DockerClient;
+ *   // Uses mock Docker client
+ * });
+ *
+ * Effect.runPromise(
+ *   test.pipe(Effect.provide(HarpoonTest))
+ * );
+ * ```
+ */
+export const HarpoonTest = Layer.mergeAll(CoreTest, InfrastructureTest, DockerTest, BatcherTest, ServicesTest);