@atproto/lex-schema 0.1.5 → 0.1.6

package/dist/schema/discriminated-union.js.map

@@ -1 +1 @@
-{"version":3,"file":"discriminated-union.js","sourceRoot":"","sources":["../../src/schema/discriminated-union.ts"],"names":[],"mappings":"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","sourcesContent":["import { isPlainObject } from '@atproto/lex-data'\nimport {\n  InferInput,\n  InferOutput,\n  Schema,\n  ValidationContext,\n  ValidationResult,\n  Validator,\n} from '../core.js'\nimport { EnumSchema } from './enum.js'\nimport { LiteralSchema } from './literal.js'\nimport { ObjectSchema } from './object.js'\n\n/**\n * Type representing a single variant in a discriminated union.\n *\n * Must be an ObjectSchema with the discriminator property using either\n * a LiteralSchema or EnumSchema.\n *\n * @template Discriminator - The discriminator property name\n */\nexport type DiscriminatedUnionVariant<Discriminator extends string = string> =\n  ObjectSchema<Record<Discriminator, EnumSchema<any> | LiteralSchema<any>>>\n\n/**\n * Type representing a non-empty tuple of discriminated union variants.\n *\n * @template TDiscriminator - The discriminator property name\n */\nexport type DiscriminatedUnionVariants<TDiscriminator extends string> =\n  readonly [\n    DiscriminatedUnionVariant<TDiscriminator>,\n    ...DiscriminatedUnionVariant<TDiscriminator>[],\n  ]\n\ntype DiscriminatedUnionSchemaInput<TVariants extends readonly Validator[]> =\n  TVariants extends readonly [\n    infer TValidator extends Validator,\n    ...infer TRest extends readonly Validator[],\n  ]\n    ? InferInput<TValidator> | DiscriminatedUnionSchemaInput<TRest>\n    : never\n\ntype DiscriminatedUnionSchemaOutput<TVariants extends readonly Validator[]> =\n  TVariants extends readonly [\n    infer TValidator extends Validator,\n    ...infer TRest extends readonly Validator[],\n  ]\n    ? InferOutput<TValidator> | DiscriminatedUnionSchemaOutput<TRest>\n    : never\n\n/**\n * Schema for validating discriminated unions of objects.\n *\n * More efficient than regular union schemas when discriminating on a known\n * property. Looks up the correct variant schema directly based on the\n * discriminator value instead of trying each variant in sequence.\n *\n * @note There is no discriminated union in Lexicon schemas. This is a custom\n * extension to allow optimized validation of union of objects when using the\n * lex library programmatically (i.e. not code generated from a lexicon schema).\n *\n * @template TDiscriminator - The discriminator property name\n * @template TVariants - Tuple type of the variant schemas\n *\n * @example\n * ```ts\n * const schema = new DiscriminatedUnionSchema('type', [\n *   l.object({ type: l.literal('text'), content: l.string() }),\n *   l.object({ type: l.literal('image'), url: l.string() }),\n * ])\n * ```\n */\nexport class DiscriminatedUnionSchema<\n  const TDiscriminator extends string,\n  const TVariants extends DiscriminatedUnionVariants<TDiscriminator>,\n> extends Schema<\n  DiscriminatedUnionSchemaInput<TVariants>,\n  DiscriminatedUnionSchemaOutput<TVariants>\n> {\n  readonly type = 'discriminatedUnion' as const\n\n  readonly variantsMap: Map<unknown, DiscriminatedUnionVariant<TDiscriminator>>\n\n  constructor(\n    readonly discriminator: TDiscriminator,\n    readonly variants: TVariants,\n  ) {\n    super()\n\n    // Although we usually try to avoid initialization work in constructors,\n    // here it is necessary to ensure that invalid discriminated throw from the\n    // place of construction, rather than later during validation.\n    this.variantsMap = buildVariantsMap(discriminator, variants)\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isPlainObject(input)) {\n      return ctx.issueUnexpectedType(input, 'object')\n    }\n\n    const { discriminator } = this\n\n    if (!Object.hasOwn(input, discriminator)) {\n      return ctx.issueRequiredKey(input, discriminator)\n    }\n\n    const discriminatorValue = input[discriminator]\n\n    const variant = this.variantsMap.get(discriminatorValue)\n    if (variant) {\n      return ctx.validate(input, variant) as ValidationResult<\n        DiscriminatedUnionSchemaInput<TVariants>\n      >\n    }\n\n    return ctx.issueInvalidPropertyValue(input, discriminator, [\n      ...this.variantsMap.keys(),\n    ])\n  }\n}\n\nfunction buildVariantsMap<Discriminator extends string>(\n  discriminator: Discriminator,\n  variants: DiscriminatedUnionVariants<Discriminator>,\n) {\n  const variantsMap = new Map<\n    unknown,\n    DiscriminatedUnionVariant<Discriminator>\n  >()\n\n  for (const variant of variants) {\n    const schema = variant.shape[discriminator]\n    if (schema instanceof LiteralSchema) {\n      if (variantsMap.has(schema.value)) {\n        throw new TypeError(`Overlapping discriminator value: ${schema.value}`)\n      }\n      variantsMap.set(schema.value, variant)\n    } else if (schema instanceof EnumSchema) {\n      for (const val of schema.values) {\n        if (variantsMap.has(val)) {\n          throw new TypeError(`Overlapping discriminator value: ${val}`)\n        }\n        variantsMap.set(val, variant)\n      }\n    } else {\n      // Only enumerable discriminator schemas are supported\n\n      // Should never happen if types are used correctly\n      throw new TypeError(\n        `Discriminator schema must be a LiteralSchema or EnumSchema`,\n      )\n    }\n  }\n\n  return variantsMap\n}\n\n/**\n * Creates a discriminated union schema for efficient object type switching.\n *\n * Unlike regular `union()`, this schema uses a discriminator property to\n * directly look up the correct variant, providing O(1) validation instead\n * of trying each variant sequentially.\n *\n * @param discriminator - Property name to discriminate on\n * @param variants - Non-empty array of object schemas with the discriminator property\n * @returns A new {@link DiscriminatedUnionSchema} instance\n *\n * @example\n * ```ts\n * // Message types discriminated by 'kind'\n * const messageSchema = l.discriminatedUnion('kind', [\n *   l.object({ kind: l.literal('text'), text: l.string() }),\n *   l.object({ kind: l.literal('image'), url: l.string(), alt: l.optional(l.string()) }),\n *   l.object({ kind: l.literal('video'), url: l.string(), duration: l.integer() }),\n * ])\n *\n * // Using enums for multiple values mapping to same variant\n * const statusSchema = l.discriminatedUnion('status', [\n *   l.object({ status: l.enum(['pending', 'processing']), startedAt: l.string() }),\n *   l.object({ status: l.literal('completed'), completedAt: l.string() }),\n *   l.object({ status: l.literal('failed'), error: l.string() }),\n * ])\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function discriminatedUnion<\n  const Discriminator extends string,\n  const Options extends DiscriminatedUnionVariants<Discriminator>,\n>(discriminator: Discriminator, variants: Options) {\n  return new DiscriminatedUnionSchema<Discriminator, Options>(\n    discriminator,\n    variants,\n  )\n}\n"]}
+{"version":3,"file":"discriminated-union.js","sourceRoot":"","sources":["../../src/schema/discriminated-union.ts"],"names":[],"mappings":"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","sourcesContent":["import { isPlainObject } from '@atproto/lex-data'\nimport {\n  type InferInput,\n  type InferOutput,\n  Schema,\n  ValidationContext,\n  type ValidationResult,\n  type Validator,\n} from '../core.js'\nimport { EnumSchema } from './enum.js'\nimport { LiteralSchema } from './literal.js'\nimport { ObjectSchema } from './object.js'\n\n/**\n * Type representing a single variant in a discriminated union.\n *\n * Must be an ObjectSchema with the discriminator property using either\n * a LiteralSchema or EnumSchema.\n *\n * @template Discriminator - The discriminator property name\n */\nexport type DiscriminatedUnionVariant<Discriminator extends string = string> =\n  ObjectSchema<Record<Discriminator, EnumSchema<any> | LiteralSchema<any>>>\n\n/**\n * Type representing a non-empty tuple of discriminated union variants.\n *\n * @template TDiscriminator - The discriminator property name\n */\nexport type DiscriminatedUnionVariants<TDiscriminator extends string> =\n  readonly [\n    DiscriminatedUnionVariant<TDiscriminator>,\n    ...DiscriminatedUnionVariant<TDiscriminator>[],\n  ]\n\ntype DiscriminatedUnionSchemaInput<TVariants extends readonly Validator[]> =\n  TVariants extends readonly [\n    infer TValidator extends Validator,\n    ...infer TRest extends readonly Validator[],\n  ]\n    ? InferInput<TValidator> | DiscriminatedUnionSchemaInput<TRest>\n    : never\n\ntype DiscriminatedUnionSchemaOutput<TVariants extends readonly Validator[]> =\n  TVariants extends readonly [\n    infer TValidator extends Validator,\n    ...infer TRest extends readonly Validator[],\n  ]\n    ? InferOutput<TValidator> | DiscriminatedUnionSchemaOutput<TRest>\n    : never\n\n/**\n * Schema for validating discriminated unions of objects.\n *\n * More efficient than regular union schemas when discriminating on a known\n * property. Looks up the correct variant schema directly based on the\n * discriminator value instead of trying each variant in sequence.\n *\n * @note There is no discriminated union in Lexicon schemas. This is a custom\n * extension to allow optimized validation of union of objects when using the\n * lex library programmatically (i.e. not code generated from a lexicon schema).\n *\n * @template TDiscriminator - The discriminator property name\n * @template TVariants - Tuple type of the variant schemas\n *\n * @example\n * ```ts\n * const schema = new DiscriminatedUnionSchema('type', [\n *   l.object({ type: l.literal('text'), content: l.string() }),\n *   l.object({ type: l.literal('image'), url: l.string() }),\n * ])\n * ```\n */\nexport class DiscriminatedUnionSchema<\n  const TDiscriminator extends string,\n  const TVariants extends DiscriminatedUnionVariants<TDiscriminator>,\n> extends Schema<\n  DiscriminatedUnionSchemaInput<TVariants>,\n  DiscriminatedUnionSchemaOutput<TVariants>\n> {\n  readonly type = 'discriminatedUnion' as const\n\n  readonly variantsMap: Map<unknown, DiscriminatedUnionVariant<TDiscriminator>>\n\n  constructor(\n    readonly discriminator: TDiscriminator,\n    readonly variants: TVariants,\n  ) {\n    super()\n\n    // Although we usually try to avoid initialization work in constructors,\n    // here it is necessary to ensure that invalid discriminated throw from the\n    // place of construction, rather than later during validation.\n    this.variantsMap = buildVariantsMap(discriminator, variants)\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isPlainObject(input)) {\n      return ctx.issueUnexpectedType(input, 'object')\n    }\n\n    const { discriminator } = this\n\n    if (!Object.hasOwn(input, discriminator)) {\n      return ctx.issueRequiredKey(input, discriminator)\n    }\n\n    const discriminatorValue = input[discriminator]\n\n    const variant = this.variantsMap.get(discriminatorValue)\n    if (variant) {\n      return ctx.validate(input, variant) as ValidationResult<\n        DiscriminatedUnionSchemaInput<TVariants>\n      >\n    }\n\n    return ctx.issueInvalidPropertyValue(input, discriminator, [\n      ...this.variantsMap.keys(),\n    ])\n  }\n}\n\nfunction buildVariantsMap<Discriminator extends string>(\n  discriminator: Discriminator,\n  variants: DiscriminatedUnionVariants<Discriminator>,\n) {\n  const variantsMap = new Map<\n    unknown,\n    DiscriminatedUnionVariant<Discriminator>\n  >()\n\n  for (const variant of variants) {\n    const schema = variant.shape[discriminator]\n    if (schema instanceof LiteralSchema) {\n      if (variantsMap.has(schema.value)) {\n        throw new TypeError(`Overlapping discriminator value: ${schema.value}`)\n      }\n      variantsMap.set(schema.value, variant)\n    } else if (schema instanceof EnumSchema) {\n      for (const val of schema.values) {\n        if (variantsMap.has(val)) {\n          throw new TypeError(`Overlapping discriminator value: ${val}`)\n        }\n        variantsMap.set(val, variant)\n      }\n    } else {\n      // Only enumerable discriminator schemas are supported\n\n      // Should never happen if types are used correctly\n      throw new TypeError(\n        `Discriminator schema must be a LiteralSchema or EnumSchema`,\n      )\n    }\n  }\n\n  return variantsMap\n}\n\n/**\n * Creates a discriminated union schema for efficient object type switching.\n *\n * Unlike regular `union()`, this schema uses a discriminator property to\n * directly look up the correct variant, providing O(1) validation instead\n * of trying each variant sequentially.\n *\n * @param discriminator - Property name to discriminate on\n * @param variants - Non-empty array of object schemas with the discriminator property\n * @returns A new {@link DiscriminatedUnionSchema} instance\n *\n * @example\n * ```ts\n * // Message types discriminated by 'kind'\n * const messageSchema = l.discriminatedUnion('kind', [\n *   l.object({ kind: l.literal('text'), text: l.string() }),\n *   l.object({ kind: l.literal('image'), url: l.string(), alt: l.optional(l.string()) }),\n *   l.object({ kind: l.literal('video'), url: l.string(), duration: l.integer() }),\n * ])\n *\n * // Using enums for multiple values mapping to same variant\n * const statusSchema = l.discriminatedUnion('status', [\n *   l.object({ status: l.enum(['pending', 'processing']), startedAt: l.string() }),\n *   l.object({ status: l.literal('completed'), completedAt: l.string() }),\n *   l.object({ status: l.literal('failed'), error: l.string() }),\n * ])\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function discriminatedUnion<\n  const Discriminator extends string,\n  const Options extends DiscriminatedUnionVariants<Discriminator>,\n>(discriminator: Discriminator, variants: Options) {\n  return new DiscriminatedUnionSchema<Discriminator, Options>(\n    discriminator,\n    variants,\n  )\n}\n"]}

