@tldraw/validate 4.2.2 → 4.2.3

package/src/lib/validation.ts

@@ -9,9 +9,6 @@ import {
 	validateIndexKey,
 } from '@tldraw/utils'
 
-/** @internal */
-const IS_DEV = process.env.NODE_ENV !== 'production'
-
 /**
  * A function that validates and returns a value of type T from unknown input.
  * The function should throw a ValidationError if the value is invalid.
@@ -234,13 +231,10 @@ export class Validator<T> implements Validatable<T> {
 	 *
 	 * validationFn - Function that validates and returns a value of type T
 	 * validateUsingKnownGoodVersionFn - Optional performance-optimized validation function
-	 * skipSameValueCheck - Internal flag to skip dev check for validators that transform values
 	 */
 	constructor(
 		readonly validationFn: ValidatorFn<T>,
-		readonly validateUsingKnownGoodVersionFn?: ValidatorUsingKnownGoodVersionFn<T>,
-		/** @internal */
-		readonly skipSameValueCheck: boolean = false
+		readonly validateUsingKnownGoodVersionFn?: ValidatorUsingKnownGoodVersionFn<T>
 	) {}
 
 	/**
@@ -265,7 +259,7 @@ export class Validator<T> implements Validatable<T> {
 	 */
 	validate(value: unknown): T {
 		const validated = this.validationFn(value)
-		if (IS_DEV && !this.skipSameValueCheck && !Object.is(value, validated)) {
+		if (process.env.NODE_ENV !== 'production' && !Object.is(value, validated)) {
 			throw new ValidationError('Validator functions must return the same value they were passed')
 		}
 		return validated
@@ -434,8 +428,7 @@ export class Validator<T> implements Validatable<T> {
 					return knownGoodValue
 				}
 				return otherValidationFn(validated)
-			},
-			true // skipSameValueCheck: refine is designed to transform values
+			}
 		)
 	}
 
