@atproto/lex-schema 0.0.14 → 0.0.16

package/dist/schema/string.js.map

@@ -1 +1 @@
-{"version":3,"file":"string.js","sourceRoot":"","sources":["../../src/schema/string.ts"],"names":[],"mappings":"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","sourcesContent":["import { graphemeLen, ifCid, utf8Len } from '@atproto/lex-data'\nimport {\n  InferStringFormat,\n  Restricted,\n  Schema,\n  StringFormat,\n  UnknownString,\n  ValidationContext,\n  isStringFormat,\n} from '../core.js'\nimport { IfAny } from '../util/if-any.js'\nimport { memoizedOptions } from '../util/memoize.js'\nimport { TokenSchema } from './token.js'\n\n/**\n * Configuration options for string schema validation.\n *\n * @property format - Expected string format (e.g., 'datetime', 'uri', 'at-uri', 'did', 'handle', 'nsid', 'cid', 'tid', 'record-key', 'at-identifier', 'language')\n * @property knownValues - Known string literal values for type narrowing\n * @property minLength - Minimum length in UTF-8 bytes\n * @property maxLength - Maximum length in UTF-8 bytes\n * @property minGraphemes - Minimum number of grapheme clusters\n * @property maxGraphemes - Maximum number of grapheme clusters\n */\nexport type StringSchemaOptions = {\n  format?: StringFormat\n  knownValues?: readonly string[]\n  minLength?: number\n  maxLength?: number\n  minGraphemes?: number\n  maxGraphemes?: number\n}\n\n/**\n * Schema for validating string values with optional format and length constraints.\n *\n * Supports various string formats defined in the Lexicon specification, as well as\n * length constraints measured in UTF-8 bytes or grapheme clusters.\n *\n * @template TOptions - The configuration options type\n *\n * @example\n * ```ts\n * const schema = new StringSchema({ format: 'datetime', maxLength: 64 })\n * const result = schema.validate('2024-01-15T10:30:00Z')\n * ```\n */\nexport class StringSchema<\n  const TOptions extends StringSchemaOptions = StringSchemaOptions,\n> extends Schema<\n  IfAny<\n    TOptions,\n    string,\n    TOptions extends { format: infer F extends StringFormat }\n      ? InferStringFormat<F>\n      : TOptions extends { knownValues: readonly (infer V extends string)[] }\n        ? V | UnknownString\n        : string\n  >\n> {\n  readonly type = 'string' as const\n\n  // @NOTE since the _string utility allows omitting knownValues when TOptions\n  // *does* include it (since it's only used for typing), we cannot type options\n  // as TOptions directly since it may not actually include knownValues at\n  // runtime, making schema.options.knownValues potentially undefined even when\n  // TOptions includes it.\n  readonly options: StringSchemaOptions\n\n  constructor(options: TOptions) {\n    super()\n    this.options = options\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    const str = coerceToString(input)\n    if (str == null) {\n      return ctx.issueUnexpectedType(input, 'string')\n    }\n\n    let lazyUtf8Len: number\n\n    const minLength = this.options.minLength\n    if (minLength != null) {\n      if ((lazyUtf8Len ??= utf8Len(str)) < minLength) {\n        return ctx.issueTooSmall(str, 'string', minLength, lazyUtf8Len)\n      }\n    }\n\n    const maxLength = this.options.maxLength\n    if (maxLength != null) {\n      // Optimization: we can avoid computing the UTF-8 length if the maximum\n      // possible length, in bytes, of the input JS string is smaller than the\n      // maxLength (in UTF-8 string bytes).\n      if (str.length * 3 <= maxLength) {\n        // Input string so small it can't possibly exceed maxLength\n      } else if ((lazyUtf8Len ??= utf8Len(str)) > maxLength) {\n        return ctx.issueTooBig(str, 'string', maxLength, lazyUtf8Len)\n      }\n    }\n\n    let lazyGraphLen: number\n\n    const minGraphemes = this.options.minGraphemes\n    if (minGraphemes != null) {\n      // Optimization: avoid counting graphemes if the length check already fails\n      if (str.length < minGraphemes) {\n        return ctx.issueTooSmall(str, 'grapheme', minGraphemes, str.length)\n      } else if ((lazyGraphLen ??= graphemeLen(str)) < minGraphemes) {\n        return ctx.issueTooSmall(str, 'grapheme', minGraphemes, lazyGraphLen)\n      }\n    }\n\n    const maxGraphemes = this.options.maxGraphemes\n    if (maxGraphemes != null) {\n      if ((lazyGraphLen ??= graphemeLen(str)) > maxGraphemes) {\n        return ctx.issueTooBig(str, 'grapheme', maxGraphemes, lazyGraphLen)\n      }\n    }\n\n    const format = this.options.format\n    if (format != null && !isStringFormat(str, format)) {\n      return ctx.issueInvalidFormat(str, format)\n    }\n\n    return ctx.success(str)\n  }\n}\n\nexport function coerceToString(input: unknown): string | null {\n  switch (typeof input) {\n    // @NOTE We do *not* coerce numbers/booleans to strings because that can\n    // lead to them being accepted as string instead of being coerced to\n    // number/boolean when the input is a string and the expected result is\n    // number/boolean (e.g. in params).\n    case 'string':\n      return input\n    case 'object': {\n      if (input == null) return null\n\n      // @NOTE Allow using TokenSchema instances in places expecting strings,\n      // converting them to their string value.\n      if (input instanceof TokenSchema) {\n        return input.toString()\n      }\n\n      if (input instanceof Date) {\n        if (Number.isNaN(input.getTime())) return null\n        return input.toISOString()\n      }\n\n      if (input instanceof URL) {\n        return input.toString()\n      }\n\n      const cid = ifCid(input)\n      if (cid) return cid.toString()\n\n      if (input instanceof String) {\n        return input.valueOf()\n      }\n    }\n\n    // falls through\n    default:\n      return null\n  }\n}\n\nfunction _string(): StringSchema<NonNullable<unknown>>\nfunction _string<\n  // Allow calling `string<{ knownValues: [...] }>()` without passing an options\n  // object, since knownValues is only used for typing and has no runtime\n  // effect, so it can be safely omitted at runtime.\n  const TOptions extends {\n    knownValues: StringSchemaOptions['knownValues']\n  } & {\n    [K in Exclude<\n      keyof StringSchemaOptions,\n      'knownValues'\n    >]?: Restricted<`An options argument is required when using the \"${K}\" option`>\n  },\n>(): StringSchema<\n  IfAny<TOptions, any, { knownValues: TOptions['knownValues'] }>\n>\nfunction _string<const TOptions extends StringSchemaOptions>(\n  // If TOptions is explicitly provided (e.g. `string<{ ... }>({ ... })`), we\n  // allow the actual options argument to omit the \"knownValues\" property since\n  // it's only used for inferring the type and has no runtime effect.\n  options: TOptions | Omit<TOptions, 'knownValues'>,\n): StringSchema<TOptions>\nfunction _string(options: StringSchemaOptions = {}) {\n  return new StringSchema(options)\n}\n\n/**\n * Creates a string schema with optional format and length constraints.\n *\n * Strings can be validated against various formats (datetime, uri, did, handle, etc.)\n * and constrained by length in UTF-8 bytes or grapheme clusters.\n *\n * @param options - Optional configuration for format and length constraints\n * @returns A new {@link StringSchema} instance\n *\n * @example\n * ```ts\n * // Basic string\n * const nameSchema = l.string()\n *\n * // With format validation\n * const dateSchema = l.string({ format: 'datetime' })\n *\n * // With length constraints (UTF-8 bytes)\n * const bioSchema = l.string({ maxLength: 256 })\n *\n * // With grapheme constraints (user-perceived characters)\n * const displayNameSchema = l.string({ maxGraphemes: 64 })\n *\n * // Combining constraints\n * const handleSchema = l.string({ format: 'handle', minLength: 3, maxLength: 253 })\n * ```\n */\nexport const string = /*#__PURE__*/ memoizedOptions(_string)\n"]}
+{"version":3,"file":"string.js","sourceRoot":"","sources":["../../src/schema/string.ts"],"names":[],"mappings":"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","sourcesContent":["import { graphemeLen, ifCid, utf8Len } from '@atproto/lex-data'\nimport {\n  InferStringFormat,\n  Restricted,\n  Schema,\n  StringFormat,\n  UnknownString,\n  ValidationContext,\n  isStringFormat,\n} from '../core.js'\nimport { IfAny } from '../util/if-any.js'\nimport { memoizedOptions } from '../util/memoize.js'\nimport { TokenSchema } from './token.js'\n\n/**\n * Configuration options for string schema validation.\n *\n * @property format - Expected string format (e.g., 'datetime', 'uri', 'at-uri', 'did', 'handle', 'nsid', 'cid', 'tid', 'record-key', 'at-identifier', 'language')\n * @property knownValues - Known string literal values for type narrowing\n * @property minLength - Minimum length in UTF-8 bytes\n * @property maxLength - Maximum length in UTF-8 bytes\n * @property minGraphemes - Minimum number of grapheme clusters\n * @property maxGraphemes - Maximum number of grapheme clusters\n */\nexport type StringSchemaOptions = {\n  format?: StringFormat\n  knownValues?: readonly string[]\n  minLength?: number\n  maxLength?: number\n  minGraphemes?: number\n  maxGraphemes?: number\n}\n\n/**\n * Schema for validating string values with optional format and length constraints.\n *\n * Supports various string formats defined in the Lexicon specification, as well as\n * length constraints measured in UTF-8 bytes or grapheme clusters.\n *\n * @template TOptions - The configuration options type\n *\n * @example\n * ```ts\n * const schema = new StringSchema({ format: 'datetime', maxLength: 64 })\n * const result = schema.validate('2024-01-15T10:30:00Z')\n * ```\n */\nexport class StringSchema<\n  const TOptions extends StringSchemaOptions = StringSchemaOptions,\n> extends Schema<\n  IfAny<\n    TOptions,\n    string,\n    TOptions extends { format: infer F extends StringFormat }\n      ? InferStringFormat<F>\n      : TOptions extends { knownValues: readonly (infer V extends string)[] }\n        ? V | UnknownString\n        : string\n  >\n> {\n  readonly type = 'string' as const\n\n  // @NOTE since the _string utility allows omitting knownValues when TOptions\n  // *does* include it (since it's only used for typing), we cannot type options\n  // as TOptions directly since it may not actually include knownValues at\n  // runtime, making schema.options.knownValues potentially undefined even when\n  // TOptions includes it.\n  readonly options: StringSchemaOptions\n\n  constructor(options: TOptions) {\n    super()\n    this.options = options\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    const str = coerceToString(input)\n    if (str == null) {\n      return ctx.issueUnexpectedType(input, 'string')\n    }\n\n    let lazyUtf8Len: number\n\n    const minLength = this.options.minLength\n    if (minLength != null) {\n      if ((lazyUtf8Len ??= utf8Len(str)) < minLength) {\n        return ctx.issueTooSmall(str, 'string', minLength, lazyUtf8Len)\n      }\n    }\n\n    const maxLength = this.options.maxLength\n    if (maxLength != null) {\n      // Optimization: we can avoid computing the UTF-8 length if the maximum\n      // possible length, in bytes, of the input JS string is smaller than the\n      // maxLength (in UTF-8 string bytes).\n      if (str.length * 3 <= maxLength) {\n        // Input string so small it can't possibly exceed maxLength\n      } else if ((lazyUtf8Len ??= utf8Len(str)) > maxLength) {\n        return ctx.issueTooBig(str, 'string', maxLength, lazyUtf8Len)\n      }\n    }\n\n    let lazyGraphLen: number\n\n    const minGraphemes = this.options.minGraphemes\n    if (minGraphemes != null) {\n      // Optimization: avoid counting graphemes if the length check already fails\n      if (str.length < minGraphemes) {\n        return ctx.issueTooSmall(str, 'grapheme', minGraphemes, str.length)\n      } else if ((lazyGraphLen ??= graphemeLen(str)) < minGraphemes) {\n        return ctx.issueTooSmall(str, 'grapheme', minGraphemes, lazyGraphLen)\n      }\n    }\n\n    const maxGraphemes = this.options.maxGraphemes\n    if (maxGraphemes != null) {\n      if ((lazyGraphLen ??= graphemeLen(str)) > maxGraphemes) {\n        return ctx.issueTooBig(str, 'grapheme', maxGraphemes, lazyGraphLen)\n      }\n    }\n\n    const format = this.options.format\n    if (format != null && !isStringFormat(str, format, ctx.options)) {\n      return ctx.issueInvalidFormat(str, format)\n    }\n\n    return ctx.success(str)\n  }\n}\n\nexport function coerceToString(input: unknown): string | null {\n  switch (typeof input) {\n    // @NOTE We do *not* coerce numbers/booleans to strings because that can\n    // lead to them being accepted as string instead of being coerced to\n    // number/boolean when the input is a string and the expected result is\n    // number/boolean (e.g. in params).\n    case 'string':\n      return input\n    case 'object': {\n      if (input == null) return null\n\n      // @NOTE Allow using TokenSchema instances in places expecting strings,\n      // converting them to their string value.\n      if (input instanceof TokenSchema) {\n        return input.toString()\n      }\n\n      if (input instanceof Date) {\n        if (Number.isNaN(input.getTime())) return null\n        return input.toISOString()\n      }\n\n      if (input instanceof URL) {\n        return input.toString()\n      }\n\n      const cid = ifCid(input)\n      if (cid) return cid.toString()\n\n      if (input instanceof String) {\n        return input.valueOf()\n      }\n    }\n\n    // falls through\n    default:\n      return null\n  }\n}\n\nfunction _string(): StringSchema<NonNullable<unknown>>\nfunction _string<\n  // Allow calling `string<{ knownValues: [...] }>()` without passing an options\n  // object, since knownValues is only used for typing and has no runtime\n  // effect, so it can be safely omitted at runtime.\n  const TOptions extends {\n    knownValues: StringSchemaOptions['knownValues']\n  } & {\n    [K in Exclude<\n      keyof StringSchemaOptions,\n      'knownValues'\n    >]?: Restricted<`An options argument is required when using the \"${K}\" option`>\n  },\n>(): StringSchema<\n  IfAny<TOptions, any, { knownValues: TOptions['knownValues'] }>\n>\nfunction _string<const TOptions extends StringSchemaOptions>(\n  // If TOptions is explicitly provided (e.g. `string<{ ... }>({ ... })`), we\n  // allow the actual options argument to omit the \"knownValues\" property since\n  // it's only used for inferring the type and has no runtime effect.\n  options: TOptions | Omit<TOptions, 'knownValues'>,\n): StringSchema<TOptions>\nfunction _string(options: StringSchemaOptions = {}) {\n  return new StringSchema(options)\n}\n\n/**\n * Creates a string schema with optional format and length constraints.\n *\n * Strings can be validated against various formats (datetime, uri, did, handle, etc.)\n * and constrained by length in UTF-8 bytes or grapheme clusters.\n *\n * @param options - Optional configuration for format and length constraints\n * @returns A new {@link StringSchema} instance\n *\n * @example\n * ```ts\n * // Basic string\n * const nameSchema = l.string()\n *\n * // With format validation\n * const dateSchema = l.string({ format: 'datetime' })\n *\n * // With length constraints (UTF-8 bytes)\n * const bioSchema = l.string({ maxLength: 256 })\n *\n * // With grapheme constraints (user-perceived characters)\n * const displayNameSchema = l.string({ maxGraphemes: 64 })\n *\n * // Combining constraints\n * const handleSchema = l.string({ format: 'handle', minLength: 3, maxLength: 253 })\n * ```\n */\nexport const string = /*#__PURE__*/ memoizedOptions(_string)\n"]}

