@atproto/lex-schema 0.0.12 → 0.0.13

package/dist/schema/union.js.map

@@ -1 +1 @@
-{"version":3,"file":"union.js","sourceRoot":"","sources":["../../src/schema/union.ts"],"names":[],"mappings":";;;AAkFA,sBAIC;AAtFD,wCAQmB;AASnB;;;;;;;;;;;;;;;GAeG;AACH,MAAa,WAEX,SAAQ,gBAGT;IACgC;IAA/B,YAA+B,UAAuB;QACpD,KAAK,EAAE,CAAA;QADsB,eAAU,GAAV,UAAU,CAAa;IAEtD,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,MAAM,QAAQ,GAAwB,EAAE,CAAA;QAExC,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACxC,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;YAC7C,IAAI,MAAM,CAAC,OAAO;gBAAE,OAAO,MAAM,CAAA;YAEjC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;QACvB,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,yBAAe,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAA;IAC5D,CAAC;CACF;AAtBD,kCAsBC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAwB;AACxB,SAAgB,KAAK,CACnB,UAAuB;IAEvB,OAAO,IAAI,WAAW,CAAc,UAAU,CAAC,CAAA;AACjD,CAAC","sourcesContent":["import {\n  InferInput,\n  InferOutput,\n  Schema,\n  ValidationContext,\n  ValidationError,\n  ValidationFailure,\n  Validator,\n} from '../core.js'\n\n/**\n * Type representing a non-empty tuple of validators for union schemas.\n *\n * Requires at least one validator in the tuple.\n */\nexport type UnionSchemaValidators = readonly [Validator, ...Validator[]]\n\n/**\n * Schema for validating values that match one of several possible schemas.\n *\n * Tries each validator in order until one succeeds. If all validators fail,\n * returns a combined error from all attempts.\n *\n * @template TValidators - Tuple type of the validators in the union\n *\n * @example\n * ```ts\n * const schema = new UnionSchema([l.string(), l.integer()])\n * schema.validate('hello') // success\n * schema.validate(42)      // success\n * schema.validate(true)    // fails\n * ```\n */\nexport class UnionSchema<\n  const TValidators extends UnionSchemaValidators = any,\n> extends Schema<\n  InferInput<TValidators[number]>,\n  InferOutput<TValidators[number]>\n> {\n  constructor(protected readonly validators: TValidators) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    const failures: ValidationFailure[] = []\n\n    for (const validator of this.validators) {\n      const result = ctx.validate(input, validator)\n      if (result.success) return result\n\n      failures.push(result)\n    }\n\n    return ctx.failure(ValidationError.fromFailures(failures))\n  }\n}\n\n/**\n * Creates a union schema that accepts values matching any of the provided schemas.\n *\n * Validators are tried in order. Use `discriminatedUnion()` for better\n * performance when discriminating on a known property.\n *\n * @param validators - Non-empty array of validators to try\n * @returns A new {@link UnionSchema} instance\n *\n * @example\n * ```ts\n * // String or number\n * const stringOrNumber = l.union([l.string(), l.integer()])\n *\n * // Nullable value\n * const nullableString = l.union([l.string(), l.null()])\n *\n * // Multiple object types\n * const mediaSchema = l.union([\n *   l.object({ type: l.literal('image'), url: l.string() }),\n *   l.object({ type: l.literal('video'), url: l.string(), duration: l.integer() }),\n * ])\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function union<const TValidators extends UnionSchemaValidators>(\n  validators: TValidators,\n) {\n  return new UnionSchema<TValidators>(validators)\n}\n"]}
+{"version":3,"file":"union.js","sourceRoot":"","sources":["../../src/schema/union.ts"],"names":[],"mappings":";;;AAoFA,sBAIC;AAxFD,wCAQmB;AASnB;;;;;;;;;;;;;;;GAeG;AACH,MAAa,WAEX,SAAQ,gBAGT;IAGgC;IAFtB,IAAI,GAAG,OAAgB,CAAA;IAEhC,YAA+B,UAAuB;QACpD,KAAK,EAAE,CAAA;QADsB,eAAU,GAAV,UAAU,CAAa;IAEtD,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,MAAM,QAAQ,GAAwB,EAAE,CAAA;QAExC,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACxC,MAAM,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,CAAA;YAC7C,IAAI,MAAM,CAAC,OAAO;gBAAE,OAAO,MAAM,CAAA;YAEjC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;QACvB,CAAC;QAED,OAAO,GAAG,CAAC,OAAO,CAAC,yBAAe,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAA;IAC5D,CAAC;CACF;AAxBD,kCAwBC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAwB;AACxB,SAAgB,KAAK,CACnB,UAAuB;IAEvB,OAAO,IAAI,WAAW,CAAc,UAAU,CAAC,CAAA;AACjD,CAAC","sourcesContent":["import {\n  InferInput,\n  InferOutput,\n  Schema,\n  ValidationContext,\n  ValidationError,\n  ValidationFailure,\n  Validator,\n} from '../core.js'\n\n/**\n * Type representing a non-empty tuple of validators for union schemas.\n *\n * Requires at least one validator in the tuple.\n */\nexport type UnionSchemaValidators = readonly [Validator, ...Validator[]]\n\n/**\n * Schema for validating values that match one of several possible schemas.\n *\n * Tries each validator in order until one succeeds. If all validators fail,\n * returns a combined error from all attempts.\n *\n * @template TValidators - Tuple type of the validators in the union\n *\n * @example\n * ```ts\n * const schema = new UnionSchema([l.string(), l.integer()])\n * schema.validate('hello') // success\n * schema.validate(42)      // success\n * schema.validate(true)    // fails\n * ```\n */\nexport class UnionSchema<\n  const TValidators extends UnionSchemaValidators = any,\n> extends Schema<\n  InferInput<TValidators[number]>,\n  InferOutput<TValidators[number]>\n> {\n  readonly type = 'union' as const\n\n  constructor(protected readonly validators: TValidators) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    const failures: ValidationFailure[] = []\n\n    for (const validator of this.validators) {\n      const result = ctx.validate(input, validator)\n      if (result.success) return result\n\n      failures.push(result)\n    }\n\n    return ctx.failure(ValidationError.fromFailures(failures))\n  }\n}\n\n/**\n * Creates a union schema that accepts values matching any of the provided schemas.\n *\n * Validators are tried in order. Use `discriminatedUnion()` for better\n * performance when discriminating on a known property.\n *\n * @param validators - Non-empty array of validators to try\n * @returns A new {@link UnionSchema} instance\n *\n * @example\n * ```ts\n * // String or number\n * const stringOrNumber = l.union([l.string(), l.integer()])\n *\n * // Nullable value\n * const nullableString = l.union([l.string(), l.null()])\n *\n * // Multiple object types\n * const mediaSchema = l.union([\n *   l.object({ type: l.literal('image'), url: l.string() }),\n *   l.object({ type: l.literal('video'), url: l.string(), duration: l.integer() }),\n * ])\n * ```\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function union<const TValidators extends UnionSchemaValidators>(\n  validators: TValidators,\n) {\n  return new UnionSchema<TValidators>(validators)\n}\n"]}

