@livestore/utils-dev 0.0.0-snapshot-dffcd59e9628b35efd943619b722cf924c4ed98f → 0.0.0-snapshot-1c345a0e6695466bdc7c4483444e7b3513620261

package/src/node/WranglerDevServer/process-tree-manager.ts

@@ -1,263 +0,0 @@
-import { Command, type CommandExecutor, Effect, Schema, type Scope, Stream } from '@livestore/utils/effect'
-
-export class ProcessTreeError extends Schema.TaggedError<ProcessTreeError>()('ProcessTreeError', {
-  cause: Schema.Unknown,
-  message: Schema.String,
-  pid: Schema.Number,
-}) {}
-
-/**
- * Finds all child processes of a given parent PID
- */
-export const findChildProcesses = (
-  parentPid: number,
-): Effect.Effect<number[], never, CommandExecutor.CommandExecutor | Scope.Scope> =>
-  Effect.gen(function* () {
-    const result = yield* Command.make('ps', '-o', 'pid,ppid', '-ax').pipe(
-      Command.start,
-      Effect.flatMap((command) =>
-        command.stdout.pipe(
-          Stream.decodeText('utf8'),
-          Stream.runCollect,
-          Effect.map((chunks) => Array.from(chunks).join('')),
-        ),
-      ),
-      Effect.catchAll(() => Effect.succeed('')), // Return empty string if command fails
-    )
-
-    if (!result) return []
-
-    const lines = result.split('\n')
-    const pattern = new RegExp(`^\\s*([0-9]+)\\s+${parentPid}\\s*$`)
-
-    const childPids = lines
-      .map((line) => {
-        const match = line.trim().match(pattern)
-        return match ? Number.parseInt(match[1]!, 10) : null
-      })
-      .filter((pid): pid is number => pid !== null)
-
-    return childPids
-  })
-
-/**
- * Recursively finds all descendants of a process
- */
-export const findProcessTree = (
-  rootPid: number,
-): Effect.Effect<number[], never, CommandExecutor.CommandExecutor | Scope.Scope> =>
-  Effect.gen(function* () {
-    const allPids = new Set<number>([rootPid])
-    const toProcess = [rootPid]
-
-    while (toProcess.length > 0) {
-      const currentPid = toProcess.pop()!
-      const children = yield* findChildProcesses(currentPid)
-
-      for (const childPid of children) {
-        if (!allPids.has(childPid)) {
-          allPids.add(childPid)
-          toProcess.push(childPid)
-        }
-      }
-    }
-
-    return Array.from(allPids)
-  })
-
-/**
- * Checks if a process is running
- */
-export const isProcessRunning = (pid: number): Effect.Effect<boolean, never, never> =>
-  Effect.sync(() => {
-    try {
-      process.kill(pid, 0)
-      return true
-    } catch {
-      return false
-    }
-  })
-
-/**
- * Kills a process tree with escalating signals
- */
-export const killProcessTree = (
-  rootPid: number,
-  options: {
-    timeout?: number
-    signals?: NodeJS.Signals[]
-    includeRoot?: boolean
-  } = {},
-): Effect.Effect<
-  { killedPids: number[]; failedPids: number[] },
-  never,
-  CommandExecutor.CommandExecutor | Scope.Scope
-> =>
-  Effect.gen(function* () {
-    const { timeout = 5000, signals = ['SIGTERM', 'SIGKILL'], includeRoot = true } = options
-
-    // Find all processes in the tree
-    const allPids = yield* findProcessTree(rootPid)
-    const pidsToKill = includeRoot ? allPids : allPids.filter((pid) => pid !== rootPid)
-
-    if (pidsToKill.length === 0) {
-      return { killedPids: [], failedPids: [] }
-    }
-
-    const killedPids: number[] = []
-    const failedPids: number[] = []
-
-    // Try each signal with timeout
-    for (const signal of signals) {
-      // Check which processes are still running and not yet killed
-      const stillRunningChecks = yield* Effect.all(
-        pidsToKill
-          .filter((pid) => !killedPids.includes(pid))
-          .map((pid) => isProcessRunning(pid).pipe(Effect.map((running) => ({ pid, running })))),
-      )
-      const remainingPids = stillRunningChecks.filter(({ running }) => running).map(({ pid }) => pid)
-
-      if (remainingPids.length === 0) break
-
-      // Send signal to all remaining processes
-      for (const pid of remainingPids) {
-        yield* Effect.sync(() => {
-          try {
-            process.kill(pid, signal)
-          } catch {
-            // Process might already be dead, continue
-          }
-        })
-      }
-
-      // Wait for processes to terminate with polling
-      const waitStart = Date.now()
-      while (Date.now() - waitStart < timeout) {
-        const runningChecks = yield* Effect.all(
-          remainingPids.map((pid) => isProcessRunning(pid).pipe(Effect.map((running) => ({ pid, running })))),
-        )
-        const stillRunning = runningChecks.filter(({ running }) => running).map(({ pid }) => pid)
-
-        if (stillRunning.length === 0) {
-          // All processes terminated
-          killedPids.push(...remainingPids)
-          break
-        }
-
-        // Short sleep before checking again
-        yield* Effect.sleep('100 millis')
-      }
-    }
-
-    // Check final status
-    const finalChecks = yield* Effect.all(
-      pidsToKill.map((pid) => isProcessRunning(pid).pipe(Effect.map((running) => ({ pid, running })))),
-    )
-
-    for (const { pid, running } of finalChecks) {
-      if (!killedPids.includes(pid) && running) {
-        failedPids.push(pid)
-      }
-    }
-
-    return { killedPids, failedPids }
-  })
-
-/**
- * Finds orphaned processes by name pattern
- */
-export const findOrphanedProcesses = (
-  namePattern: string,
-): Effect.Effect<number[], never, CommandExecutor.CommandExecutor | Scope.Scope> =>
-  Effect.gen(function* () {
-    // Find processes that match the pattern and have init (PID 1) as parent
-    const result = yield* Command.make('ps', '-eo', 'pid,ppid,comm').pipe(
-      Command.start,
-      Effect.flatMap((command) =>
-        command.stdout.pipe(
-          Stream.decodeText('utf8'),
-          Stream.runCollect,
-          Effect.map((chunks) => Array.from(chunks).join('')),
-        ),
-      ),
-      Effect.catchAll(() => Effect.succeed('')), // Return empty string if command fails
-    )
-
-    if (!result) return []
-
-    const lines = result.split('\n')
-    const patternRegex = new RegExp(namePattern)
-    const parentRegex = /^\s*(\d+)\s+1\s+/
-
-    const orphanedPids = lines
-      .filter((line) => patternRegex.test(line))
-      .map((line) => {
-        const match = line.trim().match(parentRegex)
-        return match ? Number.parseInt(match[1]!, 10) : null
-      })
-      .filter((pid): pid is number => pid !== null)
-
-    return orphanedPids
-  })
-
-/**
- * Defensive cleanup for orphaned processes matching given patterns.
- *
- * This function provides fallback cleanup for edge cases where normal process
- * termination mechanisms fail (e.g., hard crashes, SIGKILL before cleanup runs,
- * or limitations in synchronous exit handlers). While proper process tree cleanup
- * should prevent orphans in most cases, this serves as a safety net for scenarios
- * where child processes become orphaned despite cleanup efforts.
- *
- * @param processPatterns - Array of process name patterns to search for (e.g., ['wrangler', 'workerd'])
- * @returns Object with arrays of successfully cleaned and failed PIDs
- */
-export const cleanupOrphanedProcesses = (
-  processPatterns: string[],
-): Effect.Effect<{ cleaned: number[]; failed: number[] }, never, CommandExecutor.CommandExecutor | Scope.Scope> =>
-  Effect.gen(function* () {
-    const cleaned: number[] = []
-    const failed: number[] = []
-
-    // Find all orphaned processes matching the patterns
-    const allOrphanedPids: number[] = []
-    const patternCounts: Record<string, number> = {}
-
-    for (const pattern of processPatterns) {
-      const orphaned = yield* findOrphanedProcesses(pattern)
-      allOrphanedPids.push(...orphaned)
-      patternCounts[pattern] = orphaned.length
-    }
-
-    if (allOrphanedPids.length === 0) {
-      return { cleaned, failed }
-    }
-
-    const patternSummary = Object.entries(patternCounts)
-      .map(([pattern, count]) => `${count} ${pattern}`)
-      .join(', ')
-
-    yield* Effect.logInfo(
-      `Found ${allOrphanedPids.length} orphaned processes (${patternSummary}): ${allOrphanedPids.join(', ')}`,
-    )
-
-    for (const pid of allOrphanedPids) {
-      const result = yield* killProcessTree(pid, {
-        timeout: 2000,
-        signals: ['SIGTERM', 'SIGKILL'],
-        includeRoot: true,
-      }).pipe(Effect.orElse(() => Effect.succeed({ killedPids: [], failedPids: [pid] })))
-
-      if (result.failedPids.length === 0) {
-        cleaned.push(...result.killedPids)
-        yield* Effect.logInfo(
-          `Cleaned up orphaned process tree starting with ${pid} (${result.killedPids.length} processes)`,
-        )
-      } else {
-        failed.push(pid, ...result.failedPids)
-        yield* Effect.logWarning(`Failed to clean up some processes in tree ${pid}: ${result.failedPids.join(', ')}`)
-      }
-    }
-
-    return { cleaned, failed }
-  })

