@atproto/lex-schema 0.0.13 → 0.0.15

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # @atproto/lex-schema
 
+## 0.0.15
+
+### Patch Changes
+
+- [#4734](https://github.com/bluesky-social/atproto/pull/4734) [`3dc3791`](https://github.com/bluesky-social/atproto/commit/3dc37915436dec7e18c7dc9dcf01b72cad53fdbe) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Rename `IssueInvalidFormat`'s `message` property to `detail`
+
+- [#4734](https://github.com/bluesky-social/atproto/pull/4734) [`3dc3791`](https://github.com/bluesky-social/atproto/commit/3dc37915436dec7e18c7dc9dcf01b72cad53fdbe) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Add a read-only `message` property to the `Issue` class
+
+- [#4734](https://github.com/bluesky-social/atproto/pull/4734) [`3dc3791`](https://github.com/bluesky-social/atproto/commit/3dc37915436dec7e18c7dc9dcf01b72cad53fdbe) Thanks [@matthieusieben](https://github.com/matthieusieben)! - `LexValidationError` class now implements `ResultFailure` allowing it to be used as validation return value directly (without the need to be wrapped)
+
+- [#4734](https://github.com/bluesky-social/atproto/pull/4734) [`3dc3791`](https://github.com/bluesky-social/atproto/commit/3dc37915436dec7e18c7dc9dcf01b72cad53fdbe) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Update stringification of issues (`toString()`) to consistently display the error path at the end.
+
+- [`112b159`](https://github.com/bluesky-social/atproto/commit/112b159ec293a5c3fff41237474a3788fc47f9ca) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Export more string format type assertion utilities
+
+- [#4734](https://github.com/bluesky-social/atproto/pull/4734) [`3dc3791`](https://github.com/bluesky-social/atproto/commit/3dc37915436dec7e18c7dc9dcf01b72cad53fdbe) Thanks [@matthieusieben](https://github.com/matthieusieben)! - `PropertyKey` is no longer exported. Use the global value instead.
+
+- [#4734](https://github.com/bluesky-social/atproto/pull/4734) [`3dc3791`](https://github.com/bluesky-social/atproto/commit/3dc37915436dec7e18c7dc9dcf01b72cad53fdbe) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Add [Standard Schema](https://standardschema.dev/) compatibility
+
+- Updated dependencies [[`67eb0c1`](https://github.com/bluesky-social/atproto/commit/67eb0c19ac415e762e221b2ccda9f0bcf7b3dd6f)]:
+  - @atproto/syntax@0.5.1
+
+## 0.0.14
+
+### Patch Changes
+
+- [#4688](https://github.com/bluesky-social/atproto/pull/4688) [`52834ab`](https://github.com/bluesky-social/atproto/commit/52834aba182da8df3611fd9dff924e6c6a3973a7) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Allow `WWWAuthenticate` to have multiple challenges for the same scheme
+
+- [#4689](https://github.com/bluesky-social/atproto/pull/4689) [`f7c2610`](https://github.com/bluesky-social/atproto/commit/f7c26103a6d4e24e5bedbb6fd908be140420e0dd) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Export more `DatetimeString` utilities from `@atproto/syntax`
+
+- [#4688](https://github.com/bluesky-social/atproto/pull/4688) [`52834ab`](https://github.com/bluesky-social/atproto/commit/52834aba182da8df3611fd9dff924e6c6a3973a7) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Make `$` utility function bound to the instance, allowing to use them without the schema as `this` context
+
+- [#4688](https://github.com/bluesky-social/atproto/pull/4688) [`52834ab`](https://github.com/bluesky-social/atproto/commit/52834aba182da8df3611fd9dff924e6c6a3973a7) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Ignore empty strings from `params` parsing
+
+- [#4688](https://github.com/bluesky-social/atproto/pull/4688) [`52834ab`](https://github.com/bluesky-social/atproto/commit/52834aba182da8df3611fd9dff924e6c6a3973a7) Thanks [@matthieusieben](https://github.com/matthieusieben)! - Renaming `ValidationError` to `LexValidationError` for consistency with `LexError` & sub-classes
+
+- Updated dependencies [[`f7c2610`](https://github.com/bluesky-social/atproto/commit/f7c26103a6d4e24e5bedbb6fd908be140420e0dd), [`f7c2610`](https://github.com/bluesky-social/atproto/commit/f7c26103a6d4e24e5bedbb6fd908be140420e0dd), [`f7c2610`](https://github.com/bluesky-social/atproto/commit/f7c26103a6d4e24e5bedbb6fd908be140420e0dd), [`f7c2610`](https://github.com/bluesky-social/atproto/commit/f7c26103a6d4e24e5bedbb6fd908be140420e0dd), [`52834ab`](https://github.com/bluesky-social/atproto/commit/52834aba182da8df3611fd9dff924e6c6a3973a7), [`f7c2610`](https://github.com/bluesky-social/atproto/commit/f7c26103a6d4e24e5bedbb6fd908be140420e0dd), [`52834ab`](https://github.com/bluesky-social/atproto/commit/52834aba182da8df3611fd9dff924e6c6a3973a7), [`f7c2610`](https://github.com/bluesky-social/atproto/commit/f7c26103a6d4e24e5bedbb6fd908be140420e0dd), [`52834ab`](https://github.com/bluesky-social/atproto/commit/52834aba182da8df3611fd9dff924e6c6a3973a7)]:
+  - @atproto/syntax@0.5.0
+  - @atproto/lex-data@0.0.13
+
 ## 0.0.13
 
 ### Patch Changes

package/dist/core/schema.d.ts

@@ -1,3 +1,4 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
 import { InferInput, InferOutput, ValidationContext, ValidationOptions, ValidationResult, Validator } from './validator.js';
 /**
  * Options for parsing operations.
@@ -40,7 +41,6 @@ export interface SchemaInternals<out TInput = unknown, out TOutput = TInput> {
  *
  * @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
@@ -55,19 +55,20 @@ export interface SchemaInternals<out TInput = unknown, out TOutput = TInput> {
  *
  * const schema = new MySchema()
  * schema.assert('hello')     // OK
- * schema.assert(123)         // Throws ValidationError
+ * schema.assert(123)         // Throws LexValidationError
  * schema.matches('hello')    // true
  * schema.matches(123)        // false
  * ```
  */
-export declare 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 declare abstract class Schema<out TInput = unknown, out TOutput = TInput> implements Validator<TInput, TOutput>, StandardSchemaV1<TInput, TOutput> {
     /**
      * Internal phantom property for type inference.
      * This property does not exist at runtime.
      *
      * @internal
      */
-    readonly ['__lex']: TInternals;
+    readonly ['__lex']: SchemaInternals<TInput, TOutput>;
+    get '~standard'(): StandardSchemaV1.Props<TInput, TOutput>;
     abstract readonly type: string;
     /**
      * Performs validation of the input value within a validation context.
@@ -142,12 +143,12 @@ export declare abstract class Schema<out TInput = unknown, out TOutput = TInput,
      *
      * Unlike {@link validate}, this method allows the schema to transform
      * the input value (e.g., applying default values, type coercion).
-     * Throws a {@link ValidationError} if the input is invalid.
+     * Throws a {@link LexValidationError} if the input is invalid.
      *
      * @param input - The value to parse
      * @param options - Optional parsing configuration
      * @returns The parsed and potentially transformed value
-     * @throws {ValidationError} If the input fails validation
+     * @throws {LexValidationError} If the input fails validation
      *
      * @example
      * ```typescript
@@ -182,13 +183,13 @@ export declare abstract class Schema<out TInput = unknown, out TOutput = TInput,
      *
      * Unlike {@link parse}, this method requires the input to exactly match
      * the schema without any transformations (no defaults applied, no coercion).
-     * Throws a {@link ValidationError} if the input is invalid or would require transformation.
+     * Throws a {@link LexValidationError} if the input is invalid or would require transformation.
      *
      * @typeParam I - The input type (preserved in the return type)
      * @param input - The value to validate
      * @param options - Optional validation configuration
      * @returns The validated input with narrowed type
-     * @throws {ValidationError} If the input fails validation or requires transformation
+     * @throws {LexValidationError} If the input fails validation or requires transformation
      *
      * @example
      * ```typescript
@@ -220,58 +221,49 @@ export declare abstract class Schema<out TInput = unknown, out TOutput = TInput,
      */
     safeValidate<I>(input: I, options?: ValidateOptions): ValidationResult<I & InferInput<this>>;
     /**
-     * Alias for {@link assert} with `$` prefix for namespace compatibility.
-     *
+     * Bound alias for {@link assert} for compatibility with generated utilities.
      * @see {@link assert}
      */
-    $assert(input: unknown): asserts input is InferInput<this>;
+    get $assert(): typeof this.assert;
     /**
-     * Alias for {@link check} with `$` prefix for namespace compatibility.
-     *
+     * Bound alias for {@link check} for compatibility with generated utilities.
      * @see {@link check}
      */
-    $check(input: unknown): void;
+    get $check(): typeof this.check;
     /**
-     * Alias for {@link cast} with `$` prefix for namespace compatibility.
-     *
+     * Bound alias for {@link cast} for compatibility with generated utilities.
      * @see {@link cast}
      */
-    $cast<I>(input: I): I & InferInput<this>;
+    get $cast(): typeof this.cast;
     /**
-     * Alias for {@link matches} with `$` prefix for namespace compatibility.
-     *
+     * Bound alias for {@link matches} for compatibility with generated utilities.
      * @see {@link matches}
      */
-    $matches(input: unknown): input is InferInput<this>;
+    get $matches(): typeof this.matches;
     /**
-     * Alias for {@link ifMatches} with `$` prefix for namespace compatibility.
-     *
+     * Bound alias for {@link ifMatches} for compatibility with generated utilities.
      * @see {@link ifMatches}
      */
-    $ifMatches<I>(input: I): (I & InferInput<this>) | undefined;
+    get $ifMatches(): typeof this.ifMatches;
     /**
-     * Alias for {@link parse} with `$` prefix for namespace compatibility.
-     *
+     * Bound alias for {@link parse} for compatibility with generated utilities.
      * @see {@link parse}
      */
-    $parse(input: unknown, options?: ValidateOptions): InferOutput<this>;
+    get $parse(): typeof this.parse;
     /**
-     * Alias for {@link safeParse} with `$` prefix for namespace compatibility.
-     *
+     * Bound alias for {@link safeParse} for compatibility with generated utilities.
      * @see {@link safeParse}
      */
-    $safeParse(input: unknown, options?: ValidateOptions): ValidationResult<InferOutput<this>>;
+    get $safeParse(): typeof this.safeParse;
     /**
-     * Alias for {@link validate} with `$` prefix for namespace compatibility.
-     *
+     * Bound alias for {@link validate} for compatibility with generated utilities.
      * @see {@link validate}
      */
-    $validate<I>(input: I, options?: ValidateOptions): I & InferInput<this>;
+    get $validate(): typeof this.validate;
     /**
-     * Alias for {@link safeValidate} with `$` prefix for namespace compatibility.
-     *
+     * Bound alias for {@link safeValidate} for compatibility with generated utilities.
      * @see {@link safeValidate}
      */
-    $safeValidate<I>(input: I, options?: ValidateOptions): ValidationResult<I & InferInput<this>>;
+    get $safeValidate(): typeof this.safeValidate;
 }
 //# sourceMappingURL=schema.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/core/schema.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/core/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAGxD,OAAO,EACL,UAAU,EACV,WAAW,EACX,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,SAAS,EACV,MAAM,gBAAgB,CAAA;AAEvB;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAA;AAE1D;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAA;AAE7D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,eAAe,CAAC,GAAG,CAAC,MAAM,GAAG,OAAO,EAAE,GAAG,CAAC,OAAO,GAAG,MAAM;IACzE,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,OAAO,CAAA;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,8BAAsB,MAAM,CAAC,GAAG,CAAC,MAAM,GAAG,OAAO,EAAE,GAAG,CAAC,OAAO,GAAG,MAAM,CACrE,YAAW,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,gBAAgB,CAAC,MAAM,EAAE,OAAO,CAAC;IAExE;;;;;OAKG;IACH,SAAiB,CAAC,OAAO,CAAC,EAAE,eAAe,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAE5D,IAAI,WAAW,IAAI,gBAAgB,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,CAIzD;IAMD,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IAE9B;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,iBAAiB,CACxB,KAAK,EAAE,OAAO,EACd,GAAG,EAAE,iBAAiB,GACrB,gBAAgB;IAEnB;;;;;OAKG;IACH,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,UAAU,CAAC,IAAI,CAAC;IAKzD;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAI3B;;;;OAIG;IACH,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC;IAMvC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC;IAKnD;;;;;;;;;;;;;;;;;OAiBG;IACH,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC,GAAG,SAAS;IAI1D;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,WAAW,CAAC,IAAI,CAAC;IAMhE;;;;;;;;;;;;;;;;;;;OAmBG;IACH,SAAS,CACP,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,YAAY,GACrB,gBAAgB,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAOtC;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC;IAMtE;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,YAAY,CAAC,CAAC,EACZ,KAAK,EAAE,CAAC,EACR,OAAO,CAAC,EAAE,eAAe,GACxB,gBAAgB,CAAC,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IA6CzC;;;OAGG;IACH,IAAI,OAAO,IAAI,OAAO,IAAI,CAAC,MAAM,CAEhC;IAED;;;OAGG;IACH,IAAI,MAAM,IAAI,OAAO,IAAI,CAAC,KAAK,CAE9B;IAED;;;OAGG;IACH,IAAI,KAAK,IAAI,OAAO,IAAI,CAAC,IAAI,CAE5B;IAED;;;OAGG;IACH,IAAI,QAAQ,IAAI,OAAO,IAAI,CAAC,OAAO,CAElC;IAED;;;OAGG;IACH,IAAI,UAAU,IAAI,OAAO,IAAI,CAAC,SAAS,CAEtC;IAED;;;OAGG;IACH,IAAI,MAAM,IAAI,OAAO,IAAI,CAAC,KAAK,CAE9B;IAED;;;OAGG;IACH,IAAI,UAAU,IAAI,OAAO,IAAI,CAAC,SAAS,CAEtC;IAED;;;OAGG;IACH,IAAI,SAAS,IAAI,OAAO,IAAI,CAAC,QAAQ,CAEpC;IAED;;;OAGG;IACH,IAAI,aAAa,IAAI,OAAO,IAAI,CAAC,YAAY,CAE5C;CACF"}

package/dist/core/schema.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = void 0;
+const lazy_property_js_1 = require("../util/lazy-property.js");
+const standard_schema_js_1 = require("./standard-schema.js");
 const validator_js_1 = require("./validator.js");
 /**
  * Abstract base class for all schema validators in the lexicon system.
@@ -18,7 +20,6 @@ const validator_js_1 = require("./validator.js");
  *
  * @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
@@ -33,12 +34,17 @@ const validator_js_1 = require("./validator.js");
  *
  * const schema = new MySchema()
  * schema.assert('hello')     // OK
- * schema.assert(123)         // Throws ValidationError
+ * schema.assert(123)         // Throws LexValidationError
  * schema.matches('hello')    // true
  * schema.matches(123)        // false
  * ```
  */
 class Schema {
+    get '~standard'() {
+        // Lazily create, and cache, the Standard Schema adapter for this schema
+        // instance.
+        return (0, lazy_property_js_1.lazyProperty)(this, '~standard', new standard_schema_js_1.StandardSchemaAdapter(this));
+    }
     /**
      * @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
@@ -114,12 +120,12 @@ class Schema {
      *
      * Unlike {@link validate}, this method allows the schema to transform
      * the input value (e.g., applying default values, type coercion).
-     * Throws a {@link ValidationError} if the input is invalid.
+     * Throws a {@link LexValidationError} if the input is invalid.
      *
      * @param input - The value to parse
      * @param options - Optional parsing configuration
      * @returns The parsed and potentially transformed value
-     * @throws {ValidationError} If the input fails validation
+     * @throws {LexValidationError} If the input fails validation
      *
      * @example
      * ```typescript
@@ -164,13 +170,13 @@ class Schema {
      *
      * Unlike {@link parse}, this method requires the input to exactly match
      * the schema without any transformations (no defaults applied, no coercion).
-     * Throws a {@link ValidationError} if the input is invalid or would require transformation.
+     * Throws a {@link LexValidationError} if the input is invalid or would require transformation.
      *
      * @typeParam I - The input type (preserved in the return type)
      * @param input - The value to validate
      * @param options - Optional validation configuration
      * @returns The validated input with narrowed type
-     * @throws {ValidationError} If the input fails validation or requires transformation
+     * @throws {LexValidationError} If the input fails validation or requires transformation
      *
      * @example
      * ```typescript
@@ -213,90 +219,103 @@ class Schema {
     }
     // @NOTE Dollar-prefixed aliases
     //
-    // The built lexicons namespaces export utility functions that allow accessing
-    // the schema's methods without the need to specify ".main." as part of the
-    // namespace. This way, a utility for a particular record type can be called
-    // like "app.bsky.feed.post.<utility>()" instead of
-    // "app.bsky.feed.post.main.<utility>()". Because those utilities could
-    // conflict with other schemas (e.g. if there is a lexicon definition at
-    // "#<utility>"), those exported utilities will be prefixed with "$". In order
-    // to be able to consistently call the utilities, when using the "main" and
-    // non "main" definitions, we also expose the same methods with a "$" prefix.
-    // Thanks to this, both of the following call will be possible:
+    // The `lex-builder` lib generates namespaced utility functions that allow
+    // accessing the schema's methods without the need to specify the ".main."
+    // part of the namespace. This allows utilities for a particular record type
+    // to be called like "app.bsky.feed.post.<utility>()" instead of
+    // "app.bsky.feed.post.main.<utility>()".
+    //
+    // Because those utilities could conflict with other schemas (e.g. if there is
+    // a lexicon definition with the same name as the "<utility>"), those exported
+    // utilities will be prefixed with "$".
+    //
+    // Similarly, since those utilities are defined as simple "const", they are
+    // also bound (using JS's .bind) to the schema instance, so that they can be
+    // used without worrying about the context (e.g. "app.bsky.feed.post.$parse()"
+    // will work regardless of how it is imported or called).
+    //
+    // In order to provide the same functionalities for non-main definitions, we
+    // also define those aliases directly on the schema instance, so that they can
+    // be used in the same way as the utilities generated by "lex-builder". For
+    // example, if there is a non-main definition "app.bsky.feed.defs.postView",
+    // it will also be possible to call "app.bsky.feed.defs.postView.$parse()".
     //
-    // - "app.bsky.feed.post.$parse(...)" // calls a utility function created by "lex build"
-    // - "app.bsky.feed.defs.postView.$parse(...)" // uses the alias defined below on the schema instance
+    // These methods are also "bound" to the instance so that they can be used
+    // exactly like the utilities generated by "lex-builder", without worrying
+    // about the context.
+    //
+    // There are two ways we could "bind" those methods to the instance:
+    // 1. Define them as getters that return the bound method (e.g. get $parse() {
+    //    return this.parse.bind(this) })
+    // 2. Define them as properties that are initialized in the constructor (e.g.
+    //    this.$parse = this.parse.bind(this))
+    //
+    // Since a **lot** of those methods would end-up being created in systems that
+    // contains many schemas (e.g. the appview), we choose the first approach
+    // (getters) in order to avoid the overhead of creating all those bound
+    // functions upfront when instantiating the schemas.
     /**
-     * Alias for {@link assert} with `$` prefix for namespace compatibility.
-     *
+     * Bound alias for {@link assert} for compatibility with generated utilities.
      * @see {@link assert}
      */
-    $assert(input) {
-        return this.assert(input);
+    get $assert() {
+        return (0, lazy_property_js_1.lazyProperty)(this, '$assert', this.assert.bind(this));
     }
     /**
-     * Alias for {@link check} with `$` prefix for namespace compatibility.
-     *
+     * Bound alias for {@link check} for compatibility with generated utilities.
      * @see {@link check}
      */
-    $check(input) {
-        return this.check(input);
+    get $check() {
+        return (0, lazy_property_js_1.lazyProperty)(this, '$check', this.check.bind(this));
     }
     /**
-     * Alias for {@link cast} with `$` prefix for namespace compatibility.
-     *
+     * Bound alias for {@link cast} for compatibility with generated utilities.
      * @see {@link cast}
      */
-    $cast(input) {
-        return this.cast(input);
+    get $cast() {
+        return (0, lazy_property_js_1.lazyProperty)(this, '$cast', this.cast.bind(this));
     }
     /**
-     * Alias for {@link matches} with `$` prefix for namespace compatibility.
-     *
+     * Bound alias for {@link matches} for compatibility with generated utilities.
      * @see {@link matches}
      */
-    $matches(input) {
-        return this.matches(input);
+    get $matches() {
+        return (0, lazy_property_js_1.lazyProperty)(this, '$matches', this.matches.bind(this));
     }
     /**
-     * Alias for {@link ifMatches} with `$` prefix for namespace compatibility.
-     *
+     * Bound alias for {@link ifMatches} for compatibility with generated utilities.
      * @see {@link ifMatches}
      */
-    $ifMatches(input) {
-        return this.ifMatches(input);
+    get $ifMatches() {
+        return (0, lazy_property_js_1.lazyProperty)(this, '$ifMatches', this.ifMatches.bind(this));
     }
     /**
-     * Alias for {@link parse} with `$` prefix for namespace compatibility.
-     *
+     * Bound alias for {@link parse} for compatibility with generated utilities.
      * @see {@link parse}
      */
-    $parse(input, options) {
-        return this.parse(input, options);
+    get $parse() {
+        return (0, lazy_property_js_1.lazyProperty)(this, '$parse', this.parse.bind(this));
     }
     /**
-     * Alias for {@link safeParse} with `$` prefix for namespace compatibility.
-     *
+     * Bound alias for {@link safeParse} for compatibility with generated utilities.
      * @see {@link safeParse}
      */
-    $safeParse(input, options) {
-        return this.safeParse(input, options);
+    get $safeParse() {
+        return (0, lazy_property_js_1.lazyProperty)(this, '$safeParse', this.safeParse.bind(this));
     }
     /**
-     * Alias for {@link validate} with `$` prefix for namespace compatibility.
-     *
+     * Bound alias for {@link validate} for compatibility with generated utilities.
      * @see {@link validate}
      */
-    $validate(input, options) {
-        return this.validate(input, options);
+    get $validate() {
+        return (0, lazy_property_js_1.lazyProperty)(this, '$validate', this.validate.bind(this));
     }
     /**
-     * Alias for {@link safeValidate} with `$` prefix for namespace compatibility.
-     *
+     * Bound alias for {@link safeValidate} for compatibility with generated utilities.
      * @see {@link safeValidate}
      */
-    $safeValidate(input, options) {
-        return this.safeValidate(input, options);
+    get $safeValidate() {
+        return (0, lazy_property_js_1.lazyProperty)(this, '$safeValidate', this.safeValidate.bind(this));
     }
 }
 exports.Schema = Schema;

package/dist/core/schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/core/schema.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  InferInput,\n  InferOutput,\n  ValidationContext,\n  ValidationOptions,\n  ValidationResult,\n  Validator,\n} from './validator.js'\n\n/**\n * Options for parsing operations.\n * Excludes the `mode` option as it is implicitly set to `\"parse\"`.\n */\nexport type ParseOptions = Omit<ValidationOptions, 'mode'>\n\n/**\n * Options for validation operations.\n * Excludes the `mode` option as it is implicitly set to `\"validate\"`.\n */\nexport type ValidateOptions = Omit<ValidationOptions, 'mode'>\n\n/**\n * Internal type structure for schema type inference.\n *\n * This interface defines the phantom types used for compile-time type inference\n * without affecting runtime behavior. The `input` and `output` properties\n * represent the expected input type during validation and the resulting output\n * type after parsing, respectively.\n *\n * @typeParam TInput - The type accepted as input during validation\n * @typeParam TOutput - The type returned after parsing (may differ from input due to coercion)\n */\nexport interface SchemaInternals<out TInput = unknown, out TOutput = TInput> {\n  input: TInput\n  output: TOutput\n}\n\n/**\n * Abstract base class for all schema validators in the lexicon system.\n *\n * This class provides the standard validation interface that all schema types\n * implement. It offers multiple methods for validating and parsing data:\n *\n * - **Assertion methods**: `assert()`, `check()` - throw on invalid input\n * - **Type guard methods**: `matches()`, `ifMatches()` - return boolean or optional value\n * - **Parse methods**: `parse()`, `safeParse()` - allow value transformation/coercion\n * - **Validate methods**: `validate()`, `safeValidate()` - strict validation without coercion\n *\n * All methods are also available with a `$` prefix (e.g., `$parse()`, `$validate()`)\n * for consistent access in generated lexicon namespaces.\n *\n * @typeParam TInput - The type accepted as valid input during validation\n * @typeParam TOutput - The type returned after parsing (may include transformations)\n * @typeParam TInternals - Internal type structure for type inference\n *\n * @example\n * ```typescript\n * class MySchema extends Schema<string> {\n *   validateInContext(input: unknown, ctx: ValidationContext): ValidationResult {\n *     if (typeof input !== 'string') {\n *       return ctx.issueUnexpectedType(input, 'string')\n *     }\n *     return ctx.success(input)\n *   }\n * }\n *\n * const schema = new MySchema()\n * schema.assert('hello')     // OK\n * schema.assert(123)         // Throws ValidationError\n * schema.matches('hello')    // true\n * schema.matches(123)        // false\n * ```\n */\nexport abstract class Schema<\n  out TInput = unknown,\n  out TOutput = TInput,\n  out TInternals extends SchemaInternals<TInput, TOutput> = SchemaInternals<\n    TInput,\n    TOutput\n  >,\n> implements Validator<TInternals['input'], TInternals['output']>\n{\n  /**\n   * Internal phantom property for type inference.\n   * This property does not exist at runtime.\n   *\n   * @internal\n   */\n  declare readonly ['__lex']: TInternals\n\n  // Needed to discriminate multiple schema types when used in unions. Without\n  // this, Typescript could allow an EnumSchema<\"foo\" | \"bar\"> to be used where\n  // a StringSchema is expected, since they would both be structurally\n  // compatible.\n  abstract readonly type: string\n\n  /**\n   * Performs validation of the input value within a validation context.\n   *\n   * This method must be implemented by subclasses to define the actual\n   * validation logic. It should not be called directly; use\n   * {@link ValidationContext.validate} instead to ensure proper mode enforcement.\n   *\n   * @param input - The value to validate\n   * @param ctx - The validation context providing path tracking and issue reporting\n   * @returns A validation result indicating success with the validated value or failure with issues\n   *\n   * @internal\n   */\n  abstract validateInContext(\n    input: unknown,\n    ctx: ValidationContext,\n  ): ValidationResult\n\n  /**\n   * @note use {@link check}() instead of {@link assert}() if you encounter a\n   * `ts(2775)` error and you are not able to fully type the validator. This\n   * will typically arise in generic contexts, where the narrowed type is not\n   * needed.\n   */\n  assert(input: unknown): asserts input is InferInput<this> {\n    const result = ValidationContext.validate(input, this)\n    if (!result.success) throw result.reason\n  }\n\n  /**\n   * Alias for {@link assert}(). Most useful in generic contexts where the\n   * validator is not exactly typed, allowing to avoid \"_Assertions require\n   * every name in the call target to be declared with an explicit type\n   * annotation. ts(2775)_\" errors.\n   */\n  check(input: unknown): void {\n    this.assert(input)\n  }\n\n  /**\n   * Casts the input (by validating it) to the output type if it matches the\n   * schema, otherwise throws. This is the same as calling {@link parse}() with\n   * `mode: \"validate\"`.\n   */\n  cast<I>(input: I): I & InferInput<this> {\n    const result = ValidationContext.validate(input, this)\n    if (result.success) return result.value\n    throw result.reason\n  }\n\n  /**\n   * Type guard that checks if the input matches this schema.\n   *\n   * @param input - The value to check\n   * @returns `true` if the input is valid according to this schema\n   *\n   * @example\n   * ```typescript\n   * if (schema.matches(data)) {\n   *   // data is narrowed to the schema's input type\n   *   console.log(data)\n   * }\n   * ```\n   */\n  matches<I>(input: I): input is I & InferInput<this> {\n    const result = ValidationContext.validate(input, this)\n    return result.success\n  }\n\n  /**\n   * Returns the input if it matches this schema, otherwise returns `undefined`.\n   *\n   * This is useful for optional filtering operations where you want to\n   * conditionally extract values that match a schema.\n   *\n   * @param input - The value to check\n   * @returns The input value with narrowed type if valid, otherwise `undefined`\n   *\n   * @example\n   * ```typescript\n   * const validData = schema.ifMatches(data)\n   * if (validData !== undefined) {\n   *   // validData is the schema's input type\n   *   console.log(validData)\n   * }\n   * ```\n   */\n  ifMatches<I>(input: I): (I & InferInput<this>) | undefined {\n    return this.matches(input) ? input : undefined\n  }\n\n  /**\n   * Parses the input, allowing value transformations and coercion.\n   *\n   * Unlike {@link validate}, this method allows the schema to transform\n   * the input value (e.g., applying default values, type coercion).\n   * Throws a {@link ValidationError} if the input is invalid.\n   *\n   * @param input - The value to parse\n   * @param options - Optional parsing configuration\n   * @returns The parsed and potentially transformed value\n   * @throws {ValidationError} If the input fails validation\n   *\n   * @example\n   * ```typescript\n   * const result = schema.parse(rawData)\n   * // result has defaults applied and is fully typed\n   * ```\n   */\n  parse(input: unknown, options?: ParseOptions): InferOutput<this> {\n    const result = this.safeParse(input, options)\n    if (result.success) return result.value\n    throw result.reason\n  }\n\n  /**\n   * Safely parses the input without throwing, returning a result object.\n   *\n   * This method allows value transformations like {@link parse}, but\n   * returns a discriminated union result instead of throwing on error.\n   *\n   * @param input - The value to parse\n   * @param options - Optional parsing configuration\n   * @returns A {@link ValidationResult} with either the parsed value or validation errors\n   *\n   * @example\n   * ```typescript\n   * const result = schema.safeParse(data)\n   * if (result.success) {\n   *   console.log(result.value)\n   * } else {\n   *   console.error(result.reason.issues)\n   * }\n   * ```\n   */\n  safeParse(\n    input: unknown,\n    options?: ParseOptions,\n  ): ValidationResult<InferOutput<this>> {\n    return ValidationContext.validate(input, this, {\n      ...options,\n      mode: 'parse',\n    })\n  }\n\n  /**\n   * Validates the input strictly without allowing transformations.\n   *\n   * Unlike {@link parse}, this method requires the input to exactly match\n   * the schema without any transformations (no defaults applied, no coercion).\n   * Throws a {@link ValidationError} if the input is invalid or would require transformation.\n   *\n   * @typeParam I - The input type (preserved in the return type)\n   * @param input - The value to validate\n   * @param options - Optional validation configuration\n   * @returns The validated input with narrowed type\n   * @throws {ValidationError} If the input fails validation or requires transformation\n   *\n   * @example\n   * ```typescript\n   * const validated = schema.validate(data)\n   * // validated is typed as the intersection of input type and schema type\n   * ```\n   */\n  validate<I>(input: I, options?: ValidateOptions): I & InferInput<this> {\n    const result = this.safeValidate(input, options)\n    if (result.success) return result.value\n    throw result.reason\n  }\n\n  /**\n   * Safely validates the input without throwing, returning a result object.\n   *\n   * This method performs strict validation like {@link validate}, but\n   * returns a discriminated union result instead of throwing on error.\n   *\n   * @typeParam I - The input type (preserved in the result value type)\n   * @param input - The value to validate\n   * @param options - Optional validation configuration\n   * @returns A {@link ValidationResult} with either the validated value or validation errors\n   *\n   * @example\n   * ```typescript\n   * const result = schema.safeValidate(data)\n   * if (result.success) {\n   *   console.log(result.value)\n   * } else {\n   *   console.error(result.reason.issues)\n   * }\n   * ```\n   */\n  safeValidate<I>(\n    input: I,\n    options?: ValidateOptions,\n  ): ValidationResult<I & InferInput<this>> {\n    return ValidationContext.validate(input, this, {\n      ...options,\n      mode: 'validate',\n    })\n  }\n\n  // @NOTE Dollar-prefixed aliases\n  //\n  // The built lexicons namespaces export utility functions that allow accessing\n  // the schema's methods without the need to specify \".main.\" as part of the\n  // namespace. This way, a utility for a particular record type can be called\n  // like \"app.bsky.feed.post.<utility>()\" instead of\n  // \"app.bsky.feed.post.main.<utility>()\". Because those utilities could\n  // conflict with other schemas (e.g. if there is a lexicon definition at\n  // \"#<utility>\"), those exported utilities will be prefixed with \"$\". In order\n  // to be able to consistently call the utilities, when using the \"main\" and\n  // non \"main\" definitions, we also expose the same methods with a \"$\" prefix.\n  // Thanks to this, both of the following call will be possible:\n  //\n  // - \"app.bsky.feed.post.$parse(...)\" // calls a utility function created by \"lex build\"\n  // - \"app.bsky.feed.defs.postView.$parse(...)\" // uses the alias defined below on the schema instance\n\n  /**\n   * Alias for {@link assert} with `$` prefix for namespace compatibility.\n   *\n   * @see {@link assert}\n   */\n  $assert(input: unknown): asserts input is InferInput<this> {\n    return this.assert(input)\n  }\n\n  /**\n   * Alias for {@link check} with `$` prefix for namespace compatibility.\n   *\n   * @see {@link check}\n   */\n  $check(input: unknown): void {\n    return this.check(input)\n  }\n\n  /**\n   * Alias for {@link cast} with `$` prefix for namespace compatibility.\n   *\n   * @see {@link cast}\n   */\n  $cast<I>(input: I): I & InferInput<this> {\n    return this.cast(input)\n  }\n\n  /**\n   * Alias for {@link matches} with `$` prefix for namespace compatibility.\n   *\n   * @see {@link matches}\n   */\n  $matches(input: unknown): input is InferInput<this> {\n    return this.matches(input)\n  }\n\n  /**\n   * Alias for {@link ifMatches} with `$` prefix for namespace compatibility.\n   *\n   * @see {@link ifMatches}\n   */\n  $ifMatches<I>(input: I): (I & InferInput<this>) | undefined {\n    return this.ifMatches(input)\n  }\n\n  /**\n   * Alias for {@link parse} with `$` prefix for namespace compatibility.\n   *\n   * @see {@link parse}\n   */\n  $parse(input: unknown, options?: ValidateOptions): InferOutput<this> {\n    return this.parse(input, options)\n  }\n\n  /**\n   * Alias for {@link safeParse} with `$` prefix for namespace compatibility.\n   *\n   * @see {@link safeParse}\n   */\n  $safeParse(\n    input: unknown,\n    options?: ValidateOptions,\n  ): ValidationResult<InferOutput<this>> {\n    return this.safeParse(input, options)\n  }\n\n  /**\n   * Alias for {@link validate} with `$` prefix for namespace compatibility.\n   *\n   * @see {@link validate}\n   */\n  $validate<I>(input: I, options?: ValidateOptions): I & InferInput<this> {\n    return this.validate(input, options)\n  }\n\n  /**\n   * Alias for {@link safeValidate} with `$` prefix for namespace compatibility.\n   *\n   * @see {@link safeValidate}\n   */\n  $safeValidate<I>(\n    input: I,\n    options?: ValidateOptions,\n  ): ValidationResult<I & InferInput<this>> {\n    return this.safeValidate(input, options)\n  }\n}\n"]}
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/core/schema.ts"],"names":[],"mappings":"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","sourcesContent":["import { StandardSchemaV1 } from '@standard-schema/spec'\nimport { lazyProperty } from '../util/lazy-property.js'\nimport { StandardSchemaAdapter } from './standard-schema.js'\nimport {\n  InferInput,\n  InferOutput,\n  ValidationContext,\n  ValidationOptions,\n  ValidationResult,\n  Validator,\n} from './validator.js'\n\n/**\n * Options for parsing operations.\n * Excludes the `mode` option as it is implicitly set to `\"parse\"`.\n */\nexport type ParseOptions = Omit<ValidationOptions, 'mode'>\n\n/**\n * Options for validation operations.\n * Excludes the `mode` option as it is implicitly set to `\"validate\"`.\n */\nexport type ValidateOptions = Omit<ValidationOptions, 'mode'>\n\n/**\n * Internal type structure for schema type inference.\n *\n * This interface defines the phantom types used for compile-time type inference\n * without affecting runtime behavior. The `input` and `output` properties\n * represent the expected input type during validation and the resulting output\n * type after parsing, respectively.\n *\n * @typeParam TInput - The type accepted as input during validation\n * @typeParam TOutput - The type returned after parsing (may differ from input due to coercion)\n */\nexport interface SchemaInternals<out TInput = unknown, out TOutput = TInput> {\n  input: TInput\n  output: TOutput\n}\n\n/**\n * Abstract base class for all schema validators in the lexicon system.\n *\n * This class provides the standard validation interface that all schema types\n * implement. It offers multiple methods for validating and parsing data:\n *\n * - **Assertion methods**: `assert()`, `check()` - throw on invalid input\n * - **Type guard methods**: `matches()`, `ifMatches()` - return boolean or optional value\n * - **Parse methods**: `parse()`, `safeParse()` - allow value transformation/coercion\n * - **Validate methods**: `validate()`, `safeValidate()` - strict validation without coercion\n *\n * All methods are also available with a `$` prefix (e.g., `$parse()`, `$validate()`)\n * for consistent access in generated lexicon namespaces.\n *\n * @typeParam TInput - The type accepted as valid input during validation\n * @typeParam TOutput - The type returned after parsing (may include transformations)\n *\n * @example\n * ```typescript\n * class MySchema extends Schema<string> {\n *   validateInContext(input: unknown, ctx: ValidationContext): ValidationResult {\n *     if (typeof input !== 'string') {\n *       return ctx.issueUnexpectedType(input, 'string')\n *     }\n *     return ctx.success(input)\n *   }\n * }\n *\n * const schema = new MySchema()\n * schema.assert('hello')     // OK\n * schema.assert(123)         // Throws LexValidationError\n * schema.matches('hello')    // true\n * schema.matches(123)        // false\n * ```\n */\nexport abstract class Schema<out TInput = unknown, out TOutput = TInput>\n  implements Validator<TInput, TOutput>, StandardSchemaV1<TInput, TOutput>\n{\n  /**\n   * Internal phantom property for type inference.\n   * This property does not exist at runtime.\n   *\n   * @internal\n   */\n  declare readonly ['__lex']: SchemaInternals<TInput, TOutput>\n\n  get '~standard'(): StandardSchemaV1.Props<TInput, TOutput> {\n    // Lazily create, and cache, the Standard Schema adapter for this schema\n    // instance.\n    return lazyProperty(this, '~standard', new StandardSchemaAdapter(this))\n  }\n\n  // Needed to discriminate multiple schema types when used in unions. Without\n  // this, Typescript could allow an EnumSchema<\"foo\" | \"bar\"> to be used where\n  // a StringSchema is expected, since they would both be structurally\n  // compatible.\n  abstract readonly type: string\n\n  /**\n   * Performs validation of the input value within a validation context.\n   *\n   * This method must be implemented by subclasses to define the actual\n   * validation logic. It should not be called directly; use\n   * {@link ValidationContext.validate} instead to ensure proper mode enforcement.\n   *\n   * @param input - The value to validate\n   * @param ctx - The validation context providing path tracking and issue reporting\n   * @returns A validation result indicating success with the validated value or failure with issues\n   *\n   * @internal\n   */\n  abstract validateInContext(\n    input: unknown,\n    ctx: ValidationContext,\n  ): ValidationResult\n\n  /**\n   * @note use {@link check}() instead of {@link assert}() if you encounter a\n   * `ts(2775)` error and you are not able to fully type the validator. This\n   * will typically arise in generic contexts, where the narrowed type is not\n   * needed.\n   */\n  assert(input: unknown): asserts input is InferInput<this> {\n    const result = ValidationContext.validate(input, this)\n    if (!result.success) throw result.reason\n  }\n\n  /**\n   * Alias for {@link assert}(). Most useful in generic contexts where the\n   * validator is not exactly typed, allowing to avoid \"_Assertions require\n   * every name in the call target to be declared with an explicit type\n   * annotation. ts(2775)_\" errors.\n   */\n  check(input: unknown): void {\n    this.assert(input)\n  }\n\n  /**\n   * Casts the input (by validating it) to the output type if it matches the\n   * schema, otherwise throws. This is the same as calling {@link parse}() with\n   * `mode: \"validate\"`.\n   */\n  cast<I>(input: I): I & InferInput<this> {\n    const result = ValidationContext.validate(input, this)\n    if (result.success) return result.value\n    throw result.reason\n  }\n\n  /**\n   * Type guard that checks if the input matches this schema.\n   *\n   * @param input - The value to check\n   * @returns `true` if the input is valid according to this schema\n   *\n   * @example\n   * ```typescript\n   * if (schema.matches(data)) {\n   *   // data is narrowed to the schema's input type\n   *   console.log(data)\n   * }\n   * ```\n   */\n  matches<I>(input: I): input is I & InferInput<this> {\n    const result = ValidationContext.validate(input, this)\n    return result.success\n  }\n\n  /**\n   * Returns the input if it matches this schema, otherwise returns `undefined`.\n   *\n   * This is useful for optional filtering operations where you want to\n   * conditionally extract values that match a schema.\n   *\n   * @param input - The value to check\n   * @returns The input value with narrowed type if valid, otherwise `undefined`\n   *\n   * @example\n   * ```typescript\n   * const validData = schema.ifMatches(data)\n   * if (validData !== undefined) {\n   *   // validData is the schema's input type\n   *   console.log(validData)\n   * }\n   * ```\n   */\n  ifMatches<I>(input: I): (I & InferInput<this>) | undefined {\n    return this.matches(input) ? input : undefined\n  }\n\n  /**\n   * Parses the input, allowing value transformations and coercion.\n   *\n   * Unlike {@link validate}, this method allows the schema to transform\n   * the input value (e.g., applying default values, type coercion).\n   * Throws a {@link LexValidationError} if the input is invalid.\n   *\n   * @param input - The value to parse\n   * @param options - Optional parsing configuration\n   * @returns The parsed and potentially transformed value\n   * @throws {LexValidationError} If the input fails validation\n   *\n   * @example\n   * ```typescript\n   * const result = schema.parse(rawData)\n   * // result has defaults applied and is fully typed\n   * ```\n   */\n  parse(input: unknown, options?: ParseOptions): InferOutput<this> {\n    const result = this.safeParse(input, options)\n    if (result.success) return result.value\n    throw result.reason\n  }\n\n  /**\n   * Safely parses the input without throwing, returning a result object.\n   *\n   * This method allows value transformations like {@link parse}, but\n   * returns a discriminated union result instead of throwing on error.\n   *\n   * @param input - The value to parse\n   * @param options - Optional parsing configuration\n   * @returns A {@link ValidationResult} with either the parsed value or validation errors\n   *\n   * @example\n   * ```typescript\n   * const result = schema.safeParse(data)\n   * if (result.success) {\n   *   console.log(result.value)\n   * } else {\n   *   console.error(result.reason.issues)\n   * }\n   * ```\n   */\n  safeParse(\n    input: unknown,\n    options?: ParseOptions,\n  ): ValidationResult<InferOutput<this>> {\n    return ValidationContext.validate(input, this, {\n      ...options,\n      mode: 'parse',\n    })\n  }\n\n  /**\n   * Validates the input strictly without allowing transformations.\n   *\n   * Unlike {@link parse}, this method requires the input to exactly match\n   * the schema without any transformations (no defaults applied, no coercion).\n   * Throws a {@link LexValidationError} if the input is invalid or would require transformation.\n   *\n   * @typeParam I - The input type (preserved in the return type)\n   * @param input - The value to validate\n   * @param options - Optional validation configuration\n   * @returns The validated input with narrowed type\n   * @throws {LexValidationError} If the input fails validation or requires transformation\n   *\n   * @example\n   * ```typescript\n   * const validated = schema.validate(data)\n   * // validated is typed as the intersection of input type and schema type\n   * ```\n   */\n  validate<I>(input: I, options?: ValidateOptions): I & InferInput<this> {\n    const result = this.safeValidate(input, options)\n    if (result.success) return result.value\n    throw result.reason\n  }\n\n  /**\n   * Safely validates the input without throwing, returning a result object.\n   *\n   * This method performs strict validation like {@link validate}, but\n   * returns a discriminated union result instead of throwing on error.\n   *\n   * @typeParam I - The input type (preserved in the result value type)\n   * @param input - The value to validate\n   * @param options - Optional validation configuration\n   * @returns A {@link ValidationResult} with either the validated value or validation errors\n   *\n   * @example\n   * ```typescript\n   * const result = schema.safeValidate(data)\n   * if (result.success) {\n   *   console.log(result.value)\n   * } else {\n   *   console.error(result.reason.issues)\n   * }\n   * ```\n   */\n  safeValidate<I>(\n    input: I,\n    options?: ValidateOptions,\n  ): ValidationResult<I & InferInput<this>> {\n    return ValidationContext.validate(input, this, {\n      ...options,\n      mode: 'validate',\n    })\n  }\n\n  // @NOTE Dollar-prefixed aliases\n  //\n  // The `lex-builder` lib generates namespaced utility functions that allow\n  // accessing the schema's methods without the need to specify the \".main.\"\n  // part of the namespace. This allows utilities for a particular record type\n  // to be called like \"app.bsky.feed.post.<utility>()\" instead of\n  // \"app.bsky.feed.post.main.<utility>()\".\n  //\n  // Because those utilities could conflict with other schemas (e.g. if there is\n  // a lexicon definition with the same name as the \"<utility>\"), those exported\n  // utilities will be prefixed with \"$\".\n  //\n  // Similarly, since those utilities are defined as simple \"const\", they are\n  // also bound (using JS's .bind) to the schema instance, so that they can be\n  // used without worrying about the context (e.g. \"app.bsky.feed.post.$parse()\"\n  // will work regardless of how it is imported or called).\n  //\n  // In order to provide the same functionalities for non-main definitions, we\n  // also define those aliases directly on the schema instance, so that they can\n  // be used in the same way as the utilities generated by \"lex-builder\". For\n  // example, if there is a non-main definition \"app.bsky.feed.defs.postView\",\n  // it will also be possible to call \"app.bsky.feed.defs.postView.$parse()\".\n  //\n  // These methods are also \"bound\" to the instance so that they can be used\n  // exactly like the utilities generated by \"lex-builder\", without worrying\n  // about the context.\n  //\n  // There are two ways we could \"bind\" those methods to the instance:\n  // 1. Define them as getters that return the bound method (e.g. get $parse() {\n  //    return this.parse.bind(this) })\n  // 2. Define them as properties that are initialized in the constructor (e.g.\n  //    this.$parse = this.parse.bind(this))\n  //\n  // Since a **lot** of those methods would end-up being created in systems that\n  // contains many schemas (e.g. the appview), we choose the first approach\n  // (getters) in order to avoid the overhead of creating all those bound\n  // functions upfront when instantiating the schemas.\n\n  /**\n   * Bound alias for {@link assert} for compatibility with generated utilities.\n   * @see {@link assert}\n   */\n  get $assert(): typeof this.assert {\n    return lazyProperty(this, '$assert', this.assert.bind(this))\n  }\n\n  /**\n   * Bound alias for {@link check} for compatibility with generated utilities.\n   * @see {@link check}\n   */\n  get $check(): typeof this.check {\n    return lazyProperty(this, '$check', this.check.bind(this))\n  }\n\n  /**\n   * Bound alias for {@link cast} for compatibility with generated utilities.\n   * @see {@link cast}\n   */\n  get $cast(): typeof this.cast {\n    return lazyProperty(this, '$cast', this.cast.bind(this))\n  }\n\n  /**\n   * Bound alias for {@link matches} for compatibility with generated utilities.\n   * @see {@link matches}\n   */\n  get $matches(): typeof this.matches {\n    return lazyProperty(this, '$matches', this.matches.bind(this))\n  }\n\n  /**\n   * Bound alias for {@link ifMatches} for compatibility with generated utilities.\n   * @see {@link ifMatches}\n   */\n  get $ifMatches(): typeof this.ifMatches {\n    return lazyProperty(this, '$ifMatches', this.ifMatches.bind(this))\n  }\n\n  /**\n   * Bound alias for {@link parse} for compatibility with generated utilities.\n   * @see {@link parse}\n   */\n  get $parse(): typeof this.parse {\n    return lazyProperty(this, '$parse', this.parse.bind(this))\n  }\n\n  /**\n   * Bound alias for {@link safeParse} for compatibility with generated utilities.\n   * @see {@link safeParse}\n   */\n  get $safeParse(): typeof this.safeParse {\n    return lazyProperty(this, '$safeParse', this.safeParse.bind(this))\n  }\n\n  /**\n   * Bound alias for {@link validate} for compatibility with generated utilities.\n   * @see {@link validate}\n   */\n  get $validate(): typeof this.validate {\n    return lazyProperty(this, '$validate', this.validate.bind(this))\n  }\n\n  /**\n   * Bound alias for {@link safeValidate} for compatibility with generated utilities.\n   * @see {@link safeValidate}\n   */\n  get $safeValidate(): typeof this.safeValidate {\n    return lazyProperty(this, '$safeValidate', this.safeValidate.bind(this))\n  }\n}\n"]}

package/dist/core/standard-schema.d.ts

@@ -0,0 +1,14 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { Validator } from './validator.js';
+/**
+ * The Standard Schema adapter for {@link Validator} instances.
+ */
+export declare class StandardSchemaAdapter<TInput, TOutput> implements StandardSchemaV1.Props<TInput, TOutput> {
+    private readonly validator;
+    readonly version = 1;
+    readonly vendor = "@atproto/lex-schema";
+    readonly types: StandardSchemaV1.Types<TInput, TOutput>;
+    constructor(validator: Validator<TInput, TOutput>);
+    validate(value: unknown, options?: StandardSchemaV1.Options): StandardSchemaV1.Result<TOutput>;
+}
+//# sourceMappingURL=standard-schema.d.ts.map

package/dist/core/standard-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-schema.d.ts","sourceRoot":"","sources":["../../src/core/standard-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAqB,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE7D;;GAEG;AACH,qBAAa,qBAAqB,CAAC,MAAM,EAAE,OAAO,CAChD,YAAW,gBAAgB,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC;IAQtC,OAAO,CAAC,QAAQ,CAAC,SAAS;IANtC,QAAQ,CAAC,OAAO,KAAI;IAEpB,QAAQ,CAAC,MAAM,yBAAwB;IAEvC,SAAiB,KAAK,EAAE,gBAAgB,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;gBAElC,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC;IAElE,QAAQ,CACN,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,gBAAgB,CAAC,OAAO,GACjC,gBAAgB,CAAC,MAAM,CAAC,OAAO,CAAC;CAUpC"}

package/dist/core/standard-schema.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandardSchemaAdapter = void 0;
+const validator_js_1 = require("./validator.js");
+/**
+ * The Standard Schema adapter for {@link Validator} instances.
+ */
+class StandardSchemaAdapter {
+    validator;
+    version = 1;
+    vendor = '@atproto/lex-schema';
+    constructor(validator) {
+        this.validator = validator;
+    }
+    validate(value, options) {
+        // 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 validator_js_1.ValidationContext.validate(value, this.validator, {
+            ...options?.libraryOptions,
+            mode: 'parse',
+        });
+    }
+}
+exports.StandardSchemaAdapter = StandardSchemaAdapter;
+//# sourceMappingURL=standard-schema.js.map

package/dist/core/standard-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-schema.js","sourceRoot":"","sources":["../../src/core/standard-schema.ts"],"names":[],"mappings":";;;AACA,iDAA6D;AAE7D;;GAEG;AACH,MAAa,qBAAqB;IASH;IANpB,OAAO,GAAG,CAAC,CAAA;IAEX,MAAM,GAAG,qBAAqB,CAAA;IAIvC,YAA6B,SAAqC;QAArC,cAAS,GAAT,SAAS,CAA4B;IAAG,CAAC;IAEtE,QAAQ,CACN,KAAc,EACd,OAAkC;QAElC,0EAA0E;QAC1E,qEAAqE;QACrE,0DAA0D;QAC1D,8BAA8B;QAC9B,OAAO,gCAAiB,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE;YACvD,GAAG,OAAO,EAAE,cAAc;YAC1B,IAAI,EAAE,OAAO;SACd,CAAC,CAAA;IACJ,CAAC;CACF;AAxBD,sDAwBC","sourcesContent":["import { StandardSchemaV1 } from '@standard-schema/spec'\nimport { ValidationContext, Validator } from './validator.js'\n\n/**\n * The Standard Schema adapter for {@link Validator} instances.\n */\nexport class StandardSchemaAdapter<TInput, TOutput>\n  implements StandardSchemaV1.Props<TInput, TOutput>\n{\n  readonly version = 1\n\n  readonly vendor = '@atproto/lex-schema'\n\n  declare readonly types: StandardSchemaV1.Types<TInput, TOutput>\n\n  constructor(private readonly validator: Validator<TInput, TOutput>) {}\n\n  validate(\n    value: unknown,\n    options?: StandardSchemaV1.Options,\n  ): StandardSchemaV1.Result<TOutput> {\n    // Perform validation in \"parse\" mode to ensure transformations (defaults,\n    // coercions, etc.) are applied. Also ensures that the output type is\n    // returned. Note that ValidationResult is compatible with\n    // StandardSchemaV1.Result :-)\n    return ValidationContext.validate(value, this.validator, {\n      ...options?.libraryOptions,\n      mode: 'parse',\n    })\n  }\n}\n"]}

package/dist/core/string-format.d.ts

@@ -1,19 +1,9 @@
 import { AtIdentifierString, AtUriString, DatetimeString, DidString, HandleString, NsidString, RecordKeyString, TidString, UriString } from '@atproto/syntax';
 import { CheckFn } from '../util/assertion-util.js';
-/**
- * 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
- */
-export declare const isAtIdentifierString: CheckFn<AtIdentifierString>;
-export type { 
-/**
- * An AT identifier string - either a DID or a handle.
- *
- * @example `"did:plc:1234..."` or `"alice.bsky.social"`
- */
-AtIdentifierString, };
+export { type AtIdentifierString, asAtIdentifierString, ifAtIdentifierString, isAtIdentifierString, } from '@atproto/syntax';
+export { isDidIdentifier, isHandleIdentifier } from '@atproto/syntax';
+export { type DatetimeString, asDatetimeString, ifDatetimeString, isDatetimeString, } from '@atproto/syntax';
+export { currentDatetimeString, toDatetimeString } from '@atproto/syntax';
 /**
  * Type guard that checks if a value is a valid AT URI.
  *
@@ -43,20 +33,6 @@ export declare const isCidString: CheckFn<CidString>;
  * @example `"bafyreig..."`
  */
 export type CidString = string;
-/**
- * Type guard that checks if a value is a valid datetime string.
- *
- * @param value - The value to check
- * @returns `true` if the value is a valid datetime string
- */
-export declare const isDatetimeString: CheckFn<DatetimeString>;
-export type { 
-/**
- * An ISO 8601 datetime string.
- *
- * @example `"2024-01-15T12:30:00.000Z"`
- */
-DatetimeString, };
 /**
  * Type guard that checks if a value is a valid DID string.
  *