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

package/src/node/mod.ts

@@ -1,29 +1,27 @@
 import { performance } from 'node:perf_hooks'
 
-import * as OtelNodeSdk from '@effect/opentelemetry/NodeSdk'
 import * as otel from '@opentelemetry/api'
-import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http'
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'
-import { PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics'
-import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'
-
-import { IS_BUN, isNonEmptyString } from '@livestore/utils'
-import type { Tracer } from '@livestore/utils/effect'
-import { Config, Effect, FiberRef, Layer, LogLevel, OtelTracer, Schema } from '@livestore/utils/effect'
+
+import { IS_BUN } from '@livestore/utils'
+import {
+  type Tracer,
+  Config,
+  Context,
+  Effect,
+  Exit,
+  FetchHttpClient,
+  Layer,
+  Option,
+  OtelTracer,
+  Otlp,
+  Schema,
+} from '@livestore/utils/effect'
 import { OtelLiveDummy } from '@livestore/utils/node'
 
 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 * from './DockerCompose/mod.ts'
 export * as FileLogger from './FileLogger.ts'
 export * from './workspace.ts'
 
@@ -41,62 +39,45 @@ export const OtelLiveHttp = ({
   rootSpanAttributes?: Record<string, unknown>
   skipLogUrl?: boolean
   traceNodeBootstrap?: boolean
-} = {}): Layer.Layer<OtelTracer.OtelTracer | Tracer.ParentSpan> =>
+} = {}): Layer.Layer<OtelTracer.OtelTracer | Tracer.Tracer | Tracer.ParentSpan> =>
   Effect.gen(function* () {
     const configRes = yield* Config.all({
-      exporterUrl: Config.string('OTEL_EXPORTER_OTLP_ENDPOINT').pipe(
-        Config.validate({ message: 'OTEL_EXPORTER_OTLP_ENDPOINT must be set', validation: isNonEmptyString }),
-      ),
-      serviceName: serviceName !== undefined
-        ? Config.succeed(serviceName)
-        : Config.string('OTEL_SERVICE_NAME').pipe(Config.withDefault('livestore-utils-dev')),
-      rootSpanName: rootSpanName !== undefined
-        ? Config.succeed(rootSpanName)
-        : Config.string('OTEL_ROOT_SPAN_NAME').pipe(Config.withDefault('RootSpan')),
+      exporterUrl: Config.NonEmptyString('OTEL_EXPORTER_OTLP_ENDPOINT'),
+      serviceName:
+        serviceName !== undefined
+          ? Config.succeed(serviceName)
+          : Config.String('OTEL_SERVICE_NAME').pipe(Config.withDefault('livestore-utils-dev')),
+      rootSpanName:
+        rootSpanName !== undefined
+          ? Config.succeed(rootSpanName)
+          : Config.String('OTEL_ROOT_SPAN_NAME').pipe(Config.withDefault('RootSpan')),
     }).pipe(Effect.option)
 
     if (configRes._tag === 'None') {
       const RootSpanLive = Layer.span('DummyRoot', {})
-      return RootSpanLive.pipe(Layer.provideMerge(OtelLiveDummy)) as any
+      return withTracerReference(RootSpanLive.pipe(Layer.provideMerge(OtelLiveDummy)))
     }
 
     const config = configRes.value
 
-    const resource = { serviceName: config.serviceName }
-
-    const metricReader = new PeriodicExportingMetricReader({
-      exporter: new OTLPMetricExporter({ url: `${config.exporterUrl}/v1/metrics` }),
-      exportIntervalMillis: 1000,
-    })
-
-    const OtelLive = OtelNodeSdk.layer(() => ({
-      resource,
-      metricReader,
-      spanProcessor: new BatchSpanProcessor(
-        new OTLPTraceExporter({ url: `${config.exporterUrl}/v1/traces`, headers: {} }),
-        { scheduledDelayMillis: 50 },
-      ),
-    })).pipe(
-      // If an OpenTelemetry backend is not available, the `OtelNodeSdk` layer
-      // will ignore the error when attempting to connect and emit a debug log
-      // stating the reason for the error (in this case `ECONNREFUSED`). This
-      // can cause problems for programs which rely on clean `stdout` (e.g.
-      // command-line applications). To remedy this, the below code sets the
-      // minimum log level `FiberRef` to `"None"` for the duration of the
-      // `OtelNodeSdk`'s layer constructor.
-      //
-      // This can likely be removed when Livestore is migrated to the Effect
-      // native Otlp exporters.
-      Layer.locally(FiberRef.currentMinimumLogLevel, LogLevel.None),
-    )
+    const OtelLive = Otlp.layerJson({
+      baseUrl: config.exporterUrl,
+      metricsExportInterval: 1000,
+      tracerExportInterval: 50,
+      resource: { serviceName: config.serviceName },
+    }).pipe(Layer.provide(FetchHttpClient.layer))
+    const OtelTracerLive = Layer.succeed(OtelTracer.OtelTracer, otel.trace.getTracer(config.serviceName))
 
     const RootSpanLive = Layer.span(config.rootSpanName, {
       attributes: { config, ...rootSpanAttributes },
-      onEnd: skipLogUrl === true ? undefined : (span: any) => logTraceUiUrlForSpan()(span.span),
+      onEnd: skipLogUrl === true ? undefined : (span) => logTraceUiUrlForTraceId()(span.traceId),
       parent: parentSpan,
     })
 
-    const layer = yield* Layer.memoize(RootSpanLive.pipe(Layer.provideMerge(OtelLive)))
+    const baseLayer = RootSpanLive.pipe(Layer.provideMerge(Layer.mergeAll(OtelLive, OtelTracerLive)))
+
+    const memoMap = yield* Layer.makeMemoMap
+    const layer = Layer.fromBuild((_, scope) => Layer.buildWithMemoMap(baseLayer, memoMap, scope))
 
     if (traceNodeBootstrap === true && IS_BUN === false) {
       /**
@@ -104,35 +85,48 @@ export const OtelLiveHttp = ({
        * Note: Skipped in Bun since performance.nodeTiming is not properly supported.
        */
       yield* Effect.gen(function* () {
-        const tracer = yield* OtelTracer.OtelTracer
-        const currentSpan = yield* OtelTracer.currentOtelSpan
+        const tracer = yield* Effect.tracer
+        const currentSpan = yield* Effect.currentSpan
 
         const { nodeTiming, endAbs, durationAttr } = computeBootstrapTiming()
 
-        const bootSpan = tracer.startSpan(
-          'node-bootstrap',
-          {
-            startTime: nodeTiming.nodeStart,
-            attributes: {
-              'node.timing.nodeStart': nodeTiming.nodeStart,
-              'node.timing.environment': nodeTiming.environment,
-              'node.timing.bootstrapComplete': nodeTiming.bootstrapComplete,
-              'node.timing.loopStart': nodeTiming.loopStart,
-              'node.timing.duration': durationAttr,
-            },
-          },
-          otel.trace.setSpanContext(otel.context.active(), currentSpan.spanContext()),
-        )
-
-        bootSpan.end(endAbs)
+        const bootSpan = tracer.span({
+          name: 'node-bootstrap',
+          parent: Option.some(currentSpan),
+          annotations: Context.empty(),
+          links: [],
+          startTime: millisToNanos(
+            IS_BUN === true && typeof nodeTiming.nodeStart === 'number'
+              ? nodeTiming.nodeStart
+              : performance.timeOrigin + nodeTiming.nodeStart,
+          ),
+          kind: 'internal',
+          root: false,
+          sampled: true,
+        })
+
+        for (const [key, value] of Object.entries({
+          'node.timing.nodeStart': nodeTiming.nodeStart,
+          'node.timing.environment': nodeTiming.environment,
+          'node.timing.bootstrapComplete': nodeTiming.bootstrapComplete,
+          'node.timing.loopStart': nodeTiming.loopStart,
+          'node.timing.duration': durationAttr,
+        })) {
+          if (value !== undefined) bootSpan.attribute(key, value)
+        }
+
+        bootSpan.end(millisToNanos(endAbs), Exit.void)
       }).pipe(Effect.provide(layer), Effect.orDie)
     }
 
-    return layer
-  }).pipe(Layer.unwrapScoped) as any
+    return withTracerReference(layer)
+  }).pipe(Layer.unwrap)
 
 export const logTraceUiUrlForSpan = (printMsg?: (url: string) => string) => (span: otel.Span) =>