package/src/node/cmd.ts

@@ -1,99 +0,0 @@
-import { isNotUndefined, shouldNeverHappen } from '@livestore/utils'
-import { Command, type CommandExecutor, Effect, identity, type PlatformError, Schema } from '@livestore/utils/effect'
-
-export const cmd: (
-  commandInput: string | (string | undefined)[],
-  options?:
-    | {
-        cwd?: string
-        stderr?: 'inherit' | 'pipe'
-        stdout?: 'inherit' | 'pipe'
-        shell?: boolean
-        env?: Record<string, string | undefined>
-      }
-    | undefined,
-) => Effect.Effect<CommandExecutor.ExitCode, PlatformError.PlatformError | CmdError, CommandExecutor.CommandExecutor> =
-  Effect.fn('cmd')(function* (commandInput, options) {
-    const cwd = options?.cwd ?? process.env.WORKSPACE_ROOT ?? shouldNeverHappen('WORKSPACE_ROOT is not set')
-    const [command, ...args] = Array.isArray(commandInput)
-      ? commandInput.filter(isNotUndefined)
-      : commandInput.split(' ')
-
-    const debugEnvStr = Object.entries(options?.env ?? {})
-      .map(([key, value]) => `${key}='${value}' `)
-      .join('')
-    const subshellStr = options?.shell ? ' (in subshell)' : ''
-    const commandDebugStr = debugEnvStr + [command, ...args].join(' ')
-
-    yield* Effect.logDebug(`Running '${commandDebugStr}' in '${cwd}'${subshellStr}`)
-    yield* Effect.annotateCurrentSpan({ 'span.label': commandDebugStr, cwd, command, args })
-
-    return yield* Command.make(command!, ...args).pipe(
-      // TODO don't forward abort signal to the command
-      Command.stdin('inherit'), // Forward stdin to the command
-      // inherit = Stream stdout to process.stdout, pipe = Stream stdout to process.stderr
-      Command.stdout(options?.stdout ?? 'inherit'),
-      // inherit = Stream stderr to process.stderr, pipe = Stream stderr to process.stdout
-      Command.stderr(options?.stderr ?? 'inherit'),
-      Command.workingDirectory(cwd),
-      options?.shell ? Command.runInShell(true) : identity,
-      Command.env(options?.env ?? {}),
-      Command.exitCode,
-      Effect.tap((exitCode) =>
-        exitCode === 0
-          ? Effect.void
-          : Effect.fail(
-              CmdError.make({
-                command: command!,
-                args,
-                cwd,
-                env: options?.env ?? {},
-                stderr: options?.stderr ?? 'inherit',
-              }),
-            ),
-      ),
-    )
-  })
-
-export const cmdText: (
-  commandInput: string | (string | undefined)[],
-  options?: {
-    cwd?: string
-    stderr?: 'inherit' | 'pipe'
-    runInShell?: boolean
-    env?: Record<string, string | undefined>
-  },
-) => Effect.Effect<string, PlatformError.PlatformError, CommandExecutor.CommandExecutor> = Effect.fn('cmdText')(
-  function* (commandInput, options) {
-    const cwd = options?.cwd ?? process.env.WORKSPACE_ROOT ?? shouldNeverHappen('WORKSPACE_ROOT is not set')
-    const [command, ...args] = Array.isArray(commandInput)
-      ? commandInput.filter(isNotUndefined)
-      : commandInput.split(' ')
-    const debugEnvStr = Object.entries(options?.env ?? {})
-      .map(([key, value]) => `${key}='${value}' `)
-      .join('')
-
-    const commandDebugStr = debugEnvStr + [command, ...args].join(' ')
-    const subshellStr = options?.runInShell ? ' (in subshell)' : ''
-
-    yield* Effect.logDebug(`Running '${commandDebugStr}' in '${cwd}'${subshellStr}`)
-    yield* Effect.annotateCurrentSpan({ 'span.label': commandDebugStr, command, cwd })
-
-    return yield* Command.make(command!, ...args).pipe(
-      // inherit = Stream stderr to process.stderr, pipe = Stream stderr to process.stdout
-      Command.stderr(options?.stderr ?? 'inherit'),
-      Command.workingDirectory(cwd),
-      options?.runInShell ? Command.runInShell(true) : identity,
-      Command.env(options?.env ?? {}),
-      Command.string,
-    )
-  },
-)
-
-export class CmdError extends Schema.TaggedError<CmdError>()('CmdError', {
-  command: Schema.String,
-  args: Schema.Array(Schema.String),
-  cwd: Schema.String,
-  env: Schema.Record({ key: Schema.String, value: Schema.String.pipe(Schema.UndefinedOr) }),
-  stderr: Schema.Literal('inherit', 'pipe'),
-}) {}

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

