@atproto/lex-schema 0.0.16 → 0.0.18

package/dist/schema/typed-object.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typed-object.d.ts","sourceRoot":"","sources":["../../src/schema/typed-object.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"typed-object.d.ts","sourceRoot":"","sources":["../../src/schema/typed-object.ts"],"names":[],"mappings":"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"}

package/dist/schema/typed-object.js

@@ -44,7 +44,7 @@ class TypedObjectSchema extends core_js_1.Schema {
         return ctx.validate(input, this.schema);
     }
     build(input) {
-        return this.parse((0, core_js_1.$typed)(input, this.$type));
+        return (0, core_js_1.$typed)(input, this.$type);
     }
     isTypeOf(value) {
         return value.$type === undefined || value.$type === this.$type;

package/dist/schema/typed-object.js.map

@@ -1 +1 @@
-{"version":3,"file":"typed-object.js","sourceRoot":"","sources":["../../src/schema/typed-object.ts"],"names":[],"mappings":";;;AA6KA,kCAMC;AAnLD,gDAAiD;AACjD,wCAcmB;AACnB,+DAAuD;AASvD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAa,iBAGX,SAAQ,gBAGT;IAIY;IACA;IAJF,IAAI,GAAG,aAAsB,CAAA;IAEtC,YACW,KAAY,EACZ,MAAc;QAEvB,KAAK,EAAE,CAAA;QAHE,UAAK,GAAL,KAAK,CAAO;QACZ,WAAM,GAAN,MAAM,CAAQ;IAGzB,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,IAAA,wBAAa,EAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;QACjD,CAAC;QAED,IACE,OAAO,IAAI,KAAK;YAChB,KAAK,CAAC,KAAK,KAAK,SAAS;YACzB,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,EAC1B,CAAC;YACD,OAAO,GAAG,CAAC,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;QACpE,CAAC;QAED,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;IACzC,CAAC;IAED,KAAK,CACH,KAAsC;QAEtC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAA,gBAAM,EAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAG1C,CAAA;IACH,CAAC;IAED,QAAQ,CACN,KAAa;QAEb,OAAO,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,CAAA;IAChE,CAAC;IAED;;;OAGG;IACH,IAAI,MAAM;QACR,OAAO,IAAA,+BAAY,EAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAA;IAC5D,CAAC;IAED;;;OAGG;IACH,IAAI,SAAS;QACX,OAAO,IAAA,+BAAY,EAAC,IAAI,EAAE,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAA;IAClE,CAAC;CACF;AA9DD,8CA8DC;AAmED,wBAAwB;AACxB,SAAgB,WAAW,CAIzB,IAAO,EAAE,IAAO,EAAE,SAAY;IAC9B,OAAO,IAAI,iBAAiB,CAAiB,IAAA,eAAK,EAAC,IAAI,EAAE,IAAI,CAAC,EAAE,SAAS,CAAC,CAAA;AAC5E,CAAC","sourcesContent":["import { isPlainObject } from '@atproto/lex-data'\nimport {\n  $Type,\n  $TypeOf,\n  $Typed,\n  $TypedMaybe,\n  $type,\n  $typed,\n  InferInput,\n  InferOutput,\n  NsidString,\n  Schema,\n  Unknown$TypedObject,\n  ValidationContext,\n  Validator,\n} from '../core.js'\nimport { lazyProperty } from '../util/lazy-property.js'\n\nexport type MaybeTypedObject<\n  TType extends $Type,\n  TValue extends { $type?: unknown } = { $type?: unknown },\n> = TValue extends { $type?: TType }\n  ? TValue\n  : $TypedMaybe<Exclude<TValue, Unknown$TypedObject>, TType>\n\n/**\n * Schema for typed objects in Lexicon unions.\n *\n * Typed objects have a `$type` field that identifies which variant they are\n * in a union. The `$type` can be omitted in input (it's implicit), but if\n * present, it must match the expected value.\n *\n * @template TType - The $type string literal type\n * @template TShape - The validator type for the object's shape\n *\n * @example\n * ```ts\n * const schema = new TypedObjectSchema(\n *   'app.bsky.embed.images#view',\n *   l.object({ images: l.array(imageSchema) })\n * )\n * ```\n */\nexport class TypedObjectSchema<\n  const TType extends $Type = $Type,\n  const TShape extends Validator<{ [k: string]: unknown }> = any,\n> extends Schema<\n  $TypedMaybe<InferInput<TShape>, TType>,\n  $TypedMaybe<InferOutput<TShape>, TType>\n> {\n  readonly type = 'typedObject' as const\n\n  constructor(\n    readonly $type: TType,\n    readonly schema: TShape,\n  ) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isPlainObject(input)) {\n      return ctx.issueUnexpectedType(input, 'object')\n    }\n\n    if (\n      '$type' in input &&\n      input.$type !== undefined &&\n      input.$type !== this.$type\n    ) {\n      return ctx.issueInvalidPropertyValue(input, '$type', [this.$type])\n    }\n\n    return ctx.validate(input, this.schema)\n  }\n\n  build(\n    input: Omit<InferInput<this>, '$type'>,\n  ): $Typed<InferOutput<this>, TType> {\n    return this.parse($typed(input, this.$type)) as $Typed<\n      InferOutput<this>,\n      TType\n    >\n  }\n\n  isTypeOf<TValue extends Record<string, unknown>>(\n    value: TValue,\n  ): value is MaybeTypedObject<TType, TValue> {\n    return value.$type === undefined || value.$type === this.$type\n  }\n\n  /**\n   * Bound alias for {@link build} for compatibility with generated utilities.\n   * @see {@link build}\n   */\n  get $build(): typeof this.build {\n    return lazyProperty(this, '$build', this.build.bind(this))\n  }\n\n  /**\n   * Bound alias for {@link isTypeOf} for compatibility with generated utilities.\n   * @see {@link isTypeOf}\n   */\n  get $isTypeOf(): typeof this.isTypeOf {\n    return lazyProperty(this, '$isTypeOf', this.isTypeOf.bind(this))\n  }\n}\n\n/**\n * Creates a typed object schema for use in Lexicon unions.\n *\n * Typed objects are identified by their `$type` field, which combines an NSID\n * and a hash (e.g., 'app.bsky.embed.images#view'). Used for union variants.\n *\n * This function offers two overloads:\n * - One that infers the type from arguments (no circular reference support)\n * - One with explicit interface for codegen with circular references\n *\n * @param nsid - The NSID part of the type (e.g., 'app.bsky.embed.images')\n * @param hash - The hash part of the type (e.g., 'view'), defaults to 'main'\n * @param validator - Schema for validating the object properties\n * @returns A new {@link TypedObjectSchema} instance\n *\n * @example\n * ```ts\n * // Image embed view\n * const imageViewSchema = l.typedObject(\n *   'app.bsky.embed.images',\n *   'view',\n *   l.object({\n *     images: l.array(l.object({\n *       thumb: l.string(),\n *       fullsize: l.string(),\n *       alt: l.string(),\n *     })),\n *   })\n * )\n *\n * // Main type (hash defaults to 'main')\n * const postViewSchema = l.typedObject(\n *   'app.bsky.feed.defs',\n *   'postView',\n *   l.object({ uri: l.string(), cid: l.string(), author: authorSchema })\n * )\n *\n * // Use $isTypeOf to narrow union types\n * if (imageViewSchema.$isTypeOf(embed)) {\n *   // embed is narrowed to image view type\n * }\n *\n * // Use $build to construct typed objects\n * const view = imageViewSchema.$build({ images: [...] })\n * // view.$type === 'app.bsky.embed.images#view'\n * ```\n */\nexport function typedObject<\n  const N extends NsidString,\n  const H extends string,\n  const S extends Validator<{ [k: string]: unknown }>,\n>(nsid: N, hash: H, validator: S): TypedObjectSchema<$Type<N, H>, S>\nexport function typedObject<V extends { $type?: $Type }>(\n  nsid: V extends { $type?: infer T extends string }\n    ? T extends `${infer N}#${string}`\n      ? N\n      : T // (T is a \"main\" type, so already an NSID)\n    : never,\n  hash: V extends { $type?: infer T extends string }\n    ? T extends `${string}#${infer H}`\n      ? H\n      : 'main'\n    : never,\n  validator: Validator<Omit<V, '$type'>>,\n): TypedObjectSchema<$TypeOf<V>, Validator<V>>\n/*@__NO_SIDE_EFFECTS__*/\nexport function typedObject<\n  const N extends NsidString,\n  const H extends string,\n  const S extends Validator<{ [k: string]: unknown }>,\n>(nsid: N, hash: H, validator: S) {\n  return new TypedObjectSchema<$Type<N, H>, S>($type(nsid, hash), validator)\n}\n"]}
+{"version":3,"file":"typed-object.js","sourceRoot":"","sources":["../../src/schema/typed-object.ts"],"names":[],"mappings":";;;AA8KA,kCAMC;AApLD,gDAAyD;AACzD,wCAcmB;AACnB,+DAAuD;AASvD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAa,iBAGX,SAAQ,gBAGT;IAIY;IACA;IAJF,IAAI,GAAG,aAAsB,CAAA;IAEtC,YACW,KAAY,EACZ,MAAc;QAEvB,KAAK,EAAE,CAAA;QAHE,UAAK,GAAL,KAAK,CAAO;QACZ,WAAM,GAAN,MAAM,CAAQ;IAGzB,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,IAAA,wBAAa,EAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;QACjD,CAAC;QAED,IACE,OAAO,IAAI,KAAK;YAChB,KAAK,CAAC,KAAK,KAAK,SAAS;YACzB,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,EAC1B,CAAC;YACD,OAAO,GAAG,CAAC,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;QACpE,CAAC;QAED,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;IACzC,CAAC;IAQD,KAAK,CAAC,KAA8B;QAClC,OAAO,IAAA,gBAAM,EAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAA;IAClC,CAAC;IAED,QAAQ,CACN,KAAa;QAEb,OAAO,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,CAAA;IAChE,CAAC;IAED;;;OAGG;IACH,IAAI,MAAM;QACR,OAAO,IAAA,+BAAY,EAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAA;IAC5D,CAAC;IAED;;;OAGG;IACH,IAAI,SAAS;QACX,OAAO,IAAA,+BAAY,EAAC,IAAI,EAAE,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAA;IAClE,CAAC;CACF;AA/DD,8CA+DC;AAmED,wBAAwB;AACxB,SAAgB,WAAW,CAIzB,IAAO,EAAE,IAAO,EAAE,SAAY;IAC9B,OAAO,IAAI,iBAAiB,CAAiB,IAAA,eAAK,EAAC,IAAI,EAAE,IAAI,CAAC,EAAE,SAAS,CAAC,CAAA;AAC5E,CAAC","sourcesContent":["import { LexMap, isPlainObject } from '@atproto/lex-data'\nimport {\n  $Type,\n  $TypeOf,\n  $Typed,\n  $TypedMaybe,\n  $type,\n  $typed,\n  InferInput,\n  InferOutput,\n  NsidString,\n  Schema,\n  Unknown$TypedObject,\n  ValidationContext,\n  Validator,\n} from '../core.js'\nimport { lazyProperty } from '../util/lazy-property.js'\n\nexport type MaybeTypedObject<\n  TType extends $Type,\n  TValue extends { $type?: unknown } = { $type?: unknown },\n> = TValue extends { $type?: TType }\n  ? TValue\n  : $TypedMaybe<Exclude<TValue, Unknown$TypedObject>, TType>\n\n/**\n * Schema for typed objects in Lexicon unions.\n *\n * Typed objects have a `$type` field that identifies which variant they are\n * in a union. The `$type` can be omitted in input (it's implicit), but if\n * present, it must match the expected value.\n *\n * @template TType - The $type string literal type\n * @template TShape - The validator type for the object's shape\n *\n * @example\n * ```ts\n * const schema = new TypedObjectSchema(\n *   'app.bsky.embed.images#view',\n *   l.object({ images: l.array(imageSchema) })\n * )\n * ```\n */\nexport class TypedObjectSchema<\n  const TType extends $Type = $Type,\n  const TShape extends Validator<LexMap> = Validator<LexMap>,\n> extends Schema<\n  $TypedMaybe<InferInput<TShape>, TType>,\n  $TypedMaybe<InferOutput<TShape>, TType>\n> {\n  readonly type = 'typedObject' as const\n\n  constructor(\n    readonly $type: TType,\n    readonly schema: TShape,\n  ) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isPlainObject(input)) {\n      return ctx.issueUnexpectedType(input, 'object')\n    }\n\n    if (\n      '$type' in input &&\n      input.$type !== undefined &&\n      input.$type !== this.$type\n    ) {\n      return ctx.issueInvalidPropertyValue(input, '$type', [this.$type])\n    }\n\n    return ctx.validate(input, this.schema)\n  }\n\n  build(\n    input: Omit<InferOutput<TShape>, '$type'>,\n  ): $Typed<InferOutput<TShape>, TType>\n  build(\n    input: Omit<InferInput<TShape>, '$type'>,\n  ): $Typed<InferInput<TShape>, TType>\n  build(input: Record<string, unknown>) {\n    return $typed(input, this.$type)\n  }\n\n  isTypeOf<TValue extends Record<string, unknown>>(\n    value: TValue,\n  ): value is MaybeTypedObject<TType, TValue> {\n    return value.$type === undefined || value.$type === this.$type\n  }\n\n  /**\n   * Bound alias for {@link build} for compatibility with generated utilities.\n   * @see {@link build}\n   */\n  get $build(): typeof this.build {\n    return lazyProperty(this, '$build', this.build.bind(this))\n  }\n\n  /**\n   * Bound alias for {@link isTypeOf} for compatibility with generated utilities.\n   * @see {@link isTypeOf}\n   */\n  get $isTypeOf(): typeof this.isTypeOf {\n    return lazyProperty(this, '$isTypeOf', this.isTypeOf.bind(this))\n  }\n}\n\n/**\n * Creates a typed object schema for use in Lexicon unions.\n *\n * Typed objects are identified by their `$type` field, which combines an NSID\n * and a hash (e.g., 'app.bsky.embed.images#view'). Used for union variants.\n *\n * This function offers two overloads:\n * - One that infers the type from arguments (no circular reference support)\n * - One with explicit interface for codegen with circular references\n *\n * @param nsid - The NSID part of the type (e.g., 'app.bsky.embed.images')\n * @param hash - The hash part of the type (e.g., 'view'), defaults to 'main'\n * @param validator - Schema for validating the object properties\n * @returns A new {@link TypedObjectSchema} instance\n *\n * @example\n * ```ts\n * // Image embed view\n * const imageViewSchema = l.typedObject(\n *   'app.bsky.embed.images',\n *   'view',\n *   l.object({\n *     images: l.array(l.object({\n *       thumb: l.string(),\n *       fullsize: l.string(),\n *       alt: l.string(),\n *     })),\n *   })\n * )\n *\n * // Main type (hash defaults to 'main')\n * const postViewSchema = l.typedObject(\n *   'app.bsky.feed.defs',\n *   'postView',\n *   l.object({ uri: l.string(), cid: l.string(), author: authorSchema })\n * )\n *\n * // Use $isTypeOf to narrow union types\n * if (imageViewSchema.$isTypeOf(embed)) {\n *   // embed is narrowed to image view type\n * }\n *\n * // Use $build to construct typed objects\n * const view = imageViewSchema.$build({ images: [...] })\n * // view.$type === 'app.bsky.embed.images#view'\n * ```\n */\nexport function typedObject<\n  const N extends NsidString,\n  const H extends string,\n  const S extends Validator<LexMap>,\n>(nsid: N, hash: H, validator: S): TypedObjectSchema<$Type<N, H>, S>\nexport function typedObject<V extends { $type?: $Type }>(\n  nsid: V extends { $type?: infer T extends string }\n    ? T extends `${infer N}#${string}`\n      ? N\n      : T // (T is a \"main\" type, so already an NSID)\n    : never,\n  hash: V extends { $type?: infer T extends string }\n    ? T extends `${string}#${infer H}`\n      ? H\n      : 'main'\n    : never,\n  validator: Validator<Omit<V, '$type'>>,\n): TypedObjectSchema<$TypeOf<V>, Validator<V>>\n/*@__NO_SIDE_EFFECTS__*/\nexport function typedObject<\n  const N extends NsidString,\n  const H extends string,\n  const S extends Validator<LexMap>,\n>(nsid: N, hash: H, validator: S) {\n  return new TypedObjectSchema<$Type<N, H>, S>($type(nsid, hash), validator)\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/lex-schema",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "license": "MIT",
   "description": "Lexicon schema system for AT Lexicons",
   "keywords": [
@@ -38,8 +38,8 @@
     "@standard-schema/spec": "^1.1.0",
     "iso-datestring-validator": "^2.2.2",
     "tslib": "^2.8.1",
-    "@atproto/syntax": "^0.5.1",
-    "@atproto/lex-data": "^0.0.14"
+    "@atproto/syntax": "^0.5.3",
+    "@atproto/lex-data": "^0.0.15"
   },
   "devDependencies": {
     "vitest": "^4.0.16"

package/src/core/$type.test.ts

@@ -1,14 +1,18 @@
-import { describe, it } from 'vitest'
+import { describe, expectTypeOf, it } from 'vitest'
 import { LexMap } from '@atproto/lex-data'
-import { Unknown$TypedObject } from './$type.js'
+import { Unknown$Type, Unknown$TypedObject } from './$type.js'
 
 describe('Unknown$TypedObject', () => {
   it('allows assigning Unknown$TypedObject to LexMap', () => {
     function expectLexMap(_value: LexMap) {}
 
-    const someObject = {
-      $type: 'some-type',
-    } as Unknown$TypedObject
+    const someObject: Unknown$TypedObject = {
+      $type: 'some-type' as Unknown$Type,
+      // @ts-expect-error should not allow arbitrary properties
+      foo: 'bar',
+    }
+
+    expectTypeOf(someObject).toEqualTypeOf<Unknown$TypedObject>()
 
     expectLexMap(someObject)
 

package/src/core/schema.ts

@@ -120,8 +120,11 @@ export abstract class Schema<out TInput = unknown, out TOutput = TInput>
    * will typically arise in generic contexts, where the narrowed type is not
    * needed.
    */
-  assert(input: unknown): asserts input is InferInput<this> {
-    const result = ValidationContext.validate(input, this)
+  assert(
+    input: unknown,
+    options?: ValidateOptions,
+  ): asserts input is InferInput<this> {
+    const result = this.safeValidate(input, options)
     if (!result.success) throw result.reason
   }
 
@@ -131,8 +134,8 @@ export abstract class Schema<out TInput = unknown, out TOutput = TInput>
    * every name in the call target to be declared with an explicit type
    * annotation. ts(2775)_" errors.
    */
-  check(input: unknown): void {
-    this.assert(input)
+  check(input: unknown, options?: ValidateOptions): void {
+    this.assert(input, options)
   }
 
   /**
@@ -140,8 +143,8 @@ export abstract class Schema<out TInput = unknown, out TOutput = TInput>
    * schema, otherwise throws. This is the same as calling {@link parse}() with
    * `mode: "validate"`.
    */
-  cast<I>(input: I): I & InferInput<this> {
-    const result = ValidationContext.validate(input, this)
+  cast<I>(input: I, options?: ValidateOptions): I & InferInput<this> {
+    const result = this.safeValidate(input, options)
     if (result.success) return result.value
     throw result.reason
   }
@@ -149,9 +152,6 @@ export abstract class Schema<out TInput = unknown, out TOutput = TInput>
   /**
    * Type guard that checks if the input matches this schema.
    *
-   * @param input - The value to check
-   * @returns `true` if the input is valid according to this schema
-   *
    * @example
    * ```typescript
    * if (schema.matches(data)) {
@@ -160,8 +160,11 @@ export abstract class Schema<out TInput = unknown, out TOutput = TInput>
    * }
    * ```
    */
-  matches<I>(input: I): input is I & InferInput<this> {
-    const result = ValidationContext.validate(input, this)
+  matches<I>(
+    input: I,
+    options?: ValidateOptions,
+  ): input is I & InferInput<this> {
+    const result = this.safeValidate(input, options)
     return result.success
   }
 
@@ -171,9 +174,6 @@ export abstract class Schema<out TInput = unknown, out TOutput = TInput>
    * This is useful for optional filtering operations where you want to
    * conditionally extract values that match a schema.
    *
-   * @param input - The value to check
-   * @returns The input value with narrowed type if valid, otherwise `undefined`
-   *
    * @example
    * ```typescript
    * const validData = schema.ifMatches(data)
@@ -183,8 +183,11 @@ export abstract class Schema<out TInput = unknown, out TOutput = TInput>
    * }
    * ```
    */
-  ifMatches<I>(input: I): (I & InferInput<this>) | undefined {
-    return this.matches(input) ? input : undefined
+  ifMatches<I>(
+    input: I,
+    options?: ValidateOptions,
+  ): (I & InferInput<this>) | undefined {
+    return this.matches(input, options) ? input : undefined
   }
 
   /**

package/src/core/validation-error.ts

@@ -23,7 +23,7 @@ import {
  *   new IssueInvalidType(['user', 'age'], 'hello', ['number'])
  * ])
  * console.log(error.message)
- * // "Expected number value type at $.user.age (got string)"
+ * // "Expected integer value type (got "some-string") at $.user.age"
  *
  * console.log(error.issues.length) // 1
  * console.log(error.toJSON())
@@ -46,7 +46,7 @@ export class LexValidationError
    * Issues are aggregated when possible (e.g., multiple invalid type issues
    * at the same path are combined into a single issue listing all expected types).
    */
-  readonly issues: Issue[]
+  readonly issues: readonly Issue[]
 
   /**
    * Creates a new validation error from a list of issues.

package/src/core/validation-issue.ts

@@ -1,5 +1,8 @@
 import { ifCid, isLegacyBlobRef, isPlainObject } from '@atproto/lex-data'
 
+const STRING_PREVIEW_MAX_LENGTH = 48
+const STRING_PREVIEW_TRUNCATED_SUFFIX = '…'
+
 /**
  * Abstract base class for all validation issues.
  *
@@ -120,7 +123,7 @@ export class IssueInvalidType extends Issue {
   }
 
   override get message(): string {
-    return `Expected ${oneOf(this.expected.map(stringifyExpectedType))} value type (got ${stringifyType(this.input)})`
+    return `Expected ${oneOf(this.expected.map(stringifyExpectedType))} value type (got ${stringifyValue(this.input)})`
   }
 
   toJSON() {
@@ -289,55 +292,36 @@ function oneOf(arr: readonly string[]): string {
   return `one of ${arr.slice(0, -1).join(', ')} or ${arr.at(-1)}`
 }
 
-function stringifyType(value: unknown): string {
-  switch (typeof value) {
-    case 'object':
-      if (value === null) return 'null'
-      if (Array.isArray(value)) return 'array'
-      if (ifCid(value)) return 'cid'
-      if (isLegacyBlobRef(value)) return 'legacy-blob'
-      if (value instanceof Date) return 'date'
-      if (value instanceof RegExp) return 'regexp'
-      if (value instanceof Map) return 'map'
-      if (value instanceof Set) return 'set'
-      return 'object'
-    case 'number':
-      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
-  }
-}
-
 function stringifyValue(value: unknown): string {
   switch (typeof value) {
     case 'bigint':
       return `${value}n`
     case 'number':
-    case 'string':
     case 'boolean':
-      return JSON.stringify(value)
+      return String(value)
+    case 'string':
+      return JSON.stringify(
+        value.length < STRING_PREVIEW_MAX_LENGTH
+          ? value
+          : `${value.slice(0, STRING_PREVIEW_MAX_LENGTH - STRING_PREVIEW_TRUNCATED_SUFFIX.length)}${STRING_PREVIEW_TRUNCATED_SUFFIX}`,
+      )
     case 'object':
+      if (value === null) return 'null'
       if (Array.isArray(value)) {
         return `[${stringifyArray(value, stringifyValue)}]`
       }
       if (isPlainObject(value)) {
         return `{${stringifyArray(Object.entries(value), stringifyObjectEntry)}}`
       }
-    // fallthrough
+      if (ifCid(value)) return 'cid'
+      if (isLegacyBlobRef(value)) return 'legacy-blob'
+      if (value instanceof Date) return 'date'
+      if (value instanceof RegExp) return 'regexp'
+      if (value instanceof Map) return 'map'
+      if (value instanceof Set) return 'set'
+      return 'object'
     default:
-      return stringifyType(value)
+      return typeof value
   }
 }
 

package/src/helpers.ts

@@ -9,6 +9,7 @@ import {
   Subscription,
   object,
   optional,
+  regexp,
   string,
 } from './schema.js'
 
@@ -103,7 +104,12 @@ export type InferMethodError<
   M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
 > = M extends { errors: readonly (infer E extends string)[] } ? E : never
 
+/**
+ * @see {@link https://atproto.com/specs/xrpc#error-responses}
+ */
 export const lexErrorDataSchema = object({
-  error: string({ minLength: 1 }),
+  // type name of the error (generic ASCII constant, no whitespace)
+  error: regexp(/^[\w_-]+$/, 'Expected ASCII constant with no whitespace'),
+  // description of the error, appropriate for display to humans
   message: optional(string()),
 }) satisfies Schema<LexErrorData>

package/src/schema/array.test.ts

@@ -81,7 +81,7 @@ describe('ArraySchema', () => {
         success: false,
         reason: expect.objectContaining({
           message: expect.stringContaining(
-            'Expected array value type (got integer) at $',
+            'Expected array value type (got 3) at $',
           ),
         }),
       })