package/dist/schema/enum.js

@@ -1,4 +1,4 @@
-import { Schema } from '../core.js';
+import { Schema, ValidationContext } from '../core.js';
 /**
  * Schema that accepts one of several specific literal values.
  *

package/dist/schema/enum.js.map

@@ -1 +1 @@
-{"version":3,"file":"enum.js","sourceRoot":"","sources":["../../src/schema/enum.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAqB,MAAM,YAAY,CAAA;AAEtD;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,UAEX,SAAQ,MAAc;IAGtB,YAAqB,MAAyB;QAC5C,KAAK,EAAE,CAAA;QADY,WAAM,GAAN,MAAM,CAAmB;QAFrC,SAAI,GAAG,MAAe,CAAA;IAI/B,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAE,IAAI,CAAC,MAA6B,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YACzD,OAAO,GAAG,CAAC,iBAAiB,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;QAClD,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAe,CAAC,CAAA;IACrC,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAwB;AACxB,MAAM,UAAU,UAAU,CACxB,KAAmB;IAEnB,OAAO,IAAI,UAAU,CAAI,KAAK,CAAC,CAAA;AACjC,CAAC;AAED,8CAA8C;AAC9C,OAAO,EAAE,UAAU,IAAI,IAAI,EAAE,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\n\n/**\n * Schema that accepts one of several specific literal values.\n *\n * Validates that the input matches one of the allowed values using strict\n * equality. Similar to TypeScript union of literals.\n *\n * @template TValue - The union of literal types\n *\n * @example\n * ```ts\n * const schema = new EnumSchema(['pending', 'active', 'completed'])\n * schema.validate('active')  // success\n * schema.validate('invalid') // fails\n * ```\n */\nexport class EnumSchema<\n  const TValue extends null | string | number | boolean,\n> extends Schema<TValue> {\n  readonly type = 'enum' as const\n\n  constructor(readonly values: readonly TValue[]) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!(this.values as readonly unknown[]).includes(input)) {\n      return ctx.issueInvalidValue(input, this.values)\n    }\n\n    return ctx.success(input as TValue)\n  }\n}\n\n/**\n * Creates an enum schema that accepts one of the specified values.\n *\n * Similar to TypeScript's union of string literals. Use `l.enum()` for\n * the namespace-friendly alias.\n *\n * @param value - Array of allowed values\n * @returns A new {@link EnumSchema} instance\n *\n * @example\n * ```ts\n * // String enum\n * const statusSchema = l.enum(['pending', 'active', 'completed', 'failed'])\n *\n * // Number enum\n * const prioritySchema = l.enum([1, 2, 3, 4, 5])\n *\n * // Mixed types\n * const mixedSchema = l.enum(['auto', 0, 1, true])\n *\n * // Use in objects\n * const taskSchema = l.object({\n *   title: l.string(),\n *   status: l.enum(['todo', 'in-progress', 'done']),\n * })\n *\n * // In discriminated unions\n * const resultSchema = l.discriminatedUnion('status', [\n *   l.object({ status: l.enum(['pending', 'processing']), progress: l.integer() }),\n *   l.object({ status: l.literal('completed'), result: l.unknown() }),\n * ])\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function enumSchema<const V extends null | string | number | boolean>(\n  value: readonly V[],\n) {\n  return new EnumSchema<V>(value)\n}\n\n// @NOTE \"enum\" is a reserved keyword in JS/TS\nexport { enumSchema as enum }\n"]}
+{"version":3,"file":"enum.js","sourceRoot":"","sources":["../../src/schema/enum.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEtD;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,UAEX,SAAQ,MAAc;IAGtB,YAAqB,MAAyB;QAC5C,KAAK,EAAE,CAAA;QADY,WAAM,GAAN,MAAM,CAAmB;QAFrC,SAAI,GAAG,MAAe,CAAA;IAI/B,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAE,IAAI,CAAC,MAA6B,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YACzD,OAAO,GAAG,CAAC,iBAAiB,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;QAClD,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAe,CAAC,CAAA;IACrC,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAwB;AACxB,MAAM,UAAU,UAAU,CACxB,KAAmB;IAEnB,OAAO,IAAI,UAAU,CAAI,KAAK,CAAC,CAAA;AACjC,CAAC;AAED,8CAA8C;AAC9C,OAAO,EAAE,UAAU,IAAI,IAAI,EAAE,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\n\n/**\n * Schema that accepts one of several specific literal values.\n *\n * Validates that the input matches one of the allowed values using strict\n * equality. Similar to TypeScript union of literals.\n *\n * @template TValue - The union of literal types\n *\n * @example\n * ```ts\n * const schema = new EnumSchema(['pending', 'active', 'completed'])\n * schema.validate('active')  // success\n * schema.validate('invalid') // fails\n * ```\n */\nexport class EnumSchema<\n  const TValue extends null | string | number | boolean,\n> extends Schema<TValue> {\n  readonly type = 'enum' as const\n\n  constructor(readonly values: readonly TValue[]) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!(this.values as readonly unknown[]).includes(input)) {\n      return ctx.issueInvalidValue(input, this.values)\n    }\n\n    return ctx.success(input as TValue)\n  }\n}\n\n/**\n * Creates an enum schema that accepts one of the specified values.\n *\n * Similar to TypeScript's union of string literals. Use `l.enum()` for\n * the namespace-friendly alias.\n *\n * @param value - Array of allowed values\n * @returns A new {@link EnumSchema} instance\n *\n * @example\n * ```ts\n * // String enum\n * const statusSchema = l.enum(['pending', 'active', 'completed', 'failed'])\n *\n * // Number enum\n * const prioritySchema = l.enum([1, 2, 3, 4, 5])\n *\n * // Mixed types\n * const mixedSchema = l.enum(['auto', 0, 1, true])\n *\n * // Use in objects\n * const taskSchema = l.object({\n *   title: l.string(),\n *   status: l.enum(['todo', 'in-progress', 'done']),\n * })\n *\n * // In discriminated unions\n * const resultSchema = l.discriminatedUnion('status', [\n *   l.object({ status: l.enum(['pending', 'processing']), progress: l.integer() }),\n *   l.object({ status: l.literal('completed'), result: l.unknown() }),\n * ])\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function enumSchema<const V extends null | string | number | boolean>(\n  value: readonly V[],\n) {\n  return new EnumSchema<V>(value)\n}\n\n// @NOTE \"enum\" is a reserved keyword in JS/TS\nexport { enumSchema as enum }\n"]}

package/dist/schema/integer.js

@@ -1,4 +1,4 @@
-import { Schema } from '../core.js';
+import { Schema, ValidationContext } from '../core.js';
 import { memoizedOptions } from '../util/memoize.js';
 /**
  * Schema for validating integer values with optional range constraints.

package/dist/schema/integer.js.map

@@ -1 +1 @@
-{"version":3,"file":"integer.js","sourceRoot":"","sources":["../../src/schema/integer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAqB,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAapD;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,aAAc,SAAQ,MAAc;IAG/C,YAAqB,OAA8B;QACjD,KAAK,EAAE,CAAA;QADY,YAAO,GAAP,OAAO,CAAuB;QAF1C,SAAI,GAAG,SAAkB,CAAA;IAIlC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;YACtB,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;QAClD,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,OAAO,IAAI,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAClE,OAAO,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;QACzE,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,OAAO,IAAI,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAClE,OAAO,GAAG,CAAC,WAAW,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;QACvE,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAED;;GAEG;AACH,SAAS,SAAS,CAAC,KAAc;IAC/B,OAAO,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,CAAA;AACpC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,aAAa,CAAC,eAAe,CAAC,UACnD,OAA8B;IAE9B,OAAO,IAAI,aAAa,CAAC,OAAO,CAAC,CAAA;AACnC,CAAC,CAAC,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Configuration options for integer schema validation.\n *\n * @property minimum - Minimum allowed value (inclusive)\n * @property maximum - Maximum allowed value (inclusive)\n */\nexport type IntegerSchemaOptions = {\n  minimum?: number\n  maximum?: number\n}\n\n/**\n * Schema for validating integer values with optional range constraints.\n *\n * Only accepts safe integers (values that can be exactly represented in JavaScript).\n * Use {@link IntegerSchemaOptions} to constrain the allowed range.\n *\n * @example\n * ```ts\n * const schema = new IntegerSchema({ minimum: 0, maximum: 100 })\n * const result = schema.validate(42)\n * ```\n */\nexport class IntegerSchema extends Schema<number> {\n  readonly type = 'integer' as const\n\n  constructor(readonly options?: IntegerSchemaOptions) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isInteger(input)) {\n      return ctx.issueUnexpectedType(input, 'integer')\n    }\n\n    if (this.options?.minimum != null && input < this.options.minimum) {\n      return ctx.issueTooSmall(input, 'integer', this.options.minimum, input)\n    }\n\n    if (this.options?.maximum != null && input > this.options.maximum) {\n      return ctx.issueTooBig(input, 'integer', this.options.maximum, input)\n    }\n\n    return ctx.success(input)\n  }\n}\n\n/**\n * Simple wrapper around {@link Number.isSafeInteger} that acts as a type guard.\n */\nfunction isInteger(input: unknown): input is number {\n  return Number.isSafeInteger(input)\n}\n\n/**\n * Creates an integer schema with optional minimum and maximum constraints.\n *\n * Validates that the input is a safe integer (can be exactly represented in JavaScript)\n * and optionally falls within a specified range.\n *\n * @param options - Optional configuration for minimum and maximum values\n * @returns A new {@link IntegerSchema} instance\n *\n * @example\n * ```ts\n * // Basic integer\n * const countSchema = l.integer()\n *\n * // With minimum value\n * const positiveSchema = l.integer({ minimum: 1 })\n *\n * // With range constraints\n * const percentSchema = l.integer({ minimum: 0, maximum: 100 })\n *\n * // Age validation\n * const ageSchema = l.integer({ minimum: 0, maximum: 150 })\n * ```\n */\nexport const integer = /*#__PURE__*/ memoizedOptions(function (\n  options?: IntegerSchemaOptions,\n) {\n  return new IntegerSchema(options)\n})\n"]}
+{"version":3,"file":"integer.js","sourceRoot":"","sources":["../../src/schema/integer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAapD;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,aAAc,SAAQ,MAAc;IAG/C,YAAqB,OAA8B;QACjD,KAAK,EAAE,CAAA;QADY,YAAO,GAAP,OAAO,CAAuB;QAF1C,SAAI,GAAG,SAAkB,CAAA;IAIlC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;YACtB,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;QAClD,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,OAAO,IAAI,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAClE,OAAO,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;QACzE,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,EAAE,OAAO,IAAI,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YAClE,OAAO,GAAG,CAAC,WAAW,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;QACvE,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAED;;GAEG;AACH,SAAS,SAAS,CAAC,KAAc;IAC/B,OAAO,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,CAAA;AACpC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,aAAa,CAAC,eAAe,CAAC,UACnD,OAA8B;IAE9B,OAAO,IAAI,aAAa,CAAC,OAAO,CAAC,CAAA;AACnC,CAAC,CAAC,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Configuration options for integer schema validation.\n *\n * @property minimum - Minimum allowed value (inclusive)\n * @property maximum - Maximum allowed value (inclusive)\n */\nexport type IntegerSchemaOptions = {\n  minimum?: number\n  maximum?: number\n}\n\n/**\n * Schema for validating integer values with optional range constraints.\n *\n * Only accepts safe integers (values that can be exactly represented in JavaScript).\n * Use {@link IntegerSchemaOptions} to constrain the allowed range.\n *\n * @example\n * ```ts\n * const schema = new IntegerSchema({ minimum: 0, maximum: 100 })\n * const result = schema.validate(42)\n * ```\n */\nexport class IntegerSchema extends Schema<number> {\n  readonly type = 'integer' as const\n\n  constructor(readonly options?: IntegerSchemaOptions) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isInteger(input)) {\n      return ctx.issueUnexpectedType(input, 'integer')\n    }\n\n    if (this.options?.minimum != null && input < this.options.minimum) {\n      return ctx.issueTooSmall(input, 'integer', this.options.minimum, input)\n    }\n\n    if (this.options?.maximum != null && input > this.options.maximum) {\n      return ctx.issueTooBig(input, 'integer', this.options.maximum, input)\n    }\n\n    return ctx.success(input)\n  }\n}\n\n/**\n * Simple wrapper around {@link Number.isSafeInteger} that acts as a type guard.\n */\nfunction isInteger(input: unknown): input is number {\n  return Number.isSafeInteger(input)\n}\n\n/**\n * Creates an integer schema with optional minimum and maximum constraints.\n *\n * Validates that the input is a safe integer (can be exactly represented in JavaScript)\n * and optionally falls within a specified range.\n *\n * @param options - Optional configuration for minimum and maximum values\n * @returns A new {@link IntegerSchema} instance\n *\n * @example\n * ```ts\n * // Basic integer\n * const countSchema = l.integer()\n *\n * // With minimum value\n * const positiveSchema = l.integer({ minimum: 1 })\n *\n * // With range constraints\n * const percentSchema = l.integer({ minimum: 0, maximum: 100 })\n *\n * // Age validation\n * const ageSchema = l.integer({ minimum: 0, maximum: 150 })\n * ```\n */\nexport const integer = /*#__PURE__*/ memoizedOptions(function (\n  options?: IntegerSchemaOptions,\n) {\n  return new IntegerSchema(options)\n})\n"]}

package/dist/schema/intersection.d.ts