-  getTracingBackendUrl(span).pipe(
+  logTraceUiUrlForTraceId(printMsg)(span.spanContext().traceId)
+
+const logTraceUiUrlForTraceId = (printMsg?: (url: string) => string) => (traceId: string) =>
+  getTracingBackendUrl(traceId).pipe(
     Effect.tap((url) => {
       if (url === undefined) {
         return Effect.logWarning('No tracing backend url found')
@@ -146,21 +140,21 @@ export const logTraceUiUrlForSpan = (printMsg?: (url: string) => string) => (spa
     }),
   )
 
-export const getTracingBackendUrl = (span: otel.Span) =>
+export const getTracingBackendUrl = (traceIdOrSpan: string | otel.Span) =>
   Effect.gen(function* () {
-    const endpoint = yield* Config.string('GRAFANA_ENDPOINT').pipe(Config.option, Effect.orDie)
+    const endpoint = yield* Config.String('GRAFANA_ENDPOINT').pipe(Config.option)
     if (endpoint._tag === 'None') return
 
-    const traceId = span.spanContext().traceId
+    const traceId = typeof traceIdOrSpan === 'string' ? traceIdOrSpan : traceIdOrSpan.spanContext().traceId
 
     // Grafana + Tempo
 
     const grafanaEndpoint = endpoint.value
-    const left = yield* Schema.encode(Schema.parseJson())({
+    const left = yield* Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown))({
       datasource: 'tempo',
       queries: [{ query: traceId, queryType: 'traceql', refId: 'A' }],
       range: { from: 'now-1h', to: 'now' },
-    }).pipe(Effect.orDie)
+    })
     const searchParams = new URLSearchParams({
       orgId: '1',
       left,
@@ -168,7 +162,7 @@ export const getTracingBackendUrl = (span: otel.Span) =>
 
     // TODO make dynamic via env var
     return `${grafanaEndpoint}/explore?${searchParams.toString()}`
-  })
+  }).pipe(Effect.orDie)
 
 /**
  * Compute absolute start/end timestamps for the Node.js bootstrap span in a
@@ -190,29 +184,43 @@ const computeBootstrapTiming = () => {
   const nodeTiming = performance.nodeTiming
 
   // Absolute start time in ms since epoch.
-  const startAbs = IS_BUN === true
-    ? typeof nodeTiming.nodeStart === 'number'
-      ? nodeTiming.nodeStart
-      : performance.timeOrigin
-    : performance.timeOrigin + nodeTiming.nodeStart
+  const startAbs =
+    IS_BUN === true
+      ? typeof nodeTiming.nodeStart === 'number'
+        ? nodeTiming.nodeStart
+        : performance.timeOrigin
+      : performance.timeOrigin + nodeTiming.nodeStart
 
   // Absolute end time.
-  const endAbs = IS_BUN === true
-    ? (() => {
-        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
+  const endAbs =
+    IS_BUN === true
+      ? (() => {
+          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 === true
-    ? (() => {
-        const { loopStart } = nodeTiming
-        return typeof loopStart === 'number' && loopStart > 0 ? loopStart : 0
-      })()
-    : nodeTiming.duration
+  const durationAttr =
+    IS_BUN === true
+      ? (() => {
+          const { loopStart } = nodeTiming
+          return typeof loopStart === 'number' && loopStart > 0 ? loopStart : 0
+        })()
+      : nodeTiming.duration
 
   return { nodeTiming, startAbs, endAbs, durationAttr } as const
 }
+
+const millisToNanos = (millis: number): bigint => BigInt(Math.round(millis * 1_000_000))
+
+/**
+ * Effect v4 installs `Tracer.Tracer` through a `Context.Reference` fiber ref.
+ * The OTEL layers set that reference at runtime, but their layer output type is
+ * `never`, so we localize the public compatibility assertion here.
+ */
+const withTracerReference = <ROut, E, RIn>(
+  layer: Layer.Layer<ROut, E, RIn>,
+): Layer.Layer<ROut | Tracer.Tracer, E, RIn> => layer as Layer.Layer<ROut | Tracer.Tracer, E, RIn>

package/src/node/workspace.ts

@@ -6,33 +6,32 @@ import { Context, Effect, Layer } from '@livestore/utils/effect'
 export type WorkspaceInfo = string
 
 /** Current working directory. */
-export class CurrentWorkingDirectory extends Context.Tag('CurrentWorkingDirectory')<
-  CurrentWorkingDirectory,
-  WorkspaceInfo
->() {
+export class CurrentWorkingDirectory extends Context.Service<CurrentWorkingDirectory, WorkspaceInfo>()(
+  'CurrentWorkingDirectory',
+) {
   /** Layer that captures the process cwd once. */
   static live = Layer.effect(
     CurrentWorkingDirectory,
-    Effect.sync(() => process.cwd()),
+    Effect.sync(() => CurrentWorkingDirectory.of(process.cwd())),
   )
 
   /** Override CWD for tests or nested invocations. */
-  static fromPath = (cwd: string) => Layer.succeed(CurrentWorkingDirectory, cwd)
+  static fromPath = (cwd: string) => Layer.succeed(CurrentWorkingDirectory, CurrentWorkingDirectory.of(cwd))
 }
 
 /** Livestore workspace root (env required). */
-export class LivestoreWorkspace extends Context.Tag('LivestoreWorkspace')<LivestoreWorkspace, WorkspaceInfo>() {
+export class LivestoreWorkspace extends Context.Service<LivestoreWorkspace, WorkspaceInfo>()('LivestoreWorkspace') {
   /** 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
+      return LivestoreWorkspace.of(root)
     }),
   )
 
   /** Provide a fixed Livestore root. */
-  static fromPath = (root: string) => Layer.succeed(LivestoreWorkspace, root)
+  static fromPath = (root: string) => Layer.succeed(LivestoreWorkspace, LivestoreWorkspace.of(root))
 
   /** Derive a CurrentWorkingDirectory layer from the Livestore workspace root (with optional subpath) */
   static toCwd = (/** Relative path to the Livestore workspace root */ subPath?: string) =>
@@ -40,7 +39,7 @@ export class LivestoreWorkspace extends Context.Tag('LivestoreWorkspace')<Livest
       CurrentWorkingDirectory,
       Effect.gen(function* () {
         const root = yield* LivestoreWorkspace
-        return path.join(root, subPath ?? '')
+        return CurrentWorkingDirectory.of(path.join(root, subPath ?? ''))
       }),
     )
 }

package/src/node-vitest/Vitest.ts

@@ -3,18 +3,7 @@ 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 { type Cause, Duration, Effect, identity, Layer, type OtelTracer, type Scope } from '@livestore/utils/effect'
 import { OtelLiveDummy } from '@livestore/utils/node'
 
 import { OtelLiveHttp } from '../node/mod.ts'
@@ -23,24 +12,27 @@ export * from '@effect/vitest'
 
 export const DEBUGGER_ACTIVE = Boolean(process.env.DEBUGGER_ACTIVE ?? inspector.url() !== undefined)
 
+type WithoutTestCtxServices<R> = Exclude<Exclude<R, OtelTracer.OtelTracer>, Scope.Scope>
+type WithoutLayerAndTestCtxServices<R, ROut> = Exclude<Exclude<R, ROut | OtelTracer.OtelTracer>, Scope.Scope>
+
 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,
+  E | E1 | Cause.TimeoutError,
   // Exclude dependencies provided by `withTestCtx` from the layer dependencies
-  | Exclude<RIn, OtelTracer.OtelTracer | Scope.Scope>
+  | WithoutTestCtxServices<RIn>
   // Exclude dependencies provided by `withTestCtx` **and** dependencies produced
   // by the layer from the effect dependencies
-  | Exclude<R, ROut | OtelTracer.OtelTracer | Scope.Scope>
+  | WithoutLayerAndTestCtxServices<R, ROut>
 > = (ctxParams) => (testContext: Vitest.TestContext) => withTestCtx(testContext, ctxParams)
 
 export type WithTestCtxParams<ROut, E1, RIn> = {
   suffix?: string
   makeLayer?: (testContext: Vitest.TestContext) => Layer.Layer<ROut, E1, RIn | Scope.Scope>
-  timeout?: Duration.DurationInput
+  timeout?: Duration.Input
   forceOtel?: boolean
 }
 
@@ -54,8 +46,8 @@ export const withTestCtx =
       forceOtel = false,
     }: {
       suffix?: string
-      makeLayer?: (testContext: Vitest.TestContext) => Layer.Layer<ROut, E1, RIn>
-      timeout?: Duration.DurationInput
+      makeLayer?: (testContext: Vitest.TestContext) => Layer.Layer<ROut, E1, RIn | Scope.Scope>
+      timeout?: Duration.Input
       forceOtel?: boolean
     } = {},
   ) =>