@@ -1,101 +0,0 @@
-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 }, fails: true },
-  )
-})

package/src/node-vitest/Vitest.ts

@@ -1,221 +0,0 @@
-import * as inspector from 'node:inspector'
-import type * as Vitest from '@effect/vitest'
-import { IS_CI } from '@livestore/utils'
-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'
-
-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 type WithTestCtxParams<R1 = never, E1 = never> = {
-  suffix?: string
-  makeLayer?: (testContext: Vitest.TestContext) => Layer.Layer<R1, E1, Scope.Scope>
-  timeout?: Duration.DurationInput
-  forceOtel?: boolean
-}
-
-export const withTestCtx =
-  <R1 = never, E1 = never>(
-    testContext: Vitest.TestContext,
-    {
-      suffix,
-      makeLayer,
-      timeout = IS_CI ? 60_000 : 10_000,
-      forceOtel = false,
-    }: {
-      suffix?: string
-      makeLayer?: (testContext: Vitest.TestContext) => Layer.Layer<R1, E1, Scope.Scope>
-      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> => {
-    const spanName = `${testContext.task.suite?.name}:${testContext.task.name}${suffix ? `:${suffix}` : ''}`
-    const layer = makeLayer?.(testContext)
-
-    const otelLayer =
-      DEBUGGER_ACTIVE || forceOtel
-        ? OtelLiveHttp({ rootSpanName: spanName, serviceName: 'vitest-runner', skipLogUrl: false })
-        : OtelLiveDummy
-
-    const combinedLayer = (layer ?? Layer.empty).pipe(Layer.provideMerge(otelLayer))
-
-    return self.pipe(
-      DEBUGGER_ACTIVE
-        ? identity
-        : Effect.logWarnIfTakesLongerThan({
-            duration: Duration.toMillis(timeout) * 0.8,
-            label: `${spanName} approaching timeout (timeout: ${Duration.format(timeout)})`,
-          }),
-      DEBUGGER_ACTIVE ? identity : Effect.timeout(timeout),
-      Effect.provide(combinedLayer),
-      Effect.scoped, // We need to scope the effect manually here because otherwise the span is not closed
-      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,
-  )
-}