@livestore/utils-dev 0.4.0-dev.22 → 0.4.0-dev.23

package/src/node/cmd.test.ts

@@ -1,10 +1,10 @@
 import fs from 'node:fs'
 import path from 'node:path'
-
 import { CommandExecutor, Duration, Effect, Layer } 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'
 import { CurrentWorkingDirectory } from './workspace.ts'
 
@@ -30,55 +30,59 @@ Vitest.describe('cmd helper', () => {
     }).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)),
+  /** TODO(#1020): Investigate CI timeout flakiness for cmd tests that spawn many child processes */
+  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)),
+    { timeout: 30_000, retry: 3 },
   )
 
   Vitest.scopedLive('streams stdout and stderr with logger formatting', (test) =>

package/src/node/cmd.ts

@@ -17,6 +17,7 @@ import {
   Schema,
   Stream,
 } from '@livestore/utils/effect'
+
 import { applyLoggingToCommand } from './cmd-log.ts'
 import * as FileLogger from './FileLogger.ts'
 import { CurrentWorkingDirectory } from './workspace.ts'
@@ -26,23 +27,21 @@ const SUCCESS_EXIT_CODE: CommandExecutor.ExitCode = 0 as CommandExecutor.ExitCod
 
 export const cmd: (
   commandInput: string | (string | undefined)[],
-  options?:
-    | {
-        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,
+  options?: {
+    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
+  },
 ) => Effect.Effect<
   CommandExecutor.ExitCode,
   PlatformError.PlatformError | CmdError,
@@ -51,27 +50,26 @@ export const cmd: (
   const cwd = yield* CurrentWorkingDirectory
 
   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 parts = asArray === true ? commandInput.filter(isNotUndefined) : undefined
+  const [command, ...args] = asArray === true ? (parts as string[]) : commandInput.split(' ')
 
   const debugEnvStr = Object.entries(options?.env ?? {})
-    .map(([key, value]) => `${key}='${value}' `)
+    .map(([key, value]) => `${key}='${String(value)}' `)
     .join('')
 
   const loggingOpts = {
-    ...(options?.logDir ? { logDir: options.logDir } : {}),
-    ...(options?.logFileName ? { logFileName: options.logFileName } : {}),
-    ...(options?.logRetention ? { logRetention: options.logRetention } : {}),
+    ...(options?.logDir !== undefined ? { logDir: options.logDir } : {}),
+    ...(options?.logFileName !== undefined ? { logFileName: options.logFileName } : {}),
+    ...(options?.logRetention !== undefined ? { 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 useShell = (options?.shell === true ? true : false) || needsShell
 
-  const commandDebugStr =
-    debugEnvStr + (Array.isArray(finalInput) ? (finalInput as string[]).join(' ') : (finalInput as string))
-  const subshellStr = useShell ? ' (in subshell)' : ''
+  const commandDebugStr = debugEnvStr + (Array.isArray(finalInput) === true ? finalInput.join(' ') : finalInput)
+  const subshellStr = useShell === true ? ' (in subshell)' : ''
 
   yield* Effect.logDebug(`Running '${commandDebugStr}' in '${cwd}'${subshellStr}`)
   yield* Effect.annotateCurrentSpan({
@@ -91,7 +89,7 @@ export const cmd: (
     useShell,
   } as const
 
-  const exitCode = yield* isNotUndefined(logPath)
+  const exitCode = yield* isNotUndefined(logPath) === true
     ? Effect.gen(function* () {
         yield* Effect.sync(() => console.log(`Logging output to ${logPath}`))
         return yield* runWithLogging({ ...baseArgs, logPath, threadName: commandDebugStr })
@@ -99,15 +97,13 @@ export const cmd: (
     : runWithoutLogging(baseArgs)
 
   if (exitCode !== SUCCESS_EXIT_CODE) {
-    return yield* Effect.fail(
-      CmdError.make({
-        command: command!,
-        args,
-        cwd,
-        env: options?.env ?? {},
-        stderr: stderrMode,
-      }),
-    )
+    return yield* CmdError.make({
+      command: command!,
+      args,
+      cwd,
+      env: options?.env ?? {},
+      stderr: stderrMode,
+    })
   }
 
   return exitCode
@@ -123,15 +119,14 @@ export const cmdText: (
 ) => Effect.Effect<string, PlatformError.PlatformError, CommandExecutor.CommandExecutor | CurrentWorkingDirectory> =
   Effect.fn('cmdText')(function* (commandInput, options) {
     const cwd = yield* CurrentWorkingDirectory
-    const [command, ...args] = Array.isArray(commandInput)
-      ? commandInput.filter(isNotUndefined)
-      : commandInput.split(' ')
+    const [command, ...args] =
+      Array.isArray(commandInput) === true ? commandInput.filter(isNotUndefined) : commandInput.split(' ')
     const debugEnvStr = Object.entries(options?.env ?? {})
-      .map(([key, value]) => `${key}='${value}' `)
+      .map(([key, value]) => `${key}='${String(value)}' `)
       .join('')
 
     const commandDebugStr = debugEnvStr + [command, ...args].join(' ')
-    const subshellStr = options?.runInShell ? ' (in subshell)' : ''
+    const subshellStr = options?.runInShell === true ? ' (in subshell)' : ''
 
     yield* Effect.logDebug(`Running '${commandDebugStr}' in '${cwd}'${subshellStr}`)
     yield* Effect.annotateCurrentSpan({ 'span.label': commandDebugStr, command, cwd })
@@ -140,13 +135,13 @@ export const cmdText: (
       // 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,
+      options?.runInShell === true ? Command.runInShell(true) : identity,
       Command.env(options?.env ?? {}),
       Command.string,
     )
   })
 
-export class CmdError extends Schema.TaggedError<CmdError>()('CmdError', {
+export class CmdError extends Schema.TaggedError<CmdError>('~@livestore/utils-dev/CmdError')('CmdError', {
   command: Schema.String,
   args: Schema.Array(Schema.String),
   cwd: Schema.String,
@@ -169,7 +164,7 @@ const runWithoutLogging = ({ commandInput, cwd, env, stdoutMode, stderrMode, use
     Command.stdout(stdoutMode),
     Command.stderr(stderrMode),
     Command.workingDirectory(cwd),
-    useShell ? Command.runInShell(true) : identity,
+    useShell === true ? Command.runInShell(true) : identity,
     Command.env(env),
     Command.exitCode,
   )
@@ -228,14 +223,16 @@ const runWithLogging = ({
         Command.stdout('pipe'),
         Command.stderr('pipe'),
         Command.workingDirectory(cwd),
-        useShell ? Command.runInShell(true) : identity,
+        useShell === true ? 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.flatMap((running) =>
+            running === true ? proc.kill().pipe(Effect.catchAll(() => Effect.void)) : Effect.void,
+          ),
           Effect.ignore,
         ),
       )
@@ -266,7 +263,7 @@ const runWithLogging = ({
       // 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) {
+        if (stillRunning === true) {
           yield* Effect.ignore(runningProcess.kill())
         }
         yield* Effect.ignore(Fiber.join(stdoutFiber))
@@ -282,12 +279,12 @@ const runWithLogging = ({
   )
 
 const buildCommand = (input: string | string[], useShell: boolean) => {
-  if (Array.isArray(input)) {
+  if (Array.isArray(input) === true) {
     const [c, ...a] = input
     return Command.make(c!, ...a)
   }
 
-  if (useShell) {
+  if (useShell === true) {
     return Command.make(input)
   }
 
@@ -298,8 +295,8 @@ const buildCommand = (input: string | string[], useShell: boolean) => {
 type TLineTerminator = 'newline' | 'carriage-return' | 'none'
 
 type TStreamHandler = {
-  readonly onChunk: (chunk: string) => Effect.Effect<void, never>
-  readonly flush: () => Effect.Effect<void, never>
+  readonly onChunk: (chunk: string) => Effect.Effect<void>
+  readonly flush: () => Effect.Effect<void>
 }
 
 const makeStreamHandler = ({
@@ -309,7 +306,7 @@ const makeStreamHandler = ({
 }: {
   readonly channel: 'stdout' | 'stderr'
   readonly mirrorTarget?: NodeJS.WriteStream
-  readonly appendLog: (args: { channel: 'stdout' | 'stderr'; content: string }) => Effect.Effect<void, never>
+  readonly appendLog: (args: { channel: 'stdout' | 'stderr'; content: string }) => Effect.Effect<void>
 }): TStreamHandler => {
   let buffer = ''
 
@@ -322,11 +319,11 @@ const makeStreamHandler = ({
       channel,
       content,
       terminator,
-      ...(mirrorTarget ? { mirrorTarget } : {}),
+      ...(mirrorTarget !== undefined ? { mirrorTarget } : {}),
       appendLog,
     })
 
-  const consumeBuffer = (): Effect.Effect<void, never> => {
+  const consumeBuffer = (): Effect.Effect<void> => {
     if (buffer.length === 0) return Effect.void
 
     const lastChar = buffer[buffer.length - 1]
@@ -390,10 +387,10 @@ const emitSegment = ({
   readonly content: string
   readonly terminator: TLineTerminator
   readonly mirrorTarget?: NodeJS.WriteStream
-  readonly appendLog: (args: { channel: 'stdout' | 'stderr'; content: string }) => Effect.Effect<void, never>
+  readonly appendLog: (args: { channel: 'stdout' | 'stderr'; content: string }) => Effect.Effect<void>
 }) =>
   Effect.gen(function* () {
-    if (mirrorTarget) {
+    if (mirrorTarget !== undefined) {
       yield* Effect.sync(() => mirrorSegment(mirrorTarget, content, terminator))
     }
 

package/src/node/mod.ts

@@ -1,16 +1,17 @@
 import { performance } from 'node:perf_hooks'
 
 import * as OtelNodeSdk from '@effect/opentelemetry/NodeSdk'
-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'
 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 { 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'
@@ -40,16 +41,16 @@ export const OtelLiveHttp = ({
   rootSpanAttributes?: Record<string, unknown>
   skipLogUrl?: boolean
   traceNodeBootstrap?: boolean
-} = {}): Layer.Layer<OtelTracer.OtelTracer | Tracer.ParentSpan, never, never> =>
+} = {}): Layer.Layer<OtelTracer.OtelTracer | 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
+      serviceName: serviceName !== undefined
         ? Config.succeed(serviceName)
         : Config.string('OTEL_SERVICE_NAME').pipe(Config.withDefault('livestore-utils-dev')),
-      rootSpanName: rootSpanName
+      rootSpanName: rootSpanName !== undefined
         ? Config.succeed(rootSpanName)
         : Config.string('OTEL_ROOT_SPAN_NAME').pipe(Config.withDefault('RootSpan')),
     }).pipe(Effect.option)
@@ -91,13 +92,13 @@ export const OtelLiveHttp = ({
 
     const RootSpanLive = Layer.span(config.rootSpanName, {
       attributes: { config, ...rootSpanAttributes },
-      onEnd: skipLogUrl ? undefined : (span: any) => logTraceUiUrlForSpan()(span.span),
+      onEnd: skipLogUrl === true ? undefined : (span: any) => logTraceUiUrlForSpan()(span.span),
       parent: parentSpan,
     })
 
     const layer = yield* Layer.memoize(RootSpanLive.pipe(Layer.provideMerge(OtelLive)))
 
-    if (traceNodeBootstrap && !IS_BUN) {
+    if (traceNodeBootstrap === true && IS_BUN === false) {
       /**
        * Create a span representing the Node.js bootstrap duration.
        * Note: Skipped in Bun since performance.nodeTiming is not properly supported.
@@ -136,7 +137,7 @@ export const logTraceUiUrlForSpan = (printMsg?: (url: string) => string) => (spa
       if (url === undefined) {
         return Effect.logWarning('No tracing backend url found')
       } else {
-        if (printMsg) {
+        if (printMsg !== undefined) {
           return Effect.log(printMsg(url))
         } else {
           return Effect.log(`Trace URL: ${url}`)
@@ -155,13 +156,14 @@ export const getTracingBackendUrl = (span: otel.Span) =>
     // Grafana + Tempo
 
     const grafanaEndpoint = endpoint.value
+    const left = yield* Schema.encode(Schema.parseJson())({
+      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: JSON.stringify({
-        datasource: 'tempo',
-        queries: [{ query: traceId, queryType: 'traceql', refId: 'A' }],
-        range: { from: 'now-1h', to: 'now' },
-      }),
+      left,
     })
 
     // TODO make dynamic via env var
@@ -188,14 +190,14 @@ const computeBootstrapTiming = () => {
   const nodeTiming = performance.nodeTiming
 
   // Absolute start time in ms since epoch.
-  const startAbs = IS_BUN
+  const startAbs = IS_BUN === true
     ? typeof nodeTiming.nodeStart === 'number'
       ? nodeTiming.nodeStart
       : performance.timeOrigin
     : performance.timeOrigin + nodeTiming.nodeStart
 
   // Absolute end time.
-  const endAbs = IS_BUN
+  const endAbs = IS_BUN === true
     ? (() => {
         const { loopStart, bootstrapComplete } = nodeTiming
         if (typeof loopStart === 'number' && loopStart > 0) return startAbs + loopStart
@@ -205,7 +207,7 @@ const computeBootstrapTiming = () => {
     : startAbs + nodeTiming.duration
 
   // Duration attribute value for the span.
-  const durationAttr = IS_BUN
+  const durationAttr = IS_BUN === true
     ? (() => {
         const { loopStart } = nodeTiming
         return typeof loopStart === 'number' && loopStart > 0 ? loopStart : 0

package/src/node/workspace.ts

@@ -1,4 +1,5 @@
 import path from 'node:path'
+
 import { shouldNeverHappen } from '@livestore/utils'
 import { Context, Effect, Layer } from '@livestore/utils/effect'
 

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

@@ -1,6 +1,11 @@
-import { Effect, FastCheck } from '@livestore/utils/effect'
+import { Effect, FastCheck, Schema } from '@livestore/utils/effect'
+
 import * as Vitest from './Vitest.ts'
 
+export class TestError extends Schema.TaggedError<TestError>()('TestError', {
+  message: Schema.String,
+}) {}
+
 // Demonstrate enhanced asProp functionality with clear shrinking progress
 // This showcases the fix for the "Run 26/6" bug and accurate shrinking detection
 
@@ -16,7 +21,7 @@ Vitest.describe('Vitest.asProp', () => {
       Effect.gen(function* () {
         const [value] = properties
         if (value === undefined) {
-          return yield* Effect.fail(new Error('Value is undefined'))
+          return yield* new TestError({ message: 'Value is undefined' })
         }
 
         console.log(
@@ -43,7 +48,7 @@ Vitest.describe('Vitest.asProp', () => {
       Effect.gen(function* () {
         const [value] = properties
         if (value === undefined) {
-          return yield* Effect.fail(new Error('Value is undefined'))
+          return yield* new TestError({ message: 'Value is undefined' })
         }
 
         const displayInfo =
@@ -59,10 +64,10 @@ Vitest.describe('Vitest.asProp', () => {
         // 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)`))
+          return yield* new TestError({ message: `Value ${value} is too large (> 80)` })
         }
 
-        if (alreadyFailed && enhanced._tag === 'shrinking') {
+        if (alreadyFailed === true && enhanced._tag === 'shrinking') {
           ctx.skip("For the sake of this test, we don't want to fail but want to skip")
           return
         }
@@ -81,7 +86,7 @@ Vitest.describe('Vitest.asProp', () => {
       Effect.gen(function* () {
         const [value] = properties
         if (value === undefined) {
-          return yield* Effect.fail(new Error('Value is undefined'))
+          return yield* new TestError({ message: 'Value is undefined' })
         }
 
         console.log(
@@ -91,7 +96,7 @@ Vitest.describe('Vitest.asProp', () => {
 
         // 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 yield* new TestError({ message: `Value ${value} is too large (> 50) - but no shrinking!` })
         }
 
         return