@livestore/utils-dev 0.4.0-dev.6 → 0.4.0-dev.8

package/dist/wrangler/mod.d.ts

@@ -0,0 +1,2 @@
+export { type StartWranglerDevServerArgs, type WranglerDevServer, WranglerDevServerError, WranglerDevServerService, } from './WranglerDevServer.ts';
+//# sourceMappingURL=mod.d.ts.map

package/dist/wrangler/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/wrangler/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,iBAAiB,EACtB,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,wBAAwB,CAAA"}

package/dist/wrangler/mod.js

@@ -0,0 +1,2 @@
+export { WranglerDevServerError, WranglerDevServerService, } from "./WranglerDevServer.js";
+//# sourceMappingURL=mod.js.map

package/dist/wrangler/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","sourceRoot":"","sources":["../../src/wrangler/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,wBAAwB,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livestore/utils-dev",
-  "version": "0.4.0-dev.6",
+  "version": "0.4.0-dev.8",
   "type": "module",
   "sideEffects": [
     "./src/node-vitest/global.ts",
@@ -8,18 +8,21 @@
   ],
   "exports": {
     "./node": "./dist/node/mod.js",
-    "./node-vitest": "./dist/node-vitest/mod.js"
+    "./node-vitest": "./dist/node-vitest/mod.js",
+    "./wrangler": "./dist/wrangler/mod.js"
   },
   "dependencies": {
-    "@effect/opentelemetry": "0.56.4",
+    "@effect/opentelemetry": "0.56.6",
     "@effect/vitest": "0.25.1",
+    "@iarna/toml": "2.2.5",
     "@opentelemetry/api": "1.9.0",
     "@opentelemetry/exporter-metrics-otlp-http": "0.203.0",
     "@opentelemetry/exporter-trace-otlp-http": "0.203.0",
     "@opentelemetry/sdk-metrics": "2.0.1",
     "@opentelemetry/sdk-trace-base": "2.0.1",
     "@opentelemetry/sdk-trace-node": "2.0.1",
-    "@livestore/utils": "0.4.0-dev.6"
+    "wrangler": "4.32.0",
+    "@livestore/utils": "0.4.0-dev.8"
   },
   "devDependencies": {},
   "files": [

package/src/node/DockerComposeService/DockerComposeService.ts

@@ -13,7 +13,7 @@ import {
 
 export class DockerComposeError extends Schema.TaggedError<DockerComposeError>()('DockerComposeError', {
   cause: Schema.Defect,
-  message: Schema.String,
+  note: Schema.String,
 }) {}
 
 export interface DockerComposeArgs {
@@ -43,6 +43,11 @@ export interface DockerComposeOperations {
     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>
@@ -67,7 +72,7 @@ export class DockerComposeService extends Effect.Service<DockerComposeService>()
               : Effect.fail(
                   new DockerComposeError({
                     cause: new Error(`Docker compose pull failed with exit code ${exitCode}`),
-                    message: `Docker compose pull failed with exit code ${exitCode}`,
+                    note: `Docker compose pull failed with exit code ${exitCode}`,
                   }),
                 ),
           ),
@@ -89,12 +94,14 @@ export class DockerComposeService extends Effect.Service<DockerComposeService>()
           const command = yield* Command.make(baseArgs[0]!, ...baseArgs.slice(1)).pipe(
             Command.workingDirectory(cwd),
             Command.env(options.env ?? {}),
+            Command.stderr('inherit'),
+            Command.stdout('inherit'),
             Command.start,
             Effect.catchAll((cause) =>
               Effect.fail(
                 new DockerComposeError({
                   cause,
-                  message: `Failed to start Docker Compose services in ${cwd}`,
+                  note: `Failed to start Docker Compose services in ${cwd}`,
                 }),
               ),
             ),
@@ -103,13 +110,13 @@ export class DockerComposeService extends Effect.Service<DockerComposeService>()
 
           // Wait for command completion
           yield* command.exitCode.pipe(
-            Effect.flatMap((exitCode: number) =>
+            Effect.flatMap((exitCode) =>
               exitCode === 0
                 ? Effect.void
                 : Effect.fail(
                     new DockerComposeError({
                       cause: new Error(`Docker compose exited with code ${exitCode}`),
-                      message: `Docker Compose failed to start with exit code ${exitCode}`,
+                      note: `Docker Compose failed to start with exit code ${exitCode}. Env: ${JSON.stringify(options.env)}`,
                     }),
                   ),
             ),
@@ -140,7 +147,7 @@ export class DockerComposeService extends Effect.Service<DockerComposeService>()
               : Effect.fail(
                   new DockerComposeError({
                     cause: new Error(`Docker compose stop exited with code ${exitCode}`),
-                    message: `Failed to stop Docker Compose services`,
+                    note: `Failed to stop Docker Compose services`,
                   }),
                 ),
           ),
@@ -167,7 +174,7 @@ export class DockerComposeService extends Effect.Service<DockerComposeService>()
               Effect.fail(
                 new DockerComposeError({
                   cause,
-                  message: `Failed to read Docker Compose logs in ${cwd}`,
+                  note: `Failed to read Docker Compose logs in ${cwd}`,
                 }),
               ),
             ),
@@ -181,13 +188,46 @@ export class DockerComposeService extends Effect.Service<DockerComposeService>()
               (cause) =>
                 new DockerComposeError({
                   cause,
-                  message: `Error reading Docker Compose logs in ${cwd}`,
+                  note: `Error reading Docker Compose logs in ${cwd}`,
                 }),
             ),
           )
         }).pipe(Stream.unwrapScoped)
 
