@atproto/lex-schema 0.0.4 → 0.0.6

package/dist/util/memoize.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoizedOptions = memoizedOptions;
+exports.memoizedTransformer = memoizedTransformer;
+/*@__NO_SIDE_EFFECTS__*/
+function memoizedOptions(fn, keyFn) {
+    let emptyOptionsValue;
+    if (keyFn) {
+        const cache = new Map();
+        const fromCache = (options) => {
+            const key = keyFn(options);
+            if (key !== undefined) {
+                const cached = cache.get(key);
+                if (cached)
+                    return cached;
+                const result = fn(options);
+                cache.set(key, result);
+                return result;
+            }
+            return fn(options);
+        };
+        return ((options) => {
+            // Non-empty options case
+            if (options)
+                for (const _ in options)
+                    return fromCache(options);
+            // Empty or missing options case
+            return (emptyOptionsValue ??= fn(options));
+        });
+    }
+    return ((options) => {
+        // Non-empty options case
+        if (options)
+            for (const _ in options)
+                return fn(options);
+        // Empty or missing options case
+        return (emptyOptionsValue ??= fn(options));
+    });
+}
+/*@__NO_SIDE_EFFECTS__*/
+function memoizedTransformer(fn) {
+    const cache = new WeakMap();
+    return ((arg) => {
+        const cached = cache.get(arg);
+        if (cached)
+            return cached;
+        const result = fn(arg);
+        cache.set(arg, result);
+        return result;
+    });
+}
+//# sourceMappingURL=memoize.js.map

