@livestore/utils-dev 0.0.0-snapshot-e5a7caabcf7660aefa55568a44ed0fe306d00597 → 0.0.0-snapshot-9d8807d2c51c95b4df3556744702cea55dc7ded3

package/src/node/cmd.test.ts

@@ -1,129 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-
-import { CommandExecutor, Duration, Effect } from '@livestore/utils/effect'
-import { PlatformNode } from '@livestore/utils/node'
-import { Vitest } from '@livestore/utils-dev/node-vitest'
-import { expect } from 'vitest'
-import { cmd } from './cmd.ts'
-
-const withNode = Vitest.makeWithTestCtx({
-  makeLayer: () => PlatformNode.NodeContext.layer,
-  timeout: 20_000,
-})
-
-Vitest.describe('cmd helper', () => {
-  const ansiRegex = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, 'g')
-
-  Vitest.scopedLive('runs tokenized string without shell', (test) =>
-    Effect.gen(function* () {
-      const exit = yield* cmd('printf ok')
-      expect(exit).toBe(CommandExecutor.ExitCode(0))
-    }).pipe(withNode(test)),
-  )
-
-  Vitest.scopedLive('runs array input', (test) =>
-    Effect.gen(function* () {
-      const exit = yield* cmd(['printf', 'ok'])
-      expect(exit).toBe(CommandExecutor.ExitCode(0))
-    }).pipe(withNode(test)),
-  )
-
-  Vitest.scopedLive('supports logging with archive + retention', (test) =>
-    Effect.gen(function* () {
-      const workspace = process.env.WORKSPACE_ROOT!
-      const logsDir = path.join(workspace, 'tmp', 'cmd-tests', String(Date.now()))
-
-      // first run
-      const exit1 = yield* cmd('printf first', { logDir: logsDir })
-      expect(exit1).toBe(CommandExecutor.ExitCode(0))
-      const current = path.join(logsDir, 'dev.log')
-      expect(fs.existsSync(current)).toBe(true)
-      const firstLog = fs.readFileSync(current, 'utf8')
-      const firstStdoutLines = firstLog.split('\n').filter((line) => line.includes('[stdout]'))
-      expect(firstStdoutLines.length).toBeGreaterThan(0)
-      for (const line of firstStdoutLines) {
-        expect(line).toContain('[stdout] first')
-        expect(line).toContain('INFO')
-        expect(line).toContain('printf first')
-      }
-
-      // second run — archives previous
-      const exit2 = yield* cmd('printf second', { logDir: logsDir })
-      expect(exit2).toBe(CommandExecutor.ExitCode(0))
-      const archiveDir = path.join(logsDir, 'archive')
-      const archives = fs.readdirSync(archiveDir).filter((f) => f.endsWith('.log'))
-      expect(archives.length).toBe(1)
-      const archivedPath = path.join(archiveDir, archives[0]!)
-      const archivedLog = fs.readFileSync(archivedPath, 'utf8')
-      const archivedStdoutLines = archivedLog.split('\n').filter((line) => line.includes('[stdout]'))
-      expect(archivedStdoutLines.length).toBeGreaterThan(0)
-      for (const line of archivedStdoutLines) {
-        expect(line).toContain('[stdout] first')
-      }
-
-      const secondLog = fs.readFileSync(current, 'utf8')
-      const secondStdoutLines = secondLog.split('\n').filter((line) => line.includes('[stdout]'))
-      expect(secondStdoutLines.length).toBeGreaterThan(0)
-      for (const line of secondStdoutLines) {
-        expect(line).toContain('[stdout] second')
-        expect(line).toContain('INFO')
-      }
-
-      // generate many archives to exercise retention (keep 50)
-      for (let i = 0; i < 60; i++) {
-        // Use small unique payloads
-        yield* cmd(['printf', String(i)], { logDir: logsDir })
-      }
-      const archivesAfter = fs.readdirSync(archiveDir).filter((f) => f.endsWith('.log'))
-      expect(archivesAfter.length).toBeLessThanOrEqual(50)
-    }).pipe(withNode(test)),
-  )
-
-  Vitest.scopedLive('streams stdout and stderr with logger formatting', (test) =>
-    Effect.gen(function* () {
-      const workspace = process.env.WORKSPACE_ROOT!
-      const logsDir = path.join(workspace, 'tmp', 'cmd-tests', `format-${Date.now()}`)
-
-      const exit = yield* cmd(['node', '-e', "console.log('out'); console.error('err')"], {
-        logDir: logsDir,
-      })
-      expect(exit).toBe(CommandExecutor.ExitCode(0))
-
-      const current = path.join(logsDir, 'dev.log')
-      const logContent = fs.readFileSync(current, 'utf8')
-      expect(logContent).toMatch(/\[stdout] out/)
-      expect(logContent).toMatch(/\[stderr] err/)
-
-      const relevantLines = logContent
-        .split('\n')
-        .map((line) => line.trim())
-        .filter((line) => line.includes('[stdout]') || line.includes('[stderr]'))
-
-      expect(relevantLines.length).toBeGreaterThanOrEqual(2)
-
-      for (const line of relevantLines) {
-        const stripped = line.replace(ansiRegex, '')
-        expect(stripped.startsWith('[')).toBe(true)
-        expect(stripped).toMatch(/(INFO|WARN)/)
-        expect(stripped).toMatch(/\[(stdout|stderr)]/)
-      }
-    }).pipe(withNode(test)),
-  )
-
-  Vitest.scopedLive('cleans up logged child process when interrupted', (test) =>
-    Effect.gen(function* () {
-      const workspace = process.env.WORKSPACE_ROOT!
-      const logsDir = path.join(workspace, 'tmp', 'cmd-tests', `timeout-${Date.now()}`)
-
-      const result = yield* cmd(['node', '-e', 'setTimeout(() => {}, 5000)'], {
-        logDir: logsDir,
-        stdout: 'pipe',
-        stderr: 'pipe',
-      }).pipe(Effect.timeoutOption(Duration.millis(200)))
-
-      expect(result._tag).toBe('None')
-      expect(fs.existsSync(path.join(logsDir, 'dev.log'))).toBe(true)
-    }).pipe(withNode(test)),
-  )
-})