package/dist/schema/unknown.d.ts

@@ -13,6 +13,7 @@ import { Schema, ValidationContext } from '../core.js';
  * ```
  */
 export declare class UnknownSchema extends Schema<unknown> {
+    readonly type: "unknown";
     validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<unknown>;
 }
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"unknown.d.ts","sourceRoot":"","sources":["../../src/schema/unknown.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGtD;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAc,SAAQ,MAAM,CAAC,OAAO,CAAC;IAChD,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAGzD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,OAAO,qBAElB,CAAA"}
+{"version":3,"file":"unknown.d.ts","sourceRoot":"","sources":["../../src/schema/unknown.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAGtD;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAc,SAAQ,MAAM,CAAC,OAAO,CAAC;IAChD,QAAQ,CAAC,IAAI,EAAG,SAAS,CAAS;IAElC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CAGzD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,OAAO,qBAElB,CAAA"}

package/dist/schema/unknown.js

@@ -17,6 +17,7 @@ const memoize_js_1 = require("../util/memoize.js");
  * ```
  */
 class UnknownSchema extends core_js_1.Schema {
+    type = 'unknown';
     validateInContext(input, ctx) {
         return ctx.success(input);
     }

package/dist/schema/unknown.js.map

@@ -1 +1 @@
-{"version":3,"file":"unknown.js","sourceRoot":"","sources":["../../src/schema/unknown.ts"],"names":[],"mappings":";;;AAAA,wCAAsD;AACtD,mDAAoD;AAEpD;;;;;;;;;;;;GAYG;AACH,MAAa,aAAc,SAAQ,gBAAe;IAChD,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAJD,sCAIC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACU,QAAA,OAAO,GAAiB,IAAA,4BAAe,EAAC;IACnD,OAAO,IAAI,aAAa,EAAE,CAAA;AAC5B,CAAC,CAAC,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Schema that accepts any value without validation.\n *\n * Passes through any input unchanged. Use sparingly as it bypasses\n * type safety. Useful for dynamic data or when the schema is not\n * known at compile time.\n *\n * @example\n * ```ts\n * const schema = new UnknownSchema()\n * schema.validate(anything) // always succeeds\n * ```\n */\nexport class UnknownSchema extends Schema<unknown> {\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    return ctx.success(input)\n  }\n}\n\n/**\n * Creates an unknown schema that accepts any value.\n *\n * The value passes through without any validation or transformation.\n * Use this when you need to accept arbitrary data.\n *\n * @returns A new {@link UnknownSchema} instance\n *\n * @example\n * ```ts\n * // Accept any value\n * const anyDataSchema = l.unknown()\n *\n * // In an object with a dynamic field\n * const flexibleSchema = l.object({\n *   type: l.string(),\n *   data: l.unknown(),\n * })\n * ```\n */\nexport const unknown = /*#__PURE__*/ memoizedOptions(function () {\n  return new UnknownSchema()\n})\n"]}
+{"version":3,"file":"unknown.js","sourceRoot":"","sources":["../../src/schema/unknown.ts"],"names":[],"mappings":";;;AAAA,wCAAsD;AACtD,mDAAoD;AAEpD;;;;;;;;;;;;GAYG;AACH,MAAa,aAAc,SAAQ,gBAAe;IACvC,IAAI,GAAG,SAAkB,CAAA;IAElC,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,OAAO,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC3B,CAAC;CACF;AAND,sCAMC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACU,QAAA,OAAO,GAAiB,IAAA,4BAAe,EAAC;IACnD,OAAO,IAAI,aAAa,EAAE,CAAA;AAC5B,CAAC,CAAC,CAAA","sourcesContent":["import { Schema, ValidationContext } from '../core.js'\nimport { memoizedOptions } from '../util/memoize.js'\n\n/**\n * Schema that accepts any value without validation.\n *\n * Passes through any input unchanged. Use sparingly as it bypasses\n * type safety. Useful for dynamic data or when the schema is not\n * known at compile time.\n *\n * @example\n * ```ts\n * const schema = new UnknownSchema()\n * schema.validate(anything) // always succeeds\n * ```\n */\nexport class UnknownSchema extends Schema<unknown> {\n  readonly type = 'unknown' as const\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    return ctx.success(input)\n  }\n}\n\n/**\n * Creates an unknown schema that accepts any value.\n *\n * The value passes through without any validation or transformation.\n * Use this when you need to accept arbitrary data.\n *\n * @returns A new {@link UnknownSchema} instance\n *\n * @example\n * ```ts\n * // Accept any value\n * const anyDataSchema = l.unknown()\n *\n * // In an object with a dynamic field\n * const flexibleSchema = l.object({\n *   type: l.string(),\n *   data: l.unknown(),\n * })\n * ```\n */\nexport const unknown = /*#__PURE__*/ memoizedOptions(function () {\n  return new UnknownSchema()\n})\n"]}

package/dist/schema/with-default.d.ts