package/dist/util/memoize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.js","sourceRoot":"","sources":["../../src/util/memoize.ts"],"names":[],"mappings":";;AACA,0CA2CC;AAGD,kDASC;AAxDD,wBAAwB;AACxB,SAAgB,eAAe,CAG7B,EAAK,EACL,KAE4C;IAE5C,IAAI,iBAA4C,CAAA;IAEhD,IAAI,KAAK,EAAE,CAAC;QACV,MAAM,KAAK,GAAG,IAAI,GAAG,EAAmD,CAAA;QACxE,MAAM,SAAS,GAAG,CAChB,OAAsC,EACvB,EAAE;YACjB,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,CAAC,CAAA;YAC1B,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;gBACtB,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;gBAC7B,IAAI,MAAM;oBAAE,OAAO,MAAM,CAAA;gBACzB,MAAM,MAAM,GAAG,EAAE,CAAC,OAAO,CAAkB,CAAA;gBAC3C,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;gBACtB,OAAO,MAAM,CAAA;YACf,CAAC;YAED,OAAO,EAAE,CAAC,OAAO,CAAC,CAAA;QACpB,CAAC,CAAA;QAED,OAAO,CAAC,CAAC,OAAyB,EAAiB,EAAE;YACnD,yBAAyB;YACzB,IAAI,OAAO;gBAAE,KAAK,MAAM,CAAC,IAAI,OAAO;oBAAE,OAAO,SAAS,CAAC,OAAO,CAAC,CAAA;YAE/D,gCAAgC;YAChC,OAAO,CAAC,iBAAiB,KAAK,EAAE,CAAC,OAAO,CAAC,CAAC,CAAA;QAC5C,CAAC,CAAM,CAAA;IACT,CAAC;IAED,OAAO,CAAC,CAAC,OAAyB,EAAiB,EAAE;QACnD,yBAAyB;QACzB,IAAI,OAAO;YAAE,KAAK,MAAM,CAAC,IAAI,OAAO;gBAAE,OAAO,EAAE,CAAC,OAAO,CAAC,CAAA;QAExD,gCAAgC;QAChC,OAAO,CAAC,iBAAiB,KAAK,EAAE,CAAC,OAAO,CAAC,CAAC,CAAA;IAC5C,CAAC,CAAM,CAAA;AACT,CAAC;AAED,wBAAwB;AACxB,SAAgB,mBAAmB,CAA8B,EAAK;IACpE,MAAM,KAAK,GAAG,IAAI,OAAO,EAAyB,CAAA;IAClD,OAAO,CAAC,CAAC,GAAqB,EAAiB,EAAE;QAC/C,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QAC7B,IAAI,MAAM;YAAE,OAAO,MAAM,CAAA;QACzB,MAAM,MAAM,GAAG,EAAE,CAAC,GAAG,CAAkB,CAAA;QACvC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;QACtB,OAAO,MAAM,CAAA;IACf,CAAC,CAAM,CAAA;AACT,CAAC","sourcesContent":["/*@__NO_SIDE_EFFECTS__*/\nexport function memoizedOptions<\n  F extends (options?: NonNullable<unknown>) => any,\n>(\n  fn: F,\n  keyFn?: (\n    options: NonNullable<Parameters<F>[0]>,\n  ) => string | number | boolean | null | void,\n): F {\n  let emptyOptionsValue: ReturnType<F> | undefined\n\n  if (keyFn) {\n    const cache = new Map<string | number | boolean | null, ReturnType<F>>()\n    const fromCache = (\n      options: NonNullable<Parameters<F>[0]>,\n    ): ReturnType<F> => {\n      const key = keyFn(options)\n      if (key !== undefined) {\n        const cached = cache.get(key)\n        if (cached) return cached\n        const result = fn(options) as ReturnType<F>\n        cache.set(key, result)\n        return result\n      }\n\n      return fn(options)\n    }\n\n    return ((options: Parameters<F>[0]): ReturnType<F> => {\n      // Non-empty options case\n      if (options) for (const _ in options) return fromCache(options)\n\n      // Empty or missing options case\n      return (emptyOptionsValue ??= fn(options))\n    }) as F\n  }\n\n  return ((options: Parameters<F>[0]): ReturnType<F> => {\n    // Non-empty options case\n    if (options) for (const _ in options) return fn(options)\n\n    // Empty or missing options case\n    return (emptyOptionsValue ??= fn(options))\n  }) as F\n}\n\n/*@__NO_SIDE_EFFECTS__*/\nexport function memoizedTransformer<F extends (arg: any) => any>(fn: F): F {\n  const cache = new WeakMap<object, ReturnType<F>>()\n  return ((arg: Parameters<F>[0]): ReturnType<F> => {\n    const cached = cache.get(arg)\n    if (cached) return cached\n    const result = fn(arg) as ReturnType<F>\n    cache.set(arg, result)\n    return result\n  }) as F\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/lex-schema",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "license": "MIT",
   "description": "Lexicon schema system for AT Lexicons",
   "keywords": [
@@ -28,22 +28,22 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "browser": "./dist/index.js",
       "import": "./dist/index.js",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/index.js"
     }
   },
   "dependencies": {
     "tslib": "^2.8.1",
     "@atproto/syntax": "0.4.2",
-    "@atproto/lex-data": "0.0.3"
+    "@atproto/lex-data": "0.0.5"
   },
   "devDependencies": {
-    "jest": "^28.1.2"
+    "vitest": "^4.0.16"
   },
   "scripts": {
     "build": "tsc --build tsconfig.build.json",
-    "test": "jest"
+    "test": "vitest run"
   }
 }

package/src/core/$type.ts

@@ -1,4 +1,5 @@
 import { NsidString } from './string-format.js'
+import { OmitKey } from './types.js'
 
 export type $Type<
   N extends NsidString = NsidString,
@@ -20,3 +21,6 @@ export function $type<N extends NsidString, H extends string>(
 ): $Type<N, H> {
   return (hash === 'main' ? nsid : `${nsid}#${hash}`) as $Type<N, H>
 }
+
+export type $Typed<V, T extends string = string> = V & { $type: T }
+export type Un$Typed<V extends { $type?: string }> = OmitKey<V, '$type'>

package/src/core/result.ts

@@ -1,5 +1,5 @@
 export type ResultSuccess<V = any> = { success: true; value: V }
-export type ResultFailure<E = Error> = { success: false; error: E }
+export type ResultFailure<E = Error> = { success: false; reason: E }
 
 export type Result<V = any, E = Error> = ResultSuccess<V> | ResultFailure<E>
 
@@ -9,13 +9,13 @@ export function success<V>(value: V): ResultSuccess<V> {
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-export function failure<E>(error: E): ResultFailure<E> {
-  return { success: false, error }
+export function failure<E>(reason: E): ResultFailure<E> {
+  return { success: false, reason }
 }
 
 /*@__NO_SIDE_EFFECTS__*/
-export function failureError<T>(result: ResultFailure<T>): T {
-  return result.error
+export function failureReason<T>(result: ResultFailure<T>): T {
+  return result.reason
 }
 
 /*@__NO_SIDE_EFFECTS__*/
@@ -31,9 +31,9 @@ export function successValue<T>(result: ResultSuccess<T>): T {
  * @example
  *
  * ```ts
- * declare function someFunction(): Promise<ResultSuccess<string>>
+ * declare function someFunction(): Promise<string>
  *
- * const result = await someFunction().catch(catchall)
+ * const result = await someFunction().then(success, catchall)
  * if (result.success) {
  *   console.log(result.value) // string
  * } else {
@@ -58,9 +58,10 @@ export function catchall(err: unknown): ResultFailure<Error> {
  * class FooError extends Error {}
  * class BarError extends Error {}
  *
- * declare function someFunction(): Promise<ResultSuccess<string>>
+ * declare function someFunction(): Promise<string>
  *
  * const result = await someFunction()
+ *   .then(success)
  *   .catch(createCatcher(FooError))
  *   .catch(createCatcher(BarError))
  *

package/src/{validation → core}/schema.ts

@@ -5,17 +5,42 @@ import {
   ValidatorContext,
 } from './validator.js'
 
-export abstract class Schema<Output> implements Validator<Output> {
-  declare readonly ['_lex']: { output: Output }
+export abstract class Schema<Output = any> implements Validator<Output> {
+  declare readonly ['__lex']: { output: Output }
 
   abstract validateInContext(
     input: unknown,
     ctx: ValidatorContext,
   ): ValidationResult<Output>
 
+  /**
+   * @note use {@link check}() instead of {@link assert}() if you encounter a
+   * `ts(2775)` error and you are not able to fully type the validator. This
+   * will typically arise in generic contexts, where the narrowed type is not
+   * needed.
+   */
   assert(input: unknown): asserts input is Output {
     const result = this.safeParse(input, { allowTransform: false })
-    if (!result.success) throw result.error
+    if (!result.success) throw result.reason
+  }
+
+  /**
+   * Alias for {@link assert}(). Most useful in generic contexts where the
+   * validator is not exactly typed, allowing to avoid "_Assertions require
+   * every name in the call target to be declared with an explicit type
+   * annotation. ts(2775)_" errors.
+   */
+  check(input: unknown): void {
+    this.assert(input)
+  }
+
+  /**
+   * Casts the input (by validating it) to the output type if it matches the
+   * schema, otherwise throws. This is the same as calling {@link parse}() with
+   * `allowTransform: false`.
+   */
+  cast<I>(input: I): I & Output {
+    return this.parse(input, { allowTransform: false })
   }
 
   matches(input: unknown): input is Output {
@@ -34,7 +59,7 @@ export abstract class Schema<Output> implements Validator<Output> {
   parse(input: unknown, options?: ValidationOptions): Output
   parse(input: unknown, options?: ValidationOptions): Output {
     const result = this.safeParse(input, options)
-    if (!result.success) throw result.error
+    if (!result.success) throw result.reason
     return result.value
   }
 

package/src/core/string-format.ts

@@ -1,4 +1,4 @@
-import { ensureValidCidString, isLanguage } from '@atproto/lex-data'
+import { ensureValidCidString, isLanguageString } from '@atproto/lex-data'
 import {
   AtIdentifierString,
   AtUriString,
@@ -17,16 +17,25 @@ import {
   ensureValidRecordKey,
   ensureValidTid,
 } from '@atproto/syntax'
-
-type AssertFn<T> = <I extends string>(input: I) => asserts input is I & T
-type CastFn<T> = <I extends string>(input: I) => I & T
+import {
+  AssertFn,
+  CastFn,
+  CheckFn,
+  createAssertFunction,
+  createCastFunction,
+  createCheckFunction,
+} from '../util/assertion-util.js'
+
+// Format utilities missing from @atproto/syntax
+export type CidString = string
+export type LanguageString = string
+export type UriString = `${string}:${string}`
 
 /*@__NO_SIDE_EFFECTS__*/
-function createCastFunction<T>(assertFn: AssertFn<T>): CastFn<T> {
-  return <I extends string>(input: I) => {
-    assertFn(input)
-    return input as I & T
-  }
+export function isUriString<T extends string>(
+  input: T,
+): input is T & UriString {
+  return /^\w+:(?:\/\/)?[^\s/][^\s]*$/.test(input)
 }
 
 // Re-export utility typed as assertion functions so that TypeScript can
@@ -41,61 +50,72 @@ export type {
   NsidString,
   RecordKeyString,
   TidString,
-}
-
-export const assertDid: AssertFn<DidString> = ensureValidDid
-export const assertAtUri: AssertFn<AtUriString> = ensureValidAtUri
-export const assertAtIdentifier: AssertFn<AtIdentifierString> =
-  ensureValidAtIdentifier
-export const assertNsid: AssertFn<NsidString> = ensureValidNsid
-export const assertTid: AssertFn<TidString> = ensureValidTid
-export const assertRecordKey: AssertFn<RecordKeyString> = ensureValidRecordKey
-export const assertDatetime: AssertFn<DatetimeString> = ensureValidDatetime
-export const assertCidString: AssertFn<string> = ensureValidCidString
-export const assertHandle: AssertFn<HandleString> = ensureValidHandle
+} from '@atproto/syntax'
 
 // Export utilities for formats missing from @atproto/syntax
 
-export type CidString = string
-export type UriString = `${string}:${string}`
-export type LanguageString = string
-
-/*@__NO_SIDE_EFFECTS__*/
-export function assertUri(input: string): asserts input is UriString {
-  if (!/^\w+:(?:\/\/)?[^\s/][^\s]*$/.test(input)) {
-    throw new Error('Invalid URI')
-  }
-}
-
-/*@__NO_SIDE_EFFECTS__*/
-export function assertLanguage(input: string): asserts input is LanguageString {
-  if (!isLanguage(input)) {
-    throw new Error('Invalid BCP 47 string')
-  }
-}
-
-export const asDid: CastFn<DidString> =
-  /*#__PURE__*/ createCastFunction(ensureValidDid)
-export const asAtUri: CastFn<AtUriString> =
+export const assertAtIdentifierString: AssertFn<AtIdentifierString> =
+  ensureValidAtIdentifier
+export const assertAtUriString: AssertFn<AtUriString> = ensureValidAtUri
+export const assertCidString: AssertFn<CidString> = ensureValidCidString
+export const assertDatetimeString: AssertFn<DatetimeString> =
+  ensureValidDatetime
+export const assertDidString: AssertFn<DidString> = ensureValidDid
+export const assertHandleString: AssertFn<HandleString> = ensureValidHandle
+export const assertLanguageString: AssertFn<LanguageString> =
+  createAssertFunction<LanguageString>(
+    isLanguageString,
+    'Invalid BCP 47 string',
+  )
+export const assertNsidString: AssertFn<NsidString> = ensureValidNsid
+export const assertRecordKeyString: AssertFn<RecordKeyString> =
+  ensureValidRecordKey
+export const assertTidString: AssertFn<TidString> = ensureValidTid
+export const assertUriString: AssertFn<UriString> =
+  createAssertFunction<UriString>(isUriString, 'Invalid URI')
+
+export const asAtIdentifierString: CastFn<AtIdentifierString> =
+  /*#__PURE__*/ createCastFunction(assertAtIdentifierString)
+export const asAtUriString: CastFn<AtUriString> =
   /*#__PURE__*/ createCastFunction(ensureValidAtUri)
-export const asNsid: CastFn<NsidString> =
-  /*#__PURE__*/ createCastFunction(ensureValidNsid)
-export const asTid: CastFn<TidString> =
-  /*#__PURE__*/ createCastFunction(ensureValidTid)
-export const asRecordKey: CastFn<RecordKeyString> =
-  /*#__PURE__*/ createCastFunction(ensureValidRecordKey)
-export const asDatetime: CastFn<DatetimeString> =
-  /*#__PURE__*/ createCastFunction(ensureValidDatetime)
-export const asCidString: CastFn<string> =
+export const asCidString: CastFn<CidString> =
   /*#__PURE__*/ createCastFunction(ensureValidCidString)
-export const asHandle: CastFn<HandleString> =
+export const asDatetimeString: CastFn<DatetimeString> =
+  /*#__PURE__*/ createCastFunction(ensureValidDatetime)
+export const asDidString: CastFn<DidString> =
+  /*#__PURE__*/ createCastFunction(ensureValidDid)
+export const asHandleString: CastFn<HandleString> =
   /*#__PURE__*/ createCastFunction(ensureValidHandle)
-export const asUri: CastFn<UriString> =
-  /*#__PURE__*/ createCastFunction(assertUri)
-export const asLanguage: CastFn<LanguageString> =
-  /*#__PURE__*/ createCastFunction(assertLanguage)
-export const asAtIdentifier: CastFn<AtIdentifierString> =
-  /*#__PURE__*/ createCastFunction(assertAtIdentifier)
+export const asLanguageString: CastFn<LanguageString> =
+  /*#__PURE__*/ createCastFunction(assertLanguageString)
+export const asNsidString: CastFn<NsidString> =
+  /*#__PURE__*/ createCastFunction(ensureValidNsid)
+export const asRecordKeyString: CastFn<RecordKeyString> =
+  /*#__PURE__*/ createCastFunction(ensureValidRecordKey)
+export const asTidString: CastFn<TidString> =
+  /*#__PURE__*/ createCastFunction(ensureValidTid)
+export const asUriString: CastFn<UriString> =
+  /*#__PURE__*/ createCastFunction(assertUriString)
+
+export { isLanguageString }
+export const isAtIdentifierString: CheckFn<AtIdentifierString> =
+  /*#__PURE__*/ createCheckFunction(assertAtIdentifierString)
+export const isAtUriString: CheckFn<AtUriString> =
+  /*#__PURE__*/ createCheckFunction(assertAtIdentifierString)
+export const isCidString: CheckFn<CidString> =
+  /*#__PURE__*/ createCheckFunction(assertCidString)
+export const isDatetimeString: CheckFn<DatetimeString> =
+  /*#__PURE__*/ createCheckFunction(assertDatetimeString)
+export const isDidString: CheckFn<DidString> =
+  /*#__PURE__*/ createCheckFunction(assertDidString)
+export const isHandleString: CheckFn<HandleString> =
+  /*#__PURE__*/ createCheckFunction(assertHandleString)
+export const isNsidString: CheckFn<NsidString> =
+  /*#__PURE__*/ createCheckFunction(assertNsidString)
+export const isRecordKeyString: CheckFn<RecordKeyString> =
+  /*#__PURE__*/ createCheckFunction(assertRecordKeyString)
+export const isTidString: CheckFn<TidString> =
+  /*#__PURE__*/ createCheckFunction(assertTidString)
 
 // String formatting types and utilities
 
@@ -135,17 +155,17 @@ export type InferStringFormat<F> =
                   string
 
 const formatters = /*#__PURE__*/ new Map<StringFormat, (str: string) => void>([
-  ['datetime', assertDatetime],
-  ['uri', assertUri],
-  ['at-uri', assertAtUri],
-  ['did', assertDid],
-  ['handle', assertHandle],
-  ['at-identifier', assertAtIdentifier],
-  ['nsid', assertNsid],
+  ['at-identifier', assertAtIdentifierString],
+  ['at-uri', assertAtUriString],
   ['cid', assertCidString],
-  ['language', assertLanguage],
-  ['tid', assertTid],
-  ['record-key', assertRecordKey],
+  ['datetime', assertDatetimeString],
+  ['did', assertDidString],
+  ['handle', assertHandleString],
+  ['language', assertLanguageString],
+  ['nsid', assertNsidString],
+  ['record-key', assertRecordKeyString],
+  ['tid', assertTidString],
+  ['uri', assertUriString],
 ] as const)
 
 /*@__NO_SIDE_EFFECTS__*/

package/src/core/types.ts

@@ -26,3 +26,7 @@ export type WithOptionalProperties<P> = Simplify<
     -readonly [K in keyof P as undefined extends P[K] ? K : never]?: P[K]
   }
 >
+
+export type OmitKey<T, K extends keyof T> = {
+  [K2 in keyof T as K2 extends K ? never : K2]: T[K2]
+}

package/src/{validation → core}/validation-error.ts

@@ -1,36 +1,44 @@
-import { ResultFailure, failureError } from '../core.js'
+import { LexError } from '@atproto/lex-data'
 import { arrayAgg } from '../util/array-agg.js'
+import { ResultFailure, failureReason } from './result.js'
 import {
   Issue,
   IssueInvalidType,
   IssueInvalidValue,
 } from './validation-issue.js'
 
-export class ValidationError extends Error {
+export class ValidationError extends LexError {
   name = 'ValidationError'
 
   readonly issues: Issue[]
 
   constructor(issues: Issue[], options?: ErrorOptions) {
     const issuesAgg = aggregateIssues(issues)
-    super(issuesAgg.join(', '), options)
+    super('InvalidRequest', issuesAgg.join(', '), options)
     this.issues = issuesAgg
   }
 
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      issues: this.issues.map((issue) => issue.toJSON()),
+    }
+  }
+
   static fromFailures(
     failures: ResultFailure<ValidationError>[],
   ): ValidationError {
-    if (failures.length === 1) return failures[0].error
+    if (failures.length === 1) return failureReason(failures[0])
     const issues = failures.flatMap(extractFailureIssues)
     return new ValidationError(issues, {
       // Keep the original errors as the cause chain
-      cause: failures.map(failureError),
+      cause: failures.map(failureReason),
     })
   }
 }
 
 function extractFailureIssues(result: ResultFailure<ValidationError>) {
-  return result.error.issues
+  return result.reason.issues
 }
 
 function aggregateIssues(issues: Issue[]): Issue[] {

package/src/{validation → core}/validation-issue.ts

@@ -9,6 +9,14 @@ export abstract class Issue {
   ) {}
 
   abstract toString(): string
+
+  toJSON() {
+    return {
+      code: this.code,
+      path: this.path,
+      message: this.toString(),
+    }
+  }
 }
 
 export class IssueCustom extends Issue {
@@ -39,6 +47,13 @@ export class IssueInvalidFormat extends Issue {
     return `Invalid ${this.formatDescription} format${this.message ? ` (${this.message})` : ''}${stringifyPath(this.path)} (got ${stringifyValue(this.input)})`
   }
 
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      format: this.format,
+    }
+  }
+
   get formatDescription(): string {
     switch (this.format) {
       case 'at-identifier':
@@ -71,6 +86,13 @@ export class IssueInvalidType extends Issue {
   toString() {
     return `Expected ${oneOf(this.expected.map(stringifyExpectedType))} value type${stringifyPath(this.path)} (got ${stringifyType(this.input)})`
   }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      expected: this.expected,
+    }
+  }
 }
 
 export class IssueInvalidValue extends Issue {
@@ -85,6 +107,13 @@ export class IssueInvalidValue extends Issue {
   toString() {
     return `Expected ${oneOf(this.values.map(stringifyValue))}${stringifyPath(this.path)} (got ${stringifyValue(this.input)})`
   }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      values: this.values,
+    }
+  }
 }
 
 export class IssueRequiredKey extends Issue {
@@ -99,6 +128,13 @@ export class IssueRequiredKey extends Issue {
   toString() {
     return `Missing required key "${String(this.key)}"${stringifyPath(this.path)}`
   }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      key: this.key,
+    }
+  }
 }
 
 export type MeasurableType =
@@ -123,6 +159,14 @@ export class IssueTooBig extends Issue {
   toString() {
     return `${this.type} too big (maximum ${this.maximum})${stringifyPath(this.path)} (got ${this.actual})`
   }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      type: this.type,
+      maximum: this.maximum,
+    }
+  }
 }
 
 export class IssueTooSmall extends Issue {
@@ -139,6 +183,14 @@ export class IssueTooSmall extends Issue {
   toString() {
     return `${this.type} too small (minimum ${this.minimum})${stringifyPath(this.path)} (got ${this.actual})`
   }
+
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      type: this.type,
+      minimum: this.minimum,
+    }
+  }
 }
 
 function stringifyExpectedType(expected: string): string {
@@ -184,8 +236,18 @@ function stringifyType(value: unknown): string {
       if (value instanceof Set) return 'set'
       return 'object'
     case 'number':
-      if (Number.isInteger(value)) return 'integer'
-      if (Number.isNaN(value)) return 'NaN'
+      if (Number.isInteger(value) && Number.isSafeInteger(value)) {
+        return 'integer'
+      }
+      if (Number.isNaN(value)) {
+        return 'NaN'
+      }
+      if (value === Infinity) {
+        return 'Infinity'
+      }
+      if (value === -Infinity) {
+        return '-Infinity'
+      }
       return 'float'
     default:
       return typeof value

package/src/{validation → core}/validator.ts

@@ -1,5 +1,5 @@
-import { ResultFailure, ResultSuccess, failure, success } from '../core.js'
 import { PropertyKey } from './property-key.js'
+import { ResultFailure, ResultSuccess, failure, success } from './result.js'
 import { ValidationError } from './validation-error.js'
 import {
   Issue,
@@ -25,7 +25,7 @@ export type ValidationOptions = {
   allowTransform?: boolean
 }
 
-export type Infer<T extends Validator> = T['_lex']['output']
+export type Infer<T extends Validator> = T['__lex']['output']
 
 export interface Validator<Output = any> {
   /**
@@ -34,7 +34,7 @@ export interface Validator<Output = any> {
    *
    * @deprecated **INTERNAL API, DO NOT USE**.
    */
-  readonly ['_lex']: { output: Output }
+  readonly ['__lex']: { output: Output }
 
   /**
    * @internal **INTERNAL API**: use {@link ValidatorContext.validate} instead
@@ -162,24 +162,28 @@ export class ValidatorContext {
     return success(value)
   }
 
-  failure(issue: Issue): ValidationFailure {
-    return failure(new ValidationError([...this.issues, issue]))
+  failure(reason: ValidationError): ValidationFailure {
+    return failure(reason)
+  }
+
+  issue(issue: Issue) {
+    return this.failure(new ValidationError([...this.issues, issue]))
   }
 
   issueInvalidValue(input: unknown, values: readonly unknown[]) {
-    return this.failure(new IssueInvalidValue(this.path, input, values))
+    return this.issue(new IssueInvalidValue(this.path, input, values))
   }
 
   issueInvalidType(input: unknown, expected: string) {
-    return this.failure(new IssueInvalidType(this.path, input, [expected]))
+    return this.issue(new IssueInvalidType(this.path, input, [expected]))
   }
 
   issueRequiredKey(input: object, key: PropertyKey) {
-    return this.failure(new IssueRequiredKey(this.path, input, key))
+    return this.issue(new IssueRequiredKey(this.path, input, key))
   }
 
   issueInvalidFormat(input: unknown, format: string, msg?: string) {
-    return this.failure(new IssueInvalidFormat(this.path, input, format, msg))
+    return this.issue(new IssueInvalidFormat(this.path, input, format, msg))
   }
 
   issueTooBig(
@@ -188,7 +192,7 @@ export class ValidatorContext {
     max: number,
     actual: number,
   ) {
-    return this.failure(new IssueTooBig(this.path, input, max, type, actual))
+    return this.issue(new IssueTooBig(this.path, input, max, type, actual))
   }
 
   issueTooSmall(
@@ -197,7 +201,7 @@ export class ValidatorContext {
     min: number,
     actual: number,
   ) {
-    return this.failure(new IssueTooSmall(this.path, input, min, type, actual))
+    return this.issue(new IssueTooSmall(this.path, input, min, type, actual))
   }
 
   issueInvalidPropertyValue<I>(
@@ -207,7 +211,7 @@ export class ValidatorContext {
   ) {
     const value = input[property]
     const path = this.concatPath(property)
-    return this.failure(new IssueInvalidValue(path, value, values))
+    return this.issue(new IssueInvalidValue(path, value, values))
   }
 
   issueInvalidPropertyType<I>(
@@ -217,6 +221,6 @@ export class ValidatorContext {
   ) {
     const value = input[property]
     const path = this.concatPath(property)
-    return this.failure(new IssueInvalidType(path, value, [expected]))
+    return this.issue(new IssueInvalidType(path, value, [expected]))
   }
 }