@livestore/utils-dev 0.4.0 → 0.5.0-dev.0

package/src/wrangler/WranglerDevServer.test.ts

@@ -1,44 +1,40 @@
 import { expect } from 'vitest'
 
 import { Vitest } from '@livestore/utils-dev/node-vitest'
-import { Effect, FetchHttpClient, Layer } from '@livestore/utils/effect'
+import { Effect, FetchHttpClient, Layer, Result } from '@livestore/utils/effect'
 import { getFreePort, PlatformNode } from '@livestore/utils/node'
 
-import {
-  type StartWranglerDevServerArgs,
-  WranglerDevServerError,
-  WranglerDevServerService,
-} from './WranglerDevServer.ts'
+import * as WranglerDevServer from './WranglerDevServer.ts'
 
 const testTimeout = 60_000
 
-const WranglerDevServerTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
-  WranglerDevServerService.Default({
+const WranglerDevServerTest = (args: Partial<WranglerDevServer.Options> = {}) =>
+  WranglerDevServer.layer({
     cwd: `${import.meta.dirname}/fixtures`,
     ...args,
   }).pipe(Layer.provide(FetchHttpClient.layer))
 
 Vitest.describe('WranglerDevServer', { timeout: testTimeout }, () => {
   Vitest.describe('Basic Operations', () => {
-    const withBasicTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
+    const withBasicTest = (args: Partial<WranglerDevServer.Options> = {}) =>
       Vitest.makeWithTestCtx({
         timeout: testTimeout,
-        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeServices.layer)),
       })
 
-    Vitest.scopedLive('should start wrangler dev server and return port', (test) =>
+    Vitest.live('should start wrangler dev server and return port', (test) =>
       Effect.gen(function* () {
-        const server = yield* WranglerDevServerService
+        const server = yield* WranglerDevServer.WranglerDevServer
 
         expect(server.port).toBeGreaterThan(0)
         expect(server.url).toMatch(/http:\/\/127.0.0.1:\d+/)
       }).pipe(withBasicTest()(test)),
     )
 
-    Vitest.scopedLive('should use specified port when provided', (test) =>
+    Vitest.live('should use specified port when provided', (test) =>
       Effect.andThen(getFreePort, (port) =>
         Effect.gen(function* () {
-          const server = yield* WranglerDevServerService
+          const server = yield* WranglerDevServer.WranglerDevServer
 
           expect(server.port).toBe(port)
           expect(server.url).toBe(`http://127.0.0.1:${port}`)
@@ -48,83 +44,83 @@ Vitest.describe('WranglerDevServer', { timeout: testTimeout }, () => {
   })
 
   Vitest.describe('Error Handling', () => {
-    const withErrorTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
+    const withErrorTest = (args: Partial<WranglerDevServer.Options> = {}) =>
       Vitest.makeWithTestCtx({
         timeout: testTimeout,
-        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeServices.layer)),
       })
 
-    Vitest.scopedLive('should handle missing wrangler.toml but should timeout', (test) =>
+    Vitest.live('should handle missing wrangler.toml but should timeout', (test) =>
       Effect.gen(function* () {
-        const error = yield* WranglerDevServerService.pipe(
+        const error = yield* WranglerDevServer.WranglerDevServer.pipe(
           Effect.provide(
             WranglerDevServerTest({
               cwd: '/tmp',
               wranglerConfigPath: '/dev/null',
               readiness: { connectTimeout: '500 millis' },
-            }).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+            }).pipe(Layer.provide(PlatformNode.NodeServices.layer)),
           ),
           Effect.flip,
         )
 
-        expect(error).toBeInstanceOf(WranglerDevServerError)
+        expect(error).toBeInstanceOf(WranglerDevServer.WranglerDevServerError)
       }).pipe(Vitest.withTestCtx(test)),
     )
 
-    Vitest.scopedLive('should handle invalid working directory', (test) =>
+    Vitest.live('should handle invalid working directory', (test) =>
       Effect.gen(function* () {
-        const result = yield* WranglerDevServerService.pipe(
+        const result = yield* WranglerDevServer.WranglerDevServer.pipe(
           Effect.provide(
             WranglerDevServerTest({
               cwd: '/completely/nonexistent/directory',
-            }).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+            }).pipe(Layer.provide(PlatformNode.NodeServices.layer)),
           ),
-          Effect.either,
+          Effect.result,
         )
 
-        expect(result._tag).toBe('Left')
-        if (result._tag === 'Left') {
-          expect(result.left).toBeInstanceOf(WranglerDevServerError)
+        expect(result._tag).toBe('Failure')
+        if (result._tag === 'Failure') {
+          expect(result.failure).toBeInstanceOf(WranglerDevServer.WranglerDevServerError)
         }
       }).pipe(Vitest.withTestCtx(test)),
     )
 
-    Vitest.scopedLive('should timeout if server fails to start', (test) =>
+    Vitest.live('should timeout if server fails to start', (test) =>
       Effect.gen(function* () {
         // Create a command that will never output "Ready on"
-        const result = yield* WranglerDevServerService.pipe(
+        const result = yield* WranglerDevServer.WranglerDevServer.pipe(
           // Override the timeout for this test to be shorter
           Effect.timeout('5 seconds'),
-          Effect.either,
+          Effect.result,
         )
 
         // This might succeed or fail depending on actual wrangler behavior
         // The main point is testing timeout functionality
-        expect(['Left', 'Right']).toContain(result._tag)
+        expect(['Failure', 'Success']).toContain(result._tag)
       }).pipe(withErrorTest()(test)),
     )
   })
 
   Vitest.describe('Service Pattern', () => {
-    const withServiceTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
+    const withServiceTest = (args: Partial<WranglerDevServer.Options> = {}) =>
       Vitest.makeWithTestCtx({
         timeout: testTimeout,
-        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeServices.layer)),
       })
 
-    Vitest.scopedLive('should work with service pattern', (test) =>
+    Vitest.live('should work with service pattern', (test) =>
       Effect.gen(function* () {
-        const server = yield* WranglerDevServerService
+        const server = yield* WranglerDevServer.WranglerDevServer
 
         expect(server.port).toBeGreaterThan(0)
         expect(server.url).toMatch(/http:\/\/127.0.0.1:\d+/)
       }).pipe(withServiceTest()(test)),
     )
 
-    Vitest.scopedLive('should work with custom port via service', (test) =>
+    Vitest.live('should work with custom port via service', (test) =>
       Effect.andThen(getFreePort, (port) =>
         Effect.gen(function* () {
-          const server = yield* WranglerDevServerService
+          const server = yield* WranglerDevServer.WranglerDevServer
 
           expect(server.port).toBe(port)
           expect(server.url).toBe(`http://127.0.0.1:${port}`)

package/src/wrangler/WranglerDevServer.ts

@@ -1,24 +1,37 @@
 import * as path from 'node:path'
 
 import * as Toml from '@iarna/toml'
+import * as wrangler from 'wrangler'
+
 import { IS_CI } from '@livestore/utils'
-import { Cause, Duration, Effect, FileSystem, HttpClient, Schedule, Schema } from '@livestore/utils/effect'
+import {
+  Cause,
+  Context,
+  Duration,
+  Effect,
+  FileSystem,
+  HttpClient,
+  Layer,
+  Schedule,
+  Schema,
+} from '@livestore/utils/effect'
 import { getFreePort } from '@livestore/utils/node'
-import * as wrangler from 'wrangler'
 
 /**
  * Error type for WranglerDevServer operations
  */
-export class WranglerDevServerError extends Schema.TaggedError<WranglerDevServerError>('~@livestore/utils-dev/WranglerDevServerError')('WranglerDevServerError', {
-  cause: Schema.Unknown,
+export class WranglerDevServerError extends Schema.TaggedError<WranglerDevServerError>(
+  '~@livestore/utils-dev/WranglerDevServerError',
+)('WranglerDevServerError', {
+  cause: Schema.Defect(),
   message: Schema.String,
-  port: Schema.Number,
+  port: Schema.Finite,
 }) {}
 
 /**
  * WranglerDevServer instance interface
  */
-export interface WranglerDevServer {
+export interface Service {
   readonly port: number
   readonly url: string
   // readonly processId: number
@@ -34,14 +47,14 @@ export interface WranglerDevServer {
  */
 export interface WranglerReadinessOptions {
   /** Max time to wait for wrangler to report ready before retrying. */
-  startupTimeout?: Duration.DurationInput
+  startupTimeout?: Duration.Input
   /** Max time for the HTTP connectivity check after wrangler reports ready. */
-  connectTimeout?: Duration.DurationInput
+  connectTimeout?: Duration.Input
   /** Retry policy for startup attempts (applies when startupTimeout elapses or wrangler throws). */
   retrySchedule?: Schedule.Schedule<unknown>
 }
 
-export interface StartWranglerDevServerArgs {
+export interface Options {
   /** Path to wrangler.toml (defaults to cwd/wrangler.toml). */
   wranglerConfigPath?: string
   /** Working directory wrangler should use. */
@@ -57,7 +70,7 @@ export interface StartWranglerDevServerArgs {
 }
 
 /**
- * WranglerDevServer as an Effect.Service.
+ * WranglerDevServer as an Effect service.
  *
  * This service provides the WranglerDevServer properties and can be accessed
  * directly to get port and url.
@@ -65,118 +78,127 @@ export interface StartWranglerDevServerArgs {
  * TODO: Allow for config to be passed in via code instead of `wrangler.toml` file
  * (would need to be placed in temporary file as wrangler only accepts files as config)
  */
-export class WranglerDevServerService extends Effect.Service<WranglerDevServerService>()('WranglerDevServerService', {
-  scoped: (args: StartWranglerDevServerArgs) =>
-    Effect.gen(function* () {
-      const showLogs = args.showLogs ?? false
-
-      // Allocate preferred port (Wrangler may bind a different one if unavailable)
-      const preferredPort =
-        args.preferredPort ??
-        (yield* getFreePort.pipe(
-          Effect.mapError(
-            (cause) => new WranglerDevServerError({ cause, message: 'Failed to get free port', port: -1 }),
-          ),
-        ))
-
-      yield* Effect.annotateCurrentSpan({ preferredPort })
-
-      const configPath = path.resolve(args.wranglerConfigPath ?? path.join(args.cwd, 'wrangler.toml'))
-
-      const fs = yield* FileSystem.FileSystem
-      const configContent = yield* fs.readFileString(configPath)
-      const parsedConfig = yield* Effect.try(() => Toml.parse(configContent)).pipe(
-        Effect.andThen(Schema.decodeUnknown(Schema.Struct({ main: Schema.String }))),
-        Effect.mapError(
-          (error) => new WranglerDevServerError({ cause: error, message: 'Failed to parse wrangler config', port: -1 }),
-        ),
-      )
-      const resolvedMainPath = yield* Effect.try(() => path.resolve(args.cwd, parsedConfig.main))
-
-      const readiness = args.readiness ?? {}
-      const startupTimeout = readiness.startupTimeout ?? Duration.seconds(IS_CI === true ? 30 : 10)
-      const devServer = yield* Effect.promise(() =>
-        wrangler.unstable_dev(resolvedMainPath, {
-          config: configPath,
-          port: preferredPort,
-          inspectorPort: args.inspectorPort ?? 0,
-          persistTo: path.join(args.cwd, '.wrangler/state'),
-          logLevel: showLogs === true ? 'debug' : 'none',
-          experimental: {
-            disableExperimentalWarning: true,
-          },
-        }),
-      ).pipe(
-        Effect.timeout(startupTimeout),
-        Effect.mapError(
-          (cause) =>
-            new WranglerDevServerError({
-              cause,
-              message: `Failed to start wrangler dev server within ${Duration.format(startupTimeout)}`,
-              port: preferredPort,
-            }),
-        ),
-        Effect.tapError((error) =>
-          Effect.logError('Wrangler dev server failed to start', {
-            message: error.message,
-            preferredPort,
-            cwd: args.cwd,
-          }),
-        ),
-        Effect.retry(readiness.retrySchedule ?? Schedule.recurs(1)),
-      )
+export class WranglerDevServer extends Context.Service<WranglerDevServer, Service>()(
+  '@livestore/utils-dev/WranglerDevServer',
+) {}
 
-      yield* Effect.addFinalizer(
-        Effect.fn(
-          function* (exit) {
-            if (exit._tag === 'Failure' && Cause.isInterruptedOnly(exit.cause) === false) {
-              yield* Effect.logError('Closing wrangler dev server on failure', exit.cause)
-            }
-
-            yield* Effect.tryPromise(async () => {
-              await devServer.stop()
-              // TODO investigate whether we need to wait until exit (see workers-sdk repo/talk to Cloudflare team)
-              // await devServer.waitUntilExit()
-            })
-          },
-          Effect.timeout('5 seconds'),
-          Effect.orDie,
-          Effect.tapCauseLogPretty,
-          Effect.withSpan('WranglerDevServerService:stopDevServer'),
-        ),
-      )
-
-      const actualPort = devServer.port
-      const actualHost = devServer.address
-      const url = `http://${actualHost}:${actualPort}`
+export const make = (args: Options) =>
+  Effect.gen(function* () {
+    const showLogs = args.showLogs ?? false
 
-      // Use longer timeout in CI environments to account for slower HTTP readiness
-      const defaultConnectivityTimeout = Duration.seconds(IS_CI === true ? 30 : 5)
-      const connectivityTimeout = readiness.connectTimeout ?? defaultConnectivityTimeout
+    // Allocate preferred port (Wrangler may bind a different one if unavailable)
+    const preferredPort =
+      args.preferredPort ??
+      (yield* getFreePort.pipe(
+        Effect.mapError((cause) => new WranglerDevServerError({ cause, message: 'Failed to get free port', port: -1 })),
+      ))
 
-      yield* verifyHttpConnectivity({ url, showLogs, connectTimeout: connectivityTimeout })
+    yield* Effect.annotateCurrentSpan({ preferredPort })
 
-      if (showLogs === true) {
-        yield* Effect.logDebug(
-          `Wrangler dev server ready and accepting connections on port ${actualPort} (preferred: ${preferredPort})`,
-        )
-      }
+    const configPath = path.resolve(args.wranglerConfigPath ?? path.join(args.cwd, 'wrangler.toml'))
 
-      return {
-        port: actualPort,
-        url,
-      } satisfies WranglerDevServer
+    const fs = yield* FileSystem.FileSystem
+    const configContent = yield* fs.readFileString(configPath)
+    const parsedConfig = yield* Effect.try({
+      try: () => Toml.parse(configContent),
+      catch: (cause) => new Cause.UnknownError(cause),
     }).pipe(
-      Effect.mapError((error) =>
-        error instanceof WranglerDevServerError
-          ? error
-          : new WranglerDevServerError({ cause: error, message: 'Failed to start wrangler dev server', port: -1 }),
+      Effect.andThen(Schema.decodeUnknownEffect(Schema.Struct({ main: Schema.String }))),
+      Effect.mapError(
+        (error) => new WranglerDevServerError({ cause: error, message: 'Failed to parse wrangler config', port: -1 }),
       ),
-      Effect.withSpan('WranglerDevServerService', {
-        attributes: { preferredPort: args.preferredPort ?? 'auto', cwd: args.cwd },
+    )
+    const resolvedMainPath = yield* Effect.try({
+      try: () => path.resolve(args.cwd, parsedConfig.main),
+      catch: (cause) => new Cause.UnknownError(cause),
+    })
+
+    const readiness = args.readiness ?? {}
+    const startupTimeout = readiness.startupTimeout ?? Duration.seconds(IS_CI === true ? 30 : 10)
+    const startupTimeoutDuration = Duration.fromInputUnsafe(startupTimeout)
+    const devServer = yield* Effect.promise(() =>
+      wrangler.unstable_dev(resolvedMainPath, {
+        config: configPath,
+        port: preferredPort,
+        inspectorPort: args.inspectorPort ?? 0,
+        persistTo: path.join(args.cwd, '.wrangler/state'),
+        logLevel: showLogs === true ? 'debug' : 'none',
+        experimental: {
+          disableExperimentalWarning: true,
+        },
       }),
+    ).pipe(
+      Effect.timeout(startupTimeout),
+      Effect.mapError(
+        (cause) =>
+          new WranglerDevServerError({
+            cause,
+            message: `Failed to start wrangler dev server within ${Duration.format(startupTimeoutDuration)}`,
+            port: preferredPort,
+          }),
+      ),
+      Effect.tapError((error) =>
+        Effect.logError('Wrangler dev server failed to start', {
+          message: error.message,
+          preferredPort,
+          cwd: args.cwd,
+        }),
+      ),
+      Effect.retry(readiness.retrySchedule ?? Schedule.recurs(1)),
+    )
+
+    yield* Effect.addFinalizer(
+      Effect.fn(
+        function* (exit) {
+          if (exit._tag === 'Failure' && Cause.hasInterruptsOnly(exit.cause) === false) {
+            yield* Effect.logError('Closing wrangler dev server on failure', exit.cause)
+          }
+
+          yield* Effect.tryPromise(async () => {
+            await devServer.stop()
+            // TODO investigate whether we need to wait until exit (see workers-sdk repo/talk to Cloudflare team)
+            // await devServer.waitUntilExit()
+          })
+        },
+        Effect.timeout('5 seconds'),
+        Effect.orDie,
+        Effect.tapCauseLogPretty,
+        Effect.withSpan('WranglerDevServer:stopDevServer'),
+      ),
+    )
+
+    const actualPort = devServer.port
+    const actualHost = devServer.address
+    const url = `http://${actualHost}:${actualPort}`
+
+    // Use longer timeout in CI environments to account for slower HTTP readiness
+    const defaultConnectivityTimeout = Duration.seconds(IS_CI === true ? 30 : 5)
+    const connectivityTimeout = readiness.connectTimeout ?? defaultConnectivityTimeout
+
+    yield* verifyHttpConnectivity({ url, showLogs, connectTimeout: connectivityTimeout })
+
+    if (showLogs === true) {
+      yield* Effect.logDebug(
+        `Wrangler dev server ready and accepting connections on port ${actualPort} (preferred: ${preferredPort})`,
+      )
+    }
+
+    return WranglerDevServer.of({
+      port: actualPort,
+      url,
+    })
+  }).pipe(
+    Effect.mapError((error) =>
+      error instanceof WranglerDevServerError
+        ? error
+        : new WranglerDevServerError({ cause: error, message: 'Failed to start wrangler dev server', port: -1 }),
     ),
-}) {}
+    Effect.withSpan('WranglerDevServer', {
+      attributes: { preferredPort: args.preferredPort ?? 'auto', cwd: args.cwd },
+    }),
+  )
+
+export const layer = (options: Options) => Layer.effect(WranglerDevServer, make(options))
 
 /**
  * Verifies the server is actually accepting HTTP connections by making a test request
@@ -188,7 +210,7 @@ const verifyHttpConnectivity = ({
 }: {
   url: string
   showLogs: boolean
-  connectTimeout: Duration.DurationInput
+  connectTimeout: Duration.Input
 }): Effect.Effect<void, WranglerDevServerError, HttpClient.HttpClient> =>
   Effect.gen(function* () {
     const client = yield* HttpClient.HttpClient
@@ -197,22 +219,16 @@ const verifyHttpConnectivity = ({
       yield* Effect.logDebug(`Verifying HTTP connectivity to ${url}`)
     }
 
-    // Try to connect with retries using exponential backoff
     yield* client.get(url).pipe(
-      Effect.retryOrElse(
-        Schedule.exponential('50 millis', 2).pipe(
-          Schedule.jittered,
-          Schedule.intersect(Schedule.elapsed.pipe(Schedule.whileOutput(Duration.lessThanOrEqualTo(connectTimeout)))),
-          Schedule.compose(Schedule.count),
-        ),
-        (error, attemptCount) =>
-          Effect.fail(
-            new WranglerDevServerError({
-              cause: error,
-              message: `Failed to establish HTTP connection to Wrangler server at ${url} after ${attemptCount} attempts (timeout: ${Duration.toMillis(connectTimeout)}ms)`,
-              port: 0,
-            }),
-          ),
+      Effect.retry(Schedule.exponential('50 millis', 2).pipe(Schedule.jittered)),
+      Effect.timeout(connectTimeout),
+      Effect.mapError(
+        (error) =>
+          new WranglerDevServerError({
+            cause: error,
+            message: `Failed to establish HTTP connection to Wrangler server at ${url} (timeout: ${Duration.toMillis(Duration.fromInputUnsafe(connectTimeout))}ms)`,
+            port: 0,
+          }),
       ),
       Effect.tap(() => (showLogs === true ? Effect.logDebug(`HTTP connectivity verified for ${url}`) : Effect.void)),
       Effect.asVoid,

package/src/wrangler/mod.ts

@@ -1,6 +1 @@
-export {
-  type StartWranglerDevServerArgs,
-  type WranglerDevServer,
-  WranglerDevServerError,
-  WranglerDevServerService,
-} from './WranglerDevServer.ts'
+export * as WranglerDevServer from './WranglerDevServer.ts'

package/dist/node/DockerComposeService/DockerComposeService.d.ts

@@ -1,63 +0,0 @@
-import { type CommandExecutor, Duration, Effect, type PlatformError, Schema, type Scope, Stream } from '@livestore/utils/effect';
-declare const DockerComposeError_base: Schema.TaggedErrorClass<DockerComposeError, "DockerComposeError", {
-    readonly _tag: Schema.tag<"DockerComposeError">;
-} & {
-    cause: typeof Schema.Defect;
-    note: typeof Schema.String;
-}>;
-export declare class DockerComposeError extends DockerComposeError_base {
-}
-export interface DockerComposeArgs {
-    readonly cwd: string;
-    readonly serviceName?: string;
-    /** Unique project name to isolate this compose instance. If not provided, a random one is generated. */
-    readonly projectName?: string;
-}
-export interface StartOptions {
-    readonly detached?: boolean;
-    readonly env?: Record<string, string>;
-    readonly healthCheck?: {
-        readonly url: string;
-        readonly timeout?: Duration.Duration;
-        readonly interval?: Duration.Duration;
-    };
-}
-export interface LogsOptions {
-    readonly follow?: boolean;
-    readonly tail?: number;
-    readonly since?: string;
-}
-export interface DockerComposeOperations {
-    readonly pull: Effect.Effect<void, DockerComposeError | PlatformError.PlatformError>;
-    readonly start: (options?: StartOptions) => Effect.Effect<void, DockerComposeError | PlatformError.PlatformError, Scope.Scope>;
-    readonly stop: Effect.Effect<void, DockerComposeError | PlatformError.PlatformError>;
-    readonly down: (options?: {
-        readonly env?: Record<string, string>;
-        readonly volumes?: boolean;
-        readonly removeOrphans?: boolean;
-    }) => Effect.Effect<void, DockerComposeError | PlatformError.PlatformError>;
-    readonly logs: (options?: LogsOptions) => Stream.Stream<string, DockerComposeError | PlatformError.PlatformError, Scope.Scope>;
-    /** The unique project name used to isolate this compose instance */
-    readonly projectName: string;
-}
-declare const DockerComposeService_base: Effect.Service.Class<DockerComposeService, "DockerComposeService", {
-    readonly scoped: (args: DockerComposeArgs) => Effect.Effect<{
-        pull: Effect.Effect<undefined, PlatformError.PlatformError | DockerComposeError, never>;
-        start: (options?: StartOptions | undefined) => Effect.Effect<void, PlatformError.PlatformError | DockerComposeError, Scope.Scope>;
-        stop: Effect.Effect<void, PlatformError.PlatformError | DockerComposeError, never>;
-        down: (options?: {
-            readonly env?: Record<string, string>;
-            readonly volumes?: boolean;
-            readonly removeOrphans?: boolean;
-        } | undefined) => Effect.Effect<void, PlatformError.PlatformError | DockerComposeError, never>;
-        logs: (options?: LogsOptions) => Stream.Stream<string, DockerComposeError, never>;
-        projectName: string;
-    }, never, Scope.Scope | CommandExecutor.CommandExecutor>;
-}>;
-export declare class DockerComposeService extends DockerComposeService_base {
-}
-export declare const startDockerComposeServicesScoped: (args: DockerComposeArgs & {
-    healthCheck?: StartOptions["healthCheck"];
-}) => Effect.Effect<void, DockerComposeError | PlatformError.PlatformError, DockerComposeService | CommandExecutor.CommandExecutor | Scope.Scope>;
-export {};
-//# sourceMappingURL=DockerComposeService.d.ts.map

package/dist/node/DockerComposeService/DockerComposeService.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"DockerComposeService.d.ts","sourceRoot":"","sources":["../../../src/node/DockerComposeService/DockerComposeService.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,eAAe,EACpB,QAAQ,EACR,MAAM,EAEN,KAAK,aAAa,EAElB,MAAM,EACN,KAAK,KAAK,EACV,MAAM,EACP,MAAM,yBAAyB,CAAA;;;;;;;AAEhC,qBAAa,kBAAmB,SAAQ,uBAGtC;CAAG;AAEL,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,wGAAwG;IACxG,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACrC,QAAQ,CAAC,WAAW,CAAC,EAAE;QACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;QACpB,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAA;QACpC,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAA;KACtC,CAAA;CACF;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,kBAAkB,GAAG,aAAa,CAAC,aAAa,CAAC,CAAA;IACpF,QAAQ,CAAC,KAAK,EAAE,CACd,OAAO,CAAC,EAAE,YAAY,KACnB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,kBAAkB,GAAG,aAAa,CAAC,aAAa,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;IACvF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,kBAAkB,GAAG,aAAa,CAAC,aAAa,CAAC,CAAA;IACpF,QAAQ,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE;QACxB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;QACrC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;QAC1B,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAA;KACjC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,kBAAkB,GAAG,aAAa,CAAC,aAAa,CAAC,CAAA;IAC3E,QAAQ,CAAC,IAAI,EAAE,CACb,OAAO,CAAC,EAAE,WAAW,KAClB,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,GAAG,aAAa,CAAC,aAAa,EAAE,KAAK,CAAC,KAAK,CAAC,CAAA;IACzF,oEAAoE;IACpE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B;;4BAKgB,iBAAiB;;;;;2BAiLX,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;+BAClB,OAAO;qCACD,OAAO;;yBAvCX,WAAW;;;;AA7IxC,qBAAa,oBAAqB,SAAQ,yBA6NxC;CAAG;AAwCL,eAAO,MAAM,gCAAgC,GAC3C,MAAM,iBAAiB,GAAG;IACxB,WAAW,CAAC,EAAE,YAAY,CAAC,aAAa,CAAC,CAAA;CAC1C,KACA,MAAM,CAAC,MAAM,CACd,IAAI,EACJ,kBAAkB,GAAG,aAAa,CAAC,aAAa,EAChD,oBAAoB,GAAG,eAAe,CAAC,eAAe,GAAG,KAAK,CAAC,KAAK,CAYlE,CAAA"}