package/dist/schema/typed-ref.d.ts

@@ -41,7 +41,7 @@ export declare class TypedRefSchema<const TValidator extends TypedObjectValidato
     constructor(getter: TypedRefGetter<TValidator>);
     get validator(): TValidator;
     get $type(): TValidator['$type'];
-    validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationFailure | import("../core.js").ValidationSuccess<InferInput<TValidator>>;
+    validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").LexValidationError | import("../core.js").ValidationSuccess<InferInput<TValidator>>;
 }
 /**
  * Creates a reference to a typed object schema for use in typed unions.

package/dist/schema/typed-union.d.ts

@@ -26,7 +26,7 @@ export declare class TypedUnionSchema<const TValidators extends readonly (TypedR
     constructor(validators: TValidators, closed: TClosed);
     get validatorsMap(): Map<unknown, TValidators[number]>;
     get $types(): unknown[];
-    validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationFailure | import("../core.js").ValidationSuccess<Record<string, unknown>> | import("../core.js").ValidationSuccess<InferInput<TValidators[number]>>;
+    validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").LexValidationError | import("../core.js").ValidationSuccess<Record<string, unknown>> | import("../core.js").ValidationSuccess<InferInput<TValidators[number]>>;
 }
 /**
  * Creates a typed union schema for Lexicon unions.

package/dist/schema/union.d.ts

@@ -1,4 +1,4 @@
-import { InferInput, InferOutput, Schema, ValidationContext, ValidationFailure, Validator } from '../core.js';
+import { InferInput, InferOutput, LexValidationError, Schema, ValidationContext, Validator } from '../core.js';
 /**
  * Type representing a non-empty tuple of validators for union schemas.
  *
@@ -25,7 +25,7 @@ export declare class UnionSchema<const TValidators extends UnionSchemaValidators
     protected readonly validators: TValidators;
     readonly type: "union";
     constructor(validators: TValidators);
-    validateInContext(input: unknown, ctx: ValidationContext): ValidationFailure | import("../core.js").ValidationSuccess<unknown>;
+    validateInContext(input: unknown, ctx: ValidationContext): LexValidationError | import("../core.js").ValidationSuccess<unknown>;
 }
 /**
  * Creates a union schema that accepts values matching any of the provided schemas.

package/dist/schema/union.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"union.d.ts","sourceRoot":"","sources":["../../src/schema/union.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,WAAW,EAEX,MAAM,EACN,iBAAiB,EACjB,iBAAiB,EACjB,SAAS,EACV,MAAM,YAAY,CAAA;AAEnB;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,SAAS,CAAC,SAAS,EAAE,GAAG,SAAS,EAAE,CAAC,CAAA;AAExE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,WAAW,CACtB,KAAK,CAAC,WAAW,SAAS,qBAAqB,GAAG,GAAG,CACrD,SAAQ,MAAM,CACd,UAAU,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,EAC/B,WAAW,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CACjC;IAGa,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW;IAFtD,QAAQ,CAAC,IAAI,EAAG,OAAO,CAAS;gBAED,UAAU,EAAE,WAAW;IAItD,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAYzD;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,wBAAgB,KAAK,CAAC,KAAK,CAAC,WAAW,SAAS,qBAAqB,EACnE,UAAU,EAAE,WAAW,4BAGxB"}
+{"version":3,"file":"union.d.ts","sourceRoot":"","sources":["../../src/schema/union.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,WAAW,EACX,kBAAkB,EAClB,MAAM,EACN,iBAAiB,EAEjB,SAAS,EACV,MAAM,YAAY,CAAA;AAEnB;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAAG,SAAS,CAAC,SAAS,EAAE,GAAG,SAAS,EAAE,CAAC,CAAA;AAExE;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,WAAW,CACtB,KAAK,CAAC,WAAW,SAAS,qBAAqB,GAAG,GAAG,CACrD,SAAQ,MAAM,CACd,UAAU,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,EAC/B,WAAW,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CACjC;IAGa,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,WAAW;IAFtD,QAAQ,CAAC,IAAI,EAAG,OAAO,CAAS;gBAED,UAAU,EAAE,WAAW;IAItD,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAYzD;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,wBAAgB,KAAK,CAAC,KAAK,CAAC,WAAW,SAAS,qBAAqB,EACnE,UAAU,EAAE,WAAW,4BAGxB"}

package/package.json

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

package/src/core/schema.ts

@@ -1,4 +1,6 @@
+import { StandardSchemaV1 } from '@standard-schema/spec'
 import { lazyProperty } from '../util/lazy-property.js'
+import { StandardSchemaAdapter } from './standard-schema.js'
 import {
   InferInput,
   InferOutput,
@@ -45,14 +47,13 @@ export interface SchemaInternals<out TInput = unknown, out TOutput = TInput> {
  * - **Assertion methods**: `assert()`, `check()` - throw on invalid input
  * - **Type guard methods**: `matches()`, `ifMatches()` - return boolean or optional value
  * - **Parse methods**: `parse()`, `safeParse()` - allow value transformation/coercion
- * - **Validate methods**: `validate()`, `safeValidate()` - strict validation without coercion
+ * - **Validate methods**: `validate()`, `safeValidate()` - validation without coercion
  *
  * All methods are also available with a `$` prefix (e.g., `$parse()`, `$validate()`)
  * for consistent access in generated lexicon namespaces.
  *
  * @typeParam TInput - The type accepted as valid input during validation
  * @typeParam TOutput - The type returned after parsing (may include transformations)
- * @typeParam TInternals - Internal type structure for type inference
  *
  * @example
  * ```typescript
@@ -72,14 +73,8 @@ export interface SchemaInternals<out TInput = unknown, out TOutput = TInput> {
  * schema.matches(123)        // false
  * ```
  */
