@atproto/lex-schema 0.0.10 → 0.0.12

package/dist/core/validator.js

@@ -4,6 +4,34 @@ exports.ValidationContext = void 0;
 const result_js_1 = require("./result.js");
 const validation_error_js_1 = require("./validation-error.js");
 const validation_issue_js_1 = require("./validation-issue.js");
+/**
+ * Manages the state and context for validation operations.
+ *
+ * The `ValidationContext` class is responsible for:
+ * - Tracking the current path in nested structures for error reporting
+ * - Collecting validation issues during traversal
+ * - Enforcing validation mode (validate vs parse)
+ * - Providing factory methods for creating validation results
+ *
+ * Use the static {@link ValidationContext.validate} method as the primary entry point
+ * for validation. This ensures proper mode enforcement and issue aggregation.
+ *
+ * @example
+ * ```typescript
+ * // Primary usage via static method
+ * const result = ValidationContext.validate(data, schema, { mode: 'parse' })
+ *
+ * // Within a custom validator implementation
+ * class MyValidator implements Validator {
+ *   validateInContext(input: unknown, ctx: ValidationContext): ValidationResult {
+ *     if (typeof input !== 'string') {
+ *       return ctx.issueInvalidType(input, 'string')
+ *     }
+ *     return ctx.success(input)
+ *   }
+ * }
+ * ```
+ */
 class ValidationContext {
     options;
     static validate(input, validator, options) {
@@ -13,25 +41,55 @@ class ValidationContext {
         });
         return context.validate(input, validator);
     }
+    /**
+     * The current path being validated, used for error reporting.
+     */
     currentPath;
+    /**
+     * Accumulated validation issues collected during traversal.
+     */
     issues = [];
+    /**
+     * Creates a new validation context with the specified options.
+     *
+     * @param options - The validation options (path and mode are required)
+     */
     constructor(options) {
         this.options = options;
         // Create a copy because we will be mutating the array during validation.
         this.currentPath = Array.from(options.path);
     }
+    /**
+     * Returns a copy of the current validation path.
+     *
+     * The path represents the location in the data structure being validated,
+     * used for constructing meaningful error messages.
+     */
     get path() {
         return Array.from(this.currentPath);
     }
+    /**
+     * Creates a new path by appending segments to the current path.
+     *
+     * @param path - Optional path segment(s) to append
+     * @returns A new path array with the segment(s) appended
+     */
     concatPath(path) {
         if (path == null)
             return this.path;
         return this.currentPath.concat(path);
     }
     /**
-     * This is basically the entry point for validation within a context. Use this
-     * method instead of using {@link Validator.validateInContext} directly,
-     * because this method ensures the proper use of {@link ValidationOptions}.
+     * Validates input against a validator within this context.
+     *
+     * This is the primary entry point for validation within a context. Always use
+     * this method instead of calling {@link Validator.validateInContext} directly,
+     * as this method enforces validation mode rules and handles transformation detection.
+     *
+     * @typeParam V - The validator type
+     * @param input - The value to validate
+     * @param validator - The validator to use
+     * @returns A validation result with the validated value or error
      */
     validate(input, validator) {
         // This is the only place where validateInContext should be called.
@@ -59,6 +117,28 @@ class ValidationContext {
         }
         return result;
     }
+    /**
+     * Validates a child property of an object within this context.
+     *
+     * This method automatically manages the path stack, pushing the property key
+     * before validation and popping it afterward. Use this for validating object
+     * properties to ensure proper path tracking in error messages.
+     *
+     * @typeParam I - The input object type
+     * @typeParam K - The property key type
+     * @typeParam V - The validator type
+     * @param input - The parent object containing the property
+     * @param key - The property key to validate
+     * @param validator - The validator to use for the property value
+     * @returns A validation result for the property value
+     *
+     * @example
+     * ```typescript
+     * // In a custom object validator
+     * const result = ctx.validateChild(input, 'name', stringSchema)
+     * // If validation fails, error path will include 'name'
+     * ```
+     */
     validateChild(input, key, validator) {
         // Instead of creating a new context, we just push/pop the path segment.
         this.currentPath.push(key);
@@ -69,41 +149,142 @@ class ValidationContext {
             this.currentPath.length--;
         }
     }
+    /**
+     * Adds a validation issue to the context without immediately failing.
+     *
+     * Use this method to collect multiple issues during validation before
+     * determining the final result. Issues added this way will be included
+     * in the final error if validation fails.
+     *
+     * @param issue - The validation issue to add
+     */
     addIssue(issue) {
         this.issues.push(issue);
     }
+    /**
+     * Creates a successful validation result with the given value.
+     *
+     * @typeParam V - The value type
+     * @param value - The validated value
+     * @returns A successful validation result
+     */
     success(value) {
         return (0, result_js_1.success)(value);
     }
+    /**
+     * Creates a failed validation result with the given error.
+     *
+     * @param reason - The validation error
+     * @returns A failed validation result
+     */
     failure(reason) {
         return (0, result_js_1.failure)(reason);
     }
+    /**
+     * Creates a failed validation result from a single issue.
+     *
+     * Any previously accumulated issues in the context are included in the error.
+     *
+     * @param issue - The validation issue that caused the failure
+     * @returns A failed validation result
+     */
     issue(issue) {
         return this.failure(new validation_error_js_1.ValidationError([...this.issues, issue]));
     }
+    /**
+     * Creates a failure for an invalid value that doesn't match expected values.
+     *
+     * @param input - The actual value that was received
+     * @param values - The expected valid values
+     * @returns A failed validation result with an invalid value issue
+     */
     issueInvalidValue(input, values) {
         return this.issue(new validation_issue_js_1.IssueInvalidValue(this.path, input, values));
     }
+    /**
+     * Creates a failure for an invalid type.
+     *
+     * @param input - The actual value that was received
+     * @param expected - The expected type name
+     * @returns A failed validation result with an invalid type issue
+     */
     issueInvalidType(input, expected) {
         return this.issue(new validation_issue_js_1.IssueInvalidType(this.path, input, [expected]));
     }
+    /**
+     * Creates a failure for a missing required key in an object.
+     *
+     * @param input - The object missing the required key
+     * @param key - The name of the required key
+     * @returns A failed validation result with a required key issue
+     */
     issueRequiredKey(input, key) {
         return this.issue(new validation_issue_js_1.IssueRequiredKey(this.path, input, key));
     }
+    /**
+     * Creates a failure for an invalid string format.
+     *
+     * @param input - The actual value that was received
+     * @param format - The expected format name (e.g., 'did', 'handle', 'uri')
+     * @param msg - Optional additional message describing the format error
+     * @returns A failed validation result with an invalid format issue
+     */
     issueInvalidFormat(input, format, msg) {
         return this.issue(new validation_issue_js_1.IssueInvalidFormat(this.path, input, format, msg));
     }
+    /**
+     * Creates a failure for a value that exceeds a maximum constraint.
+     *
+     * @param input - The actual value that was received
+     * @param type - The type of measurement (e.g., 'string', 'array', 'bytes')
+     * @param max - The maximum allowed value
+     * @param actual - The actual measured value
+     * @returns A failed validation result with a too big issue
+     */
     issueTooBig(input, type, max, actual) {
         return this.issue(new validation_issue_js_1.IssueTooBig(this.path, input, max, type, actual));
     }
+    /**
+     * Creates a failure for a value that is below a minimum constraint.
+     *
+     * @param input - The actual value that was received
+     * @param type - The type of measurement (e.g., 'string', 'array', 'bytes')
+     * @param min - The minimum required value
+     * @param actual - The actual measured value
+     * @returns A failed validation result with a too small issue
+     */
     issueTooSmall(input, type, min, actual) {
         return this.issue(new validation_issue_js_1.IssueTooSmall(this.path, input, min, type, actual));
     }
+    /**
+     * Creates a failure for an invalid property value within an object.
+     *
+     * This is a convenience method that automatically extracts the property value
+     * and constructs the appropriate path.
+     *
+     * @typeParam I - The input object type
+     * @param input - The object containing the invalid property
+     * @param property - The property key with the invalid value
+     * @param values - The expected valid values
+     * @returns A failed validation result with an invalid value issue at the property path
+     */
     issueInvalidPropertyValue(input, property, values) {
         const value = input[property];
         const path = this.concatPath(property);
         return this.issue(new validation_issue_js_1.IssueInvalidValue(path, value, values));
     }