@@ -18,6 +18,7 @@ import { InferInput, InferOutput, Schema, ValidationContext, Validator } from '.
 export declare class WithDefaultSchema<const TValidator extends Validator> extends Schema<InferInput<TValidator>, InferOutput<TValidator>> {
     readonly validator: TValidator;
     readonly defaultValue: InferInput<TValidator>;
+    readonly type: "withDefault";
     constructor(validator: TValidator, defaultValue: InferInput<TValidator>);
     validateInContext(input: unknown, ctx: ValidationContext): import("../core.js").ValidationResult<InferInput<TValidator>>;
 }

package/dist/schema/with-default.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"with-default.d.ts","sourceRoot":"","sources":["../../src/schema/with-default.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,WAAW,EACX,MAAM,EACN,iBAAiB,EACjB,SAAS,EACV,MAAM,YAAY,CAAA;AAEnB;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,iBAAiB,CAC5B,KAAK,CAAC,UAAU,SAAS,SAAS,CAClC,SAAQ,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC;IAE7D,QAAQ,CAAC,SAAS,EAAE,UAAU;IAC9B,QAAQ,CAAC,YAAY,EAAE,UAAU,CAAC,UAAU,CAAC;gBADpC,SAAS,EAAE,UAAU,EACrB,YAAY,EAAE,UAAU,CAAC,UAAU,CAAC;IAK/C,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CASzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,WAAW,CAAC,KAAK,CAAC,UAAU,SAAS,SAAS,EAC5D,SAAS,EAAE,UAAU,EACrB,YAAY,EAAE,UAAU,CAAC,UAAU,CAAC,iCAGrC"}
+{"version":3,"file":"with-default.d.ts","sourceRoot":"","sources":["../../src/schema/with-default.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,WAAW,EACX,MAAM,EACN,iBAAiB,EACjB,SAAS,EACV,MAAM,YAAY,CAAA;AAEnB;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,iBAAiB,CAC5B,KAAK,CAAC,UAAU,SAAS,SAAS,CAClC,SAAQ,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC;IAI7D,QAAQ,CAAC,SAAS,EAAE,UAAU;IAC9B,QAAQ,CAAC,YAAY,EAAE,UAAU,CAAC,UAAU,CAAC;IAJ/C,QAAQ,CAAC,IAAI,EAAG,aAAa,CAAS;gBAG3B,SAAS,EAAE,UAAU,EACrB,YAAY,EAAE,UAAU,CAAC,UAAU,CAAC;IAK/C,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,iBAAiB;CASzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,WAAW,CAAC,KAAK,CAAC,UAAU,SAAS,SAAS,EAC5D,SAAS,EAAE,UAAU,EACrB,YAAY,EAAE,UAAU,CAAC,UAAU,CAAC,iCAGrC"}

package/dist/schema/with-default.js

@@ -22,6 +22,7 @@ const core_js_1 = require("../core.js");
 class WithDefaultSchema extends core_js_1.Schema {
     validator;
     defaultValue;
+    type = 'withDefault';
     constructor(validator, defaultValue) {
         super();
         this.validator = validator;

package/dist/schema/with-default.js.map

@@ -1 +1 @@
-{"version":3,"file":"with-default.js","sourceRoot":"","sources":["../../src/schema/with-default.ts"],"names":[],"mappings":";;;AAyEA,kCAKC;AA9ED,wCAMmB;AAEnB;;;;;;;;;;;;;;;GAeG;AACH,MAAa,iBAEX,SAAQ,gBAAuD;IAEpD;IACA;IAFX,YACW,SAAqB,EACrB,YAAoC;QAE7C,KAAK,EAAE,CAAA;QAHE,cAAS,GAAT,SAAS,CAAY;QACrB,iBAAY,GAAZ,YAAY,CAAwB;IAG/C,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,kEAAkE;QAClE,iCAAiC;QACjC,IAAI,KAAK,KAAK,SAAS,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;YAC3D,OAAO,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;QACxD,CAAC;QAED,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;IAC5C,CAAC;CACF;AAnBD,8CAmBC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,SAAgB,WAAW,CACzB,SAAqB,EACrB,YAAoC;IAEpC,OAAO,IAAI,iBAAiB,CAAa,SAAS,EAAE,YAAY,CAAC,CAAA;AACnE,CAAC","sourcesContent":["import {\n  InferInput,\n  InferOutput,\n  Schema,\n  ValidationContext,\n  Validator,\n} from '../core.js'\n\n/**\n * Schema wrapper that provides a default value when the input is undefined.\n *\n * In parse mode, when the input is `undefined`, the default value is used\n * instead. In validate mode, undefined values pass through unchanged (the\n * default is not applied).\n *\n * @template TValidator - The wrapped validator type\n *\n * @example\n * ```ts\n * const schema = new WithDefaultSchema(l.integer(), 0)\n * schema.parse(undefined) // 0\n * schema.parse(42)        // 42\n * ```\n */\nexport class WithDefaultSchema<\n  const TValidator extends Validator,\n> extends Schema<InferInput<TValidator>, InferOutput<TValidator>> {\n  constructor(\n    readonly validator: TValidator,\n    readonly defaultValue: InferInput<TValidator>,\n  ) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    // When in a validation context, the output should not be altered,\n    // so we don't apply the default.\n    if (input === undefined && ctx.options.mode !== 'validate') {\n      return ctx.validate(this.defaultValue, this.validator)\n    }\n\n    return ctx.validate(input, this.validator)\n  }\n}\n\n/**\n * Creates a schema that applies a default value when the input is undefined.\n *\n * Commonly used with `optional()` to provide fallback values for missing\n * properties. The default value is validated against the schema.\n *\n * @param validator - The validator for the value\n * @param defaultValue - The default value to use when input is undefined\n * @returns A new {@link WithDefaultSchema} instance\n *\n * @example\n * ```ts\n * // Integer with default\n * const countSchema = l.withDefault(l.integer(), 0)\n * countSchema.parse(undefined) // 0\n * countSchema.parse(5)         // 5\n *\n * // Commonly combined with optional in objects\n * const settingsSchema = l.object({\n *   theme: l.optional(l.withDefault(l.string(), 'light')),\n *   pageSize: l.optional(l.withDefault(l.integer(), 25)),\n * })\n * settingsSchema.parse({}) // { theme: 'light', pageSize: 25 }\n *\n * // Boolean with default\n * const enabledSchema = l.withDefault(l.boolean(), false)\n * ```\n */\nexport function withDefault<const TValidator extends Validator>(\n  validator: TValidator,\n  defaultValue: InferInput<TValidator>,\n) {\n  return new WithDefaultSchema<TValidator>(validator, defaultValue)\n}\n"]}
+{"version":3,"file":"with-default.js","sourceRoot":"","sources":["../../src/schema/with-default.ts"],"names":[],"mappings":";;;AA2EA,kCAKC;AAhFD,wCAMmB;AAEnB;;;;;;;;;;;;;;;GAeG;AACH,MAAa,iBAEX,SAAQ,gBAAuD;IAIpD;IACA;IAJF,IAAI,GAAG,aAAsB,CAAA;IAEtC,YACW,SAAqB,EACrB,YAAoC;QAE7C,KAAK,EAAE,CAAA;QAHE,cAAS,GAAT,SAAS,CAAY;QACrB,iBAAY,GAAZ,YAAY,CAAwB;IAG/C,CAAC;IAED,iBAAiB,CAAC,KAAc,EAAE,GAAsB;QACtD,kEAAkE;QAClE,iCAAiC;QACjC,IAAI,KAAK,KAAK,SAAS,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;YAC3D,OAAO,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;QACxD,CAAC;QAED,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;IAC5C,CAAC;CACF;AArBD,8CAqBC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,SAAgB,WAAW,CACzB,SAAqB,EACrB,YAAoC;IAEpC,OAAO,IAAI,iBAAiB,CAAa,SAAS,EAAE,YAAY,CAAC,CAAA;AACnE,CAAC","sourcesContent":["import {\n  InferInput,\n  InferOutput,\n  Schema,\n  ValidationContext,\n  Validator,\n} from '../core.js'\n\n/**\n * Schema wrapper that provides a default value when the input is undefined.\n *\n * In parse mode, when the input is `undefined`, the default value is used\n * instead. In validate mode, undefined values pass through unchanged (the\n * default is not applied).\n *\n * @template TValidator - The wrapped validator type\n *\n * @example\n * ```ts\n * const schema = new WithDefaultSchema(l.integer(), 0)\n * schema.parse(undefined) // 0\n * schema.parse(42)        // 42\n * ```\n */\nexport class WithDefaultSchema<\n  const TValidator extends Validator,\n> extends Schema<InferInput<TValidator>, InferOutput<TValidator>> {\n  readonly type = 'withDefault' as const\n\n  constructor(\n    readonly validator: TValidator,\n    readonly defaultValue: InferInput<TValidator>,\n  ) {\n    super()\n  }\n\n  validateInContext(input: unknown, ctx: ValidationContext) {\n    // When in a validation context, the output should not be altered,\n    // so we don't apply the default.\n    if (input === undefined && ctx.options.mode !== 'validate') {\n      return ctx.validate(this.defaultValue, this.validator)\n    }\n\n    return ctx.validate(input, this.validator)\n  }\n}\n\n/**\n * Creates a schema that applies a default value when the input is undefined.\n *\n * Commonly used with `optional()` to provide fallback values for missing\n * properties. The default value is validated against the schema.\n *\n * @param validator - The validator for the value\n * @param defaultValue - The default value to use when input is undefined\n * @returns A new {@link WithDefaultSchema} instance\n *\n * @example\n * ```ts\n * // Integer with default\n * const countSchema = l.withDefault(l.integer(), 0)\n * countSchema.parse(undefined) // 0\n * countSchema.parse(5)         // 5\n *\n * // Commonly combined with optional in objects\n * const settingsSchema = l.object({\n *   theme: l.optional(l.withDefault(l.string(), 'light')),\n *   pageSize: l.optional(l.withDefault(l.integer(), 25)),\n * })\n * settingsSchema.parse({}) // { theme: 'light', pageSize: 25 }\n *\n * // Boolean with default\n * const enabledSchema = l.withDefault(l.boolean(), false)\n * ```\n */\nexport function withDefault<const TValidator extends Validator>(\n  validator: TValidator,\n  defaultValue: InferInput<TValidator>,\n) {\n  return new WithDefaultSchema<TValidator>(validator, defaultValue)\n}\n"]}

package/dist/schema.d.ts

@@ -6,13 +6,14 @@ export * from './schema/cid.js';
 export * from './schema/dict.js';
 export * from './schema/enum.js';
 export * from './schema/integer.js';
+export * from './schema/lex-map.js';
+export * from './schema/lex-value.js';
 export * from './schema/literal.js';
 export * from './schema/never.js';
 export * from './schema/null.js';
 export * from './schema/object.js';
 export * from './schema/regexp.js';
 export * from './schema/string.js';
-export * from './schema/unknown-object.js';
 export * from './schema/unknown.js';
 export * from './schema/custom.js';
 export * from './schema/discriminated-union.js';

package/dist/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AACA,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA;AAChC,cAAc,qBAAqB,CAAA;AACnC,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA;AAChC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,qBAAqB,CAAA;AAGnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,iCAAiC,CAAA;AAC/C,cAAc,0BAA0B,CAAA;AACxC,cAAc,sBAAsB,CAAA;AACpC,cAAc,sBAAsB,CAAA;AACpC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,0BAA0B,CAAA;AAGxC,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA;AACnC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AACrC,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,cAAc,0BAA0B,CAAA;AACxC,cAAc,uBAAuB,CAAA;AACrC,cAAc,yBAAyB,CAAA"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AACA,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA;AAChC,cAAc,qBAAqB,CAAA;AACnC,cAAc,mBAAmB,CAAA;AACjC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,qBAAqB,CAAA;AACnC,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,mBAAmB,CAAA;AACjC,cAAc,kBAAkB,CAAA;AAChC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,oBAAoB,CAAA;AAClC,cAAc,iCAAiC,CAAA;AAC/C,cAAc,0BAA0B,CAAA;AACxC,cAAc,sBAAsB,CAAA;AACpC,cAAc,sBAAsB,CAAA;AACpC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,0BAA0B,CAAA;AAGxC,cAAc,oBAAoB,CAAA;AAClC,cAAc,qBAAqB,CAAA;AACnC,cAAc,4BAA4B,CAAA;AAC1C,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AACrC,cAAc,mBAAmB,CAAA;AACjC,cAAc,oBAAoB,CAAA;AAClC,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,cAAc,0BAA0B,CAAA;AACxC,cAAc,uBAAuB,CAAA;AACrC,cAAc,yBAAyB,CAAA"}

package/dist/schema.js

@@ -10,13 +10,14 @@ tslib_1.__exportStar(require("./schema/cid.js"), exports);
 tslib_1.__exportStar(require("./schema/dict.js"), exports);
 tslib_1.__exportStar(require("./schema/enum.js"), exports);
 tslib_1.__exportStar(require("./schema/integer.js"), exports);
+tslib_1.__exportStar(require("./schema/lex-map.js"), exports);
+tslib_1.__exportStar(require("./schema/lex-value.js"), exports);
 tslib_1.__exportStar(require("./schema/literal.js"), exports);
 tslib_1.__exportStar(require("./schema/never.js"), exports);
 tslib_1.__exportStar(require("./schema/null.js"), exports);
 tslib_1.__exportStar(require("./schema/object.js"), exports);
 tslib_1.__exportStar(require("./schema/regexp.js"), exports);
 tslib_1.__exportStar(require("./schema/string.js"), exports);
-tslib_1.__exportStar(require("./schema/unknown-object.js"), exports);
 tslib_1.__exportStar(require("./schema/unknown.js"), exports);
 // Composite Types
 tslib_1.__exportStar(require("./schema/custom.js"), exports);

package/dist/schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"schema.js","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":";;;AAAA,iBAAiB;AACjB,4DAAiC;AACjC,2DAAgC;AAChC,8DAAmC;AACnC,4DAAiC;AACjC,0DAA+B;AAC/B,2DAAgC;AAChC,2DAAgC;AAChC,8DAAmC;AACnC,8DAAmC;AACnC,4DAAiC;AACjC,2DAAgC;AAChC,6DAAkC;AAClC,6DAAkC;AAClC,6DAAkC;AAClC,qEAA0C;AAC1C,8DAAmC;AAEnC,kBAAkB;AAClB,6DAAkC;AAClC,0EAA+C;AAC/C,mEAAwC;AACxC,+DAAoC;AACpC,+DAAoC;AACpC,0DAA+B;AAC/B,6DAAkC;AAClC,4DAAiC;AACjC,mEAAwC;AAExC,yBAAyB;AACzB,6DAAkC;AAClC,8DAAmC;AACnC,qEAA0C;AAC1C,iEAAsC;AACtC,gEAAqC;AACrC,4DAAiC;AACjC,6DAAkC;AAClC,mEAAwC;AACxC,4DAAiC;AACjC,mEAAwC;AACxC,gEAAqC;AACrC,kEAAuC","sourcesContent":["// Concrete Types\nexport * from './schema/array.js'\nexport * from './schema/blob.js'\nexport * from './schema/boolean.js'\nexport * from './schema/bytes.js'\nexport * from './schema/cid.js'\nexport * from './schema/dict.js'\nexport * from './schema/enum.js'\nexport * from './schema/integer.js'\nexport * from './schema/literal.js'\nexport * from './schema/never.js'\nexport * from './schema/null.js'\nexport * from './schema/object.js'\nexport * from './schema/regexp.js'\nexport * from './schema/string.js'\nexport * from './schema/unknown-object.js'\nexport * from './schema/unknown.js'\n\n// Composite Types\nexport * from './schema/custom.js'\nexport * from './schema/discriminated-union.js'\nexport * from './schema/intersection.js'\nexport * from './schema/nullable.js'\nexport * from './schema/optional.js'\nexport * from './schema/ref.js'\nexport * from './schema/refine.js'\nexport * from './schema/union.js'\nexport * from './schema/with-default.js'\n\n// Lexicon specific Types\nexport * from './schema/params.js'\nexport * from './schema/payload.js'\nexport * from './schema/permission-set.js'\nexport * from './schema/permission.js'\nexport * from './schema/procedure.js'\nexport * from './schema/query.js'\nexport * from './schema/record.js'\nexport * from './schema/subscription.js'\nexport * from './schema/token.js'\nexport * from './schema/typed-object.js'\nexport * from './schema/typed-ref.js'\nexport * from './schema/typed-union.js'\n"]}
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":";;;AAAA,iBAAiB;AACjB,4DAAiC;AACjC,2DAAgC;AAChC,8DAAmC;AACnC,4DAAiC;AACjC,0DAA+B;AAC/B,2DAAgC;AAChC,2DAAgC;AAChC,8DAAmC;AACnC,8DAAmC;AACnC,gEAAqC;AACrC,8DAAmC;AACnC,4DAAiC;AACjC,2DAAgC;AAChC,6DAAkC;AAClC,6DAAkC;AAClC,6DAAkC;AAClC,8DAAmC;AAEnC,kBAAkB;AAClB,6DAAkC;AAClC,0EAA+C;AAC/C,mEAAwC;AACxC,+DAAoC;AACpC,+DAAoC;AACpC,0DAA+B;AAC/B,6DAAkC;AAClC,4DAAiC;AACjC,mEAAwC;AAExC,yBAAyB;AACzB,6DAAkC;AAClC,8DAAmC;AACnC,qEAA0C;AAC1C,iEAAsC;AACtC,gEAAqC;AACrC,4DAAiC;AACjC,6DAAkC;AAClC,mEAAwC;AACxC,4DAAiC;AACjC,mEAAwC;AACxC,gEAAqC;AACrC,kEAAuC","sourcesContent":["// Concrete Types\nexport * from './schema/array.js'\nexport * from './schema/blob.js'\nexport * from './schema/boolean.js'\nexport * from './schema/bytes.js'\nexport * from './schema/cid.js'\nexport * from './schema/dict.js'\nexport * from './schema/enum.js'\nexport * from './schema/integer.js'\nexport * from './schema/lex-map.js'\nexport * from './schema/lex-value.js'\nexport * from './schema/literal.js'\nexport * from './schema/never.js'\nexport * from './schema/null.js'\nexport * from './schema/object.js'\nexport * from './schema/regexp.js'\nexport * from './schema/string.js'\nexport * from './schema/unknown.js'\n\n// Composite Types\nexport * from './schema/custom.js'\nexport * from './schema/discriminated-union.js'\nexport * from './schema/intersection.js'\nexport * from './schema/nullable.js'\nexport * from './schema/optional.js'\nexport * from './schema/ref.js'\nexport * from './schema/refine.js'\nexport * from './schema/union.js'\nexport * from './schema/with-default.js'\n\n// Lexicon specific Types\nexport * from './schema/params.js'\nexport * from './schema/payload.js'\nexport * from './schema/permission-set.js'\nexport * from './schema/permission.js'\nexport * from './schema/procedure.js'\nexport * from './schema/query.js'\nexport * from './schema/record.js'\nexport * from './schema/subscription.js'\nexport * from './schema/token.js'\nexport * from './schema/typed-object.js'\nexport * from './schema/typed-ref.js'\nexport * from './schema/typed-union.js'\n"]}

package/dist/util/if-any.d.ts

@@ -0,0 +1,2 @@
+export type IfAny<T, TrueValue, FalseValue> = 0 extends 1 & T ? TrueValue : FalseValue;
+//# sourceMappingURL=if-any.d.ts.map

package/dist/util/if-any.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"if-any.d.ts","sourceRoot":"","sources":["../../src/util/if-any.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,SAAS,EAAE,UAAU,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GACzD,SAAS,GACT,UAAU,CAAA"}

package/dist/util/if-any.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=if-any.js.map

package/dist/util/if-any.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"if-any.js","sourceRoot":"","sources":["../../src/util/if-any.ts"],"names":[],"mappings":"","sourcesContent":["export type IfAny<T, TrueValue, FalseValue> = 0 extends 1 & T\n  ? TrueValue\n  : FalseValue\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/lex-schema",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "license": "MIT",
   "description": "Lexicon schema system for AT Lexicons",
   "keywords": [
@@ -37,7 +37,7 @@
   "dependencies": {
     "tslib": "^2.8.1",
     "@atproto/syntax": "^0.4.3",
-    "@atproto/lex-data": "^0.0.11"
+    "@atproto/lex-data": "^0.0.12"
   },
   "devDependencies": {
     "vitest": "^4.0.16"

package/src/core/schema.ts

@@ -11,13 +11,13 @@ import {
  * Options for parsing operations.
  * Excludes the `mode` option as it is implicitly set to `"parse"`.
  */
-type ParseOptions = Omit<ValidationOptions, 'mode'>
+export type ParseOptions = Omit<ValidationOptions, 'mode'>
 
 /**
  * Options for validation operations.
  * Excludes the `mode` option as it is implicitly set to `"validate"`.
  */
-type ValidateOptions = Omit<ValidationOptions, 'mode'>
+export type ValidateOptions = Omit<ValidationOptions, 'mode'>
 
 /**
  * Internal type structure for schema type inference.
@@ -58,7 +58,7 @@ export interface SchemaInternals<out TInput = unknown, out TOutput = TInput> {
  * class MySchema extends Schema<string> {
  *   validateInContext(input: unknown, ctx: ValidationContext): ValidationResult {
  *     if (typeof input !== 'string') {
- *       return ctx.issueInvalidType(input, 'string')
+ *       return ctx.issueUnexpectedType(input, 'string')
  *     }
  *     return ctx.success(input)
  *   }
@@ -88,6 +88,12 @@ export abstract class Schema<
    */
   declare readonly ['__lex']: TInternals
 
+  // Needed to discriminate multiple schema types when used in unions. Without
+  // this, Typescript could allow an EnumSchema<"foo" | "bar"> to be used where
+  // a StringSchema is expected, since they would both be structurally
+  // compatible.
+  abstract readonly type: string
+
   /**
    * Performs validation of the input value within a validation context.
    *

package/src/core/validation-issue.ts

@@ -1,4 +1,4 @@
-import { ifCid, isPlainObject } from '@atproto/lex-data'
+import { ifCid, isLegacyBlobRef, isPlainObject } from '@atproto/lex-data'
 import { PropertyKey } from './property-key.js'
 
 /**
@@ -260,7 +260,7 @@ export class IssueTooSmall extends Issue {
 
 function stringifyExpectedType(expected: string): string {
   if (expected === '$typed') {
-    return 'an object or record which includes a "$type" property'
+    return 'an object which includes the "$type" property'
   }
   return expected
 }
@@ -295,6 +295,7 @@ function stringifyType(value: unknown): string {
       if (value === null) return 'null'
       if (Array.isArray(value)) return 'array'
       if (ifCid(value)) return 'cid'
+      if (isLegacyBlobRef(value)) return 'legacy-blob'
       if (value instanceof Date) return 'date'
       if (value instanceof RegExp) return 'regexp'
       if (value instanceof Map) return 'map'

package/src/core/validator.ts

@@ -192,7 +192,7 @@ export type ValidationOptions = {
  * class MyValidator implements Validator {
  *   validateInContext(input: unknown, ctx: ValidationContext): ValidationResult {
  *     if (typeof input !== 'string') {
- *       return ctx.issueInvalidType(input, 'string')
+ *       return ctx.issueUnexpectedType(input, 'string')
  *     }
  *     return ctx.success(input)
  *   }
@@ -377,6 +377,15 @@ export class ValidationContext {
     K extends PropertyKey & keyof I,
     V extends Validator,
   >(input: I, key: K, validator: V): ValidationResult<InferInput<V>> {
+    // @NOTE we could add support for recursive schemas by keeping track of
+    // "parent" objects in the context and checking for circular references
+    // here. This would allow us to validate recursive structures without
+    // hitting maximum call stack errors, and would also allow us to provide
+    // better error messages for circular reference issues. However, this is not
+    // a priority at the moment as recursive structures are not supported in
+    // the context of AT Protocol lexicons, and we can always add this in the
+    // future if needed.
+
     // Instead of creating a new context, we just push/pop the path segment.
     this.currentPath.push(key)
     try {
@@ -443,6 +452,17 @@ export class ValidationContext {
     return this.issue(new IssueInvalidValue(this.path, input, values))
   }
 
+  /**
+   * Creates a failure for an invalid type.
+   *
+   * @param input - The actual value that was received
+   * @param expected - An array of expected type names
+   * @returns A failed validation result with an invalid type issue
+   */
+  issueInvalidType(input: unknown, expected: readonly string[]) {
+    return this.issue(new IssueInvalidType(this.path, input, expected))
+  }
+
   /**
    * Creates a failure for an invalid type.
    *
@@ -450,8 +470,8 @@ export class ValidationContext {
    * @param expected - The expected type name
    * @returns A failed validation result with an invalid type issue
    */
-  issueInvalidType(input: unknown, expected: string) {
-    return this.issue(new IssueInvalidType(this.path, input, [expected]))
+  issueUnexpectedType(input: unknown, expected: string) {
+    return this.issueInvalidType(input, [expected])
   }
 
   /**

package/src/helpers.test.ts

@@ -61,7 +61,7 @@ describe('InferMethodParams', () => {
         l.params({
           cursor: l.optional(l.integer()),
         }),
-        l.unknownObject(),
+        l.lexMap(),
       )
 
       type Params = l.InferMethodParams<typeof subscription>

package/src/helpers.ts

@@ -26,47 +26,81 @@ export function getMain<T extends object>(ns: Main<T>): T {
  * `ReadableStream`, etc.). This type is a placeholder to represent binary data
  * when not explicitly provided.
  */
-type BinaryData = Restricted<'Binary data'>
+export type BinaryData = Restricted<'Binary data'>
 
-export type InferMethodParams<M extends Procedure | Query | Subscription> =
-  InferOutput<M['parameters']>
+export type InferMethodParams<
+  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
+> =
+  M extends Procedure<any, infer TParams, any, any, any>
+    ? InferOutput<TParams>
+    : M extends Query<any, infer TParams, any, any>
+      ? InferOutput<TParams>
+      : M extends Subscription<any, infer TParams, any, any>
+        ? InferOutput<TParams>
+        : never
 
 export type InferMethodInput<
-  M extends Procedure | Query | Subscription,
+  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
   B = BinaryData,
-> = M extends Procedure ? InferPayload<M['input'], B> : undefined
+> =
+  M extends Procedure<any, any, infer TInput, any, any>
+    ? InferPayload<TInput, B>
+    : undefined
 
 export type InferMethodInputBody<
-  M extends Procedure | Query | Subscription,
+  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
   B = BinaryData,
-> = M extends Procedure ? InferPayloadBody<M['input'], B> : undefined
+> =
+  M extends Procedure<any, any, infer TInput, any, any>
+    ? InferPayloadBody<TInput, B>
+    : undefined
 
 export type InferMethodInputEncoding<
-  M extends Procedure | Query | Subscription,
-> = M extends Procedure ? InferPayloadEncoding<M['input']> : undefined
+  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
+> =
+  M extends Procedure<any, any, infer TInput, any, any>
+    ? InferPayloadEncoding<TInput>
+    : undefined
 
 export type InferMethodOutput<
-  M extends Procedure | Query | Subscription,
+  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
   B = BinaryData,
-> = M extends Procedure | Query ? InferPayload<M['output'], B> : undefined
+> =
+  M extends Procedure<any, any, any, infer TOutput, any>
+    ? InferPayload<TOutput, B>
+    : M extends Query<any, any, infer TOutput, any>
+      ? InferPayload<TOutput, B>
+      : undefined
 
 export type InferMethodOutputBody<
-  M extends Procedure | Query | Subscription,
+  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
   B = BinaryData,
-> = M extends Procedure | Query ? InferPayloadBody<M['output'], B> : undefined
+> =
+  M extends Procedure<any, any, any, infer TOutput, any>
+    ? InferPayloadBody<TOutput, B>
+    : M extends Query<any, any, infer TOutput, any>
+      ? InferPayloadBody<TOutput, B>
+      : undefined
 
 export type InferMethodOutputEncoding<
-  M extends Procedure | Query | Subscription,
-> = M extends Procedure | Query ? InferPayloadEncoding<M['output']> : undefined
+  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
+> =
+  M extends Procedure<any, any, any, infer TOutput, any>
+    ? InferPayloadEncoding<TOutput>
+    : M extends Query<any, any, infer TOutput, any>
+      ? InferPayloadEncoding<TOutput>
+      : undefined
 
 export type InferMethodMessage<
-  //
-  M extends Subscription,
-> = M extends Subscription ? InferOutput<M['message']> : undefined
+  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
+> =
+  M extends Subscription<any, any, infer TMessage, any>
+    ? InferOutput<TMessage>
+    : undefined
 
 export type InferMethodError<
   //
-  M extends Procedure | Query | Subscription,
+  M extends Procedure | Query | Subscription = Procedure | Query | Subscription,
 > = M extends { errors: readonly (infer E extends string)[] } ? E : never
 
 export const lexErrorDataSchema = object({

package/src/schema/array.ts

@@ -36,6 +36,8 @@ export class ArraySchema<const TItem extends Validator> extends Schema<
   Array<InferInput<TItem>>,
   Array<InferOutput<TItem>>
 > {
+  readonly type = 'array' as const
+
   constructor(
     readonly validator: TItem,
     readonly options: ArraySchemaOptions = {},
@@ -45,7 +47,7 @@ export class ArraySchema<const TItem extends Validator> extends Schema<
 
   validateInContext(input: unknown, ctx: ValidationContext) {
     if (!Array.isArray(input)) {
-      return ctx.issueInvalidType(input, 'array')
+      return ctx.issueUnexpectedType(input, 'array')
     }
 
     const { minLength, maxLength } = this.options

package/src/schema/blob.ts

@@ -32,6 +32,7 @@ export type BlobSchemaOptions = BlobRefCheckOptions & {
 }
 
 export type { BlobRef, LegacyBlobRef }
+export { isBlobRef, isLegacyBlobRef }
 
 /**
  * Schema for validating blob references in AT Protocol.
@@ -53,6 +54,8 @@ export class BlobSchema<
 > extends Schema<
   TOptions extends { allowLegacy: true } ? BlobRef | LegacyBlobRef : BlobRef
 > {
+  readonly type = 'blob' as const
+
   constructor(readonly options?: TOptions) {
     super()
   }
@@ -68,7 +71,7 @@ export class BlobSchema<
           : null
 
     if (!blob) {
-      return ctx.issueInvalidType(input, 'blob')
+      return ctx.issueUnexpectedType(input, 'blob')
     }
 
     const accept = this.options?.accept

package/src/schema/boolean.ts

@@ -16,12 +16,14 @@ import { memoizedOptions } from '../util/memoize.js'
  * ```
  */
 export class BooleanSchema extends Schema<boolean> {
+  readonly type = 'boolean' as const
+
   validateInContext(input: unknown, ctx: ValidationContext) {
     if (typeof input === 'boolean') {
       return ctx.success(input)
     }
 
-    return ctx.issueInvalidType(input, 'boolean')
+    return ctx.issueUnexpectedType(input, 'boolean')
   }
 }
 

package/src/schema/bytes.ts

@@ -26,6 +26,8 @@ export type BytesSchemaOptions = {
  * ```
  */
 export class BytesSchema extends Schema<Uint8Array> {
+  readonly type = 'bytes' as const
+
   constructor(readonly options: BytesSchemaOptions = {}) {
     super()
   }
@@ -35,7 +37,7 @@ export class BytesSchema extends Schema<Uint8Array> {
     const bytes =
       ctx.options.mode === 'parse' ? asUint8Array(input) : ifUint8Array(input)
     if (!bytes) {
-      return ctx.issueInvalidType(input, 'bytes')
+      return ctx.issueUnexpectedType(input, 'bytes')
     }
 
     const { minLength } = this.options

package/src/schema/cid.ts

@@ -29,13 +29,15 @@ export type CidSchemaOptions = CheckCidOptions
 export class CidSchema<
   const TOptions extends CidSchemaOptions = { flavor: undefined },
 > extends Schema<InferCheckedCid<TOptions>> {
+  readonly type = 'cid' as const
+
   constructor(readonly options?: TOptions) {
     super()
   }
 
   validateInContext(input: unknown, ctx: ValidationContext) {
     if (!isCid(input, this.options)) {
-      return ctx.issueInvalidType(input, 'cid')
+      return ctx.issueUnexpectedType(input, 'cid')
     }
 
     return ctx.success(input)

package/src/schema/custom.ts

@@ -46,6 +46,8 @@ export type CustomAssertion<TValue> = (
  * ```
  */
 export class CustomSchema<out TValue = unknown> extends Schema<TValue> {
+  readonly type = 'custom' as const
+
   constructor(
     private readonly assertion: CustomAssertion<TValue>,
     private readonly message: string,

package/src/schema/dict.ts

@@ -34,6 +34,8 @@ export class DictSchema<
   Record<InferInput<TKey>, InferInput<TValue>>,
   Record<InferInput<TKey>, InferOutput<TValue>>
 > {
+  readonly type = 'dict' as const
+
   constructor(
     readonly keySchema: TKey,
     readonly valueSchema: TValue,
@@ -47,7 +49,7 @@ export class DictSchema<
     options?: { ignoredKeys?: { has(k: string): boolean } },
   ) {
     if (!isPlainObject(input)) {
-      return ctx.issueInvalidType(input, 'dict')
+      return ctx.issueUnexpectedType(input, 'dict')
     }
 
     let copy: undefined | Record<string, unknown>

package/src/schema/discriminated-union.ts

@@ -78,6 +78,8 @@ export class DiscriminatedUnionSchema<
   DiscriminatedUnionSchemaInput<TVariants>,
   DiscriminatedUnionSchemaOutput<TVariants>
 > {
+  readonly type = 'discriminatedUnion' as const
+
   readonly variantsMap: Map<unknown, DiscriminatedUnionVariant<TDiscriminator>>
 
   constructor(
@@ -94,7 +96,7 @@ export class DiscriminatedUnionSchema<
 
   validateInContext(input: unknown, ctx: ValidationContext) {
     if (!isPlainObject(input)) {
-      return ctx.issueInvalidType(input, 'object')
+      return ctx.issueUnexpectedType(input, 'object')
     }
 
     const { discriminator } = this

package/src/schema/enum.ts

@@ -18,6 +18,8 @@ import { Schema, ValidationContext } from '../core.js'
 export class EnumSchema<
   const TValue extends null | string | number | boolean,
 > extends Schema<TValue> {
+  readonly type = 'enum' as const
+
   constructor(readonly values: readonly TValue[]) {
     super()
   }

package/src/schema/integer.ts

@@ -25,13 +25,15 @@ export type IntegerSchemaOptions = {
  * ```
  */
 export class IntegerSchema extends Schema<number> {
+  readonly type = 'integer' as const
+
   constructor(readonly options?: IntegerSchemaOptions) {
     super()
   }
 
   validateInContext(input: unknown, ctx: ValidationContext) {
     if (!isInteger(input)) {
-      return ctx.issueInvalidType(input, 'integer')
+      return ctx.issueUnexpectedType(input, 'integer')
     }
 
     if (this.options?.minimum != null && input < this.options.minimum) {

package/src/schema/intersection.ts

@@ -56,6 +56,8 @@ export class IntersectionSchema<
   Simplify<Intersect<InferInput<Left>, InferInput<Right>>>,
   Simplify<Intersect<InferOutput<Left>, InferOutput<Right>>>
 > {
+  readonly type = 'intersection' as const
+
   constructor(
     protected readonly left: Left,
     protected readonly right: Right,