package/src/node/cmd.ts

@@ -1,419 +0,0 @@
-import fs from 'node:fs'
-
-import { isNotUndefined, shouldNeverHappen } from '@livestore/utils'
-import {
-  Cause,
-  Command,
-  type CommandExecutor,
-  Effect,
-  Fiber,
-  FiberId,
-  FiberRefs,
-  HashMap,
-  identity,
-  List,
-  LogLevel,
-  type PlatformError,
-  Schema,
-  Stream,
-} from '@livestore/utils/effect'
-import { applyLoggingToCommand } from './cmd-log.ts'
-import * as FileLogger from './FileLogger.ts'
-
-// Branded zero value so we can compare exit codes without touching internals.
-const SUCCESS_EXIT_CODE: CommandExecutor.ExitCode = 0 as CommandExecutor.ExitCode
-
-export const cmd: (
-  commandInput: string | (string | undefined)[],
-  options?:
-    | {
-        cwd?: string
-        stderr?: 'inherit' | 'pipe'
-        stdout?: 'inherit' | 'pipe'
-        shell?: boolean
-        env?: Record<string, string | undefined>
-        /**
-         * When provided, streams command output to terminal AND to a canonical log file (`${logDir}/dev.log`) in this directory.
-         * Also archives the previous run to `${logDir}/archive/dev-<ISO>.log` and keeps only the latest 50 archives.
-         */
-        logDir?: string
-        /** Optional basename for the canonical log file; defaults to 'dev.log' */
-        logFileName?: string
-        /** Optional number of archived logs to retain; defaults to 50 */
-        logRetention?: number
-      }
-    | 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 asArray = Array.isArray(commandInput)
-    const parts = asArray ? (commandInput as (string | undefined)[]).filter(isNotUndefined) : undefined
-    const [command, ...args] = asArray ? (parts as string[]) : (commandInput as string).split(' ')
-
-    const debugEnvStr = Object.entries(options?.env ?? {})
-      .map(([key, value]) => `${key}='${value}' `)
-      .join('')
-
-    const loggingOpts = {
-      ...(options?.logDir ? { logDir: options.logDir } : {}),
-      ...(options?.logFileName ? { logFileName: options.logFileName } : {}),
-      ...(options?.logRetention ? { logRetention: options.logRetention } : {}),
-    } as const
-    const { input: finalInput, subshell: needsShell, logPath } = yield* applyLoggingToCommand(commandInput, loggingOpts)
-
-    const stdoutMode = options?.stdout ?? 'inherit'
-    const stderrMode = options?.stderr ?? 'inherit'
-    const useShell = (options?.shell ? true : false) || needsShell
-
-    const commandDebugStr =
-      debugEnvStr + (Array.isArray(finalInput) ? (finalInput as string[]).join(' ') : (finalInput as string))
-    const subshellStr = useShell ? ' (in subshell)' : ''
-
-    yield* Effect.logDebug(`Running '${commandDebugStr}' in '${cwd}'${subshellStr}`)
-    yield* Effect.annotateCurrentSpan({
-      'span.label': commandDebugStr,
-      cwd,
-      command,
-      args,
-      logDir: options?.logDir,
-    })
-
-    const baseArgs = {
-      commandInput: finalInput,
-      cwd,
-      env: options?.env ?? {},
-      stdoutMode,
-      stderrMode,
-      useShell,
-    } as const
-
-    const exitCode = yield* isNotUndefined(logPath)
-      ? Effect.gen(function* () {
-          yield* Effect.sync(() => console.log(`Logging output to ${logPath}`))
-          return yield* runWithLogging({ ...baseArgs, logPath, threadName: commandDebugStr })
-        })
-      : runWithoutLogging(baseArgs)
-
-    if (exitCode !== SUCCESS_EXIT_CODE) {
-      return yield* Effect.fail(
-        CmdError.make({
-          command: command!,
-          args,
-          cwd,
-          env: options?.env ?? {},
-          stderr: stderrMode,
-        }),
-      )
-    }
-
-    return exitCode
-  })
-
-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'),
-}) {}
-
-type TRunBaseArgs = {
-  readonly commandInput: string | string[]
-  readonly cwd: string
-  readonly env: Record<string, string | undefined>
-  readonly stdoutMode: 'inherit' | 'pipe'
-  readonly stderrMode: 'inherit' | 'pipe'
-  readonly useShell: boolean
-}
-
-const runWithoutLogging = ({ commandInput, cwd, env, stdoutMode, stderrMode, useShell }: TRunBaseArgs) =>
-  buildCommand(commandInput, useShell).pipe(
-    Command.stdin('inherit'),
-    Command.stdout(stdoutMode),
-    Command.stderr(stderrMode),
-    Command.workingDirectory(cwd),
-    useShell ? Command.runInShell(true) : identity,
-    Command.env(env),
-    Command.exitCode,
-  )
-
-type TRunWithLoggingArgs = TRunBaseArgs & {
-  readonly logPath: string
-  readonly threadName: string
-}
-
-const runWithLogging = ({
-  commandInput,
-  cwd,
-  env,
-  stdoutMode,
-  stderrMode,
-  useShell,
-  logPath,
-  threadName,
-}: TRunWithLoggingArgs) =>
-  // When logging is enabled we have to replace the `2>&1 | tee` pipeline the
-  // shell used to give us. We now pipe both streams through Effect so we can
-  // mirror to the terminal (only when requested) and append formatted entries
-  // into the canonical log ourselves.
-  Effect.scoped(
-    Effect.gen(function* () {
-      const envWithColor = env.FORCE_COLOR === undefined ? { ...env, FORCE_COLOR: '1' } : env
-
-      const logFile = yield* Effect.acquireRelease(
-        Effect.sync(() => fs.openSync(logPath, 'a', 0o666)),
-        (fd) => Effect.sync(() => fs.closeSync(fd)),
-      )
-
-      const prettyLogger = FileLogger.prettyLoggerTty({
-        colors: true,
-        stderr: false,
-        formatDate: (date) => `${FileLogger.defaultDateFormat(date)} ${threadName}`,
-      })
-
-      const appendLog = ({ channel, content }: { channel: 'stdout' | 'stderr'; content: string }) =>
-        Effect.sync(() => {
-          const formatted = prettyLogger.log({
-            fiberId: FiberId.none,
-            logLevel: channel === 'stdout' ? LogLevel.Info : LogLevel.Warning,
-            message: [`[${channel}]${content.length > 0 ? ` ${content}` : ''}`],
-            cause: Cause.empty,
-            context: FiberRefs.empty(),
-            spans: List.empty(),
-            annotations: HashMap.empty(),
-            date: new Date(),
-          })
-          fs.writeSync(logFile, formatted)
-        })
-
-      const command = buildCommand(commandInput, useShell).pipe(
-        Command.stdin('inherit'),
-        Command.stdout('pipe'),
-        Command.stderr('pipe'),
-        Command.workingDirectory(cwd),
-        useShell ? Command.runInShell(true) : identity,
-        Command.env(envWithColor),
-      )
-
-      // Acquire/start the command and make sure we kill it on interruption.
-      const runningProcess = yield* Effect.acquireRelease(command.pipe(Command.start), (proc) =>
-        proc.isRunning.pipe(
-          Effect.flatMap((running) => (running ? proc.kill().pipe(Effect.catchAll(() => Effect.void)) : Effect.void)),
-          Effect.ignore,
-        ),
-      )
-
-      const stdoutHandler = makeStreamHandler({
-        channel: 'stdout',
-        ...(stdoutMode === 'inherit' ? { mirrorTarget: process.stdout } : {}),
-        appendLog,
-      })
-      const stderrHandler = makeStreamHandler({
-        channel: 'stderr',
-        ...(stderrMode === 'inherit' ? { mirrorTarget: process.stderr } : {}),
-        appendLog,
-      })
-
-      const stdoutFiber = yield* runningProcess.stdout.pipe(
-        Stream.decodeText('utf8'),
-        Stream.runForEach((chunk) => stdoutHandler.onChunk(chunk)),
-        Effect.forkScoped,
-      )
-
-      const stderrFiber = yield* runningProcess.stderr.pipe(
-        Stream.decodeText('utf8'),
-        Stream.runForEach((chunk) => stderrHandler.onChunk(chunk)),
-        Effect.forkScoped,
-      )
-
-      // Dump any buffered data and finish both stream fibers before we return.
-      const flushOutputs = Effect.gen(function* () {
-        const stillRunning = yield* runningProcess.isRunning.pipe(Effect.catchAll(() => Effect.succeed(false)))
-        if (stillRunning) {
-          yield* Effect.ignore(runningProcess.kill())
-        }
-        yield* Effect.ignore(Fiber.join(stdoutFiber))
-        yield* Effect.ignore(Fiber.join(stderrFiber))
-        yield* stdoutHandler.flush()
-        yield* stderrHandler.flush()
-      })
-
-      const exitCode = yield* runningProcess.exitCode.pipe(Effect.ensuring(flushOutputs))
-
-      return exitCode
-    }),
-  )
-
-const buildCommand = (input: string | string[], useShell: boolean) => {
-  if (Array.isArray(input)) {
-    const [c, ...a] = input
-    return Command.make(c!, ...a)
-  }
-
-  if (useShell) {
-    return Command.make(input)
-  }
-
-  const [c, ...a] = input.split(' ')
-  return Command.make(c!, ...a)
-}
-
-type TLineTerminator = 'newline' | 'carriage-return' | 'none'
-
-type TStreamHandler = {
-  readonly onChunk: (chunk: string) => Effect.Effect<void, never>
-  readonly flush: () => Effect.Effect<void, never>
-}
-
-const makeStreamHandler = ({
-  channel,
-  mirrorTarget,
-  appendLog,
-}: {
-  readonly channel: 'stdout' | 'stderr'
-  readonly mirrorTarget?: NodeJS.WriteStream
-  readonly appendLog: (args: { channel: 'stdout' | 'stderr'; content: string }) => Effect.Effect<void, never>
-}): TStreamHandler => {
-  let buffer = ''
-
-  // Effect's FileLogger expects line-oriented messages, but the subprocess
-  // gives us arbitrary UTF-8 chunks. We keep a tiny line splitter here so the
-  // log and console stay readable (and consistent with the previous `tee`
-  // behaviour).
-  const emit = (content: string, terminator: TLineTerminator) =>
-    emitSegment({
-      channel,
-      content,
-      terminator,
-      ...(mirrorTarget ? { mirrorTarget } : {}),
-      appendLog,
-    })
-
-  const consumeBuffer = (): Effect.Effect<void, never> => {
-    if (buffer.length === 0) return Effect.void
-
-    const lastChar = buffer[buffer.length - 1]
-    if (lastChar === '\r') {
-      const line = buffer.slice(0, -1)
-      buffer = ''
-      return emit(line, 'carriage-return')
-    }
-
-    const line = buffer
-    buffer = ''
-    return line.length === 0 ? Effect.void : emit(line, 'none')
-  }
-
-  return {
-    onChunk: (chunk) =>
-      Effect.gen(function* () {
-        buffer += chunk
-        while (buffer.length > 0) {
-          const newlineIndex = buffer.indexOf('\n')
-          const carriageIndex = buffer.indexOf('\r')
-
-          if (newlineIndex === -1 && carriageIndex === -1) {
-            break
-          }
-
-          let index: number
-          let terminator: TLineTerminator
-          let skip = 1
-
-          if (carriageIndex !== -1 && (newlineIndex === -1 || carriageIndex < newlineIndex)) {
-            index = carriageIndex
-            if (carriageIndex + 1 < buffer.length && buffer[carriageIndex + 1] === '\n') {
-              skip = 2
-              terminator = 'newline'
-            } else {
-              terminator = 'carriage-return'
-            }
-          } else {
-            index = newlineIndex!
-            terminator = 'newline'
-          }
-
-          const line = buffer.slice(0, index)
-          buffer = buffer.slice(index + skip)
-          yield* emit(line, terminator)
-        }
-      }),
-    flush: () => consumeBuffer(),
-  }
-}
-
-const emitSegment = ({
-  channel,
-  content,
-  terminator,
-  mirrorTarget,
-  appendLog,
-}: {
-  readonly channel: 'stdout' | 'stderr'
-  readonly content: string
-  readonly terminator: TLineTerminator
-  readonly mirrorTarget?: NodeJS.WriteStream
-  readonly appendLog: (args: { channel: 'stdout' | 'stderr'; content: string }) => Effect.Effect<void, never>
-}) =>
-  Effect.gen(function* () {
-    if (mirrorTarget) {
-      yield* Effect.sync(() => mirrorSegment(mirrorTarget, content, terminator))
-    }
-
-    const contentForLog = terminator === 'carriage-return' ? `${content}\r` : content
-
-    yield* appendLog({ channel, content: contentForLog })
-  })
-
-const mirrorSegment = (target: NodeJS.WriteStream, content: string, terminator: TLineTerminator) => {
-  switch (terminator) {
-    case 'newline': {
-      target.write(`${content}\n`)
-      break
-    }
-    case 'carriage-return': {
-      target.write(`${content}\r`)
-      break
-    }
-    case 'none': {
-      target.write(content)
-      break
-    }
-  }
-}

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

@@ -1,112 +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) {
-          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,
-    },
-  )
-})