+    /**
+     * Creates a failure for an invalid property type within an object.
+     *
+     * This is a convenience method that automatically extracts the property value
+     * and constructs the appropriate path.
+     *
+     * @typeParam I - The input object type
+     * @param input - The object containing the invalid property
+     * @param property - The property key with the invalid type
+     * @param expected - The expected type name
+     * @returns A failed validation result with an invalid type issue at the property path
+     */
     issueInvalidPropertyType(input, property, expected) {
         const value = input[property];
         const path = this.concatPath(property);

package/dist/core/validator.js.map

@@ -1 +1 @@
-{"version":3,"file":"validator.js","sourceRoot":"","sources":["../../src/core/validator.ts"],"names":[],"mappings":"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","sourcesContent":["import { PropertyKey } from './property-key.js'\nimport { ResultFailure, ResultSuccess, failure, success } from './result.js'\nimport { ValidationError } from './validation-error.js'\nimport {\n  Issue,\n  IssueInvalidFormat,\n  IssueInvalidType,\n  IssueInvalidValue,\n  IssueRequiredKey,\n  IssueTooBig,\n  IssueTooSmall,\n  MeasurableType,\n} from './validation-issue.js'\n\nexport type ValidationSuccess<Value = unknown> = ResultSuccess<Value>\nexport type ValidationFailure = ResultFailure<ValidationError>\nexport type ValidationResult<Value = unknown> =\n  | ValidationSuccess<Value>\n  | ValidationFailure\n\nexport type InferInput<V extends Validator> = V['__lex']['input']\nexport type InferOutput<V extends Validator> = V['__lex']['output']\n\nexport type { InferInput as Infer }\n\nexport interface Validator<TInput = unknown, TOutput = TInput> {\n  /**\n   * This property is used for type inference purposes and does not actually\n   * exist at runtime.\n   *\n   * @deprecated **INTERNAL API, DO NOT USE**.\n   */\n  readonly ['__lex']: {\n    /** @internal The inferred validation type */\n    input: TInput\n    /** @internal The inferred parse type */\n    output: TOutput\n  }\n\n  /**\n   * @internal **INTERNAL API**: use {@link ValidationContext.validate} instead\n   *\n   * This method is implemented by subclasses to perform transformation and\n   * validation of the input value. Do not call this method directly; as the\n   * {@link ValidationContext.options.mode} option will **not** be enforced. See\n   * {@link ValidationContext.validate} for details. When delegating validation\n   * from one validator sub-class implementation to another schema,\n   * {@link ValidationContext.validate} must be used instead of calling\n   * {@link Validator.validateInContext}. This will allow to stop the validation\n   * process if the value was transformed (by the other schema) but\n   * transformations are not allowed.\n   *\n   * By convention, the {@link ValidationResult} must return the original input\n   * value if validation was successful and no transformation was applied (i.e.\n   * the input already conformed to the schema). If a default value, or any\n   * other transformation was applied, the returned value can be different from\n   * the input.\n   *\n   * This convention allows the {@link Validator.check check} and\n   * {@link Validator.assert assert} methods to check whether the input value\n   * exactly matches the schema (without defaults or transformations), by\n   * checking if the returned value is strictly equal to the input.\n   *\n   * @see {@link ValidationContext.validate}\n   */\n  validateInContext(input: unknown, ctx: ValidationContext): ValidationResult\n}\n\nexport type ValidationOptions = {\n  /**\n   * When set to `\"validate\"` (default), the result of validation must be\n   * strictly equal to the input value (i.e. no transformation, such as applying\n   * default values, is allowed).\n   */\n  mode?: 'validate' | 'parse'\n\n  /**\n   * The path to the value being validated. This is used to provide more\n   * context in validation issues.\n   */\n  path?: readonly PropertyKey[]\n}\n\nexport class ValidationContext {\n  static validate<V extends Validator>(\n    input: unknown,\n    validator: V,\n    options: ValidationOptions & {\n      mode: 'parse'\n    },\n  ): ValidationResult<InferOutput<V>>\n  static validate<V extends Validator, I = unknown>(\n    input: I,\n    validator: V,\n    options?: ValidationOptions & {\n      mode?: 'validate'\n    },\n  ): ValidationResult<I & InferInput<V>>\n  static validate<V extends Validator>(\n    input: unknown,\n    validator: V,\n    options?: ValidationOptions,\n  ): ValidationResult<InferOutput<V> | InferInput<V>>\n  static validate<V extends Validator>(\n    input: unknown,\n    validator: V,\n    options?: ValidationOptions,\n  ): ValidationResult<InferOutput<V> | InferInput<V>> {\n    const context = new ValidationContext({\n      path: options?.path ?? [],\n      mode: options?.mode ?? 'validate',\n    })\n    return context.validate(input, validator)\n  }\n\n  protected readonly currentPath: PropertyKey[]\n  protected readonly issues: Issue[] = []\n\n  constructor(readonly options: Required<ValidationOptions>) {\n    // Create a copy because we will be mutating the array during validation.\n    this.currentPath = Array.from(options.path)\n  }\n\n  get path() {\n    return Array.from(this.currentPath)\n  }\n\n  concatPath(path?: PropertyKey | readonly PropertyKey[]) {\n    if (path == null) return this.path\n    return this.currentPath.concat(path)\n  }\n\n  /**\n   * This is basically the entry point for validation within a context. Use this\n   * method instead of using {@link Validator.validateInContext} directly,\n   * because this method ensures the proper use of {@link ValidationOptions}.\n   */\n  validate<V extends Validator>(\n    input: unknown,\n    validator: V,\n  ): ValidationResult<InferInput<V>> {\n    // This is the only place where validateInContext should be called.\n    const result = validator.validateInContext(input, this)\n\n    if (result.success) {\n      if (this.issues.length > 0) {\n        // Validator returned a success but issues were added via the context.\n        // This means the overall validation failed.\n        return failure(new ValidationError(Array.from(this.issues)))\n      }\n\n      if (this.options.mode !== 'parse' && !Object.is(result.value, input)) {\n        // If the value changed, it means that a default (or some other\n        // transformation) was applied, meaning that the original value did\n        // *not* match the (output) schema. When not in \"parse\" mode, we\n        // consider this a failure.\n\n        // This check is the reason why Validator.validateInContext should not\n        // be used directly, and ValidatorContext.validate should be used\n        // instead, even when delegating validation from one validator to\n        // another.\n\n        // This if block comes before the next one because 'this.issues' will\n        // end-up being appended to the returned ValidationError (see the\n        // \"failure\" method below), resulting in a more complete error report.\n        return this.issueInvalidValue(input, [result.value])\n      }\n    }\n\n    return result as ValidationResult<InferInput<V>>\n  }\n\n  validateChild<\n    I extends object,\n    K extends PropertyKey & keyof I,\n    V extends Validator,\n  >(input: I, key: K, validator: V): ValidationResult<InferInput<V>> {\n    // Instead of creating a new context, we just push/pop the path segment.\n    this.currentPath.push(key)\n    try {\n      return this.validate(input[key], validator)\n    } finally {\n      this.currentPath.length--\n    }\n  }\n\n  addIssue(issue: Issue): void {\n    this.issues.push(issue)\n  }\n\n  success<V>(value: V): ValidationResult<V> {\n    return success(value)\n  }\n\n  failure(reason: ValidationError): ValidationFailure {\n    return failure(reason)\n  }\n\n  issue(issue: Issue) {\n    return this.failure(new ValidationError([...this.issues, issue]))\n  }\n\n  issueInvalidValue(input: unknown, values: readonly unknown[]) {\n    return this.issue(new IssueInvalidValue(this.path, input, values))\n  }\n\n  issueInvalidType(input: unknown, expected: string) {\n    return this.issue(new IssueInvalidType(this.path, input, [expected]))\n  }\n\n  issueRequiredKey(input: object, key: PropertyKey) {\n    return this.issue(new IssueRequiredKey(this.path, input, key))\n  }\n\n  issueInvalidFormat(input: unknown, format: string, msg?: string) {\n    return this.issue(new IssueInvalidFormat(this.path, input, format, msg))\n  }\n\n  issueTooBig(\n    input: unknown,\n    type: MeasurableType,\n    max: number,\n    actual: number,\n  ) {\n    return this.issue(new IssueTooBig(this.path, input, max, type, actual))\n  }\n\n  issueTooSmall(\n    input: unknown,\n    type: MeasurableType,\n    min: number,\n    actual: number,\n  ) {\n    return this.issue(new IssueTooSmall(this.path, input, min, type, actual))\n  }\n\n  issueInvalidPropertyValue<I>(\n    input: I,\n    property: keyof I & PropertyKey,\n    values: readonly unknown[],\n  ) {\n    const value = input[property]\n    const path = this.concatPath(property)\n    return this.issue(new IssueInvalidValue(path, value, values))\n  }\n\n  issueInvalidPropertyType<I>(\n    input: I,\n    property: keyof I & PropertyKey,\n    expected: string,\n  ) {\n    const value = input[property]\n    const path = this.concatPath(property)\n    return this.issue(new IssueInvalidType(path, value, [expected]))\n  }\n}\n\nexport type UnwrapValidator<T extends Validator> = T extends {\n  unwrap(): infer U extends Validator\n}\n  ? UnwrapValidator<U>\n  : T\n\nexport interface WrappedValidator<out Validator> {\n  unwrap(): Validator\n}\n"]}
+{"version":3,"file":"validator.js","sourceRoot":"","sources":["../../src/core/validator.ts"],"names":[],"mappings":"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","sourcesContent":["import { PropertyKey } from './property-key.js'\nimport { ResultFailure, ResultSuccess, failure, success } from './result.js'\nimport { ValidationError } from './validation-error.js'\nimport {\n  Issue,\n  IssueInvalidFormat,\n  IssueInvalidType,\n  IssueInvalidValue,\n  IssueRequiredKey,\n  IssueTooBig,\n  IssueTooSmall,\n  MeasurableType,\n} from './validation-issue.js'\n\n/**\n * Represents a successful validation result.\n *\n * @typeParam Value - The type of the validated value\n */\nexport type ValidationSuccess<Value = unknown> = ResultSuccess<Value>\n\n/**\n * Represents a failed validation result containing a {@link ValidationError}.\n */\nexport type ValidationFailure = ResultFailure<ValidationError>\n\n/**\n * Discriminated union representing the outcome of a validation operation.\n *\n * Check the `success` property to determine if validation passed or failed:\n * - If `success` is `true`, the `value` property contains the validated data\n * - If `success` is `false`, the `reason` property contains the {@link ValidationError}\n *\n * @typeParam Value - The type of the validated value on success\n *\n * @example\n * ```typescript\n * const result: ValidationResult<string> = schema.safeParse(data)\n * if (result.success) {\n *   // result.value is string\n * } else {\n *   // result.reason is ValidationError\n * }\n * ```\n */\nexport type ValidationResult<Value = unknown> =\n  | ValidationSuccess<Value>\n  | ValidationFailure\n\n/**\n * Extracts the input type that a validator accepts.\n *\n * Use this utility type to infer what type a schema will accept during validation.\n *\n * @typeParam V - A validator type\n *\n * @example\n * ```typescript\n * const userSchema = new ObjectSchema({ name: stringSchema, age: numberSchema })\n * type UserInput = InferInput<typeof userSchema>\n * // { name: string; age: number }\n * ```\n */\nexport type InferInput<V extends Validator> = V['__lex']['input']\n\n/**\n * Extracts the output type that a validator produces after parsing.\n *\n * The output type may differ from the input type when the schema applies\n * transformations such as default values or type coercion during parsing.\n *\n * @typeParam V - A validator type\n *\n * @example\n * ```typescript\n * const schema = new StringSchema().default('hello')\n * type Input = InferInput<typeof schema>   // string | undefined\n * type Output = InferOutput<typeof schema> // string\n * ```\n */\nexport type InferOutput<V extends Validator> = V['__lex']['output']\n\n/**\n * Alias for {@link InferInput} for convenient type inference.\n *\n * @typeParam V - A validator type\n */\nexport type { InferInput as Infer }\n\nexport interface Validator<TInput = unknown, TOutput = TInput> {\n  /**\n   * This property is used for type inference purposes and does not actually\n   * exist at runtime.\n   *\n   * @internal\n   * @deprecated **INTERNAL API, DO NOT USE**.\n   */\n  readonly ['__lex']: {\n    input: TInput\n    output: TOutput\n  }\n\n  /**\n   * @internal **INTERNAL API**: use {@link ValidationContext.validate} instead\n   *\n   * This method is implemented by subclasses to perform transformation and\n   * validation of the input value. Do not call this method directly; as the\n   * {@link ValidationContext.options.mode} option will **not** be enforced. See\n   * {@link ValidationContext.validate} for details. When delegating validation\n   * from one validator sub-class implementation to another schema,\n   * {@link ValidationContext.validate} must be used instead of calling\n   * {@link Validator.validateInContext}. This will allow to stop the validation\n   * process if the value was transformed (by the other schema) but\n   * transformations are not allowed.\n   *\n   * By convention, the {@link ValidationResult} must return the original input\n   * value if validation was successful and no transformation was applied (i.e.\n   * the input already conformed to the schema). If a default value, or any\n   * other transformation was applied, the returned value can be different from\n   * the input.\n   *\n   * This convention allows the {@link Validator.check check} and\n   * {@link Validator.assert assert} methods to check whether the input value\n   * exactly matches the schema (without defaults or transformations), by\n   * checking if the returned value is strictly equal to the input.\n   *\n   * @see {@link ValidationContext.validate}\n   */\n  validateInContext(input: unknown, ctx: ValidationContext): ValidationResult\n}\n\n/**\n * Configuration options for validation and parsing operations.\n *\n * @example\n * ```typescript\n * // Validate mode (strict, no transformations)\n * ValidationContext.validate(data, schema, { mode: 'validate' })\n *\n * // Parse mode (allows transformations like defaults)\n * ValidationContext.validate(data, schema, { mode: 'parse' })\n *\n * // With initial path for nested validation\n * ValidationContext.validate(data, schema, { path: ['user', 'profile'] })\n * ```\n */\nexport type ValidationOptions = {\n  /**\n   * The validation mode determining how transformations are handled.\n   *\n   * - `\"validate\"` (default): Strict validation where the result must be\n   *   strictly equal to the input value. No transformations such as applying\n   *   default values are allowed.\n   * - `\"parse\"`: Allows the schema to transform the input value, such as\n   *   applying default values or performing type coercion.\n   */\n  mode?: 'validate' | 'parse'\n\n  /**\n   * The initial path to the value being validated.\n   *\n   * This is used to provide context in validation issues when validating\n   * nested structures. The path is prepended to all issue paths.\n   *\n   * @example\n   * ```typescript\n   * // Issues will be reported at paths like \"user.name\" instead of just \"name\"\n   * ValidationContext.validate(data, schema, { path: ['user'] })\n   * ```\n   */\n  path?: readonly PropertyKey[]\n}\n\n/**\n * Manages the state and context for validation operations.\n *\n * The `ValidationContext` class is responsible for:\n * - Tracking the current path in nested structures for error reporting\n * - Collecting validation issues during traversal\n * - Enforcing validation mode (validate vs parse)\n * - Providing factory methods for creating validation results\n *\n * Use the static {@link ValidationContext.validate} method as the primary entry point\n * for validation. This ensures proper mode enforcement and issue aggregation.\n *\n * @example\n * ```typescript\n * // Primary usage via static method\n * const result = ValidationContext.validate(data, schema, { mode: 'parse' })\n *\n * // Within a custom validator implementation\n * class MyValidator implements Validator {\n *   validateInContext(input: unknown, ctx: ValidationContext): ValidationResult {\n *     if (typeof input !== 'string') {\n *       return ctx.issueInvalidType(input, 'string')\n *     }\n *     return ctx.success(input)\n *   }\n * }\n * ```\n */\nexport class ValidationContext {\n  /**\n   * Validates input against a validator in parse mode.\n   *\n   * In parse mode, the schema may transform the input (e.g., apply defaults).\n   *\n   * @param input - The value to validate\n   * @param validator - The validator to use\n   * @param options - Validation options with mode set to 'parse'\n   * @returns A validation result with the parsed output type\n   */\n  static validate<V extends Validator>(\n    input: unknown,\n    validator: V,\n    options: ValidationOptions & {\n      mode: 'parse'\n    },\n  ): ValidationResult<InferOutput<V>>\n  /**\n   * Validates input against a validator in validate mode (default).\n   *\n   * In validate mode, the result must be strictly equal to the input.\n   * No transformations are allowed.\n   *\n   * @typeParam V - The validator type\n   * @typeParam I - The input type\n   * @param input - The value to validate\n   * @param validator - The validator to use\n   * @param options - Optional validation options (defaults to validate mode)\n   * @returns A validation result preserving the input type intersected with the schema type\n   */\n  static validate<V extends Validator, I = unknown>(\n    input: I,\n    validator: V,\n    options?: ValidationOptions & {\n      mode?: 'validate'\n    },\n  ): ValidationResult<I & InferInput<V>>\n  /**\n   * Validates input against a validator with configurable options.\n   *\n   * @param input - The value to validate\n   * @param validator - The validator to use\n   * @param options - Optional validation options\n   * @returns A validation result with either the input or output type\n   */\n  static validate<V extends Validator>(\n    input: unknown,\n    validator: V,\n    options?: ValidationOptions,\n  ): ValidationResult<InferOutput<V> | InferInput<V>>\n  static validate<V extends Validator>(\n    input: unknown,\n    validator: V,\n    options?: ValidationOptions,\n  ): ValidationResult<InferOutput<V> | InferInput<V>> {\n    const context = new ValidationContext({\n      path: options?.path ?? [],\n      mode: options?.mode ?? 'validate',\n    })\n    return context.validate(input, validator)\n  }\n\n  /**\n   * The current path being validated, used for error reporting.\n   */\n  protected readonly currentPath: PropertyKey[]\n\n  /**\n   * Accumulated validation issues collected during traversal.\n   */\n  protected readonly issues: Issue[] = []\n\n  /**\n   * Creates a new validation context with the specified options.\n   *\n   * @param options - The validation options (path and mode are required)\n   */\n  constructor(readonly options: Required<ValidationOptions>) {\n    // Create a copy because we will be mutating the array during validation.\n    this.currentPath = Array.from(options.path)\n  }\n\n  /**\n   * Returns a copy of the current validation path.\n   *\n   * The path represents the location in the data structure being validated,\n   * used for constructing meaningful error messages.\n   */\n  get path() {\n    return Array.from(this.currentPath)\n  }\n\n  /**\n   * Creates a new path by appending segments to the current path.\n   *\n   * @param path - Optional path segment(s) to append\n   * @returns A new path array with the segment(s) appended\n   */\n  concatPath(path?: PropertyKey | readonly PropertyKey[]) {\n    if (path == null) return this.path\n    return this.currentPath.concat(path)\n  }\n\n  /**\n   * Validates input against a validator within this context.\n   *\n   * This is the primary entry point for validation within a context. Always use\n   * this method instead of calling {@link Validator.validateInContext} directly,\n   * as this method enforces validation mode rules and handles transformation detection.\n   *\n   * @typeParam V - The validator type\n   * @param input - The value to validate\n   * @param validator - The validator to use\n   * @returns A validation result with the validated value or error\n   */\n  validate<V extends Validator>(\n    input: unknown,\n    validator: V,\n  ): ValidationResult<InferInput<V>> {\n    // This is the only place where validateInContext should be called.\n    const result = validator.validateInContext(input, this)\n\n    if (result.success) {\n      if (this.issues.length > 0) {\n        // Validator returned a success but issues were added via the context.\n        // This means the overall validation failed.\n        return failure(new ValidationError(Array.from(this.issues)))\n      }\n\n      if (this.options.mode !== 'parse' && !Object.is(result.value, input)) {\n        // If the value changed, it means that a default (or some other\n        // transformation) was applied, meaning that the original value did\n        // *not* match the (output) schema. When not in \"parse\" mode, we\n        // consider this a failure.\n\n        // This check is the reason why Validator.validateInContext should not\n        // be used directly, and ValidatorContext.validate should be used\n        // instead, even when delegating validation from one validator to\n        // another.\n\n        // This if block comes before the next one because 'this.issues' will\n        // end-up being appended to the returned ValidationError (see the\n        // \"failure\" method below), resulting in a more complete error report.\n        return this.issueInvalidValue(input, [result.value])\n      }\n    }\n\n    return result as ValidationResult<InferInput<V>>\n  }\n\n  /**\n   * Validates a child property of an object within this context.\n   *\n   * This method automatically manages the path stack, pushing the property key\n   * before validation and popping it afterward. Use this for validating object\n   * properties to ensure proper path tracking in error messages.\n   *\n   * @typeParam I - The input object type\n   * @typeParam K - The property key type\n   * @typeParam V - The validator type\n   * @param input - The parent object containing the property\n   * @param key - The property key to validate\n   * @param validator - The validator to use for the property value\n   * @returns A validation result for the property value\n   *\n   * @example\n   * ```typescript\n   * // In a custom object validator\n   * const result = ctx.validateChild(input, 'name', stringSchema)\n   * // If validation fails, error path will include 'name'\n   * ```\n   */\n  validateChild<\n    I extends object,\n    K extends PropertyKey & keyof I,\n    V extends Validator,\n  >(input: I, key: K, validator: V): ValidationResult<InferInput<V>> {\n    // Instead of creating a new context, we just push/pop the path segment.\n    this.currentPath.push(key)\n    try {\n      return this.validate(input[key], validator)\n    } finally {\n      this.currentPath.length--\n    }\n  }\n\n  /**\n   * Adds a validation issue to the context without immediately failing.\n   *\n   * Use this method to collect multiple issues during validation before\n   * determining the final result. Issues added this way will be included\n   * in the final error if validation fails.\n   *\n   * @param issue - The validation issue to add\n   */\n  addIssue(issue: Issue): void {\n    this.issues.push(issue)\n  }\n\n  /**\n   * Creates a successful validation result with the given value.\n   *\n   * @typeParam V - The value type\n   * @param value - The validated value\n   * @returns A successful validation result\n   */\n  success<V>(value: V): ValidationResult<V> {\n    return success(value)\n  }\n\n  /**\n   * Creates a failed validation result with the given error.\n   *\n   * @param reason - The validation error\n   * @returns A failed validation result\n   */\n  failure(reason: ValidationError): ValidationFailure {\n    return failure(reason)\n  }\n\n  /**\n   * Creates a failed validation result from a single issue.\n   *\n   * Any previously accumulated issues in the context are included in the error.\n   *\n   * @param issue - The validation issue that caused the failure\n   * @returns A failed validation result\n   */\n  issue(issue: Issue) {\n    return this.failure(new ValidationError([...this.issues, issue]))\n  }\n\n  /**\n   * Creates a failure for an invalid value that doesn't match expected values.\n   *\n   * @param input - The actual value that was received\n   * @param values - The expected valid values\n   * @returns A failed validation result with an invalid value issue\n   */\n  issueInvalidValue(input: unknown, values: readonly unknown[]) {\n    return this.issue(new IssueInvalidValue(this.path, input, values))\n  }\n\n  /**\n   * Creates a failure for an invalid type.\n   *\n   * @param input - The actual value that was received\n   * @param expected - The expected type name\n   * @returns A failed validation result with an invalid type issue\n   */\n  issueInvalidType(input: unknown, expected: string) {\n    return this.issue(new IssueInvalidType(this.path, input, [expected]))\n  }\n\n  /**\n   * Creates a failure for a missing required key in an object.\n   *\n   * @param input - The object missing the required key\n   * @param key - The name of the required key\n   * @returns A failed validation result with a required key issue\n   */\n  issueRequiredKey(input: object, key: PropertyKey) {\n    return this.issue(new IssueRequiredKey(this.path, input, key))\n  }\n\n  /**\n   * Creates a failure for an invalid string format.\n   *\n   * @param input - The actual value that was received\n   * @param format - The expected format name (e.g., 'did', 'handle', 'uri')\n   * @param msg - Optional additional message describing the format error\n   * @returns A failed validation result with an invalid format issue\n   */\n  issueInvalidFormat(input: unknown, format: string, msg?: string) {\n    return this.issue(new IssueInvalidFormat(this.path, input, format, msg))\n  }\n\n  /**\n   * Creates a failure for a value that exceeds a maximum constraint.\n   *\n   * @param input - The actual value that was received\n   * @param type - The type of measurement (e.g., 'string', 'array', 'bytes')\n   * @param max - The maximum allowed value\n   * @param actual - The actual measured value\n   * @returns A failed validation result with a too big issue\n   */\n  issueTooBig(\n    input: unknown,\n    type: MeasurableType,\n    max: number,\n    actual: number,\n  ) {\n    return this.issue(new IssueTooBig(this.path, input, max, type, actual))\n  }\n\n  /**\n   * Creates a failure for a value that is below a minimum constraint.\n   *\n   * @param input - The actual value that was received\n   * @param type - The type of measurement (e.g., 'string', 'array', 'bytes')\n   * @param min - The minimum required value\n   * @param actual - The actual measured value\n   * @returns A failed validation result with a too small issue\n   */\n  issueTooSmall(\n    input: unknown,\n    type: MeasurableType,\n    min: number,\n    actual: number,\n  ) {\n    return this.issue(new IssueTooSmall(this.path, input, min, type, actual))\n  }\n\n  /**\n   * Creates a failure for an invalid property value within an object.\n   *\n   * This is a convenience method that automatically extracts the property value\n   * and constructs the appropriate path.\n   *\n   * @typeParam I - The input object type\n   * @param input - The object containing the invalid property\n   * @param property - The property key with the invalid value\n   * @param values - The expected valid values\n   * @returns A failed validation result with an invalid value issue at the property path\n   */\n  issueInvalidPropertyValue<I>(\n    input: I,\n    property: keyof I & PropertyKey,\n    values: readonly unknown[],\n  ) {\n    const value = input[property]\n    const path = this.concatPath(property)\n    return this.issue(new IssueInvalidValue(path, value, values))\n  }\n\n  /**\n   * Creates a failure for an invalid property type within an object.\n   *\n   * This is a convenience method that automatically extracts the property value\n   * and constructs the appropriate path.\n   *\n   * @typeParam I - The input object type\n   * @param input - The object containing the invalid property\n   * @param property - The property key with the invalid type\n   * @param expected - The expected type name\n   * @returns A failed validation result with an invalid type issue at the property path\n   */\n  issueInvalidPropertyType<I>(\n    input: I,\n    property: keyof I & PropertyKey,\n    expected: string,\n  ) {\n    const value = input[property]\n    const path = this.concatPath(property)\n    return this.issue(new IssueInvalidType(path, value, [expected]))\n  }\n}\n\n/**\n * Recursively unwraps a wrapped validator to its innermost validator type.\n *\n * Some validators wrap other validators (e.g., optional, nullable). This type\n * utility recursively unwraps such wrappers to reveal the core validator.\n *\n * @typeParam T - A validator type, possibly wrapped\n *\n * @example\n * ```typescript\n * type Inner = UnwrapValidator<OptionalValidator<NullableValidator<StringSchema>>>\n * // Result: StringSchema\n * ```\n */\nexport type UnwrapValidator<T extends Validator> = T extends {\n  unwrap(): infer U extends Validator\n}\n  ? UnwrapValidator<U>\n  : T\n\n/**\n * Interface for validators that wrap another validator.\n *\n * Implement this interface when creating validators that wrap or modify\n * the behavior of another validator (e.g., optional, nullable, transform).\n *\n * @typeParam Validator - The type of the wrapped validator\n *\n * @example\n * ```typescript\n * class OptionalSchema<V extends Validator> implements WrappedValidator<V> {\n *   constructor(private inner: V) {}\n *\n *   unwrap(): V {\n *     return this.inner\n *   }\n * }\n * ```\n */\nexport interface WrappedValidator<out Validator> {\n  /**\n   * Returns the inner wrapped validator.\n   *\n   * @returns The wrapped validator\n   */\n  unwrap(): Validator\n}\n"]}

package/dist/helpers.d.ts

@@ -1,6 +1,5 @@
-import { LexValue } from '@atproto/lex-data';
-import { InferOutput, Restricted, Schema } from './core.js';
-import { InferPayload, InferPayloadBody, InferPayloadEncoding, Payload, Procedure, Query, Subscription } from './schema.js';
+import { InferOutput, Restricted } from './core.js';
+import { InferPayload, InferPayloadBody, InferPayloadEncoding, Procedure, Query, Subscription } from './schema.js';
 export type Main<T> = T | {
     main: T;
 };
@@ -15,28 +14,17 @@ export declare function getMain<T extends object>(ns: Main<T>): T;
  */
 type BinaryData = Restricted<'Binary data'>;
 export type InferMethodParams<M extends Procedure | Query | Subscription> = InferOutput<M['parameters']>;
-export type InferMethodInput<M extends Procedure | Query | Subscription, B = BinaryData> = M extends {
-    input: Payload;
-} ? InferPayload<M['input'], B> : undefined;
-export type InferMethodInputBody<M extends Procedure | Query | Subscription, B = BinaryData> = M extends {
-    input: Payload;
-} ? InferPayloadBody<M['input'], B> : undefined;
-export type InferMethodInputEncoding<M extends Procedure | Query | Subscription> = M extends {
-    input: Payload;
-} ? InferPayloadEncoding<M['input']> : undefined;
-export type InferMethodOutput<M extends Procedure | Query | Subscription, B = BinaryData> = M extends {
-    output: Payload;
-} ? InferPayload<M['output'], B> : undefined;
-export type InferMethodOutputBody<M extends Procedure | Query | Subscription, B = BinaryData> = M extends {
-    output: Payload;
-} ? InferPayloadBody<M['output'], B> : undefined;
-export type InferMethodOutputEncoding<M extends Procedure | Query | Subscription> = M extends {
-    output: Payload;
-} ? InferPayloadEncoding<M['output']> : undefined;
-export type InferMethodMessage<M extends Procedure | Query | Subscription> = M extends {
-    message: Schema;
-} ? LexValue & InferOutput<M['message']> : undefined;
-export declare const lexErrorData: import("./schema.js").ObjectSchema<{
+export type InferMethodInput<M extends Procedure | Query | Subscription, B = BinaryData> = M extends Procedure ? InferPayload<M['input'], B> : undefined;
+export type InferMethodInputBody<M extends Procedure | Query | Subscription, B = BinaryData> = M extends Procedure ? InferPayloadBody<M['input'], B> : undefined;
+export type InferMethodInputEncoding<M extends Procedure | Query | Subscription> = M extends Procedure ? InferPayloadEncoding<M['input']> : undefined;
+export type InferMethodOutput<M extends Procedure | Query | Subscription, B = BinaryData> = M extends Procedure | Query ? InferPayload<M['output'], B> : undefined;
+export type InferMethodOutputBody<M extends Procedure | Query | Subscription, B = BinaryData> = M extends Procedure | Query ? InferPayloadBody<M['output'], B> : undefined;
+export type InferMethodOutputEncoding<M extends Procedure | Query | Subscription> = M extends Procedure | Query ? InferPayloadEncoding<M['output']> : undefined;
+export type InferMethodMessage<M extends Subscription> = M extends Subscription ? InferOutput<M['message']> : undefined;
+export type InferMethodError<M extends Procedure | Query | Subscription> = M extends {
+    errors: readonly (infer E extends string)[];
+} ? E : never;
+export declare const lexErrorDataSchema: import("./schema.js").ObjectSchema<{
     readonly error: import("./schema.js").StringSchema<{
         readonly minLength: 1;
     }>;

package/dist/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAC1D,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAC3D,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,oBAAoB,EACpB,OAAO,EACP,SAAS,EACT,KAAK,EACL,YAAY,EAIb,MAAM,aAAa,CAAA;AAEpB,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,CAAA;AAErC,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAExD;AAED;;;;;;;GAOG;AACH,KAAK,UAAU,GAAG,UAAU,CAAC,aAAa,CAAC,CAAA;AAE3C,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,YAAY,IACtE,WAAW,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAA;AAE9B,MAAM,MAAM,gBAAgB,CAC1B,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,YAAY,EAC1C,CAAC,GAAG,UAAU,IACZ,CAAC,SAAS;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAA;AAE1E,MAAM,MAAM,oBAAoB,CAC9B,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,YAAY,EAC1C,CAAC,GAAG,UAAU,IACZ,CAAC,SAAS;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,gBAAgB,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAA;AAE9E,MAAM,MAAM,wBAAwB,CAClC,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,YAAY,IACxC,CAAC,SAAS;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG,oBAAoB,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,SAAS,CAAA;AAE/E,MAAM,MAAM,iBAAiB,CAC3B,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,YAAY,EAC1C,CAAC,GAAG,UAAU,IACZ,CAAC,SAAS;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,GAAG,YAAY,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAA;AAE5E,MAAM,MAAM,qBAAqB,CAC/B,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,YAAY,EAC1C,CAAC,GAAG,UAAU,IACZ,CAAC,SAAS;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,GAAG,gBAAgB,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAA;AAEhF,MAAM,MAAM,yBAAyB,CACnC,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,YAAY,IACxC,CAAC,SAAS;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,GAC7B,oBAAoB,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,GACjC,SAAS,CAAA;AAEb,MAAM,MAAM,kBAAkB,CAE5B,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,YAAY,IACxC,CAAC,SAAS;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GAC7B,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,GACpC,SAAS,CAAA;AAEb,eAAO,MAAM,YAAY;;;;;EAGQ,CAAA"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAU,MAAM,WAAW,CAAA;AAC3D,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,oBAAoB,EACpB,SAAS,EACT,KAAK,EACL,YAAY,EAIb,MAAM,aAAa,CAAA;AAEpB,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,CAAA;AAErC,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAExD;AAED;;;;;;;GAOG;AACH,KAAK,UAAU,GAAG,UAAU,CAAC,aAAa,CAAC,CAAA;AAE3C,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,YAAY,IACtE,WAAW,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAA;AAE9B,MAAM,MAAM,gBAAgB,CAC1B,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,YAAY,EAC1C,CAAC,GAAG,UAAU,IACZ,CAAC,SAAS,SAAS,GAAG,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAA;AAEjE,MAAM,MAAM,oBAAoB,CAC9B,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,YAAY,EAC1C,CAAC,GAAG,UAAU,IACZ,CAAC,SAAS,SAAS,GAAG,gBAAgB,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAA;AAErE,MAAM,MAAM,wBAAwB,CAClC,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,YAAY,IACxC,CAAC,SAAS,SAAS,GAAG,oBAAoB,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,SAAS,CAAA;AAEtE,MAAM,MAAM,iBAAiB,CAC3B,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,YAAY,EAC1C,CAAC,GAAG,UAAU,IACZ,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,YAAY,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAA;AAE1E,MAAM,MAAM,qBAAqB,CAC/B,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,YAAY,EAC1C,CAAC,GAAG,UAAU,IACZ,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,gBAAgB,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,CAAA;AAE9E,MAAM,MAAM,yBAAyB,CACnC,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,YAAY,IACxC,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,oBAAoB,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,CAAA;AAE/E,MAAM,MAAM,kBAAkB,CAE5B,CAAC,SAAS,YAAY,IACpB,CAAC,SAAS,YAAY,GAAG,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,GAAG,SAAS,CAAA;AAElE,MAAM,MAAM,gBAAgB,CAE1B,CAAC,SAAS,SAAS,GAAG,KAAK,GAAG,YAAY,IACxC,CAAC,SAAS;IAAE,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,SAAS,MAAM,CAAC,EAAE,CAAA;CAAE,GAAG,CAAC,GAAG,KAAK,CAAA;AAEzE,eAAO,MAAM,kBAAkB;;;;;EAGE,CAAA"}

package/dist/helpers.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lexErrorData = void 0;
+exports.lexErrorDataSchema = void 0;
 exports.getMain = getMain;
 const schema_js_1 = require("./schema.js");
 function getMain(ns) {
     return 'main' in ns ? ns.main : ns;
 }
-exports.lexErrorData = (0, schema_js_1.object)({
+exports.lexErrorDataSchema = (0, schema_js_1.object)({
     error: (0, schema_js_1.string)({ minLength: 1 }),
     message: (0, schema_js_1.optional)((0, schema_js_1.string)()),
 });

package/dist/helpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":";;;AAiBA,0BAEC;AAjBD,2CAWoB;AAIpB,SAAgB,OAAO,CAAmB,EAAW;IACnD,OAAO,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAA;AACpC,CAAC;AAoDY,QAAA,YAAY,GAAG,IAAA,kBAAM,EAAC;IACjC,KAAK,EAAE,IAAA,kBAAM,EAAC,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC;IAC/B,OAAO,EAAE,IAAA,oBAAQ,EAAC,IAAA,kBAAM,GAAE,CAAC;CAC5B,CAAgC,CAAA","sourcesContent":["import { LexErrorData, LexValue } from '@atproto/lex-data'\nimport { InferOutput, Restricted, Schema } from './core.js'\nimport {\n  InferPayload,\n  InferPayloadBody,\n  InferPayloadEncoding,\n  Payload,\n  Procedure,\n  Query,\n  Subscription,\n  object,\n  optional,\n  string,\n} from './schema.js'\n\nexport type Main<T> = T | { main: T }\n\nexport function getMain<T extends object>(ns: Main<T>): T {\n  return 'main' in ns ? ns.main : ns\n}\n\n/**\n * Every XRPC implementation should translate `application/json` and `text/*`\n * payloads into their native equivalent ({@link LexValue} or string). Binary\n * data payloads, however, can be represented differently depending on the\n * environment and use case (e.g. `Uint8Array`, `Blob`, `Buffer`,\n * `ReadableStream`, etc.). This type is a placeholder to represent binary data\n * when not explicitly provided.\n */\ntype BinaryData = Restricted<'Binary data'>\n\nexport type InferMethodParams<M extends Procedure | Query | Subscription> =\n  InferOutput<M['parameters']>\n\nexport type InferMethodInput<\n  M extends Procedure | Query | Subscription,\n  B = BinaryData,\n> = M extends { input: Payload } ? InferPayload<M['input'], B> : undefined\n\nexport type InferMethodInputBody<\n  M extends Procedure | Query | Subscription,\n  B = BinaryData,\n> = M extends { input: Payload } ? InferPayloadBody<M['input'], B> : undefined\n\nexport type InferMethodInputEncoding<\n  M extends Procedure | Query | Subscription,\n> = M extends { input: Payload } ? InferPayloadEncoding<M['input']> : undefined\n\nexport type InferMethodOutput<\n  M extends Procedure | Query | Subscription,\n  B = BinaryData,\n> = M extends { output: Payload } ? InferPayload<M['output'], B> : undefined\n\nexport type InferMethodOutputBody<\n  M extends Procedure | Query | Subscription,\n  B = BinaryData,\n> = M extends { output: Payload } ? InferPayloadBody<M['output'], B> : undefined\n\nexport type InferMethodOutputEncoding<\n  M extends Procedure | Query | Subscription,\n> = M extends { output: Payload }\n  ? InferPayloadEncoding<M['output']>\n  : undefined\n\nexport type InferMethodMessage<\n  //\n  M extends Procedure | Query | Subscription,\n> = M extends { message: Schema }\n  ? LexValue & InferOutput<M['message']>\n  : undefined\n\nexport const lexErrorData = object({\n  error: string({ minLength: 1 }),\n  message: optional(string()),\n}) satisfies Schema<LexErrorData>\n"]}
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":";;;AAgBA,0BAEC;AAhBD,2CAUoB;AAIpB,SAAgB,OAAO,CAAmB,EAAW;IACnD,OAAO,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAA;AACpC,CAAC;AAqDY,QAAA,kBAAkB,GAAG,IAAA,kBAAM,EAAC;IACvC,KAAK,EAAE,IAAA,kBAAM,EAAC,EAAE,SAAS,EAAE,CAAC,EAAE,CAAC;IAC/B,OAAO,EAAE,IAAA,oBAAQ,EAAC,IAAA,kBAAM,GAAE,CAAC;CAC5B,CAAgC,CAAA","sourcesContent":["import { LexErrorData } from '@atproto/lex-data'\nimport { InferOutput, Restricted, Schema } from './core.js'\nimport {\n  InferPayload,\n  InferPayloadBody,\n  InferPayloadEncoding,\n  Procedure,\n  Query,\n  Subscription,\n  object,\n  optional,\n  string,\n} from './schema.js'\n\nexport type Main<T> = T | { main: T }\n\nexport function getMain<T extends object>(ns: Main<T>): T {\n  return 'main' in ns ? ns.main : ns\n}\n\n/**\n * Every XRPC implementation should translate `application/json` and `text/*`\n * payloads into their native equivalent ({@link LexValue} or string). Binary\n * data payloads, however, can be represented differently depending on the\n * environment and use case (e.g. `Uint8Array`, `Blob`, `Buffer`,\n * `ReadableStream`, etc.). This type is a placeholder to represent binary data\n * when not explicitly provided.\n */\ntype BinaryData = Restricted<'Binary data'>\n\nexport type InferMethodParams<M extends Procedure | Query | Subscription> =\n  InferOutput<M['parameters']>\n\nexport type InferMethodInput<\n  M extends Procedure | Query | Subscription,\n  B = BinaryData,\n> = M extends Procedure ? InferPayload<M['input'], B> : undefined\n\nexport type InferMethodInputBody<\n  M extends Procedure | Query | Subscription,\n  B = BinaryData,\n> = M extends Procedure ? InferPayloadBody<M['input'], B> : undefined\n\nexport type InferMethodInputEncoding<\n  M extends Procedure | Query | Subscription,\n> = M extends Procedure ? InferPayloadEncoding<M['input']> : undefined\n\nexport type InferMethodOutput<\n  M extends Procedure | Query | Subscription,\n  B = BinaryData,\n> = M extends Procedure | Query ? InferPayload<M['output'], B> : undefined\n\nexport type InferMethodOutputBody<\n  M extends Procedure | Query | Subscription,\n  B = BinaryData,\n> = M extends Procedure | Query ? InferPayloadBody<M['output'], B> : undefined\n\nexport type InferMethodOutputEncoding<\n  M extends Procedure | Query | Subscription,\n> = M extends Procedure | Query ? InferPayloadEncoding<M['output']> : undefined\n\nexport type InferMethodMessage<\n  //\n  M extends Subscription,\n> = M extends Subscription ? InferOutput<M['message']> : undefined\n\nexport type InferMethodError<\n  //\n  M extends Procedure | Query | Subscription,\n> = M extends { errors: readonly (infer E extends string)[] } ? E : never\n\nexport const lexErrorDataSchema = object({\n  error: string({ minLength: 1 }),\n  message: optional(string()),\n}) satisfies Schema<LexErrorData>\n"]}

package/dist/schema/array.d.ts

@@ -1,14 +1,59 @@
 import { InferInput, InferOutput, Schema, ValidationContext, Validator } from '../core.js';
+/**
+ * Configuration options for array schema validation.
+ *
+ * @property minLength - Minimum number of items in the array
+ * @property maxLength - Maximum number of items in the array
+ */
 export type ArraySchemaOptions = {
     minLength?: number;
     maxLength?: number;
 };
+/**
+ * Schema for validating arrays where all items match a given schema.
+ *
+ * Validates that the input is an array, checks length constraints, and
+ * validates each item against the provided item schema.
+ *
+ * @template TItem - The validator type for array items
+ *
+ * @example
+ * ```ts
+ * const schema = new ArraySchema(l.string(), { maxLength: 10 })
+ * const result = schema.validate(['a', 'b', 'c'])
+ * ```
+ */
 export declare class ArraySchema<const TItem extends Validator> extends Schema<Array<InferInput<TItem>>, Array<InferOutput<TItem>>> {
     readonly validator: TItem;
     readonly options: ArraySchemaOptions;
     constructor(validator: TItem, options?: ArraySchemaOptions);
     validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<any[]>;
 }
+/**
+ * Creates an array schema that validates each item against the provided schema.
+ *
+ * @param items - Schema to validate each array item against
+ * @param options - Optional length constraints
+ * @returns A new {@link ArraySchema} instance
+ *
+ * @example
+ * ```ts
+ * // Array of strings
+ * const tagsSchema = l.array(l.string())
+ *
+ * // Array with length constraints
+ * const limitedSchema = l.array(l.integer(), { maxLength: 100 })
+ *
+ * // Array of objects
+ * const usersSchema = l.array(l.object({
+ *   name: l.string(),
+ *   age: l.integer(),
+ * }))
+ *
+ * // Non-empty array
+ * const nonEmptySchema = l.array(l.string(), { minLength: 1 })
+ * ```
+ */
 declare function arraySchema<const TValidator extends Validator>(items: TValidator, options?: ArraySchemaOptions): ArraySchema<TValidator>;
 declare function arraySchema<const TValue, const TValidator extends Validator<TValue> = Validator<TValue>>(items: TValidator, options?: ArraySchemaOptions): ArraySchema<TValidator>;
 export declare const array: typeof arraySchema;

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

@@ -1 +1 @@
-{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/schema/array.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,WAAW,EACX,MAAM,EACN,iBAAiB,EACjB,SAAS,EACV,MAAM,YAAY,CAAA;AAGnB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,qBAAa,WAAW,CAAC,KAAK,CAAC,KAAK,SAAS,SAAS,CAAE,SAAQ,MAAM,CACpE,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EACxB,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAC1B;IAEG,QAAQ,CAAC,SAAS,EAAE,KAAK;IACzB,QAAQ,CAAC,OAAO,EAAE,kBAAkB;gBAD3B,SAAS,EAAE,KAAK,EAChB,OAAO,GAAE,kBAAuB;IAK3C,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAmCzD;AAGD,iBAAS,WAAW,CAAC,KAAK,CAAC,UAAU,SAAS,SAAS,EACrD,KAAK,EAAE,UAAU,EACjB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,WAAW,CAAC,UAAU,CAAC,CAAA;AAC1B,iBAAS,WAAW,CAClB,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,UAAU,SAAS,SAAS,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,EAC9D,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,WAAW,CAAC,UAAU,CAAC,CAAA;AAQ3E,eAAO,MAAM,KAAK,oBAAiD,CAAA"}
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/schema/array.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,WAAW,EACX,MAAM,EACN,iBAAiB,EACjB,SAAS,EACV,MAAM,YAAY,CAAA;AAGnB;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,WAAW,CAAC,KAAK,CAAC,KAAK,SAAS,SAAS,CAAE,SAAQ,MAAM,CACpE,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EACxB,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAC1B;IAEG,QAAQ,CAAC,SAAS,EAAE,KAAK;IACzB,QAAQ,CAAC,OAAO,EAAE,kBAAkB;gBAD3B,SAAS,EAAE,KAAK,EAChB,OAAO,GAAE,kBAAuB;IAK3C,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAmCzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,iBAAS,WAAW,CAAC,KAAK,CAAC,UAAU,SAAS,SAAS,EACrD,KAAK,EAAE,UAAU,EACjB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,WAAW,CAAC,UAAU,CAAC,CAAA;AAC1B,iBAAS,WAAW,CAClB,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,UAAU,SAAS,SAAS,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,EAC9D,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,WAAW,CAAC,UAAU,CAAC,CAAA;AAQ3E,eAAO,MAAM,KAAK,oBAAiD,CAAA"}

package/dist/schema/array.js

@@ -3,6 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.array = exports.ArraySchema = void 0;
 const core_js_1 = require("../core.js");
 const memoize_js_1 = require("../util/memoize.js");
+/**
+ * Schema for validating arrays where all items match a given schema.
+ *
+ * Validates that the input is an array, checks length constraints, and
+ * validates each item against the provided item schema.
+ *
+ * @template TItem - The validator type for array items
+ *
+ * @example
+ * ```ts
+ * const schema = new ArraySchema(l.string(), { maxLength: 10 })
+ * const result = schema.validate(['a', 'b', 'c'])
+ * ```
+ */
 class ArraySchema extends core_js_1.Schema {
     validator;
     options;

package/dist/schema/array.js.map

@@ -1 +1 @@
-{"version":3,"file":"array.js","sourceRoot":"","sources":["../../src/schema/array.ts"],"names":[],"mappings":";;;AAAA,wCAMmB;AACnB,mDAAwD;AAOxD,MAAa,WAA2C,SAAQ,gBAG/D;IAEY;IACA;IAFX,YACW,SAAgB,EAChB,UAA8B,EAAE;QAEzC,KAAK,EAAE,CAAA;QAHE,cAAS,GAAT,SAAS,CAAO;QAChB,YAAO,GAAP,OAAO,CAAyB;IAG3C,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;QAC7C,CAAC;QAED,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,OAAO,CAAA;QAE7C,IAAI,SAAS,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;YAClD,OAAO,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;QACnE,CAAC;QAED,IAAI,SAAS,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;YAClD,OAAO,GAAG,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;QACjE,CAAC;QAED,IAAI,IAA2B,CAAA;QAE/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACtC,MAAM,MAAM,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;YAC1D,IAAI,CAAC,MAAM,CAAC,OAAO;gBAAE,OAAO,MAAM,CAAA;YAElC,IAAI,MAAM,CAAC,KAAK,KAAK,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC9B,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;oBACpC,sEAAsE;oBACtE,OAAO,GAAG,CAAC,yBAAyB,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;gBAChE,CAAC;gBAED,6DAA6D;gBAC7D,IAAI,KAAK,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;gBAC1B,IAAI,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,CAAA;YACxB,CAAC;QACH,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,KAAK,CAAC,CAAA;IACnC,CAAC;CACF;AA9CD,kCA8CC;AAWD,SAAS,WAAW,CAClB,KAAiB,EACjB,OAA4B;IAE5B,OAAO,IAAI,WAAW,CAAa,KAAK,EAAE,OAAO,CAAC,CAAA;AACpD,CAAC;AAEY,QAAA,KAAK,GAAiB,IAAA,gCAAmB,EAAC,WAAW,CAAC,CAAA","sourcesContent":["import {\n  InferInput,\n  InferOutput,\n  Schema,\n  ValidationContext,\n  Validator,\n} from '../core.js'\nimport { memoizedTransformer } from '../util/memoize.js'\n\nexport type ArraySchemaOptions = {\n  minLength?: number\n  maxLength?: number\n}\n\nexport class ArraySchema<const TItem extends Validator> extends Schema<\n  Array<InferInput<TItem>>,\n  Array<InferOutput<TItem>>\n> {\n  constructor(\n    readonly validator: TItem,\n    readonly options: ArraySchemaOptions = {},\n  ) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!Array.isArray(input)) {\n      return ctx.issueInvalidType(input, 'array')\n    }\n\n    const { minLength, maxLength } = this.options\n\n    if (minLength != null && input.length < minLength) {\n      return ctx.issueTooSmall(input, 'array', minLength, input.length)\n    }\n\n    if (maxLength != null && input.length > maxLength) {\n      return ctx.issueTooBig(input, 'array', maxLength, input.length)\n    }\n\n    let copy: undefined | unknown[]\n\n    for (let i = 0; i < input.length; i++) {\n      const result = ctx.validateChild(input, i, this.validator)\n      if (!result.success) return result\n\n      if (result.value !== input[i]) {\n        if (ctx.options.mode === 'validate') {\n          // In \"validate\" mode, we can't modify the input, so we issue an error\n          return ctx.issueInvalidPropertyValue(input, i, [result.value])\n        }\n\n        // Copy on write (but only if we did not already make a copy)\n        copy ??= Array.from(input)\n        copy[i] = result.value\n      }\n    }\n\n    return ctx.success(copy ?? input)\n  }\n}\n\n/*@__NO_SIDE_EFFECTS__*/\nfunction arraySchema<const TValidator extends Validator>(\n  items: TValidator,\n  options?: ArraySchemaOptions,\n): ArraySchema<TValidator>\nfunction arraySchema<\n  const TValue,\n  const TValidator extends Validator<TValue> = Validator<TValue>,\n>(items: TValidator, options?: ArraySchemaOptions): ArraySchema<TValidator>\nfunction arraySchema<const TValidator extends Validator>(\n  items: TValidator,\n  options?: ArraySchemaOptions,\n) {\n  return new ArraySchema<TValidator>(items, options)\n}\n\nexport const array = /*#__PURE__*/ memoizedTransformer(arraySchema)\n"]}
+{"version":3,"file":"array.js","sourceRoot":"","sources":["../../src/schema/array.ts"],"names":[],"mappings":";;;AAAA,wCAMmB;AACnB,mDAAwD;AAaxD;;;;;;;;;;;;;GAaG;AACH,MAAa,WAA2C,SAAQ,gBAG/D;IAEY;IACA;IAFX,YACW,SAAgB,EAChB,UAA8B,EAAE;QAEzC,KAAK,EAAE,CAAA;QAHE,cAAS,GAAT,SAAS,CAAO;QAChB,YAAO,GAAP,OAAO,CAAyB;IAG3C,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;QAC7C,CAAC;QAED,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,OAAO,CAAA;QAE7C,IAAI,SAAS,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;YAClD,OAAO,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;QACnE,CAAC;QAED,IAAI,SAAS,IAAI,IAAI,IAAI,KAAK,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;YAClD,OAAO,GAAG,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;QACjE,CAAC;QAED,IAAI,IAA2B,CAAA;QAE/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACtC,MAAM,MAAM,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;YAC1D,IAAI,CAAC,MAAM,CAAC,OAAO;gBAAE,OAAO,MAAM,CAAA;YAElC,IAAI,MAAM,CAAC,KAAK,KAAK,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC9B,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;oBACpC,sEAAsE;oBACtE,OAAO,GAAG,CAAC,yBAAyB,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;gBAChE,CAAC;gBAED,6DAA6D;gBAC7D,IAAI,KAAK,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;gBAC1B,IAAI,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,KAAK,CAAA;YACxB,CAAC;QACH,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,KAAK,CAAC,CAAA;IACnC,CAAC;CACF;AA9CD,kCA8CC;AAoCD,SAAS,WAAW,CAClB,KAAiB,EACjB,OAA4B;IAE5B,OAAO,IAAI,WAAW,CAAa,KAAK,EAAE,OAAO,CAAC,CAAA;AACpD,CAAC;AAEY,QAAA,KAAK,GAAiB,IAAA,gCAAmB,EAAC,WAAW,CAAC,CAAA","sourcesContent":["import {\n  InferInput,\n  InferOutput,\n  Schema,\n  ValidationContext,\n  Validator,\n} from '../core.js'\nimport { memoizedTransformer } from '../util/memoize.js'\n\n/**\n * Configuration options for array schema validation.\n *\n * @property minLength - Minimum number of items in the array\n * @property maxLength - Maximum number of items in the array\n */\nexport type ArraySchemaOptions = {\n  minLength?: number\n  maxLength?: number\n}\n\n/**\n * Schema for validating arrays where all items match a given schema.\n *\n * Validates that the input is an array, checks length constraints, and\n * validates each item against the provided item schema.\n *\n * @template TItem - The validator type for array items\n *\n * @example\n * ```ts\n * const schema = new ArraySchema(l.string(), { maxLength: 10 })\n * const result = schema.validate(['a', 'b', 'c'])\n * ```\n */\nexport class ArraySchema<const TItem extends Validator> extends Schema<\n  Array<InferInput<TItem>>,\n  Array<InferOutput<TItem>>\n> {\n  constructor(\n    readonly validator: TItem,\n    readonly options: ArraySchemaOptions = {},\n  ) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!Array.isArray(input)) {\n      return ctx.issueInvalidType(input, 'array')\n    }\n\n    const { minLength, maxLength } = this.options\n\n    if (minLength != null && input.length < minLength) {\n      return ctx.issueTooSmall(input, 'array', minLength, input.length)\n    }\n\n    if (maxLength != null && input.length > maxLength) {\n      return ctx.issueTooBig(input, 'array', maxLength, input.length)\n    }\n\n    let copy: undefined | unknown[]\n\n    for (let i = 0; i < input.length; i++) {\n      const result = ctx.validateChild(input, i, this.validator)\n      if (!result.success) return result\n\n      if (result.value !== input[i]) {\n        if (ctx.options.mode === 'validate') {\n          // In \"validate\" mode, we can't modify the input, so we issue an error\n          return ctx.issueInvalidPropertyValue(input, i, [result.value])\n        }\n\n        // Copy on write (but only if we did not already make a copy)\n        copy ??= Array.from(input)\n        copy[i] = result.value\n      }\n    }\n\n    return ctx.success(copy ?? input)\n  }\n}\n\n/**\n * Creates an array schema that validates each item against the provided schema.\n *\n * @param items - Schema to validate each array item against\n * @param options - Optional length constraints\n * @returns A new {@link ArraySchema} instance\n *\n * @example\n * ```ts\n * // Array of strings\n * const tagsSchema = l.array(l.string())\n *\n * // Array with length constraints\n * const limitedSchema = l.array(l.integer(), { maxLength: 100 })\n *\n * // Array of objects\n * const usersSchema = l.array(l.object({\n *   name: l.string(),\n *   age: l.integer(),\n * }))\n *\n * // Non-empty array\n * const nonEmptySchema = l.array(l.string(), { minLength: 1 })\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nfunction arraySchema<const TValidator extends Validator>(\n  items: TValidator,\n  options?: ArraySchemaOptions,\n): ArraySchema<TValidator>\nfunction arraySchema<\n  const TValue,\n  const TValidator extends Validator<TValue> = Validator<TValue>,\n>(items: TValidator, options?: ArraySchemaOptions): ArraySchema<TValidator>\nfunction arraySchema<const TValidator extends Validator>(\n  items: TValidator,\n  options?: ArraySchemaOptions,\n) {\n  return new ArraySchema<TValidator>(items, options)\n}\n\nexport const array = /*#__PURE__*/ memoizedTransformer(arraySchema)\n"]}

package/dist/schema/blob.d.ts

@@ -1,5 +1,12 @@
 import { BlobRef, BlobRefCheckOptions, LegacyBlobRef } from '@atproto/lex-data';
 import { Schema, ValidationContext } from '../core.js';
+/**
+ * Configuration options for blob schema validation.
+ *
+ * @property allowLegacy - Whether to allow legacy blob references format
+ * @property accept - List of accepted MIME types (supports wildcards like 'image/*' or '*\/*')
+ * @property maxSize - Maximum blob size in bytes
+ */
 export type BlobSchemaOptions = BlobRefCheckOptions & {
     /**
      * Whether to allow legacy blob references format
@@ -16,6 +23,21 @@ export type BlobSchemaOptions = BlobRefCheckOptions & {
     maxSize?: number;
 };
 export type { BlobRef, LegacyBlobRef };
+/**
+ * Schema for validating blob references in AT Protocol.
+ *
+ * Validates BlobRef objects which contain a CID reference to binary data,
+ * along with metadata like MIME type and size. Can optionally accept
+ * legacy blob reference format.
+ *
+ * @template TOptions - The configuration options type
+ *
+ * @example
+ * ```ts
+ * const schema = new BlobSchema({ accept: ['image/*'], maxSize: 1000000 })
+ * const result = schema.validate(blobRef)
+ * ```
+ */
 export declare class BlobSchema<const TOptions extends BlobSchemaOptions = NonNullable<unknown>> extends Schema<TOptions extends {
     allowLegacy: true;
 } ? BlobRef | LegacyBlobRef : BlobRef> {
@@ -24,6 +46,30 @@ export declare class BlobSchema<const TOptions extends BlobSchemaOptions = NonNu
     validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<BlobRef | LegacyBlobRef>;
     matchesMime(mime: string): boolean;
 }
+/**
+ * Creates a blob schema for validating blob references with optional constraints.
+ *
+ * Blob references are used in AT Protocol to reference binary data stored
+ * separately from records. They contain a CID, MIME type, and size information.
+ *
+ * @param options - Optional configuration for MIME type filtering and size limits
+ * @returns A new {@link BlobSchema} instance
+ *
+ * @example
+ * ```ts
+ * // Basic blob reference
+ * const fileSchema = l.blob()
+ *
+ * // Image files only
+ * const imageSchema = l.blob({ accept: ['image/png', 'image/jpeg', 'image/gif'] })
+ *
+ * // Any image type with size limit
+ * const avatarSchema = l.blob({ accept: ['image/*'], maxSize: 1000000 })
+ *
+ * // Allow legacy format
+ * const legacySchema = l.blob({ allowLegacy: true })
+ * ```
+ */
 export declare const blob: <O extends BlobSchemaOptions = {
     allowLegacy?: false;
 }>(options?: O) => BlobSchema<O>;