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

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.test.ts

@@ -14,7 +14,7 @@ Vitest.describe('Vitest.asProp', () => {
 
   // Always-passing test - should only show initial phase
   Vitest.asProp(
-    Vitest.scopedLive,
+    Vitest.live,
     'always-pass test (shows only initial runs)',
     [IntArbitrary],
     (properties, _ctx, enhanced) =>
@@ -38,10 +38,29 @@ Vitest.describe('Vitest.asProp', () => {
     { fastCheck: { numRuns: 4 } },
   )
 
+  Vitest.asProp(
+    Vitest.live,
+    'converts record-form schemas to arbitraries',
+    {
+      count: Schema.Int,
+      payload: Schema.Struct({
+        label: Schema.String,
+        note: Schema.optional(Schema.String),
+      }),
+    },
+    ({ count, payload }) =>
+      Effect.sync(() => {
+        Vitest.expect(Number.isInteger(count)).toBe(true)
+        Vitest.expect(typeof payload.label).toBe('string')
+        Vitest.expect(payload.note === undefined || typeof payload.note === 'string').toBe(true)
+      }),
+    { fastCheck: { numRuns: 10 } },
+  )
+
   // Failing test - should show initial + shrinking phases
   let alreadyFailed = false
   Vitest.asProp(
-    Vitest.scopedLive,
+    Vitest.live,
     'failing test (shows initial runs + shrinking)',
     [IntArbitrary],
     (properties, ctx, enhanced) =>
@@ -79,7 +98,7 @@ Vitest.describe('Vitest.asProp', () => {
 
   // Test with endOnFailure: true - should not show shrinking
   Vitest.asProp(
-    Vitest.scopedLive,
+    Vitest.live,
     'failing test with endOnFailure (no shrinking)',
     [IntArbitrary],
     (properties, _ctx, enhanced) =>

package/src/node-vitest/Vitest.ts

@@ -23,24 +23,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 +57,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 +66,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,14 +91,14 @@ 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
+    )
   }
 
 /**
@@ -121,19 +128,17 @@ export type EnhancedTestContext =
 /**
  * Normalizes propOptions to ensure @effect/vitest receives correct fastCheck structure
  */
+type ArbitraryValues<Arbs extends Vitest.Vitest.Arbitraries> = {
+  [K in keyof Arbs]: Arbs[K] extends FC.Arbitrary<infer T> ? T : Arbs[K] extends Schema.Schema<infer T> ? T : never
+}
+
+type PropOptions<Arbs extends Vitest.Vitest.Arbitraries> = Omit<Vitest.TestOptions, 'fastCheck'> & {
+  fastCheck?: FC.Parameters<ArbitraryValues<Arbs>>
+}
+
 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]>
-  }>
-} => {
+  propOptions: number | PropOptions<Arbs>,
+): PropOptions<Arbs> => {
   // If it's a number, treat as timeout and add our default fastCheck
   if (Predicate.isObject(propOptions) === false) {
     return {
@@ -180,23 +185,8 @@ 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]>
-        }>
-      }),
+  test: Vitest.Vitest.TestFunction<A, E, R, [ArbitraryValues<Arbs>, Vitest.TestContext, EnhancedTestContext]>,
+  propOptions: number | PropOptions<Arbs>,
 ) => {
   const normalizedPropOptions = normalizePropOptions(propOptions)
   const numRuns = normalizedPropOptions.fastCheck?.numRuns ?? 100