-export abstract class Schema<
-  out TInput = unknown,
-  out TOutput = TInput,
-  out TInternals extends SchemaInternals<TInput, TOutput> = SchemaInternals<
-    TInput,
-    TOutput
-  >,
-> implements Validator<TInternals['input'], TInternals['output']>
+export abstract class Schema<out TInput = unknown, out TOutput = TInput>
+  implements Validator<TInput, TOutput>, StandardSchemaV1<TInput, TOutput>
 {
   /**
    * Internal phantom property for type inference.
@@ -87,7 +82,13 @@ export abstract class Schema<
    *
    * @internal
    */
-  declare readonly ['__lex']: TInternals
+  declare readonly ['__lex']: SchemaInternals<TInput, TOutput>
+
+  get '~standard'(): StandardSchemaV1.Props<TInput, TOutput> {
+    // Lazily create, and cache, the Standard Schema adapter for this schema
+    // instance.
+    return lazyProperty(this, '~standard', new StandardSchemaAdapter(this))
+  }
 
   // Needed to discriminate multiple schema types when used in unions. Without
   // this, Typescript could allow an EnumSchema<"foo" | "bar"> to be used where

package/src/core/standard-schema.test.ts

@@ -0,0 +1,124 @@
+import { assert, describe, expect, it } from 'vitest'
+import { array } from '../schema/array.js'
+import { integer } from '../schema/integer.js'
+import { object } from '../schema/object.js'
+import { optional } from '../schema/optional.js'
+import { string } from '../schema/string.js'
+import { withDefault } from '../schema/with-default.js'
+import { LexValidationError } from './validation-error.js'
+
+describe('StandardSchemaAdapter', () => {
+  describe('metadata', () => {
+    const schema = integer()
+
+    it('has version 1', () => {
+      expect(schema['~standard'].version).toBe(1)
+    })
+
+    it('has vendor @atproto/lex-schema', () => {
+      expect(schema['~standard'].vendor).toBe('@atproto/lex-schema')
+    })
+  })
+
+  describe('lazy caching', () => {
+    it('returns the same adapter instance on repeated accesses', () => {
+      const schema = integer()
+      const first = schema['~standard']
+      const second = schema['~standard']
+      expect(first).toBe(second)
+    })
+  })
+
+  describe('validate() result shape on success', () => {
+    it('returns a value property for a valid integer', () => {
+      const result = integer()['~standard'].validate(42)
+      expect(result).toMatchObject({ value: 42 })
+    })
+
+    it('returns a value property for a valid string', () => {
+      const result = string()['~standard'].validate('hello')
+      expect(result).toMatchObject({ value: 'hello' })
+    })
+
+    it('does not include an issues property on success', () => {
+      const result = integer()['~standard'].validate(1)
+      expect(result).not.toHaveProperty('issues')
+    })
+  })
+
+  describe('validate() result shape on failure', () => {
+    it('returns a LexValidationError with issues for an invalid value', () => {
+      const result = integer()['~standard'].validate('not-a-number')
+      assert(result instanceof LexValidationError)
+      expect(Array.isArray(result.issues)).toBe(true)
+      expect(result.issues.length).toBeGreaterThan(0)
+    })
+
+    it('does not include a value property on failure', () => {
+      const result = integer()['~standard'].validate('not-a-number')
+      expect(result).not.toHaveProperty('value')
+    })
+
+    describe('issues[].message', () => {
+      it('is a non-empty string', () => {
+        const result = integer()['~standard'].validate('not-a-number')
+        assert(result instanceof LexValidationError)
+        for (const issue of result.issues) {
+          expect(typeof issue.message).toBe('string')
+          expect(issue.message.length).toBeGreaterThan(0)
+        }
+      })
+
+      it('describes the type mismatch', () => {
+        const result = integer()['~standard'].validate('not-a-number')
+        assert(result instanceof LexValidationError)
+        expect(result.issues[0].message).toContain('integer')
+      })
+    })
+
+    describe('issues[].path', () => {
+      it('is an empty array for a root-level failure', () => {
+        const result = integer()['~standard'].validate('not-a-number')
+        assert(result instanceof LexValidationError)
+        expect(result.issues[0].path).toEqual([])
+      })
+
+      it('reflects the property key for a nested object failure', () => {
+        const schema = object({ age: integer() })
+        const result = schema['~standard'].validate({ age: 'not-a-number' })
+        assert(result instanceof LexValidationError)
+        expect(result.issues[0].path).toContain('age')
+      })
+
+      it('reflects the index for an array element failure', () => {
+        const schema = array(integer())
+        const result = schema['~standard'].validate([1, 'bad', 3])
+        assert(result instanceof LexValidationError)
+        expect(result.issues[0].path).toContain(1)
+      })
+    })
+  })
+
+  describe('parse mode (default value application)', () => {
+    it('applies default values when input is undefined', () => {
+      const schema = withDefault(integer(), 10)
+      const result = schema['~standard'].validate(undefined)
+      expect(result).toMatchObject({ value: 10 })
+    })
+
+    it('uses the provided value instead of default when input is present', () => {
+      const schema = withDefault(integer(), 10)
+      const result = schema['~standard'].validate(42)
+      expect(result).toMatchObject({ value: 42 })
+    })
+
+    it('applies defaults for optional object properties in parse mode', () => {
+      const schema = object({
+        name: string(),
+        count: optional(withDefault(integer(), 0)),
+      })
+      const result = schema['~standard'].validate({ name: 'Alice' })
+      expect(result).toMatchObject({ value: { name: 'Alice', count: 0 } })
+    })
+  })
+})

package/src/core/standard-schema.ts

@@ -0,0 +1,31 @@
+import { StandardSchemaV1 } from '@standard-schema/spec'
+import { ValidationContext, Validator } from './validator.js'
+
+/**
+ * The Standard Schema adapter for {@link Validator} instances.
+ */
+export class StandardSchemaAdapter<TInput, TOutput>
+  implements StandardSchemaV1.Props<TInput, TOutput>
+{
+  readonly version = 1
+
+  readonly vendor = '@atproto/lex-schema'
+
+  declare readonly types: StandardSchemaV1.Types<TInput, TOutput>
+
+  constructor(private readonly validator: Validator<TInput, TOutput>) {}
+
+  validate(
+    value: unknown,
+    options?: StandardSchemaV1.Options,
+  ): StandardSchemaV1.Result<TOutput> {
+    // Perform validation in "parse" mode to ensure transformations (defaults,
+    // coercions, etc.) are applied. Also ensures that the output type is
+    // returned. Note that ValidationResult is compatible with
+    // StandardSchemaV1.Result :-)
+    return ValidationContext.validate(value, this.validator, {
+      ...options?.libraryOptions,
+      mode: 'parse',
+    })
+  }
+}

package/src/core/string-format.ts

@@ -1,3 +1,4 @@
+import { isValidISODateString } from 'iso-datestring-validator'
 import { validateCidString } from '@atproto/lex-data'
 import {
   AtIdentifierString,
@@ -9,8 +10,8 @@ import {
   RecordKeyString,
   TidString,
   UriString,
+  isAtIdentifierString,
   isDatetimeString,
-  isValidAtIdentifier as isValidAtId,
   isValidAtUri,
   isValidDid,
   isValidHandle,
@@ -30,31 +31,47 @@ import { CheckFn } from '../util/assertion-util.js'
 // documentation for types and utilities that are already well-defined there.
 // @TODO rework other string formats in @atproto/syntax to follow this pattern
 // and re-export here, e.g. language tags, NSIDs, record keys, etc.
+
+export {
+  type AtIdentifierString,
+  asAtIdentifierString,
+  ifAtIdentifierString,
+  isAtIdentifierString,
+} from '@atproto/syntax'
+
+// AtIdentifierString utilities
+export { isDidIdentifier, isHandleIdentifier } from '@atproto/syntax'
+
 export {
   type DatetimeString,
   asDatetimeString,
-  currentDatetimeString,
   ifDatetimeString,
   isDatetimeString,
-  toDatetimeString,
 } from '@atproto/syntax'
 
 /**
- * Type guard that checks if a value is a valid AT identifier (DID or handle).
- *
- * @param value - The value to check
- * @returns `true` if the value is a valid AT identifier
+ * Matches any ISO-ish datetime string. This is a more lenient check than
+ * the strict {@link isDatetimeString} guard, which only allows datetimes that
+ * fully conform to the AT Protocol specification (e.g. must include timezone).
  */
-export const isAtIdentifierString: CheckFn<AtIdentifierString> = isValidAtId
-export type {
-  /**
-   * An AT identifier string - either a DID or a handle.
-   *
-   * @example `"did:plc:1234..."` or `"alice.bsky.social"`
-   */
-  AtIdentifierString,
+export function isDatetimeStringLoose<I>(
+  input: I,
+): input is I & DatetimeString {
+  // @NOTE the returned type assertion is inaccurate wrt. the DatetimeString
+  // type definition. A more accurate solution would be to use a branded type
+  // instead of a template literal for the "datetime" format
+  if (typeof input !== 'string') return false
+  try {
+    return isValidISODateString(input)
+  } catch {
+    // @NOTE isValidISODateString throws on some inputs
+    return false
+  }
 }
 
+// DatetimeString utilities
+export { currentDatetimeString, toDatetimeString } from '@atproto/syntax'
+
 /**
  * Type guard that checks if a value is a valid AT URI.
  *
@@ -227,23 +244,39 @@ type StringFormats = {
 export type StringFormat = Extract<keyof StringFormats, string>
 
 const stringFormatVerifiers: {
-  readonly [K in StringFormat]: CheckFn<StringFormats[K]>
+  readonly [K in StringFormat]: readonly [
+    strict: CheckFn<StringFormats[K]>,
+    loose?: CheckFn<StringFormats[K]>,
+  ]
 } = /*#__PURE__*/ Object.freeze({
   __proto__: null,
 
-  'at-identifier': isAtIdentifierString,
-  'at-uri': isAtUriString,
-  cid: isCidString,
-  datetime: isDatetimeString,
-  did: isDidString,
-  handle: isHandleString,
-  language: isLanguageString,
-  nsid: isNsidString,
-  'record-key': isRecordKeyString,
-  tid: isTidString,
-  uri: isUriString,
+  'at-identifier': [isAtIdentifierString],
+  'at-uri': [isAtUriString],
+  cid: [isCidString],
+  datetime: [isDatetimeString, isDatetimeStringLoose],
+  did: [isDidString],
+  handle: [isHandleString],
+  language: [isLanguageString],
+  nsid: [isNsidString],
+  'record-key': [isRecordKeyString],
+  tid: [isTidString],
+  uri: [isUriString],
 })
 
+export type StringFormatValidationOptions = {
+  /**
+   * Allows to be more lenient in validation by using a "loose" verification
+   * function, if available. The behavior of the loose verifier depends on the
+   * specific format, but generally it may allow for a wider range of valid
+   * inputs, including values that are not compliant with the AT Protocol
+   * specification.
+   *
+   * @default true
+   */
+  strict?: boolean
+}
+
 /**
  * Infers the string type for a given format name.
  *
@@ -281,12 +314,18 @@ export type InferStringFormat<F extends StringFormat> = F extends StringFormat
 export function isStringFormat<I extends string, F extends StringFormat>(
   input: I,
   format: F,
+  options?: StringFormatValidationOptions,
 ): input is I & StringFormats[F] {
   const formatVerifier = stringFormatVerifiers[format]
   // Fool-proof
   if (!formatVerifier) throw new TypeError(`Unknown string format: ${format}`)
 
-  return formatVerifier(input)
+  const check: CheckFn<StringFormats[F]> =
+    options?.strict === false
+      ? formatVerifier[1] ?? formatVerifier[0]
+      : formatVerifier[0]
+
+  return check(input)
 }
 
 /**
@@ -308,8 +347,9 @@ export function isStringFormat<I extends string, F extends StringFormat>(
 export function assertStringFormat<I extends string, F extends StringFormat>(
   input: I,
   format: F,
+  options?: StringFormatValidationOptions,
 ): asserts input is I & StringFormats[F] {
-  if (!isStringFormat(input, format)) {
+  if (!isStringFormat(input, format, options)) {
     throw new TypeError(`Invalid string format (${format}): ${input}`)
   }
 }
@@ -336,8 +376,9 @@ export function assertStringFormat<I extends string, F extends StringFormat>(
 export function asStringFormat<I extends string, F extends StringFormat>(
   input: I,
   format: F,
+  options?: StringFormatValidationOptions,
 ): I & StringFormats[F] {
-  assertStringFormat(input, format)
+  assertStringFormat(input, format, options)
   return input
 }
 
@@ -365,8 +406,9 @@ export function asStringFormat<I extends string, F extends StringFormat>(
 export function ifStringFormat<I extends string, F extends StringFormat>(
   input: I,
   format: F,
+  options?: StringFormatValidationOptions,
 ): undefined | (I & StringFormats[F]) {
-  return isStringFormat(input, format) ? input : undefined
+  return isStringFormat(input, format, options) ? input : undefined
 }
 
 /**

package/src/core/validation-error.ts

@@ -29,8 +29,15 @@ import {
  * console.log(error.toJSON())
  * // { error: 'InvalidRequest', message: '...', issues: [...] }
  * ```
+ *
+ * @note this class implements {@link ResultFailure} to allow it to be used
+ * directly as a failure reason in validation results, avoiding the need for
+ * wrapping it in an additional object.
  */
-export class LexValidationError extends LexError<'InvalidRequest'> {
+export class LexValidationError
+  extends LexError<'InvalidRequest'>
+  implements ResultFailure<LexValidationError>
+{
   name = 'LexValidationError'
 
   /**
@@ -56,6 +63,14 @@ export class LexValidationError extends LexError<'InvalidRequest'> {
     this.issues = issuesAgg
   }
 
+  /** @see {ResultFailure.success} */
+  readonly success = false as const
+
+  /** @see {ResultFailure.reason} */
+  get reason() {
+    return this
+  }
+
   /**
    * Converts the error to a JSON-serializable object.
    *