@livestore/utils-dev 0.0.0-snapshot-1c345a0e6695466bdc7c4483444e7b3513620261 → 0.0.0-snapshot-92c31f56117b4fd377b66f55163ed565795c5e4c

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

@@ -0,0 +1,263 @@
+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

@@ -0,0 +1,99 @@
+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/mod.ts

@@ -1,9 +1,9 @@
 import { performance } from 'node:perf_hooks'
 
 import * as OtelNodeSdk from '@effect/opentelemetry/NodeSdk'
-import { IS_BUN, isNotUndefined, shouldNeverHappen } from '@livestore/utils'
-import type { CommandExecutor, PlatformError, Tracer } from '@livestore/utils/effect'
-import { Command, Config, Effect, identity, Layer, OtelTracer } 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'
@@ -11,8 +11,26 @@ import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'
 import { PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics'
 import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'
 
-export { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'
 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 './WranglerDevServer/process-tree-manager.ts'
+export {
+  type StartWranglerDevServerArgs,
+  type WranglerDevServer,
+  WranglerDevServerError,
+  WranglerDevServerService,
+} from './WranglerDevServer/WranglerDevServer.ts'
 
 export const OtelLiveHttp = ({
   serviceName,
@@ -31,7 +49,9 @@ export const OtelLiveHttp = ({
 } = {}): Layer.Layer<OtelTracer.OtelTracer | Tracer.ParentSpan, never, never> =>
   Effect.gen(function* () {
     const configRes = yield* Config.all({
-      exporterUrl: Config.string('OTEL_EXPORTER_OTLP_ENDPOINT'),
+      exporterUrl: Config.string('OTEL_EXPORTER_OTLP_ENDPOINT').pipe(
+        Config.validate({ message: 'OTEL_EXPORTER_OTLP_ENDPOINT must be set', validation: isNonEmptyString }),
+      ),
       serviceName: serviceName
         ? Config.succeed(serviceName)
         : Config.string('OTEL_SERVICE_NAME').pipe(Config.withDefault('livestore-utils-dev')),
@@ -42,7 +62,7 @@ export const OtelLiveHttp = ({
 
     if (configRes._tag === 'None') {
       const RootSpanLive = Layer.span('DummyRoot', {})
-      return RootSpanLive.pipe(Layer.provide(OtelLiveDummy))
+      return RootSpanLive.pipe(Layer.provideMerge(OtelLiveDummy)) as any
     }
 
     const config = configRes.value
@@ -61,7 +81,19 @@ export const OtelLiveHttp = ({
         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 RootSpanLive = Layer.span(config.rootSpanName, {
       attributes: { config, ...rootSpanAttributes },
@@ -143,73 +175,3 @@ export const getTracingBackendUrl = (span: otel.Span) =>
     // TODO make dynamic via env var
     return `${grafanaEndpoint}/explore?${searchParams.toString()}`
   })
-
-export const cmd: (
-  commandInput: string | (string | undefined)[],
-  options?:
-    | {
-        cwd?: string
-        shell?: boolean
-        env?: Record<string, string | undefined>
-      }
-    | undefined,
-) => Effect.Effect<CommandExecutor.ExitCode, PlatformError.PlatformError, 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 commandDebugStr = debugEnvStr + [command, ...args].join(' ')
-
-  yield* Effect.logDebug(`Running '${commandDebugStr}' in '${cwd}'`)
-  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
-    Command.stdout('inherit'), // Stream stdout to process.stdout
-    Command.stderr('inherit'), // Stream stderr to process.stderr
-    Command.workingDirectory(cwd),
-    options?.shell ? Command.runInShell(true) : identity,
-    Command.env(options?.env ?? {}),
-    Command.exitCode,
-    Effect.tap((exitCode) => (exitCode === 0 ? Effect.void : Effect.die(`${commandDebugStr} failed`))),
-  )
-})
-
-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(' ')
-
-    yield* Effect.logDebug(`Running '${commandDebugStr}' in '${cwd}'`)
-    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,
-    )
-  },
-)

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

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