@@ -523,27 +516,11 @@ export class ArrayOfValidator<T> extends Validator<T[]> {
 			(value) => {
 				const arr = array.validate(value)
 				for (let i = 0; i < arr.length; i++) {
-					if (IS_DEV) {
-						prefixError(i, () => itemValidator.validate(arr[i]))
-					} else {
-						// Production: inline error handling to avoid closure overhead
-						try {
-							itemValidator.validate(arr[i])
-						} catch (err) {
-							if (err instanceof ValidationError) {
-								throw new ValidationError(err.rawMessage, [i, ...err.path])
-							}
-							throw new ValidationError((err as Error).toString(), [i])
-						}
-					}
+					prefixError(i, () => itemValidator.validate(arr[i]))
 				}
 				return arr as T[]
 			},
 			(knownGoodValue, newValue) => {
-				// Fast path: reference equality means no changes
-				if (Object.is(knownGoodValue, newValue)) {
-					return knownGoodValue
-				}
 				if (!itemValidator.validateUsingKnownGoodVersion) return this.validate(newValue)
 				const arr = array.validate(newValue)
 				let isDifferent = knownGoodValue.length !== arr.length
@@ -551,46 +528,18 @@ export class ArrayOfValidator<T> extends Validator<T[]> {
 					const item = arr[i]
 					if (i >= knownGoodValue.length) {
 						isDifferent = true
-						if (IS_DEV) {
-							prefixError(i, () => itemValidator.validate(item))
-						} else {
-							try {
-								itemValidator.validate(item)
-							} catch (err) {
-								if (err instanceof ValidationError) {
-									throw new ValidationError(err.rawMessage, [i, ...err.path])
-								}
-								throw new ValidationError((err as Error).toString(), [i])
-							}
-						}
+						prefixError(i, () => itemValidator.validate(item))
 						continue
 					}
 					// sneaky quick check here to avoid the prefix + validator overhead
 					if (Object.is(knownGoodValue[i], item)) {
 						continue
 					}
-					if (IS_DEV) {
-						const checkedItem = prefixError(i, () =>
-							itemValidator.validateUsingKnownGoodVersion!(knownGoodValue[i], item)
-						)
-						if (!Object.is(checkedItem, knownGoodValue[i])) {
-							isDifferent = true
-						}
-					} else {
-						try {
-							const checkedItem = itemValidator.validateUsingKnownGoodVersion!(
-								knownGoodValue[i],
-								item
-							)
-							if (!Object.is(checkedItem, knownGoodValue[i])) {
-								isDifferent = true
-							}
-						} catch (err) {
-							if (err instanceof ValidationError) {
-								throw new ValidationError(err.rawMessage, [i, ...err.path])
-							}
-							throw new ValidationError((err as Error).toString(), [i])
-						}
+					const checkedItem = prefixError(i, () =>
+						itemValidator.validateUsingKnownGoodVersion!(knownGoodValue[i], item)
+					)
+					if (!Object.is(checkedItem, knownGoodValue[i])) {
+						isDifferent = true
 					}
 				}
 
@@ -679,24 +628,10 @@ export class ObjectValidator<Shape extends object> extends Validator<Shape> {
 					throw new ValidationError(`Expected object, got ${typeToString(object)}`)
 				}
 
-				for (const key in config) {
-					if (!hasOwnProperty(config, key)) continue
-					const validator = config[key as keyof typeof config]
-					if (IS_DEV) {
-						prefixError(key, () => {
-							;(validator as Validatable<unknown>).validate(getOwnProperty(object, key))
-						})
-					} else {
-						// Production: inline error handling to avoid closure overhead
-						try {
-							;(validator as Validatable<unknown>).validate(getOwnProperty(object, key))
-						} catch (err) {
-							if (err instanceof ValidationError) {
-								throw new ValidationError(err.rawMessage, [key, ...err.path])
-							}
-							throw new ValidationError((err as Error).toString(), [key])
-						}
-					}
+				for (const [key, validator] of Object.entries(config)) {
+					prefixError(key, () => {
+						;(validator as Validatable<unknown>).validate(getOwnProperty(object, key))
+					})
 				}
 
 				if (!shouldAllowUnknownProperties) {
@@ -710,52 +645,29 @@ export class ObjectValidator<Shape extends object> extends Validator<Shape> {
 				return object as Shape
 			},
 			(knownGoodValue, newValue) => {
-				// Fast path: reference equality means no changes
-				if (Object.is(knownGoodValue, newValue)) {
-					return knownGoodValue
-				}
 				if (typeof newValue !== 'object' || newValue === null) {
 					throw new ValidationError(`Expected object, got ${typeToString(newValue)}`)
 				}
 
 				let isDifferent = false
 
-				for (const key in config) {
-					if (!hasOwnProperty(config, key)) continue
-					const validator = config[key as keyof typeof config]
+				for (const [key, validator] of Object.entries(config)) {
 					const prev = getOwnProperty(knownGoodValue, key)
 					const next = getOwnProperty(newValue, key)
 					// sneaky quick check here to avoid the prefix + validator overhead
 					if (Object.is(prev, next)) {
 						continue
 					}
-					if (IS_DEV) {
-						const checked = prefixError(key, () => {
-							const validatable = validator as Validatable<unknown>
-							if (validatable.validateUsingKnownGoodVersion) {
-								return validatable.validateUsingKnownGoodVersion(prev, next)
-							} else {
-								return validatable.validate(next)
-							}
-						})
-						if (!Object.is(checked, prev)) {
-							isDifferent = true
-						}
-					} else {
-						try {
-							const validatable = validator as Validatable<unknown>
-							const checked = validatable.validateUsingKnownGoodVersion
-								? validatable.validateUsingKnownGoodVersion(prev, next)
-								: validatable.validate(next)
-							if (!Object.is(checked, prev)) {
-								isDifferent = true
-							}
-						} catch (err) {
-							if (err instanceof ValidationError) {
-								throw new ValidationError(err.rawMessage, [key, ...err.path])
-							}
-							throw new ValidationError((err as Error).toString(), [key])
+					const checked = prefixError(key, () => {
+						const validatable = validator as Validatable<unknown>
+						if (validatable.validateUsingKnownGoodVersion) {
+							return validatable.validateUsingKnownGoodVersion(prev, next)
+						} else {
+							return validatable.validate(next)
 						}
+					})
+					if (!Object.is(checked, prev)) {
+						isDifferent = true
 					}
 				}
 
@@ -882,7 +794,6 @@ export class UnionValidator<
 				return prefixError(`(${key} = ${variant})`, () => matchingSchema.validate(input))
 			},
 			(prevValue, newValue) => {
-				// Note: Object.is check is already done by base Validator class
 				this.expectObject(newValue)
 				this.expectObject(prevValue)
 
@@ -922,15 +833,8 @@ export class UnionValidator<
 			throw new ValidationError(
 				`Expected a string for key "${this.key}", got ${typeToString(variant)}`
 			)
-		} else if (this.useNumberKeys) {
-			// Fast finite number check: numVariant - numVariant === 0 is false for Infinity and NaN
-			// This avoids Number.isFinite function call overhead
-			const numVariant = Number(variant)
-			if (numVariant - numVariant !== 0) {
-				throw new ValidationError(
-					`Expected a number for key "${this.key}", got "${variant as any}"`
-				)
-			}
+		} else if (this.useNumberKeys && !Number.isFinite(Number(variant))) {
+			throw new ValidationError(`Expected a number for key "${this.key}", got "${variant as any}"`)
 		}
 
 		const matchingSchema = hasOwnProperty(this.config, variant) ? this.config[variant] : undefined
@@ -991,26 +895,11 @@ export class DictValidator<Key extends string, Value> extends Validator<Record<K
 					throw new ValidationError(`Expected object, got ${typeToString(object)}`)
 				}
 
-				// Use for...in instead of Object.entries() to avoid array allocation
-				for (const key in object) {
-					if (!hasOwnProperty(object, key)) continue
-					if (IS_DEV) {
-						prefixError(key, () => {
-							keyValidator.validate(key)
-							valueValidator.validate((object as Record<string, unknown>)[key])
-						})
-					} else {
-						// Production: inline error handling to avoid closure overhead
-						try {
-							keyValidator.validate(key)
-							valueValidator.validate((object as Record<string, unknown>)[key])
-						} catch (err) {
-							if (err instanceof ValidationError) {
-								throw new ValidationError(err.rawMessage, [key, ...err.path])
-							}
-							throw new ValidationError((err as Error).toString(), [key])
-						}
-					}
+				for (const [key, value] of Object.entries(object)) {
+					prefixError(key, () => {
+						keyValidator.validate(key)
+						valueValidator.validate(value)
+					})
 				}
 
 				return object as Record<Key, Value>
@@ -1020,84 +909,39 @@ export class DictValidator<Key extends string, Value> extends Validator<Record<K
 					throw new ValidationError(`Expected object, got ${typeToString(newValue)}`)
 				}
 
-				const newObj = newValue as Record<string, unknown>
 				let isDifferent = false
-				let newKeyCount = 0
-
-				// Use for...in instead of Object.entries() to avoid array allocation
-				for (const key in newObj) {
-					if (!hasOwnProperty(newObj, key)) continue
-					newKeyCount++
-
-					const next = newObj[key]
 
+				for (const [key, value] of Object.entries(newValue)) {
 					if (!hasOwnProperty(knownGoodValue, key)) {
 						isDifferent = true
-						if (IS_DEV) {
-							prefixError(key, () => {
-								keyValidator.validate(key)
-								valueValidator.validate(next)
-							})
-						} else {
-							try {
-								keyValidator.validate(key)
-								valueValidator.validate(next)
-							} catch (err) {
-								if (err instanceof ValidationError) {
-									throw new ValidationError(err.rawMessage, [key, ...err.path])
-								}
-								throw new ValidationError((err as Error).toString(), [key])
-							}
-						}
+						prefixError(key, () => {
+							keyValidator.validate(key)
+							valueValidator.validate(value)
+						})
 						continue
 					}
-
-					const prev = (knownGoodValue as Record<string, unknown>)[key]
-
-					// Quick reference equality check to avoid validator overhead
+					const prev = getOwnProperty(knownGoodValue, key)
+					const next = value
+					// sneaky quick check here to avoid the prefix + validator overhead
 					if (Object.is(prev, next)) {
 						continue
 					}
-
-					if (IS_DEV) {
-						const checked = prefixError(key, () => {
-							if (valueValidator.validateUsingKnownGoodVersion) {
-								return valueValidator.validateUsingKnownGoodVersion(prev as Value, next)
-							} else {
-								return valueValidator.validate(next)
-							}
-						})
-						if (!Object.is(checked, prev)) {
-							isDifferent = true
-						}
-					} else {
-						try {
-							const checked = valueValidator.validateUsingKnownGoodVersion
-								? valueValidator.validateUsingKnownGoodVersion(prev as Value, next)
-								: valueValidator.validate(next)
-							if (!Object.is(checked, prev)) {
-								isDifferent = true
-							}
-						} catch (err) {
-							if (err instanceof ValidationError) {
-								throw new ValidationError(err.rawMessage, [key, ...err.path])
-							}
-							throw new ValidationError((err as Error).toString(), [key])
+					const checked = prefixError(key, () => {
+						if (valueValidator.validateUsingKnownGoodVersion) {
+							return valueValidator.validateUsingKnownGoodVersion(prev as any, next)
+						} else {
+							return valueValidator.validate(next)
 						}
+					})
+					if (!Object.is(checked, prev)) {
+						isDifferent = true
 					}
 				}
 
-				// Only check for removed keys if counts might differ
-				// This avoids iterating over knownGoodValue when no keys were removed
-				if (!isDifferent) {
-					let oldKeyCount = 0
-					for (const key in knownGoodValue) {
-						if (hasOwnProperty(knownGoodValue, key)) {
-							oldKeyCount++
-						}
-					}
-					if (oldKeyCount !== newKeyCount) {
+				for (const key of Object.keys(knownGoodValue)) {
+					if (!hasOwnProperty(newValue, key)) {
 						isDifferent = true
+						break
 					}
 				}
 
@@ -1164,21 +1008,13 @@ export const string = typeofValidator<string>('string')
  * ```
  * @public
  */
-export const number = new Validator<number>((value) => {
-	// Fast path: check for valid finite number using arithmetic trick
-	// value - value === 0 is false for Infinity and NaN (avoids function call overhead)
-	if (Number.isFinite(value)) {
-		return value as number
-	}
-	// Slow path: determine specific error
-	if (typeof value !== 'number') {
-		throw new ValidationError(`Expected number, got ${typeToString(value)}`)
-	}
-	// value !== value is true only for NaN (faster than Number.isNaN)
-	if (value !== value) {
+export const number = typeofValidator<number>('number').check((number) => {
+	if (Number.isNaN(number)) {
 		throw new ValidationError('Expected a number, got NaN')
 	}
-	throw new ValidationError(`Expected a finite number, got ${value}`)
+	if (!Number.isFinite(number)) {
+		throw new ValidationError(`Expected a finite number, got ${number}`)
+	}
 })
 /**
  * Validator that ensures a value is a non-negative number (\>= 0).
@@ -1192,20 +1028,8 @@ export const number = new Validator<number>((value) => {
  * ```
  * @public
  */
-export const positiveNumber = new Validator<number>((value) => {
-	if (Number.isFinite(value) && (value as number) >= 0) {
-		return value as number
-	}
-	if (typeof value !== 'number') {
-		throw new ValidationError(`Expected number, got ${typeToString(value)}`)
-	}
-	if (value !== value) {
-		throw new ValidationError('Expected a number, got NaN')
-	}
-	if (value < 0) {
-		throw new ValidationError(`Expected a positive number, got ${value}`)
-	}
-	throw new ValidationError(`Expected a finite number, got ${value}`)
+export const positiveNumber = number.check((value) => {
+	if (value < 0) throw new ValidationError(`Expected a positive number, got ${value}`)
 })
 /**
  * Validator that ensures a value is a positive number (\> 0). Rejects zero and negative numbers.
@@ -1218,73 +1042,8 @@ export const positiveNumber = new Validator<number>((value) => {
  * ```
  * @public
  */
-export const nonZeroNumber = new Validator<number>((value) => {
-	if (Number.isFinite(value) && (value as number) > 0) {
-		return value as number
-	}
-	if (typeof value !== 'number') {
-		throw new ValidationError(`Expected number, got ${typeToString(value)}`)
-	}
-	if (value !== value) {
-		throw new ValidationError('Expected a number, got NaN')
-	}
-	if (value <= 0) {
-		throw new ValidationError(`Expected a non-zero positive number, got ${value}`)
-	}
-	throw new ValidationError(`Expected a finite number, got ${value}`)
-})
-/**
- * Validator that ensures a value is a finite, non-zero number. Allows negative numbers.
- * Useful for scale factors that can be negative (for flipping) but not zero.
- *
- * @example
- * ```ts
- * const scale = T.nonZeroFiniteNumber.validate(-1.5) // Returns -1.5 (valid, allows negative)
- * T.nonZeroFiniteNumber.validate(0) // Throws ValidationError: "Expected a non-zero number, got 0"
- * T.nonZeroFiniteNumber.validate(Infinity) // Throws ValidationError
- * ```
- * @public
- */
-export const nonZeroFiniteNumber = new Validator<number>((value) => {
-	if (Number.isFinite(value) && (value as number) !== 0) {
-		return value as number
-	}
-	if (typeof value !== 'number') {
-		throw new ValidationError(`Expected number, got ${typeToString(value)}`)
-	}
-	if (value !== value) {
-		throw new ValidationError('Expected a number, got NaN')
-	}
-	if (value === 0) {
-		throw new ValidationError(`Expected a non-zero number, got 0`)
-	}
-	throw new ValidationError(`Expected a finite number, got ${value}`)
-})
-/**
- * Validator that ensures a value is a number in the unit interval [0, 1].
- * Useful for opacity, percentages expressed as decimals, and other normalized values.
- *
- * @example
- * ```ts
- * const opacity = T.unitInterval.validate(0.5) // Returns 0.5
- * T.unitInterval.validate(0) // Returns 0 (valid)
- * T.unitInterval.validate(1) // Returns 1 (valid)
- * T.unitInterval.validate(1.5) // Throws ValidationError
- * T.unitInterval.validate(-0.1) // Throws ValidationError
- * ```
- * @public
- */
-export const unitInterval = new Validator<number>((value) => {
-	if (Number.isFinite(value) && (value as number) >= 0 && (value as number) <= 1) {
-		return value as number
-	}
-	if (typeof value !== 'number') {
-		throw new ValidationError(`Expected number, got ${typeToString(value)}`)
-	}
-	if (value !== value) {
-		throw new ValidationError('Expected a number, got NaN')
-	}
-	throw new ValidationError(`Expected a number between 0 and 1, got ${value}`)
+export const nonZeroNumber = number.check((value) => {
+	if (value <= 0) throw new ValidationError(`Expected a non-zero positive number, got ${value}`)
 })
 /**
  * Validator that ensures a value is an integer (whole number).
@@ -1297,21 +1056,8 @@ export const unitInterval = new Validator<number>((value) => {
  * ```
  * @public
  */
-export const integer = new Validator<number>((value) => {
-	// Fast path: Number.isInteger checks typeof, finiteness, and integrality in one call
-	if (Number.isInteger(value)) {
-		return value as number
-	}
-	if (typeof value !== 'number') {
-		throw new ValidationError(`Expected number, got ${typeToString(value)}`)
-	}
-	if (value !== value) {
-		throw new ValidationError('Expected a number, got NaN')
-	}
-	if (value - value !== 0) {
-		throw new ValidationError(`Expected a finite number, got ${value}`)
-	}
-	throw new ValidationError(`Expected an integer, got ${value}`)
+export const integer = number.check((value) => {
+	if (!Number.isInteger(value)) throw new ValidationError(`Expected an integer, got ${value}`)
 })
 /**
  * Validator that ensures a value is a non-negative integer (\>= 0).
@@ -1326,23 +1072,8 @@ export const integer = new Validator<number>((value) => {
  * ```
  * @public
  */
-export const positiveInteger = new Validator<number>((value) => {
-	if (Number.isInteger(value) && (value as number) >= 0) {
-		return value as number
-	}
-	if (typeof value !== 'number') {
-		throw new ValidationError(`Expected number, got ${typeToString(value)}`)
-	}
-	if (value !== value) {
-		throw new ValidationError('Expected a number, got NaN')
-	}
-	if (value - value !== 0) {
-		throw new ValidationError(`Expected a finite number, got ${value}`)
-	}
-	if (value < 0) {
-		throw new ValidationError(`Expected a positive integer, got ${value}`)
-	}
-	throw new ValidationError(`Expected an integer, got ${value}`)
+export const positiveInteger = integer.check((value) => {
+	if (value < 0) throw new ValidationError(`Expected a positive integer, got ${value}`)
 })
 /**
  * Validator that ensures a value is a positive integer (\> 0). Rejects zero and negative integers.
@@ -1355,23 +1086,8 @@ export const positiveInteger = new Validator<number>((value) => {
  * ```
  * @public
  */
-export const nonZeroInteger = new Validator<number>((value) => {
-	if (Number.isInteger(value) && (value as number) > 0) {
-		return value as number
-	}
-	if (typeof value !== 'number') {
-		throw new ValidationError(`Expected number, got ${typeToString(value)}`)
-	}
-	if (value !== value) {
-		throw new ValidationError('Expected a number, got NaN')
-	}
-	if (value - value !== 0) {
-		throw new ValidationError(`Expected a finite number, got ${value}`)
-	}
-	if (value <= 0) {
-		throw new ValidationError(`Expected a non-zero positive integer, got ${value}`)
-	}
-	throw new ValidationError(`Expected an integer, got ${value}`)
+export const nonZeroInteger = integer.check((value) => {
+	if (value <= 0) throw new ValidationError(`Expected a non-zero positive integer, got ${value}`)
 })
 
 /**
@@ -1820,14 +1536,13 @@ export function optional<T>(validator: Validatable<T>): Validator<T | undefined>
 			return validator.validate(value)
 		},
 		(knownGoodValue, newValue) => {
+			if (knownGoodValue === undefined && newValue === undefined) return undefined
 			if (newValue === undefined) return undefined
 			if (validator.validateUsingKnownGoodVersion && knownGoodValue !== undefined) {
 				return validator.validateUsingKnownGoodVersion(knownGoodValue as T, newValue)
 			}
 			return validator.validate(newValue)
-		},
-		// Propagate skipSameValueCheck from inner validator to allow refine wrappers
-		validator instanceof Validator && validator.skipSameValueCheck
+		}
 	)
 }
 
@@ -1857,9 +1572,7 @@ export function nullable<T>(validator: Validatable<T>): Validator<T | null> {
 				return validator.validateUsingKnownGoodVersion(knownGoodValue as T, newValue)
 			}
 			return validator.validate(newValue)
-		},
-		// Propagate skipSameValueCheck from inner validator to allow refine wrappers
-		validator instanceof Validator && validator.skipSameValueCheck
+		}
 	)
 }
 

package/src/test/validation.test.ts

@@ -117,56 +117,23 @@ describe('validations', () => {
 			`[ValidationError: At animal(type = cat).meow: Expected boolean, got undefined]`
 		)
 	})
-
-	it('Rejects Infinity and -Infinity in numberUnion discriminators', () => {
-		const numberUnionSchema = T.numberUnion('version', {
-			1: T.object({ version: T.literal(1), data: T.string }),
-			2: T.object({ version: T.literal(2), data: T.string }),
-		})
-
-		// Valid cases
-		expect(numberUnionSchema.validate({ version: 1, data: 'hello' })).toEqual({
-			version: 1,
-			data: 'hello',
-		})
-		expect(numberUnionSchema.validate({ version: 2, data: 'world' })).toEqual({
-			version: 2,
-			data: 'world',
-		})
-
-		// Should reject Infinity
-		expect(() =>
-			numberUnionSchema.validate({ version: Infinity, data: 'test' })
-		).toThrowErrorMatchingInlineSnapshot(
-			`[ValidationError: At null: Expected a number for key "version", got "Infinity"]`
-		)
-
-		// Should reject -Infinity
-		expect(() =>
-			numberUnionSchema.validate({ version: -Infinity, data: 'test' })
-		).toThrowErrorMatchingInlineSnapshot(
-			`[ValidationError: At null: Expected a number for key "version", got "-Infinity"]`
-		)
-
-		// Should reject NaN
-		expect(() => numberUnionSchema.validate({ version: NaN, data: 'test' })).toThrowError(
-			/Expected a number for key "version"/
-		)
-	})
 })
 
 describe('T.refine', () => {
 	it('Refines a validator.', () => {
-		// refine can transform values (e.g., string to number)
 		const stringToNumber = T.string.refine((str) => parseInt(str, 10))
+		const originalEnv = process.env.NODE_ENV
+		process.env.NODE_ENV = 'production'
 		expect(stringToNumber.validate('42')).toBe(42)
+		process.env.NODE_ENV = originalEnv
 
-		// refine can also modify values of the same type
 		const prefixedString = T.string.refine((str) =>
 			str.startsWith('prefix:') ? str : `prefix:${str}`
 		)
+		process.env.NODE_ENV = 'production'
 		expect(prefixedString.validate('test')).toBe('prefix:test')
 		expect(prefixedString.validate('prefix:existing')).toBe('prefix:existing')
+		process.env.NODE_ENV = originalEnv
 	})
 
 	it('Produces a type error if the refinement is not of the correct type.', () => {