@livestore/utils-dev 0.4.0-dev.2 → 0.4.0-dev.20

package/src/node/mod.ts

@@ -1,19 +1,9 @@
 import { performance } from 'node:perf_hooks'
 
 import * as OtelNodeSdk from '@effect/opentelemetry/NodeSdk'
-import { IS_BUN, isNonEmptyString, isNotUndefined, shouldNeverHappen } from '@livestore/utils'
-import type { CommandExecutor, PlatformError, Tracer } from '@livestore/utils/effect'
-import {
-  Command,
-  Config,
-  Effect,
-  FiberRef,
-  identity,
-  Layer,
-  LogLevel,
-  OtelTracer,
-  Schema,
-} from '@livestore/utils/effect'
+import { IS_BUN, isNonEmptyString } from '@livestore/utils'
+import type { Tracer } from '@livestore/utils/effect'
+import { Config, Effect, FiberRef, Layer, LogLevel, OtelTracer } from '@livestore/utils/effect'
 import { OtelLiveDummy } from '@livestore/utils/node'
 import * as otel from '@opentelemetry/api'
 import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http'
@@ -23,8 +13,18 @@ import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'
 
 export { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http'
 export { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'
-
+export * from './cmd.ts'
+export {
+  type DockerComposeArgs,
+  DockerComposeError,
+  type DockerComposeOperations,
+  DockerComposeService,
+  type LogsOptions,
+  type StartOptions,
+  startDockerComposeServicesScoped,
+} from './DockerComposeService/DockerComposeService.ts'
 export * as FileLogger from './FileLogger.ts'
+export * from './workspace.ts'
 
 export const OtelLiveHttp = ({
   serviceName,
@@ -105,10 +105,7 @@ export const OtelLiveHttp = ({
         const tracer = yield* OtelTracer.OtelTracer
         const currentSpan = yield* OtelTracer.currentOtelSpan
 
-        const nodeTiming = performance.nodeTiming
-
-        // TODO get rid of this workaround for Bun once Bun properly supports performance.nodeTiming
-        const startTime = IS_BUN ? nodeTiming.startTime : performance.timeOrigin + nodeTiming.nodeStart
+        const { nodeTiming, endAbs, durationAttr } = computeBootstrapTiming()
 
         const bootSpan = tracer.startSpan(
           'node-bootstrap',
@@ -119,13 +116,13 @@ export const OtelLiveHttp = ({
               'node.timing.environment': nodeTiming.environment,
               'node.timing.bootstrapComplete': nodeTiming.bootstrapComplete,
               'node.timing.loopStart': nodeTiming.loopStart,
-              'node.timing.duration': nodeTiming.duration,
+              'node.timing.duration': durationAttr,
             },
           },
           otel.trace.setSpanContext(otel.context.active(), currentSpan.spanContext()),
         )
 
-        bootSpan.end(startTime + nodeTiming.duration)
+        bootSpan.end(endAbs)
       }).pipe(Effect.provide(layer), Effect.orDie)
     }
 
@@ -170,99 +167,49 @@ export const getTracingBackendUrl = (span: otel.Span) =>
     return `${grafanaEndpoint}/explore?${searchParams.toString()}`
   })
 
-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'),
-}) {}
+/**
+ * Compute absolute start/end timestamps for the Node.js bootstrap span in a
+ * way that works in both Node and Bun.
+ *
+ * Context: Bun's perf_hooks PerformanceNodeTiming currently throws when
+ * accessing standard PerformanceEntry getters like `startTime` and
+ * `duration`, and some fields differ in semantics (e.g. `nodeStart` appears
+ * as an epoch timestamp rather than an offset). See:
+ * https://github.com/oven-sh/bun/issues/23041
+ *
+ * We therefore avoid the problematic getters and derive absolute timestamps
+ * using fields that exist in both runtimes.
+ *
+ * TODO: Simplify to a single, non-branching computation once the Bun issue
+ * above is fixed and Bun matches Node's semantics for PerformanceNodeTiming.
+ */
+const computeBootstrapTiming = () => {
+  const nodeTiming = performance.nodeTiming
+
+  // Absolute start time in ms since epoch.
+  const startAbs = IS_BUN
+    ? typeof nodeTiming.nodeStart === 'number'
+      ? nodeTiming.nodeStart
+      : performance.timeOrigin
+    : performance.timeOrigin + nodeTiming.nodeStart
+
+  // Absolute end time.
+  const endAbs = IS_BUN
+    ? (() => {
+        const { loopStart, bootstrapComplete } = nodeTiming
+        if (typeof loopStart === 'number' && loopStart > 0) return startAbs + loopStart
+        if (typeof bootstrapComplete === 'number' && bootstrapComplete >= startAbs) return bootstrapComplete
+        return startAbs + 1
+      })()
+    : startAbs + nodeTiming.duration
+
+  // Duration attribute value for the span.
+  const durationAttr = IS_BUN
+    ? (() => {
+        const { loopStart } = nodeTiming
+        return typeof loopStart === 'number' && loopStart > 0 ? loopStart : 0
+      })()
+    : nodeTiming.duration
+
+  return { nodeTiming, startAbs, endAbs, durationAttr } as const
+}

package/src/node/workspace.ts

@@ -0,0 +1,45 @@
+import path from 'node:path'
+import { shouldNeverHappen } from '@livestore/utils'
+import { Context, Effect, Layer } from '@livestore/utils/effect'
+
+export type WorkspaceInfo = string
+
+/** Current working directory. */
+export class CurrentWorkingDirectory extends Context.Tag('CurrentWorkingDirectory')<
+  CurrentWorkingDirectory,
+  WorkspaceInfo
+>() {
+  /** Layer that captures the process cwd once. */
+  static live = Layer.effect(
+    CurrentWorkingDirectory,
+    Effect.sync(() => process.cwd()),
+  )
+
+  /** Override CWD for tests or nested invocations. */
+  static fromPath = (cwd: string) => Layer.succeed(CurrentWorkingDirectory, cwd)
+}
+
+/** Livestore workspace root (env required). */
+export class LivestoreWorkspace extends Context.Tag('LivestoreWorkspace')<LivestoreWorkspace, WorkspaceInfo>() {
+  /** Resolve from WORKSPACE_ROOT env. */
+  static live = Layer.effect(
+    LivestoreWorkspace,
+    Effect.sync(() => {
+      const root = process.env.WORKSPACE_ROOT ?? shouldNeverHappen('WORKSPACE_ROOT is not set')
+      return root
+    }),
+  )
+
+  /** Provide a fixed Livestore root. */
+  static fromPath = (root: string) => Layer.succeed(LivestoreWorkspace, root)
+
+  /** Derive a CurrentWorkingDirectory layer from the Livestore workspace root (with optional subpath) */
+  static toCwd = (/** Relative path to the Livestore workspace root */ subPath?: string) =>
+    Layer.effect(
+      CurrentWorkingDirectory,
+      Effect.gen(function* () {
+        const root = yield* LivestoreWorkspace
+        return path.join(root, subPath ?? '')
+      }),
+    )
+}

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) {
+          return 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,
+  )
+}