-      return { pull, start, stop, logs }
+      const down = (options?: {
+        readonly env?: Record<string, string>
+        readonly volumes?: boolean
+        readonly removeOrphans?: boolean
+      }) =>
+        Effect.gen(function* () {
+          yield* Effect.log(`Tearing down Docker Compose services in ${cwd}`)
+
+          const baseArgs = ['docker', 'compose', 'down']
+          if (options?.volumes) baseArgs.push('-v')
+          if (options?.removeOrphans) baseArgs.push('--remove-orphans')
+          if (serviceName) baseArgs.push(serviceName)
+
+          yield* Command.make(baseArgs[0]!, ...baseArgs.slice(1)).pipe(
+            Command.workingDirectory(cwd),
+            Command.env(options?.env ?? {}),
+            Command.exitCode,
+            Effect.flatMap((exitCode: number) =>
+              exitCode === 0
+                ? Effect.void
+                : Effect.fail(
+                    new DockerComposeError({
+                      cause: new Error(`Docker compose down exited with code ${exitCode}`),
+                      note: `Failed to tear down Docker Compose services`,
+                    }),
+                  ),
+            ),
+            Effect.provide(commandExecutorContext),
+          )
+
+          yield* Effect.log(`Docker Compose services torn down successfully`)
+        }).pipe(Effect.withSpan('downDockerCompose'))
+
+      return { pull, start, stop, down, logs }
     }),
 }) {}
 
@@ -219,7 +259,7 @@ const performHealthCheck = ({
         Effect.fail(
           new DockerComposeError({
             cause: new Error('Health check timeout'),
-            message: `Health check failed for ${url} after ${Duration.toMillis(timeout)}ms`,
+            note: `Health check failed for ${url} after ${Duration.toMillis(timeout)}ms`,
           }),
         ),
       ),

package/src/node/mod.ts

@@ -24,13 +24,6 @@ export {
   startDockerComposeServicesScoped,
 } from './DockerComposeService/DockerComposeService.ts'
 export * as FileLogger from './FileLogger.ts'
-export * from './WranglerDevServer/process-tree-manager.ts'
-export {
-  type StartWranglerDevServerArgs,
-  type WranglerDevServer,
-  WranglerDevServerError,
-  WranglerDevServerService,
-} from './WranglerDevServer/WranglerDevServer.ts'
 
 export const OtelLiveHttp = ({
   serviceName,

package/src/node-vitest/Vitest.test.ts

@@ -96,6 +96,17 @@ Vitest.describe('Vitest.asProp', () => {
 
         return
       }),
-    { fastCheck: { numRuns: 5, endOnFailure: true }, fails: true },
+    {
+      fastCheck: {
+        numRuns: 5,
+        endOnFailure: true,
+        // Provide explicit samples so the second run crosses >50. Randomly drawing five
+        // integers has ~3% chance to stay ≤ 50, which would break the `fails: true`
+        // expectation even though shrinking remains disabled. The examples keep the
+        // demo readable while leaving the remaining runs to FastCheck.
+        examples: [[5], [66]],
+      },
+      fails: true,
+    },
   )
 })