@@ -63,15 +55,19 @@ export const withTestCtx =
     self: Effect.Effect<A, E, R>,
   ): Effect.Effect<
     A,
-    E | E1 | Cause.TimeoutException,
+    E | E1 | Cause.TimeoutError,
     // Exclude dependencies provided internally from the provided layer's dependencies
-    | Exclude<RIn, OtelTracer.OtelTracer | Scope.Scope>
+    | WithoutTestCtxServices<RIn>
     // Exclude dependencies provided internally **and** dependencies produced by the
     // provided layer from the effect dependencies
-    | Exclude<R, ROut | OtelTracer.OtelTracer | Scope.Scope>
+    | WithoutLayerAndTestCtxServices<R, ROut>
   > => {
     const spanName = `${testContext.task.suite?.name}:${testContext.task.name}${suffix !== undefined ? `:${suffix}` : ''}`
-    const layer = makeLayer?.(testContext) ?? Layer.empty
+    // `Layer.empty` provides `never`, which is narrower than an arbitrary generic
+    // `ROut`; widen it for the no-layer branch so `Effect.provide` can typecheck.
+    const layer: Layer.Layer<ROut, E1, RIn | Scope.Scope> =
+      makeLayer?.(testContext) ?? (Layer.empty as unknown as Layer.Layer<ROut, E1, RIn | Scope.Scope>)
+    const timeoutDuration = Duration.fromInputUnsafe(timeout)
 
     const otelLayer =
       DEBUGGER_ACTIVE === true || forceOtel === true
@@ -84,159 +80,12 @@ export const withTestCtx =
       DEBUGGER_ACTIVE === true
         ? identity
         : Effect.logWarnIfTakesLongerThan({
-            duration: Duration.toMillis(timeout) * 0.8,
-            label: `${spanName} approaching timeout (timeout: ${Duration.format(timeout)})`,
+            duration: Duration.toMillis(timeoutDuration) * 0.8,
+            label: `${spanName} approaching timeout (timeout: ${Duration.format(timeoutDuration)})`,
           }),
       DEBUGGER_ACTIVE === true ? 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) === false) {
-    return {
-      timeout: propOptions,
-      fastCheck: { numRuns: 100 },
-    }
-  }
-
-  // If no fastCheck property, add it with our default numRuns
-  if (propOptions.fastCheck == null) {
-    return {
-      ...propOptions,
-      fastCheck: { numRuns: 100 },
-    }
-  }
-
-  // If fastCheck exists but no numRuns, add our default
-  if (propOptions.fastCheck !== undefined && propOptions.fastCheck.numRuns == null) {
-    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 === true) {
-        return ctx.skip('Test aborted')
-      }
-
-      totalExecutions++
-      const isInShrinkingPhase = runIndex >= numRuns
-
-      if (isInShrinkingPhase === true) {
-        shrinkAttempts++
-      }
-
-      const enhancedContext: EnhancedTestContext =
-        isInShrinkingPhase === true
-          ? {
-              _tag: 'shrinking',
-              numRuns,
-              runIndex: runIndex++,
-              shrinkAttempt: shrinkAttempts,
-              totalExecutions,
-            }
-          : {
-              _tag: 'initial',
-              numRuns,
-              runIndex: runIndex++,
-              totalExecutions,
-            }
-
-      return test(properties, ctx, enhancedContext)
-    },
-    normalizedPropOptions,
-  )
-}