@@ -1,4 +1,4 @@
-import { InferInput, InferOutput, Schema, Simplify, ValidationContext } from '../core.js';
+import { type InferInput, type InferOutput, Schema, type Simplify, ValidationContext } from '../core.js';
 import { DictSchema } from './dict.js';
 import { ObjectSchema } from './object.js';
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"intersection.d.ts","sourceRoot":"","sources":["../../src/schema/intersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,WAAW,EACX,MAAM,EACN,QAAQ,EACR,iBAAiB,EAClB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE1C;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,KAAK,GAClD,CAAC,GACD,MAAM,CAAC,GAAG,MAAM,CAAC,SAAS,KAAK,GAE7B,AADA,8CAA8C;AAC9C,CAAC,GAAG,CAAC,GAGL,AAFA,iEAAiE;AAEjE,CAAC,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;CAAE,CAAA;AAEnD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,kBAAkB,CAC7B,KAAK,CAAC,IAAI,SAAS,YAAY,GAAG,GAAG,EACrC,KAAK,CAAC,KAAK,SAAS,UAAU,GAAG,GAAG,CACpC,SAAQ,MAAM,CACd,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,EACxD,QAAQ,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAC3D;IAIG,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI;IAC7B,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK;IAJjC,QAAQ,CAAC,IAAI,EAAG,cAAc,CAAS;IAEvC,YACqB,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,KAAK,EAGhC;IAED,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB,6GAOvD;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,wBAAgB,YAAY,CAC1B,KAAK,CAAC,IAAI,SAAS,YAAY,EAC/B,KAAK,CAAC,KAAK,SAAS,UAAU,EAC9B,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,mCAEzB"}
+{"version":3,"file":"intersection.d.ts","sourceRoot":"","sources":["../../src/schema/intersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,MAAM,EACN,KAAK,QAAQ,EACb,iBAAiB,EAClB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE1C;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,KAAK,GAClD,CAAC,GACD,MAAM,CAAC,GAAG,MAAM,CAAC,SAAS,KAAK,GAE7B,AADA,8CAA8C;AAC9C,CAAC,GAAG,CAAC,GAGL,AAFA,iEAAiE;AAEjE,CAAC,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;CAAE,CAAA;AAEnD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,kBAAkB,CAC7B,KAAK,CAAC,IAAI,SAAS,YAAY,GAAG,GAAG,EACrC,KAAK,CAAC,KAAK,SAAS,UAAU,GAAG,GAAG,CACpC,SAAQ,MAAM,CACd,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,EACxD,QAAQ,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAC3D;IAIG,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI;IAC7B,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK;IAJjC,QAAQ,CAAC,IAAI,EAAG,cAAc,CAAS;IAEvC,YACqB,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,KAAK,EAGhC;IAED,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB,6GAOvD;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,wBAAgB,YAAY,CAC1B,KAAK,CAAC,IAAI,SAAS,YAAY,EAC/B,KAAK,CAAC,KAAK,SAAS,UAAU,EAC9B,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,mCAEzB"}

package/dist/schema/intersection.js

@@ -1,4 +1,6 @@
-import { Schema, } from '../core.js';
+import { Schema, ValidationContext, } from '../core.js';
+import { DictSchema } from './dict.js';
+import { ObjectSchema } from './object.js';
 /**
  * Schema for combining an object schema with a dictionary schema.
  *

package/dist/schema/intersection.js.map

@@ -1 +1 @@
-{"version":3,"file":"intersection.js","sourceRoot":"","sources":["../../src/schema/intersection.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,MAAM,GAGP,MAAM,YAAY,CAAA;AAyBnB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,OAAO,kBAGX,SAAQ,MAGT;IAGC,YACqB,IAAU,EACV,KAAY;QAE/B,KAAK,EAAE,CAAA;QAHY,SAAI,GAAJ,IAAI,CAAM;QACV,UAAK,GAAL,KAAK,CAAO;QAJxB,SAAI,GAAG,cAAuB,CAAA;IAOvC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,MAAM,UAAU,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAA;QACjD,IAAI,CAAC,UAAU,CAAC,OAAO;YAAE,OAAO,UAAU,CAAA;QAE1C,OAAO,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,UAAU,CAAC,KAAK,EAAE,GAAG,EAAE;YACzD,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,aAAa;SACrC,CAAC,CAAA;IACJ,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAwB;AACxB,MAAM,UAAU,YAAY,CAG1B,IAAU,EAAE,KAAY;IACxB,OAAO,IAAI,kBAAkB,CAAc,IAAI,EAAE,KAAK,CAAC,CAAA;AACzD,CAAC","sourcesContent":["import {\n  InferInput,\n  InferOutput,\n  Schema,\n  Simplify,\n  ValidationContext,\n} from '../core.js'\nimport { DictSchema } from './dict.js'\nimport { ObjectSchema } from './object.js'\n\n/**\n * Type utility for computing the intersection of two object types.\n *\n * Allows to more accurately represent the intersection of two object types\n * where both types may share some keys, and one of them uses an index\n * signature.\n *\n * @template A - First object type (typically from ObjectSchema)\n * @template B - Second object type (typically from DictSchema)\n *\n * @see {@link https://www.typescriptlang.org/play/?#code/C4TwDgpgBAglC8UDeUBmB7dAuKByARgIYBOuUAvlAGTJQDaA+lAJYB2UAzsMWwOYC6OVgFcAtvgjEKAKGkATCAGMANiWiL0rLlEI4YsjVuBQA1hBA4uPVrwRQARBnT2Dm7QDdCy4dESE6ZiD8UAD0IVAi4pJQABQcABbowspyUBIORMT2AJSyEAAeYOjExqCQUACSrMCSHErAzJoAPNJQsFAFNaxyHFAASkrFck1WfAA0UMKsJqzoAO6sAHxjrVAAQh35XT39g8TDozYTUzPzSyuLdqtwVKttMYHoqO00j88bnRDdvawQ7pJ3NpQAD860BbRwSHBQLadAA0ix2G91oJ1vDggAfWABcxPF5QOH8aFtci5aRlaAwVDMfIQVKIKo1Yh1RQNZq0Jw4AgkMjkCYoRiIzjcPioyISKTkRayBQqNRQQzaQgAMRpdL01NpclcRignm8EFVWrsKrVchxQVC4XF0SxmSAA Playground link}\n */\nexport type Intersect<A, B> = B[keyof B] extends never\n  ? A\n  : keyof A & keyof B extends never\n    ? // If A and B don't overlap, just return A & B\n      A & B\n    : // Otherwise, properly represent the fact that accessing using an\n      // index signature could return a value from either A or B\n      A & { [K in keyof B]: B[K] | A[keyof A & K] }\n\n/**\n * Schema for combining an object schema with a dictionary schema.\n *\n * Validates that the input matches both the fixed object shape and allows\n * additional properties that match the dictionary schema. Properties defined\n * in the object schema are validated by the object, and remaining properties\n * are validated by the dictionary.\n *\n * @template Left - The ObjectSchema type for fixed properties\n * @template Right - The DictSchema type for additional properties\n *\n * @example\n * ```ts\n * const schema = new IntersectionSchema(\n *   l.object({ name: l.string() }),\n *   l.dict(l.string(), l.integer())\n * )\n * // Validates: { name: 'test', score: 100, count: 5 }\n * ```\n */\nexport class IntersectionSchema<\n  const Left extends ObjectSchema = any,\n  const Right extends DictSchema = any,\n> extends Schema<\n  Simplify<Intersect<InferInput<Left>, InferInput<Right>>>,\n  Simplify<Intersect<InferOutput<Left>, InferOutput<Right>>>\n> {\n  readonly type = 'intersection' as const\n\n  constructor(\n    protected readonly left: Left,\n    protected readonly right: Right,\n  ) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    const leftResult = ctx.validate(input, this.left)\n    if (!leftResult.success) return leftResult\n\n    return this.right.validateInContext(leftResult.value, ctx, {\n      ignoredKeys: this.left.validatorsMap,\n    })\n  }\n}\n\n/**\n * Creates an intersection schema combining fixed object properties with dynamic dictionary properties.\n *\n * Useful for objects that have a known set of properties plus additional\n * arbitrary properties that follow a pattern.\n *\n * @param left - Object schema defining the fixed, known properties\n * @param right - Dictionary schema for validating additional properties\n * @returns A new {@link IntersectionSchema} instance\n *\n * @example\n * ```ts\n * // Object with fixed and dynamic properties\n * const configSchema = l.intersection(\n *   l.object({\n *     version: l.integer(),\n *     name: l.string(),\n *   }),\n *   l.dict(l.string(), l.string()) // Additional string properties\n * )\n *\n * configSchema.parse({\n *   version: 1,\n *   name: 'my-config',\n *   customField: 'value',\n *   anotherField: 'another',\n * })\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function intersection<\n  const Left extends ObjectSchema,\n  const Right extends DictSchema,\n>(left: Left, right: Right) {\n  return new IntersectionSchema<Left, Right>(left, right)\n}\n"]}
+{"version":3,"file":"intersection.js","sourceRoot":"","sources":["../../src/schema/intersection.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,MAAM,EAEN,iBAAiB,GAClB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAuB1C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,OAAO,kBAGX,SAAQ,MAGT;IAGC,YACqB,IAAU,EACV,KAAY;QAE/B,KAAK,EAAE,CAAA;QAHY,SAAI,GAAJ,IAAI,CAAM;QACV,UAAK,GAAL,KAAK,CAAO;QAJxB,SAAI,GAAG,cAAuB,CAAA;IAOvC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,MAAM,UAAU,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAA;QACjD,IAAI,CAAC,UAAU,CAAC,OAAO;YAAE,OAAO,UAAU,CAAA;QAE1C,OAAO,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,UAAU,CAAC,KAAK,EAAE,GAAG,EAAE;YACzD,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,aAAa;SACrC,CAAC,CAAA;IACJ,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAwB;AACxB,MAAM,UAAU,YAAY,CAG1B,IAAU,EAAE,KAAY;IACxB,OAAO,IAAI,kBAAkB,CAAc,IAAI,EAAE,KAAK,CAAC,CAAA;AACzD,CAAC","sourcesContent":["import {\n  type InferInput,\n  type InferOutput,\n  Schema,\n  type Simplify,\n  ValidationContext,\n} from '../core.js'\nimport { DictSchema } from './dict.js'\nimport { ObjectSchema } from './object.js'\n\n/**\n * Type utility for computing the intersection of two object types.\n *\n * Allows to more accurately represent the intersection of two object types\n * where both types may share some keys, and one of them uses an index\n * signature.\n *\n * @template A - First object type (typically from ObjectSchema)\n * @template B - Second object type (typically from DictSchema)\n *\n * @see {@link https://www.typescriptlang.org/play/?#code/C4TwDgpgBAglC8UDeUBmB7dAuKByARgIYBOuUAvlAGTJQDaA+lAJYB2UAzsMWwOYC6OVgFcAtvgjEKAKGkATCAGMANiWiL0rLlEI4YsjVuBQA1hBA4uPVrwRQARBnT2Dm7QDdCy4dESE6ZiD8UAD0IVAi4pJQABQcABbowspyUBIORMT2AJSyEAAeYOjExqCQUACSrMCSHErAzJoAPNJQsFAFNaxyHFAASkrFck1WfAA0UMKsJqzoAO6sAHxjrVAAQh35XT39g8TDozYTUzPzSyuLdqtwVKttMYHoqO00j88bnRDdvawQ7pJ3NpQAD860BbRwSHBQLadAA0ix2G91oJ1vDggAfWABcxPF5QOH8aFtci5aRlaAwVDMfIQVKIKo1Yh1RQNZq0Jw4AgkMjkCYoRiIzjcPioyISKTkRayBQqNRQQzaQgAMRpdL01NpclcRignm8EFVWrsKrVchxQVC4XF0SxmSAA Playground link}\n */\nexport type Intersect<A, B> = B[keyof B] extends never\n  ? A\n  : keyof A & keyof B extends never\n    ? // If A and B don't overlap, just return A & B\n      A & B\n    : // Otherwise, properly represent the fact that accessing using an\n      // index signature could return a value from either A or B\n      A & { [K in keyof B]: B[K] | A[keyof A & K] }\n\n/**\n * Schema for combining an object schema with a dictionary schema.\n *\n * Validates that the input matches both the fixed object shape and allows\n * additional properties that match the dictionary schema. Properties defined\n * in the object schema are validated by the object, and remaining properties\n * are validated by the dictionary.\n *\n * @template Left - The ObjectSchema type for fixed properties\n * @template Right - The DictSchema type for additional properties\n *\n * @example\n * ```ts\n * const schema = new IntersectionSchema(\n *   l.object({ name: l.string() }),\n *   l.dict(l.string(), l.integer())\n * )\n * // Validates: { name: 'test', score: 100, count: 5 }\n * ```\n */\nexport class IntersectionSchema<\n  const Left extends ObjectSchema = any,\n  const Right extends DictSchema = any,\n> extends Schema<\n  Simplify<Intersect<InferInput<Left>, InferInput<Right>>>,\n  Simplify<Intersect<InferOutput<Left>, InferOutput<Right>>>\n> {\n  readonly type = 'intersection' as const\n\n  constructor(\n    protected readonly left: Left,\n    protected readonly right: Right,\n  ) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    const leftResult = ctx.validate(input, this.left)\n    if (!leftResult.success) return leftResult\n\n    return this.right.validateInContext(leftResult.value, ctx, {\n      ignoredKeys: this.left.validatorsMap,\n    })\n  }\n}\n\n/**\n * Creates an intersection schema combining fixed object properties with dynamic dictionary properties.\n *\n * Useful for objects that have a known set of properties plus additional\n * arbitrary properties that follow a pattern.\n *\n * @param left - Object schema defining the fixed, known properties\n * @param right - Dictionary schema for validating additional properties\n * @returns A new {@link IntersectionSchema} instance\n *\n * @example\n * ```ts\n * // Object with fixed and dynamic properties\n * const configSchema = l.intersection(\n *   l.object({\n *     version: l.integer(),\n *     name: l.string(),\n *   }),\n *   l.dict(l.string(), l.string()) // Additional string properties\n * )\n *\n * configSchema.parse({\n *   version: 1,\n *   name: 'my-config',\n *   customField: 'value',\n *   anotherField: 'another',\n * })\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function intersection<\n  const Left extends ObjectSchema,\n  const Right extends DictSchema,\n>(left: Left, right: Right) {\n  return new IntersectionSchema<Left, Right>(left, right)\n}\n"]}

package/dist/schema/lex-map.d.ts

@@ -1,4 +1,4 @@
-import { LexMap } from '@atproto/lex-data';
+import { type LexMap } from '@atproto/lex-data';
 import { Schema, ValidationContext } from '../core.js';
 export type { LexMap };
 /**

package/dist/schema/lex-map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lex-map.d.ts","sourceRoot":"","sources":["../../src/schema/lex-map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAiB,MAAM,mBAAmB,CAAA;AACzD,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAMtD,YAAY,EAAE,MAAM,EAAE,CAAA;AAEtB;;;;;;GAMG;AACH,qBAAa,YAAa,SAAQ,MAAM,CAAC,MAAM,CAAC;IAC9C,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAS;IAEjC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB,6GAgBvD;CACF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,oBAEjB,CAAA;AAEF,6CAA6C;AAC7C,eAAO,MAAM,aAAa,oBAAS,CAAA"}
+{"version":3,"file":"lex-map.d.ts","sourceRoot":"","sources":["../../src/schema/lex-map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAiB,MAAM,mBAAmB,CAAA;AAC9D,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAMtD,YAAY,EAAE,MAAM,EAAE,CAAA;AAEtB;;;;;;GAMG;AACH,qBAAa,YAAa,SAAQ,MAAM,CAAC,MAAM,CAAC;IAC9C,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAS;IAEjC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB,6GAgBvD;CACF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,oBAEjB,CAAA;AAEF,6CAA6C;AAC7C,eAAO,MAAM,aAAa,oBAAS,CAAA"}

package/dist/schema/lex-map.js

@@ -1,5 +1,5 @@
 import { isPlainObject } from '@atproto/lex-data';
-import { Schema } from '../core.js';
+import { Schema, ValidationContext } from '../core.js';
 import { memoizedOptions } from '../util/memoize.js';
 import { lexValue } from './lex-value.js';
 const propertyValueSchema = /*#__PURE__*/ lexValue();

package/dist/schema/lex-map.js.map

@@ -1 +1 @@
-{"version":3,"file":"lex-map.js","sourceRoot":"","sources":["../../src/schema/lex-map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACzD,OAAO,EAAE,MAAM,EAAqB,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAEzC,MAAM,mBAAmB,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAA;AAIpD;;;;;;GAMG;AACH,MAAM,OAAO,YAAa,SAAQ,MAAc;IAAhD;;QACW,SAAI,GAAG,QAAiB,CAAA;IAmBnC,CAAC;IAjBC,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;QACjD,CAAC;QAED,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACrC,oEAAoE;YACpE,qEAAqE;YACrE,wEAAwE;YACxE,0EAA0E;YAC1E,SAAS;YACT,MAAM,CAAC,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,mBAAmB,CAAC,CAAA,CAAC,sCAAsC;YACnG,IAAI,CAAC,CAAC,CAAC,OAAO;gBAAE,OAAO,CAAC,CAAA;QAC1B,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,aAAa,CAAC,eAAe,CAAC;IAClD,OAAO,IAAI,YAAY,EAAE,CAAA;AAC3B,CAAC,CAAC,CAAA;AAEF,6CAA6C;AAC7C,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAA","sourcesContent":["import { LexMap, isPlainObject } from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\nimport { lexValue } from './lex-value.js'\n\nconst propertyValueSchema = /*#__PURE__*/ lexValue()\n\nexport type { LexMap }\n\n/**\n * AT Protocol lexicon schema definitions with \"type\": \"unknown\" are represented\n * as plain objects with string keys and values that are valid AT Protocol data\n * types (string, integer, boolean, null, bytes, cid, array, or object). This\n * type alias corresponds to the expected structure of such \"unknown\" schema\n * values.\n */\nexport class LexMapSchema extends Schema<LexMap> {\n  readonly type = 'lexMap' as const\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isPlainObject(input)) {\n      return ctx.issueUnexpectedType(input, 'object')\n    }\n\n    for (const key of Object.keys(input)) {\n      // @NOTE We use a lexValue() schema here to recursively validate all\n      // nested values, which ensures that the error reporting includes the\n      // correct path and type information for any invalid nested values. This\n      // allows for more informative error descriptions than a simple \"isLexMap\"\n      // check.\n      const r = ctx.validateChild(input, key, propertyValueSchema) // recursively validate all properties\n      if (!r.success) return r\n    }\n\n    return ctx.success(input)\n  }\n}\n\n/**\n * Creates a schema that accepts any plain object with string keys and values\n * that are valid AT Protocol data types (string, integer, boolean, null, bytes,\n * cid, array, or object).\n *\n * @see {@link LexMap} from `@atproto/lex-data` for the type definition of valid AT Protocol data types\n * @returns A new {@link LexMapSchema} instance\n *\n * @example\n * ```ts\n * // Accept any object shape\n * const schema = l.lexMap()\n *\n * schema.validate({ any: 'props' })    // success\n * schema.validate([1, 2, 3])           // fails - only plain objects are accepted\n * schema.validate({ foo: new Date() }) // fails - Date is not a valid LexValue\n * schema.validate({ foo: 1.2 })        // fails - 1.2 is not a valid LexValue (not an integer)\n * ```\n */\nexport const lexMap = /*#__PURE__*/ memoizedOptions(function () {\n  return new LexMapSchema()\n})\n\n/** @deprecated Use {@link lexMap} instead */\nexport const unknownObject = lexMap\n"]}
+{"version":3,"file":"lex-map.js","sourceRoot":"","sources":["../../src/schema/lex-map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAC9D,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAEzC,MAAM,mBAAmB,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAA;AAIpD;;;;;;GAMG;AACH,MAAM,OAAO,YAAa,SAAQ,MAAc;IAAhD;;QACW,SAAI,GAAG,QAAiB,CAAA;IAmBnC,CAAC;IAjBC,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;QACjD,CAAC;QAED,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACrC,oEAAoE;YACpE,qEAAqE;YACrE,wEAAwE;YACxE,0EAA0E;YAC1E,SAAS;YACT,MAAM,CAAC,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,mBAAmB,CAAC,CAAA,CAAC,sCAAsC;YACnG,IAAI,CAAC,CAAC,CAAC,OAAO;gBAAE,OAAO,CAAC,CAAA;QAC1B,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,aAAa,CAAC,eAAe,CAAC;IAClD,OAAO,IAAI,YAAY,EAAE,CAAA;AAC3B,CAAC,CAAC,CAAA;AAEF,6CAA6C;AAC7C,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAA","sourcesContent":["import { type LexMap, isPlainObject } from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\nimport { lexValue } from './lex-value.js'\n\nconst propertyValueSchema = /*#__PURE__*/ lexValue()\n\nexport type { LexMap }\n\n/**\n * AT Protocol lexicon schema definitions with \"type\": \"unknown\" are represented\n * as plain objects with string keys and values that are valid AT Protocol data\n * types (string, integer, boolean, null, bytes, cid, array, or object). This\n * type alias corresponds to the expected structure of such \"unknown\" schema\n * values.\n */\nexport class LexMapSchema extends Schema<LexMap> {\n  readonly type = 'lexMap' as const\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isPlainObject(input)) {\n      return ctx.issueUnexpectedType(input, 'object')\n    }\n\n    for (const key of Object.keys(input)) {\n      // @NOTE We use a lexValue() schema here to recursively validate all\n      // nested values, which ensures that the error reporting includes the\n      // correct path and type information for any invalid nested values. This\n      // allows for more informative error descriptions than a simple \"isLexMap\"\n      // check.\n      const r = ctx.validateChild(input, key, propertyValueSchema) // recursively validate all properties\n      if (!r.success) return r\n    }\n\n    return ctx.success(input)\n  }\n}\n\n/**\n * Creates a schema that accepts any plain object with string keys and values\n * that are valid AT Protocol data types (string, integer, boolean, null, bytes,\n * cid, array, or object).\n *\n * @see {@link LexMap} from `@atproto/lex-data` for the type definition of valid AT Protocol data types\n * @returns A new {@link LexMapSchema} instance\n *\n * @example\n * ```ts\n * // Accept any object shape\n * const schema = l.lexMap()\n *\n * schema.validate({ any: 'props' })    // success\n * schema.validate([1, 2, 3])           // fails - only plain objects are accepted\n * schema.validate({ foo: new Date() }) // fails - Date is not a valid LexValue\n * schema.validate({ foo: 1.2 })        // fails - 1.2 is not a valid LexValue (not an integer)\n * ```\n */\nexport const lexMap = /*#__PURE__*/ memoizedOptions(function () {\n  return new LexMapSchema()\n})\n\n/** @deprecated Use {@link lexMap} instead */\nexport const unknownObject = lexMap\n"]}

package/dist/schema/lex-value.d.ts

@@ -1,4 +1,4 @@
-import { LexValue } from '@atproto/lex-data';
+import { type LexValue } from '@atproto/lex-data';
 import { Schema, ValidationContext } from '../core.js';
 export type { LexValue };
 /**

package/dist/schema/lex-value.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lex-value.d.ts","sourceRoot":"","sources":["../../src/schema/lex-value.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAA8B,MAAM,mBAAmB,CAAA;AACxE,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGtD,YAAY,EAAE,QAAQ,EAAE,CAAA;AAexB;;;GAGG;AACH,qBAAa,cAAe,SAAQ,MAAM,CAAC,QAAQ,CAAC;IAClD,QAAQ,CAAC,IAAI,EAAG,UAAU,CAAS;IAEnC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB,6JAgCvD;CACF;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,QAAQ,sBAEnB,CAAA"}
+{"version":3,"file":"lex-value.d.ts","sourceRoot":"","sources":["../../src/schema/lex-value.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAA8B,MAAM,mBAAmB,CAAA;AAC7E,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGtD,YAAY,EAAE,QAAQ,EAAE,CAAA;AAexB;;;GAGG;AACH,qBAAa,cAAe,SAAQ,MAAM,CAAC,QAAQ,CAAC;IAClD,QAAQ,CAAC,IAAI,EAAG,UAAU,CAAS;IAEnC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB,6JAgCvD;CACF;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,QAAQ,sBAEnB,CAAA"}

package/dist/schema/lex-value.js

@@ -1,5 +1,5 @@
 import { isLexScalar, isPlainObject } from '@atproto/lex-data';
-import { Schema } from '../core.js';
+import { Schema, ValidationContext } from '../core.js';
 import { memoizedOptions } from '../util/memoize.js';
 const EXPECTED_TYPES = Object.freeze([
     // Scalar types

package/dist/schema/lex-value.js.map

@@ -1 +1 @@
-{"version":3,"file":"lex-value.js","sourceRoot":"","sources":["../../src/schema/lex-value.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,WAAW,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACxE,OAAO,EAAE,MAAM,EAAqB,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAIpD,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC;IACnC,eAAe;IACf,MAAM;IACN,SAAS;IACT,SAAS;IACT,QAAQ;IACR,KAAK;IACL,OAAO;IACP,kBAAkB;IAClB,OAAO;IACP,QAAQ;CACA,CAAC,CAAA;AAEX;;;GAGG;AACH,MAAM,OAAO,cAAe,SAAQ,MAAgB;IAApD;;QACW,SAAI,GAAG,UAAmB,CAAA;IAmCrC,CAAC;IAjCC,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,wEAAwE;QACxE,mEAAmE;QACnE,0EAA0E;QAC1E,6BAA6B;QAE7B,oEAAoE;QACpE,qBAAqB;QACrB,4EAA4E;QAC5E,0EAA0E;QAC1E,4EAA4E;QAC5E,wEAAwE;QACxE,gCAAgC;QAChC,4EAA4E;QAC5E,uEAAuE;QACvE,4EAA4E;QAC5E,wBAAwB;QACxB,IAAI,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;YACzB,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;gBACrC,MAAM,CAAC,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,CAAA,CAAC,sCAAsC;gBACpF,IAAI,CAAC,CAAC,CAAC,OAAO;oBAAE,OAAO,CAAC,CAAA;YAC1B,CAAC;QACH,CAAC;aAAM,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACtC,MAAM,CAAC,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,CAAA,CAAC,uCAAuC;gBACnF,IAAI,CAAC,CAAC,CAAC,OAAO;oBAAE,OAAO,CAAC,CAAA;YAC1B,CAAC;QACH,CAAC;aAAM,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;YAC/B,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,cAAc,CAAC,CAAA;QACpD,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,aAAa,CAAC,eAAe,CAAC;IACpD,OAAO,IAAI,cAAc,EAAE,CAAA;AAC7B,CAAC,CAAC,CAAA","sourcesContent":["import { LexValue, isLexScalar, isPlainObject } from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\nexport type { LexValue }\n\nconst EXPECTED_TYPES = Object.freeze([\n  // Scalar types\n  'null',\n  'boolean',\n  'integer',\n  'string',\n  'cid',\n  'bytes',\n  // Recursive types\n  'array',\n  'object',\n] as const)\n\n/**\n * AT Protocol lexicon values are any valid AT Protocol data types: string,\n * integer, boolean, null, bytes, cid, array, or object.\n */\nexport class LexValueSchema extends Schema<LexValue> {\n  readonly type = 'lexValue' as const\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    // @NOTE We are *not* using \"isLexValue\" here to allow for more specific\n    // error messages about the path and type of the invalid value. The\n    // \"isLexValue\" check is effectively performed by the recursive validation\n    // of child properties below.\n\n    // @NOTE There are two limitations to the fact that we are not using\n    // \"isLexValue\" here:\n    // 1. We cannot detect circular references in objects or arrays, which would\n    //    cause infinite recursion. However, circular references are not valid\n    //    AT Protocol data types, so this is not a concern for valid input. This\n    //    could easily be addressed in the \"validateChild\" method by keeping\n    //    track of \"parent\" objects.\n    // 2. We are limited in the recursion depth we can validate due to potential\n    //    recursion depth limits in JavaScript. However, this is also not a\n    //    concern for most valid input, as extremely deep nesting is unlikely in\n    //    typical use cases.\n    if (isPlainObject(input)) {\n      for (const key of Object.keys(input)) {\n        const r = ctx.validateChild(input, key, this) // recursively validate all properties\n        if (!r.success) return r\n      }\n    } else if (Array.isArray(input)) {\n      for (let i = 0; i < input.length; i++) {\n        const r = ctx.validateChild(input, i, this) // recursively validate all array items\n        if (!r.success) return r\n      }\n    } else if (!isLexScalar(input)) {\n      return ctx.issueInvalidType(input, EXPECTED_TYPES)\n    }\n\n    return ctx.success(input)\n  }\n}\n\n/**\n * Creates a schema that accepts any valid AT Protocol data type: string,\n * integer, boolean, null, bytes, cid, array, or plain object. Arrays and\n * objects are recursively validated to ensure all nested values are also valid\n * AT Protocol data types.\n *\n * @see {@link LexValue} from `@atproto/lex-data` for the type definition of valid AT Protocol data types\n * @returns A new {@link LexValueSchema} instance\n *\n * @example\n * ```ts\n * const schema = l.lexValue()\n *\n * schema.validate('hello')              // success\n * schema.validate(42)                   // success\n * schema.validate(null)                 // success\n * schema.validate([1, 'two', null])     // success\n * schema.validate({ any: 'props' })     // success\n * schema.validate(new Date())           // fails - Date is not a valid LexValue\n * schema.validate({ foo: 1.2 })         // fails - 1.2 is not a valid LexValue (not an integer)\n * ```\n */\nexport const lexValue = /*#__PURE__*/ memoizedOptions(function () {\n  return new LexValueSchema()\n})\n"]}
+{"version":3,"file":"lex-value.js","sourceRoot":"","sources":["../../src/schema/lex-value.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,WAAW,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAC7E,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAIpD,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC;IACnC,eAAe;IACf,MAAM;IACN,SAAS;IACT,SAAS;IACT,QAAQ;IACR,KAAK;IACL,OAAO;IACP,kBAAkB;IAClB,OAAO;IACP,QAAQ;CACA,CAAC,CAAA;AAEX;;;GAGG;AACH,MAAM,OAAO,cAAe,SAAQ,MAAgB;IAApD;;QACW,SAAI,GAAG,UAAmB,CAAA;IAmCrC,CAAC;IAjCC,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,wEAAwE;QACxE,mEAAmE;QACnE,0EAA0E;QAC1E,6BAA6B;QAE7B,oEAAoE;QACpE,qBAAqB;QACrB,4EAA4E;QAC5E,0EAA0E;QAC1E,4EAA4E;QAC5E,wEAAwE;QACxE,gCAAgC;QAChC,4EAA4E;QAC5E,uEAAuE;QACvE,4EAA4E;QAC5E,wBAAwB;QACxB,IAAI,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;YACzB,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;gBACrC,MAAM,CAAC,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,CAAA,CAAC,sCAAsC;gBACpF,IAAI,CAAC,CAAC,CAAC,OAAO;oBAAE,OAAO,CAAC,CAAA;YAC1B,CAAC;QACH,CAAC;aAAM,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACtC,MAAM,CAAC,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,CAAA,CAAC,uCAAuC;gBACnF,IAAI,CAAC,CAAC,CAAC,OAAO;oBAAE,OAAO,CAAC,CAAA;YAC1B,CAAC;QACH,CAAC;aAAM,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;YAC/B,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,cAAc,CAAC,CAAA;QACpD,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,aAAa,CAAC,eAAe,CAAC;IACpD,OAAO,IAAI,cAAc,EAAE,CAAA;AAC7B,CAAC,CAAC,CAAA","sourcesContent":["import { type LexValue, isLexScalar, isPlainObject } from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\nexport type { LexValue }\n\nconst EXPECTED_TYPES = Object.freeze([\n  // Scalar types\n  'null',\n  'boolean',\n  'integer',\n  'string',\n  'cid',\n  'bytes',\n  // Recursive types\n  'array',\n  'object',\n] as const)\n\n/**\n * AT Protocol lexicon values are any valid AT Protocol data types: string,\n * integer, boolean, null, bytes, cid, array, or object.\n */\nexport class LexValueSchema extends Schema<LexValue> {\n  readonly type = 'lexValue' as const\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    // @NOTE We are *not* using \"isLexValue\" here to allow for more specific\n    // error messages about the path and type of the invalid value. The\n    // \"isLexValue\" check is effectively performed by the recursive validation\n    // of child properties below.\n\n    // @NOTE There are two limitations to the fact that we are not using\n    // \"isLexValue\" here:\n    // 1. We cannot detect circular references in objects or arrays, which would\n    //    cause infinite recursion. However, circular references are not valid\n    //    AT Protocol data types, so this is not a concern for valid input. This\n    //    could easily be addressed in the \"validateChild\" method by keeping\n    //    track of \"parent\" objects.\n    // 2. We are limited in the recursion depth we can validate due to potential\n    //    recursion depth limits in JavaScript. However, this is also not a\n    //    concern for most valid input, as extremely deep nesting is unlikely in\n    //    typical use cases.\n    if (isPlainObject(input)) {\n      for (const key of Object.keys(input)) {\n        const r = ctx.validateChild(input, key, this) // recursively validate all properties\n        if (!r.success) return r\n      }\n    } else if (Array.isArray(input)) {\n      for (let i = 0; i < input.length; i++) {\n        const r = ctx.validateChild(input, i, this) // recursively validate all array items\n        if (!r.success) return r\n      }\n    } else if (!isLexScalar(input)) {\n      return ctx.issueInvalidType(input, EXPECTED_TYPES)\n    }\n\n    return ctx.success(input)\n  }\n}\n\n/**\n * Creates a schema that accepts any valid AT Protocol data type: string,\n * integer, boolean, null, bytes, cid, array, or plain object. Arrays and\n * objects are recursively validated to ensure all nested values are also valid\n * AT Protocol data types.\n *\n * @see {@link LexValue} from `@atproto/lex-data` for the type definition of valid AT Protocol data types\n * @returns A new {@link LexValueSchema} instance\n *\n * @example\n * ```ts\n * const schema = l.lexValue()\n *\n * schema.validate('hello')              // success\n * schema.validate(42)                   // success\n * schema.validate(null)                 // success\n * schema.validate([1, 'two', null])     // success\n * schema.validate({ any: 'props' })     // success\n * schema.validate(new Date())           // fails - Date is not a valid LexValue\n * schema.validate({ foo: 1.2 })         // fails - 1.2 is not a valid LexValue (not an integer)\n * ```\n */\nexport const lexValue = /*#__PURE__*/ memoizedOptions(function () {\n  return new LexValueSchema()\n})\n"]}

package/dist/schema/literal.js

@@ -1,4 +1,4 @@
-import { Schema } from '../core.js';
+import { Schema, ValidationContext } from '../core.js';
 /**
  * Schema that only accepts a specific literal value.
  *

package/dist/schema/literal.js.map

@@ -1 +1 @@
-{"version":3,"file":"literal.js","sourceRoot":"","sources":["../../src/schema/literal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAqB,MAAM,YAAY,CAAA;AAEtD;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,aAEX,SAAQ,MAAc;IAGtB,YAAqB,KAAa;QAChC,KAAK,EAAE,CAAA;QADY,UAAK,GAAL,KAAK,CAAQ;QAFzB,SAAI,GAAG,SAAkB,CAAA;IAIlC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC;YACzB,OAAO,GAAG,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;QACnD,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IAChC,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAwB;AACxB,MAAM,UAAU,OAAO,CACrB,KAAQ;IAER,OAAO,IAAI,aAAa,CAAI,KAAK,CAAC,CAAA;AACpC,CAAC","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\n\n/**\n * Schema that only accepts a specific literal value.\n *\n * Validates that the input is exactly equal to the specified value using\n * strict equality (===).\n *\n * @template TValue - The literal type (null, string, number, or boolean)\n *\n * @example\n * ```ts\n * const schema = new LiteralSchema('admin')\n * schema.validate('admin') // success\n * schema.validate('user')  // fails\n * ```\n */\nexport class LiteralSchema<\n  const TValue extends null | string | number | boolean,\n> extends Schema<TValue> {\n  readonly type = 'literal' as const\n\n  constructor(readonly value: TValue) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (input !== this.value) {\n      return ctx.issueInvalidValue(input, [this.value])\n    }\n\n    return ctx.success(this.value)\n  }\n}\n\n/**\n * Creates a literal schema that only accepts the exact specified value.\n *\n * Useful for discriminator fields in unions, constant values, or type narrowing.\n *\n * @param value - The exact value that must be matched\n * @returns A new {@link LiteralSchema} instance\n *\n * @example\n * ```ts\n * // String literal\n * const roleSchema = l.literal('admin')\n *\n * // Number literal\n * const versionSchema = l.literal(1)\n *\n * // Boolean literal\n * const enabledSchema = l.literal(true)\n *\n * // Null literal\n * const nullSchema = l.literal(null)\n *\n * // In discriminated unions\n * const actionSchema = l.discriminatedUnion('type', [\n *   l.object({ type: l.literal('create'), data: l.unknown() }),\n *   l.object({ type: l.literal('delete'), id: l.string() }),\n * ])\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function literal<const V extends null | string | number | boolean>(\n  value: V,\n) {\n  return new LiteralSchema<V>(value)\n}\n"]}
+{"version":3,"file":"literal.js","sourceRoot":"","sources":["../../src/schema/literal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEtD;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,aAEX,SAAQ,MAAc;IAGtB,YAAqB,KAAa;QAChC,KAAK,EAAE,CAAA;QADY,UAAK,GAAL,KAAK,CAAQ;QAFzB,SAAI,GAAG,SAAkB,CAAA;IAIlC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC;YACzB,OAAO,GAAG,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;QACnD,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IAChC,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAwB;AACxB,MAAM,UAAU,OAAO,CACrB,KAAQ;IAER,OAAO,IAAI,aAAa,CAAI,KAAK,CAAC,CAAA;AACpC,CAAC","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\n\n/**\n * Schema that only accepts a specific literal value.\n *\n * Validates that the input is exactly equal to the specified value using\n * strict equality (===).\n *\n * @template TValue - The literal type (null, string, number, or boolean)\n *\n * @example\n * ```ts\n * const schema = new LiteralSchema('admin')\n * schema.validate('admin') // success\n * schema.validate('user')  // fails\n * ```\n */\nexport class LiteralSchema<\n  const TValue extends null | string | number | boolean,\n> extends Schema<TValue> {\n  readonly type = 'literal' as const\n\n  constructor(readonly value: TValue) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (input !== this.value) {\n      return ctx.issueInvalidValue(input, [this.value])\n    }\n\n    return ctx.success(this.value)\n  }\n}\n\n/**\n * Creates a literal schema that only accepts the exact specified value.\n *\n * Useful for discriminator fields in unions, constant values, or type narrowing.\n *\n * @param value - The exact value that must be matched\n * @returns A new {@link LiteralSchema} instance\n *\n * @example\n * ```ts\n * // String literal\n * const roleSchema = l.literal('admin')\n *\n * // Number literal\n * const versionSchema = l.literal(1)\n *\n * // Boolean literal\n * const enabledSchema = l.literal(true)\n *\n * // Null literal\n * const nullSchema = l.literal(null)\n *\n * // In discriminated unions\n * const actionSchema = l.discriminatedUnion('type', [\n *   l.object({ type: l.literal('create'), data: l.unknown() }),\n *   l.object({ type: l.literal('delete'), id: l.string() }),\n * ])\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function literal<const V extends null | string | number | boolean>(\n  value: V,\n) {\n  return new LiteralSchema<V>(value)\n}\n"]}

package/dist/schema/never.js

@@ -1,4 +1,4 @@
-import { Schema } from '../core.js';
+import { Schema, ValidationContext } from '../core.js';
 import { memoizedOptions } from '../util/memoize.js';
 /**
  * Schema that always fails validation.

package/dist/schema/never.js.map

@@ -1 +1 @@
-{"version":3,"file":"never.js","sourceRoot":"","sources":["../../src/schema/never.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAqB,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAEpD;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,WAAY,SAAQ,MAAa;IAA9C;;QACW,SAAI,GAAG,OAAgB,CAAA;IAKlC,CAAC;IAHC,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;IAChD,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,aAAa,CAAC,eAAe,CAAC;IACjD,OAAO,IAAI,WAAW,EAAE,CAAA;AAC1B,CAAC,CAAC,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Schema that always fails validation.\n *\n * Represents an impossible type - no value can satisfy this schema.\n * Useful for exhaustiveness checking or marking impossible branches.\n *\n * @example\n * ```ts\n * const schema = new NeverSchema()\n * schema.validate(anything) // always fails\n * ```\n */\nexport class NeverSchema extends Schema<never> {\n  readonly type = 'never' as const\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    return ctx.issueUnexpectedType(input, 'never')\n  }\n}\n\n/**\n * Creates a never schema that always fails validation.\n *\n * Useful for exhaustiveness checking in TypeScript or marking impossible\n * code paths.\n *\n * @returns A new {@link NeverSchema} instance\n *\n * @example\n * ```ts\n * // Exhaustiveness checking\n * type Status = 'active' | 'inactive'\n *\n * function handleStatus(status: Status) {\n *   switch (status) {\n *     case 'active': return 'Active'\n *     case 'inactive': return 'Inactive'\n *     default:\n *       // TypeScript will error if we miss a case\n *       l.never().parse(status)\n *   }\n * }\n *\n * // In impossible union branches\n * const schema = l.object({\n *   type: l.literal('fixed'),\n *   dynamic: l.never(), // This property can never exist\n * })\n * ```\n */\nexport const never = /*#__PURE__*/ memoizedOptions(function () {\n  return new NeverSchema()\n})\n"]}
+{"version":3,"file":"never.js","sourceRoot":"","sources":["../../src/schema/never.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAEpD;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,WAAY,SAAQ,MAAa;IAA9C;;QACW,SAAI,GAAG,OAAgB,CAAA;IAKlC,CAAC;IAHC,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;IAChD,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,aAAa,CAAC,eAAe,CAAC;IACjD,OAAO,IAAI,WAAW,EAAE,CAAA;AAC1B,CAAC,CAAC,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Schema that always fails validation.\n *\n * Represents an impossible type - no value can satisfy this schema.\n * Useful for exhaustiveness checking or marking impossible branches.\n *\n * @example\n * ```ts\n * const schema = new NeverSchema()\n * schema.validate(anything) // always fails\n * ```\n */\nexport class NeverSchema extends Schema<never> {\n  readonly type = 'never' as const\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    return ctx.issueUnexpectedType(input, 'never')\n  }\n}\n\n/**\n * Creates a never schema that always fails validation.\n *\n * Useful for exhaustiveness checking in TypeScript or marking impossible\n * code paths.\n *\n * @returns A new {@link NeverSchema} instance\n *\n * @example\n * ```ts\n * // Exhaustiveness checking\n * type Status = 'active' | 'inactive'\n *\n * function handleStatus(status: Status) {\n *   switch (status) {\n *     case 'active': return 'Active'\n *     case 'inactive': return 'Inactive'\n *     default:\n *       // TypeScript will error if we miss a case\n *       l.never().parse(status)\n *   }\n * }\n *\n * // In impossible union branches\n * const schema = l.object({\n *   type: l.literal('fixed'),\n *   dynamic: l.never(), // This property can never exist\n * })\n * ```\n */\nexport const never = /*#__PURE__*/ memoizedOptions(function () {\n  return new NeverSchema()\n})\n"]}

package/dist/schema/null.js

@@ -1,4 +1,4 @@
-import { Schema } from '../core.js';
+import { Schema, ValidationContext } from '../core.js';
 import { memoizedOptions } from '../util/memoize.js';
 /**
  * Schema for validating null values.

package/dist/schema/null.js.map

@@ -1 +1 @@
-{"version":3,"file":"null.js","sourceRoot":"","sources":["../../src/schema/null.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAqB,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAEpD;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,UAAW,SAAQ,MAAY;IAA5C;;QACW,SAAI,GAAG,MAAe,CAAA;IASjC,CAAC;IAPC,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;QAC/C,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,CAAC;CACF;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,aAAa,CAAC,eAAe,CAAC;IACtD,OAAO,IAAI,UAAU,EAAE,CAAA;AACzB,CAAC,CAAC,CAAA;AAEF,OAAO,EAAE,UAAU,IAAI,IAAI,EAAE,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Schema for validating null values.\n *\n * Only accepts the JavaScript `null` value. Rejects `undefined` and all\n * other values.\n *\n * @example\n * ```ts\n * const schema = new NullSchema()\n * schema.validate(null)      // success\n * schema.validate(undefined) // fails\n * ```\n */\nexport class NullSchema extends Schema<null> {\n  readonly type = 'null' as const\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (input !== null) {\n      return ctx.issueUnexpectedType(input, 'null')\n    }\n\n    return ctx.success(null)\n  }\n}\n\n/**\n * Creates a null schema that only accepts the null value.\n *\n * Useful for explicitly representing null in union types or optional fields.\n *\n * @returns A new {@link NullSchema} instance\n *\n * @example\n * ```ts\n * // Explicit null\n * const nullOnlySchema = l.null()\n *\n * // Nullable string (string or null)\n * const nullableStringSchema = l.union([l.string(), l.null()])\n * ```\n */\nexport const nullSchema = /*#__PURE__*/ memoizedOptions(function () {\n  return new NullSchema()\n})\n\nexport { nullSchema as null }\n"]}
+{"version":3,"file":"null.js","sourceRoot":"","sources":["../../src/schema/null.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAEpD;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,UAAW,SAAQ,MAAY;IAA5C;;QACW,SAAI,GAAG,MAAe,CAAA;IASjC,CAAC;IAPC,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;QAC/C,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,CAAC;CACF;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,aAAa,CAAC,eAAe,CAAC;IACtD,OAAO,IAAI,UAAU,EAAE,CAAA;AACzB,CAAC,CAAC,CAAA;AAEF,OAAO,EAAE,UAAU,IAAI,IAAI,EAAE,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Schema for validating null values.\n *\n * Only accepts the JavaScript `null` value. Rejects `undefined` and all\n * other values.\n *\n * @example\n * ```ts\n * const schema = new NullSchema()\n * schema.validate(null)      // success\n * schema.validate(undefined) // fails\n * ```\n */\nexport class NullSchema extends Schema<null> {\n  readonly type = 'null' as const\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (input !== null) {\n      return ctx.issueUnexpectedType(input, 'null')\n    }\n\n    return ctx.success(null)\n  }\n}\n\n/**\n * Creates a null schema that only accepts the null value.\n *\n * Useful for explicitly representing null in union types or optional fields.\n *\n * @returns A new {@link NullSchema} instance\n *\n * @example\n * ```ts\n * // Explicit null\n * const nullOnlySchema = l.null()\n *\n * // Nullable string (string or null)\n * const nullableStringSchema = l.union([l.string(), l.null()])\n * ```\n */\nexport const nullSchema = /*#__PURE__*/ memoizedOptions(function () {\n  return new NullSchema()\n})\n\nexport { nullSchema as null }\n"]}

package/dist/schema/nullable.d.ts

@@ -1,4 +1,4 @@
-import { InferInput, InferOutput, Schema, ValidationContext, Validator } from '../core.js';
+import { type InferInput, type InferOutput, Schema, ValidationContext, type Validator } from '../core.js';
 /**
  * Schema wrapper that allows null values in addition to the wrapped schema.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"nullable.d.ts","sourceRoot":"","sources":["../../src/schema/nullable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,WAAW,EACX,MAAM,EACN,iBAAiB,EACjB,SAAS,EACV,MAAM,YAAY,CAAA;AAGnB;;;;;;;;;;;;;;GAcG;AACH,qBAAa,cAAc,CAAC,KAAK,CAAC,UAAU,SAAS,SAAS,CAAE,SAAQ,MAAM,CAC5E,UAAU,CAAC,UAAU,CAAC,GAAG,IAAI,EAC7B,WAAW,CAAC,UAAU,CAAC,GAAG,IAAI,CAC/B;IAGa,QAAQ,CAAC,SAAS,EAAE,UAAU;IAF1C,QAAQ,CAAC,IAAI,EAAG,UAAU,CAAS;IAEnC,YAAqB,SAAS,EAAE,UAAU,EAEzC;IAED,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB,gHAMvD;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,QAAQ,SACb,UAAU,SAAS,SAAS,aACvB,UAAU,+BAErB,CAAA"}
+{"version":3,"file":"nullable.d.ts","sourceRoot":"","sources":["../../src/schema/nullable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,MAAM,EACN,iBAAiB,EACjB,KAAK,SAAS,EACf,MAAM,YAAY,CAAA;AAGnB;;;;;;;;;;;;;;GAcG;AACH,qBAAa,cAAc,CAAC,KAAK,CAAC,UAAU,SAAS,SAAS,CAAE,SAAQ,MAAM,CAC5E,UAAU,CAAC,UAAU,CAAC,GAAG,IAAI,EAC7B,WAAW,CAAC,UAAU,CAAC,GAAG,IAAI,CAC/B;IAGa,QAAQ,CAAC,SAAS,EAAE,UAAU;IAF1C,QAAQ,CAAC,IAAI,EAAG,UAAU,CAAS;IAEnC,YAAqB,SAAS,EAAE,UAAU,EAEzC;IAED,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB,gHAMvD;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,QAAQ,SACb,UAAU,SAAS,SAAS,aACvB,UAAU,+BAErB,CAAA"}

package/dist/schema/nullable.js

@@ -1,4 +1,4 @@
-import { Schema, } from '../core.js';
+import { Schema, ValidationContext, } from '../core.js';
 import { memoizedTransformer } from '../util/memoize.js';
 /**
  * Schema wrapper that allows null values in addition to the wrapped schema.

package/dist/schema/nullable.js.map

@@ -1 +1 @@
-{"version":3,"file":"nullable.js","sourceRoot":"","sources":["../../src/schema/nullable.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,MAAM,GAGP,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAExD;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,cAAmD,SAAQ,MAGvE;IAGC,YAAqB,SAAqB;QACxC,KAAK,EAAE,CAAA;QADY,cAAS,GAAT,SAAS,CAAY;QAFjC,SAAI,GAAG,UAAmB,CAAA;IAInC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;QAC1B,CAAC;QAED,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;IAC5C,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,aAAa,CAAC,mBAAmB,CAAC,UAExD,SAAqB;IACrB,OAAO,IAAI,cAAc,CAAa,SAAS,CAAC,CAAA;AAClD,CAAC,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 * Schema wrapper that allows null values in addition to the wrapped schema.\n *\n * When the input is `null`, validation succeeds immediately. Otherwise,\n * the input is validated against the wrapped schema.\n *\n * @template TValidator - The wrapped validator type\n *\n * @example\n * ```ts\n * const schema = new NullableSchema(l.string())\n * schema.validate(null)    // success\n * schema.validate('hello') // success\n * ```\n */\nexport class NullableSchema<const TValidator extends Validator> extends Schema<\n  InferInput<TValidator> | null,\n  InferOutput<TValidator> | null\n> {\n  readonly type = 'nullable' as const\n\n  constructor(readonly validator: TValidator) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (input === null) {\n      return ctx.success(null)\n    }\n\n    return ctx.validate(input, this.validator)\n  }\n}\n\n/**\n * Creates a nullable schema that accepts null in addition to the wrapped type.\n *\n * Wraps another schema to allow null values. Different from `optional()` which\n * allows undefined.\n *\n * @param validator - The validator to make nullable\n * @returns A new {@link NullableSchema} instance\n *\n * @example\n * ```ts\n * // Nullable string\n * const nullableString = l.nullable(l.string())\n * nullableString.parse(null)    // null\n * nullableString.parse('hello') // 'hello'\n *\n * // In an object\n * const userSchema = l.object({\n *   name: l.string(),\n *   deletedAt: l.nullable(l.string({ format: 'datetime' })),\n * })\n *\n * // Combine with optional for null or undefined\n * const maybeString = l.optional(l.nullable(l.string()))\n * ```\n */\nexport const nullable = /*#__PURE__*/ memoizedTransformer(function <\n  const TValidator extends Validator,\n>(validator: TValidator) {\n  return new NullableSchema<TValidator>(validator)\n})\n"]}
+{"version":3,"file":"nullable.js","sourceRoot":"","sources":["../../src/schema/nullable.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,MAAM,EACN,iBAAiB,GAElB,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAExD;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,cAAmD,SAAQ,MAGvE;IAGC,YAAqB,SAAqB;QACxC,KAAK,EAAE,CAAA;QADY,cAAS,GAAT,SAAS,CAAY;QAFjC,SAAI,GAAG,UAAmB,CAAA;IAInC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;QAC1B,CAAC;QAED,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;IAC5C,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,aAAa,CAAC,mBAAmB,CAAC,UAExD,SAAqB;IACrB,OAAO,IAAI,cAAc,CAAa,SAAS,CAAC,CAAA;AAClD,CAAC,CAAC,CAAA","sourcesContent":["import {\n  type InferInput,\n  type InferOutput,\n  Schema,\n  ValidationContext,\n  type Validator,\n} from '../core.js'\nimport { memoizedTransformer } from '../util/memoize.js'\n\n/**\n * Schema wrapper that allows null values in addition to the wrapped schema.\n *\n * When the input is `null`, validation succeeds immediately. Otherwise,\n * the input is validated against the wrapped schema.\n *\n * @template TValidator - The wrapped validator type\n *\n * @example\n * ```ts\n * const schema = new NullableSchema(l.string())\n * schema.validate(null)    // success\n * schema.validate('hello') // success\n * ```\n */\nexport class NullableSchema<const TValidator extends Validator> extends Schema<\n  InferInput<TValidator> | null,\n  InferOutput<TValidator> | null\n> {\n  readonly type = 'nullable' as const\n\n  constructor(readonly validator: TValidator) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (input === null) {\n      return ctx.success(null)\n    }\n\n    return ctx.validate(input, this.validator)\n  }\n}\n\n/**\n * Creates a nullable schema that accepts null in addition to the wrapped type.\n *\n * Wraps another schema to allow null values. Different from `optional()` which\n * allows undefined.\n *\n * @param validator - The validator to make nullable\n * @returns A new {@link NullableSchema} instance\n *\n * @example\n * ```ts\n * // Nullable string\n * const nullableString = l.nullable(l.string())\n * nullableString.parse(null)    // null\n * nullableString.parse('hello') // 'hello'\n *\n * // In an object\n * const userSchema = l.object({\n *   name: l.string(),\n *   deletedAt: l.nullable(l.string({ format: 'datetime' })),\n * })\n *\n * // Combine with optional for null or undefined\n * const maybeString = l.optional(l.nullable(l.string()))\n * ```\n */\nexport const nullable = /*#__PURE__*/ memoizedTransformer(function <\n  const TValidator extends Validator,\n>(validator: TValidator) {\n  return new NullableSchema<TValidator>(validator)\n})\n"]}

package/dist/schema/object.d.ts

@@ -1,4 +1,5 @@
-import { InferInput, InferOutput, Schema, ValidationContext, Validator, WithOptionalProperties } from '../core.js';
+import { Schema, ValidationContext } from '../core.js';
+import type { InferInput, InferOutput, Validator, WithOptionalProperties } from '../core.js';
 /**
  * Type representing the shape of an object schema.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../src/schema/object.ts"],"names":[],"mappings":"AACA,OAAO,EACL,UAAU,EACV,WAAW,EACX,MAAM,EACN,iBAAiB,EACjB,SAAS,EACT,sBAAsB,EACvB,MAAM,YAAY,CAAA;AAGnB;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;AAEzD;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,YAAY,CACvB,KAAK,CAAC,MAAM,SAAS,iBAAiB,GAAG,GAAG,CAC5C,SAAQ,MAAM,CACd,sBAAsB,CAAC;KACpB,CAAC,IAAI,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAC3C,CAAC,EACF,sBAAsB,CAAC;KACpB,CAAC,IAAI,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAC5C,CAAC,CACH;IAGa,QAAQ,CAAC,KAAK,EAAE,MAAM;IAFlC,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAS;IAEjC,YAAqB,KAAK,EAAE,MAAM,EAEjC;IAED,IAAI,aAAa,IAAI,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAI1C;IAED,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB,6GAoCvD;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,wBAAgB,MAAM,CAAC,KAAK,CAAC,MAAM,SAAS,iBAAiB,EAC3D,UAAU,EAAE,MAAM,wBAGnB"}
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../src/schema/object.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,KAAK,EACV,UAAU,EACV,WAAW,EACX,SAAS,EACT,sBAAsB,EACvB,MAAM,YAAY,CAAA;AAGnB;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;AAEzD;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,YAAY,CACvB,KAAK,CAAC,MAAM,SAAS,iBAAiB,GAAG,GAAG,CAC5C,SAAQ,MAAM,CACd,sBAAsB,CAAC;KACpB,CAAC,IAAI,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAC3C,CAAC,EACF,sBAAsB,CAAC;KACpB,CAAC,IAAI,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAC5C,CAAC,CACH;IAGa,QAAQ,CAAC,KAAK,EAAE,MAAM;IAFlC,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAS;IAEjC,YAAqB,KAAK,EAAE,MAAM,EAEjC;IAED,IAAI,aAAa,IAAI,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAI1C;IAED,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB,6GAoCvD;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,wBAAgB,MAAM,CAAC,KAAK,CAAC,MAAM,SAAS,iBAAiB,EAC3D,UAAU,EAAE,MAAM,wBAGnB"}

package/dist/schema/object.js

@@ -1,5 +1,5 @@
 import { isPlainObject } from '@atproto/lex-data';
-import { Schema, } from '../core.js';
+import { Schema, ValidationContext } from '../core.js';
 import { lazyProperty } from '../util/lazy-property.js';
 /**
  * Schema for validating objects with a defined shape.

package/dist/schema/object.js.map

@@ -1 +1 @@
-{"version":3,"file":"object.js","sourceRoot":"","sources":["../../src/schema/object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,EAGL,MAAM,GAIP,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AASvD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,YAEX,SAAQ,MAOT;IAGC,YAAqB,KAAa;QAChC,KAAK,EAAE,CAAA;QADY,UAAK,GAAL,KAAK,CAAQ;QAFzB,SAAI,GAAG,QAAiB,CAAA;IAIjC,CAAC;IAED,IAAI,aAAa;QACf,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;QAE/C,OAAO,YAAY,CAAC,IAAI,EAAE,eAAe,EAAE,GAAG,CAAC,CAAA;IACjD,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;QACjD,CAAC;QAED,oBAAoB;QACpB,IAAI,IAAyC,CAAA;QAE7C,KAAK,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YAChD,MAAM,MAAM,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,CAAA;YACrD,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;gBACpB,IAAI,CAAC,CAAC,GAAG,IAAI,KAAK,CAAC,EAAE,CAAC;oBACpB,sCAAsC;oBACtC,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;gBACzC,CAAC;gBAED,OAAO,MAAM,CAAA;YACf,CAAC;YAED,uEAAuE;YACvE,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS,IAAI,CAAC,CAAC,GAAG,IAAI,KAAK,CAAC,EAAE,CAAC;gBAClD,SAAQ;YACV,CAAC;YAED,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;gBACzC,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;oBACpC,sEAAsE;oBACtE,OAAO,GAAG,CAAC,yBAAyB,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;gBAClE,CAAC;gBAED,IAAI,KAAK,EAAE,GAAG,KAAK,EAAE,CAAA;gBACrB,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,CAAA;YAC1B,CAAC;QACH,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,KAAK,CAAC,CAAA;IACnC,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAwB;AACxB,MAAM,UAAU,MAAM,CACpB,UAAkB;IAElB,OAAO,IAAI,YAAY,CAAS,UAAU,CAAC,CAAA;AAC7C,CAAC","sourcesContent":["import { isPlainObject } from '@atproto/lex-data'\nimport {\n  InferInput,\n  InferOutput,\n  Schema,\n  ValidationContext,\n  Validator,\n  WithOptionalProperties,\n} from '../core.js'\nimport { lazyProperty } from '../util/lazy-property.js'\n\n/**\n * Type representing the shape of an object schema.\n *\n * Maps property names to their corresponding validators.\n */\nexport type ObjectSchemaShape = Record<string, Validator>\n\n/**\n * Schema for validating objects with a defined shape.\n *\n * Each property in the shape is validated against its corresponding schema.\n * Properties wrapped in `optional()` are not required.\n *\n * @template TShape - The object shape type mapping property names to validators\n *\n * @example\n * ```ts\n * const schema = new ObjectSchema({\n *   name: l.string(),\n *   age: l.optional(l.integer()),\n * })\n * const result = schema.validate({ name: 'Alice' })\n * ```\n */\nexport class ObjectSchema<\n  const TShape extends ObjectSchemaShape = any,\n> extends Schema<\n  WithOptionalProperties<{\n    [K in keyof TShape]: InferInput<TShape[K]>\n  }>,\n  WithOptionalProperties<{\n    [K in keyof TShape]: InferOutput<TShape[K]>\n  }>\n> {\n  readonly type = 'object' as const\n\n  constructor(readonly shape: TShape) {\n    super()\n  }\n\n  get validatorsMap(): Map<string, Validator> {\n    const map = new Map(Object.entries(this.shape))\n\n    return lazyProperty(this, 'validatorsMap', map)\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isPlainObject(input)) {\n      return ctx.issueUnexpectedType(input, 'object')\n    }\n\n    // Lazily copy value\n    let copy: undefined | Record<string, unknown>\n\n    for (const [key, propDef] of this.validatorsMap) {\n      const result = ctx.validateChild(input, key, propDef)\n      if (!result.success) {\n        if (!(key in input)) {\n          // Transform into \"required key\" issue\n          return ctx.issueRequiredKey(input, key)\n        }\n\n        return result\n      }\n\n      // Skip copying if key is not present in input (and value is undefined)\n      if (result.value === undefined && !(key in input)) {\n        continue\n      }\n\n      if (!Object.is(result.value, input[key])) {\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, key, [result.value])\n        }\n\n        copy ??= { ...input }\n        copy[key] = result.value\n      }\n    }\n\n    return ctx.success(copy ?? input)\n  }\n}\n\n/**\n * Creates an object schema with the specified property validators.\n *\n * Validates that the input is a plain object and each property matches\n * its corresponding schema. Properties wrapped in `optional()` are not required.\n *\n * @param properties - Object mapping property names to their validators\n * @returns A new {@link ObjectSchema} instance\n *\n * @example\n * ```ts\n * // Basic object\n * const userSchema = l.object({\n *   name: l.string(),\n *   email: l.string({ format: 'uri' }),\n * })\n *\n * // With optional properties\n * const profileSchema = l.object({\n *   displayName: l.string(),\n *   bio: l.optional(l.string({ maxLength: 256 })),\n *   avatar: l.optional(l.blob({ accept: ['image/*'] })),\n * })\n *\n * // Nested objects\n * const postSchema = l.object({\n *   text: l.string(),\n *   author: l.object({\n *     did: l.string({ format: 'did' }),\n *     handle: l.string({ format: 'handle' }),\n *   }),\n * })\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function object<const TShape extends ObjectSchemaShape>(\n  properties: TShape,\n) {\n  return new ObjectSchema<TShape>(properties)\n}\n"]}
+{"version":3,"file":"object.js","sourceRoot":"","sources":["../../src/schema/object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAOtD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AASvD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,YAEX,SAAQ,MAOT;IAGC,YAAqB,KAAa;QAChC,KAAK,EAAE,CAAA;QADY,UAAK,GAAL,KAAK,CAAQ;QAFzB,SAAI,GAAG,QAAiB,CAAA;IAIjC,CAAC;IAED,IAAI,aAAa;QACf,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;QAE/C,OAAO,YAAY,CAAC,IAAI,EAAE,eAAe,EAAE,GAAG,CAAC,CAAA;IACjD,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,GAAG,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;QACjD,CAAC;QAED,oBAAoB;QACpB,IAAI,IAAyC,CAAA;QAE7C,KAAK,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YAChD,MAAM,MAAM,GAAG,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,CAAC,CAAA;YACrD,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;gBACpB,IAAI,CAAC,CAAC,GAAG,IAAI,KAAK,CAAC,EAAE,CAAC;oBACpB,sCAAsC;oBACtC,OAAO,GAAG,CAAC,gBAAgB,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;gBACzC,CAAC;gBAED,OAAO,MAAM,CAAA;YACf,CAAC;YAED,uEAAuE;YACvE,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS,IAAI,CAAC,CAAC,GAAG,IAAI,KAAK,CAAC,EAAE,CAAC;gBAClD,SAAQ;YACV,CAAC;YAED,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;gBACzC,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;oBACpC,sEAAsE;oBACtE,OAAO,GAAG,CAAC,yBAAyB,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;gBAClE,CAAC;gBAED,IAAI,KAAK,EAAE,GAAG,KAAK,EAAE,CAAA;gBACrB,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,CAAA;YAC1B,CAAC;QACH,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,IAAI,IAAI,KAAK,CAAC,CAAA;IACnC,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAwB;AACxB,MAAM,UAAU,MAAM,CACpB,UAAkB;IAElB,OAAO,IAAI,YAAY,CAAS,UAAU,CAAC,CAAA;AAC7C,CAAC","sourcesContent":["import { isPlainObject } from '@atproto/lex-data'\nimport { Schema, ValidationContext } from '../core.js'\nimport type {\n  InferInput,\n  InferOutput,\n  Validator,\n  WithOptionalProperties,\n} from '../core.js'\nimport { lazyProperty } from '../util/lazy-property.js'\n\n/**\n * Type representing the shape of an object schema.\n *\n * Maps property names to their corresponding validators.\n */\nexport type ObjectSchemaShape = Record<string, Validator>\n\n/**\n * Schema for validating objects with a defined shape.\n *\n * Each property in the shape is validated against its corresponding schema.\n * Properties wrapped in `optional()` are not required.\n *\n * @template TShape - The object shape type mapping property names to validators\n *\n * @example\n * ```ts\n * const schema = new ObjectSchema({\n *   name: l.string(),\n *   age: l.optional(l.integer()),\n * })\n * const result = schema.validate({ name: 'Alice' })\n * ```\n */\nexport class ObjectSchema<\n  const TShape extends ObjectSchemaShape = any,\n> extends Schema<\n  WithOptionalProperties<{\n    [K in keyof TShape]: InferInput<TShape[K]>\n  }>,\n  WithOptionalProperties<{\n    [K in keyof TShape]: InferOutput<TShape[K]>\n  }>\n> {\n  readonly type = 'object' as const\n\n  constructor(readonly shape: TShape) {\n    super()\n  }\n\n  get validatorsMap(): Map<string, Validator> {\n    const map = new Map(Object.entries(this.shape))\n\n    return lazyProperty(this, 'validatorsMap', map)\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    if (!isPlainObject(input)) {\n      return ctx.issueUnexpectedType(input, 'object')\n    }\n\n    // Lazily copy value\n    let copy: undefined | Record<string, unknown>\n\n    for (const [key, propDef] of this.validatorsMap) {\n      const result = ctx.validateChild(input, key, propDef)\n      if (!result.success) {\n        if (!(key in input)) {\n          // Transform into \"required key\" issue\n          return ctx.issueRequiredKey(input, key)\n        }\n\n        return result\n      }\n\n      // Skip copying if key is not present in input (and value is undefined)\n      if (result.value === undefined && !(key in input)) {\n        continue\n      }\n\n      if (!Object.is(result.value, input[key])) {\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, key, [result.value])\n        }\n\n        copy ??= { ...input }\n        copy[key] = result.value\n      }\n    }\n\n    return ctx.success(copy ?? input)\n  }\n}\n\n/**\n * Creates an object schema with the specified property validators.\n *\n * Validates that the input is a plain object and each property matches\n * its corresponding schema. Properties wrapped in `optional()` are not required.\n *\n * @param properties - Object mapping property names to their validators\n * @returns A new {@link ObjectSchema} instance\n *\n * @example\n * ```ts\n * // Basic object\n * const userSchema = l.object({\n *   name: l.string(),\n *   email: l.string({ format: 'uri' }),\n * })\n *\n * // With optional properties\n * const profileSchema = l.object({\n *   displayName: l.string(),\n *   bio: l.optional(l.string({ maxLength: 256 })),\n *   avatar: l.optional(l.blob({ accept: ['image/*'] })),\n * })\n *\n * // Nested objects\n * const postSchema = l.object({\n *   text: l.string(),\n *   author: l.object({\n *     did: l.string({ format: 'did' }),\n *     handle: l.string({ format: 'handle' }),\n *   }),\n * })\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function object<const TShape extends ObjectSchemaShape>(\n  properties: TShape,\n) {\n  return new ObjectSchema<TShape>(properties)\n}\n"]}

package/dist/schema/optional.d.ts

@@ -1,4 +1,5 @@
-import { InferInput, InferOutput, Schema, UnwrapValidator, ValidationContext, Validator } from '../core.js';
+import { Schema, ValidationContext } from '../core.js';
+import type { InferInput, InferOutput, UnwrapValidator, Validator } from '../core.js';
 import { WithDefaultSchema } from './with-default.js';
 /**
  * Schema wrapper that makes a value optional (allows undefined).

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

@@ -1 +1 @@
-{"version":3,"file":"optional.d.ts","sourceRoot":"","sources":["../../src/schema/optional.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,WAAW,EACX,MAAM,EACN,eAAe,EACf,iBAAiB,EACjB,SAAS,EACV,MAAM,YAAY,CAAA;AAEnB,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,cAAc,CAAC,UAAU,SAAS,SAAS,CAAE,SAAQ,MAAM,CACtE,UAAU,CAAC,UAAU,CAAC,GAAG,SAAS,EAClC,eAAe,CAAC,UAAU,CAAC,SAAS,iBAAiB,CAAC,MAAM,UAAU,CAAC,GACnE,WAAW,CAAC,UAAU,CAAC,GACvB,WAAW,CAAC,UAAU,CAAC,GAAG,SAAS,CACxC;IAGa,QAAQ,CAAC,SAAS,EAAE,UAAU;IAF1C,QAAQ,CAAC,IAAI,EAAG,UAAU,CAAS;IAEnC,YAAqB,SAAS,EAAE,UAAU,EAEzC;IAED,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB,gKAmBvD;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,QAAQ,SACb,UAAU,SAAS,SAAS,aACvB,UAAU,+BAErB,CAAA"}
+{"version":3,"file":"optional.d.ts","sourceRoot":"","sources":["../../src/schema/optional.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,KAAK,EACV,UAAU,EACV,WAAW,EACX,eAAe,EACf,SAAS,EACV,MAAM,YAAY,CAAA;AAEnB,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,cAAc,CAAC,UAAU,SAAS,SAAS,CAAE,SAAQ,MAAM,CACtE,UAAU,CAAC,UAAU,CAAC,GAAG,SAAS,EAClC,eAAe,CAAC,UAAU,CAAC,SAAS,iBAAiB,CAAC,MAAM,UAAU,CAAC,GACnE,WAAW,CAAC,UAAU,CAAC,GACvB,WAAW,CAAC,UAAU,CAAC,GAAG,SAAS,CACxC;IAGa,QAAQ,CAAC,SAAS,EAAE,UAAU;IAF1C,QAAQ,CAAC,IAAI,EAAG,UAAU,CAAS;IAEnC,YAAqB,SAAS,EAAE,UAAU,EAEzC;IAED,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB,gKAmBvD;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,QAAQ,SACb,UAAU,SAAS,SAAS,aACvB,UAAU,+BAErB,CAAA"}

package/dist/schema/optional.js

@@ -1,5 +1,6 @@
-import { Schema, } from '../core.js';
+import { Schema, ValidationContext } from '../core.js';
 import { memoizedTransformer } from '../util/memoize.js';
+import { WithDefaultSchema } from './with-default.js';
 /**
  * Schema wrapper that makes a value optional (allows undefined).
  *

package/dist/schema/optional.js.map

@@ -1 +1 @@
-{"version":3,"file":"optional.js","sourceRoot":"","sources":["../../src/schema/optional.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,MAAM,GAIP,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAGxD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,cAA6C,SAAQ,MAKjE;IAGC,YAAqB,SAAqB;QACxC,KAAK,EAAE,CAAA;QADY,cAAS,GAAT,SAAS,CAAY;QAFjC,SAAI,GAAG,UAAmB,CAAA;IAInC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,0EAA0E;QAC1E,IAAI,KAAK,KAAK,SAAS,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;YAC3D,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAC3B,CAAC;QAED,0EAA0E;QAC1E,8BAA8B;QAC9B,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;QAElD,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;YACnB,OAAO,MAAM,CAAA;QACf,CAAC;QAED,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAC3B,CAAC;QAED,OAAO,MAAM,CAAA;IACf,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,aAAa,CAAC,mBAAmB,CAAC,UAExD,SAAqB;IACrB,OAAO,IAAI,cAAc,CAAa,SAAS,CAAC,CAAA;AAClD,CAAC,CAAC,CAAA","sourcesContent":["import {\n  InferInput,\n  InferOutput,\n  Schema,\n  UnwrapValidator,\n  ValidationContext,\n  Validator,\n} from '../core.js'\nimport { memoizedTransformer } from '../util/memoize.js'\nimport { WithDefaultSchema } from './with-default.js'\n\n/**\n * Schema wrapper that makes a value optional (allows undefined).\n *\n * When the input is `undefined`, validation succeeds without running the\n * inner validator. If the inner validator has a default value (via `withDefault`),\n * that default will be applied in parse mode.\n *\n * @template TValidator - The wrapped validator type\n *\n * @example\n * ```ts\n * const schema = new OptionalSchema(l.string())\n * schema.validate(undefined) // success\n * schema.validate('hello')   // success\n * ```\n */\nexport class OptionalSchema<TValidator extends Validator> extends Schema<\n  InferInput<TValidator> | undefined,\n  UnwrapValidator<TValidator> extends WithDefaultSchema<infer TValidator>\n    ? InferOutput<TValidator>\n    : InferOutput<TValidator> | undefined\n> {\n  readonly type = 'optional' as const\n\n  constructor(readonly validator: TValidator) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    // Optimization: No need to apply child schema defaults in validation mode\n    if (input === undefined && ctx.options.mode === 'validate') {\n      return ctx.success(input)\n    }\n\n    // @NOTE The inner schema might apply a default value so we need to run it\n    // even if input is undefined.\n    const result = ctx.validate(input, this.validator)\n\n    if (result.success) {\n      return result\n    }\n\n    if (input === undefined) {\n      return ctx.success(input)\n    }\n\n    return result\n  }\n}\n\n/**\n * Creates an optional schema that allows undefined values.\n *\n * Wraps another schema to make it optional. When used in an object schema,\n * properties with optional schemas are not required.\n *\n * @param validator - The validator to make optional\n * @returns A new {@link OptionalSchema} instance\n *\n * @example\n * ```ts\n * // Optional string\n * const optionalBio = l.optional(l.string())\n *\n * // In an object - property is not required\n * const userSchema = l.object({\n *   name: l.string(),\n *   bio: l.optional(l.string()),\n * })\n * userSchema.parse({ name: 'Alice' }) // Valid, bio is undefined\n *\n * // With default value\n * const countSchema = l.optional(l.withDefault(l.integer(), 0))\n * countSchema.parse(undefined) // Returns 0\n * ```\n */\nexport const optional = /*#__PURE__*/ memoizedTransformer(function <\n  const TValidator extends Validator,\n>(validator: TValidator) {\n  return new OptionalSchema<TValidator>(validator)\n})\n"]}
+{"version":3,"file":"optional.js","sourceRoot":"","sources":["../../src/schema/optional.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAOtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,OAAO,cAA6C,SAAQ,MAKjE;IAGC,YAAqB,SAAqB;QACxC,KAAK,EAAE,CAAA;QADY,cAAS,GAAT,SAAS,CAAY;QAFjC,SAAI,GAAG,UAAmB,CAAA;IAInC,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,0EAA0E;QAC1E,IAAI,KAAK,KAAK,SAAS,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;YAC3D,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAC3B,CAAC;QAED,0EAA0E;QAC1E,8BAA8B;QAC9B,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;QAElD,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;YACnB,OAAO,MAAM,CAAA;QACf,CAAC;QAED,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAC3B,CAAC;QAED,OAAO,MAAM,CAAA;IACf,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,aAAa,CAAC,mBAAmB,CAAC,UAExD,SAAqB;IACrB,OAAO,IAAI,cAAc,CAAa,SAAS,CAAC,CAAA;AAClD,CAAC,CAAC,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\nimport type {\n  InferInput,\n  InferOutput,\n  UnwrapValidator,\n  Validator,\n} from '../core.js'\nimport { memoizedTransformer } from '../util/memoize.js'\nimport { WithDefaultSchema } from './with-default.js'\n\n/**\n * Schema wrapper that makes a value optional (allows undefined).\n *\n * When the input is `undefined`, validation succeeds without running the\n * inner validator. If the inner validator has a default value (via `withDefault`),\n * that default will be applied in parse mode.\n *\n * @template TValidator - The wrapped validator type\n *\n * @example\n * ```ts\n * const schema = new OptionalSchema(l.string())\n * schema.validate(undefined) // success\n * schema.validate('hello')   // success\n * ```\n */\nexport class OptionalSchema<TValidator extends Validator> extends Schema<\n  InferInput<TValidator> | undefined,\n  UnwrapValidator<TValidator> extends WithDefaultSchema<infer TValidator>\n    ? InferOutput<TValidator>\n    : InferOutput<TValidator> | undefined\n> {\n  readonly type = 'optional' as const\n\n  constructor(readonly validator: TValidator) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    // Optimization: No need to apply child schema defaults in validation mode\n    if (input === undefined && ctx.options.mode === 'validate') {\n      return ctx.success(input)\n    }\n\n    // @NOTE The inner schema might apply a default value so we need to run it\n    // even if input is undefined.\n    const result = ctx.validate(input, this.validator)\n\n    if (result.success) {\n      return result\n    }\n\n    if (input === undefined) {\n      return ctx.success(input)\n    }\n\n    return result\n  }\n}\n\n/**\n * Creates an optional schema that allows undefined values.\n *\n * Wraps another schema to make it optional. When used in an object schema,\n * properties with optional schemas are not required.\n *\n * @param validator - The validator to make optional\n * @returns A new {@link OptionalSchema} instance\n *\n * @example\n * ```ts\n * // Optional string\n * const optionalBio = l.optional(l.string())\n *\n * // In an object - property is not required\n * const userSchema = l.object({\n *   name: l.string(),\n *   bio: l.optional(l.string()),\n * })\n * userSchema.parse({ name: 'Alice' }) // Valid, bio is undefined\n *\n * // With default value\n * const countSchema = l.optional(l.withDefault(l.integer(), 0))\n * countSchema.parse(undefined) // Returns 0\n * ```\n */\nexport const optional = /*#__PURE__*/ memoizedTransformer(function <\n  const TValidator extends Validator,\n>(validator: TValidator) {\n  return new OptionalSchema<TValidator>(validator)\n})\n"]}

package/dist/schema/params.d.ts

@@ -1,4 +1,4 @@
-import { Infer, InferInput, InferOutput, LexValidationError, ParseOptions, Schema, ValidationContext, Validator, WithOptionalProperties } from '../core.js';
+import { type Infer, type InferInput, type InferOutput, LexValidationError, type ParseOptions, Schema, ValidationContext, type Validator, type WithOptionalProperties } from '../core.js';
 import { ArraySchema } from './array.js';
 import { BooleanSchema } from './boolean.js';
 import { EnumSchema } from './enum.js';

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

@@ -1 +1 @@
-{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["../../src/schema/params.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["../../src/schema/params.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,KAAK,EACV,KAAK,UAAU,EACf,KAAK,WAAW,EAIhB,kBAAkB,EAClB,KAAK,YAAY,EACjB,MAAM,EACN,iBAAiB,EACjB,KAAK,SAAS,EACd,KAAK,sBAAsB,EAC5B,MAAM,YAAY,CAAA;AAGnB,OAAO,EAAE,WAAW,EAAS,MAAM,YAAY,CAAA;AAC/C,OAAO,EAAE,aAAa,EAAW,MAAM,cAAc,CAAA;AAErD,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AACtC,OAAO,EAAE,aAAa,EAAW,MAAM,cAAc,CAAA;AACrD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,EAAE,cAAc,EAAY,MAAM,eAAe,CAAA;AACxD,OAAO,EAAE,YAAY,EAAU,MAAM,aAAa,CAAA;AAElD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAErD;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AACzD,QAAA,MAAM,iBAAiB,6FAA0C,CAAA;AAEjE;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAE7C;;GAEG;AACH,eAAO,MAAM,WAAW,iOAKtB,CAAA;AAEF;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAE/C;;GAEG;AACH,eAAO,MAAM,YAAY,mSAAwC,CAAA;AAEjE,MAAM,MAAM,oBAAoB,GAI5B,aAAa,CAAC,MAAM,CAAC,GACrB,aAAa,CAAC,MAAM,CAAC,GACrB,aAAa,CAAC,OAAO,CAAC,GACtB,UAAU,CAAC,MAAM,CAAC,GAClB,UAAU,CAAC,MAAM,CAAC,GAElB,YAAY,CAAC,GAAG,CAAC,GACjB,aAAa,GACb,aAAa,CAAA;AAEjB,KAAK,kBAAkB,CAAC,OAAO,SAAS,SAAS,IAO/C,OAAO,SAAS,GAAG,GAAG,WAAW,CAAC,OAAO,CAAC,GAAG,KAAK,CAAA;AAEpD,MAAM,MAAM,mBAAmB,GAC3B,oBAAoB,GACpB,kBAAkB,CAAC,oBAAoB,CAAC,CAAA;AAE5C,MAAM,MAAM,cAAc,GACtB,mBAAmB,GACnB,cAAc,CAAC,mBAAmB,CAAC,GACnC,cAAc,CAAC,iBAAiB,CAAC,mBAAmB,CAAC,CAAC,GACtD,iBAAiB,CAAC,mBAAmB,CAAC,CAAA;AAE1C;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,CAAC,CAAC,EAAE,MAAM,GAAG,cAAc,CAAA;CAC5B,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,YAAY,CACvB,KAAK,CAAC,MAAM,SAAS,WAAW,GAAG,WAAW,CAC9C,SAAQ,MAAM,CACd,sBAAsB,CAAC;KACpB,CAAC,IAAI,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAC3C,CAAC,EACF,sBAAsB,CAAC;KACpB,CAAC,IAAI,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;CAC5C,CAAC,CACH;IAGa,QAAQ,CAAC,KAAK,EAAE,MAAM;IAFlC,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAS;IAEjC,YAAqB,KAAK,EAAE,MAAM,EAEjC;IAED,IAAI,eAAe,IAAI,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAIjD;IAED,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB,wFAuDvD;IAED,mBAAmB,CACjB,KAAK,EAAE,MAAM,GAAG,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC1C,OAAO,CAAC,EAAE,YAAY,GACrB,WAAW,CAAC,IAAI,CAAC,CAgCnB;IAED,iBAAiB,CAAC,KAAK,EAAE,UAAU,CAAC,IAAI,CAAC,GAAG,eAAe,CAkB1D;CACF;AA2DD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,MAAM,SACX,MAAM,SAAS,WAAW,oBACpB,MAAM,yBAElB,CAAA"}

package/dist/schema/params.js

@@ -1,5 +1,5 @@
 import { isPlainObject } from '@atproto/lex-data';
-import { IssueInvalidType, IssueInvalidValue, LexValidationError, Schema, } from '../core.js';
+import { Issue, IssueInvalidType, IssueInvalidValue, LexValidationError, Schema, ValidationContext, } from '../core.js';
 import { lazyProperty } from '../util/lazy-property.js';
 import { memoizedOptions } from '../util/memoize.js';
 import { ArraySchema, array } from './array.js';