package/src/node-vitest/Vitest.ts

@@ -20,25 +20,29 @@ export * from '@effect/vitest'
 
 export const DEBUGGER_ACTIVE = Boolean(process.env.DEBUGGER_ACTIVE ?? inspector.url() !== undefined)
 
-export const makeWithTestCtx: <R1, E1>(
-  ctxParams: WithTestCtxParams<R1, E1>,
-) => (
-  testContext: Vitest.TestContext,
-) => <A, E>(
-  self: Effect.Effect<A, E, Scope.Scope | NoInfer<R1> | OtelTracer.OtelTracer>,
-) => Effect.Effect<A, E1 | Cause.TimeoutException | E, Scope.Scope> =
-  (ctxParams) => (testContext: Vitest.TestContext) =>
-    withTestCtx(testContext, ctxParams)
-
-export type WithTestCtxParams<R1, E1> = {
+export const makeWithTestCtx: <ROut = never, E1 = never, RIn = never>(
+  ctxParams: WithTestCtxParams<ROut, E1, RIn>,
+) => (testContext: Vitest.TestContext) => <A, E, R>(
+  self: Effect.Effect<A, E, R>,
+) => Effect.Effect<
+  A,
+  E | E1 | Cause.TimeoutException,
+  // Exclude dependencies provided by `withTestCtx` from the layer dependencies
+  | Exclude<RIn, OtelTracer.OtelTracer | Scope.Scope>
+  // Exclude dependencies provided by `withTestCtx` **and** dependencies produced
+  // by the layer from the effect dependencies
+  | Exclude<R, ROut | OtelTracer.OtelTracer | Scope.Scope>
+> = (ctxParams) => (testContext: Vitest.TestContext) => withTestCtx(testContext, ctxParams)
+
+export type WithTestCtxParams<ROut, E1, RIn> = {
   suffix?: string
-  makeLayer?: (testContext: Vitest.TestContext) => Layer.Layer<R1, E1, Scope.Scope>
+  makeLayer?: (testContext: Vitest.TestContext) => Layer.Layer<ROut, E1, RIn | Scope.Scope>
   timeout?: Duration.DurationInput
   forceOtel?: boolean
 }
 
 export const withTestCtx =
-  <R1 = never, E1 = never>(
+  <ROut = never, E1 = never, RIn = never>(
     testContext: Vitest.TestContext,
     {
       suffix,
@@ -47,23 +51,31 @@ export const withTestCtx =
       forceOtel = false,
     }: {
       suffix?: string
-      makeLayer?: (testContext: Vitest.TestContext) => Layer.Layer<R1, E1, Scope.Scope>
+      makeLayer?: (testContext: Vitest.TestContext) => Layer.Layer<ROut, E1, RIn>
       timeout?: Duration.DurationInput
       forceOtel?: boolean
     } = {},
   ) =>
-  <A, E>(
-    self: Effect.Effect<A, E, Scope.Scope | OtelTracer.OtelTracer | R1>,
-  ): Effect.Effect<A, E | Cause.TimeoutException | E1, Scope.Scope> => {
+  <A, E, R>(
+    self: Effect.Effect<A, E, R>,
+  ): Effect.Effect<
+    A,
+    E | E1 | Cause.TimeoutException,
+    // Exclude dependencies provided internally from the provided layer's dependencies
+    | Exclude<RIn, OtelTracer.OtelTracer | Scope.Scope>
+    // Exclude dependencies provided internally **and** dependencies produced by the
+    // provided layer from the effect dependencies
+    | Exclude<R, ROut | OtelTracer.OtelTracer | Scope.Scope>
+  > => {
     const spanName = `${testContext.task.suite?.name}:${testContext.task.name}${suffix ? `:${suffix}` : ''}`
-    const layer = makeLayer?.(testContext)
+    const layer = makeLayer?.(testContext) ?? Layer.empty
 
     const otelLayer =
       DEBUGGER_ACTIVE || forceOtel
         ? OtelLiveHttp({ rootSpanName: spanName, serviceName: 'vitest-runner', skipLogUrl: false })
         : OtelLiveDummy
 
-    const combinedLayer = (layer ?? Layer.empty).pipe(Layer.provideMerge(otelLayer))
+    const combinedLayer = layer.pipe(Layer.provideMerge(otelLayer))
 
     return self.pipe(
       DEBUGGER_ACTIVE

package/src/wrangler/WranglerDevServer.test.ts

@@ -0,0 +1,133 @@
+import { Effect, FetchHttpClient, Layer } from '@livestore/utils/effect'
+import { getFreePort, PlatformNode } from '@livestore/utils/node'
+import { Vitest } from '@livestore/utils-dev/node-vitest'
+import { expect } from 'vitest'
+import {
+  type StartWranglerDevServerArgs,
+  WranglerDevServerError,
+  WranglerDevServerService,
+} from './WranglerDevServer.ts'
+
+const testTimeout = 60_000
+
+const WranglerDevServerTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
+  WranglerDevServerService.Default({
+    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> = {}) =>
+      Vitest.makeWithTestCtx({
+        timeout: testTimeout,
+        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+      })
+
+    Vitest.scopedLive('should start wrangler dev server and return port', (test) =>
+      Effect.gen(function* () {
+        const server = yield* WranglerDevServerService
+
+        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) =>
+      Effect.andThen(getFreePort, (port) =>
+        Effect.gen(function* () {
+          const server = yield* WranglerDevServerService
+
+          expect(server.port).toBe(port)
+          expect(server.url).toBe(`http://127.0.0.1:${port}`)
+        }).pipe(withBasicTest({ preferredPort: port })(test)),
+      ),
+    )
+  })
+
+  Vitest.describe('Error Handling', () => {
+    const withErrorTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
+      Vitest.makeWithTestCtx({
+        timeout: testTimeout,
+        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+      })
+
+    Vitest.scopedLive('should handle missing wrangler.toml but should timeout', (test) =>
+      Effect.gen(function* () {
+        const error = yield* WranglerDevServerService.pipe(
+          Effect.provide(
+            WranglerDevServerTest({
+              cwd: '/tmp',
+              wranglerConfigPath: '/dev/null',
+              connectTimeout: '500 millis',
+            }).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+          ),
+          Effect.flip,
+        )
+
+        expect(error).toBeInstanceOf(WranglerDevServerError)
+      }).pipe(Vitest.withTestCtx(test)),
+    )
+
+    Vitest.scopedLive('should handle invalid working directory', (test) =>
+      Effect.gen(function* () {
+        const result = yield* WranglerDevServerService.pipe(
+          Effect.provide(
+            WranglerDevServerTest({
+              cwd: '/completely/nonexistent/directory',
+            }).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+          ),
+          Effect.either,
+        )
+
+        expect(result._tag).toBe('Left')
+        if (result._tag === 'Left') {
+          expect(result.left).toBeInstanceOf(WranglerDevServerError)
+        }
+      }).pipe(Vitest.withTestCtx(test)),
+    )
+
+    Vitest.scopedLive('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(
+          // Override the timeout for this test to be shorter
+          Effect.timeout('5 seconds'),
+          Effect.either,
+        )
+
+        // This might succeed or fail depending on actual wrangler behavior
+        // The main point is testing timeout functionality
+        expect(['Left', 'Right']).toContain(result._tag)
+      }).pipe(withErrorTest()(test)),
+    )
+  })
+
+  Vitest.describe('Service Pattern', () => {
+    const withServiceTest = (args: Partial<StartWranglerDevServerArgs> = {}) =>
+      Vitest.makeWithTestCtx({
+        timeout: testTimeout,
+        makeLayer: () => WranglerDevServerTest(args).pipe(Layer.provide(PlatformNode.NodeContext.layer)),
+      })
+
+    Vitest.scopedLive('should work with service pattern', (test) =>
+      Effect.gen(function* () {
+        const server = yield* WranglerDevServerService
+
+        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) =>
+      Effect.andThen(getFreePort, (port) =>
+        Effect.gen(function* () {
+          const server = yield* WranglerDevServerService
+
+          expect(server.port).toBe(port)
+          expect(server.url).toBe(`http://127.0.0.1:${port}`)
+        }).pipe(withServiceTest({ preferredPort: port })(test)),
+      ),
+    )
+  })
+})

package/src/wrangler/WranglerDevServer.ts

@@ -0,0 +1,180 @@
+import * as path from 'node:path'
+import * as Toml from '@iarna/toml'
+import { IS_CI } from '@livestore/utils'
+import { Cause, Duration, Effect, FileSystem, HttpClient, 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>()('WranglerDevServerError', {
+  cause: Schema.Unknown,
+  message: Schema.String,
+  port: Schema.Number,
+}) {}
+
+/**
+ * WranglerDevServer instance interface
+ */
+export interface WranglerDevServer {
+  readonly port: number
+  readonly url: string
+  // readonly processId: number
+}
+
+/**
+ * Configuration for starting WranglerDevServer
+ */
+export interface StartWranglerDevServerArgs {
+  wranglerConfigPath?: string
+  cwd: string
+  /** The port to try first. The dev server may bind a different port if unavailable. */
+  preferredPort?: number
+  /** @default false */
+  showLogs?: boolean
+  inspectorPort?: number
+  connectTimeout?: Duration.DurationInput
+}
+
+/**
+ * WranglerDevServer as an Effect.Service.
+ *
+ * This service provides the WranglerDevServer properties and can be accessed
+ * directly to get port and url.
+ *
+ * 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 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 ? 'info' : 'none',
+          experimental: {
+            disableExperimentalWarning: true,
+          },
+        }),
+      )
+
+      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}`
+
+      // Use longer timeout in CI environments to account for slower startup times
+      const defaultTimeout = Duration.seconds(IS_CI ? 30 : 5)
+
+      yield* verifyHttpConnectivity({ url, showLogs, connectTimeout: args.connectTimeout ?? defaultTimeout })
+
+      if (showLogs) {
+        yield* Effect.logDebug(
+          `Wrangler dev server ready and accepting connections on port ${actualPort} (preferred: ${preferredPort})`,
+        )
+      }
+
+      return {
+        port: actualPort,
+        url,
+      } satisfies WranglerDevServer
+    }).pipe(
+      Effect.mapError(
+        (error) =>
+          new WranglerDevServerError({ cause: error, message: 'Failed to start wrangler dev server', port: -1 }),
+      ),
+      Effect.withSpan('WranglerDevServerService', {
+        attributes: { preferredPort: args.preferredPort ?? 'auto', cwd: args.cwd },
+      }),
+    ),
+}) {}
+
+/**
+ * Verifies the server is actually accepting HTTP connections by making a test request
+ */
+const verifyHttpConnectivity = ({
+  url,
+  showLogs,
+  connectTimeout,
+}: {
+  url: string
+  showLogs: boolean
+  connectTimeout: Duration.DurationInput
+}): Effect.Effect<void, WranglerDevServerError, HttpClient.HttpClient> =>
+  Effect.gen(function* () {
+    const client = yield* HttpClient.HttpClient
+
+    if (showLogs) {
+      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.tap(() => (showLogs ? Effect.logDebug(`HTTP connectivity verified for ${url}`) : Effect.void)),
+      Effect.asVoid,
+      Effect.withSpan('verifyHttpConnectivity'),
+    )
+  })

package/src/wrangler/mod.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"WranglerDevServer.d.ts","sourceRoot":"","sources":["../../../src/node/WranglerDevServer/WranglerDevServer.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,QAAQ,EACR,MAAM,EAEN,UAAU,EAGV,MAAM,EAEP,MAAM,yBAAyB,CAAA;;;;;;;;AAIhC;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,2BAI1C;CAAG;AAEL;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,qBAAqB;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,cAAc,CAAC,EAAE,QAAQ,CAAC,aAAa,CAAA;CACxC;;4BAYgB,0BAA0B;;;;;;AAV3C;;;;;;;;GAQG;AACH,qBAAa,wBAAyB,SAAQ,6BA6I5C;CAAG"}