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

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

@@ -0,0 +1,112 @@
+import { Effect, FastCheck } from '@livestore/utils/effect'
+import * as Vitest from './Vitest.ts'
+
+// Demonstrate enhanced asProp functionality with clear shrinking progress
+// This showcases the fix for the "Run 26/6" bug and accurate shrinking detection
+
+Vitest.describe('Vitest.asProp', () => {
+  const IntArbitrary = FastCheck.integer({ min: 1, max: 100 })
+
+  // Always-passing test - should only show initial phase
+  Vitest.asProp(
+    Vitest.scopedLive,
+    'always-pass test (shows only initial runs)',
+    [IntArbitrary],
+    (properties, _ctx, enhanced) =>
+      Effect.gen(function* () {
+        const [value] = properties
+        if (value === undefined) {
+          return yield* Effect.fail(new Error('Value is undefined'))
+        }
+
+        console.log(
+          `✅ ALWAYS-PASS [${enhanced._tag.toUpperCase()}]: ` +
+            (enhanced._tag === 'initial'
+              ? `Run ${enhanced.runIndex + 1}/${enhanced.numRuns}`
+              : `Shrink #${enhanced.shrinkAttempt} (finding minimal counterexample)`) +
+            `, value=${value}, total=${enhanced.totalExecutions}`,
+        )
+
+        // This test always passes, so no shrinking will occur
+        return
+      }),
+    { fastCheck: { numRuns: 4 } },
+  )
+
+  // Failing test - should show initial + shrinking phases
+  let alreadyFailed = false
+  Vitest.asProp(
+    Vitest.scopedLive,
+    'failing test (shows initial runs + shrinking)',
+    [IntArbitrary],
+    (properties, ctx, enhanced) =>
+      Effect.gen(function* () {
+        const [value] = properties
+        if (value === undefined) {
+          return yield* Effect.fail(new Error('Value is undefined'))
+        }
+
+        const displayInfo =
+          enhanced._tag === 'initial'
+            ? `Run ${enhanced.runIndex + 1}/${enhanced.numRuns}`
+            : `Shrink #${enhanced.shrinkAttempt} (finding minimal counterexample)`
+
+        const status = value > 80 ? '💥' : '✅'
+        console.log(
+          `${status} FAILING-TEST [${enhanced._tag.toUpperCase()}]: ${displayInfo}, value=${value}, total=${enhanced.totalExecutions}`,
+        )
+
+        // Fail when value is greater than 80 to trigger shrinking
+        if (value > 80) {
+          alreadyFailed = true
+          return yield* Effect.fail(new Error(`Value ${value} is too large (> 80)`))
+        }
+
+        if (alreadyFailed && enhanced._tag === 'shrinking') {
+          ctx.skip("For the sake of this test, we don't want to fail but want to skip")
+          return
+        }
+
+        return
+      }),
+    { fastCheck: { numRuns: 3 } },
+  )
+
+  // Test with endOnFailure: true - should not show shrinking
+  Vitest.asProp(
+    Vitest.scopedLive,
+    'failing test with endOnFailure (no shrinking)',
+    [IntArbitrary],
+    (properties, _ctx, enhanced) =>
+      Effect.gen(function* () {
+        const [value] = properties
+        if (value === undefined) {
+          return yield* Effect.fail(new Error('Value is undefined'))
+        }
+
+        console.log(
+          `🚫 END-ON-FAILURE [${enhanced._tag.toUpperCase()}]: ` +
+            `Run ${enhanced.runIndex + 1}/${enhanced.numRuns}, value=${value}, total=${enhanced.totalExecutions}`,
+        )
+
+        // This will fail but shrinking is disabled
+        if (value > 50) {
+          yield* Effect.fail(new Error(`Value ${value} is too large (> 50) - but no shrinking!`))
+        }
+
+        return
+      }),
+    {
+      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

@@ -1,7 +1,18 @@
 import * as inspector from 'node:inspector'
 import type * as Vitest from '@effect/vitest'
 import { IS_CI } from '@livestore/utils'
-import { type Cause, Duration, Effect, identity, Layer, type OtelTracer, type Scope } from '@livestore/utils/effect'
+import {
+  type Cause,
+  Duration,
+  Effect,
+  type FastCheck as FC,
+  identity,
+  Layer,
+  type OtelTracer,
+  Predicate,
+  type Schema,
+  type Scope,
+} from '@livestore/utils/effect'
 import { OtelLiveDummy } from '@livestore/utils/node'
 import { OtelLiveHttp } from '../node/mod.ts'
 
@@ -9,20 +20,29 @@ export * from '@effect/vitest'
 
 export const DEBUGGER_ACTIVE = Boolean(process.env.DEBUGGER_ACTIVE ?? inspector.url() !== undefined)
 
-export const makeWithTestCtx =
-  <R1 = never, E1 = never>(ctxParams: WithTestCtxParams<R1, E1>) =>
-  (testContext: Vitest.TestContext) =>
-    withTestCtx(testContext, ctxParams)
+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<R1 = never, E1 = never> = {
+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,
@@ -31,19 +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({ serviceName: 'vitest-runner', skipLogUrl: false }) : OtelLiveDummy
+      DEBUGGER_ACTIVE || forceOtel
+        ? OtelLiveHttp({ rootSpanName: spanName, serviceName: 'vitest-runner', skipLogUrl: false })
+        : OtelLiveDummy
+
+    const combinedLayer = layer.pipe(Layer.provideMerge(otelLayer))
 
     return self.pipe(
       DEBUGGER_ACTIVE
@@ -53,10 +85,154 @@ export const withTestCtx =
             label: `${spanName} approaching timeout (timeout: ${Duration.format(timeout)})`,
           }),
       DEBUGGER_ACTIVE ? identity : Effect.timeout(timeout),
-      Effect.provide(otelLayer),
-      Effect.provide(layer ?? Layer.empty),
+      Effect.provide(combinedLayer),
       Effect.scoped, // We need to scope the effect manually here because otherwise the span is not closed
-      Effect.withSpan(spanName),
       Effect.annotateLogs({ suffix }),
     ) as any
   }
+
+/**
+ * Shared properties for all enhanced test context phases
+ */
+export interface EnhancedTestContextBase {
+  numRuns: number
+  /** 0-based index */
+  runIndex: number
+  /** Total number of executions including initial runs and shrinking attempts */
+  totalExecutions: number
+}
+
+/**
+ * Enhanced context for property-based tests that includes shrinking phase information
+ */
+export type EnhancedTestContext =
+  | (EnhancedTestContextBase & {
+      _tag: 'initial'
+    })
+  | (EnhancedTestContextBase & {
+      _tag: 'shrinking'
+      /** Number of shrinking attempts */
+      shrinkAttempt: number
+    })
+
+/**
+ * Normalizes propOptions to ensure @effect/vitest receives correct fastCheck structure
+ */
+const normalizePropOptions = <Arbs extends Vitest.Vitest.Arbitraries>(
+  propOptions:
+    | number
+    | (Vitest.TestOptions & {
+        fastCheck?: FC.Parameters<{
+          [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]>
+        }>
+      }),
+): Vitest.TestOptions & {
+  fastCheck?: FC.Parameters<{
+    [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]>
+  }>
+} => {
+  // If it's a number, treat as timeout and add our default fastCheck
+  if (!Predicate.isObject(propOptions)) {
+    return {
+      timeout: propOptions,
+      fastCheck: { numRuns: 100 },
+    }
+  }
+
+  // If no fastCheck property, add it with our default numRuns
+  if (!propOptions.fastCheck) {
+    return {
+      ...propOptions,
+      fastCheck: { numRuns: 100 },
+    }
+  }
+
+  // If fastCheck exists but no numRuns, add our default
+  if (propOptions.fastCheck && !propOptions.fastCheck.numRuns) {
+    return {
+      ...propOptions,
+      fastCheck: {
+        ...propOptions.fastCheck,
+        numRuns: 100,
+      },
+    }
+  }
+
+  // If everything is properly structured, pass through
+  return propOptions
+}
+
+/**
+ * Equivalent to Vitest.prop but provides enhanced context including shrinking progress visibility
+ *
+ * This function enhances the standard property-based testing by providing clear information about
+ * whether FastCheck is in the initial testing phase or the shrinking phase, solving the confusion
+ * where tests show "Run 26/6" when FastCheck's shrinking algorithm is active.
+ *
+ * TODO: allow for upper timelimit instead of / additional to `numRuns`
+ *
+ * TODO: Upstream to Effect
+ */
+export const asProp = <Arbs extends Vitest.Vitest.Arbitraries, A, E, R>(
+  api: Vitest.Vitest.Tester<R>,
+  name: string,
+  arbitraries: Arbs,
+  test: Vitest.Vitest.TestFunction<
+    A,
+    E,
+    R,
+    [
+      { [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]> },
+      Vitest.TestContext,
+      EnhancedTestContext,
+    ]
+  >,
+  propOptions:
+    | number
+    | (Vitest.TestOptions & {
+        fastCheck?: FC.Parameters<{
+          [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Schema.Schema.Type<Arbs[K]>
+        }>
+      }),
+) => {
+  const normalizedPropOptions = normalizePropOptions(propOptions)
+  const numRuns = normalizedPropOptions.fastCheck?.numRuns ?? 100
+  let runIndex = 0
+  let shrinkAttempts = 0
+  let totalExecutions = 0
+
+  return api.prop(
+    name,
+    arbitraries,
+    (properties, ctx) => {
+      if (ctx.signal.aborted) {
+        return ctx.skip('Test aborted')
+      }
+
+      totalExecutions++
+      const isInShrinkingPhase = runIndex >= numRuns
+
+      if (isInShrinkingPhase) {
+        shrinkAttempts++
+      }
+
+      const enhancedContext: EnhancedTestContext = isInShrinkingPhase
+        ? {
+            _tag: 'shrinking',
+            numRuns,
+            runIndex: runIndex++,
+            shrinkAttempt: shrinkAttempts,
+            totalExecutions,
+          }
+        : {
+            _tag: 'initial',
+            numRuns,
+            runIndex: runIndex++,
+            totalExecutions,
+          }
+
+      return test(properties, ctx, enhancedContext)
+    },
+    normalizedPropOptions,
+  )
+}

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 ? 'debug' : '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/fixtures/cf-worker.ts

@@ -0,0 +1,11 @@
+export default {
+  async fetch(_request: Request): Promise<Response> {
+    return new Response('Hello from Wrangler Dev Server test worker!')
+  },
+}
+
+export class TestDO {
+  async fetch(_request: Request): Promise<Response> {
+    return new Response('Hello from Test Durable Object!')
+  }
+}

package/src/wrangler/fixtures/wrangler.toml

@@ -0,0 +1,11 @@
+name = "wrangler-dev-server-test"
+main = "./cf-worker.ts"
+compatibility_date = "2024-05-12"
+
+[[durable_objects.bindings]]
+name = "TEST_DO"
+class_name = "TestDO"
+
+[[migrations]]
+tag = "v1"
+new_sqlite_classes = ["TestDO"]